Calculateur d'intérêts composés

JavaScript

// Compound interest with monthly contributions
function compoundGrowth(P, r, n, t, pmt) {
  // P = principal, r = annual rate (decimal)
  // n = compounds/year, t = years, pmt = monthly contrib
  const monthlyRate =
    Math.pow(1 + r / n, n / 12) - 1;
  let balance = P;
  for (let y = 1; y <= t; y++) {
    for (let m = 0; m < 12; m++) {
      balance *= (1 + monthlyRate);
      balance += pmt;
    }
  }
  return balance;
}

// Example: $10k at 7%, 20 years, $500/mo
console.log(compoundGrowth(10000, 0.07, 1, 20, 500));
// → ~$284,428

Python

def compound_growth(P, r, n, t, pmt=0):
    """
    P   = initial principal
    r   = annual rate (decimal, e.g. 0.07)
    n   = compounding frequency per year
    t   = years
    pmt = monthly contribution
    """
    monthly_rate = (1 + r / n) ** (n / 12) - 1
    balance = P
    for _ in range(t * 12):
        balance *= (1 + monthly_rate)
        balance += pmt
    return balance

# $10,000 at 7% for 20 years + $500/mo
print(f"USD {compound_growth(10000, 0.07, 1, 20, 500):,.2f}")
# → USD 284,428.09

Excel / Google Sheets

// Future Value formula (no contributions)
=FV(rate/n, n*t, 0, -PV)

// With monthly contributions (monthly compounding)
// pmt = monthly payment, rate = annual rate
=FV(rate/12, years*12, -pmt, -PV)

// Example: $10k principal, 7% rate, 20 years
// with $500/month contribution:
=FV(7%/12, 20*12, -500, -10000)
// → $284,428.09

// Rule of 72 — years to double:
=72 / (rate * 100)

Go

package main

import (
    "fmt"
    "math"
)

func compoundGrowth(P, r float64, n, t int, pmt float64) float64 {
    monthlyRate := math.Pow(1+r/float64(n), float64(n)/12) - 1
    balance := P
    for i := 0; i < t*12; i++ {
        balance *= (1 + monthlyRate)
        balance += pmt
    }
    return balance
}

func main() {
    result := compoundGrowth(10000, 0.07, 1, 20, 500)
    fmt.Printf("$%.2f\n", result) // $284,428.09
}