int main(int argc, char *argv[]) { SymEngine::print_stack_on_segfault(); int N; if (argc == 2) { N = std::atoi(argv[1]); } else { N = 20; } RCP<const Basic> x = symbol("x"), y = symbol("y"), e, f; e = pow(add(one, add(mul(sqrt(integer(3)), x), mul(sqrt(integer(5)), y))), integer(N)); f = mul(e, add(e, sqrt(integer(7)))); auto t1 = std::chrono::high_resolution_clock::now(); f = expand(f); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1) .count() << "ms" << std::endl; // std::cout << f->__str__() << std::endl; return 0; }
int main(int argc, char* argv[]) { Teuchos::print_stack_on_segfault(); RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> w = symbol("w"); RCP<const Basic> i100 = integer(100); RCP<const Basic> e, r; e = pow(add(add(pow(x, y), pow(y, x)), pow(z, x)), i100); std::cout << "Expanding: " << *e << std::endl; auto t1 = std::chrono::high_resolution_clock::now(); r = expand(e); auto t2 = std::chrono::high_resolution_clock::now(); //std::cout << *r << std::endl; std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << "ms" << std::endl; std::cout << "number of terms: " << rcp_dynamic_cast<const Add>(r)->dict_.size() << std::endl; return 0; }
int main(int argc, char* argv[]) { SymEngine::print_stack_on_segfault(); RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> w = symbol("w"); RCP<const Basic> i15 = integer(15); RCP<const Basic> e, f, r; e = pow(add(add(add(x, y), z), w), i15); f = mul(e, add(e, w)); std::cout << "Expanding: " << *f << std::endl; auto t1 = std::chrono::high_resolution_clock::now(); r = expand(f); auto t2 = std::chrono::high_resolution_clock::now(); //std::cout << *r << std::endl; std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << "ms" << std::endl; std::cout << "number of terms: " << rcp_dynamic_cast<const Add>(r)->dict_.size() << std::endl; return 0; }
double R3() { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> f = add(x, add(y, z)); std::vector<bool> vec(10); auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < 10; i++) { vec.push_back(eq(*f, *f)); } auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
int main(int argc, char *argv[]) { SymEngine::print_stack_on_segfault(); RCP<const Symbol> x = symbol("x"); std::vector<Expression> v; int N; N = 1000; for (int i = 0; i < N; ++i) { Expression coef(i); v.push_back(coef); } UExprDict c, p(UExprPoly::from_vec(x, v)->get_dict()); auto t1 = std::chrono::high_resolution_clock::now(); c = UnivariateSeries::mul(p, p, 1000); auto t2 = std::chrono::high_resolution_clock::now(); // std::cout << *a << std::endl; std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1) .count() << "ms" << std::endl; return 0; }
double R8() { RCP<const Basic> x = symbol("x"); auto t1 = std::chrono::high_resolution_clock::now(); x = right(pow(x, integer(2)), integer(0), integer(5), x, 10000); auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
double R2() { RCP<const Basic> g; RCP<const Integer> n = integer(15); RCP<const Basic> y = symbol("y"); auto t1 = std::chrono::high_resolution_clock::now(); g = hermite(n, y); auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
double R5() { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> f = add(x, add(y, z)); vec_basic v; v.push_back(x); v.push_back(y); v.push_back(z); for (int i = 0; i < 8; i++) { v.push_back(add(v[i], add(v[i + 1], v[i + 2]))); } auto t1 = std::chrono::high_resolution_clock::now(); std::set<RCP<const Basic>, RCPBasicKeyLess> s(v.begin(), v.end()); auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
int main(int argc, char* argv[]) { Teuchos::print_stack_on_segfault(); int N; if (argc == 2) { N = std::atoi(argv[1]); } else { N = 100; } auto t1 = std::chrono::high_resolution_clock::now(); RCP<const Basic> e, f, s, a0, a1; a0 = symbol("a0"); a1 = symbol("a1"); e = add(a0, a1); f = zero; for (int i = 2; i < N; i++) { s = symbol("a" + std::to_string(i)); e = add(e, s); f = sub(f, s); } e = expand(mul(e, e)); map_basic_basic dict; insert(dict, a0, f); e = e->subs(dict); e = expand(e); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << "ms" << std::endl; std::cout << e->__str__() << std::endl; return 0; }
int main(int argc, char *argv[]) { SymEngine::print_stack_on_segfault(); int N; if (argc == 2) { N = std::atoi(argv[1]); } else { N = 100; } RCP<const Basic> e, f, s, a0, a1; a0 = symbol("a0"); a1 = symbol("a1"); e = add(a0, a1); f = zero; for (long long i = 2; i < N; i++) { std::ostringstream o; o << "a" << i; s = symbol(o.str()); e = add(e, s); f = add(f, s); } f = neg(f); auto t1 = std::chrono::high_resolution_clock::now(); e = expand(pow(e, integer(2))); e = e->subs({{a0, f}}); e = expand(e); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1) .count() << "ms" << std::endl; std::cout << e->__str__() << std::endl; return 0; }
int main(int argc, char* argv[]) { Teuchos::print_stack_on_segfault(); RCP<const Basic> x = symbol("x"); RCP<const Basic> a, c; int N; N = 3000; a = x; c = integer(1); auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < N; i++) { a = add(a, mul(c, pow(x, integer(i)))); c = mul(c, integer(-1)); } auto t2 = std::chrono::high_resolution_clock::now(); //std::cout << *a << std::endl; std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << "ms" << std::endl; std::cout << "number of terms: " << rcp_dynamic_cast<const Add>(a)->dict_.size() << std::endl; return 0; }
using SymEngine::zero; using SymEngine::sin; using SymEngine::erf; using SymEngine::RCP; using SymEngine::rcp_dynamic_cast; using SymEngine::map_basic_basic; using SymEngine::print_stack_on_segfault; using SymEngine::real_double; using SymEngine::kronecker_delta; using SymEngine::levi_civita; using SymEngine::msubs; using SymEngine::function_symbol; TEST_CASE("Symbol: subs", "[subs]") { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> w = symbol("w"); RCP<const Basic> i2 = integer(2); RCP<const Basic> i3 = integer(3); RCP<const Basic> i4 = integer(4); RCP<const Basic> r1 = x; RCP<const Basic> r2 = y; map_basic_basic d; d[x] = y; REQUIRE(eq(*r1->subs(d), *r2)); REQUIRE(neq(*r1->subs(d), *r1)); }
int main(int argc, char* argv[]) { print_stack_on_segfault(); RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> w = symbol("w"); RCP<const Basic> i15 = integer(15); RCP<const Basic> e, f1, f2, r; e = pow(add(add(add(x, y), z), w), i15); f1 = expand(e); f2 = expand(add(e, w)); umap_basic_num syms; insert(syms, x, integer(0)); insert(syms, y, integer(1)); insert(syms, z, integer(2)); insert(syms, w, integer(3)); umap_vec_mpz P1, P2, C; expr2poly(f1, syms, P1); expr2poly(f2, syms, P2); std::cout << "poly_mul start" << std::endl; auto t1 = std::chrono::high_resolution_clock::now(); poly_mul(P1, P2, C); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << "poly_mul stop" << std::endl; /* std::cout << *e << std::endl; std::cout << *f1 << std::endl; std::cout << P1 << std::endl; std::cout << *f2 << std::endl; std::cout << P2 << std::endl; std::cout << "RESULT:" << std::endl; std::cout << C << std::endl; */ std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << "ms" << std::endl; std::cout << "number of terms: " << C.size() << std::endl; return 0; }
double S2() { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> e; RCP<const Basic> f; e = pow(add(pow(x, sin(x)), add(pow(y, cos(y)), pow(z, add(x, y)))), integer(100)); auto t1 = std::chrono::high_resolution_clock::now(); f = expand(e); auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
double E() { RCP<const Basic> s = integer(0); RCP<const Basic> y = symbol("y"); RCP<const Basic> t = symbol("t"); auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 1; i <= 10; i++) { s = add(s, div(mul(integer(i), mul(y, pow(t, integer(i)))), pow(add(y, mul(integer(abs(5 - i)), t)), integer(i)))); } auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
double S3a() { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> e; RCP<const Basic> f; e = pow(add(pow(x, y), add(pow(y, z), pow(z, x))), integer(500)); e = expand(e); auto t1 = std::chrono::high_resolution_clock::now(); f = e->diff(rcp_static_cast<const Symbol>(x)); auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
double S1() { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> e; RCP<const Basic> f; e = pow(add(x, add(y, add(z, one))), integer(7)); f = mul(e, add(e, one)); auto t1 = std::chrono::high_resolution_clock::now(); f = expand(f); auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
void test_expand() { RCP<const Basic> x = symbol("x"); RCP<const Basic> y = symbol("y"); RCP<const Basic> z = symbol("z"); RCP<const Basic> w = symbol("w"); RCP<const Basic> i4 = integer(2); RCP<const Basic> e, f1, f2, r; e = pow(add(add(add(x, y), z), w), i4); f1 = expand(e); f2 = expand(add(e, w)); umap_basic_num syms; insert(syms, x, integer(0)); insert(syms, y, integer(1)); insert(syms, z, integer(2)); insert(syms, w, integer(3)); umap_vec_mpz P1, P2, C; expr2poly(f1, syms, P1); expr2poly(f2, syms, P2); std::cout << "poly_mul start" << std::endl; auto t1 = std::chrono::high_resolution_clock::now(); poly_mul(P1, P2, C); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << "poly_mul stop" << std::endl; /* std::cout << *e << std::endl; std::cout << *f1 << std::endl; std::cout << P1 << std::endl; std::cout << *f2 << std::endl; std::cout << P2 << std::endl; std::cout << "RESULT:" << std::endl; std::cout << C << std::endl; */ std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << "ms" << std::endl; }
double R7() { RCP<const Basic> x = symbol("x"); RCP<const Basic> f = add(pow(x, integer(24)), add(mul(integer(34), pow(x, integer(12))), add(mul(integer(45), pow(x, integer(3))), add(mul(integer(9), pow(x, integer(18))), add(mul(integer(34), pow(x, integer(10))), mul(integer(32), pow(x, integer(21)))))))); vec_basic v; auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < 10000; ++i) { v.push_back(f->subs({{x, real_double(0.5)}})); } auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
using SymEngine::umap_short_basic; using SymEngine::EulerGamma; using SymEngine::Number; using SymEngine::umap_int_basic; using SymEngine::pi; using SymEngine::I; using SymEngine::DomainError; using SymEngine::NotImplementedError; using SymEngine::SymEngineException; using SymEngine::gamma; using namespace SymEngine::literals; TEST_CASE("Create UnivariateSeries", "[UnivariateSeries]") { RCP<const Symbol> x = symbol("x"); map_int_Expr adict_ = {{0, 1}, {1, 2}, {2, 1}}; UExprDict apoly_(adict_); RCP<const UnivariateSeries> P = univariate_series(x, 2, apoly_); REQUIRE(P->__str__() == "x**2 + 2*x + 1 + O(x**2)"); map_int_Expr bdict_ = {{0, 1}, {1, 0}, {2, 2}, {3, 1}}; UExprDict bpoly_(bdict_); RCP<const UnivariateSeries> Q = UnivariateSeries::create(x, 5, bpoly_); REQUIRE(Q->__str__() == "x**3 + 2*x**2 + 1 + O(x**5)"); map_int_Expr cdict_ = {{0, symbol("c")}, {1, symbol("b")}, {2, symbol("a")}}; UExprDict cpoly_(cdict_); RCP<const UnivariateSeries> R = UnivariateSeries::create(x, 3, cpoly_); REQUIRE(R->__str__() == "a*x**2 + b*x + c + O(x**3)");
using SymEngine::MIntPoly; using SymEngine::MExprPoly; using namespace SymEngine::literals; TEST_CASE("find_gen_poly", "[b2poly]") { umap_basic_num gens, rgens; RCP<const Basic> basic; RCP<const Integer> one = integer(1); RCP<const Integer> minus_one = integer(-1); RCP<const Number> i2 = rcp_static_cast<const Number>(integer(2)); RCP<const Number> i3 = rcp_static_cast<const Number>(integer(3)); RCP<const Number> i6 = rcp_static_cast<const Number>(integer(6)); RCP<const Number> hf = rcp_static_cast<const Number>(div(one, integer(2))); RCP<const Symbol> x = symbol("x"); RCP<const Symbol> y = symbol("y"); RCP<const Symbol> z = symbol("z"); RCP<const Basic> xb2 = div(x, i2); RCP<const Basic> twopx = pow(i2, x); // x**2 + x**(1/2) -> (x**(1/2)) basic = add(pow(x, hf), pow(x, i2)); gens = _find_gens_poly(basic); rgens = {{x, hf}}; REQUIRE(unified_eq(gens, rgens)); // x**(-1/2) + x**2 + x**(-1) -> (x, x**(-1/2)) basic = add(add(pow(x, neg(hf)), pow(x, i2)), pow(x, minus_one)); gens = _find_gens_poly(basic); rgens = {{x, one}, {pow(x, minus_one), hf}};
int main(int argc, char* argv[]) { SymEngine::print_stack_on_segfault(); DenseMatrix A = DenseMatrix(3, 3, {symbol("a"), symbol("b"), symbol("c"), symbol("d"), symbol("e"), symbol("f"), symbol("g"), symbol("h"), symbol("i")}); DenseMatrix B = DenseMatrix(3, 3, {symbol("x"), symbol("y"), symbol("z"), symbol("p"), symbol("q"), symbol("r"), symbol("u"), symbol("v"), symbol("w")}); DenseMatrix C(3, 3); std::cout << "Multiplying Two Matrices; matrix dimensions: 3 x 3" << std::endl; unsigned N = 10000; auto t1 = std::chrono::high_resolution_clock::now(); for (unsigned i = 0; i < N; i++) mul_dense_dense(A, B, C); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << std::chrono::duration_cast<std::chrono::microseconds>(t2-t1).count()/N << " microseconds" << std::endl; return 0; }
int main(int argc, char* argv[]) { SymEngine::print_stack_on_segfault(); DenseMatrix A = DenseMatrix(3, 3, {symbol("a"), symbol("b"), symbol("c"), symbol("d"), symbol("e"), symbol("f"), symbol("g"), symbol("h"), symbol("i")}); DenseMatrix B = DenseMatrix(3, 3, {symbol("x"), symbol("y"), symbol("z"), symbol("p"), symbol("q"), symbol("r"), symbol("u"), symbol("v"), symbol("w")}); DenseMatrix C(3, 3); std::cout << "Adding Two Matrices; matrix dimensions: 3 x 3" << std::endl; // We are taking an average time since time for a single addition varied in // a range of 40-50 microseconds unsigned N = 10000; auto t1 = std::chrono::high_resolution_clock::now(); for (unsigned i = 0; i < N; i++) add_dense_dense(A, B, C); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << std::chrono::duration_cast<std::chrono::microseconds>(t2-t1).count()/N << " microseconds" << std::endl; return 0; }
using SymEngine::Precedence; using SymEngine::PrecedenceEnum; using SymEngine::vec_uint; using SymEngine::vec_int; using SymEngine::vec_basic; using SymEngine::vec_uint; using SymEngine::RCPBasicKeyLess; using SymEngine::MExprPoly; using SymEngine::UExprPoly; using SymEngine::SymEngineException; using namespace SymEngine::literals; TEST_CASE("Constructing MExprPoly", "[MExprPoly]") { RCP<const Symbol> x = symbol("x"); RCP<const Symbol> y = symbol("y"); Expression a(symbol("a")); // a Expression negB(-Expression(symbol("b"))); //-b Expression num1(integer(2)); // 2 Expression negNum(integer(-3)); //-3 Expression comp1(integer(1) + Expression(symbol("c"))); //(1+c) Expression comp2(integer(2) - Expression(symbol("d"))); //(2 - d) Expression comp3(integer(-3) + Expression(symbol("e"))); //(-3 + e) Expression comp4(integer(-4) - Expression(symbol("f"))); //(-4 - f) vec_basic s; vec_int v; RCP<const MExprPoly> p1 = MExprPoly::from_dict( {x, y}, {{{1, 1}, a}, {{1, 2}, negB}, {{2, 1}, num1}, {{0, 1}, negNum}});
using SymEngine::map_uint_mpz; using SymEngine::Basic; using SymEngine::one; using SymEngine::zero; using SymEngine::integer; using SymEngine::vec_basic_eq_perm; using SymEngine::integer_class; using SymEngine::UIntDict; using SymEngine::add; using SymEngine::vec_integer_class; using namespace SymEngine::literals; TEST_CASE("Constructor of UIntPoly", "[UIntPoly]") { RCP<const Symbol> x = symbol("x"); RCP<const UIntPoly> P = UIntPoly::from_dict(x, {{0, 1_z}, {1, 2_z}, {2, 1_z}}); REQUIRE(P->__str__() == "x**2 + 2*x + 1"); RCP<const UIntPoly> Q = UIntPoly::from_vec(x, {1_z, 0_z, 2_z, 1_z}); REQUIRE(Q->__str__() == "x**3 + 2*x**2 + 1"); RCP<const UIntPoly> R = UIntPoly::from_vec(x, {1_z, 0_z, 2_z, 1_z}); REQUIRE(R->__str__() == "x**3 + 2*x**2 + 1"); RCP<const UIntPoly> S = UIntPoly::from_dict(x, {{0, 2_z}}); REQUIRE(S->__str__() == "2"); RCP<const UIntPoly> T = UIntPoly::from_dict(x, map_uint_mpz{}); REQUIRE(T->__str__() == "0");
#include "catch.hpp" #include <iostream> #include <chrono> #include <symengine/expression.h> using SymEngine::Expression; using SymEngine::symbol; TEST_CASE("Constructors of Expression", "[Expression]") { Expression e0 = symbol("x"); } TEST_CASE("Printing of Expression", "[Expression]") { Expression e0 = symbol("x"); std::cout << e0 << std::endl; } TEST_CASE("Arithmetic of Expression", "[Expression]") { Expression x = symbol("x"), y = symbol("y"); auto z = x + y; std::cout << z << std::endl; z += y; std::cout << z << std::endl; REQUIRE(z == x + y + y); REQUIRE(z == x + 2 * y); std::cout << pow_ex(z, z) << std::endl; std::cout << pow_ex(z, 45) << std::endl;
#include <chrono> #include <symengine/expression.h> using SymEngine::Expression; using SymEngine::symbol; using SymEngine::eq; using SymEngine::integer; using SymEngine::real_double; using SymEngine::complex_double; using SymEngine::sin; 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]") {
using SymEngine::add; using SymEngine::Symbol; using SymEngine::Integer; using SymEngine::DenseMatrix; using SymEngine::Subs; using SymEngine::Derivative; using SymEngine::function_symbol; using SymEngine::I; using SymEngine::real_double; using SymEngine::complex_double; TEST_CASE("test_printing(): printing", "[printing]") { RCP<const Basic> r, r1, r2; RCP<const Integer> i = integer(-1); RCP<const Symbol> x = symbol("x"); RCP<const Symbol> y = symbol("y"); RCP<const Symbol> z = symbol("z"); r = div(integer(12), pow(integer(196), div(integer(1), integer(2)))); REQUIRE(r->__str__() == "(3/49)*196**(1/2)"); r = mul(integer(12), pow(integer(196), div(integer(1), integer(2)))); REQUIRE(r->__str__() == "12*196**(1/2)"); r = mul(integer(23), mul(pow(integer(5), div(integer(1), integer(2))), pow(integer(7), div(integer(1), integer(2))))); REQUIRE(r->__str__() == "23*5**(1/2)*7**(1/2)"); r = mul(integer(2), pow(symbol("x"), integer(2))); REQUIRE(r->__str__() == "2*x**2");
using SymEngine::pow; using SymEngine::RCP; using SymEngine::make_rcp; using SymEngine::print_stack_on_segfault; using SymEngine::Complex; using SymEngine::has_symbol; using SymEngine::is_a; using SymEngine::rcp_static_cast; using SymEngine::set_basic; using SymEngine::free_symbols; using SymEngine::function_symbol; using SymEngine::rational_class; TEST_CASE("Symbol hash: Basic", "[basic]") { RCP<const Symbol> x = symbol("x"); RCP<const Symbol> x2 = symbol("x"); RCP<const Symbol> y = symbol("y"); REQUIRE(x->__eq__(*x)); REQUIRE(x->__eq__(*x2)); REQUIRE(not (x->__eq__(*y))); REQUIRE(x->__neq__(*y)); std::hash<Basic> hash_fn; // Hashes of x and x2 must be the same: REQUIRE(hash_fn(*x) == hash_fn(*x2)); // Hashes of x and y can but don't have to be different: if (hash_fn(*x) != hash_fn(*y)) REQUIRE(x->__neq__(*y));
#include <symengine/pow.h> #include <symengine/series.h> using SymEngine::Basic; using SymEngine::Integer; using SymEngine::integer; using SymEngine::rational; using SymEngine::Symbol; using SymEngine::Number; using SymEngine::symbol; using SymEngine::Add; using SymEngine::rcp_static_cast; using SymEngine::RCP; using SymEngine::add; using SymEngine::sin; using SymEngine::cos; using SymEngine::series; TEST_CASE("Expression series expansion interface", "[Expansion interface]") { RCP<const Symbol> x = symbol("x"), y = symbol("y"); auto ex = div(integer(1), add(integer(1), x)); auto ser = series(ex, x, 10); REQUIRE(rcp_static_cast<const Number>(ser->get_coeff(7))->is_minus_one()); REQUIRE(rcp_static_cast<const Number>(ser->as_dict()[8])->is_one()); REQUIRE(ser->as_basic()->__str__() == "1 - x + x**2 - x**3 + x**4 - x**5 + x**6 - x**7 + x**8 - x**9"); }