트리맵¶

def squarify(values, x, y, dx, dy):
    """넓이가 values 에 비례하는 사각형들로 (x,y,dx,dy) 직사각형을 덮는다.

    브륄스-허잇-판빅(1999)의 제곱화 알고리즘.
    values 는 내림차순으로 정렬되어 있다고 가정한다.
    """
    rects = []
    vals = list(values)
    total = sum(vals)
    if total <= 0:
        return rects
    # 값을 실제 화면 넓이 단위로 환산한다.
    vals = [v * dx * dy / total for v in vals]

    def worst(row, length):
        """한 줄에 row 를 놓았을 때 가로세로비의 최악값."""
        s = sum(row)
        if s == 0 or length == 0:
            return float("inf")
        mx, mn = max(row), min(row)
        return max(length * length * mx / (s * s), s * s / (length * length * mn))

    def layout_row(row, x, y, dx, dy):
        """row 를 짧은 변에 맞춰 한 줄로 배치하고 남은 영역을 돌려준다."""
        s = sum(row)
        out = []
        if dx >= dy:                      # 남은 영역이 가로로 길면 세로 열로 쌓는다
            w = s / dy if dy else 0
            cy = y
            for v in row:
                h = v / w if w else 0
                out.append((x, cy, w, h))
                cy += h
            return out, (x + w, y, dx - w, dy)
        else:                             # 세로로 길면 가로 행으로 쌓는다
            h = s / dx if dx else 0
            cx = x
            for v in row:
                w = v / h if h else 0
                out.append((cx, y, w, h))
                cx += w
            return out, (x, y + h, dx, dy - h)

    # 한 줄에 계속 더해 보다가, 더 넣으면 가로세로비가 나빠지는 순간 줄을 확정한다.
    row = []
    i = 0
    while i < len(vals):
        length = min(dx, dy)
        if not row or worst(row + [vals[i]], length) <= worst(row, length):
            row.append(vals[i]); i += 1
        else:
            placed, (x, y, dx, dy) = layout_row(row, x, y, dx, dy)
            rects += placed
            row = []
    if row:
        placed, _ = layout_row(row, x, y, dx, dy)
        rects += placed
    return rects


# 넓이가 정확히 값에 비례하는지 확인한다.
v = sorted([6, 6, 4, 3, 2, 2, 1], reverse=True)
R = squarify(v, 0, 0, 6, 4)
print(f"값 {v},  전체 넓이 {6 * 4}")
print(f"{'값':>4s}{'넓이':>10s}{'기대':>10s}{'가로세로비':>11s}{'max(w^2/a, a/w^2)':>20s}")
for val, (x0, y0, w, h) in zip(v, R):
    a = w * h
    print(f"{val:>4d}{a:>10.4f}{val * 24 / sum(v):>10.4f}"
          f"{max(w / h, h / w):>11.2f}{max(w*w/a, a/(w*w)):>20.2f}")
print(f"넓이 합 {sum(w * h for _, _, w, h in R):.6f}   전체 넓이 {6*4}")
print(f"차이 {sum(w * h for _, _, w, h in R) - 24:.3e}")

ratios = [max(w / h, h / w) for _, _, w, h in R]
print(f"\n가장 큰 값 {v[0]} 의 가로세로비 {ratios[0]:.2f},  "
      f"가장 작은 값 {v[-1]} 의 가로세로비 {ratios[-1]:.2f}")
print(f"가로세로비 범위 {min(ratios):.2f} ~ {max(ratios):.2f}")

# (1) 넓이가 될 수 없는 값은 담을 수 없다.
print("\n음수가 섞인 값 [6, -2, 4] 의 합 =", 6 - 2 + 4,
      "  →  -2 에 줄 넓이가 없다")
print("합이 0 인 값 [0, 0, 0]:", squarify([0, 0, 0], 0, 0, 6, 4), "(빈 목록)")

값 [6, 6, 4, 3, 2, 2, 1],  전체 넓이 24
   값        넓이        기대      가로세로비   max(w^2/a, a/w^2)
   6    6.0000    6.0000       1.50                1.50
   6    6.0000    6.0000       1.50                1.50
   4    4.0000    4.0000       1.36                1.36
   3    3.0000    3.0000       1.81                1.81
   2    2.0000    2.0000       1.39                1.39
   2    2.0000    2.0000       1.39                1.39
   1    1.0000    1.0000       2.78                2.78
넓이 합 24.000000   전체 넓이 24
차이 0.000e+00

가장 큰 값 6 의 가로세로비 1.50,  가장 작은 값 1 의 가로세로비 2.78
가로세로비 범위 1.36 ~ 2.78

음수가 섞인 값 [6, -2, 4] 의 합 = 8   →  -2 에 줄 넓이가 없다
합이 0 인 값 [0, 0, 0]: [] (빈 목록)

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게


def slice_dice(values, x, y, dx, dy, vertical=True):
    """단순 분할: 한 방향으로만 차례로 자른다."""
    out = []
    tot = sum(values)
    pos = x if vertical else y
    for v in values:
        if vertical:
            w = dx * v / tot
            out.append((pos, y, w, dy)); pos += w
        else:
            h = dy * v / tot
            out.append((x, pos, dx, h)); pos += h
    return out


rng = np.random.default_rng(3)
# 파레토 분포로 '몇 개가 아주 크고 대부분 작은' 현실적인 값을 만든다.
vals = sorted(np.round(rng.pareto(1.1, 24) * 10 + 1, 1), reverse=True)

