Finite population growth rate calculator
See how much a population multiplies between censuses: 100 animals counted one year and 120 the next give λ = 1.2, a 20% rise with r ≈ 0.1823. Counts several years apart are handled too. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N0
- 100
- N1
- 120
- Intervals
- 1
- Resistance (Ω)
- 0.1823215568
- Lambda
- 1.2
- Finite rate
- 1.2
A finite rate of increase calculator answers the discrete-time ecology question: by what factor does a population multiply from one census to the next. That factor is lambda (λ), the finite rate of increase. When you have two successive counts, λ is the later size divided by the earlier size. When the counts are k intervals apart, raise that ratio to one over k. When you already know the continuous intrinsic growth rate r, λ is e to the r. Lambda greater than one means growth, lambda equal to one means a stable stock, and a value between zero and one means decline.
What the finite rate of increase λ means and how it is computed
Population ecology uses two closely related growth numbers that students and managers mix up. The continuous intrinsic rate r is the instantaneous per-capita slope of log N, the quantity that appears in the differential equation dN/dt = rN. The finite rate of increase λ is the discrete multiplier that takes this year's count to next year's count under geometric growth: N_{t+1} = λ N_t.
Those two numbers are not rivals; they are the same trajectory written in two clocks. The conversion is exact: λ equals e to the r, and r equals the natural log of λ whenever λ is positive. A census pair is the most common way to obtain λ.
If a closed population is counted at one hundred in year t and one hundred and twenty in year t+1, then λ is 120/100 = 1.2 and r is ln(1.2) ≈ 0.1823 per year. If the same pair of counts is four years apart, the annual finite rate is the fourth root of the ratio, (120/100)^{1/4}, so the calculator does not silently treat a multi-year span as a single step.
Lambda greater than one is an increasing stock; lambda equal to one is stable; a value between zero and one is a decline; a later count of zero is a valid extinct-next-census case with λ = 0. This page evaluates only that discrete identity and the exponential conversion from r.
It does not estimate a life table, it does not solve the Euler–Lotka characteristic equation for a structured population, it does not compute net reproductive rate R0, and it does not return the logistic instantaneous slope dN/dt = rN(1 − N/K). Those are different searches and different identities. Give it two positive-and-non-negative census sizes in consistent units, or a finite r whose exponential stays defined, and it returns the finite rate you would write on a geometric-growth homework sheet or in a harvest model that steps once per year.
Where a finite-rate-of-increase calculator earns its keep
Wildlife and fisheries notebooks keep the same identity next to an annual census when a manager needs the discrete multiplier for a harvest or restocking model that steps once per year, not a continuous tangent. Conservation plans, pest-outbreak sheets, microbial batch counts taken on a regular clock, and LMS homework oracles need a deterministic parse that rejects a missing n0 or a zero divisor instead of returning Infinity. Failed validation does not consume balance.
Keep n0, n1, r, and intervals inside the declared ceilings, pin λ = 1.2 for the textbook one-hundred-to-one-hundred-twenty case, and you get reproducible answers across a lecture notebook, an LMS plugin, and a population-management script.
What you can do with it
Year-over-year wildlife census
A biologist enters this year's count as n0 and next year's count as n1 and reads λ, percent change, and whether the stock is increasing, stable, or declining.
Convert r to a discrete multiplier
A modeller who already has an estimated intrinsic rate r sends that rate and receives λ = e^r for a model that steps once per year.
FAQ
How do I calculate the finite rate of increase λ from two census counts?
Send n0 as the earlier count and n1 as the later count. For successive years, λ is n1/n0. One hundred becoming one hundred and twenty is λ = 1.2. If the counts are k intervals apart, also send intervals so the engine returns (n1/n0) raised to 1/k.
How do I obtain λ from the intrinsic growth rate r?
A rate of 0.2 per unit time yields λ ≈ 1.2214. The conversion is exact; it is not a linear approximation.
What is the difference between λ and r?
r is the continuous per-capita rate in 1/time. λ is the discrete multiplier per census interval. They describe the same geometric trajectory: λ = e^r and r = ln(λ) when λ is positive.
Is λ the same as net reproductive rate R0?
No. R0 is the expected number of offspring per individual over a lifetime from a life table. λ equals R0 only in special non-overlapping-generation models. This calculator does not accept a maternity schedule and does not solve Euler–Lotka.
How do I get the yearly λ when my counts are several years apart?
Enter the number of intervals between the counts. The calculator divides the later count by the earlier one and raises that ratio to one over the number of intervals, so 100 and 120 four years apart give (120/100)^(1/4), not 1.2.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/bio/finite-growth-rate-lambda \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"r":0.2}'const res = await fetch("https://api.kit.forhosting.com/bio/finite-growth-rate-lambda", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"r": 0.2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/bio/finite-growth-rate-lambda",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"r": 0.2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/bio/finite-growth-rate-lambda", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"r":0.2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"r":0.2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/bio/finite-growth-rate-lambda", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"r": 0.2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "bio.finite_growth_rate_lambda",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_abs | 1000000000000000 |
max_abs_r | 700 |
max_intervals | 10000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
This endpoint evaluates those two identities, returns the matching instantaneous r as the natural log of lambda, reports percent change per interval, and, when it is finite, the doubling or halving time. It does not fit a life table, it does not solve the Euler–Lotka equation, and it is not the logistic instantaneous slope dN/dt.
Input contract, response shape, and error behaviour
POST a JSON body that follows one of two paths. For successive sizes, send n0 as the count at time t (aliases n_t, nt, population_t, initial_population, n_start) and n1 as the count at time t plus k (aliases n_t1, nt1, n_next, population_t1, final_population, n_end). n0 must be strictly positive because λ divides by it; n1 may be zero, which reports λ = 0 and regime extinct. Optional intervals is the number of time steps k between the two counts (aliases years, k, steps, time_steps) and defaults to one, the successive-year case. For the intrinsic-rate path, send r (aliases intrinsic_rate, intrinsic_growth_rate, r_max, rmax); λ is then e to the r. Optional mode is the closed set from_sizes or from_rate (alias method); omit it and the engine auto-detects from which fields you sent. Each numeric field may arrive as a JSON number or as a decimal or scientific string. Missing both a census pair and r, a non-positive n0, a negative n1, a non-positive intervals value, a non-finite number, a mode outside the enum, or an r whose exponential overflows all fail with invalid_input that names the field. Those failures are not billed. On success the body reports method, echoes the sizes and intervals when they were used, returns lambda and the synonym finite_rate, percent_change as (λ − 1) times one hundred, the matching r = ln(λ) when λ is positive, a regime of increasing, stable, declining, or extinct, and, when it is finite, doubling_time as ln(2)/ln(λ) or halving_time as ln(0.5)/ln(λ). Optional output keys are omitted, never null. formula restates the identity; formula_applied substitutes this call's numbers. Example: n0 = 100 and n1 = 120 yields λ = 1.2, r ≈ 0.1823, twenty percent growth, and a doubling time of about 3.80 intervals. Pair λ with your own census schedule; this endpoint does not project a full N(t) series beyond the identities above.
Where a finite-rate-of-increase calculator earns its keep
Teaching labs and introductory ecology courses use a finite population growth rate calculator so students stop treating r and λ as interchangeable labels and can show that one hundred individuals becoming one hundred and twenty is λ = 1.2, not r = 0.2.
Integration use cases
Classroom geometric-growth check
A student enters n0 = 100 and n1 = 120 and confirms λ = 1.2, r = ln(1.2), and a doubling time of about 3.80 census intervals.
Technical questions
What does the finite population growth rate calculator cost?
The browser tool is free. API requests use prepaid balance at $0.002 per successful call; invalid input is not billed.