rust/fpnum/src/lib.rs
changeset 13929 ff77c9920007
parent 13928 5fdc41cd0841
child 13932 7bb60596c27e
equal deleted inserted replaced
13928:5fdc41cd0841 13929:ff77c9920007
   418 }
   418 }
   419 
   419 
   420 bin_op_impl!(ops::Add, add);
   420 bin_op_impl!(ops::Add, add);
   421 bin_op_impl!(ops::Sub, sub);
   421 bin_op_impl!(ops::Sub, sub);
   422 bin_op_impl!(ops::Mul, mul);
   422 bin_op_impl!(ops::Mul, mul);
       
   423 bin_op_impl!(ops::Div, div);
   423 scalar_bin_op_impl!(ops::Add<FPNum>, add);
   424 scalar_bin_op_impl!(ops::Add<FPNum>, add);
   424 scalar_bin_op_impl!(ops::Mul<FPNum>, mul);
   425 scalar_bin_op_impl!(ops::Mul<FPNum>, mul);
   425 scalar_bin_op_impl!(ops::Sub<FPNum>, sub);
   426 scalar_bin_op_impl!(ops::Sub<FPNum>, sub);
   426 scalar_bin_op_impl!(ops::Div<FPNum>, div);
   427 scalar_bin_op_impl!(ops::Div<FPNum>, div);
       
   428 
       
   429 macro_rules! bin_assign_op_impl {
       
   430     ($typ: tt, $($op: tt)::+, $name: tt, $delegate: tt) => {
       
   431         bin_assign_op_impl!($typ, $($op)::+<$typ>, $name, $delegate);
       
   432     };
       
   433     ($typ: tt, $($op: tt)::+<$arg: tt>, $name: tt, $delegate: tt) => {
       
   434         impl $($op)::+<$arg> for $typ {
       
   435             #[inline]
       
   436             fn $name(&mut self, rhs: $arg) {
       
   437                 *self = *self $delegate rhs;
       
   438             }
       
   439         }
       
   440     }
       
   441 }
       
   442 
       
   443 bin_assign_op_impl!(FPNum, ops::AddAssign, add_assign, +);
       
   444 bin_assign_op_impl!(FPNum, ops::SubAssign, sub_assign, -);
       
   445 bin_assign_op_impl!(FPNum, ops::MulAssign, mul_assign, *);
       
   446 bin_assign_op_impl!(FPNum, ops::DivAssign, div_assign, /);
       
   447 bin_assign_op_impl!(FPNum, ops::MulAssign<i32>, mul_assign, *);
       
   448 bin_assign_op_impl!(FPNum, ops::DivAssign<i32>, div_assign, /);
       
   449 bin_assign_op_impl!(FPNum, ops::DivAssign<u32>, div_assign, /);
       
   450 
       
   451 bin_assign_op_impl!(FPPoint, ops::AddAssign, add_assign, +);
       
   452 bin_assign_op_impl!(FPPoint, ops::SubAssign, sub_assign, -);
       
   453 bin_assign_op_impl!(FPPoint, ops::MulAssign, mul_assign, *);
       
   454 bin_assign_op_impl!(FPPoint, ops::DivAssign, div_assign, /);
       
   455 bin_assign_op_impl!(FPPoint, ops::AddAssign<FPNum>, add_assign, +);
       
   456 bin_assign_op_impl!(FPPoint, ops::SubAssign<FPNum>, sub_assign, -);
       
   457 bin_assign_op_impl!(FPPoint, ops::MulAssign<FPNum>, mul_assign, *);
       
   458 bin_assign_op_impl!(FPPoint, ops::DivAssign<FPNum>, div_assign, /);
   427 
   459 
   428 #[inline]
   460 #[inline]
   429 pub fn distance<T>(x: T, y: T) -> FPNum
   461 pub fn distance<T>(x: T, y: T) -> FPNum
   430     where T: ops::Add + ops::Mul + Copy +
   462     where T: ops::Add + ops::Mul + Copy +
   431              From<<T as ops::Add>::Output> +
   463              From<<T as ops::Add>::Output> +
   506     assert_eq!((-n1_5).sqr(), n2_25);
   538     assert_eq!((-n1_5).sqr(), n2_25);
   507 
   539 
   508     assert_eq!(n2_25.sqrt(), n1_5);
   540     assert_eq!(n2_25.sqrt(), n1_5);
   509 
   541 
   510     assert_eq!((n1_5 * n1_5 * n1_5.sqr()).sqrt(), n2_25);
   542     assert_eq!((n1_5 * n1_5 * n1_5.sqr()).sqrt(), n2_25);
       
   543 
       
   544     let mut m = fp!(1);
       
   545     m += n1_5;
       
   546     assert_eq!(m, fp!(5/2));
   511 }
   547 }
   512 
   548 
   513 #[test]
   549 #[test]
   514 fn point() {
   550 fn point() {
   515     let z = FPPoint::zero();
   551     let z = FPPoint::zero();