spb/traite-evaluation-qc

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

modified analysis/python/cases/ch12_mesurage.py +1 −1

		@@ -37,7 +37,7 @@ PLAN = {
37	37	"sous_sol_plancher_sous_sol_m": 1.90, # plancher du sous-sol à 1,90 m sous le niveau moyen du sol (> 0,4 m : pas un étage MEFQ)
38	38	"garage_long_m": 6.10, "garage_larg_m": 3.66, # garage simple attaché (20 pi × 12 pi), hors empreinte principale
39	39	"lot_facade_m": 15.24, "lot_prof_m": 40.68, # lot rectangulaire 50 pi × 133,5 pi ≈ 620 m²
40		− "marge_avant_m": 7.50, "marge_lat_gauche_m": 2.00, "marge_lat_droite_m": 1.50,
	40	+ "marge_avant_m": 7.50, "marge_lat_gauche_m": 2.00, "marge_lat_droite_m": 1.66, # 15,24 − 7,92 − 3,66 − 2,00
41	41	}
42	42
43	43

modified analysis/python/cases/ch15_segmentation.py +3 −1

		@@ -188,7 +188,9 @@ def validation_croisee(v: pd.DataFrame, segments: dict, n_plis: int = 10) -> pd.
188	188	y = np.log(v["prix_vente"].astype(float)).values; Xb = matrice_base(v)
189	189	kf = KFold(n_splits=n_plis, shuffle=True, random_state=GRAINE)
190	190	def ajuster_predire(Xtr, ytr, Xte):
191		− b = h.mco(Xtr, ytr)["beta"]; return Xte @ b
	191	+ with np.errstate(invalid="ignore"): # petits segments : variance nulle d'un régresseur → erreurs-types non définies (non utilisées ici)
	192	+ b = h.mco(Xtr, ytr)["beta"]
	193	+ return Xte @ b
192	194	resultats = []
193	195	specs = {"Équation unique sans segment": ("aucun", v["secteur"].astype(str))}
194	196	for nom, lab in segments.items():

modified analysis/python/cases/ch19_spatial.py +23 −0

		@@ -258,6 +258,29 @@ def sensibilite(b: dict) -> pd.DataFrame:
258	258	"rho": sar["rho"], "se_rho": sar["se_rho"], "aic_sar": sar["aic"], "lambda": sem["lambda"], "se_lambda": sem["se_lambda"], "aic_sem": sem["aic"]})
259	259	return pd.DataFrame(rows)
260	260
	261	+
	262	+# ----------------------------------------------------------------------------- exercice 19.7
	263	+
	264	+def exercice_7(b: dict | None = None) -> dict:
	265	+ """SEM sans secteur avec 4, 8 et 16 voisins : λ, espérance conditionnelle du résidu au sujet et indication ;
	266	+ matrice spatio-temporelle avec fenêtre de 24 mois : ventes sans voisine antérieure et ρ_st."""
	267	+ b = b or charger_base(); y, Xr, xy, xs, n = b["y"], b["Xr"].values, b["xy"], b["xs_r"], len(b["y"])
	268	+ duan = lambda res: float(np.mean(np.exp(res)))
	269	+ rows = []
	270	+ for k in [4, 8, 16]:
	271	+ W = h.matrice_poids_knn(xy, k); sem = h.sem_mv(y, Xr, W)
	272	+ xy_aug = np.vstack([xy, b["cs"]]); Wa = np.zeros((n + 1, n + 1)); Wa[:n, :n] = W
	273	+ Wa[n, :n] = h.matrice_poids_knn(xy_aug, k)[n, :n]; Wa[n] /= Wa[n].sum()
	274	+ u_s = float(h.sem_esperance_conditionnelle(sem["lambda"], Wa, sem["residus"], [n])[0])
	275	+ rows.append({"k": k, "lambda": sem["lambda"], "u_sujet": u_s, "indication": float(np.exp(xs @ sem["beta"] + u_s) * duan(sem["innovations"]))})
	276	+ sem_k = pd.DataFrame(rows)
	277	+ out = {"sem_par_k": sem_k}
	278	+ for fen in [12, 24]:
	279	+ Wst = h.matrice_poids_spatio_temporelle(xy, b["mois"], PORTEE_KM, fen); ok = Wst.sum(1) > 0
	280	+ Z = np.column_stack([(Wst @ y)[ok], Xr[ok]]); r = h.mco(Z, y[ok])
	281	+ out[f"st_{fen}"] = {"sans_voisin": int((~ok).sum()), "voisins_moyen": float((Wst[ok] > 0).sum(1).mean()), "rho_st": float(r["beta"][0]), "se": float(r["se_hc1"][0])}
	282	+ return out
	283	+
261	284	# ----------------------------------------------------------------------------- contrôle croisé facultatif
262	285
263	286	def controle_croise(b: dict, W: np.ndarray, g: dict) -> dict:

added analysis/python/cases/ch24_depreciation.py +343 −0

		@@ -0,0 +1,343 @@
	1	+#!/usr/bin/env python3
	2	+"""Chapitre 24 — dépréciation et désuétudes du sujet du cas 1 (Gatineau, DONNÉES SYNTHÉTIQUES).
	3	+
	4	+Imprime tous les chiffres cités dans le chapitre 24 :
	5	+ * âges (chronologique, effectif selon la convention du ch. 11), vie économique et vie restante ;
	6	+ * dépréciation physique : âge-vie simple (âge chronologique / âge effectif), âge-vie modifiée, ventilée par composantes
	7	+ (fiche d'état et travaux du ch. 11, traite.cout.depreciation_ventilee) ;
	8	+ * désuétude fonctionnelle : carence curable du sujet (salle d'eau), exemples incurables (perte de loyer × MRB du cas 2 ;
	9	+ perte de RNE capitalisée) ; désuétude externe (ventes appariées, capitalisation) ;
	10	+ * extraction de marché sur les 600 ventes du cas 1 : coût neuf par vente (élasticité de taille du ch. 21), prix ramenés à la
	11	+ date d'évaluation (tendance du modèle hédonique), valeur de terrain par secteur extraite des ventes récentes, dépréciation
	12	+ par vente, profil en fonction de l'âge (médianes par tranche, ajustements linéaire et quadratique) ;
	13	+ * profils comparés : âge-vie linéaire, extraction, courbe hédonique (coefficients âge et âge² de traite.cas1.hedonique)
	14	+ et profil « vrai » du générateur (data/synthetic/README.md), convertis en dépréciation du bâtiment ;
	15	+ * valeur par le coût du sujet (traite.cout.valeur_par_cout) selon deux lectures de la dépréciation, et sensibilité.
	16	+
	17	+Usage (racine du dépôt) : PYTHONPATH=analysis/python python3 analysis/python/cases/ch24_depreciation.py
	18	+Toutes les formules de dépréciation proviennent de analysis/python/traite/cout.py (aucune réécriture)."""
	19	+from __future__ import annotations
	20	+import sys, pathlib
	21	+import numpy as np, pandas as pd
	22	+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
	23	+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
	24	+from traite import cout as ct, cas1
	25	+from traite import hedonique as h
	26	+import ch21_cout_neuf as c21
	27	+import ch11_inspection as c11
	28	+
	29	+ROOT = pathlib.Path(__file__).resolve().parents[3]
	30	+
	31	+# --- conventions et hypothèses déclarées ---------------------------------------------------------------------
	32	+VIE_ECONOMIQUE = c11.VIE_ECONOMIQUE # 60 ans (convention des ch. 11 et 24, hypothèse pédagogique)
	33	+AGE_CHRONO = 28 # 1998 → 2026
	34	+DATE_EVAL = "2026-09-01"
	35	+ELASTICITE_TAILLE = -0.10 # ch. 21 : coût unitaire ∝ (S/S_réf)^ε
	36	+FACTEUR_QUALITE = 0.05 # coût neuf ± 5 % par classe de qualité (hypothèse pédagogique)
	37	+AGE_MAX_RECENT = 10 # ventes « récentes » servant à extraire la valeur du terrain
	38	+S_REF = 165.0
	39	+# Carence fonctionnelle curable du sujet (constat FICTIF du ch. 24) : aucune salle d'eau au rez-de-chaussée
	40	+SALLE_EAU_AJOUT = 16000.0 # soumission fictive : ajout a posteriori, installé (hypothèse pédagogique)
	41	+SALLE_EAU_POSTES = {"Plomberie brute et finition": 2.0, "Vanités et accessoires (2 sdb)": 0.5, "Portes intérieures et moulures": 1.0,
	42	+ "Gypse et tirage de joints": 12.0, "Peinture intérieure": 12.0, "Planchers céramique": 3.0} # quantités si incluse à neuf
	43	+# Exemples illustratifs (hypothèses pédagogiques, hors sujet)
	44	+TRIPLEX_PERTE_LOYER_MOIS = 75.0 # $/mois, logement sans entrée laveuse-sécheuse
	45	+RNE_PERTE_ANNUELLE = 6000.0 # $/an
	46	+TAUX_CAP_ILLUSTRATIF = 0.045 # milieu de la fourchette CBRE T3 2026 Montréal low-rise B (4,25-4,75 %), calibration.json SRC-E-045
	47	+PART_BATIMENT_ILLUSTRATIVE = 0.70
	48	+PAIRES_SANS, PAIRES_AVEC, PAIRES_PART_BAT = 520000.0, 490000.0, 0.60
	49	+
	50	+
	51	+def charger() -> dict:
	52	+ devis, sujet, cn = c11.charger()
	53	+ d = cas1.charger()
	54	+ m = cas1.hedonique(d["ventes"])
	55	+ fiche = c11.fiche(devis, cn)
	56	+ trav = c11.travaux(devis, cn)
	57	+ return {"devis": devis, "sujet": sujet, "cn": cn, "ventes": d["ventes"], "modele": m, "fiche": fiche, "travaux": trav}
	58	+
	59	+
	60	+# --------------------------------------------------------------------------------------------- âges et âge-vie
	61	+
	62	+def ages_sujet(fiche: pd.DataFrame) -> dict:
	63	+ s = fiche[fiche["longue_duree"]].iloc[0]
	64	+ pond = float((fiche["cout_neuf"] * fiche["ratio"]).sum() / fiche["cout_neuf"].sum())
	65	+ return {"chronologique": AGE_CHRONO, "effectif_structure": float(s.age_effectif), "vie_economique": VIE_ECONOMIQUE,
	66	+ "vie_restante": ct.vie_restante(VIE_ECONOMIQUE, float(s.age_effectif)),
	67	+ "ratio_pondere": pond, "age_effectif_pondere": pond * VIE_ECONOMIQUE, "indice_etat": c11.indice_etat(fiche)}
	68	+
	69	+
	70	+def variantes_physique(cn: dict, fiche: pd.DataFrame, trav: pd.DataFrame) -> dict:
	71	+ """Quatre lectures de la dépréciation physique du sujet (toutes sur C_N = 397 567,33 $)."""
	72	+ a_eff = ages_sujet(fiche)["effectif_structure"]
	73	+ curable = float(trav["cout"].sum())
	74	+ simple_chrono = ct.depreciation_age_vie(cn["total"], AGE_CHRONO, VIE_ECONOMIQUE)
	75	+ simple_eff = ct.depreciation_age_vie(cn["total"], a_eff, VIE_ECONOMIQUE)
	76	+ modifiee = ct.depreciation_age_vie_modifiee(cn["total"], curable, a_eff, VIE_ECONOMIQUE)
	77	+ ventilee = c11.depreciation(fiche, trav, cn)
	78	+ return {"age_vie_chrono": simple_chrono, "age_vie_effectif": simple_eff, "modifiee": modifiee, "ventilee": ventilee,
	79	+ "curable": curable, "age_effectif": a_eff}
	80	+
	81	+
	82	+# ------------------------------------------------------------------------------------------ désuétudes
	83	+
	84	+def carence_salle_eau(devis: pd.DataFrame, cn: dict) -> dict:
	85	+ """Désuétude fonctionnelle curable (carence) : coût d'ajout a posteriori − coût de l'élément s'il avait été inclus à neuf.
	86	+ Le coût « à neuf » est reconstitué à partir des prix unitaires du devis (quantités déclarées), majoré comme le coût neuf."""
	87	+ g = c11.facteur_majoration(cn)
	88	+ direct = 0.0
	89	+ for poste, q in SALLE_EAU_POSTES.items():
	90	+ pu = float(devis.loc[devis["poste"] == poste, "prix_unitaire"].iloc[0])
	91	+ direct += pu * q
	92	+ cout_si_neuf = direct * g
	93	+ d = ct.desuetude_fonctionnelle_curable(SALLE_EAU_AJOUT, cout_si_neuf, 0.0)
	94	+ return {"cout_si_neuf_direct": direct, "cout_si_neuf": cout_si_neuf, "cout_ajout": SALLE_EAU_AJOUT, "desuetude": d}
	95	+
	96	+
	97	+def exemples_incurables() -> dict:
	98	+ from traite import cas2
	99	+ ind = cas2.indicateurs_marche(cas2.comparables_plex(cas2.charger()["ventes"], cas2.charger()["sujet"]))
	100	+ mrb_annuel = ind["mrb_median_triplex"]
	101	+ loyer = ct.desuetude_incurable_par_loyer(TRIPLEX_PERTE_LOYER_MOIS, mrb_annuel * 12)
	102	+ rne = ct.desuetude_incurable_par_rne(RNE_PERTE_ANNUELLE, TAUX_CAP_ILLUSTRATIF, PART_BATIMENT_ILLUSTRATIVE)
	103	+ rne_total = ct.desuetude_incurable_par_rne(RNE_PERTE_ANNUELLE, TAUX_CAP_ILLUSTRATIF, 1.0)
	104	+ paires = ct.desuetude_externe_ventes_appariees(PAIRES_SANS, PAIRES_AVEC, PAIRES_PART_BAT)
	105	+ return {"mrb_annuel": mrb_annuel, "mrb_mensuel": mrb_annuel * 12, "perte_loyer_capitalisee": loyer,
	106	+ "perte_rne_capitalisee_totale": rne_total, "perte_rne_batiment": rne, "paires": paires}
	107	+
	108	+
	109	+# ------------------------------------------------------------------------------------------ extraction de marché
	110	+
	111	+def cout_neuf_ventes(v: pd.DataFrame, cn_total: float, elasticite: float = ELASTICITE_TAILLE, fq: float = FACTEUR_QUALITE) -> pd.Series:
	112	+ """Coût neuf de chaque vente, transposé du sujet : C_N × (S/165)^(1+ε) × (1 + fq·(qualité − 3))."""
	113	+ unit = ct.cout_par_superficie_ajuste(cn_total / S_REF, S_REF, v["superficie_habitable_m2"].astype(float), elasticite)
	114	+ return unit * v["superficie_habitable_m2"].astype(float) * (1.0 + fq * (v["qualite_1a5"].astype(float) - 3.0))
	115	+
	116	+
	117	+def prix_a_la_date(v: pd.DataFrame, modele: dict, date_eval: str = DATE_EVAL) -> pd.Series:
	118	+ """Prix ramenés à la date d'évaluation par la tendance mensuelle du modèle hédonique (ch. 17-18)."""
	119	+ g = modele["croissance_mensuelle"]
	120	+ mois = (pd.Timestamp(date_eval) - pd.to_datetime(v["date_vente"])).dt.days / 30.4375
	121	+ return v["prix_vente"].astype(float) * (1.0 + g) ** mois
	122	+
	123	+
	124	+def valeur_terrain_par_secteur(v: pd.DataFrame, p_adj: pd.Series, cn_i: pd.Series, age_max: int = AGE_MAX_RECENT) -> pd.DataFrame:
	125	+ """Valeur du terrain par secteur, extraite des ventes récentes : V_L = P_adj − C_N (1 − âge/L) (extraction, ch. 25)."""
	126	+ r = v[v["age"] <= age_max].copy()
	127	+ r["p_adj"] = p_adj[r.index]; r["cn"] = cn_i[r.index]
	128	+ r["dep"] = [ct.depreciation_age_vie(c, a, VIE_ECONOMIQUE) for c, a in zip(r["cn"], r["age"])]
	129	+ r["vl"] = r["p_adj"] - (r["cn"] - r["dep"])
	130	+ r["part"] = r["vl"] / r["p_adj"]
	131	+ g = r.groupby("secteur").agg(n=("vl", "size"), vl_mediane=("vl", "median"), vl_moyenne=("vl", "mean"), vl_ecart_type=("vl", "std"),
	132	+ part_mediane=("part", "median"), terrain_m2_median=("superficie_terrain_m2", "median"))
	133	+ g["vl_par_m2"] = g["vl_mediane"] / g["terrain_m2_median"]
	134	+ return g
	135	+
	136	+
	137	+def extraction(v: pd.DataFrame, modele: dict, cn_total: float, elasticite: float = ELASTICITE_TAILLE, fq: float = FACTEUR_QUALITE,
	138	+ age_max: int = AGE_MAX_RECENT) -> tuple[pd.DataFrame, pd.DataFrame]:
	139	+ """Dépréciation totale extraite de chaque vente : D = C_N − (P_adj − V_L) (traite.cout.extraction_depreciation_marche)."""
	140	+ w = v.copy()
	141	+ w["cn"] = cout_neuf_ventes(w, cn_total, elasticite, fq)
	142	+ w["p_adj"] = prix_a_la_date(w, modele)
	143	+ vl = valeur_terrain_par_secteur(w, w["p_adj"], w["cn"], age_max)
	144	+ w["vl"] = w["secteur"].map(vl["vl_mediane"])
	145	+ ext = [ct.extraction_depreciation_marche(p, l, c, a) for p, l, c, a in zip(w["p_adj"], w["vl"], w["cn"], w["age"])]
	146	+ w["contribution_batiment"] = [e["contribution_batiment"] for e in ext]
	147	+ w["D"] = [e["depreciation"] for e in ext]
	148	+ w["taux"] = [e["taux"] for e in ext]
	149	+ w["taux_annuel"] = [e.get("taux_annuel", np.nan) for e in ext]
	150	+ return w, vl
	151	+
	152	+
	153	+def ajuster_profil(w: pd.DataFrame) -> dict:
	154	+ """Ajustements du taux de dépréciation extrait sur l'âge : linéaire (constante), quadratique, linéaire par l'origine."""
	155	+ a = w["age"].astype(float).values; y = w["taux"].values; n = len(w)
	156	+ lin = h.mco(np.column_stack([np.ones(n), a]), y)
	157	+ quad = h.mco(np.column_stack([np.ones(n), a, a ** 2]), y)
	158	+ orig = h.mco(a.reshape(-1, 1), y)
	159	+ return {"lineaire": lin, "quadratique": quad, "origine": orig,
	160	+ "taux_annuel_origine": float(orig["beta"][0]), "vie_implicite": 1.0 / float(orig["beta"][0])}
	161	+
	162	+
	163	+def taux_quadratique(quad: dict, age) -> np.ndarray:
	164	+ b = quad["beta"]; age = np.asarray(age, dtype=float)
	165	+ return b[0] + b[1] * age + b[2] * age ** 2
	166	+
	167	+
	168	+def tranches(w: pd.DataFrame, bornes=(0, 10, 20, 30, 40, 50, 60, 100)) -> pd.DataFrame:
	169	+ g = w.groupby(pd.cut(w["age"], bornes), observed=True)["taux"].agg(["size", "median", "mean", "std"])
	170	+ g.index = [f"{int(i.left) + (1 if i.left else 0)}-{int(i.right)}" for i in g.index]
	171	+ return g
	172	+
	173	+
	174	+# ------------------------------------------------------------------------------------------ profils comparés
	175	+
	176	+def prix_neuf_sujet(modele: dict, sujet: dict) -> float:
	177	+ """Prédiction hédonique du sujet s'il était neuf (âge 0), même date, correction de Duan."""
	178	+ s = dict(sujet); s["age"] = 0; s["annee_construction"] = 2026
	179	+ return float(cas1.predire(modele, cas1.sujet_df(s))[0])
	180	+
	181	+
	182	+def profil_total_hedonique(modele: dict, age) -> np.ndarray:
	183	+ """Baisse du prix TOTAL avec l'âge selon le modèle : 1 − exp(β₁ âge + β₂ âge²)."""
	184	+ b1 = float(modele["coef"].loc["age", "coef"]); b2 = float(modele["coef"].loc["age2_100", "coef"]) / 100.0
	185	+ age = np.asarray(age, dtype=float)
	186	+ return 1.0 - np.exp(b1 * age + b2 * age ** 2)
	187	+
	188	+
	189	+def profil_total_generateur(age) -> np.ndarray:
	190	+ """Loi de génération du cas 1 (data/synthetic/README.md) : −0,0055·âge + 0,00003·âge²."""
	191	+ age = np.asarray(age, dtype=float)
	192	+ return 1.0 - np.exp(-0.0055 * age + 0.00003 * age ** 2)
	193	+
	194	+
	195	+def total_vers_batiment(d_total, alpha: float) -> np.ndarray:
	196	+ """Conversion : si le terrain vaut une part α du prix neuf et ne se déprécie pas, d_B = d_total / (1 − α)."""
	197	+ return np.asarray(d_total, dtype=float) / (1.0 - alpha)
	198	+
	199	+
	200	+def profils(modele: dict, sujet: dict, vl: float, quad: dict, ages=np.arange(0, 81)) -> dict:
	201	+ p0 = prix_neuf_sujet(modele, sujet)
	202	+ alpha = vl / p0
	203	+ return {"ages": ages, "prix_neuf": p0, "alpha": alpha,
	204	+ "age_vie": np.minimum(ages / VIE_ECONOMIQUE, 1.0),
	205	+ "extraction": taux_quadratique(quad, ages),
	206	+ "hedonique_total": profil_total_hedonique(modele, ages), "generateur_total": profil_total_generateur(ages),
	207	+ "hedonique_bat": total_vers_batiment(profil_total_hedonique(modele, ages), alpha),
	208	+ "generateur_bat": total_vers_batiment(profil_total_generateur(ages), alpha)}
	209	+
	210	+
	211	+# ------------------------------------------------------------------------------------------ valeur par le coût
	212	+
	213	+def valeur_terrain_retenue(vl: pd.DataFrame, secteur: str = "Hull") -> dict:
	214	+ med = float(vl.loc[secteur, "vl_mediane"])
	215	+ return {"mediane": med, "retenue": round(med / 1000.0) * 1000.0, "n": int(vl.loc[secteur, "n"]), "part": float(vl.loc[secteur, "part_mediane"])}
	216	+
	217	+
	218	+def valeur_sujet(cn: dict, vl_retenue: float, quad: dict, fonc: float, variantes: dict) -> dict:
	219	+ """Deux lectures : (A) dépréciation physique ventilée (ch. 11) + désuétude fonctionnelle ; (B) dépréciation extraite du marché
	220	+ à l'âge chronologique + désuétude fonctionnelle spécifique au sujet."""
	221	+ t28 = float(taux_quadratique(quad, AGE_CHRONO))
	222	+ d_ext = t28 * cn["total"]
	223	+ A = ct.valeur_par_cout(vl_retenue, cn["total"], variantes["ventilee"]["total"], fonc, 0.0)
	224	+ B = ct.valeur_par_cout(vl_retenue, cn["total"], d_ext, fonc, 0.0)
	225	+ return {"taux_extrait_28": t28, "d_extraite": d_ext, "A_ventilee": A, "B_extraction": B,
	226	+ "ecart": B["valeur"] - A["valeur"], "valeur_retenue": B["valeur"], "valeur_arrondie": round(B["valeur"] / 5000.0) * 5000.0}
	227	+
	228	+
	229	+# ------------------------------------------------------------------------------------------ sensibilité
	230	+
	231	+def grille_age_vie(cn: dict, curable: float, vies=(50, 60, 70, 80, 100), ages_eff=(20, 25, 29, 33, 37)) -> pd.DataFrame:
	232	+ """Taux de dépréciation (âge-vie modifiée, curable fixé) pour chaque couple (vie économique, âge effectif)."""
	233	+ rows = {}
	234	+ for L in vies:
	235	+ rows[L] = {a: ct.depreciation_age_vie_modifiee(cn["total"], curable, a, L)["total"] / cn["total"] for a in ages_eff}
	236	+ return pd.DataFrame(rows).T
	237	+
	238	+
	239	+def sensibilite_extraction(v: pd.DataFrame, modele: dict, cn_total: float) -> pd.DataFrame:
	240	+ """Taux extrait à 28 ans et valeur du terrain (Hull) selon les choix de l'extraction."""
	241	+ rows = []
	242	+ for nom, kw in [("cas de base", {}), ("ventes récentes ≤ 5 ans", {"age_max": 5}), ("ventes récentes ≤ 15 ans", {"age_max": 15}),
	243	+ ("élasticité −0,05", {"elasticite": -0.05}), ("élasticité −0,15", {"elasticite": -0.15}),
	244	+ ("qualité ±0 %", {"fq": 0.0}), ("qualité ±10 %", {"fq": 0.10})]:
	245	+ w, vl = extraction(v, modele, cn_total, **kw)
	246	+ q = ajuster_profil(w)["quadratique"]
	247	+ rows.append({"variante": nom, "vl_hull": float(vl.loc["Hull", "vl_mediane"]), "taux_28": float(taux_quadratique(q, AGE_CHRONO)),
	248	+ "taux_annuel": ajuster_profil(w)["taux_annuel_origine"]})
	249	+ return pd.DataFrame(rows)
	250	+
	251	+
	252	+def tornade(cn: dict, vl: float, d_ext: float, fonc: float, variantes: dict, sens_ext: pd.DataFrame) -> list[dict]:
	253	+ base = ct.valeur_par_cout(vl, cn["total"], d_ext, fonc)["valeur"]
	254	+ out = []
	255	+ def add(param, bas, haut, etiquette):
	256	+ out.append({"param": param, "bas": bas, "haut": haut, "base": base, "etiquette": etiquette})
	257	+ add("Valeur du terrain ±15 %", ct.valeur_par_cout(vl * 0.85, cn["total"], d_ext, fonc)["valeur"], ct.valeur_par_cout(vl * 1.15, cn["total"], d_ext, fonc)["valeur"], f"{vl*0.85:,.0f} → {vl*1.15:,.0f} $".replace(",", " "))
	258	+ t = sens_ext["taux_28"]
	259	+ add("Choix d'extraction (taux à 28 ans)", ct.valeur_par_cout(vl, cn["total"], t.max() * cn["total"], fonc)["valeur"], ct.valeur_par_cout(vl, cn["total"], t.min() * cn["total"], fonc)["valeur"], f"{t.max()*100:.1f} % → {t.min()*100:.1f} %")
	260	+ add("Coût neuf ±8,6 % (date des prix)", ct.valeur_par_cout(vl, cn["total"] / 1.086, d_ext / 1.086, fonc)["valeur"], ct.valeur_par_cout(vl, cn["total"] * 1.086, d_ext * 1.086, fonc)["valeur"], "indice ×0,921 → ×1,086")
	261	+ add("Désuétude fonctionnelle 0 → 2×", ct.valeur_par_cout(vl, cn["total"], d_ext, 2 * fonc)["valeur"], ct.valeur_par_cout(vl, cn["total"], d_ext, 0.0)["valeur"], f"{2*fonc:,.0f} → 0 $".replace(",", " "))
	262	+ add("Lecture ventilée (ch. 11) au lieu de l'extraction", ct.valeur_par_cout(vl, cn["total"], variantes["ventilee"]["total"], fonc)["valeur"], base, f"{variantes['ventilee']['total']/cn['total']*100:.1f} % → {d_ext/cn['total']*100:.1f} %")
	263	+ return out
	264	+
	265	+
	266	+# ------------------------------------------------------------------------------------------ main
	267	+
	268	+def main() -> dict:
	269	+ d = charger()
	270	+ cn, fiche, trav, v, m, sujet, devis = d["cn"], d["fiche"], d["travaux"], d["ventes"], d["modele"], d["sujet"], d["devis"]
	271	+ f2 = lambda x: f"{x:,.2f}".replace(",", " "); f0 = lambda x: f"{x:,.0f}".replace(",", " ")
	272	+ print("== DONNÉES SYNTHÉTIQUES — sujet cas 1 :", sujet["type"], sujet["annee_construction"], sujet["superficie_habitable_m2"], "m² hab.,", sujet["secteur"], "; évaluation", DATE_EVAL)
	273	+ print(f"== Coût neuf C_N (ch. 21) = {f2(cn['total'])} $")
	274	+ ag = ages_sujet(fiche)
	275	+ print(f"== Âges : chronologique {ag['chronologique']} ans ; effectif de la structure {ag['effectif_structure']:.1f} ans (convention ch. 11, λ = {c11.LAMBDA}) ; "
	276	+ f"vie économique {ag['vie_economique']:.0f} ans ; vie restante {ag['vie_restante']:.1f} ans ; indice d'état {ag['indice_etat']:.3f} ; "
	277	+ f"âge effectif pondéré par les coûts {ag['age_effectif_pondere']:.1f} ans")
	278	+ var = variantes_physique(cn, fiche, trav)
	279	+ print("== Dépréciation physique — quatre lectures :")
	280	+ print(f" âge-vie simple, âge chronologique 28/60 : {f2(var['age_vie_chrono'])} $ ({var['age_vie_chrono']/cn['total']*100:.2f} %)")
	281	+ print(f" âge-vie simple, âge effectif {var['age_effectif']:.0f}/60 : {f2(var['age_vie_effectif'])} $ ({var['age_vie_effectif']/cn['total']*100:.2f} %)")
	282	+ mo = var["modifiee"]
	283	+ print(f" âge-vie modifiée : curable {f2(mo['curable'])} + incurable {f2(mo['incurable'])} = {f2(mo['total'])} $ ({mo['total']/cn['total']*100:.2f} %)")
	284	+ ve = var["ventilee"]
	285	+ print(f" ventilée (ch. 11) : curable {f2(ve['curable'])} + courte durée {f2(sum(ve['courte_duree'].values()))} + longue durée {f2(ve['longue_duree'])} "
	286	+ f"(base {f2(ve['base_longue'])} × {ve['age_effectif_structure']:.0f}/60) = {f2(ve['total'])} $ ({ve['taux']*100:.2f} %)")
	287	+ courtes = fiche[(~fiche["longue_duree"]) & (fiche["composante"] != "Entrée asphaltée")]
	288	+ print(f" composantes de courte durée : {len(courtes)} ; coût neuf {f2(courtes['cout_neuf'].sum())} $ ; dépréciation {f2(sum(ve['courte_duree'].values()))} $ "
	289	+ f"({sum(ve['courte_duree'].values())/courtes['cout_neuf'].sum()*100:.1f} % de leur coût neuf)")
	290	+ fin = [(k, x, fiche.loc[fiche['composante'] == k, 'cout_neuf'].iloc[0]) for k, x in ve["courte_duree"].items()]
	291	+ for k, x, c in sorted(fin, key=lambda t: -t[1]):
	292	+ print(f" {k:58s} coût neuf {f2(c):>11s} $ dépréciation {f2(x):>11s} $ ({x/c*100:5.1f} %)")
	293	+ se = carence_salle_eau(devis, cn)
	294	+ print("== Désuétude fonctionnelle curable du sujet (carence : salle d'eau au rez-de-chaussée, constat fictif) :")
	295	+ print(f" coût si incluse à neuf : direct {f2(se['cout_si_neuf_direct'])} $ → majoré {f2(se['cout_si_neuf'])} $ ; ajout a posteriori {f2(se['cout_ajout'])} $ ; désuétude = {f2(se['desuetude'])} $")
	296	+ ex = exemples_incurables()
	297	+ print("== Exemples incurables (hypothèses pédagogiques) :")
	298	+ print(f" triplex cas 2 : perte {TRIPLEX_PERTE_LOYER_MOIS:.0f} $/mois × MRB mensuel {ex['mrb_mensuel']:.2f} (= 12 × {ex['mrb_annuel']:.2f}) = {f2(ex['perte_loyer_capitalisee'])} $")
	299	+ print(f" perte de RNE {f0(RNE_PERTE_ANNUELLE)} $/an / {TAUX_CAP_ILLUSTRATIF*100:.2f} % = {f2(ex['perte_rne_capitalisee_totale'])} $ ; part bâtiment {PART_BATIMENT_ILLUSTRATIVE:.0%} → {f2(ex['perte_rne_batiment'])} $")
	300	+ print(f" paires : ({f0(PAIRES_SANS)} − {f0(PAIRES_AVEC)}) × {PAIRES_PART_BAT:.0%} = {f2(ex['paires'])} $")
	301	+ w, vl = extraction(v, m, cn["total"])
	302	+ print(f"== Extraction de marché sur {len(w)} ventes : tendance {m['croissance_mensuelle']*100:.3f} %/mois ; C_N par vente = C_N × (S/165)^(1{ELASTICITE_TAILLE:+.2f}) × (1 ± {FACTEUR_QUALITE:.0%}/classe)")
	303	+ print(f" Valeur du terrain par secteur (ventes ≤ {AGE_MAX_RECENT} ans) :")
	304	+ print(vl.round(3).to_string())
	305	+ vlr = valeur_terrain_retenue(vl)
	306	+ print(f" → Hull : médiane {f2(vlr['mediane'])} $ sur {vlr['n']} ventes (part médiane du prix {vlr['part']*100:.1f} %) ; VALEUR DE TERRAIN RETENUE V_L = {f0(vlr['retenue'])} $ ({vlr['retenue']/620:.0f} $/m² pour 620 m²)")
	307	+ tr = tranches(w)
	308	+ print(" Taux de dépréciation extrait par tranche d'âge :"); print(tr.round(3).to_string())
	309	+ aj = ajuster_profil(w)
	310	+ q = aj["quadratique"]; l = aj["lineaire"]
	311	+ print(f" linéaire : taux = {l['beta'][0]:.4f} + {l['beta'][1]:.5f}·âge (se {l['se_hc1'][1]:.5f}), R² {l['r2']:.3f}")
	312	+ print(f" quadratique : taux = {q['beta'][0]:.4f} + {q['beta'][1]:.5f}·âge {q['beta'][2]:+.7f}·âge² (se {q['se_hc1'][0]:.4f}, {q['se_hc1'][1]:.5f}, {q['se_hc1'][2]:.7f}), R² {q['r2']:.3f}")
	313	+ print(f" par l'origine : {aj['taux_annuel_origine']*100:.3f} % de C_N par année → vie économique linéaire implicite {aj['vie_implicite']:.0f} ans")
	314	+ for a in (10, 28, 40, 60):
	315	+ print(f" taux quadratique à {a:2d} ans : {float(taux_quadratique(q, a))*100:.2f} %")
	316	+ pr = profils(m, sujet, vlr["retenue"], q)
	317	+ print(f"== Profils : prix hédonique du sujet neuf {f0(pr['prix_neuf'])} $ ; part du terrain α = {pr['alpha']:.3f}")
	318	+ print(" âge | âge-vie | extraction | hédonique total → bâtiment | générateur total → bâtiment")
	319	+ for a in (10, 20, 28, 40, 60, 80):
	320	+ i = int(a)
	321	+ print(f" {a:3d} | {pr['age_vie'][i]*100:6.1f} | {pr['extraction'][i]*100:7.1f} | {pr['hedonique_total'][i]*100:6.1f} → {pr['hedonique_bat'][i]*100:6.1f} | {pr['generateur_total'][i]*100:6.1f} → {pr['generateur_bat'][i]*100:6.1f}")
	322	+ vs = valeur_sujet(cn, vlr["retenue"], q, se["desuetude"], var)
	323	+ print("== Valeur par le coût du sujet (traite.cout.valeur_par_cout) :")
	324	+ A, B = vs["A_ventilee"], vs["B_extraction"]
	325	+ print(f" (A) ventilée : V_L {f0(vlr['retenue'])} + C_N {f2(cn['total'])} − D_phys {f2(ve['total'])} − D_fonc {f2(se['desuetude'])} = {f2(A['valeur'])} $ (dépréciation totale {A['taux_depreciation']*100:.2f} %)")
	326	+ print(f" (B) extraction : D_extraite(28) = {vs['taux_extrait_28']*100:.2f} % × C_N = {f2(vs['d_extraite'])} $ ; V = {f0(vlr['retenue'])} + {f2(cn['total'])} − {f2(vs['d_extraite'])} − {f2(se['desuetude'])} = {f2(B['valeur'])} $ "
	327	+ f"(dépréciation totale {f2(B['depreciation_totale'])} $ = {B['taux_depreciation']*100:.2f} % ; contribution du bâtiment {f2(B['contribution_batiment'])} $)")
	328	+ print(f" écart B − A = {f2(vs['ecart'])} $ ; VALEUR RETENUE PAR LE COÛT {f2(vs['valeur_retenue'])} $, arrondie {f0(vs['valeur_arrondie'])} $")
	329	+ gr = grille_age_vie(cn, var["curable"])
	330	+ print("== Sensibilité âge-vie modifiée (taux en %) : vie économique (lignes) × âge effectif (colonnes)"); print((gr * 100).round(1).to_string())
	331	+ sx = sensibilite_extraction(v, m, cn["total"])
	332	+ print("== Sensibilité de l'extraction :"); print(sx.assign(taux_28=sx.taux_28 * 100, taux_annuel=sx.taux_annuel * 100).round(2).to_string())
	333	+ to = tornade(cn, vlr["retenue"], vs["d_extraite"], se["desuetude"], var, sx)
	334	+ print("== Tornade (valeur par le coût) :")
	335	+ for o in to:
	336	+ print(f" {o['param']:48s} {o['etiquette']:28s} bas {f0(o['bas'])} haut {f0(o['haut'])} (base {f0(o['base'])}) ; étendue {(o['haut']-o['bas'])/o['base']*100:.1f} %")
	337	+ return {"cn": cn, "fiche": fiche, "travaux": trav, "ventes": v, "modele": m, "sujet": sujet, "devis": devis, "ages": ag, "variantes": var,
	338	+ "salle_eau": se, "exemples": ex, "extraction": w, "vl": vl, "vl_retenue": vlr, "tranches": tr, "ajustements": aj, "profils": pr,
	339	+ "valeur": vs, "grille": gr, "sens_extraction": sx, "tornade": to}
	340	+
	341	+
	342	+if __name__ == "__main__":
	343	+ main()

