SIPs, STPs and SWPs: mechanics and behaviour

"""Rupee-cost averaging: twelve SIP instalments against one lump sum, on three invented NAV paths.

A SIP instalment buys units at the NAV of its day: units = instalment ÷ NAV. A fixed amount buys more units when the
NAV is low and fewer when it is high, so the average cost of a unit (money paid ÷ units bought) is the harmonic mean
of the NAVs, which is never above their plain average. Whether the plan gains still depends only on the last NAV
against that average cost. The NAVs are invented; units are rounded to three decimals; stamp duty and tax are left
aside. Decimal arithmetic, rounding half up.
"""

from decimal import ROUND_HALF_UP, Decimal

INSTALMENT = Decimal(5000)
PATHS = {
    "A, falls and partly recovers": ["20", "18", "16", "14", "12", "12", "13", "14", "15", "15", "16", "16"],
    "B, rises steadily": ["20", "20.5", "21", "21.5", "22", "22.5", "23", "23.5", "24", "24.5", "25", "25.5"],
    "C, falls and stays down": ["20", "19", "18", "17", "16", "15", "14", "13", "12", "12", "12", "12"],
}


def inr(amount):
    value = int(Decimal(amount).quantize(Decimal("1"), rounding=ROUND_HALF_UP))
    sign, digits = ("−" if value < 0 else ""), str(abs(value))
    head, tail = digits[:-3], digits[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return sign + "₹" + ",".join(groups + [tail])


def pct(x):
    value = (x * 100).quantize(Decimal("0.1"), rounding=ROUND_HALF_UP)
    return ("+" if value > 0 else "−" if value < 0 else "") + f"{abs(value)} %"


def money2(x):
    return "₹" + str(Decimal(x).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))


def units_for(amount, nav):
    return (amount / nav).quantize(Decimal("0.001"), rounding=ROUND_HALF_UP)


# Part 1: path A month by month.
navs = [Decimal(n) for n in PATHS["A, falls and partly recovers"]]
print(f"1. Path A: {inr(INSTALMENT)} at the NAV of each month")
print(f"{'Month':>5}{'NAV':>8}{'Units bought':>14}{'Units so far':>14}")
total = Decimal(0)
for month, nav in enumerate(navs, start=1):
    units = units_for(INSTALMENT, nav)
    total += units
    print(f"{month:>5}{money2(nav):>8}{units:>14}{total:>14}")
paid = INSTALMENT * len(navs)
print(f"Paid in {inr(paid)}; {total} units, worth {inr(total * navs[-1])} at the last NAV of {money2(navs[-1])}.")
lump_units = units_for(paid, navs[0])
print(f"The same {inr(paid)} at once in month 1: {lump_units} units, worth {inr(lump_units * navs[-1])}.")

# Part 2: the three paths side by side.
print()
print("2. Average NAV, average cost of a unit and the result, path by path")
print(f"{'Path':<30}{'Avg NAV':>9}{'Avg cost':>10}{'SIP end':>11}{'SIP':>9}{'Lump end':>11}{'Lump':>9}")
for name, path in PATHS.items():
    navs = [Decimal(n) for n in path]
    units = sum(units_for(INSTALMENT, nav) for nav in navs)
    paid = INSTALMENT * len(navs)
    avg_nav = sum(navs) / len(navs)
    avg_cost = paid / units
    sip_end = units * navs[-1]
    lump_end = units_for(paid, navs[0]) * navs[-1]
    print(
        f"{name:<30}{money2(avg_nav):>9}{money2(avg_cost):>10}{inr(sip_end):>11}{pct(sip_end / paid - 1):>9}"
        f"{inr(lump_end):>11}{pct(lump_end / paid - 1):>9}"
    )
print("In every path the average cost is below the average NAV; the SIP gains only where the last NAV is above it.")

