계단 그림과 면적 그림¶

import numpy as np
import matplotlib.pyplot as plt

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

years = np.arange(2015, 2025)
rate = np.array([1.50, 1.25, 1.50, 1.75, 1.25, 0.50, 0.50, 3.25, 3.50, 3.50])

fig, (a, b) = plt.subplots(1, 2, figsize=(12, 3.8))

# (1) 잘못된 방법: 직선으로 잇는다.
#     2021 -> 2022 구간이 서서히 오른 것처럼 보이지만 실제로는 계단이다.
a.plot(years, rate, '-o', color='gray', alpha=.5, label='직선 잇기 (틀림)')

# (2) 옳은 방법: 계단으로 그린다.
#     where='post' 는 "이 점의 값이 다음 점까지 유지된다"는 뜻이다.
#       'post' : 값이 그 시점부터 유지 (금리, 요금표 등에 맞다)
#       'pre'  : 값이 그 시점까지 유지
#       'mid'  : 두 점의 중간에서 바뀜
a.step(years, rate, where='post', color='crimson', lw=2, label='계단 (맞음)')

a.set_title("기준금리 — 계단과 직선")
a.set_xlabel("연도")
a.set_ylabel("금리 (%)")
a.legend()

# --- 오른쪽: 누적 면적 그림 ---
cats = ['제품 A', '제품 B', '제품 C']
vals = np.array([[10, 12, 14, 15, 18, 20, 22, 25, 27, 30],
                 [ 5,  6,  8,  9,  9, 10, 12, 13, 15, 16],
                 [20, 19, 18, 16, 15, 13, 12, 10,  9,  8]])

# stackplot은 계열을 아래에서부터 차곡차곡 쌓는다.
# 맨 위 경계선이 곧 전체 합계가 된다.
b.stackplot(years, vals, labels=cats, alpha=.85)
b.set_title("누적 면적 — 매출 구성")
b.set_xlabel("연도")
b.set_ylabel("매출")
b.legend(loc='upper left', fontsize=8)

for ax in (a, b):
    ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

dt = np.diff(years).astype(float)
dy = np.diff(rate)
A_post = np.sum(rate[:-1] * dt)                        # 계단 'post' 아래
A_pre = np.sum(rate[1:] * dt)                          # 계단 'pre' 아래
A_trap = np.sum((rate[:-1] + rate[1:]) / 2 * dt)       # 직선(사다리꼴) 아래
print(f"계단(post) 아래 면적 = {A_post:7.4f} %·년")
print(f"계단(pre)  아래 면적 = {A_pre:7.4f} %·년")
print(f"사다리꼴   아래 면적 = {A_trap:7.4f} %·년")
print(f"차 (사다리꼴 - post)       = {A_trap - A_post:.4f}")
print(f"공식 (1/2) sum dy_i dt_i   = {0.5 * np.sum(dy * dt):.4f}")
print(f"등간격이면 (y_끝 - y_처음)/2 = {(rate[-1] - rate[0]) / 2:.4f}")
print(f"(post + pre)/2             = {(A_post + A_pre) / 2:.4f}")
T = years[-1] - years[0]
print(f"평균 금리: 계단 {A_post / T:.4f}%,  직선 {A_trap / T:.4f}%  "
      f"(상대오차 {100 * (A_trap / A_post - 1):+.2f}%)")

# 누적 면적에서 C 의 두 경계는 C 자체와 아무 관계가 없다.
cum = np.cumsum(vals, axis=0)
print(f"\n제품 C 자체의 기울기         = {(vals[2, -1] - vals[2, 0]) / 9:+.4f} /년")
print(f"제품 C 띠의 아래 경계 기울기 = {(cum[1, -1] - cum[1, 0]) / 9:+.4f} /년")
print(f"제품 C 띠의 위  경계 기울기 = {(cum[2, -1] - cum[2, 0]) / 9:+.4f} /년")

fig, (a, b) = plt.subplots(1, 2, figsize=(12, 3.8))

# 왼쪽: 두 면적의 차이를 부호별로 칠한다.
g = np.linspace(years[0], years[-1], 4000)
step_g = rate[np.clip(np.searchsorted(years, g, side="right") - 1, 0, len(years) - 1)]
line_g = np.interp(g, years, rate)
up = 0.5 * np.sum(np.maximum(dy, 0) * dt)      # 직선이 계단보다 위인 몫
dn = 0.5 * np.sum(np.minimum(dy, 0) * dt)      # 아래인 몫
print(f"\n직선이 계단보다 위인 넓이 = {up:+.4f},  아래인 넓이 = {dn:+.4f},  "
      f"합 = {up + dn:+.4f}")
