Dividend Portfolio Backtesting: Reinvestment and Total Returns

The dividend accounting illusion: Price return vs. Total returnCopy Anchor Link

In quantitative strategy research, equity performance is frequently evaluated using simple price changes derived from raw or split-adjusted daily closes. For short-term momentum or intraday mean-reversion strategies, ignoring cash distributions introduces negligible tracking error. However, for multi-year holding horizons, dividend-yield factors, and multi-asset asset allocation models, disregarding dividends fundamentally corrupts your performance metrics.

Historically, reinvested dividends have accounted for over 40% to 50% of the S&P 500's cumulative total return over multi-decade periods. For dedicated high-dividend equity baskets—such as utilities, real estate investment trusts (REITs), and Dividend Aristocrats—cash distributions often represent more than 70% of total investor return. Evaluating a dividend-focused strategy purely on price return makes a disciplined value or income portfolio appear chronically uncompetitive relative to pure growth indices.

Long-Term Return Trajectory (Theoretical Comparison)
Equity ($)
 ▲
 │                                              ┌─── Double-Counting Illusion (Fatal Bug)
 │                                        ┌─────┘    (Adj Close + Cash Crediting)
 │                                  ┌─────┘
 │                            ┌─────┴─────────────── True Total Return (DRIP Reinvestment)
 │                      ┌─────┘
 │                ┌─────┘               ┌─────────── Cash Accumulation (With Cash Drag)
 │          ┌─────┘               ┌─────┘
 │    ┌─────┘               ┌─────┘
 │────┴─────────────────────┴─────────────────────── Pure Price Return (Dividends Discarded)
 └──────────────────────────────────────────────────► Time (Years)

Conversely, attempting to fix this omission through naive ad-hoc corrections frequently introduces an even worse distortion: the double-counting trap. If a researcher calculates signals and equity curves on backwards dividend-adjusted prices while simultaneously crediting dividend cash distributions to the account balance, the backtest fabricates compound returns that never existed in the real world.

To construct an empirical dividend portfolio backtest that yields actionable research, you must understand the exact lifecycle of corporate cash distributions, the mechanics of ex-dividend price adjustments, and the mathematical difference between synthetic total return indices and explicit physical cash ledgers.

Mechanics of dividend events in historical dataCopy Anchor Link

A corporate cash dividend is not an instantaneous windfall that materializes overnight. It is a scheduled administrative sequence governed by corporate governance rules, statutory exchange bylaws, and clearinghouse settlement conventions.

Corporate Dividend Lifecycle and Settlement Timeline
┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Declaration  │────►│ Ex-Dividend  │────►│ Record Date  │────►│ Payment Date │
│     Date     │     │     Date     │     │   (Record)   │     │  (Cash Pay)  │
└──────────────┘     └──────────────┘     └──────────────┘     └──────────────┘
  Board votes &        Exchange price       Shareholder list     Physical cash
  announces $D/sh      drops by ~$D         finalized by DTC     credited to broker
                       (Cutoff point)       (T+1 settlement)     (2 to 4 weeks later)

The corporate distribution lifecycle spans four discrete milestones:

1. Declaration Date: The company's board of directors publicly announces the dividend amount per share (D), the record date, and the anticipated payable date. At this point, the dividend is a future liability for the firm, but no market price adjustment occurs.
2. Ex-Dividend Date (t_{\text{ex}}): The official cutoff date established by the listing exchange. Under the US standard T+1 settlement regime (mandated under SEC Rule 15c6-1 since May 2024; historically T+2), an investor must purchase the stock before the ex-dividend date to be the owner of record on the record date. If an investor buys shares on or after t_{\text{ex}}, the seller retains the dividend rights.
3. Record Date (t_{\text{rec}}): The date on which the issuer inspects its registered shareholder register to determine eligibility. Under T+1 settlement, the record date is the business day immediately following t_{\text{ex}}.
4. Payment Date (t_{\text{pay}}): The physical disbursement date, typically two to four weeks after t_{\text{ex}}, when cash funds or newly issued DRIP shares are transferred into brokerage custody accounts.

The Ex-Date price drop and market microstructureCopy Anchor Link

The most critical market microstructure phenomenon for backtesting engines occurs between the close of day t_{\text{ex}}-1 and the opening auction of day t_{\text{ex}}.