1. Path A: ₹5,000 at the NAV of each month
Month     NAV  Units bought  Units so far
    1  ₹20.00       250.000       250.000
    2  ₹18.00       277.778       527.778
    3  ₹16.00       312.500       840.278
    4  ₹14.00       357.143      1197.421
    5  ₹12.00       416.667      1614.088
    6  ₹12.00       416.667      2030.755
    7  ₹13.00       384.615      2415.370
    8  ₹14.00       357.143      2772.513
    9  ₹15.00       333.333      3105.846
   10  ₹15.00       333.333      3439.179
   11  ₹16.00       312.500      3751.679
   12  ₹16.00       312.500      4064.179
Paid in ₹60,000; 4064.179 units, worth ₹65,027 at the last NAV of ₹16.00.
The same ₹60,000 at once in month 1: 3000.000 units, worth ₹48,000.

2. Average NAV, average cost of a unit and the result, path by path
Path                            Avg NAV  Avg cost    SIP end      SIP   Lump end     Lump
A, falls and partly recovers     ₹15.08    ₹14.76    ₹65,027   +8.4 %    ₹48,000  −20.0 %
B, rises steadily                ₹22.75    ₹22.62    ₹67,644  +12.7 %    ₹76,500  +27.5 %
C, falls and stays down          ₹15.00    ₹14.50    ₹49,672  −17.2 %    ₹36,000  −40.0 %
In every path the average cost is below the average NAV; the SIP gains only where the last NAV is above it.

"""A flat SIP and a step-up SIP projected at three assumed returns, and what missed instalments do.

Every projection here is arithmetic on an assumption, not a forecast. The convention is stated: the assumed return is
an effective yearly rate, so the monthly rate is (1 + r)^(1/12) − 1 and twelve months multiply to exactly 1 + r;
instalments go in at the start of each month (an annuity due). The step-up raises the instalment by 10 % at the start
of every year. Part 3 also gives the end-of-month values, the convention of the model on the lesson's page. Decimal
arithmetic, rounding half up to the rupee.
"""

from decimal import ROUND_HALF_UP, Decimal, getcontext

getcontext().prec = 40
START = Decimal(5000)
YEARS = 10
STEP_UP = Decimal("0.10")
RATES = [Decimal("0.06"), Decimal("0.09"), Decimal("0.12")]


