an.tsouchlos/b2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add files

Browse Source
This commit is contained in:
Andreas Tsouchlos
2025-01-14 01:15:48 +01:00
commit 2f9fcec55b
406 changed files with 87154 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
python/test/classes/__init__.py Normal file
View File

179
python/test/classes/differentiation_test.py Normal file
View File

@@ -0,0 +1,179 @@
# This file is part of Bertini 2.
#
# python/test/differentiation_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/differentiation_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/differentiation_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2016-2018 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# James Collins
# West Texas A&M University
# Spring 2016
#
# silviana amethyst
# UWEC
# Spring 2018
#
from pybertini import *
from pybertini.function_tree.symbol import *
from pybertini.function_tree.root import *
from pybertini.function_tree import *
import numpy as np;
import unittest
import pdb
import pybertini.multiprec as mp
from pybertini.multiprec import Float as mpfr_float
from pybertini.multiprec import Complex as mpfr_complex
class DiffTest(unittest.TestCase):
def setUp(self):
default_precision(30);
self.x = Variable("x")
self.x.set_current_value(complex(-2.43,.21 ))
self.y = Variable("y")
self.y.set_current_value(complex(4.84, -1.94))
self.z = Variable('z')
self.z.set_current_value(complex(-6.48, -.731))
self.p = Variable('p')
self.p.set_current_value(complex(-.321, -.72))
self.a = Float("3.12", ".612")
self.b = Float("-.823", "2.62")
self.tol_d = float(1e-14);
#
self.x.set_current_value(mpfr_complex("-2.43",".21" ))
self.y.set_current_value(mpfr_complex("4.84", "-1.94"))
self.z.set_current_value(mpfr_complex("-6.48", "-.731"))
self.p.set_current_value(mpfr_complex("-.321", "-.72"))
self.a = Float(mpfr_complex("3.12", ".612"))
self.b = Float(mpfr_complex("-.823", "2.62"))
self.tol_mp = mpfr_float("1e-27");
def test_sum_rule(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = x+y+a;
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real/(1.0)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(x).imag-0), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real/mpfr_float("1.0")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag-mpfr_float("0")), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real/(1.0)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag-0), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real/mpfr_float("1.0")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag-mpfr_float("0")), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(z).real-0), tol_d)
self.assertLessEqual(np.abs(df.eval_d(z).imag-0), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(z).real-mpfr_float("0.0")), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(z).imag-mpfr_float("0")), tol_mp)
def test_power_rule(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = x**2 + y**3;
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real / (-4.86)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(x).imag / (0.42)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real / mpfr_float("-4.86")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag / mpfr_float("0.42")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real / (58.9860)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag / (-56.3376)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real / mpfr_float("58.9860")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag / mpfr_float("-56.3376")-1), tol_mp)
def test_prod_rule(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = x**2*y**4 - a*x*y*z**2;
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real / (-559.28968169592)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(x).imag / (3577.05276993648)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real / mpfr_float("-559.28968169592")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag / mpfr_float("3577.05276993648")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real / (1161.85042980828)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag / (-3157.24325320476)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real / mpfr_float("1161.85042980828")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag / mpfr_float("-3157.24325320476")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(z).real / (-520.5265859088)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(z).imag / (84.7479679056)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(z).real / mpfr_float("-520.5265859088")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(z).imag / mpfr_float("84.7479679056")-1), tol_mp)
def test_trancendental(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = sin(x*y) + exp(z*y) - log(x*x);
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real / (-17.648420086229721902138620795382021306411662490)-1), 9e-13)
self.assertLessEqual(np.abs(df.eval_d(x).imag / (-803.11883403426275105632833868183320319093878729)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real / mpfr_float("-17.648420086229721902138620795382021306411662490")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag / mpfr_float("-803.11883403426275105632833868183320319093878729")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real / (-100.97157179433748763552280062599971478593963953)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag / (361.98093991820979266721712882115615553425318528)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real / mpfr_float("-100.97157179433748763552280062599971478593963953")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag / mpfr_float("361.98093991820979266721712882115615553425318528")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(z).real / (-2.1642907643013779167501866500194314960002972412e-14)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(z).imag / (2.1105887207247540399884720817624768568595288922e-14)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(z).real / mpfr_float("-2.1642907643013779167501866500194314960002972412e-14")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(z).imag / mpfr_float("2.1105887207247540399884720817624768568595288922e-14")-1), tol_mp)
if __name__ == '__main__':
unittest.main();

107
python/test/classes/eigenpy_numpy.py Normal file
View File

@@ -0,0 +1,107 @@
# This file is part of Bertini 2.
#
# python/test/mpfr_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/mpfr_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/mpfr_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2024-2025 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# silviana amethyst
# Max Planck Institute of Molecular Cell Biology and Genetics
# Fall 2024, Spring 2025
# the purpose of this test suite is to make ensure numpy functionality with the custom types defined by Bertini (via EigenPy).
import numpy as np
import pybertini as pb
from pybertini import multiprec as mp
import unittest
import pdb
class TestFloat(unittest.TestCase):
def setUp(self):
mp.default_precision(30);
self.shape = (5,10)
def test_make_array_empty(self):
A = np.empty(self.shape, dtype = mp.Float)
A[0,0] = mp.Float(0)
def test_make_array_zeros(self):
A = np.zeros(self.shape, dtype = mp.Float)
A[0,0] = mp.Float(1)
def test_make_array_zeros_with_conversion(self):
A = np.array( np.zeros(self.shape), dtype = mp.Float)
def test_make_array_zeros_with_conversion_and_astype_int64(self):
A = np.array( np.zeros(self.shape).astype(np.int64), dtype = mp.Float)
def test_make_array_ones(self):
A = np.ones(self.shape, dtype = mp.Float)
A[0,0] = mp.Float(2)
def test_make_array_ones_with_conversion(self):
A = np.array( np.ones(self.shape), dtype = mp.Float)
def test_make_array_ones_with_conversion_and_astype_int64(self):
A = np.array( np.ones(self.shape).astype(np.int64), dtype = mp.Float)
class TestComplex(unittest.TestCase):
def setUp(self):
mp.default_precision(30);
self.shape = (5,10)
def test_make_array_empty(self):
A = np.empty(self.shape, dtype = mp.Complex)
A[0,0] = mp.Complex(0)
def test_make_array_zeros(self):
A = np.zeros(self.shape, dtype = mp.Complex)
A[0,0] = mp.Complex(1)
def test_make_array_zeros_with_conversion(self):
A = np.array( np.zeros(self.shape), dtype = mp.Complex)
def test_make_array_zeros_with_conversion_and_astype_int64(self):
A = np.array( np.zeros(self.shape).astype(np.int64), dtype = mp.Complex)
def test_make_array_ones(self):
A = np.ones(self.shape, dtype = mp.Complex)
A[0,0] = mp.Complex(2)
def test_make_array_ones_with_conversion(self):
A = np.array( np.ones(self.shape), dtype = mp.Complex)
def test_make_array_ones_with_conversion_and_astype_int64(self):
A = np.array( np.ones(self.shape).astype(np.int64), dtype = mp.Complex)
if __name__ == '__main__':
unittest.main();

