Calculate rates of phenotypic evolution in Darwins and Haldanes
Years
Generations
Million Years
Required to calculate Haldanes if time is in years.
Standard deviation of the trait within the population (In ln units for Haldanes).
Calculation Results
Rate in Darwins ($d$)
Change in factors of $e$ per million years
–
Rate in Haldanes ($h$)
Standard deviations per generation
–
Absolute Change
Raw difference ($x_2 – x_1$)
–
Total Generations
Estimated number of generations elapsed
–
How to Calculate Rate of Evolution
Evolutionary biology relies on quantifying how fast traits change over time to understand adaptation, genetic drift, and selection pressures. This calculator computes the two most standard metrics for rates of evolution: the Darwin and the Haldane.
1. The Darwin ($d$)
The Darwin is a unit of evolutionary change defined as a change in a trait by a factor of $e$ (the base of natural logarithms) per one million years. It was proposed by J.B.S. Haldane in 1949.
Formula:
$$ d = \frac{\ln(x_2) – \ln(x_1)}{\Delta t} $$
$x_1$: Mean value of the trait at the beginning.
$x_2$: Mean value of the trait at the end.
$\Delta t$: Time elapsed in millions of years.
Because the Darwin uses natural logarithms, it measures proportional change rather than absolute change. It is useful for comparing rates across traits of different physical dimensions (e.g., comparing weight changes to length changes).
2. The Haldane ($h$)
The Haldane is generally considered the superior metric for microevolutionary studies because it accounts for the variability within the population and scales time by generations rather than years.
Formula:
$$ h = \frac{\frac{x_2 – x_1}{s_p}}{g} $$
$x_2 – x_1$: The difference in mean trait values.
$s_p$: The pooled standard deviation of the trait (typically of the log-transformed data).
$g$: The number of generations that have elapsed.
A rate of 1 Haldane means the population mean shifts by one standard deviation per generation, which represents an extremely rapid rate of evolution.
Data Input Guide
Initial & Final Mean: Enter the average measurement of the morphological trait (e.g., beak depth, wing length, body mass).
Time Interval: Enter the duration between the two sample points.
Generation Time: If your time input is in years, you must provide the average time it takes for one generation (age at reproduction) to calculate Haldanes correctly.
Pooled Standard Deviation: This represents the phenotypic variance. For calculating Haldanes strictly, this should ideally be the standard deviation of the natural log of the measurements, though raw SD is often used for approximation in general contexts.
Interpreting the Results
Darwins: A value of 1.0 Darwin is considered a rapid rate in the fossil record, though rates measured in field studies over short timescales (microevolution) can be much higher (thousands of Darwins).
Haldanes: Values in natural populations typically range from 0 to 0.1. A value exceeding 0.1 suggests very strong directional selection or a small population size heavily influenced by drift.
function toggleGenerationInput() {
var unit = document.getElementById("timeUnit").value;
var row = document.getElementById("genTimeRow");
if (unit === "generations") {
row.style.display = "none";
} else {
row.style.display = "flex";
}
}
function calculateEvolution() {
// 1. Get Inputs
var x1 = parseFloat(document.getElementById("meanStart").value);
var x2 = parseFloat(document.getElementById("meanEnd").value);
var t = parseFloat(document.getElementById("timeElapsed").value);
var unit = document.getElementById("timeUnit").value;
var genTime = parseFloat(document.getElementById("genTime").value);
var sd = parseFloat(document.getElementById("stdDev").value);
// 2. Validate Inputs
if (isNaN(x1) || isNaN(x2) || isNaN(t) || isNaN(sd)) {
alert("Please enter valid numerical values for Mean Values, Time, and Standard Deviation.");
return;
}
if (t <= 0) {
alert("Time elapsed must be greater than 0.");
return;
}
if (sd <= 0) {
alert("Standard Deviation must be greater than 0.");
return;
}
if (x1 <= 0 || x2 <= 0) {
alert("Trait means must be positive for Logarithmic calculations (Darwins).");
return;
}
// 3. Logic: Normalize Time
var timeInMillions = 0;
var timeInGenerations = 0;
if (unit === "years") {
timeInMillions = t / 1000000;
if (isNaN(genTime) || genTime <= 0) {
alert("Please enter a valid Generation Time.");
return;
}
timeInGenerations = t / genTime;
} else if (unit === "generations") {
timeInGenerations = t;
// Approximation: if generations are selected, we assume generation time isn't strictly defined for Years calculation
// unless we force a user to input it. For Darwins, we need absolute time.
// In this specific logic, if user selects generations, we cannot accurately calc Darwins
// without knowing generation length in years.
// We will default generation length to 1 year for the Darwin Calc if not provided,
// or ask user. For simplicity in this logic:
// Darwins require T in Million Years. If input is Gens, T_years = Gens * GenTime.
if (isNaN(genTime) || genTime <= 0) genTime = 1;
timeInMillions = (t * genTime) / 1000000;
} else if (unit === "my") {
timeInMillions = t;
// Convert back to years for generations
var totalYears = t * 1000000;
if (isNaN(genTime) || genTime <= 0) {
alert("Please enter a valid Generation Time to calculate Haldanes.");
return;
}
timeInGenerations = totalYears / genTime;
}
// 4. Calculate Rate in Darwins
// Formula: (ln(x2) – ln(x1)) / Time_in_Million_Years
var lnX2 = Math.log(x2);
var lnX1 = Math.log(x1);
var darwins = (lnX2 – lnX1) / timeInMillions;
// 5. Calculate Rate in Haldanes
// Formula: ((x2 – x1) / sd) / generations
// Note: Strict Haldanes use ln(x) for the numerator difference as well,
// but often in simple calculators (x2-x1)/sd is used as "standard deviations of change".
// Gingerich (1993) defines Haldanes as change in standard deviations per generation.
// H = ( (x2 – x1) / sd_pooled ) / generations.
// Many sources use ln-transformed data for x1 and x2 for Haldanes too,
// but basic phenotypic change is often calculated on raw scale normalized by SD.
// We will use the raw scale difference normalized by SD, as this is the intuitive input.
var changeRaw = x2 – x1;
var changeInSDUnits = changeRaw / sd;
var haldanes = changeInSDUnits / timeInGenerations;
// 6. Display Results
document.getElementById("resDarwins").innerText = darwins.toFixed(4) + " d";
document.getElementById("resHaldanes").innerText = haldanes.toFixed(6) + " h";
document.getElementById("resChange").innerText = changeRaw.toFixed(4);
document.getElementById("resGens").innerText = Math.round(timeInGenerations).toLocaleString();
document.getElementById("resultDisplay").style.display = "block";
}