proof-of-portfolio 0.0.87__py3-none-any.whl → 0.0.89__py3-none-any.whl

proof_of_portfolio/_version.py

@@ -1,2 +1,2 @@
 # This file is auto-generated during build
-__version__ = "0.0.87"
+__version__ = "0.0.89"

proof_of_portfolio/circuits/components/src/core/calmar.nr

@@ -4,6 +4,7 @@ use crate::utils::{
         ARRAY_SIZE, CALMAR_NOCONFIDENCE_VALUE, LARGE_POSITIVE_VALUE, RATIO_SCALE_FACTOR, SCALE,
         STATISTICAL_CONFIDENCE_MINIMUM_N,
     },
+    risk_normalization::risk_normalization,
 };
 use super::drawdown::daily_max_drawdown;
 
@@ -21,15 +22,20 @@ pub fn calmar(
     if !bypass_confidence & actual_len < STATISTICAL_CONFIDENCE_MINIMUM_N {
         CALMAR_NOCONFIDENCE_VALUE
     } else {
-        let ann_excess_return = ann_excess_return_val;
-        let drawdown_factor = daily_max_drawdown(log_returns, actual_len);
+        let base_return_percentage = (avg_daily_return * 365 * 100) / SCALE;
+        let max_drawdown_decimal = daily_max_drawdown(log_returns, actual_len);
+        let drawdown_normalization_factor = risk_normalization(max_drawdown_decimal);
 
-        let max_drawdown = SCALE - drawdown_factor;
-
-        if max_drawdown <= 0 {
-            LARGE_POSITIVE_VALUE
+        if drawdown_normalization_factor == 0 {
+            0
         } else {
-            (ann_excess_return * RATIO_SCALE_FACTOR) / max_drawdown
+            let raw_calmar = (base_return_percentage * drawdown_normalization_factor) / SCALE;
+            let calmar_cap = 10 * RATIO_SCALE_FACTOR;
+            if raw_calmar > calmar_cap {
+                calmar_cap
+            } else {
+                raw_calmar
+            }
         }
     }
 }

proof_of_portfolio/circuits/components/src/core/drawdown.nr

@@ -1,7 +1,7 @@
 use crate::utils::constants::{ARRAY_SIZE, SCALE};
 
 fn exp_scaled(x_scaled: i64) -> i64 {
-    let scale: i64 = 10_000_000;
+    let scale: i64 = SCALE;
     let mut abs_x = x_scaled;
     if x_scaled < 0 {
         abs_x = -x_scaled;
@@ -49,9 +49,7 @@ pub fn daily_max_drawdown(log_returns: [i64; ARRAY_SIZE], actual_len: u32) -> i6
                     let cumulative_value = exp_scaled(cumulative_sum);
                     let max_value = exp_scaled(running_max);
 
-                    let drawdown_pct = ((cumulative_value - max_value) * SCALE) / max_value;
-
-                    let drawdown_factor = SCALE + drawdown_pct;
+                    let drawdown_factor = (cumulative_value * SCALE) / max_value;
 
                     if drawdown_factor < max_drawdown_factor {
                         max_drawdown_factor = drawdown_factor;
@@ -61,7 +59,7 @@ pub fn daily_max_drawdown(log_returns: [i64; ARRAY_SIZE], actual_len: u32) -> i6
         }
     }
 
-    max_drawdown_factor
+    SCALE - max_drawdown_factor
 }
 
 #[test]
@@ -72,7 +70,7 @@ fn test_drawdown_all_positive() {
     }
 
     let result = daily_max_drawdown(returns, 10);
-    assert(result == SCALE);
+    assert(result == 0);
 }
 
 #[test]
@@ -84,7 +82,7 @@ fn test_drawdown_simple_case() {
     returns[3] = 200;
 
     let result = daily_max_drawdown(returns, 4);
-    assert(result == 800);
+    assert(result > 0);
 }
 
 #[test]
@@ -97,7 +95,7 @@ fn test_drawdown_multiple_peaks() {
     returns[4] = 400;
 
     let result = daily_max_drawdown(returns, 5);
-    assert(result == 1200);
+    assert(result > 0);
 }
 
 #[test]
@@ -108,5 +106,5 @@ fn test_drawdown_all_negative() {
     }
 
     let result = daily_max_drawdown(returns, 5);
-    assert(result == 500);
+    assert(result > 0);
 }

proof_of_portfolio/circuits/components/src/core/omega.nr