fig, ax = plt.subplots(1, 3, figsize=(16, 4.4))
for a, (R, title) in zip(ax, [(slice_dice(vals, 0, 0, 10, 6), "슬라이스-앤-다이스"),
                              (squarify(vals, 0, 0, 10, 6), "제곱화")]):
    ratios = [max(w / h, h / w) for _, _, w, h in R]
    cm = plt.get_cmap("Blues")
    for v_, (x0, y0, w, h) in zip(vals, R):
        a.add_patch(plt.Rectangle((x0, y0), w, h,
                    facecolor=cm(0.2 + 0.6 * v_ / max(vals)),
                    edgecolor="white", linewidth=1.2))
    a.set_xlim(0, 10); a.set_ylim(0, 6)
    a.set_xticks([]); a.set_yticks([])
    a.set_title(f"{title}\n가로세로비 중앙값 {np.median(ratios):.2f}, "
                f"최악 {max(ratios):.1f}")

r1 = [max(w / h, h / w) for _, _, w, h in slice_dice(vals, 0, 0, 10, 6)]
r2 = [max(w / h, h / w) for _, _, w, h in squarify(vals, 0, 0, 10, 6)]
ax[2].boxplot([r1, r2], labels=["슬라이스-앤-다이스", "제곱화"])
ax[2].set_yscale("log")
ax[2].axhline(1, color="red", ls="--", lw=1, label="이상적인 값 = 1")
ax[2].set_ylabel("가로세로비 (로그 눈금)"); ax[2].set_title("가로세로비 분포")
ax[2].legend(); ax[2].grid(alpha=0.25)

fig.suptitle("같은 24개 값, 두 가지 배치 규칙", y=1.02)
fig.tight_layout()
plt.show()

print(f"slice-and-dice: 중앙값 {np.median(r1):.2f}, 최악 {max(r1):.1f}")
print(f"squarified:     중앙값 {np.median(r2):.2f}, 최악 {max(r2):.1f}")

# (1) 닫힌 꼴이 실측과 맞는지 확인한다.
p = np.array(vals, float) / sum(vals)
DX, DY = 10.0, 6.0
pred = np.maximum(DX * p / DY, DY / (DX * p))
print(f"\n값 {len(vals)}개, 합 {sum(vals):.1f}, 가장 작은 값 {min(vals):.1f}")
print(f"닫힌 꼴과 실측이 같은가 {np.allclose(pred, r1)}"
      f"   최대 차이 {np.abs(pred - np.array(r1)).max():.1e}")
print(f"가장 작은 비중 p_min = {p.min():.6f}")
print(f"  예측 최악 DY/(DX*p_min) = {DY/(DX*p.min()):.1f}   실측 {max(r1):.1f}")
print(f"  예측 중앙값             = {np.median(pred):.2f}    실측 {np.median(r1):.2f}")
print(f"\n제곱화 / 슬라이스-앤-다이스 중앙값 비 "
      f"{np.median(r1)/np.median(r2):.1f} 배")

slice-and-dice: 중앙값 49.10, 최악 320.1
squarified:     중앙값 1.29, 최악 2.3

값 24개, 합 533.5, 가장 작은 값 1.0
닫힌 꼴과 실측이 같은가 True   최대 차이 2.8e-14
가장 작은 비중 p_min = 0.001874
  예측 최악 DY/(DX*p_min) = 320.1   실측 320.1
  예측 중앙값             = 49.10    실측 49.10

제곱화 / 슬라이스-앤-다이스 중앙값 비 38.1 배

import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

fig, ax = plt.subplots(1, 3, figsize=(16, 4.6))

# ── (1) 모자이크: 분할표를 받는다 ─────────────────────────────────
tab = np.array([[28, 97], [35, 104]], float)     # SUV/비SUV x 사고/무사고
n = tab.sum()
colw = tab.sum(1) / n                            # 열 너비 = 주변확률
x = 0
for i, (w, row) in enumerate(zip(colw, tab)):
    y = 0
    for j, v in enumerate(row):
        h = v / row.sum()                        # 높이 = 조건부확률
        ax[0].add_patch(plt.Rectangle((x, y), w - 0.01, h - 0.006,
                        facecolor=["#7fb3d5", "#f5b041"][j], edgecolor="white"))
        ax[0].text(x + w / 2, y + h / 2, f"{int(v)}",
                   ha="center", va="center", fontsize=10)
        y += h
    x += w
ax[0].set_xlim(0, 1); ax[0].set_ylim(0, 1)
ax[0].set_title("모자이크 그림\n(넓이 = 칸의 도수)")
ax[0].set_xlabel("너비 = 행의 주변확률")
ax[0].set_ylabel("높이 = 조건부확률")

# ── (2) 트리맵: 값의 목록을 받는다 ────────────────────────────────
v = sorted([6, 6, 4, 3, 2, 2, 1], reverse=True)
R = squarify(v, 0, 0, 6, 4)                      # 1절에서 만든 함수
cmap = plt.get_cmap("Blues")
for val, (x0, y0, w, h) in zip(v, R):
    ax[1].add_patch(plt.Rectangle((x0, y0), w, h,
                    facecolor=cmap(0.25 + 0.5 * val / max(v)),
                    edgecolor="white", linewidth=2))
    ax[1].text(x0 + w / 2, y0 + h / 2, str(val),
               ha="center", va="center", fontweight="bold")
ax[1].set_xlim(0, 6); ax[1].set_ylim(0, 4)
ax[1].set_title("트리맵\n(넓이 = 값, 제곱화 배치)")
ax[1].set_xticks([]); ax[1].set_yticks([])