When a stock trades ex-dividend, the exchange's matching engine automatically adjusts the previous closing price downward by the exact dividend amount to set reference prices for the pre-market auction:

P_{\text{ref}, t_{\text{ex}}} = P_{\text{close}, t_{\text{ex}}-1} - D

Because the company disburses cash reserves off its balance sheet to shareholders, the book value of the underlying business declines. In a frictionless, tax-neutral market, the stock opens lower by exactly D.

In empirical markets, however, the ex-date opening drop rarely equals exactly 100% of D. Market microstructure research (e.g., Elton & Gruber) indicates that stocks frequently drop by approximately (1 - \tau_d) / (1 - \tau_{cg}) \times D, where \tau_d is the marginal dividend tax rate and \tau_{cg} is the marginal capital gains tax rate. For backtesting standard long-only systematic strategies, assuming a 100% price drop is standard institutional convention, but quants must be aware that microstructure drift and overnight inventory adjustments introduce slight noise around open prints.

Special dividends vs. Regular cash distributionsCopy Anchor Link

Another critical data classification involves distinguishing between ordinary periodic dividends (e.g., standard quarterly distributions) and special (non-recurring) cash dividends.

• Ordinary Dividends: Paid regularly out of recurring operating cash flow. Exchanges adjust the reference opening price automatically, and standard vendor Adj Close series scale historical prices smoothly.
• Special Dividends: One-off lump-sum capital returns (such as Microsoft's $3.00 special dividend in 2004 or Costco's periodic $10-$15 special payouts). Large special payouts can equal 5% to 15% of the total share price in a single day.
• Option and Stop Order Implications: While ordinary dividends do not adjust exchange strike prices on standardized equity options, large special dividends trigger official adjustments by the Options Clearing Corporation (OCC) and special rules for broker stop-loss books. In an unadjusted backtest, an unhandled 10% special dividend will trigger false stop-outs across every momentum position.

[!WARNING] If a backtest engine runs on raw, unadjusted daily prices and does not account for dividend receivables on the ex-date, trailing stop-loss orders or volatility triggers (such as Average True Range breakdowns) may misinterpret the mechanical $2.00 ex-date drop as an adverse market sell-off, triggering fictitious forced liquidations.

The fatal double-counting trapCopy Anchor Link

Most institutional data vendors (such as CRSP) and retail data feeds (including Yahoo Finance, Polygon, and Tiingo) provide two primary price columns: Close and Adj Close. Understanding how Adj Close is calculated reveals why naive dividend modeling produces catastrophic backtest errors.

How backwards dividend adjustment worksCopy Anchor Link

Data vendors construct Adj Close to produce a smooth, continuous price path for technical indicators and quantitative return calculations. Rather than injecting cash payments into historical records, the data vendor multiplies all historical prices prior to each dividend event backwards by an adjustment factor:

k_t = 1 - \frac{D_t}{P_{t-1}}

P_{\text{adj}, \tau} = P_{\tau} \times \prod_{t > \tau} k_t

Where D_t is the cash dividend distributed on ex-date t, and P_{t-1} is the unadjusted close on the day preceding the ex-date.

Raw Traded Close vs. Backward-Adjusted Close (Ex-Dividend Event at Bar t)

Day t-1 Close:    Raw = $100.00 ───────┐ (Drop of $2.00 Dividend)
                                       ▼
Day t   Close:                         Raw = $98.00 (Neutral performance)

Backward Adjusted Series:
Day t-1 Adj Close: Adj = $98.00 ───────► Day t Adj Close: Adj = $98.00
(Historical price scaled down by 0.98; return is flat at 0.0%)

By discounting the historical price series prior to the ex-dividend date, the synthetic price change:

R_{\text{adj}, t} = \frac{P_{\text{adj}, t}}{P_{\text{adj}, t-1}} - 1 = \frac{98.00}{98.00} - 1 = 0.0\%

matches the true economic holding period return ((98.00 + $2.00) / $100.00 - 1 = 0.0%$).

The mathematical anatomy of the double-counting errorCopy Anchor Link

To see exactly why double counting generates astronomical phantom alpha, trace the arithmetic across a single dividend event.

Suppose you allocate $10,000 to buy 100 shares of Stock A at $100.00. One month later, the stock trades at $100.00 and distributes a $4.00 cash dividend per share (D =4.00), opening at96.00 on the ex-date.

