@ebowwa/quant-rust 0.1.0

package/src/prediction/pnl.rs

@@ -0,0 +1,254 @@
+//! # PnL and Payout Calculations
+//!
+//! Calculate payouts, realized and unrealized PnL for prediction positions.
+
+use crate::prediction::Outcome;
+
+/// Calculate payout for a resolved prediction market.
+///
+/// # Arguments
+/// * `shares` - Number of shares held
+/// * `outcome` - Outcome you bet on
+/// * `resolved_outcome` - Actual resolved outcome
+///
+/// # Returns
+/// Payout amount ($1 per winning share, $0 for losing shares)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::pnl::calculate_payout;
+/// use quant_rust::prediction::Outcome;
+/// let payout = calculate_payout(100.0, Outcome::Yes, Outcome::Yes);
+/// assert_eq!(payout, 100.0);
+///
+/// let payout = calculate_payout(100.0, Outcome::Yes, Outcome::No);
+/// assert_eq!(payout, 0.0);
+/// ```
+pub fn calculate_payout(shares: f64, outcome: Outcome, resolved_outcome: Outcome) -> f64 {
+    if outcome == resolved_outcome {
+        shares
+    } else {
+        0.0
+    }
+}
+
+/// Calculate PnL for a closed position.
+///
+/// # Arguments
+/// * `shares` - Number of shares held
+/// * `avg_price` - Average purchase price per share
+/// * `outcome` - Outcome you bet on
+/// * `resolved_outcome` - Actual resolved outcome
+///
+/// # Returns
+/// Profit/Loss (payout - cost)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::pnl::calculate_pnl;
+/// use quant_rust::prediction::Outcome;
+/// // Won: bought 100 shares at $0.50, resolved YES
+/// let pnl = calculate_pnl(100.0, 0.5, Outcome::Yes, Outcome::Yes);
+/// assert_eq!(pnl, 50.0); // $100 payout - $50 cost
+///
+/// // Lost: bought 100 shares at $0.50, resolved NO
+/// let pnl = calculate_pnl(100.0, 0.5, Outcome::Yes, Outcome::No);
+/// assert_eq!(pnl, -50.0); // $0 payout - $50 cost
+/// ```
+pub fn calculate_pnl(
+    shares: f64,
+    avg_price: f64,
+    outcome: Outcome,
+    resolved_outcome: Outcome,
+) -> f64 {
+    let payout = calculate_payout(shares, outcome, resolved_outcome);
+    let cost = shares * avg_price;
+    payout - cost
+}
+
+/// Calculate unrealized PnL for an open position.
+///
+/// # Arguments
+/// * `shares` - Number of shares held
+/// * `avg_price` - Average purchase price per share
+/// * `current_price` - Current market price
+///
+/// # Returns
+/// Unrealized PnL (current value - cost)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::pnl::calculate_unrealized_pnl;
+/// // Bought at $0.50, now at $0.60
+/// let pnl = calculate_unrealized_pnl(100.0, 0.5, 0.6);
+/// assert_eq!(pnl, 10.0); // $60 value - $50 cost
+/// ```
+pub fn calculate_unrealized_pnl(shares: f64, avg_price: f64, current_price: f64) -> f64 {
+    let current_value = shares * current_price;
+    let cost = shares * avg_price;
+    current_value - cost
+}
+
+/// A closed position for TWR calculation
+#[derive(Debug, Clone, Copy)]
+pub struct ClosedPosition {
+    /// Entry timestamp (milliseconds)
+    pub entry_time: i64,
+    /// Exit timestamp (milliseconds)
+    pub exit_time: i64,
+    /// Value at entry
+    pub entry_value: f64,
+    /// Value at exit
+    pub exit_value: f64,
+}
+
+/// Calculate time-weighted return for a prediction portfolio.
+///
+/// TWR = product(exit_value / entry_value) - 1
+///
+/// This eliminates the effect of cash flows on returns.
+///
+/// # Arguments
+/// * `positions` - Slice of closed positions
+///
+/// # Returns
+/// Time-weighted return as decimal (e.g., 0.10 = 10%)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::pnl::{time_weighted_return, ClosedPosition};
+/// let positions = vec![
+///     ClosedPosition { entry_time: 0, exit_time: 100, entry_value: 100.0, exit_value: 110.0 },
+///     ClosedPosition { entry_time: 100, exit_time: 200, entry_value: 110.0, exit_value: 121.0 },
+/// ];
+/// let twr = time_weighted_return(&positions);
+/// // 10% + 10% = 21% total
+/// assert!((twr - 0.21).abs() < 1e-10);
+/// ```
+pub fn time_weighted_return(positions: &[ClosedPosition]) -> f64 {
+    if positions.is_empty() {
+        return 0.0;
+    }
+
+    let mut twr = 1.0;
+    for pos in positions {
+        if pos.entry_value > 0.0 {
+            twr *= pos.exit_value / pos.entry_value;
+        }
+    }
+
+    twr - 1.0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calculate_payout_winner() {
+        let payout = calculate_payout(100.0, Outcome::Yes, Outcome::Yes);
+        assert_eq!(payout, 100.0);
+    }
+
+    #[test]
+    fn test_calculate_payout_loser() {
+        let payout = calculate_payout(100.0, Outcome::Yes, Outcome::No);
+        assert_eq!(payout, 0.0);
+    }
+
+    #[test]
+    fn test_calculate_pnl_winner() {
+        let pnl = calculate_pnl(100.0, 0.5, Outcome::Yes, Outcome::Yes);
+        assert_eq!(pnl, 50.0); // $100 - $50
+    }
+
+    #[test]
+    fn test_calculate_pnl_loser() {
+        let pnl = calculate_pnl(100.0, 0.5, Outcome::Yes, Outcome::No);
+        assert_eq!(pnl, -50.0); // $0 - $50
+    }
+
+    #[test]
+    fn test_calculate_pnl_zero_cost() {
+        let pnl = calculate_pnl(100.0, 0.0, Outcome::Yes, Outcome::Yes);
+        assert_eq!(pnl, 100.0);
+    }
+
+    #[test]
+    fn test_calculate_unrealized_pnl_positive() {
+        let pnl = calculate_unrealized_pnl(100.0, 0.5, 0.6);
+        assert_eq!(pnl, 10.0); // $60 - $50
+    }
+
+    #[test]
+    fn test_calculate_unrealized_pnl_negative() {
+        let pnl = calculate_unrealized_pnl(100.0, 0.6, 0.5);
+        assert_eq!(pnl, -10.0); // $50 - $60
+    }
+
+    #[test]
+    fn test_calculate_unrealized_pnl_zero() {
+        let pnl = calculate_unrealized_pnl(100.0, 0.5, 0.5);
+        assert_eq!(pnl, 0.0);
+    }
+
+    #[test]
+    fn test_time_weighted_return_empty() {
+        let twr = time_weighted_return(&[]);
+        assert_eq!(twr, 0.0);
+    }
+
+    #[test]
+    fn test_time_weighted_return_single() {
+        let positions = vec![ClosedPosition {
+            entry_time: 0,
+            exit_time: 100,
+            entry_value: 100.0,
+            exit_value: 110.0,
+        }];
+        let twr = time_weighted_return(&positions);
+        assert!((twr - 0.10).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_time_weighted_return_multiple() {
+        let positions = vec![
+            ClosedPosition {
+                entry_time: 0,
+                exit_time: 100,
+                entry_value: 100.0,
+                exit_value: 110.0,
+            },
+            ClosedPosition {
+                entry_time: 100,
+                exit_time: 200,
+                entry_value: 110.0,
+                exit_value: 121.0,
+            },
+        ];
+        let twr = time_weighted_return(&positions);
+        // 1.1 * 1.1 - 1 = 0.21
+        assert!((twr - 0.21).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_time_weighted_return_with_loss() {
+        let positions = vec![
+            ClosedPosition {
+                entry_time: 0,
+                exit_time: 100,
+                entry_value: 100.0,
+                exit_value: 90.0,
+            },
+            ClosedPosition {
+                entry_time: 100,
+                exit_time: 200,
+                entry_value: 90.0,
+                exit_value: 99.0,
+            },
+        ];
+        let twr = time_weighted_return(&positions);
+        // 0.9 * 1.1 - 1 = -0.01
+        assert!((twr - (-0.01)).abs() < 1e-10);
+    }
+}

package/src/prediction/risk.rs

@@ -0,0 +1,228 @@
+//! # Prediction Market Risk Metrics
+//!
+//! Risk calculations for binary outcome positions.
+
+/// Risk metrics for a prediction market position
+#[derive(Debug, Clone, Copy)]
+pub struct PredictionRiskMetrics {
+    /// Expected value of the position
+    pub expected_value: f64,
+    /// Variance of returns
+    pub variance: f64,
+    /// Standard deviation of returns
+    pub std_dev: f64,
+    /// Sharpe-like ratio (EV / StdDev)
+    pub sharpe: f64,
+    /// Maximum loss (cost of position)
+    pub max_loss: f64,
+    /// Maximum gain (payout - cost)
+    pub max_gain: f64,
+    /// Payoff ratio (max_gain / max_loss)
+    pub payoff_ratio: f64,
+    /// Edge per dollar invested
+    pub edge_per_dollar: f64,
+}
+
+/// Calculate risk metrics for a prediction position.
+///
+/// # Arguments
+/// * `your_prob` - Your estimated probability of winning
+/// * `_market_price` - Price paid per share (unused, kept for API compatibility)
+/// * `shares` - Number of shares
+/// * `cost` - Total cost of position
+///
+/// # Returns
+/// PredictionRiskMetrics with detailed risk analysis
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::risk::calculate_prediction_risk;
+/// let metrics = calculate_prediction_risk(0.6, 0.5, 100.0, 50.0);
+/// assert!(metrics.expected_value > 0.0);
+/// assert!(metrics.max_loss == 50.0);
+/// ```
+pub fn calculate_prediction_risk(
+    your_prob: f64,
+    _market_price: f64,
+    shares: f64,
+    cost: f64,
+) -> PredictionRiskMetrics {
+    // Binary outcome: Win = shares * $1, Lose = $0
+    let max_gain = shares - cost; // If wins, get $1 per share
+    let max_loss = cost; // If loses, lose entire cost
+
+    // Expected value = p * maxGain - (1-p) * maxLoss
+    let expected_value = your_prob * max_gain - (1.0 - your_prob) * max_loss;
+
+    // Variance of binary = p(1-p) * (maxGain + maxLoss)^2
+    let variance = your_prob * (1.0 - your_prob) * (max_gain + max_loss).powi(2);
+    let std_dev = variance.sqrt();
+
+    // Sharpe-like ratio for single bet
+    let sharpe = if std_dev > 0.0 {
+        expected_value / std_dev
+    } else {
+        0.0
+    };
+
+    // Edge per dollar invested
+    let edge_per_dollar = if cost > 0.0 {
+        expected_value / cost
+    } else {
+        0.0
+    };
+
+    // Payoff ratio
+    let payoff_ratio = if max_loss > 0.0 {
+        max_gain / max_loss
+    } else {
+        0.0
+    };
+
+    PredictionRiskMetrics {
+        expected_value,
+        variance,
+        std_dev,
+        sharpe,
+        max_loss,
+        max_gain,
+        payoff_ratio,
+        edge_per_dollar,
+    }
+}
+
+/// Check if a bet has positive expected value.
+///
+/// # Arguments
+/// * `your_prob` - Your estimated probability
+/// * `market_price` - Current market price
+///
+/// # Returns
+/// true if your_prob > market_price
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::risk::has_positive_ev;
+/// assert!(has_positive_ev(0.6, 0.5));
+/// assert!(!has_positive_ev(0.4, 0.5));
+/// ```
+pub fn has_positive_ev(your_prob: f64, market_price: f64) -> bool {
+    your_prob > market_price
+}
+
+/// Calculate edge (your probability - market implied probability).
+///
+/// # Arguments
+/// * `your_prob` - Your estimated probability
+/// * `market_price` - Current market price
+///
+/// # Returns
+/// Edge (positive = favorable)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::risk::calculate_edge;
+/// let edge = calculate_edge(0.6, 0.5);
+/// assert!((edge - 0.1).abs() < 1e-10);
+/// ```
+pub fn calculate_edge(your_prob: f64, market_price: f64) -> f64 {
+    your_prob - market_price
+}
+
+/// Calculate break-even probability.
+///
+/// For a binary bet at price p, you need probability > p to have positive EV.
+///
+/// # Arguments
+/// * `market_price` - Current market price
+///
+/// # Returns
+/// Break-even probability
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::risk::break_even_prob;
+/// let prob = break_even_prob(0.5);
+/// assert!((prob - 0.5).abs() < 1e-10);
+/// ```
+pub fn break_even_prob(market_price: f64) -> f64 {
+    market_price
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calculate_prediction_risk_positive_ev() {
+        let metrics = calculate_prediction_risk(0.6, 0.5, 100.0, 50.0);
+        assert!(metrics.expected_value > 0.0);
+        assert_eq!(metrics.max_loss, 50.0);
+        assert_eq!(metrics.max_gain, 50.0); // 100 shares - 50 cost
+    }
+
+    #[test]
+    fn test_calculate_prediction_risk_negative_ev() {
+        let metrics = calculate_prediction_risk(0.4, 0.5, 100.0, 50.0);
+        assert!(metrics.expected_value < 0.0);
+    }
+
+    #[test]
+    fn test_calculate_prediction_risk_max_gain_loss() {
+        let metrics = calculate_prediction_risk(0.5, 0.5, 100.0, 50.0);
+        assert_eq!(metrics.max_loss, 50.0);
+        assert_eq!(metrics.max_gain, 50.0);
+    }
+
+    #[test]
+    fn test_calculate_prediction_risk_payoff_ratio() {
+        let metrics = calculate_prediction_risk(0.6, 0.4, 100.0, 40.0);
+        // Max gain = 100 - 40 = 60, Max loss = 40
+        assert!((metrics.payoff_ratio - 1.5).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_has_positive_ev_true() {
+        assert!(has_positive_ev(0.6, 0.5));
+        assert!(has_positive_ev(0.51, 0.5));
+    }
+
+    #[test]
+    fn test_has_positive_ev_false() {
+        assert!(!has_positive_ev(0.4, 0.5));
+        assert!(!has_positive_ev(0.5, 0.5));
+    }
+
+    #[test]
+    fn test_calculate_edge_positive() {
+        let edge = calculate_edge(0.6, 0.5);
+        assert!((edge - 0.1).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_calculate_edge_negative() {
+        let edge = calculate_edge(0.4, 0.5);
+        assert!((edge - (-0.1)).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_break_even_prob() {
+        assert!((break_even_prob(0.5) - 0.5).abs() < 1e-10);
+        assert!((break_even_prob(0.75) - 0.75).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_risk_metrics_sharpe() {
+        // High edge should give positive sharpe
+        let metrics = calculate_prediction_risk(0.8, 0.5, 100.0, 50.0);
+        assert!(metrics.sharpe > 0.0);
+    }
+
+    #[test]
+    fn test_edge_per_dollar() {
+        let metrics = calculate_prediction_risk(0.6, 0.5, 100.0, 50.0);
+        // EV = 0.6 * 50 - 0.4 * 50 = 10
+        // Edge per dollar = 10 / 50 = 0.2
+        assert!((metrics.edge_per_dollar - 0.2).abs() < 1e-10);
+    }
+}