a.fill_between(g, step_g, 0, color="#DCEBFB", zorder=0)
a.fill_between(g, step_g, line_g, where=line_g >= step_g, color="#FFE0B2",
               zorder=1, label=f"직선이 위 {up:+.2f}")
a.fill_between(g, step_g, line_g, where=line_g < step_g, color="#C5E1A5",
               zorder=1, label=f"직선이 아래 {dn:+.2f}")
a.plot(np.repeat(years, 2)[1:], np.repeat(rate, 2)[:-1], color="#1565C0", lw=2,
       zorder=2, label=f"계단 아래 = {A_post:.2f}")
a.plot(years, rate, "-o", color="#D32F2F", lw=1.6, ms=4, zorder=3,
       label=f"직선 아래 = {A_trap:.2f}")
a.set_ylim(0, 4.3)
a.set_xlabel("연도")
a.set_ylabel("금리 (%)")
a.set_title("계단 아래와 직선 아래의 면적 차", fontsize=11)
a.legend(fontsize=8, loc="upper left", ncol=2)

# 오른쪽: 누적 면적에서 C 의 두 경계와 C 자체
b.stackplot(years, vals, labels=["제품 A", "제품 B", "제품 C"], alpha=.5,
            colors=["#C5E1A5", "#DCEBFB", "#FFE0B2"])
b.plot(years, cum[1], color="#E65100", lw=2, ls="--", label="C 의 아래 경계")
b.plot(years, cum[2], color="#E65100", lw=2, label="C 의 위 경계")
b.plot(years, vals[2], color="#D32F2F", lw=2.4, label="C 자체 (두께)")
b.set_xlabel("연도")
b.set_ylabel("매출")
b.set_title("두 경계는 오르는데 C 는 줄어든다", fontsize=11)
b.legend(fontsize=8, loc="upper left", ncol=2)

for ax in (a, b):
    ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

계단(post) 아래 면적 = 15.0000 %·년
계단(pre)  아래 면적 = 17.0000 %·년
사다리꼴   아래 면적 = 16.0000 %·년
차 (사다리꼴 - post)       = 1.0000
공식 (1/2) sum dy_i dt_i   = 1.0000
등간격이면 (y_끝 - y_처음)/2 = 1.0000
(post + pre)/2             = 16.0000
평균 금리: 계단 1.6667%,  직선 1.7778%  (상대오차 +6.67%)

제품 C 자체의 기울기         = -1.3333 /년
제품 C 띠의 아래 경계 기울기 = +3.4444 /년
제품 C 띠의 위  경계 기울기 = +2.1111 /년

직선이 계단보다 위인 넓이 = +1.7500,  아래인 넓이 = -0.7500,  합 = +1.0000

import numpy as np
import matplotlib.pyplot as plt

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

years = np.arange(2015, 2025)
vals = np.array([[10, 12, 14, 15, 18, 20, 22, 25, 27, 30],
                 [ 5,  6,  8,  9,  9, 10, 12, 13, 15, 16],
                 [20, 19, 18, 16, 15, 13, 12, 10,  9,  8]])

# 각 열(연도)의 합으로 나누어 100%로 정규화한다
pct = vals / vals.sum(axis=0) * 100

fig, ax = plt.subplots(figsize=(6, 3.8))
ax.stackplot(years, pct, labels=['제품 A', '제품 B', '제품 C'], alpha=.85)
ax.set_ylim(0, 100)
ax.set_xlabel("연도")
ax.set_ylabel("점유율 (%)")
ax.legend(loc='center left', bbox_to_anchor=(1.0, 0.5))
plt.tight_layout()
plt.show()

print("A의 점유율:", (pct[0]).round(1))
print("C의 점유율:", (pct[2]).round(1))

A의 점유율: [28.6 32.4 35.  37.5 42.9 46.5 47.8 52.1 52.9 55.6]
C의 점유율: [57.1 51.4 45.  40.  35.7 30.2 26.1 20.8 17.6 14.8]

S = vals.sum(axis=0)
g_tot = S[-1] / S[0]
print(f"전체 합계 {S[0]} -> {S[-1]},  배수 {g_tot:.4f}")
print(f"{'계열':<6}{'매출 배수':>10}{'/ 전체 배수':>13}"
      f"{'= 예측 점유율 배수':>19}{'실제 점유율 배수':>18}")
