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

equal deleted inserted replaced

-:f783f5d55717
+:924f7e38815e
 use std::{cmp, ops, ops::Shl};
+const POSITIVE_MASK: u64 = 0x0000_0000_0000_0000;
+const NEGATIVE_MASK: u64 = 0xFFFF_FFFF_FFFF_FFFF;
+#[inline]
+fn bool_mask(is_negative: bool) -> u64 {
+if is_negative {
+NEGATIVE_MASK
+} else {
+POSITIVE_MASK
+}
+}
 #[derive(Clone, Debug, Copy)]
 pub struct FPNum {
-is_negative: bool,
+sign_mask: u64,
 value: u64,
 }
 impl FPNum {
 #[inline]
 FPNum::from(numerator) / denominator
 }
 #[inline]
 pub fn signum(&self) -> i8 {
-if self.is_negative {
+(1u8 ^ self.sign_mask as u8).wrapping_sub(self.sign_mask as u8) as i8
--1
-} else {
-1
-}
 }
 #[inline]
 pub const fn is_negative(&self) -> bool {
-self.is_negative
+self.sign_mask != POSITIVE_MASK
 }
 #[inline]
 pub const fn is_positive(&self) -> bool {
-!self.is_negative
+self.sign_mask == POSITIVE_MASK
 }
 #[inline]
 pub const fn is_zero(&self) -> bool {
 self.value == 0
 }
 #[inline]
 pub const fn abs(&self) -> Self {
 Self {
-is_negative: false,
+sign_mask: POSITIVE_MASK,
 value: self.value,
 }
 }
 #[inline]
 pub fn round(&self) -> i32 {
-if self.is_negative {
+((self.value >> 32) as i32 ^ self.sign_mask as i32).wrapping_sub(self.sign_mask as i32)
--((self.value >> 32) as i32)
-} else {
-(self.value >> 32) as i32
-}
 }
 #[inline]
 pub const fn abs_round(&self) -> u32 {
 (self.value >> 32) as u32
 }
 #[inline]
 pub fn sqr(&self) -> Self {
 Self {
-is_negative: false,
+sign_mask: 0,
 value: ((self.value as u128).pow(2) >> 32) as u64,
 }
 }
 pub fn sqrt(&self) -> Self {
-debug_assert!(!self.is_negative);
+debug_assert!(self.is_positive());
-let mut t: u64 = 0x4000000000000000;
+let mut t: u64 = 0x4000_0000_0000_0000;
 let mut r: u64 = 0;
 let mut q = self.value;
 for _ in 0..32 {
 let s = r + t;
 }
 t >>= 2;
 }
 Self {
-is_negative: false,
+sign_mask: POSITIVE_MASK,
 value: r << 16,
 }
 }
 #[inline]
