스타트업 밸류에이션 완전 가이드: DCF·멀티플 분석부터 Python 자동화까지

┌──────────────────────────────────────────────────────────────────┐
│                 Startup Valuation Workflow                        │
│                                                                  │
│  ┌────────────┐    ┌─────────────┐    ┌──────────────────────┐  │
│  │  1. Data    │    │ 2. Method   │    │ 3. Cross-Validation  │  │
│  │  Collection │───▶│ Application │───▶│    & Triangulation   │  │
│  └────────────┘    └─────────────┘    └──────────────────────┘  │
│       │                   │                      │               │
│  ┌────▼────┐         ┌───▼────┐            ┌────▼─────┐        │
│  │ Revenue  │         │  DCF   │            │ Weighted │        │
│  │ Forecast │         ├────────┤            │ Average  │        │
│  │ Market   │         │Comps   │            │ Range    │        │
│  │ Data     │         ├────────┤            │ Analysis │        │
│  │ Cap Table│         │  VC    │            └────┬─────┘        │
│  │ Comps    │         │Method  │                 │              │
│  └─────────┘         ├────────┤            ┌────▼─────┐        │
│                      │Berkus  │            │Negotiation│        │
│                      └────────┘            │  Range    │        │
│                                            └──────────┘         │
│                                                                  │
│  ┌────────────────────────────────────────────────────────────┐  │
│  │              4. Sensitivity & Monte Carlo Analysis          │  │
│  │  ┌──────────┐  ┌──────────────┐  ┌──────────────────────┐ │  │
│  │  │ Scenario │  │ Monte Carlo  │  │  Risk-Adjusted       │ │  │
│  │  │ Analysis │  │ Simulation   │  │  Valuation Range     │ │  │
│  │  └──────────┘  └──────────────┘  └──────────────────────┘ │  │
│  └────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────┘

Enterprise Value = Sum of [FCFt / (1 + WACC)^t] + Terminal Value / (1 + WACC)^n

import numpy as np
import pandas as pd
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class DCFModel:
    """스타트업 DCF 밸류에이션 모델"""

    # 기본 재무 가정
    current_revenue: float          # 현재 연 매출 (억원)
    revenue_growth_rates: list      # 연도별 매출 성장률 [0.8, 0.5, 0.3, 0.2, 0.15]
    operating_margin_path: list     # 연도별 영업이익률 [-0.3, -0.1, 0.05, 0.12, 0.18]
    capex_ratio: float = 0.05       # 매출 대비 설비투자 비율
    nwc_ratio: float = 0.10         # 매출 대비 순운전자본 비율
    tax_rate: float = 0.22          # 법인세율 (한국 기준)

    # 할인율 및 터미널 가정
    wacc: float = 0.25              # 스타트업 WACC (25%)
    terminal_growth_rate: float = 0.03  # 영구 성장률
    projection_years: int = 5       # 추정 기간

    def project_financials(self) -> pd.DataFrame:
        """재무제표 추정"""
        years = range(1, self.projection_years + 1)
        revenues = []
        rev = self.current_revenue

        for i, yr in enumerate(years):
            rev = rev * (1 + self.revenue_growth_rates[i])
            revenues.append(rev)

        df = pd.DataFrame({
            'Year': list(years),
            'Revenue': revenues,
            'Growth_Rate': self.revenue_growth_rates,
            'Op_Margin': self.operating_margin_path,
        })

        df['EBIT'] = df['Revenue'] * df['Op_Margin']
        df['NOPAT'] = df['EBIT'] * (1 - self.tax_rate)
        df['Capex'] = df['Revenue'] * self.capex_ratio
        df['Delta_NWC'] = df['Revenue'].diff().fillna(
            df['Revenue'].iloc[0] - self.current_revenue
        ) * self.nwc_ratio
        df['FCF'] = df['NOPAT'] - df['Capex'] - df['Delta_NWC']

        return df

    def calculate_terminal_value(self, last_fcf: float) -> float:
        """Gordon Growth Model로 터미널 밸류 계산"""
        return last_fcf * (1 + self.terminal_growth_rate) / (
            self.wacc - self.terminal_growth_rate
        )

    def calculate_enterprise_value(self) -> dict:
        """기업 가치 산출"""
        df = self.project_financials()

        # 각 연도 FCF의 현재 가치
        discount_factors = [(1 + self.wacc) ** yr for yr in df['Year']]
        pv_fcfs = df['FCF'].values / np.array(discount_factors)

        # 터미널 밸류
        tv = self.calculate_terminal_value(df['FCF'].iloc[-1])
        pv_tv = tv / (1 + self.wacc) ** self.projection_years

        # 기업 가치
        ev = pv_fcfs.sum() + pv_tv

        return {
            'financials': df,
            'pv_fcfs': pv_fcfs,
            'terminal_value': tv,
            'pv_terminal_value': pv_tv,
            'enterprise_value': ev,
            'tv_share': pv_tv / ev * 100 if ev > 0 else 0,
        }

    def sensitivity_analysis(
        self,
        wacc_range: tuple = (0.15, 0.35, 0.05),
        tgr_range: tuple = (0.01, 0.05, 0.01),
    ) -> pd.DataFrame:
        """민감도 분석: WACC vs 영구성장률"""
        waccs = np.arange(*wacc_range)
        tgrs = np.arange(*tgr_range)
        results = []

        original_wacc = self.wacc
        original_tgr = self.terminal_growth_rate

        for w in waccs:
            row = []
            for t in tgrs:
                self.wacc = w
                self.terminal_growth_rate = t
                ev = self.calculate_enterprise_value()['enterprise_value']
                row.append(round(ev, 1))
            results.append(row)

        self.wacc = original_wacc
        self.terminal_growth_rate = original_tgr

        return pd.DataFrame(
            results,
            index=[f'WACC {w:.0%}' for w in waccs],
            columns=[f'TGR {t:.0%}' for t in tgrs],
        )


