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 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 R1() { RCP<const Basic> g; RCP<const Basic> h = div(I, integer(2)); auto t1 = std::chrono::high_resolution_clock::now(); g = expand(f(f(f(f(f(f(f(f(f(f(h))))))))))); 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 A() { auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 1; i <= 100; i++) { div(factorial(1000 + i), factorial(900 + i)); } 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(); 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; }
double B() { RCP<const Number> s = integer(0); auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 1; i <= 1000; i++) { s = s->add(*one->div(*integer(i))); } auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
RCP<const Basic> right(const RCP<const Basic> &f, const RCP<const Number> &a, const RCP<const Number> &b, const RCP<const Basic> &x, int n) { RCP<const Number> Deltax = b->sub(*a)->div(*integer(n)); RCP<const Number> c = a; RCP<const Number> est = integer(0); for (int i = 0; i < n; i++) { iaddnum(outArg(c), Deltax); iaddnum(outArg(est), rcp_static_cast<const Number>(f->subs({{x, c}}))); } return mulnum(est, Deltax); }
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 Basic> e = sin(integer(1)); double r, r_exact; for (int i = 0; i < 10000; i++) e = pow(add(mul(add(e, pow(integer(2), integer(-3))), integer(3)), integer(1)), div(integer(2), integer(3))); // Too long: // std::cout << "Evaluating: " << *e << std::endl; auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < 500; i++) r = eval_double(*e); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1) .count() / 500. << "ms" << std::endl; /* In SymPy for few iterations: In [7]: sympify("(1 + 3*(1/8 + (1 + 3*(1/8 + (1 + 3*(1/8 + (1 + 3*(1/8 + (1 + 3*(1/8 + sin(1)))^(2/3)))^(2/3)))^(2/3)))^(2/3)))^(2/3)").n(20) Out[7]: 8.0152751504518535013 // r_exact = 8.0152751504518535013; Here is code to use SymPy for more iterations: In [5]: e = sin(1) In [6]: for i in range(10): ...: e = ((e+2**(-S(3)))*3 + 1)**(S(2)/3) ...: In [7]: e.n(20) Out[7]: 9.6473976427977306146 But unfortunately SymPy can't do more than perhaps 10 or 20 iterations, while we need to test ~10000. However, the numbers seem to converge to 9.85647... */ r_exact = 9.8564741713701043569; std::cout << "r (double) = " << r << std::endl; std::cout << "r (exact) = " << r_exact << std::endl; std::cout << "error = " << std::abs(r - r_exact) << std::endl; return 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; }
CWRAPPER_OUTPUT_TYPE function_symbol_set(basic s, const char *c, const CVecBasic *arg) { CWRAPPER_BEGIN s->m = function_symbol(c, arg->m); CWRAPPER_END }
CWRAPPER_OUTPUT_TYPE rational_get_mpq(mpq_t a, const basic s) { CWRAPPER_BEGIN SYMENGINE_ASSERT(is_a<Rational>(*(s->m))); mpq_set(a, get_mpq_t((rcp_static_cast<const Rational>(s->m)) ->as_rational_class())); CWRAPPER_END }
CWRAPPER_OUTPUT_TYPE dense_matrix_eye(CDenseMatrix *s, unsigned long int N, unsigned long int M, int k) { CWRAPPER_BEGIN dense_matrix_rows_cols(s, N, M); eye(s->m, k); CWRAPPER_END }
CWRAPPER_OUTPUT_TYPE dense_matrix_zeros(CDenseMatrix *s, unsigned long int r, unsigned long int c) { CWRAPPER_BEGIN dense_matrix_rows_cols(s, r, c); zeros(s->m); CWRAPPER_END }
CWRAPPER_OUTPUT_TYPE integer_get_mpz(mpz_t a, const basic s) { CWRAPPER_BEGIN SYMENGINE_ASSERT(is_a<Integer>(*(s->m))); mpz_set(a, get_mpz_t( (rcp_static_cast<const Integer>(s->m))->as_integer_class())); CWRAPPER_END }
CWRAPPER_OUTPUT_TYPE real_mpfr_set_d(basic s, double d, int prec) { CWRAPPER_BEGIN mpfr_class mc = mpfr_class(prec); mpfr_set_d(mc.get_mpfr_t(), d, MPFR_RNDN); s->m = SymEngine::real_mpfr(std::move(mc)); CWRAPPER_END }
int main(int argc, char* argv[]) { print_stack_on_segfault(); test_homogeneous_lde(); return 0; }
int main(int argc, char* argv[]) { print_stack_on_segfault(); test_monomial_mul(); test_expand(); return 0; }
CWRAPPER_OUTPUT_TYPE dense_matrix_diag(CDenseMatrix *s, CVecBasic *d, long int k) { CWRAPPER_BEGIN int vec_size = vecbasic_size(d); dense_matrix_rows_cols(s, vec_size + (k >= 0 ? k : -k), vec_size + (k >= 0 ? k : -k)); diag(s->m, d->m, k); CWRAPPER_END }
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[]) { 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; }
double C() { RCP<const Integer> x = integer(13*17*31); RCP<const Integer> y = integer(13*19*29); auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 1; i <= 200; i++) { gcd(*rcp_static_cast<const Integer>(pow(x, integer(300 + i%181))), *rcp_static_cast<const Integer>(pow(y, integer(200 + i%183)))); } auto t2 = std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count()/1000000000.0; }
void test_monomial_mul() { vec_int a, b, c, d; a = {1, 2, 3, 4}; b = {2, 3, 2, 5}; c = {0, 0, 0, 0}; monomial_mul(a, b, c); d = {3, 5, 5, 9}; assert(c == d); d = {5, 6, 5, 5}; assert(c != d); umap_vec_mpz m; m[a] = 4; }
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[]) { 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; }
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)); }
RCP<const Basic> hermite(RCP<const Integer> n, RCP<const Basic> y) { if (eq(*n, *one)) return mul(y, integer(2)); if (eq(*n, *zero)) return one; return expand(sub(mul(mul(integer(2), y), hermite(n->subint(*one), y)), mul(integer(2), mul(n->subint(*one), hermite(n->subint(*integer(2)), y))))); }
RCP<const Basic> f(RCP<const Basic> z) { return add(mul(sqrt(div(one, integer(3))), pow(z, integer(2))), div(I, integer(3))); }