ldiv

auto kyosu::ldiv = eve::functor<ldiv_t>

inlineconstexpr

Computes the left division of the product of the arguments but the first.

Header file

#include <kyosu/functions.hpp>

Callable Signatures

namespace kyosu
{
  // Regular overloads
  constexpr auto ldiv(auto xs...) noexcept;                                     noexcept; // 1
  constexpr auto dliv(eve::non_empty_product_type auto const& tup)             noexcept; // 2
  constexpr auto ldiv[kahan](/*any of the above overloads*/)                    noexcept; // 3
 
  // Lanes masking
  constexpr auto ldiv[conditional_expr auto c](/*any of the above overloads*/)  noexcept; // 4
  constexpr auto ldiv[logical_value auto m](/*any of the above overloads*/)     noexcept; // 4
}

Parameters

• xs...: Values to process.
• tup : kumi tuple of arguments.

Return value

1. left division.
   • For one argument returns the inverse of the argument
   • For two arguments returns the left division of the two arguments. This function is not equivalent to z1/z0 as soon as multiplication is not commutative (i.e. for general Cayley-Dickson values with dimensionality strictly above 2).
   • For more arguments the left division of the product of the arguments but the first, by the first is returned.
2. same as 1. on the tuple elements.
3. kahan algorithm is used to enhance accuracy.
4. The operation is performed conditionnaly

Example

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