# 사용 예시: SaaS 스타트업 DCF
model = DCFModel(
    current_revenue=30,              # 현재 매출 30억
    revenue_growth_rates=[0.80, 0.50, 0.35, 0.25, 0.15],
    operating_margin_path=[-0.30, -0.10, 0.05, 0.12, 0.18],
    wacc=0.25,
    terminal_growth_rate=0.03,
)

result = model.calculate_enterprise_value()
print("=== DCF Valuation Result ===")
print(f"Enterprise Value: {result['enterprise_value']:.1f}억 원")
print(f"Terminal Value 비중: {result['tv_share']:.1f}%")
print("\n=== 재무 추정 ===")
print(result['financials'][['Year', 'Revenue', 'EBIT', 'FCF']].to_string(index=False))
print("\n=== 민감도 분석 (WACC vs TGR) ===")
print(model.sensitivity_analysis())

import pandas as pd
import numpy as np
from dataclasses import dataclass


@dataclass
class ComparableAnalysis:
    """비교 기업 멀티플 분석"""

    target_name: str
    target_revenue: float          # 대상 기업 연 매출 (억원)
    target_ebitda: float           # 대상 기업 EBITDA (억원)
    target_revenue_growth: float   # 대상 기업 매출 성장률

    def add_comparable_set(self, comps: list[dict]) -> pd.DataFrame:
        """
        비교 기업 데이터 입력
        comps: [{'name': 'A', 'ev': 500, 'revenue': 100,
                 'ebitda': 20, 'revenue_growth': 0.3}, ...]
        """
        df = pd.DataFrame(comps)
        df['EV/Revenue'] = df['ev'] / df['revenue']
        df['EV/EBITDA'] = df.apply(
            lambda r: r['ev'] / r['ebitda'] if r['ebitda'] > 0 else np.nan,
            axis=1,
        )
        df['EV/Rev/Growth'] = df['EV/Revenue'] / df['revenue_growth']
        self.comps_df = df
        return df

    def calculate_valuation_range(self) -> dict:
        """다양한 멀티플로 밸류에이션 레인지 산출"""
        metrics = {}

        # EV/Revenue 기반
        ev_rev_median = self.comps_df['EV/Revenue'].median()
        ev_rev_mean = self.comps_df['EV/Revenue'].mean()
        ev_rev_25 = self.comps_df['EV/Revenue'].quantile(0.25)
        ev_rev_75 = self.comps_df['EV/Revenue'].quantile(0.75)

        metrics['EV/Revenue'] = {
            'median': ev_rev_median,
            'mean': ev_rev_mean,
            'val_median': self.target_revenue * ev_rev_median,
            'val_25th': self.target_revenue * ev_rev_25,
            'val_75th': self.target_revenue * ev_rev_75,
        }

        # EV/EBITDA 기반 (EBITDA 양수인 경우만)
        if self.target_ebitda > 0:
            ev_ebitda_median = self.comps_df['EV/EBITDA'].dropna().median()
            metrics['EV/EBITDA'] = {
                'median': ev_ebitda_median,
                'val_median': self.target_ebitda * ev_ebitda_median,
            }

        # 성장률 조정 멀티플 (PEG 유사 개념)
        ev_rev_growth = self.comps_df['EV/Rev/Growth'].median()
        adjusted_multiple = ev_rev_growth * self.target_revenue_growth
        metrics['Growth_Adjusted'] = {
            'adjusted_multiple': adjusted_multiple,
            'val_adjusted': self.target_revenue * adjusted_multiple,
        }

        return metrics

    def football_field_summary(self) -> pd.DataFrame:
        """풋볼 필드 차트용 요약 (밸류에이션 레인지)"""
        vals = self.calculate_valuation_range()
        rows = []

        if 'EV/Revenue' in vals:
            v = vals['EV/Revenue']
            rows.append({
                'Method': 'EV/Revenue',
                'Low': v['val_25th'],
                'Mid': v['val_median'],
                'High': v['val_75th'],
            })

        if 'EV/EBITDA' in vals:
            v = vals['EV/EBITDA']
            rows.append({
                'Method': 'EV/EBITDA',
                'Low': v['val_median'] * 0.8,
                'Mid': v['val_median'],
                'High': v['val_median'] * 1.2,
            })

        if 'Growth_Adjusted' in vals:
            v = vals['Growth_Adjusted']
            rows.append({
                'Method': 'Growth-Adjusted',
                'Low': v['val_adjusted'] * 0.85,
                'Mid': v['val_adjusted'],
                'High': v['val_adjusted'] * 1.15,
            })

        return pd.DataFrame(rows)


