sec

auto eve::sec = functor<sec_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto sec(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto sec[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto sec[logical_value auto m](floating_value auto x)    noexcept; // 2
 
   // Semantic options
   constexpr auto sec[quarter_circle](floating_value auto x)           noexcept; // 3.a
   constexpr auto sec[half_circle](floating_value auto x)              noexcept; // 3.b
   constexpr auto sec[full_circle](floating_value auto x)              noexcept; // 3.c
   constexpr auto sec[raw](floating_value auto x)                      noexcept; // 4.a
   constexpr auto sec[fast] (floating_value auto x)                    noexcept; // 4.b
   constexpr auto sec[rad](floating_value auto x)                      noexcept; // 1
   constexpr auto sec[deg](floating_value auto x)                      noexcept; // 5
   constexpr auto sec[pirad](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 secant of (the inverse of the cosine). In particular: In particular:
   1. assume a parameter in radian.
   2. assume a parameter in degree.
   3. assume a parameter in \(\pi\) multiples.

1. The operation is performed conditionnaly.
2. 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.
3. faster but less accurate versions that can be mixed with range limitations to quarter_circle or half_circle_option to have any effect.
4. assume a parameter in degree.
5. 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::lower](eve::as(wf));
 
  std::cout << "<- wf                     = " << wf << "\n";
 
  std::cout << "-> sec(wf)                = " << eve::sec(wf) << "\n";
  std::cout << "-> sec[deg](wf)           = " << eve::sec[eve::deg](wf) << "\n";
  std::cout << "-> sec[radpi](wf)         = " << eve::sec[eve::radpi](wf) << "\n";
  std::cout << "-> sec[rad](wf)           = " << eve::sec[eve::rad](wf) << "\n";
  std::cout << "-> sec[ignore_last(2)](wf)= " << eve::sec[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> sec[wf > 0.0](wf)      = " << eve::sec[wf > 0.0](wf) << "\n";
  std::cout << "-> sec[quarter_circle](wf)= " << eve::sec[eve::quarter_circle](wf) << "\n";
  std::cout << "-> sec[half_circle](wf)   = " << eve::sec[eve::half_circle](wf) << "\n";
  std::cout << "-> sec[full_circle](wf)   = " << eve::sec[eve::full_circle](wf) << "\n";
}