arg

eve::arg = functor<arg_t>

inlineconstexpr

Callable Signatures

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto arg(floating_value auto x)                  noexcept; // 1
 
   // Lanes masking
   constexpr auto abs[conditional_expr auto c](value auto x)  noexcept; // 2
   constexpr auto abs[logical_value auto m](value auto x)     noexcept; // 2
 
   // Semantic option
   constexpr auto absmax[pedantic](floating_value auto x)     noexcept; // 3
}

Parameters

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

Return value

1. Returns elementwise the phase angle (in radians) of the input (0 or \(\pi\)) depending of the bit of sign of the input
2. The operation is performed conditionnaly.
3. If the entry is NaN the result is NaN.

External references

• C++ standard reference

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = { 0.0f, -0.0f, 1.0f, -1.0f,
                   -0.5f, 0.5f, eve::inf(eve::as<float>()), eve::nan(eve::as<float>())};
 
  std::cout << "<- wf                      = " << wf << "\n";
 
  std::cout << "-> arg(wf)                 = " << eve::arg(wf) << "\n";
  std::cout << "-> arg[pedantic](wf)       = " << eve::arg[eve::pedantic](wf) << "\n";
  std::cout << "-> arg[ignore_last(2)](wf) = " << eve::arg[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> arg[wf != 0.5f](wf)     = " << eve::arg[wf != 0.5f](wf) << "\n";
}