110 lines
2.4 KiB
Rust
110 lines
2.4 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 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(){
|
|
let a=I32F32::ONE;
|
|
assert_eq!(a.fix_8(),I256F256::ONE);
|
|
}
|
|
#[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);
|
|
}
|