proof-of-portfolio 0.0.91__py3-none-any.whl → 0.0.92__py3-none-any.whl

proof_of_portfolio/_version.py

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

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

@@ -24,33 +24,71 @@ pub fn sortino(
     } else {
         let excess_return = ann_excess_return_val;
 
-        let mut downside_variance_sum: u64 = 0;
-        let mut negative_count: u32 = 0;
+        let mut weighted_sum_down: i64 = 0;
+        let mut sum_w_down: i64 = 0;
         let mut downside_returns_sum: i64 = 0;
+        let mut negative_count: u32 = 0;
 
         for i in 0..ARRAY_SIZE {
             if (i as u32) < actual_len {
                 if log_returns[i] < DAILY_LOG_RISK_FREE_RATE {
                     downside_returns_sum += log_returns[i];
-                    negative_count = negative_count + 1;
+                    negative_count += 1;
+                    if use_weighting {
+                        weighted_sum_down += log_returns[i] * weights[i];
+                        sum_w_down += weights[i];
+                    }
                 }
             }
         }
 
         if negative_count > 1 {
-            let downside_mean = downside_returns_sum / (negative_count as i64);
+            let downside_mean = if use_weighting {
+                if sum_w_down != 0 {
+                    weighted_sum_down / sum_w_down
+                } else {
+                    0
+                }
+            } else {
+                downside_returns_sum / (negative_count as i64)
+            };
 
-            for i in 0..ARRAY_SIZE {
-                if (i as u32) < actual_len {
-                    if log_returns[i] < DAILY_LOG_RISK_FREE_RATE {
-                        let diff = log_returns[i] - downside_mean;
-                        downside_variance_sum += ((diff * diff) as u64);
+            let downside_variance_pre = if use_weighting {
+                let mut weighted_sum_sq_diff: i64 = 0;
+                for i in 0..ARRAY_SIZE {
+                    if (i as u32) < actual_len {
+                        if log_returns[i] < DAILY_LOG_RISK_FREE_RATE {
+                            let diff = log_returns[i] - downside_mean;
+                            let sq_diff = (diff * diff) / 1000000;
+                            weighted_sum_sq_diff += sq_diff * weights[i];
+                        }
                     }
                 }
-            }
+                if sum_w_down != 0 {
+                    weighted_sum_sq_diff / sum_w_down
+                } else {
+                    0
+                }
+            } else {
+                let mut sum_sq_diff: i64 = 0;
+                for i in 0..ARRAY_SIZE {
+                    if (i as u32) < actual_len {
+                        if log_returns[i] < DAILY_LOG_RISK_FREE_RATE {
+                            let diff = log_returns[i] - downside_mean;
+                            let sq_diff = (diff * diff) / 1000000;
+                            sum_sq_diff += sq_diff;
+                        }
+                    }
+                }
+                if negative_count > 0 {
+                    sum_sq_diff / (negative_count as i64)
+                } else {
+                    0
+                }
+            };
 
-            let downside_variance = downside_variance_sum / ((negative_count - 1) as u64);
-            let downside_volatility = sqrt(downside_variance * (DAYS_IN_YEAR as u64)) as i64;
+            let annualized_variance = downside_variance_pre * (DAYS_IN_YEAR as i64) * 1000000;
+            let downside_volatility = sqrt(annualized_variance as u64) as i64;
 
             let effective_downside_volatility = if downside_volatility > SORTINO_DOWNSIDE_MINIMUM {
                 downside_volatility
@@ -60,7 +98,7 @@ pub fn sortino(
 
             (excess_return * RATIO_SCALE_FACTOR) / effective_downside_volatility
         } else {
-            LARGE_POSITIVE_VALUE
+            0
         }
     }
 }

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

@@ -1,20 +1,17 @@
 use crate::utils::constants::SCALE;
 
 pub fn mdd_augmentation(drawdown_decimal: i64) -> i64 {
-    let drawdown_factor = SCALE - drawdown_decimal;
+    let max_drawdown_percentage = 10;
 
-    if (drawdown_factor <= 0) | (drawdown_factor > SCALE) {
+    if (drawdown_decimal <= 0) | (drawdown_decimal >= SCALE) {
         0
     } else {
-        let drawdown_percentage = ((SCALE - drawdown_factor) * 100) / SCALE;
-        let max_drawdown_percentage = 10;
+        let dd_percent = (drawdown_decimal * 100) / SCALE;
 
-        if drawdown_percentage >= max_drawdown_percentage {
-            0
-        } else if drawdown_percentage <= 0 {
+        if dd_percent <= 0 | dd_percent >= max_drawdown_percentage {
             0
         } else {
-            SCALE / drawdown_percentage
+            SCALE / dd_percent
         }
     }
 }

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

@@ -55,11 +55,7 @@ pub fn variance(
                 }
             }
 
-            let denominator = if actual_len > ddof {
-                (actual_len - ddof) as i64
-            } else {
-                1
-            };
+            let denominator = actual_len as i64;
             variance = sum_sq_diff / denominator;
         }
     }

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

@@ -28,7 +28,7 @@ pub fn weighting_distribution(actual_len: u32) -> [i64; ARRAY_SIZE] {
     for i in 0..ARRAY_SIZE {
         if (i as u32) < actual_len {
             let position_from_newest = (actual_len - 1) - (i as u32);
-            let neg_x_scaled = -(decay_rate * (position_from_newest as i64)) / 1000;
+            let neg_x_scaled = -(decay_rate * (position_from_newest as i64)) / 1;
             let exp_val_scaled = exp_decay_scaled(neg_x_scaled);
 
             let weighted_val = (weight_range * exp_val_scaled) / scale;