doc/html/test_expr_functions_exponential.html

 // ========================================================================= //
 // This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
 // and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
 // ========================================================================= //

 #include <myramath/expression/Expression.h>
 #include <myramath/expression/expr.h>
 #include <myramath/expression/functions.h>
 #include <myramath/expression/arithmetic.h>
 #include <myramath/expression/frobenius.h>

 // Reporting.
 #include <tests/myratest.h>

 using namespace myra;

 #ifdef MYRAMATH_ENABLE_CPP11

 ADD_TEST("expr_functions_trig","[expression]")
   {
   double tol = 1.0e-12;
   double pi = std::acos(-1.0);
   auto E = expr({0.0,pi/6.0,pi/4.0,pi/3.0,pi/2.0});
   REQUIRE( frobenius( sin(E) - expr({0.0,0.5,sqrt(2.0)/2.0,sqrt(3.0)/2.0,1.0}) ) < tol );
   REQUIRE( frobenius( cos(E) - expr({1.0,sqrt(3.0)/2.0,sqrt(2.0)/2.0,0.5,0.0}) ) < tol );
   auto X = cos(E);
   auto Y = sin(E);
   REQUIRE( frobenius( atan2(Y,X) - E ) < tol );
   }

 ADD_TEST("expr_functions_exponential","[expression]")
   {
   double tol = 1.0e-12;
   auto E = expr({0.0,1.0,2.0,3.0});
   REQUIRE( frobenius( log(exp(E)) - E ) < tol );
   REQUIRE( frobenius( log10(pow(10.0,E)) - E ) < tol );
   }

 ADD_TEST("expr_functions_power","[expression]")
   {
   double tol = 1.0e-12;
   auto E  = expr({0.0,1.0,2.0,3.0});
   auto E2 = expr({0.0,1.0,4.0,9.0});
   REQUIRE( frobenius( pow(E,2.0) - E2 ) < tol );
   REQUIRE( frobenius( sqrt(E2) - E ) < tol );
   }

 ADD_TEST("expr_functions_complex","[expression]")
   {
   double tol = 1.0e-12;
   double pi = std::acos(-1.0);
   std::complex<double> j(0.0,1.0);
   auto P = expr({0.0,pi/6.0,pi/4.0,pi/3.0,pi/2.0});
   auto R = cos(P);
   auto I = sin(P);
   auto Z = exp( j*make_complex(P) );
   REQUIRE( frobenius( R - realpart(Z) ) < tol );
   REQUIRE( frobenius( I - imagpart(Z) ) < tol );
   REQUIRE( frobenius( P - argument(Z) ) < tol );
   REQUIRE( frobenius( P + argument(conjugate(Z)) ) < tol );
   }

 ADD_TEST("expr_functions_measure","[expression]")
   {
   double tol = 1.0e-12;
   std::vector<double> r {3.0, 5.0, 8.0, 7.0};
   std::vector<double> i {4.0,12.0,15.0,24.0};
   std::vector<double> a {5.0,13.0,17.0,25.0};
   auto R = expr(r);
   auto I = expr(i);
   auto Z = make_complex(R,I);
   auto A = expr(a);
   REQUIRE( frobenius( abs(Z) - A ) < tol );
   }

 #endif
myra::abs
Expression< 1, NumberS > abs(const Expression< 1, NumberS > &A)
Returns the std::abs() of an Expression.
Definition: functions_measure.cpp:29

myra::exp
Expression< 1, NumberS > exp(const Expression< 1, NumberS > &A)
Returns the std::exp() of an Expression.
Definition: functions_exponential.cpp:29

expr.h
Overloads expr() for std::vector<Number> and (C++11 only) std::initializer_list<Number> ...

myra::pow
Expression< 1, NumberS > pow(const Expression< 1, NumberS > &A, const Expression< 1, NumberS > &B)
Returns A^B, an Expression base raised to an Expression power.
Definition: functions_power.cpp:53

myra::sin
Expression< 1, NumberS > sin(const Expression< 1, NumberS > &A)
Returns the std::sin() of an Expression.
Definition: functions_trig.cpp:30

Expression.h
An interface used to fill containers from Expression&#39;s (see Matrix::evaluate(), for example)...

myra
Definition: syntax.dox:1

myra::cos
Expression< 1, NumberS > cos(const Expression< 1, NumberS > &A)
Returns the std::cos() of an Expression.
Definition: functions_trig.cpp:60

arithmetic.h
Arithmetic operators (+,-,*,/) for Expression&#39;s.

frobenius.h
Routines for computing Frobenius norms of Expression&#39;s.

myra::sqrt
Expression< 1, NumberS > sqrt(const Expression< 1, NumberS > &A)
Returns the std::sqrt() of an Expression.
Definition: functions_power.cpp:30

functions.h
Function overloads (sin, exp, etc) for Expression&#39;s.

myra::log10
Expression< 1, NumberS > log10(const Expression< 1, NumberS > &A)
Returns the std::log10() of an Expression.
Definition: functions_exponential.cpp:89

myra::atan2
Expression< 1, NumberS > atan2(const Expression< 1, NumberS > &Y, const Expression< 1, NumberS > &X)
Returns the std::atan2(y,x) of a real Expression.
Definition: functions_trig.cpp:212

myra::make_complex
Expression< 1, NumberC > make_complex(const Expression< 1, NumberS > &A)
Promotes a real Expression into a complex one.
Definition: functions_complex.cpp:122

myra::log
Expression< 1, NumberS > log(const Expression< 1, NumberS > &A)
Returns the std::log() of an Expression.
Definition: functions_exponential.cpp:59