Time Value of Money & Free Cash Flow

12.1 The Time Value of Money: The First Principle of Finance

The time value of money (TVM) is the foundation on which all of DCF valuation rests. The principle is simple: a rupee received today is worth more than a rupee received tomorrow, because today's rupee can be invested and earn a return. TVM provides the mathematics that converts future cash flows — which we spent Chapters 7–9 forecasting — into a single present value.

12.1.1 Present Value and Future Value

Where r is the discount rate (our WACC from Chapter 11) and n is the number of periods. The discount factor 1/(1+r)ⁿ converts a future cash flow into today's rupees. As n increases, the discount factor shrinks — distant cash flows contribute less to present value.

A rupee received 20 years from now is worth only 15 paise today at a 10% discount rate. This is why the terminal value (Chapter 13) — which captures cash flows beyond the explicit forecast — matters so much, and why the perpetual growth rate assumption in the terminal value formula has such enormous leverage on the final valuation.

12.1.2 Net Present Value (NPV)

The NPV is the sum of the present values of all future cash flows, minus the initial investment. In a DCF valuation, the enterprise value is the NPV of all future FCFFs.

import numpy as np
import numpy_financial as npf

def compute_npv(cash_flows, discount_rate):
    """
    Compute NPV of a series of cash flows.

    Parameters
    ----------
    cash_flows : list or array — CF[0] is Year 0 (investment, usually negative),
                  CF[1] is Year 1, CF[2] is Year 2, etc.
    discount_rate : float — annual discount rate (WACC)

    Returns
    -------
    float — Net Present Value
    """
    # Manual computation (for transparency)
    npv = 0
    for t, cf in enumerate(cash_flows):
        npv += cf / (1 + discount_rate) ** t
    return npv

# Example: Investment of Rs. 1000, returns of Rs. 200/year for 7 years
cf = [-1000, 200, 200, 200, 200, 200, 200, 200]
npv_10 = compute_npv(cf, 0.10)
print(f"NPV at 10%: Rs. {npv_10:.2f}")
print(f"NPV at 8%:  Rs. {compute_npv(cf, 0.08):.2f}")
print(f"NPV at 12%: Rs. {compute_npv(cf, 0.12):.2f}")

# When NPV > 0, the investment creates value.
# When NPV < 0, it destroys value.

12.1.3 Internal Rate of Return (IRR)

The IRR is the discount rate that makes the NPV equal to zero. It represents the compounded annual return of the investment. If IRR > WACC, the investment creates value.

def compute_irr(cash_flows, guess=0.10, tolerance=1e-8, max_iter=1000):
    """
    Compute IRR using Newton-Raphson iteration.

    IRR is the rate r such that Σ CF_t / (1+r)^t = 0.
    """
    def npv_at_rate(r):
        return sum(cf / (1 + r) ** t for t, cf in enumerate(cash_flows))

    def npv_derivative(r):
        return sum(-t * cf / (1 + r) ** (t + 1) for t, cf in enumerate(cash_flows))

    r = guess
    for _ in range(max_iter):
        npv_val = npv_at_rate(r)
        if abs(npv_val) < tolerance:
            return r
        deriv = npv_derivative(r)
        if abs(deriv) < 1e-12:
            break
        r = r - npv_val / deriv
        if r <= -1:  # IRR cannot be below -100%
            return None

    return r

irr = compute_irr(cf)
print(f"\nIRR: {irr*100:.2f}%")
print(f"WACC = 10%: {'ACCEPT (IRR > WACC)' if irr > 0.10 else 'REJECT'}")

12.2 Free Cash Flow to Firm (FCFF): The Engine of Enterprise Valuation

FCFF is the cash available to all providers of capital — both debt and equity holders — after the company has made all the investments necessary to sustain and grow the business. It is the numerator in an enterprise-level DCF, discounted at WACC.

12.2.1 The FCFF Formula — Two Equivalent Approaches

12.2.2 FCFF from the Integrated Model