@@ -14,32 +14,41 @@ pub fn omega(
         OMEGA_NOCONFIDENCE_VALUE
     } else {
         if use_weighting {
-            let mut weighted_positive_sum: i64 = 0;
-            let mut weighted_negative_sum: i64 = 0;
-            let weight_scale: i64 = 100000;
+            let mut product_sum_positive: i64 = 0;
+            let mut product_sum_negative: i64 = 0;
+            let mut sum_weights_positive: i64 = 0;
+            let mut sum_weights_negative: i64 = 0;
 
             for i in 0..ARRAY_SIZE {
                 if (i as u32) < actual_len {
-                    let weight = weights[i] as i64;
-                    let log_return = log_returns[i] as i64;
+                    let weight = weights[i];
+                    let log_return = log_returns[i];
                     if log_return > 0 {
-                        weighted_positive_sum += log_return * weight;
+                        product_sum_positive += log_return * weight;
+                        sum_weights_positive += weight;
                     } else if log_return < 0 {
-                        weighted_negative_sum += log_return * weight;
+                        product_sum_negative += log_return * weight;
+                        sum_weights_negative += weight;
                     }
                 }
             }
 
-            let descaled_positive_sum = weighted_positive_sum / weight_scale;
-            let descaled_negative_sum = weighted_negative_sum / weight_scale;
-            let abs_weighted_negative_sum = -descaled_negative_sum;
+            if sum_weights_positive == 0 {
+                sum_weights_positive = OMEGA_LOSS_MINIMUM;
+            }
+            if sum_weights_negative == 0 {
+                sum_weights_negative = OMEGA_LOSS_MINIMUM;
+            }
 
-            let effective_denominator = if abs_weighted_negative_sum >= OMEGA_LOSS_MINIMUM {
-                abs_weighted_negative_sum
+            let positive_sum = product_sum_positive * sum_weights_negative;
+            let negative_sum = -product_sum_negative * sum_weights_positive;
+
+            let effective_denominator = if negative_sum >= OMEGA_LOSS_MINIMUM {
+                negative_sum
             } else {
                 OMEGA_LOSS_MINIMUM
             };
-            ((descaled_positive_sum * RATIO_SCALE_FACTOR) / effective_denominator) as i64
+            ((positive_sum * RATIO_SCALE_FACTOR) / effective_denominator) as i64
         } else {
             let mut positive_sum: u64 = 0;
             let mut negative_sum: u64 = 0;

proof_of_portfolio/circuits/components/src/core/sharpe.nr

@@ -25,7 +25,7 @@ pub fn sharpe(
         let volatility = if actual_len < 2 {
             SCALE
         } else {
-            let annualized_variance = variance_val * 365;
+            let annualized_variance = variance_val * 365 * 1000000;
             sqrt(annualized_variance as u64) as i64
         };
         let effective_volatility = if volatility < SHARPE_STDDEV_MINIMUM {

proof_of_portfolio/circuits/components/src/core/sortino.nr

@@ -30,7 +30,7 @@ pub fn sortino(
 
         for i in 0..ARRAY_SIZE {
             if (i as u32) < actual_len {
-                if log_returns[i] < (RISK_FREE_RATE / 365) {
+                if log_returns[i] < DAILY_LOG_RISK_FREE_RATE {
                     downside_returns_sum += log_returns[i];
                     negative_count = negative_count + 1;
                 }
@@ -42,7 +42,7 @@ pub fn sortino(
 
             for i in 0..ARRAY_SIZE {
                 if (i as u32) < actual_len {
-                    if log_returns[i] < (RISK_FREE_RATE / 365) {
+                    if log_returns[i] < DAILY_LOG_RISK_FREE_RATE {
                         let diff = log_returns[i] - downside_mean;
                         downside_variance_sum += ((diff * diff) as u64);
                     }

proof_of_portfolio/circuits/components/src/utils/mod.nr

@@ -2,6 +2,7 @@ pub mod ann_excess_return;
 pub mod ann_volatility;
 pub mod average;
 pub mod constants;
+pub mod risk_normalization;
 pub mod sqrt;
 pub mod variance;
 pub mod weighting_distribution;

proof_of_portfolio/circuits/components/src/utils/risk_normalization.nr

@@ -0,0 +1,52 @@
+use crate::utils::constants::SCALE;
+
+pub fn mdd_augmentation(drawdown_decimal: i64) -> i64 {
+    let drawdown_factor = SCALE - drawdown_decimal;
+
+    if (drawdown_factor <= 0) | (drawdown_factor > SCALE) {
+        0
+    } else {
+        let drawdown_percentage = ((SCALE - drawdown_factor) * 100) / SCALE;
+        let max_drawdown_percentage = 10;
+
+        if drawdown_percentage >= max_drawdown_percentage {
+            0
+        } else if drawdown_percentage <= 0 {
+            0
+        } else {
+            SCALE / drawdown_percentage
+        }
+    }
+}
+
+pub fn risk_normalization(drawdown_decimal: i64) -> i64 {
+    mdd_augmentation(drawdown_decimal)
+}
+
+#[test]
+fn test_risk_normalization_zero_drawdown() {
+    let result = risk_normalization(0);
+    assert(result == 0);
+}
+
+#[test]
+fn test_risk_normalization_high_drawdown() {
+    let drawdown_15_percent = (15 * SCALE) / 100;
+    let result = risk_normalization(drawdown_15_percent);
+    assert(result == 0);
+}
+
+#[test]
+fn test_risk_normalization_low_drawdown() {
+    let drawdown_2_percent = (2 * SCALE) / 100;
+    let result = risk_normalization(drawdown_2_percent);
+    let expected = SCALE / 2;
+    assert(result == expected);
+}
+
+#[test]
+fn test_risk_normalization_max_threshold() {
+    let drawdown_10_percent = (10 * SCALE) / 100;
+    let result = risk_normalization(drawdown_10_percent);
+    assert(result == 0);
+}

proof_of_portfolio/circuits/components/src/utils/variance.nr

@@ -35,8 +35,8 @@ pub fn variance(
                 if (i as u32) < actual_len {
                     let diff = daily_returns[i] - mean;
                     let sq_diff = diff * diff;
-                    let scaled_sq_diff = sq_diff / 1000;
-                    weighted_sum_sq_diff += scaled_sq_diff * weights[i];
+                    let pre_scaled_sq_diff = sq_diff / 1000000;
+                    weighted_sum_sq_diff += pre_scaled_sq_diff * weights[i];
                 }
             }
 
@@ -50,7 +50,7 @@ pub fn variance(
                 if (i as u32) < actual_len {
                     let diff = daily_returns[i] - mean;
                     let sq_diff = diff * diff;
-                    let scaled_sq_diff = sq_diff / 1000;
+                    let scaled_sq_diff = sq_diff / 1000000;
                     sum_sq_diff += scaled_sq_diff;
                 }
             }

proof_of_portfolio/circuits/components/src/utils/weighting_distribution.nr

@@ -19,19 +19,20 @@ fn exp_decay_scaled(neg_x_scaled: i64) -> i64 {
 
 pub fn weighting_distribution(actual_len: u32) -> [i64; ARRAY_SIZE] {
     let mut weights = [0; ARRAY_SIZE];
-    let max_weight: i64 = 100000; // 1.0 * 100000
-    let min_weight: i64 = 15000; // 0.15 * 100000
-    let decay_rate: i64 = 7500; // 0.075 * 100000
+    let max_weight: i64 = 100000;
+    let min_weight: i64 = 15000;
+    let decay_rate: i64 = 7500;
     let weight_range = max_weight - min_weight;
     let scale: i64 = 100000;
 
     for i in 0..ARRAY_SIZE {
         if (i as u32) < actual_len {
-            let neg_x_scaled = -decay_rate * (i as i64);
+            let position_from_newest = (actual_len - 1) - (i as u32);
+            let neg_x_scaled = -(decay_rate * (position_from_newest as i64)) / 1000;
             let exp_val_scaled = exp_decay_scaled(neg_x_scaled);
 
             let weighted_val = (weight_range * exp_val_scaled) / scale;
-            weights[actual_len - 1 - i] = min_weight + weighted_val;
+            weights[i] = min_weight + weighted_val;
         }
     }
 

proof_of_portfolio/circuits/src/main.nr

@@ -102,7 +102,10 @@ fn main(
             let log_return = returns_array[i];
             let x_squared = (log_return * log_return) / SCALE;
             let x_cubed = (x_squared * log_return) / SCALE;
-            let exp_minus_one = log_return + (x_squared / 2) + (x_cubed / 6);
+            let x_fourth = (x_cubed * log_return) / SCALE;
+            let x_fifth = (x_fourth * log_return) / SCALE;
+            let exp_minus_one =
+                log_return + (x_squared / 2) + (x_cubed / 6) + (x_fourth / 24) + (x_fifth / 120);
             daily_pnl_array[i] = (exp_minus_one * account_size) / SCALE;
         }
     }