added analysis/python/cases/ch25_terrain.py +364 −0

		@@ -0,0 +1,364 @@
	1	+#!/usr/bin/env python3
	2	+"""Chapitre 25 — Évaluation du terrain (DONNÉES SYNTHÉTIQUES, graine 20261031).
	3	+
	4	+Imprime tous les chiffres cités dans le chapitre 25 :
	5	+ * jeu synthétique de ventes de terrains vacants « Gatineau » (data/synthetic/ch25_terrains_ventes.csv) : lois déclarées ;
	6	+ * modèle hédonique des terrains (traite.hedonique.mco) : élasticité de superficie, façade, services, topographie, forme, densité ;
	7	+ * comparaison directe : sélection de cinq terrains comparables pour le sujet du cas 1 et grille d'ajustements ;
	8	+ * allocation : part du terrain dans les ventes du cas 1 (secteur Hull) ; prix implicite marginal du modèle hédonique (traite.cas1) ;
	9	+ * extraction : prix − coût déprécié du bâtiment sur les cinq comparables du chapitre 16 (coût neuf du chapitre 21) ;
	10	+ * technique résiduelle du terrain sur le cas 3 (RNE de traite.cas3 ; taux déclarés) et sensibilité ;
	11	+ * lotissement (développement actualisé) d'un site de 10 000 m² en 12 terrains (traite.finance.van) ;
	12	+ * capitalisation d'une rente foncière (emphytéose) ;
	13	+ * synthèse des indications et valeur de terrain retenue pour le sujet du cas 1 (reprise par les ch. 20, 24, 45).
	14	+
	15	+Usage (racine du dépôt) : PYTHONPATH=analysis/python python3 analysis/python/cases/ch25_terrain.py
	16	+Toutes les fonctions financières proviennent de analysis/python/traite (aucune réécriture)."""
	17	+from __future__ import annotations
	18	+import sys, json, pathlib
	19	+import numpy as np, pandas as pd
	20	+
	21	+ROOT = pathlib.Path(__file__).resolve().parents[3]
	22	+sys.path.insert(0, str(ROOT / "analysis/python")); sys.path.insert(0, str(ROOT / "analysis/python/cases"))
	23	+from traite import hedonique as hd, comparables as cp, finance as fin, cout as ct, cas1, cas3
	24	+
	25	+D = ROOT / "data/synthetic"
	26	+CSV_TERRAINS = D / "ch25_terrains_ventes.csv"
	27	+GRAINE = 20261031
	28	+REF_DATE = pd.Timestamp("2024-07-01")
	29	+DATE_EVAL = pd.Timestamp("2026-09-01")
	30	+
	31	+# ----------------------------------------------------------------------------- 1. jeu synthétique de ventes de terrains
	32	+# Lois déclarées (hypothèses pédagogiques ; voir data/synthetic/README.md, section « Chapitre 25 »)
	33	+P_REF = 225_000.0 # prix du terrain de référence : 560 m², façade 18 m, desservi, plat, régulier, 1 logement, Hull, 2024-07-01
	34	+ELAST_T = 0.50 # élasticité du prix du terrain à la superficie (< 1 : valeur unitaire décroissante)
	35	+ELAST_F = 0.08 # élasticité à la façade (à superficie donnée)
	36	+B_NON_DESSERVI = -0.30 # ni aqueduc ni égout (puits + installation septique à la charge de l'acheteur)
	37	+B_PENTE = -0.06 # pente marquée
	38	+B_ROC = -0.12 # roc affleurant ou remblai important
	39	+B_IRREG = -0.05 # forme irrégulière (triangle, drapeau, trapèze prononcé)
	40	+B_LOGEMENT = 0.12 # par logement constructible supplémentaire (zonage H2/H3)
	41	+TENDANCE_MOIS = 0.0036 # même tendance que le coefficient « mois » du modèle hédonique du cas 1 (≈ 4,4 %/an)
	42	+SIGMA = 0.10
	43	+MEDIANES_APCIQ = {"Hull": 475_000, "Gatineau": 464_900, "Aylmer": 530_000, "Buckingham": 395_000, "Masson-Angers": 395_000 * 0.98}
	44	+PRIME_SECTEUR = {k: float(np.log(v / MEDIANES_APCIQ["Hull"])) for k, v in MEDIANES_APCIQ.items()}
	45	+CENTROIDES = {"Hull": (45.4296, -75.7450), "Gatineau": (45.4769, -75.6650), "Aylmer": (45.3936, -75.8450),
	46	+ "Buckingham": (45.5899, -75.4200), "Masson-Angers": (45.5468, -75.4150)}
	47	+N_PAR_SECTEUR = {"Hull": 70, "Gatineau": 60, "Aylmer": 40, "Buckingham": 15, "Masson-Angers": 15}
	48	+
	49	+def generer_terrains(graine: int = GRAINE) -> pd.DataFrame:
	50	+ """Ventes synthétiques de terrains vacants résidentiels (2023-01 → 2026-08). Aucun terrain réel."""
	51	+ rng = np.random.default_rng(graine)
	52	+ rows = []
	53	+ k = 0
	54	+ for sct, n in N_PAR_SECTEUR.items():
	55	+ periurbain = sct in ("Buckingham", "Masson-Angers")
	56	+ for _ in range(n):
	57	+ k += 1
	58	+ desservi = int(rng.random() < (0.30 if periurbain else 0.85))
	59	+ if desservi:
	60	+ T = float(np.clip(np.exp(rng.normal(np.log(600), 0.28)), 320, 2500))
	61	+ else:
	62	+ T = float(np.clip(np.exp(rng.normal(np.log(2200), 0.45)), 900, 9000))
	63	+ F = float(np.clip(0.60 * np.sqrt(T) * np.exp(rng.normal(0, 0.14)), 10, 90))
	64	+ topo = rng.choice(["plat", "pente", "roc"], p=[0.70, 0.20, 0.10])
	65	+ forme = rng.choice(["régulier", "irrégulier"], p=[0.80, 0.20])
	66	+ logements = int(rng.choice([1, 2, 3], p=[0.82, 0.12, 0.06])) if desservi and not periurbain else 1
	67	+ jours = int(rng.integers(0, (pd.Timestamp("2026-08-31") - pd.Timestamp("2023-01-01")).days + 1))
	68	+ date = pd.Timestamp("2023-01-01") + pd.Timedelta(days=jours)
	69	+ mois = (date - REF_DATE).days / 30.4375
	70	+ lat0, lon0 = CENTROIDES[sct]
	71	+ lat = lat0 + rng.normal(0, 0.012); lon = lon0 + rng.normal(0, 0.017)
	72	+ lnp = (np.log(P_REF) + ELAST_T * np.log(T / 560) + ELAST_F * np.log(F / 18) + B_NON_DESSERVI * (1 - desservi)
	73	+ + B_PENTE * (topo == "pente") + B_ROC * (topo == "roc") + B_IRREG * (forme == "irrégulier")
	74	+ + B_LOGEMENT * (logements - 1) + PRIME_SECTEUR[sct] + TENDANCE_MOIS * mois + rng.normal(0, SIGMA))
	75	+ prix = float(np.round(np.exp(lnp) / 500) * 500)
	76	+ rows.append({"id_vente": f"T{k:03d}", "date_vente": date.strftime("%Y-%m-%d"), "secteur": sct, "superficie_m2": round(T, 1),
	77	+ "facade_m": round(F, 2), "desservi": desservi, "topographie": topo, "forme": forme, "logements_constructibles": logements,
	78	+ "lat": round(lat, 5), "lon": round(lon, 5), "prix_vente": prix})
	79	+ df = pd.DataFrame(rows)
	80	+ df["prix_m2"] = df["prix_vente"] / df["superficie_m2"]
	81	+ return df
	82	+
	83	+def charger_terrains(regenerer: bool = False) -> pd.DataFrame:
	84	+ if regenerer or not CSV_TERRAINS.exists():
	85	+ df = generer_terrains(); df.to_csv(CSV_TERRAINS, index=False)
	86	+ df = pd.read_csv(CSV_TERRAINS, parse_dates=["date_vente"])
	87	+ return df
	88	+
	89	+# ----------------------------------------------------------------------------- 2. modèle hédonique des terrains
	90	+SECTEURS = ["Hull", "Gatineau", "Aylmer", "Buckingham", "Masson-Angers"]
	91	+
	92	+def matrice_terrains(df: pd.DataFrame) -> pd.DataFrame:
	93	+ X = pd.DataFrame(index=df.index)
	94	+ X["const"] = 1.0
	95	+ X["ln_T"] = np.log(df["superficie_m2"] / 560.0)
	96	+ X["ln_F"] = np.log(df["facade_m"] / 18.0)
	97	+ X["non_desservi"] = 1.0 - df["desservi"].astype(float)
	98	+ X["pente"] = (df["topographie"] == "pente").astype(float)
	99	+ X["roc"] = (df["topographie"] == "roc").astype(float)
	100	+ X["irregulier"] = (df["forme"] == "irrégulier").astype(float)
	101	+ X["logements_sup"] = df["logements_constructibles"].astype(float) - 1.0
	102	+ for s in SECTEURS[1:]:
	103	+ X[f"sect_{s}"] = (df["secteur"] == s).astype(float)
	104	+ X["mois"] = ((pd.to_datetime(df["date_vente"]) - REF_DATE).dt.days / 30.4375).astype(float)
	105	+ return X
	106	+
	107	+def hedonique_terrains(df: pd.DataFrame) -> dict:
	108	+ X = matrice_terrains(df); y = np.log(df["prix_vente"].astype(float))
	109	+ r = hd.mco(X.values, y.values)
	110	+ coef = pd.DataFrame({"coef": r["beta"], "se_hc1": r["se_hc1"]}, index=X.columns)
	111	+ coef["t"] = coef["coef"] / coef["se_hc1"]; coef["effet_pct"] = np.exp(coef["coef"]) - 1
	112	+ return {"coef": coef, "beta": pd.Series(r["beta"], index=X.columns), "r2": r["r2"], "sigma": float(np.sqrt(r["sigma2"])), "n": r["n"],
	113	+ "residus": r["residus"], "X": X, "duan": float(np.mean(np.exp(r["residus"])))}
	114	+
	115	+def sujet_terrain() -> dict:
	116	+ """Le terrain du sujet du cas 1, réputé vacant : 620 m², Hull, desservi, plat, régulier, zonage unifamilial ; façade posée à 20 m (hypothèse)."""
	117	+ s = cas1.charger()["sujet"]
	118	+ return {"id_vente": "SUJET", "secteur": s["secteur"], "superficie_m2": float(s["superficie_terrain_m2"]), "facade_m": 20.0, "desservi": 1,
	119	+ "topographie": "plat", "forme": "régulier", "logements_constructibles": 1, "lat": s["lat"], "lon": s["lon"], "date_vente": DATE_EVAL}
	120	+
	121	+def predire_terrain(modele: dict, terrain: dict | pd.DataFrame, duan: bool = True) -> float:
	122	+ df = pd.DataFrame([terrain]) if isinstance(terrain, dict) else terrain
	123	+ X = matrice_terrains(df)[modele["X"].columns]
	124	+ return float(np.exp(X.values @ modele["beta"].values)[0] * (modele["duan"] if duan else 1.0))
	125	+
	126	+# ----------------------------------------------------------------------------- 3. comparaison directe
	127	+ECHELLES = {"superficie_m2": 100.0, "facade_m": 4.0, "dist_km": 1.5, "mois_anc": 6.0}
	128	+POIDS = {"superficie_m2": 2.0, "facade_m": 0.5, "dist_km": 1.5, "mois_anc": 1.0}
	129	+
	130	+def selection_terrains(df: pd.DataFrame, suj: dict, k: int = 5, mois_max: float = 24, dist_max: float = 4.0) -> dict:
	131	+ v = df.copy()
	132	+ v["mois_anc"] = (DATE_EVAL - v["date_vente"]).dt.days / 30.4375
	133	+ v["dist_km"] = np.sqrt(((v["lat"] - suj["lat"]) * 111) ** 2 + ((v["lon"] - suj["lon"]) * 78) ** 2)
	134	+ etapes = {"total": len(v)}
	135	+ f = v[v["mois_anc"].between(0, mois_max)]; etapes["fenetre"] = len(f)
	136	+ f = f[f["dist_km"] <= dist_max]; etapes["rayon"] = len(f)
	137	+ f = f[(f["desservi"] == 1) & (f["logements_constructibles"] == 1)]; etapes["desservi_unifamilial"] = len(f)
	138	+ f = f[f["superficie_m2"].between(0.6 * suj["superficie_m2"], 1.4 * suj["superficie_m2"])]; etapes["superficie"] = len(f)
	139	+ s0 = dict(suj); s0["mois_anc"] = 0.0; s0["dist_km"] = 0.0
	140	+ f = f.assign(distance=[cp.distance_attributs(s0, r, ECHELLES, POIDS) for r in f.to_dict("records")]).sort_values("distance")
	141	+ return {"etapes": etapes, "candidats": f, "comparables": f.head(k), "ventes": v}
	142	+
	143	+GROUPES = {"conditions_marche": ["mois"], "localisation": [f"sect_{s}" for s in SECTEURS[1:]], "superficie": ["ln_T"], "facade": ["ln_F"],
	144	+ "services": ["non_desservi"], "topographie": ["pente", "roc"], "forme": ["irregulier"], "densite": ["logements_sup"]}
	145	+
	146	+def grille_terrains(modele: dict, comps: pd.DataFrame, suj: dict) -> pd.DataFrame:
	147	+ """Ajustements en cascade dérivés du modèle hédonique des terrains (même logique que traite.cas1.ajustements_hedoniques) :
	148	+ A_k = base × [exp(β_k (x_s − x_c)) − 1], conditions du marché d'abord, puis localisation, puis caractéristiques physiques."""
	149	+ Xs = matrice_terrains(pd.DataFrame([suj])).iloc[0]; Xc = matrice_terrains(comps); beta = modele["beta"]
	150	+ rows = []
	151	+ for i, c in comps.iterrows():
	152	+ base = float(c["prix_vente"]); row = {"id_vente": c["id_vente"], "prix_vente": base}
	153	+ for g, cols in GROUPES.items():
	154	+ dlog = float(sum(beta[col] * (Xs[col] - Xc.loc[i, col]) for col in cols))
	155	+ adj = base * (np.exp(dlog) - 1.0); row[g] = adj; base += adj
	156	+ row["prix_ajuste"] = base
	157	+ row["ajust_brut_pct"] = sum(abs(row[g]) for g in GROUPES) / row["prix_vente"]
	158	+ row["ajust_net_pct"] = (base - row["prix_vente"]) / row["prix_vente"]
	159	+ rows.append(row)
	160	+ return pd.DataFrame(rows)
	161	+
	162	+def reconcilier(grille: pd.DataFrame) -> dict:
	163	+ objs = [cp.ComparableAjuste(r["id_vente"], r["prix_vente"], {g: r[g] for g in GROUPES}) for _, r in grille.iterrows()]
	164	+ w = cp.poids_inverse_brut(objs)
	165	+ return {**cp.reconciliation(objs, w), "objets": objs}
	166	+
	167	+def comparaison(df: pd.DataFrame | None = None) -> dict:
	168	+ df = charger_terrains() if df is None else df
	169	+ m = hedonique_terrains(df); suj = sujet_terrain(); sel = selection_terrains(df, suj)
	170	+ g = grille_terrains(m, sel["comparables"], suj); rec = reconcilier(g)
	171	+ pred = predire_terrain(m, suj)
	172	+ return {"terrains": df, "modele": m, "sujet": suj, "selection": sel, "grille": g, "reconciliation": rec, "prediction_hedonique": pred,
	173	+ "valeur_m2": rec["valeur_ponderee"] / suj["superficie_m2"]}
	174	+
	175	+# ----------------------------------------------------------------------------- 4. allocation et prix implicite marginal (cas 1)
	176	+C_N_SUJET = 397_567.33 # coût neuf du sujet du cas 1 (ch. 21, analysis/python/cases/ch21_cout_neuf.py)
	177	+ELAST_COUT_TOTAL = 0.90 # élasticité du coût total à la superficie (ch. 21 : ε = −0,10 sur le coût unitaire)
	178	+QUALITE_COUT = 0.10 # ±10 % de coût neuf par classe de qualité (hypothèse pédagogique)
	179	+VIE_ECONOMIQUE = 60.0 # variante « âge-vie » de l'extraction (convention déclarée ; le ch. 24 discute la vie économique)
	180	+
	181	+def cout_neuf_comparable(S: float, qualite: float) -> float:
	182	+ """Coût neuf d'un comparable transposé depuis le sujet : C_N(S, q) = C_N,sujet × (S/165)^0,90 × (1 + 0,10 (q − 3))."""
	183	+ return C_N_SUJET * (S / 165.0) ** ELAST_COUT_TOTAL * (1 + QUALITE_COUT * (qualite - 3))
	184	+
	185	+def facteur_age(modele_cas1: dict, age) -> np.ndarray:
	186	+ """Rapport prix à l'âge a / prix neuf selon le profil d'âge du modèle hédonique du cas 1 : exp(β_age a + β_age2 a²/100)."""
	187	+ b = modele_cas1["coef"]["coef"]
	188	+ a = np.asarray(age, float)
	189	+ return np.exp(b["age"] * a + b["age2_100"] * a ** 2 / 100.0)
	190	+
	191	+def extraction_cas1(cas: dict | None = None) -> dict:
	192	+ """Extraction sur les cinq comparables du chapitre 16 : V_L = P − C_N(1 − δ), sous deux conventions de dépréciation :
	193	+ (a) âge-vie linéaire (vie 60 ans) ; (b) dépréciation implicite du marché (profil d'âge hédonique) : V_L = P_neuf − C_N."""
	194	+ cas = cas or cas1.tout()
	195	+ comps = cas["selection"]["comparables"].copy(); m = cas["modele"]
	196	+ comps["C_N"] = cout_neuf_comparable(comps["superficie_habitable_m2"], comps["qualite_1a5"])
	197	+ comps["delta_agevie"] = comps["age"] / VIE_ECONOMIQUE
	198	+ comps["V_L_agevie"] = comps["prix_vente"] - comps["C_N"] * (1 - comps["delta_agevie"])
	199	+ f = facteur_age(m, comps["age"]); comps["P_neuf"] = comps["prix_vente"] / f
	200	+ comps["delta_marche"] = (comps["P_neuf"] - comps["prix_vente"]) / comps["C_N"]
	201	+ comps["V_L_marche"] = comps["P_neuf"] - comps["C_N"]
	202	+ for k in ("agevie", "marche"):
	203	+ comps[f"V_L_{k}_m2"] = comps[f"V_L_{k}"] / comps["superficie_terrain_m2"]
	204	+ # transposition au terrain du sujet (620 m²) avec l'élasticité de superficie du marché des terrains
	205	+ comps[f"V_L_{k}_sujet"] = comps[f"V_L_{k}"] * (620.0 / comps["superficie_terrain_m2"]) ** ELAST_T
	206	+ # Hull, toutes ventes : part du terrain par extraction (dépréciation de marché)
	207	+ v = cas["ventes"]; h = v[v["secteur"] == "Hull"].copy()
	208	+ h["C_N"] = cout_neuf_comparable(h["superficie_habitable_m2"], h["qualite_1a5"])
	209	+ h["V_L"] = h["prix_vente"] / facteur_age(m, h["age"]) - h["C_N"]; h["part"] = h["V_L"] / h["prix_vente"]; h["V_L_m2"] = h["V_L"] / h["superficie_terrain_m2"]
	210	+ return {"comparables": comps, "hull": h, "part_hull_mediane": float(h["part"].median()), "part_hull_q1": float(h["part"].quantile(0.25)),
	211	+ "part_hull_q3": float(h["part"].quantile(0.75)), "V_L_hull_mediane": float(h["V_L"].median()),
	212	+ "indication_agevie": float(comps["V_L_agevie_sujet"].median()), "indication_marche": float(comps["V_L_marche_sujet"].median())}
	213	+
	214	+def allocation_cas1(cas: dict | None = None, extr: dict | None = None) -> dict:
	215	+ cas = cas or cas1.tout(); extr = extr or extraction_cas1(cas)
	216	+ a = extr["part_hull_mediane"]
	217	+ P_grille = float(cas["ajustements"]["prix_ajuste"].mean()) # moyenne des prix ajustés des 5 comparables (ch. 17)
	218	+ P_hed = float(cas["prediction_hedonique"]) # prédiction hédonique du sujet (ch. 18)
	219	+ b = cas["modele"]["coef"]["coef"]; T = 620.0
	220	+ return {"ratio": a, "sur_grille": a * P_grille, "sur_hedonique": a * P_hed, "P_grille": P_grille, "P_hed": P_hed,
	221	+ "beta_ln_T": float(b["ln_T"]), "prix_marginal_m2": float(b["ln_T"] * P_hed / T), "contribution_marginale": float(b["ln_T"] * P_hed),
	222	+ "sujet_age_factor": float(facteur_age(cas["modele"], 28)), "delta_marche_sujet": float((P_hed / facteur_age(cas["modele"], 28) - P_hed) / C_N_SUJET)}
	223	+
	224	+# ----------------------------------------------------------------------------- 5. technique résiduelle du terrain (cas 3)
	225	+RES = {"cout_unitaire_neuf": 2500.0, "superficie_brute_m2": 950.0, "taux_depreciation": 0.52, "R_L": 0.0375, "n_restante": 40, "terrain_m2": 740.0}
	226	+
	227	+def residuelle_cas3(params: dict | None = None, t3: dict | None = None) -> dict:
	228	+ p = {**RES, **(params or {})}; t3 = t3 or cas3.tout()
	229	+ noi = float(t3["base"]["rne"]); R = float(t3["taux"]["mediane"]); V_cap = float(t3["valeur_capitalisation"])
	230	+ C_N = p["cout_unitaire_neuf"] * p["superficie_brute_m2"]; C_B = C_N * (1 - p["taux_depreciation"])
	231	+ R_B = p["R_L"] + 1.0 / p["n_restante"]
	232	+ V_L = (noi - R_B * C_B) / p["R_L"]
	233	+ R_L_implicite = (noi - R_B * C_B) / (V_cap - C_B) if V_cap > C_B else float("nan")
	234	+ return {"noi": noi, "R": R, "V_cap": V_cap, "C_N": C_N, "C_B": C_B, "R_L": p["R_L"], "R_B": R_B, "revenu_batiment": R_B * C_B,
	235	+ "revenu_terrain": noi - R_B * C_B, "V_L": V_L, "V_L_m2": V_L / p["terrain_m2"], "somme": V_L + C_B, "ecart_vs_cap": (V_L + C_B) / V_cap - 1,
	236	+ "R_L_implicite": R_L_implicite, "part_terrain": V_L / (V_L + C_B), "params": p}
	237	+
	238	+def sensibilite_residuelle(t3: dict | None = None, R_Ls=(0.0325, 0.035, 0.0375, 0.04, 0.0425), ns=(30, 40, 50), deltas=(0.44, 0.52, 0.60)) -> pd.DataFrame:
	239	+ t3 = t3 or cas3.tout(); rows = []
	240	+ for d in deltas:
	241	+ for n in ns:
	242	+ for rl in R_Ls:
	243	+ r = residuelle_cas3({"taux_depreciation": d, "n_restante": n, "R_L": rl}, t3)
	244	+ rows.append({"taux_depreciation": d, "C_B": r["C_B"], "n_restante": n, "R_L": rl, "R_B": r["R_B"], "V_L": r["V_L"], "V_L_m2": r["V_L_m2"]})
	245	+ return pd.DataFrame(rows)
	246	+
	247	+# ----------------------------------------------------------------------------- 6. lotissement (développement actualisé)
	248	+LOT = {"site_m2": 10_000.0, "n_lots": 12, "lot_m2": 625.0, "rue_m2": 1500.0, "parc_m2": 1000.0, "facade_m": 20.0,
	249	+ "infrastructure_par_lot": 65_000.0, "honoraires_permis": 90_000.0, "taxes_annuelles": 12_000.0, "frais_vente_pct": 0.04,
	250	+ "profit_pct": 0.15, "lots_par_an": 4, "taux": 0.10, "croissance_prix": 0.0}
	251	+
	252	+def lotissement(modele_terrains: dict, params: dict | None = None) -> dict:
	253	+ """Valeur d'un site brut par la méthode du lotissement actualisé (subdivision development method).
	254	+ Produit des ventes de lots finis au prix prédit par le modèle hédonique des terrains à la date d'évaluation, moins les coûts
	255	+ de viabilisation, d'honoraires, de portage, de vente et le profit du promoteur ; flux de fin d'année actualisés au taux déclaré."""
	256	+ p = {**LOT, **(params or {})}
	257	+ assert abs(p["n_lots"] * p["lot_m2"] + p["rue_m2"] + p["parc_m2"] - p["site_m2"]) < 1e-6
	258	+ lot = {"secteur": "Hull", "superficie_m2": p["lot_m2"], "facade_m": p["facade_m"], "desservi": 1, "topographie": "plat", "forme": "régulier",
	259	+ "logements_constructibles": 1, "date_vente": DATE_EVAL}
	260	+ prix_lot = predire_terrain(modele_terrains, lot)
	261	+ n_ans = int(np.ceil(p["n_lots"] / p["lots_par_an"]))
	262	+ flux, detail = [], []
	263	+ # t = 0 : honoraires, permis, études
	264	+ f0 = -p["honoraires_permis"]; flux.append(f0); detail.append({"annee": 0, "lots_vendus": 0, "revenus": 0.0, "infrastructure": 0.0, "honoraires": p["honoraires_permis"],
	265	+ "taxes": 0.0, "frais_vente": 0.0, "profit": 0.0, "flux": f0})
	266	+ restants = p["n_lots"]
	267	+ for t in range(1, n_ans + 1):
	268	+ vendus = min(p["lots_par_an"], restants); restants -= vendus
	269	+ rev = vendus * prix_lot * (1 + p["croissance_prix"]) ** (t - 1)
	270	+ infra = p["infrastructure_par_lot"] * p["n_lots"] if t == 1 else 0.0
	271	+ taxes = p["taxes_annuelles"] * (restants + vendus) / p["n_lots"]
	272	+ fv = p["frais_vente_pct"] * rev; prof = p["profit_pct"] * rev
	273	+ f = rev - infra - taxes - fv - prof
	274	+ flux.append(f); detail.append({"annee": t, "lots_vendus": vendus, "revenus": rev, "infrastructure": infra, "honoraires": 0.0, "taxes": taxes,
	275	+ "frais_vente": fv, "profit": prof, "flux": f})
	276	+ V = fin.van(flux, p["taux"])
	277	+ statique = sum(d["flux"] for d in detail)
	278	+ return {"prix_lot": prix_lot, "produit_brut": prix_lot * p["n_lots"], "flux": flux, "detail": pd.DataFrame(detail), "valeur_actualisee": V,
	279	+ "valeur_statique": statique, "valeur_m2": V / p["site_m2"], "valeur_statique_m2": statique / p["site_m2"], "n_ans": n_ans,
	280	+ "ratio_terrain_brut_sur_produit": V / (prix_lot * p["n_lots"]), "params": p}
	281	+
	282	+def sensibilite_lotissement(modele_terrains: dict) -> dict:
	283	+ base = lotissement(modele_terrains)["valeur_actualisee"]
	284	+ out = {"base": base}
	285	+ out["absorption"] = {k: lotissement(modele_terrains, {"lots_par_an": k})["valeur_actualisee"] for k in (2, 3, 4, 6, 12)}
	286	+ out["taux"] = {r: lotissement(modele_terrains, {"taux": r})["valeur_actualisee"] for r in (0.08, 0.10, 0.12, 0.15)}
	287	+ out["prix"] = {}
	288	+ for d in (-0.10, 0.0, 0.10):
	289	+ m2 = dict(modele_terrains); m2["duan"] = modele_terrains["duan"] * (1 + d)
	290	+ out["prix"][d] = lotissement(m2)["valeur_actualisee"]
	291	+ out["infrastructure"] = {c: lotissement(modele_terrains, {"infrastructure_par_lot": c})["valeur_actualisee"] for c in (50_000, 65_000, 80_000)}
	292	+ out["profit"] = {c: lotissement(modele_terrains, {"profit_pct": c})["valeur_actualisee"] for c in (0.10, 0.15, 0.20)}
	293	+ return out
	294	+
	295	+# ----------------------------------------------------------------------------- 7. capitalisation de la rente foncière
	296	+def rente_fonciere(rente: float = 11_000.0, R_L: float = 0.05, g: float = 0.02, n: int = 40, valeur_reversion: float = 300_000.0) -> dict:
	297	+ """Terrain loué (emphytéose ou bail foncier) : V_L = rente/R_L (rente constante perpétuelle) ; V_L = rente_1/(R_L − g) (Gordon) ;
	298	+ bail de n ans à rente croissante + réversion actualisée."""
	299	+ perp = rente / R_L
	300	+ gordon = rente / fin.taux_gordon(R_L, g)
	301	+ va_rentes = sum(rente * (1 + g) ** (t - 1) / (1 + R_L) ** t for t in range(1, n + 1))
	302	+ va_rev = valeur_reversion / (1 + R_L) ** n
	303	+ return {"perpetuelle": perp, "gordon": gordon, "bail_n": va_rentes + va_rev, "va_rentes": va_rentes, "va_reversion": va_rev, "n": n}
	304	+
	305	+# ----------------------------------------------------------------------------- 8. synthèse et valeur retenue
	306	+def synthese() -> dict:
	307	+ df = charger_terrains(); comp = comparaison(df); cas = cas1.tout(); extr = extraction_cas1(cas); allo = allocation_cas1(cas, extr)
	308	+ t3 = cas3.tout(); res = residuelle_cas3(t3=t3); lot = lotissement(comp["modele"]); rf = rente_fonciere()
	309	+ retenue = round(comp["reconciliation"]["valeur_ponderee"] / 5000) * 5000
	310	+ return {"comparaison": comp, "cas1": cas, "extraction": extr, "allocation": allo, "cas3": t3, "residuelle": res, "lotissement": lot,
	311	+ "rente": rf, "valeur_retenue": retenue, "part_retenue_grille": retenue / allo["P_grille"], "part_retenue_hed": retenue / allo["P_hed"]}
	312	+
	313	+def _d(x): return f"{x:,.0f} $".replace(",", " ")
	314	+
	315	+def main() -> dict:
	316	+ S = synthese(); c = S["comparaison"]; m = c["modele"]; df = c["terrains"]
	317	+ print("=== 1. Jeu synthétique de terrains (ch25_terrains_ventes.csv, graine 20261031) ===")
	318	+ print(f"n = {len(df)} ; desservis = {int(df.desservi.sum())} ; période {df.date_vente.min().date()} → {df.date_vente.max().date()}")
	319	+ print(df.groupby("secteur").agg(n=("prix_vente", "size"), T_med=("superficie_m2", "median"), prix_med=("prix_vente", "median"), prix_m2_med=("prix_m2", "median")).round(0))
	320	+ print(df.groupby("desservi")[["superficie_m2", "prix_vente", "prix_m2"]].median().round(0))
	321	+ print("\n=== 2. Modèle hédonique des terrains ===")
	322	+ print(m["coef"].round(4)); print(f"R² = {m['r2']:.3f} ; σ = {m['sigma']:.3f} ; Duan = {m['duan']:.4f}")
	323	+ print("\n=== 3. Comparaison directe — sujet 620 m², Hull ===")
	324	+ print("Entonnoir :", c["selection"]["etapes"])
	325	+ comps = c["selection"]["comparables"]
	326	+ print(comps[["id_vente", "date_vente", "secteur", "superficie_m2", "facade_m", "topographie", "forme", "dist_km", "mois_anc", "prix_vente", "prix_m2", "distance"]].round(2).to_string())
	327	+ print(c["grille"].round(0).to_string())
	328	+ r = c["reconciliation"]
	329	+ print(f"Poids (inverse du brut) : {np.round(r['poids'], 3)} ; valeur pondérée {_d(r['valeur_ponderee'])} ; moyenne {_d(r['moyenne'])} ; médiane {_d(r['mediane'])} ; "
	330	+ f"min {_d(r['min'])} ; max {_d(r['max'])} ; étendue {r['etendue_pct']*100:.1f} % ; {_d(c['valeur_m2'])}/m²")
	331	+ print(f"Prédiction hédonique directe du terrain du sujet : {_d(c['prediction_hedonique'])}")
	332	+ print("\n=== 4. Allocation et prix implicite marginal (cas 1) ===")
	333	+ a = S["allocation"]; e = S["extraction"]
	334	+ print(f"Part du terrain, ventes de Hull (extraction, dépréciation de marché) : médiane {a['ratio']*100:.1f} % (Q1 {e['part_hull_q1']*100:.1f} %, Q3 {e['part_hull_q3']*100:.1f} %) ; V_L médian Hull {_d(e['V_L_hull_mediane'])}")
	335	+ print(f"Allocation sur la grille du ch. 17 ({_d(a['P_grille'])}) : {_d(a['sur_grille'])} ; sur la prédiction hédonique ({_d(a['P_hed'])}) : {_d(a['sur_hedonique'])}")
	336	+ print(f"β(ln T) = {a['beta_ln_T']:.4f} → prix implicite marginal {a['prix_marginal_m2']:.1f} $/m² ; contribution marginale β × P = {_d(a['contribution_marginale'])}")
	337	+ print(f"Facteur d'âge du sujet (28 ans) : {a['sujet_age_factor']:.4f} → dépréciation implicite {a['delta_marche_sujet']*100:.1f} % de C_N")
	338	+ print("\n=== 5. Extraction sur les 5 comparables du ch. 16 ===")
	339	+ cols = ["id_vente", "prix_vente", "superficie_habitable_m2", "superficie_terrain_m2", "age", "qualite_1a5", "C_N", "delta_agevie", "V_L_agevie", "V_L_agevie_m2",
	340	+ "P_neuf", "delta_marche", "V_L_marche", "V_L_marche_m2", "V_L_agevie_sujet", "V_L_marche_sujet"]
	341	+ print(e["comparables"][cols].round(3).to_string())
	342	+ print(f"Indication (médiane transposée à 620 m²) : âge-vie 60 ans {_d(e['indication_agevie'])} ; dépréciation de marché {_d(e['indication_marche'])}")
	343	+ print("\n=== 6. Technique résiduelle du terrain (cas 3) ===")
	344	+ rs = S["residuelle"]
	345	+ print({k: (round(v, 4) if isinstance(v, float) else v) for k, v in rs.items() if k != "params"})
	346	+ sens = sensibilite_residuelle(S["cas3"]); print(sens.pivot_table(index=["taux_depreciation", "n_restante"], columns="R_L", values="V_L").round(0))
	347	+ print("\n=== 7. Lotissement actualisé ===")
	348	+ L = S["lotissement"]; print(f"Prix d'un lot fini (625 m², Hull, {DATE_EVAL.date()}) : {_d(L['prix_lot'])} ; produit brut {_d(L['produit_brut'])}")
	349	+ print(L["detail"].round(0).to_string())
	350	+ print(f"Valeur actualisée du site brut : {_d(L['valeur_actualisee'])} ({L['valeur_m2']:.1f} $/m²) ; statique {_d(L['valeur_statique'])} ({L['valeur_statique_m2']:.1f} $/m²) ; "
	351	+ f"ratio terrain brut / produit {L['ratio_terrain_brut_sur_produit']*100:.1f} %")
	352	+ sl = sensibilite_lotissement(m)
	353	+ for k, v in sl.items():
	354	+ if k != "base": print(k, {kk: round(vv) for kk, vv in v.items()})
	355	+ print("\n=== 8. Rente foncière ===")
	356	+ print({k: round(v, 0) if isinstance(v, float) else v for k, v in S["rente"].items()})
	357	+ print("\n=== 9. Synthèse — sujet du cas 1 ===")
	358	+ print(f"Comparaison (terrains) {_d(r['valeur_ponderee'])} ; extraction (marché) {_d(e['indication_marche'])} ; extraction (âge-vie 60) {_d(e['indication_agevie'])} ; "
	359	+ f"allocation (grille) {_d(a['sur_grille'])} ; allocation (hédonique) {_d(a['sur_hedonique'])}")
	360	+ print(f"VALEUR DU TERRAIN RETENUE : {_d(S['valeur_retenue'])} ({S['valeur_retenue']/620:.0f} $/m²) ; part de la grille {S['part_retenue_grille']*100:.1f} % ; part de la prédiction hédonique {S['part_retenue_hed']*100:.1f} %")
	361	+ return S
	362	+
	363	+if __name__ == "__main__":
	364	+ main()

