Fix lack of use of num_traits::identities

Older commits didn't utilise some properities afforded by Real and
RealField.

Also added a useless(?) cfg(attr = "alloc") compiler attribute for
consistency.

sci-rs/src/signal/filter/design/kaiser.rs

@@ -1,5 +1,4 @@
-use core::f64::consts::PI;
-use core::ops::Mul;
+use nalgebra::RealField;
 use num_traits::{real::Real, MulAdd, Pow, ToPrimitive};
 
 /// Compute the Kaiser parameter `beta`, given the attenuation `a`.
@@ -43,8 +42,8 @@ where
             F::from(0.5842).unwrap(),
             F::from(0.07886).unwrap() * a,
         )
-    } else if a > F::from(0).unwrap() {
-        F::from(0).unwrap()
+    } else if a > F::zero() {
+        F::zero()
     } else {
         panic!("Expected a positive input.")
     }
@@ -84,11 +83,11 @@ where
 /// [kaiserord], [kaiser_beta]
 pub fn kaiser_atten<F>(numtaps: u32, width: F) -> F
 where
-    F: Real + MulAdd<Output = F>,
+    F: Real + MulAdd<Output = F> + RealField,
 {
     MulAdd::mul_add(
         width,
-        F::from(numtaps - 1).unwrap() * F::from(2.285 * PI).unwrap(),
+        F::from(numtaps - 1).unwrap() * F::from(2.285).unwrap() * F::pi(),
         F::from(7.95).unwrap(),
     )
 }
@@ -217,16 +216,16 @@ where
 ///
 pub fn kaiserord<F>(ripple: F, width: F) -> (F, F)
 where
-    F: Real + MulAdd<Output = F> + Pow<F, Output = F>,
+    F: Real + MulAdd<Output = F> + Pow<F, Output = F> + RealField,
 {
-    let a = ripple.abs();
+    let a = Real::abs(ripple);
     if a < F::from(8).unwrap() {
         panic!("Requested maximum ripple attenuation is too small for the Kaiser formula.");
     }
     let beta = kaiser_beta(a);
     let numtaps =
-        F::from(1).unwrap() + (a - F::from(7.95).unwrap()) / (F::from(2.285 * PI).unwrap() * width);
-    (numtaps.ceil(), beta)
+        F::one() + (a - F::from(7.95).unwrap()) / (F::from(2.285).unwrap() * F::pi() * width);
+    (Real::ceil(numtaps), beta)
 }
 
 #[cfg(test)]

sci-rs/src/signal/windows/boxcar.rs

@@ -62,9 +62,9 @@ where
         let (m, needs_trunc) = extend(self.m, self.sym);
 
         if !needs_trunc {
-            vec![W::from(1).unwrap(); m]
+            vec![W::one(); m]
         } else {
-            vec![W::from(1).unwrap(); m - 1]
+            vec![W::one(); m - 1]
         }
     }
 }

sci-rs/src/signal/windows/general_hamming.rs

@@ -145,12 +145,8 @@ where
     /// [5]: #references
     #[cfg(feature = "alloc")]
     fn get_window(&self) -> Vec<W> {
-        GeneralCosine::new(
-            self.m,
-            [self.alpha, F::from(1).unwrap() - self.alpha].into(),
-            self.sym,
-        )
-        .get_window()
+        GeneralCosine::new(self.m, [self.alpha, F::one() - self.alpha].into(), self.sym)
+            .get_window()
     }
 }
 

sci-rs/src/signal/windows/kaiser.rs

@@ -172,6 +172,7 @@ where
     /// [3]: #references
     /// [4]: #references
     /// [5]: #references
+    #[cfg(feature = "alloc")]
     fn get_window(&self) -> Vec<W> {
         if len_guard(self.m) {
             return Vec::<W>::new();

sci-rs/src/signal/windows/triangle.rs

@@ -76,14 +76,14 @@ where
         let w: Vec<W> = match m % 2 {
             0 => {
                 let mut w: Vec<W> = n
-                    .map(|n| (W::from(2).unwrap() * n - W::from(1).unwrap()) / m_f)
+                    .map(|n| (W::from(2).unwrap() * n - W::one()) / m_f)
                     .collect();
                 w.extend(w.clone().iter().rev());
                 w
             }
             1 => {
                 let mut w: Vec<W> = n
-                    .map(|n| W::from(2).unwrap() * n / (m_f + W::from(1).unwrap()))
+                    .map(|n| W::from(2).unwrap() * n / (m_f + W::one()))
                     .collect();
                 w.extend(w.clone().iter().rev().skip(1));
                 w