1. In Reality (Raw Traded Series):
   • On the ex-date, you hold 100 shares at $96.00 = $9,600.00.
   • You receive $400.00 in cash (100 \times4.00$).
   • Total account value: $$9,600.00 + $400.00 = $10,000.00$ (0.0% return, identical to market reality).
2. In Standard Adjusted Close (Adj Close):
   • The vendor sets the adjustment multiplier k = 1 - (4 / 100) = 0.96.
   • The historical purchase price is retroactively adjusted downward: P_{\text{adj}, 0} =100.00 \times 0.96 = $96.00$.
   • Calculating return via adjusted prices: R = (96.00 / $96.00) - 1 = 0.0%$.
   • Notice the key implication: the 0.96 multiplier implicitly credited you with 104.167 shares (10,000 / 96) from Day 1.
3. In the Flawed Double-Counting Engine:
   • The engine evaluates position value using Adj Close (104.167 \times96.00 = $10,000.00$).
   • The engine simultaneously fires a dividend event handler: \text{Cash} \mathrel{+}= 104.167 \times4.00 = $416.67$.
   • Reported Equity on Ex-Date: $$10,000.00 + $416.67 = \mathbf{$10,416.67}$.

# ANTI-PATTERN: Double-counting cash dividends on adjusted series
price = bar.adj_close  # Already discounted backwards for dividends!

if bar.is_ex_dividend:
    # Double count! Injects phantom cash on top of already adjusted prices
    portfolio.cash += portfolio.shares * bar.dividend_amount

On a day when the underlying asset experienced zero economic return, the flawed engine recorded an instantaneous +4.17% gain out of thin air. Over a multi-year backtest with 20 or 40 quarterly distributions, this synthetic return compounds exponentially:

V_{\text{flawed}}(T) \approx V_{\text{true}}(T) \times \prod_{t=1}^{N} (1 + y_t)

Where y_t is the dividend yield at each distribution event. For a portfolio yielding 4% annually over 10 years, this artifact inflates backtested portfolio wealth by nearly 48% above true economic returns.

Data Ingestion Rule of Thumb:
┌─────────────────────────────────┬─────────────────────────────────┐
│ If Price Series Used Is:        │ Cash Dividend Handling:         │
├─────────────────────────────────┼─────────────────────────────────┤
│ Split-Adjusted Close            │ Explicitly credit cash on       │
│ (Raw prices adjusted for splits)│ payment date; handle DRIP/cash. │
├─────────────────────────────────┼─────────────────────────────────┤
│ Fully Adjusted Close            │ DO NOT credit cash dividends!   │
│ (Adjusted for splits & divs)    │ Cash is already embedded.       │
└─────────────────────────────────┴─────────────────────────────────┘

Reinvestment models: DRIP vs. Cash balance accumulationCopy Anchor Link

When modeling cash distributions using split-adjusted market prices, a quantitative researcher must define what happens to cash proceeds when they arrive. In real-world asset management, two primary paradigms exist: Instant Dividend Reinvestment (DRIP) and Cash Balance Accumulation.

1. Instant Dividend Reinvestment Plan (DRIP)Copy Anchor Link

In a synthetic DRIP model, dividend cash is converted immediately into additional shares of the issuing security:

\Delta S = \frac{S \times D}{P_{\text{reinvest}}}

• Execution Timing: In retail brokerages, DRIP shares are purchased on the official payment date (t_{\text{pay}}) at the volume-weighted average price (VWAP) or market open. In simplified daily backtests, researchers often assume execution at t_{\text{ex}} or t_{\text{pay}} open.
• Fractional Shares: DRIP programs routinely allocate fractional shares (e.g., executing to four decimal places: +2.4182 shares). If your backtesting simulation strictly enforces whole-share integer lot constraints without fractional support, small dividend distributions on high-priced equities will fail to execute, causing unintended cash accumulation.
• Capital Drag Elimination: Because cash is immediately redeployed, the strategy maintains near-100% equity exposure, maximizing compounding during extended equity bull markets.

2. Cash balance accumulation and periodic rebalancingCopy Anchor Link

In multi-asset institutional portfolios, fund managers rarely allow automated DRIP reinvestment into individual securities. Instead, cash dividends flow into a centralized cash account and are retained until the next scheduled rebalance date:

• Formalizing Cash Drag: Uninvested cash dilutes portfolio performance whenever equity markets appreciate:

\text{Cash Drag} = w_{\text{cash}} \times (R_{\text{equity}} - R_{\text{cash}})

If a high-dividend portfolio holds an average uninvested cash buffer of w_{\text{cash}} = 3.5\% while the equity sleeve compounds at R_{\text{equity}} = 12\% and cash yields R_{\text{cash}} = 2\%, the annualized cash drag is 0.035 \times (0.12 - 0.02) = 0.35\% (35 basis points) per year. Over a 20-year horizon, a 35 bps annual penalty reduces terminal wealth by approximately 7.5%.

• Cross-Asset Rebalancing: Rather than reinvesting capital back into the asset that paid it (which may have become overvalued), pooled dividend cash is systematically deployed into under-target portfolio holdings during the next rebalancing cycle.
• Transaction Cost Efficiency: Reinvesting tiny dividend disbursements on individual ex-dates generates dozens of micro-transactions, accumulating minimum ticket fees and exchange routing costs. Centralizing distributions into periodic rebalancing batches drastically reduces operational overhead.

Complete Python implementation: Auditable dividend accountingCopy Anchor Link

The following self-contained Python script models a 5-year equity series subject to quarterly dividend payouts. It executes all four accounting methodologies on the exact same price path, proving the quantitative divergence between Price Return, Cash Accumulation, Auditable DRIP, and the Double-Counting Trap.

import numpy as np
import pandas as pd


def run_dividend_simulation():
    # 1. Generate 5 years of daily business bars (approx 1,260 bars)
    np.random.seed(101)
    dates = pd.bdate_range("2020-01-01", "2024-12-31")
    n_bars = len(dates)

    # 7% annualized underlying geometric drift, 15% annualized volatility
    mu = 0.07 / 252
    sigma = 0.15 / np.sqrt(252)
    daily_returns = np.random.normal(mu, sigma, n_bars)

    # Define quarterly ex-dividend schedule ($1.25/share, ~5% annual yield)
    quarter_ends = pd.date_range("2020-01-01", "2024-12-31", freq="QE")
    ex_date_indices = [
        dates.get_indexer([q], method="nearest")[0] for q in quarter_ends
    ]
    ex_date_indices = sorted(list(set(ex_date_indices)))

    dividend_schedule = np.zeros(n_bars)
    for idx in ex_date_indices:
        dividend_schedule[idx] = 1.25

    # 2. Simulate raw traded price path with ex-date price drop
    raw_close = np.zeros(n_bars)
    raw_close[0] = 100.00

    for i in range(1, n_bars):
        # Organic market movement
        price = raw_close[i - 1] * np.exp(daily_returns[i])
        # Mechanical overnight ex-date price drop
        if dividend_schedule[i] > 0:
            price = max(price - dividend_schedule[i], 1.0)
        raw_close[i] = price

    df = pd.DataFrame(
        {"raw_close": raw_close, "dividend": dividend_schedule}, index=dates
    )

    # 3. Calculate synthetic Backward Dividend-Adjusted Close (CRSP / Yahoo method)
    # Adjustment factor k_t = 1 - (D_t / P_{t-1})
    adj_factors = np.ones(n_bars)
    for i in range(1, n_bars):
        if df["dividend"].iloc[i] > 0:
            p_prev = df["raw_close"].iloc[i - 1]
            adj_factors[i] = 1.0 - (df["dividend"].iloc[i] / p_prev)

    cum_adj_factor = np.cumprod(adj_factors[::-1])[::-1]
    df["adj_close"] = df["raw_close"] * (cum_adj_factor / cum_adj_factor[-1])

    # 4. Strategy Execution Simulation ($10,000 initial capital = 100 shares)
    initial_capital = 10_000.00
    initial_shares = initial_capital / df["raw_close"].iloc[0]

    # Model A: Pure Price Return (Dividends discarded)
    equity_pr = initial_shares * df["raw_close"]

    # Model B: Cash Accumulation (Dividends collected in cash ledger, no reinvestment)
    cash_ca = 0.0
    equity_ca = np.zeros(n_bars)
    for i in range(n_bars):
        if df["dividend"].iloc[i] > 0:
            cash_ca += initial_shares * df["dividend"].iloc[i]
        equity_ca[i] = (initial_shares * df["raw_close"].iloc[i]) + cash_ca

    # Model C: Auditable DRIP (Cash reinvested on ex-date into fractional shares)
    shares_drip = initial_shares
    equity_drip = np.zeros(n_bars)
    for i in range(n_bars):
        if df["dividend"].iloc[i] > 0:
            payout = shares_drip * df["dividend"].iloc[i]
            # Buy fractional shares at prevailing market close
            new_shares = payout / df["raw_close"].iloc[i]
            shares_drip += new_shares
        equity_drip[i] = shares_drip * df["raw_close"].iloc[i]

    # Model D: The Fatal Double-Counting Trap
    # Runs on adj_close AND credits cash payouts
    shares_dc = initial_capital / df["adj_close"].iloc[0]
    cash_dc = 0.0
    equity_dc = np.zeros(n_bars)
    for i in range(n_bars):
        if df["dividend"].iloc[i] > 0:
            cash_dc += shares_dc * df["dividend"].iloc[i]
        equity_dc[i] = (shares_dc * df["adj_close"].iloc[i]) + cash_dc

    # Synthetic Total Return buy-and-hold benchmark on pure Adj Close (No extra cash)
    adj_benchmark = (
        initial_capital / df["adj_close"].iloc[0]
    ) * df["adj_close"]

    # 5. Compile and format summary metrics
    results = [
        ("Price Return Only", equity_pr.iloc[-1]),
        ("Cash Accumulation (Cash Drag)", equity_ca[-1]),
        ("Auditable DRIP (Reinvested)", equity_drip[-1]),
        ("Pure Adj Close Benchmark", adj_benchmark.iloc[-1]),
        ("Double-Counting Trap", equity_dc[-1]),
    ]

    print("\n" + "=" * 78)
    print("5-YEAR DIVIDEND ACCOUNTING AUDIT REPORT (Initial Capital: $10,000.00)")
    print("=" * 78)
    print(
        f"{'Accounting Methodology':<32} | {'Final Equity':>14} | {'Total Return':>12} | {'CAGR':>8}"
    )
    print("-" * 78)

    years = (dates[-1] - dates[0]).days / 365.25
    for name, final_val in results:
        tot_ret = (final_val / initial_capital - 1.0) * 100
        cagr = ((final_val / initial_capital) ** (1.0 / years) - 1.0) * 100
        print(f"{name:<32} | ${final_val:>13,.2f} | {tot_ret:>11.2f}% | {cagr:>7.2f}%")
    print("=" * 78)


