correctly use no_std, get rid of macro in exchange for zips and maps,…

… bump ver

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "fath"
 authors = [ "burgerindividual", "duplexsystem" ]
-version = "0.1.5"
+version = "0.1.6"
 edition = "2021"
 license = "LGPL-3.0"
 repository = "https://github.com/burgerindividual/fath"

src/lib.rs

@@ -1,14 +1,10 @@
-#![feature(core_intrinsics, portable_simd)]
-// #![no_std]
-
-pub extern crate std as core;
-
-extern crate alloc;
+#![feature(core_intrinsics, portable_simd, array_zip)]
+#![no_std]
 
 pub mod scalar;
 pub mod shared;
 // #![cfg_attr(feature = "portable_simd", feature(portable_simd))]
 pub mod simd;
 
 #[cfg(test)]
-pub mod test;
+pub mod test;

src/simd/float.rs

@@ -1,5 +1,4 @@
 use crate::shared::float::*;
-use crate::*;
 use core::simd::*;
 
 impl<const LANES: usize> FastApproxFloat for Simd<f32, LANES>
@@ -8,21 +7,37 @@ where
 {
     #[inline(always)]
     unsafe fn sin_fast_approx<const PRECISION: usize>(self) -> Self {
-        wrap_auto_vectorize!(sin_fast_approx::<PRECISION, false>, LANES, self)
+        Simd::from_array(
+            self.as_array()
+                .map(|e| sin_fast_approx::<PRECISION, false>(e)),
+        )
     }
 
     #[inline(always)]
     unsafe fn cos_fast_approx<const PRECISION: usize>(self) -> Self {
-        wrap_auto_vectorize!(sin_fast_approx::<PRECISION, true>, LANES, self)
+        Simd::from_array(
+            self.as_array()
+                .map(|e| sin_fast_approx::<PRECISION, true>(e)),
+        )
     }
 
     #[inline(always)]
     unsafe fn log_fast_approx<const PRECISION: usize>(self, base: Self) -> Self {
-        wrap_auto_vectorize!(log_fast_approx::<PRECISION>, LANES, self, base)
+        Simd::from_array(
+            self.as_array()
+                .zip(*base.as_array())
+                .map(|(self_elem, base_elem)| log_fast_approx::<PRECISION>(self_elem, base_elem)),
+        )
     }
 
     #[inline(always)]
     unsafe fn log_fast_approx_const_base<const PRECISION: usize>(self, base: Self) -> Self {
-        wrap_auto_vectorize!(log_fast_approx_const_base::<PRECISION>, LANES, self, base)
+        Simd::from_array(
+            self.as_array()
+                .zip(*base.as_array())
+                .map(|(self_elem, base_elem)| {
+                    log_fast_approx_const_base::<PRECISION>(self_elem, base_elem)
+                }),
+        )
     }
 }

src/simd/int.rs

@@ -1,9 +1,8 @@
 use crate::shared::int::*;
 use crate::*;
 
+use core::mem::size_of;
 use core::simd::*;
-use mem::size_of;
-use std::mem;
 
 macro_rules! unsigned_impl {
     ($u:ty,$s:ty,$f:ty,$mant_bits:expr) => {
@@ -31,10 +30,10 @@ macro_rules! unsigned_impl {
                     let unsigned_mask = Mask::from_int_unchecked(
                         self.cast::<$s>() >> Simd::splat(UNSIGNED_LOG2 as $s),
                     );
-                    
+
                     // need to get rid of bits that could cause a round-up
                     let adjusted = (self & !(self >> Simd::splat($mant_bits + 1))).cast::<$s>();
-                    
+
                     let exponent = (adjusted.cast::<$f>().to_bits() >> Simd::splat($mant_bits))
                         - Simd::splat((1 << ((size_of::<$f>() * 8) - 2 - $mant_bits)) - 1);
 

src/simd/mod.rs

@@ -1,3 +1,2 @@
-pub mod consts;
 pub mod float;
 pub mod int;

src/test/compile.rs

@@ -1,8 +1,8 @@
-use crate::shared::int::*;
+use crate::shared::float::FastApproxFloat;
 use core::simd::*;
 
 #[inline(never)]
 #[allow(dead_code)]
-pub fn test(x: u32x8) -> u32x8 {
-    unsafe { x.ilog_const_base_unchecked::<2>() }
+pub fn test(x: f32x8, base: f32x8) -> f32x8 {
+    unsafe { x.log_fast_approx::<0>(base) }
 }

src/test/mod.rs

@@ -1,2 +1,4 @@
+#[cfg(test)]
 pub mod checks;
-pub mod compile;
+
+pub mod compile;