csc

auto eve::csc = functor<csc_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

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

Parameters

• x: floating value.
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

1. Returns the elementwise cosecant of the input. In particular:
   • If the element is \(\pm0\), \(\pm\infty\) is returned.
   • If the element is \(\pm\infty\), Nan is returned.
   • If the element is a NaN, NaN is returned. (the inverse of the sine). In particular:
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.
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

• 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::upper](eve::as(wf));
 
  std::cout << "<- wf                     = " << wf << "\n";
 
  std::cout << "-> csc(wf)                = " << eve::csc(wf) << "\n";
  std::cout << "-> csc[deg](wf)           = " << eve::csc[eve::deg](wf) << "\n";
  std::cout << "-> csc[radpi](wf)         = " << eve::csc[eve::radpi](wf) << "\n";
  std::cout << "-> csc[rad](wf)           = " << eve::csc[eve::rad](wf) << "\n";
  std::cout << "-> csc[ignore_last(2)](wf)= " << eve::csc[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> csc[wf != -2.0f](wf)   = " << eve::csc[wf != -2.0f](wf) << "\n";
  std::cout << "-> csc[quarter_circle](wf)= " << eve::csc[eve::quarter_circle](wf) << "\n";
  std::cout << "-> csc[half_circle](wf)   = " << eve::csc[eve::half_circle](wf) << "\n";
  std::cout << "-> csc[full_circle](wf)   = " << eve::csc[eve::full_circle](wf) << "\n";
}