# 사용 예시: 한국 SaaS 스타트업 멀티플 분석
analyzer = ComparableAnalysis(
    target_name="TargetCo",
    target_revenue=50,
    target_ebitda=5,
    target_revenue_growth=0.60,
)

# 비교 기업 데이터
comps_data = [
    {'name': 'CompA (상장)', 'ev': 1200, 'revenue': 200,
     'ebitda': 40, 'revenue_growth': 0.35},
    {'name': 'CompB (상장)', 'ev': 800, 'revenue': 120,
     'ebitda': 24, 'revenue_growth': 0.45},
    {'name': 'CompC (비상장)', 'ev': 600, 'revenue': 80,
     'ebitda': -5, 'revenue_growth': 0.70},
    {'name': 'CompD (상장)', 'ev': 2000, 'revenue': 300,
     'ebitda': 60, 'revenue_growth': 0.25},
    {'name': 'CompE (비상장)', 'ev': 400, 'revenue': 60,
     'ebitda': 8, 'revenue_growth': 0.55},
]

comps_table = analyzer.add_comparable_set(comps_data)
print("=== 비교 기업 멀티플 ===")
print(comps_table[['name', 'EV/Revenue', 'EV/EBITDA', 'EV/Rev/Growth']]
      .to_string(index=False))

print("\n=== 밸류에이션 레인지 (풋볼 필드) ===")
print(analyzer.football_field_summary().to_string(index=False))

Post-money Valuation = Exit Value / Target Return Multiple
Pre-money Valuation = Post-money - Investment Amount

import numpy as np
from dataclasses import dataclass