481
python/test/classes/function_tree_test.py Normal file
View File

@@ -0,0 +1,481 @@
# This file is part of Bertini 2.
#
# python/test/function_tree_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/function_tree_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/function_tree_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2016-2018 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# James Collins
# West Texas A&M University
# Spring 2016
#
# silviana amethyst
# UWEC
# Spring 2018
#
from pybertini import *
from pybertini.function_tree.symbol import *
from pybertini.function_tree.root import *
from pybertini.function_tree import *
import numpy as np;
import unittest
import pybertini.multiprec as mp
from pybertini.multiprec import Float as mpfr_float
from pybertini.multiprec import Complex as mpfr_complex
class SymbolTest(unittest.TestCase):
def setUp(self):
default_precision(30);
self.x_d = complex(-2.43,.21 );
self.y_d = complex(4.84, -1.94);
self.z_d = complex(-6.48, -.731);
self.p_d = complex(-.321, -.72);
self.tol_d = float(1e-15);
#
self.x_mp = mpfr_complex("-2.43",".21" );
self.y_mp = mpfr_complex("4.84", "-1.94");
self.z_mp = mpfr_complex("-6.48", "-.731");
self.p_mp = mpfr_complex("-.321", "-.72");
self.tol_mp = mpfr_float("1e-27");
def test_Float_construct(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Float("4.3", "-9e-3");
x = Float(y_mp);
x = Float(mpfr_float("9.3"), mpfr_float("-3"));
x = Float("9.2", "-43.2e2");
def test_Float_eval(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Float(x_mp); y = Float(y_mp); z = Float(z_mp);
#
self.assertLessEqual(np.abs(x.eval_d().real/(-2.43)-1), tol_d);
self.assertLessEqual(np.abs(x.eval_d().imag/(.21)-1), tol_d);
#
self.assertLessEqual(mp.abs(y.eval_mp().real/mpfr_float("4.84")-1), tol_mp);
self.assertLessEqual(mp.abs(y.eval_mp().imag/mpfr_float("-1.94")-1), tol_mp);
def test_Float_funcs(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Float(x_mp); y = Float(y_mp); z = Float(z_mp);
#
self.assertEqual(x.degree(), 0)
d = y.differentiate();
self.assertLessEqual(mp.abs(d.eval_mp().real-mpfr_float("0")), tol_mp)
self.assertLessEqual(mp.abs(d.eval_mp().imag-mpfr_float("0")), tol_mp)
self.assertTrue(y.is_homogeneous());
self.assertTrue(y.is_polynomial());
def test_Variable_construct(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Variable("x");
def test_Variable_eval(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Variable("x"); y = Variable("y");
x.set_current_value(x_d); x.set_current_value(x_mp)
#
self.assertLessEqual(np.abs(x.eval_d().real/(-2.43)-1), tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag/(.21)-1), tol_d)
#
self.assertLessEqual(mp.abs(x.eval_mp().real/mpfr_float("-2.43")-1), tol_mp)
self.assertLessEqual(mp.abs(x.eval_mp().imag/mpfr_float(".21")-1), tol_mp)
def test_Variable_funcs(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Variable("x"); y = Variable("y")
#
self.assertEqual(x.degree(), 1)
self.assertEqual(x.degree(x), 1)
self.assertEqual(x.degree(y), 0)
d = y.differentiate()
self.assertTrue(y.is_homogeneous())
self.assertTrue(y.is_polynomial())
def test_Pi_construct(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = Pi()
y = make_pi()
#
self.assertLessEqual(np.abs(x.eval_d().real/(3.1415926535897932384626433832795028841971693994)-1), tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(mp.abs(x.eval_mp().real/mpfr_float("3.1415926535897932384626433832795028841971693994")-1), tol_mp)
self.assertLessEqual(mp.abs(x.eval_mp().imag - mpfr_float("0")), tol_mp)
#
self.assertLessEqual(np.abs(y.eval_d().real/(3.1415926535897932384626433832795028841971693994)-1), tol_d)
self.assertLessEqual(np.abs(y.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(mp.abs(y.eval_mp().real/mpfr_float("3.1415926535897932384626433832795028841971693994")-1), tol_mp)
self.assertLessEqual(mp.abs(y.eval_mp().imag - mpfr_float("0")), tol_mp)
def test_E_construct(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
x = E()
y = make_e()
#
self.assertLessEqual(np.abs(x.eval_d().real/(2.7182818284590452353602874713526624977572470937)-1), tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(mp.abs(x.eval_mp().real - mpfr_float("2.7182818284590452353602874713526624977572470937")), tol_mp)
self.assertLessEqual(mp.abs(x.eval_mp().imag - mpfr_float("0")), tol_mp)
#
self.assertLessEqual(np.abs(y.eval_d().real/(2.7182818284590452353602874713526624977572470937)-1), tol_d)
self.assertLessEqual(np.abs(y.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(mp.abs(y.eval_mp().real/mpfr_float("2.7182818284590452353602874713526624977572470937")-1), tol_mp)
self.assertLessEqual(mp.abs(y.eval_mp().imag - mpfr_float("0")), tol_mp)
def test_I_construct(self):
x_d = self.x_d; y_d = self.y_d; z_d = self.z_d; p_d = self.p_d; tol_d = self.tol_d;
x_mp = self.x_mp; y_mp = self.y_mp; z_mp = self.z_mp; p_mp = self.p_mp; tol_mp = self.tol_mp;
y = make_i()
#
self.assertLessEqual(np.abs(y.eval_d().real - (0)), tol_d)
self.assertLessEqual(np.abs(y.eval_d().imag/(1.0)-1), tol_d)
#
self.assertLessEqual(mp.abs(y.eval_mp().real - mpfr_float("0")), tol_mp)
self.assertLessEqual(mp.abs(y.eval_mp().imag/mpfr_float("1.0")-1), tol_mp)
class OperatorTest(unittest.TestCase):
def setUp(self):
default_precision(30);
self.x = Variable("x")
self.x.set_current_value(complex(-2.43,.21 ))
self.y = Variable("y")
self.y.set_current_value(complex(4.84, -1.94))
self.z = Variable("z")
self.z.set_current_value(complex(-6.48, -.731))
self.p = Variable("p")
self.p.set_current_value(complex(-.321, -.72))
self.a = Float(mpfr_complex("3.12", ".612"))
self.b = Float(mpfr_complex("-.823", "2.62"))
self.tol_d = float(9e-14);
#
self.x.set_current_value(mpfr_complex("-2.43",".21" ))
self.y.set_current_value(mpfr_complex("4.84", "-1.94"))
self.z.set_current_value(mpfr_complex("-6.48", "-.731"))
self.p.set_current_value(mpfr_complex("-.321", "-.72"))
self.a = Float(mpfr_complex("3.12", ".612"))
self.b = Float(mpfr_complex("-.823", "2.62"))
self.tol_mp = mpfr_float("1e-27");
def test_plus(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(x+y+a)
self.assertLessEqual(np.abs(f.eval_d().real/(5.53)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(-1.118)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real/mpfr_float("5.53")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag/mpfr_float("-1.118")-1), tol_mp)
#
f = Function(x+Float("3.87"))
self.assertLessEqual(np.abs(f.eval_d().real/(1.44)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(0.21)-1), tol_d)
#
f = Function(x+mpfr_complex("3.87", "-2.1"))
self.assertLessEqual(np.abs(f.eval_d().real/(1.44)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(-1.89)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real/mpfr_float("1.44")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag/mpfr_float("-1.89")-1), tol_mp)
#
f = Function(x+(-5))
self.assertLessEqual(np.abs(f.eval_d().real/(-7.43)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(0.21)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real/mpfr_float("-7.43")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag/mpfr_float("0.21")-1), tol_mp)
#
f = Function(x); f += y; f += a;
self.assertLessEqual(np.abs(f.eval_d().real/(5.53)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(-1.118)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real/mpfr_float("5.53")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag/mpfr_float("-1.118")-1), tol_mp)
#
f = Function(x); f += Float("3.87");
self.assertLessEqual(np.abs(f.eval_d().real/(1.44)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(0.21)-1), tol_d)
def test_sub(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(x-y-a)
self.assertLessEqual(np.abs(f.eval_d().real/(-10.39)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(1.538)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real/mpfr_float("-10.39")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag/mpfr_float("1.538")-1), tol_mp)
#
f = Function(y-Float("3.87"))
self.assertLessEqual(np.abs(f.eval_d().real/(0.97)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(-1.94)-1), tol_d)
#
f = Function(y-Float("3.87","0"))
self.assertLessEqual(np.abs(f.eval_d().real / (0.97)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94)-1), tol_d)
#
#
f = Function(y-mpfr_complex("3.87", "-2.1"))
self.assertLessEqual(np.abs(f.eval_d().real / (0.97)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (0.16)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("0.97")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("0.16")-1), tol_mp)
#
f = Function(y-(-5))
self.assertLessEqual(np.abs(f.eval_d().real / (9.84)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94)-1), tol_d)
#
f = Function(x); f -= y; f -= a;
self.assertLessEqual(np.abs(f.eval_d().real / (-10.39)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (1.538)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-10.39")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("1.538")-1), tol_mp)
#
f = Function(y); f -= Float("3.87");
self.assertLessEqual(np.abs(f.eval_d().real / (0.97)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94)-1), tol_d)
def test_num_times_var(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(a*x*b*y)
#
self.assertLessEqual(np.abs(f.eval_d().real / (3.4011196056)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-110.9953448712)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("3.4011196056")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-110.9953448712")-1), tol_mp)
def test_var_times_var(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(x*y*z)
self.assertLessEqual(np.abs(f.eval_d().real / (77.7616926)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-28.8346602)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("77.7616926")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-28.8346602")-1), tol_mp)
def test_var_div_var(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(x/y)
self.assertLessEqual(np.abs(f.eval_d().real / (-.44755270475041560619657805305047592426404601827)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-.13600253041648890000441351713180233327939034617)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-.44755270475041560619657805305047592426404601827")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-.13600253041648890000441351713180233327939034617")-1), tol_mp)
def test_trans_funcs(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(sin(x))
self.assertLessEqual(np.abs(f.eval_d().real/(-.66749329633668695550441899166308616328986315948)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag/(-.16020928942503633132090203927960650380076680938)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-.66749329633668695550441899166308616328986315948")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-.16020928942503633132090203927960650380076680938")-1), tol_mp)
#
f = Function(cos(y))
self.assertLessEqual(np.abs(f.eval_d().real / (0.45194679593300564730917329070452033759984813611)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-3.3798161097977088705360399142708324234265626016)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("0.45194679593300564730917329070452033759984813611")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-3.3798161097977088705360399142708324234265626016")-1), tol_mp)
#
f = Function(tan(z))
self.assertLessEqual(np.abs(f.eval_d().real / (-.11998086808607765336591715593714295443402911227)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-.63859741450762243500349270264429166927927928889)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-.11998086808607765336591715593714295443402911227")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-.63859741450762243500349270264429166927927928889")-1), tol_mp)
#
f = Function(asin(x))
self.assertLessEqual(np.abs(f.eval_d().real / (-1.4763431474004472804452143435221887167393328861)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (1.5406263884278099750127157814537559611048741005)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-1.4763431474004472804452143435221887167393328861")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("1.5406263884278099750127157814537559611048741005")-1), tol_mp)
#
f = Function(acos(y))
self.assertLessEqual(np.abs(f.eval_d().real / (0.38769800860408664087229892623614567735197135529)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (2.3379037587834289977359318611458042347281923566)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("0.38769800860408664087229892623614567735197135529")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("2.3379037587834289977359318611458042347281923566")-1), tol_mp)
#
f = Function(atan(z))
self.assertLessEqual(np.abs(f.eval_d().real / (-1.4195347801361539102032503530226060969949192059)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-0.16801358511827150554928904776095870747673962940e-1)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-1.4195347801361539102032503530226060969949192059")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-0.16801358511827150554928904776095870747673962940e-1")-1), tol_mp)
#
f = Function(exp(y))
self.assertLessEqual(np.abs(f.eval_d().real / (-45.639359208255772966298371983389382308765171859)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-117.94721623715960520658000231550940351946595854)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-45.639359208255772966298371983389382308765171859")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-117.94721623715960520658000231550940351946595854")-1), tol_mp)
#
f = Function(log(z))
self.assertLessEqual(np.abs(f.eval_d().real / (1.8750432590213669716781046977781508038070552297)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-3.0292589170775161726973168096174940982043177322)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("1.8750432590213669716781046977781508038070552297")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-3.0292589170775161726973168096174940982043177322")-1), tol_mp)
def test_power(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(y**3);
self.assertLessEqual(np.abs(f.eval_d().real / (58.732432)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-129.035608)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("58.732432")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-129.035608")-1), tol_mp)
#
f = Function(pow(y,3));
self.assertLessEqual(np.abs(f.eval_d().real / (58.732432)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-129.035608)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("58.732432")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-129.035608")-1), tol_mp)
#
f = Function(x**p);
self.assertLessEqual(np.abs(f.eval_d().real / (-.35190932545709434788093164550270669097948909024)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-6.7687858345625791466707575744042177964518271087)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-.35190932545709434788093164550270669097948909024")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-6.7687858345625791466707575744042177964518271087")-1), tol_mp)
#
f = Function(pow(x,p));
self.assertLessEqual(np.abs(f.eval_d().real / (-.35190932545709434788093164550270669097948909024)-1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-6.7687858345625791466707575744042177964518271087)-1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("-.35190932545709434788093164550270669097948909024")-1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("-6.7687858345625791466707575744042177964518271087")-1), tol_mp)
def test_Operator_degree(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(x**3-9*y*y*z*pow(x,4));
w = VariableGroup(); w.append(x); w.append(y);
self.assertEqual(f.degree(),7)
self.assertEqual(f.degree(x),4)
self.assertEqual(f.degree(y),2)
self.assertEqual(f.degree(z),1)
self.assertEqual(f.degree(w),6)
w = VariableGroup(); w.append(y); w.append(z);
self.assertEqual(f.degree(w),3)
def test_Operator_ishom(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(y**2 - 9*y*z + 3*x*x - y*82*x - pow(z,2));
self.assertTrue(f.is_homogeneous())
f = Function(y**2 - 9*y*z + 3*x*x - y*82*x - pow(z,4));
self.assertFalse(f.is_homogeneous())
f = Function(y**2 - 9*y*z + 3*x*x - 5);
self.assertFalse(f.is_homogeneous())
def test_Operator_ispoly(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = Function(y**2 - 9*y*z + 3*x*x - y*82*x - pow(z,2));
self.assertTrue(f.is_polynomial());
#
f = Function(x**2*y - 9 + sin(z));
self.assertFalse(f.is_polynomial())
def test_Homogenize(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
h = Variable("h");
f = Function(x**2 + y**2 + z**2 - 1);
#
vars = VariableGroup();
vars.append(y); vars.append(x); vars.append(z);
#
f.homogenize(vars,h);
self.assertEqual(f.degree(h),2)
self.assertTrue(f.is_homogeneous())
#
self.assertFalse(f.is_homogeneous(x))
self.assertFalse(f.is_homogeneous(y))
self.assertFalse(f.is_homogeneous(z))
self.assertFalse(f.is_homogeneous(h))
#
vars.append(h);
self.assertTrue(f.is_homogeneous(vars))
if __name__ == '__main__':
unittest.main();

408
python/test/classes/mpfr_test.py Normal file
View File

@@ -0,0 +1,408 @@
# This file is part of Bertini 2.
#
# python/test/mpfr_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/mpfr_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/mpfr_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2016-2018 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# silviana amethyst
# University of Wisconsin - Eau Claire
# Fall 2017, Spring 2018
#
# James Collins
# West Texas A&M University
# Spring 2016
#
import pybertini as pb
from pybertini import multiprec as mp
import unittest
import pdb
dbltol = 1e-15;
class MPFRFloat(unittest.TestCase):
def setUp(self):
mp.default_precision(30);
self.x = mp.Float("4.23")
self.y = mp.Float("-3.86")
self.z = mp.Float("1.1495")
self.p = mp.Float(".34")
self.tol = mp.Float("1e-27");
def test_arith_int(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
self.assertLessEqual(mp.abs((x+8) - mp.Float("12.23")), tol)
self.assertLessEqual(mp.abs((y-2) - mp.Float("-5.86")), tol)
self.assertLessEqual(mp.abs((8+x) - mp.Float("12.23")), tol)
self.assertLessEqual(mp.abs((2-y) - mp.Float("5.86")), tol)
self.assertLessEqual(mp.abs((z*6) - mp.Float("6.897")), tol)
self.assertLessEqual(mp.abs((6*z) - mp.Float("6.897")), tol)
self.assertLessEqual(mp.abs((y/3) - mp.Float("-1.2866666666666666666666666666666667")), tol)
self.assertLessEqual(mp.abs((3/y) - mp.Float("-.77720207253886010362694300518134714")), tol)
self.assertLessEqual(mp.abs((x**3) - mp.Float("75.686967")), tol)
#
result = mp.Float(x);
result += 8;
self.assertLessEqual(mp.abs(result - mp.Float("12.23")), tol)
result = mp.Float(y);
result -= 2;
self.assertLessEqual(mp.abs(result - mp.Float("-5.86")), tol)
result = mp.Float(z);
result *= 6;
self.assertLessEqual(mp.abs(result - mp.Float("6.897")), tol)
result = mp.Float(y);
result /= 3;
self.assertLessEqual(mp.abs(result - mp.Float("-1.2866666666666666666666666666666667")), tol)
#
self.assertLessEqual(mp.abs((-z) - mp.Float("-1.1495")), tol)
def test_arith_mpfr(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
self.assertLessEqual(mp.abs((x+y) - mp.Float("0.37")), tol)
self.assertLessEqual(mp.abs((z-y) - mp.Float("5.0095")), tol)
self.assertLessEqual(mp.abs((z*y) - mp.Float("-4.437070")), tol)
self.assertLessEqual(mp.abs((y/x) - mp.Float("-.91252955082742316784869976359338061")), tol)
self.assertLessEqual(mp.abs((x**y) - mp.Float("0.0038223124228935822000384505727705508")), tol)
self.assertLessEqual(mp.abs((-z) - mp.Float("-1.1495")), tol)
#
result = mp.Float(x);
result += y;
self.assertLessEqual(mp.abs(result - mp.Float("0.37")), tol)
result = mp.Float(z);
result -= y;
self.assertLessEqual(mp.abs(result - mp.Float("5.0095")), tol)
result = mp.Float(z);
result *= y;
self.assertLessEqual(mp.abs(result - mp.Float("-4.437070")), tol)
result = mp.Float(y);
result /= x;
self.assertLessEqual(mp.abs(result - mp.Float("-.91252955082742316784869976359338061")), tol)
def test_trancendentals(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
self.assertLessEqual(mp.abs((mp.exp(x)) - mp.Float("68.717232173846461408252914213396109")), tol)
self.assertLessEqual(mp.abs((mp.log(z)) - mp.Float("0.13932706522109918666170810230684295")), tol)
self.assertLessEqual(mp.abs((mp.sqrt(z)) - mp.Float("1.0721473779289860297522254519889560")), tol)
#
self.assertLessEqual(mp.abs((mp.sin(x)) - mp.Float("-.88588921129660245121088859729926237")), tol)
self.assertLessEqual(mp.abs((mp.cos(y)) - mp.Float("-.75285494656729525719980460936483635")), tol)
self.assertLessEqual(mp.abs((mp.tan(z)) - mp.Float("2.2315038042849919118711153687209483")), tol)
#
self.assertLessEqual(mp.abs((mp.asin(p)) - mp.Float("0.34691689752716170922069696210451452")), tol)
self.assertLessEqual(mp.abs((mp.acos(p)) - mp.Float("1.2238794292677349100106247295352369")), tol)
self.assertLessEqual(mp.abs((mp.atan(z)) - mp.Float("0.85483739856328448882289109284144652")), tol)
#
self.assertLessEqual(mp.abs((mp.sinh(x)) - mp.Float("34.351339891649022639414777866662100")), tol)
self.assertLessEqual(mp.abs((mp.cosh(y)) - mp.Float("23.743209684188284295743755381842167")), tol)
self.assertLessEqual(mp.abs((mp.tanh(z)) - mp.Float("0.81758837109637920976170104688035086")), tol)
def test_change_prec(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
mp.default_precision(40);
tol = mp.Float("1e-37");
t = mp.Float("4.23")
self.assertLessEqual(mp.abs(t**(-2) - mp.Float("0.055888089689206333238323580861682566828183245868")), tol)
mp.default_precision(30);
tol = mp.Float("1e-27");
class MPFRComplex(unittest.TestCase):
def setUp(self):
mp.default_precision(30);
self.x = mp.Complex("-2.43",".21" )
self.y = mp.Complex("4.84", "-1.94")
self.z = mp.Complex("-6.48", "-.731")
self.p = mp.Complex("-.321", "-.72")
self.tol = mp.Float("1e-27");
def test_construct(self):
t = mp.Complex(3.452)
t = mp.Complex(mp.Float("-5.6"))
t = mp.Complex("3.89")
t = mp.Complex(mp.Float("2.98"), mp.Float("-1e-4"))
t = mp.Complex(3.4, 3.5)
t = mp.Complex("6e2", mp.Float("4.32"))
t = mp.Complex(mp.Float("4.32"), "6e2")
def test_arith_mp_float(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
a = mp.Float("3.12"); b = mp.Float("-5.92")
res = mp.Complex(x+a)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.69")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.21")), tol)
res = mp.Complex(y-b)
self.assertLessEqual(mp.abs(res.real - mp.Float("10.76")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.94")), tol)
res = mp.Complex(a+x)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.69")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.21")), tol)
res = mp.Complex(b-y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-10.76")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.94")), tol)
res = mp.Complex(z*a)
self.assertLessEqual(mp.abs(res.real - mp.Float("-20.2176")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.28072")), tol)
res = mp.Complex(a*z)
self.assertLessEqual(mp.abs(res.real - mp.Float("-20.2176")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.28072")), tol)
res = mp.Complex(y/b)
self.assertLessEqual(mp.abs(res.real - mp.Float("-.81756756756756756756756756756756756756756756757")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".3277027027027027027027027027027027027027027027")), tol)
res = mp.Complex(b/y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-1.0538301972842157915642975887484736586585850264")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-.42240301296102864372618539714298324334662292381")), tol)
res = mp.Complex(x**a)
self.assertLessEqual(mp.abs(res.real - mp.Float("-16.054376621961088182387920766649714821973863952")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.7411284591111236754359685247799914985638458821")), tol)
#
#
#
res = mp.Complex(x);
res += a;
self.assertLessEqual(mp.abs(res.real - mp.Float("0.69")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.21")), tol)
res = mp.Complex(y);
res -= b;
self.assertLessEqual(mp.abs(res.real - mp.Float("10.76")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.94")), tol)
res = mp.Complex(z);
res *= a;
self.assertLessEqual(mp.abs(res.real - mp.Float("-20.2176")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.28072")), tol)
res = mp.Complex(y);
res /= b;
self.assertLessEqual(mp.abs(res.real - mp.Float("-.81756756756756756756756756756756756756756756757")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".3277027027027027027027027027027027027027027027")), tol)
#
res = mp.Complex(x**4);
self.assertLessEqual(mp.abs(res.real - mp.Float("33.30735228")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-11.96306496")), tol)
#
res = mp.Complex(-z);
self.assertLessEqual(mp.abs(res.real - mp.Float("6.48")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".731")), tol)
def test_mp_complex_precision(self):
mp.default_precision(30);
x = mp.Complex(1);
mp.default_precision(40);
y = x;
a = mp.Complex(4)
b = mp.Complex(5)
self.assertEqual(y.precision(),30)
mp.default_precision(50);
z = mp.Complex(3);
mp.default_precision(60)
c = mp.Complex(6)
d = mp.Complex(7)
w = x+y
self.assertEqual(w.precision(),60)
c = a
self.assertEqual(c.precision(),40) # even though the source is 40, target is 60, and APPoT.
d = a+b
self.assertEqual(d.precision(),60) # even though the source is 30, target is 60, and APPoT.
def test_arith_mp_complex(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
#
res = mp.Complex(x+y)
self.assertLessEqual(mp.abs(res.real - mp.Float("2.41")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.73")), tol)
res = mp.Complex(y-z)
self.assertLessEqual(mp.abs(res.real - mp.Float("11.32")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.209")), tol)
res = mp.Complex(y+x)
self.assertLessEqual(mp.abs(res.real - mp.Float("2.41")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.73")), tol)
res = mp.Complex(z-y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-11.32")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.209")), tol)
res = mp.Complex(z*x)
self.assertLessEqual(mp.abs(res.real - mp.Float("15.89991")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.41553")), tol)
res = mp.Complex(x*z)
self.assertLessEqual(mp.abs(res.real - mp.Float("15.89991")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".41553")), tol)
res = mp.Complex(y/x)
self.assertLessEqual(mp.abs(res.real - mp.Float("-2.0454866364094805849722642460917801311144730207")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.62158345940494200706001008572869389813414019163")), tol)
res = mp.Complex(x/y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-.44755270475041560619657805305047592426404601827")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-.13600253041648890000441351713180233327939034617")), tol)
res = mp.Complex(y**z)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.0000051612634484879218649489640888954160904291899461")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.16242051733741136410199105656393042124100116889e-4")), tol)
#
#
#
res = mp.Complex(x);
res += y;
self.assertLessEqual(mp.abs(res.real - mp.Float("2.41")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.73")), tol)
res = mp.Complex(y);
res -= z;
self.assertLessEqual(mp.abs(res.real - mp.Float("11.32")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.209")), tol)
res = mp.Complex(z);
res *= x;
self.assertLessEqual(mp.abs(res.real - mp.Float("15.89991")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".41553")), tol)
res = mp.Complex(y);
res /= x;
self.assertLessEqual(mp.abs(res.real - mp.Float("-2.0454866364094805849722642460917801311144730207")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.62158345940494200706001008572869389813414019163")), tol)
def test_trancendentals(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
#
res = mp.exp(x)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.086102743899954532232498058731947255067424332219")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.018352149302889219131202317785160051395400089327")), tol)
res = mp.log(y)
self.assertLessEqual(mp.abs(res.real - mp.Float("1.6514099178148475691128039277241118340531698491")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-0.38121862770417378405072154507774424569831993182")), tol)
res = mp.sqrt(z)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.14335482322754515813189359093523204816185445814")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.5496177371015053245565185485769652617478797292")), tol)
res = mp.sin(x)
self.assertLessEqual(mp.abs(res.real - mp.Float("-0.66749329633668695550441899166308616328986315948")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-0.16020928942503633132090203927960650380076680938")), tol)
res = mp.cos(y)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.45194679593300564730917329070452033759984813611")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-3.3798161097977088705360399142708324234265626016")), tol)
res = mp.tan(z)
self.assertLessEqual(mp.abs(res.real - mp.Float("-0.11998086808607765336591715593714295443402911227")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-0.63859741450762243500349270264429166927927928889")), tol)
res = mp.asin(x)
self.assertLessEqual(mp.abs(res.real - mp.Float("-1.4763431474004472804452143435221887167393328861")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.5406263884278099750127157814537559611048741005")), tol)
res = mp.acos(y)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.38769800860408664087229892623614567735197135529")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("2.3379037587834289977359318611458042347281923566")), tol)
res = mp.atan(z)
self.assertLessEqual(mp.abs(res.real - mp.Float("-1.4195347801361539102032503530226060969949192059")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-0.016801358511827150554928904776095870747673962940")), tol)
res = mp.sinh(x)
self.assertLessEqual(mp.abs(res.real - mp.Float("-5.5116175435238027338707341903303682792175349461")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.1931117850318239903301857156967336540973461581")), tol)
res = mp.cosh(y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-22.821106324812396153305984541517740047129741299")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-58.969920999917202046449299163531439999586349377")), tol)
res = mp.tanh(z)
self.assertLessEqual(mp.abs(res.real - mp.Float("-.99999948909538256503828034023523935671055767287")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-0.0000046773288796255165542679839050497228616710086412")), tol)
# taken out since move to bmp::mpc_complex
# res = mp.square(z)
# self.assertLessEqual(mp.abs(res.real - mp.Float("41.456039")), tol)
# self.assertLessEqual(mp.abs(res.imag - mp.Float("9.47376")), tol)
# res = mp.cube(z)
# self.assertLessEqual(mp.abs(res.real - mp.Float("-261.70981416")), tol)
# self.assertLessEqual(mp.abs(res.imag - mp.Float("-91.694329309")), tol)
def test_complex_abs(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
#
# test absolute value computation
res = mp.abs(x)
self.assertLessEqual(mp.abs(res - mp.Float("2.4390571949013413818264861306502")), tol)
# res = mp.abs2(x)
# self.assertLessEqual(mp.abs(res - mp.Float("5.949")), tol)
def test_complex_conj(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
# res = mp.conj(x)
# self.assertLessEqual(mp.abs(res.real - x.real), tol)
# self.assertLessEqual(mp.abs(res.imag - (-x.imag)), tol)
def test_complex_construct_from_polar(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
# test construction of complex from polar coordinates
res = mp.polar(mp.Float("3.21"), mp.Float("-5.62"))
self.assertLessEqual(mp.abs(res.real - mp.Float("2.5295931897050156212406076422629449344206513531")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.9761726378527774897831544771425943545375239972")), tol)
def test_complex_arg(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
# compute the argument of a complex number
res = mp.arg(y)
self.assertLessEqual(mp.abs(res - mp.Float("-.38121862770417378405072154507774424569831993182")), tol)
# compute reciprocation / inversion
# this was removed with the switch to boost.multiprecision.complex...
# res = mp.inverse(z)
# self.assertLessEqual(mp.abs(res.real - mp.Float("-0.15238180880075963272315628064317633672297417498")), tol)
# self.assertLessEqual(mp.abs(res.imag - mp.Float("0.017189984912554828938368401412062021935878722517")), tol)
def test_change_prec(self):
x = self.x; y = self.y; z = self.z; p = self.p; tol = self.tol;
mp.default_precision(45);
tol = mp.Float("1e-37");
t = mp.Complex("-2.43",".21")
t = t**(-2);
self.assertLessEqual(mp.abs(t.real - mp.Float("0.16560329111110602501494676510297183141930819429")), tol)
self.assertLessEqual(mp.abs(t.imag - mp.Float("0.028838165251841866149715852522538399390278791818")), tol)
mp.default_precision(30);
tol = mp.Float("1e-27");
if __name__ == '__main__':
unittest.main();

70
python/test/classes/parser_test.py Normal file
View File

@@ -0,0 +1,70 @@
# This file is part of Bertini 2.
#
# python/test/parser_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/parser_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/parser_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2016-2018 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# James Collins
# West Texas A&M University
# Spring 2016
#
# silviana amethyst
# UWEC
# Spring 2018
#
__author__ = 'jcollins'
from pybertini import *
import unittest
import numpy as np
import pdb
import pybertini.parse as pp
class ParserTest(unittest.TestCase):
def setUp(self):
self.tol_d = 1e-15;
def test_create_system(self):
tol_d = self.tol_d;
input = 'function f, g; variable_group x,y,z; f = 3*x*y*z; g = x^2 + y^2 + z^2 - 1;';
sys = pp.system(input);
#
vals = np.array((complex(-2.43,.21 ),complex(4.84, -1.94),complex(-6.48, -.731)))
sysEval = sys.eval(vals);
#
self.assertLessEqual(np.abs(sysEval[0].real / (233.2850778)-1), tol_d)
self.assertLessEqual(np.abs(sysEval[0].imag / (-86.5039806)-1), tol_d)
self.assertLessEqual(np.abs(sysEval[1].real / (65.978839)-1), tol_d)
self.assertLessEqual(np.abs(sysEval[1].imag / (-10.32604)-1), tol_d)
#
sys.differentiate()
sysJac = sys.eval_jacobian(vals)
if __name__ == '__main__':
unittest.main();

237
python/test/classes/system_test.py Normal file
View File

@@ -0,0 +1,237 @@
# This file is part of Bertini 2.
#
# python/test/system_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/system_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/system_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2016-2018 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# James Collins
# West Texas A&M University
# Spring 2016
#
# silviana amethyst
# UWEC
# Spring 2018
#
__author__ = 'jcollins'
from pybertini import *
from pybertini.function_tree.symbol import *
from pybertini.function_tree.root import *
from pybertini.function_tree import *
import unittest
import numpy as np
import pdb
import pybertini as pb
import pybertini.multiprec as mp
from pybertini.multiprec import Float as mpfr_float
from pybertini.multiprec import Complex as mpfr_complex
class SystemTest(unittest.TestCase):
def setUp(self):
self.toldbl = 1e-15;
self.x = Variable("x");
self.y = Variable("y");
self.z = Variable("z");
self.a = Float("4.897", "1.23")
#
self.f = Function(self.x*self.y);
self.g = Function(pow(self.x,2)*self.y - self.a*self.z*self.x);
def test_system_create(self):
self.x = Variable("x");
self.y = Variable("y");
self.f = Function(self.x*self.y);
#
s = System();
vg = pb.VariableGroup()
vg.append(self.x)
vg.append(self.y)
s.add_variable_group(vg)
s.add_function(self.f)
def test_system_eval(self):
exact_real = (-32.841085, -150.5480559)
exact_imag = (-26.66705, -258.97936865)
#
s = System();
vg = pb.VariableGroup()
vg.append(self.x)
vg.append(self.y)
vg.append(self.z)
s.add_variable_group(vg)
s.add_function(self.f)
s.add_function(self.g)
#
v = np.array([complex(0),complex(0),complex(0)])
v[0] = complex(3.5,2.89); v[1] = complex(-9.32,.0765); v[2] = complex(5.4,-2.13);
#
e = s.eval(v)
#
self.assertTrue(np.abs(e[0].real - exact_real[0]) < self.toldbl*np.abs(exact_real[0]));
self.assertTrue(np.abs(e[0].imag - exact_imag[0]) < self.toldbl*np.abs(exact_imag[0]));
self.assertTrue(np.abs(e[1].real - exact_real[1]) < self.toldbl*np.abs(exact_real[1]));
self.assertTrue(np.abs(e[1].imag - exact_imag[1]) < self.toldbl*np.abs(exact_imag[1]));
#
#
s = pb.parse.system('function f1, f2; variable_group x,y,z; f1 = x*y; f2 = x^2*y - z*x;')
self.toldbl = mpfr_float('1e-27');
exact_real = (mpfr_float('-32.841085'), mpfr_float('-62.9317230'))
exact_imag = (mpfr_float('-26.66705'), mpfr_float('-196.39641065'))
self.a = mpfr_complex('4.897', '1.23')
v = np.array((mpfr_complex('3.5', '2.89'), mpfr_complex('-9.32', '.0765'), mpfr_complex('5.4', '-2.13')));
#
e = s.eval(v)
#
self.assertLessEqual(mp.abs(e[0].real / exact_real[0]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[0].imag / exact_imag[0]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1].real / exact_real[1]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1].imag / exact_imag[1]-1) , self.toldbl);
def test_system_Jac(self):
exact_real = ((-9.32, 3.5, 0), \
(-94.745870,3.8979,-13.5848))
exact_imag = ((.0765, 2.89, 0),\
(-49.54549,20.230,-18.45733))
#
s = System();
vg = pb.VariableGroup()
vg.append(self.x)
vg.append(self.y)
vg.append(self.z)
s.add_variable_group(vg)
s.add_function(self.f)
s.add_function(self.g)
#
v = np.array([complex(0),complex(0),complex(0)])
v[0] = complex(3.5,2.89); v[1] = complex(-9.32,.0765); v[2] = complex(5.4,-2.13);
#
s.differentiate();
e = s.eval_jacobian(v)
#
self.assertTrue(np.abs(e[0][0].real - exact_real[0][0]) <= self.toldbl*np.abs(exact_real[0][0]));
self.assertTrue(np.abs(e[0][0].imag - exact_imag[0][0]) <= self.toldbl*np.abs(exact_imag[0][0]));
self.assertTrue(np.abs(e[0][1].real - exact_real[0][1]) <= self.toldbl*np.abs(exact_real[0][1]));
self.assertTrue(np.abs(e[0][1].imag - exact_imag[0][1]) <= self.toldbl*np.abs(exact_imag[0][1]));
self.assertTrue(np.abs(e[0][2].real - exact_real[0][2]) <= self.toldbl*np.abs(exact_real[0][2]));
self.assertTrue(np.abs(e[0][2].imag - exact_imag[0][2]) <= self.toldbl*np.abs(exact_imag[0][2]));
self.assertTrue(np.abs(e[1][0].real - exact_real[1][0]) <= self.toldbl*np.abs(exact_real[1][0]));
self.assertTrue(np.abs(e[1][0].imag - exact_imag[1][0]) <= self.toldbl*np.abs(exact_imag[1][0]));
self.assertTrue(np.abs(e[1][1].real - exact_real[1][1]) <= self.toldbl*np.abs(exact_real[1][1]));
self.assertTrue(np.abs(e[1][1].imag - exact_imag[1][1]) <= self.toldbl*np.abs(exact_imag[1][1]));
self.assertTrue(np.abs(e[1][2].real - exact_real[1][2]) <= self.toldbl*np.abs(exact_real[1][2]));
self.assertTrue(np.abs(e[1][2].imag - exact_imag[1][2]) <= self.toldbl*np.abs(exact_imag[1][2]));
#
#
#
#
s = pb.parse.system('function f1, f2; variable_group x,y,z; f1 = x*y; f2 = x^2*y - z*x;')
self.toldbl = mpfr_float('1e-27');
exact_real = ((mpfr_float('-9.32'), mpfr_float('3.5'), mpfr_float('0')), \
(mpfr_float('-71.082170'),mpfr_float('3.8979'),mpfr_float('-3.5')))
exact_imag = ((mpfr_float('.0765'), mpfr_float('2.89'), mpfr_float('0')),\
(mpfr_float('-51.20410'),mpfr_float('20.230'),mpfr_float('-2.89')))
v = np.array((mpfr_complex('3.5', '2.89'), mpfr_complex('-9.32', '.0765'), mpfr_complex('5.4', '-2.13')));
#
s.differentiate();
e = s.eval_jacobian(v);
#
self.assertLessEqual(mp.abs(e[0][0].real / exact_real[0][0]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[0][0].imag / exact_imag[0][0]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[0][1].real / exact_real[0][1]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[0][1].imag / exact_imag[0][1]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[0][2].real ) , self.toldbl);
self.assertLessEqual(mp.abs(e[0][2].imag ) , self.toldbl);
self.assertLessEqual(mp.abs(e[1][0].real / exact_real[1][0]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1][0].imag / exact_imag[1][0]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1][1].real / exact_real[1][1]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1][1].imag / exact_imag[1][1]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1][2].real / exact_real[1][2]-1) , self.toldbl);
self.assertLessEqual(mp.abs(e[1][2].imag / exact_imag[1][2]-1) , self.toldbl);
def test_add_systems(self):
x = self.x; y = self.y;
s1 = System(); s2 = System();
#
vars = VariableGroup();
vars.append(x); vars.append(y);
#
s1.add_variable_group(vars)
s1.add_function(y+1)
s1.add_function(x*y)
#
s2.add_variable_group(vars)
s2.add_function(-y-1)
s2.add_function(-x*y)
#
s1 += s2;
values = np.array((2,3))
v = s1.eval(values)
#
self.assertEqual(v[0], 0.0)
self.assertEqual(v[1], 0.0)
#
deg = s1.degrees()
self.assertEqual(len(deg),2)
#
self.assertEqual(deg[0], 1)
self.assertEqual(deg[1], 2)
def test_mult_system_node(self):
tol_d = self.toldbl;
sys = pb.parse.system('function f1, f2; variable_group x,y,z; f1 = x+2; f2 = y*y;')
#
z = Variable("z");
sys *= Integer(2);
#
vals = np.array((complex(-2.43,.21 ),complex(4.84, -1.94),complex(-6.48, -.731)))
sysEval = sys.eval(vals);
#
self.assertLessEqual(np.abs(sysEval[0].real / (-.86)-1), tol_d)
self.assertLessEqual(np.abs(sysEval[0].imag / (0.42)-1), tol_d)
self.assertLessEqual(np.abs(sysEval[1].real / (39.3240)-1), tol_d)
self.assertLessEqual(np.abs(sysEval[1].imag / (-37.5584)-1), tol_d)
if __name__ == '__main__':
unittest.main();

53
python/test/classes/test_classes.py Normal file
View File

@@ -0,0 +1,53 @@
# This file is part of Bertini 2.
#
# python/test/b2_class_test.py is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python/test/b2_class_test.py is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with python/test/b2_class_test.py. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright(C) 2016-2025 by Bertini2 Development Team
#
# See <http://www.gnu.org/licenses/> for a copy of the license,
# as well as COPYING. Bertini2 is provided with permitted
# additional terms in the b2/licenses/ directory.
# individual authors of this file include:
#
# James Collins
# West Texas A&M University
# Spring 2016
#
# silviana amethyst
# spring 2025
from __future__ import print_function
import classes.mpfr_test as mpfr_test
import classes.function_tree_test as function_tree_test
import classes.differentiation_test as differentiation_test
import classes.system_test as system_test
import classes.parser_test as parser_test
import classes.eigenpy_numpy as eigenpy_numpy
import unittest
mods = (mpfr_test, function_tree_test, differentiation_test, system_test, parser_test, eigenpy_numpy)
suite = unittest.TestSuite();
print(mods)
for tests in mods:
thissuite = unittest.TestLoader().loadTestsFromModule(tests);
print(thissuite)
suite.addTests(thissuite)
#
unittest.TextTestRunner(verbosity=2).run(suite)