def solve(self, qr_reduction=True, reducedGroebner=True):
'''
The main function. Initializes the matrix, adds the phi's and r's, and then reduces it. Repeats until the reduction
no longer adds any more polynomials to the matrix. Print statements let us see the progress of the code.
'''
MultiCheb.clearTime()
MultiPower.clearTime()
startTime = time.time()
polys_were_added = True
i = 1 #Tracks what loop we are on.
while polys_were_added:
#print("Starting Loop #"+str(i))
#print("Num Polys - ", len(self.new_polys + self.old_polys))
self.initialize_np_matrix()
self.add_phi_to_matrix()
self.add_r_to_matrix()
self.create_matrix()
#print(self.np_matrix.shape)
polys_were_added = self.reduce_matrix(
qr_reduction=qr_reduction, triangular_solve=False
) #Get rid of triangular solve when done testing
i += 1
#print("Basis found!")
self.get_groebner()
if reducedGroebner:
self.reduce_groebner_basis()
endTime = time.time()
#print("WE WIN")
print("Run time was {} seconds".format(endTime - startTime))
print(times)
MultiCheb.printTime()
MultiPower.printTime()
#print("Basis - ")
#for poly in self.groebner_basis:
# print(poly.coeff)
#break #print just one
return self.groebner_basis
def Macaulay(initial_poly_list, global_accuracy = 1.e-10):
"""
Macaulay will take a list of polynomials and use them to construct a Macaulay matrix.
parameters
--------
initial_poly_list: A list of polynomials
global_accuracy: How small we want a number to be before assuming it is zero.
--------
Returns
-----------
Reduced Macaulay matrix that can be passed into the root finder.
-----------
"""
times = {}
startTime = time.time()
MultiCheb.clearTime()
MultiPower.clearTime()
Power = bool
if all([type(p) == MultiPower for p in initial_poly_list]):
Power = True
elif all([type(p) == MultiCheb for p in initial_poly_list]):
Power = False
else:
print([type(p) == MultiPower for p in initial_poly_list])
raise ValueError('Bad polynomials in list')
poly_list = []
degree = find_degree(initial_poly_list)
startAdding = time.time()
for i in initial_poly_list:
poly_list = add_polys(degree, i, poly_list)
endAdding = time.time()
times["adding polys"] = (endAdding - startAdding)
startCreate = time.time()
matrix, matrix_terms = create_matrix(poly_list)
endCreate = time.time()
times["create matrix"] = (endCreate - startCreate)
#plt.matshow([i==0 for i in matrix])
startReduce = time.time()
matrix = rrqr_reduce(matrix)
matrix = clean_zeros_from_matrix(matrix)
non_zero_rows = np.sum(abs(matrix),axis=1) != 0
matrix = matrix[non_zero_rows,:] #Only keeps the non_zero_polymonials
endReduce = time.time()
times["reduce matrix"] = (endReduce - startReduce)
#plt.matshow([i==0 for i in matrix])
startTri = time.time()
matrix = triangular_solve(matrix)
matrix = clean_zeros_from_matrix(matrix)
endTri = time.time()
times["triangular solve"] = (endTri - startTri)
#plt.matshow([i==0 for i in matrix])
startGetPolys = time.time()
rows = get_good_rows(matrix, matrix_terms)
final_polys = get_poly_from_matrix(rows,matrix,matrix_terms,Power)
endGetPolys = time.time()
times["get polys"] = (endGetPolys - startGetPolys)
endTime = time.time()
print("Macaulay run time is {} seconds".format(endTime-startTime))
print(times)
MultiCheb.printTime()
MultiPower.printTime()
#for poly in final_polys:
# print(poly.lead_term)
return final_polys
