src/algorithms/base.rs

   1 use crate::traits::{Context, Float};
   2
   3 pub fn abs_f16<Ctx: Context>(ctx: Ctx, x: Ctx::VecF16) -> Ctx::VecF16 {
   4     Ctx::VecF16::from_bits(x.to_bits() & ctx.make(0x7FFFu16))
   5 }
   6
   7 pub fn abs_f32<Ctx: Context>(ctx: Ctx, x: Ctx::VecF32) -> Ctx::VecF32 {
   8     Ctx::VecF32::from_bits(x.to_bits() & ctx.make(!(1u32 << 31)))
   9 }
  10
  11 pub fn abs_f64<Ctx: Context>(ctx: Ctx, x: Ctx::VecF64) -> Ctx::VecF64 {
  12     Ctx::VecF64::from_bits(x.to_bits() & ctx.make(!(1u64 << 63)))
  13 }
  14
  15 #[cfg(test)]
  16 mod tests {
  17     use super::*;
  18     use crate::{
  19         f16::F16,
  20         scalar::{Scalar, Value},
  21     };
  22
  23     #[test]
  24     #[cfg_attr(
  25         not(feature = "f16"),
  26         should_panic(expected = "f16 feature is not enabled")
  27     )]
  28     fn test_abs_f16() {
  29         for bits in 0..=u16::MAX {
  30             let v = F16::from_bits(bits);
  31             let expected = v.abs();
  32             let result = abs_f16(Scalar, Value(v)).0;
  33             assert_eq!(expected.to_bits(), result.to_bits());
  34         }
  35     }
  36
  37     #[test]
  38     fn test_abs_f32() {
  39         for bits in (0..=u32::MAX).step_by(10001) {
  40             let v = f32::from_bits(bits);
  41             let expected = v.abs();
  42             let result = abs_f32(Scalar, Value(v)).0;
  43             assert_eq!(expected.to_bits(), result.to_bits());
  44         }
  45     }
  46
  47     #[test]
  48     fn test_abs_f64() {
  49         for bits in (0..=u64::MAX).step_by(100_000_000_000_001) {
  50             let v = f64::from_bits(bits);
  51             let expected = v.abs();
  52             let result = abs_f64(Scalar, Value(v)).0;
  53             assert_eq!(expected.to_bits(), result.to_bits());
  54         }
  55     }
  56 }