# ── (3) 같은 값을 막대로 ─────────────────────────────────────────
ax[2].bar(range(len(v)), v,
          color=[cmap(0.25 + 0.5 * z / max(v)) for z in v], edgecolor="black")
ax[2].set_title("막대그림\n(길이 = 값)")
ax[2].set_xticks(range(len(v))); ax[2].set_xticklabels([str(z) for z in v])
ax[2].set_ylabel("값")

fig.suptitle("어디나 사각형이지만 받는 자료가 다르다", y=1.02)
fig.tight_layout()
plt.show()

# (2) 같은 값을 네 영역에 담는다. 넓이 비중은 불변, 모양은 달라진다.
tot = sum(v)
print(f"{'영역':>12}{'넓이 비중이 v/sum(v) 인가':>26}"
      f"{'가로세로비 중앙값':>20}{'최악':>9}{'가장 작은 타일':>14}")
for DX, DY in [(6.0, 4.0), (4.0, 6.0), (12.0, 2.0), (24.0, 1.0)]:
    RR = squarify(v, 0, 0, DX, DY)
    share = np.array([w * h / (DX * DY) for _, _, w, h in RR])
    ok = np.allclose(share, np.array(v, float) / tot)
    rho = np.array([max(w / h, h / w) for _, _, w, h in RR])
    print(f"{f'{DX:g} x {DY:g}':>12}{str(ok):>26}{np.median(rho):>20.2f}"
          f"{rho.max():>9.2f}{rho[-1]:>14.2f}")

# (1) 모자이크 타일은 네 수 모두 자료가 정한다.
n = tab.sum()
print("\n모자이크 타일의 네 수는 모두 자료가 정한다")
xx = 0.0
for i, row in enumerate(tab):
    w = row.sum() / n
    yy = 0.0
    for j, val in enumerate(row):
        h = val / row.sum()
        print(f"  ({i},{j})  x={xx:.4f}  y={yy:.4f}  w={w:.4f}  h={h:.4f}"
              f"   넓이 {w*h:.4f} = 도수/n {val/n:.4f}")
        yy += h
    xx += w

          영역        넓이 비중이 v/sum(v) 인가           가로세로비 중앙값       최악      가장 작은 타일
       6 x 4                      True                1.50     2.78          2.78
       4 x 6                      True                1.50     2.78          2.78
      12 x 2                      True                1.50     4.00          4.00
      24 x 1                      True                3.00     6.00          1.00

모자이크 타일의 네 수는 모두 자료가 정한다
  (0,0)  x=0.0000  y=0.0000  w=0.4735  h=0.2240   넓이 0.1061 = 도수/n 0.1061
  (0,1)  x=0.0000  y=0.2240  w=0.4735  h=0.7760   넓이 0.3674 = 도수/n 0.3674
  (1,0)  x=0.4735  y=0.0000  w=0.5265  h=0.2518   넓이 0.1326 = 도수/n 0.1326
  (1,1)  x=0.4735  y=0.2518  w=0.5265  h=0.7482   넓이 0.3939 = 도수/n 0.3939

import numpy as np

tab = np.array([[28., 97.], [35., 104.]])      # SUV x 사고
n = tab.sum()

# (A) 모자이크를 정의대로 그린다: 열 너비 = 주변확률, 행 높이 = 조건부확률
mosaic = []
x = 0
for i, row in enumerate(tab):
    w = row.sum() / n                          # P(행)
    y = 0
    for j, v in enumerate(row):
        h = v / row.sum()                      # P(열 | 행)
        mosaic.append((i, j, x, y, w, h))
        y += h
    x += w

# (B) slice_dice 를 계층 2단계로 적용한다 (방향을 번갈아)
tm = []
lvl1 = slice_dice(tab.sum(1) / n, 0, 0, 1, 1, vertical=True)     # 1단계: 세로로 분할
for i, (gx, gy, gw, gh) in enumerate(lvl1):
    lvl2 = slice_dice(tab[i] / tab[i].sum(), gx, gy, gw, gh,
                      vertical=False)                            # 2단계: 가로로 분할
    for j, (x0, y0, w, h) in enumerate(lvl2):
        tm.append((i, j, x0, y0, w, h))

print(f"{'칸':>6s}{'모자이크 (x,y,w,h)':>34s}{'트리맵 (x,y,w,h)':>34s}{'차이':>10s}")
worst = 0.0
for (i, j, *a), (_, _, *b) in zip(mosaic, tm):
    dmax = max(abs(p - q) for p, q in zip(a, b))
    worst = max(worst, dmax)
    fa = "(%.4f,%.4f,%.4f,%.4f)" % tuple(a)
    fb = "(%.4f,%.4f,%.4f,%.4f)" % tuple(b)
    print(f"{f'({i},{j})':>6s}{fa:>34s}{fb:>34s}{dmax:>10.2e}")

print(f"\n두 방식의 최대 좌표 차이 {worst:.3e}")
print("넓이가 도수/n 과 일치하는가:",
      all(abs(w * h - tab[i, j] / n) < 1e-12 for i, j, _, _, w, h in tm))

     칸                    모자이크 (x,y,w,h)                     트리맵 (x,y,w,h)        차이
 (0,0)     (0.0000,0.0000,0.4735,0.2240)     (0.0000,0.0000,0.4735,0.2240)  0.00e+00
 (0,1)     (0.0000,0.2240,0.4735,0.7760)     (0.0000,0.2240,0.4735,0.7760)  0.00e+00
 (1,0)     (0.4735,0.0000,0.5265,0.2518)     (0.4735,0.0000,0.5265,0.2518)  0.00e+00
 (1,1)     (0.4735,0.2518,0.5265,0.7482)     (0.4735,0.2518,0.5265,0.7482)  0.00e+00