def compute_fcff(ebit, tax_rate, depreciation, capex, delta_wc):
    """
    Compute Free Cash Flow to Firm.

    Parameters
    ----------
    ebit : float or array — Earnings Before Interest and Taxes
    tax_rate : float — effective tax rate
    depreciation : float or array — depreciation & amortization
    capex : float or array — capital expenditure (positive value)
    delta_wc : float or array — change in working capital
              (positive = increase = cash outflow)

    Returns
    -------
    float or array — FCFF
    """
    nopat = ebit * (1 - tax_rate)
    fcff = nopat + depreciation - capex - delta_wc
    return fcff


# --- Example using Chapter 9 integrated model output ---
# Simulate a 5-year forecast (would come from IntegratedFinancialModel)
import pandas as pd

forecast_data = {
    'Year':       [1,     2,     3,     4,     5],
    'Revenue':    [40500, 45800, 51300, 56900, 62600],
    'EBIT':       [8100,  9160, 10260, 11380, 12520],
    'Depreciation': [1215, 1374, 1539, 1707, 1878],
    'Capex':      [2228, 2519, 2822, 3130, 3443],
    'Delta_WC':   [450,   410,   380,   350,   310],
}

df = pd.DataFrame(forecast_data).set_index('Year')

tax_rate = 0.25
df['NOPAT'] = df['EBIT'] * (1 - tax_rate)
df['FCFF'] = compute_fcff(
    df['EBIT'], tax_rate, df['Depreciation'], df['Capex'], df['Delta_WC']
)

print("=== FCFF COMPUTATION (Rs. Crore) ===")
print(df.round(0))

print(f"\nFCFF as % of Revenue:")
for yr in df.index:
    print(f"  Year {yr}: {df.loc[yr, 'FCFF']/df.loc[yr, 'Revenue']*100:.1f}%")

total_fcff = df['FCFF'].sum()
print(f"\nTotal 5-Year FCFF: Rs. {total_fcff:.0f} Cr")

12.2.3 The Reinvestment Rate: Linking Growth to Cash Flow

The reinvestment rate is the proportion of NOPAT that must be reinvested to achieve a given growth rate. It is a crucial consistency check:

df['Reinvestment'] = df['Capex'] - df['Depreciation'] + df['Delta_WC']
df['Reinvestment_Rate'] = (df['Reinvestment'] / df['NOPAT']) * 100
df['Implied_Growth'] = df['Reinvestment_Rate'] / 100 * 0.30  # Assume ROIC = 30%

print("\n=== REINVESTMENT ANALYSIS ===")
print(f"{'Year':<6} {'Reinv Rate':<13} {'Implied Growth':<16}")
for yr in df.index:
    rr = df.loc[yr, 'Reinvestment_Rate']
    ig = df.loc[yr, 'Implied_Growth']
    print(f"  {yr:<4} {rr:.1f}%{'':<8} {ig*100:.1f}%")

# If implied growth from reinvestment rate ≠ your forecast growth,
# either ROIC must adjust or your capex/WC assumptions are inconsistent.

12.3 Free Cash Flow to Equity (FCFE): The Equity Investor's Perspective

FCFE is the cash available to equity holders after all debt obligations have been met. It is the cash that can potentially be paid out as dividends or used for share buybacks. FCFE is discounted at the cost of equity (Ke) to derive equity value directly — an alternative to the FCFF → Enterprise Value → Equity Value route.

Where Net Borrowing = New debt issued − Debt repaid. If the company increases its debt, more cash is available to equity holders. If it pays down debt, less is available.

def compute_fcfe(net_income, depreciation, capex, delta_wc, net_borrowing):
    """
    Compute Free Cash Flow to Equity from net income.

    Parameters
    ----------
    net_income : float or array
    depreciation : float or array
    capex : float or array
    delta_wc : float or array — change in working capital
    net_borrowing : float or array — new debt issued minus debt repaid

    Returns
    -------
    float or array — FCFE
    """
    return net_income + depreciation - capex - delta_wc + net_borrowing


def fcff_to_fcfe(fcff, interest_expense, tax_rate, net_borrowing):
    """Convert FCFF to FCFE."""
    return fcff - interest_expense * (1 - tax_rate) + net_borrowing