@dataclass
class VCMethod:
    """VC Method 밸류에이션"""

    # 투자 조건
    investment_amount: float      # 투자금 (억원)
    investment_stage: str         # 'seed', 'series_a', 'series_b', 'series_c'

    # Exit 가정
    exit_year: int = 5            # Exit까지 예상 기간 (년)
    exit_revenue: float = 0       # Exit 시점 예상 매출 (억원)
    exit_multiple: float = 8.0    # Exit 시점 EV/Revenue 멀티플

    # 희석 가정
    expected_dilution: float = 0.20  # 향후 라운드로 인한 예상 희석률

    # 단계별 목표 수익 배수
    TARGET_RETURNS = {
        'seed': 25.0,
        'series_a': 12.0,
        'series_b': 6.0,
        'series_c': 3.5,
    }

    def calculate(self) -> dict:
        """VC Method 밸류에이션 수행"""
        target_return = self.TARGET_RETURNS[self.investment_stage]

        # 1. Exit Value 계산
        exit_value = self.exit_revenue * self.exit_multiple

        # 2. 필요 소유 지분 (Exit 시점)
        required_ownership_at_exit = (
            self.investment_amount * target_return / exit_value
        )

        # 3. 희석 고려한 현재 필요 지분
        required_ownership_now = (
            required_ownership_at_exit / (1 - self.expected_dilution)
        )

        # 4. Post-money / Pre-money 계산
        post_money = self.investment_amount / required_ownership_now
        pre_money = post_money - self.investment_amount

        # 5. 검증: IRR 계산
        irr = (exit_value * required_ownership_at_exit
               / self.investment_amount) ** (1 / self.exit_year) - 1

        return {
            'exit_value': exit_value,
            'target_return': target_return,
            'required_ownership_exit': required_ownership_at_exit,
            'required_ownership_now': required_ownership_now,
            'post_money_valuation': post_money,
            'pre_money_valuation': pre_money,
            'implied_irr': irr,
            'ownership_pct': required_ownership_now * 100,
        }

    def scenario_analysis(
        self,
        exit_revenues: list,
        exit_multiples: list,
    ) -> list[dict]:
        """시나리오 분석"""
        scenarios = []
        for rev in exit_revenues:
            for mult in exit_multiples:
                self.exit_revenue = rev
                self.exit_multiple = mult
                result = self.calculate()
                scenarios.append({
                    'Exit Revenue': rev,
                    'Exit Multiple': mult,
                    'Exit Value': result['exit_value'],
                    'Pre-money': round(result['pre_money_valuation'], 1),
                    'Ownership %': round(result['ownership_pct'], 1),
                })
        return scenarios


# 사용 예시: Series A 투자
vc = VCMethod(
    investment_amount=30,          # 30억 투자
    investment_stage='series_a',
    exit_year=5,
    exit_revenue=500,              # 5년 후 예상 매출 500억
    exit_multiple=8.0,             # SaaS 기업 평균 EV/Revenue
    expected_dilution=0.25,        # Series B, C에서 25% 희석 예상
)

result = vc.calculate()
print("=== VC Method Valuation ===")
print(f"Exit Value: {result['exit_value']:.0f}억 원")
print(f"목표 수익 배수: {result['target_return']:.0f}x")
print(f"필요 지분율 (현재): {result['ownership_pct']:.1f}%")
print(f"Pre-money Valuation: {result['pre_money_valuation']:.1f}억 원")
print(f"Post-money Valuation: {result['post_money_valuation']:.1f}억 원")
print(f"Implied IRR: {result['implied_irr']:.1%}")

# 시나리오 분석
import pandas as pd
scenarios = vc.scenario_analysis(
    exit_revenues=[300, 500, 800],
    exit_multiples=[5.0, 8.0, 12.0],
)
print("\n=== 시나리오 분석 ===")
print(pd.DataFrame(scenarios).to_string(index=False))

import pandas as pd
from dataclasses import dataclass, field


@dataclass
class Shareholder:
    """주주 정보"""
    name: str
    shares: int
    share_class: str          # 'common', 'preferred_seed', 'preferred_a', ...
    investment_amount: float  # 투자금 (억원)
    price_per_share: float    # 주당 가격 (원)


