ROI Calculator

Two investors hold the same fund and earn dramatically different "returns" — not because the fund performed differently for each, but because they used different return calculations. The choice between time-weighted return (TWR) and money-weighted return (MWR / IRR) is foundational, and getting it wrong distorts every comparison you make. Time-Weighted Return measures the fund manager's skill — the actual investment performance free of cashflow timing. The calculation breaks the holding period into sub-periods, each ending when a deposit or withdrawal occurs, computes a return for each sub-period, and chains them: TWR = ((1 + r1)(1 + r2)...(1 + rn)) − 1. The Global Investment Performance Standards (GIPS) maintained by the CFA Institute mandate TWR for fund-manager performance reporting precisely because it neutralizes the effect of investor cashflows that the manager did not control. CAGR (Compound Annual Growth Rate) is the annualized form of TWR over a single uninterrupted period: CAGR = (Ending / Beginning)^(1/years) − 1. Money-Weighted Return — also called Internal Rate of Return (IRR), or Extended IRR (XIRR) when cashflows are irregular — solves for the discount rate that makes the net present value of all cashflows equal zero: 0 = Σ CFi / (1 + r)^ti. It captures the actual return the investor experienced, including the impact of when they added or removed money. If you contributed heavily right before a market crash, your XIRR will be lower than the fund's TWR even though you held the same fund. Concrete example. You start with $10,000 in a fund on January 1. The fund returns +30% in year 1 (your $10,000 becomes $13,000). On December 31, you contribute another $50,000 (now $63,000). In year 2 the fund loses −20% (your $63,000 becomes $50,400). At the end of year 2 your total contributions were $60,000 and your account is worth $50,400 — you lost $9,600. TWR for the period: (1.30)(0.80) − 1 = +4.0% total, or about +1.98% annualized. That is what the manager delivered. Your money-weighted return (XIRR) is approximately −10.7% annualized — disastrously different. The fund did not change; your timing did. Both numbers are correct; they answer different questions. Use TWR / CAGR when comparing fund managers, comparing strategies, or assessing investment skill. Use MWR / IRR / XIRR when evaluating your personal returns, especially with irregular contributions, dollar-cost averaging, or rebalancing. The U.S. Securities and Exchange Commission requires fund prospectuses to report TWR-based annualized returns; brokerage account statements often show MWR for personal performance. Reading them as if they are the same is a common mistake that overstates or understates results substantially. Practical computation: spreadsheet XIRR functions (Excel, Google Sheets) take an array of dates and cashflows. The math is iterative — Newton-Raphson root-finding — and rarely closed-form. Most public datasets (Morningstar, S&P Indices, MSCI) publish TWR/CAGR. Educational only — consult a licensed advisor for personalized analysis.

// CAGR (annualized TWR over uninterrupted period)
function cagr(start, end, years) {
  return Math.pow(end/start, 1/years) - 1;
}
cagr(10000, 14641, 4); // 0.10 (10% per year)

// TWR with intermediate cashflows
function twr(periods) {
  return periods.reduce((acc, p) => acc * (1 + p), 1) - 1;
}
twr([0.30, -0.20]); // 0.04 (+4% cumulative)

// XIRR is iterative — Newton-Raphson on:
// f(r) = Σ CFi / (1+r)^(ti/365)
// Real implementations: Excel XIRR, scipy.optimize.brentq, etc.

"I made 100% ROI on this investment" sounds like a brag. Then ask: "Over how long?" If the answer is one day, you are looking at a phenomenal trade. If it is forty years, you have been beaten by an inflation-only Treasury bill. Yet news headlines and investment pitches routinely report ROI without time, leaving readers to fill in optimistic assumptions. Simple ROI = (Final Value − Initial Investment) / Initial Investment. It is dimensionless and silent on duration. To compare investments meaningfully, annualize: Annualized Return = (1 + ROI)^(1/years) − 1. A 100% ROI in 1 year is +100% annualized. A 100% ROI in 10 years is just +7.18% annualized — slightly above long-run inflation, slightly below the long-run S&P average. A 100% ROI in 40 years is +1.75% annualized — a real loss after inflation. Same ROI, four different stories. The stakes get larger when leverage or compounding is involved. Real-estate marketing frequently advertises "200% returns" on leveraged property — a $100,000 down payment on a $500,000 property that appreciates to $700,000 produces a $200,000 gain on the original $100,000 stake (200% ROI), but if it took 15 years that is +7.6% annualized on the equity, before mortgage interest, taxes, insurance, maintenance, and vacancy. Subtracting these drops the annualized return into single digits and often into negative territory after inflation. Always demand the time horizon, then annualize. Multiperiod aggregation introduces another trap: the average of annual returns is not the annualized return. If a fund returns +50% one year and −50% the next, the arithmetic mean is 0% but the actual end-of-period value is $100 × 1.50 × 0.50 = $75 — a 25% loss, or −13.4% annualized. The geometric mean is the only honest summary for compounding investments: GM = (Π(1 + ri))^(1/n) − 1. Reports that quote "average annual return" instead of "annualized return" exploit the gap. Volatility widens the gap further: variance drag = σ²/2 (approximately), where σ is the annual standard deviation. A fund averaging 8% with 20% standard deviation experiences roughly 6% annualized — the missing 2% is volatility tax. Always look for: (1) the time period, (2) whether the number is annualized vs cumulative vs arithmetic average, (3) whether dividends or distributions are reinvested ("total return") or not, (4) whether the number is gross or net of fees and taxes. Mutual fund prospectuses are required by SEC Rule 482 to disclose 1-, 5-, and 10-year annualized returns net of fees, plus the SEC standardized yield for income funds. Use those — not glossy marketing — when comparing. Educational only. Past performance does not guarantee future results.

