impl `trig` for `core::simd`

[Lokathor]

• sin
• cos
• tan
• asin
• acos
• atan
• atan2
• sinh
• cosh
• tanh
• asinh
• acosh
• atanh

[etemesi-ke]

Heey, i could implement some of these and submit a PR, and I was wondering
If the appropriate way was to use the Taylor series for the above trig functions since am not sure what the rust standard library uses

[calebzulawski]

The Taylor series is probably not sufficient since it's only accurate near 0. This paper summarizes a variety of algorithms used for vectorized implementations of popular numeric functions, including trigonometry: https://arxiv.org/abs/2001.09258. The referenced SLEEF library is used by packed_simd, however I don't believe SLEEF itself can be used in this crate.

[etemesi-ke]

What algorithm did you have in mind then?

And would the impls look like

trait trig {
     type Output=Self::Output
     #[target-enable="sse"]
     fn cos(&self);
}
impl trig for _mm128{
     type Output = _mm128
    #[target-enable="sse"]
     
    fn cos(){
     //Code
    }
}

[etemesi-ke]

Sorry for the first part, after re-reading your comment if I understand it right you want to use the algorithms in the paper used by sleef but not necessarily the sleef library. I.e rewrite them in rust?

[Lokathor]

So, I don't know what the quality or speed is, but LLVM has built-in handling for vector trig same as with vector add, sub, etc.

Example from packed_simd: https://github.com/rust-lang/packed_simd/blob/master/src/codegen/math/float/cos.rs

If the LLVM versions are of sufficient quality, we should likely just use that.

[bjorn3]

There are platform-intrinsic versions for sin and cos by the way, so no need to use LLVM intrinsics directly. Curiously enough there are no versions for other trigonometry functions, but that should be easy to add.

https://github.com/rust-lang/rust/blob/41507ed0d57eba71adc20a021a19b64322162f04/compiler/rustc_codegen_llvm/src/intrinsic.rs#L1080-L1085

[etemesi-ke]

Are the LLVM intrinsics useful for SIMD
with what I understand according to their doc their cos function for example just operates on one floating point value

[bjorn3]

There are LLVM intrinsics with names like llvm.cos.v2f32 that operate on vectors.

[etemesi-ke]

@bjorn3 Thanks for clarifying that,

so the code might look like

![feature(link_llvm_intrinsics)]
extern {
    #[link_name="llvm.cos.v2f32"]
      fn cos(a:[f64;2])->[f64;2];
}
/// A vector for two floating points
struct f64x2([f64; 2]);

impl trig for f64x2{
   fn cos(&self)->f64x2{
        f64x2(cos(self.0))
   }
}

[bjorn3]

More like

#![feature(link_llvm_intrinsics)]
extern {
    #[link_name="llvm.cos.v2f32"]
      fn cos(a: f64x2)-> f64x2;
}
/// A vector for two floating points
#[repr(simd)]
struct f64x2([f64; 2]);

impl trig for f64x2{
   fn cos(&self)-> f64x2{
        cos(self)
   }
}

[etemesi-ke]

Okay that makes sin and cos easy

And the rest are we gonna implement from the ground up?

[emmanuelantony2000]

I think so yes, tan and others have to be implemented from the ground up.
Is it implemented by using sin and cos, or is there an another way?