Computer Algebra Independent Integration Tests

\begin{axiom}
setSimplifyDenomsFlag(true)
integrate(sin(x),x)
\end{axiom}

1. How to measure CPU time used from the int call?
(3) -> )set messages time on
(3) -> integrate(x^(3/2)/sqrt(1 + x^5), x)

Type: Union(Expression(Integer),...)
Time: 0.06 (EV) + 0.00 (OT) = 0.06 sec

That is command ’)set messages time on’ tell FriCAS to print
time needed to execute following command. The (EV) part means
actual computation (OT) printing and at the end there is total

2. How to measure leaf count/size of result? (Maple and Mathematica have
build in function to do this)

That is a bit tricky. FriCAS (like Axiom) has quite different
representation of expressions tham Maple or Mathematica.
In FriCAS expression is a quotient of two polnomials, with
variables beeing kernels:

(13) -> f := exp(x^3 + 1/x) + 1
(14) -> numer(f)

4
x + 1
------
x

(15) -> denom(f)

(16) -> variables(numer(f))

4
x + 1
------
x
(16) [%e ]
Type: List(Kernel(Expression(Integer)))
Time: 0.00 (OT) = 0.00 sec

From FriCAS point of view natural measure of size is number
of monomials in numerator and denominator:

(17) -> numberOfMonomials(numer(f))

(17) 2
(18) -> numberOfMonomials(denom(f))
(18) 1

but this may underestimate size because kernels may be big.
Also internally given kernel is stored only once, but in
printed output it may appear several times.

It is possible to traverse expression is somewhat tree like
manner, so it is possible to give better approximation
to say Maple result, but that would require investigating
what Maple is doing. I personally never used Maple node
count so I do not know it this is simple or if there are
some traps.

3. How to check if int passed or failed? Aborted? nil result? etc..

integrate may produce an error (in particular it will do so
if it can not decide if integral is elementary). Or may
produce unevaluated integral. Or normal result. At programistic
level it is possible to catch errors, but a bit tricky,
If you look at printed output, than errors are reasonably
easy to match via a regex:

(22) -> integrate(1/sqrt(exp(x) - x + 1), x)
integrate: implementation incomplete (constant residues)

the ’>> Error’ part indicates error. Unevaluated integrals
always have integral sign at top level. FriCAS never returns
partial results, so text match is relatively easy. Or you
may use code like:

test_int(f) ==
res : Union(Expression Integer, LE)
res := integrate(f, ’x)
res0 : List Expression Integer :=
res case Expression Integer =>
[res::(Expression Integer)]@(List Expression Integer)
res case List Expression Integer =>
res::(List Expression Integer)
error "test_int: impossible 1"
for ri in res0 repeat
#(kernels ri) > 0 and is?(operator first kernels ri, ’integral) =>
print("Unevaluated integral"::OutputForm)

Note1: this is part extracted from bigger test script, I did not
test it alone.

Note2: FriCAS may either return list of results or a single result.
Middle part converts this to have always a list (typically of
length 1). The last part is a loop so that all solutions can
be examined. It you only want to know if result is evaluated, than
loop is not needed: more than one result means that integral
is evaluated.

Note3: In FriCAS testsuite I use a bit different test for
evaluated integrals. Namely, FriCAS can do useful computations
on unevaluated integrals and in particular unevaluated integrals
may appear in the argument to integrate. Such unevaluated
integrals of course may propagate form input to the output.
The test above may misclasify such integral as unevaluated,
while better test checks that unevaluated integral came from
the input.

4. And most importantly, how to export the result (if it passed) to a
plain text file in _Latex_ format?

(24) -> )set output tex on
(24) -> integrate(exp(x)*exp(1/(exp(x)+1)-x), x)

Here one have to decide what to do with errors. Without error
trapping error will abort currently executing function
and propagate to top level (up to command line).

After doing:

)set break resume

after error FriCAS will continue executing file from next
command (but still abort current command). If you need
real loop then I can provide error catcher, but it is
a bit more complicated than snippets above.
Waldek Hebisch

)clear all

)clear completely

from sympy import *

or

import sympy #but now have to add sympy. to each call

import os
os.getcwd()
os.chdir(’X:\\data\\public_html\\my_notes\\CAS_integration_tests\\reports\\rubi_4_11\\code’)
os.getcwd()
import math
init_printing()
init_printing(use_unicode=False, wrap_line=False, no_global=True)
x = symbols(’x’, real=True)
r=integrate(x,x)
r0=latex(r)
text_file = open("python.txt", "w")
text_file.write("\"%s\"" % r0)
text_file.close()

r=integrate(f*g, (x, L/2, L))
type(r) is integrals.Integral

Out[41]: True

or

isinstance(r, integrals.Integral)
Out[48]: True

r=integrate(x,x)
type(r) is integrals.Integral
Out[43]: False

if isinstance(r, integrals.Integral):
result = 0
else:
result=1

os.getcwd()

To get list of folder in cwd do

os.listdir(os.getcwd())

or

ls

Out[85]:
[’1_Algebraic_functions’,
’2_Exponentials’,
’3_Logarithms’,
’4_Trig_functions’,
’5_Inverse_trig_functions’,
’6_Hyperbolic_functions’,
’7_Inverse_hyperbolic_functions’,
’8_Special_functions’,
’Independent_test_suites’]

f = open(’Hebisch_Problems.txt’,’r’)
f.readline()
f.close()

def _timeout(self, function, timeout):
         def callback(x, y):
             signal.alarm(0)
             raise Skipped("Timeout")
         signal.signal(signal.SIGALRM, callback)
         signal.alarm(timeout)  # Set an alarm with a given timeout
         function()
         signal.alarm(0)  # Disable the alarm

AppellF1 --> #hypergeometric function of two variables
Ellipticpi-->
arctanh -->atanh
arctan --> atan
arccosh->acosh
Pi --> pi.
arcsin -> asin
arccos -> acos
hypergeom -> hyper,
arccoth -> acoth
GAMMA -> uppergamma()
arccsc -> acsc
arcsec -> asec
arccot -> acot,
EllipticF -> elliptic_f
EllipticE -> elliptic_e
Li -> Li
Si -> Si
Ci -> Ci
Ei -> Ei
FresnelS -> fresnels
FresnelC -> fresnelc

cd /media/data/public_html/my_notes/CAS_integration_tests/reports/rubi_4_11
python sympy_main.py

for n in range(0,1): #change the last number to the number of tests to do

conda update conda
conda update python

pip list | grep sympy
pip install --upgrade sympy
\end{x300}

To find version, from inside python, type
\begin{x300}
import sympy
sympy.__version__

To obtain a Rational in SymPy, one of these methods must be used:

>>> from sympy import Rational
>>> Rational(2, 7)
2/7

>>> for num,val in enumerate(sol,start=1):
... print("root number {} is {}".format(num,val))

from subprocess import STDOUT, check_output
output = check_output(’dir’, shell=True, stderr=STDOUT, timeout=5)
print(output)

Computer Algebra Independent Integration Tests

1 Note on build system

2 My PC during running the tests

3 cheat sheet notes

3.1 Fricas

3.2 sympy