# --- Example: Derive FCFE from FCFF ---
interest = np.array([160, 150, 140, 130, 120])
net_borrowing = np.array([0, 0, 0, 0, 0])  # No change in debt

df['Interest'] = interest
df['Net_Borrowing'] = net_borrowing
df['FCFE'] = fcff_to_fcfe(df['FCFF'], df['Interest'], tax_rate, df['Net_Borrowing'])

print("\n=== FCFF vs FCFE (Rs. Crore) ===")
print(f"{'Year':<6} {'FCFF':<10} {'Interest(1-T)':<15} {'FCFE':<10}")
for yr in df.index:
    fcff = df.loc[yr, 'FCFF']
    int_after_tax = df.loc[yr, 'Interest'] * (1 - tax_rate)
    fcfe = df.loc[yr, 'FCFE']
    print(f"  {yr:<4} {fcff:<10.0f} {int_after_tax:<15.0f} {fcfe:<10.0f}")

print(f"\nNote: FCFE < FCFF because after-tax interest is subtracted.")
print(f"Total 5-Year FCFE: Rs. {df['FCFE'].sum():.0f} Cr")

12.3.1 FCFF vs FCFE: When to Use Which

12.4 Discounting Mechanics: Converting FCFF to Present Value

With FCFF computed and WACC estimated, the remaining task is to discount each year's FCFF back to today. The discounting mechanics must be correct — a small error in the timing convention compounds across all years.

12.4.1 Year-End vs Mid-Year Discounting

The standard DCF formula assumes cash flows arrive at the end of each year. But in reality, cash flows are generated throughout the year. The mid-year convention assumes cash flows arrive in the middle of each year, which increases their present value (they are received earlier).

def discount_fcff(fcff_array, wacc, mid_year=True):
    """
    Discount a series of FCFFs to present value.

    Parameters
    ----------
    fcff_array : list or array — FCFF for years 1, 2, ..., n
    wacc : float — weighted average cost of capital
    mid_year : bool — use mid-year convention if True

    Returns
    -------
    pv_fcff : array of present values for each year
    total_pv : sum of all present values
    """
    pv_fcff = []
    for t, fcff in enumerate(fcff_array, start=1):
        exponent = t - 0.5 if mid_year else t
        pv = fcff / (1 + wacc) ** exponent
        pv_fcff.append(pv)

    total_pv = sum(pv_fcff)
    return np.array(pv_fcff), total_pv


# --- Discount the forecast FCFF ---
wacc = 0.108  # From Chapter 11

fcff_values = df['FCFF'].values
pv_year_end, total_ye = discount_fcff(fcff_values, wacc, mid_year=False)
pv_mid_year, total_my = discount_fcff(fcff_values, wacc, mid_year=True)

print(f"\n=== DISCOUNTED FCFF (WACC = {wacc*100:.1f}%) ===")
print(f"{'Year':<6} {'FCFF':<10} {'PV (Yr-End)':<14} {'PV (Mid-Yr)':<14}")
for yr in df.index:
    idx = yr - 1
    print(f"  {yr:<4} {fcff_values[idx]:<10.0f} {pv_year_end[idx]:<14.0f} {pv_mid_year[idx]:<14.0f}")

print(f"\n  Total PV (Year-End): Rs. {total_ye:.0f} Cr")
print(f"  Total PV (Mid-Year): Rs. {total_my:.0f} Cr")
print(f"  Mid-Year Premium:    Rs. {total_my - total_ye:.0f} Cr ({(total_my/total_ye - 1)*100:.1f}%)")

# Show discount factors
print(f"\n  Discount Factors (WACC = {wacc*100:.0f}%):")
for t in range(1, 6):
    df_ye = 1 / (1 + wacc) ** t
    df_my = 1 / (1 + wacc) ** (t - 0.5)
    print(f"    Year {t}: Year-End = {df_ye:.4f}, Mid-Year = {df_my:.4f}")

12.5 Building the DCF Engine: The Present Value of Explicit Forecasts

Let us build the core DCF function that takes FCFF and WACC and returns the present value of the explicit forecast period. This is the first of two components of enterprise value (the second being terminal value, covered in Chapter 13).

