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)));
}
