def generate_linear_instance(num_var, num_pieces, seed=None): A = [ sp.randMatrix(num_var, min=_min, max=_max, seed=seed) for _ in range(num_pieces) ] v = [ sp.randMatrix(num_var, c=1, min=_min, max=_max, seed=seed) for _ in range(num_pieces - 1) ] x = sp.randMatrix(num_var, c=1, min=_min, max=_max, seed=seed) return A, x, v
def test_siso_place(self): n = 6 A = sp.randMatrix(n, n, seed=1648, min=-10, max=10) b = sp.randMatrix(n, 1, seed=1649, min=-10, max=10) ev = np.sort(np.random.random(n) * 10) f = st.siso_place(A, b, ev) A2 = st.to_np(A + b * f.T) ev2 = np.sort(np.linalg.eigvals(A2)) diff = np.sum(np.abs((ev - ev2) / ev)) self.assertTrue(diff < 1e-6)
def test_siso_place2(self): n = 4 A = sp.randMatrix(n, n, seed=1648, min=-10, max=10) b = sp.randMatrix(n, 1, seed=1649, min=-10, max=10) omega = np.pi * 2 / 2.0 ev = np.sort([1j * omega, -1j * omega, -2, -3]) f = st.siso_place(A, b, ev) A2 = st.to_np(A + b * f.T) ev2 = np.sort(np.linalg.eigvals(A2)) diff = np.sum(np.abs((ev - ev2) / ev)) self.assertTrue(diff < 1e-6)
def setUp(self): n = 5 self.ev = sp.randMatrix(n, 1, seed=1631) d = sp.diag(*self.ev) self.T = T = sp.randMatrix(n, n, seed=1632) assert not T.det() == 0 self.M1 = T * d * T.inv() self.ev_sorted = list(self.ev) self.ev_sorted.sort(reverse=True) # # self.M2 = sp.Matrix([[0, 1], [-1, 0]])
def test_solve_linear_system1(self): M = sp.randMatrix(3, 8, seed=1131) xx = sp.Matrix(sp.symbols('x1:9')) bb = sp.Matrix(sp.symbols('b1:4')) eqns = M * xx + bb sol1 = sp.solve(eqns, xx) sol2 = st.solve_linear_system(eqns, xx) self.assertEqual(xx.subs(sol1) - xx.subs(sol2), xx * 0) # symbolic coefficient matrix # this is (currently) not possible with sp.solve # (additionally add a zero line) M2 = st.symbMatrix(4, 8) bb2 = sp.Matrix(sp.symbols('b1:5')) eqns = M2 * xx + bb2 eqns[-1, :] *= 0 sol3 = st.solve_linear_system(eqns, xx) res = eqns.subs(sol3) res.simplify() self.assertEqual(res, res * 0)
def get_random_A(dim=3, valid=True, diagonal=True, ints=True, max_val=1e+3): """ :param dim: dimension of A :param valid: True iff A's eigenvalues are all negative :param diagonal: if True, A will be diagonal :param ints: A will have only integer elements :param max_val: max value of A if diagonal, else the square of the max value :return: A """ max_val = int(max_val) sgn = -1 if valid else 1 r = random.randint if ints else random.uniform diag = set() # generate n unique numbers for x in itertools.takewhile(lambda x: len(diag) < dim, _grand(r, 1, max_val, int=ints)): diag.add(sgn * x) D = sp.diag(*diag) if not diagonal: M = sp.Matrix([[sp.nan]]) while any(x == sp.nan for x in M): # avoid nan (due to X) X = sp.randMatrix(dim, dim, min=-max_val, max=max_val, seed=int(time.time() * 1000)) # eigenvals from D: det(XDX^-1 -tI) = det(X(D-tI)X^-1) = det(D-tI) M = X * D * (X ** -1) return M else: return D # diagonal matrix with -r values
def validate_dba_db(dba_db, exp, log, dim, a=None, b=None): if not a: a = sy.randMatrix(dim, 1, -1e6, 1e6) * 1e-6 if not b: b = sy.randMatrix(dim, 1, -1e6, 1e6) * 1e-6 numeric = sy.zeros(dim, dim) for i in range(dim): dx = sy.zeros(dim, 1) dx[i] = 1e-6 w1 = log(exp(a)**-1 * exp(b)) w2 = log(exp(a)**-1 * exp(dx) * exp(b)) numeric[:, i] = (w2 - w1) / 1e-6 symbolic = dba_db(a, b) check_matrices(numeric, symbolic, a, b)
def test_create_simfunction2(self): x1, x2, x3, x4 = xx = sp.Matrix(sp.symbols("x1, x2, x3, x4")) u1, u2 = uu = sp.Matrix(sp.symbols("u1, u2")) # inputs p1, p2, p3, p4 = pp = sp.Matrix( sp.symbols("p1, p2, p3, p4")) # parameter t = sp.Symbol('t') A = A0 = sp.randMatrix(len(xx), len(xx), -10, 10, seed=704) B = B0 = sp.randMatrix(len(xx), len(uu), -10, 10, seed=705) v1 = A[0, 0] A[0, 0] = p1 v2 = A[2, -1] A[2, -1] = p2 v3 = B[3, 0] B[3, 0] = p3 v4 = B[2, 1] B[2, 1] = p4 par_vals = lzip(pp, [v1, v2, v3, v4]) f = A * xx G = B fxu = (f + G * uu).subs(par_vals) # some random initial values x0 = st.to_np(sp.randMatrix(len(xx), 1, -10, 10, seed=706)).squeeze() u0 = st.to_np(sp.randMatrix(len(uu), 1, -10, 10, seed=2257)).squeeze() # create the model and the rhs-function mod = st.SimulationModel(f, G, xx, par_vals) rhs_xx_uu = mod.create_simfunction(free_input_args=True) res0_1 = rhs_xx_uu(x0, u0, 0) dres0_1 = st.to_np(fxu.subs(lzip(xx, x0) + lzip(uu, u0))).squeeze() bin_res01 = np.isclose(res0_1, dres0_1) # binary array self.assertTrue(np.all(bin_res01))
def test_num_trajectory_compatibility_test(self): x1, x2, x3, x4 = xx = sp.Matrix(sp.symbols("x1, x2, x3, x4")) u1, u2 = uu = sp.Matrix(sp.symbols("u1, u2")) # inputs t = sp.Symbol('t') # we want to create a random but stable matrix np.random.seed(2805) diag = np.diag(np.random.random(len(xx)) * -10) T = sp.randMatrix(len(xx), len(xx), -10, 10, seed=704) Tinv = T.inv() A = Tinv * diag * T B = B0 = sp.randMatrix(len(xx), len(uu), -10, 10, seed=705) x0 = st.to_np(sp.randMatrix(len(xx), 1, -10, 10, seed=706)).squeeze() tt = np.linspace(0, 5, 2000) des_input = st.piece_wise((2 - t, t <= 1), (t, t < 2), (2 * t - 2, t < 3), (4, True)) des_input_func_vec = st.expr_to_func(t, sp.Matrix([des_input, des_input])) mod2 = st.SimulationModel(A * xx, B, xx) rhs3 = mod2.create_simfunction(input_function=des_input_func_vec) XX = sc.integrate.odeint(rhs3, x0, tt) UU = des_input_func_vec(tt) res1 = mod2.num_trajectory_compatibility_test(tt, XX, UU) self.assertTrue(res1) # slightly different input signal -> other results res2 = mod2.num_trajectory_compatibility_test(tt, XX, UU * 1.1) self.assertFalse(res2)
def test_partial_trace2(self): import sympy as sp dm = sp.randMatrix(2**4, 2**4) dm1 = partial_trace(dm, 4, [0, 2, 3]) dm2 = partial_trace(dm, 4, [0, 1, 2]) dm3 = partial_trace(dm, 4, [0, 2]) T1_0 = dm1[0, 0] T3_0 = dm2[0, 0] T13_00 = dm3[0, 0] T13_01 = dm3[1, 1] T13_10 = dm3[2, 2] T13_11 = dm3[3, 3] self.assertEqual(T1_0, T13_00 + T13_01) self.assertEqual(T3_0, T13_00 + T13_10)
def validate_dw_dw(dw_dw, exp, log, dim, w=None): if not w: w = sy.randMatrix(dim, 1, -1e6, 1e6) * 1e-6 numeric = sy.zeros(dim, dim) for i in range(dim): dx = sy.zeros(dim, 1) dx[i] = 1e-6 w2 = log(exp(dx) * exp(w)) numeric[:, i] = (w2 - w) / 1e-6 symbolic = dw_dw(w) check_matrices(numeric, symbolic, w, None)
def test_random(): M = randMatrix(3, 3) M = randMatrix(3, 3, seed=3) M = randMatrix(3, 4, 0, 150)
#!/usr/bin/env python from random import randrange from sympy import Matrix, pprint, randMatrix, N, eye from sympy.printing.str import StrPrinter from sympy.abc import x filename = "test_nml_mat_lup_solve.data" num_tests = 400 min_M_cols = 1 min_M_rows = 1 max_M_cols = 25 max_M_rows = 25 min_val = 0 max_val = 100 fs = open(filename, "w") fs.write("{}".format(num_tests)) for i in range(num_tests): M_dim = randrange(min_M_cols, max_M_cols) M = randMatrix(M_dim, M_dim, min=min_val, max=max_val, percent=100) print("Creating test case: ", i) fs.write("\n{} {}\n".format(M_dim, M_dim)) fs.write(M.table(StrPrinter(), rowstart="", rowend="", colsep="\t")) fs.close()
import sympy as sp import numpy as np quat_vars = sp.symbols('q:4') theta_vars = sp.symbols('theta:3') g = sp.Quaternion(*quat_vars) * sp.Quaternion(1, *theta_vars) g_mat = sp.Matrix([getattr(g, att) for att in 'abcd']) G = g_mat.jacobian(theta_vars) for i in range(1): quat_this = sp.Quaternion(*np.random.uniform(-1, 1, 4)).normalize() subdict = dict(zip(quat_vars, [getattr(quat_this, att) for att in 'abcd'])) G_this = G.subs(subdict) P_this = sp.randMatrix(3, 3) P_this = P_this * P_this.T Pq = G_this * sp.randMatrix(3, 3) * G_this.T
def test_create_simfunction(self): x1, x2, x3, x4 = xx = sp.Matrix(sp.symbols("x1, x2, x3, x4")) u1, u2 = uu = sp.Matrix(sp.symbols("u1, u2")) # inputs p1, p2, p3, p4 = pp = sp.Matrix( sp.symbols("p1, p2, p3, p4")) # parameter t = sp.Symbol('t') A = A0 = sp.randMatrix(len(xx), len(xx), -10, 10, seed=704) B = B0 = sp.randMatrix(len(xx), len(uu), -10, 10, seed=705) v1 = A[0, 0] A[0, 0] = p1 v2 = A[2, -1] A[2, -1] = p2 v3 = B[3, 0] B[3, 0] = p3 v4 = B[2, 1] B[2, 1] = p4 par_vals = lzip(pp, [v1, v2, v3, v4]) f = A * xx G = B fxu = (f + G * uu).subs(par_vals) # some random initial values x0 = st.to_np(sp.randMatrix(len(xx), 1, -10, 10, seed=706)).squeeze() # Test handling of unsubstituted parameters mod = st.SimulationModel(f, G, xx, model_parameters=par_vals[1:]) with self.assertRaises(ValueError) as cm: rhs0 = mod.create_simfunction() self.assertTrue("unexpected symbols" in cm.exception.args[0]) # create the model and the rhs-function mod = st.SimulationModel(f, G, xx, par_vals) rhs0 = mod.create_simfunction() self.assertFalse(mod.compiler_called) self.assertFalse(mod.use_sp2c) res0_1 = rhs0(x0, 0) dres0_1 = st.to_np(fxu.subs(lzip(xx, x0) + st.zip0(uu))).squeeze() bin_res01 = np.isclose(res0_1, dres0_1) # binary array self.assertTrue(np.all(bin_res01)) # difference should be [0, 0, ..., 0] self.assertFalse(np.any(rhs0(x0, 0) - rhs0(x0, 3.7))) # simulate tt = np.linspace(0, 0.5, 100) # simulation should be short due to instability res1 = sc.integrate.odeint(rhs0, x0, tt) # create and try sympy_to_c bridge (currently only works on linux # and if sympy_to_c is installed (e.g. with `pip install sympy_to_c`)) # until it is not available for windows we do not want it as a requirement # see also https://stackoverflow.com/a/10572833/333403 try: import sympy_to_c except ImportError: # noinspection PyUnusedLocal sympy_to_c = None sp2c_available = False else: sp2c_available = True if sp2c_available: rhs0_c = mod.create_simfunction(use_sp2c=True) self.assertTrue(mod.compiler_called) res1_c = sc.integrate.odeint(rhs0_c, x0, tt) self.assertTrue(np.all(np.isclose(res1_c, res1))) mod.compiler_called = None rhs0_c = mod.create_simfunction(use_sp2c=True) self.assertTrue(mod.compiler_called is None) # proof calculation # x(t) = x0*exp(A*t) Anum = st.to_np(A.subs(par_vals)) Bnum = st.to_np(G.subs(par_vals)) # noinspection PyUnresolvedReferences xt = [np.dot(sc.linalg.expm(Anum * T), x0) for T in tt] xt = np.array(xt) # test whether numeric results are close within given tolerance bin_res1 = np.isclose(res1, xt, rtol=2e-5) # binary array self.assertTrue(np.all(bin_res1)) # test handling of parameter free models: mod2 = st.SimulationModel(Anum * xx, Bnum, xx) rhs2 = mod2.create_simfunction() res2 = sc.integrate.odeint(rhs2, x0, tt) self.assertTrue(np.allclose(res1, res2)) # test input functions des_input = st.piece_wise((0, t <= 1), (t, t < 2), (0.5, t < 3), (1, True)) des_input_func_scalar = st.expr_to_func(t, des_input) des_input_func_vec = st.expr_to_func(t, sp.Matrix([des_input, des_input])) # noinspection PyUnusedLocal with self.assertRaises(TypeError) as cm: mod2.create_simfunction(input_function=des_input_func_scalar) rhs3 = mod2.create_simfunction(input_function=des_input_func_vec) # noinspection PyUnusedLocal res3_0 = rhs3(x0, 0) rhs4 = mod2.create_simfunction(input_function=des_input_func_vec, time_direction=-1) res4_0 = rhs4(x0, 0) self.assertTrue(np.allclose(res3_0, np.array([119., -18., -36., -51.]))) self.assertTrue(np.allclose(res4_0, -res3_0))
from AntColonyOptimizer import AntColonyOptimizer import numpy as np import pandas as pd import matplotlib.pyplot as plt import time import warnings import sympy np.random.seed(0) dist = sympy.randMatrix(r=100, c=100, min=1, max=99, symmetric=True, seed=0) # sympy 의 인덱스 접근은 [r][c] 형식이 아닌 [r,c]형식 for i in range(100): dist[i, i] = 0 dist = np.array(dist, dtype='float64') print(dist) optimizer = AntColonyOptimizer(ants=100, evaporation_rate=.1, intensification=2, alpha=1, beta=1, beta_evaporation_rate=0, choose_best=.1) best = optimizer.fit(dist, 100) optimizer.plot()
def test_random(): M = randMatrix(3,3) M = randMatrix(3,3,seed=3) M = randMatrix(3,4,0,150)
filename = "test_nml_mat_rref.data" num_tests = 400 min_M_cols = 1 min_M_rows = 1 max_M_cols = 15 max_M_rows = 15 min_val = 0 max_val = 15 percent_min = 90 percent_max = 100 fs = open(filename, "w") fs.write("{}\n\n".format(num_tests)) for i in range(num_tests): M_rows = randrange(min_M_rows, max_M_rows) M_cols = randrange(min_M_cols, max_M_cols) M = randMatrix(M_rows, M_cols, min=0, max=10, percent=randrange(percent_min, percent_max)) MRREF = M.rref()[0].applyfunc(N) print("Creating test cases: ", i) fs.write("{} {}\n".format(M_rows, M_cols)) fs.write(M.table(StrPrinter(), rowstart="", rowend="", colsep="\t")) fs.write("\n") fs.write("{} {}\n".format(M_rows, M_cols)) fs.write(MRREF.table(StrPrinter(), rowstart="", rowend="", colsep="\t")) fs.write("\n") fs.close()