rust/fpnum/src/lib.rs
changeset 13891 9ae1184886db
parent 13885 cd39e87d7a80
child 13896 ac1801fe51d9
equal deleted inserted replaced
13886:b6c35ac1c5ba 13891:9ae1184886db
   268             value: self.value / rhs as u64,
   268             value: self.value / rhs as u64,
   269         }
   269         }
   270     }
   270     }
   271 }
   271 }
   272 
   272 
       
   273 macro_rules! fp {
       
   274     (-$n: tt / $d: tt) => { FPNum::new(-$n, $d) };
       
   275     ($n: tt / $d: tt) => { FPNum::new($n, $d) };
       
   276     ($n: tt) => { FPNum::from($n) };
       
   277 }
       
   278 
   273 /* TODO:
   279 /* TODO:
   274  Distance
   280  Distance
   275  DistanceI
   281  DistanceI
   276  SignAs
   282  SignAs
   277  AngleSin
   283  AngleSin
   279 */
   285 */
   280 
   286 
   281 #[cfg(test)]
   287 #[cfg(test)]
   282 #[test]
   288 #[test]
   283 fn basics() {
   289 fn basics() {
   284     let n = FPNum::new(15, 2);
   290     let n = fp!(15/2);
   285     assert!(n.is_positive());
   291     assert!(n.is_positive());
   286     assert!(!n.is_negative());
   292     assert!(!n.is_negative());
   287 
   293 
   288     assert!(!(-n).is_positive());
   294     assert!(!(-n).is_positive());
   289     assert!((-n).is_negative());
   295     assert!((-n).is_negative());
   290 
   296 
   291     assert_eq!(-(-n), n);
   297     assert_eq!(-(-n), n);
   292     assert_eq!((-n).abs(), n);
   298     assert_eq!((-n).abs(), n);
   293     assert_eq!(-n, FPNum::new(-15, 2));
   299     assert_eq!(-n, fp!(-15/2));
   294 
   300 
   295     assert_eq!(n.round(), 7);
   301     assert_eq!(n.round(), 7);
   296     assert_eq!((-n).round(), -7);
   302     assert_eq!((-n).round(), -7);
   297 }
   303 }
   298 
   304 
   299 #[test]
   305 #[test]
   300 fn zero() {
   306 fn zero() {
   301     let z = FPNum::from(0);
   307     let z = fp!(0);
   302     let n = FPNum::new(15, 2);
   308     let n = fp!(15/2);
   303 
   309 
   304     assert!(z.is_zero());
   310     assert!(z.is_zero());
   305     assert!(z.is_positive());
   311     assert!(z.is_positive());
   306     assert!((-z).is_negative);
   312     assert!((-z).is_negative);
   307     assert_eq!(n - n, z);
   313     assert_eq!(n - n, z);
   308     assert_eq!(-n + n, z);
   314     assert_eq!(-n + n, z);
   309 }
   315 }
   310 
   316 
   311 #[test]
   317 #[test]
   312 fn ord() {
   318 fn ord() {
   313     let z = FPNum::from(0);;
   319     let z = fp!(0);
   314     let n1_5 = FPNum::new(3, 2);
   320     let n1_5 = fp!(3/2);
   315     let n2_25 = FPNum::new(9, 4);
   321     let n2_25 = fp!(9/4);
   316 
   322 
   317     assert!(!(z > z));
   323     assert!(!(z > z));
   318     assert!(!(z < z));
   324     assert!(!(z < z));
   319     assert!(n2_25 > n1_5);
   325     assert!(n2_25 > n1_5);
   320     assert!(-n2_25 < n1_5);
   326     assert!(-n2_25 < n1_5);
   321     assert!(-n2_25 < -n1_5);
   327     assert!(-n2_25 < -n1_5);
   322 }
   328 }
   323 
   329 
   324 #[test]
   330 #[test]
   325 fn arith() {
   331 fn arith() {
   326     let n1_5 = FPNum::new(3, 2);
   332     let n1_5 = fp!(3/2);
   327     let n2_25 = FPNum::new(9, 4);
   333     let n2_25 = fp!(9/4);
   328     let n_0_15 = FPNum::new(-15, 100);
   334     let n_0_15 = fp!(-15/100);
   329 
   335 
   330     assert_eq!(n1_5 + n1_5, FPNum::from(3));
   336     assert_eq!(n1_5 + n1_5, fp!(3));
   331     assert_eq!(-n1_5 - n1_5, FPNum::from(-3));
   337     assert_eq!(-n1_5 - n1_5, fp!(-3));
   332 
   338 
   333     assert_eq!(n1_5 * n1_5, n2_25);
   339     assert_eq!(n1_5 * n1_5, n2_25);
   334     assert_eq!(-n1_5 * -n1_5, n2_25);
   340     assert_eq!(-n1_5 * -n1_5, n2_25);
   335     assert_eq!(n1_5 * -n1_5, -n2_25);
   341     assert_eq!(n1_5 * -n1_5, -n2_25);
   336     assert_eq!(-n1_5 * n1_5, -n2_25);
   342     assert_eq!(-n1_5 * n1_5, -n2_25);