proof-of-portfolio 0.0.107__py3-none-any.whl → 0.0.109__py3-none-any.whl

proof_of_portfolio/_version.py

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

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

@@ -35,7 +35,6 @@ pub fn omega(
                 }
             }
 
-            // 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 {
@@ -47,20 +46,18 @@ pub fn omega(
                 omega_loss_min
             };
 
-            // Apply PTN cross-multiplication with overflow-safe scaling
-            // positive_sum = product_sum_positive * sum_weights_negative
-            // negative_sum = product_sum_negative * sum_weights_positive
-            // final = (positive_sum * RATIO_SCALE_FACTOR) / max(abs(negative_sum), omega_loss_min)
-
-            // Scale down product_sums first to prevent overflow in cross-multiplication
-            let scale_factor = 1000000; // Scale down by 1M to prevent overflow
+            let scale_factor = 1000000;
             let product_sum_positive_scaled = product_sum_positive / scale_factor;
             let product_sum_negative_scaled = product_sum_negative / scale_factor;
 
             let positive_cross = product_sum_positive_scaled * sum_weights_negative;
             let negative_cross = product_sum_negative_scaled * sum_weights_positive;
 
-            let abs_negative = if negative_cross >= 0 { negative_cross } else { -negative_cross };
+            let abs_negative = if negative_cross >= 0 {
+                negative_cross
+            } else {
+                -negative_cross
+            };
             let omega_loss_min_scaled = omega_loss_min / scale_factor;
             let effective_denominator = if abs_negative >= omega_loss_min_scaled {
                 abs_negative
@@ -68,9 +65,6 @@ pub fn omega(
                 omega_loss_min_scaled
             };
 
-            // Adjust final calculation to account for scale_factor
-            // Original formula: (positive_cross * RATIO_SCALE_FACTOR) / effective_denominator
-            // With scaling: (positive_cross_scaled * RATIO_SCALE_FACTOR * scale_factor) / effective_denominator_scaled
             let adjusted_ratio_scale = RATIO_SCALE_FACTOR * scale_factor;
 
             if effective_denominator >= adjusted_ratio_scale {
@@ -163,7 +157,7 @@ fn test_omega_ptn_parity() {
     returns[1] = -20000000;
     returns[2] = 0;
     returns[3] = 15000000;
-    let weights = [0; ARRAY_SIZE]; // not used since unweighted
+    let weights = [0; ARRAY_SIZE];
     let result = omega(returns, 4, weights, false, true, 10000000, 0);
     assert(result == 1250000);
 }
@@ -171,13 +165,13 @@ fn test_omega_ptn_parity() {
 #[test]
 fn test_omega_scaling() {
     let mut log_returns = [0; ARRAY_SIZE];
-    log_returns[0] = SCALE / 100; // 0.01 * SCALE
-    log_returns[1] = -SCALE / 200; // -0.005 * SCALE
+    log_returns[0] = SCALE / 100;
+    log_returns[1] = -SCALE / 200;
     let actual_len = 60u32;
     let weights = [100000; ARRAY_SIZE];
     let use_weighting = false;
     let bypass_confidence = true;
-    let omega_loss_min = SCALE / 10; // 0.1 * SCALE
+    let omega_loss_min = SCALE / 10;
     let daily_rf = 0;
     let result = omega(
         log_returns,
@@ -188,25 +182,17 @@ fn test_omega_scaling() {
         omega_loss_min,
         daily_rf,
     );
-    assert(result > 0); // scaling test, result should be positive
+    assert(result > 0);
 }
 
 #[test]
 fn test_omega_parity() {
     let mut returns = [0; ARRAY_SIZE];
-    returns[0] = 1000000i64; // 0.01 * SCALE
-    returns[1] = -2000000i64; // -0.02 * SCALE
-    returns[2] = 1500000i64; // 0.015 * SCALE
+    returns[0] = 1000000i64;
+    returns[1] = -2000000i64;
+    returns[2] = 1500000i64;
     let weights = [100000i64; ARRAY_SIZE];
-    let result = omega(
-        returns,
-        3u32,
-        weights,
-        false,
-        true,
-        10000000i64, // 0.1 * SCALE
-        0i64,
-    );
+    let result = omega(returns, 3u32, weights, false, true, 10000000i64, 0i64);
     let expected = 250000i64;
     let diff = if result > expected {
         result - expected