if __name__ == "__main__":
    run_dividend_simulation()

Execution audit outputCopy Anchor Link

Running this deterministic simulation generates the following audit breakdown:

==============================================================================
5-YEAR DIVIDEND ACCOUNTING AUDIT REPORT (Initial Capital: $10,000.00)
==============================================================================
Accounting Methodology           |   Final Equity | Total Return |     CAGR
------------------------------------------------------------------------------
Price Return Only                |     $16,245.06 |       62.45% |   10.19%
Cash Accumulation (Cash Drag)    |     $18,745.06 |       87.45% |   13.39%
Auditable DRIP (Reinvested)      |     $19,783.14 |       97.83% |   14.62%
Pure Adj Close Benchmark         |     $19,636.78 |       96.37% |   14.45%
Double-Counting Trap             |     $22,658.75 |      126.59% |   17.77%
==============================================================================

Key takeaways from the numbersCopy Anchor Link

1. Price Return Understatement: Looking only at price appreciation misses $3,538.08 of legitimate return (62.45% vs. 97.83%), understating compound annual performance by over 440 basis points annually.
2. Quantifying Cash Drag: Cash accumulation yielded $18,745.06 versus $19,783.14 for DRIP. The $1,038.08 difference represents pure cash drag—the cost of holding uninvested cash during an appreciating equity regime.
3. The Disastrous Double Count: The double-counting error fabricates $2,875.61 of phantom wealth (126.59% vs. 97.83%), exaggerating CAGR from 14.62% to 17.77%.

Framework positioning: Single-asset historical engines vs. Portfolio layersCopy Anchor Link

When organizing quantitative backtesting code, maintaining clear architectural boundaries between the order-matching engine and the multi-asset portfolio layer is essential for simulation fidelity.

