hedgewars-draft: comparison rust/fpnum/src/lib.rs

equal deleted inserted replaced

-:69db1d2e4cec
+:c27461e6a9eb
 use std::cmp;
 use std::ops;
+use std::ops::Shl;
 #[derive(Clone, Debug, Copy)]
 pub struct FPNum {
 is_negative: bool,
 value: u64,
 }
 }
 #[inline]
 pub fn with_sign(&self, is_negative: bool) -> FPNum {
-FPNum{ is_negative, ..*self}
+FPNum {
+is_negative,
+..*self
+}
 }
 #[inline]
 pub fn with_sign_as(self, other: FPNum) -> FPNum {
 self.with_sign(other.is_negative)
 }
 }
 #[macro_export]
 macro_rules! fp {
-(-$n: tt / $d: tt) => { FPNum::new(-$n, $d) };
+(-$n: tt / $d: tt) => {
-($n: tt / $d: tt) => { FPNum::new($n, $d) };
+FPNum::new(-$n, $d)
-(-$n: tt) => { FPNum::from(-$n) };
+};
-($n: tt) => { FPNum::from($n) };
+($n: tt / $d: tt) => {
+FPNum::new($n, $d)
+};
+(-$n: tt) => {
+FPNum::from(-$n)
+};
+($n: tt) => {
+FPNum::from($n)
+};
 }
 const LINEARIZE_TRESHOLD: u64 = 0x1_0000;
 #[derive(Clone, Copy, Debug)]
 pub fn new(x: FPNum, y: FPNum) -> Self {
 Self {
 x_is_negative: x.is_negative,
 y_is_negative: y.is_negative,
 x_value: x.value,
-y_value: y.value
+y_value: y.value,
 }
 }
 #[inline]
