@ebowwa/quant-rust 0.1.0

package/src/risk/ratios.rs

@@ -0,0 +1,290 @@
+//! Risk-Adjusted Return Ratios
+//!
+//! Sharpe, Sortino, Calmar, Treynor, and Information ratios.
+
+use serde::{Deserialize, Serialize};
+
+use crate::utils::{mean, std_dev, sum};
+
+use super::drawdown::calculate_drawdown;
+
+/// Calculate Sharpe Ratio
+///
+/// Measures risk-adjusted returns using total volatility.
+///
+/// # Arguments
+/// * `returns` - Array of periodic returns
+/// * `risk_free_rate` - Annual risk-free rate (e.g., 0.04 for 4%)
+/// * `periods_per_year` - Number of periods in a year (252 for daily, 12 for monthly)
+///
+/// # Returns
+/// Annualized Sharpe ratio
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::ratios::sharpe_ratio;
+/// let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+/// let sharpe = sharpe_ratio(&returns, 0.04, 252);
+/// assert!(sharpe.is_finite());
+/// ```
+pub fn sharpe_ratio(returns: &[f64], risk_free_rate: f64, periods_per_year: usize) -> f64 {
+    if returns.is_empty() {
+        return 0.0;
+    }
+
+    let avg_return = mean(returns);
+    let sd = std_dev(returns, false); // Sample std dev
+
+    if sd == 0.0 {
+        return 0.0;
+    }
+
+    // Annualize
+    let annualized_return = avg_return * periods_per_year as f64;
+    let annualized_vol = sd * (periods_per_year as f64).sqrt();
+
+    (annualized_return - risk_free_rate) / annualized_vol
+}
+
+/// Calculate Sortino Ratio
+///
+/// Like Sharpe, but only penalizes downside volatility.
+///
+/// # Arguments
+/// * `returns` - Array of periodic returns
+/// * `risk_free_rate` - Annual risk-free rate
+/// * `periods_per_year` - Number of periods in a year
+///
+/// # Returns
+/// Annualized Sortino ratio
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::ratios::sortino_ratio;
+/// let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+/// let sortino = sortino_ratio(&returns, 0.04, 252);
+/// assert!(sortino.is_finite() || sortino.is_infinite());
+/// ```
+pub fn sortino_ratio(returns: &[f64], risk_free_rate: f64, periods_per_year: usize) -> f64 {
+    if returns.is_empty() {
+        return 0.0;
+    }
+
+    let avg_return = mean(returns);
+    let target_return = risk_free_rate / periods_per_year as f64;
+
+    // Downside deviation
+    let downside_returns: Vec<f64> = returns.iter().filter(|&&r| r < target_return).cloned().collect();
+
+    if downside_returns.is_empty() {
+        return f64::INFINITY;
+    }
+
+    let squared_downside: Vec<f64> = downside_returns.iter().map(|r| (r - target_return).powi(2)).collect();
+    let downside_deviation = (sum(&squared_downside) / returns.len() as f64).sqrt();
+
+    if downside_deviation == 0.0 {
+        return 0.0;
+    }
+
+    let annualized_return = avg_return * periods_per_year as f64;
+    let annualized_downside = downside_deviation * (periods_per_year as f64).sqrt();
+
+    (annualized_return - risk_free_rate) / annualized_downside
+}
+
+/// Calculate Calmar Ratio
+///
+/// Return divided by maximum drawdown.
+///
+/// # Arguments
+/// * `returns` - Array of periodic returns
+/// * `equity_curve` - Array of equity values over time
+/// * `periods_per_year` - Number of periods in a year
+///
+/// # Returns
+/// Calmar ratio
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::ratios::calmar_ratio;
+/// let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+/// let equity = vec![100.0, 101.0, 103.0, 102.0, 105.0, 103.0, 104.0, 106.0, 107.0, 106.0, 108.0];
+/// let calmar = calmar_ratio(&returns, &equity, 252);
+/// assert!(calmar.is_finite());
+/// ```
+pub fn calmar_ratio(returns: &[f64], equity_curve: &[f64], periods_per_year: usize) -> f64 {
+    if returns.is_empty() || equity_curve.is_empty() {
+        return 0.0;
+    }
+
+    let dd_result = calculate_drawdown(equity_curve);
+    if dd_result.max_drawdown == 0.0 {
+        return 0.0;
+    }
+
+    let annualized_return = mean(returns) * periods_per_year as f64;
+
+    annualized_return / dd_result.max_drawdown
+}
+
+/// Calculate Treynor Ratio
+///
+/// Risk-adjusted return relative to systematic risk (beta).
+///
+/// # Arguments
+/// * `returns` - Array of portfolio periodic returns
+/// * `beta` - Portfolio beta relative to benchmark
+/// * `risk_free_rate` - Annual risk-free rate
+/// * `periods_per_year` - Number of periods in a year
+///
+/// # Returns
+/// Treynor ratio
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::ratios::treynor_ratio;
+/// let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+/// let treynor = treynor_ratio(&returns, 1.2, 0.04, 252);
+/// assert!(treynor.is_finite());
+/// ```
+pub fn treynor_ratio(returns: &[f64], beta: f64, risk_free_rate: f64, periods_per_year: usize) -> f64 {
+    if returns.is_empty() || beta == 0.0 {
+        return 0.0;
+    }
+
+    let annualized_return = mean(returns) * periods_per_year as f64;
+
+    (annualized_return - risk_free_rate) / beta
+}
+
+/// Calculate Information Ratio
+///
+/// Active return divided by tracking error.
+///
+/// # Arguments
+/// * `portfolio_returns` - Array of portfolio periodic returns
+/// * `benchmark_returns` - Array of benchmark periodic returns
+///
+/// # Returns
+/// Information ratio
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::ratios::information_ratio;
+/// let portfolio = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+/// let benchmark = vec![0.005, 0.015, -0.005, 0.02, -0.01, 0.005, 0.015, 0.01, -0.005, 0.015];
+/// let ir = information_ratio(&portfolio, &benchmark);
+/// assert!(ir.is_finite());
+/// ```
+pub fn information_ratio(portfolio_returns: &[f64], benchmark_returns: &[f64]) -> f64 {
+    if portfolio_returns.len() != benchmark_returns.len() || portfolio_returns.is_empty() {
+        return 0.0;
+    }
+
+    // Active returns
+    let active_returns: Vec<f64> = portfolio_returns
+        .iter()
+        .zip(benchmark_returns.iter())
+        .map(|(p, b)| p - b)
+        .collect();
+
+    let avg_active = mean(&active_returns);
+    let tracking_error = std_dev(&active_returns, false); // Sample std dev
+
+    if tracking_error == 0.0 {
+        return 0.0;
+    }
+
+    avg_active / tracking_error
+}
+
+/// Comprehensive risk-adjusted metrics
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RiskAdjustedMetrics {
+    /// Sharpe ratio
+    pub sharpe_ratio: f64,
+    /// Sortino ratio
+    pub sortino_ratio: f64,
+    /// Calmar ratio
+    pub calmar_ratio: f64,
+}
+
+/// Calculate all risk-adjusted metrics
+///
+/// # Arguments
+/// * `returns` - Array of periodic returns
+/// * `equity_curve` - Array of equity values over time
+/// * `risk_free_rate` - Annual risk-free rate
+/// * `periods_per_year` - Number of periods in a year
+///
+/// # Returns
+/// RiskAdjustedMetrics struct
+pub fn calculate_risk_adjusted_metrics(
+    returns: &[f64],
+    equity_curve: &[f64],
+    risk_free_rate: f64,
+    periods_per_year: usize,
+) -> RiskAdjustedMetrics {
+    RiskAdjustedMetrics {
+        sharpe_ratio: sharpe_ratio(returns, risk_free_rate, periods_per_year),
+        sortino_ratio: sortino_ratio(returns, risk_free_rate, periods_per_year),
+        calmar_ratio: calmar_ratio(returns, equity_curve, periods_per_year),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sharpe_ratio() {
+        let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+        let sharpe = sharpe_ratio(&returns, 0.04, 252);
+        assert!(sharpe.is_finite());
+    }
+
+    #[test]
+    fn test_sharpe_ratio_empty() {
+        let sharpe = sharpe_ratio(&[], 0.04, 252);
+        assert_eq!(sharpe, 0.0);
+    }
+
+    #[test]
+    fn test_sortino_ratio() {
+        let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+        let sortino = sortino_ratio(&returns, 0.04, 252);
+        assert!(sortino.is_finite() || sortino.is_infinite());
+    }
+
+    #[test]
+    fn test_calmar_ratio() {
+        let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+        let equity = vec![100.0, 101.0, 103.0, 102.0, 105.0, 103.0, 104.0, 106.0, 107.0, 106.0, 108.0];
+        let calmar = calmar_ratio(&returns, &equity, 252);
+        assert!(calmar.is_finite());
+    }
+
+    #[test]
+    fn test_treynor_ratio() {
+        let returns = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+        let treynor = treynor_ratio(&returns, 1.2, 0.04, 252);
+        assert!(treynor.is_finite());
+    }
+
+    #[test]
+    fn test_information_ratio() {
+        let portfolio = vec![0.01, 0.02, -0.01, 0.03, -0.02, 0.01, 0.02, 0.01, -0.01, 0.02];
+        let benchmark = vec![0.005, 0.015, -0.005, 0.02, -0.01, 0.005, 0.015, 0.01, -0.005, 0.015];
+        let ir = information_ratio(&portfolio, &benchmark);
+        assert!(ir.is_finite());
+    }
+
+    #[test]
+    fn test_information_ratio_mismatched_lengths() {
+        let portfolio = vec![0.01, 0.02, -0.01];
+        let benchmark = vec![0.005, 0.015];
+        let ir = information_ratio(&portfolio, &benchmark);
+        assert_eq!(ir, 0.0);
+    }
+}

package/src/risk/sizing.rs

@@ -0,0 +1,194 @@
+//! Position Sizing Functions
+//!
+//! Methods for calculating appropriate position sizes based on risk parameters.
+
+use serde::{Deserialize, Serialize};
+
+/// Result of position sizing calculation
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct PositionSizeResult {
+    /// Number of shares/contracts
+    pub shares: usize,
+    /// Total position value
+    pub position_value: f64,
+    /// Amount of capital at risk
+    pub risk_amount: f64,
+}
+
+/// Calculate position size based on fixed fractional method
+///
+/// Determines the number of shares to buy based on the percentage of capital
+/// you're willing to risk and the distance to your stop loss.
+///
+/// # Arguments
+/// * `capital` - Total trading capital
+/// * `risk_percent` - Percent of capital to risk (e.g., 0.02 for 2%)
+/// * `entry_price` - Planned entry price
+/// * `stop_loss` - Stop loss price
+///
+/// # Returns
+/// PositionSizeResult with shares, position value, and risk amount
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::sizing::fixed_fractional_size;
+/// let result = fixed_fractional_size(100000.0, 0.02, 50.0, 45.0);
+/// assert_eq!(result.shares, 400);
+/// assert_eq!(result.risk_amount, 2000.0);
+/// ```
+pub fn fixed_fractional_size(
+    capital: f64,
+    risk_percent: f64,
+    entry_price: f64,
+    stop_loss: f64,
+) -> PositionSizeResult {
+    let risk_amount = capital * risk_percent;
+    let risk_per_share = (entry_price - stop_loss).abs();
+
+    if risk_per_share == 0.0 {
+        return PositionSizeResult {
+            shares: 0,
+            position_value: 0.0,
+            risk_amount: 0.0,
+        };
+    }
+
+    let shares = (risk_amount / risk_per_share).floor() as usize;
+    let position_value = shares as f64 * entry_price;
+
+    PositionSizeResult {
+        shares,
+        position_value,
+        risk_amount,
+    }
+}
+
+/// Calculate position size using volatility-based sizing
+///
+/// Sizes positions such that a 1 standard deviation move equals the risk amount.
+/// This normalizes risk across assets with different volatilities.
+///
+/// # Arguments
+/// * `capital` - Total trading capital
+/// * `risk_percent` - Percent of capital to risk
+/// * `volatility` - Asset volatility (daily standard deviation as decimal)
+/// * `price` - Current price
+///
+/// # Returns
+/// PositionSizeResult with shares, position value, and risk amount
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::sizing::volatility_based_size;
+/// let result = volatility_based_size(100000.0, 0.02, 0.02, 100.0);
+/// assert_eq!(result.shares, 100);
+/// assert_eq!(result.risk_amount, 2000.0);
+/// ```
+pub fn volatility_based_size(
+    capital: f64,
+    risk_percent: f64,
+    volatility: f64,
+    price: f64,
+) -> PositionSizeResult {
+    let risk_amount = capital * risk_percent;
+
+    if volatility == 0.0 || price == 0.0 {
+        return PositionSizeResult {
+            shares: 0,
+            position_value: 0.0,
+            risk_amount: 0.0,
+        };
+    }
+
+    // Size such that expected 1 SD move = risk amount
+    let shares = (risk_amount / (price * volatility)).floor() as usize;
+    let position_value = shares as f64 * price;
+
+    PositionSizeResult {
+        shares,
+        position_value,
+        risk_amount,
+    }
+}
+
+/// Calculate optimal position size using Kelly criterion (for continuous returns)
+///
+/// The Kelly criterion maximizes long-term growth rate.
+/// Kelly = expected_return / variance
+///
+/// # Arguments
+/// * `expected_return` - Expected return of the asset
+/// * `variance` - Variance of returns
+/// * `capital` - Total trading capital
+/// * `fraction` - Fraction of Kelly to use (1.0 = full Kelly, 0.5 = half Kelly)
+///
+/// # Returns
+/// Optimal position size in currency units
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::sizing::kelly_size;
+/// let size = kelly_size(0.10, 0.04, 100000.0, 0.5);
+/// assert!((size - 125000.0).abs() < 1e-10);
+/// ```
+pub fn kelly_size(expected_return: f64, variance: f64, capital: f64, fraction: f64) -> f64 {
+    if variance <= 0.0 {
+        return 0.0;
+    }
+
+    let kelly = expected_return / variance;
+    capital * kelly * fraction
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fixed_fractional_size() {
+        let result = fixed_fractional_size(100000.0, 0.02, 50.0, 45.0);
+        assert_eq!(result.shares, 400);
+        assert_eq!(result.risk_amount, 2000.0);
+        assert!((result.position_value - 20000.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_fixed_fractional_size_zero_risk() {
+        let result = fixed_fractional_size(100000.0, 0.02, 50.0, 50.0);
+        assert_eq!(result.shares, 0);
+    }
+
+    #[test]
+    fn test_volatility_based_size() {
+        let result = volatility_based_size(100000.0, 0.02, 0.02, 100.0);
+        // risk_amount = 100000 * 0.02 = 2000
+        // shares = floor(2000 / (100 * 0.02)) = floor(2000 / 2) = 1000
+        assert_eq!(result.shares, 1000);
+        assert_eq!(result.risk_amount, 2000.0);
+        assert!((result.position_value - 100000.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_volatility_based_size_zero_vol() {
+        let result = volatility_based_size(100000.0, 0.02, 0.0, 100.0);
+        assert_eq!(result.shares, 0);
+    }
+
+    #[test]
+    fn test_kelly_size() {
+        let size = kelly_size(0.10, 0.04, 100000.0, 1.0);
+        assert!((size - 250000.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_kelly_size_half() {
+        let size = kelly_size(0.10, 0.04, 100000.0, 0.5);
+        assert!((size - 125000.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_kelly_size_zero_variance() {
+        let size = kelly_size(0.10, 0.0, 100000.0, 1.0);
+        assert_eq!(size, 0.0);
+    }
+}

package/src/risk/var.rs

@@ -0,0 +1,222 @@
+//! Value at Risk (VaR) Functions
+//!
+//! Historical and parametric VaR calculations with Expected Shortfall (CVaR).
+
+use serde::{Deserialize, Serialize};
+
+use crate::utils::{mean, std_dev};
+
+/// Configuration for VaR calculation
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct VaRConfig {
+    /// Confidence level for VaR (default: 0.95)
+    pub confidence_level: f64,
+}
+
+impl Default for VaRConfig {
+    fn default() -> Self {
+        VaRConfig {
+            confidence_level: 0.95,
+        }
+    }
+}
+
+/// Result of VaR calculation containing both 95% and 99% confidence levels
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VaRResult {
+    /// Value at Risk at 95% confidence
+    pub var95: f64,
+    /// Value at Risk at 99% confidence
+    pub var99: f64,
+    /// Expected Shortfall (CVaR) at 95% confidence
+    pub expected_shortfall95: f64,
+    /// Expected Shortfall (CVaR) at 99% confidence
+    pub expected_shortfall99: f64,
+}
+
+/// Calculate historical Value at Risk
+///
+/// Uses historical simulation to estimate potential losses at a given confidence level.
+///
+/// # Arguments
+/// * `returns` - Array of historical returns
+/// * `confidence` - Confidence level (e.g., 0.95 for 95%)
+///
+/// # Returns
+/// VaR as a positive number representing potential loss
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::var::historical_var;
+/// let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+/// let var = historical_var(&returns, 0.95);
+/// assert!(var > 0.0);
+/// ```
+pub fn historical_var(returns: &[f64], confidence: f64) -> f64 {
+    if returns.is_empty() {
+        return 0.0;
+    }
+
+    let mut sorted = returns.to_vec();
+    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+    let index = ((1.0 - confidence) * returns.len() as f64).floor() as usize;
+    let index = index.min(sorted.len() - 1);
+
+    sorted[index].abs()
+}
+
+/// Calculate parametric Value at Risk (assuming normal distribution)
+///
+/// Uses the assumption of normally distributed returns to estimate VaR.
+///
+/// # Arguments
+/// * `returns` - Array of historical returns
+/// * `confidence` - Confidence level (e.g., 0.95 for 95%)
+///
+/// # Returns
+/// VaR as a positive number representing potential loss
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::var::parametric_var;
+/// let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+/// let var = parametric_var(&returns, 0.95);
+/// assert!(var > 0.0);
+/// ```
+pub fn parametric_var(returns: &[f64], confidence: f64) -> f64 {
+    if returns.is_empty() {
+        return 0.0;
+    }
+
+    let avg = mean(returns);
+    let sd = std_dev(returns, false); // Sample std dev
+
+    // Z-scores for common confidence levels
+    let z = match confidence {
+        c if (c - 0.90).abs() < 1e-6 => 1.282,
+        c if (c - 0.95).abs() < 1e-6 => 1.645,
+        c if (c - 0.99).abs() < 1e-6 => 2.326,
+        _ => 1.645, // Default to 95%
+    };
+
+    (avg - z * sd).abs()
+}
+
+/// Calculate VaR and Expected Shortfall (CVaR) at 95% and 99% confidence
+///
+/// Comprehensive VaR calculation returning both VaR and Expected Shortfall
+/// at two common confidence levels.
+///
+/// # Arguments
+/// * `returns` - Array of historical returns
+/// * `config` - Optional configuration (uses defaults if not provided)
+///
+/// # Returns
+/// VaRResult containing VaR and CVaR at 95% and 99%
+///
+/// # Example
+/// ```
+/// use quant_rust::risk::var::{calculate_var, VaRConfig};
+/// let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+/// let result = calculate_var(&returns, VaRConfig::default());
+/// assert!(result.var95 > 0.0);
+/// assert!(result.var99 >= result.var95);
+/// assert!(result.expected_shortfall95 >= result.var95);
+/// ```
+pub fn calculate_var(returns: &[f64], _config: VaRConfig) -> VaRResult {
+    if returns.is_empty() {
+        return VaRResult {
+            var95: 0.0,
+            var99: 0.0,
+            expected_shortfall95: 0.0,
+            expected_shortfall99: 0.0,
+        };
+    }
+
+    let mut sorted = returns.to_vec();
+    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+    let index95 = ((1.0 - 0.95) * returns.len() as f64).floor() as usize;
+    let index99 = ((1.0 - 0.99) * returns.len() as f64).floor() as usize;
+
+    let index95 = index95.min(sorted.len() - 1);
+    let index99 = index99.min(sorted.len() - 1);
+
+    let var95 = sorted[index95].abs();
+    let var99 = sorted[index99].abs();
+
+    // Expected Shortfall (average of returns below VaR)
+    let tail95: Vec<f64> = sorted.iter().take(index95 + 1).cloned().collect();
+    let tail99: Vec<f64> = sorted.iter().take(index99 + 1).cloned().collect();
+
+    let expected_shortfall95 = if tail95.is_empty() {
+        var95
+    } else {
+        tail95.iter().sum::<f64>().abs() / tail95.len() as f64
+    };
+
+    let expected_shortfall99 = if tail99.is_empty() {
+        var99
+    } else {
+        tail99.iter().sum::<f64>().abs() / tail99.len() as f64
+    };
+
+    VaRResult {
+        var95,
+        var99,
+        expected_shortfall95,
+        expected_shortfall99,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_historical_var() {
+        let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+        let var = historical_var(&returns, 0.95);
+        assert!(var > 0.0);
+        assert!(var <= 0.1);
+    }
+
+    #[test]
+    fn test_historical_var_empty() {
+        let var = historical_var(&[], 0.95);
+        assert_eq!(var, 0.0);
+    }
+
+    #[test]
+    fn test_parametric_var() {
+        let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+        let var = parametric_var(&returns, 0.95);
+        assert!(var > 0.0);
+    }
+
+    #[test]
+    fn test_parametric_var_99() {
+        let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+        let var95 = parametric_var(&returns, 0.95);
+        let var99 = parametric_var(&returns, 0.99);
+        assert!(var99 >= var95);
+    }
+
+    #[test]
+    fn test_calculate_var() {
+        let returns = vec![-0.05, -0.02, 0.01, 0.03, 0.02, -0.04, 0.05, -0.01, 0.02, 0.01];
+        let result = calculate_var(&returns, VaRConfig::default());
+        assert!(result.var95 > 0.0);
+        assert!(result.var99 >= result.var95);
+        assert!(result.expected_shortfall95 >= result.var95);
+        assert!(result.expected_shortfall99 >= result.var99);
+    }
+
+    #[test]
+    fn test_calculate_var_empty() {
+        let result = calculate_var(&[], VaRConfig::default());
+        assert_eq!(result.var95, 0.0);
+        assert_eq!(result.var99, 0.0);
+    }
+}