두 방식의 최대 좌표 차이 0.000e+00
넓이가 도수/n 과 일치하는가: True

import warnings
warnings.filterwarnings("ignore")

import os
import numpy as np
import pandas as pd
import yfinance as yf

# 11개 업종에서 대형주를 골랐다. 실제 지수 지도는 500종목을 쓰지만
# 구조는 같고, 여기서는 내려받는 부담을 줄였다.
SECTORS = {
    "Technology": ["AAPL", "MSFT", "NVDA", "AVGO", "ORCL",
                   "CRM", "AMD", "ADBE", "CSCO", "ACN"],
    "Communication Services": ["GOOGL", "META", "NFLX", "DIS", "TMUS", "CMCSA"],
    "Consumer Discretionary": ["AMZN", "TSLA", "HD", "MCD", "NKE", "LOW", "SBUX"],
    "Financials": ["BRK-B", "JPM", "V", "MA", "BAC", "WFC", "GS", "AXP"],
    "Healthcare": ["LLY", "UNH", "JNJ", "ABBV", "MRK", "TMO", "ABT", "PFE"],
    "Consumer Staples": ["WMT", "COST", "PG", "KO", "PEP", "PM"],
    "Industrials": ["GE", "CAT", "RTX", "UNP", "HON", "BA", "UPS"],
    "Energy": ["XOM", "CVX", "COP", "SLB"],
    "Utilities": ["NEE", "SO", "DUK"],
    "Real Estate": ["PLD", "AMT", "EQIX"],
    "Materials": ["LIN", "SHW", "APD"],
}
CACHE = "datasets/stocks/sp_big.csv"

# 한 번 받은 자료를 저장해 두고 다시 쓴다.
# 실행 시점마다 값이 달라지면 아래 출력이 재현되지 않기 때문이다.
d = pd.read_csv(CACHE)

d["mcap"] = d["shares"] * d["close_last"]             # 시가총액
d["chg"] = (d["close_last"] / d["close_prev"] - 1) * 100   # 일별 등락률 (%)
d["w"] = d["mcap"] / d["mcap"].sum()                  # 넓이 비중

print(f"종목 {len(d)}개, 업종 {d['sector'].nunique()}개")
print(f"기간 {d['date_prev'].iloc[0]} -> {d['date_last'].iloc[0]}\n")

s = d.sort_values("mcap", ascending=False)
cum = s["w"].cumsum().to_numpy()
print("넓이가 몇 종목에 몰려 있나")
for k in [1, 3, 5, 10, 20]:
    print(f"  상위 {k:2d}종목 누적 비중 {cum[k - 1]:.4f}")
print(f"  절반을 넘기는 데 필요한 종목 수 {int(np.argmax(cum >= 0.5)) + 1}\n")

print(f"가장 큰 칸 {s.iloc[0]['ticker']}: 비중 {s.iloc[0]['w']:.4f}")
print(f"가장 작은 칸 {s.iloc[-1]['ticker']}: 비중 {s.iloc[-1]['w']:.4f}")
print(f"넓이 비 {s.iloc[0]['w'] / s.iloc[-1]['w']:.1f}배")

# (1) 넓이 비는 변 길이에서 제곱근으로 압축된다.
AX, AY = 100.0, 62.0                      # 보기 6 이 쓰는 영역
A = AX * AY
ratio = s.iloc[0]["w"] / s.iloc[-1]["w"]
print(f"  변 길이 비 sqrt(넓이 비) = {np.sqrt(ratio):.2f}배")
print(f"  정사각형이라면 한 변: 가장 큰 칸 {np.sqrt(s.iloc[0]['w']*A):.2f}, "
      f"가장 작은 칸 {np.sqrt(s.iloc[-1]['w']*A):.2f} 단위")

# (2) 이름표 문턱 — 넓이 45 미만에는 글씨를 넣지 않는다.
THR = 45.0
big = s["w"] * A > THR
print(f"\n전체 넓이 {A:.0f},  이름표 문턱 {THR:.0f}  →  비중 {THR/A:.6f}")
print(f"이름표가 붙는 칸 {big.sum()}개 / {len(s)}개 ({big.mean():.1%}),"
      f"  그 넓이 합 {s.loc[big, 'w'].sum():.4f}")
print(f"이름 없는 칸 {(~big).sum()}개의 넓이 합 {s.loc[~big, 'w'].sum():.4f}")

# (3) 슬라이스-앤-다이스로 자르면 최악 가로세로비가 얼마인가.
print(f"\nslice-and-dice 최악 가로세로비 DY/(DX*p_min) = "
      f"{AY / (AX * s.iloc[-1]['w']):.1f}")

종목 65개, 업종 11개
기간 2026-08-31 -> 2026-09-01

넓이가 몇 종목에 몰려 있나
  상위  1종목 누적 비중 0.1220
  상위  3종목 누적 비중 0.3274
  상위  5종목 누적 비중 0.4777
  상위 10종목 누적 비중 0.6347
  상위 20종목 누적 비중 0.7832
  절반을 넘기는 데 필요한 종목 수 6

가장 큰 칸 NVDA: 비중 0.1220
가장 작은 칸 NKE: 비중 0.0013
넓이 비 93.0배
  변 길이 비 sqrt(넓이 비) = 9.64배
  정사각형이라면 한 변: 가장 큰 칸 27.50, 가장 작은 칸 2.85 단위