for k, nm in enumerate("ABC"):
    gk = vals[k, -1] / vals[k, 0]
    print(f"{nm:<6}{gk:>10.4f}{g_tot:>13.4f}{gk / g_tot:>19.4f}"
          f"{pct[k, -1] / pct[k, 0]:>18.4f}")

# 매출이 한 해도 변하지 않은 제품 D 를 끼워 넣는다.
D = np.full(10, 10.0)
vals4 = np.vstack([vals, D])
pct4 = vals4 / vals4.sum(axis=0) * 100
print(f"\n제품 D 매출: {D[0]:.0f} -> {D[-1]:.0f}  (한 번도 바뀌지 않음)")
print(f"제품 D 점유율: {pct4[3,0]:.3f}% -> {pct4[3,-1]:.3f}%   "
      f"(배수 {pct4[3,-1]/pct4[3,0]:.4f})")
S4 = vals4.sum(axis=0)
print(f"예측 배수 = S(처음)/S(끝) = {S4[0]:.0f}/{S4[-1]:.0f} = {S4[0]/S4[-1]:.4f}")
print(f"점유율 변화량 합 = {np.sum(pct4[:,-1]-pct4[:,0]):+.4f} (0 이어야 한다)")

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 3.8))
ax1.stackplot(years, vals4, labels=['제품 A', '제품 B', '제품 C', '제품 D (고정)'],
              alpha=.85, colors=["#C5E1A5", "#DCEBFB", "#FFE0B2", "#CE93D8"])
ax1.set_title("절대 매출 — D 는 10 으로 고정", fontsize=11)
ax1.set_xlabel("연도")
ax1.set_ylabel("매출")
ax1.legend(loc='upper left', fontsize=8, ncol=2)
ax2.stackplot(years, pct4, labels=['제품 A', '제품 B', '제품 C', '제품 D (고정)'],
              alpha=.85, colors=["#C5E1A5", "#DCEBFB", "#FFE0B2", "#CE93D8"])
ax2.set_ylim(0, 100)
ax2.set_title("100% 누적 — D 의 몫이 줄어든다", fontsize=11)
ax2.set_xlabel("연도")
ax2.set_ylabel("점유율 (%)")
ax2.annotate(f"D = {pct4[3,0]:.1f}%", xy=(years[0], 100 - pct4[3, 0] / 2),
             xytext=(years[0] + 0.3, 92), fontsize=9, color="#6A1B9A")
ax2.annotate(f"D = {pct4[3,-1]:.1f}%", xy=(years[-1], 100 - pct4[3, -1] / 2),
             xytext=(years[-1] - 2.3, 92), fontsize=9, color="#6A1B9A")
for ax in (ax1, ax2):
    ax.spines[['top','right']].set_visible(False)
plt.tight_layout()
plt.show()

전체 합계 35 -> 54,  배수 1.5429
계열         매출 배수      / 전체 배수        = 예측 점유율 배수         실제 점유율 배수
A         3.0000       1.5429             1.9444            1.9444
B         3.2000       1.5429             2.0741            2.0741
C         0.4000       1.5429             0.2593            0.2593

제품 D 매출: 10 -> 10  (한 번도 바뀌지 않음)
제품 D 점유율: 22.222% -> 15.625%   (배수 0.7031)
예측 배수 = S(처음)/S(끝) = 45/64 = 0.7031
점유율 변화량 합 = +0.0000 (0 이어야 한다)

import numpy as np
import matplotlib.pyplot as plt

x = np.sort([2, 3, 3, 7, 9])
n = len(x)
xs = np.concatenate([[x[0] - 1], x])          # 왼쪽 끝을 0으로 시작하기 위해
ys = np.concatenate([[0], np.arange(1, n + 1) / n])
plt.step(xs, ys, where='post')

import numpy as np
import matplotlib.pyplot as plt

x = np.array([2, 3, 3, 7, 9], float)
xs = np.sort(x)
n = len(xs)
F = np.arange(1, n + 1) / n

print(f"자료 {xs}")
print(f"{'x':>6}{'F(x) 참값':>12}")
for q in (1.9, 2.0, 2.5, 3.0, 6.9, 7.0):
    print(f"{q:>6.1f}{np.mean(xs <= q):>12.4f}")

fig, axes = plt.subplots(1, 3, figsize=(13, 3.6), sharey=True)
for ax, w in zip(axes, ["pre", "post", "mid"]):
    ax.step(xs, F, where=w, lw=2)
    ax.plot(xs, F, "o", ms=5, color="C3")
    ax.set_title(f'where="{w}"', fontsize=10)
    ax.set_ylim(-0.05, 1.05)