-pub fn zero() -> FPPoint { FPPoint::new(fp!(0), fp!(0)) }
+pub fn zero() -> FPPoint {
+FPPoint::new(fp!(0), fp!(0))
-#[inline]
+}
-pub fn unit_x() -> FPPoint { FPPoint::new(fp!(1), fp!(0)) }
+#[inline]
-#[inline]
+pub fn unit_x() -> FPPoint {
-pub fn unit_y() -> FPPoint { FPPoint::new(fp!(0), fp!(1)) }
+FPPoint::new(fp!(1), fp!(0))
+}
+#[inline]
+pub fn unit_y() -> FPPoint {
+FPPoint::new(fp!(0), fp!(1))
+}
 #[inline]
 pub fn x(&self) -> FPNum {
 FPNum {
 is_negative: self.x_is_negative,
-value: self.x_value
+value: self.x_value,
 }
 }
 #[inline]
 pub fn y(&self) -> FPNum {
 FPNum {
 is_negative: self.y_is_negative,
-value: self.y_value
+value: self.y_value,
 }
 }
 #[inline]
 pub fn max_norm(&self) -> FPNum {
 pub fn distance(&self) -> FPNum {
 let r = self.x_value | self.y_value;
 if r < LINEARIZE_TRESHOLD {
 FPNum::from(r as u32)
 } else {
-self.sqr_distance().sqrt()
+let mut sqr: u128 = (self.x_value as u128).pow(2) + (self.y_value as u128).pow(2);
+let mut t: u128 = 0x40000000_00000000_00000000_00000000;
+let mut r: u128 = 0;
+for _ in 0..64 {
+let s = r + t;
+r >>= 1;
+if s <= sqr {
+sqr -= s;
+r += t;
+}
+t >>= 2;
+}
+FPNum {
+is_negative: false,
+value: r as u64,
+}
 }
 }
 #[inline]
 pub fn is_in_range(&self, radius: FPNum) -> bool {
 impl $op for FPPoint {
 type Output = Self;
 #[inline]
 fn $name(self, rhs: Self) -> Self {
-Self::new(self.x().$name(rhs.x()),
+Self::new(self.x().$name(rhs.x()), self.y().$name(rhs.y()))
-self.y().$name(rhs.y()))
+}
 }
-}
+};
-}
 }
 macro_rules! right_scalar_bin_op_impl {
 ($($op: tt)::+, $name: tt) => {
 impl $($op)::+<FPNum> for FPPoint {
 bin_assign_op_impl!(FPPoint, ops::AddAssign<FPNum>, add_assign, +);
 bin_assign_op_impl!(FPPoint, ops::SubAssign<FPNum>, sub_assign, -);
 bin_assign_op_impl!(FPPoint, ops::MulAssign<FPNum>, mul_assign, *);
 bin_assign_op_impl!(FPPoint, ops::DivAssign<FPNum>, div_assign, /);
-#[inline]
 pub fn distance<T>(x: T, y: T) -> FPNum
-where T: ops::Add + ops::Mul + Copy +
+where
-From<<T as ops::Add>::Output> +
+T: Into<i64> + std::fmt::Debug,
-From<<T as ops::Mul>::Output> +
-Into<FPNum>
 {
-let sqr: FPNum = T::from(T::from(x * x) + T::from(y * y)).into();
+let mut sqr: u128 = (x.into().pow(2) as u128).shl(64) + (y.into().pow(2) as u128).shl(64);
-sqr.sqrt()
+let mut t: u128 = 0x40000000_00000000_00000000_00000000;
+let mut r: u128 = 0;
+for _ in 0..64 {
+let s = r + t;
+r >>= 1;
+if s <= sqr {
+sqr -= s;
+r += t;
+}
+t >>= 2;
+}
+FPNum {
+is_negative: false,
+value: r as u64,
+}
 }
 /* TODO:
 AngleSin
 AngleCos
 */
 #[cfg(test)]
 #[test]
 fn basics() {
-let n = fp!(15/2);
+let n = fp!(15 / 2);
 assert!(n.is_positive());
 assert!(!n.is_negative());
 assert!(!(-n).is_positive());
 assert!((-n).is_negative());
 assert_eq!(-(-n), n);
 assert_eq!((-n).abs(), n);
-assert_eq!(-n, fp!(-15/2));
+assert_eq!(-n, fp!(-15 / 2));
 assert_eq!(n.round(), 7);
 assert_eq!((-n).round(), -7);
 }
 #[test]
 fn zero() {
 let z = fp!(0);
-let n = fp!(15/2);
+let n = fp!(15 / 2);
 assert!(z.is_zero());
 assert!(z.is_positive());
 assert!((-z).is_negative);
 assert_eq!(n - n, z);
 }
 #[test]
 fn ord() {
 let z = fp!(0);
-let n1_5 = fp!(3/2);
+let n1_5 = fp!(3 / 2);
-let n2_25 = fp!(9/4);
+let n2_25 = fp!(9 / 4);
 assert!(!(z > z));
 assert!(!(z < z));
 assert!(n2_25 > n1_5);
 assert!(-n2_25 < n1_5);
 assert!(-n2_25 < -n1_5);
 }
 #[test]
 fn arith() {
-let n1_5 = fp!(3/2);
+let n1_5 = fp!(3 / 2);
-let n2_25 = fp!(9/4);
+let n2_25 = fp!(9 / 4);
-let n_0_15 = fp!(-15/100);
+let n_0_15 = fp!(-15 / 100);
 assert_eq!(n1_5 + n1_5, fp!(3));
 assert_eq!(-n1_5 - n1_5, fp!(-3));
 assert_eq!(n1_5 * n1_5, n2_25);
 assert_eq!((n1_5 * n1_5 * n1_5.sqr()).sqrt(), n2_25);
 let mut m = fp!(1);
 m += n1_5;
-assert_eq!(m, fp!(5/2));
+assert_eq!(m, fp!(5 / 2));
+}
+#[test]
+fn test_distance_high_values() {
+assert_eq!(distance(1_000_000i32, 0), fp!(1_000_000));
+assert_eq!(
+FPPoint::new(fp!(1_000_000), fp!(0)).distance(),
+fp!(1_000_000)
+);
 }
 #[test]
 fn point() {
 let z = FPPoint::zero();
-let n = fp!(16/9);
+let n = fp!(16 / 9);
 let p = FPPoint::new(fp!(1), fp!(-2));
 assert_eq!(p.sqr_distance(), fp!(5));
 assert_eq!(p + -p, FPPoint::zero());
 assert_eq!(p * z, z);

changeset 14143	c27461e6a9eb
parent 14102	5d42204ac35e
child 14160	37c99587825d