forked from StrafesNET/strafe-project
219 lines
6.1 KiB
Rust
219 lines
6.1 KiB
Rust
use crate::types::I32F32;
|
|
use crate::types::I256F256;
|
|
|
|
#[test]
|
|
fn you_can_add_numbers(){
|
|
let a=I256F256::from((3i128*2).pow(4));
|
|
assert_eq!(a+a,I256F256::from((3i128*2).pow(4)*2));
|
|
}
|
|
|
|
#[test]
|
|
fn to_f32(){
|
|
let a=I256F256::from(1)>>2;
|
|
let f:f32=a.into();
|
|
assert_eq!(f,0.25f32);
|
|
let f:f32=(-a).into();
|
|
assert_eq!(f,-0.25f32);
|
|
let a=I256F256::from(0);
|
|
let f:f32=(-a).into();
|
|
assert_eq!(f,0f32);
|
|
let a=I256F256::from(237946589723468975i64)<<16;
|
|
let f:f32=a.into();
|
|
assert_eq!(f,237946589723468975f32*2.0f32.powi(16));
|
|
}
|
|
|
|
#[test]
|
|
fn to_f64(){
|
|
let a=I256F256::from(1)>>2;
|
|
let f:f64=a.into();
|
|
assert_eq!(f,0.25f64);
|
|
let f:f64=(-a).into();
|
|
assert_eq!(f,-0.25f64);
|
|
let a=I256F256::from(0);
|
|
let f:f64=(-a).into();
|
|
assert_eq!(f,0f64);
|
|
let a=I256F256::from(237946589723468975i64)<<16;
|
|
let f:f64=a.into();
|
|
assert_eq!(f,237946589723468975f64*2.0f64.powi(16));
|
|
}
|
|
|
|
#[test]
|
|
fn from_f32(){
|
|
let a=I256F256::from(1)>>2;
|
|
let b:Result<I256F256,_>=0.25f32.try_into();
|
|
assert_eq!(b,Ok(a));
|
|
let a=I256F256::from(-1)>>2;
|
|
let b:Result<I256F256,_>=(-0.25f32).try_into();
|
|
assert_eq!(b,Ok(a));
|
|
let a=I256F256::from(0);
|
|
let b:Result<I256F256,_>=0.try_into();
|
|
assert_eq!(b,Ok(a));
|
|
let a=I256F256::from(0b101011110101001010101010000000000000000000000000000i64)<<16;
|
|
let b:Result<I256F256,_>=(0b101011110101001010101010000000000000000000000000000u64 as f32*2.0f32.powi(16)).try_into();
|
|
assert_eq!(b,Ok(a));
|
|
//I32F32::MAX into f32 is truncated into this value
|
|
let a=I32F32::raw(0b111111111111111111111111000000000000000000000000000000000000000i64);
|
|
let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MAX).try_into();
|
|
assert_eq!(b,Ok(a));
|
|
//I32F32::MIN hits a special case since it's not representable as a positive signed integer
|
|
//TODO: don't return an overflow because this is technically possible
|
|
let a=I32F32::MIN;
|
|
let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
|
|
assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
|
|
//16 is within the 24 bits of float precision
|
|
let b:Result<I32F32,_>=Into::<f32>::into(-I32F32::MIN.fix_2()).try_into();
|
|
assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
|
|
let b:Result<I32F32,_>=f32::MIN_POSITIVE.try_into();
|
|
assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Underflow));
|
|
//test many cases
|
|
for i in 0..64{
|
|
let a=crate::fixed::Fixed::<2,64>::raw_digit(0b111111111111111111111111000000000000000000000000000000000000000i64)<<i;
|
|
let f:f32=a.into();
|
|
let b:Result<crate::fixed::Fixed<2,64>,_>=f.try_into();
|
|
assert_eq!(b,Ok(a));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn from_f64(){
|
|
let a=I256F256::from(1)>>2;
|
|
let b:Result<I256F256,_>=0.25f64.try_into();
|
|
assert_eq!(b,Ok(a));
|
|
let a=I256F256::from(-1)>>2;
|
|
let b:Result<I256F256,_>=(-0.25f64).try_into();
|
|
assert_eq!(b,Ok(a));
|
|
let a=I256F256::from(0);
|
|
let b:Result<I256F256,_>=0.try_into();
|
|
assert_eq!(b,Ok(a));
|
|
let a=I256F256::from(0b101011110101001010101010000000000000000000000000000i64)<<16;
|
|
let b:Result<I256F256,_>=(0b101011110101001010101010000000000000000000000000000u64 as f64*2.0f64.powi(16)).try_into();
|
|
assert_eq!(b,Ok(a));
|
|
}
|
|
|
|
#[test]
|
|
fn you_can_shr_numbers(){
|
|
let a=I32F32::from(4);
|
|
assert_eq!(a>>1,I32F32::from(2));
|
|
}
|
|
|
|
#[test]
|
|
fn test_wide_mul(){
|
|
let a=I32F32::ONE;
|
|
let aa=a.wide_mul_1_1(a);
|
|
assert_eq!(aa,crate::types::I64F64::ONE);
|
|
}
|
|
|
|
#[test]
|
|
fn test_wide_div(){
|
|
let a=I32F32::ONE*4;
|
|
let b=I32F32::ONE*2;
|
|
let wide_a=a.wide_mul_1_1(I32F32::ONE);
|
|
let wide_b=b.wide_mul_1_1(I32F32::ONE);
|
|
let ab=a.wide_div_1_1(b);
|
|
assert_eq!(ab,crate::types::I64F64::ONE*2);
|
|
let wab=wide_a.wide_div_2_1(b);
|
|
assert_eq!(wab,crate::fixed::Fixed::<3,96>::ONE*2);
|
|
let awb=a.wide_div_1_2(wide_b);
|
|
assert_eq!(awb,crate::fixed::Fixed::<3,96>::ONE*2);
|
|
}
|
|
|
|
#[test]
|
|
fn test_wide_mul_repeated() {
|
|
let a=I32F32::from(2);
|
|
let b=I32F32::from(3);
|
|
|
|
let w1=a.wide_mul_1_1(b);
|
|
let w2=w1.wide_mul_2_2(w1);
|
|
let w3=w2.wide_mul_4_4(w2);
|
|
|
|
assert_eq!(w3,I256F256::from((3i128*2).pow(4)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_bint(){
|
|
let a=I32F32::ONE;
|
|
assert_eq!(a*2,I32F32::from(2));
|
|
}
|
|
|
|
#[test]
|
|
fn test_fix(){
|
|
assert_eq!(I32F32::ONE.fix_8(),I256F256::ONE);
|
|
assert_eq!(I32F32::ONE,I256F256::ONE.fix_1());
|
|
assert_eq!(I32F32::NEG_ONE.fix_8(),I256F256::NEG_ONE);
|
|
assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.fix_1());
|
|
}
|
|
#[test]
|
|
fn test_sqrt(){
|
|
let a=I32F32::ONE*4;
|
|
assert_eq!(a.sqrt(),I32F32::from(2));
|
|
}
|
|
#[test]
|
|
fn test_sqrt_zero(){
|
|
let a=I32F32::ZERO;
|
|
assert_eq!(a.sqrt(),I32F32::ZERO);
|
|
}
|
|
#[test]
|
|
fn test_sqrt_low(){
|
|
let a=I32F32::HALF;
|
|
let b=a.fixed_mul(a);
|
|
assert_eq!(b.sqrt(),a);
|
|
}
|
|
fn find_equiv_sqrt_via_f64(n:I32F32)->I32F32{
|
|
//GIMME THEM BITS BOY
|
|
let &[bits]=n.to_bits().to_bits().digits();
|
|
let ibits=bits as i64;
|
|
let f=(ibits as f64)/((1u64<<32) as f64);
|
|
let f_ans=f.sqrt();
|
|
let i=(f_ans*((1u64<<32) as f64)) as i64;
|
|
let r=I32F32::from_bits(bnum::BInt::<1>::from(i));
|
|
//mimic the behaviour of the algorithm,
|
|
//return the result if it truncates to the exact answer
|
|
if (r+I32F32::EPSILON).wide_mul_1_1(r+I32F32::EPSILON)==n.wide_mul_1_1(I32F32::ONE){
|
|
return r+I32F32::EPSILON;
|
|
}
|
|
if (r-I32F32::EPSILON).wide_mul_1_1(r-I32F32::EPSILON)==n.wide_mul_1_1(I32F32::ONE){
|
|
return r-I32F32::EPSILON;
|
|
}
|
|
return r;
|
|
}
|
|
fn test_exact(n:I32F32){
|
|
assert_eq!(n.sqrt(),find_equiv_sqrt_via_f64(n));
|
|
}
|
|
#[test]
|
|
fn test_sqrt_exact(){
|
|
//43
|
|
for i in 0..((i64::MAX as f32).ln() as u32){
|
|
let n=I32F32::from_bits(bnum::BInt::<1>::from((i as f32).exp() as i64));
|
|
test_exact(n);
|
|
}
|
|
}
|
|
#[test]
|
|
fn test_sqrt_max(){
|
|
let a=I32F32::MAX;
|
|
test_exact(a);
|
|
}
|
|
#[test]
|
|
#[cfg(all(feature="zeroes",not(feature="deferred-division")))]
|
|
fn test_zeroes_normal(){
|
|
// (x-1)*(x+1)
|
|
// x^2-1
|
|
let zeroes=I32F32::zeroes2(I32F32::NEG_ONE,I32F32::ZERO,I32F32::ONE);
|
|
assert_eq!(zeroes,arrayvec::ArrayVec::from_iter([I32F32::NEG_ONE,I32F32::ONE]));
|
|
let zeroes=I32F32::zeroes2(I32F32::NEG_ONE*3,I32F32::ONE*2,I32F32::ONE);
|
|
assert_eq!(zeroes,arrayvec::ArrayVec::from_iter([I32F32::NEG_ONE*3,I32F32::ONE]));
|
|
}
|
|
#[test]
|
|
#[cfg(all(feature="zeroes",feature="deferred-division"))]
|
|
fn test_zeroes_deferred_division(){
|
|
// (x-1)*(x+1)
|
|
// x^2-1
|
|
let zeroes=I32F32::zeroes2(I32F32::NEG_ONE,I32F32::ZERO,I32F32::ONE);
|
|
assert_eq!(
|
|
zeroes,
|
|
arrayvec::ArrayVec::from_iter([
|
|
ratio_ops::ratio::Ratio::new(I32F32::ONE*2,I32F32::NEG_ONE*2),
|
|
ratio_ops::ratio::Ratio::new(I32F32::ONE*2,I32F32::ONE*2),
|
|
])
|
|
);
|
|
}
|