"""Reproduce the public Australian mortgage cases using independent Decimal math. Usage: python scripts/check_au_mortgage_reference.py [cases.json] The standard-library checker neither imports production code nor contacts a lender. The hypothetical cases test our declared periodic model, not Australian lender daily accrual, professional review, approval or observed user outcomes. """ from decimal import Decimal as D, ROUND_HALF_UP, ROUND_CEILING, getcontext import json from pathlib import Path import sys getcontext().prec = 50 ROOT = Path(__file__).resolve().parents[1] FREQUENCIES = {"monthly": 12, "fortnightly": 26, "weekly": 52} def integer(value): return int(D(value).to_integral_value(rounding=ROUND_HALF_UP)) def money(value): return integer(D(value) * 100) def period_count(frequency, years, extra_months=0): return int((D(12 * years + extra_months) * frequency / 12).to_integral_value(rounding=ROUND_CEILING)) def annuity(principal_cents, rate_percent, frequency, years, extra_months=0): periods = period_count(frequency, years, extra_months) rate = D(rate_percent) / 100 / frequency if not rate: return integer(D(principal_cents) / periods) return integer(D(principal_cents) * rate / (1 - (1 + rate) ** -periods)) def ledger(principal, rate, years, frequency, scheduled, extra, offset, annual_fees, upfront, extra_months=0): balance = principal interest_total = principal_total = repayment_total = 0 maximum_periods = period_count(frequency, years, extra_months) rows = [] for period in range(1, maximum_periods + 1): opening = balance charge = integer(D(max(0, opening - offset)) * D(rate) / 100 / frequency) due = opening + charge paid = due if period == maximum_periods else min(due, scheduled + extra) principal_paid = paid - charge balance = due - paid cumulative_fee = integer(D(annual_fees) * period / frequency) prior_fee = integer(D(annual_fees) * (period - 1) / frequency) rows.append({ "period": period, "opening_balance_cents": opening, "interest_cents": charge, "payment_cents": paid, "principal_cents": principal_paid, "fee_cents": cumulative_fee - prior_fee, "closing_balance_cents": balance, }) interest_total += charge repayment_total += paid principal_total += principal_paid assert balance >= 0 assert paid <= due if not balance: break assert balance == 0 assert principal_total == principal assert repayment_total == principal + interest_total fees = integer(D(annual_fees) * len(rows) / frequency) assert sum(row["fee_cents"] for row in rows) == fees return { "periods": len(rows), "interest_cents": interest_total, "repayments_cents": repayment_total, "ongoing_fees_cents": fees, "total_outflow_cents": repayment_total + fees + upfront, "final_payment_cents": rows[-1]["payment_cents"], "first_interest_cents": rows[0]["interest_cents"], "first_closing_balance_cents": rows[0]["closing_balance_cents"], } def calculate(fields): principal = money(fields["loan"]) rate = D(fields["rate"]) years = int(fields["years"]) months = int(fields.get("months", "0")) frequency = FREQUENCIES[fields["frequency"]] extra = money(fields.get("extra", "0")) offset = money(fields.get("offset", "0")) annual_fees = money(fields.get("annual_fee", "0")) + 12 * money(fields.get("monthly_fee", "0")) upfront = money(fields.get("upfront_fee", "0")) scheduled = annuity(principal, rate, frequency, years, months) scenario_scheduled = scheduled selected_stress = annuity(principal, rate + 3, frequency, years, months) if fields.get("mode", "standard") == "accelerated": monthly = annuity(principal, rate, 12, years, months) divisor = {26: 2, 52: 4}[frequency] scenario_scheduled = integer(D(monthly) / divisor) selected_stress = integer(D(annuity(principal, rate + 3, 12, years, months)) / divisor) baseline = ledger(principal, rate, years, frequency, scheduled, 0, 0, annual_fees, upfront, months) scenario = ledger(principal, rate, years, frequency, scenario_scheduled, extra, offset, annual_fees, upfront, months) result = { "baseline_payment_cents": scheduled, "scenario_payment_cents": scenario_scheduled + extra, "stress_payment_cents": annuity(principal, rate + 3, frequency, years, months), "stress_selected_mode_payment_cents": selected_stress, "periods_saved": baseline["periods"] - scenario["periods"], "interest_saved_cents": baseline["interest_cents"] - scenario["interest_cents"], "outflow_saved_cents": baseline["total_outflow_cents"] - scenario["total_outflow_cents"], } for name, values in (("baseline", baseline), ("scenario", scenario)): result.update({f"{name}_{key}": value for key, value in values.items()}) return result def main(): path = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "assets/au-mortgage-cases.json" data = json.loads(path.read_text(encoding="utf-8")) cases = data["cases"] assert len({case["id"] for case in cases}) == len(cases) checks = 0 for case in cases: actual = calculate(case["inputs"]) for key, expected in case["expected"].items(): assert str(actual[key]) == str(expected), (case["id"], key, actual[key], expected) checks += 1 # Fixed hand-checkable anchors do not read their expected values from JSON. assert annuity(60000000, D(6), 12, 30) == 359730 assert annuity(60000000, D(6), 26, 30) == 165950 assert annuity(60000000, D(6), 52, 30) == 82958 assert annuity(12000000, D(0), 12, 10) == 100000 assert annuity(60000000, D(9), 12, 30) == 482774 assert period_count(12, 24, 7) == 295 assert period_count(26, 0, 1) == 3 assert period_count(52, 0, 1) == 5 print(json.dumps({"status": "passed", "cases": len(cases), "expected_outputs": checks, "precision": getcontext().prec})) if __name__ == "__main__": main()