@dataclass
class CapTableSimulator:
    """Cap Table 시뮬레이터"""

    company_name: str
    total_authorized_shares: int = 10_000_000
    shareholders: list = field(default_factory=list)
    rounds: list = field(default_factory=list)

    def initialize_founders(self, founders: list[dict]):
        """
        창업자 지분 설정
        founders: [{'name': 'CEO', 'shares': 5000000, 'vesting_months': 48}, ...]
        """
        for f in founders:
            self.shareholders.append(Shareholder(
                name=f['name'],
                shares=f['shares'],
                share_class='common',
                investment_amount=0,
                price_per_share=0,
            ))

    def create_esop_pool(self, pool_pct: float):
        """ESOP 풀 생성 (전체 주식의 pool_pct%)"""
        total_shares = sum(s.shares for s in self.shareholders)
        pool_shares = int(total_shares * pool_pct / (1 - pool_pct))

        self.shareholders.append(Shareholder(
            name='ESOP Pool',
            shares=pool_shares,
            share_class='options',
            investment_amount=0,
            price_per_share=0,
        ))

    def simulate_round(
        self,
        round_name: str,
        pre_money_valuation: float,    # 억원
        investment_amount: float,       # 억원
        investor_name: str,
        new_esop_pct: float = 0.0,     # 추가 ESOP 비율
    ) -> pd.DataFrame:
        """투자 라운드 시뮬레이션"""
        # 현재 총 주식 수
        total_shares_before = sum(s.shares for s in self.shareholders)

        # 추가 ESOP 먼저 발행 (투자 전 희석)
        if new_esop_pct > 0:
            esop_increase = int(total_shares_before * new_esop_pct / (1 - new_esop_pct))
            esop_holder = next(
                (s for s in self.shareholders if s.name == 'ESOP Pool'), None
            )
            if esop_holder:
                esop_holder.shares += esop_increase
            else:
                self.shareholders.append(Shareholder(
                    name='ESOP Pool',
                    shares=esop_increase,
                    share_class='options',
                    investment_amount=0,
                    price_per_share=0,
                ))
            total_shares_before = sum(s.shares for s in self.shareholders)

        # 신주 발행 계산
        post_money = pre_money_valuation + investment_amount
        investor_pct = investment_amount / post_money
        new_shares = int(total_shares_before * investor_pct / (1 - investor_pct))
        price_per_share = (investment_amount * 100_000_000) / new_shares  # 원 단위

        # 투자자 추가
        self.shareholders.append(Shareholder(
            name=investor_name,
            shares=new_shares,
            share_class=f'preferred_{round_name.lower().replace(" ", "_")}',
            investment_amount=investment_amount,
            price_per_share=price_per_share,
        ))

        # 라운드 기록
        self.rounds.append({
            'round': round_name,
            'pre_money': pre_money_valuation,
            'investment': investment_amount,
            'post_money': post_money,
            'price_per_share': price_per_share,
            'new_shares': new_shares,
        })

        return self.get_cap_table()

    def get_cap_table(self) -> pd.DataFrame:
        """현재 Cap Table 반환"""
        total_shares = sum(s.shares for s in self.shareholders)
        data = []

        for s in self.shareholders:
            data.append({
                'Shareholder': s.name,
                'Shares': s.shares,
                'Class': s.share_class,
                'Ownership %': round(s.shares / total_shares * 100, 2),
                'Investment (억)': s.investment_amount,
            })

        return pd.DataFrame(data)

    def dilution_summary(self) -> pd.DataFrame:
        """라운드별 창업자 희석 추적"""
        return pd.DataFrame(self.rounds)


# 사용 예시: Seed -> Series A -> Series B 시뮬레이션
sim = CapTableSimulator(company_name="TechStartup Inc.")

# 1. 창업자 설정
sim.initialize_founders([
    {'name': 'CEO (창업자 1)', 'shares': 5_000_000, 'vesting_months': 48},
    {'name': 'CTO (창업자 2)', 'shares': 3_000_000, 'vesting_months': 48},
    {'name': 'COO (창업자 3)', 'shares': 2_000_000, 'vesting_months': 48},
])

# 2. ESOP 풀 생성 (12%)
sim.create_esop_pool(0.12)

print("=== 초기 Cap Table ===")
print(sim.get_cap_table().to_string(index=False))

# 3. Seed 라운드
print("\n=== Seed 라운드 후 ===")
seed_table = sim.simulate_round(
    round_name='Seed',
    pre_money_valuation=30,
    investment_amount=5,
    investor_name='Seed VC Fund',
)
print(seed_table.to_string(index=False))

# 4. Series A 라운드
print("\n=== Series A 라운드 후 ===")
series_a_table = sim.simulate_round(
    round_name='Series A',
    pre_money_valuation=150,
    investment_amount=30,
    investor_name='Growth VC Fund',
    new_esop_pct=0.05,
)
print(series_a_table.to_string(index=False))

# 5. 라운드 요약
print("\n=== 라운드 요약 ===")
print(pd.DataFrame(sim.rounds).to_string(index=False))

import numpy as np
import pandas as pd
from dataclasses import dataclass