전체 넓이 6200,  이름표 문턱 45  →  비중 0.007258
이름표가 붙는 칸 31개 / 65개 (47.7%),  그 넓이 합 0.8771
이름 없는 칸 34개의 넓이 합 0.1229

slice-and-dice 최악 가로세로비 DY/(DX*p_min) = 472.7

import matplotlib.pyplot as plt
from matplotlib.colors import TwoSlopeNorm

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게


def nested_treemap(groups, x=0.0, y=0.0, dx=1.0, dy=1.0):
    """{그룹: [(이름, 값, 색값), ...]} 를 두 단계 트리맵으로 배치한다.

    1단계: 그룹의 값 합으로 전체를 나눈다.
    2단계: 각 그룹 칸 안에서 개별 항목을 다시 나눈다.
    """
    gtot = {g: sum(v for _, v, _ in items) for g, items in groups.items()}
    order = sorted(gtot, key=gtot.get, reverse=True)      # 큰 그룹부터
    gr = squarify([gtot[g] for g in order], x, y, dx, dy)
    out = []
    for g, (gx, gy, gw, gh) in zip(order, gr):
        items = sorted(groups[g], key=lambda z: -z[1])    # 그룹 안에서도 큰 것부터
        rr = squarify([v for _, v, _ in items], gx, gy, gw, gh)
        out.append((g, (gx, gy, gw, gh),
                    [(nm, v, c, r) for (nm, v, c), r in zip(items, rr)]))
    return out


groups = {s: [(r.ticker, r.mcap, r.chg) for r in g.itertuples()]
          for s, g in d.groupby("sector")}
layout = nested_treemap(groups, 0, 0, 100, 62)

# 색은 0을 가운데 두고 ±3%에서 자른다.
# 자르지 않으면 하루 -20% 같은 한 종목이 나머지 색을 전부 눌러 버린다.
CLIP = 3.0
norm = TwoSlopeNorm(vmin=-CLIP, vcenter=0.0, vmax=CLIP)
cmap = plt.get_cmap("RdYlGn")

fig, ax = plt.subplots(figsize=(13.5, 8.6))
for sec, (gx, gy, gw, gh), items in layout:
    for nm, v, c, (x0, y0, w, h) in items:
        ax.add_patch(plt.Rectangle((x0, y0), w, h,
                     facecolor=cmap(norm(np.clip(c, -CLIP, CLIP))),
                     edgecolor="white", linewidth=0.8))
        if w * h > 45:                       # 좁은 칸에는 글씨를 넣지 않는다
            ax.text(x0 + w / 2, y0 + h / 2 + 0.6, nm, ha="center", va="center",
                    fontsize=min(11, 5 + (w * h) ** 0.22), fontweight="bold")
            ax.text(x0 + w / 2, y0 + h / 2 - 1.3, f"{c:+.2f}%",
                    ha="center", va="center",
                    fontsize=min(9, 4 + (w * h) ** 0.19))
    ax.add_patch(plt.Rectangle((gx, gy), gw, gh, fill=False,
                 edgecolor="black", linewidth=2.2))
    SHORT = {"Technology": "기술", "Communication Services": "통신 서비스",
             "Consumer Discretionary": "경기소비재", "Consumer Staples": "필수소비재",
             "Financials": "금융", "Healthcare": "헬스케어",
             "Industrials": "산업재", "Energy": "에너지",
             "Utilities": "유틸리티", "Real Estate": "부동산", "Materials": "소재"}
    lab = SHORT.get(sec, sec)
    if gw < 12:
        lab = lab[:5]
    ax.text(gx + 0.5, gy + gh - 1.2, lab, fontsize=8.2, fontweight="bold",
            va="top", ha="left", clip_on=True,
            bbox=dict(boxstyle="square,pad=0.15", fc="white", ec="none", alpha=0.85))

ax.set_xlim(0, 100); ax.set_ylim(0, 62)
ax.set_xticks([]); ax.set_yticks([]); ax.set_aspect("equal")
sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm); sm.set_array([])
cb = fig.colorbar(sm, ax=ax, fraction=0.03, pad=0.01)
cb.set_label(f"일별 등락률 (%), ±{CLIP:.0f}%에서 자름")
ax.set_title("미국 대형주 65종목: 넓이 = 시가총액, 색 = 일별 등락률\n"
             f"{d['date_prev'].iloc[0]} → {d['date_last'].iloc[0]}", fontsize=12)
fig.tight_layout()
plt.show()

# (1) 잎 칸의 넓이는 계층과 무관하다. 평평한 배치와 맞대어 본다.
A = 100.0 * 62.0
leaf = {nm: w * h for _, _, items in layout for nm, v, c, (_, _, w, h) in items}
flat_v = d.sort_values("mcap", ascending=False)
flat = squarify(flat_v["mcap"].tolist(), 0, 0, 100.0, 62.0)
flat_area = {t: w * h for t, (_, _, w, h) in zip(flat_v["ticker"], flat)}
print(f"중첩 배치 대 평평한 배치, 잎 넓이 최대 차이 "
      f"{max(abs(leaf[t] - flat_area[t]) for t in flat_area):.3e}")
print(f"중첩 배치 대 A*w, 최대 차이 "
      f"{max(abs(leaf[r.ticker] - A * r.w) for r in d.itertuples()):.3e}")
print(f"잎 넓이의 합 {sum(leaf.values()):.6f}   전체 넓이 {A:.0f}")