def inr(amount):
    value = int(Decimal(amount).quantize(Decimal("1"), rounding=ROUND_HALF_UP))
    sign, digits = ("−" if value < 0 else ""), str(abs(value))
    head, tail = digits[:-3], digits[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return sign + "₹" + ",".join(groups + [tail])


def monthly_rate(r):
    return (1 + r) ** (Decimal(1) / 12) - 1


def project(rate, step_up=Decimal(0), skip=(), start_of_month=True):
    """Corpus after YEARS, with instalments rising by step_up each year; months in skip pay nothing."""
    g = 1 + monthly_rate(rate)
    balance = paid = Decimal(0)
    for month in range(1, YEARS * 12 + 1):
        amount = START * (1 + step_up) ** ((month - 1) // 12)
        if month in skip:
            amount = Decimal(0)
        if start_of_month:
            balance = (balance + amount) * g
        else:
            balance = balance * g + amount
        paid += amount
    return balance, paid


print(f"1. {inr(START)} a month for {YEARS} years, flat or stepped up 10 % every year (start of each month)")
print(f"{'Assumed return':<16}{'Flat: paid':>13}{'Flat: corpus':>15}{'Step-up: paid':>16}{'Step-up: corpus':>18}")
for r in RATES:
    flat, flat_paid = project(r)
    step, step_paid = project(r, STEP_UP)
    print(f"{f'{r * 100:.0f} % a year':<16}{inr(flat_paid):>13}{inr(flat):>15}{inr(step_paid):>16}{inr(step):>18}")
print(f"The instalment of the step-up plan in year {YEARS}: {inr(START * (1 + STEP_UP) ** (YEARS - 1))} a month.")

print()
print("2. Three instalments missed in year 2 (months 13 to 15), at an assumed 9 %")
full, full_paid = project(RATES[1])
missed, missed_paid = project(RATES[1], skip={13, 14, 15})
print(f"All 120 paid: {inr(full_paid)} in, {inr(full)} at the end.")
print(f"117 paid:     {inr(missed_paid)} in, {inr(missed)} at the end: {inr(full - missed)} less, the {inr(full_paid - missed_paid)} not paid and its growth.")

print()
print("3. The flat plan with each instalment at the end of its month instead (one month less growth for each)")
for r in RATES:
    end, _ = project(r, start_of_month=False)
    print(f"{f'{r * 100:.0f} % a year':<16}{inr(end):>15}")

1. ₹5,000 a month for 10 years, flat or stepped up 10 % every year (start of each month)
Assumed return     Flat: paid   Flat: corpus   Step-up: paid   Step-up: corpus
6 % a year          ₹6,00,000      ₹8,16,321       ₹9,56,245        ₹12,43,135
9 % a year          ₹6,00,000      ₹9,55,430       ₹9,56,245        ₹14,23,617
12 % a year         ₹6,00,000     ₹11,20,179       ₹9,56,245        ₹16,34,449
The instalment of the step-up plan in year 10: ₹11,790 a month.

2. Three instalments missed in year 2 (months 13 to 15), at an assumed 9 %
All 120 paid: ₹6,00,000 in, ₹9,55,430 at the end.
117 paid:     ₹5,85,000 in, ₹9,23,084 at the end: ₹32,346 less, the ₹15,000 not paid and its growth.

3. The flat plan with each instalment at the end of its month instead (one month less growth for each)
6 % a year            ₹8,12,367
9 % a year            ₹9,48,593
12 % a year          ₹11,09,650

"""The XIRR of an invented step-up SIP with two late instalments and one that failed.

Twenty-four instalments were due a month apart: ₹5,000 in the first year and ₹5,500 in the second, a 10 % step-up.
Instalment 5 went in 4 days late, instalment 9 six days late, and instalment 15 failed, so it bought nothing and is
not a cash flow at all. Each instalment bought units at the invented NAV of its day; the holding is valued on day 730.
Days are counted from the first instalment. XIRR, as the spreadsheet function defines it, is the yearly rate at which
every dated flow, discounted to day 0 on a 365-day year, adds up to zero (money paid in negative, the value positive).
Decimal arithmetic, units to three decimals, rounding half up.
"""

from decimal import ROUND_HALF_UP, Decimal, getcontext

getcontext().prec = 40
DUE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365, 396, 424, 455, 485, 516, 546, 577, 608, 638, 669, 699]
LATE = {5: 4, 9: 6}   # instalment number: days late
FAILED = {15}         # instalment numbers whose debit failed
NAVS = ["40.00", "39.10", "38.40", "37.20", "36.10", "35.40", "34.60", "34.00", "34.90", "36.20", "37.10", "38.30",
        "39.00", "39.80", "40.60", "41.20", "40.10", "41.70", "42.90", "43.60", "44.20", "45.10", "45.80", "46.40"]
VALUE_DAY, VALUE_NAV = 730, Decimal("46.80")


def inr(amount, paise=False):
    q = Decimal("0.01") if paise else Decimal("1")
    value = Decimal(amount).quantize(q, rounding=ROUND_HALF_UP)
    whole, _, frac = str(abs(value)).partition(".")
    head, tail = whole[:-3], whole[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return ("−" if value < 0 else "") + "₹" + ",".join(groups + [tail]) + (("." + frac) if paise else "")


def pct(x, places="0.01"):
    value = (x * 100).quantize(Decimal(places), rounding=ROUND_HALF_UP)
    return ("−" if value < 0 else "") + f"{abs(value)} %"


def xnpv(rate, flows):
    return sum(Decimal(p) / (1 + rate) ** (Decimal(d) / 365) for d, p in flows)


def xirr(flows):
    lo, hi = Decimal("-0.99"), Decimal(1)
    while hi - lo > Decimal("0.0000001"):
        mid = (lo + hi) / 2
        if xnpv(mid, flows) > 0:
            lo = mid
        else:
            hi = mid
    return (lo + hi) / 2


flows, units = [], Decimal(0)
print(f"{'No.':>4}{'Day':>6}{'Amount':>10}{'NAV':>9}{'Units':>10}")
for n, (day, nav) in enumerate(zip(DUE, NAVS), start=1):
    amount = Decimal(5000 if n <= 12 else 5500)
    if n in FAILED:
        print(f"{n:>4}{day:>6}{'failed':>10}{nav:>9}{'—':>10}")
        continue
    day += LATE.get(n, 0)
    bought = (amount / Decimal(nav)).quantize(Decimal("0.001"), rounding=ROUND_HALF_UP)
    units += bought
    flows.append((day, -amount))
    print(f"{n:>4}{day:>6}{inr(amount):>10}{nav:>9}{bought:>10}")
value = units * VALUE_NAV
flows.append((VALUE_DAY, value))
paid = -sum(p for _, p in flows if p < 0)
print(f"Paid in {inr(paid)} in {len(flows) - 1} instalments; {units} units worth {inr(value)} on day {VALUE_DAY}.")
print()
rate = xirr(flows)
print(f"Absolute return: {pct(value / paid - 1)} over the whole plan.")
print(f"XIRR: {pct(rate)} a year; XNPV at that rate {inr(xnpv(rate, flows), paise=True)}.")

# The two common mistakes when the flows are typed in.
wrong_failed = flows[:-1] + [(DUE[14], Decimal(-5500)), (VALUE_DAY, value)]
print(f"Entering the failed instalment as if it was paid: {pct(xirr(wrong_failed))}, too low.")
on_schedule = [(DUE[n - 1], Decimal(-(5000 if n <= 12 else 5500))) for n in range(1, 25) if n not in FAILED] + [(VALUE_DAY, value)]
print(f"Ignoring the two late days and using the due dates: {pct(xirr(on_schedule))}.")

 No.   Day    Amount      NAV     Units
   1     0    ₹5,000    40.00   125.000
   2    31    ₹5,000    39.10   127.877
   3    59    ₹5,000    38.40   130.208
   4    90    ₹5,000    37.20   134.409
   5   124    ₹5,000    36.10   138.504
   6   151    ₹5,000    35.40   141.243
   7   181    ₹5,000    34.60   144.509
   8   212    ₹5,000    34.00   147.059
   9   249    ₹5,000    34.90   143.266
  10   273    ₹5,000    36.20   138.122
  11   304    ₹5,000    37.10   134.771
  12   334    ₹5,000    38.30   130.548
  13   365    ₹5,500    39.00   141.026
  14   396    ₹5,500    39.80   138.191
  15   424    failed    40.60         —
  16   455    ₹5,500    41.20   133.495
  17   485    ₹5,500    40.10   137.157
  18   516    ₹5,500    41.70   131.894
  19   546    ₹5,500    42.90   128.205
  20   577    ₹5,500    43.60   126.147
  21   608    ₹5,500    44.20   124.434
  22   638    ₹5,500    45.10   121.951
  23   669    ₹5,500    45.80   120.087
  24   699    ₹5,500    46.40   118.534
Paid in ₹1,20,500 in 23 instalments; 3056.637 units worth ₹1,43,051 on day 730.

Absolute return: 18.71 % over the whole plan.
XIRR: 17.65 % a year; XNPV at that rate ₹0.00.
Entering the failed instalment as if it was paid: 12.99 %, too low.
Ignoring the two late days and using the due dates: 17.63 %.

"""An STP of ₹6,00,000 from an invented liquid scheme to an invented equity scheme, ₹50,000 a month for 12 months.

Every transfer is two transactions: units of the source scheme are sold back at its NAV, and the money buys units of
the target scheme at its NAV. The sale realises the gain on the units sold: (NAV now − NAV paid) × units. Units of a
scheme with more than 65 % in debt and money market instruments, bought in or after the financial year 2023-24, give a
short-term gain whatever the holding period (Income-tax Act, 2025, section 76), taxed with the rest of the income at
the slab rate; here an assumed marginal rate of 20.8 % (the 20 % slab and the 4 % cess). The NAVs are invented; units
are rounded to three decimals and NAVs of the liquid scheme to four. Decimal arithmetic, rounding half up.
"""

from decimal import ROUND_HALF_UP, Decimal

LUMP, TRANSFER, MONTHS = Decimal(600000), Decimal(50000), 12
SOURCE_START = Decimal("2500.0000")
SOURCE_GROWTH = Decimal("0.0055")  # an invented 0.55 % a month for the liquid scheme
TARGET_NAVS = ["50.00", "48.70", "47.20", "45.90", "46.80", "48.10", "47.40", "49.20", "50.60", "51.30", "52.00", "53.10"]
MARGINAL = Decimal("0.208")


def inr(amount):
    value = int(Decimal(amount).quantize(Decimal("1"), rounding=ROUND_HALF_UP))
    sign, digits = ("−" if value < 0 else ""), str(abs(value))
    head, tail = digits[:-3], digits[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return sign + "₹" + ",".join(groups + [tail])


def q3(x):
    return x.quantize(Decimal("0.001"), rounding=ROUND_HALF_UP)


source_units = q3(LUMP / SOURCE_START)
print(f"Day 0: {inr(LUMP)} buys {source_units} units of the liquid scheme at ₹{SOURCE_START}.")
print()
print(f"{'Month':>5}{'Source NAV':>11}{'Sold':>8}{'Moved':>9}{'Gain':>8}{'Target NAV':>11}{'Bought':>10}{'Left':>10}")
target_units, gains = Decimal(0), Decimal(0)
for month in range(1, MONTHS + 1):
    nav = (SOURCE_START * (1 + SOURCE_GROWTH) ** month).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    amount = TRANSFER if month < MONTHS else min(TRANSFER, source_units * nav)
    sold = source_units if month == MONTHS else q3(amount / nav)
    amount = sold * nav if month == MONTHS else amount
    gain = sold * (nav - SOURCE_START)
    source_units -= sold
    gains += gain
    tnav = Decimal(TARGET_NAVS[month - 1])
    bought = q3(amount / tnav)
    target_units += bought
    print(f"{month:>5}{nav:>11}{sold:>8}{inr(amount):>9}{inr(gain):>8}{tnav:>11}{bought:>10}{inr(source_units * nav):>10}")
print()
print(f"The last transfer moved what was left, {inr(amount)}: the liquid units kept earning while they waited.")
print(f"Moved into the equity scheme: {target_units} units, worth {inr(target_units * Decimal(TARGET_NAVS[-1]))} at its last NAV.")
print(f"Gains realised in the liquid scheme over the 12 sales: {inr(gains)}.")
print(f"Tax on them at an assumed marginal rate of 20.8 %: {inr(gains * MARGINAL)}.")
lump_units = q3(LUMP / Decimal(TARGET_NAVS[0]))
print(f"For comparison, {inr(LUMP)} straight into the equity scheme on day 0: {lump_units} units, worth {inr(lump_units * Decimal(TARGET_NAVS[-1]))}.")

Day 0: ₹6,00,000 buys 240.000 units of the liquid scheme at ₹2500.0000.

Month Source NAV    Sold    Moved    Gain Target NAV    Bought      Left
    1  2513.7500  19.891  ₹50,000    ₹274      50.00  1000.000 ₹5,53,299
    2  2527.5756  19.782  ₹50,000    ₹546      48.70  1026.694 ₹5,06,342
    3  2541.4773  19.674  ₹50,000    ₹816      47.20  1059.322 ₹4,59,125
    4  2555.4554  19.566  ₹50,000  ₹1,085      45.90  1089.325 ₹4,11,651
    5  2569.5104  19.459  ₹50,000  ₹1,353      46.80  1068.376 ₹3,63,915
    6  2583.6427  19.353  ₹50,000  ₹1,619      48.10  1039.501 ₹3,15,915
    7  2597.8528  19.247  ₹50,000  ₹1,883      47.40  1054.852 ₹2,67,652
    8  2612.1410  19.141  ₹50,000  ₹2,146      49.20  1016.260 ₹2,19,125
    9  2626.5077  19.037  ₹50,000  ₹2,408      50.60   988.142 ₹1,70,329
   10  2640.9535  18.933  ₹50,000  ₹2,669      51.30   974.659 ₹1,21,265
   11  2655.4788  18.829  ₹50,000  ₹2,928      52.00   961.538   ₹71,932
   12  2670.0839  27.088  ₹72,327  ₹4,607      53.10  1362.095        ₹0

The last transfer moved what was left, ₹72,327: the liquid units kept earning while they waited.
Moved into the equity scheme: 12640.764 units, worth ₹6,71,225 at its last NAV.
Gains realised in the liquid scheme over the 12 sales: ₹22,333.
Tax on them at an assumed marginal rate of 20.8 %: ₹4,645.
For comparison, ₹6,00,000 straight into the equity scheme on day 0: 12000.000 units, worth ₹6,37,200.

"""An SWP of ₹20,000 a month from an invented equity-oriented scheme: units sold, and the gain inside each payment.

₹20,00,000 bought 40,000 units at a NAV of ₹50.00, 18 months before the first payment. Every payment sells units at
the NAV of its day (this invented scheme charges no exit load after 12 months), so a payment is part money you paid
in (the cost of the units sold) and part gain. Only the gain is a capital gain. Income-tax Act, 2025: units of an
equity-oriented fund are short-term if held 12 months or less (section 2(101)), and the gain is taxed at 20 %
(section 196); held longer, the year's long-term gains above ₹1,25,000 are taxed at 12.5 % (section 198). The Finance
Act, 2026 adds a 4 % cess. The last part shows the tax if the same units had been held 12 months or less. The NAVs
are invented; units to three decimals; decimal arithmetic, rounding half up.
"""

from decimal import ROUND_HALF_UP, Decimal

COST_NAV, UNITS = Decimal("50.00"), Decimal(40000)
PAYMENT = Decimal(20000)
NAVS = ["60.00", "61.20", "59.80", "58.90", "60.40", "62.10", "63.00", "61.70", "62.80", "64.10", "63.50", "65.00"]
LTCG_EXEMPT, CESS = Decimal(125000), Decimal("0.04")


def inr(amount):
    value = int(Decimal(amount).quantize(Decimal("1"), rounding=ROUND_HALF_UP))
    sign, digits = ("−" if value < 0 else ""), str(abs(value))
    head, tail = digits[:-3], digits[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return sign + "₹" + ",".join(groups + [tail])


units = UNITS
print(f"{inr(COST_NAV * UNITS)} bought 40,000 units at ₹{COST_NAV}, 18 months before the first payment.")
print(f"{'Payment':>7}{'NAV':>8}{'Units sold':>12}{'Cost of them':>14}{'Gain':>9}{'Units left':>12}")
total_cost = total_gain = Decimal(0)
for n, nav in enumerate((Decimal(x) for x in NAVS), start=1):
    sold = (PAYMENT / nav).quantize(Decimal("0.001"), rounding=ROUND_HALF_UP)
    cost = sold * COST_NAV
    gain = PAYMENT - cost
    units -= sold
    total_cost += cost
    total_gain += gain
    print(f"{n:>7}{nav:>8}{sold:>12}{inr(cost):>14}{inr(gain):>9}{units:>12}")
paid_out = PAYMENT * len(NAVS)
print()
print(f"Paid out {inr(paid_out)}: {inr(total_cost)} of it was the cost of the units sold, {inr(total_gain)} was gain.")
print(f"Still invested: {units} units, worth {inr(units * Decimal(NAVS[-1]))} at the last NAV.")
print()
print("Tax on that gain (no other capital gains that year, no surcharge):")
long_tax = max(Decimal(0), total_gain - LTCG_EXEMPT) * Decimal("0.125") * (1 + CESS)
print(f"  Held over 12 months, so long-term: {inr(long_tax)}; {inr(total_gain)} is within the ₹1,25,000 exemption")
short_tax = total_gain * Decimal("0.20") * (1 + CESS)
print(f"  Had they been held 12 months or less: {inr(short_tax)}, 20.8 % of the gain")
print(f"Taxing all {inr(paid_out)} as income at 20.8 % would wrongly give {inr(paid_out * Decimal('0.208'))}.")

₹20,00,000 bought 40,000 units at ₹50.00, 18 months before the first payment.
Payment     NAV  Units sold  Cost of them     Gain  Units left
      1   60.00     333.333       ₹16,667   ₹3,333   39666.667
      2   61.20     326.797       ₹16,340   ₹3,660   39339.870
      3   59.80     334.448       ₹16,722   ₹3,278   39005.422
      4   58.90     339.559       ₹16,978   ₹3,022   38665.863
      5   60.40     331.126       ₹16,556   ₹3,444   38334.737
      6   62.10     322.061       ₹16,103   ₹3,897   38012.676
      7   63.00     317.460       ₹15,873   ₹4,127   37695.216
      8   61.70     324.149       ₹16,207   ₹3,793   37371.067
      9   62.80     318.471       ₹15,924   ₹4,076   37052.596
     10   64.10     312.012       ₹15,601   ₹4,399   36740.584
     11   63.50     314.961       ₹15,748   ₹4,252   36425.623
     12   65.00     307.692       ₹15,385   ₹4,615   36117.931

Paid out ₹2,40,000: ₹1,94,103 of it was the cost of the units sold, ₹45,897 was gain.
Still invested: 36117.931 units, worth ₹23,47,666 at the last NAV.

Tax on that gain (no other capital gains that year, no surcharge):
  Held over 12 months, so long-term: ₹0; ₹45,897 is within the ₹1,25,000 exemption
  Had they been held 12 months or less: ₹9,546, 20.8 % of the gain
Taxing all ₹2,40,000 as income at 20.8 % would wrongly give ₹49,920.

"""The order of returns for a SIP and for an SWP, then a withdrawal plan tested on 10,000 synthetic paths.

Part 1 takes ten invented yearly returns, two bad years and eight good ones, and spreads each year's return evenly over
its twelve months. Order A meets the bad years first; order B is the same list reversed. A SIP pays ₹10,000 in at the
start of every month; an SWP takes ₹15,000 out of ₹20,00,000 at the start of every month, while money is left.
Part 2 draws 10,000 synthetic 25-year paths of yearly returns from a bell curve with an average of 8.8 % and a
volatility of 11.5 % (seeded, so every run gives the same paths) and withdraws a share of the starting ₹50,00,000
each year, raised by an assumed 5 % a year for rising prices. Nothing here is a forecast; no real investment is
described. Floats for the 10,000 paths, rounded only for printing.
"""

import random
import statistics

RETURNS = [-0.25, -0.15, 0.05, 0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.22]


def inr(amount):
    value = round(amount)
    sign, digits = ("−" if value < 0 else ""), str(abs(value))
    head, tail = digits[:-3], digits[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return sign + "₹" + ",".join(groups + [tail])


def monthly(order):
    for r in order:
        for _ in range(12):
            yield (1 + r) ** (1 / 12)


orders = {"A, bad years first:": RETURNS, "B, bad years last: ": RETURNS[::-1]}
print("1a. A SIP of ₹10,000 at the start of each month, ₹12,00,000 paid in over ten years")
for name, order in orders.items():
    sip = 0.0
    for g in monthly(order):
        sip = (sip + 10000) * g
    print(f"   Order {name} ends at {inr(sip)}")
print("1b. An SWP of ₹15,000 at the start of each month from ₹20,00,000")
for name, order in orders.items():
    swp, taken, month_out = 2000000.0, 0.0, None
    for month, g in enumerate(monthly(order), start=1):
        take = min(15000.0, swp)
        swp, taken = (swp - take) * g, taken + take
        if swp <= 0 and month_out is None:
            month_out = month
    end = f"runs out in month {month_out}" if month_out else f"ends with {inr(swp)}"
    print(f"   Order {name} {end}, after paying {inr(taken)}")

print()
print("2. ₹50,00,000 on 10,000 synthetic 25-year paths, withdrawn monthly at a starting")
print("   yearly rate of the corpus, raised 5 % every year")
rng = random.Random(2026)
paths = [[rng.gauss(0.088, 0.115) for _ in range(25)] for _ in range(10000)]
print(f"{'Starting rate':<15}{'First year':>12}{'Lasts 25 years':>16}{'Median left':>14}")
runs_out = {}
for rate in (0.04, 0.06, 0.08):
    lasted, ends = 0, []
    for i, path in enumerate(paths):
        balance, yearly = 5000000.0, 5000000.0 * rate
        for year, r in enumerate(path):
            g = (1 + r) ** (1 / 12)
            take = yearly * 1.05 ** year / 12
            for _ in range(12):
                balance = max(0.0, balance - take) * g
            if balance <= 0:
                break
        lasted += balance > 0
        ends.append(balance)
        if rate == 0.06:
            runs_out[i] = balance <= 0
    print(f"{f'{rate * 100:.0f} %':<15}{inr(5000000 * rate):>12}{f'{lasted / 100:.1f} %':>16}{inr(statistics.median(ends)):>14}")


def growth(returns):
    product = 1.0
    for r in returns:
        product *= 1 + r
    return product ** (1 / len(returns)) - 1


print()
print("3. At 6 %, the paths whose 25 years grew at 7.5 % to 8.5 % a year, split by their")
print("   first five years")
similar = [i for i, path in enumerate(paths) if 0.075 <= growth(path) <= 0.085]
for label, test in (("grew under 3 % a year", lambda g: g < 0.03), ("grew over 12 % a year", lambda g: g > 0.12)):
    group = [i for i in similar if test(growth(paths[i][:5]))]
    share = sum(runs_out[i] for i in group) / len(group)
    print(f"   First five years {label}: {len(group):>4} paths, {share * 100:5.1f} % ran out")
print(f"   ({len(similar)} of the 10,000 paths grew at 7.5 % to 8.5 % a year over the 25 years.)")

1a. A SIP of ₹10,000 at the start of each month, ₹12,00,000 paid in over ten years
   Order A, bad years first: ends at ₹23,40,562
   Order B, bad years last:  ends at ₹11,28,559
1b. An SWP of ₹15,000 at the start of each month from ₹20,00,000
   Order A, bad years first: runs out in month 113, after paying ₹16,88,430
   Order B, bad years last:  ends with ₹16,98,247, after paying ₹18,00,000

2. ₹50,00,000 on 10,000 synthetic 25-year paths, withdrawn monthly at a starting
   yearly rate of the corpus, raised 5 % every year
Starting rate    First year  Lasts 25 years   Median left
4 %               ₹2,00,000          88.9 %  ₹1,09,61,557
6 %               ₹3,00,000          44.7 %            ₹0
8 %               ₹4,00,000          10.9 %            ₹0

3. At 6 %, the paths whose 25 years grew at 7.5 % to 8.5 % a year, split by their
   first five years
   First five years grew under 3 % a year:  225 paths,  99.1 % ran out
   First five years grew over 12 % a year:  328 paths,  21.6 % ran out
   (1729 of the 10,000 paths grew at 7.5 % to 8.5 % a year over the 25 years.)