def practice(): #doesnt work print('Welcome to the chemical equation practice tool.') f = open('samples.txt', 'r') samples_list = [] print('Enter a number between 1 and 5 to fetch a problem to solve') sample_search = input() for row in f: (k, v) = row.split(':', 1) if k == sample_search: print(v) unbalanced = v print( 'Try to balance this equation. Your answer\nshould look something like this\n2H2 + O2 = 2H2O ' ) attempt = input() equation = Equation(v) correct = equation.balance() if correct == attempt: print('Well done! That is the correct answer!') print( 'Would you like to try another problem? Enter 1 for yes 2 for no.' ) answer = input() if answer == '1': practice() if answer == 2: print('Thanks for practicing!') input() if equation != attempt: print( 'Oops... that isn\'t correct.. But heres the correct one...' ) print(correct) f.close()
def getModel(system): # check dependancy set_provided = set([equ[0] for equ in system]) set_needed = set(reduce(lambda x, y: x+y, [equ[1] for equ in system])) # dependancy checking is not needed. # if not set_needed <= set_provided: # print 'Needed value is not provided.' # return None # else: # print 'Dependancy test: pass.' # check valid rendered = [] for equ in system: e = Equation(dict(equ[2]), equ[3].replace(':', '_')) var = [ele.replace(':', '_') for ele in [equ[0]]+equ[1]+['t'] ] eval_dict = dict(zip(var, [0.]*len(var))) eval_dict['__builtins__'] = None print '='*20 try: testv = eval(e.render(), eval_dict, safe_dict) print 'Test pass:'******'\tValue(all 0):', testv rendered.append(e.render()) except Exception, exp: print 'Test error:', e.render() print '\t', exp return None, None
def set_table(self, X, Y, n): self.__X = copy.copy(X) self.__Y = copy.copy(Y) self.__n = n A_elems = [] B_elems = [] for k in range(n + 1): for i in range(n + 1): coef = 0 for x in X: coef += x**(k + i) A_elems.append(coef) b = 0 for x, y in zip(X, Y): b += y * x**k B_elems.append(b) A = Matrix(n + 1, elems=A_elems) B = Matrix(n + 1, 1, B_elems) self.A = A self.B = B eq = Equation(A, B) self.__a = eq.analytic_solution().to_list()
def __str__(self): if self.terms == {}: return "Dimensionless" dummyEquation = Equation() dummyEquation.terms = self.terms dummyEquation.coefficient = 1 return equationToString(dummyEquation)
def test_substituteEquation(self): equation1 = Equation(1,4.0,{2:-2.0,3:2.0}) equation2 = Equation(4,4.0,{1:-2.0,3:2.0}) self.assertTrue(equation2.substituteEquation(equation1)) self.assertEquals(equation2.basicVar,4) self.assertEquals(equation2.bValue,-4.0) self.assertEquals(equation2.rhsDict[2],4.0) self.assertEquals(equation2.rhsDict[3],-2.0) self.assertEquals(len(equation2.rhsDict.keys()),2)
def __init__(self, size=0, coefficients=0, points=[]): if coefficients == 0: self.coefficients = self.generateRandom(size) self.size = size else: self.coefficients = coefficients self.size = len(coefficients) self.equation = Equation(self.coefficients) self.points = points
def from_json(j): equations = list() for eq_j in j['equations']: equations.append(Equation.from_json(eq_j)) solution = dict() for var, eq_j in j['solution'].iteritems(): solution[Symbol(var)] = Equation.from_json(eq_j) return Template(equations, solution)
def test_equation_cancellation_is_applicable(self): lhs = Parser(Tokenizer.tokenize('x + 4')).parse() rhs = Parser(Tokenizer.tokenize('y')).parse() equation = Equation(lhs, rhs) addition_cancellation = EquationCancellation(OperationType.PLUS(), OperationType.MINUS()) self.assertTrue(addition_cancellation.is_applicable_to(equation)) flipped = equation.flip() self.assertFalse(addition_cancellation.is_applicable_to(flipped))
def test_addition(self): '''An addition operation should be valid 1 + 2 = 3 ''' # a = 1, b = 2, operator = addition self.fake_numbers = [1, 2, 0] eq = Equation(10, self.fakeRandom) self.assertTrue(eq.a is 1 and eq.b is 2 and eq.operator is 0) self.assertTrue(eq.validate(3))
def test_subtraction1(self): '''A subtraction operation should be valid 2-1 = 1 ''' # a = 2, b = 1, operator = subtraction self.fake_numbers = [2, 1, 1] eq = Equation(10, self.fakeRandom) self.assertTrue(eq.a is 2 and eq.b is 1 and eq.operator is 1) self.assertTrue(eq.validate(1))
def __build_func__(self): X = self.__X Y = self.__Y h = [X[i] - X[i - 1] for i in range(1, len(X))] A_elems = [2 * (h[0] + h[1]), h[1]] B_elems = [3 * ((Y[2] - Y[1]) / h[1] - (Y[1] - Y[0]) / h[0])] for i in range(2, len(h) - 1): A_elems.append(h[i - 1]) A_elems.append(2 * (h[i - 1] + h[i])) A_elems.append(h[i]) B_elems.append(3 * ((Y[i + 1] - Y[i]) / h[i] - (Y[i] - Y[i - 1]) / h[i - 1])) A_elems.append(h[-2]) A_elems.append(2 * (h[-2] + h[-1])) B_elems.append(3 * ((Y[-1] - Y[-2]) / h[-1] - (Y[-2] - Y[-3]) / h[-2])) triA = TriDiagonalMatrix(len(h) - 1, A_elems) B = Matrix(len(h) - 1, 1, B_elems) self.triA = triA self.B = B tri_equation = Equation(triA, B) tri_solution = tri_equation.sweep_method() a = Y[:-1] c = [0] c.extend(tri_solution.to_list()) b = [] d = [] for i in range(len(h) - 1): b.append((Y[i + 1] - Y[i]) / h[i] - 1 / 3 * h[i] * (c[i + 1] + 2 * c[i])) d.append((c[i + 1] - c[i]) / 3 / h[i]) b.append((Y[-1] - Y[-2]) / h[-1] - 2 / 3 * h[-1] * c[-1]) d.append(-c[-1] / 3 / h[-1]) self.__a = a self.__b = b self.__c = c self.__d = d
def test_subtraction2(self): '''Subtraction should always be positive When the first random number generated is smaller than the second during a subtraction, the results should remain positive by swapping the two operands. ''' # a = 1, b = 2, operator = subtraction self.fake_numbers = [2, 1, 1] eq = Equation(10, self.fakeRandom) self.assertTrue(eq.a is 2 and eq.b is 1 and eq.operator is 1) self.assertTrue(eq.validate(1))
def getModel(system, dependancy_check=True): """ :system: the equation system. Get the ODE model to simulate from system. """ # check dependancy set_provided = set([equ[0] for equ in system]) set_needed = set(reduce(lambda x, y: x+y, [equ[1] for equ in system], [])) # dependancy checking is not needed. if dependancy_check: # the needed set is included in the provided set if not set_needed <= set_provided: auto = set_needed - set_provided for ele in list(auto): system.append([ele, [], [], '0']) # debug code # print 'needed:', set_needed # print 'provided:', set_provided # print 'Needed value is not provided.' # return None, 'Needed value is not provided.' # else: # print 'Dependancy test: pass.' # check valid rendered = [] for equ in system: # e is the Equation object e = Equation(dict(equ[2]), equ[3].replace(':', '_')) # all the variables var = [ele.replace(':', '_') for ele in [equ[0]]+equ[1]+['t'] ] # the look-up table of variables eval_dict = dict(zip(var, [0.]*len(var))) eval_dict['__builtins__'] = None try: # try to evaluate the formula testv = eval(e.render(), eval_dict, safe_dict) # print 'Test pass:'******'\tValue(all 0):', testv rendered.append(e.render()) except Exception, exp: print 'Test error:', equ msg = traceback.format_exc() #print '\t', exp.message print msg return None, msg, None
def parse_system(eqs): ''' Parse an array of lin dif eq, and create the corresponding n-dimensional equation X' = AX + O(E) ''' system_vars, system = [], {} for eq in eqs: e = parse_equation(eq) if e['var'] not in system_vars: system_vars.append(e['var']) for v in e['params']: if v not in system_vars: system_vars.append(v) system[e['var']] = e system_mat, system_error = [], [] for v in system_vars: eq_line = [] for p in system_vars: if p in system[v]['params']: eq_line.append(system[v]['params'][p]) else: eq_line.append(0) system_mat.append(eq_line) system_error.append(system[v]['error'].toList()) return Equation(np.transpose(np.array(system_vars)), np.array(system_mat), np.array(system_error))
def extract_template(self): parsed_equations = [ Equation.from_string(eq) for eq in self.labeled_example.equations ] self.template = Template.from_equations_and_nlp( parsed_equations, self.nlp) return self.template
def parse_equation(string): assert type(string) == str tokenized = Tokenizer.tokenize(string) if not(Parser.is_equation(tokenized)): raise ParserException('Input to parse_equation is not an equation: {}'.format(str(tokenized))) lhs = list() rhs = list() before_equals = True for token in tokenized: if before_equals: if token.token_type == TokenType.EQUALS: before_equals = False else: lhs.append(token) else: rhs.append(token) assert len(lhs) > 0 assert len(rhs) > 0 lhs = Parser(lhs).parse() rhs = Parser(rhs).parse() return Equation(lhs, rhs)
def ordered_question_list(lhs, rhs): """take the lhs and rhs and produce an ordered list of questions""" result = [] for l_n in lhs: for r_n in rhs: result.append(Equation(l_n, OPERATION, r_n)) return result
def generate_equation_2d(): terms = [] for i in range(4): for j in range(4): terms.append(Term(1, (i, j))) return Equation(*terms)
def __implicit(self, middle_coefs, A_borders, B_borders): Ut = self.__get_first_two_layaers() for k in range(2, self.n_t_steps): t = k * self.t_step sqr_x_step = self.x_step**2 A_coefs = A_borders[0] u_prev = Ut[-1] B_coefs = [B_borders[0](u_prev, t)] A_coefs += middle_coefs.A * (self.n_x_steps - 2) B_coefs += [ middle_coefs.B_functor(u_prev, Ut[-2], j) for j in range(1, self.n_x_steps - 1) ] A_coefs.extend(A_borders[1]) B_coefs.append(B_borders[1](u_prev, t)) A = TriDiagonalMatrix(self.n_x_steps, A_coefs) B = Matrix(self.n_x_steps, 1, elems=B_coefs) u_curr = Equation(A, B).sweep_method().to_list() Ut.append(u_curr) return Ut
def get_fn(l, var): eq = Equation() var = [""] + var for i in range(len(var)): if var[i] == "" and i != 0: continue eq += EqElement(-l[i].calc(), {var[i]: 1}) return eq
def main(argv): EquationString = Equation() print('__________________________________________') print(' ________ |\\\\ V0.1 DoctorDJO') print(' |License | | \\\\') print(' _____ |equation| | \\\\') print(' | | ((( .--. |________| |') print(' |DrDJO| ~OvO~ __ (////) | The only possibility of calcul is \'+\' and \'-\'.') print(' | | ( _ )|==| \\__/ | * is accepted but will apply an error or a power of.') print(' |o | \\_/ |_(| / \\ _______ |') print(' | | //|\\\\ \\\\//| |\\\\ |__o__| |') print(' | __|//\\_/\\\\ __\\/ |__|// |__o__| |') print(' | |==""//=\\\\""====|||||) |__o__| |') print('_|__||_|_||_||_____||||||____|__o__|_____ |') print(' || (_) (_) |||||| \\') print(' [] [(_)(_)') print('') if (len(argv) == 1): EquationString.String = input("Entrez une equation: ") # print (EquationString.String) elif (len(argv) == 2) : EquationString.String = argv[1] # print (EquationString.String) else : print("usage: python ./main.py") print(" python ./main.py [equation]") print(" python ./main.py [file.test]") return -1 if (EquationString.String[len(EquationString.String) - 1] == 't' and EquationString.String[len(EquationString.String) - 2] == 's' and EquationString.String[len(EquationString.String) - 3] == 'e' and EquationString.String[len(EquationString.String) - 4] == 't' and EquationString.String[len(EquationString.String) - 5] == '.'): path = EquationString.String try: with open(path) as end: for line in end: print(line.rstrip()) EquationString.String = line.rstrip() ParseString(EquationString) print("") except: print("Error: file not found!") else: ParseString(EquationString)
def _execute_step_if_new_input(self, equation): if self._last_input is None: return self._execute_step(equation) elif Equation.areEqual(self._last_input, equation): return self._execute_step(equation) else: return None
class Chromosome: UPPER_BOUND = 10 LOWER_BOUND = -10 def __init__(self, size=0, coefficients=0, points=[]): if coefficients == 0: self.coefficients = self.generateRandom(size) self.size = size else: self.coefficients = coefficients self.size = len(coefficients) self.equation = Equation(self.coefficients) self.points = points def fitness(self): n = len(self.points) sum = 0 for point in self.points: yCalc = self.equation.substituteX(point.x) sum += (yCalc - point.y)**2 return round(sum / n, 6) def generateRandom(self, size): coefficients = [] for i in range(size): coefficients.append( round(random.uniform(self.LOWER_BOUND, self.UPPER_BOUND), 6)) return coefficients def crossOver(self, parent): intHalfLength = int(random.random() * self.size) + 1 childOne = Chromosome( coefficients=parent.coefficients[0:intHalfLength] + self.coefficients[intHalfLength - 1:]) childTwo = Chromosome(coefficients=self.coefficients[0:intHalfLength] + parent.coefficients[intHalfLength - 1:]) childOne.points = self.points childTwo.points = self.points return childOne, childTwo def mutate(self, rate=0.5): if (random.random() < rate): randomIndex = int(random.randrange(self.size)) gene = self.coefficients[randomIndex] rand = random.random() deltaLower = gene - self.LOWER_BOUND deltaUpper = self.UPPER_BOUND - gene delta = deltaLower if rand <= 0.5 else deltaUpper rand = random.random() * delta newGene = gene - rand if delta == deltaLower else gene + rand self.coefficients[randomIndex] = round(newGene, 6) def __str__(self): return ",".join(str(x) for x in self.coefficients) def __eq__(self, other): return self.fitness() == other.fitness()
def apply(self, equation): assert isinstance(equation, Equation) assert self.is_applicable_to(equation) assert len(equation.lhs.arguments) == 2 operand = equation.lhs.arguments[1] lhs = equation.lhs.arguments[0] rhs = Operation(self._inverse_type, [equation.rhs, operand]) return Equation(lhs, rhs)
def __calc_next(self, u_prev, k, stage_k, A_coefs, calc_B, A_coefs_border, calc_B_border, order, exceptions): if order == 1: ordered = [self.N2, self.N1] h = self.h2 u_cur = [[] for _ in range(self.N1)] elif order == 2: ordered = [self.N1, self.N2] h = self.h1 u_cur = [] else: raise NotImplementedError shift = int(bool(exceptions)) for i in range(shift, ordered[0] - shift): A = list(A_coefs_border[0]) B = [calc_B_border[0](h * i, self.dt * stage_k)] for j in range(1, ordered[1] - 1): A.extend(A_coefs) B.append(calc_B(u_prev, i, j, k)) A.extend(A_coefs_border[1]) B.append(calc_B_border[1](h * i, self.dt * stage_k)) A = TriDiagonalMatrix(ordered[1], A) B = Matrix(ordered[1], 1, B) solution = Equation(A, B).sweep_method().to_list() if order == 1: for i, el in enumerate(solution): u_cur[i].append(el) else: u_cur.append(solution) if exceptions: if order == 1: for i, el in enumerate(u_cur): begin = exceptions[0](el, i, stage_k) end = exceptions[1](el, i, stage_k) el.insert(0, begin) el.append(end) else: begin = [] end = [] for j in range(len(u_cur[0])): begin.append(exceptions[0](u_cur[0], j, stage_k)) end.append(exceptions[1](u_cur[-1], j, stage_k)) u_cur.insert(0, begin) u_cur.append(end) return u_cur
def run_balance(): """ Runs the chemical equation balance algorithm """ print('=================================================') print( 'Introduce ecuacion quimica con elementos dentro de \nparentesis seguido por numero de atomos:' ) print('Ejemplo: (H)2 + (O)2 = (H)2(O)1') user_input = input('>>> ') try: equation = Equation(user_input) print('Ecuacion balanceada: ' + equation.balance()) sleep(3) run_balance() except IndexError: print('Input invalido...') sleep(3) run_balance()
def run_balance(): #prompts user to input a chemical equation and gives them correct format print('=================================================') print( 'Insert chemical equation with elements in parentheses followed by the number of atoms:' ) print('Example: (H)2 + (O)2 = (H)2(O)1') user_input = input('>>> ') #checks to see if the input matches the correct format and runs the balancing function try: equation = Equation(user_input) print('Balanced equation: ' + equation.balance()) sleep(3) run_balance() #if input is not correctly formated then it will return as invalid input and ask the player again except IndexError: print('Invalid input...') sleep(3) run_balance()
def run_balance(): """ Runs the chemical equation balance algorithm """ print('=================================================') print( 'Insert chemical equation with elements in\nparentheses followed by the number of atoms:' ) print('Example: (H)2 + (O)2 = (H)2(O)1') user_input = input('>>> ') try: equation = Equation(user_input) print('Balanced equation: ' + equation.balance()) sleep(3) run_balance() except IndexError: print('Invalid input...') sleep(3) run_balance()
async def stoichiometry(self, ctx, element, unknown_element, known_mass: float, mmA: float, mmB: float, *, eq): equation = Equation(eq) balanced_equation = equation.balance() split = balanced_equation.split(' = ') left = split[0] right = split[1] left_components = left.split(' + ') right_components = right.split(' + ') left_coefs = {} right_coefs = {} lis = [] lis2 = [] u = 0 u2 = 0 p = lambda x: enumerate(x) o = list(p(left_components)) o2 = list(p(right_components)) for i in range(len(o)): lis.append(o[u][0]) u += 1 for i in range(len(o2)): lis2.append(o[u2][0]) u2 += 1 for x in lis: if x >= 0: left_coefs[left_components[x][1:len(left_components[x]) + 1]] = left_components[x][0] for x2 in lis2: if x2 >= 0: right_coefs[right_components[x2][1:len(right_components[x2]) + 1]] = right_components[x2][0] if element in left_coefs.keys(): coefA = int(left_coefs[element]) elif element in right_coefs.keys(): coefA = int(right_coefs[element]) else: await ctx.send(left_coefs) if unknown_element in left_coefs.keys(): coefB = int(left_coefs[unknown_element]) elif unknown_element + " " in right_coefs.keys(): coefB = int(right_coefs[unknown_element + ' ']) else: await ctx.send(right_coefs) # Calculation mass_to_mass = (known_mass * coefB) * (mmB) / (mmA * coefA) await ctx.send(f'{round(mass_to_mass, 2)} grams of {unknown_element}')
def test_equation(self): two = Operation(OperationType.POSITIVE(), [Variable(2)]) negative_x = Operation(OperationType.NEGATIVE(), [Variable('x')]) lhs = Operation(OperationType.TIMES(), [two, negative_x]) rhs = Variable(3.1415) eq = Equation(lhs, rhs) verify(str(eq), self.reporter)
def __init__(self, mesh, unit_length): self.mesh = mesh self.unit_length = unit_length self.S1 = df.FunctionSpace(mesh, "CG", 1) self.S3 = df.VectorFunctionSpace(mesh, "CG", 1, dim=3) self.alpha = Field(self.S1, name="alpha") self.dmdt = Field(self.S3, name="dmdt") self.H = Field(self.S3, name="H") # TODO: connect effective field to H self.m = Field(self.S3, name="m") self.Ms = Field(self.S1, name="Ms") self.pins = [] # TODO: connect pins to instant code self.effective_field = EffectiveField(self.m, self.Ms, self.unit_length) self.eq = Equation(self.m.as_vector(), self.H.as_vector(), self.dmdt.as_vector()) self.eq.set_alpha(self.alpha.as_vector()) self.eq.set_gamma(consts.gamma) self.eq.set_saturation_magnetisation(self.Ms.as_vector())
def test_equation_cancellation(self): lhs = Parser(Tokenizer.tokenize('x * 4')).parse() rhs = Parser(Tokenizer.tokenize('y')).parse() equation = Equation(lhs, rhs) multiplication_cancellation = EquationCancellation( OperationType.TIMES(), OperationType.DIVIDE()) self.assertTrue(multiplication_cancellation.is_applicable_to(equation)) result = multiplication_cancellation.apply(equation) verify(str(result), self.reporter)
def test_equation_cancellation_with_negative(self): lhs = Parser(Tokenizer.tokenize('x + -4')).parse() rhs = Parser(Tokenizer.tokenize('y')).parse() equation = Equation(lhs, rhs) addition_cancellation = EquationCancellation(OperationType.PLUS(), OperationType.MINUS()) self.assertTrue(addition_cancellation.is_applicable_to(equation)) result = addition_cancellation.apply(equation) verify(str(result), self.reporter)
class TestEquation(unittest.TestCase): def setUp(self): # metoda ktora sluzy do inicjalizacji zmiennych self.eq_no_result=Equation(1,2,3) self.eq_one_result = Equation(1,2,1) self.eq_two_result = Equation(1,-2,-15) self.eq_zero_all = Equation(0,0,0) def testNoResult(self):#metoda do testowania czy nasza klasa dziala poprawnie jak nie ma wynikow wynik = self.eq_no_result.solve() self.assertEqual(wynik, None) def testOneResult(self):#metoda do tesotwania czy nasz klasa dziala poprawnie jak jest jedno rozwiaznaie wynik = self.eq_one_result.solve() self.assertEqual(wynik, -1) def testTwoResult(self):# wynik = self.eq_two_result.solve() self.assertEqual(wynik,(-3,5)) def testZeroArgs(self): self.assertEqual(True, True)
def solve_equ(input): input = re.sub(r'\s+', ' ', input) solution = 'Equation: {}\n'.format(input) input = re.sub(r'\s+', '', input) input = input.replace('+-', '-') input = input.replace('-+', '-') input = input.replace('--', '+') input = input.replace('++', '+') # Check the count of equal sign equals_count = input.count('=') if equals_count != 1: return 'Wrong format: found {} equal signs'.format(equals_count) # Simplify both terms of the equation equation = Equation(input) if not equation.check_terms(): return 'Wrong format: check that you properly formatted the equation' if not equation.get_reduced_form(): return ('Reduced form: 0 * X^0 = 0\n' + 'Polynomial degree: 0\n' + 'All real numbers are solution') solution += 'Reduced form: {}= 0\n'.format(equation.reduced_form) solution += 'Polynomial degree: {}\n'.format(equation.get_degree()) # Check degree if equation.degree > 2: return (re.sub(r'\.0 ', ' ', solution) + 'The polynomial degree is stricly greater than 2' + ', sorry I can\'t solve it.') elif equation.degree == 0: return re.sub(r'\.0 ', ' ', solution) + 'Equation is invalid' solution += equation.solve() return re.sub(r'\.0 ', ' ', solution)
def main(): # User input while True: try: a = int( input( 'What is the "a" value of your equation? (in standard form):\n' )) b = int(input('"b" value? (in standard form):\n')) c = int(input('"c" value? (in standard form):\n')) break except: pass # Equation class equation = Equation((a, b, c)) standard_form = equation.get_standard_form() vertex_form = equation.get_vertex_form() a, b, c = equation.values x1, x2 = equation.get_zeros() x, y = equation.get_vertex() print(""" [+] Standard Form = {}\n [+] Vertex Form = {}\n [+] 1st zero/root = {}\n [+] 2nd zero/root = {}\n [+] Vertex = {}\n [+] AOS: x = {}""".format(standard_form, vertex_form, x1, x2, (x, y), x)) graph(equation)
def test_exitVarRebalance(self): equation = Equation(1,4.0,{2:-2.0,3:2.0}) self.assertTrue(equation.exitVarRebalance(2)) self.assertEquals(equation.basicVar,2) self.assertEquals(equation.bValue,2.0) self.assertEquals(equation.rhsDict[1],-0.5) self.assertEquals(equation.rhsDict[3],1.0) self.assertFalse(equation.exitVarRebalance(2)) equation = Equation(4,0.0,{3:0.0,6:-1.0,2:1.0,7:3.0}) equation.exitVarRebalance(6) self.assertTrue(Equation.equals(equation,Equation(6,0.0,{3:0.0,4:-1.0,2:1.0,7:3.0})))
def main(): #Initialisation des variables hypothese = ['A','B','D'] systeme = [Equation(['A','B'], 'X'), Equation(['C','E','D'], 'F'),Equation(['X','D'], 'Z')] #Affichage de l'hypothèse initiale print('Hypothèse initiale: ' + str(hypothese)) #Pour chaque H de Hypothèses faire for h in hypothese: #Pour chaque equation E de S faire for e in systeme: #Si H appartient à premisse de E alors supprimer H de premisse de E fsi if h in e.premisse: e.premisse.remove(h) #Si vide(premisse de E) alors ajouter conclusion de E à Hypothese fsi if e.premisse == [] and e.conclusion not in hypothese: hypothese.append(e.conclusion) #Affichage de l'hypothèse finale print('Hypothèse finale: ' + str(hypothese))
def getter(self): from equation import Equation return Equation.by_ids(self.lib.equation_lib.values())
def test_valueOfEntryZeroCoeff(self): eq = Equation(6,0.0,{2:-1.0,4:0.0,5:-2.0,7:0.0}) self.assertIsNone(eq.valueOfEntry(4))
def setUp(self): # metoda ktora sluzy do inicjalizacji zmiennych self.eq_no_result=Equation(1,2,3) self.eq_one_result = Equation(1,2,1) self.eq_two_result = Equation(1,-2,-15) self.eq_zero_all = Equation(0,0,0)
def setUp(self): self.equation = Equation(1,4.6,{2:-5.7,3:5.7})
def test_equationEqualsTrue(self): self.assertTrue(Equation.equals(Equation(1,4.0,{2:-2.0,3:2.0}),Equation(1,4.0,{2:-2.0,3:2.0}))) self.assertTrue(Equation.equals(Equation(1,4.0,{3:2.0}),Equation(1,4.0,{3:2.0}))) self.assertTrue(Equation.equals(Equation(1,4.0,{4:0.0,3:2.0}),Equation(1,4.0,{3:2.0})))
def test_equationEqualsFalse(self): self.assertFalse(Equation.equals(Equation(1,4.0,{6:-2.0,3:2.0}),Equation(1,4.0,{2:-2.0,3:2.0}))) self.assertFalse(Equation.equals(Equation(1,4.0,{2:0.0,3:2.0}),Equation(1,4.0,{2:-2.0,3:2.0})))
class EquationTestCase(unittest.TestCase): def setUp(self): self.equation = Equation(1,4.6,{2:-5.7,3:5.7}) def test_equation(self): self.assertIsNotNone(self.equation) def test_copy(self): copyEquation= self.equation.copy() self.assertNotEquals(self.equation,copyEquation) def test_copyIntensive(self): copyEquation= self.equation.copy() self.assertEquals(self.equation.basicVar,copyEquation.basicVar) self.assertEquals(self.equation.bValue,copyEquation.bValue) self.assertEquals(self.equation.rhsDict,copyEquation.rhsDict) self.assertNotEquals(id(self.equation.rhsDict),id(copyEquation.rhsDict)) def test_valueOfEntry(self): equation = Equation(1,4.0,{2:-2.0,3:2.0}) self.assertEquals(equation.valueOfEntry(2),2.0) self.assertEquals(equation.valueOfEntry(3),-2.0) def test_valueOfEntryInvalidEntry(self): self.assertIsNone(self.equation.valueOfEntry(9)) def test_valueOfEntryZeroCoeff(self): eq = Equation(6,0.0,{2:-1.0,4:0.0,5:-2.0,7:0.0}) self.assertIsNone(eq.valueOfEntry(4)) def test_exitVarRebalanceInvalidIndex(self): self.assertFalse(self.equation.exitVarRebalance(103)) def test_exitVarRebalanceInvalidCoeff(self): self.equation.rhsDict[103] = 0.0 self.assertFalse(self.equation.exitVarRebalance(103)) def test_exitVarRebalance(self): equation = Equation(1,4.0,{2:-2.0,3:2.0}) self.assertTrue(equation.exitVarRebalance(2)) self.assertEquals(equation.basicVar,2) self.assertEquals(equation.bValue,2.0) self.assertEquals(equation.rhsDict[1],-0.5) self.assertEquals(equation.rhsDict[3],1.0) self.assertFalse(equation.exitVarRebalance(2)) equation = Equation(4,0.0,{3:0.0,6:-1.0,2:1.0,7:3.0}) equation.exitVarRebalance(6) self.assertTrue(Equation.equals(equation,Equation(6,0.0,{3:0.0,4:-1.0,2:1.0,7:3.0}))) def test_substituteEquationNone(self): self.assertFalse(self.equation.substituteEquation(None)) def test_substituteEquationZeroCoeff(self): equation1 = Equation(1,4.0,{2:-2.0,3:2.0}) equation2 = Equation(4,4.0,{1:0.0,3:2.0}) self.assertTrue(equation2.substituteEquation(equation1)) def test_substituteEquation(self): equation1 = Equation(1,4.0,{2:-2.0,3:2.0}) equation2 = Equation(4,4.0,{1:-2.0,3:2.0}) self.assertTrue(equation2.substituteEquation(equation1)) self.assertEquals(equation2.basicVar,4) self.assertEquals(equation2.bValue,-4.0) self.assertEquals(equation2.rhsDict[2],4.0) self.assertEquals(equation2.rhsDict[3],-2.0) self.assertEquals(len(equation2.rhsDict.keys()),2) def test_equationEqualsTrue(self): self.assertTrue(Equation.equals(Equation(1,4.0,{2:-2.0,3:2.0}),Equation(1,4.0,{2:-2.0,3:2.0}))) self.assertTrue(Equation.equals(Equation(1,4.0,{3:2.0}),Equation(1,4.0,{3:2.0}))) self.assertTrue(Equation.equals(Equation(1,4.0,{4:0.0,3:2.0}),Equation(1,4.0,{3:2.0}))) def test_equationEqualsFalse(self): self.assertFalse(Equation.equals(Equation(1,4.0,{6:-2.0,3:2.0}),Equation(1,4.0,{2:-2.0,3:2.0}))) self.assertFalse(Equation.equals(Equation(1,4.0,{2:0.0,3:2.0}),Equation(1,4.0,{2:-2.0,3:2.0})))
def test_substituteEquationZeroCoeff(self): equation1 = Equation(1,4.0,{2:-2.0,3:2.0}) equation2 = Equation(4,4.0,{1:0.0,3:2.0}) self.assertTrue(equation2.substituteEquation(equation1))
def test_valueOfEntry(self): equation = Equation(1,4.0,{2:-2.0,3:2.0}) self.assertEquals(equation.valueOfEntry(2),2.0) self.assertEquals(equation.valueOfEntry(3),-2.0)