added analysis/python/cases/ch26_etat_locatif.py +318 −0

		@@ -0,0 +1,318 @@
	1	+#!/usr/bin/env python3
	2	+"""Chapitre 26 — Baux et loyers : calculs de l'exemple intégral (cas 3, 12 logements à Montréal ; cas 2, triplex à Québec ;
	3	+DONNÉES SYNTHÉTIQUES) et des exercices.
	4	+
	5	+Tous les chiffres cités dans manuscript/chapters/ch26.tex et solutions/ch26.tex sortent d'ici. Les revenus du cas 3 et du
	6	+cas 2 viennent des modules partagés traite.cas3 / traite.cas2 (fonctions `charger`, `revenus`, `rne`, `taux_extraits`,
	7	+`indicateurs_marche`) afin de coïncider avec les chapitres 2, 27-31 et 46-47 ; les facteurs d'actualisation viennent de
	8	+traite.finance. La formule fermée de la valeur actuelle de l'écart contractuel/marché sous rotation géométrique est celle
	9	+du chapitre 2 (éq. « rotation-va ») ; elle est appliquée ici logement par logement.
	10	+
	11	+Hypothèses de travail propres au chapitre (déclarées comme telles dans le texte, pas des statistiques) :
	12	+ - profil mensuel de consommation d'électricité d'un 4½ chauffé à l'électricité, 12 000 kWh/an (PROFIL_KWH) ;
	13	+ - loyer « chauffé-éclairé » d'un comparable fictif : 1 450 $/mois (COMPARABLE_CHAUFFE) ;
	14	+ - structure du tarif D d'Hydro-Québec en vigueur le 1er avril 2026 (source : hydrotarifs2026, section 2.5).
	15	+
	16	+Usage (racine du dépôt) : PYTHONPATH=analysis/python python3 analysis/python/cases/ch26_etat_locatif.py
	17	+"""
	18	+from __future__ import annotations
	19	+import sys, pathlib, datetime as dt
	20	+import numpy as np, pandas as pd
	21	+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
	22	+from traite import cas3, cas2, finance as fin
	23	+
	24	+ROOT = pathlib.Path(__file__).resolve().parents[3]
	25	+DATE_EVAL = dt.date(2026, 9, 1)
	26	+
	27	+# ----------------------------------------------------------------------------- tarif D (Hydro-Québec, 1er avril 2026)
	28	+TARIF_D = {"redevance_par_jour": 0.46154, "prix_tranche1": 0.07065, "seuil_kwh_par_jour": 40.0, "prix_tranche2": 0.11142}
	29	+# Hypothèse de travail (pas une statistique) : consommation mensuelle d'un 4½ de 70 m² chauffé à l'électricité, 12 000 kWh/an.
	30	+MOIS = ["janv.", "févr.", "mars", "avr.", "mai", "juin", "juil.", "août", "sept.", "oct.", "nov.", "déc."]
	31	+JOURS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
	32	+PROFIL_KWH = [1900, 1700, 1400, 1000, 700, 550, 500, 500, 600, 850, 1150, 1150]
	33	+COMPARABLE_CHAUFFE = 1450.0 # $/mois, loyer « chauffé-éclairé » d'un comparable fictif (hypothèse pédagogique)
	34	+GESTION = 0.04 # convention du cas 3 : gestion imputée à 4 % du RBE
	35	+
	36	+
	37	+# ----------------------------------------------------------------------------- état locatif et indicateurs
	38	+def tableau_etat(etat: pd.DataFrame, date_eval: dt.date = DATE_EVAL) -> pd.DataFrame:
	39	+ """État locatif enrichi : ancienneté (années), écarts mensuel/annuel, ratio contrat/marché, mois avant l'échéance."""
	40	+ t = etat.copy()
	41	+ t["anciennete"] = date_eval.year - t["locataire_depuis"].astype(int)
	42	+ t["ecart_mensuel"] = t["loyer_mensuel_marche"] - t["loyer_mensuel_contrat"]
	43	+ t["ecart_annuel"] = 12 * t["ecart_mensuel"]
	44	+ t["ecart_pct"] = t["ecart_mensuel"] / t["loyer_mensuel_marche"]
	45	+ t["ratio"] = t["loyer_mensuel_contrat"] / t["loyer_mensuel_marche"]
	46	+ ech = pd.to_datetime(t["echeance_bail"]).dt.date
	47	+ t["mois_echeance"] = [round((e - date_eval).days / 30.4375, 1) for e in ech]
	48	+ t["loyer_m2_contrat"] = t["loyer_mensuel_contrat"] / t["superficie_m2"]
	49	+ t["loyer_m2_marche"] = t["loyer_mensuel_marche"] / t["superficie_m2"]
	50	+ return t
	51	+
	52	+
	53	+def indicateurs(etat: pd.DataFrame, hyp: dict, seuils=(0.05, 0.10, 0.20)) -> dict:
	54	+ """Indicateurs synthétiques de l'état locatif (éq. 26.1 à 26.4 du chapitre)."""
	55	+ t = tableau_etat(etat)
	56	+ r = cas3.revenus(etat, hyp) # RBP contrat / marché / écart (module partagé)
	57	+ lc, lm = t["loyer_mensuel_contrat"].astype(float), t["loyer_mensuel_marche"].astype(float)
	58	+ out = {**r, "n": len(t),
	59	+ "ecart_pondere": float((lm - lc).sum() / lm.sum()), # δ̄ = Σ(Lm − Lc) / Σ Lm
	60	+ "ratio_pondere": float(lc.sum() / lm.sum()),
	61	+ "ratio_moyen_simple": float(t["ratio"].mean()),
	62	+ "ecart_mensuel_moyen": float((lm - lc).mean()),
	63	+ "ecart_mensuel_median": float((lm - lc).median()),
	64	+ "anciennete_moyenne": float(t["anciennete"].mean()), "anciennete_mediane": float(t["anciennete"].median()),
	65	+ "anciennete_max": int(t["anciennete"].max()),
	66	+ "loyer_moyen_contrat": float(lc.mean()), "loyer_moyen_marche": float(lm.mean()),
	67	+ "loyer_m2_contrat_moyen": float(lc.sum() / t["superficie_m2"].sum()), "loyer_m2_marche_moyen": float(lm.sum() / t["superficie_m2"].sum()),
	68	+ "part_ecart_top3": float((lm - lc).sort_values(ascending=False).head(3).sum() / (lm - lc).sum()),
	69	+ "nb_stationnements": int(t["stationnement"].sum()), "tableau": t}
	70	+ for s in seuils:
	71	+ out[f"part_sous_marche_{int(s*100)}"] = float((t["ratio"] < 1 - s).mean())
	72	+ out[f"nb_sous_marche_{int(s*100)}"] = int((t["ratio"] < 1 - s).sum())
	73	+ return out
	74	+
	75	+
	76	+# ----------------------------------------------------------------------------- rotation, survie et valeur de l'écart
	77	+def survie(rho: float, t: int | np.ndarray) -> float | np.ndarray:
	78	+ """Probabilité qu'un locataire en place le soit encore après t années (départs géométriques, taux ρ)."""
	79	+ return (1 - rho) ** t
	80	+
	81	+
	82	+def esperance_duree(rho: float) -> float:
	83	+ """Durée espérée de l'occupation restante, E[n] = Σ t ρ(1−ρ)^(t−1) = 1/ρ (années ; départ compté en fin d'année)."""
	84	+ if not 0 < rho <= 1:
	85	+ raise ValueError("ρ doit être dans ]0, 1]")
	86	+ return 1.0 / rho
	87	+
	88	+
	89	+def va_ecart(delta1: float, r: float, g: float, rho: float) -> float:
	90	+ """VA espérée de l'écart contractuel/marché d'un logement : Δ₁ reçu avec certitude l'année 1, puis l'écart croît à g et
	91	+ survit avec probabilité (1−ρ) chaque année → Δ₁ / (r − g + ρ(1+g)) (formule fermée du chapitre 2, éq. rotation-va).
	92	+ Condition de convergence : (1−ρ)(1+g) < 1+r."""
	93	+ if (1 - rho) * (1 + g) >= 1 + r:
	94	+ raise ValueError("série divergente : (1−ρ)(1+g) ≥ 1+r")
	95	+ return delta1 / (r - g + rho * (1 + g))
	96	+
	97	+
	98	+def va_ecart_serie(delta1: float, r: float, g: float, rho: float, T: int = 400) -> float:
	99	+ """Même valeur par sommation explicite (vérification numérique de la formule fermée)."""
	100	+ t = np.arange(1, T + 1)
	101	+ return float(np.sum(delta1 * ((1 - rho) * (1 + g)) ** (t - 1) / (1 + r) ** t))
	102	+
	103	+
	104	+def va_annuite(delta: float, r: float, n: float) -> float:
	105	+ """Annuité d'un écart constant pendant n années (éq. « annuite » du chapitre 2) ; n peut être non entier."""
	106	+ return delta * (1 - (1 + r) ** (-n)) / r
	107	+
	108	+
	109	+def va_ecart_logements(etat: pd.DataFrame, hyp: dict, rhos=(0.085, 0.094, 0.15), r: float | None = None, g: float | None = None) -> pd.DataFrame:
	110	+ """VA de l'écart par logement, nette de l'inoccupation (convention du chapitre 2 : Δ₁ = 12 × écart mensuel × (1 − v))."""
	111	+ t = tableau_etat(etat); r = hyp["taux_actualisation"] if r is None else r; g = hyp["croissance_loyers_marche"] if g is None else g
	112	+ v = hyp["taux_inoccupation_pertes"]
	113	+ out = t[["logement", "pieces", "anciennete", "ecart_mensuel", "ecart_annuel"]].copy()
	114	+ out["delta1_net"] = out["ecart_annuel"] * (1 - v)
	115	+ for rho in rhos:
	116	+ out[f"va_rho_{rho:.3f}"] = [va_ecart(d, r, g, rho) for d in out["delta1_net"]]
	117	+ out["va_perpetuel"] = out["delta1_net"] / (r - g)
	118	+ return out
	119	+
	120	+
	121	+def sensibilite_va(etat: pd.DataFrame, hyp: dict, rhos=(0.05, 0.085, 0.094, 0.15, 0.25), rs=(0.0625, 0.0725, 0.0825), gs=(0.025, 0.035, 0.045)) -> dict:
	122	+ """VA agrégée de l'écart (12 logements) selon ρ × r (g du cas) et ρ × g (r du cas)."""
	123	+ t = tableau_etat(etat); v = hyp["taux_inoccupation_pertes"]; d1 = float(t["ecart_annuel"].sum() * (1 - v))
	124	+ g0, r0 = hyp["croissance_loyers_marche"], hyp["taux_actualisation"]
	125	+ tab_r = pd.DataFrame({f"r={r:.4f}": [va_ecart(d1, r, g0, rho) for rho in rhos] for r in rs}, index=[f"rho={rho:.3f}" for rho in rhos])
	126	+ tab_g = pd.DataFrame({f"g={g:.3f}": [va_ecart(d1, r0, g, rho) for rho in rhos] for g in gs}, index=[f"rho={rho:.3f}" for rho in rhos])
	127	+ return {"delta1_net": d1, "par_taux": tab_r, "par_croissance": tab_g, "sans_rotation": d1 / (r0 - g0)}
	128	+
	129	+
	130	+# ----------------------------------------------------------------------------- loyer économique
	131	+def loyer_economique(base: dict, R: float, V: float, n_logements: int, m: float = GESTION) -> dict:
	132	+ """Loyer économique (loyer de faisabilité) : RBP requis pour que le RNE après réserve rémunère la valeur V au taux R,
	133	+ compte tenu des dépenses hors gestion DE_hg, de la réserve RR, des autres revenus A, de l'inoccupation v et d'une
	134	+ gestion à m × RBE : RNE* = R·V ; RBE* = (RNE* + DE_hg + RR)/(1 − m) ; RBP* = (RBE* − A)/(1 − v)."""
	135	+ det = base["detail"]; v = base["taux_vacance_pertes"]; A = base["autres_revenus"]
	136	+ gestion = float(det.loc[det["poste"].str.startswith("Gestion"), "normalise"].sum())
	137	+ de_hg = base["depenses_hors_reserve"] - gestion; RR = base["reserve"]
	138	+ rne_req = R * V; rbe_req = (rne_req + de_hg + RR) / (1 - m); rbp_req = (rbe_req - A) / (1 - v)
	139	+ return {"R": R, "V": V, "rne_requis": rne_req, "rbe_requis": rbe_req, "rbp_requis": rbp_req, "de_hors_gestion": de_hg, "reserve": RR,
	140	+ "loyer_economique_mensuel": rbp_req / (12 * n_logements), "loyer_contrat_mensuel": base["rbp_contrat"] / (12 * n_logements),
	141	+ "loyer_marche_mensuel": base["rbp_marche"] / (12 * n_logements)}
	142	+
	143	+
	144	+# ----------------------------------------------------------------------------- normalisation : électricité (tarif D)
	145	+def cout_electricite_mensuel(kwh: float, jours: int, tarif: dict = TARIF_D) -> dict:
	146	+ """Coût mensuel hors taxes de vente selon la structure du tarif D : redevance × jours + 1re tranche (≤ 40 kWh/jour) + 2e tranche."""
	147	+ seuil = tarif["seuil_kwh_par_jour"] * jours
	148	+ t1 = min(kwh, seuil); t2 = max(kwh - seuil, 0.0)
	149	+ red = tarif["redevance_par_jour"] * jours
	150	+ return {"kwh": kwh, "jours": jours, "redevance": red, "tranche1_kwh": t1, "tranche2_kwh": t2,
	151	+ "cout_tranche1": t1 * tarif["prix_tranche1"], "cout_tranche2": t2 * tarif["prix_tranche2"],
	152	+ "total": red + t1 * tarif["prix_tranche1"] + t2 * tarif["prix_tranche2"]}
	153	+
	154	+
	155	+def normalisation_electricite(profil=PROFIL_KWH, jours=JOURS, loyer_chauffe: float = COMPARABLE_CHAUFFE, tarif: dict = TARIF_D) -> dict:
	156	+ rows = [{"mois": m, **cout_electricite_mensuel(k, j, tarif)} for m, k, j in zip(MOIS, profil, jours)]
	157	+ tab = pd.DataFrame(rows)
	158	+ annuel = float(tab["total"].sum()); mensuel = annuel / 12
	159	+ return {"tableau": tab, "kwh_annuel": float(sum(profil)), "cout_annuel": annuel, "cout_mensuel_moyen": mensuel,
	160	+ "cout_moyen_kwh": annuel / sum(profil), "part_redevance": float(tab["redevance"].sum() / annuel),
	161	+ "kwh_tranche2": float(tab["tranche2_kwh"].sum()), "mois_depassement": int((tab["tranche2_kwh"] > 0).sum()),
	162	+ "loyer_chauffe": loyer_chauffe, "loyer_nu": loyer_chauffe - mensuel,
	163	+ "cout_mensuel_indexe_2027": mensuel * 1.03} # hausse domestique 3,0 % (Régie, D-2026-033) appliquée à toute la facture, approximation
	164	+
	165	+
	166	+# ----------------------------------------------------------------------------- calendrier des avis
	167	+def _moins_mois(d: dt.date, k: int) -> dt.date:
	168	+ """Date d, moins k mois (même quantième, borné à la fin du mois)."""
	169	+ y, m = d.year, d.month - k
	170	+ while m <= 0:
	171	+ m += 12; y -= 1
	172	+ while m > 12:
	173	+ m -= 12; y += 1
	174	+ import calendar
	175	+ return dt.date(y, m, min(d.day, calendar.monthrange(y, m)[1]))
	176	+
	177	+
	178	+def calendrier(echeance: dt.date = dt.date(2027, 6, 30), duree_mois: int = 12) -> dict:
	179	+ """Fenêtres légales (C.c.Q.) pour un bail à durée fixe se terminant à `echeance` :
	180	+ avis de modification 3 à 6 mois avant le terme (art. 1942 ; 1 à 2 mois si bail < 12 mois) ; réponse du locataire dans le
	181	+ mois (1945) ; demande de fixation dans le mois du refus (1947) ; avis de reprise/éviction 6 mois avant (1960 ; 1 mois si
	182	+ bail ≤ 6 mois) ; nouveau locataire : 10 jours (1950) après la conclusion du bail suivant."""
	183	+ if duree_mois >= 12:
	184	+ a_min, a_max = 3, 6
	185	+ else:
	186	+ a_min, a_max = 1, 2
	187	+ debut_fenetre, fin_fenetre = _moins_mois(echeance, a_max), _moins_mois(echeance, a_min)
	188	+ reprise = _moins_mois(echeance, 6 if duree_mois > 6 else 1)
	189	+ reponse_si_fin = _moins_mois(echeance, a_min - 1) # avis reçu au dernier jour permis → réponse dans le mois
	190	+ demande_tal = _moins_mois(echeance, a_min - 2) # refus au dernier jour → demande dans le mois
	191	+ debut_suivant = echeance + dt.timedelta(days=1)
	192	+ return {"echeance": echeance, "avis_modification_debut": debut_fenetre, "avis_modification_fin": fin_fenetre,
	193	+ "reponse_locataire_fin_si_avis_tardif": reponse_si_fin, "demande_fixation_fin_si_refus_tardif": demande_tal,
	194	+ "avis_reprise_eviction_fin": reprise, "debut_bail_suivant": debut_suivant,
	195	+ "nouveau_locataire_fixation_10j": debut_suivant + dt.timedelta(days=10), "nouveau_locataire_sans_avis_2mois": _moins_mois(debut_suivant, -2)}
	196	+
	197	+
	198	+# ----------------------------------------------------------------------------- loyer maximal des cinq ans (art. 1955)
	199	+def croissance_max_1955(loyer_initial: float, loyer_maximal: float, annees: int = 5) -> float:
	200	+ """Taux annuel composé maximal compatible avec le loyer maximal indiqué au bail (art. 1955 C.c.Q., 2024, c. 2)."""
	201	+ return (loyer_maximal / loyer_initial) ** (1 / annees) - 1
	202	+
	203	+
	204	+# ----------------------------------------------------------------------------- bail commercial : loyer net équivalent
	205	+def loyer_net_equivalent(loyer_brut_annuel: float, depenses_recuperables: float, superficie_m2: float) -> dict:
	206	+ net = loyer_brut_annuel - depenses_recuperables
	207	+ return {"loyer_brut": loyer_brut_annuel, "recuperables": depenses_recuperables, "loyer_net": net,
	208	+ "brut_m2": loyer_brut_annuel / superficie_m2, "net_m2": net / superficie_m2}
	209	+
	210	+
	211	+# ----------------------------------------------------------------------------- cas 2 (triplex)
	212	+def cas2_etat() -> dict:
	213	+ d = cas2.charger(); l = d["loyers"].copy(); r = cas2.revenus(l)
	214	+ l["anciennete"] = DATE_EVAL.year - l["locataire_depuis"].astype(int)
	215	+ l["ecart_mensuel"] = l["loyer_marche_estime"] - l["loyer_mensuel"]; l["ratio"] = l["loyer_mensuel"] / l["loyer_marche_estime"]
	216	+ return {**r, "tableau": l, "ecart_pondere": float(l["ecart_mensuel"].sum() / l["loyer_marche_estime"].sum()),
	217	+ "anciennete_moyenne": float(l["anciennete"].mean()), "nb_sous_marche_10": int((l["ratio"] < 0.9).sum()), "sujet": d["sujet"], "data": d}
	218	+
	219	+
	220	+# ----------------------------------------------------------------------------- tout
	221	+def calculer() -> dict:
	222	+ d = cas3.charger(); etat, dep, hyp, sujet = d["etat"], d["dep"], d["hyp"], d["sujet"]
	223	+ ind = indicateurs(etat, hyp); base = cas3.rne(etat, dep, hyp); tx = cas3.taux_extraits(d["comps"])
	224	+ R = tx["mediane"]; V_cap = fin.capitalisation_directe(base["rne"], R)
	225	+ econ_role = loyer_economique(base, R, hyp["valeur_role_2026"], sujet["nb_logements"])
	226	+ econ_cap = loyer_economique(base, R, V_cap, sujet["nb_logements"])
	227	+ va = va_ecart_logements(etat, hyp); sens = sensibilite_va(etat, hyp)
	228	+ r, g, rho = hyp["taux_actualisation"], hyp["croissance_loyers_marche"], hyp["rotation_annuelle"]
	229	+ va_agregee_cas = va_ecart(sens["delta1_net"], r, g, rho) # = 102 188 $ (chapitre 2, ρ = 15 %)
	230	+ norm = normalisation_electricite(); cal = calendrier()
	231	+ return {"etat": etat, "hyp": hyp, "sujet": sujet, "ind": ind, "base": base, "R": R, "V_cap": V_cap,
	232	+ "econ_role": econ_role, "econ_cap": econ_cap, "va": va, "sens": sens, "va_agregee_cas": va_agregee_cas,
	233	+ "esperance_duree": {rho_: esperance_duree(rho_) for rho_ in (0.085, 0.094, 0.15, 0.13)},
	234	+ "norm": norm, "cal": cal, "cas2": cas2_etat()}
	235	+
	236	+
	237	+# ----------------------------------------------------------------------------- exercices
	238	+def exercices(res: dict | None = None) -> dict:
	239	+ res = res or calculer(); hyp = res["hyp"]; ex = {}
	240	+ # 26.1 — délais : bail 12 mois échéant le 30 juin 2027 et bail de 6 mois échéant le 31 décembre 2026
	241	+ ex["1"] = {"bail12": calendrier(dt.date(2027, 6, 30), 12), "bail6": calendrier(dt.date(2026, 12, 31), 6)}
	242	+ # 26.2 — indicateurs d'un état locatif fictif de six logements (énoncé)
	243	+ e2 = pd.DataFrame({"logement": ["1", "2", "3", "4", "5", "6"], "loyer_mensuel_contrat": [850, 925, 1180, 1240, 1410, 1495],
	244	+ "loyer_mensuel_marche": [1100, 1100, 1300, 1300, 1550, 1550], "locataire_depuis": [2012, 2016, 2021, 2025, 2019, 2024],
	245	+ "superficie_m2": [52, 52, 70, 70, 92, 92], "echeance_bail": ["2027-06-30"] * 6, "chauffage_inclus": [0] * 6, "stationnement": [1, 0, 1, 0, 1, 0]})
	246	+ hyp2 = {**hyp, "autres_revenus_annuels": 0.0, "taux_inoccupation_pertes": 0.03}
	247	+ ex["2"] = indicateurs(e2, hyp2)
	248	+ # 26.3 — normalisation : comparable chauffé-éclairé 1 450 $, profil de consommation donné ; variante 1 500 $ et 14 000 kWh (profil × 14/12)
	249	+ ex["3"] = {"base": normalisation_electricite(), "variante": normalisation_electricite(profil=[k * 14000 / 12000 for k in PROFIL_KWH], loyer_chauffe=1500.0)}
	250	+ # 26.4 — VA de l'écart du logement 103 (319 $/mois) : ρ = 9,4 % vs 15 % ; annuité sur E[n] = 1/ρ années ; perpétuel
	251	+ d103 = 12 * 319 * (1 - hyp["taux_inoccupation_pertes"]); r, g = hyp["taux_actualisation"], hyp["croissance_loyers_marche"]
	252	+ ex["4"] = {"delta1_net": d103, "va_094": va_ecart(d103, r, g, 0.094), "va_150": va_ecart(d103, r, g, 0.15),
	253	+ "E_n_094": esperance_duree(0.094), "E_n_150": esperance_duree(0.15),
	254	+ "annuite_094": va_annuite(d103, r, esperance_duree(0.094)), "annuite_150": va_annuite(d103, r, esperance_duree(0.15)),
	255	+ "perpetuel": d103 / (r - g), "serie_094": va_ecart_serie(d103, r, g, 0.094)}
	256	+ # 26.5 — loyer économique du triplex (cas 2) sur la valeur au rôle 495 000 $ et sur la valeur par capitalisation
	257	+ c2 = res["cas2"]["data"]; base2 = cas2.rne(c2["loyers"], c2["depenses"]); comp2 = cas2.comparables_plex(c2["ventes"], c2["sujet"]); ind2 = cas2.indicateurs_marche(comp2)
	258	+ R2 = ind2["taux_median"]; V2_role = c2["sujet"]["valeur_role_2025"]; V2_cap = fin.capitalisation_directe(base2["rne"], R2)
	259	+ det2 = base2["detail"]; gestion2 = float(det2.loc[det2["type"] == "imputée", "normalise"].sum()); de_hg2 = base2["depenses_hors_reserve"] - gestion2
	260	+ def econ2(V):
	261	+ rne_req = R2 * V; rbe_req = (rne_req + de_hg2 + base2["reserve"]) / (1 - cas2.GESTION_IMPUTEE); rbp_req = rbe_req / (1 - cas2.TAUX_VACANCE_PERTES)
	262	+ return {"V": V, "rne_requis": rne_req, "rbe_requis": rbe_req, "rbp_requis": rbp_req, "loyer_mensuel_moyen": rbp_req / 36}
	263	+ ex["5"] = {"R": R2, "base": base2, "de_hors_gestion": de_hg2, "role": econ2(V2_role), "cap": econ2(V2_cap), "V_cap": V2_cap,
	264	+ "rbp_contrat": base2["rbp_contrat"], "rbp_marche": base2["rbp_marche"]}
	265	+ # 26.6 — immeuble neuf (art. 1955) : loyer 1 600 $, loyer maximal 1 850 $ indiqué au bail ; trois trajectoires sur cinq ans :
	266	+ # (a) indexation au taux de base 3,1 % (sans clause : fixation possible), (b) saut au loyer maximal dès la 2e année (borne haute permise
	267	+ # par la clause), (c) croissance régulière au taux g_max ; VA des loyers des années 1 à 5 au taux r du cas (7,25 %).
	268	+ L0, Lmax, gtal = 1600.0, 1850.0, 0.031
	269	+ gmax = croissance_max_1955(L0, Lmax)
	270	+ traj_tal = [L0 * (1 + gtal) ** t for t in range(0, 5)]
	271	+ traj_saut = [L0] + [Lmax] * 4
	272	+ traj_reg = [L0 * (1 + gmax) ** t for t in range(0, 5)]
	273	+ va = lambda traj: sum(12 * traj[t - 1] / (1 + r) ** t for t in range(1, 6))
	274	+ ex["6"] = {"g_max": gmax, "traj_tal": traj_tal, "traj_saut": traj_saut, "traj_reg": traj_reg, "va_tal": va(traj_tal), "va_saut": va(traj_saut), "va_reg": va(traj_reg),
	275	+ "loyer_an5_tal": traj_tal[4], "depasse_tal": traj_tal[4] > Lmax, "annee_depassement": next((t + 1 for t, L in enumerate(traj_tal) if L > Lmax), None),
	276	+ "loyer_an6_tal": L0 * (1 + gtal) ** 5}
	277	+ # 26.7 — bail commercial au rez-de-chaussée : brut 36 000 $/an, récupérables 9 500 $, 110 m², 5 ans fixes, option 5 ans ; VA à 7,25 %
	278	+ lne = loyer_net_equivalent(36000.0, 9500.0, 110.0)
	279	+ va_com = fin.van([0.0] + [lne["loyer_net"]] * 5, r)
	280	+ loyer_res = 1292.0 * 12 * (1 - hyp["taux_inoccupation_pertes"]) # logement de marché moyen du cas 3 (1 292 $) indexé à g
	281	+ va_res = sum(loyer_res * (1 + g) ** (t - 1) / (1 + r) ** t for t in range(1, 6))
	282	+ ex["7"] = {**lne, "va_net_5ans": va_com, "va_residentiel_5ans": va_res, "ratio_va": va_com / va_res, "loyer_res_an1_net": loyer_res}
	283	+ return ex
	284	+
	285	+
	286	+def _f(x): return f"{x:,.0f}".replace(",", " ")
	287	+
	288	+
	289	+if __name__ == "__main__":
	290	+ res = calculer(); ind = res["ind"]; t = ind["tableau"]
	291	+ print("=== Cas 3 — état locatif (données synthétiques)")
	292	+ print(t[["logement", "pieces", "superficie_m2", "loyer_mensuel_contrat", "loyer_mensuel_marche", "anciennete", "ecart_mensuel", "ecart_pct", "ratio", "echeance_bail", "mois_echeance"]].to_string(index=False))
	293	+ for k in ["rbp_contrat", "rbp_marche", "ecart_marche", "ecart_pondere", "ratio_pondere", "ratio_moyen_simple", "ecart_mensuel_moyen", "ecart_mensuel_median",
	294	+ "anciennete_moyenne", "anciennete_mediane", "anciennete_max", "part_sous_marche_5", "part_sous_marche_10", "part_sous_marche_20",
	295	+ "nb_sous_marche_5", "nb_sous_marche_10", "nb_sous_marche_20", "loyer_moyen_contrat", "loyer_moyen_marche", "loyer_m2_contrat_moyen", "loyer_m2_marche_moyen", "part_ecart_top3"]:
	296	+ print(f"{k:28s} {ind[k]:.4f}" if isinstance(ind[k], float) else f"{k:28s} {ind[k]}")
	297	+ print("\n=== Loyer économique (R médian = %.4f %%)" % (100 * res["R"]))
	298	+ for lab, e in (("sur valeur au rôle 2 200 000 $", res["econ_role"]), ("sur valeur par capitalisation", res["econ_cap"])):
	299	+ print(lab, {k: round(v, 2) for k, v in e.items()})
	300	+ print("\n=== VA de l'écart par logement (r = %.4f, g = %.3f ; nette de l'inoccupation)" % (res["hyp"]["taux_actualisation"], res["hyp"]["croissance_loyers_marche"]))
	301	+ print(res["va"].round(0).to_string(index=False)); print("totaux :", res["va"].drop(columns=["logement", "pieces"]).sum().round(0).to_dict())
	302	+ print("VA agrégée ρ = 15 % (chapitre 2) :", round(res["va_agregee_cas"], 0), "; sans rotation :", round(res["sens"]["sans_rotation"], 0))
	303	+ print("Durées espérées 1/ρ :", {k: round(v, 2) for k, v in res["esperance_duree"].items()})
	304	+ print("\n=== Sensibilité (VA agrégée)"); print(res["sens"]["par_taux"].round(0)); print(res["sens"]["par_croissance"].round(0))
	305	+ n = res["norm"]; print("\n=== Normalisation électricité (tarif D, hypothèse 12 000 kWh/an)")
	306	+ print(n["tableau"].round(2).to_string(index=False))
	307	+ print({k: round(v, 2) for k, v in n.items() if k != "tableau"})
	308	+ print("\n=== Calendrier (bail 2026-07-01 → 2027-06-30)"); print(res["cal"])
	309	+ c2 = res["cas2"]; print("\n=== Cas 2 — triplex"); print(c2["tableau"].to_string(index=False))
	310	+ print({k: (round(v, 4) if isinstance(v, float) else v) for k, v in c2.items() if k not in ("tableau", "sujet", "data")})
	311	+ print("\n=== Exercices"); ex = exercices(res)
	312	+ for k, v in ex.items():
	313	+ print(f"--- {k}")
	314	+ if isinstance(v, dict):
	315	+ for kk, vv in v.items():
	316	+ if isinstance(vv, (int, float)): print(f" {kk}: {vv:.4f}")
	317	+ elif isinstance(vv, dict): print(f" {kk}: {{" + ", ".join(f"{a}: {round(b, 4) if isinstance(b, float) else b}" for a, b in vv.items() if not isinstance(b, (pd.DataFrame, dict))) + "}")
	318	+ elif isinstance(vv, list): print(f" {kk}: {[round(x, 2) for x in vv]}")

