sin

auto eve::sin = functor<sin_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto sin(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto sin[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto sin[logical_value auto m](floating_value auto x)    noexcept; // 2
 
   // Semantic options
   constexpr auto sin[quarter_circle](floating_value auto x)          noexcept; // 3.a
   constexpr auto sin[half_circle](floating_value auto x)             noexcept; // 3.b
   constexpr auto sin[full_circle](floating_value auto x)             noexcept; // 3.c
   constexpr auto sin[raw](floating_value auto x)                     noexcept; // 4
   constexpr auto sin[fast] (floating_value auto x)                   noexcept; // 4
   constexpr auto sin[rad](floating_value auto x)                     noexcept; // 1
   constexpr auto sin[deg](floating_value auto x)                     noexcept; // 5
   constexpr auto sin[radpi](floating_value auto x)                   noexcept; // 6
}

Parameters

 * `x`: [floating value](@ref eve::floating_value).
 * `c`: [Conditional expression](@ref eve::conditional_expr) masking the operation.
 * `m`: [Logical value](@ref eve::logical_value) masking the operation.

Return value

1. Returns the elementwise sine of the input in radian. In particular:
   • If the element is \(\pm0\), \(\pm0\) is returned.
   • If the element is \(\pm\infty\), Nan is returned.
   • If the element is a Nan, NaN is returned.
2. The operation is performed conditionnaly.

3. These are optimized calls providing a balance between speed and range limitation.

   1. assumes that the inputs elements belong to \([-\pi/4,\pi/4]\) and return NaN outside.
   2. assumes that the inputs elements belong to \([-\pi/2,\pi/2]\) and return NaN outside.
   3. assumes that the inputs elements belong to \([-\pi,\pi]\) and return NaN outside. these options can be combined with the previous ones with ranges adapted to the chosen unity.

   these options can be combined with the previous ones with ranges adapted to the chosen unity.

4. faster but less accurate versions that can be mixed with range limitations to quarter_circle or half_circle_option to have any effect.
5. assume a parameter in degree.
6. assume a parameter in \(\pi\) multiples.

External references

• C++ standard reference
• Wikipedia
• Wolfram MathWorld

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25, -0.5, -2.0};
  wf *= eve::pi[eve::lower](eve::as(wf));
 
  std::cout << "<- wf = " << wf << "\n";
  std::cout << "-> sin(wf)                = " << eve::sin(wf) << "\n";
  std::cout << "-> sin[deg](wf)           = " << eve::sin[eve::deg](wf) << "\n";
  std::cout << "-> sin[radpi](wf)         = " << eve::sin[eve::radpi](wf) << "\n";
  std::cout << "-> sin[rad](wf)           = " << eve::sin[eve::rad](wf) << "\n";
  std::cout << "-> sin[ignore_last(2)](wf)= " << eve::sin[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> sin[wf != -2.0f](wf)   = " << eve::sin[wf != -2.0f](wf) << "\n";
  std::cout << "-> sin[quarter_circle](wf)= " << eve::sin[eve::quarter_circle](wf) << "\n";
  std::cout << "-> sin[half_circle](wf)   = " << eve::sin[eve::half_circle](wf) << "\n";
  std::cout << "-> sin[full_circle](wf)   = " << eve::sin[eve::full_circle](wf) << "\n";
}