Quantitative Architecture: Two-Layer Design
┌─────────────────────────────────────────────────────────────────┐
│               Outer Layer: Multi-Asset Portfolio                │
│  - Shared Cash Accounting & Capital Sweeping                    │
│  - Corporate Action Reconciliation (Ex-Dates & Payable Dates)   │
│  - Periodic Rebalancing Schedules & Target Weights              │
└────────────────────────────────┬────────────────────────────────┘
                                 │
     Passes orders / allocations │ Receives executed fills
                                 ▼
┌─────────────────────────────────────────────────────────────────┐
│              Inner Layer: OpenBacktesting Engine                │
│  - Single-Asset Historical Bar-by-Bar Execution                 │
│  - Causal Order Matching (Market, Limit, Stop, Trailing)        │
│  - Explicit Slippage & Broker Commission Deduction              │
│  - Zero Lookahead Signal Evaluation                             │
└─────────────────────────────────────────────────────────────────┘

OpenBacktesting's execution modelCopy Anchor Link

OpenBacktesting (version 0.2.1) is an open-source Python framework engineered specifically for single-asset historical OHLCV bar-by-bar backtesting. It provides:

• Deterministic order execution modeling (market, limit, stop, stop-limit, trailing stop, and one-cancels-the-other orders).
• Configurable commission structures and slippage models.
• Mathematical parameter optimization (grid search and sequential model-based optimization via SAMBO).
• Local strategy inspection via browser-based OpenBacktesting Studio.

OpenBacktesting is deliberately built as a high-fidelity single-asset execution engine. It does not provide a native multi-asset portfolio accounting engine, automated cross-asset cash pooling, or native futures settlement.

How to configure single-asset vs. Multi-asset workflowsCopy Anchor Link

Depending on your research scope, structure your data ingestion as follows:

1. Single-Asset Trend or Momentum Research:
   • If you are evaluating a technical or quantitative rule on a single instrument (e.g., trend following on an ETF or single stock), feed fully dividend-adjusted prices (Adj Close) into OpenBacktesting.
   • In this mode, order fills and indicator values operate on the total return continuum. You do not need to model dividend cash flows manually, because reinvestment compounding is embedded in the series.
2. Multi-Asset Dividend Allocation Portfolios:
   • If you are constructing a multi-asset dividend strategy (e.g., rotating between 30 high-yielding dividend stocks with quarterly rebalancing, as outlined in our guide on multi-asset portfolio backtesting):
   • Ingest split-adjusted prices for single-asset signal generation and order fill verification.
   • Maintain an outer Python portfolio orchestrator that manages the pooled cash ledger, logs dividend receivables on t_{\text{ex}}, credits cash on t_{\text{pay}}, and disburses pooled liquidity across assets during rebalance checkpoints.

This clean separation ensures you never corrupt low-level order fills with high-level cash adjustments. For detailed examples of handling corporate actions on individual equities, refer to our guide on stock backtesting in Python.

Summary checklist for dividend backtestsCopy Anchor Link

Before accepting the results of any dividend or equity income strategy backtest, run your simulation through this technical audit checklist:

• Price Series Disambiguation: Confirm whether your price series is raw unadjusted, split-adjusted only, or backward dividend-adjusted (Adj Close).
• Zero Double-Counting: Verify that your event handlers never add dividend dollar amounts to account equity when operating on dividend-adjusted price series.
• Ex-Date Order Protection: Ensure stop-loss, take-profit, and trailing-stop orders are evaluated against split-adjusted or total-return-adjusted references to prevent false triggers during overnight ex-dividend gap downs.
• Settlement and Payment Lag: For cash accumulation strategies, credit dividend proceeds on the realistic payment date (t_{\text{pay}}), rather than prematurely front-running liquidity to the announcement or ex-date.
• Fractional Lot Feasibility: If modeling DRIP, determine whether your target execution venue supports fractional shares; if trading institutional integer lots, route residual dividend funds into the cash ledger.
• Cash Drag Modeling: If dividends are not instantly reinvested via DRIP, ensure unallocated cash remains in the account cash balance to capture realistic cash drag.
• Foreign Withholding Taxes: If backtesting international dividend equities (e.g., European ADRs or non-US listings), deduct statutory withholding tax (typically 15% to 30%) from gross dividend amounts before crediting net cash.

For further details on execution models, parameter optimization, and reproducible strategy design, explore the official OpenBacktesting Documentation.