def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' from triangular import triangular_solve from QR import factor from matutil import mat2rowdict Q, R = factor(A) rowlist = [mat2rowdict(R)[v] for v in mat2rowdict(R)] label_list = sorted(A.D[1], key=repr) return triangular_solve(rowlist, label_list, b * Q)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' I = {i:Vec(A.D[0],{i:1}) for i in A.D[1]} rl = list() ll = list() cd = dict() rd = mat2rowdict(A) for k,i in rd.items(): ll.append(k) rl.append(rd[k]) for k in ll: cd[k]= triangular_solve(rl,ll,I[k]) return coldict2mat(cd)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' from triangular import triangular_solve from QR import factor from matutil import mat2rowdict Q,R = factor(A) rowlist = [mat2rowdict(R)[v] for v in mat2rowdict(R)] label_list = sorted(A.D[1], key = repr) return triangular_solve(rowlist, label_list, b*Q)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' Q,R = factor(A) return triangular_solve(mat2rowdict(R),list(A.D[1]), Q.transpose()*b) # test #domain = ({'a','b','c'},{'A','B'}) #A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) #Q, R = factor(A) #b = Vec(domain[0], {'a': 1, 'b': -1}) #x = QR_solve(A, b) #result = A.transpose()*(b-A*x) #print(result * result < 1E-10)
def QR_solve(A, b): ''' Input: - A: a Mat with linearly independent columns - b: a Vec whose domain equals the set of row-labels of A Output: - vector x that minimizes norm(b - A*x) Note: This procedure uses the procedure QR_factor, which in turn uses dict2list and list2dict. You wrote these procedures long back in python_lab. Make sure the completed python_lab.py is in your matrix directory. Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR_factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result.is_almost_zero() True ''' Q, R = QR_factor(A) c = Q.transpose() * b rowlist = mat2rowdict(R) labelslist = sorted(A.D[1], key=repr) return triangular_solve(rowlist, labelslist, c)
def QR_solve(A, b): ''' Input: - A: a Mat with linearly independent columns - b: a Vec whose domain equals the set of row-labels of A Output: - vector x that minimizes norm(b - A*x) Note: This procedure uses the procedure QR_factor, which in turn uses dict2list and list2dict. You wrote these procedures long back in python_lab. Make sure the completed python_lab.py is in your matrix directory. Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR_factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result.is_almost_zero() True ''' Q,R = QR_factor(A) keylist = sorted(R.D[1], key=repr) c = Q.transpose() * b res = triangular_solve(mat2rowdict(R), keylist, c) return res
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' from triangular import triangular_solve from QR import factor from dictutil import dict2list from vecutil import vec2list Q,R = factor(A) b = Q.transpose()*b rowdict = mat2rowdict(R) rowlist = dict2list(rowdict, list(rowdict.keys())) x = triangular_solve(rowlist, list(rowlist[0].D), vec2list(b)) return x
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' Q,R = factor(A) c = Q.transpose()*b return triangular_solve(mat2rowdict(R), sorted(A.D[1],key=repr), c) # A=Mat(({'a','b','c'},{'A','B'}), {('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1, ('c','B'):-2}) # b = Vec({'a','b','c'}, {'a':1,'b':-1}) # x = QR_solve(A,b) # print(x) # print(A.transpose()*(b-A*x)) # print(QR_solve(least_squares_A1, least_squares_b1)) # print(QR_solve(least_squares_A2, least_squares_b2))
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' I = {i: Vec(A.D[0], {i: 1}) for i in A.D[1]} rl = list() ll = list() cd = dict() rd = mat2rowdict(A) for k, i in rd.items(): ll.append(k) rl.append(rd[k]) for k in ll: cd[k] = triangular_solve(rl, ll, I[k]) return coldict2mat(cd)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' from QR import factor from triangular import triangular_solve from mat import transpose from matutil import mat2rowdict Q, R = factor(A) qT = Q.transpose() c = qT * b rows = [rowVec for index, rowVec in mat2rowdict(R).items()] colLabels = sorted(A.D[1], key=repr) x_hat = triangular_solve(rows, colLabels, c) return x_hat
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' Q, R = factor(A) c = Q.transpose() * b return triangular_solve(mat2rowdict(R), sorted(A.D[1], key=repr), c) # A=Mat(({'a','b','c'},{'A','B'}), {('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1, ('c','B'):-2}) # b = Vec({'a','b','c'}, {'a':1,'b':-1}) # x = QR_solve(A,b) # print(x) # print(A.transpose()*(b-A*x)) # print(QR_solve(least_squares_A1, least_squares_b1)) # print(QR_solve(least_squares_A2, least_squares_b2))
def find_triangular_matrix_inverse(A): """ input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True """ I_col_dict = {i: Vec(A.D[0], {i: 1}) for i in A.D[1]} # def triangular_solve(rowlist, label_list, b): rowlist = list() label_list = list() from matutil import mat2rowdict rowdict = mat2rowdict(A) for key in rowdict.keys(): label_list.append(key) rowlist.append(rowdict[key]) B_coldict = dict() from triangular import triangular_solve for key in label_list: B_coldict[key] = triangular_solve(rowlist, label_list, I_col_dict[key]) return coldict2mat(B_coldict)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' from QR import factor from triangular import triangular_solve from mat import transpose from matutil import mat2rowdict Q, R = factor(A) qT = Q.transpose() c = qT*b rows = [rowVec for index,rowVec in mat2rowdict(R).items()] colLabels = sorted(A.D[1], key=repr) x_hat = triangular_solve(rows,colLabels,c) return x_hat
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' R = len(A.D[0]) C = len(A.D[1]) coldict = {} for i in range(C): b = [0] * R b[i] = 1 s = triangular_solve(list(matutil.mat2rowdict(A).values()), list(A.D[0]), list2vec(b)) coldict[i] = s return coldict2mat(coldict) # import hw5 # import hw4 # from mat import Mat # import vecutil # import matutil # from vec import Vec # from GF2 import one # L = [Vec({0, 1, 2},{0: 1, 1: 0, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 0, 2: 1}), Vec({0, 1, 2},{0: 1, 1: 1, 2: 1}), Vec({0, 1, 2},{0: 1, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 1})] # hw5.my_is_independent(L) # hw5.my_is_independent(L[:2]) # S = [vecutil.list2vec(v) for v in [[1,0,0],[0,1,0],[0,0,1]]] # B = [vecutil.list2vec(v) for v in [[1,1,0],[0,1,1],[1,0,1]]] # ff = hw5.morph(S, B) # ff == [(Vec({0, 1, 2},{0: 1, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 1, 1: 0, 2: 0})), (Vec({0, 1, 2},{0: 0, 1: 1, 2: 1}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 0})), (Vec({0, 1, 2},{0: 1, 1: 0, 2: 1}), Vec({0, 1, 2},{0: 0, 1: 0, 2: 1}))] # a0 = Vec({'a','b','c','d'}, {'a':1}) # a1 = Vec({'a','b','c','d'}, {'b':1}) # a2 = Vec({'a','b','c','d'}, {'c':1}) # a3 = Vec({'a','b','c','d'}, {'a':1,'c':3}) # sb = hw5.subset_basis([a0,a1,a2,a3]) # sb == [Vec({'c', 'b', 'a', 'd'},{'a': 1}), Vec({'c', 'b', 'a', 'd'},{'b': 1}), Vec({'c', 'b', 'a', 'd'},{'c': 1})] # U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})] # V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})] # w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}) # ss = hw5.direct_sum_decompose(U_basis, V_basis, w) # ss == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0})) # M = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0}) # hw5.is_invertible(M) # A = Mat(({0, 1}, {0, 1, 2}), {(0, 1): 2, (1, 2): 1, (0, 0): 1, (1, 0): 3, (0, 2): 3, (1, 1): 1}) # B = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0}) # C = Mat(({0, 1, 2}, {0, 1}), {(0, 1): 0, (2, 0): 2, (0, 0): 1, (1, 0): 0, (1, 1): 1, (2, 1): 1}) # D = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): 5, (1, 2): 2, (0, 0): 1, (2, 0): 4, (1, 0): 2, (2, 2): 7, (0, 2): 8, (2, 1): 6, (1, 1): 5}) # E = Mat(({0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}), {(1, 2): 7, (3, 2): 7, (0, 0): 3, (3, 0): 1, (0, 4): 3, (1, 4): 2, (1, 3): 4, (2, 3): 0, (2, 1): 56, (2, 4): 5, (4, 2): 6, (1, 0): 2, (0, 3): 7, (4, 0): 2, (0, 1): 5, (3, 3): 4, (4, 1): 4, (3, 1): 23, (4, 4): 5, (0, 2): 7, (2, 0): 2, (4, 3): 8, (2, 2): 9, (3, 4): 2, (1, 1): 4}) # M = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (1, 2): 0, (0, 0): 0, (2, 0): 0, (1, 0): one, (2, 2): one, (0, 2): 0, (2, 1): 0, (1, 1): 0}) # hw5.find_matrix_inverse(M) == Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (2, 0): 0, (0, 0): 0, (2, 2): one, (1, 0): one, (1, 2): 0, (1, 1): 0, (2, 1): 0, (0, 2): 0}) # A = matutil.listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) # hw5.find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' return coldict2mat([triangular_solve([row for row in mat2rowdict(A).values()], range(len(A.D[0])), Vec(A.D[0],{i:1})) for i in range(len(A.D[0]))])
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' (v,k)=(list(mat2rowdict(A).values()),list(mat2rowdict(A).keys())) return coldict2mat([triangular_solve(v,k,Vec(A.D[1], {e:1})) for e in A.D[1]])
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' (v, k) = (list(mat2rowdict(A).values()), list(mat2rowdict(A).keys())) return coldict2mat( [triangular_solve(v, k, Vec(A.D[1], {e: 1})) for e in A.D[1]])
def find_triangular_matrix_inverse(A): L=[] label_list = [] I = identity(A.D[0],1) R = mat2rowdict(A) w = mat2rowdict(I) label_list.extend(range(len(R))) for k,v in w.items(): print(k,v,) s = triangular_solve(R, label_list, v) L.append(s) return coldict2mat(L)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' solution = identity(A.D[0],1) solutionrowdict = mat2rowdict(solution) Arowveclist = list(mat2rowdict(A).values()) label_list = list(range(len(Arowveclist))) return coldict2mat({key:triangular_solve(Arowveclist, label_list, vec) for key,vec in solutionrowdict.items()})
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' cols = [] i = identity(A.D[0], 1) i_cols = mat2coldict(i) for k in A.D[0]: cols.append( triangular_solve([ mat2rowdict(A)[k] for k in mat2rowdict(A) ], list(range(len(A.D[0]))), i_cols[k]) ) return coldict2mat(cols)
def find_triangular_matrix_inverse(A): """ input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True """ cd = list() label_list = list(mat2rowdict(A).keys()) rowlist = list(mat2rowdict(A).values()) for j in label_list: c = triangular_solve(rowlist, label_list, list2vec([1 if i == j else 0 for i in label_list])) cd.append(c) return coldict2mat(cd)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' from triangular import triangular_solve from matutil import mat2rowdict sol = [] rowlist = mat2rowdict(A) label_list = list(rowlist[0].D) for i in A.D[0]: sol = sol + [triangular_solve(rowlist,label_list,Vec(A.D[0],{i:1}))] return coldict2mat(sol)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' D = A.D[0] I = Mat((D,D), {(d,d):1 for d in D}) col_I = mat2coldict(I) rowdict_A = mat2rowdict(A) rowlist_A = dict2list(rowdict_A, list(D)) B = dict() for i in col_I.keys(): B[i] = triangular_solve(rowlist_A, list(D), col_I[i]) return coldict2mat(B)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' aa = [a for a in mat2rowdict(A).values()] dd = [d for d in A.D[0]] return coldict2mat([triangular_solve(aa, dd, i) for i in mat2coldict(identity(A.D[0], 1)).values()])
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' label_list = list(A.D[1]) rowlist = list(mat2rowdict(A).values()) return coldict2mat([triangular_solve(rowlist, label_list, Vec(A.D[1], {i:1})) for i in A.D[1]])
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' inverseColDict = dict() rowList = [val for val in mat2rowdict(A).values()] label_list = [d for d in A.D[0]] identVecList = [ val for val in mat2coldict(identity(A.D[0] , 1)).values()] for k in range(len(rowList)): inverseColDict[k] = triangular_solve(rowList, label_list, identVecList[k]) return coldict2mat(inverseColDict)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' counter = 0 resultantVec = Vec(A.D[0], {i : 0 for i in A.D[0]}) matrix = list() while counter < len(A.D[0]): resultantVec.f[list(A.D[0])[counter]] = 1 if counter > 0: resultantVec.f[list(A.D[0])[counter - 1]] = 0 matrix.append(triangular_solve(list(mat2rowdict(A).values()), list(A.D[1]), resultantVec)) counter += 1 return coldict2mat(matrix)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' rowlist = [v for _,v in mat2rowdict(A).items()] label_list = [label for label in A.D[0]] b = [[0 if j!= i else 1 for j in range(len(A.D[0]))] for i in range(len(A.D[1]))] veclist = {i: triangular_solve(rowlist, label_list, b[i]) for i in range(len(b))} return coldict2mat(veclist)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' label_list = list(A.D[1]) rowlist = list(mat2rowdict(A).values()) return coldict2mat([ triangular_solve(rowlist, label_list, Vec(A.D[1], {i: 1})) for i in A.D[1] ])
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' num_equations = len(A.D[0]) b_vecs = [Vec(A.D[0], {i: 1}) for i in range(num_equations)] inverse_cols = [ triangular_solve(mat2rowdict(A), list(A.D[1]), b_vecs[i]) for i in range(num_equations) ] return coldict2mat(inverse_cols)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' Q,R = factor(A) Qt = Q.transpose() Rx = Qt * b return triangular_solve(list(mat2rowdict(R).values()), sorted(R.D[1], key=repr), Rx)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' x = [] n = len(A.D[0]) rowlist = list(mat2rowdict(A).values()) for i in range(n): bi = list2vec([1 if i == j else 0 for j in range(n)]) x.append(triangular_solve(rowlist, range(n), bi)) return coldict2mat(x)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' from triangular import triangular_solve A_rows = list(mat2rowdict(A).values()) B = [] #initializing inverse matrix A_nrows = len(A.D[0]) A_rowspace = set(range(A_nrows)) for i in range(A_nrows): v = Vec(A_rowspace, {i: 1}) # corresponding col of I matrix b = triangular_solve(A_rows, range(A_nrows), v) B.append(b) #add to list of inverse matrix columns return coldict2mat(B)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' inverse_cols = [] dim = len(A.D[0]) for i in range(dim): b = Vec(set(range(dim)), {i:1}) inv_col = triangular_solve(list(mat2rowdict(A).values()), range(dim), b) inverse_cols.append(inv_col) return coldict2mat(inverse_cols)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' L = [] label_list = [] I = identity(A.D[0], 1) R = mat2rowdict(A) w = mat2rowdict(I) label_list.extend(range(len(R))) for k, v in w.items(): s = triangular_solve(R, label_list, v) L.append(s) return coldict2mat(L)
def find_triangular_matrix_inverse(A): ''' Supporting GF2 is not required. Input: - A: an upper triangular Mat with nonzero diagonal elements Output: - Mat that is the inverse of A Example: >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' rows = range(len(mat2rowdict(A))) b = mat2coldict(identity(A.D[0], 1)) rowlist = mat2rowdict(A) ret = list() for n in rows: ones = b[n] ret.append(triangular_solve(list(rowlist.values()), list(A.D[1]), ones)) return coldict2mat(ret)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' Q, R = factor(A) Qt = Q.transpose() Rx = Qt * b return triangular_solve(list(mat2rowdict(R).values()), sorted(R.D[1], key=repr), Rx)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' L=[] label_list = [] I = identity(A.D[0],1) R = mat2rowdict(A) w = mat2rowdict(I) label_list.extend(range(len(R))) for k,v in w.items(): s = triangular_solve(R, label_list, v) L.append(s) return coldict2mat(L)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' import QR from triangular import triangular_solve (Q, R) = QR.factor(A) Rlist = [mat2rowdict(R)[i] for i in R.D[0]] return triangular_solve(Rlist, sorted(A.D[1], key=repr), b * Q)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' Q, R = factor(A) c = Q.transpose()*b Rdict = mat2rowdict(R) Rrows = [Rdict[key] for key in Rdict] labels = sorted(A.D[1], key=repr) return triangular_solve(Rrows, labels, c)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' import QR from triangular import triangular_solve (Q,R) = QR.factor(A) Rlist = [mat2rowdict(R)[i] for i in R.D[0]] return triangular_solve(Rlist, sorted(A.D[1], key=repr), b*Q)
def find_triangular_matrix_inverse(A): ''' input: An upper triangular Mat, A, with nonzero diagonal elements output: Inverse of A >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]]) >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}) True ''' I_col_dict = {i:Vec(A.D[0],{i:1}) for i in A.D[1]} #def triangular_solve(rowlist, label_list, b): rowlist = list() label_list = list() from matutil import mat2rowdict rowdict = mat2rowdict(A) for key in rowdict.keys(): label_list.append(key) rowlist.append(rowdict[key]) B_coldict = dict() from triangular import triangular_solve for key in label_list: B_coldict[key] = triangular_solve(rowlist,label_list,I_col_dict[key]) return coldict2mat(B_coldict)
def QR_solve(A, b): ''' Input: - A: a Mat - b: a Vec Output: - vector x that minimizes norm(b - A*x) Example: >>> domain = ({'a','b','c'},{'A','B'}) >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2}) >>> Q, R = QR.factor(A) >>> b = Vec(domain[0], {'a': 1, 'b': -1}) >>> x = QR_solve(A, b) >>> result = A.transpose()*(b-A*x) >>> result * result < 1E-10 True ''' from triangular import triangular_solve from QR import factor from matutil import mat2rowdict Q, R = factor(A) c = Q.transpose() * b x = triangular_solve(list(mat2rowdict(R).values()), list(A.D[1]), c) return x
def QR_solve(A, b): Q, R = factor(A) R_rowlist = mat2rowdict(R) label_list = sorted(A.D[1], key=repr) return triangular_solve(R_rowlist, label_list, Q.transpose() * b)
def new_tria_solve(rowlist, b): collist = remove_irr_col(rowlist) new_rowlist = [ values for (keys, values) in mat2rowdict(coldict2mat(collist)).items() ] return triangular_solve(new_rowlist, list(new_rowlist[0].D), b)