fig.tight_layout()
plt.show()

자료 [2. 3. 3. 7. 9.]
     x     F(x) 참값
   1.9      0.0000
   2.0      0.2000
   2.5      0.2000
   3.0      0.6000
   6.9      0.6000
   7.0      0.8000

import numpy as np
import matplotlib.pyplot as plt

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

t = np.arange(24)
a = 100 + 2.0 * t                       # 맨 아래 층: 꾸준히 증가
b = 60 + 1.2 * t
c = 40 + 0.5 * t
d = 30 + 0.2 * t                        # 관심 층: 거의 평평하다
e = 20 + 0.1 * t
layers = np.vstack([a, b, c, d, e])

print("각 층의 실제 증가율 (마지막 - 처음)")
for name, s in zip("ABCDE", layers):
    print(f"  {name}: {s[0]:.1f} → {s[-1]:.1f}   증가 {s[-1] - s[0]:+.1f}")
print(f"\nD 의 윗변(A+B+C+D) 은 {layers[:4, 0].sum():.1f} → {layers[:4, -1].sum():.1f}"
      f"   증가 {layers[:4, -1].sum() - layers[:4, 0].sum():+.1f}")
print("  → 윗변만 보면 D 가 급증한 것처럼 보이지만 실제 증가는 "
      f"{layers[3, -1] - layers[3, 0]:+.1f} 뿐이다")

fig, axes = plt.subplots(1, 2, figsize=(11, 4))
axes[0].stackplot(t, layers, labels=list("ABCDE"))
axes[0].legend(loc="upper left", fontsize=8)
axes[0].set_title("누적 면적 — D 층의 변화를 읽기 어렵다", fontsize=10)
for name, s in zip("ABCDE", layers):
    axes[1].plot(t, s, label=name)
axes[1].legend(fontsize=8)
axes[1].set_title("층을 따로 그리면 — D 는 거의 평평하다", fontsize=10)
fig.tight_layout()
plt.show()

각 층의 실제 증가율 (마지막 - 처음)
  A: 100.0 → 146.0   증가 +46.0
  B: 60.0 → 87.6   증가 +27.6
  C: 40.0 → 51.5   증가 +11.5
  D: 30.0 → 34.6   증가 +4.6
  E: 20.0 → 22.3   증가 +2.3

D 의 윗변(A+B+C+D) 은 230.0 → 319.7   증가 +89.7
  → 윗변만 보면 D 가 급증한 것처럼 보이지만 실제 증가는 +4.6 뿐이다

import numpy as np
import matplotlib.pyplot as plt

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

t = np.arange(20)
total = 100 * 1.12 ** t                      # 전체가 빠르게 성장
share_a = 0.55 - 0.004 * t                   # A 의 비중은 거의 그대로
a = total * share_a
b = total * (1 - share_a)

print(f"전체 {total[0]:.0f} → {total[-1]:,.0f}   ({total[-1]/total[0]:.1f}배)")
print(f"A   {a[0]:.0f} → {a[-1]:,.0f}   ({a[-1]/a[0]:.1f}배)")
print(f"A 의 비중 {share_a[0]:.3f} → {share_a[-1]:.3f}   (거의 변화 없음)")

fig, axes = plt.subplots(1, 2, figsize=(11, 4))
axes[0].stackplot(t, [a / total, b / total], labels=["A", "B"])
axes[0].legend(fontsize=8); axes[0].set_ylim(0, 1)
axes[0].set_title("100% 누적 — 아무 일도 없어 보인다", fontsize=10)
axes[1].stackplot(t, [a, b], labels=["A", "B"])
axes[1].legend(fontsize=8)
axes[1].set_title("절대량 — 둘 다 폭증했다", fontsize=10)
fig.tight_layout()
plt.show()

전체 100 → 861   (8.6배)
A   55 → 408   (7.4배)
A 의 비중 0.550 → 0.474   (거의 변화 없음)

import numpy as np
import matplotlib.pyplot as plt

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

# 사망 시점 (간단한 예: 검열 없음)
times = np.array([2, 5, 5, 9, 14, 20, 27, 31])
n = len(times)
uniq = np.unique(times)
surv = np.array([np.mean(times > u) for u in uniq])

print(f"관측 {n}명, 사망 시점 {times}")
print(f"{'t':>5}{'생존 인원':>10}{'S(t)':>9}")
for u, s in zip(uniq, surv):
    print(f"{u:>5}{int(s * n):>10}{s:>9.3f}")

