Transaction Costs & Market Impact: Models & Analysis › Practical Implementation: Complete Cost Model

class TransactionCostModel:
    """
    Comprehensive transaction cost model combining explicit costs,
    bid-ask spread, and market impact.
    """

    def __init__(
        self,
        commission_per_share=0.005,
        exchange_fee_rate=0.0003,
        spread_bps=5,
        impact_eta=0.1,
        impact_gamma=0.5,
        daily_volume=1_000_000,
        daily_volatility=0.02,
    ):
        """
        Initialize the cost model with market-specific parameters.
        """
        self.commission_per_share = commission_per_share
        self.exchange_fee_rate = exchange_fee_rate
        self.spread_bps = spread_bps
        self.impact_eta = impact_eta
        self.impact_gamma = impact_gamma
        self.daily_volume = daily_volume
        self.daily_volatility = daily_volatility

    def explicit_costs(self, shares, price):
        """Calculate explicit trading costs."""
        trade_value = shares * price
        commission = shares * self.commission_per_share
        exchange_fee = trade_value * self.exchange_fee_rate
        return commission + exchange_fee

    def spread_cost(self, shares, price):
        """Calculate bid-ask spread cost (half spread for single trade)."""
        trade_value = shares * price
        return trade_value * (self.spread_bps / 10000) / 2

    def market_impact(self, shares, price):
        """Calculate market impact using square-root model."""
        participation_rate = shares / self.daily_volume
        impact_pct = (
            self.daily_volatility
            * self.impact_eta
            * (participation_rate**self.impact_gamma)
        )
        return shares * price * impact_pct

    def total_cost(self, shares, price):
        """Calculate total transaction cost for a trade."""
        explicit = self.explicit_costs(shares, price)
        spread = self.spread_cost(shares, price)
        impact = self.market_impact(shares, price)

        return {
            "explicit": explicit,
            "spread": spread,
            "impact": impact,
            "total": explicit + spread + impact,
        }

    def cost_summary(self, shares, price):
        """Return cost breakdown as percentage of trade value."""
        costs = self.total_cost(shares, price)
        trade_value = shares * price

        return {
            "trade_value": trade_value,
            "explicit_bps": costs["explicit"] / trade_value * 10000,
            "spread_bps": costs["spread"] / trade_value * 10000,
            "impact_bps": costs["impact"] / trade_value * 10000,
            "total_bps": costs["total"] / trade_value * 10000,
        }


# Create cost models for different market conditions
liquid_large_cap = TransactionCostModel(
    commission_per_share=0.003,
    spread_bps=2,
    impact_eta=0.05,
    daily_volume=10_000_000,
    daily_volatility=0.015,
)

mid_cap = TransactionCostModel(
    commission_per_share=0.005,
    spread_bps=10,
    impact_eta=0.10,
    daily_volume=500_000,
    daily_volatility=0.025,
)

small_cap = TransactionCostModel(
    commission_per_share=0.008,
    spread_bps=30,
    impact_eta=0.20,
    daily_volume=50_000,
    daily_volatility=0.035,
)

# Analyze costs for different trade sizes
price = 50.0
trade_sizes = [1000, 10000, 50000, 100000]

cost_comparison = []
for model, name in [
    (liquid_large_cap, "Large Cap"),
    (mid_cap, "Mid Cap"),
    (small_cap, "Small Cap"),
]:
    for size in trade_sizes:
        summary = model.cost_summary(size, price)
        summary["market"] = name
        summary["shares"] = size
        cost_comparison.append(summary)

cost_df = pd.DataFrame(cost_comparison)