added analysis/python/cases/ch27_revenus.py +356 −0

		@@ -0,0 +1,356 @@
	1	+#!/usr/bin/env python3
	2	+"""Chapitre 27 — Revenus potentiels, vacance et pertes : calculs du cas 3 (12 logements, Rosemont) et du cas 2 (triplex,
	3	+Limoilou) — DONNÉES SYNTHÉTIQUES — et lecture des tableaux publics de la SCHL (Enquête sur les logements locatifs,
	4	+octobre 2025, data/raw/schl_rml_2025/) — DONNÉES RÉELLES citées avec attribution.
	5	+
	6	+Tous les chiffres cités dans manuscript/chapters/ch27.tex et solutions/ch27.tex sortent d'ici. Les revenus des cas
	7	+viennent de traite.cas3.revenus / traite.cas2.revenus et la projection des loyers de traite.cas3.projection_dcf, pour
	8	+coïncider avec les chapitres 29, 30, 32, 46 et 47 ; les formules viennent de traite.finance (aucune n'est réécrite).
	9	+
	10	+Usage (racine du dépôt) : PYTHONPATH=analysis/python python3 analysis/python/cases/ch27_revenus.py
	11	+"""
	12	+from __future__ import annotations
	13	+import copy, math, pathlib, sys
	14	+import numpy as np, pandas as pd
	15	+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
	16	+from traite import cas2, cas3, finance as fin
	17	+
	18	+ROOT = pathlib.Path(__file__).resolve().parents[3]
	19	+RAW = ROOT / "data/raw/schl_rml_2025"
	20	+SIZES = ["3 à 5 unités", "6 à 19 unités", "20 à 49 unités", "50 à 99 unités", "100 unités et +", "Tous les immeubles"]
	21	+TYPES = ["Studio", "1 chambre", "2 chambres", "3 chambres +", "Tous"]
	22	+RMR_FICHIER = {"Montréal": "rmr-montreal-2025-fr.xlsx", "Québec": "rmr-quebec-2025-fr.xlsx", "Gatineau (partie QC)": "rmr-gatineau-2025-fr.xlsx",
	23	+ "Sherbrooke": "rmr-sherbrooke-2025-fr.xlsx", "Trois-Rivières": "rmr-trois-rivieres-2025-fr.xlsx", "Saguenay": "rmr-saguenay-2025-fr.xlsx"}
	24	+# Libellés de la RMR dans les fichiers (tableaux par centre du fichier Québec ; tableaux par zone des autres fichiers)
	25	+RMR_LIBELLE_QC = {"Montréal": "Montréal (RMR)", "Québec": "Québec (RMR)", "Gatineau (partie QC)": "Ottawa-Gatineau (RMR) (partie QC)",
	26	+ "Sherbrooke": "Sherbrooke (RMR)", "Trois-Rivières": "Trois-Rivières (RMR)", "Saguenay": "Saguenay (RMR)"}
	27	+
	28	+
	29	+# ----------------------------------------------------------------------------- lecture des tableaux SCHL (réels)
	30	+def _valeurs(tokens) -> list[float]:
	31	+ """Convertit une ligne SCHL en nombres : « 2,9 » → 2.9 ; « ** » (supprimé) → NaN ; lettres de qualité a-d et flèches ignorées."""
	32	+ out = []
	33	+ for t in tokens:
	34	+ s = str(t).strip()
	35	+ if s == "**":
	36	+ out.append(float("nan")); continue
	37	+ if s in {"a", "b", "c", "d", "↑", "↓", "-", "–", "O", "N"}:
	38	+ continue
	39	+ try:
	40	+ out.append(float(s.replace(",", ".").replace(" ", "").replace(" ", "")))
	41	+ except ValueError:
	42	+ continue
	43	+ return out
	44	+
	45	+
	46	+def _lignes(fichier: str, tableau: str) -> list[tuple[str, list[float]]]:
	47	+ import openpyxl
	48	+ wb = openpyxl.load_workbook(RAW / fichier, read_only=True, data_only=True)
	49	+ ws = wb[tableau]
	50	+ rows = []
	51	+ for r in ws.iter_rows(values_only=True):
	52	+ cells = [c for c in r if c is not None]
	53	+ if not cells:
	54	+ continue
	55	+ rows.append((str(cells[0]).strip(), _valeurs(cells[1:])))
	56	+ return rows
	57	+
	58	+
	59	+def _bloc(rows, debut: str, libelles: list[str]) -> dict[str, list[float]]:
	60	+ """Extrait, dans le bloc commençant par la ligne `debut`, les lignes dont le libellé figure dans `libelles`."""
	61	+ out, actif = {}, False
	62	+ for lab, vals in rows:
	63	+ if lab == debut:
	64	+ actif = True; continue
	65	+ if actif and lab in libelles and len(vals) >= 2:
	66	+ out[lab] = vals
	67	+ if actif and lab in libelles and lab == libelles[-1]:
	68	+ break
	69	+ return out
	70	+
	71	+
	72	+def schl_inoccupation_rmr() -> pd.DataFrame:
	73	+ """Taux d'inoccupation (%), tous les appartements, oct. 2024 et oct. 2025, par RMR (tableau 1.1.1 du fichier Québec, par centre)."""
	74	+ rows = _lignes("rmr-quebec-2025-fr.xlsx", "Tableau 1.1.1")
	75	+ rec = []
	76	+ for rmr, lab in RMR_LIBELLE_QC.items():
	77	+ v = [vals for l, vals in rows if l == lab][0]
	78	+ # 5 types × (2024, 2025) = 10 valeurs ; « Tous » = les deux dernières
	79	+ rec.append({"rmr": rmr, "inocc_2024": v[-2], "inocc_2025": v[-1], "inocc_2ch_2025": v[5]})
	80	+ return pd.DataFrame(rec).set_index("rmr")
	81	+
	82	+
	83	+def schl_rotation_rmr() -> pd.DataFrame:
	84	+ """Taux de rotation (%), tous les appartements, oct. 2024 et 2025, par RMR (tableau 1.1.6 du fichier Québec)."""
	85	+ rows = _lignes("rmr-quebec-2025-fr.xlsx", "Tableau 1.1.6")
	86	+ rec = []
	87	+ for rmr, lab in RMR_LIBELLE_QC.items():
	88	+ v = [vals for l, vals in rows if l == lab][0]
	89	+ rec.append({"rmr": rmr, "rotation_2024": v[-2], "rotation_2025": v[-1]})
	90	+ return pd.DataFrame(rec).set_index("rmr")
	91	+
	92	+
	93	+def schl_taille_montreal() -> pd.DataFrame:
	94	+ """Inoccupation (tous les appartements, %) et rotation (%) selon la taille de l'immeuble, oct. 2025 : RMR de Montréal et île de Montréal
	95	+ (tableaux 1.3.1 et 1.3.4 du fichier Montréal)."""
	96	+ inoc = _lignes("rmr-montreal-2025-fr.xlsx", "Tableau 1.3.1"); rot = _lignes("rmr-montreal-2025-fr.xlsx", "Tableau 1.3.4")
	97	+ rec = []
	98	+ for zone, debut in (("Île de Montréal", "Île de Montréal (zones 1-18)"), ("RMR de Montréal", "Montréal (RMR)")):
	99	+ bi = _bloc(inoc, debut, SIZES); br = _bloc(rot, debut, SIZES)
	100	+ for s in SIZES:
	101	+ vi = bi.get(s, []); vr = br.get(s, [])
	102	+ rec.append({"zone": zone, "taille": s, "inocc_2024": vi[-2] if len(vi) >= 2 else np.nan, "inocc_2025": vi[-1] if vi else np.nan,
	103	+ "rotation_2024": vr[-2] if len(vr) >= 2 else np.nan, "rotation_2025": vr[-1] if vr else np.nan})
	104	+ return pd.DataFrame(rec)
	105	+
	106	+
	107	+def schl_quartiles_montreal() -> pd.DataFrame:
	108	+ """Inoccupation (%) selon le quartile de loyer, tous les appartements, RMR de Montréal, oct. 2024 et 2025 (tableau 1.4)."""
	109	+ rows = _lignes("rmr-montreal-2025-fr.xlsx", "Tableau 1.4")
	110	+ b = _bloc(rows, "Montréal (RMR)", ["Q1", "Q2", "Q3", "Q4"])
	111	+ return pd.DataFrame([{"quartile": q, "inocc_2024": b[q][-2], "inocc_2025": b[q][-1]} for q in ["Q1", "Q2", "Q3", "Q4"]]).set_index("quartile")
	112	+
	113	+
	114	+def schl_inoccupes_occupes_ile() -> pd.DataFrame:
	115	+ """Loyer moyen ($) des logements inoccupés et occupés, île de Montréal, oct. 2025, par taille de logement (tableau 1.1.9)."""
	116	+ rows = _lignes("rmr-montreal-2025-fr.xlsx", "Tableau 1.1.9")
	117	+ v = [vals for l, vals in rows if l.startswith("Île-de-Montréal")][0]
	118	+ rec = [{"type": t, "inoccupes": v[2 * i], "occupes": v[2 * i + 1], "ecart_pct": (v[2 * i] / v[2 * i + 1] - 1) * 100} for i, t in enumerate(TYPES)]
	119	+ return pd.DataFrame(rec).set_index("type")
	120	+
	121	+
	122	+def schl_annee_construction_ile() -> pd.DataFrame:
	123	+ """Inoccupation (%) selon l'année de construction, tous les appartements, île de Montréal, oct. 2025 (tableau 1.2.1)."""
	124	+ rows = _lignes("rmr-montreal-2025-fr.xlsx", "Tableau 1.2.1")
	125	+ libs = ["Avant 1940", "1940 à 1959", "1960 à 1974", "1975 à 1989", "1990 à 2004", "2005 à 2014", "2015 ou après", "Tous les immeubles"]
	126	+ b = _bloc(rows, "Île de Montréal (zones 1-18)", libs)
	127	+ return pd.DataFrame([{"periode": k, "inocc_2025": b[k][-1]} for k in libs if k in b]).set_index("periode")
	128	+
	129	+
	130	+def ipc_loyer_quebec() -> dict:
	131	+ """IPC « Loyer », Québec, non désaisonnalisé (Statistique Canada 18-10-0004-01, 2002 = 100) : variation sept. 2026 / sept. 2025
	132	+ et croissance annuelle moyenne sur 10 ans (sept. 2016 → sept. 2026)."""
	133	+ p = ROOT / "data/raw/statcan_18100004/18100004.csv"
	134	+ import csv
	135	+ vals = {}
	136	+ with p.open(encoding="utf-8-sig") as f:
	137	+ for row in csv.reader(f, delimiter=";"):
	138	+ if len(row) > 10 and row[1] == "Québec" and row[3] == "Loyer" and row[0] >= "2015-01":
	139	+ try:
	140	+ vals[row[0]] = float(row[10])
	141	+ except ValueError:
	142	+ pass
	143	+ s = pd.Series(vals).sort_index()
	144	+ return {"serie": s, "sept2026": s["2026-09"], "sept2025": s["2025-09"], "var_12m": s["2026-09"] / s["2025-09"] - 1,
	145	+ "cagr_10ans": (s["2026-09"] / s["2016-09"]) ** (1 / 10) - 1, "cagr_5ans": (s["2026-09"] / s["2021-09"]) ** (1 / 5) - 1}
	146	+
	147	+
	148	+# ----------------------------------------------------------------------------- cas 3 et cas 2 (synthétiques)
	149	+def cascade_cas3() -> dict:
	150	+ d = cas3.charger(); etat, hyp = d["etat"], d["hyp"]
	151	+ r = cas3.revenus(etat, hyp)
	152	+ n = len(etat); sup = float(etat["superficie_m2"].sum())
	153	+ v = r["taux_vacance_pertes"]
	154	+ r.update({
	155	+ "n_logements": n, "superficie_m2": sup, "loyer_mensuel_contrat": float(etat["loyer_mensuel_contrat"].sum()),
	156	+ "loyer_mensuel_marche": float(etat["loyer_mensuel_marche"].sum()),
	157	+ "deficit_loyer": r["ecart_marche"], "deficit_pct": r["ecart_marche"] / r["rbp_marche"],
	158	+ "rbp_contrat_sur_marche": r["rbp_contrat"] / r["rbp_marche"],
	159	+ "loyers_effectifs": r["rbp_contrat"] * (1 - v),
	160	+ "taux_occupation_economique": r["rbp_contrat"] * (1 - v) / r["rbp_marche"], # loyers encaissés / loyers de marché
	161	+ "rbe_sur_rbp": r["rbe"] / r["rbp_contrat"], "autres_sur_rbp": r["autres_revenus"] / r["rbp_contrat"],
	162	+ "autres_par_logement_mois": r["autres_revenus"] / n / 12,
	163	+ "rbe_par_logement": r["rbe"] / n, "rbe_par_m2": r["rbe"] / sup, "rbp_par_m2": r["rbp_contrat"] / sup,
	164	+ "rbe_marche": fin.revenu_brut_effectif(r["rbp_marche"], v, r["autres_revenus"]),
	165	+ # variantes de convention (même v) : v appliqué au RBP + autres revenus ; autres revenus à 50 % vacants ; v sur RBP de marché
	166	+ "rbe_variante_v_sur_tout": (r["rbp_contrat"] + r["autres_revenus"]) * (1 - v),
	167	+ "rbe_variante_v_sur_marche": r["rbp_marche"] * (1 - v) + r["autres_revenus"],
	168	+ })
	169	+ r["ecart_variante_v_sur_tout"] = r["rbe_variante_v_sur_tout"] - r["rbe"]
	170	+ # décomposition de v (hypothèse pédagogique déclarée, cohérente avec le ch. 47) : frictionnel = rotation × durée ; reste = créances + structurel
	171	+ rot, duree = hyp["rotation_annuelle"], 1.0
	172	+ r["v_frictionnel_dossier"] = fin.taux_vacance_frictionnelle(rot, duree)
	173	+ r["v_residuel_dossier"] = v - r["v_frictionnel_dossier"]
	174	+ r["etat"] = etat; r["hyp"] = hyp; r["sujet"] = d["sujet"]
	175	+ return r
	176	+
	177	+
	178	+def par_type_cas3(etat: pd.DataFrame) -> pd.DataFrame:
	179	+ g = etat.groupby("pieces").agg(n=("logement", "count"), superficie=("superficie_m2", "sum"), contrat=("loyer_mensuel_contrat", "sum"),
	180	+ marche=("loyer_mensuel_marche", "sum"), anciennete=("locataire_depuis", lambda s: float((2026 - s).mean())))
	181	+ g["contrat_moyen"] = g["contrat"] / g["n"]; g["marche_moyen"] = g["marche"] / g["n"]
	182	+ g["ecart"] = g["marche"] - g["contrat"]; g["ecart_pct"] = g["ecart"] / g["marche"] * 100
	183	+ g["rbp_contrat"] = g["contrat"] * 12; g["rbp_marche"] = g["marche"] * 12
	184	+ tot = g.sum(numeric_only=True); tot["contrat_moyen"] = tot["contrat"] / tot["n"]; tot["marche_moyen"] = tot["marche"] / tot["n"]
	185	+ tot["ecart_pct"] = tot["ecart"] / tot["marche"] * 100; tot["anciennete"] = float((2026 - etat["locataire_depuis"]).mean())
	186	+ g.loc["Total"] = tot
	187	+ return g
	188	+
	189	+
	190	+def cascade_cas2() -> dict:
	191	+ c = cas2.charger(); loyers = c["loyers"]
	192	+ r = cas2.revenus(loyers)
	193	+ v = r["taux_vacance_pertes"]
	194	+ r.update({"n_logements": len(loyers), "superficie_m2": float(loyers["superficie_m2"].sum()), "vacance_pertes": r["rbp_contrat"] * v,
	195	+ "deficit_pct": r["ecart_marche"] / r["rbp_marche"], "taux_occupation_economique": r["rbp_contrat"] * (1 - v) / r["rbp_marche"],
	196	+ "rbe_par_logement": r["rbe"] / len(loyers), "autres_revenus": 0.0,
	197	+ # décomposition déclarée du 3 % du dossier : inoccupation SCHL Québec 2,4 % + créances ≈ 0,6 %
	198	+ "v_inoccupation_schl": 0.024, "v_creances": v - 0.024,
	199	+ # occupant : le logement du propriétaire (RC, hypothèse du ch. 46) n'a pas de risque d'inoccupation marchand → RBE si l'on
	200	+ # n'applique v qu'aux deux logements loués (variante pédagogique)
	201	+ "loyers": loyers})
	202	+ loue = loyers[loyers["logement"] != "RC"]
	203	+ r["rbe_variante_occupant"] = float(loyers.loc[loyers["logement"] == "RC", "loyer_mensuel"].sum() * 12) + fin.revenu_brut_effectif(float(loue["loyer_mensuel"].sum() * 12), v)
	204	+ return r
	205	+
	206	+
	207	+# ----------------------------------------------------------------------------- modèle d'inoccupation frictionnelle et grilles
	208	+def grille_frictionnelle(rotations=(0.05, 0.094, 0.13, 0.15, 0.20, 0.25), durees=(0.5, 1.0, 1.5, 2.0, 3.0)) -> pd.DataFrame:
	209	+ g = pd.DataFrame({d: [fin.taux_vacance_frictionnelle(r, d) * 100 for r in rotations] for d in durees}, index=[r * 100 for r in rotations])
	210	+ g.index.name = "rotation_pct"; g.columns.name = "duree_mois"
	211	+ return g
	212	+
	213	+
	214	+def sensibilite_v(base: dict, taux=(0.02, 0.029, 0.039, 0.05, 0.06, 0.08)) -> pd.DataFrame:
	215	+ """RBE, RNE normalisé et valeur par capitalisation (taux médian du cas 3) pour différents v ; dépenses recalculées par traite.cas3.rne
	216	+ (la gestion imputée à 4 % du RBE varie avec v)."""
	217	+ d = cas3.charger(); R = cas3.taux_extraits(d["comps"])["mediane"]
	218	+ rows = []
	219	+ for v in taux:
	220	+ h = copy.deepcopy(d["hyp"]); h["taux_inoccupation_pertes"] = v
	221	+ b = cas3.rne(d["etat"], d["dep"], h)
	222	+ rows.append({"v": v, "vacance_pertes": b["vacance_pertes"], "rbe": b["rbe"], "rne": b["rne"], "valeur": fin.capitalisation_directe(b["rne"], R)})
	223	+ s = pd.DataFrame(rows)
	224	+ h0 = copy.deepcopy(d["hyp"]); b0 = cas3.rne(d["etat"], d["dep"], h0) # référence = v du dossier, même si absent de la grille
	225	+ ref = {"rbe": b0["rbe"], "valeur": fin.capitalisation_directe(b0["rne"], R)}
	226	+ s["d_rbe"] = s["rbe"] - ref["rbe"]; s["d_valeur"] = s["valeur"] - ref["valeur"]; s["d_valeur_pct"] = s["valeur"] / ref["valeur"] - 1
	227	+ s.attrs["R"] = R
	228	+ # dérivées analytiques : ∂RBE/∂v = −RBP ; ∂RNE/∂v = −RBP(1−0,04) ; ∂V/∂v = ∂RNE/∂v / R
	229	+ s.attrs["dRBE_dv_pt"] = -base["rbp_contrat"] / 100
	230	+ s.attrs["dRNE_dv_pt"] = -base["rbp_contrat"] * (1 - 0.04) / 100
	231	+ s.attrs["dV_dv_pt"] = -base["rbp_contrat"] * (1 - 0.04) / 100 / R
	232	+ return s
	233	+
	234	+
	235	+# ----------------------------------------------------------------------------- trajectoires des loyers (cas 3)
	236	+def trajectoires_cas3() -> dict:
	237	+ """Trois trajectoires du RBP sur l'horizon du DCF : (i) indexation TAL seule (rotation 0) ; (ii) base du dossier (TAL 3,1 % + rotation 15 %
	238	+ relouée au marché, marché +3,5 %) ; (iii) RBP au marché (indice) ; variante (iv) rotation SCHL 9,4 %."""
	239	+ d = cas3.charger(); etat, dep, hyp = d["etat"], d["dep"], d["hyp"]
	240	+ def proj(**chg):
	241	+ h = copy.deepcopy(hyp); h.update(chg)
	242	+ return cas3.projection_dcf(etat, dep, h)
	243	+ base = proj(); tal = proj(rotation_annuelle=0.0); rot_schl = proj(rotation_annuelle=0.094)
	244	+ rot_schl_marche_schl = proj(rotation_annuelle=0.094, croissance_loyers_marche=0.033) # marché au rythme de l'IPC-loyer récent
	245	+ t = pd.DataFrame({"annee": base["annee"], "exercice": base["exercice"], "tal_seul": tal["rbp"], "base_rot15": base["rbp"],
	246	+ "rot_schl_094": rot_schl["rbp"], "marche": base["rbp_marche"], "rot094_marche033": rot_schl_marche_schl["rbp"],
	247	+ "rbe_tal_seul": tal["rbe"], "rbe_base": base["rbe"], "rbe_rot094": rot_schl["rbe"], "rbe_marche_plein": base["rbp_marche"] * (1 - hyp["taux_inoccupation_pertes"]) + hyp["autres_revenus_annuels"] * (1 + hyp["croissance_depenses"]) ** (base["annee"] - 1)})
	248	+ t["ecart_base_pct"] = (1 - t["base_rot15"] / t["marche"]) * 100
	249	+ t["ecart_tal_pct"] = (1 - t["tal_seul"] / t["marche"]) * 100
	250	+ t["ecart_rot094_pct"] = (1 - t["rot_schl_094"] / t["marche"]) * 100
	251	+ T = hyp["horizon_ans"]
	252	+ res = {"table": t, "hyp": hyp, "T": T,
	253	+ "cagr": {k: (t.loc[t["annee"] == T, k].iloc[0] / t.loc[t["annee"] == 1, k].iloc[0]) ** (1 / (T - 1)) - 1 for k in ["tal_seul", "base_rot15", "rot_schl_094", "marche"]},
	254	+ "rbp_T": {k: float(t.loc[t["annee"] == T, k].iloc[0]) for k in ["tal_seul", "base_rot15", "rot_schl_094", "marche"]},
	255	+ "somme_rbp_1_T": {k: float(t.loc[t["annee"] <= T, k].sum()) for k in ["tal_seul", "base_rot15", "rot_schl_094", "marche"]}}
	256	+ # valeur DCF associée à chaque trajectoire (pour mémoire : sensibilité de la valeur à la trajectoire ; ch. 30/34 approfondissent)
	257	+ res["valeur_dcf"] = {"tal_seul": cas3.valeur_dcf(tal, hyp)["valeur"], "base_rot15": cas3.valeur_dcf(base, hyp)["valeur"],
	258	+ "rot_schl_094": cas3.valeur_dcf(rot_schl, hyp)["valeur"]}
	259	+ return res
	260	+
	261	+
	262	+def mini_projection(loyers: list[float], marche: float, g_c: float, g_m: float, k_par_an: int, annees: int) -> pd.DataFrame:
	263	+ """Petit modèle de trajectoire (exercice 27.6) : chaque année, les loyers reconduits croissent de g_c, le marché de g_m, et les k logements les
	264	+ plus sous le marché sont reloués au marché. Année 1 = loyers en place. Reproduit la logique de traite.cas3.projection_dcf à petite échelle."""
	265	+ L = np.array(loyers, dtype=float); M = float(marche); rows = []
	266	+ for t in range(1, annees + 1):
	267	+ if t > 1:
	268	+ L = L * (1 + g_c); M = M * (1 + g_m)
	269	+ idx = np.argsort(L / M)[:k_par_an]; L[idx] = M
	270	+ rows.append({"annee": t, "loyers": L.copy(), "marche": M, "rbp": L.sum() * 12, "rbp_marche": M * len(L) * 12})
	271	+ return pd.DataFrame(rows)
	272	+
	273	+
	274	+# ----------------------------------------------------------------------------- exercices (solutions/ch27.tex)
	275	+def exercices(base3: dict, base2: dict) -> dict:
	276	+ ex = {}
	277	+ # 27.1 — RBP contractuel, au marché, déficit ; six logements
	278	+ L = [895, 910, 1040, 1150, 1225, 1310]; M = [1100, 1100, 1150, 1250, 1300, 1350]
	279	+ ex["1"] = {"loyers": L, "marche": M, "rbp_c": sum(L) * 12, "rbp_m": sum(M) * 12, "deficit": (sum(M) - sum(L)) * 12,
	280	+ "deficit_pct": 1 - sum(L) / sum(M), "ecarts_pct": [1 - l / m for l, m in zip(L, M)]}
	281	+ # 27.2 — RBE selon trois conventions ; v = 4 %, autres 4 800 $
	282	+ rbp = ex["1"]["rbp_c"]; v = 0.04; autres = 4800.0
	283	+ ex["2"] = {"rbp": rbp, "v": v, "autres": autres, "rbe_livre": fin.revenu_brut_effectif(rbp, v, autres), "rbe_v_sur_tout": (rbp + autres) * (1 - v),
	284	+ "rbe_autres_demi": rbp * (1 - v) + autres * (1 - v / 2), "vacance": rbp * v}
	285	+ ex["2"]["ecart_tout"] = ex["2"]["rbe_v_sur_tout"] - ex["2"]["rbe_livre"]
	286	+ # 27.3 — inoccupation frictionnelle : Québec rotation 13 %, durées 1 et 1,5 mois ; créances 0,5 % ; comparer à SCHL 2,4 %
	287	+ ex["3"] = {"rot": 0.13, "vf_1": fin.taux_vacance_frictionnelle(0.13, 1.0), "vf_15": fin.taux_vacance_frictionnelle(0.13, 1.5),
	288	+ "creances": 0.005, "schl": 0.024}
	289	+ ex["3"]["v_1"] = ex["3"]["vf_1"] + 0.005; ex["3"]["v_15"] = ex["3"]["vf_15"] + 0.005
	290	+ ex["3"]["duree_implicite_schl"] = 0.024 * 12 / 0.13 # durée (mois) qui reproduirait 2,4 % avec ρ = 13 %
	291	+ # 27.4 — concession : un mois gratuit sur 12 à 1 300 $ ; équivalent en v ; deux mois sur 24
	292	+ ex["4"] = {"L": 1300.0, "L_eff_1_12": fin.loyer_effectif_concession(1300, 1, 12), "L_eff_2_24": fin.loyer_effectif_concession(1300, 2, 24),
	293	+ "v_equiv_1_12": 1 / 12, "v_equiv_2_24": 2 / 24, "double_compte": 1300 * 12 * (1 - 1 / 12) * (1 - 1 / 12)}
	294	+ ex["4"]["rbp_annuel"] = 1300 * 12; ex["4"]["rbe_correct"] = 1300 * 12 * (1 - 1 / 12)
	295	+ # 27.5 — triplex (cas 2) : cascade, RBE marché, occupation économique, variante occupant
	296	+ ex["5"] = {k: base2[k] for k in ["rbp_contrat", "rbp_marche", "ecart_marche", "taux_vacance_pertes", "vacance_pertes", "rbe", "rbe_marche", "taux_occupation_economique", "rbe_variante_occupant", "rbe_par_logement"]}
	297	+ # 27.6 — mini-projection : 4 logements
	298	+ mp = mini_projection([900, 950, 1000, 1100], 1200, 0.031, 0.035, 1, 4)
	299	+ ex["6"] = {"table": mp, "rbp": mp["rbp"].tolist(), "rbp_marche": mp["rbp_marche"].tolist(), "ecart_pct": (1 - mp["rbp"] / mp["rbp_marche"]).tolist(),
	300	+ "tal_seul": [sum([900, 950, 1000, 1100]) * 12 * 1.031 ** (t - 1) for t in range(1, 5)]}
	301	+ # 27.7 — valeur et v : cas 3 à v = 2,9 % et 5,9 % ; R = médiane ; via traite.cas3.rne
	302	+ s = sensibilite_v(base3, taux=(0.029, 0.039, 0.059))
	303	+ ex["7"] = {"table": s, "R": s.attrs["R"], "dV_dv_pt": s.attrs["dV_dv_pt"], "dRBE_dv_pt": s.attrs["dRBE_dv_pt"],
	304	+ "V_029": float(s.loc[np.isclose(s["v"], 0.029), "valeur"].iloc[0]), "V_039": float(s.loc[np.isclose(s["v"], 0.039), "valeur"].iloc[0]),
	305	+ "V_059": float(s.loc[np.isclose(s["v"], 0.059), "valeur"].iloc[0]),
	306	+ "rne_029": float(s.loc[np.isclose(s["v"], 0.029), "rne"].iloc[0]), "rne_059": float(s.loc[np.isclose(s["v"], 0.059), "rne"].iloc[0])}
	307	+ ex["7"]["approx_lineaire_2pts"] = 2 * ex["7"]["dV_dv_pt"]
	308	+ # 27.8 — lecture SCHL : quartiles, loyers inoccupés/occupés, implication pour un immeuble au-dessus du marché
	309	+ q = schl_quartiles_montreal(); io = schl_inoccupes_occupes_ile()
	310	+ ex["8"] = {"quartiles": q, "inoccupes_occupes": io, "ratio_tous": io.loc["Tous", "inoccupes"] / io.loc["Tous", "occupes"],
	311	+ "ratio_2ch": io.loc["2 chambres", "inoccupes"] / io.loc["2 chambres", "occupes"], "q4_sur_q1": q.loc["Q4", "inocc_2025"] / q.loc["Q1", "inocc_2025"]}
	312	+ return ex
	313	+
	314	+
	315	+def calculer() -> dict:
	316	+ base3 = cascade_cas3(); base2 = cascade_cas2()
	317	+ res = {"cas3": base3, "cas2": base2, "par_type": par_type_cas3(base3["etat"]),
	318	+ "schl_rmr": schl_inoccupation_rmr().join(schl_rotation_rmr()), "schl_taille": schl_taille_montreal(),
	319	+ "schl_quartiles": schl_quartiles_montreal(), "schl_inocc_occ": schl_inoccupes_occupes_ile(), "schl_annee": schl_annee_construction_ile(),
	320	+ "ipc_loyer": ipc_loyer_quebec(), "grille_frictionnelle": grille_frictionnelle(), "sensibilite_v": sensibilite_v(base3),
	321	+ "trajectoires": trajectoires_cas3()}
	322	+ res["exercices"] = exercices(base3, base2)
	323	+ return res
	324	+
	325	+
	326	+def _fmt(x, d=2):
	327	+ return f"{x:,.{d}f}".replace(",", " ").replace(".", ",")
	328	+
	329	+
	330	+if __name__ == "__main__":
	331	+ r = calculer(); c3 = r["cas3"]; c2 = r["cas2"]
	332	+ print("=== Cas 3 — cascade RBP → RBE (données synthétiques)")
	333	+ for k in ["loyer_mensuel_contrat", "loyer_mensuel_marche", "rbp_contrat", "rbp_marche", "deficit_loyer", "deficit_pct", "taux_vacance_pertes", "vacance_pertes",
	334	+ "loyers_effectifs", "autres_revenus", "autres_par_logement_mois", "rbe", "rbe_sur_rbp", "rbe_par_logement", "rbe_par_m2", "rbp_par_m2",
	335	+ "taux_occupation_economique", "rbe_marche", "rbe_variante_v_sur_tout", "ecart_variante_v_sur_tout", "rbe_variante_v_sur_marche",
	336	+ "v_frictionnel_dossier", "v_residuel_dossier"]:
	337	+ print(f" {k:32s} {_fmt(c3[k], 4 if abs(c3[k]) < 2 else 2)}")
	338	+ print(r["par_type"].round(2).to_string())
	339	+ print("=== Cas 2 — triplex")
	340	+ for k in ["rbp_contrat", "rbp_marche", "ecart_marche", "deficit_pct", "taux_vacance_pertes", "vacance_pertes", "rbe", "rbe_marche", "taux_occupation_economique", "rbe_variante_occupant", "rbe_par_logement"]:
	341	+ print(f" {k:32s} {_fmt(c2[k], 4 if abs(c2[k]) < 2 else 2)}")
	342	+ print("=== SCHL oct. 2025 (réel) — inoccupation et rotation par RMR"); print(r["schl_rmr"].to_string())
	343	+ print("=== SCHL — taille d'immeuble (Montréal)"); print(r["schl_taille"].to_string())
	344	+ print("=== SCHL — quartiles RMR Montréal"); print(r["schl_quartiles"].to_string())
	345	+ print("=== SCHL — loyers inoccupés / occupés, île"); print(r["schl_inocc_occ"].round(1).to_string())
	346	+ print("=== SCHL — année de construction, île"); print(r["schl_annee"].to_string())
	347	+ ipc = r["ipc_loyer"]; print(f"=== IPC loyer Québec : sept. 2026 {ipc['sept2026']} / sept. 2025 {ipc['sept2025']} → {ipc['var_12m']*100:.2f} % ; TCAC 10 ans {ipc['cagr_10ans']*100:.2f} % ; 5 ans {ipc['cagr_5ans']*100:.2f} %")
	348	+ print("=== Grille frictionnelle (v_f en %)"); print(r["grille_frictionnelle"].round(2).to_string())
	349	+ s = r["sensibilite_v"]; print("=== Sensibilité à v (R = %.4f %%)" % (s.attrs["R"] * 100)); print(s.round(2).to_string())
	350	+ print(f" dRBE/dv (par point) {s.attrs['dRBE_dv_pt']:.2f} ; dRNE/dv {s.attrs['dRNE_dv_pt']:.2f} ; dV/dv {s.attrs['dV_dv_pt']:.2f}")
	351	+ t = r["trajectoires"]; print("=== Trajectoires RBP"); print(t["table"].round(2).to_string()); print("TCAC", {k: round(v * 100, 3) for k, v in t["cagr"].items()})
	352	+ print("RBP_T", {k: round(v, 2) for k, v in t["rbp_T"].items()}); print("Somme 1..T", {k: round(v, 2) for k, v in t["somme_rbp_1_T"].items()}); print("V_DCF", {k: round(v, 2) for k, v in t["valeur_dcf"].items()})
	353	+ print("=== Exercices")
	354	+ for k, v in r["exercices"].items():
	355	+ print(k, {kk: (vv if not isinstance(vv, (pd.DataFrame, pd.Series)) else "<table>") for kk, vv in v.items()})
	356	+ print(r["exercices"]["6"]["table"].to_string()); print(r["exercices"]["7"]["table"].round(2).to_string())