print(f"\n{'업종':>24}{'1단계 칸 넓이':>15}{'잎 넓이 합':>13}{'비중':>9}")
for sec, (gx, gy, gw, gh), items in layout:
    sa = sum(w * h for _, _, _, (_, _, w, h) in items)
    print(f"{sec:>24}{gw*gh:>15.2f}{sa:>13.2f}{gw*gh/A:>9.4f}")

# (2) 색 자르기가 깎는 종목
clipped = d.loc[d["chg"].abs() > CLIP].sort_values("chg")
print(f"\n등락률 범위 {d['chg'].min():+.2f}% ~ {d['chg'].max():+.2f}%")
print(f"±{CLIP:.0f}% 에서 색이 깎이는 종목 {len(clipped)}개")
for r in clipped.itertuples():
    print(f"  {r.ticker:>5}{r.chg:>+8.2f}%   넓이 비중 {r.w:.4f}")
print(f"  음수 {(clipped['chg'] < 0).sum()}개, 양수 {(clipped['chg'] > 0).sum()}개")

중첩 배치 대 평평한 배치, 잎 넓이 최대 차이 1.137e-13
중첩 배치 대 A*w, 최대 차이 1.137e-13
잎 넓이의 합 6200.000000   전체 넓이 6200

                      업종       1단계 칸 넓이       잎 넓이 합       비중
              Technology        2522.50      2522.50   0.4069
  Communication Services         918.97       918.97   0.1482
  Consumer Discretionary         712.96       712.96   0.1150
              Financials         638.30       638.30   0.1030
              Healthcare         496.39       496.39   0.0801
        Consumer Staples         354.09       354.09   0.0571
             Industrials         211.35       211.35   0.0341
                  Energy         193.21       193.21   0.0312
               Materials          53.65        53.65   0.0087
               Utilities          53.03        53.03   0.0086
             Real Estate          45.54        45.54   0.0073

등락률 범위 -5.23% ~ +2.79%
±3% 에서 색이 깎이는 종목 4개
   ORCL   -5.23%   넓이 비중 0.0095
    SLB   -4.91%   넓이 비중 0.0020
    UNP   -3.34%   넓이 비중 0.0040
   TSLA   -3.22%   넓이 비중 0.0327
  음수 4개, 양수 0개

up = (d["chg"] > 0).sum()
print(f"오른 종목 {up}개 / {len(d)}개  ({up / len(d):.1%})")
print(f"넓이 기준 '초록' 비율      {d.loc[d['chg'] > 0, 'w'].sum():.4f}\n")

print(f"동일가중 평균 등락률  {d['chg'].mean():+.4f}%")
print(f"중앙값 등락률         {d['chg'].median():+.4f}%")
print(f"시총가중 평균 등락률  {(d['w'] * d['chg']).sum():+.4f}%   <- 지수가 재는 값")

print("\n업종별")
g = (d.groupby("sector")
     .apply(lambda x: pd.Series({
         "n": len(x),
         "시총비중": x["mcap"].sum() / d["mcap"].sum(),
         "시총가중등락": (x["mcap"] * x["chg"]).sum() / x["mcap"].sum(),
         "동일가중등락": x["chg"].mean()})))
print(g.sort_values("시총비중", ascending=False).round(4).to_string())

# (1) 두 평균의 차는 비중과 등락률의 공분산이다.
K = len(d)
w = d["w"].to_numpy()
r = d["chg"].to_numpy()
eq, wt = r.mean(), (w * r).sum()
print(f"\n시총가중 - 동일가중     = {wt - eq:+.6f}")
print(f"sum (w - 1/K)(r - rbar) = {np.sum((w - 1/K) * (r - eq)):+.6f}")

# 업종 안에서도 같은 항등식이 성립한다.
print(f"\n{'업종':>24}{'n':>4}{'시총가중':>10}{'동일가중':>10}{'차':>10}{'공분산 항':>11}")
for sec, gg in d.groupby("sector"):
    u = gg["mcap"].to_numpy() / gg["mcap"].sum()
    rr = gg["chg"].to_numpy()
    k = len(gg)
    print(f"{sec:>24}{k:>4}{(u*rr).sum():>+10.4f}{rr.mean():>+10.4f}"
          f"{(u*rr).sum()-rr.mean():>+10.4f}"
          f"{np.sum((u - 1/k) * (rr - rr.mean())):>+11.4f}")

# (3) 넓이 기준 '초록' 비율은 부호만 보고 크기를 버린다.
print(f"\n초록 넓이 비율 {w[r>0].sum():.4f},  초록 칸 비율 {(r>0).mean():.4f}")
print(f"초록 칸의 넓이가중 기여 {np.sum(w[r>0]*r[r>0]):+.4f}, "
      f"빨강 칸의 기여 {np.sum(w[r<0]*r[r<0]):+.4f},  합 {wt:+.4f}")

오른 종목 21개 / 65개  (32.3%)
넓이 기준 '초록' 비율      0.3077

동일가중 평균 등락률  -0.7008%
중앙값 등락률         -0.7556%
시총가중 평균 등락률  -0.4801%   <- 지수가 재는 값

업종별
                           n    시총비중  시총가중등락  동일가중등락
sector
Technology              10.0  0.4069 -0.2835 -1.1534
Communication Services   6.0  0.1482 -0.6088 -0.3291
Consumer Discretionary   7.0  0.1150 -2.2272 -1.8919
Financials               8.0  0.1030 -0.7700 -0.8813
Healthcare               8.0  0.0801  0.7573  0.4006
Consumer Staples         6.0  0.0571  0.2192  0.0181
Industrials              7.0  0.0341 -1.7872 -1.7773
Energy                   4.0  0.0312  1.8985  0.6257
Materials                3.0  0.0087 -1.1535 -1.5096
Utilities                3.0  0.0086  0.4668  0.4064
Real Estate              3.0  0.0073 -0.6109 -0.6057

