refactor(big rational): fraction to denom and numer

Author: cong-or

Cargo.lock

@@ -33,6 +33,7 @@ rand = "0.8"
 cryptoxide = "0.4"
 tracing.workspace = true
 bigdecimal = "0.4.7"
+num = "0.4.3"
 
 
 [features]

src/chain-libs/chain-impl-mockchain/Cargo.toml

@@ -6,6 +6,8 @@ use crate::{
 use bigdecimal::BigDecimal;
 use bigdecimal::ToPrimitive;
 use chain_vote::EncryptedTally;
+use num::BigRational;
+use num::{BigInt, FromPrimitive};
 use std::num::NonZeroI64;
 
 use std::str::FromStr;
@@ -177,19 +179,19 @@ impl TallyResult {
             const PRECISION: &str = "QUADRATIC_VOTING_PRECISION";
 
             // Apply quadratic scaling if gamma value specified in env var. Else gamma is 1 and has no effect.
-            let gamma = env::var(GAMMA).unwrap_or(1.to_string());
+            let gamma = f64::from_str(&env::var(GAMMA).unwrap_or(1.0.to_string())).unwrap();
 
             let precision =
                 i64::from_str(&env::var(PRECISION).unwrap_or(1.to_string())).unwrap_or(1);
 
-            let mut gamma = BigDecimal::from_str(&gamma).unwrap_or(BigDecimal::from(1));
-            // Gamma must be between 0 and 1, anything else is treated as bad input; defaulting gamma to 1.
-            if gamma < BigDecimal::from(0) || gamma > BigDecimal::from(1) {
-                gamma = BigDecimal::from(1);
-            }
+            let gamma =
+                BigRational::from_f64(gamma).unwrap_or(BigRational::from_integer(BigInt::from(1)));
+            let denom = BigDecimal::from_bigint(gamma.denom().clone(), precision);
+            let numer = BigDecimal::from_bigint(gamma.numer().clone(), precision);
+
             let stake = BigDecimal::from(weight.0);
 
-            let weight = (gamma * stake)
+            let weight = ((stake.clone() * numer.clone()) / denom)
                 .round(precision)
                 .to_u64()
                 .unwrap_or(weight.0);

src/chain-libs/chain-impl-mockchain/src/vote/tally.rs

@@ -15,6 +15,8 @@ cryptoxide = "^0.4.2"
 const_format = "0.2"
 base64 = "0.21.0"
 bigdecimal = "0.4.7"
+num = "0.4.3"
+tracing = "*"
 
 
 [dev-dependencies]

src/chain-libs/chain-vote/Cargo.toml

@@ -12,6 +12,10 @@ use crate::{
     TallyOptimizationTable,
 };
 use base64::{engine::general_purpose, Engine as _};
+use num::BigInt;
+use num::BigRational;
+use num::FromPrimitive;
+use tracing::info;
 
 use bigdecimal::BigDecimal;
 use bigdecimal::ToPrimitive;
@@ -169,17 +173,22 @@ impl EncryptedTally {
         const PRECISION: &str = "QUADRATIC_VOTING_PRECISION";
 
         // Apply quadratic scaling if gamma value specified in env var. Else gamma is 1 and has no effect.
-        let gamma = env::var(GAMMA).unwrap_or(1.to_string());
+        let gamma = f64::from_str(&env::var(GAMMA).unwrap_or(1.0.to_string())).unwrap();
         let precision = i64::from_str(&env::var(PRECISION).unwrap_or(1.to_string())).unwrap_or(1);
 
-        let mut gamma = BigDecimal::from_str(&gamma).unwrap_or(BigDecimal::from(1));
-        // Gamma must be between 0 and 1, anything else is treated as bad input; defaulting gamma to 1.
-        if gamma < BigDecimal::from(0) || gamma > BigDecimal::from(1) {
-            gamma = BigDecimal::from(1);
-        }
+        let gamma =
+            BigRational::from_f64(gamma).unwrap_or(BigRational::from_integer(BigInt::from(1)));
+        let denom = BigDecimal::from_bigint(gamma.denom().clone(), precision);
+        let numer = BigDecimal::from_bigint(gamma.numer().clone(), precision);
+
         let stake = BigDecimal::from(weight);
 
-        let weight = (gamma * stake).round(precision).to_u64().unwrap_or(weight);
+        let weight = ((stake.clone() * numer.clone()) / denom)
+            .round(precision)
+            .to_u64()
+            .unwrap_or(weight);
+
+        info!("stake before {:?} stake after {:?}", stake.to_u64(), weight);
 
         for (ri, ci) in self.r.iter_mut().zip(ballot.vote().iter()) {
             *ri = &*ri + &(ci * weight);