def add_multiple_times_row_to_row(self, coefficient, row_to_add, row_to_be_added_to): row1 = self[row_to_add].normal_vector.times_scalar(coefficient) k1 = self[row_to_add].constant_term * coefficient row2 = self[row_to_be_added_to].normal_vector.plus(row1) k2 = self[row_to_be_added_to].constant_term k = k1 + k2 self[row_to_be_added_to] = Hyperplane(normal_vector=row2,constant_term=k)
def multiply_coefficient_and_row(self, coefficient, row): '''mulitply normal vector and constant term with coefficient''' n = self[row].normal_vector k = self[row].constant_term new_normal_vector = n.times_scalar(coefficient) new_constant_term = k * coefficient self[row] = Hyperplane(normal_vector=new_normal_vector, constant_term=new_constant_term)
def add_multiple_times_row_to_row(self, coefficient, row_to_add, row_to_be_added_to): recipient_plane = self[row_to_be_added_to] new_plane = _get_new_plane(coefficient, self[row_to_add]) new_normal_vector = \ recipient_plane.normal_vector.plus(new_plane.normal_vector) constant_term = new_plane.constant_term + recipient_plane.constant_term self[row_to_be_added_to] = Hyperplane(normal_vector=new_normal_vector, constant_term=constant_term)
def add_multiple_times_row_to_row(self, coefficient, row_to_add, row_to_add_to): c = coefficient rta = row_to_add rtat = row_to_add_to temp_constant = self[rta].constant_term * c temp_vector = Vector(self[rta].normal_vector.scalar_mult(c)) self[rtat] = Hyperplane(Vector(temp_vector.plus(self[rtat].normal_vector)),\ self[rtat].constant_term + temp_constant) return
def add_multiple_times_row_to_row(self, coefficient, row_to_add, row_to_be_added_to): n1 = self[row_to_add].normal_vector k1 = self[row_to_add].constant_term n2 = self[row_to_be_added_to].normal_vector k2 = self[row_to_be_added_to].constant_term new_normal_vector = n1.times_scalar(coefficient).plus(n2) new_constant_term = k1 * coefficient + k2 self[row_to_be_added_to] = Hyperplane(normal_vector=new_normal_vector, constant_term=new_constant_term)
def add_multiple_times_row_to_row(self, coefficient, from_here, to_here): '''add multiple times from_here row to_here row''' n1 = self[from_here].normal_vector n2 = self[to_here].normal_vector k1 = self[from_here].constant_term k2 = self[to_here].constant_term new_normal_vector = n1.times_scalar(coefficient).plus(n2) new_constant_term = (k1 * coefficient) + k2 self[to_here] = Hyperplane(normal_vector=new_normal_vector, constant_term=new_constant_term)
def multiply_coefficient_and_row(self, coefficient, row): # Notice that I make a new plane object here instead of just altering the normal_vector and constant_term of the current plane. # If I had altered the existing plane, I need to reset the plane's # base_point or else I would introduce some subtle bugs. n = self[row].normal_vector k = self[row].constant_term new_normal_vector = n.times_scalar(coefficient) new_constant_term = k * coefficient self[row] = Hyperplane(normal_vector=new_normal_vector, constant_term=new_constant_term)
def add_multiple_times_row_to_row(self, coofficient, row_to_add, row_to_be_add_to): try: receipt_row = self[row_to_be_add_to] new_plane = self.multiply_coefficient_and_row( coofficient, row_to_add) new_normal_vector = receipt_row.normal_vector.plus( new_plane.normal_vector) new_contant_term = receipt_row.contant_term + new_plane.contant_term self[row_to_be_add_to] = Hyperplane( normal_vector=new_normal_vector, contant_term=new_contant_term) except Exception as e: return str(e)
self.direction_vectors = direction_vectors self.dimension = self.basepoint.dimension try: for v in direction_vectors: assert v.dimension == self.dimension except AssertionError: raise Exception(self.BASEPT_AND_DIR_VECTORS_MUST_BE_IN_SAME_DIM) def __str__(self): output = '' for coord in range(self.dimension): output += 'x_{} = {} '.format(coord + 1, round(self.basepoint[coord], 3)) for free_var, vector in enumerate(self.direction_vectors): output += '+ {} t_{}'.format(round(vector[coord], 3), free_var + 1) output += '\n' return output p1 = Hyperplane(normal_vector=Vector(['0.786', '0.786', '8.123', '1.111', '-8.363']), constant_term='-9.955') p2 = Hyperplane(normal_vector=Vector(['0.131', '-0.131', '7.05', '-2.813', '1.19']), constant_term='-1.991') p3 = Hyperplane(normal_vector=Vector(['9.015', '-5.873', '-1.105', '2.013', '-2.802']), constant_term='-3.982') system = LinearSystem([p1, p2, p3]) print (system.compute_solution())
def _get_new_plane(coofficient, plane): new_normal_vector = plane.normal_vector.times_scalar(coofficient) return Hyperplane(dimension=new_normal_vector.dimension, normal_vector=new_normal_vector, constant_term=Decimal(plane.constant_term) * Decimal(coofficient))
def _get_new_plane(coefficient, plane): new_normal_vector = plane.normal_vector.times_scalar(coefficient) return Hyperplane(normal_vector=new_normal_vector, constant_term=coefficient * plane.constant_term)
# p2 = Hyperplane(normal_vector=Vector(['-2.158','3.01','-1.727']), constant_term='-0.831') # # s2 = LinearSystem([p0,p1,p2]) # # print('System 2 Solution:\n{}'.format(s2.compute_solution())) # # p0 = Hyperplane(normal_vector=Vector(['0.935','1.76','-9.365']), constant_term='-9.955') # p1 = Hyperplane(normal_vector=Vector(['0.187','0.352','-1.873']), constant_term='-1.991') # p2 = Hyperplane(normal_vector=Vector(['0.374','0.704','-3.746']), constant_term='-3.982') # p3 = Hyperplane(normal_vector=Vector(['-0.561','-1.056','5.619']), constant_term='5.973') # # s3 = LinearSystem([p0,p1,p2,p3]) # # print('System 3 Solution:\n{}'.format(s3.compute_solution())) '''Extendint to Higher Dimensions''' p0 = Hyperplane(normal_vector=Vector([0.786, 0.786]), constant_term=-0.714) p1 = Hyperplane(normal_vector=Vector([-0.131, -0.131]), constant_term=0.319) s1 = LinearSystem([p0, p1]) print('System 1 Solution:\n{}'.format(s1.compute_solution())) p0 = Hyperplane(normal_vector=Vector(['2.102', '7.489', '-0.786']), constant_term='-5.113') p1 = Hyperplane(normal_vector=Vector(['-1.131', '-8.318', '1.209']), constant_term='-6.775') p2 = Hyperplane(normal_vector=Vector(['9.015', '-5.873', '1.105']), constant_term='-0.831') s2 = LinearSystem([p0, p1, p2])
p1 = Plane(normal_vector=Vector([8.631, 5.112, -1.816]), constant_term=-5.113) p2 = Plane(normal_vector=Vector([4.315, 11.132, -5.27]), constant_term=-6.775) p3 = Plane(normal_vector=Vector([-2.158, 3.01, -1.727]), constant_term=-0.831) s = LinearSystem([p1, p2, p3]) r = s.compute_rref() cs = s.compute_ge_solution() ps = s.compute_solution() print('Gauss Elim:') print(cs) print('RREF:') print(r) print('Parametrized:') print(ps) print() p1 = Hyperplane(normal_vector=Vector([5.262, 2.739, -9.878]), constant_term=-3.441) p2 = Hyperplane(normal_vector=Vector([5.111, 6.358, 7.638]), constant_term=-2.152) p3 = Hyperplane(normal_vector=Vector([2.016, -9.924, -1.367]), constant_term=-9.278) p4 = Hyperplane(normal_vector=Vector([2.167, -13.543, -18.883]), constant_term=-10.567) s = LinearSystem([p1, p2, p3, p4]) r = s.compute_rref() cs = s.compute_ge_solution() ps = s.compute_solution() print('Gauss Elim:') print(cs) print('RREF:') print(r) print('Parametrized:')
def solve(self): """ Solve the linear quation system. :return: None if there is no solution, a Vector object if there is exactly one solution, a Parametrization if there are indefinitely many solutions. """ # Compute the solution in form of rref: rref = self.compute_rref() print(rref) # 1. System is inconsistent if one row is 0 = k for k <> 0 for plane in rref.planes: try: Plane.first_nonzero_index(plane.normal_vector) except Exception as ex: if str(ex) == Plane.NO_NONZERO_ELTS_FOUND_MSG: k = MyDecimal(plane.constant_term) if not k.is_near_zero(): # row is 0 = k for k <> 0, so no solution return None else: raise ex # 2. Indefinite number of solutions, if number of pivot variables < dimension of solution set pivot_indices = rref.indices_of_first_nonzero_terms_in_each_row() num_pivots = sum([1 if index >= 0 else 0 for index in pivot_indices]) if num_pivots < rref.dimension: # Yes, indefinite number of solutions. # # First: Calculate the direction vectors of parametrized solution: # direction_vectors = [] # Calculate indices of free variables (those who are not pivot variables): free_var_indices = set(range(rref.dimension)) - set(pivot_indices) # for every free variable calulate a direction vector: for free_var_index in free_var_indices: # build an empty direction vector dir_vector_coords = [0] * rref.dimension # set coordinate of free variable to 1 dir_vector_coords[free_var_index] = 1 # set coordinates of pivot variables: for i, plane in enumerate(rref.planes): if pivot_indices[i] < 0: # this one is not a pivot variable -> goto next break # calculate direction vector coordinate for this variable: dir_vector_coords[pivot_indices[ i]] = -plane.normal_vector[free_var_index] # Add direction vector to : direction_vectors.append(Vector(dir_vector_coords)) # # Second: Calculate the base point of parametrized solution # base_point_coords = [0] * rref.dimension for i, plane in enumerate(rref.planes): if pivot_indices[i] < 0: break base_point_coords[pivot_indices[i]] = plane.constant_term base_point = Vector(base_point_coords) return Parametrization(base_point, direction_vectors) # 3. Consistent set has unique solution <=> each variable is a pivot variable solution_coords = [ rref.planes[row].constant_term for row in range(rref.dimension) ] return Vector(solution_coords)
from linearsys import LinearSystem, MyDecimal from vector_alt import Vector from hyperplane import Hyperplane p0 = Hyperplane(normal_vector=Vector([1,1,1]), constant_term = 1) p1 = Hyperplane(normal_vector=Vector([0,1,0]), constant_term = 2) p2 = Hyperplane(normal_vector=Vector([1,1,-1]), constant_term = 3) p3 = Hyperplane(normal_vector=Vector([1,0,-2]), constant_term = 2) s = LinearSystem([p0,p1,p2,p3]) print(s) print() #print('First non-zero index of each eqn:', s.indices_of_first_nonzero_terms_in_each_row()) #print() ##print('{}\n{}\n{}\n{}'.format(s[0],s[1],s[2],s[3])) print('# Equations:', len(s)) print() s[0] = p1 print(s) print() print(MyDecimal('1e-9').is_near_zero()) print(MyDecimal('1e-11').is_near_zero())
# print(s.indices_of_first_nonzero_terms_in_each_row()) # print('{},{},{},{}'.format(s[0], s[1], s[2], s[3])) # print(len(s)) # print(s) # s[0] = p1 # print(s) # print(MyDecimal('1e-9').is_near_zero()) # print(MyDecimal('1e-11').is_near_zero()) print('###########################') print('Quiz: Coding Row Operations') p0 = Hyperplane(normal_vector=Vector(['1', '1', '1']), constant_term='1') p1 = Hyperplane(normal_vector=Vector(['0', '1', '0']), constant_term='2') p2 = Hyperplane(normal_vector=Vector(['1', '1', '-1']), constant_term='3') p3 = Hyperplane(normal_vector=Vector(['1', '0', '-2']), constant_term='2') s = LinearSystem([p0, p1, p2, p3]) s.swap_rows(0, 1) if not (s[0] == p1 and s[1] == p0 and s[2] == p2 and s[3] == p3): print('test case 1 failed') s.swap_rows(1, 3) if not (s[0] == p1 and s[1] == p3 and s[2] == p2 and s[3] == p0): print('test case 2 failed') s.swap_rows(3, 1)
p1 = Plane(normal_vector=Vector([8.631, 5.112, -1.816]), constant_term=-5.113) p2 = Plane(normal_vector=Vector([4.315, 11.132, -5.27]), constant_term=-6.775) p3 = Plane(normal_vector=Vector([-2.158, 3.01, -1.727]), constant_term=-0.831) s = LinearSystem([p1, p2, p3]) r = s.compute_rref() cs = s.compute_ge_solution() ps = s.compute_solution() print('Gauss Elim:') print(cs) print('RREF:') print(r) print('Parametrized:') print(ps) print() p1 = Hyperplane(normal_vector=Vector([0.935, 1.76, -9.365]), constant_term=-9.955) p2 = Hyperplane(normal_vector=Vector([0.187, 0.352, -1.873]), constant_term=-1.991) p3 = Hyperplane(normal_vector=Vector([0.374, 0.704, -3.746]), constant_term=-3.982) p4 = Hyperplane(normal_vector=Vector([-0.561, -1.056, 5.619]), constant_term=5.973) s = LinearSystem([p1, p2, p3, p4]) r = s.compute_rref() cs = s.compute_ge_solution() ps = s.compute_solution() print('Gauss Elim:') print(cs) print('RREF:') print(r) print('Parametrized:')
t[3] == Hyperplane()): print 'test case 3 failed' p1 = Hyperplane(normal_vector=Vector(['0', '1', '1']), constant_term='1') p2 = Hyperplane(normal_vector=Vector(['1', '-1', '1']), constant_term='2') p3 = Hyperplane(normal_vector=Vector(['1', '2', '-5']), constant_term='3') s = LinearSystem([p1, p2, p3]) t = s.compute_triangular_form() if not (t[0] == Hyperplane(normal_vector=Vector(['1', '-1', '1']), constant_term='2') and t[1] == Hyperplane(normal_vector=Vector(['0', '1', '1']), constant_term='1') and t[2] == Hyperplane(normal_vector=Vector(['0', '0', '-9']), constant_term='-2')): print 'test case 4 failed' ''' # Test Cases - Gaussian Elimination Solution p1 = Hyperplane(normal_vector=Vector(['5.862', '1.178', '-10.366']), constant_term='-8.15') p2 = Hyperplane(normal_vector=Vector(['-2.931', '-0.589', '5.183']), constant_term='-4.075') s = LinearSystem([p1, p2]) solution = s.compute_solution() print "{}\nSolution: {} \n".format(s,solution) p1 = Hyperplane(normal_vector=Vector(['8.631', '5.112', '-1.816']), constant_term='-5.113') p2 = Hyperplane(normal_vector=Vector(['4.315', '11.132', '-5.27']), constant_term='-6.775') p3 = Hyperplane(normal_vector=Vector(['-2.158', '3.01', '-1.727']), constant_term='-0.831') s1 = LinearSystem([p1, p2, p3]) solution1 = s1.compute_solution() print "{}\n{} \n".format(s1,solution1) p1 = Hyperplane(normal_vector=Vector(['5.262', '2.739', '-9.878']), constant_term='-3.441') p2 = Hyperplane(normal_vector=Vector(['5.111', '6.358', '7.638']), constant_term='-2.152') p3 = Hyperplane(normal_vector=Vector(['2.016', '-9.924', '-1.367']), constant_term='-9.278')
# print (system.compute_solution()) # The systems bellow are just to test hyperplanes # p1 = Hyperplane(normal_vector=Vector([0.786, 0.786]), constant_term=0.786) # p2 = Hyperplane(normal_vector=Vector([-0.131, -0.131]), constant_term=-0.131) # system = LinearSystem([p1, p2]) # print (system.compute_solution()) # p1 = Hyperplane(normal_vector=Vector([2.102, 7.489, -0.786]), # constant_term=-5.113) # p2 = Hyperplane(normal_vector=Vector([-1.131, 8.318, -1.209]), # constant_term=-6.775) # p3 = Hyperplane(normal_vector=Vector([9.015, 5.873, -1.105]), # constant_term=-0.831) # system = LinearSystem([p1, p2, p3]) # print (system.compute_solution()) p1 = Hyperplane(normal_vector=Vector([0.786, 0.786, 8.123, 1.111, -8.363]), constant_term=-9.955) p2 = Hyperplane(normal_vector=Vector([0.131, -0.131, 7.05, -2.813, 1.19]), constant_term=-1.991) p3 = Hyperplane(normal_vector=Vector([9.015, -5.873, -1.105, 2.013, -2.802]), constant_term=-3.982) system = LinearSystem([p1, p2, p3]) print (system.compute_solution())
def multiply_coefficient_and_row(self, coefficient, row): c = coefficient constant_term = self[row].constant_term * c self[row] = Hyperplane(Vector(self[row].normal_vector.scalar_mult(c)), constant_term) return
def multiply_coefficient_and_row(self, coefficient, row): aux = self[row].normal_vector.times_scalar(coefficient) aux2 = self[row].constant_term * coefficient self[row] = Hyperplane(normal_vector=aux, constant_term=aux2)
from linearsys import LinearSystem from hyperplane import Hyperplane from vector_alt import Vector h1 = Hyperplane(normal_vector=Vector([0.786, 0.786]), constant_term=-0.714) h2 = Hyperplane(normal_vector=Vector([-0.131, -0.131]), constant_term=0.319) s = LinearSystem([h1, h2]) r = s.compute_rref() cs = s.compute_ge_solution() ps = s.compute_solution() print('2D Test') print('Gauss Elimination:') print(cs) print() print('Reduced Row Eschelon Form:') print(r) print() print('Parametrized:') print(ps) print() h1 = Hyperplane(normal_vector=Vector([2.102, 7.489, -0.786]), constant_term=-0.713555) h2 = Hyperplane(normal_vector=Vector([-1.131, -8.318, 1.209]), constant_term=0.118855) h3 = Hyperplane(normal_vector=Vector([9.015, -5.873, 1.105]), constant_term=0.221634) s = LinearSystem([h1, h2, h3]) r = s.compute_rref() cs = s.compute_ge_solution() ps = s.compute_solution()
p2 = Plane(Vector([4.315, 11.132, -5.27]), -6.775) p3 = Plane(Vector([-2.158, 3.01, -1.727]), -0.831) system = LinearSystem([p1, p2, p3]) print system.compute_solution() p1 = Plane(Vector([0.935, 1.76, -9.365]), -9.955) p2 = Plane(Vector([0.187, 0.352, -1.873]), -1.991) p3 = Plane(Vector([0.374, 0.704, -3.746]), -3.982) p4 = Plane(Vector([-0.561, -1.056, 5.619]), 5.973) print system.compute_solution() # The systems bellow are just to test hyperplanes p1 = Hyperplane(normal_vector=Vector([0.786, 0.786]), constant_term=0.786) p2 = Hyperplane(normal_vector=Vector([-0.131, -0.131]), constant_term=-0.131) system = LinearSystem([p1, p2]) print system.compute_solution() p1 = Hyperplane(normal_vector=Vector([2.102, 7.489, -0.786]), constant_term=-5.113) p2 = Hyperplane(normal_vector=Vector([-1.131, 8.318, -1.209]), constant_term=-6.775) p3 = Hyperplane(normal_vector=Vector([9.015, 5.873, -1.105]), constant_term=-0.831) system = LinearSystem([p1, p2, p3]) print system.compute_solution()