-pub const fn with_sign(&self, is_negative: bool) -> FPNum {
+pub fn with_sign(&self, is_negative: bool) -> FPNum {
 FPNum {
-is_negative,
+sign_mask: bool_mask(is_negative),
 ..*self
 }
 }
 #[inline]
 pub const fn with_sign_as(self, other: FPNum) -> FPNum {
-self.with_sign(other.is_negative)
+FPNum {
+sign_mask: other.sign_mask,
+..self
+}
 }
 #[inline]
 pub const fn point(self) -> FPPoint {
 FPPoint::new(self, self)
 }
+#[inline]
+const fn temp_i128(self) -> i128 {
+((self.value ^ self.sign_mask) as u128 as i128).wrapping_sub(self.sign_mask as i128)
+}
 }
 impl From<i32> for FPNum {
 #[inline]
 fn from(n: i32) -> Self {
 FPNum {
-is_negative: n < 0,
+sign_mask: bool_mask(n < 0),
 value: (n.abs() as u64) << 32,
 }
 }
 }
 impl From<u32> for FPNum {
 #[inline]
 fn from(n: u32) -> Self {
 Self {
-is_negative: false,
+sign_mask: NEGATIVE_MASK,
 value: (n as u64) << 32,
 }
 }
 }
 impl From<FPNum> for f64 {
 #[inline]
 fn from(n: FPNum) -> Self {
-if n.is_negative {
+if n.is_negative() {
 n.value as f64 / (-0x10000000 as f64)
 } else {
 n.value as f64 / 0x10000000 as f64
 }
 }
 }
 impl PartialEq for FPNum {
 #[inline]
 fn eq(&self, other: &Self) -> bool {
-self.value == other.value && (self.is_negative == other.is_negative || self.value == 0)
+self.value == other.value && (self.sign_mask == other.sign_mask || self.value == 0)
 }
 }
 impl Eq for FPNum {}
 }
 impl Ord for FPNum {
 #[inline]
 fn cmp(&self, rhs: &Self) -> cmp::Ordering {
-#[inline]
+self.temp_i128().cmp(&(rhs.temp_i128()))
-fn extend(n: &FPNum) -> i128 {
-if n.is_negative {
--(n.value as i128)
-} else {
-n.value as i128
-}
-}
-extend(self).cmp(&(extend(rhs)))
 }
 }
 impl ops::Add for FPNum {
 type Output = Self;
 #[inline]
 fn add(self, rhs: Self) -> Self {
-if self.is_negative == rhs.is_negative {
+let tmp = self.temp_i128() + rhs.temp_i128();
-Self {
+let mask = bool_mask(tmp < 0);
-is_negative: self.is_negative,
+Self {
-value: self.value + rhs.value,
+sign_mask: mask,
-}
+value: ((tmp as u64) ^ mask).wrapping_sub(mask),
-} else if self.value > rhs.value {
-Self {
-is_negative: self.is_negative,
-value: self.value - rhs.value,
-}
-} else {
-Self {
-is_negative: rhs.is_negative,
-value: rhs.value - self.value,
-}
 }
 }
 }
 impl ops::Sub for FPNum {
 type Output = Self;
 #[inline]
-fn sub(self, rhs: Self) -> Self {
+fn sub(self, mut rhs: Self) -> Self {
-if self.is_negative == rhs.is_negative {
+rhs.sign_mask = !rhs.sign_mask;
-if self.value > rhs.value {
+self + rhs
-Self {
-is_negative: self.is_negative,
-value: self.value - rhs.value,
-}
-} else {
-Self {
-is_negative: !rhs.is_negative,
-value: rhs.value - self.value,
-}
-}
-} else {
-Self {
-is_negative: self.is_negative,
-value: self.value + rhs.value,
-}
-}
 }
 }
 impl ops::Neg for FPNum {
 type Output = Self;
 #[inline]
 fn neg(self) -> Self {
 Self {
-is_negative: !self.is_negative,
+sign_mask: !self.sign_mask,
 value: self.value,
 }
 }
 }
 type Output = Self;
 #[inline]
 fn mul(self, rhs: Self) -> Self {
 Self {
-is_negative: self.is_negative ^ rhs.is_negative,
+sign_mask: self.sign_mask ^ rhs.sign_mask,
 value: ((self.value as u128 * rhs.value as u128) >> 32) as u64,
 }
 }
 }
 type Output = Self;
 #[inline]
 fn mul(self, rhs: i32) -> Self {
 Self {
-is_negative: self.is_negative ^ (rhs < 0),
+sign_mask: self.sign_mask ^ bool_mask(rhs < 0),
 value: self.value * rhs.abs() as u64,
 }
 }
 }
 type Output = Self;
 #[inline]
 fn div(self, rhs: Self) -> Self {
 Self {
-is_negative: self.is_negative ^ rhs.is_negative,
+sign_mask: self.sign_mask ^ rhs.sign_mask,
 value: (((self.value as u128) << 32) / rhs.value as u128) as u64,
 }
 }
 }
 type Output = Self;
 #[inline]
 fn div(self, rhs: i32) -> Self {
 Self {
-is_negative: self.is_negative ^ (rhs < 0),
+sign_mask: self.sign_mask ^ bool_mask(rhs < 0),
 value: self.value / rhs.abs() as u64,
 }
 }
 }
 type Output = Self;
 #[inline]
 fn div(self, rhs: u32) -> Self {
 Self {
-is_negative: self.is_negative,
+sign_mask: self.sign_mask,
 value: self.value / rhs as u64,
 }
 }
 }
 const LINEARIZE_TRESHOLD: u64 = 0x1_0000;
 #[derive(Clone, Copy, Debug)]
 pub struct FPPoint {
-x_is_negative: bool,
+x_sign_mask: u32,
-y_is_negative: bool,
+y_sign_mask: u32,
 x_value: u64,
 y_value: u64,
 }
 impl FPPoint {
 #[inline]
 pub const fn new(x: FPNum, y: FPNum) -> Self {
 Self {
-x_is_negative: x.is_negative,
+x_sign_mask: x.sign_mask as u32,
-y_is_negative: y.is_negative,
+y_sign_mask: y.sign_mask as u32,
 x_value: x.value,
 y_value: y.value,
 }
 }
 }
 #[inline]
 pub const fn x(&self) -> FPNum {
 FPNum {
-is_negative: self.x_is_negative,
+sign_mask: self.x_sign_mask as i32 as u64,
 value: self.x_value,
 }
 }
 #[inline]
 pub const fn y(&self) -> FPNum {
 FPNum {
-is_negative: self.y_is_negative,
+sign_mask: self.y_sign_mask as i32 as u64,
 value: self.y_value,
 }
 }
 #[inline]
 }
 t >>= 2;
 }
 FPNum {
-is_negative: false,
+sign_mask: POSITIVE_MASK,
 value: r as u64,
 }
 }
 }
 }
 t >>= 2;
 }
 FPNum {
-is_negative: false,
+sign_mask: POSITIVE_MASK,
 value: r as u64,
 }
 }
 /* TODO:
 let z = fp!(0);
 let n = fp!(15 / 2);
 assert!(z.is_zero());
 assert!(z.is_positive());
-assert!((-z).is_negative);
+assert!((-z).is_negative());
 assert_eq!(n - n, z);
 assert_eq!(-n + n, z);
 assert_eq!(n.with_sign_as(-n), -n);
 }
 assert!(!(z > z));
 assert!(!(z < z));
 assert!(n2_25 > n1_5);
 assert!(-n2_25 < n1_5);
 assert!(-n2_25 < -n1_5);
+assert_eq!(n1_5.signum(), 1);
+assert_eq!((-n1_5).signum(), -1);
 }
 #[test]
 fn arith() {
 let n1_5 = fp!(3 / 2);
 let n2_25 = fp!(9 / 4);
 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, fp!(0));
 assert_eq!(n1_5 * n1_5, n2_25);
 assert_eq!(-n1_5 * -n1_5, n2_25);
 assert_eq!(n1_5 * -n1_5, -n2_25);
 assert_eq!(-n1_5 * n1_5, -n2_25);

changeset 15211	924f7e38815e
parent 14701	5e2c892b0222
child 15212	293250953317