maxabs

auto kyosu::maxabs = eve::functor<maxabs_t>

inlineconstexpr

Callable object computing the maxabs operation.

Header file

#include <kyosu/functions.hpp>

Callable Signatures

namespace kyosu
{
   //regular call
   template<typename ... Ts> auto maxabs(Ts ... zs       ) const noexcept// 1
   template<typename Tup>    auto maxabs(kumi::tuple Tup ) const noexcept// 2
 
   // Semantic modifyiers
   auto maxabs[raw](/* any previous overload*/) const      noexcept;     // 3
   auto maxabs[numeric](/* any previous overload*/) const  noexcept;     // 4
   auto maxabs[pedantic](/* any previous overload*/) const noexcept;     // 5
   auto maxnabs[flat](/* any previous overload*/) const    noexcept;     // 6
}

Parameters

• zi...: cayley_dickson_like values to process.
• tup : tuple of cayley_dickson_like values to process.

Return value

1. Returns elementwise the square root maximum of the squared absolute values of the parameters. 2 Same as 1, but the parameters are from the tuple
2. With the raw option no provision is made to enhance accuracy and avoid overflows
3. With the flat option it is the \(\l_\infty\) norm of all the components that is computed.
4. Returns elementwise the pedantic maximum of the absolute values of the parameters.
5. Returns elementwise the numeric maximum of the absolute values of the parameters.

Example

#include <eve/wide.hpp>
#include <iostream>
#include <kyosu/kyosu.hpp>
 
int main()
{
  using kyosu::complex_t;
  using kyosu::maxabs;
  using kyosu::quaternion_t;
  using e_t = float;
  using c_t = kyosu::complex_t<float>;
  using q_t = kyosu::quaternion_t<float>;
  using we_t = eve::wide<float, eve::fixed<2>>;
  using wc_t = eve::wide<kyosu::complex_t<float>, eve::fixed<2>>;
  using wq_t = eve::wide<kyosu::quaternion_t<float>, eve::fixed<2>>;
 
  std::cout << "Real:        " << "\n";
  e_t e0(1);
  e_t e1(2);
  std::cout << e0 << ", " << e1 << " -> " << maxabs(e0, e1) << "\n";
  we_t we0(e0);
  we_t we1(e1);
  std::cout << we0 << ", " << we1 << " -> " << maxabs(we0, we1) << "\n";
 
  std::cout << "Complex:     " << "\n";
  c_t c0(5);
  c_t c1(5, 9);
  std::cout << c0 << ", " << c1 << " -> " << maxabs(c0, c1) << "\n";
  wc_t wc0(c0);
  wc_t wc1(c1);
  std::cout << wc0 << ", " << wc1 << " -> " << maxabs(wc0, wc1) << "\n";
 
  std::cout << "Quaternion:  " << "\n";
  q_t q0(5, 2, 3);
  q_t q1(5, 9, 6, 7);
  std::cout << q0 << ", " << q1 << " -> " << maxabs(q0, q1) << "\n";
  wq_t wq0(q0);
  wq_t wq1(q1);
  std::cout << wq0 << ", " << wq1 << " -> " << maxabs(wq0, wq1) << "\n";
 
  return 0;
}