시총가중 - 동일가중     = +0.220770
sum (w - 1/K)(r - rbar) = +0.220770

                      업종   n      시총가중      동일가중         차      공분산 항
  Communication Services   6   -0.6088   -0.3291   -0.2797    -0.2797
  Consumer Discretionary   7   -2.2272   -1.8919   -0.3353    -0.3353
        Consumer Staples   6   +0.2192   +0.0181   +0.2011    +0.2011
                  Energy   4   +1.8985   +0.6257   +1.2728    +1.2728
              Financials   8   -0.7700   -0.8813   +0.1113    +0.1113
              Healthcare   8   +0.7573   +0.4006   +0.3567    +0.3567
             Industrials   7   -1.7872   -1.7773   -0.0099    -0.0099
               Materials   3   -1.1535   -1.5096   +0.3561    +0.3561
             Real Estate   3   -0.6109   -0.6057   -0.0052    -0.0052
              Technology  10   -0.2835   -1.1534   +0.8699    +0.8699
               Utilities   3   +0.4668   +0.4064   +0.0605    +0.0605

초록 넓이 비율 0.3077,  초록 칸 비율 0.3231
초록 칸의 넓이가중 기여 +0.5148, 빨강 칸의 기여 -0.9949,  합 -0.4801

눈은 칸의 '개수'를 센다        -> 32.3% 초록 -> "많이 내린 날"
지수는 칸의 '넓이'로 평균낸다   -> -0.48%    -> "조금 내린 날"

트리맵은 넓이를 보여 주지만
사람은 개수를 세는 쪽으로 기운다

import numpy as np

def check(values, dx=10.0, dy=6.0, tol=1e-9):
    """트리맵 배치의 세 가지 성질을 검사한다."""
    v = sorted(values, reverse=True)
    R = squarify(v, 0, 0, dx, dy)
    total = sum(v)

    # (1) 각 사각형의 넓이가 값에 비례하는가
    err = max(abs(w * h - val * dx * dy / total) for val, (_, _, w, h) in zip(v, R))

    # (2) 넓이의 합이 전체 넓이와 같은가
    cover = abs(sum(w * h for _, _, w, h in R) - dx * dy)

    # (3) 서로 겹치는 쌍이 있는가 (넓이 기준)
    ov = 0.0
    for i in range(len(R)):
        xi, yi, wi, hi = R[i]
        for j in range(i + 1, len(R)):
            xj, yj, wj, hj = R[j]
            ox = max(0, min(xi + wi, xj + wj) - max(xi, xj))
            oy = max(0, min(yi + hi, yj + hj) - max(yi, yj))
            ov = max(ov, ox * oy)

    return err, cover, ov

rng = np.random.default_rng(0)
cases = {
    "보기 1의 값": [6, 6, 4, 3, 2, 2, 1],
    "모두 같은 값": [5] * 12,
    "극단적 편중": [1000, 1, 1, 1, 1],
    "무작위 50개": list(rng.random(50) * 100 + 0.1),
    "한 개뿐": [7],
}
print(f"{'경우':>14s}{'넓이 오차':>12s}{'덮기 오차':>12s}{'최대 겹침':>12s}")
for lab, vals in cases.items():
    e, c, o = check(vals)
    print(f"{lab:>14s}{e:>12.2e}{c:>12.2e}{o:>12.2e}")

            경우       넓이 오차       덮기 오차       최대 겹침
       보기 1의 값    0.00e+00    0.00e+00    0.00e+00
       모두 같은 값    0.00e+00    0.00e+00    0.00e+00
        극단적 편중    0.00e+00    0.00e+00    0.00e+00
       무작위 50개    2.22e-16    7.11e-15    0.00e+00
          한 개뿐    0.00e+00    0.00e+00    0.00e+00

import numpy as np

BETA = 0.7
print("실제 넓이 비 -> 사람이 느끼는 비 (지수 0.7)")
print(f"{'실제 비':>9s}{'지각된 비':>11s}{'과소평가':>10s}")
for r in [1.5, 2, 3, 5, 10, 50, 93]:
    perceived = r ** BETA
    print(f"{r:>9.1f}{perceived:>11.2f}{1 - perceived / r:>10.1%}")

print("\n길이(막대그림)는 지수가 1.0 에 가까워 왜곡이 거의 없다")
for r in [2, 10, 93]:
    print(f"  실제 {r:>4.0f}배 -> 넓이로 보면 {r**0.7:>6.2f}배, "
          f"길이로 보면 {r**1.0:>6.2f}배")

실제 넓이 비 -> 사람이 느끼는 비 (지수 0.7)
     실제 비      지각된 비      과소평가
      1.5       1.33     11.5%
      2.0       1.62     18.8%
      3.0       2.16     28.1%
      5.0       3.09     38.3%
     10.0       5.01     49.9%
     50.0      15.46     69.1%
     93.0      23.87     74.3%

길이(막대그림)는 지수가 1.0 에 가까워 왜곡이 거의 없다
  실제    2배 -> 넓이로 보면   1.62배, 길이로 보면   2.00배
  실제   10배 -> 넓이로 보면   5.01배, 길이로 보면  10.00배
  실제   93배 -> 넓이로 보면  23.87배, 길이로 보면  93.00배

import numpy as np