fig, axes = plt.subplots(1, 2, figsize=(11, 4), sharey=True)
t_plot = np.concatenate([[0], uniq])
s_plot = np.concatenate([[1.0], surv])
axes[0].step(t_plot, s_plot, where="post", lw=2)
axes[0].set_title('계단 (where="post") — 옳다', fontsize=10)
axes[1].plot(t_plot, s_plot, "-o", lw=2, ms=4)
axes[1].set_title("선으로 이으면 — 틀리다", fontsize=10)
for ax in axes:
    ax.set_xlabel("시간"); ax.set_ylim(0, 1.05)
axes[0].set_ylabel("생존 확률 S(t)")
fig.tight_layout()
plt.show()

관측 8명, 사망 시점 [ 2  5  5  9 14 20 27 31]
    t     생존 인원     S(t)
    2         7    0.875
    5         5    0.625
    9         4    0.500
   14         3    0.375
   20         2    0.250
   27         1    0.125
   31         0    0.000

import numpy as np
import matplotlib.pyplot as plt

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

# 대기열 길이: 도착·이탈 시점에만 바뀐다
events = np.array([0, 2, 3, 5, 8, 9, 13, 15, 18, 20], float)
queue = np.array([0, 1, 2, 1, 2, 3, 2, 1, 1, 0], float)

dt = np.diff(events)
area = np.sum(queue[:-1] * dt)                     # 계단 아래 면적
total_time = events[-1] - events[0]

print(f"{'구간':>12}{'길이':>7}{'대기 인원':>10}{'기여':>8}")
for i in range(len(dt)):
    print(f"{f'[{events[i]:.0f}, {events[i+1]:.0f})':>12}{dt[i]:>7.0f}"
          f"{queue[i]:>10.0f}{queue[i] * dt[i]:>8.0f}")
print(f"\n계단 아래 면적 = {area:.0f} (인원·시간)")
print(f"평균 대기열 길이 = 면적 / 전체 시간 = {area / total_time:.4f}")

fig, ax = plt.subplots(figsize=(8, 3.5))
ax.step(events, queue, where="post", lw=2)
ax.fill_between(events, queue, step="post", alpha=0.25)
ax.set_xlabel("시간"); ax.set_ylabel("대기 인원")
ax.set_title(f"계단 아래 면적 = {area:.0f}, 평균 길이 = {area/total_time:.2f}", fontsize=10)
fig.tight_layout()
plt.show()

          구간     길이     대기 인원      기여
      [0, 2)      2         0       0
      [2, 3)      1         1       1
      [3, 5)      2         2       4
      [5, 8)      3         1       3
      [8, 9)      1         2       2
     [9, 13)      4         3      12
    [13, 15)      2         2       4
    [15, 18)      3         1       3
    [18, 20)      2         1       2

계단 아래 면적 = 31 (인원·시간)
평균 대기열 길이 = 면적 / 전체 시간 = 1.5500

import numpy as np
import matplotlib.pyplot as plt

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

t = np.arange(20)
rng = np.random.default_rng(0)
layers = np.vstack([
    40 + 1.5 * t,                       # 꾸준히 증가
    30 + 0 * t,                         # 변화 없음
    20 + np.where(t < 10, 0, 3 * (t - 10)),   # 후반에 급증
    15 - 0.3 * t,                       # 서서히 감소
])
names = ["증가", "일정", "후반 급증", "감소"]

print("각 층의 시작 → 끝")
for nm, s in zip(names, layers):
    print(f"  {nm:>8}: {s[0]:.1f} → {s[-1]:.1f}   ({s[-1]-s[0]:+.1f})")

fig, axes = plt.subplots(1, 2, figsize=(11, 4), sharey=True)
axes[0].stackplot(t, layers, labels=names)
axes[0].legend(loc="upper left", fontsize=8)
axes[0].set_title("원래 순서", fontsize=10)
order = [2, 0, 1, 3]                    # 관심 층을 맨 아래로
axes[1].stackplot(t, layers[order], labels=[names[i] for i in order])
axes[1].legend(loc="upper left", fontsize=8)
axes[1].set_title("'후반 급증'을 맨 아래로", fontsize=10)
fig.tight_layout()
plt.show()

각 층의 시작 → 끝
        증가: 40.0 → 68.5   (+28.5)
        일정: 30.0 → 30.0   (+0.0)
     후반 급증: 20.0 → 47.0   (+27.0)
        감소: 15.0 → 9.3   (-5.7)