using SymEngine::pi;
TEST_CASE("Constructors of Expression", "[Expression]")
{
Expression e0 = symbol("x");
REQUIRE(eq(*e0.get_basic(), *symbol("x")));
Expression e1 = 20;
REQUIRE(eq(*e1.get_basic(), *integer(20)));
Expression e2 = 10.0;
REQUIRE(eq(*e2.get_basic(), *real_double(10.0)));
Expression e3 = std::complex<double>(1.0, 2.0);
REQUIRE(
eq(*e3.get_basic(), *complex_double(std::complex<double>(1.0, 2.0))));
}
TEST_CASE("Printing of Expression", "[Expression]")
{
Expression e0 = symbol("x");
std::stringstream s;
s << e0;
REQUIRE(s.str() == "x");
}
TEST_CASE("Arithmetic of Expression", "[Expression]")
{
Expression x = symbol("x"), y = symbol("y");
auto z = x + y;
std::cout << z << std::endl;
r2 = add(I, x);
REQUIRE(eq(*r1, *r2));
r1 = mul(x, I);
r2 = mul(mul(I, i2), x);
r3 = mul(mul(I, i3), x);
r2 = add(r1, r2);
REQUIRE(eq(*r3, *r2));
r1 = real_double(0.1);
r2 = Rational::from_mpq(mpq_class(1, 2));
r3 = add(add(add(r1, r2), integer(1)), real_double(0.2));
REQUIRE(is_a<RealDouble>(*r3));
REQUIRE(std::abs(rcp_static_cast<const RealDouble>(r3)->i - 1.8) < 1e-12);
r1 = complex_double(std::complex<double>(0.1, 0.2));
r2 = Complex::from_two_nums(*Rational::from_mpq(mpq_class(1, 2)), *Rational::from_mpq(mpq_class(7, 5)));
r3 = add(add(add(r1, r2), integer(1)), real_double(0.4));
REQUIRE(is_a<ComplexDouble>(*r3));
REQUIRE(std::abs(rcp_static_cast<const ComplexDouble>(r3)->i.real() - 2.0) < 1e-12);
REQUIRE(std::abs(rcp_static_cast<const ComplexDouble>(r3)->i.imag() - 1.6) < 1e-12);
}
TEST_CASE("Mul: arit", "[arit]")
{
RCP<const Basic> x = symbol("x");
RCP<const Basic> y = symbol("y");
RCP<const Basic> z = symbol("z");
RCP<const Basic> im2 = integer(-2);
RCP<const Basic> i2 = integer(2);
RCP<const Basic> i3 = integer(3);
r = max({x, add(mul(y, z), integer(3))});
v.init({x, y, z}, *r);
d = v.call({4.0, 1.0, 2.5});
REQUIRE(::fabs(d - 5.5) < 1e-12);
r = min({pow(x, y), add(mul(y, z), integer(3))});
v.init({x, y, z}, *r);
d = v.call({4.0, 2.0, 2.5});
REQUIRE(::fabs(d - 8.0) < 1e-12);
// Evaluating to double when there are complex doubles raise an exception
CHECK_THROWS_AS(
v.init({x}, *add(complex_double(std::complex<double>(1, 2)), x)),
std::runtime_error);
// Undefined symbols raise an exception
CHECK_THROWS_AS(v.init({x}, *r), std::runtime_error);
}
TEST_CASE("Evaluate to std::complex<double>", "[lambda_complex_double]")
{
RCP<const Basic> x, y, z, r;
std::complex<double> d;
x = symbol("x");
y = symbol("y");
z = symbol("z");
r = add(x,
RCP<const Number> r1 = rational(1, 1);
RCP<const Number> rm1 = rational(-1, 1);
RCP<const Number> r0 = rational(0, 1);
RCP<const Integer> im1 = integer(-1);
RCP<const Integer> i0 = integer(0);
RCP<const Infty> a = Infty::from_direction(r1);
RCP<const Infty> b = Infty::from_direction(rm1);
RCP<const Infty> c = Infty::from_direction(r0);
REQUIRE(eq(*a, *Inf));
REQUIRE(eq(*b, *NegInf));
REQUIRE(eq(*c, *ComplexInf));
CHECK_THROWS_AS(a->is_canonical(complex_double(std::complex<double>(2, 3))),
NotImplementedError &);
CHECK_THROWS_AS(
a->is_canonical(Complex::from_two_nums(*integer(1), *integer(2))),
NotImplementedError &);
REQUIRE(not(a->is_canonical(integer(2))));
a = infty();
b = infty(-1);
c = infty(0);
REQUIRE(eq(*a, *Inf));
REQUIRE(eq(*b, *NegInf));
REQUIRE(eq(*c, *ComplexInf));
mpfr_set_ui(a.get_mpfr_t(), 10, MPFR_RNDN);
mpfr_set_ui(b.get_mpfr_t(), 20, MPFR_RNDN);
mpfr_set_ui(c.get_mpfr_t(), 100, MPFR_RNDN);
mpfr_set_ui(d.get_mpfr_t(), 1024, MPFR_RNDN);
RCP<const Number> r1 = real_mpfr(std::move(a));
RCP<const Number> r2 = real_mpfr(std::move(b));
RCP<const Number> r3 = real_mpfr(std::move(c));
RCP<const Number> r4 = real_mpfr(std::move(d));
RCP<const Number> r5 = subnum(integer(0), r1);
RCP<const Number> i1 = integer(1);
RCP<const Number> i2 = integer(2);
RCP<const Number> half = integer(1)->div(*integer(2));
RCP<const Number> c1 = Complex::from_two_nums(*i1, *i1);
RCP<const Number> rat1 = Rational::from_two_ints(*integer(10), *integer(3));
RCP<const Number> rd1 = real_double(10.0);
RCP<const Number> cd1 = complex_double(std::complex<double>(1, 2));
REQUIRE(not r1->is_one());
REQUIRE(not r1->is_minus_one());
REQUIRE(not r1->is_complex());
REQUIRE(eq(*r2, *addnum(r1, r1)));
REQUIRE(is_a<RealMPFR>(*addnum(r1, rat1)));
REQUIRE(eq(*r2, *addnum(r1, rd1)));
REQUIRE(eq(*r1, *subnum(r1, integer(0))));
REQUIRE(is_a<RealMPFR>(*subnum(r2, rat1)));
REQUIRE(eq(*r1, *subnum(r2, rd1)));
REQUIRE(is_a<RealMPFR>(*subnum(rat1, r2)));
REQUIRE(eq(*neg(r1), *subnum(rd1, r2)));
REQUIRE(eq(*r2, *mulnum(r1, i2)));
REQUIRE(eq(*r2, *mulnum(i2, r1)));
