common_traits

This is a collection of traits and dependancies I often use to write generic code for both data-structures and scientific computing.

Everything is experimental and I'll change them to my needs :)

The point of making this crate public is to be able to discuss this as it covers many core missings from Rust.

The crate contains the following traits: - [Number] to abstract over all the numerical traits. - [Float] for floating point numbers. - [Word] for unsigned integers. - [SignedWord] for signed integers. - [Atomic] for Atomic values. - [AtomicNumber] for Atomic numbers. - [NonZero] for the non zero variants of numbers.

These are similar to the ones from num-traits but they are more connected which allows to write generic codes with less bounds.

The numerical traits dependancy chains is this:

This crate adds emulated atomic floats through fetch_update for the following types: - [f64] as [AtomicF64] - [f32] as [AtomicF32] - [half::f16] as [AtomicF16] - [half::bf16] as [AtomicBF16]

The crate also contains a couple of extra traits: - [Rng] for a generic random number generator. - [Splat] to broadcast a smaller type on a larger type, mainly used for SWAR. - [SelectInWord] to find the position of the i-th 1 or 0 in word. - [FastRange] for faster div, mod, and range operations. - [Sequence], [SequenceMut], and [SequenceGrowable] to abstract over slices and other sequence like types.

Traits for conversion between types are also provided: - [UpcastableInto] and [UpcastableFrom] to cast primitive values which are known to don't lose precision.

• [DowncastableInto] and [DowncastableFrom] to cast primitive values which are known to lose precision.

  

• [CastableInto] and [CastableFrom] to cast primitive values which may or may not lose precision. This is the union of [DowncastableInto] and [UpcastableInto].

• [To], to cast primitve values using as.

  The difference between Castable and [To] is that Castable does not allow casting from f32 to u32 for example, because Castable is implemented only between integers and between floats, while [To] is implemented for all primitive types.

  Features

  This crate has the following features:

• simd: To enable portable_simd and be able to do generic simd code
• atomic_from_mut: to add the get_mut_slice and from_mut_slice methods
• std: to disable for no_std

• half: to enable support for half::f16 (WORK IN PROGRESS)

  Example

  Mixed precision generic dot products! ```rust use common_traits::*;

  [inline]

  pub fn dotproduct(a: A, b: B) -> RT where A: Sequence, B: Sequence, A::Item: To, B::Item: To, MT: To, RT: To, { // Check compatability of the vectors asserteq!(a.len(), b.len());

  // Compute the dot product let mut accum = RT::ZERO; for (a, b) in a.iter().zip(b.iter()) { accum = (a.to()).mul_add(b.to(), accum.to()).to(); }

  accum }

  let x: Vec = vec![1.0, 2.0, 3.0]; let w: Vec = vec![3, 2, 1]; // compute the dot product between f32 and u8, casting to f64 and // accumulating as u16 let res: u16 = dot_product::(&x, &w); println!("{:?}", res); ```