added analysis/python/cases/ch31_financement.py +330 −0

		@@ -0,0 +1,330 @@
	1	+#!/usr/bin/env python3
	2	+"""Chapitre 31 — Financement, levier, RCD et RPV : calculs du chapitre (cas 3, 12 logements, Montréal,
	3	+DONNÉES SYNTHÉTIQUES, sauf les taux de la Banque du Canada cités en repère).
	4	+Tous les chiffres de manuscript/chapters/ch31.tex et solutions/ch31.tex proviennent de ce script, qui n'appelle que la
	5	+bibliothèque commune (traite.finance, traite.cas3) et les fonctions du chapitre 30 (cases.ch30_dcf) pour les flux.
	6	+Usage (racine du dépôt) : PYTHONPATH=analysis/python python3 analysis/python/cases/ch31_financement.py [--latex]
	7	+Les fonctions sont importées par analysis/python/figures/ch31_*.py et analysis/python/tests/test_ch31.py.
	8	+
	9	+Aides propres au chapitre (candidates à une promotion dans traite.finance après harmonisation) :
	10	+ prime_aph(rpv, amortissement_mois) — barème SCHL immeubles collectifs (locatif ordinaire / APH Select)
	11	+ mise_de_fonds_minimale(prix) — règle fédérale 5 % / 10 % (plafond 1,5 M$) en vigueur le 15 déc. 2024
	12	+ renouvellement(...) — recalcul exact du paiement sur le solde au terme, à un nouveau taux
	13	+ cout_effectif_dette(...) — TRI annuel des flux de la dette (coût effectif k)
	14	+"""
	15	+from __future__ import annotations
	16	+import sys, pathlib
	17	+import numpy as np, pandas as pd
	18	+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
	19	+from traite import cas3, finance as fin
	20	+from cases import ch30_dcf as c30
	21	+
	22	+ROOT = pathlib.Path(__file__).resolve().parents[3]
	23	+
	24	+# Repères publics (sources/notes-C.md §4, consultés le 2026-10-31) — valeurs citées dans le texte, non des intrants du cas 3
	25	+REPERES = {
	26	+ "taux_directeur": 0.0250, # BdC, 28 octobre 2026
	27	+ "gdc_5ans": 0.0358, "gdc_10ans": 0.0384, # BdC Valet, 2026-10-29
	28	+ "affiche_5ans": 0.0619, # V80691335, semaine du 2026-10-28
	29	+ "assure_5ans_plus": 0.0412, # A4_RATES_MORTGAGES, V122667780, août 2026
	30	+ "non_assure_5ans_plus": 0.0458, # A4_RATES_MORTGAGES, V122667786, août 2026
	31	+ "mqr_plancher": 0.0525, "mqr_marge": 0.02, # BSIF, page modifiée le 2026-01-29
	32	+ "lti_multiple": 4.5, # BSIF, limites LTI
	33	+ "plafond_assurable": 1_500_000.0, "seuil_mdf": 500_000.0, # Finances Canada, 15 décembre 2024
	34	+}
	35	+
	36	+# ----------------------------------------------------------------------------- aides propres au chapitre
	37	+
	38	+def prime_aph(rpv: float, amortissement_mois: int) -> float:
	39	+ """Prime d'assurance SCHL (immeubles collectifs, locatif ordinaire et APH Select, tous buts sauf construction),
	40	+ en proportion du prêt : barème par tranche de RPV + surprime de 0,25 % par tranche de 5 ans d'amortissement au-delà
	41	+ de 25 ans (sources/notes-C.md §4.4, PDF « Droits et primes » consulté le 2026-10-31)."""
	42	+ if rpv <= 0.65: base = 0.0260
	43	+ elif rpv <= 0.70: base = 0.0285
	44	+ elif rpv <= 0.75: base = 0.0335
	45	+ elif rpv <= 0.80: base = 0.0435
	46	+ elif rpv <= 0.85: base = 0.0535
	47	+ elif rpv <= 0.90: base = 0.0590
	48	+ else: base = 0.0615
	49	+ annees = amortissement_mois / 12
	50	+ tranches = max(0, int(np.ceil((annees - 25) / 5 - 1e-9)))
	51	+ return base + 0.0025 * tranches
	52	+
	53	+def mise_de_fonds_minimale(prix: float) -> float:
	54	+ """Mise de fonds minimale d'un prêt assuré (résidentiel 1-4 logements, propriétaire-occupant) : 5 % jusqu'à 500 000 $,
	55	+ 10 % de la tranche entre 500 000 $ et 1,5 M$ ; au-delà de 1,5 M$ le prêt n'est pas assurable (20 % exigés en pratique
	56	+ par la règle RPV ≤ 80 % de B-20). Règles fédérales en vigueur le 15 décembre 2024 (notes-C.md §4.3)."""
	57	+ if prix > REPERES["plafond_assurable"]:
	58	+ return 0.20 * prix
	59	+ s = REPERES["seuil_mdf"]
	60	+ return 0.05 * min(prix, s) + 0.10 * max(prix - s, 0.0)
	61	+
	62	+def cout_effectif_dette(hyp: fin.Hypotheque, annees: int) -> dict:
	63	+ """Coût effectif annuel de la dette : TRI des flux annuels de l'emprunteur (+M_0 ; −SD … ; −SD − solde) sur `annees`,
	64	+ comparé au taux effectif annuel (1 + i/2)^2 − 1 (paiements mensuels agrégés en fin d'année ⇒ TRI annuel < effectif)."""
	65	+ sd = hyp.service_dette_annuel; solde = hyp.solde(annees * 12)
	66	+ flux_emprunteur = [hyp.capital] + [-sd] * annees
	67	+ flux_emprunteur[-1] -= solde
	68	+ flux_preteur = [-x for x in flux_emprunteur]
	69	+ return {"k_annuel": fin.tri(flux_preteur), "taux_effectif": fin.taux_effectif_annuel(hyp.taux_nominal, hyp.composition),
	70	+ "flux_emprunteur": flux_emprunteur, "solde_fin": solde}
	71	+
	72	+# ----------------------------------------------------------------------------- cœur
	73	+
	74	+def base() -> dict:
	75	+ """Tout le cas 3 (via traite.cas3.tout) + flux après dette du chapitre 30."""
	76	+ r = c30.base()
	77	+ r["levier30"] = c30.flux_levier(r)
	78	+ return r
	79	+
	80	+def conventions(capital: float, i: float = 0.0412, n: int = 480) -> pd.DataFrame:
	81	+ """Comparaison des conventions canadienne (composition semestrielle) et américaine (mensuelle) sur un même prêt."""
	82	+ rows = []
	83	+ for nom, comp in (("Canada (semestrielle)", 2), ("États-Unis (mensuelle)", 12)):
	84	+ h = fin.Hypotheque(capital, i, n, composition=comp)
	85	+ rows.append({"convention": nom, "composition": comp, "taux_mensuel": h.taux_periodique, "taux_effectif": fin.taux_effectif_annuel(i, comp),
	86	+ "paiement": h.paiement, "service_dette": h.service_dette_annuel, "constante": h.constante_hypothecaire,
	87	+ "solde_60": h.solde(60), "solde_120": h.solde(120), "interets_an1": h.interets_annee(1), "capital_an1": h.capital_annee(1)})
	88	+ df = pd.DataFrame(rows)
	89	+ return df
	90	+
	91	+def tableau_extraits(h: fin.Hypotheque, periodes=(1, 2, 3, 12, 13, 60, 61, 120, 121, 240, 360, 479, 480)) -> pd.DataFrame:
	92	+ tab = pd.DataFrame(h.tableau())
	93	+ out = tab[tab["periode"].isin(periodes)].copy()
	94	+ out["part_interet"] = out["interet"] / out["paiement"]
	95	+ return out.reset_index(drop=True)
	96	+
	97	+def decomposition_annuelle(h: fin.Hypotheque) -> pd.DataFrame:
	98	+ tab = pd.DataFrame(h.tableau()); tab["annee"] = (tab["periode"] - 1) // 12 + 1
	99	+ g = tab.groupby("annee").agg(interet=("interet", "sum"), capital=("capital", "sum"), paiement=("paiement", "sum"), solde_fin=("solde", "last")).reset_index()
	100	+ g["solde_debut"] = [h.capital] + g["solde_fin"].tolist()[:-1]
	101	+ return g
	102	+
	103	+def financement(r: dict) -> dict:
	104	+ """Dimensionnement du prêt du cas 3 (traite.cas3.financement) + indicateurs dérivés (ratios, point mort, coût effectif)."""
	105	+ f = r["financement"]; h = f["hypotheque"]; b = r["base"]; hyp = r["hyp"]; T = hyp["horizon_ans"]
	106	+ V = r["dcf"]["valeur"]; noi1 = b["rne"]
	107	+ cout = cout_effectif_dette(h, T)
	108	+ return {**{k: v for k, v in f.items() if k != "hypotheque"}, "hypotheque": h, "valeur": V, "rne_1": noi1,
	109	+ "paiement": h.paiement, "taux_effectif": fin.taux_effectif_annuel(h.taux_nominal, 2), "taux_mensuel_us": h.taux_nominal / 12,
	110	+ "interets_an1": h.interets_annee(1), "capital_an1": h.capital_annee(1), "solde_60": h.solde(60), "solde_120": h.solde(120),
	111	+ "rpv_max_par_rcd_sur_V": noi1 / (hyp["financement"]["rcd_min"] * h.constante_hypothecaire) / V,
	112	+ "rpv_max_par_rcd_sur_Vcap": r["taux"]["mediane"] / (hyp["financement"]["rcd_min"] * h.constante_hypothecaire),
	113	+ "R_dcf": noi1 / V, "R_median": r["taux"]["mediane"],
	114	+ "point_mort": fin.ratio_point_mort(b["depenses_totales"], h.service_dette_annuel, b["rbp_contrat"]),
	115	+ "point_mort_hors_reserve": fin.ratio_point_mort(b["depenses_hors_reserve"], h.service_dette_annuel, b["rbp_contrat"]),
	116	+ "flux_apres_dette_1": noi1 - h.service_dette_annuel, "cash_on_cash_1": (noi1 - h.service_dette_annuel) / f["mise_de_fonds"],
	117	+ "dette_sur_fp": f["pret"] / f["mise_de_fonds"], "k_annuel": cout["k_annuel"], "tri_fp": r["levier30"]["tri"], "tri_sans_levier": hyp["taux_actualisation"]}
	118	+
	119	+def levier_courant(r: dict) -> dict:
	120	+ """Vérification de R_E = (R − M f)/(1 − M) = R + (R − f) D/E sur la base DCF et sur la base capitalisation directe."""
	121	+ fi = financement(r); f = fi["constante"]; M = fi["rpv"]
	122	+ R = fi["R_dcf"]; RE_formule = (R - M * f) / (1 - M); RE_alt = R + (R - f) * fi["dette_sur_fp"]
	123	+ # sur la valeur par capitalisation directe (prix = V_cap, même prêt) :
	124	+ Vc = r["valeur_capitalisation"]; Mc = fi["pret"] / Vc; Rc = fi["rne_1"] / Vc
	125	+ return {"R": R, "f": f, "M": M, "D_sur_E": fi["dette_sur_fp"], "RE_formule": RE_formule, "RE_alt": RE_alt, "RE_direct": fi["cash_on_cash_1"],
	126	+ "R_cap": Rc, "M_cap": Mc, "RE_cap": (Rc - Mc * f) / (1 - Mc), "levier_courant": "négatif" if R < f else "positif"}
	127	+
	128	+def levier_par_rpv(r: dict, rpvs=(0.0, 0.25, 0.50, 0.60, None, 0.70, 0.75, 0.80, 0.85)) -> pd.DataFrame:
	129	+ """Effet du ratio prêt-valeur sur la mise de fonds, le service de la dette, le RCD, le rendement courant et le TRI des fonds
	130	+ propres (achat à la valeur DCF, flux du cas 3, même taux et même amortissement ; None = RPV du prêt retenu)."""
	131	+ d = r["dcf"]; hyp = r["hyp"]; fi = r["financement"]; V = d["valeur"]; T = hyp["horizon_ans"]
	132	+ noi1 = r["base"]["rne"]; cf = d["flux"]
	133	+ rows = []
	134	+ for M in rpvs:
	135	+ Mv = fi["rpv"] if M is None else M
	136	+ pret = Mv * V
	137	+ h = fin.Hypotheque(pret, hyp["financement"]["taux"], hyp["financement"]["amortissement_mois"])
	138	+ res = fin.rendement_fonds_propres_levier(cf, V, h, d["vt_nette"])
	139	+ sd = h.service_dette_annuel
	140	+ rows.append({"rpv": Mv, "pret": pret, "mise_de_fonds": V - pret, "service_dette": sd, "rcd_1": (noi1 / sd) if sd > 0 else np.inf,
	141	+ "flux_apres_dette_1": noi1 - sd, "cash_on_cash_1": (noi1 - sd) / (V - pret), "tri_fp": res["tri"],
	142	+ "flux_min": min(res["flux"][1:-1]), "retenu": M is None})
	143	+ return pd.DataFrame(rows)
	144	+
	145	+def tri_fp_courbe(r: dict, rpvs=np.linspace(0.0, 0.85, 35)) -> pd.DataFrame:
	146	+ return levier_par_rpv(r, tuple(float(x) for x in rpvs))
	147	+
	148	+def pret_maximal(r: dict) -> dict:
	149	+ fi = r["financement"]; hyp = r["hyp"]["financement"]
	150	+ return {"pret_rpv": fi["pret_rpv"], "pret_rcd": fi["pret_rcd"], "pret": fi["pret"], "contrainte": fi["contrainte"],
	151	+ "sd_max": r["base"]["rne"] / hyp["rcd_min"], "f": fi["constante"]}
	152	+
	153	+def grille_pret_max(r: dict, taux=(0.0312, 0.0412, 0.0512, 0.0612), amort=(300, 360, 480), rcd=(1.10, 1.20, 1.30)) -> pd.DataFrame:
	154	+ """Prêt maximal par le RCD selon le taux, l'amortissement et le RCD minimal, en dollars et en % de la valeur DCF."""
	155	+ noi1 = r["base"]["rne"]; V = r["dcf"]["valeur"]; rows = []
	156	+ for i in taux:
	157	+ for n in amort:
	158	+ for q in rcd:
	159	+ p = fin.pret_max_par_rcd(noi1, q, i, n)
	160	+ rows.append({"taux": i, "amortissement_mois": n, "rcd_min": q, "pret_max": p, "rpv_implicite": p / V,
	161	+ "constante": fin.Hypotheque(1.0, i, n).constante_hypothecaire})
	162	+ return pd.DataFrame(rows)
	163	+
	164	+def aph_select(r: dict, rcd_min: float = 1.10, rpv_max: float = 0.85, amorts=(480, 540, 600)) -> pd.DataFrame:
	165	+ """Variante APH Select (50 points : RPV 85 %, RCD 1,10 ; 70 points : 45 ans ; 100 points : 50 ans) sur la valeur DCF, au
	166	+ même taux de 4,12 % ; prime SCHL selon le barème (prime_aph), capitalisée ou non au prêt (ici affichée séparément)."""
	167	+ noi1 = r["base"]["rne"]; V = r["dcf"]["valeur"]; i = r["hyp"]["financement"]["taux"]; rows = []
	168	+ fi = r["financement"]
	169	+ rows.append({"formule": "Conventionnel 40 ans (RPV 75 %, RCD 1,20)", "amortissement_mois": 480, "pret_rpv": fi["pret_rpv"], "pret_rcd": fi["pret_rcd"], "pret": fi["pret"],
	170	+ "rpv": fi["pret"] / V, "service_dette": fi["service_dette"], "mise_de_fonds": V - fi["pret"], "prime_pct": np.nan, "prime": np.nan, "rcd_1": noi1 / fi["service_dette"]})
	171	+ for n in amorts:
	172	+ p_rpv = fin.pret_max_par_rpv(V, rpv_max); p_rcd = fin.pret_max_par_rcd(noi1, rcd_min, i, n); p = min(p_rpv, p_rcd)
	173	+ h = fin.Hypotheque(p, i, n); pr = prime_aph(p / V, n)
	174	+ rows.append({"formule": f"APH Select {n // 12} ans (RPV {rpv_max:.0%}, RCD {rcd_min:.2f})".replace("%", " %"), "amortissement_mois": n, "pret_rpv": p_rpv, "pret_rcd": p_rcd, "pret": p,
	175	+ "rpv": p / V, "service_dette": h.service_dette_annuel, "mise_de_fonds": V - p, "prime_pct": pr, "prime": pr * p, "rcd_1": noi1 / h.service_dette_annuel})
	176	+ return pd.DataFrame(rows)
	177	+
	178	+# ----------------------------------------------------------------------------- B-20, MQR, LTI, mise de fonds
	179	+
	180	+def regles_residentielles() -> dict:
	181	+ """Illustrations chiffrées des règles fédérales (résidentiel 1-4 logements)."""
	182	+ mqr_na = fin.taux_admissible_minimal(REPERES["non_assure_5ans_plus"]); mqr_as = fin.taux_admissible_minimal(REPERES["assure_5ans_plus"])
	183	+ mqr_bas = fin.taux_admissible_minimal(0.0300)
	184	+ prix = (400_000.0, 650_000.0, 1_000_000.0, 1_500_000.0, 1_600_000.0)
	185	+ mdf = pd.DataFrame({"prix": prix, "mise_de_fonds": [mise_de_fonds_minimale(p) for p in prix]})
	186	+ mdf["pct"] = mdf["mise_de_fonds"] / mdf["prix"]; mdf["pret"] = mdf["prix"] - mdf["mise_de_fonds"]; mdf["rpv"] = mdf["pret"] / mdf["prix"]
	187	+ # capacité d'emprunt d'un ménage : paiement admissible au MQR vs au taux contractuel (ménage fictif, 25 ans)
	188	+ revenu = 120_000.0; part_dette = 0.39 # ratio ABD indicatif, hypothèse pédagogique (non une règle citée)
	189	+ paiement_mensuel = revenu * part_dette / 12 * 0.85 # 85 % du service de la dette admissible va à l'hypothèque (reste : taxes, chauffage) — hypothèse
	190	+ def capacite(i, n=300):
	191	+ f = fin.Hypotheque(1.0, i, n).paiement
	192	+ return paiement_mensuel / f
	193	+ cap = {"revenu": revenu, "paiement_mensuel": paiement_mensuel, "pret_au_contrat": capacite(REPERES["non_assure_5ans_plus"]), "pret_au_mqr": capacite(mqr_na),
	194	+ "pret_lti": REPERES["lti_multiple"] * revenu}
	195	+ cap["reduction_mqr"] = 1 - cap["pret_au_mqr"] / cap["pret_au_contrat"]
	196	+ return {"mqr_non_assure": mqr_na, "mqr_assure": mqr_as, "mqr_taux_bas": mqr_bas, "mise_de_fonds": mdf, "capacite": cap}
	197	+
	198	+def stress_rcd(r: dict, marges=(0.0, 0.01, 0.02, 0.03)) -> pd.DataFrame:
	199	+ """Test de résistance « à la B-20 » appliqué au RCD du cas 3 : service de la dette du prêt retenu recalculé au taux contractuel
	200	+ + marge (même amortissement), RCD sur le RNE de l'année 1, et prêt maximal si le prêteur qualifiait au taux majoré."""
	201	+ fi = r["financement"]; hyp = r["hyp"]["financement"]; noi1 = r["base"]["rne"]; V = r["dcf"]["valeur"]; rows = []
	202	+ for m in marges:
	203	+ i = hyp["taux"] + m
	204	+ h = fin.Hypotheque(fi["pret"], i, hyp["amortissement_mois"])
	205	+ pmax = fin.pret_max_par_rcd(noi1, hyp["rcd_min"], i, hyp["amortissement_mois"])
	206	+ rows.append({"marge": m, "taux": i, "service_dette": h.service_dette_annuel, "rcd_1": noi1 / h.service_dette_annuel,
	207	+ "pret_max_qualifie": pmax, "rpv_qualifie": pmax / V, "constante": h.constante_hypothecaire})
	208	+ return pd.DataFrame(rows)
	209	+
	210	+# ----------------------------------------------------------------------------- renouvellement au terme
	211	+
	212	+def renouvellement(r: dict, deltas=(0.0, 0.01, 0.02, 0.03), terme_ans: int | None = None) -> dict:
	213	+ """Renouvellement exact à l'échéance du terme : solde après `terme` années, nouveau paiement sur l'amortissement résiduel
	214	+ au taux initial + delta ; service de la dette, RCD des années suivantes, flux des fonds propres et TRI (achat à la valeur
	215	+ DCF, projection de base du cas 3). Comparaison avec l'approximation du chapitre 30 (taux majoré dès l'origine)."""
	216	+ d = r["dcf"]; hyp = r["hyp"]; fi = r["financement"]; h0 = fi["hypotheque"]; T = hyp["horizon_ans"]
	217	+ terme = terme_ans or hyp["financement"]["terme_ans"]; n0 = hyp["financement"]["amortissement_mois"]
	218	+ V = d["valeur"]; mise = V - h0.capital; cf = list(d["flux"]); rne = r["projection"].loc[r["projection"]["annee"] <= T, "rne"].tolist()
	219	+ solde_terme = h0.solde(terme * 12); n_res = n0 - terme * 12
	220	+ sd0 = h0.service_dette_annuel
	221	+ rows = []; detail = {}
	222	+ for dlt in deltas:
	223	+ i2 = h0.taux_nominal + dlt
	224	+ h2 = fin.Hypotheque(solde_terme, i2, n_res)
	225	+ sd2 = h2.service_dette_annuel
	226	+ sd = [sd0] * terme + [sd2] * (T - terme)
	227	+ solde_T = h2.solde((T - terme) * 12)
	228	+ flux = [-mise] + [cf[t] - sd[t] for t in range(T)]
	229	+ flux[-1] += d["vt_nette"] - solde_T
	230	+ tri = fin.tri(flux)
	231	+ rcd = [rne[t] / sd[t] for t in range(T)]
	232	+ # approximation du ch. 30 : même prêt, taux majoré dès l'origine
	233	+ h_approx = fin.Hypotheque(h0.capital, i2, n0)
	234	+ approx = fin.rendement_fonds_propres_levier(cf, V, h_approx, d["vt_nette"])
	235	+ rows.append({"delta": dlt, "taux_renouvele": i2, "solde_terme": solde_terme, "paiement_2": h2.paiement, "service_dette_2": sd2,
	236	+ "hausse_sd": sd2 - sd0, "hausse_sd_pct": sd2 / sd0 - 1, "rcd_an_terme_plus_1": rcd[terme], "rcd_min_apres": min(rcd[terme:]),
	237	+ "rcd_an_T": rcd[-1], "flux_apres_dette_an_terme_plus_1": cf[terme] - sd2, "solde_T": solde_T, "tri_fp": tri,
	238	+ "tri_fp_approx_ch30": approx["tri"], "sd_approx_ch30": h_approx.service_dette_annuel, "interets_an_terme_plus_1": h2.interets_annee(1)})
	239	+ detail[dlt] = {"flux": flux, "rcd": rcd, "sd": sd, "hypotheque_2": h2}
	240	+ tab = pd.DataFrame(rows)
	241	+ # seuil : hausse de taux qui ramène le RCD de l'année terme+1 à 1,20 et à 1,00
	242	+ def rcd_apres(dlt):
	243	+ h2 = fin.Hypotheque(solde_terme, h0.taux_nominal + dlt, n_res); return rne[terme] / h2.service_dette_annuel
	244	+ def bissection(cible, lo=0.0, hi=0.20):
	245	+ for _ in range(200):
	246	+ mid = 0.5 * (lo + hi)
	247	+ if rcd_apres(mid) > cible: lo = mid
	248	+ else: hi = mid
	249	+ return 0.5 * (lo + hi)
	250	+ return {"tableau": tab, "detail": detail, "solde_terme": solde_terme, "n_residuel": n_res, "terme": terme,
	251	+ "delta_rcd_120": bissection(1.20), "delta_rcd_100": bissection(1.00), "taux_rcd_120": h0.taux_nominal + bissection(1.20), "taux_rcd_100": h0.taux_nominal + bissection(1.00)}
	252	+
	253	+def sensibilite_service_dette(r: dict, taux=np.arange(0.03, 0.0801, 0.0025), amorts=(300, 360, 480)) -> pd.DataFrame:
	254	+ """Service de la dette et RCD (RNE_1) du prêt retenu selon le taux et l'amortissement (pour la figure et le tableau)."""
	255	+ fi = r["financement"]; noi1 = r["base"]["rne"]; rows = []
	256	+ for n in amorts:
	257	+ for i in taux:
	258	+ h = fin.Hypotheque(fi["pret"], float(i), n)
	259	+ rows.append({"amortissement_mois": n, "taux": float(i), "service_dette": h.service_dette_annuel, "rcd_1": noi1 / h.service_dette_annuel, "constante": h.constante_hypothecaire})
	260	+ return pd.DataFrame(rows)
	261	+
	262	+def risque_levier(r: dict, sigma_actif: float = 0.08) -> dict:
	263	+ """Illustration : écart-type du rendement des fonds propres = σ_actif / (1 − M) (dette sans risque, une période)."""
	264	+ fi = r["financement"]; M = fi["rpv"]
	265	+ return {"sigma_actif": sigma_actif, "M": M, "sigma_fp": sigma_actif / (1 - M), "multiplicateur": 1 / (1 - M),
	266	+ "grille": pd.DataFrame({"rpv": [0, 0.25, 0.5, M, 0.75, 0.85], "sigma_fp": [sigma_actif / (1 - m) for m in [0, 0.25, 0.5, M, 0.75, 0.85]]})}
	267	+
	268	+# ----------------------------------------------------------------------------- exercices
	269	+
	270	+def exercices() -> dict:
	271	+ r = base(); e = {}
	272	+ # ex 1 : convention canadienne vs américaine, 850 000 $, 4,58 %, 300 mois
	273	+ e["ex1"] = conventions(850_000.0, 0.0458, 300).set_index("convention").to_dict("index")
	274	+ # ex 2 : terme vs amortissement : prêt 1 000 000 $, 4,12 %, 480 mois ; solde à 60 et 120 ; intérêts an 1 ; part du capital remboursée au terme
	275	+ h = fin.Hypotheque(1_000_000.0, 0.0412, 480)
	276	+ e["ex2"] = {"paiement": h.paiement, "sd": h.service_dette_annuel, "solde_60": h.solde(60), "solde_120": h.solde(120), "interets_an1": h.interets_annee(1),
	277	+ "capital_an1": h.capital_annee(1), "part_remboursee_60": 1 - h.solde(60) / h.capital, "interets_totaux": h.paiement * 480 - h.capital,
	278	+ "h25": fin.Hypotheque(1_000_000.0, 0.0412, 300)}
	279	+ e["ex2"]["interets_totaux_25"] = e["ex2"]["h25"].paiement * 300 - 1_000_000.0; e["ex2"]["sd_25"] = e["ex2"]["h25"].service_dette_annuel
	280	+ # ex 3 : prêt maximal : RNE 120 000 $, valeur 2 600 000 $, RPV 75 %, RCD 1,25, 4,58 %, 360 mois ; puis APH 1,10 / 85 % / 480 mois
	281	+ e["ex3"] = {"pret_rpv": fin.pret_max_par_rpv(2_600_000, 0.75), "pret_rcd": fin.pret_max_par_rcd(120_000, 1.25, 0.0458, 360),
	282	+ "f": fin.Hypotheque(1.0, 0.0458, 360).constante_hypothecaire, "pret_rcd_aph": fin.pret_max_par_rcd(120_000, 1.10, 0.0412, 480),
	283	+ "pret_rpv_aph": fin.pret_max_par_rpv(2_600_000, 0.85), "f_aph": fin.Hypotheque(1.0, 0.0412, 480).constante_hypothecaire}
	284	+ e["ex3"]["pret"] = min(e["ex3"]["pret_rpv"], e["ex3"]["pret_rcd"]); e["ex3"]["pret_aph"] = min(e["ex3"]["pret_rpv_aph"], e["ex3"]["pret_rcd_aph"])
	285	+ e["ex3"]["prime_aph"] = prime_aph(e["ex3"]["pret_aph"] / 2_600_000, 480); e["ex3"]["rpv_aph"] = e["ex3"]["pret_aph"] / 2_600_000
	286	+ # ex 4 : levier courant : R = 5,2 %, f = 6,0 % et 4,5 %, M = 0,70
	287	+ e["ex4"] = {M: {f: (0.052 - M * f) / (1 - M) for f in (0.060, 0.045)} for M in (0.0, 0.5, 0.7, 0.8)}
	288	+ # ex 5 : MQR et mise de fonds : prix 720 000 $, taux 4,58 %
	289	+ e["ex5"] = {"mdf": mise_de_fonds_minimale(720_000), "mqr": fin.taux_admissible_minimal(0.0458), "mqr_bas": fin.taux_admissible_minimal(0.0300),
	290	+ "paiement_contrat": fin.Hypotheque(720_000 - mise_de_fonds_minimale(720_000), 0.0458, 300).paiement,
	291	+ "paiement_mqr": fin.Hypotheque(720_000 - mise_de_fonds_minimale(720_000), fin.taux_admissible_minimal(0.0458), 300).paiement,
	292	+ "lti_revenu_requis": (720_000 - mise_de_fonds_minimale(720_000)) / 4.5}
	293	+ # ex 6 : renouvellement du cas 3 à +150 pb
	294	+ e["ex6"] = renouvellement(r, deltas=(0.015,))["tableau"].iloc[0].to_dict()
	295	+ # ex 7 : levier et TRI par RPV (cas 3) : 50 % et 85 %
	296	+ e["ex7"] = levier_par_rpv(r, (0.50, 0.85)).to_dict("records")
	297	+ e["ex7_k"] = financement(r)["k_annuel"]
	298	+ return e
	299	+
	300	+# ----------------------------------------------------------------------------- sortie
	301	+
	302	+def _d(x): return f"{x:,.0f}".replace(",", " ") + " $"
	303	+def _p(x, d=2): return f"{x*100:.{d}f}".replace(".", ",") + " %"
	304	+
	305	+def main():
	306	+ r = base(); fi = financement(r)
	307	+ print("=== Cas 3 — financement (traite.cas3.financement) ===")
	308	+ for k in ("valeur", "rne_1", "pret_rpv", "pret_rcd", "pret", "contrainte", "rpv", "mise_de_fonds", "paiement", "service_dette", "constante", "taux_mensuel", "taux_mensuel_us", "taux_effectif",
	309	+ "interets_an1", "capital_an1", "solde_60", "solde_120", "rcd", "flux_apres_dette_1", "cash_on_cash_1", "dette_sur_fp", "point_mort", "point_mort_hors_reserve",
	310	+ "rpv_max_par_rcd_sur_V", "rpv_max_par_rcd_sur_Vcap", "R_dcf", "R_median", "k_annuel", "tri_fp", "tri_sans_levier"):
	311	+ v = fi[k]; print(f"{k:28s} {v if not isinstance(v, float) else (round(v, 6) if abs(v) < 10 else round(v, 2))}")
	312	+ print("\n=== Conventions (prêt du cas 3) ===\n", conventions(fi["pret"]).T)
	313	+ print("\n=== Tableau d'amortissement — extraits ===\n", tableau_extraits(fi["hypotheque"]).round(2).to_string())
	314	+ dec = decomposition_annuelle(fi["hypotheque"]); print("\n=== Décomposition annuelle (années 1, 5, 10, 20, 30, 40) ===\n", dec[dec["annee"].isin([1, 5, 10, 20, 30, 40])].round(0).to_string())
	315	+ print("\n=== Levier courant ===\n", levier_courant(r))
	316	+ print("\n=== Levier par RPV ===\n", levier_par_rpv(r).round(4).to_string())
	317	+ print("\n=== Prêt maximal ===\n", pret_maximal(r))
	318	+ print("\n=== Grille prêt max (RCD) ===\n", grille_pret_max(r).round(4).to_string())
	319	+ print("\n=== APH Select ===\n", aph_select(r).round(4).to_string())
	320	+ rr = regles_residentielles(); print("\n=== Règles résidentielles ===\n", {k: v for k, v in rr.items() if k != "mise_de_fonds"}, "\n", rr["mise_de_fonds"].round(4).to_string())
	321	+ print("\n=== Stress RCD (taux + marge) ===\n", stress_rcd(r).round(4).to_string())
	322	+ ren = renouvellement(r); print("\n=== Renouvellement au terme ===\n", ren["tableau"].round(4).T.to_string(), "\nseuils :", {k: ren[k] for k in ("solde_terme", "n_residuel", "delta_rcd_120", "delta_rcd_100", "taux_rcd_120", "taux_rcd_100")})
	323	+ print("\n=== Risque ===\n", risque_levier(r)["grille"].round(4).to_string())
	324	+ s = sensibilite_service_dette(r, taux=np.array([0.03, 0.04, 0.0412, 0.05, 0.06, 0.07, 0.08])); print("\n=== Service de la dette vs taux ===\n", s.round(4).to_string())
	325	+ print("\n=== Exercices ===")
	326	+ e = exercices()
	327	+ for k, v in e.items(): print(k, v)
	328	+
	329	+if __name__ == "__main__":
	330	+ main()

