def movesolvenumstoleftside(self,solvesideinput,constantsideinput,solvenum,firstrun=True): """ Returns to new expressions that are just as equal as the one you put in. Should have put the solvenum on the solveside (the first index in the return value) """ solvenumstring=solvenum.num if solvesideinput.contains(solvenumstring) and not constantsideinput.contains(solvenumstring): return [solvesideinput,constantsideinput] elif constantsideinput.contains(solvenumstring) and not solvesideinput.contains(solvenumstring): return [constantsideinput,solvesideinput] elif not constantsideinput.contains(solvenumstring) and not solvesideinput.contains(solvenumstring): return [constantsideinput,solvesideinput] solveside=solvesideinput.simplify(solvenum) constantside=constantsideinput.simplify(solvenum) if constantside.type()=="addition": # newconstantsideaddends=[] newsolvesideaddends=[solveside] for addend in constantside.addends: if addend.contains(solvenumstring): newsolvesideaddends.append( ent.maybeclass([ent.number(["-1"]),addend],ent.product) ) else: newconstantsideaddends.append(addend) newsolveside=ent.addition(newsolvesideaddends) newconstantside=ent.addition(newconstantsideaddends) return self.movesolvenumstoleftside(newsolveside,newconstantside,solvenum,False) elif constantside.type()=="product": newsolvedividors=[] newconstantsidefacts=[] for factor in constantside.factors: if factor.contains(solvenumstring): newsolvedividors.append(factor) else: newconstantsidefacts.append(factor) newsolveside=ent.division([solveside,ent.maybeclass(newsolvedividors,ent.product)]) newconstantside=ent.maybeclass(newconstantsidefacts,ent.product) return self.movesolvenumstoleftside(newsolveside,newconstantside,solvenum,False) elif constantside.type()=="division": num=constantside.numerator denom=constantside.denominator if num.contains(solvenumstring): newsolveside=ent.addition([solveside,ent.product([ent.number(["-1"]),constantside])]) newconstantside=ent.number(["0"]) elif denom.contains(solvenumstring): newsolveside=ent.product([denom,solveside]) newconstantside=num return self.movesolvenumstoleftside(newsolveside,newconstantside,solvenum,False) elif constantside.type()=="potens": root=constantside.root exponent=constantside.exponent newsolveside=ent.addition([solveside,ent.product([ent.number(["-1"]),constantside])]) newconstantside=ent.number(["0"]) return self.movesolvenumstoleftside(newsolveside,newconstantside,solvenum,False) elif constantside.type() in ["number","sine","cosine","tangent","arcsine","arccosine","arctangent","natlogarithm","comlogarithm","squareroot"]: newsolveside=ent.addition([solveside,ent.product([ent.number(["-1"]),constantside])]) newconstantside=ent.number(["0"]) return self.movesolvenumstoleftside(newsolveside,newconstantside,solvenum,False)
def solveproduct(self,solveside,constantside,solvenum): """ Is a solving method Will move constantfactors to the other side """ newsolvefactors=[] newconstdividors=[] for factor in solveside.factors: if factor.contains(solvenum.num): newsolvefactors.append(factor) else: newconstdividors.append(factor) returnsolveside=ent.maybeclass(newsolvefactors,ent.product) returnconstant=ent.division([constantside,ent.maybeclass(newconstdividors,ent.product)]) if len(newsolvefactors)!=1: return None return [[returnsolveside,returnconstant]]
def solveaddition(self,solveside,constantside,solvenum): """ The solving method if the solveside is an instance of addition will try to put terms on the constantside such that there's only one term with solvenum in it. If that fails, it will try to solve it as a polynomial (but that function is not finished) """ newaddends=[] newconstandsideaddends=[constantside] for addend in solveside.addends: if addend.contains(solvenum.num): newaddends.append(addend) else: newconstandsideaddends.append(ent.product([ent.number(["-1"]),addend])) returnsolveside=ent.maybeclass(newaddends,ent.addition) returnconstantside=ent.maybeclass(newconstandsideaddends,ent.addition) if len(newaddends)!=1: degrees=False ispol=True poladdends=[[ent.product([ent.number(["-1"]),returnconstantside]).simplify(solvenum),0]]# [coeff,potens] subvalue=False #the part that contains x for addend in newaddends: coeffadd=False if addend.type()=="product": for index,fact in enumerate(addend.factors): if fact.contains(solvenum.num): if coeffadd==False: if fact.type()=="potens": if fact.exponent.evaluable(True) and eval(fact.exponent.tostring().replace("^","**"))%1==0 and (subvalue==False or fact.root==subvalue) and coeffadd==False: subvalue=fact.root coeffadd=[addend.delfactor(index),int(eval(fact.exponent.tostring().replace("^","**")))] else: ispol=False break elif fact.type()=="product": #damned negative number if fact.factors[1].type()=="potens": exponent=fact.factors[1].exponent if exponent.evaluable(True) and eval(exponent.tostring().replace("^","**"))%1==0 and (subvalue==False or fact1.factors[1].root==subvalue) and coeffadd==False: subvalue=fact.factors[1].root coeffadd=[ent.product([ent.number(["-1"]),addend.delfactor(index)]),int(eval(exponent.tostring().replace("^","**")))] else: ispol=False break else: thisval=fact.factors[1] if coeffadd==False and (subvalue==False or thisval==subvalue): subvalue=thisval coeffadd[ent.product([ent.number(["-1"]),addend.delfactor(index)]),1] else: ispol=False break else: if coeffadd==False and (subvalue==False or subvalue==fact): subvalue=fact coeffadd=[addend.delfactor(index),1] else: ispol=False break else: ispol=False break elif addend.type()=="potens": if coeffadd==False and (addend.exponent.evaluable(True) and eval(addend.exponent.tostring().replace("^","**"))%1==0 and (subvalue==False or addend.root==subvalue)): subvalue=addend.root coeffadd=[ent.number(["1"]),int(eval(addend.exponent.tostring().replace("^","**")))] else: ispol=False break else: if coeffadd==False and (subvalue==False or addend==subvalue): subvalue=addend coeffadd=[ent.number(["1"]),1] else: ispol=False break if coeffadd!=False: poladdends.append(coeffadd) if subvalue==False or not ispol: return None polsolveresult=self.polsolve(poladdends) retvar=[] for solution in polsolveresult: retvar.append([subvalue,solution]) return retvar return [[returnsolveside,returnconstantside]]