def test_TVB_paper_example(): #Power form of the polys p1 = MultiPower(np.array([[1, -4, 0], [0, 3, 0], [1, 0, 0]])) #y^2 + 3xy - 4x +1 p2 = MultiPower(np.array([[3, 0, -2], [6, -6, 0], [0, 0, 0]])) #-6xy -2x^2 + 6y +3 #Cheb form of the polys c1 = MultiCheb(np.array([[2, 0, -1], [6, -6, 0], [0, 0, 0]])) #p1 in Cheb form c2 = MultiCheb(np.array([[1.5, -4, 0], [0, 3, 0], [.5, 0, 0]])) #p2 in Cheb form #Homogenous power form p1 = MultiPower(np.array([[1, -4, 0], [0, 3, 0], [1, 0, 0]])) #y^2 + 3xy - 4x +1 p2 = MultiPower(np.array([[3, 0, -2], [6, -6, 0], [0, 0, 0]])) #-6xy -2x^2 + 6y +3 right_number_of_roots = 4 power_roots = tvb.solve([p1, p2], verbose=True) assert len(power_roots) == right_number_of_roots for root in power_roots: assert np.isclose(0, p1(root), atol=1.e-8) assert np.isclose(0, p2(root), atol=1.e-8) cheb_roots = tvb.solve([c1, c2], verbose=True) assert len(cheb_roots) == right_number_of_roots for root in cheb_roots: assert np.isclose(0, c1(root), atol=1.e-8) assert np.isclose(0, c1(root), atol=1.e-8)
def testRoots_4(): f1 = MultiPower(np.array([[5, -1], [1, 0]])) f2 = MultiPower(np.array([[1, -1], [-1, 0]])) root = rf.roots([f1, f2], method='Macaulay')[0] assert (all(np.isclose(root, [-2, 3])))
def Mxi_Matrix(i, basisDict, VB, dim, poly_type, verbose=False): ''' Uses the reduced Macaulay matrix to construct the Moller-Stetter matrix M_xi, which represents the linear map of multiplying by xi in the space C[x1, ..., xn]/I. Parameters ---------- i : int The index of the variable xi to make the Moller-Stetter matrix of, where variables are indexed as x1, x2, ..., xn. basisDict: dictionary A dictionary which maps monomials not in the basis to linear combinations of monomials in the basis. Generated using the TVB method. VB: numpy array Represents a vector basis for the space C[x1, ..., xn]/I created with the TVB method. Each row represents a monomial in the basis as the degrees of each variable. For example, x^2y^5 would be represented as [2,5]. dim: int The dimension of the system (n) verbose : bool Prints information about how the roots are computed. Returns ------- Mxi : 2D numpy array The Moller-Stetter matrix which represents multiplying by xi ''' VB = VB.tolist() #convert to list bc numpy's __contains__() function is broken #Construct the polynomial to create the MS Matrix of (xi) xi_ind = np.zeros(dim, dtype=int) xi_ind[i-1] = 1 coef = np.zeros((2,)*dim) coef[tuple(xi_ind)] = 1 if poly_type == "MultiPower": xi = MultiPower(np.array(coef)) elif poly_type == "MultiCheb": xi = MultiCheb(np.array(coef)) if verbose: print("\nCoefficients of polynomial whose Moller-Stetter matrix we construt\n", xi.coeff) # Build multiplication matrix M_xi Mxi = np.zeros((len(VB), len(VB))) for j in range(len(VB)): #multiply each monomial in the basis by xi product_coef = xi.mon_mult(VB[j], returnType = 'Matrix') for monomial in zip(*np.where(product_coef != 0)): if list(monomial) in VB: #convert to list to test if list of lists Mxi[VB.index(list(monomial))][j] += product_coef[monomial] else: Mxi[:,j] -= product_coef[monomial]*basisDict[monomial] # Construct var_dict var_dict = {} for i in range(len(VB)): mon = VB[i] if np.sum(mon) == 1 or np.sum(mon) == 0: var_dict[tuple(mon)] = i return Mxi
def test_mon_mult_random(): np.random.seed(988) #test with random matrices possible_dim = np.random.randint(1,5, (1,10)) dim = possible_dim[0, np.random.randint(1,9)] shape = list() for i in range(dim): shape.append(np.random.randint(2,4)) matrix1 = np.random.randint(1,11,(shape)) M1 = MultiPower(matrix1) shape2 = list() for i in range(dim): shape2.append(np.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_coeff, new_M4_coeff = utils.match_size(M3.coeff,M4.coeff) else: new_M3_coeff, new_M4_coeff = M3.coeff, M4.coeff assert np.allclose(new_M3_coeff, new_M4_coeff)
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 testReducePoly(): poly = MultiPower(np.array([[-3], [2], [-4], [1]])) g = MultiPower(np.array([[2], [1]])) basisSet = set() basisSet.add((0, 0)) reduced = rf.reduce_poly(poly, [g], basisSet) assert (MultiPower(reduced).coeff == np.array([[-31.]]))
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], method='Macaulay') assert (all(np.isclose(roots[0], [-0.61803399, 0.38196601]))) assert (all(np.isclose(roots[1], [1.61803399, 2.61803399])))
def testReducePoly_2(): poly = MultiPower(np.array([[-7], [2], [-13], [4]])) g = MultiPower(np.array([[-2], [3], [1]])) basisSet = set() basisSet.add((0, 0)) basisSet.add((1, 0)) reduced = rf.reduce_poly(poly, [g], basisSet) assert (np.all(MultiPower(reduced).coeff == np.array([[-57.], [85.]])))
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))
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], method='Groebner') values_at_roots = np.array([[f1(root) for root in roots], [f2(root) for root in roots]]) assert (np.all(np.isclose(values_at_roots, 0)))
def test_roots_at_inf(): g = MultiPower(np.array([[0, 0, 1], [-1, 0, 0]]).T) #f(x,y) = x^2 - y assert roots_at_inf(g) == [(0, 1)] f = MultiPower(np.array([[0, 1]])) #f(x,y) = y g = MultiPower(np.array([[0, 0, -1], [1, 0, 0]])) #f(x,y) = x - y^2 assert roots_at_inf(f) == [(1, 0)] assert roots_at_inf(g) == [(1, 0)] f = MultiPower(np.array([[5, 6, 2], [9, 3, 0], [1, 0, 0]])) assert roots_at_inf(f) == [(-2, 1), (-1, 1)]
def test_evaluate_grid1(): #Evaluate 2 + yx^2 + 3y^2 - xy on grid (0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2) poly = MultiPower(np.array([[2,0,3], [0,-1,0], [0,1,0]])) x = np.arange(3) xy = np.column_stack([x,x]) sol = np.array([[2,5,14], [2,5,14], [2,7,18]]) assert(np.all(poly.evaluate_grid(xy) == sol))
def test_find_degree(): #Test Case #1 - 2,3,4, and 5 2D Polynomials of degree 3 degree3Coeff = np.array([[1, 1, 1, 1], [1, 1, 1, 0], [1, 1, 0, 0], [1, 0, 0, 0]]) A = MultiPower(degree3Coeff) B = MultiPower(degree3Coeff) C = MultiPower(degree3Coeff) D = MultiPower(degree3Coeff) E = MultiPower(degree3Coeff) assert (find_degree([A, B]) == 5) assert (find_degree([A, B, C]) == 7) assert (find_degree([A, B, C, D]) == 9) assert (find_degree([A, B, C, D, E]) == 11) #Test Case #2 - A 2D polynomials of degree 3 and one of degree 5 degree5Coeff = np.array([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 0, 0], [1, 1, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0]]) F = MultiPower(degree5Coeff) assert (find_degree([A, F]) == 7) #Test Case #3 - Two 3D polynomials of degree 15 G = MultiPower(np.random.rand(6, 6, 6)) H = MultiPower(np.random.rand(6, 6, 6)) assert (find_degree([G, H]) == 29)
def test_find_degree(): '''Test Case #1 - 2,3,4, and 5 2D Polynomials of degree 3''' degree3Coeff = np.array([ [1,1,1,1], [1,1,1,0], [1,1,0,0], [1,0,0,0]]) A = MultiPower(degree3Coeff) B = MultiPower(degree3Coeff) C = MultiPower(degree3Coeff) D = MultiPower(degree3Coeff) E = MultiPower(degree3Coeff) assert(find_degree([A,B]) == 5) assert(find_degree([A,B,C]) == 7) assert(find_degree([A,B,C,D]) == 9) assert(find_degree([A,B,C,D,E]) == 11) '''Test Case #2 - A 2D polynomials of degree 3 and one of degree 5''' degree5Coeff = np.array([ [1,1,1,1,1,1], [1,1,1,1,1,0], [1,1,1,1,0,0], [1,1,1,0,0,0], [1,1,0,0,0,0], [1,0,0,0,0,0]]) F = MultiPower(degree5Coeff) assert(find_degree([A,F]) == 7) ''' Test Case #3 - Two 3D polynomials of degree 15''' G = MultiPower(np.random.rand(6,6,6)) H = MultiPower(np.random.rand(6,6,6)) assert(find_degree([G,H]) == 29) #Test 3 - Simple Example in 2D poly1 = MultiPower(np.array([[3,0,1],[0,0,0],[0,0,1]])) poly2 = MultiPower(np.array([[3,0],[1,1],[0,1]])) found_degree = find_degree([poly1,poly2]) correct_degree = 6 assert found_degree == correct_degree #Test 4 - Simple Example in 3D a = np.zeros((4,4,4)) a[3,3,3] = 1 poly1 = MultiCheb(a) poly2 = MultiCheb(np.ones((3,5,4))) poly3 = MultiCheb(np.ones((2,4,5))) found_degree1 = find_degree([poly1,poly2,poly3]) correct_degree1 = 24 assert found_degree1 == correct_degree1
def test_sorted_polys_coeff(): A = MultiPower( np.array([[2, 0, -3, 0, 0], [0, 1, 0, 0, 0], [-2, 0, 0, 0, 0], [0, 0, 4, 0, 0], [0, 0, 0, 0, -2]])) B = MultiPower( np.array([[3, 0, -5, 0, 0, 4, 2, -6, 3, -6], [-2, 0, -1, 1, -1, 4, 2, -6, -5, -2], [-1, 3, 2, -2, 0, 4, -1, -2, -4, 6], [4, 2, 5, 9, 0, 3, 2, -1, -3, -3], [3, -3, -5, -2, 0, 4, -2, 2, 1, -6]])) assert ([A, B] == ut.sorted_polys_coeff([A, B])) C = MultiPower(np.array([[1]])) assert ([C, A, B] == ut.sorted_polys_coeff([A, B, C]))
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], method='Groebner') values_at_roots = np.array([[f1(root) for root in roots], [f2(root) for root in roots], [f3(root) for root in roots]]) assert (np.all(np.isclose(values_at_roots, 0)))
def roots_at_inf(f): ''' Finds the roots at infinity of a homogenous, bivarite power-basis polynomial. Parameters ---------- poly: a bivariate power-basis polynomial returns ------- the roots at infinity of the polynomial (list of tuples). In the form (x,y). Since at infinity, z = 0 ''' #get the coefficients of the homogenous part of f: [y^d ... x^d] f_d_coefs = np.diag(np.fliplr(pad_with_zeros(f.coeff))) #find all x s.t. f_d(x,1) == 0 #essentially, set y = 1 and solve a 1D polynomial with coefficients from f_d #if there is only 1 nonzero coefficient in this 1D polynomial have to handle separately if sum(f_d_coefs != 0) == 1: if np.where(f_d_coefs != 0) == np.array([0]): #if the nonzero coef in the 1D poly is the constant, only root at inf is (1,0) return [(1,0)] else: #f_d(x,y) = x^a y^b, so 0 = f_d(x,1) == x^a implies x = 0 x_coords = np.array([0]) else: x_coords = solve(MultiPower(f_d_coefs)) inf_roots_f_d = list(zip(x_coords, np.ones(len(x_coords)))) #check if f_d(1,0) == 0 #f_d(1,0) = the coef of x^d if np.isclose(f_d_coefs[-1],0): inf_roots_f_d.append((1,0)) return inf_roots_f_d
def _random_poly(_type, dim): ''' Generates a random polynomial that has the form c_1x_1 + c_2x_2 + ... + c_nx_n where n = dim and each c_i is a randomly chosen integer between 0 and 1000. Parameters ---------- _type : string Type of Polynomial to generate. "MultiCheb" or "MultiPower". dim : int Degree of polynomial to generate (?). Returns ------- Polynomial Randomly generated Polynomial. ''' _vars = get_var_list(dim) random_poly_shape = [2 for i in range(dim)] random_poly_coeff = np.zeros(tuple(random_poly_shape), dtype=int) for var in _vars: random_poly_coeff[var] = np.random.randint(1000) if _type == 'MultiCheb': return MultiCheb(random_poly_coeff), _vars else: return MultiPower(random_poly_coeff), _vars
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]]])) basisSet = set() for i in range(2): for j in range(3): for k in range(1): basisSet.add((k, i, j)) reduced = rf.reduce_poly(poly, [d1, d2, d3], basisSet) assert (np.all( MultiPower(reduced).coeff == np.array([[[-1, -7, 0], [2, 0, 1]]])))
def test_evaluate(): # 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((4,2,1)) == 15)
def getPoly(deg, power): ''' A helper function for testing. Returns a random 1D polynomial of the given degree. power is a boolean indicating whether or not the polynomial should be MultiPower. ''' coeff = np.random.random_sample(deg+1) if power: return MultiPower(coeff) else: return MultiCheb(coeff)
def test_common_root_at_inf(): f = MultiPower(np.array([[0, 1]])) #f(x,y) = y g = MultiPower(np.array([[0, 0, -1], [1, 0, 0]])) #f(x,y) = x - y^2 #assert common_root_at_inf([f,g]) == True f = MultiPower(np.array([[0, 1]])) #f(x,y) = y g = MultiPower(np.array([[0, 0, -1], [1, 0, 0]]).T) #f(x,y) = x^2 - y #assert common_root_at_inf([f,g]) == False #from ./Easy/dpdx-dpdy_ex016.mat, which is a dupliate of ./Easy/dpdx-dpdy_ex007.mat and almost the same as ./Easy/dpdx-dpdy_ex008.mat f = MultiPower( np.array([[-0.21875, 0., 1.3125, 0., -1.09375, 0., 0.21875], [0., -2.625, 0., 4.375, 0., -1.3125, 0.], [1.3125, 0., -6.5625, 0., 3.28125, 0., 0.], [0., 4.375, 0., -4.375, 0., 0., 0.], [-1.09375, 0., 3.28125, 0., 0., 0., 0.], [0., -1.3125, 0., 0., 0., 0., 0.], [0.21875, 0., 0., 0., 0., 0., 0.]])) g = MultiPower( np.array([[0., -0.65625, 0., 1.09375, 0., -0.328125], [0.65625, 0., -3.28125, 0., 1.640625, 0.], [0., 3.28125, 0., -3.28125, 0., 0.], [-1.09375, 0., 3.28125, 0., 0., 0.], [0., -1.640625, 0., 0., 0., 0.], [0.328125, 0., 0., 0., 0., 0.]])) assert common_root_at_inf([f, g]) == True #from ./Easy/dpdx-dpdy_C1.mat f = MultiPower( np.array([[0., 1., -1.5, -0.5, -1.875, 0., 0.875], [0., -3., 1.5, 1.5, -0.625, 0., 0.], [-0.125, 2.5, 0.375, -1.5, 1.25, 0., 0.], [0.125, 0.5, -0.75, 0.5, 0., 0., 0.], [0.125, -1.5, 0.375, 0., 0., 0., 0.], [-0.125, 0.5, 0., 0., 0., 0., 0.]])) g = MultiPower( np.array([[0., 0.25, 9.], [0., 0., 0.], [-0.75, -1., 0.], [0, 0, 0]])) assert common_root_at_inf([f, g]) == False f = MultiPower(np.array([[0., 0., 0., 1.]])) g = MultiPower(np.array([[0., 0., 0., 0., 1.25]])) assert common_root_at_inf([f, g]) == True
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 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]])) basisSet = set() basisSet.add((0, 0)) basisSet.add((0, 1)) basisSet.add((0, 2)) basisSet.add((1, 0)) basisSet.add((1, 1)) basisSet.add((1, 2)) reduced = rf.reduce_poly(poly, [g1, g2], basisSet) assert (np.all( MultiPower(reduced).coeff == np.array([[0, 0, 0], [1, 2, 2]])))
def test_mon_mult(): """ Tests monomial multiplication using normal polynomial multiplication. """ np.random.seed(4) #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 getPoly(deg, dim): ''' A helper function for testing. Returns a random upper triangular polynomial of the given dimension and degree. power is a boolean indicating whether or not the polynomial should be MultiPower. ''' deg += 1 ACoeff = np.random.random_sample(deg * np.ones(dim, dtype=int)) for i, j in np.ndenumerate(ACoeff): if np.sum(i) >= deg: ACoeff[i] = 0 return MultiPower(ACoeff)
def test_evaluate2(): # 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((7.4, 2.33, .25)), 16.94732))
def test_evaluate_grid2(): #Evaluate zy^2 + 3z^2 + 3x + zx^2y^2 on grid {0, 1, 2}X{0, 1, 2}X{0, 1, 2} poly = MultiPower(np.array([[[0,0,3], [0,0,0], [0,1,0]], [[3,0,0], [0,0,0], [0,0,0]], [[0,0,0], [0,0,0], [0,1,0]]])) x = np.arange(3) xyz = np.column_stack([x,x,x]) sol = np.array([[[0,3,12], [0,4,14], [0,7,20]], [[3,6,15], [3,8,19], [3,14,31]], [[6,9,18], [6,14,28], [6,29,58]]]) assert(np.all(poly.evaluate_grid(xyz) == sol))
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], method='Groebner') values_at_roots = np.array([[f1(root) for root in roots], [f2(root) for root in roots], [f3(root) for root in roots]]) assert (np.all(np.isclose(values_at_roots, 0)))