// Annualize cumulative ROI
function annualize(roi, years) {
  return Math.pow(1 + roi, 1/years) - 1;
}
annualize(1.0, 1);  // 1.0000 (100% annualized)
annualize(1.0, 10); // 0.0718 (7.18%)
annualize(1.0, 40); // 0.0175 (1.75%)

// Geometric vs arithmetic mean
const returns = [0.50, -0.50];
const arith = returns.reduce((a,b)=>a+b)/returns.length;            // 0.00
const geom  = Math.pow(returns.reduce((a,b)=>a*(1+b), 1), 1/2) - 1; // -0.134

Two funds returned 12% last year. Fund A had a quiet, steady ride — drawdowns under 5%, daily volatility minimal. Fund B was on a rollercoaster — 30% drawdowns, daily moves of ±3%. Both funds report the same ROI, but they are not the same investment. The Sharpe Ratio, introduced by Nobel laureate William F. Sharpe in 1966, measures excess return per unit of risk: Sharpe = (R_p − R_f) / σ_p, where R_p is the portfolio return, R_f is the risk-free rate (typically the 3-month U.S. Treasury bill), and σ_p is the standard deviation of the portfolio's excess returns. Higher is better. Why subtract the risk-free rate? Any investor can earn R_f without taking risk. The Sharpe Ratio asks: how much extra return did you earn per unit of risk you accepted? A fund returning 12% in a 5% T-bill environment with 15% volatility has Sharpe = (12% − 5%) / 15% = 0.467. A fund returning 8% with 5% volatility has Sharpe = (8% − 5%) / 5% = 0.600 — better risk-adjusted, despite lower headline return. Common interpretation benchmarks: Sharpe < 0.5 is generally considered weak; 0.5–1.0 is acceptable; 1.0–2.0 is good; 2.0+ is excellent (and rare); 3.0+ over multiyear periods is suspicious — Bernie Madoff reported a Sharpe of ~2.5 for years before the fraud unraveled, and post-mortem analysis showed his returns were too smooth to be real. Hedge fund auditors flag Sharpe ratios that look too good as a fraud indicator. Limitations matter. (1) Sharpe assumes returns are normally distributed; real markets have fat tails. The 2008 crisis showed many "low-vol" credit strategies with high reported Sharpes whose risk was hidden in tail events. (2) Sharpe punishes upside volatility equally with downside volatility, even though investors only fear the latter. The Sortino Ratio addresses this by using only downside deviation: Sortino = (R_p − R_f) / σ_downside. (3) Sharpe is sensitive to the measurement horizon. Daily, monthly, and annual Sharpe ratios are not directly comparable; annualizing requires multiplying by sqrt(observations per year), which assumes IID returns — frequently violated. Risk-free rate choice matters. The 3-month Treasury yield (DGS3MO on FRED) is standard for U.S.-domiciled comparisons. The St. Louis Fed publishes the rate daily at fred.stlouisfed.org/series/DGS3MO. Comparing a fund's reported Sharpe to the rate that was actually risk-free in that period — not the current rate — is essential. A 1990s Sharpe computed with 6% T-bills is not comparable to a 2020 Sharpe computed with 0.05% T-bills. Practical use: when a fund or strategy advertises a return number, ask for the Sharpe over the same period. If the strategy refuses or uses a non-standard ratio (Calmar, Omega, MAR), pin down what they actually compute and against which benchmark. Educational only — consult a licensed financial advisor for portfolio decisions.

// Sharpe Ratio
function sharpe(returns, riskFreeRate) {
  const mean = returns.reduce((a,b)=>a+b, 0) / returns.length;
  const variance = returns.reduce((s,r)=>s + (r - mean)**2, 0) / returns.length;
  const stdev = Math.sqrt(variance);
  return (mean - riskFreeRate) / stdev;
}

// Annualize a daily Sharpe (assumes IID returns)
function annualizedSharpe(dailySharpe) {
  return dailySharpe * Math.sqrt(252); // 252 trading days/yr
}

// Sortino — only downside deviation
function sortino(returns, riskFreeRate) {
  const mean = returns.reduce((a,b)=>a+b, 0) / returns.length;
  const downside = returns.filter(r => r < riskFreeRate);
  const dVar = downside.reduce((s,r)=>s + (r - riskFreeRate)**2, 0) / returns.length;
  return (mean - riskFreeRate) / Math.sqrt(dVar);
}