mirror of
https://github.com/darkrenaissance/darkfi.git
synced 2026-01-09 14:48:08 -05:00
94 lines
3.0 KiB
Rust
94 lines
3.0 KiB
Rust
/* This file is part of DarkFi (https://dark.fi)
|
|
*
|
|
* Copyright (C) 2020-2022 Dyne.org foundation
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
use darkfi_sdk::pasta::pallas;
|
|
use dashu::integer::{IBig, Sign};
|
|
use log::debug;
|
|
|
|
use super::Float10;
|
|
|
|
pub fn fbig2ibig(f: Float10) -> IBig {
|
|
let rad = IBig::try_from(10).unwrap();
|
|
let sig = f.repr().significand();
|
|
let exp = f.repr().exponent();
|
|
let val: IBig = if exp >= 0 { sig.clone() * rad.pow(exp as usize) } else { sig.clone() };
|
|
debug!("fbig2ibig (f): {}", f);
|
|
debug!("fbig2ibig (i): {}", val);
|
|
val
|
|
}
|
|
/*
|
|
pub fn base2ibig(base: pallas::Base) -> IBig {
|
|
//
|
|
let byts: [u8; 32] = base.to_repr();
|
|
let words: [u64; 4] = [
|
|
u64::from_le_bytes(byts[0..8].try_into().expect("")),
|
|
u64::from_le_bytes(byts[8..16].try_into().expect("")),
|
|
u64::from_le_bytes(byts[16..24].try_into().expect("")),
|
|
u64::from_le_bytes(byts[24..32].try_into().expect("")),
|
|
];
|
|
let uparts = UBig::from_words(&words);
|
|
//TODO both y, and t are positive, but workout the sign for general use
|
|
let ibig = IBig::from_parts(Sign::Positive, uparts);
|
|
ibig
|
|
}
|
|
*/
|
|
pub fn fbig2base(f: Float10) -> pallas::Base {
|
|
debug!("fbig -> base (f): {}", f);
|
|
let val: IBig = fbig2ibig(f);
|
|
let (sign, word) = val.as_sign_words();
|
|
let mut words: [u64; 4] = [0, 0, 0, 0];
|
|
words[..word.len()].copy_from_slice(word);
|
|
match sign {
|
|
Sign::Positive => pallas::Base::from_raw(words),
|
|
Sign::Negative => pallas::Base::from_raw(words).neg(),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use dashu::integer::IBig;
|
|
|
|
use crate::consensus::{constants::RADIX_BITS, types::Float10, utils::fbig2ibig};
|
|
|
|
#[test]
|
|
fn dashu_fbig2ibig() {
|
|
let f =
|
|
Float10::from_str_native("234234223.000").unwrap().with_precision(RADIX_BITS).value();
|
|
let i: IBig = fbig2ibig(f);
|
|
let sig = IBig::from(234234223);
|
|
assert_eq!(i, sig);
|
|
}
|
|
|
|
/*
|
|
#[test]
|
|
fn dashu_test_base2ibig() {
|
|
//
|
|
let fbig: Float10 = Float10::from_str_native(
|
|
"28948022309329048855892746252171976963363056481941560715954676764349967630337",
|
|
)
|
|
.unwrap()
|
|
.with_precision(RADIX_BITS)
|
|
.value();
|
|
let ibig = fbig2ibig(fbig.clone());
|
|
let res_base: pallas::Base = fbig2base(fbig.clone());
|
|
let res_ibig: IBig = base2ibig(res_base);
|
|
assert_eq!(res_ibig, ibig);
|
|
}
|
|
*/
|
|
}
|