@dataclass
class MonteCarloValuation:
    """Monte Carlo 기반 밸류에이션"""

    # 매출 가정 (억원)
    current_revenue: float = 30
    revenue_growth_mean: float = 0.50    # 평균 매출 성장률
    revenue_growth_std: float = 0.20     # 성장률 표준편차

    # 마진 가정
    terminal_margin_mean: float = 0.15   # 최종 영업이익률 평균
    terminal_margin_std: float = 0.05    # 마진 표준편차

    # 멀티플 가정
    exit_multiple_mean: float = 8.0
    exit_multiple_std: float = 3.0

    # 할인율
    wacc_mean: float = 0.25
    wacc_std: float = 0.05

    # 시뮬레이션 설정
    n_simulations: int = 10_000
    projection_years: int = 5
    survival_rate: float = 0.30          # 5년 생존율

    def run_simulation(self) -> dict:
        """Monte Carlo 시뮬레이션 실행"""
        np.random.seed(42)
        valuations = []
        successful = 0

        for _ in range(self.n_simulations):
            # 생존 여부 결정
            if np.random.random() > self.survival_rate:
                valuations.append(0)  # 폐업 = 가치 0
                continue

            successful += 1

            # 랜덤 변수 생성
            growth_rates = np.random.normal(
                self.revenue_growth_mean,
                self.revenue_growth_std,
                self.projection_years,
            )
            growth_rates = np.clip(growth_rates, -0.2, 1.5)  # 합리적 범위 제한

            terminal_margin = np.random.normal(
                self.terminal_margin_mean,
                self.terminal_margin_std,
            )
            terminal_margin = np.clip(terminal_margin, -0.1, 0.4)

            exit_multiple = np.random.normal(
                self.exit_multiple_mean,
                self.exit_multiple_std,
            )
            exit_multiple = max(exit_multiple, 1.0)

            wacc = np.random.normal(self.wacc_mean, self.wacc_std)
            wacc = np.clip(wacc, 0.10, 0.50)

            # 매출 추정
            revenue = self.current_revenue
            for gr in growth_rates:
                revenue *= (1 + gr)

            # Exit Value 계산
            ebitda = revenue * terminal_margin
            exit_value = max(ebitda * exit_multiple, revenue * 1.0)

            # 현재 가치로 할인
            pv = exit_value / (1 + wacc) ** self.projection_years
            valuations.append(pv)

        valuations = np.array(valuations)

        return {
            'valuations': valuations,
            'mean': np.mean(valuations),
            'median': np.median(valuations),
            'std': np.std(valuations),
            'percentile_10': np.percentile(valuations, 10),
            'percentile_25': np.percentile(valuations, 25),
            'percentile_75': np.percentile(valuations, 75),
            'percentile_90': np.percentile(valuations, 90),
            'survival_count': successful,
            'zero_count': np.sum(valuations == 0),
            'positive_mean': np.mean(valuations[valuations > 0]) if successful > 0 else 0,
        }

    def print_report(self):
        """결과 리포트 출력"""
        result = self.run_simulation()

        print("=" * 60)
        print("Monte Carlo Valuation Report")
        print("=" * 60)
        print(f"시뮬레이션 횟수: {self.n_simulations:,}")
        print(f"생존 기업: {result['survival_count']:,} "
              f"({result['survival_count']/self.n_simulations:.1%})")
        print(f"폐업 (가치=0): {result['zero_count']:,}")
        print("-" * 60)
        print(f"전체 평균 밸류에이션: {result['mean']:.1f}억 원")
        print(f"전체 중앙값: {result['median']:.1f}억 원")
        print(f"생존 기업만의 평균: {result['positive_mean']:.1f}억 원")
        print("-" * 60)
        print("밸류에이션 분포:")
        print(f"  10th percentile: {result['percentile_10']:.1f}억 원")
        print(f"  25th percentile: {result['percentile_25']:.1f}억 원")
        print(f"  Median:          {result['median']:.1f}억 원")
        print(f"  75th percentile: {result['percentile_75']:.1f}억 원")
        print(f"  90th percentile: {result['percentile_90']:.1f}억 원")
        print("-" * 60)
        print(f"표준편차: {result['std']:.1f}억 원")
        print(f"합리적 밸류에이션 레인지: "
              f"{result['percentile_25']:.0f}억 ~ {result['percentile_75']:.0f}억 원")
        print("=" * 60)

        return result


