def test_inverse_P(): # Simple Test Case. C = MultiPower(np.array([[-1, 0, 1], [0, 0, 0]])) D = MultiPower(np.array([[-1, 0, 0], [0, 1, 0], [1, 0, 0]])) # Creating a random object to run tests. grob = Groebner([C, D]) # Create matrix M = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]) # Order of Column flips. p = [1, 4, 3, 2, 0, 5] # N is the matrix with the columns flipped. N = M[:, p] # Find the order of columns to flip back to. pt = grob.inverse_P(p) # Result done by hand. pt_inv = [4, 0, 3, 2, 1, 5] assert (np.allclose(M, N[:, pt])), "Matrix are not the same." assert (all(pt == pt_inv)), "Wrong matrix order." # Test Case 2: A = np.random.random((5, 10)) Q, R, p = qr(A, pivoting=True) pt = grob.inverse_P(p) # We know that A[:,p] = QR, want to see if pt flips QR back to A. assert (np.allclose(A, np.dot(Q, R)[:, pt]))
def test_add(): a1 = np.arange(27).reshape((3, 3, 3)) Test2 = MultiPower(a1) a2 = np.ones((3, 3, 3)) Test3 = MultiPower(a2) addTest = Test2 + Test3 assert (addTest.coeff == (Test2.coeff + Test3.coeff)).all()
def test_mon_mult_random(): #test with random matrices possible_dim = np.random.randint(1, 5, (1, 10)) dim = possible_dim[0, random.randint(1, 9)] shape = list() for i in range(dim): shape.append(random.randint(2, 4)) matrix1 = np.random.randint(1, 11, (shape)) M1 = MultiPower(matrix1) shape2 = list() for i in range(dim): shape2.append(random.randint(2, 4)) matrix2 = np.ones(shape2) M2 = MultiPower(matrix2) M3 = M1 * M2 for index, i in np.ndenumerate(M2.coeff): if sum(index) == 0: M4 = MultiPower.mon_mult(M1, index) else: M4 = M4 + MultiPower.mon_mult(M1, index) if M3.shape != M4.shape: new_M3, new_M4 = MultiPower.match_size(M3, M3, M4) else: new_M3, new_M4 = M3, M4 assert np.allclose(new_M3.coeff, new_M4.coeff)
def test_evaluate_at(): # Evaluate .5xyz + 2x + y + z at (4,2,1) poly = MultiPower( np.array([[[0, 1, 0], [1, 0, 0], [0, 0, 0]], [[2, 0, 0], [0, .5, 0], [0, 0, 0]]])) assert (poly.evaluate_at((4, 2, 1)) == 15)
def testRoots_4(): f1 = MultiPower(np.array([[5,-1],[1,0]])) f2 = MultiPower(np.array([[1,-1],[-1,0]])) root = rf.roots([f1, f2])[0] assert(all(np.isclose(root, [-2,3])))
def calc_s(self, a, b): ''' Calculates the S-polynomial of a,b ''' lcm = self._lcm(a, b) a_coeffs = np.zeros_like(a.coeff) a_coeffs[tuple([i - j for i, j in zip(lcm, a.lead_term) ])] = 1. / (a.coeff[tuple(a.lead_term)]) b_coeffs = np.zeros_like(b.coeff) b_coeffs[tuple([i - j for i, j in zip(lcm, b.lead_term) ])] = 1. / (b.coeff[tuple(b.lead_term)]) if isinstance(a, MultiPower) and isinstance(b, MultiPower): b_ = MultiPower(b_coeffs) a_ = MultiPower(a_coeffs) elif isinstance(a, MultiCheb) and isinstance(b, MultiCheb): b_ = MultiCheb(b_coeffs) a_ = MultiCheb(a_coeffs) else: raise ValueError('Incompatiable polynomials') a1 = a_ * a b1 = b_ * b s = a_ * a - b_ * b #self.polys.append(s) return s
def test_mult(): test1 = np.array([[0, 1], [2, 1]]) test2 = np.array([[2, 2], [3, 0]]) p1 = MultiPower(test1) p2 = MultiPower(test2) new_poly = p1 * p2 truth = MultiPower(np.array([[0, 2, 2], [4, 9, 2], [6, 3, 0]])) assert np.allclose(new_poly.coeff, truth.coeff)
def testRoots_5(): f1 = MultiPower(np.array([[0,-1],[0,0],[1,0]])) f2 = MultiPower(np.array([[1,-1],[1,0]])) roots = rf.roots([f1, f2]) assert(all(np.isclose(roots[0], [-0.61803399, 0.38196601]))) assert(all(np.isclose(roots[1], [1.61803399, 2.61803399])))
def test_evaluate_at2(): # Evaluate -.5x^2y + 2xy^2 - 3z^2 + yz at (7.4,2.33,.25) poly = MultiPower( np.array([[[0, 0, -3], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [2, 0, 0]], [[0, 0, 0], [-.5, 0, 0], [0, 0, 0]]])) assert (np.isclose(poly.evaluate_at((7.4, 2.33, .25)), 16.94732))
def test_triangular_solve(): """This tests the triangular_solve() method. A visual graph of zeroes on the diagonal was also used to test this function. """ # Simple Test Case. M = MultiPower(np.array([[-1, 0, 1], [0, 0, 0]])) N = MultiPower(np.array([[-1, 0, 0], [0, 1, 0], [1, 0, 0]])) # Creating a random object to run tests. grob = Groebner([M, N]) A = np.array([[1, 2, 3, 4, 5], [0, 1, 2, 3, 4], [0, 0, 0, 1, 2]]) matrix = grob.triangular_solve(A) answer = np.array([[1., 0., -1., 0., 1.], [0., 1., 2., 0., -2.], [0., 0., 0., 1., 2.]]) assert (np.allclose(matrix, answer)) # Randomize test case: square matrix. A = np.random.random((50, 50)) Q, R, p = qr(A, pivoting=True) diagonal = np.diag(R) r = np.sum(np.abs(diagonal) > 1e-10) matrix = R[:r] new_matrix = grob.triangular_solve(matrix) true = sy.Matrix(new_matrix).rref() x = sy.symbols('x') f = sy.lambdify(x, true[0]) assert (np.allclose(new_matrix, f(1))) # Randomize test case: shorter rows than column. A = np.random.random((10, 50)) Q, R, p = qr(A, pivoting=True) diagonal = np.diag(R) r = np.sum(np.abs(diagonal) > 1e-10) matrix = R[:r] new_matrix = grob.triangular_solve(matrix) true = sy.Matrix(new_matrix).rref() x = sy.symbols('x') f = sy.lambdify(x, true[0]) print(f(1)) print(new_matrix) assert (np.allclose(new_matrix, f(1))) # Randomize test case: longer rows than columns. A = np.random.random((50, 10)) Q, R, p = qr(A, pivoting=True) diagonal = np.diag(R) r = np.sum(np.abs(diagonal) > 1e-10) matrix = R[:r] new_matrix = grob.triangular_solve(matrix) true = sy.Matrix(new_matrix).rref() x = sy.symbols('x') f = sy.lambdify(x, true[0]) print(f(1)) print(new_matrix) assert (np.allclose(new_matrix, f(1)))
def test_vectorSpaceBasis(): f1 = MultiPower(np.array([[0,-1.5,.5],[-1.5,1.5,0],[1,0,0]])) f2 = MultiPower(np.array([[0,0,0],[-1,0,1],[0,0,0]])) f3 = MultiPower(np.array([[0,-1,0,1],[0,0,0,0],[0,0,0,0],[0,0,0,0]])) G = [f1, f2, f3] basis = rf.vectorSpaceBasis(G)[0] trueBasis = [(0,0), (1,0), (0,1), (1,1), (0,2)] assert (len(basis) == len(trueBasis)) and (m in basis for m in trueBasis), \ "Failed on MultiPower in 2 vars."
def testRoots_7(): # This test sometimes fails due to stability issues... f1_coeff = np.zeros((3,3,3)) f1_coeff[(0,2,0)] = 1 f1_coeff[(1,1,0)] = -1 f1_coeff[(1,0,1)] = -2 f1 = MultiPower(f1_coeff) f2_coeff = np.zeros((4,4,4)) f2_coeff[(0,3,0)] = 1 f2_coeff[(0,0,2)] = 1 f2_coeff[(0,0,0)] = 1 f2 = MultiPower(f2_coeff) f3_coeff = np.zeros((3,3,3)) f3_coeff[(2,1,1)] = 1 f3_coeff[(0,1,1)] = -1 f3 = MultiPower(f3_coeff) roots = rf.roots([f1, f2, f3]) values_at_roots = [[f1.evaluate_at(root) for root in roots], [f2.evaluate_at(root) for root in roots], [f3.evaluate_at(root) for root in roots]] assert(np.all(np.isclose(values_at_roots, 0)))
def testReducePoly_3(): poly = MultiPower( np.array([[0, -1, 0, 1], [0, 2, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0]])) g1 = MultiPower(np.array([[0, 0, 0], [-2, 0, 0], [1, 0, 0]])) g2 = MultiPower( np.array([[0, -1, 0, 1], [3, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])) reduced = rf.reduce_poly(poly, [g1, g2]) assert (np.all(reduced.coeff == np.array([[0, 0, 0], [1, 2, 2]])))
def testReducePoly_4(): poly = MultiPower(np.array([[[-1,2,0],[0,0,0],[-3,0,0]], [[0,0,0],[2,0,0],[0,0,0]], [[0,0,0],[0,0,1],[0,0,0]]])) d1 = MultiPower(np.array([[0,-3,0], [0,0,0], [1,0,0]])) d2 = MultiPower(np.array([[0,0,0,1], [4,0,0,0]])) d3 = MultiPower(np.array([[[-1,1]]])) reduced = rf.reduce_poly(poly, [d1, d2, d3]) assert(np.all(reduced.coeff == np.array([[[1],[0]],[[0],[2]]])))
def testRoots(): f1 = MultiPower(np.array([[0,-1.5,.5],[-1.5,1.5,0],[1,0,0]]), clean_zeros=False) f2 = MultiPower(np.array([[0,0,0],[-1,0,1],[0,0,0]]), clean_zeros=False) f3 = MultiPower(np.array([[0,-1,0,1],[0,0,0,0],[0,0,0,0],[0,0,0,0]]), clean_zeros=False) roots = rf.roots([f1, f2, f3]) values_at_roots = np.array([[f1.evaluate_at(root) for root in roots], [f2.evaluate_at(root) for root in roots], [f3.evaluate_at(root) for root in roots]]) assert(np.all(values_at_roots==0))
def multMatrix(poly, GB, basis): ''' Finds the matrix of the linear operator m_f on A = C[x_1,...,x_n]/I where f is the polynomial argument. The linear operator m_f is defined as m_f([g]) = [f]*[g] where [f] represents the coset of f in A. Since m_f is a linear operator on A, it can be represented by its matrix with respect to the vector space basis. parameters ---------- poly : polynomial object The polynomial f for which to find the matrix m_f. GB: list of polynomial objects Polynomials that make up a Groebner basis for the ideal basis : list of tuples The monomials that make up a basis for the vector space A return ------ multOperatorMatrix : square numpy array The matrix m_f ''' # Reshape poly's coefficienet matrix if it is not in the same number # of variables as the polynomials in the Groebner basis. # (i.e. len(shape) is the number of variables the polynomial is in) numVars = len(GB[0].shape) polyVars = len(poly.coeff.shape) if polyVars != numVars: new_shape = [i for i in poly.coeff.shape] for j in range(numVars-polyVars): new_shape.append(1) if type(poly) is MultiPower: poly = MultiPower(poly.coeff.reshape(tuple(new_shape))) if type(poly) is MultiCheb: poly = MultiCheb(poly.coeff.reshape(tuple(new_shape))) dim = len(basis) operatorMatrix = np.zeros((dim, dim)) for i in range(dim): monomial = basis[i] poly_ = poly.mon_mult(monomial) operatorMatrix[:,i] = coordinateVector(poly_, GB, basis) return operatorMatrix
def sm_to_poly(self, rows, reduced_matrix): ''' Takes a list of indicies corresponding to the rows of the reduced matrix and returns a list of polynomial objects ''' shape = [] p_list = [] matrix_term_vals = [i.val for i in self.matrix_terms] # Finds the maximum size needed for each of the poly coeff tensors for i in range(len(matrix_term_vals[0])): # add 1 to each to compensate for constant term shape.append(max(matrix_term_vals, key=itemgetter(i))[i] + 1) # Grabs each polynomial, makes coeff matrix and constructs object for i in rows: p = reduced_matrix[i] p[np.where(abs(p) < global_accuracy)] = 0 coeff = np.zeros(shape) for j, term in enumerate(matrix_term_vals): coeff[term] = p[j] if self.power: poly = MultiPower(coeff) p_list.append(poly) else: poly = MultiCheb(coeff) p_list.append(poly) return p_list
def testMultMatrix_2(): f1 = MultiPower(np.array([[0,-1.5,.5],[-1.5,1.5,0],[1,0,0]])) f2 = MultiPower(np.array([[0,0,0],[-1,0,1],[0,0,0]])) f3 = MultiPower(np.array([[0,-1,0,1],[0,0,0,0],[0,0,0,0],[0,0,0,0]])) GB = [f1, f2, f3] VB = rf.vectorSpaceBasis(GB)[0] x = MultiPower(np.array([[0],[1]])) y = MultiPower(np.array([[0,1]])) mx_Eig = np.linalg.eigvals(rf.multMatrix(x, GB, VB)) my_Eig = np.linalg.eigvals(rf.multMatrix(y, GB, VB)) assert(len(mx_Eig) == 5) assert(len(my_Eig) == 5) assert(np.allclose(mx_Eig, [-1., 2., 1., 1., 0.])) assert(np.allclose(my_Eig, [1., -1., 1., -1., 0.]))
def test_reduce_matrix(): poly1 = MultiPower(np.array([[1., 0.], [0., 1.]])) poly2 = MultiPower(np.array([[0., 0.], [1., 0.]])) poly3 = MultiPower(np.array([[1., 0.], [12., -5.]])) grob = Groebner([]) grob.new_polys = list((poly1, poly2, poly3)) grob.matrix_terms = [] grob.np_matrix = np.array([]) grob.term_set = set() grob.lead_term_set = set() grob._add_polys(grob.new_polys) #This breaks becasue it hasn't been initialized. #assert(grob.reduce_matrix()) #assert(len(grob.old_polys) == 2) #assert(len(grob.new_polys) == 1) poly1 = MultiPower(np.array([[1., 0.], [0., 0.]])) poly2 = MultiPower(np.array([[0., 0.], [1., 0.]])) poly3 = MultiPower(np.array([[1., 0.], [12., 0.]])) grob = Groebner([]) grob.new_polys = list((poly1, poly2, poly3)) grob.matrix_terms = [] grob.np_matrix = np.array([]) grob.term_set = set() grob.lead_term_set = set() grob._add_polys(grob.new_polys) #This breaks becasue it hasn't been initialized. #assert(not grob.reduce_matrix()) #assert(len(grob.old_polys) == 3) #assert(len(grob.new_polys) == 0) poly1 = MultiPower(np.array([[1., -14.], [0., 2.]])) poly2 = MultiPower(np.array([[0., 3.], [1., 6.]])) poly3 = MultiPower(np.array([[1., 0.], [12., -5.]])) grob = Groebner([]) grob.new_polys = list((poly1, poly2, poly3)) grob.matrix_terms = [] grob.np_matrix = np.array([]) grob.term_set = set() grob.lead_term_set = set() grob._add_polys(grob.new_polys) assert (grob.reduce_matrix()) #assert(len(grob.old_polys) == 3) assert (len(grob.new_polys) == 2)
def test_mon_mult(): """ Tests monomial multiplication using normal polynomial multiplication. """ #Simple 2D test cases cheb1 = MultiCheb(np.array([[0, 0, 0], [0, 0, 0], [0, 0, 1]])) mon1 = (1, 1) result1 = cheb1.mon_mult(mon1) truth1 = np.array([[0, 0, 0, 0], [0, 0.25, 0, 0.25], [0, 0, 0, 0], [0, 0.25, 0, 0.25]]) assert np.allclose(result1.coeff, truth1) #test with random matrices cheb2 = np.random.randint(-9, 9, (4, 4)) C1 = MultiCheb(cheb2) C2 = cheb2poly(C1) C3 = MultiCheb.mon_mult(C1, (1, 1)) C4 = MultiPower.mon_mult(C2, (1, 1)) C5 = poly2cheb(C4) assert np.allclose(C3.coeff, C5.coeff) # test results of chebyshev mult compared to power multiplication cheb3 = np.random.randn(5, 4) c1 = MultiCheb(cheb3) c2 = MultiCheb(np.ones((4, 2))) for index, i in np.ndenumerate(c2.coeff): if sum(index) == 0: c3 = c1.mon_mult(index) else: c3 = c3 + c1.mon_mult(index) p1 = cheb2poly(c1) p2 = cheb2poly(c2) p3 = p1 * p2 p4 = cheb2poly(c3) assert np.allclose(p3.coeff, p4.coeff) # test results of chebyshev mult compared to power multiplication in 3D cheb4 = np.random.randn(3, 3, 3) a1 = MultiCheb(cheb4) a2 = MultiCheb(np.ones((3, 3, 3))) for index, i in np.ndenumerate(a2.coeff): if sum(index) == 0: a3 = a1.mon_mult(index) else: a3 = a3 + a1.mon_mult(index) q1 = cheb2poly(a1) q2 = cheb2poly(a2) q3 = q1 * q2 q4 = cheb2poly(a3) assert np.allclose(q3.coeff, q4.coeff)
def test_vectorSpaceBasis_2(): f1 = MultiPower(np.array([[[0,0,1],[0,3/20,0],[0,0,0]], [[0,0,0],[-3/40,1,0],[0,0,0]], [[0,0,0],[0,0,0],[0,0,0]]])) f2 = MultiPower(np.array([[[3/16,-5/2,0],[0,3/16,0],[0,0,0]], [[0,0,1],[0,0,0],[0,0,0]], [[0,0,0],[0,0,0],[0,0,0]]])) f3 = MultiPower(np.array([[[0,1,1/2],[0,3/40,1],[0,0,0]], [[-1/2,20/3,0],[-3/80,0,0],[0,0,0]], [[0,0,0],[0,0,0],[0,0,0]]])) f4 = MultiPower(np.array([[[3/32,-7/5,0,1],[-3/16,83/32,0,0],[0,0,0,0],[0,0,0,0]], [[3/40,-1,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]], [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]], [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]])) f5 = MultiPower(np.array([[[5,0,0],[0,0,0],[0,0,0]], [[0,-2,0],[0,0,0],[0,0,0]], [[1,0,0],[0,0,0],[0,0,0]]])) f6 = MultiPower(np.array([[[0,0,0],[0,0,0],[1,0,0]], [[0,-8/3,0],[0,0,0],[0,0,0]], [[0,0,0],[0,0,0],[0,0,0]]])) G = [f1, f2, f3, f4, f5, f6] basis = rf.vectorSpaceBasis(G)[0] trueBasis = [(0,0,0),(1,0,0),(0,1,0),(1,1,0),(0,0,1),(0,0,2),(1,0,1),(0,1,1)] assert (len(basis) == len(trueBasis)) and (m in basis for m in trueBasis), \ "Failed on MultiPower in 3 vars."
def testRoots_2(): f1 = MultiPower(np.array([[[5,0,0],[0,0,0],[0,0,0]], [[0,-2,0],[0,0,0],[0,0,0]], [[1,0,0],[0,0,0],[0,0,0]]])) f2 = MultiPower(np.array([[[1,0,0],[0,1,0],[0,0,0]], [[0,0,0],[0,0,0],[1,0,0]], [[0,0,0],[0,0,0],[0,0,0]]])) f3 = MultiPower(np.array([[[0,0,0],[0,0,0],[3,0,0]], [[0,-8,0],[0,0,0],[0,0,0]], [[0,0,0],[0,0,0],[0,0,0]]])) roots = rf.roots([f1, f2, f3]) values_at_roots = np.array([[f1.evaluate_at(root) for root in roots], [f2.evaluate_at(root) for root in roots], [f3.evaluate_at(root) for root in roots]]) assert(np.all(abs(values_at_roots)<1.e-5))
def calc_r(self, m): ''' Finds the r polynomial that has a leading monomial m Returns the polynomial. ''' for p in self.new_polys + self.old_polys: l = list(p.lead_term) if all([i <= j for i, j in zip(l, m) ]) and len(l) == len(m): #Checks to see if l divides m c = [j - i for i, j in zip(l, m)] if not l == m: #Make sure c isn't all 0 return p.mon_mult(c) if self.power: return MultiPower(np.array([0])) else: return MultiCheb(np.array([0]))
def testRoots_3(): # roots of [x^2-y, x^3-y+1] f1 = MultiPower(np.array([[0,-1],[0,0],[1,0]])) f2 = MultiPower(np.array([[1,-1],[0,0],[0,0],[1,0]])) roots = rf.roots([f1, f2]) values_at_roots = np.array([[f1.evaluate_at(root) for root in roots], [f2.evaluate_at(root) for root in roots]]) assert(np.all(values_at_roots==0))
def add_r_to_matrix(self): ''' Makes Heap out of all monomials, and finds lcms to add them into the matrix ''' for monomial in self.term_set: m = list(monomial) for p in self.polys: l = list(p.lead_term) if all([i <= j for i, j in zip(l, m)]) and len(l) == len(m): c = [j - i for i, j in zip(l, m)] c_coeff = np.zeros(np.array(self.largest_mon.val) + 1) c_coeff[tuple(c)] = 1 if isinstance(p, MultiCheb): c = MultiCheb(c_coeff) elif isinstance(p, MultiPower): c = MultiPower(c_coeff) r = c * p self.add_poly_to_matrix(r) break pass
def testMultMatrix(): f1 = MultiPower( np.array([[[5, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, -2, 0], [0, 0, 0], [0, 0, 0]], [[1, 0, 0], [0, 0, 0], [0, 0, 0]]])) f2 = MultiPower( np.array([[[1, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]])) f3 = MultiPower( np.array([[[0, 0, 0], [0, 0, 0], [3, 0, 0]], [[0, -8, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]])) F = [f1, f2, f3] Gr = Groebner(F) GB = Gr.solve() VB = rf.vectorSpaceBasis(GB) x = MultiPower(np.array([[0], [1]])) y = MultiPower(np.array([[0, 1]])) z = MultiPower(np.array([[[0, 1]]])) mx_RealEig = [eig.real for eig in \ np.linalg.eigvals(rf.multMatrix(x, GB, VB)) if (eig.imag == 0)] my_RealEig = [eig.real for eig in \ np.linalg.eigvals(rf.multMatrix(y, GB, VB)) if (eig.imag==0)] mz_RealEig = [eig.real for eig in \ np.linalg.eigvals(rf.multMatrix(z, GB, VB)) if (eig.imag==0)] assert (len(mx_RealEig) == 2) assert (len(my_RealEig) == 2) assert (len(mz_RealEig) == 2) assert (np.allclose(mx_RealEig, [-1.100987715, .9657124563], atol=1.e-8)) assert (np.allclose(my_RealEig, [-2.878002536, -2.81249605], atol=1.e-8)) assert (np.allclose(mz_RealEig, [3.071618528, -2.821182227], atol=1.e-8))
def test_mon_mult(): """ Tests monomial multiplication using normal polynomial multiplication. """ mon = (1, 2) Poly = MultiPower( np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])) mon_matr = MultiPower( np.array([[0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]])) P1 = mon_matr * Poly P2 = MultiPower.mon_mult(Poly, mon) mon2 = (0, 1, 1) Poly2 = MultiPower(np.arange(1, 9).reshape(2, 2, 2)) mon_matr2 = MultiPower(np.array([[[0, 0], [0, 1]], [[0, 0], [0, 0]]])) T1 = mon_matr2 * Poly2 T2 = MultiPower.mon_mult(Poly2, mon2) assert np.allclose(P1.coeff, P2.coeff, atol=1.0e-10) assert np.allclose(T1.coeff, T2.coeff, atol=1.0e-10)
def test_solve(): #First Test A = MultiPower(np.array([[-10, 0], [0, 1], [1, 0]])) B = MultiPower(np.array([[-26, 0, 0], [0, 0, 1], [0, 0, 0], [1, 0, 0]])) C = MultiPower( np.array([[-70, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]])) grob = Groebner([A, B, C]) X = MultiPower(np.array([[-2.], [1.]])) Y = MultiPower(np.array([[-3., 1.]])) x1, y1 = grob.solve() assert (np.any([X == i and Y == j for i, j in permutations((x1, y1), 2)])) #Second Test A = MultiPower( np.array([[[[ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]], [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]]], [[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]], [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]]]])) B = MultiPower( np.array([[[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]], [[ -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]]], [[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]], [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]]]])) C = MultiPower( np.array([[[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]], [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]]], [[[ -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]], [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]]]])) grob = Groebner([A, B, C]) w1, x1, y1, z1 = grob.solve() W = MultiPower( np.array([[[[0.], [0.]], [[0.], [0.]], [[0.], [0.]], [[1.], [0.]]], [[[0.], [-1.]], [[0.], [0.]], [[0.], [0.]], [[0.], [0.]]]])) X = MultiPower( np.array([[[[0., 0., 0., 0., 0., 1.], [-1., 0., 0., 0., 0., 0.]]]])) Y = MultiPower(np.array([[[[0.], [0.], [1.]], [[-1.], [0.], [0.]]]])) Z = MultiPower( np.array([[[[0.], [0.]], [[0.], [0.]], [[0.], [1.]]], [[[-1.], [0.]], [[0.], [0.]], [[0.], [0.]]]])) assert (np.any([ W == i and X == j and Y == k and Z == l for i, j, k, l in permutations((w1, x1, y1, z1), 4) ])) #Third Test A = MultiPower(np.array([[-1, 0, 1], [0, 0, 0]])) B = MultiPower(np.array([[-1, 0, 0], [0, 1, 0], [1, 0, 0]])) grob = Groebner([A, B]) x1, y1 = grob.solve() assert (np.any([A == i and B == j for i, j in permutations((x1, y1), 2)])) #Fourth Test A = MultiPower(np.array([[-10, 0], [0, 1], [1, 0]])) B = MultiPower(np.array([[-25, 0, 0], [0, 0, 1], [0, 0, 0], [1, 0, 0]])) C = MultiPower( np.array([[-70, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]])) grob = Groebner([A, B, C]) X = MultiPower(np.array([[1.]])) x1 = grob.solve() assert (X == x1[0]) #Fifth Test A = MultiPower(np.array([[1, 1], [0, 0]])) B = MultiPower(np.array([[1, 0], [1, 0]])) C = MultiPower(np.array([[1, 0], [1, 0], [0, 1]])) grob = Groebner([A, B, C]) X = MultiPower(np.array([[1.]])) x1 = grob.solve() assert (X == x1[0])
def testReducePoly_2(): poly = MultiPower(np.array([[-7], [2], [-13], [4]])) g = MultiPower(np.array([[-2], [3], [1]])) reduced = rf.reduce_poly(poly, [g]) assert (np.all(reduced.coeff == np.array([[-57.], [85.]])))
def testReducePoly(): poly = MultiPower(np.array([[-3], [2], [-4], [1]])) g = MultiPower(np.array([[2], [1]])) reduced = rf.reduce_poly(poly, [g]) assert (reduced.coeff == np.array([[-31.]]))