added analysis/python/cases/ch32_plex.py +298 −0

Large diff (298 lines) is not loaded by default to keep the page fast.Load diff

modified analysis/python/figures/ch12_figures.py +1 −1

Large diff (8 lines) is not loaded by default to keep the page fast.Load diff

modified analysis/python/figures/ch14_figures.py +10 −7

Large diff (58 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch15_figures.py +132 −0

Large diff (132 lines) is not loaded by default to keep the page fast.Load diff

modified analysis/python/figures/ch22_ecarts.py +1 −1

Large diff (8 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch23_ipcb_divisions.py +38 −0

Large diff (38 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch23_ipcb_types.py +44 −0

Large diff (44 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch23_sensibilite.py +40 −0

Large diff (40 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch23_structure.py +35 −0

Large diff (35 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch24_composantes.py +40 −0

Large diff (40 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch24_courbes.py +58 −0

Large diff (58 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch24_decomposition.py +60 −0

Large diff (60 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch24_sensibilite.py +47 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch25_figures.py +126 −0

Large diff (126 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch26_figures.py +104 −0

Large diff (104 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch27_figures.py +139 −0

Large diff (139 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch31_levier.py +37 −0

Large diff (37 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch31_service_dette.py +36 −0

Large diff (36 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch31_solde.py +41 −0

Large diff (41 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/figures/ch31_taux_bdc.py +48 −0

Large diff (48 lines) is not loaded by default to keep the page fast.Load diff

modified analysis/python/tests/test_ch11.py +8 −0

Large diff (11 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/tests/test_ch14.py +185 −0

Large diff (185 lines) is not loaded by default to keep the page fast.Load diff

modified analysis/python/tests/test_ch22.py +41 −38

Large diff (151 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/tests/test_ch23.py +280 −0

Large diff (280 lines) is not loaded by default to keep the page fast.Load diff

added analysis/python/tests/test_ch26.py +178 −0

Large diff (178 lines) is not loaded by default to keep the page fast.Load diff

modified analysis/python/traite/finance.py +15 −0

Large diff (21 lines) is not loaded by default to keep the page fast.Load diff

modified assets/figures/ch12/ch12-fig-attenuation.pdf +0 −0

Binary file not shown.

modified assets/figures/ch12/ch12-fig-conventions-sujet.pdf +0 −0

Binary file not shown.

modified assets/figures/ch12/ch12-fig-erreur-valeur.pdf +0 −0

Binary file not shown.

modified assets/figures/ch14/ch14-fig-avant-apres.pdf +0 −0

Binary file not shown.

modified assets/figures/ch14/ch14-fig-geocodage.pdf +0 −0

Binary file not shown.

modified assets/figures/ch14/ch14-fig-levier-cook.pdf +0 −0

Binary file not shown.

modified assets/figures/ch14/ch14-fig-scores-robustes.pdf +0 −0

Binary file not shown.

modified assets/figures/ch14/ch14-fig-sensibilite-seuils.pdf +0 −0

Binary file not shown.

added assets/figures/ch15/ch15-fig-carte-segments.pdf +0 −0

Binary file not shown.

added assets/figures/ch15/ch15-fig-coefficients-secteurs.pdf +0 −0

Binary file not shown.

added assets/figures/ch15/ch15-fig-dendrogramme.pdf +0 −0

Binary file not shown.

added assets/figures/ch15/ch15-fig-loyers-rosemont.pdf +0 −0

Binary file not shown.

added assets/figures/ch15/ch15-fig-mois-inventaire.pdf +0 −0

Binary file not shown.

added assets/figures/ch15/ch15-fig-silhouette.pdf +0 −0

Binary file not shown.

modified assets/figures/ch22/ch22-fig-ecarts-metre.pdf +0 −0

Binary file not shown.

modified assets/figures/ch22/ch22-fig-repartition-corps.pdf +0 −0

Binary file not shown.

added assets/figures/ch23/ch23-fig-ipcb-divisions.pdf +0 −0

Binary file not shown.

added assets/figures/ch23/ch23-fig-ipcb-types.pdf +0 −0

Binary file not shown.

added assets/figures/ch23/ch23-fig-sensibilite.pdf +0 −0

Binary file not shown.

added assets/figures/ch23/ch23-fig-structure-couts.pdf +0 −0

Binary file not shown.

added assets/figures/ch24/ch24-fig-composantes.pdf +0 −0

Binary file not shown.

added assets/figures/ch24/ch24-fig-courbes.pdf +0 −0

Binary file not shown.

added assets/figures/ch24/ch24-fig-decomposition.pdf +0 −0

Binary file not shown.

added assets/figures/ch24/ch24-fig-sensibilite.pdf +0 −0

Binary file not shown.

added assets/figures/ch25/ch25-fig-carte-terrains.pdf +0 −0

Binary file not shown.

added assets/figures/ch25/ch25-fig-lotissement.pdf +0 −0

Binary file not shown.

added assets/figures/ch25/ch25-fig-residuelle-sensibilite.pdf +0 −0

Binary file not shown.

added assets/figures/ch25/ch25-fig-valeur-unitaire-superficie.pdf +0 −0

Binary file not shown.

added assets/figures/ch26/ch26-fig-anciennete.pdf +0 −0

Binary file not shown.

added assets/figures/ch26/ch26-fig-contrat-marche.pdf +0 −0

Binary file not shown.

added assets/figures/ch26/ch26-fig-normalisation.pdf +0 −0

Binary file not shown.

added assets/figures/ch26/ch26-fig-va-ecart.pdf +0 −0

Binary file not shown.

added assets/figures/ch27/ch27-fig-cascade.pdf +0 −0

Binary file not shown.

added assets/figures/ch27/ch27-fig-inoccupation-rmr.pdf +0 −0

Binary file not shown.

added assets/figures/ch27/ch27-fig-sensibilite.pdf +0 −0

Binary file not shown.

added assets/figures/ch27/ch27-fig-trajectoires.pdf +0 −0

Binary file not shown.

added assets/figures/ch31/ch31-fig-levier.pdf +0 −0

Binary file not shown.

added assets/figures/ch31/ch31-fig-service-dette.pdf +0 −0

Binary file not shown.

added assets/figures/ch31/ch31-fig-solde.pdf +0 −0

Binary file not shown.

added assets/figures/ch31/ch31-fig-taux-bdc.pdf +0 −0

Binary file not shown.

added data/synthetic/README-brut.md +50 −0

Large diff (50 lines) is not loaded by default to keep the page fast.Load diff

added data/synthetic/ch25_terrains_ventes.csv +201 −0

Large diff (201 lines) is not loaded by default to keep the page fast.Load diff

modified manuscript/chapters/ch11.tex +24 −11

Large diff (99 lines) is not loaded by default to keep the page fast.Load diff

modified manuscript/chapters/ch12.tex +9 −9

Large diff (63 lines) is not loaded by default to keep the page fast.Load diff

modified manuscript/chapters/ch19.tex +382 −0

Large diff (385 lines) is not loaded by default to keep the page fast.Load diff

added references/lib-ch11.bib +123 −0

Large diff (123 lines) is not loaded by default to keep the page fast.Load diff

added references/lib-ch12.bib +50 −0

Large diff (50 lines) is not loaded by default to keep the page fast.Load diff

added references/lib-ch14.bib +114 −0

Large diff (114 lines) is not loaded by default to keep the page fast.Load diff

modified references/library.bib +268 −13

Large diff (293 lines) is not loaded by default to keep the page fast.Load diff

modified solutions/ch11.tex +61 −0

Large diff (62 lines) is not loaded by default to keep the page fast.Load diff

modified solutions/ch12.tex +49 −0

Large diff (50 lines) is not loaded by default to keep the page fast.Load diff

modified sources/registry.csv +6 −0

Large diff (12 lines) is not loaded by default to keep the page fast.Load diff

modified tools/BRIEF-CHAPITRE.md +2 −0

Large diff (8 lines) is not loaded by default to keep the page fast.Load diff

modified verification/calculations.csv +23 −0

Large diff (26 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch11-calculations.csv +12 −0

Large diff (12 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch11-claims.csv +26 −0

Large diff (26 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch11-figures.csv +6 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch12-calculations.csv +13 −0

Large diff (13 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch12-claims.csv +20 −0

Large diff (20 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch12-figures.csv +6 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch12-registry.csv +7 −0

Large diff (7 lines) is not loaded by default to keep the page fast.Load diff

added verification/chapters/ch12.md +36 −0

Large diff (36 lines) is not loaded by default to keep the page fast.Load diff

modified verification/claims.csv +44 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

modified verification/figures.csv +10 −0

Large diff (14 lines) is not loaded by default to keep the page fast.Load diff