Economic Value Added

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

/** Canonical TypeScript parity implementation for D18-F02 Intrinsic Valuation. */

type Input = Record<string, unknown>;
type Output = Record<string, unknown>;

function numberValue(value: unknown, name: string): number {
  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${name} must be a finite number`);
  return value;
}

function rate(value: unknown, name: string): number {
  const result = numberValue(value, name);
  if (result <= 0 || result >= 1) throw new Error(`${name} must be strictly between 0 and 1`);
  return result;
}

function growth(value: unknown, name: string, discountRate: number): number {
  const result = numberValue(value, name);
  if (result <= -1) throw new Error(`${name} must be greater than -1`);
  if (result >= discountRate) throw new Error(`${name} must be below the matching discount rate`);
  return result;
}

function series(value: unknown, name: string): number[] {
  if (!Array.isArray(value) || value.length < 1) throw new Error(`${name} must contain at least 1 value`);
  return value.map((item, index) => numberValue(item, `${name}[${index}]`));
}

function sameLength(left: unknown[], right: unknown[], leftName: string, rightName: string): void {
  if (left.length !== right.length) throw new Error(`${leftName} and ${rightName} must have the same length`);
}

function discount(value: number, discountRate: number, period: number): [number, number] {
  const factor = 1 / ((1 + discountRate) ** period);
  return [factor, value * factor];
}

function fcffDcf(data: Input): Output {
  const fcff = series(data.fcff, "fcff");
  const wacc = rate(data.wacc, "wacc");
  const terminalGrowth = growth(data.terminal_growth, "terminal_growth", wacc);
  const cash = numberValue(data.cash_and_non_operating_assets, "cash_and_non_operating_assets");
  const debt = numberValue(data.debt, "debt");
  const preferred = numberValue(data.preferred_equity, "preferred_equity");
  const minority = numberValue(data.noncontrolling_interest, "noncontrolling_interest");
  const shares = numberValue(data.diluted_shares, "diluted_shares");
  if (shares <= 0) throw new Error("diluted_shares must be positive");
  let pvExplicit = 0;
  const schedule = fcff.map((flow, index) => {
    const period = index + 1;
    const [discountFactor, presentValue] = discount(flow, wacc, period);
    pvExplicit += presentValue;
    return { period, fcff: flow, discount_factor: discountFactor, present_value: presentValue };
  });
  const terminalFcff = fcff.at(-1)! * (1 + terminalGrowth);
  const terminalValue = terminalFcff / (wacc - terminalGrowth);
  const [terminalDiscountFactor, pvTerminal] = discount(terminalValue, wacc, fcff.length);
  const enterpriseValue = pvExplicit + pvTerminal;
  const netEquityBridge = cash - debt - preferred - minority;
  const equityValue = enterpriseValue + netEquityBridge;
  return {
    state: "valued", method: "fcff-enterprise-dcf", schedule,
    pv_explicit_fcff: pvExplicit, terminal_fcff: terminalFcff, terminal_value: terminalValue,
    terminal_discount_factor: terminalDiscountFactor, pv_terminal_value: pvTerminal,
    terminal_value_share: enterpriseValue ? pvTerminal / enterpriseValue : 0,
    enterprise_value: enterpriseValue, net_equity_bridge: netEquityBridge,
    equity_value: equityValue, intrinsic_value_per_share: equityValue / shares,
  };
}

function ddm(data: Input): Output {
  const dividends = series(data.dividends, "dividends");
  if (dividends.some((value) => value < 0)) throw new Error("dividends must be nonnegative");
  const cost = rate(data.cost_of_equity, "cost_of_equity");
  const terminalGrowth = growth(data.terminal_growth, "terminal_growth", cost);
  let pvExplicit = 0;
  const schedule = dividends.map((dividend, index) => {
    const period = index + 1;
    const [discountFactor, presentValue] = discount(dividend, cost, period);
    pvExplicit += presentValue;
    return { period, dividend, discount_factor: discountFactor, present_value: presentValue };
  });
  const terminalDividend = dividends.at(-1)! * (1 + terminalGrowth);
  const terminalValue = terminalDividend / (cost - terminalGrowth);
  const [terminalDiscountFactor, pvTerminal] = discount(terminalValue, cost, dividends.length);
  const value = pvExplicit + pvTerminal;
  return {
    state: "valued", method: "multi-stage-dividend-discount", schedule,
    pv_explicit_dividends: pvExplicit, terminal_dividend: terminalDividend,
    terminal_value: terminalValue, terminal_discount_factor: terminalDiscountFactor,
    pv_terminal_value: pvTerminal, terminal_value_share: value ? pvTerminal / value : 0,
    intrinsic_value_per_share: value,
  };
}

function gordon(data: Input): Output {
  const dividendNext = numberValue(data.dividend_next, "dividend_next");
  if (dividendNext < 0) throw new Error("dividend_next must be nonnegative");
  const cost = rate(data.cost_of_equity, "cost_of_equity");
  const perpetualGrowth = growth(data.perpetual_growth, "perpetual_growth", cost);
  const spread = cost - perpetualGrowth;
  return {
    state: "valued", method: "gordon-growth", dividend_timing: "D1-next-period",
    discount_growth_spread: spread, capitalization_multiple: 1 / spread,
    intrinsic_value_per_share: dividendNext / spread,
  };
}

function residualIncome(data: Input): Output {
  const openingBook = numberValue(data.opening_book_value_per_share, "opening_book_value_per_share");
  if (openingBook <= 0) throw new Error("opening_book_value_per_share must be positive");
  const earnings = series(data.earnings_per_share, "earnings_per_share");
  const dividends = series(data.dividends_per_share, "dividends_per_share");
  const adjustments = series(data.nonowner_equity_adjustments_per_share, "nonowner_equity_adjustments_per_share");
  sameLength(earnings, dividends, "earnings_per_share", "dividends_per_share");
  sameLength(earnings, adjustments, "earnings_per_share", "nonowner_equity_adjustments_per_share");
  const cost = rate(data.cost_of_equity, "cost_of_equity");
  const terminalGrowth = growth(data.terminal_residual_income_growth, "terminal_residual_income_growth", cost);
  let book = openingBook;
  let pvExplicit = 0;
  const residualValues: number[] = [];
  const schedule = earnings.map((eps, index) => {
    const period = index + 1;
    const dividend = dividends[index];
    const adjustment = adjustments[index];
    if (dividend < 0) throw new Error("dividends_per_share must be nonnegative");
    const opening = book;
    const equityCharge = cost * opening;
    const residual = eps - equityCharge;
    const [discountFactor, presentValue] = discount(residual, cost, period);
    const closing = opening + eps - dividend + adjustment;
    if (closing <= 0) throw new Error("clean-surplus book-value roll-forward must remain positive");
    pvExplicit += presentValue;
    residualValues.push(residual);
    book = closing;
    return {
      period, opening_book_value_per_share: opening, earnings_per_share: eps,
      dividends_per_share: dividend, nonowner_equity_adjustment_per_share: adjustment,
      equity_charge_per_share: equityCharge, residual_income_per_share: residual,
      discount_factor: discountFactor, present_value: presentValue,
      closing_book_value_per_share: closing,
    };
  });
  const terminalResidual = residualValues.at(-1)! * (1 + terminalGrowth);
  const continuingValue = terminalResidual / (cost - terminalGrowth);
  const [terminalDiscountFactor, pvContinuing] = discount(continuingValue, cost, earnings.length);
  const value = openingBook + pvExplicit + pvContinuing;
  return {
    state: "valued", method: "residual-income", schedule,
    pv_explicit_residual_income: pvExplicit, terminal_residual_income_per_share: terminalResidual,
    continuing_value: continuingValue, terminal_discount_factor: terminalDiscountFactor,
    pv_continuing_value: pvContinuing, continuing_value_share: value ? pvContinuing / value : 0,
    closing_book_value_per_share: book, intrinsic_value_per_share: value,
  };
}

function eva(data: Input): Output {
  const openingCapital = numberValue(data.opening_invested_capital, "opening_invested_capital");
  if (openingCapital <= 0) throw new Error("opening_invested_capital must be positive");
  const nopat = series(data.nopat, "nopat");
  const investment = series(data.net_investment, "net_investment");
  sameLength(nopat, investment, "nopat", "net_investment");
  const wacc = rate(data.wacc, "wacc");
  const terminalGrowth = growth(data.terminal_eva_growth, "terminal_eva_growth", wacc);
  let capital = openingCapital;
  let pvExplicit = 0;
  const evaValues: number[] = [];
  const schedule = nopat.map((periodNopat, index) => {
    const period = index + 1;
    const opening = capital;
    const capitalCharge = wacc * opening;
    const periodEva = periodNopat - capitalCharge;
    const roic = periodNopat / opening;
    const [discountFactor, presentValue] = discount(periodEva, wacc, period);
    const closing = opening + investment[index];
    if (closing <= 0) throw new Error("invested-capital roll-forward must remain positive");
    pvExplicit += presentValue;
    evaValues.push(periodEva);
    capital = closing;
    return {
      period, opening_invested_capital: opening, nopat: periodNopat,
      net_investment: investment[index], capital_charge: capitalCharge, roic,
      roic_wacc_spread: roic - wacc, eva: periodEva,
      discount_factor: discountFactor, present_value: presentValue,
      closing_invested_capital: closing,
    };
  });
  const terminalEva = evaValues.at(-1)! * (1 + terminalGrowth);
  const continuingValue = terminalEva / (wacc - terminalGrowth);
  const [terminalDiscountFactor, pvContinuing] = discount(continuingValue, wacc, nopat.length);
  const marketValueAdded = pvExplicit + pvContinuing;
  const enterpriseValue = openingCapital + marketValueAdded;
  return {
    state: "valued", method: "economic-value-added", schedule,
    pv_explicit_eva: pvExplicit, terminal_eva: terminalEva, continuing_value: continuingValue,
    terminal_discount_factor: terminalDiscountFactor, pv_continuing_value: pvContinuing,
    market_value_added: marketValueAdded,
    continuing_value_share: enterpriseValue ? pvContinuing / enterpriseValue : 0,
    closing_invested_capital: capital, enterprise_value: enterpriseValue,
  };
}

const calculators: Record<string, (data: Input) => Output> = {
  "D18-F02-A01": fcffDcf,
  "D18-F02-A02": ddm,
  "D18-F02-A03": gordon,
  "D18-F02-A04": residualIncome,
  "D18-F02-A05": eva,
};

export function calculate(topicId: string, data: Input): Output {
  const calculator = calculators[topicId];
  if (!calculator) throw new Error(`unsupported topic_id: ${topicId}`);
  if (!data || Array.isArray(data) || typeof data !== "object") throw new Error("data must be an object");
  return calculator(data);
}