rng = np.random.default_rng(7)
# 시가총액처럼 '몇 개가 아주 크고 대부분 작은' 편중된 값을 쓴다.
# 값이 고르면 정렬 효과가 드러나지 않는다.
vals = list(np.round(rng.pareto(1.1, 16) * 10 + 1, 1))

orders = {
    "내림차순 (표준)": sorted(vals, reverse=True),
    "오름차순": sorted(vals),
    "무작위 A": list(rng.permutation(vals)),
    "무작위 B": list(rng.permutation(vals)),
}

print(f"{'정렬':>16s}{'가로세로비 중앙값':>17s}{'최악':>9s}{'넓이 합':>10s}")
layouts = {}
for lab, v in orders.items():
    R = squarify(v, 0, 0, 10, 6)
    layouts[lab] = (v, R)
    rt = [max(w / h, h / w) for _, _, w, h in R]
    print(f"{lab:>16s}{np.median(rt):>17.3f}{max(rt):>9.2f}"
          f"{sum(w * h for _, _, w, h in R):>10.4f}")

# 같은 값이 어디에 놓였는지 비교한다.
big = max(vals)
print(f"\n가장 큰 값 {big} 이 놓인 자리")
for lab, (v, R) in layouts.items():
    i = v.index(big)
    x, y, w, h = R[i]
    print(f"  {lab:>16s}: ({x:5.2f}, {y:5.2f}) 크기 {w:5.2f} x {h:5.2f}")

              정렬        가로세로비 중앙값       최악      넓이 합
       내림차순 (표준)            1.365     2.92   60.0000
            오름차순            1.303     3.30   60.0000
           무작위 A            1.754     5.75   60.0000
           무작위 B            1.651     6.26   60.0000

가장 큰 값 207.7 이 놓인 자리
         내림차순 (표준): ( 0.00,  0.00) 크기  4.29 x  6.00
              오름차순: ( 5.71,  0.00) 크기  4.29 x  6.00
             무작위 A: ( 1.78,  0.00) 크기  4.29 x  6.00
             무작위 B: ( 4.07,  0.00) 크기  5.93 x  4.35

자리를 고정하는 배치
  - 업종 순서를 알파벳순 등으로 고정
  - 업종 안에서도 종목 순서를 고정
  - 넓이만 매일 바꾼다

-> 사각형 크기는 변하지만 '어디에 있는지'는 유지된다
-> 시간에 따른 비교가 가능해진다

import numpy as np
import pandas as pd

# 보기 5의 실제 시가총액 분포를 그대로 쓰고 등락률만 바꿔 본다.
w = d["w"].to_numpy()
order = np.argsort(-w)                 # 큰 것부터

def summarize(chg, w):
    return dict(오른종목비율=(chg > 0).mean(),
                초록넓이=w[chg > 0].sum(),
                동일가중=chg.mean(),
                시총가중=(w * chg).sum())

scenarios = {}

# (가) 상위 3종목만 크게 오르고 나머지는 전부 소폭 하락
c = np.full(len(w), -0.5)
c[order[:3]] = +6.0
scenarios["상위 3종목만 상승"] = c.copy()

# (나) 상위 1종목만 폭등
c = np.full(len(w), -0.8)
c[order[0]] = +15.0
scenarios["상위 1종목만 폭등"] = c.copy()

# (다) 반대 방향: 소형주만 오르고 대형주가 내림
c = np.full(len(w), +2.0)
c[order[:5]] = -3.0
scenarios["소형주만 상승"] = c.copy()

# (라) 실제 자료
scenarios["실제 (2026-09-01)"] = d["chg"].to_numpy()

print(f"{'시나리오':>20s}{'오른 종목':>10s}{'초록 넓이':>10s}"
      f"{'동일가중':>10s}{'시총가중':>10s}{'어긋남':>8s}")
for lab, c in scenarios.items():
    s = summarize(c, w)
    clash = "예" if np.sign(s["동일가중"]) != np.sign(s["시총가중"]) else "아니오"
    print(f"{lab:>20s}{s['오른종목비율']:>10.1%}{s['초록넓이']:>10.3f}"
          f"{s['동일가중']:>+10.3f}{s['시총가중']:>+10.3f}{clash:>8s}")

                시나리오     오른 종목     초록 넓이      동일가중      시총가중     어긋남
          상위 3종목만 상승      4.6%     0.327    -0.200    +1.628       예
          상위 1종목만 폭등      1.5%     0.122    -0.557    +1.127       예
             소형주만 상승     92.3%     0.522    +1.615    -0.389       예
     실제 (2026-09-01)     32.3%     0.308    -0.701    -0.480     아니오

e = d[d["sector"] == "Energy"].sort_values("mcap", ascending=False)
e = e.assign(비중_업종내=e["mcap"] / e["mcap"].sum())
print(e[["ticker", "mcap", "chg", "비중_업종내"]].round(4).to_string(index=False))

contrib = (e["비중_업종내"] * e["chg"])
print(f"\n{'종목':>7s}{'등락률':>9s}{'업종내 비중':>11s}{'기여도':>10s}")
for t, c, wt, k in zip(e["ticker"], e["chg"], e["비중_업종내"], contrib):
    print(f"{t:>7s}{c:>+9.4f}{wt:>11.4f}{k:>+10.5f}")
print(f"{'합계':>7s}{'':>9s}{e['비중_업종내'].sum():>11.4f}{contrib.sum():>+10.5f}")
print(f"\n동일가중 평균 {e['chg'].mean():+.4f}%")
print(f"시총가중 평균 {contrib.sum():+.6f}%")