floating-distance 0.3.1

Measure distance between floating-point vectors in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use cfg_if::cfg_if;

/// Get the correct simd lane count for the specified scalar type
/// 
/// # Examples
/// ```rust
/// use floating_distance::*;
/// use std::mem::size_of;
/// 
/// const LANES: usize = auto_lane_count!(f32);
/// assert_eq!(LANES, 16);
/// assert!(LANES / size_of::<f32>() >= 1);
/// assert!(LANES % size_of::<f32>() == 0);
/// ```
/// 
/// # Details
/// It relies on `#[cfg(target_feature)]`.
/// The result is evaluated in compile time.
#[macro_export]
macro_rules! auto_lane_count {
  ($scalar: ty) => {{
    cfg_if::cfg_if! {
    if #[cfg(feature = "simd")] {
      512 / 8 / std::mem::size_of::<$scalar>()
    } else {
      1
    }
    }
  }}
}

cfg_if! {
if #[cfg(feature = "simd")] {
  pub (crate) use std::simd::{
    LaneCount,
    Simd,
    SimdElement,
    SimdFloat,
    SupportedLaneCount,
  };

  /// [`std::simd::LaneCount`]
  pub type AutoLaneCount<S> = LaneCount<{ auto_lane_count!(S) }>;
  /// [`std::simd::Simd`]
  pub type AutoSimd<S> = Simd<S, { auto_lane_count!(S) }>;
  /// [`std::simd::SimdElement`]
  pub trait AutoSimdElement: SimdElement {}
  /// [`std::simd::SimdFloat`]
  pub trait AutoSimdFloat: SimdFloat {}
  /// [`std::simd::SupportedLaneCount`]
  pub trait AutoSupportedLaneCount: SupportedLaneCount {}

  impl<S: SimdElement> AutoSimdElement for S {}
  impl<S: SimdFloat> AutoSimdFloat for S {}
  impl<S: SupportedLaneCount> AutoSupportedLaneCount for S {}

} else {
  /// Stub for [`std::simd::LaneCount`]
  pub type AutoLaneCount<S> = S;
  /// Stub for [`std::simd::Simd`]
  pub type AutoSimd<S> = S;
  /// Stub for [`std::simd::SimdElement`]
  pub trait AutoSimdElement {}
  /// Stub for [`std::simd::SimdFloat`]
  pub trait AutoSimdFloat {
    /// Stub for [`std::simd::SimdFloat::Scalar`]
    type Scalar;
  }
  /// Stub for [`std::simd::SupportedLaneCount`]
  pub trait AutoSupportedLaneCount {}

  impl<S> AutoSimdElement for S {}
  impl<P> AutoSimdFloat for P { type Scalar = P; }
  impl<S> AutoSupportedLaneCount for AutoLaneCount<S> {}
}
}