proof-of-portfolio 0.0.102__py3-none-any.whl → 0.0.104__py3-none-any.whl

proof_of_portfolio/_version.py

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

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

@@ -1,9 +1,6 @@
-use crate::utils::{
-    constants::{
-        ARRAY_SIZE, CALMAR_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, SCALE,
-        STATISTICAL_CONFIDENCE_MINIMUM_N,
-    },
-    risk_normalization::risk_normalization,
+use crate::utils::constants::{
+    ARRAY_SIZE, CALMAR_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, SCALE,
+    STATISTICAL_CONFIDENCE_MINIMUM_N,
 };
 use super::drawdown::daily_max_drawdown;
 
@@ -14,24 +11,22 @@ pub fn calmar(
     avg_daily_return: i64,
     calmar_cap: i64,
     days_in_year: i64,
-    drawdown_max_percent: i64,
+    _drawdown_max_percent: i64,
 ) -> i64 {
     if !bypass_confidence & actual_len < STATISTICAL_CONFIDENCE_MINIMUM_N {
         CALMAR_NOCONFIDENCE_VALUE
     } else {
-        let base_return_percentage = (avg_daily_return * days_in_year * 100) / SCALE;
-        let max_drawdown_decimal = daily_max_drawdown(log_returns, actual_len) / SCALE;
-        let drawdown_normalization_factor =
-            risk_normalization(max_drawdown_decimal, drawdown_max_percent);
+        let ann_excess_return = avg_daily_return * days_in_year;
+        let max_drawdown_decimal = daily_max_drawdown(log_returns, actual_len);
 
-        if drawdown_normalization_factor == 0 {
+        if (max_drawdown_decimal == 0) | (ann_excess_return <= 0) {
             0
         } else {
-            let raw_calmar = base_return_percentage * drawdown_normalization_factor;
-            if raw_calmar > calmar_cap {
+            let raw_calmar = (ann_excess_return * RATIO_SCALE_FACTOR) / max_drawdown_decimal;
+            if raw_calmar > (calmar_cap * RATIO_SCALE_FACTOR) {
                 calmar_cap * RATIO_SCALE_FACTOR
             } else {
-                raw_calmar * RATIO_SCALE_FACTOR
+                raw_calmar
             }
         }
     }

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

@@ -18,8 +18,8 @@ pub fn omega(
         if use_weighting {
             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;
+            let mut sum_weights_positive_raw: i64 = 0;
+            let mut sum_weights_negative_raw: i64 = 0;
 
             for i in 0..ARRAY_SIZE {
                 if (i as u32) < actual_len {
@@ -27,31 +27,36 @@ pub fn omega(
                     let log_return = log_returns[i];
                     if log_return > 0 {
                         product_sum_positive += log_return * weight;
-                        sum_weights_positive += weight;
+                        sum_weights_positive_raw += weight;
                     } else {
                         product_sum_negative += log_return * weight;
-                        sum_weights_negative += weight;
+                        sum_weights_negative_raw += weight;
                     }
                 }
             }
 
-            let mean_pos = if sum_weights_positive != 0 {
-                product_sum_positive / sum_weights_positive
+            // Apply max with omega_loss_min like in Python reference
+            let sum_weights_positive = if sum_weights_positive_raw >= omega_loss_min {
+                sum_weights_positive_raw
             } else {
-                0
+                omega_loss_min
             };
-            let mean_neg = if sum_weights_negative != 0 {
-                (-product_sum_negative) / sum_weights_negative
+            let sum_weights_negative = if sum_weights_negative_raw >= omega_loss_min {
+                sum_weights_negative_raw
             } else {
-                0
+                omega_loss_min
             };
 
-            let effective_denominator = if mean_neg >= omega_loss_min {
-                mean_neg
+            // Apply cross-multiplication like in PTN reference implementation
+            let positive_sum_weighted = product_sum_positive * sum_weights_negative;
+            let negative_sum_weighted = product_sum_negative * sum_weights_positive;
+
+            let effective_denominator = if (-negative_sum_weighted) >= omega_loss_min {
+                -negative_sum_weighted
             } else {
                 omega_loss_min
             };
-            (mean_pos * RATIO_SCALE_FACTOR) / effective_denominator
+            (positive_sum_weighted * RATIO_SCALE_FACTOR) / effective_denominator
         } else {
             let mut positive_sum: i64 = 0;
             let mut negative_sum: i64 = 0;