def pv_of_explicit_forecast(fcff_forecast, wacc, mid_year=True):
    """
    Compute the present value of explicit forecast period FCFFs.

    This is Component 1 of a DCF valuation.
    Component 2 (Terminal Value PV) is covered in Chapter 13.

    Parameters
    ----------
    fcff_forecast : list or array — FCFF for forecast years 1 through n
    wacc : float
    mid_year : bool

    Returns
    -------
    dict with year-by-year PV, total PV, and discount factors.
    """
    n = len(fcff_forecast)

    pv_details = []
    for t, fcff in enumerate(fcff_forecast, start=1):
        exponent = t - 0.5 if mid_year else t
        discount_factor = 1 / (1 + wacc) ** exponent
        pv = fcff * discount_factor
        pv_details.append({
            'Year': t,
            'FCFF': fcff,
            'Discount Factor': round(discount_factor, 4),
            'PV of FCFF': round(pv, 1)
        })

    pv_df = pd.DataFrame(pv_details).set_index('Year')
    total_pv = pv_df['PV of FCFF'].sum()

    # Percentage of total from each year
    pv_df['% of Total'] = (pv_df['PV of FCFF'] / total_pv * 100).round(1)

    print(f"Present Value of {n}-Year Explicit Forecast:")
    print(f"  WACC: {wacc*100:.2f}% | Convention: {'Mid-Year' if mid_year else 'Year-End'}")
    print(f"\n{pv_df.to_string()}")
    print(f"\n  TOTAL PV (Explicit Forecast): Rs. {total_pv:,.0f} Cr")

    return {
        'pv_details': pv_df,
        'total_pv': total_pv,
        'wacc': wacc,
        'mid_year': mid_year
    }


# --- Run ---
explicit_pv = pv_of_explicit_forecast(fcff_values, wacc, mid_year=True)

# Sensitivity: Total PV at different WACCs
print(f"\n  Sensitivity — Total PV at Different WACC:")
for w in [0.08, 0.09, 0.10, 0.11, 0.12, 0.13]:
    _, total = discount_fcff(fcff_values, w, mid_year=True)
    print(f"    WACC = {w*100:.0f}% → PV = Rs. {total:,.0f} Cr")

12.6 The Complete FCFF Pipeline: From Model to Present Value

Now we connect Chapter 9 (integrated model) → Chapter 11 (WACC) → Chapter 12 (FCFF + discounting) into a single pipeline:

def dcf_preparation_pipeline(ticker_symbol, forecast_years=5):
    """
    Prepare all inputs for a DCF valuation.

    1. Fetch historical data
    2. Build integrated forecast (Chapter 9)
    3. Compute WACC (Chapter 11)
    4. Extract and discount FCFF (Chapter 12)

    Returns everything needed for the DCF in Chapters 13–14.
    """
    import yfinance as yf
    from scipy import stats

    # --- Fetch data ---
    ticker = yf.Ticker(ticker_symbol)
    info = ticker.info

    # --- WACC computation (simplified inline) ---
    rf = 0.0675
    us_erp, india_crp = 0.05, 0.0225
    india_erp = us_erp + india_crp
    tax_rate = 0.25

    # Beta
    stock_p = yf.download(ticker_symbol, period='5y', progress=False)['Adj Close']
    mkt_p = yf.download('^NSEI', period='5y', progress=False)['Adj Close']
    stock_r = stock_p.resample('ME').last().pct_change().dropna()
    mkt_r = mkt_p.resample('ME').last().pct_change().dropna()
    common = stock_r.index.intersection(mkt_r.index)
    rf_m = (1 + rf)**(1/12) - 1
    raw_beta, _, _, _, _ = stats.linregress(
        mkt_r[common] - rf_m, stock_r[common] - rf_m)
    adj_beta = (2/3) * raw_beta + (1/3)

    ke = rf + adj_beta * india_erp

    # Cost of debt and WACC (simplified — use compute_wacc in production)
    is_df = ticker.financials
    bs_df = ticker.balance_sheet

    def safe_get(df, candidates):
        for c in ([candidates] if isinstance(candidates, str) else candidates):
            if c in df.index:
                return df.loc[c]
        return None

    ebit_val = safe_get(is_df, ['Operating Income', 'EBIT'])
    interest_val = safe_get(is_df, ['Interest Expense'])
    ebit_y0 = ebit_val.iloc[0] / 1e7 if ebit_val is not None else 5000
    interest_y0 = interest_val.iloc[0] / 1e7 if interest_val is not None else 200
    icr = ebit_y0 / interest_y0 if interest_y0 > 0 else 10

    # Synthetic rating
    icr_map = [(8.5, 0.0065), (6.5, 0.01), (4.5, 0.018), (3.0, 0.03),
               (2.0, 0.045), (1.5, 0.06), (0, 0.10)]
    spread = next(s for icr_min, s in icr_map if icr >= icr_min)
    kd = rf + spread

    # Capital structure
    mkt_cap = info.get('marketCap', 1e12) / 1e7
    debt = safe_get(bs_df, ['Total Debt', 'Long Term Debt'])
    debt = debt.iloc[0] / 1e7 if debt is not None else 0
    cash = safe_get(bs_df, ['Cash And Cash Equivalents'])
    cash = cash.iloc[0] / 1e7 if cash is not None else 0
    net_debt = debt - cash

    ev = mkt_cap + max(net_debt, 0)
    e_weight = mkt_cap / ev
    d_weight = max(net_debt, 0) / ev

    wacc = e_weight * ke + d_weight * kd * (1 - tax_rate)

    # --- Build simplified forecast ---
    rev = safe_get(is_df, ['Total Revenue', 'Revenue']).iloc[0] / 1e7
    growth_rates = [0.14, 0.13, 0.12, 0.11, 0.10]
    op_margin = (ebit_y0 / rev) if rev > 0 else 0.20
    depr_rate = 0.03
    capex_pct = 0.06
    wc_pct = 0.02

    fcff_forecast = []
    prev_rev = rev
    for g in growth_rates:
        rev_next = prev_rev * (1 + g)
        ebit_next = rev_next * op_margin
        nopat = ebit_next * (1 - tax_rate)
        depr = rev_next * depr_rate
        capex_val = rev_next * capex_pct
        delta_wc = (rev_next - prev_rev) * wc_pct
        fcff = nopat + depr - capex_val - delta_wc
        fcff_forecast.append(fcff)
        prev_rev = rev_next

    # --- Discount FCFF ---
    _, pv_explicit = discount_fcff(fcff_forecast, wacc, mid_year=True)

    # --- Display Summary ---
    print(f"\n{'='*60}")
    print(f"  DCF PREPARATION: {info.get('longName', ticker_symbol)}")
    print(f"{'='*60}")
    print(f"\n  WACC:               {wacc*100:.2f}%")
    print(f"  Cost of Equity:     {ke*100:.2f}%")
    print(f"  After-Tax Kd:       {kd*(1-tax_rate)*100:.2f}%")
    print(f"  D/E:                {net_debt/mkt_cap:.2f}")
    print(f"\n  FCFF Forecast (Rs. Cr):")
    for i, fcff in enumerate(fcff_forecast, 1):
        print(f"    Year {i}: Rs. {fcff:,.0f} Cr")
    print(f"\n  PV of Explicit Forecast: Rs. {pv_explicit:,.0f} Cr")

    return {
        'ticker': ticker_symbol,
        'company': info.get('longName', ticker_symbol),
        'wacc': wacc,
        'ke': ke,
        'fcff_forecast': fcff_forecast,
        'pv_explicit': pv_explicit,
        'market_cap': mkt_cap,
        'net_debt': net_debt,
        'shares_outstanding': info.get('sharesOutstanding', None),
    }


# --- Run for a sample company ---
dcf_inputs = dcf_preparation_pipeline("ASIANPAINT.NS")

This pipeline produces everything needed for the complete DCF in Chapter 14. The pv_explicit value will be combined with the terminal value PV (Chapter 13) to derive enterprise value, then equity value, then the per-share intrinsic value.