# 실행
mc = MonteCarloValuation(
    current_revenue=30,
    revenue_growth_mean=0.50,
    revenue_growth_std=0.20,
    exit_multiple_mean=8.0,
    exit_multiple_std=3.0,
    n_simulations=10_000,
    survival_rate=0.30,
)
result = mc.print_report()

import numpy as np
import pandas as pd
from dataclasses import dataclass


@dataclass
class IntegratedValuation:
    """다중 방법론 통합 밸류에이션"""

    company_name: str
    current_revenue: float      # 억원
    current_ebitda: float       # 억원
    revenue_growth: float       # 매출 성장률

    def dcf_valuation(self) -> dict:
        """간소화된 DCF"""
        revenues = [self.current_revenue]
        growth_rates = [0.60, 0.40, 0.25, 0.20, 0.15]
        margins = [-0.20, -0.05, 0.08, 0.15, 0.20]
        wacc = 0.25

        for g in growth_rates:
            revenues.append(revenues[-1] * (1 + g))

        fcfs = [revenues[i+1] * margins[i] * 0.78 for i in range(5)]
        pv_fcfs = sum(f / (1 + wacc) ** (i + 1) for i, f in enumerate(fcfs))
        tv = fcfs[-1] * (1.03) / (wacc - 0.03)
        pv_tv = tv / (1 + wacc) ** 5

        return {
            'method': 'DCF',
            'low': (pv_fcfs + pv_tv) * 0.8,
            'mid': pv_fcfs + pv_tv,
            'high': (pv_fcfs + pv_tv) * 1.2,
        }

    def multiples_valuation(self, peer_ev_revenue: float = 7.0) -> dict:
        """멀티플 밸류에이션"""
        mid = self.current_revenue * peer_ev_revenue
        return {
            'method': 'EV/Revenue',
            'low': mid * 0.75,
            'mid': mid,
            'high': mid * 1.25,
        }

    def vc_method_valuation(
        self,
        exit_revenue: float,
        exit_multiple: float = 8.0,
        target_return: float = 12.0,
    ) -> dict:
        """VC Method"""
        exit_value = exit_revenue * exit_multiple
        current_value = exit_value / target_return
        return {
            'method': 'VC Method',
            'low': current_value * 0.7,
            'mid': current_value,
            'high': current_value * 1.3,
        }

    def berkus_valuation(self, scores: dict) -> dict:
        """
        Berkus Method
        scores: {'idea': 0~5, 'prototype': 0~5, 'team': 0~5,
                 'relationships': 0~5, 'rollout': 0~5}
        각 요소 최대 5,000만 달러 (약 6.5억 원)
        """
        max_per_factor = 6.5  # 억원
        total = sum(s / 5 * max_per_factor for s in scores.values())
        return {
            'method': 'Berkus',
            'low': total * 0.8,
            'mid': total,
            'high': total * 1.2,
        }

    def integrated_report(self) -> pd.DataFrame:
        """통합 밸류에이션 리포트"""
        results = [
            self.dcf_valuation(),
            self.multiples_valuation(),
            self.vc_method_valuation(exit_revenue=400),
            self.berkus_valuation({
                'idea': 4, 'prototype': 4, 'team': 5,
                'relationships': 3, 'rollout': 2,
            }),
        ]

        df = pd.DataFrame(results)
        df['Low'] = df['low'].round(1)
        df['Mid'] = df['mid'].round(1)
        df['High'] = df['high'].round(1)

        # 가중 평균 (방법론별 가중치)
        weights = {'DCF': 0.25, 'EV/Revenue': 0.35,
                   'VC Method': 0.25, 'Berkus': 0.15}
        weighted_mid = sum(
            r['mid'] * weights.get(r['method'], 0.25) for r in results
        )

        print(f"\n{'='*60}")
        print(f"통합 밸류에이션 리포트: {self.company_name}")
        print(f"{'='*60}")
        print(df[['method', 'Low', 'Mid', 'High']].to_string(index=False))
        print(f"\n가중 평균 밸류에이션: {weighted_mid:.1f}억 원")
        print(f"합리적 레인지: {min(r['low'] for r in results):.0f}억 "
              f"~ {max(r['high'] for r in results):.0f}억 원")

        return df


# 사용 예시
valuation = IntegratedValuation(
    company_name="TechStartup Inc.",
    current_revenue=50,
    current_ebitda=5,
    revenue_growth=0.60,
)
valuation.integrated_report()