From 36eadf8fbcfa2be63bfd59a958bf100909f19697 Mon Sep 17 00:00:00 2001 From: Aldo Tamariz Date: Mon, 12 Feb 2024 01:19:44 -0500 Subject: [PATCH] Add files via upload --- Libaldo/lib_Algorith.py | 2384 +++++++++++++++ Libaldo/lib_Exponencial.py | 1796 +++++++++++ Libaldo/lib_Mathbasic.py | 764 +++++ Libaldo/lib_Mathematica.py | 3520 +++++++++++++++++++++ Libaldo/lib_MyDiff.py | 2072 +++++++++++++ Libaldo/lib_MyEq.py | 5755 +++++++++++++++++++++++++++++++++++ Libaldo/lib_MyEqEq.py | 4009 ++++++++++++++++++++++++ Libaldo/lib_MyIntegral.py | 479 +++ Libaldo/lib_Physics.py | 2738 +++++++++++++++++ Libaldo/lib_Variables.py | 70 + Libaldo/lib_funcdiff.py | 76 + Libaldo/lib_tools.py | 2011 ++++++++++++ Libaldo/lib_toolsEq.py | 838 +++++ Libaldo/libaldo_algorith.py | 2373 +++++++++++++++ Libaldo/libaldo_math2.py | 3101 +++++++++++++++++++ Libaldo/mathbasic.py | 765 +++++ Libaldo/mathexponencial.py | 1104 +++++++ 17 files changed, 33855 insertions(+) create mode 100644 Libaldo/lib_Algorith.py create mode 100644 Libaldo/lib_Exponencial.py create mode 100644 Libaldo/lib_Mathbasic.py create mode 100644 Libaldo/lib_Mathematica.py create mode 100644 Libaldo/lib_MyDiff.py create mode 100644 Libaldo/lib_MyEq.py create mode 100644 Libaldo/lib_MyEqEq.py create mode 100644 Libaldo/lib_MyIntegral.py create mode 100644 Libaldo/lib_Physics.py create mode 100644 Libaldo/lib_Variables.py create mode 100644 Libaldo/lib_funcdiff.py create mode 100644 Libaldo/lib_tools.py create mode 100644 Libaldo/lib_toolsEq.py create mode 100644 Libaldo/libaldo_algorith.py create mode 100644 Libaldo/libaldo_math2.py create mode 100644 Libaldo/mathbasic.py create mode 100644 Libaldo/mathexponencial.py diff --git a/Libaldo/lib_Algorith.py b/Libaldo/lib_Algorith.py new file mode 100644 index 0000000..17d955a --- /dev/null +++ b/Libaldo/lib_Algorith.py @@ -0,0 +1,2384 @@ +from sympy import * + +from lib_Mathematica import * + + + + +k,x,t=symbols('k x t') +# Trandformacion de monimios and informacion Funciones +s,v,u,w=symbols('s v u w') + + +def diffsymbolprime(var): + svar=str(var) + dsvar1=svar+"'" + dsvar2=svar+"''" + kres= dsvar1+' '+dsvar2 + + return symbols(kres) + + + + +def exp_in(ksym): # retorna True si hay una funcion exp en ksym + # exp_in(4*exp(m)) return True + # exp_in(4*m) return False + sres=str(ksym) + if 'exp' in sres: + return True + return False + +def Is_Exp(ksym): + return exp_in(ksym=ksym) + +################################################ + + +def get_exp_Mono(ksym): # retorna la parte exp de un monomio + if exp_in(ksym): # get_exp_Mono(4*exp(x)) return exp(x) + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + for i in mm: + if exp_in(i): + return i + return ksym + +def get_Euler (ksym): + return get_cofac_exp(ksym=ksym) + +########################################## + +def get_cofac_exp(ksym): # retorna la parte no exp de un monomio + kexp=get_exp_Mono(ksym) # get_cofac_exp (4*exp(x)) return 4 + if kexp!=ksym: + return simplify(ksym/kexp) + return 1 + +def get_facEuler(ksym): + return get_cofac_exp(ksym=ksym) + +#################################### + + +def get_expoinexp(ksym): + kres=ksym + if exp_in(ksym): + mm=get_exp_Mono(ksym) + mm2=fpoly(mm,'list') + kres=mm2[0] + return kres + return 1 + +def get_expnEuler(ksym): + return get_expoinexp(ksym=ksym) + + +# LOG + +def log_in(ksym): # retorna True si hay una funcion log en ksym + # log_in(4*exp(m)) return False + sres=str(ksym) # log_in(log(4)*m) return True + if 'log' in sres: + return True + return False + +def get_log_Mono(ksym): # retorna la parte exp de un monomio + if log_in(ksym): # get_exp_Mono(4*exp(x)) return exp(x) + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + for i in mm: + if log_in(i): + return i + return ksym + +def get_cofac_log(ksym): # retorna la parte no exp de un monomio + kexp=get_log_Mono(ksym) # get_cofac_exp (4*exp(x)) return 4 + if kexp!=ksym: + return simplify(ksym/kexp) + return ksym + +def get_insidelog(ksym): # + kexp=get_log_Mono(ksym) # + return simplify(exp(kexp)) + +##################################### +# Monomie Tools +##################################### + +def monodata(*args): + r''' + data_mono(monomie, op1, op2) + inputs args: + op1=='isexp' ,return True if ksym is monomie whit exp factor + op1=='getexp' ,return only exp factor + op1=='getexpfac' ,return all factors less exp fac + + ''' + ksym=args[0] + if len(args)==2: + op1=args[1] + if len(args)==3: + op2=args[1] + + # Exp + if op1=='isexp': + return exp_in(ksym) + + elif op1=='getexp': + return get_exp_Mono(ksym) + elif op1=='getexpfac': + return get_cofac_exp(ksym) + elif op1=='getexpoinexp': + return get_expoinexp(ksym) + + # Log + if op1=='islog': + return log_in(ksym) + + elif op1=='getlog': + return get_log_Mono(ksym) + elif op1=='getlogfac': + return get_cofac_log(ksym) + elif op1=='getinlog': + return get_insidelog(ksym) + + +def clear_exp_QQ(ksym1,ksym2,vmain=k,var2=t): + p2=simplify(ksym2) + p1=simplify(ksym1) + if Is_Add(p2) and Is_Poly(p2): + mm=0 + mmexp=0 + for i in fpoly(p2,'list'): + if exp_in(i): + mmexp+=i + else: + mm+=i + p2=mmexp + p1=p1-mm + if Is_Mono(p2) and denom(p2)!=1: + kdeno=denom(p2) + p1=p1*kdeno + p2=simplify(p2*kdeno) + + mm=get_facEuler(p2) + if mm!=1: + p1=p1/mm + p2=simplify(p2/mm) + + + return (p1,p2) + +def getexponent(ksym): # return only exponente , not sqrt + + kres=ksym + ssym=str(ksym) + if 'sqrt' in ssym: + if 'sqrt'==ssym[0:4]: + nssym=between_par(ssym,'sqrt') + kres=parse_expr(nssym) + if Is_Pow(kres): + mm=fpoly(kres,'list') + return mm[1] + else: + return 1 + +''' +def getexpo(ksym): + return getexponent(ksym) + +def getbase(ksym): # return base from Pow monomie expresion + + input: x**a + return : x + + ksym=ksym*1 + if Is_Pow(ksym): + kres=ksym + ssym=str(ksym) + if 'sqrt' in ssym: + if 'sqrt'==ssym[0:4]: + nssym=between_par(ssym,'sqrt') + kres=parse_expr(nssym) + return getbase(kres) + + mm=fpoly(ksym,'list') + return mm[0] + + + else: + return ksym +''' +def partPow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + if Is_Root(expr): + p1,p2=expr.args + nP=numer(p2) + dP=denom(p2) + bb=p1 + ee=nP + rr=dP + if Is_Pow(bb): + ff=getexpo(p1) + bb=getbase(p1) + ee=ee*ff + else: + ee=getexpo(expr) + bb=getbase(expr) + rr=1 + else: + bb=expr + ee=1 + rr=1 + return bb,ee,rr + +def sqrt2pow(ksym): # convert sqrt(x**y) in x**(y/2) + + b1,e1,r1=partPow(ksym) + return kpow(b1,cfrac(e1,r1)) + +def root2pow(ksym): # convert sqrt(x**y) in x**(y/2) + + b1,e1,r1=partPow(ksym) + return kpow(b1,cfrac(e1,r1)) + +def pow2sqrt(ksym): # convert (x**(y/2)) in sqrt(x**y) + b1,e1,r1=partPow(ksym) + if r1==2: + return sqrt(kpow(b1,e1)) + else: + return ksym + + + b1,e1,r1=partPow(ksym) + return kpow(e1,cfrac(e1,1)) +def modulores(ksym,rr=2): # function use by reduceroot + b,ee,r1=partPow(ksym) + + if denom(ee)!=1: + nn=numer(ee) + dd=denom(ee) + p2=nn%rr + p1=int(nn/rr) + p3=cfrac(p2,dd) + return(b,p1,p3) + else: + nn=ee + dd=r1 + p2=nn%rr + p1=int(nn/rr) + p3=cfrac(p2,r1) + return(b,p1,p3) + +def reduceroot(ksym2,rr=2): + + P1=1 + P2=1 + ksym=kpow(ksym2,rr) + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + for i in mm: + if Is_Pow(i): + b,p1,p2=modulores(i,rr) + + P1=P1*kpow(b,p1) + P2=P2*kpow(b,p2) + else: + P2=P2*i + P3=rpow(P2,rr) + return Mul(P1, P3, evaluate=False) + else: + return ksym +def simplifyroot(ksym): + + ksym=1*ksym + if Is_Pow(ksym): + + kres= root2pow(ksym) + return kres + + elif Is_Add(ksym): + kres=0 + for i in fpoly(ksym,'list'): + kres+=simplifyroot(i) + return kres + elif Is_Mul(ksym): + kres=1 + for i in fpoly(ksym,'list'): + kres=kres*simplifyroot(i) + return kres + else: + return ksym + + +##################################### +# MyEqEq +##################################### + + + + + +##################################### +# str +##################################### +def fix_mulpar(sexp): + vec1='0123456789' + vec2='abcdefghijklmnopqrstuvwxyz' + vec3='ABCDEFGHIJKLMNOPQRSTUVWXYZ' + p1=sexp.find('(') + if p1==-1 or p1==0: + return sexp + elif sexp[p1-1] in vec1 or sexp[p1-1] in vec2 or sexp[p1-1] in vec3: + sexp=sexp[0:p1]+'*'+sexp[p1:len(sexp)] + return sexp + else: + return sexp +def between_par(sall,ssym=''): # between_par('***(12(**)3)***') return '12(**)3' + if ssym!='': + ssym=fix_mulpar(ssym) + mm=str(sall) + if ssym=='': + ssym='(' + q1=mm.find(ssym) + if q1==-1: + return '' + mm2=mm[q1::] + + q2=mm2.find('(') + mm3=mm2[q2::] + + cc=1 + sres='' + p=1 + i=1 + while cc>0: + v=mm3[i] + if v=='(': + cc+=1 + if v==')': + cc-=1 + if cc>0: + sres+=v + i+=1 + return parse_expr(sres) + +def between_func(ksym,sfunc): + ''' + input a function like + ksym=sqrt(y + 4)*sqrt((x - 2)**2) type: symbols o function + sfunc='sqrt(' type=str + return: + vec ['y + 4', '(x - 2)**2'] ,all inside sqrt(*****) in tihs case + + ''' + svar=str(ksym) + qq=svar.count(sfunc) + vecf=[] + posx=0 + for i in range(qq): + ff=between_par(svar,sfunc) + vecf.append(ff) + posx=svar.find(sfunc) + svar=svar[posx+1::] + return vecf + +def fix_str_math_space(ssym): + ''' + input:'3*x*(y+1)' + return 3*x*(y + 1)' + ''' + + kres='' + cc=0 + for i in ssym: + if cc==0: + kres=kres+i + else: + if i=='+' or i=='-': + + if ssym[cc-1]!=' ': + kres+=' ' + kres+=i + if ssym[cc+1]!=' ': + kres+=' ' + else: + kres+=i + cc+=1 + return kres + +def sgetmonofactor(ksym,s1,op=''): + ''' + return valid math expresion when convert math expr in str(expr) + example: + A=x*y*(1+a)*sqrt(z+1)+20*z + sgetmonofactor(A,'x*y') return 'x*y*(1 + a)' + sgetmonofactor(A,'x*y','f') return 'x*y*(1 + a)*sqrt(z + 1)' + ''' + + if type(ksym)!=str: + smm=str(ksym) + else: + smm=ksym + smm=fix_str_math_space(smm) + done=True + pstar=False + if type(op)==int: + nsmm=smm[op::] + p1=nsmm.find(s1) + if p1==-1: + return ksym + p1=p1+op + else: + p1=smm.find(s1) + if p1==-1: + return ksym + sres=s1 + qq=len(s1) + cc=0 + i=p1+qq + while done: + vf=smm[i] + sres+=vf + if vf=='(': + cc+=1 + pstar=True + if vf==')': + cc+=-1 + if pstar and cc==0: + done=False + + i+=1 + if op!='' and type(op)==str: + if smm[i+1]!='': + sres=sgetmonofactor(ksym,sres) + + return sres +##################################### +# polynomie Tools +##################################### + +def getmonoexpr(ksym,sval,op=''): + ''' + return valid math expresion that include sval expr + example: + A=x*y*(1+a)*sqrt(z+1)+20*z + getmonoexpr(A,'x*y') return x*y*(1 + a) + getmonoexpr(A,'x*y','f') return x*y*(1+a)*sqrt(z+1) + ''' + skres=sgetmonofactor(ksym,sval,op=op) + try: + kres=parse_expr(skres) + return kres + except: + return ksym + + +# squaresum() +# ----------- +def squaresum(ksym,p1=0,p2=0): + ''' + sqauresum(ksym,p1=x,p2=1) + input : + ksym = initial function to trasform + p1,p2 = (p1+p2)**2 new formate to get convert + return: + (p1+p2)**2 + K ..such that (p1+p2)**2 + K = ksym + example: + the polynomie 4*x*x+8*x-6 tray transfor to (2*x+2)**2 +K + + squaresum(4*x*x+8*x-6,2*x,2) return (2*x + 2)**2 - 10 + ''' + + vec1=expand((p1+p2)**2) + vec2=ksym-vec1 + kres=kpow((p1+p2),2)+vec2 + return kres + + +def parcial_fraction(x,L,a,b,c,d): + r''' + input L/((a*x+b)*(c*x+d)) + + return A/(a*x+b) + B/(c*x+d) + ''' + A=L*a/(d*(a - c)) + B=-L*c/(d*(a - c)) + p1=(a*x+b) + p2=(a*x+b) + + kres=A/p1+B/p2 + return kres + +def par_frac(ksym,var=''): + r''' + FRACCION PARCIAL + input C/[A+B] + return if it possible C1/A + C2/A que es igula a C/[A+B] + ''' + + + kres=ksym + + if Is_Mono(kres) and Is_Mul(kres): + + p1=numer(kres) + done=False + if var!='': + X=symbols('X') + kres=ksym.subs(var,X) + done=True + + + p2=denom(kres) + + + mm= fpoly(p2,'list') + + qq=len(mm) + A1,A2=symbols('A1 A2') + f1=A1*mm[0] + f2=A2*mm[1] + kres2=simplify(expand(f1+f2)) + kres3=factorSec(kres2,X) + + A22=solve(parse_expr(between_par(str(kres3),'X*(')),A2)[0] + kres4=kres3.subs(A2,A22) + r1=solve(1-kres4,A1)[0] + r2=A22.subs(A1,r1) + dd1=mm[0] + dd2=mm[1] + + if done: + dd1=dd1.subs(X,var) + dd2=dd2.subs(X,var) + + fac1=p1*r1/dd1 + fac2=p1*r2/dd2 + return fac1+fac2 + + else: ksym + + +def real_subs(QQ,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + + vvar=fpoly(QQ,'free') + mvar=[] + for i in vvar: + nname=str(i) + nname=nname.replace('_','') + nvar=symbols(nname) + mvar.append(nvar) + + kres=QQ + sres=str(kres) + sres=sres.replace('_','') + kres=parse_expr(sres) + mkey=[] + vvalue=[] + for key, value in kwargs.items(): + mkey.append(key) + vvalue.append(value) + + kres=kres.subs(parse_expr(key),value) + for i,j in zip(mvar,vvar): + kres=kres.subs(i,j) + return (kres) + +def coef_list(*args ,size=''): # return coef list complete according max degree + ''' + ee=x*x*a+x*b+c + return [a,b,c] + + ''' + ksym=args[0] + var2=x + for i in args: + if type(i)==Symbol: + var2=i + vcoef=[] + if str(var2) not in str(ksym): + vcoef=[ksym] + else: + dd=degree(ksym,gen=var2) + + for i in range(1,dd+1): + pe=dd+1-i + xfac=var2**pe + + vcoef.append(ksym.coeff(xfac)) + kres=ksym.subs(var2,0) + vcoef.append(kres) + if size!='': + qq1=degree(expand(ksym),var2) + if size>qq1: + qq2=size-qq1 + vec2=[0]*qq2 + vcoef=vec2+vcoef + return vcoef + + if 'noncero' in args: + kres=[] + for i in vcoef: + if i!=0: + kres.append(i) + return kres + return vcoef + +def sortdegree(ksym,var2=x): + ''' + group polynomies respect main varible + ''' + if str(var2) not in str(ksym): + return ksym + mm=coef_list(ksym,var2) + kres=0 + qq=len(mm) + cc=qq-1 + for i in mm: + kres+=i*var2**cc + cc+=-1 + return kres + +def solve_compare_coef(*args): + ''' + input (Lista de coeficientes del poly1,Lista de coeficientes del poly2) + return solucion al comparar vlores + ejm: + vec1=[x1+3*x2,x2-2*x2] + vec2=[2,3] + devuelve la sol de x1 y x2 en x1+3*x2=1 y x2-2*x2=3 + opcion: + solve_compare_coef([x1+3*x2,x2-2*x2],[2,3],[x2,x1]) + ''' + Vec1=args[0] + Vec2=args[1] + Lv='' + if len(args)==3: + Lv=args[2] + vecQ=[] + Sv=0 + for i,j in zip(Vec1,Vec2): + vecQ.append(Eq(i,j)) + Sv+=i + if Lv=='': + Lv=get_symbols(Vec1) + solu=solve(vecQ,Lv) + try: + key,value=unpack(solu) + return value + except: + return solu +def max_degree(*args,gen=x): + ''' + input (x*x+x+1,x*8+,5) + output 2 + ''' + dmax=0 + if len(args)==1 and type(args[0])==list: + args=args[0] + for i in args: + k=degree(i,gen=gen) + if k>dmax: + dmax=k + return dmax +def algebra_compare_coef(*args,var2=x): + ''' + function that resuelve variables when compare 2 polinomies wits same grade and same coef + input= args: + function,or,symbols + gen= function with defaul gen=x + output: solution all variables possibles + + + ''' + p1='' + p2='' + vsym=[] + for i in args: + if Is_Symbol(i): + vsym.append(i) + else: + if p1=='': + p1=i + else: + p2=i + + + + ql1=coef_list(p1,var2=var2) + ql2=coef_list(p2,var2=var2) + qq=[] + for i,j in zip(ql1,ql2): + qq.append(i-j) + kres=solve(qq,vsym) + if type(kres)==dict: + kres= kunpakDic(kres) + nvar=kres[0] + nval=kres[1] + if type(kres)==list: + kres= kunpakDic(kres) + nvar=kres[0] + nval =kres[1] + + return nval + + + + +##################################### +# functions +##################################### +def subsnumber(ksym,val1,val2): # replace an integer number by symbol + kres=ksym + sres=str(kres) + sv1=str(val1) + sv2=str(val2) + sres=sres.replace(sv1,sv2) + kres2=parse_expr(sres) + return kres2 + +def func2symbol(ksym,y,x): + veri='('+str(x)+')' + sf=str(y) + if veri in sf: + nf=sf.replace(veri,'') + else: + nf=sf + oldf=nf+veri + sres=str(ksym) + sres=sres.replace(oldf,nf) + return parse_expr(sres) + +def unfog(expr,*args): + if type(expr)==MyEq: + expr=expr.ksym + svec=[] + vvec=[] + for i in args: + if type(i)==str: + svec.append(i) + else: + vvec.append(i) + kres=findFunc(expr,svec,vvec) + return kres +#def findFunc(f1,vecf,vecv): +def findFunc(f1,vecf,vecv): + ''' + f((x+1)**2)= 2*x*x+4*x+5 , f1= 2*x+3 + procces, x--> Add(1) -->['A'],[1] -->x+1 -->Pow(2) -->['A','P'],[1,2] --> + vecf = ['A','P'] ,Posibles...>add,'A',mul 'M',divide 'D',sqrt 'R',pow 'P' + vecv = ['A','P'] + findFunc(2*x*x+4*x+5,['A','P'],[1,2]) + + return f(x)= 2*x+3 + ''' + y,z=symbols('y z') + #Q=MyEqEq(y,f1) + xx=solve(y-f1,x) + if type(xx)==list: + xx=xx[0] + for i,j in zip(vecf,vecv): + if i=='R': + xx=sqrs(xx,j) + elif i=='M': + xx=xx*j + elif i=='D': + xx=xx/j + elif i=='P': + xx=xx**j + else: + xx+=j + yy=solve(z-xx,y) + if type(yy)==list: + yy=yy[0] + y=yy.subs(z,x) + + + return y + + + + +##################################### +# monomies tools +##################################### + +def baselist(ksym): # return list of all monomies in Monomie in Mul expr + ''' + input (x+a)**a*(y-2)**b*z**c + return [(x+a),(y-2),z] + ''' + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + vres=[] + for i in mm: + if Is_Pow(i): + vres.append(getbase(i)) + else: + vres.append(i) + return vres + else: + return ksym +def expolist(ksym): # return list of each exponents in Monomie from Mul expr + ''' + input (x+a)**a*(y-2)**b*z**c + return [(a,b,c] + ''' + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + vres=[] + for i in mm: + if Is_Pow(i): + vres.append(getexponent(i)) + else: + vres.append(1) + return vres + else: + return ksym + +def expandfracpart(expr,gen=x): + P1=numer(expr) + P2=denom(expr) + Ng=max_degree(P1,gen=gen) + Dg=max_degree(P2,gen=gen) + if Ng>Dg: + Q=quo(P1,P2,gen) + remain=rem(P1,P2,gen) + mm=[Q,remain/P2] + return mm + else: + return [0,expr] + + + +def powlist(expr): + if Is_Pow(expr): + b,ee,rr=partPow(expr) + mm=[] + for i in range(ee): + mm.append(b**(i+1)) + return mm + else: + return [expr] + +def factorlist3(expr): + ''' + input((x+1)(x-1)) + output[x+1,x-1] + ''' + expr=factor(expr) + + if Is_Pow(expr): + return powlist(expr) + else: + mm=fpoly(expr,'list') + kres=[] + for i in mm: + if Is_Mul(i): + mm1= fpoly(i,'list') + kres=kres+mm1 + elif Is_Pow(i): + kres=kres+ powlist(i) + else: + kres.append(i) + return kres +''' +def partialfraction(*args): # Return divition monimies in partial fraction + y1,y2,y3,y4,y5,y6,y7,y8,y9,y10=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10') + y11,y12,y13,y14,y15,y16=symbols('y11 y12 y13 y14 y15 y16') + fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] + expr=args[0] + if len(args)==2: + var=args[1] + else: + var=x + expr=factor(expr) + p1=numer(expr) + p2=denom(expr) + vec2=complete2partfrac(p2) + vec1=vec_daughter(vec2,fabr,gen=var) + P=0 + for i,j in zip(vec1,vec2): + P=P+cfrac(i,j) + P2=factor(P) + P3=numer(P2) + P4=expand(P3) + dg1=degree(p1,gen=var) + dg2=degree(P4,gen=var) + if dg1dg2: + vec1=coef_list(p1,var2=var) + vec2=coef_list(P4,size=dg1,var2=var) + else: + vec1=coef_list(p1,var2=var) + vec2=coef_list(P4,var2=var) + + vec3=[vec2[i]-vec1[i] for i in range(3)] + kres=solve(vec3) + svar,vval=ganswer(kres,'varname','value') + for i,j in zip(svar,vval): + P=P.subs(i,j) + return P +''' +def swaplist(klist): + qq=len(klist) + mm=[] + for i in range(qq): + mm.append(klist[qq-1-i]) + return mm + +##################################### +# polynomies tools +##################################### + +# simplifysum() +# ----------- +def simplifysum(pval): + ''' + return sum of each monomie of pval but uniformatin each one to get real sum + + + ''' + if Is_Add(pval): + mm=fpoly(pval,'list') + + kk=0 + for i in mm: + k1=simplify(i) + kk+=mulexp(k1) + return kk + else: + return pval + + +# linfactor() +# ----------- +def linfactor(ksym,kvar=''): + ''' + factorize() return personality factorization of Polynomie summ + example: + if kfunc = a*x*x+b*c*x*x+3*x + factorize(kfunc,x*x) + return : + x*x*(x+b*x)+3*x + + ''' + + p1=ksym + if kvar!='' and type(p1)==Add: + oldv=0 + newv=0 + kfac=kvar + mm=fpoly(p1,'list') + for i in mm: + vec=simplify(i/kfac) + if denom(vec)==1: + newv+=vec + else: + oldv+=i + kres=oldv+newv*kfac + return kres + else: + return ksym + + + + +def Area2funcXY(ee1, ee2, var=x, cota='', kope=''): + if type(ee1)==MyEq: + kres1=ee1.ksym + else: + kres1=ee1 + if type(ee2)==MyEq: + kres2=ee2.ksym + else: + kres2=ee2 + kres=solve(kres1-kres2,var) + if cota=='' and len(kres)==2: + segx=kres + else: + x1,x2=cota + segx=[x1] + for i in kres: + if i>x1 and i return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + kres=ksym + if Is_Number(ksym): + + return ksym + + + if Is_Div(ksym): + + p1=powexpand(numer(ksym)) + p2=powexpand(denom(ksym)) + + return p1/p2 + + + elif Is_Mul(ksym): + mm=fpoly(ksym,'list') + kres=1 + for i in mm: + kres=kres*powexpand(i,op=op) + + return kres + + elif type(ksym)==Pow: + mm=fpoly(ksym,'list') + val=mm[0] + vexp=mm[1] + if type(vexp)==Pow: + + return ksym + elif type(vexp)==Mul: + mm2=fpoly(vexp,'list') + if len(mm2)==2: + p1=mm2[0] + p2=mm2[1] + if op!='': + kres=(val**p2) + kres=kres**p1 + else: + kres=(val**p1) + kres=kres**p2 + return kres + + else: + return ksym + + + + elif Is_Add(ksym): + mm=fpoly(ksym,'list') + mmr=0 + for i in mm: + mmr+=powexpand(i,op=op) + return mmr + else: + return ksym + +def div2mulexp(ksym): + ''' + input ((a/b)**x ----> return(a**x)*(b**(-x)) + + ''' + if Is_Div(ksym): + p1=numer(ksym) + p2=denom(ksym) + kres=p1*simplify(p2**(-1)) + return kres + if Is_Pow(ksym): + mm=fpoly(ksym,'list') + vald=mm[0] + vale=mm[1] + if denom(vald)!='1': + p1=numer(vald) + p2=denom(vald) + kres=(p1**vale)*(p2**(-1*vale)) + return kres + else: + return ksym + if Is_Add(ksym): + kres=0 + mm=fpoly(ksym,'list') + for i in mm: + kres+=div2mulexp(i) + return kres + if Is_Mul(ksym): + kres=1 + mm=fpoly(ksym,'list') + for i in mm: + kres=kres*div2mulexp(i) + return kres + else: + return ksym + + + + +def reducePow(ksym): + kres= simplifyexp(mulexpo(div2mulexp(ksym))) + return simplifyexp(kres) +##################################### +# GDC MCM +##################################### + +def GCD(ee1,ee2): # returm GDC between ee1,ee2 Maximo Comun Divisor + b1=baselist(1*ee1) + b2=baselist(1*ee2) + e1=expolist(1*ee1) + e2=expolist(1*ee2) + kres=1 + for v1,ve1 in zip(b1,e1): + for v2,ve2 in zip(b2,e2): + if v2==v1: + if Is_Number(ve1) and Is_Number(ve2): + nexp=min(ve1,ve2) + kres=kres*v1**nexp + return kres + +def LCM(v1,v2): # returm GDC between ee1,ee2 Maximo Comun Divisor + ee1=1*v1 + ee2=1*v2 + b1=baselist(1*ee1) + b2=baselist(1*ee2) + e1=expolist(1*ee1) + e2=expolist(1*ee2) + bb=unionvec(b1,b2) + + kres=1 + for i in bb: + ex1=0 + ex2=0 + ee=[] + if i in b1 : + p1=getindex(i,b1) + ex1=e1[p1] + if i in b2 : + p2=getindex(i,b2) + ex2=e2[p2] + if ex1!=0: + ee.append(ex1) + if ex2!=0: + ee.append(ex2) + + ef=min(ee) + kres=kres*i**ef + return kres + + +def addexpand(expr): # converte in factor inside sum polinomies factor + if Is_Div(expr): + p1=addexpand(numer(expr)) + p2=addexpand(denom(expr)) + + return cfrac(p1,p2) + + elif Is_Pow(expr): + B,ee,rr=partPow(expr) + B=addexpand(B) + + return kpow(B,ee,rr) + + elif Is_Mul(expr): + mm=fpoly(expr,'list') + kres=1 + for i in mm: + kres=kres*addexpand(i) + + return kres + elif Is_Add(expr): + kres=factor(expr) + + return kres + else: + return expr + +########################################## +##### simplify Root !!!!!!!!! + +def lsimplify(expr): + if Is_Add(expr): + expr2=logcombine(expr) + if str(expr2)!=str(expr): + return expr2 + else: + mm=0 + for i in fpoly(expr,'list'): + mm=mm+lsimplify(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=lsimplify(p1) + P2=lsimplify(p2) + + return Div(P1,P2) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*lsimplify(i) + return mm + + else: + return expr + +def lcombine(expr): + if Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*lcombine(i) + return kres + if Is_Div(expr): + p1=numer(expr) + p2=denom(expr) + p1=unisymbols(lcombine(p1)) + p2=unisymbols(lcombine(p2)) + return unisymbols(Div(p1,p2)) + else: + return logcombine(unisymbols(expr),force=True) +def simplifyroot(expr): + if Is_Pow(expr): + B,ee,rr=partPow(expr) + if Is_Div(B): + p1=numer(B) + p2=denom(B) + P1=kpow(p1,ee,rr) + P2=kpow(p2,ee,rr) + + expr=cfrac(P1,P2) + expr=killroot(expr) + if Is_Mul(B) and not Is_Div(B): + kres=1 + mm=fpoly(B,'list') + for i in mm: + kres=kres*rpow(i**ee,rr) + expr=kres + expr=killroot(expr) + + + + A=0 + B,ee,rr=partPow(expr) + + if Is_Div(ee): + p2=denom(ee) + rr=rr*p2 + ee=numer(ee) + if Is_Pow(B): + B2,ee2,rr2=partPow(B) + + ee=ee*ee2 + rr=rr*rr2 + B=B2 + + + + if Is_Div(ee): + p2=denom(ee) + rr=rr*p2 + ee=numer(ee) + nM,nE=compdiv(ee,rr) + P1=kpow(B,nM) + P2=kpow(B,nE,rr) + if P1==1: + P3=P2 + elif P2==1: + P3=P1 + else: + P3=Mul(P1,P2,evaluate=False) + + return P3 + + +def compdiv(p1,p2): + R=p1%p2 + C=cfrac((p1-R),p2) + return(C,R) + + +def simplify_root_exp(expr): + if Is_Pow(expr): + B,ee,rr=partPow(expr) + if Is_Div(B): + + p1=numer(B) + p2=denom(B) + P1=rpow(p1**ee,rr) + P2=rpow(p2**ee,rr) + expr=cfrac(P1,P2) + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+simplify_root_exp(i) + return mm + elif Is_Div(expr): + p1=simplify_root_exp(numer(expr)) + p2=simplify_root_exp(denom(expr)) + return cfrac(p1,p2) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*simplify_root_exp(i) + return mm + else: + return simplifyroot(expr) + + + + + +def truetable (n): + if n < 1: + return [[]] + subtable = truetable(n-1) + return [ row + [v] for row in subtable for v in [0,1] ] + + +## PLOt + +from matplotlib.patches import Polygon +def Area2(self,*args,typos=-1,tsize=10): + var=self.var + done=False + ksolu=solve(self.ksym,var) + if len(ksolu)>0: + done=True + if len(args)==2: + x1=args[0] + x2=args[1] + x3=100 + X1=args[0] + X2=args[1] + elif len(args)==3: + x1=args[0] + x2=args[1] + x3=args[2] + X1=args[0] + X2=args[1] + else: + + ksolu=solve(self.ksym,var) + x1=min(ksolu) + X1=min(ksolu) + x2=max(ksolu) + X2=max(ksolu) + x3=100 + dx=(x2-x1)/10 + x1=x1-dx + x2=x2+dx + done=True + fac=(x2-x1)/x3 + X=[] + Y=[] + yvalor=self('value',var=fac) + + #for i in range(x3): + #valor=float(x1+fac*i) + #X.append(float(valor)) + #Yvalor=yvalor.subs(var,valor) + + #Y.append(float(Yvalor)) + allvar=[] + if done: + if len(ksolu)>0: + allvar=ksolu + if X1 not in allvar: + allvar.append(X1) + if X2 not in allvar: + allvar.append(X2) + ksolu=allvar + ksolu.sort() + X1=min(ksolu) + X2=max(ksolu) + fig, ax = plt.subplots() + ix,iy =funclist(self,X1,X2,100) + + + verts = [(X1,0),*zip(ix, iy),(X2,0)] + + poly = Polygon(verts, facecolor='0.9', edgecolor='0.5') + ax.add_patch(poly) + ax.grid(True, which='both') + ax.plot(ix, iy) + Lx=[x1,x2] + Ly=[0,0] + ymin,ymax=ax.get_ylim() + ax.plot(Lx, Ly,color='black') + if done: + + ysolu=funclist(self,ksolu) + + for i ,j in zip(ksolu,ysolu): + ax.plot([i,i],[j,0],linestyle='-.',color='black') + ax.plot([i],[j],'o',color='red') + tvec=textpos(ksolu,typos,tsize) + tex=f'${latex(Integral(self.primi,self.var))}$' + Yp=1 + for i in tvec: + tx,ty,tf=i + ty=ty*Yp + Yp=-1*Yp + ax.text(tx, ty, tex,fontsize=tf) + + + ax.grid(True, linestyle='-.') + ax.tick_params(labelcolor='r', labelsize='medium', width=3) + + plt.show() + return ksolu + + +def funclist(self,*args): + + if len(args)>1: + x1=args[0] + x2=args[1] + qq=50 + if len(args)>2: + qq=args[2] + xr=list(range(qq+1)) + fac=(x2-x1)/qq + xx=[x1+fac*i for i in xr] + else: + xx=args[0] + + kfunc=self.ksym + yy=[kfunc.subs(self.var,i) for i in xx] + if type(args[0])==list: + return yy + else: + return xx,yy + +def squarecomplete(expr,var): + ''' + input: + expr= x*x+2*x* + var=x + return: + (x+1)**2 -1 + ''' + + + expr=sortdegree(expr,var) + L1=coef_list(expr,var) + r=L1[2] + p1,p2=L1[0],L1[1] + done=False + if signo(p1)==-1: + L1=[-1*i for i in L1] + done=True + L1[2]=a + p1,p2=L1[0],L1[1] + + b=simplify(sqrt(p1)) + c=p2/(2*b) + + if done: + r2=r+c*c + return -1*(b*var+c)**2+r2 + else: + r2=r-c*c + return (b*var+c)**2+r2 + +def setpack(expr,**kwargs): + ''' + replace value of kwaargs in exprend return expr + ''' + doned=False + if "'" in str(expr): + doned=True + if not Is_Number(expr): + if doned: + expr=amperdiff2normaldiff(expr) + + svec,vvec=unpack(kwargs) + for i,j in zip(svec,vvec): + if doned: + expr=expr.replace(i,str(j)) + else: + expr=expr.subs(i,j) + + if doned: + expr=normaldiff2amperdiff(expr) + return expr + else: + return expr + +def amperdiff2normaldiff(expr): + sQ=str(expr) + vecvaldiff=['d2x','d2y','d2z','d2u','d2v','d2w','dx','dy','dz','du','dv','dw'] + vecvaldiffp=["x''","y''","z''","u''","v''","w''","x'","y'","z'","u'","v'","w'"] + for i,j in zip(vecvaldiff,vecvaldiffp): + sQ=sQ.replace(j,i) + + return sQ + +def normaldiff2amperdiff(expr): + sQ=parse_expr(expr) + vecvaldiff=['d2x','d2y','d2z','d2w','d2u','d2v','dx','dy','dz','dw','du','dv'] + vecvaldiffp=[d2x,d2y,d2z,d2w,d2u,d2v,dx,dy,dz,dw,du,dv] + for i,j in zip(vecvaldiff,vecvaldiffp): + sQ=sQ.subs(i,j) + + return sQ + +def normalizediff(expr,sf,var): + ''' + traduce sympy diff expressions to + MyEqEq diff mat expressions + ''' + B,C=symbols('B C') + t=symbols(var) + f=Function(sf)(t) + expr=expr.subs(f.diff(var),B) + expr=expr.subs(f,C) + f=symbols(sf) + df,d2f=diffsymbolprime(f) + dt,d2t=diffsymbolprime(t) + expr=expr.subs(C,f) + expr=expr.subs(B,df/dt) + x,y,z,u,v,w=symbols('x y z u v w') + mm=normaldiff2amperdiff(amperdiff2normaldiff(expr)) + return mm + +def conjugate(expr): + ''' + if expr=a+b return a-b + if expr=a-b return a+b + ''' + mm=expr.args + return (mm[1]-mm[0]) + +def squareadd2squaremul(expr): + '''' + input (x*x-y*y) + return (x+y)*(x-y) + ''' + var1,var2=expr.free_symbols + svar1=str(var1) + svar2=str(var2) + k1=symbols(svar1,positive=True) + k2=symbols(svar2,positive=True) + expr=expr.subs(var1,k1) + expr=expr.subs(var2,k2) + p1,p2= expr.args + p11=sqrt(p1) + p111=str(p11) + p111=p111.replace('I','1') + p11=parse_expr(p111) + done=False + if signo(p2)==-1: + done=True + p2=-1*p2 + p22=sqrt(p2) + p222=str(p22) + p222=p222.replace('I','1') + p22=parse_expr(p222) + sp1=str(p11) + sp2=str(p22) + sexpr="("+sp2+"+"+sp1+")*("+sp2+"-"+sp1+")" + kres=sympify(sexpr,evaluate=False) + return UnevaluatedExpr(kres) + + +def Divunevaluate(expr): + ''' + expr is a unevaluate expr + expr= a*b/b + Divunevaluate(expr) return a* + ''' + + expr2=expr.args[0] + kn=numer(expr2) + kn=sympify(str(kn)) + kd=denom(expr2) + kd=sympify(str(kd)) + nkn=1 + nkd=1 + if type(kn)==Mul: + nlist=kn.args + else: + nlist=[kn] + if type(kd)==Mul: + dlist=kd.args + else: + dlist=[kd] + for i in nlist: + if i not in dlist: + nkn=nkn*i + for i in dlist: + if i not in nlist: + nkd=nkd*i + return nkn/nkd + + + +def simplifyMul(p1,p2): + P1=p1 + P2=p2 + if Is_Mul(p1) and Is_Mul(p2): + P1=1 + P2=1 + mm1=p1.args + mm2=p2.args + for i in mm1: + if i not in mm2: + P1=P1*i + for j in mm2: + if j not in mm1: + P2=P2*j + + return P1,P2 + + +def simplifySum(p1,p2): + P1=p1 + P2=p2 + if Is_Add(p1) and Is_Add(p2): + P1=0 + P2=0 + mm1=p1.args + mm2=p2.args + for i in mm1: + if i not in mm2: + P1=P1+i + for j in mm2: + if j not in mm1: + P2=P2+j + + return P1,P2 + +def precross(expr): + if Is_Add(expr): + expr=factor(expr) + p1,p2=fraction(expr) + + elif Is_Div(expr): + p1,p2=fraction(expr) + elif Is_Pow(expr): + + bb=getbase(expr) + ee=getexpo(expr) + if Is_Div(bb): + p1,p2=fraction(bb) + p1=p1**ee + p2=p2**ee + else: + p1=expr + p2=1 + return p1,p2 + +def monodegree(obj,var=x): + expr= obj + if not str(var) in str(expr): + return 0 + else: + p=expr.subs(var,1) + p2=simplify(expr/p) + p3=getexpo(p2) + return p3 +def monocoef(obj,var=x): + expr= obj + p=expr.subs(var,1) + return p + +from operator import itemgetter +def infodegreemat(obj,var=x): + kres=[] + expr= obj + mm=expr.args + for i in mm: + coe=monocoef(i,var=var) + gra=monodegree(i,var=var) + kres.append([coe,gra,i]) + kres=sorted(kres, key=itemgetter(1), reverse=True) + vecc=[] + vecg=[] + vece=[] + for i in range(len(kres)): + vec=kres[i] + vecc.append(vec[0]) + vecg.append(vec[1]) + vece.append(vec[2]) + return vecc,vecg,vece + +def trinomio2squarebinomio(obj,var=x): + expr=obj + mm=expr.args + if len(mm)==3: + vecc,vecg,vece=infodegreemat(expr,var=var) + #if (vecg[0]+vecg[2])/2==vecg[1]: + ksigno=signo(vece[1]) + a=rsimplify(sqrt(vece[0])) + b=vece[1]/2/a + + ebin=(a+b)**2 + eebin=expand(ebin) + resto=simplify(eebin-vece[0]-vece[1]-vece[2]) + return ebin+resto + + else: + return expr + +def tri2squ(obj,var=x): + expr=obj + mm=expr.args + if len(mm)==3: + vecc,vecg,vece=infodegreemat(expr,var=var) + #if (vecg[0]+vecg[2])/2==vecg[1]: + ksigno=signo(vece[1]) + a=sqrt(vece[0]) + b=vece[1]/2/a + + ebin=(a+b)**2 + eebin=expand(ebin) + resto=simplify(eebin-vece[0]-vece[1]-vece[2]) + return ebin+resto + + else: + return expr + +def tri2bin(expr,sexpr,var=''): + if var=='': + var=self.var + nexpr=parse_expr(sexpr) + expr2=tri2squ(nexpr,var=var) + msexpr=str(expr) + kres=subsubs(expr,nexpr,expr2) + return kres + +def functiondiff(*args): + ''' + if Area= b*h/2 in function of time... + then A(t)=b(t)*h(t)/2... + input : functiondiff(expr, var, varF1, varF2,varF3...etc) + in this case: + A=functiondiff(A,t,A) = dA + R=functiondiff(b*h/2,t,b,h) = b*dh/2 + db*h/2 + + ''' + expr=args[0] + var=args[1] + if len(args)==2: + return diff(expr,var) + else: + v1=[] + for i in range(2,len(args)): + v1.append(args[i]) + v2=[] + cc=1 + for i in v1: + F='f'+str(i) + F=Function(str(i))(var) + v2.append(F) + cc=cc+1 + v3=[] + for i in v2: + v3.append(diff(i,var)) + v4=[] + for i in v3: + v4.append(str(i)) + v5=[] + for i in v1: + svar='d'+str(i) + svar=symbols(svar) + v5.append(svar) + + + for i,j in zip(v1,v2): + expr=expr.subs(i,j) + dexpr=diff(expr,var) + for i,j in zip(v3,v5): + dexpr=dexpr.subs(i,j) + for i,j in zip(v2,v1): + dexpr=dexpr.subs(i,j) + return dexpr \ No newline at end of file diff --git a/Libaldo/lib_Exponencial.py b/Libaldo/lib_Exponencial.py new file mode 100644 index 0000000..dfb176e --- /dev/null +++ b/Libaldo/lib_Exponencial.py @@ -0,0 +1,1796 @@ + + + +from sympy import * +from lib_Mathematica import * +from lib_Mathbasic import * +from lib_Algorith import * +## exponenciales functions... + +x,s,t,y=symbols('x s t y') +# ussefull variables to use in partial fracction algorith +y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10 y11 y12 y13 y14 y15 y16') +fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] + +### CORE +def sfunc2func(expr,kfunc): + ''' + args: + expr=math exprssion + kfunc= str,function name + return: + kfunc(expr) + ''' + sexpr=kfunc+'('+str(expr)+')' + expr2=eval(sexpr) + return expr2 + +def corefunc(expr,kfunc): + ''' + simplify loop of: + Is_Add + Is_Div + Is_Mul + ''' + + expr=unisymbols(expr) + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+sfunc2func(i,kfunc) + elif Is_Div(expr): + p1,p2=fraction(expr) + kres=Div(sfunc2func(p1,kfunc),sfunc2func(p2,kfunc)) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*sfunc2func(i,kfunc) + else: + kres=expr + return kres + +### End Core + + +def getexpo(expr,op=''): # return exponente in expr + if Is_Pow(expr): + mm=expr.args + return mm[1] + + else: + return 1 + +def getpow(expr): # return exponente in expr + ''' + expr = x**y, x*y + return y ,1 + ''' + if Is_Root(expr): + kres=insideroot(expr) + return getexpo(kres) + elif Is_Pow(expr): + ee=expr.args[1] + p1,p2=fraction(ee) + + return p1 + elif Is_Root(expr): + kres=insideroot(expr) + return getexpo(kres) + else: + return 1 + + +def getbase(expr): # return base in expr + ''' + expr = x**y,x*y + return x ,x*y + ''' + + if Is_Pow(expr): + ee=expr.args[0] + return ee + else: + return expr + +# ***Multifunc to Add Div and Mul**** +# ------------------------------ +def getroot(expr): + if Is_Root(expr): + mm=expr.args + kres=mm[1] + p1,p2=fraction(kres) + return p2 + + else: + return 1 + + +''' +def simplifyexpo(expr): # simplify each exponent in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+simplifyexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=simplifyexpo(p1) + P2=simplifyexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*simplifyexpo(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + ee=simplify(ee) + return bb**ee + else: + return expr +''' +def simplifyexpo(expr): # simplify each exponent in expr + kres=corefunc(expr,'simplifyexpo') + if Is_Pow(kres): + kres=getbase(kres)**simplify(getexpo(kres)) + return kres +''' +def expandexpo(expr): # simplify each exponent in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+expandexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=expandexpo(p1) + P2=expandexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*expandexpo(i) + return mm + elif Is_Pow(expr): + + bb=getbase(expr) + ee=getexpo(expr) + ee=expand(ee) + return ppow(bb,ee) + + else: + return expr +''' +def expandexpo(expr): # simplify each exponent in expr + kres=corefunc(expr,'expandexpo') + if Is_Pow(kres): + kres=getbase(kres)**expand(getexpo(kres)) + return kres +def expandexpoexpand(expr): # simplify each exponent in expr + kres=corefunc(expr,'expandexpo') + if Is_Pow(kres): + ee=getexpo(kres) + base=getbase(kres) + if Is_Pow(ee): + ee=expandexpo(ee) + kres= bb**ee + return kres +''' +def factorexpo(expr): + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+factorexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=factorexpo(p1) + P2=factorexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*factorexpo(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + ee=factor(ee) + return bb**ee + else: + return expr +''' +def factorexpo(expr): # simplify each exponent in expr + kres=corefunc(expr,'factorexpo') + if Is_Pow(kres): + kres=getbase(kres)**factor(getexpo(kres)) + return kres + +''' +def simplifybase(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+simplifybase(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=simplifybase(p1) + P2=simplifybase(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*simplifybase(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + bb=simplify(bb) + return bb**ee + else: + return expr +''' +def simplifybase(expr): # simplify each exponent in expr + kres=corefunc(expr,'simplifybase') + if Is_Pow(kres): + kres=getbase(kres)**simplify(getexpo(kres)) + return kres + + +''' +def expandbase(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+expandbase(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=expandbase(p1) + P2=expandbase(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*expandbase(i) + return mm + elif Is_Pow(expr): + return expand_power_base(expr) + else: + return expr +''' +def expandbase(expr): # simplify each exponent in expr + kres=corefunc(expr,'expandbase') + if Is_Pow(kres): + kres=expand(getbase(kres))**getexpo(kres) + return kres +''' +def factorbase(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+factorbase(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=factorbase(p1) + P2=factorbase(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*factorbase(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + bb=factor(bb) + return bb**ee + else: + return expr +''' +def factorbase(expr): # simplify each exponent in expr + kres=corefunc(expr,'factorbase') + if Is_Pow(kres): + kres=factor(getbase(kres))**getexpo(kres) + return kres + +def mulexpo(expr,force=False): # simplify each ecponet in expr + if Is_Symbol(expr): + return expr + if Is_Number(expr): + return expr + if Is_Root(expr): + rr=getroot(expr) + bb=insideroot(expr) + ee=getexpo(expr) + if Is_e(bb): + nee=bb.args[0] + if rr==1: + return exp(simplify(ee*nee)) + elif rr==2: + return sqrt(exp(simplify(ee*nee))) + else: + return Sqrt(exp(simplify(ee*nee)),rr) + + + + elif Is_Add(expr): + mm=0 + for i in expr.args: + mm=mm+mulexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=mulexpo(p1) + P2=mulexpo(p2) + return unisymbols(cfrac(P1,P2)) + elif Is_Mul(expr): + mm=1 + for i in expr.args: + mm=mm*mulexpo(i) + return mm + elif Is_Pow(expr): + if Is_PowPow(expr): + bb,ee=getbase(expr),getexpo(expr) + bb2,ee2=getbase(bb),getexpo(bb) + return bb2**(ee*ee2) + else: + bb=getbase(expr) + ee=getexpo(expr) + if Is_Mul(bb): + mm=bb.args + kres=1 + for i in mm: + if Is_Pow(i): + bi=getbase(i) + ei=getexpo(i) + kres=kres*bi**(ei*ee) + else: + kres=kres*i**ee + return kres + else: + bb2=mulexpo(bb) + ee2=mulexpo(ee) + return bb2**ee2 + else: + return expr + + + +def lexpand(expr,force=True): # simplify each exponent in expr + + if Is_Add(expr): + mm=0 + for i in expr.args: + mm=mm+lexpand(i) + expr=mm + expr=corefunc(expr,'lexpand') + if Is_Log(expr): + return expand_log(expr, force=True) + + else: + return expr + +def lmul2lpow(expr): + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+lmul2pow(expr) + return kres + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=lmul2pow(p1) + p2=lmul2pow(p2) + return cfrac(p1,p2) + elif Is_Mul(expr): + + if 'log' in str(expr): + ee=1 + vlog=1 + for i in fpoly(expr,'list'): + + if type(i)==log: + vlog=i.args[0] + else: + ee=ee*i + vlog=vlog**ee + return log(vlog) + else: + return expr + +# def lfactor(expr): # expand logaritm + # if Is_Add(expr): + # mm=0 + # for i in fpoly(expr,'list'): + # mm=mm+lfactor(i) + # return mm + # elif Is_Div(expr): + # p1,p2=fraction(expr) + # P1=lfactor(p1) + # P2=lfactor(p2) + # sP='('+str(P1)+')/('+str(P2)+')' + # return mirror_parse_expr(sP) + # elif Is_Mul(expr): + # mm=1 + # for i in fpoly(expr,'list'): + # mm=mm*lfactor(i) + # return mm + + # elif Is_Log(expr): + # return logcombine(expr, force=True) + + # else: + # return expr + +def lfactor(expr): + kres=corefunc(expr,'lexpand') + if Is_Log(kres): + return expand_log(expr, force=True) + + else: + return expr + +def lexponent(expr): + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+lexponent(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=lexponent(p1) + P2=lexponent(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*lexponent(i) + return mm + elif Is_Log(expr): + expr2=expr.args[0] + ee=getexpo(expr2) + bb=getbase(expr2) + + return ee*log(bb) + else: + return expr + +def lcombine(expr): + expr=logcombine(expr,force=True) + return expr + + + + + +def partPow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + if Is_Root(expr): + p1,p2=expr.args + nP=numer(p2) + dP=denom(p2) + bb=p1 + ee=nP + rr=dP + if Is_Pow(bb): + ff=getexpo(p1) + bb=getbase(p1) + ee=ee*ff + else: + ee=getexpo(expr) + bb=getbase(expr) + rr=1 + else: + bb=expr + ee=1 + rr=1 + return bb,ee,rr + +def partpow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + return getbase(expr),getexpo(expr) + else: + return expr,1 + + +def pow2powpow(*args): + expr=args[0] + ktype='out' + exp1='' + if len(args)==2: + exp1=args[1] + if len(args)==3: + ktype=args[2] + + + + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+pow2powpow(i,exp1) + return mm + elif Is_Div(expr): + return cfrac(pow2powpow(numer(expr),exp1),pow2powpow(denom(expr),exp1)) + elif Is_Mul(expr): + + mm=1 + for i in fpoly(expr,'list'): + mm=mm*pow2powpow(i,exp1) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + + if Is_Mul(ee): + + mm2=fpoly(ee,'list') + if exp1!='' and exp1 in mm2: + ee1=exp1 + ee2=simplify(ee/ee1) + if ktype!='out': + return((bb**ee2)**ee1) + else: + return((bb**ee1)**ee2) + else: + + ee1=mm2[0] + ee2=simplify(ee/ee1) + return((bb**ee1)**ee2) + else: + return expr + + else: + return expr + + +def powexpand(ksym,op=''): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + kres=ksym + if Is_Number(ksym): + + return ksym + + + if Is_Div(ksym): + + p1=powexpand(numer(ksym)) + p2=powexpand(denom(ksym)) + + return p1/p2 + + + elif Is_Mul(ksym): + mm=fpoly(ksym,'list') + kres=1 + for i in mm: + kres=kres*powexpand(i,op=op) + + return kres + + elif type(ksym)==Pow: + mm=fpoly(ksym,'list') + val=mm[0] + vexp=mm[1] + if type(vexp)==Pow: + + return ksym + elif type(vexp)==Mul: + mm2=fpoly(vexp,'list') + if len(mm2)==2: + p1=mm2[0] + p2=mm2[1] + if op!='': + kres=(val**p2) + kres=kres**p1 + else: + kres=(val**p1) + kres=kres**p2 + return kres + + else: + return ksym + + + + elif Is_Add(ksym): + mm=fpoly(ksym,'list') + mmr=0 + for i in mm: + mmr+=powexpand(i,op=op) + return mmr + else: + return ksym + + + +def powsimplifybase(ksym,combine='base'): + ''' + input (x**y*x**z*y**z ----> returnx**(x+y)*y**z + + ''' + expr=ksym + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+powsimp(i, combine='base', force=True) + return mm + if Is_Number(expr): + + return ksym + + + if fraction(expr)[0]==1: + + p1,p2==fraction(expr) + + + return powsimp(p1, combine='base', force=True)/powsimp(p2, combine='base', force=True) + + + elif Is_Mul(ksym): + mm=fpoly(ksym,'list') + kres=1 + for i in mm: + kres=kres*powsimp(p1, combine='base', force=True) + + return kres + + elif type(ksym)==Pow: + mm=fpoly(ksym,'list') + val=mm[0] + vexp=mm[1] + if type(vexp)==Pow: + + return ksym + elif type(vexp)==Mul: + mm2=fpoly(vexp,'list') + if len(mm2)==2: + p1=mm2[0] + p2=mm2[1] + if op!='': + kres=(val**p2) + kres=kres**p1 + else: + kres=(val**p1) + kres=kres**p2 + return kres + + else: + return ksym + + + + elif Is_Add(ksym): + mm=fpoly(ksym,'list') + mmr=0 + for i in mm: + mmr+=powexpand(i,op=op) + return mmr + else: + return ksym + +def div2mulexp(ksym): + ''' + input ((a/b)**x ----> return(a**x)*(b**(-x)) + + ''' + if Is_Div(ksym): + p1=numer(ksym) + p2=denom(ksym) + kres=p1*simplify(p2**(-1)) + return kres + if Is_Pow(ksym): + mm=fpoly(ksym,'list') + vald=mm[0] + vale=mm[1] + if denom(vald)!='1': + p1=numer(vald) + p2=denom(vald) + kres=(p1**vale)*(p2**(-1*vale)) + return kres + else: + return ksym + if Is_Add(ksym): + kres=0 + mm=fpoly(ksym,'list') + for i in mm: + kres+=div2mulexp(i) + return kres + if Is_Mul(ksym): + kres=1 + mm=fpoly(ksym,'list') + for i in mm: + kres=kres*div2mulexp(i) + return kres + else: + return ksym + +def joinbase(expr): + ''' + if expr= x**(a+b)*x(z) joinbase(expr)= x**(a+b+z) + ''' + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+joinbase(i) + return kres + elif Is_Mul(expr) and denom(expr)!=1: + + return simplify(expr) + elif Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb=joinbase(bb) + ee=joinbase(ee) + return ppow(bb,ee) + elif Is_Mul(expr): + kres=1 + mm=fpoly(expr,'list') + bb=[] + ee=[] + for i in mm: + bb1=getbase(i) + ee1=getexpo(i) + if bb1 not in bb: + bb.append(bb1) + ee.append(ee1) + else: + p1=bb.index(bb1) + nexp=ee[p1] + nexp=nexp+ee1 + ee[p1]=nexp + kres=1 + for i,j in zip(bb,ee): + kres=kres*ppow(i,j) + if kres==expr: + return powsimp(kres,force=True) + else: + return kres + else: + return expr + +def disjoinbase(expr): + return separebase(expr) + +def disjoinexpo(expr): + kres=corefunc(expr,'disjoinexpo') + if Is_Pow(expr): + base=getbase(expr) + ee=getexpo(expr) + ee2=disjoinbase(ee) + kres=base**ee2 + return kres + + +def expopos(expr): + if Is_e(expr): + mm=expr.args + sexp=mm[0] + if signo(sexp)==-1: + kres=parse_expr(str(1)+'/'+str(exp(-1*sexp)),evaluate=False) + obj=kres.args + return obj[1] + + bb,ee,rr=dataPow(expr) + if Is_Add(ee): + p1=1 + p2=1 + for i in ee.args: + if signo(i)==-1: + p2=p2*Sqrt(bb,rr,-1*i) + else: + p1=p1*Sqrt(bb,rr,i) + if p2!=1: + return parse_expr(str(p1)+'/('+str(p2)+')',evaluate=False) + else: + return p1 + elif Is_Mul(ee): + if signo(ee)==-1: + kres=parse_expr(str(1)+'/'+str(Sqrt(bb,rr,-1*ee)),evaluate=False) + obj=kres.args + + return obj[1] + + else: + return Sqrt(bb,rr,ee) + + else: + return expr +def sfactor(expr): + if Is_Root(expr): + bb,ee,rr=dataPow(expr) + if rr==2 and ee==1: + return parse_expr('sqrt('+str(sfactor(bb))+')',evaluate=False) + elif rr==2 and ee!=1: + return parse_expr('(sqrt('+str(sfactor(bb))+'))**'+str(ee),evaluate=False) + if Is_Add(expr): + return cleansumvec(expr) + + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=sfactor(p1) + p2=sfactor(p2) + return Div(p1/p2) + elif Is_Mul(expr): + + cc=1 + for i in expr.args: + if cc==1: + kres= str(sfactor(i)) + cc=cc+1 + else: + kres= kres+'*'+str(sfactor(i)) + + return parse_expr(kres,evaluate=False) + elif Is_Root(expr): + BB=insideroot(expr) + bb=getbase(BB) + ee=getexpo(BB) + rr=getroot(expr) + nbb=sfactor(bb) + try: + return Sqrt(nbb,rr,ee) + except: + return expr + else: + return expr +def positivexpo(expr): + if type(expr)==Symbol: + return expr + elif Is_Number(expr): + return expr + + if Is_Root(expr): + + bb,ee,rr=dataPow(expr) + if Is_Mul(bb): + bb=cleanMul(positivexpo(bb)) + return Sqrt(positivexpo(bb),rr,ee) + elif Is_e(expr): + return cleanMul(expopos(expr)) + + elif Is_Add(expr): + + mm=0 + for i in expr.args: + mm=mm+cleanMul(positivexpo(i)) + return mm + + elif Is_Div(expr): + + nn=numer(expr) + dd=denom(expr) + + return parse_expr(str(nn)+'/('+str(dd)+')',evaluate=False) + + elif Is_Mul(expr): + + kres=1 + for i in expr.args: + kres=kres*cleanMul(positivexpo(i)) + return cleanMul(kres) + + elif Is_Pow(expr): + return expopos(expr) + + else: + return expr +def cleanMul(expr): + mm=expr.args + if len(mm)==2 and mm[0]==1: + return mm[1] + else: + return expr +def cleansumvec(expr): + vec=expr.args + k=1 + for i in vec: + k=k*denom(i) + kk=sum(Array([simplify(i*k) for i in vec])) + return parse_expr('('+str(kk)+')'+'/'+str(k),evaluate=False) + +def Is_e(ksym): + if type(ksym)==exp: + return True + else: + return False +def separebase(expr): + ''' + if expr= x**(a*z) expandbasepow(expr)= x**a*x**z + ''' + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+separebase(i) + return kres + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=separebase(p1) + P2=separebase(p2) + return cfrac(P1,P2) + + elif Is_Mul(expr): + kres=1 + for i in expr.args: + if Is_Pow(i): + kres=kres*separebase(i) + else: + kres=kres*i + return kres + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + kk=1 + mm=list(ee.args) + if mm==[]: + mm=[ee] + for i in mm: + kk=kk*ppow(bb,i) + #kk=Mul(kk,ppow(bb,i),evaluate=False) + + return kk + else: + return expr +def sum2mulexpo(expr): + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+sum2mulexpo(i) + return mm + + elif Is_Mul(expr): + + mm=1 + for i in fpoly(expr,'list'): + + mm=mm*sum2mulexpo(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + if Is_Add(ee): + kres=1 + for i in fpoly(ee,'list'): + kres=kres*bb**i + return kres + else: + return expr + else: + return expr + + +def rsimplify(expr): + if type(expr)==list: + return [rsimplify9(i) for i in expr] + elif type(expr)==Array: + vec=list(expr) + kres=[rsimplify9(i) for i in vec] + return Array(kres) + else: + return rsimplify9(expr) + + +def rsimplify3(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+rsimplify3(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=rsimplify3(p1) + P2=rsimplify3(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*rsimplify3(i) + return mm + elif Is_Pow(expr) and not Is_Root(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb=rsimplify3(bb) + return bb**ee + + elif Is_Root(expr): + rr=getroot(expr) + mm=insideroot(expr) + if Is_Pow(mm): + bb=getbase(mm) + ee=getexpo(mm) + return(bb**(simplify(cfrac(ee,rr)))) + elif Is_Mul(mm): + kres=1 + kl=mm.args + for i in kl: + bb=getbase(i) + ee=getexpo(i) + kres=kres*bb**(simplify(cfrac(ee,rr))) + return kres + else: + return expr + + else: + return expr +def krsimplify(expr): + if Is_Root(expr): + r=symbols('r') + rr=getroot(expr) + exp2=insideroot(expr) + nexpr=ppow(exp2,cfrac(1,r)) + nexpr=mulexpo(nexpr) + nexpr=simplifyexpo(nexpr) + nexpr=subsubs(nexpr,r,rr) + return nexpr + else: + return expr + +def rsimplify2(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+rsimplify2(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=rsimplify2(p1) + P2=rsimplify2(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*rsimplify2(i) + return mm + elif Is_Pow(expr): + return krsimplify(expr) + + else: + return expr + + +def swapPow2Pow(expr): + + if Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + + if Is_Pow(bb): + + bb2=UnevaluatedExpr(getbase(bb)) + ee2=UnevaluatedExpr(getexpo(bb)) + return ppow(bb2**ee,ee2) + +def checkrpow(expr,rval): + if Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + if rval==ee: + return bb + else: + nee=simplify(frs(ee,rval)) + return ppow(bb,nee) + elif Is_Number(expr): + expr=simplify(ppow(expr,1,rval)) + return expr + else: + return ppow(expr,frs(1,rval)) + + +def joinexpo(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + if Is_MulPow(i): + kres=kres+joinexpo(i) + else: + kres=kres+i + return kres + elif Is_Div(unisymbols(expr)): + p1,p2=unisymbols(fraction(expr)) + if Is_MulPow(p1): + p1=joinexpo(p1) + if Is_MulPow(p2): + p2=joinexpo(p2) + + kres=Div(p1,p2) + return kres + elif Is_MulPow(unisymbols(expr)): + vecnor=[] + vecpow=[] + for i in expr.args: + if type(i)==Pow: + vecpow.append(i) + else: + vecnor.append(i) + vecee=[] + for i in vecpow: + ee=getexpo(i) + if ee not in vecee: + vecee.append(ee) + vecbases=[] + for i in vecee: + vecbase=[] + for j in vecpow: + base=getbase(j) + ee=getexpo(j) + if ee==i: + vecbase.append(base) + vecbases.append(vecbase) + kres=1 + vecpro=[] + for i in vecbases: + kres=1 + for j in i: + kres=kres*j + vecpro.append(kres) + vecexp=[] + for i in vecpro: + try: + kres=expand(i) + except: + kres=i + vecexp.append(kres) + kres=1 + for i,j in zip( vecexp,vecee): + kres=kres*(i**j) + for i in vecnor: + kres=kres*i + return kres + else: + return expr +''' +def joinexpo(expr,op=''): + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+joinexpoA(i,op=op) + return kres + elif Is_Mul(expr) or Is_Div(expr): + return joinexpoA(expr,op=op) + else: + return expr +''' + +def joinexpoA(expr,op=''): + ''' + input x**a*z**a/y**a + return (x*z/y)**a + ''' + vecexpo=[] + vecbases=[] + for i in expr.args: + if Is_Pow(i): + bb=getbase(i) + ee=getexpo(i) + if ee in vecexpo: + kpos=getposinvec(vecexpo,ee) + pbase=vecbases[kpos] + pbase.append(bb) + vecbases[kpos]=pbase + elif -1*ee in vecexpo: + kpos=getposinvec(vecexpo,-1*ee) + pbase=vecbases[kpos] + pbase.append(1/bb) + vecbases[kpos]=pbase + + else: + vecexpo.append(ee) + vecbases.append([bb]) + mres=1 + for i,j in zip(vecexpo,vecbases): + kres=1 + for ii in j: + if op=='simplify': + kres=simplify(expand(kres*ii)) + else: + kres=kres*ii + kres=kres**i + mres=mres*kres + return mres + +def getposinvec(vec,expr): + pp=-1 + cc=0 + qq=len(vec) + for i in range(qq): + expr1=vec[i] + if str(expr1)==str(expr): + return cc + cc=cc+1 + return -1 + + + +def getrealexpo(expr): + + rr=getroot(expr) + expr=mulexpo(expr) + if rr==1: + return getexpo(expr) + else: + ee=factor(getexpo(mulexpo(expr))) + if Is_Div(factor(ee)): + p1,p2=fraction(factor(ee)) + if rr==p2: + return p1 + else: + return ee + else: + return ee + +def realdataexpo(expr): + if Is_PowRoot(expr): + p1,p2=expr.args + if Is_Pow(p1): + bb,ee=p1.args + r1,r2=fraction(p2) + rr=r2 + + else: + bb=p1 + ee=p2 + rr=1 + + else : + bb=getbase(expr) + ee=getexpo(expr) + rr=1 + return bb,ee,rr + +def fight_r_e(ee,rr): + if rr==ee: + return 1,1 + else: + dd=simplify(factor(ee)/factor(rr)) + p1,p2=fraction(dd) + return p1,p2 + +def rfactor(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+rfactor(i) + return factor(kres) + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=rfactor(p1) + p2=rfactor(p2) + return factor(p1/p2) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + + kres=kres*rfactor(i) + return factor(kres) + elif Is_Root(expr): + BB=insideroot(expr) + BB3=factor(BB) + if Is_Div(BB3): + + p1=factor(mulexpo(numer(factor(BB3)))) + p2=factor(mulexpo(denom(factor(BB3)))) + BB2=factor(p1/p2) + return factor(expr.subs(BB,BB2)) + elif Is_Add(BB): + BB2=factor(unisymbols(BB)) + return factor(expr.subs(BB,BB2)) + else: + return expr + else: + return expr + +def killpow(expr): + if Is_PowRoot(expr): + try: + bb,ee,rr=realdataexpo(expr) + if ee==rr: + return bb + + ee2=simplify(ee/rr) + return bb**ee2 + + except: + return expr + else: + return expr + +def rexpsimplify(expr): + if Is_ExpRoot(expr): + r=getroot(expr) + b=insideroot(expr) + ee=b.args[0] + nexpr=simplify(cfrac(ee,r)) + if denom(nexpr)==1: + return exp(nexpr) + else: + nn=numer(nexpr) + dd=denom(nexpr) + return rpow(exp(nn),dd) + + else: + return expr + +def simplersimplify(expr): + bb,ee,rr=dataPow(expr) + if Is_Pow(bb): + return rsimplify(expr) + elif Is_Div(bb): + p1=simplersimplify(Sqrt(numer(bb),rr)) + p2=simplersimplify(Sqrt(denom(bb),rr)) + return sDiv(p1,p2) + elif Is_Mul(bb): + mm=bb.args + vec=[simplersimplify(Sqrt(i,rr)) for i in mm] + kres=list2mul(vec) + return kres + + else: + return expr +def rsimplify9(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+rsimplify9(i) + return kres + elif Is_Div(expr): + p1=numer(expr) + p1=rsimplify9(p1) + p2=denom(expr) + p2=rsimplify9(p2) + return Div(p1,p2) + elif Is_Mul(expr): + mm=expr.args + vec=[rsimplify9(i) for i in mm] + kres=list2mul(vec) + return kres + elif Is_Root(expr): + if (Is_Root(expr) and (Is_Div(insideroot(expr)) or Is_Mul(insideroot(expr)))): + return simplersimplify(expr) + else: + return mono_rsimplify(Sqrt(expr)) + else: + return expr +def rsimplify8(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+rsimplify8(i) + return kres + elif Is_Div(expr): + p1=numer(expr) + p1=rsimplify8(p1) + p2=denom(expr) + p2=rsimplify8(p2) + return Div(p1,p2) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*rsimplify8(i) + return kres + elif Is_Root(expr): + if (Is_Root(expr) and (Is_Add(insideroot(expr)) or Is_Mul(insideroot(expr)))): + kres=insideroot(expr) + kres=rsimplify8(kres) + rr=getroot(expr) + return Sqrt(kres**sDiv(1,rr)) + else: + return mono_rsimplify(Sqrt(expr)) + else: + return expr +def rsimplify7(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+rsimplify7(i) + return kres + elif Is_Div(expr): + p1=numer(expr) + p1=rsimplify7(p1) + p2=denom(expr) + p2=rsimplify7(p2) + return Div(p1,p2) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*rsimplify7(i) + return kres + elif Is_Root(expr): + return mono_rsimplify(expr) + else: + return expr + + +def rsimplify6(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+rsimplify6(i) + return kres + elif Is_Div(expr): + p1=numer(expr) + p1=rsimplify6(p1) + p2=denom(expr) + p2=rsimplify6(p2) + return Div(p1,p2) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*rsimplify6(i) + return kres + elif Is_Root(expr): + return mono_rsimplify(expr) + else: + return expr + + +def rsimplify5(expr): + + + if Is_Root(expr) and not Is_Add(insideroot(expr)): + rr=getroot(expr) + bb=getbase(expr) + P1=1 + P2=1 + mm=bb.args + + for i in mm: + kres=expr + for j in mm: + if j!=i: + kres=kres.subs(j,1) + exprr=kres + res1,res2=rsimplifyRPow(exprr,'parts') + + if res1!=1: + if P1==1: + P1=res1 + else: + P1=Mul(P1,res1,evaluate=False) + if res2!=1: + if P2==1: + P2=res2 + else: + P2=Mul(P2,res2,evaluate=False) + if P1!=1: + return Mul(rsimplify(P1),joinbase(P2),evaluate=False) + else: + return rsimplify(P2) + + elif Is_ExpRoot(expr): + return rexpsimplify(expr) + + elif Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+unisymbols(rsimplify5(i)) + return kres + + + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=unisymbols(rsimplify5(p1)) + p2=unisymbols(rsimplify5(p2)) + return p1/p2 + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*unisymbols(rsimplify5(i)) + return kres + elif Is_Root(expr): + BB=insideroot(expr) + rr=getroot(expr) + BB3=factor(BB) + if Is_Div(BB3): + p1=unisymbols(factor(mulexpo(numer(factor(BB3))))) + p2=unisymbols(factor(mulexpo(denom(factor(BB3))))) + p1=simplify(rsimplify(rpow(p1,rr))) + p2=simplify(rsimplify(rpow(p2,rr))) + p1=killpow(p1) + p2=killpow(p2) + return p1/p2 + else: + return killpow(expr) + + else: + return expr + + +####################### +######## used to rsimplify +################ + +def Is_RootMonoPow(expr): + done=False + if Is_Root(expr): + if Is_Pow(insideroot(expr)): + return True + return False +def preSqrt(expr): + bb,ee,rr= dataPow(expr) + if type(ee)==Float: + nee=Rational(ee).limit_denominator(10**3) + knumer=numer(nee) + kdenom=denom(nee) + rr=rr*kdenom + ee=knumer + if Is_Pow(bb): + bb2,ee2,rr2=preSqrt(bb) + bb=bb2**cfrac(ee2,rr2) + return bb,ee,rr +def prePow(expr): + bb,ee,rr=preSqrt(expr) + if rr==1 and ee==1: + return bb + elif rr==1: + return bb**ee + elif ee==1: + return bb**sDiv(1,rr) + else: + return bb**sDiv(ee,rr) + +def Sqrt(*args): + kres=Sqrt2(*args) + return prePow(kres) + +def Sqrt2(*args,evaluate=True): + if len(args)==1 and Is_Add(args[0]): + kres=0 + mm=args[0].args + for i in mm: + kres=kres+Sqrt2(i) + return kres + + if len(args)==1 and Is_Div(args[0]): + P=args[0] + p1=prePow(numer(P)) + p2=prePow(denom(P)) + P1=Sqrt2(p1) + P2=Sqrt2(p2) + if Is_Root(P1) and Is_Root(P2) and (getroot(P1)==getroot(P2)): + bb1,ee1,rr1=preSqrt(P1) + bb2,ee2,rr2=preSqrt(p2) + return Sqrt2(sDiv(bb1**ee1,bb2**ee2),rr1) + else: + return sDiv(P1,P2) + + if len(args)==1 and Is_Mul(args[0]): + cc=1 + mm=args[0].args + for i in mm: + if cc==1: + kres=Sqrt2(i) + cc=cc+1 + else: + kres=kres*Sqrt2(i) + return kres + + if len(args)==1 and Is_Pow(args[0]): + bb,ee,rr=preSqrt(args[0]) + bb=Sqrt2(bb) + return Sqrt2(bb,ee,rr) + + + if len(args)==2: + bb=args[0] + rr=args[1] + ee=1 + elif len(args)==3: + bb=args[0] + ee=args[1] + rr=args[2] + else: + bb,ee,rr=preSqrt(args[0]) + bb=prePow(bb) + + if not evaluate: + bb=prePow(bb) + bb=parse_expr(str(bb),evaluate=False) + if rr==1: + bb=prePow(bb) + return bb**ee + elif rr==2: + if ee==1: + return parse_expr('sqrt('+str(bb)+')',evaluate=False) + else: + return parse_expr('sqrt(('+str(bb)+')**'+str(ee)+')',evaluate=False) + else: + bb=prePow(bb) + if Is_Number(rr): + + sexpr='\\sqrt['+str(latex(rr))+']' + if ee==1: + sexpr=sexpr+'{'+str(latex(bb))+'}' + else: + sexpr=sexpr+'{'+str(latex(bb))+'^{'+str(latex(ee))+'}}' + return latex2sympy(sexpr) + else: + return bb**sDiv(ee,rr) + + +def Sqrt1(val,sq,ee=1,evaluate=True): + if not evaluate: + val=parse_expr(str(val),evaluate=False) + if sq==1: + return val**ee + elif sq==2: + if ee==1: + return parse_expr('sqrt('+str(val)+')',evaluate=False) + else: + return sparse_expr('sqrt('+str(val)+'**'+str(ee)+')',evaluate=False) + else: + if Is_Number(sq): + sexpr='\\sqrt['+str(latex(sq))+']' + if ee==1: + sexpr=sexpr+'{'+str(latex(val))+'}' + else: + sexpr=sexpr+'{'+str(latex(val))+'^{'+str(latex(ee))+'}}' + return latex2sympy(sexpr) + else: + return val**cfrac(ee,sq) + +def fracmixta(expr): + expr=simplify(factor(expr)) + if denom(expr)!=1: + p1=numer(expr) + p2=denom(expr) + P1=1 + K1=1 + if Is_Number(p1): + P1=p1 + + elif Is_Mul(p1): + for i in p1.args: + if Is_Number(i): + P1=i + else: + K1=K1*i + else: + return (0,0,expr) + P2=1 + K2=1 + if Is_Number(p2): + P2=p2 + elif Is_Mul(p2): + for i in p2.args: + if Is_Number(i): + P2=i + else: + K2=K2*i + else: + return (0,0,expr) + + kres=P1%P2 + return (P1-kres)/P2,kres*K1/K2,P2 + + + + else: + return 0,expr,1 +def rsimplifyRPow(expr,*args): + if Is_RootMonoPow(expr): + base,ee,rr=partPow(expr) + p1,p2,p3=fracmixta(ee/rr) + if p1!=0: + P3=Sqrt(base,p3,ee=p2) + if 'parts' in args: + return base,P3 + else: + return Mul(base**p1,P3,evaluate=False) + else: + if 'parts' in args: + return 1,expr + else: + return expr + + if 'parts' in args: + return 1,expr + else: + return expr + +def mono_rsimplify(expr): # version 1 + bb,ee,rr=dataPow(expr) + nexpr=bb**(simplify(Div(ee,rr))) + bb,ee,rr=dataPow(nexpr) + if rr==1: + return nexpr + elif ee==rr: + return bb + elif ee==1 and rr!=1: + if Is_Div(bb): + p1=numer(bb) + p1=mono_rsimplify(Sqrt(p1,rr)) + p2=denom(bb) + p2=mono_rsimplify(Sqrt(p2,rr)) + return Div(p1,p2) + elif Is_Mul(bb): + kres=1 + for i in bb.args: + kres=kres*mono_rsimplify(rpow(i,rr)) + return kres + else: + try: + eres=ee%rr + esal=ee-eres + nee=esal/rr + kres=Mul(bb**nee,Sqrt(bb,rr),evaluate=False) + return kres + except: + return Sqrt(bb,rr,ee) + elif ee==1 and rr==1: + return expr + + + else: + try: + eres=ee%rr + esal=ee-eres + nee=esal/rr + kres=Mul(bb**nee,Sqrt(bb,rr),evaluate=False) + return kres + except: + return Sqrt(bb,rr,ee) +def mono_rsimplify2(expr):# version 1 + bb,ee,rr=dataPow(expr) + nexpr=bb**(simplify(Div(ee,rr))) + bb,ee,rr=dataPow(nexpr) + if rr==1: + if ee==1: + return bb + else: + return bb**ee + elif ee==1: + if rr==1: + return bb + else: + try: + return Sqrt(bb,rr) + except: + try: + return mulexpo(disjoinexpo(bb**ee)) + except: + return expr + + else: + try: + eres=ee%rr + esal=ee-eres + nee=esal/rr + kres=Mul(bb**nee,Sqrt(bb,rr),evaluate=False) + return kres + except: + return Sqrt(bb,rr,ee) + + +def dataPow(expr): + if Is_e(expr): + rr=getroot(expr) + bb=exp(1) + ee=expr.args[0] + else: + bb,ee,rr=partPow(expr) + + bb,ee,rr=unisymbols(bb),unisymbols(ee),unisymbols(rr) + if denom(ee)!=1: + rr=rr*denom(ee) + ee=numer(ee) + if denom(rr)!=1: + ee=ee*denom(rr) + rr=numer(rr) + return bb,ee,rr + diff --git a/Libaldo/lib_Mathbasic.py b/Libaldo/lib_Mathbasic.py new file mode 100644 index 0000000..5d1fcbc --- /dev/null +++ b/Libaldo/lib_Mathbasic.py @@ -0,0 +1,764 @@ + + + +from sympy import * +from lib_Mathematica import * + +## PARTIAL FRACTION... + +x,s,t,y=symbols('x s t y') +# ussefull variables to use in partial fracction algorith +y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10 y11 y12 y13 y14 y15 y16') +fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] +def getbase(expr): # return base in expr + ''' + expr = x**y,x*y + return x ,x*y + ''' + + if Is_Pow(expr): + ee=expr.args[0] + return ee + else: + return expr + +def getexpo(expr,op=''): # return exponente in expr + if Is_Pow(expr): + mm=expr.args + return mm[1] + + else: + return 1 +def str2mathstr(sexpr): + ''' + input str math expr + return str math expr + this f fix space between + and - symbols + example: + str2mathstr('x**2+z*(x+1)') + return 'x**2 + z*(x + 1)' + ''' + + + qq=len(sexpr) + sres='' + + for i in range(qq): + sval=sexpr[i] + if i==0: + sres=sres+sval + elif sval=='+' or sval=='-': + if sexpr[i-1] != ' ': + sres=sres+' ' + sres=sres+sval + if idg2: + # vec1=coef_list(p1,var2=var) + # vec2=coef_list(P4,size=dg1,var2=var) + # else: + # vec1=coef_list(p1,var2=var) + # vec2=coef_list(P4,var2=var) + + # vec3=[vec2[i]-vec1[i] for i in range(len(vec2))] + # kres=solve(vec3) + # svar,vval=ganswer(kres,'varname','value') + # for i,j in zip(svar,vval): + # P=P.subs(i,j) + # return P + +# getinsidepar + +def vecfind(sexp,sval): + sexp=str(sexp) + mv=[] + qq=len(sexp) + if sexp[-1]==sval: + mv=[qq] + sexp=str(sexp) + mm=[] + done=True + while done: + p=sexp.find(sval) + if p==-1: + done=False + else: + mm.append(p) + sexp=sexp[p+1:-1] + mm=mm+mv + return mm + +def insidepar(expr,svar=''): + if svar=='': + sexpr=str(expr) + p1=sexpr.find('(') + vp2=vecfind(sexpr,')') + qq=len(vp2) + sres=sexpr[p1+1:vp2[qq-1]+1] + return parse_expr(sres) + else: + sexpr=str(expr) + pp=sexpr.find(svar) + sexpr2=sexpr[pp::] + if sexpr2[0]=='(': + sres= sexpr2 + else: + + p3=sexpr2.find('(') + sres=sexpr2[p3::] + + vec1=vecfind(sres,'(') + vec2=vecfind(sres,')') + mm=[] + for i in vec1: + mm.append([i,1]) + for i in vec2: + mm.append([i,-1]) + mm.sort() + qq=len(mm) + p1=0 + p2=mm[qq-1][0] + cc=1 + for i in range(1,qq): + cc=cc+mm[i][1] + if cc==0: + p2=mm[i][0] + break + kres=sres[p1:p2] + return parse_expr(kres) + +## Pprimefactor... + + +def factorp(expr): + kres='' + if Is_Add(expr): + done=True + for i in expr.args: + if done: + kres=factorp(i) + done=False + else: + kres=kres+'+'+factorp(i) + + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=factorp(p1) + P2=factorp(p2) + kres= '('+P1+')/('+P2+')' + elif Is_Mul(expr): + done=True + for i in expr.args: + if done: + kres=factorp(i) + done=False + else: + kres=kres+'*('+factorp(i)+')' + + elif Is_Root(expr): + bb=insideroot(expr) + rr=getroot(expr) + kres=factorp(bb) + kres='('+kres+')**('+str(frs(1,rr))+')' + + + elif Is_NumberPow(expr): + bb=getbase(expr) + ee=getexpo(expr) + vecbase,vecexp=factoresprimosvec(bb) + done=True + for i,j in zip(vecbase,vecexp): + newe=simplify(j*ee) + if done: + kres=str(i)+'**('+str(newe)+')' + done=False + else: + kres=kres+'*'+str(i)+'**('+str(newe)+')' + + elif Is_Number(expr): + mm=factorint(expr) + vecbase,vecexp=unpack(mm) + qq=len(vecbase) + done=True + for i,j in zip(vecbase,vecexp): + if j!=1: + if done: + sres=str(i)+'**'+str(j) + done=False + else: + sres=sres+'*'+str(i)+'**'+str(j) + else: + if done: + sres=str(i) + done=False + else: + sres=sres+'*'+str(i) + kres=sres + + + + else: + kres=str(expr) + return kres + +def factorp(expr): + mm=factorint(expr) + vecbase,vecexp=unpack(mm) + return vecbase,vecexp + + +def getfaclist(expr): + vecb=[] + vece=[] + mm=expr.args + + for i in mm: + try: + base,eee=unpack(factorint(i)) + for k,j in zip(base,eee): + vecb.append(k) + vece.append(j) + except: + vecb.append(i) + vece.append(1) + kres='' + done=True + + for i,j in zip(vecb,vece): + if j==1: + subres=str(i) + else: + subres=str(i)+'**'+str(j) + if done: + kres=subres + done=False + else: + kres=kres+'*'+subres + return sympify( kres,evaluate=False) + + +def primefactor(expr): + if Is_Add(expr): + + kres='' + done=True + for i in expr.args: + if done: + kres=str(primefactor(i)) + done=False + else: + kres=kres+"+"+str(primefactor(i)) + + elif Is_Div(expr): + + p1,p2=fraction(expr) + p1=str(primefactor(p1)) + p2=str(primefactor(p2)) + kres= p1+'/'+p2 + + elif Is_Mul(expr): + + + kres='' + done=True + mm=expr.args + for i in mm: + if done: + kres= str(primefactor(i)) + done=False + else: + kres= kres+'*'+str(primefactor(i)) + elif Is_Log(expr): + + mm=expr.args + expr2=mm[0] + kres=str(primefactor(expr2)) + kres= 'log('+kres+')' + + + + elif type(expr)==Rational: + + knume=numer(expr) + kdeno=denom(expr) + knum=primefactor(knume) + kden=primefactor(kdeno) + return cfrac(knume,kdeno) + + + elif type(expr)==int or type(expr)==Integer: + + if isprime(expr): + kres=str(expr) + else: + val=expr + vecn,vece=kunpakDic(factorint(val)) + newf='' + for i,j in zip(vecn,vece): + if j==1: + newf=str(i)+'*'+newf + else: + newf=str(i)+'**'+str(j)+'*'+newf + newf=newf[0:-1] + newf=str(newf) + kres=sympify(newf,evaluate=False) + + + + + elif type(expr)==Pow: + + base=getbase(expr) + ee=getexpo(expr) + if Is_Symbol(base) or isprime(base): + kres=str(expr) + + else: + if type(base)==Rational: + return (primefactor(base))**ee + + elif not isprime(base): + vec1,vec2=unpack(factorint(base)) + done=True + kres='' + for i,j in zip(vec1,vec2): + if done: + kres= str(i)+'**'+'('+str(j*ee)+')' + done=False + else: + kres=kres+'*'+str(i)+'**'+'('+str(j*ee)+')' + + else: + kres= getfaclist(expr) + elif Is_Root(expr): + + rr=getroot(expr) + B=insideroot(expr) + try: + kres=primefactor(B) + ee=getexpo(kres) + bb=getbase(kres) + return bb**cfrac(ee,rr) + except: + return expr + else: + + kres=expr + return (sympify(kres,evaluate=False)) + + + + + +def superfactor(expr,kdiv,*args): + ''' + superfactor(exp2factorize, factor expr, op) + op = + 'factor',factorize before doit + 'simplify' simplify ... + 'expand'.. + 'expo', applied suerfactor in exponenets + ''' + if 'factor' in args: + expr=factor(expr) + if 'expand' in args: + expr=expand(expr) + if 'simplify' in args: + expr=simplify(expr) + if Is_Pow(expr): + bb=superfactor(getbase(expr),kdiv) + ee=getexpo(expr) + if 'expo' in args: + ee=superfactor(expo,kdiv) + return ppow(bb,ee) + if Is_Div(expr): + p1,p2=fraction(expr) + return cfrac(superfactor(p1,kdiv),superfactor(p2,kdiv)) + + if Is_Add(expr): + P1=0 + P2=0 + + for i in fpoly(expr,'list'): + i=superfactor(i,kdiv) + kres=i/kdiv + p1,p2=fraction(kres) + if p2==1: + P1+=p1 + else: + P2+=i + return P2+P1*kdiv + elif '+' in str(expr) or '-' in str(expr): + kres=1 + for i in fpoly(expr,'list'): + if Is_Add(i): + kres=kres*superfactor(i,kdiv) + else: + kres=kres*i + return kres + else: + return expr + + + +# basic ope + + + +def Div(p1,p2): + kres= p1/p2 + try: + if int(kres)==kres: + return int(kres) + except: + return kres +# math whit list + +def SubstracList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1-a2,b1-b2,...] + ''' + + kres=[] + for i,j in zip(vec1,vec2): + kres.append(i-j) + return kres + +def AddList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1+a2,b1+b2,...] + ''' + kres=[] + for i,j in zip(vec1,vec2): + kres.append(i+j) + return kres + +def MulList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1*a2,b1*b2,...] + ''' + kres=[] + for i,j in zip(vec1,vec2): + kres.append(i*j) + return kres +def DivList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1/a2,b1/b2,...] + ''' + kres=[] + for i,j in zip(vec1,vec2): + kres.append(cfrac(i,j)) + return kres + + +def symbolslist(vec,var=''): + ''' + symbolslist(x+a+b+4)=[x,a,b] + symbolslist(x+a+b+4,x)=[a,b] + symbolslist([x+a+b+4,a,z])=[a,b,x,z] + symbolslist([x+a+b+4,a,z],x)=[a,b,xz] + + ''' + if type(vec)==list: + qq=len(vec) + kres=0 + cc=10 + for i in vec: + kres=expand(kres+i/cc) + cc=cc*10 + else: + kres=vec + + slist=kres.free_symbols + vecs=list(slist) + if var!='': + kres=[] + for i in vecs: + if i!=var: + kres.append(i) + else: + kres=slist + return kres + +# DEGREE LIST ALGORTHMICS + +def pre_vec2compare(vec1,vec2): + ''' + filter (0=2) in coefflist + + ''' + nv1=[] + nv2=[] + for i,j in zip(vec1,vec2): + if not Is_Number(i) or not Is_Number(j): + nv1.append(i) + nv2.append(j) + return nv1,nv2 + +def pre_coeff2list(expr1,expr2,var=x): + ''' + prepare 2 coefflist two not generate error + ''' + + d1=degree(expr1,var) + d2=degree(expr2,var) + d3=max(d1,d2) + vec1=coef_list(expr1,var,d3) + vec2=coef_list(expr2,var,d3) + vec1,vec2=pre_vec2compare(vec1,vec2) + return vec1,vec2 + + +# imaginary number +def module_img(expr): + p1=re(expr) + p2=im(expr) + return get_hipo(p1,p2) + +def imodule(expr): + p1=re(expr) + p2=im(expr) + return get_hipo(p1,p2) + +def powi(expr,ee): + return expand(expr**ee) + + +def rpart(expr): + if Is_Div(expr): + p1,p2=fraction + sres=str(expr) + sres=sres.replace('I','0') + kres=parse_expr(sres) + return kres + +def repart(expr): + sres=str(expr) + sres=sres.replace('I','0') + kres=parse_expr(sres) + return kres + + +def imgpart(expr): + p1=expr-repart(expr) + p2=str(p1) + p2=p2.replace('I','1') + p3=parse_expr(p2) + return p3 + +def ipart(expr): + p1=expr-repart(expr) + p2=str(p1) + p2=p2.replace('I','1') + p3=parse_expr(p2) + return p3 + +def simplify_img(expr): + if Is_Add(expr): + kres=(repart(expr))+imgpart(expr)*I + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=simplify_img(p1) + p2=simplify_img(p2) + return cfrac(p1,p2) + elif Is_Mul(expr): + return simplify(expr) + else: + return simplify(expr) + return kres + +def polar2img(*args): + ''' + polar2img(sqrt(2),pi/4) + return 1+i + ''' + p1=args[0] + p2=args[1] + angle=p2 + radio=p1 + if 'pi' in str(p1): + angle=p1 + radio=p2 + pre=radio*cos(angle) + pim=radio*sin(angle) + sres=str(pre)+'+'+str(pim)+'*I' + return parse_expr(sres) + +def img2polar(expr): + ''' + img2polar(1+I) + return sqrt(2),pi/4 + ''' + p1=re(expr) + p2=im(expr) + p3=module_img(expr) + alpha=atan(cfrac(p2/p1)) + alpha=simplify(alpha) + return p3,alpha + +def conjugada(z): + if Is_Pow(z): + bb=getbase(z) + ee=getexponent(z) + bb2=conjugada(bb) + ee2=conjugada(ee) + return bb**ee2 + else: + sz=str(z) + sz=sz.replace('I','-I') + return parse_expr(sz) + +def premath(expr,*args): + ''' + pre trasforms answer in simplesolve + ''' + if len(args)>0: + if 'factor' in args: + try: + expr=factor(expr) + except: + pass + if 'simplify' in args or 'simpli' in args: + try: + expr=simplify(expr) + except: + pass + if 'expand' in args: + try: + expr=expand(expr) + except: + pass + if 'reduce' in args: + try: + expr=reduce(expr) + except: + pass + + if 'unisymbols' in args or 'unisys' in args: + try: + expr=unisymbols(expr) + except: + pass + if 'mulexpo' in args: + try: + expr=mulexpo(expr) + except: + pass + if 'rsimplify' in args: + try: + expr=rsimplify(expr) + except: + pass + return expr + + +def doindenom(*args): + expr=args[0] + func=args[1] + p1,p2=fraction(expr) + if len(args)==3: + expr2=args[2] + p2=dothis(p2,func,expr2) + else: + p2=dothis(p2,func,expr2) + + return unisymbols(Div(p1,p2)) + + +def doinnumer(*args): + expr=args[0] + func=args[1] + p1,p2=fraction(expr) + if len(args)==3: + expr2=args[2] + p1=dothis(p1,func,expr2) + else: + p1=dothis(p1,func,expr2) + + return unisymbols(Div(p1,p2)) + diff --git a/Libaldo/lib_Mathematica.py b/Libaldo/lib_Mathematica.py new file mode 100644 index 0000000..74e919d --- /dev/null +++ b/Libaldo/lib_Mathematica.py @@ -0,0 +1,3520 @@ +from sympy import * +from latex2sympy2 import latex2sympy +from functools import reduce +import matplotlib.pyplot as plt +import sys + +from IPython.display import Math # ,display + +import re + +# VARIABLE +t,a,b,c,d,x,y,z,w,i,j,k,alpha=symbols('t a b c d x y z w i j k alpha') +AA=symbols('AA') +########################################## +# Variable Crea Transforma +########################################## +def cleanvar(*args): + mm=[] + for i in args: + mm.append(symbols(str(i))) + if len(mm)==1: + return mm[0] + else: + return mm + +def clearvar(*args): + mm=[] + for i in args: + mm.append(symbols(str(i))) + if len(mm)==1: + return mm[0] + else: + return mm +def diffvar(*args): #crea variables dieferenciables + mm=[] + for i in args: + sres='d_'+alphaname(str(i)) + mm.append(symbols(sres)) + if len(mm)==1: + return mm[0] + else: + return mm +def c2c(kval): + if Is_Number(kval) and type(kval)==float and (kval-int(kval))==0: + return int(kval) + return kval + +def cleandfs(sexpr): + sexpr=sexpr.replace('d','') + sexpr=sexpr.replace('/','') + if len(sexpr)==2: + sexpr=sexpr[1]+sexpr[0] + kres=[] + for i in sexpr: + kres.append(symbols(i)) + return kres + +def get_varfunc(ksym): # input symbols 'v(t)' return symbols 't' + sres=str(ksym) # inputs and output are symbols variables + p1=sres.find('(') + p2=sres.find(')') + sres=sres[p1+1:p2] + return parse_expr(sres) + +def antiprimitiva(ksym): # input symbols 'v(t)' return symbols 'v' + # input symbols 'v' return symbols 'v' + + sres=str(ksym) # inputs and output are symbols variables + p1=sres.find('(') + if p1!=-1 and p1>0: + sres=sres[0:p1] + return parse_expr(sres) + else: + return ksym + + + + + +def unisymbols(ksym): + ''' + unisymbols() : this function homegenize diferent variables whit + the same symbolic name in omly one in all symbols expresion + ''' + if type(ksym)==list: + return [unisymbols(i) for i in ksym] + else: + + try: + kres=parse_expr(str(ksym)) + except: + kres=ksym + return(kres) + +def sydem(ksym): + + ''' + sydem() : symbol-idem + try to return the original function + with out auto math transformathis + ''' + kres=UnevaluatedExpr(ksym) + return unisymbols(kres) + +def sym2func(nval,ksym): + ''' + sym2func() + ----------------------- + input : nval = symbolic name function + ksym = posible dependient variable + return : nval function + ''' + return convFunc(nval,ksym) + +def convFunc(nval,ksym): # symbol to Function args=(symbols, var2) + newF=Function(nval)(ksym) + return newF + +def sym2func(nval,ksym): + return convFunc(nval,ksym) + +def primitivename(ksym): + kres=ksym + sres=str(ksym) + if '(' in sres: + nsres=sres[0:sres.find('(')] + kres=symbols(nsres) + return kres + +def get_symbols(*args): + ''' + return vector insode all expr in args + ''' + mm=[] + for i in args: + if type(i)==list: + for j in i: + vecm=fpoly(j,'free') + for k in vecm: + if k not in mm: + mm.append(k) + else: + vecm=fpoly(i,'free') + for k in vecm: + if k not in mm: + mm.append(k) + return mm +def sym2Function(*args): # symbols vector to Function vector *args=(symbols,symbols,......,var2) + + mm=[] + vt=args[-1] + for i in args[:-1]: + mm.append(convFunc(i,vt)) + return mm + +def symboldiff(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"'" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff(i)) + return mm + +def symboldiff2(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"''" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff2(i)) + return mm +################################# +# create list variables +################################# + +def replacestrinvec(vec,val1,val2): + ''' + vec=['1','2','3','4','5'] + we need change '3' by 'x' + replacestrinvec(vec,'3','x') + return ['1','2','x','4','5'] + ''' + kres=[val2 if i==val1 else i for i in vec] + return kres + +def mzero(kval,kop=0): # return list with [kop,kop,kop,.....] kval times + mm=[] + for i in range(kval): + mm.append(kop) + return mm + + +def subtrac_list(lst1, lst2): # return list2 without similares in list2 + lst3 = [value for value in lst1 if value not in lst2] + return lst3 + +def listmul(list1): + kres=1 + for i in list1: + kres=kres*i + return kres + + + +################################# +# Math +################################# +def nformat(ksym,qn): + return N(ksym,qn) + + +def try2float(kk): + if type(kk)==list: + mm=[] + for i in kk: + mm.append(try2float(i)) + return mm + else: + try: + kk2=float(kk) + return kk2 + except: + return kk + + +# cfrac() ***************** +def cfrac(*args,evaluate=False): + if len(args)==0: + helplib('cfrac') + return + if len(args)==1 and type(args[0])!=str: + p1=1 + p2=args[0] + elif len(args)==1: + p1=numer(args[0]) + p2=denom(args[0]) + else: + p1=args[0] + p2=args[1] + + if not evaluate: + return UnevaluatedExpr(UnevaluatedExpr(p1)/(p2)) + else: + try: + return frs(k1=p1,k2=p2) + except: + return p1/p2 + +def frs(k1,k2): # return S('k1/k2') + + if Is_Number(k1) and Is_Number(k2): + return Rational(k1, k2) + else: + return sydem(k1/k2) + +# sqrs() ***************** + +def rpow(*args): + kval=args[0] + if len(args)==1: + kres= sqrt(kval) + else: + rr=args[1] + kres= ppow(kval,cfrac(1,rr)) + return kres + + +def sqrs(k1,k2='',k3=1): # return pow(k1,S('k2')) + ''' + sqrs() + input: sqrs(a) return sqrt(a) + input: sqrs(a,b) return sqrt(b) of (a) + input: sqrs(a,b,c) return sqrt(b) of (a)**c + + ''' + k1=1*k1 + + if k2=='': + k2=2 + else: + k2=1*k2 + v1=str(k2) + if k3!=1: + k3=1*k3 + v2='('+str(k3)+')/('+v1+')' + else: + v2='1/('+v1+')' + kres=pow(k1,S(v2)) + + return(kres) + + +# ppow() ***************** +def ppow(*args): + if len(args)==0: + helplib('ppow') + return + + return kpow(*args) + +def kpow(*args): + ''' + kpow(a) return a**2 + kpow(a,b) return a** b + kpow(a,b,c) return a** (b/c) + + ''' + if len(args)==0: + helplib('kpow') + return + ksym=args[0] + if len( args)==1: + return ksym**2 + elif len( args)==2: + ee=args[1] + return ksym**ee + else: + rr=args[2] + ee=args[1] + if rr==2: + return sqrt(ksym**ee) + else: + return ksym**cfrac(ee,rr) + + + + + +# sex2rad() ***************** + +def realangle(expr): # return angle displacement + try: + if expr<2*pi: + return expr + else: + try: + kres=expr/(2*pi) + kres2=int(kres) + kres3=simplify(kres-2*pi*kres2) + return kres3 + except: + return expr + except: + return expr + +def sex2rad(k): # convert segsadesimal to radial + if k=='': + helplib('sex2rad') + return + k=simplify(pi*k/180) + return(k) + +# rad2sex() ***************** +def rad2sex(k): # convert radial to sexages. + if k=='': + helplib('sex2rad') + return + if 'pi' in str(k): + k=cfrac(180*k,pi) + else: + k=180*k/3.1416 + return(k) +# rpm2rad() ***************** +def rpm2rad(expr): # convert rrpm to rad/s. + return expr*2*pi/60 + +# sex2rad_i() ***************** +def sex2rad_i(kang,s='r'): + if s=='s': + kang=sex2rad(kang) + return(kang) + +# killabs() ***************** +def kilabs(ksym): + if ksym=='': + helplib('killabs') + return + + ''' + input: abs(x) + return : x + ''' + return killAbs(ksym=ksym) + +def killAbs(ksym): + kres=ksym + try: + mm=str(kres) + mm=mm.replace('Abs','') + return parse_expr(mm) + except: + return kres + +# signo() ***************** +def makepos(kres): + return kres*signo(kres) + + +def signo(ksym): + if ksym=='': + helplib('signo') + return + ''' + input: x + return : -1 if x<0 + return : 0 if x=0 + return : 1 if x>0 + + ''' + kres=1*ksym + mm=fpoly(ksym,'free') + for i in mm: + kres=kres.subs(i,1) + + try: + if kres<0: + return -1 + elif kres>0: + return 1 + else: + return 1 + except: + return 1 + +# unfloatdiv() ***************** +def unfloatdiv(p1,p2): # return p1/p2 whitout avaluate + P1=str(p1) + P2=str(p2) + P3='('+P1+')/('+P2+')' + return parse_expr(P3,evaluate=False) + +##################### +# get info +##################### + +# insideroot() ***************** +def insideroot(ksym=''): + ''' + input: x**(a/b) + return : x**a + + + ''' + if ksym=='': + helplib('insideroot') + return + + return get_inside_root(ksym=1*ksym) + +def get_inside_root(ksym): + kres=ksym + if Is_Root(kres): + mm=fpoly(kres,'list') + return mm[0] + return kres + +# insidepow() ***************** +def insidepow(ksym=''): + if ksym=='': + helplib('insidepow') + return + ''' + input: x**(a/b) + return : x**(1/b) + + ''' + return get_inside_Pow(ksym=1*ksym) +def get_inside_Pow(ksym): + kres=ksym + if Is_Pow2(kres): + mm=fpoly(kres,'list') + return mm[0] + return kres + +# getexponent() ***************** + + +# getbase() ***************** + + + +def get_killexpo(ksym): + if Is_Mono(ksym): + mm=fpoly(ksym,'list') + return mm[0] + + +##################### +# get info Geometry +##################### + +# gethipo() ***************** +def gethipo(a,b,kope=''): + if a=='' or b=='': + helplib('gethipo') + return + + a=a*1 + b=b*1 + return get_hipo(a=a,b=b,kope=kope) # return raiz(a*a+b*b) + +def get_hipo(a,b,kope=''): + + kres=rpow(kpow(a,2)+kpow(b,2),2) + kres=opemat(kres,kope=kope) + return kres + +# gethipo() ***************** +def getcateto(a,b,kope=''): + if a=='' or b=='': + helplib('getcateto') + return + a=a*1 + b=b*1 + return get_cateto(a=a,b=b,kope=kope) # return raiz(a*a-b*b) + +def get_cateto(a,b,kope=''): + kres=rpow(kpow(a,2)-kpow(b,2),2) + kres=opemat(kres,kope=kope) + return kres + +# componentx() ***************** +def componentx(kr,kang): + kr=kr*1 + kang=kang*1 + return x_pol(kr=kr,kang=kang) + + +def x_pol(kr,kang): + return kr*cos(kang) + +# componenty() ***************** +def componenty(kr,kang): + kr=kr*1 + kang=kang*1 + return y_pol(kr=kr,kang=kang) +def y_pol(kr,kang): + return kr*sin(kang) + +def lenght2point(x1,y1,x2,y2,kope=''): + x1,y1,x2,y2=1*x1,1*y1,1*x2,1*y2 + + l1=x2-x1 + l2=y2-y1 + kres=rpow(l1*l1-l2*l2) + kres=opemat(kres,kope=kope) + return kres + +# algebra1() ***************** + +def get_sum2(a,b,kope=''): # return a*a+b*b + a=unisymbols(a) + b=unisymbols(b) + kres= kpow(a,2)+kpow(b,2) + kres=opemat(kres,kope=kope) + return kres + +def get_dif2(a,b,kope=''): + a=unisymbols(a) + b=unisymbols(b) + kres= kpow(a,2)-kpow(b,2) + kres=opemat(kres,kope=kope) + return kres + + +##################### +# SOLVE +##################### + +def ksolve(kres,var,*args,**kwargs): + try: + Vk=var.name + except: + Vk=str(var) + + solu=solve(kres,Vk) + if type(solu)==list: + if 'all' in args: + return solu + else: + try: + solu=solu[0] + except: + pass + if len(args)>0: + if 'positive' in args: + solu=solu*signo(solu) + return solu + +def csolve(Eq1,ksym,kd='',korden='',kpositive=False,kope='',kdisp=False,unifique=False): + Eq1=unisymbols(1*Eq1) + ksym=unisymbols(ksym) + + + if not(kd==''): + kdisp=True + + if unifique: + kres=solve(Eq1,sympy_unifiq(Eq1,ksym)) + else: + kres=solve(Eq1,ksym) + qq=len(kres) + if qq==1: + kres=kres[0] + if qq>1: + kres=list(kres) + if kpositive: + kres=[i for i in kres if i>0] + + if len(kres)==1: + kres=kres[0] + if not(korden==''): + if qq>1: + kres=kres[korden] + + kres=opemat(kres,kope) + #qq=len(kres) + #if qq==1: + #kres=kres[0] + if kd!='': + sR=kd+' =' + display(Math(sR+latex(kres))) + #if kreturn: + return(kres) + + + +def csolveR(Eq1,ksym,kd='',kope=''): # solve 2do grade Eq return positive part + nksym=ppow(1*ksym,2) + kres=csolve(1*Eq1,nksym,kope=kope) + kres=opemat(kres,kope) + kres=rpow(kres,2) + if kd!='': + sR=kd+' =' + display(Math(sR+latex(kres))) + + return(kres) + + + +##################### +# Transformation +##################### +def tsimplify(kres): + if kres=='': + helplib('tsimpify') + return + return trigsimp(kres) + + +def subsubs(*args,force=False): + if len(args)==0: + helplib('subsubs') + return + expr,expr1,expr2=args + + sres=str(expr) + sres1=str(expr1) + sres2=str(expr2) + sres=sres.replace(sres1,sres2) + if force: + try: + kres=parse_expr(sres,evaluate=False) + return kres + except: + return expr + else: + try: + kres=parse_expr(sres) + return kres + except: + return expr + +def texpand(kres): + if kres=='': + helplib('texpand') + return + if type(kres)==Add: + rtt=0 + mm=fpoly(kres,'list') + for i in mm: + rtt=rtt+expand_trig(i) + return rtt + else: + return expand_trig(kres) + + +def opemat(ksym,kope=''): + if kope=='': + return ksym + ''' + opemat(Equation,kope=opt) + opt + 'f'= factor(Equation), + 'e'= expand(Equation), + 's'= simplify(Equation), + 't'= trigsimp(Equation) + 'x'= expand trig(Equation) + 'v'= Equation.evalf() + 'a'= apart(Equation) + 'c'= cancel(Equation) + 'E'= Equation.expand(force=True) + '2' = kill sqrt( x^2 ) + ''' + if '(' in kope: + newEq=creaQ(ksym,kope) + return newEq + + kres=unisymbols(ksym) + for i in kope: + + if i=='e' : + try: + kres=expand(kres) + except: + done=True + if i=='f' : + try: + kres=factor(kres) + except: + done=True + if i=='t' : + try: + kres=trigsimp(kres) + except: + done=True + if i=='x' : + try: + kres=expand_trig(kres) + except: + done=True + if i=='s' : + try: + kres=simplify(kres) + except: + done=True + if i=='v' : + + try: + try: + kres=float(evalf(kres)) + float(kres) + return(kres) + except: + try: + kres=float(evalf(kres)) + except: + kres=evalf(kres) + return(kres) + except: + if len(fpoly(kres,'free'))==0: + try: + kres=kres.evalf() + return(kres) + except: + try: + if not(type(kres)==float or type(kres)==int): + kres=kres.evalf() + return(kres) + except: + kres=kres + return(kres) + + + + if i=='a' : + kres=apart(kres) + if i=='c' : + kres=cancel(kres) + if i=='r' : + try: + kres=kill_root_poly(kres) + except: + if Is_Mono(ksym): + kres=kres+1 + kres=kill_root_poly(kres) + kres=kres-1 + else: + kres=kill_root_poly(ksym) + try: + mm=fpoly(kres,'list') + skres=str(kres) + smm=[] + vres=[] + for i in mm: + vres.append(str(opemat(i,'r'))) + smm.append(str(i)) + + for i,j in zip(smm,vres): + skres=skres.replace(i,j) + kres=parse_expr(kres) + except: + done=true + if i=='-' : + kres2=kres + try: + kres2=kpow(kres,-1) + kres2=opemat(kres2,'r') + kres=kpow(kres2,-1) + except: + done=False + + if i=='2' : + kres=kill_RootPow(kres) + + if i=='E' : + kres=kres.expand(force=True) + + if i=='F' : + + kres=nsimplify(kres) + if i=='R' : + kres=reduFac2(kres) + + if i=='C' : + mm=fpoly(kres,'free') + for i in mm: + try: + kres=cut_root2(kres,i) + except: + done=true + if i=='K' or i=='k' : + kres=expand(kres) + if Is_Mono(kres): + kres=signed_sqrt(kres*kres) + if Is_Poly(kres): + kres=kill_root_poly(kres) + if i=='N': + if Is_Number(kres) and not Is_Symbol(kres): + kres=float(kres) + kres=N(kres) + + return(kres) + +def reduFac2(ksym): + kres=ksym + try: + mm=fpoly(factor(kres),'list') + try: + mkres=1 + for i in mm: + if Is_Poly(i): + mkres=mkres*i + return mkres + except: + return kres + + except: + return kres + +def reduMonoFac(ksym): + kres=ksym + nkres=1 + dfactor=False + if Is_Poly(kres): + kres=factor(kres) + if Is_Mono(kres): + dfactor=True + return denom(kres) + if Is_Mono(kres): + mm=fpoly(kres,'list') + + done=False + for i in mm: + done=False + eqs=str(i) + if '+ ' in eqs or '- ' in eqs: + done=True + if done: + nkres=nkres*i + if dfactor: + return expand(nkres) + else: + return nkres + else: + return kres + +def opemat_vec(ksym,kope): + mm=[] + for i in ksym: + kres=opemat(i,kope) + mm.append(kres) + return mm + +def opematsec(ksym,kope=''): # equal to opemat but secuential + kres=unisymbols(ksym) + for op in kope: + kres=opemat(kres,kope=op) + + return kres + +def opematPolySec(ksym,kope=''): + kres=ksym + if Is_Add(kres): + mm=0 + for i in fpoly(kres,'list'): + mm+=opemat(i,kope=kope) + kres=mm + + else: + kres=opemat(kres,kope) + + return kres + +def opemat_deno(ksym,kope=''): + knume=numer(ksym) + kdeno=denom(ksym) + kdeno=opemat(kdeno,kope=kope) + kres=knume/kdeno + return kres + +def opemat_nume(ksym,kope=''): + knume=numer(ksym) + kdeno=denom(ksym) + knume=opemat(knume,kope=kope) + kres=knume/kdeno + return kres + + +##################### +# get info ALgebra +##################### + + +def fpoly(ksym,kopt='',op2='',op3=''): + + ''' + 'n': return number of args + 'list': return list of args + 'get': return args No =op2 in list args + 'get_inv': return inverse of args No=op2 in,list + 'gets': return sum of term(a)+term(b)+... op2= 'ab...' + 'getp': return multi of term(a)+term(b)+... op2= 'ab...' + 'free': return list of all variable symbols in ksym + 'filt': + 'unfilt': + 'frac2sum': + 'lam': return lambdify(op2,ksym) + 'simpow': + 'subs': return(ksym.subs(op2,op3) + 'facmono': factorize ksym whit op2 + 'in_allexp': + 'simp_fac': + 'simp_facs': + ''' + if kopt!='free' and kopt!='n' and kopt!='forze_subs': + if kopt!='forze_subs': + karg=ksym.args + klist=list(karg) + knum=len(klist) + kres=ksym + done=False + if kopt=='h': + kres=kres.subs(op2,op3) + print(op2,op3,kres.subs(op2,op3)) + + + if kopt=='n': + if type(ksym)==int or type(ksym)==float: + kres=0 + done=True + elif type(ksym)==Symbol: + kres=1 + done=True + + else: + kres=len(ksym.args) + done=True + + if kopt=='list': + if type(ksym)==int or type(ksym)==float: + kres=[] + done=True + elif type(ksym)==Symbol: + + mm=[] + mm.append(ksym) + + kres=mm + done=True + elif op2=='poly': + if Is_Mono(ksym): + if not Is_Poly(ksym): + kres=[ksym] + done=True + + else: + karg=ksym.args + kres=list(karg) + done=True + + if kopt=='get': + kres=(klist[op2]) + done=True + if kopt=='get_inv': + kres=(klist[op2]) + kres=kres**-1 + done=True + if kopt=='gets': + done=True + for i in op2: + nsym=klist[int(i)] + if done: + mm=nsym + done=False + else: + mm=mm+nsym + kres=(mm) + done=True + if kopt=='getp': + mm=1 + for i in op2: + nsym=klist[int(i)] + mm=mm*nsym + kres=(mm) + done=True + if kopt=='free': + try: + kres=(list(ksym.free_symbols )) + done=True + except: + kres=[] + done=True + + + if kopt=='frees': + vsym=fpoly(ksym,'free') + vsyms=[] + for i in vsym: + vsyms.append(str(i)) + kres=vsyms + if kopt=='filt' and op2!='': + kres=0 + for i in fpoly(ksym,'list'): + if op2 in fpoly(i,'free'): + kres=kres+i + + if kopt=='filtp' and op2!='': + kres=0 + for i in fpoly(ksym,'list'): + if op2 in fpoly(i,'free'): + kres=kres+i + + if kopt=='unfilt' and op2!='': + kres=0 + for i in fpoly(ksym,'list'): + if op2 not in fpoly(i,'free'): + kres=kres+i + + + if kopt=='frac2sum': + kres=klist + + kq0=klist[0] + kq1=kq0.args[0] + kq2=klist[1] + kres=(kq2,kq1) + + done=True + if kopt=='rqt': + kstr='1/'+str(op2) + kres=Pow(ksym,S(kstr)) + if kopt=='lam': + kres=lambdify(op2,ksym) + if kopt=='simpow': + kres=pow(fpoly(ksym,'get',0).args[0],fpoly(ksym,'list')[0].args[1]*fpoly(ksym,'get',1)) + if kopt=='zubs': + kres=ksym.subs(op2,op3) + if kopt=='zubsV': + for i, j in zip(op2,op3): + kres=kres.subs(i,j) + + if kopt=='facmono': + klist=poly(ksym,'list') + mm=0 + for i in klist: + if op2 in fpoly(i,'free'): + mm=mm+i + kres=mm + if kopt=='in_allexp': + bres=True + klist=fpoly(ksym,'list') + for i in klist: + if op2 not in fpoly(i,'free'): + bres=False + kres=bres + + if kopt=='simp_fac': + newm=0 + oldm=0 + klist=fpoly(ksym,'list') + kvvar=fpoly(ksym,'free') + kvar=fpoly(op2,'free') + kvar=kvar[0] + for i in klist: + kres1=fpoly(i/op2,'free') + if kvar not in kres1: + newm=newm+i/op2 + else: + oldm=oldm+i + if op3==1: + kres=(newm) + elif op3==2: + kres=(oldm) + elif op3==0: + kres=(op2*newm) + else: + kres=op2*(newm)+oldm + + if kopt=='simp_facs': + + kres=ksym + skres=0 + veck=op2 + for op2 in veck: + + klist=fpoly(kres,'list') + km1=0 + km2=0 + for i in klist: + try: + mm= fpoly(i,'list') + if len(mm)>0: + if op2 in mm: + #print(mm) + km1=km1+i/op2 + km2=km2+i + except: + done=False + kres=kres-km2 + skres=skres+op2*km1 + skres=skres+(kres) + kres=skres + + if kopt=='list_tree': + mm=[] + kres=mm + for i in fpoly(ksym,'list'): + mm.append(short_type_name(i)) #mm.append(short_type_name(i)) + kres=mm + + if kopt=='get_type': + kres=short_type_name(ksym) + + + if kopt=='forze_subs': + + kexp=parse_expr(str(ksym)) + ksym=parse_expr(str(op2)) + kval=parse_expr(str(op3)) + kres=kexp.subs(ksym,kval) + + if kopt=='if_have': + + klist=fpoly(ksym,'list') + ksym=unisymbols(op2) + kres=0 + for i in klist: + vsym=fpoly(i,'free') + if unisymbols(ksym) in vsym: + kres+=i + if kopt=='simplypol': + klist=fpoly(ksym,'list') + kres=0 + for i in klist: + kres+=opemat(i,kope=op2) + + + return(kres) + +# # factorizar Polinomios lineales +def getargs(kres,*args): + if kres=='': + helplib('getargs') + return + return get_args(kres=kres,*args) + +def get_args(kres,*args): + + for i in args: + kres=kres.args[i] + return kres +def get_factor_with(eqq,kx,kcomple=True): + mm=fpoly(eqq,'list') # gcf(2*x*x+3*L*x+2*x+4,x) return (3*L+2) + kres=0 + for i in mm: + try : + newm=fpoly(i,'list') + if kx in newm: + if kcomple: + kres+=i/kx + else: + kres+=i + except: + pass + return kres + +def get_rest(eqq,kx): + mm=fpoly(eqq,'list') # gcf(2*x*x+3*L*x+2*x+4,x) return (3*L+2) + kres=0 + for i in mm: + try : + vhay=fpoly(i,'free') + if kx not in vhay: + kres+=i + except: + pass + return kres +def numerexpand(expr): + p1,p2=fraction(expr) + p1=expand(p1) + return cfrac(p1,p2) +def numerfactor(expr): + p1,p2=fraction(expr) + p1=factor(p1) + return cfrac(p1,p2) +def numersimplify(expr): + p1,p2=fraction(expr) + p1=simplify(p1) + return cfrac(p1,p2) +def denoexpand(expr): + p1,p2=fraction(expr) + p2=expand(p2) + return cfrac(p1,p2) +def denofactor(expr): + p1,p2=fraction(expr) + p2=factor(p2) + return cfrac(p1,p2) +def denosimplify(expr): + p1,p2=fraction(expr) + p2=simplify(p2) + return cfrac(p1,p2) + + +def factorize(expr,fexpr): + return factors(expr,fexpr) + +def factors(expr,kfac): + if Is_Add(expr): + p1=0 + p2=0 + for i in expr.args: + kres=simplify(i/kfac) + if denom(kres)==1: + p2=p2+simplify(i/kfac) + else: + p1=p1+i + if type(p2)==Add: + return p1+Mul(kfac,p2,evaluate=False) + else: + return expr + elif Is_Mul(expr): + if not Is_Poly(expr): + kres=1 + for i in expr.args: + if '+' in str(i) or '-' in str(i): + kres=kres*factors(i,kfac) + return kres + else: + return expr + elif Is_Div(expr): + p1,p2=fraction(expr) + return factors(p1,kfac)/factors(p2,kfac) + elif Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb=factors(bb,kfac) + return bb**ee + elif Is_Root(expr): + bb=getbase(expr) + ee=getroot(expr) + bb=factors(bb,kfac) + return rpow(bb,ee) + else: + return expr +def factoriza(expr,*args): + kres=expr + for i in args: + kres=factoriza2(kres,i) + return kres + +def factoriza2(expr,fexpr): + if Is_Add(expr): + return factorize(expr,fexpr) + elif Is_Div(expr): + knum,kden=fraction(expr) + p1=factorize(knum,fexpr) + p2=factorize(kden,fexpr) + return p1/p2 + elif Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb2=factorize(bb,fexpr) + return bb2**ee + elif Is_Mul(expr): + if '+' in str(expr): + kres=1 + for i in expr.args: + kres=kres*factorize(i,fexpr) + return kres + else: + return expr + else: + return expr +def dfactor(expr,var,var1,op=''): + ''' + input diff expr( dx/dt then var=t, var1=x + op= like factorize + dD2=diff(x,t,t) + dD1=diff(x,t) + dD=x(t) + + ''' + Da2,Da1,Da=simplediff(var,var1) + sexpr=str(expr) + sD2=str(Da2) + sD1=str(Da1) + sD=str(Da) + sexp=str(expr) + sexp=sexp.replace(sD2,'dD2') + sexp=sexp.replace(sD1,'dD1') + sexp=sexp.replace(sD,'dD') + dD2,dD1,dD=symbols('dD2 dD1 dD') + exp2=parse_expr(sexp) + if op!='': + mode=parse_expr(op) + exp2=factorize(exp2,mode) + else: + exp2=factor(exp2) + + exp2=exp2.subs(dD2,Da2) + exp2=exp2.subs(dD1,Da1) + exp2=exp2.subs(dD,Da) + return(exp2) + +def dsimplify(expr,var,var1): + ''' + input diff expr( dx/dt then var=t, var1=x + op= like factorize + dD2=diff(x,t,t) + dD1=diff(x,t) + dD=x(t) + + ''' + Da2,Da1,Da=simplediff(var,var1) + sexpr=str(expr) + sD2=str(Da2) + sD1=str(Da1) + sD=str(Da) + sexp=str(expr) + sexp=sexp.replace(sD2,'dD2') + sexp=sexp.replace(sD1,'dD1') + sexp=sexp.replace(sD,'dD') + dD2,dD1,dD=symbols('dD2 dD1 dD') + exp2=parse_expr(sexp) + + + exp2=simplify(exp2) + + + exp2=exp2.subs(dD2,Da2) + exp2=exp2.subs(dD1,Da1) + exp2=exp2.subs(dD,D) + return(exp2) +def factorSec(kEq,ksym,kfiltro='.'): + if type(ksym)==list: + return MgrupFac(kEq=kEq,ksym=ksym,kfiltro=kfiltro) + else: + return grupFac(kEq=kEq,ksym=ksym,kfiltro=kfiltro) + +def grupFac(kEq,ksym,kfiltro='.'): + return My_factor(kEq=kEq,ksym=ksym,kfiltro=kfiltro) + + +def part(expr,address): + r""" + Returns part of an expression + + Arguments + --------- + expr : sympy expression + address : (list of integers) indexes of the part + of the expression tree to be recovered + Returns + ------- + requested part of the expression tree + """ + for num in address: + expr = expr.args[num] + return expr + +def inpart(expr,repl,address): + r""" + Replaces a part of the tree of an expression (and returns + the copy) + + Arguments + --------- + expr: (sympy expression) expression to be intervened + repl: (sympy expression) modified part of the expression + address: (list of integers) indexes of the part of the + expression tree to be replaced (see 'part()') + Returns + ------- + new expression with the replacement done + """ + if len(address) == 1: + largs = list(expr.args) + largs[address[0]] = repl + return expr.func(*largs) + else: + largs = list(expr.args) + largs[address[0]] = inpart(expr.args[address[0]],repl,address[1:]) + new = expr.func(*largs) + return new + +def cpart(expr,address): + r""" + makes easier to visualize walking the tree. It returns a set of two expressions: + the original expression with the part located by 'address' substituted + by the symbol 'PIECE' and the part requested. + """ + PART = Symbol(r'{\color{red}{PART}}') + return Set(inpart(expr,PART,address),part(expr,address)) + +def kreturn(ksym): + unisymbols(ksym) + + +##################### +# Differential +##################### + + +# Fix sympy functions to not have problem whit difernet value to same symbols +def kdiff(ksym,kvar,kope=''): # Force differential + + ksym=unisymbols(ksym) + kvar=unisymbols(kvar) + kres=diff(ksym,kvar) + kres=opemat(kres,kope) + return kres + +def kintegrate(ksym,kvar,kope=''): # force integration + ksym=unisymbols(ksym) + kvar=unisymbols(kvar) + + kres=integrate(ksym,kvar) + kres=opemat(kres,kope) + return kres + + +##################### +# Substitution +##################### + + +def ksubs (ksym,kval,nkval,kope=''): + ksym=unisymbols(ksym) + kval=unisymbols(kval) + nkval=unisymbols(nkval) + kres=ksym.subs(kval,nkval) + kres=opemat(kres,kope) + return kres + +def psimplify(ksym,op1='',op2='',kope=''): + ksym=unisymbols(ksym) + kres=operacion(ksym,op1=op1,op2=op2,kope=kope) + return kres + + + +##################### +# Verifica (Is) +##################### +def typedata(ksym): # typedata((x*x*5)/8) return + kres=' ' + if Is_Symbol(ksym): + kres+='Symbol, ' + if Is_Number(ksym): + kres+='Number, ' + if Is_Add(ksym): + kres+='Add, ' + if Is_Mul(ksym): + kres+='Mul, ' + if Is_Pow(ksym): + kres+='Pow, ' + if Is_Div(ksym): + kres+='Div, ' + if Is_Mono(ksym): + kres+='Mono, ' + if Is_Poly(ksym): + kres+='Poly, ' + if Is_Pow2(ksym): + kres+='Pow2, ' + if Is_Root(ksym): + kres+='Root, ' + if Is_Real(ksym): + kres+='Real, ' + if Is_Integer(ksym): + kres+='Integer, ' + if Is_Even(ksym): + kres+='Even, ' + sE([kres]) + + +def allType(ksym,kop='list'): + if kop=='list': + sE([ksym]) + sE(['Is Polynomie = ',Is_Poly(ksym)]); + sE(['Is Symbols= ',Is_Symbol(ksym)]); + sE(['Is Number= ',Is_Number(ksym)]); + sE(['Is Real= ',Is_Real(ksym)]); + sE(['Is Integer= ',Is_Integer(ksym)]); + sE(['Is Even= ',Is_Even(ksym)]); + sE(['Is Odd= ',Is_Odd(ksym)]); + sE(['Is Monomie= ',Is_Mono(ksym)]); + sE(['Is Add= ',Is_Add(ksym)]); + sE(['Is Mul= ',Is_Mul(ksym)]); + sE(['Is Pow=',Is_Pow(ksym)]); + sE(['Is Pow2= ',Is_Pow2(ksym)]); + sE(['Is Root= ',Is_Root(ksym)]) + else: + sE([ksym]) + sE(['Is Polynomie = ',Is_Poly(ksym),' Is Symbols= ',Is_Symbol(ksym),' Is Number= ',Is_Number(ksym)]); + sE(['Is Real= ',Is_Real(ksym),' Is Integer= ',Is_Integer(ksym),' Is Even= ',Is_Even(ksym),' Is Odd= ',Is_Odd(ksym)]); + sE(['Is Monomie= ',Is_Mono(ksym),' Is Add= ',Is_Add(ksym),' Is Mul= ',Is_Mul(ksym)]); + sE(['Is Pow=',Is_Pow(ksym),' Is Pow2= ',Is_Pow2(ksym),' Is Root= ',Is_Root(ksym)]) + sE(['---------------------------------------------------------']) + +def Is_Poly(ksym): + done=True + if Is_Mono(ksym): + done=False + + return done + +def Is_Symbol(expr): + done=False + try: + done=ask((expr).is_Symbol) + return done + except: + return done + + +def Is_notSymbol(ksym): + done=False + try: + done=ask((expr).is_Symbol) + return not done + except: + return done + +def Is_Number(ksym): + try: + mm=float(unisymbols(ksym)) + return True + except: + return False +def Is_PositiveAdd(expr): + if Is_Add(expr): + done=False + for i in expr.args: + if Is_PositiveAdd(i): + done=True + return done + elif Is_Number(expr): + if expr==0: + return True + elif signo(expr)==1: + return True + else: + return False + + elif Is_Mul(expr): + vec=expr.args + mfac=vec[0] + if Is_Number(mfac): + if mfac==0: + return True + elif signo(mfac)==1: + return True + else: + return False + else: + return True + else: + return True +def Is_Real(ksym): + return TrFa(sympify(ksym).is_real) + +def Is_Integer(ksym): + return TrFa(sympify(ksym).is_integer) + +def Is_Even(ksym): + return (sympify(ksym).is_even ) + +def Is_Odd(ksym): + return (sympify(ksym).is_odd ) + +def TrFa(kval): # is True False + if kval==True or kval==False: + return(kval) + else: + return False + +def Is_Mono(ksym): + ksym=expand(ksym) + if type(ksym)==Mul or type(ksym)==Pow or type(ksym)==Symbol: + return True + try: + kn=len(fpoly(ksym,'list0')) + if kn==1: + return True + else: + return False + except: + return False + +def Is_Add(ksym): + kres=ksym + if type(kres)==Add: + return True + else: + return False + +def Is_Mul(ksym): + kres=ksym + if type(kres)==Mul: + return True + else: + return False + +def Is_NMul(ksym): + kres=ksym + if Is_Mul(kres): + if ksym.args[0]==-1: + return True + return False + +def Is_PowPow(expr): + if Is_Pow(expr): + base=getbase(expr) + if Is_Pow(base): + return True + return False + +def Is_MulPow(expr): + if Is_Mul(expr): + if 'Pow' in srepr(denom(expr)): + return True + if 'Pow' in srepr(numer(expr)): + return True + return False + +def Is_NPow(ksym): + if type(ksym)==Mul: + if ksym.args[0]==-1: + if Is_Pow(ksym.args[1]): + return True + return False + +def Is_Pow(ksym): + kres=ksym + + + if type(kres)==Mul: + if kres.args[0]==-1: + if Is_Pow(kres.args[1]): + return True + + elif type(kres)==Pow : + return True + else: + return False + +def Is_Pow2(ksym): + try: + mm=fpoly(ksym,'list') + p1=mm[0] + p2=mm[1] + except: + return False + + if type(ksym)==Pow and p2==2: + return True + else: + return False +def Is_NumberPow(expr): + done=False + if Is_Pow(expr): + bb=getbase(expr) + if Is_Number(bb): + done=True + return done + +def Is_Log(ksym): + if type(ksym)==log: + return True + else: + return False + + + + +def Is_Root(expr): + if Is_Pow(expr): + aa,bb=expr.args + if denom(bb)!=1: + return True + return False + + + +def Is_MonoMul(ksym): + if type(ksym)==type(expand(ksym)): + return True + else: + return False + +def Is_NMono(expr): + if not Is_Add(expr): + try: + mm=expr.args + if Is_Number(mm[0]) and signo(mm[0])==-1: + return True + except: + return False + return False + +def Is_MonoPoly(ksym): + return not Is_MonoMul(ksym) + +def Is_Integral(ksym): + mm=str(ksym.args) + if (mm[-3::])==',))': + return True + else: + return False + +def Is_Div(ksym): + pi,p2=fraction(ksym) + if p2!=1: + return True + else: + return False + +def Is_Inversa(expr): + if Is_Div(expr): + p1,p2=fraction(expr) + if p1==1 or p1==-1: + return True + return False +def Is_Inverse(expr): + if Is_Div(expr): + p1,p2=fraction(expr) + if p1==1 or p1==-1: + return True + return False + +def Is_Diff(expr): + vec=list(expr.free_symbols) + svec=[str(i) for i in vec] + done=False + for i in svec: + if len(i)>1: + if i[0]=='d': + done=True + return done + +def Is_TrigFunc(expr): # return True if expr = sin(alpha), cos(x)...etc + vec=['sin','cos','tan','ctg','sec','csc'] + if str(type(expr)) in vec: + return True + return False +def Is_PowTrigFunc(expr): # return True if expr = sin(alpha)**2, cos(x)**z...etc + if Is_Pow(expr): + bb=getbase(expr) + if Is_TrigFunc(bb): + return True + return False + return False + if str(type(expr)) in vec: + return True + return False + +def Is_Sin(expr): # return True if expr = sin(alpha), + if type(expr)==sin: + return True + return False +def Is_Cos(expr): # return True if expr = scos(alpha), + if type(expr)==cos: + return True + return False +def Is_PowSin(expr): # return True if expr = sin(alpha)**y, + if Is_PowTrigFunc(expr): + bb=getbase(expr) + if Is_Sin(bb): + return True + return False + return False +def Is_PowCos(expr): # return True if expr = cos(alpha)**y + if Is_PowTrigFunc(expr): + bb=getbase(expr) + if Is_Cos(bb): + return True + return False + return False +def Is_PowRoot(obj): + done=False + if Is_Pow(obj) and Is_Root(obj): + done=True + return done +def Is_ExpRoot(expr): + done=False + if Is_Root(expr): + b=insideroot(expr) + if type(b)==exp: + done=True + return done +####################################### +### Fix Trigomo,etrisc subs functions + +def fixremptrig(ksym,alpha,kkval): + valsin=sin(kkval) + valcos=cos(kkval) + msym=[kpow(sin(alpha),x) for x in range(4)] + vsym=[kpow(valsin,x) for x in range(4)] + kres=ksym + for i,j in zip(msym,vsym): + kres=kres.subs(i,j) + msym=[kpow(cos(alpha),x) for x in range(4)] + vsym=[kpow(valcos,x) for x in range(4)] + for i,j in zip(msym,vsym): + kres=kres.subs(i,j) + return kres + valsin=opemat(sin(alpha1),'v') + msym=[kpow(sin(alpha1),x) for x in range(4)] + vsym=[opemat(kpow(valsin,x),'v') for x in range(4)] + +def simplifac(p1,p2): + p1=factor(p1) + p2=factor(p2) + try: + if (Is_Mul(p1) and Is_Symbol(p2)) or (Is_Mul(p2) and Is_Symbol(p2)) or (Is_Mul(p2) and Is_Mul(p2)): + mm1=fpoly(p1,'list') + mm2=fpoly(p2,'list') + P1=p1 + P2=p2 + TF1=False + TF2=False + Nu1=0 + Nu2=0 + for i in mm1: + if Is_Number(i): + TF1=True + Nu1=i + for i in mm2: + if Is_Number(i): + TF2=True + Nu2=i + if TF1 and TF2: + Nu3=min(Nu1,Nu2) + p1=p1/Nu3 + p2=p2/Nu3 + P1=p1 + P2=p2 + mm1=fpoly(P2,'free') + mm2=fpoly(P1,'free') + for i in mm1: + if i in mm2: + grade1=degree(P1,gen=i) + grade2=degree(P2,gen=i) + + grade3=min(grade1,grade2) + nfac=i**grade3 + p1=p1/nfac + p2=p2/nfac + return p1,p2 + else: + return p1,p2 + except: + return p1,p2 +def simpliadd(p1,p2): + P1=p1 + P2=p2 + + if Is_Add(p1) or Is_Add(p2): + mm1=fpoly(p1,'list') + mm2=fpoly(p2,'list') + mm3=fpoly(p1,'list') + + + for i in mm3: + if i in mm1: + p1=p1-i + p2=p2-i + + + return p2,p1 +def simplifyr(ksym): + kres=ksym + kres=simplify(kres*kres) + kres=rpow(kres,2) + return kres + + + + + +def lexp_simplify(ksym): + sksym=str(ksym) + if 'log(exp(' in sksym: + kint=insidepar(insidepar(kk,'log(exp('),'exp(') + skint=str(kint) + tkill='log(exp('+skint+'))' + sksym=sksym.replace(tkill,skint) + return parse_expr(sksym) + else: + return ksym + + + + +def fix_sqrt2pow(ksym): + try: + kres=ksym + mm=str(ksym) + mm1= mm.replace('**2','**1') + mm2=mm1.replace('sqrt(','(') + mm3=parse_expr(mm2) + return mm3 + except: + return ksym + +def positivediv(expr): + ''' + input (-x-4)/(x+1) return (-x-4)/(x+1) + input (-x-4)/(x-1) return (x+4)/(1-x) + input (-x-4)/(-x-1) return (x+4)/(x+1) + ''' + if Is_Div(expr): + p1=numer(expr) + p2=denom(expr) + if not Is_PositiveAdd(p1): + if not Is_PositiveAdd(p2): + return simplifysigno(expr) + else: + return changesignodiv(expr) + else: + return expr + else: + return expr + +def rationalize(expr): + if Is_Div(expr): + return positivediv(radsimp(expr)) + elif Is_Add(expr): + kres3=0 + for i in expr.args: + kres3=kres3+rationalize(i) + return kres3 + elif Is_Mul(expr): + kres4=1 + for i in expr.args: + kres4=kres4*rationalize(i) + return kres4 + else: + return expr + +def tintegral_def(keq,alpha,a1,a2,kope=''): + kfun=kintegrate(keq,alpha) + val1=fixremptrig(kfun,alpha,a1) + val2=fixremptrig(kfun,alpha,a2) + kres=val2-val1 + kres=opemat(kres,kope=kope) + return kres + + +def change_diff(ksym,y,x,newQ=''): # ksym =Integral func, y old v,x =mew v, new Func + if Is_Integral(ksym): + + Isol=ksym.doit() + if newQ!='': + Isol=Isol.subs(y,newQ) + else: + Isol.subs(y,x) + return Integral(Isol,x) + else: + return ksym + +def cut_fac(ksym,kval): + if type(ksym)==Mul: + return(simplify(unisymbols(ksym/kval))) + elif type(ksym)==Add: + mlist=fpoly(ksym,'list') + mm=0 + for i in mlist: + mm+=cut_fac(i,kval) + return mm + +def cut_root2(ksym,kval): + kk2='sqrt('+str(kval)+'**2)' + if ksym!=0: + try: + if type(ksym)==Mul: + kk= str(ksym) + + kk3=kk.replace(kk2,str(kval)) + ksol=parse_expr(kk3) + return ksol + if type(ksym)==Add: + nksym=0 + mm=fpoly(ksym,'list') + for i in mm: + nksym+=cut_root2(i,kval) + + return nksym + except: + return ksym + else: + return ksym + + + + +class MyTriang: + def __init__(self, hipo='',cat1='',cat2='',kope=''): + + self.khipo=hipo + self.kcat1=cat1 + self.kcat2=cat2 + + if hipo=='': + kres=get_hipo(cat1,cat2) + self.khipo=opemat(kres,kope=kope) + if cat2=='': + kres=get_cateto(hipo,cat1) + self.kcat2=opemat(kres,kope=kope) + if cat1=='': + kres=get_cateto(hipo,cat2) + self.kcat1=opemat(kres,kope=kope) + + def sin(self,kope=''): + hipo=self.khipo + cat1=self.kcat1 + kres=cat1/hipo + kres=opemat(kres,kope=kope) + + return kres + + def cos(self,kope=''): + hipo=self.khipo + cat2=self.kcat2 + kres=cat2/hipo + kres=opemat(kres,kope=kope) + + return kres + + def tan(self,kope=''): + cat1=self.kcat1 + cat2=self.kcat2 + kres=cat1/cat2 + kres=opemat(kres,kope=kope) + + return kres + + def hipo(self,kope=''): + kres=self.khipo + + return kres + + def cat1(self,kope=''): + kres=self.kcat1 + + return kres + + def cat2(self,kope=''): + kres=self.kcat2 + + return kres + + def s(self): + sE(['sin()=',self.sin(),' cos()=',self.cos(),'tan()=',self.tan()]) + + +def sqrt2fracpow(expr): + return(signed_sqrt(expr)) + +def signed_sqrt(expr): # This function from WenyinWei founded in GitHub + """Signed sqrt operator + Args: + expr (sympy.expr): sympy expression + Returns: + sympy.expr: A simplified expression + """ + + + expr = expr.factor() + # recurse the function on each arg if the top function is a multiplication + # e.g. signed_sqrt( 4 * b^2 ) == 2 * b + if expr.func == Mul: + args_signed_sqrt = [signed_sqrt(arg) for arg in expr.args] + return reduce(Mul, args_signed_sqrt) + elif expr.func == Pow: + base, exponent = expr.args + if exponent.is_even: + return base**(exponent/2) + return sqrt(expr) + + +def fixrootpow(expr,k=''): + if k=='': + expr=fixrootpow(expr,2) + expr=fixrootpow(expr,3) + return expr + else: + sres=str(expr) + snum=str(k) + srot='**'+snum+')**(1/'+snum+')' + if srot in sres: + sres=sres.replace(srot,')') + nexpr=parse_expr(sres) + return nexpr + else: + return expr + +def KrP(ksym,kope=''): + return kill_root_mono(ksym,kope=kope) + +def kill_root_mono(ksym,kope=''): # kill root(pow(ksym)) if Is_Mono(ksym) = True + + if Is_Root(ksym): + kres= signed_sqrt(ksym*ksym) + else: + kres= ksym + + return kres + +def kill_root_poly(ksym,kope=''): # kill root(pow(ksym1)) + root(pow(ksym1)) if Is_Poly(ksym) = True + if Is_Poly(ksym): # ksym=ksym1+ksym2+ .... + mm=0 + vksym=fpoly(ksym,'list') + for i in vksym: + mm+=kill_root_poly(i,kope='') + mm=opemat(mm,kope=kope) + return mm + elif Is_Mul(ksym): # ksym=ksym1+ksym2+ .... + kt=1 + vksym=fpoly(ksym,'list') + for i in vksym: + kt*=kill_root_poly(i) + + return kt + else: + kres=kill_root_mono(ksym,kope='') + return kres + +''' +def sin2cos(ksym,angu,korden=2,kope=''): + e1=unisymbols(ksym) + e1=e1.subs(unisymbols(kpow(sin(angu),4)),(unisymbols(kpow(sin(angu),2)*kpow(sin(angu),2)))) + e1=e1.subs(unisymbols(kpow(sin(angu),3)),(unisymbols(kpow(sin(angu),2)*sin(angu)))) + e1=e1.subs(unisymbols(kpow(sin(angu),2)),(unisymbols(1-kpow(cos(angu),2)))) + if korden==1: + e1=e1.subs(unisymbols(sin(angu)),(unisymbolsrpow(1-kpow(cos(angu),2))) ) + + kres=e1 + kres=opemat(kres,kope=kope) + return kres +''' +def sin2cos(expr,ang=alpha): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+sin2cos(i,ang=ang) + return kres + elif Is_Div(expr): + p1,p2=fraction(expr) + return sin2cos(p1,ang=ang)/sin2cos(p2,ang=ang) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*sin2cos(i,ang=ang) + return kres + elif Is_PowSin(expr): + ee=getexpo(expr) + resto=ee%2 + nee=float2int((ee-resto)/2) + if resto>0: + kres=(1-cos(ang)**2)**nee*sin(ang) + else: + kres=(1-cos(ang)**2)**nee + return kres + else: + return expr + +''' +def cos2sin(ksym,angu,korden=2,kope=''): + e1=unisymbols(ksym) + e1=e1.subs(unisymbols(kpow(cos(angu),4)),unisymbols((kpow(cos(angu),2)*kpow(cos(angu),2)))) + e1=e1.subs(unisymbols(kpow(cos(angu),3)),unisymbols((kpow(cos(angu),2)*cos(angu)))) + e1=e1.subs(unisymbols(kpow(cos(angu),2)),unisymbols((1-kpow(sin(angu),2)))) + if korden==1: + e1=e1.sub(unisymbols(cos(angu)),unisymbols(rpow(1-kpow(sin(angu),2)))) + + kres=e1 + kres=opemat(kres,kope=kope) + return kres +''' +def cos2sin(expr,ang=alpha): + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+cos2sin(i,ang=ang) + return kres + elif Is_Div(expr): + p1,p2=fraction(expr) + return cos2sin(p1,ang=ang)/cos2sin(p2,ang=ang) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*cos2sin(i,ang=ang) + return kres + elif Is_PowCos(expr): + ee=getexpo(expr) + resto=ee%2 + nee=float2int((ee-resto)/2) + if resto>0: + kres=(1-sin(ang)**2)**nee*cos(ang) + else: + kres=(1-sin(ang)**2)**nee + return kres + else: + return expr +def tan2sincos(expr,ang=alpha): + resu=str(expr.subs(tan(ang),sin(ang)/cos(ang))) + return parse_expr(resu,evaluate=False) + +def MaT(x,y=''): + if y=='': + y=x[1] + x=x[0] + return(Matrix([[x,y]])) + +def moduloMat(kMat): + xx1=kMat[0] + yy1=kMat[1] + + return get_hipo(xx1,yy1) + + +# algebra +def sortPoly(ksym,kvar,kindi): + kres=ksym + for i in range(kindi): + kres=factorSec(kres,kpow(kvar,i+1)) + + return kres + + + # Diccionario +def unpack(mm): + return kunpakDic(mm=mm) + +def kunpakDic(mm): + + kkey=list(mm.keys()) + kvalu=list(mm.values()) + + return( kkey,kvalu) + +####################### +## used by MyEq +####################### + +def multiSet(ksym, kval, vecEq=[]): + if type(ksym) == list: + for i, j in zip(ksym, kval): + for kQ in vecEq: + kQ.setValue(i, j, kshow=False) + else: + for kQ in vecEq: + kQ.setValue(ksym, kval, kshow=False) + + for i in vecEq: + i.s() + +def multiRedFac(kvec=[]): + for i in kvec: + i.reduFac() + i.s() + +# convinaciones de soluciones +def solveFrom(eeV,ssV,kope=''): + vec1=[x() for x in eeV] + kres= solve(vec1,ssV) + kres1=[opemat(x,kope=kope) for x in kres] + kres2=kres1[0] + mainres=[] + for i ,j in zip(kres2,ssV): + mainres.append(i) + ee=MyEq(i,j.name,kshow=False,kope=kope) + ee.s() + return mainres +#def solve2sysEq(kvar=[], keq=[], kname=[]): + +def killPwise(sksym): # Kill otherwise answer in simple str + kres=sksym + if 'Piecewise' in kres: + x1=sksym.find('Piecewise(') + x2=x1+len('Piecewise(') + x3=sksym.find(', Ne(') + x4=sksym.find('True)') + x5=x4+len('True)') + kres=sksym[0:x1]+sksym[x2:x3]+sksym[x5::] + return kres + +def fix_otherwise(ksym,kop=''): # Kill otherwise answer in answer + kres2=ksym + if kop=='odb': + ksym=ksym.rhs + + mm=fpoly(ksym,'list') + kres='' + done=True + kk='+' + for i in mm: + ss=str(i) + if done: + kres+=killPwise(ss) + done=False + else: + kres+='+'+killPwise(ss) + try: + return unisymbols(parse_expr (kres)) + except: + return kres2 + + +####################### +## used by MyInteger +####################### + + +def Ope2Inte(e1,e2,kope='Add'): + ope1=e1.kinte + ope2=e2.kinte + if kope=='Mul': + return ope1*ope2 + elif kope=='Div': + return ope1/ope2 + + else: + return ope1+ope2 + +def opeInteSolu(val1,val2,kope='Add'): + if kope=='Mul': + return val1*val2 + elif kope=='Div': + return val1/val2 + + else: + return val1+val2 + +def miniopI(val1,val2,ktype='Add'): + if ktype=='Mul': + return val1.kinte*val2.kinte + elif ktype=='Div': + return val1.kinte/val2.kinte + else: + return val1.kinte+val2.kinte + + + +############## LAtex +def lxprint(*args): + vec='' + for i in args: + if type(i)==str: + vec+= i+'\;' + else: + vec+= latex(i)+'\;' + display(Math(vec)) + +def symb_diff(*args): + kres='' + for i in args: + kres=kres+' d'+alphaname(i) + return kres + +def diff_name(ksym): + kres='d_'+ alphaname(ksym) + return kres + +def diff_name_prima(ksym): + kres=alphaname(ksym)+"'" + return kres + +def diffname(k1,k2): + if type(k1)!=str: + k1=k1.name + k1=alphaname(primitivename(k1)) + k2=alphaname(primitivename(k2)) + xx='d_'+k1 + tt='d_'+k2 + xkname='\\frac{'+xx+'}{'+tt+'}' + return xkname + +def difffuncname(kfunc,ksym): + kres='d'+alphaname(kfunc)+'('+alphaname(ksym)+')' + return kres + +def funcname(kfunc,ksym): + kres=alphaname(kfunc)+'('+alphaname(ksym)+')' + return kres + +# def diffname(ksym): + # kres='d'+ alphaname(ksym) + # return kres +def clean_underline(ksym): + sres=str(ksym) + sres=sres.replace('_','') + return sres + +def alphasubname(ksym,op=1): + aaname=alphaname(ksym) + aaname=aaname+'_'+str(op) + return aaname + + + +def eQrec(x1=0,y1=0,x2=0,y2=0,var2=''): + mm=frs((y2-y1),(x2-x1)) + bb=y2-x2*mm + kres=opemat(var2*mm+bb,'s') + return kres + +def diffvariable(k1,k2): + return get_diff_name(k1,k2) + +def get_diff_name(k1,k2): + k1=alphaname(k1) + k2=alphaname(k2) + xx='d_'+k1 + tt='d_'+k2 + xt='\\frac{'+xx+'}{'+tt+'}' + dxt=symbols(xt) + return dxt + +def difvar(*args): #crea variables dieferenciables + + mm=[] + for i in args: + sres='d'+diffsymbol(i) + mm.append(symbols(sres)) + return mm + + + +def Cg2func(f1,f2,x,x1,x2): + Area=integrate(f1,(x,x1,x2))-integrate(f2,(x,x1,x2)) + X=integrate((f1-f2)*x,(x,x1,x2)) + X=X/Area + + Y=integrate((f1-f2)*(f1+f2)/2,(x,x1,x2)) + Y=Y/Area + return X,Y + +def findSubFunc(ksym,sval,inside=''): + + kini=0 + kini2=0 + sroot=[] + done=0 + while kini","","","",""] +def arglist(expr,deep=3): + + infoexpr=[] + infopos=[] + cc='' + A,B,C,D=ruta(expr,infoexpr,infopos,cc) + BC=[[i,j] for i,j in zip(B,C) if not Is_NMono(i)] + B1,C1=[],[] + for i in BC: + B1.append(i[0]) + C1.append(i[1]) + BC2=[[i,j] for i,j in zip(B1,C1) if len(j)0: + for i in range(len(mm)): + nexp=mm[i] + npos=cc+str(i) + + if nexp not in infoexpr: + if str(type(nexp)) not in vecreatr : + if nexp not in infoexpr: + if not Is_Number(nexp): + + infoexpr.append(nexp) + infopos.append(npos) + try: + nexp,ninfo,ncc=ruta(nexp,infoexpr,infopos,npos) + return nexp,ninfo,ncc + except: + pass + return expr,infoexpr,infopos,cc + else: + return expr,infoexpr,infopos,cc + +def dothis(*args): + if 'numer' in args or 'denom' in args: + args2=args + expr=args[0] + + done=None + for i in args: + if i=='numer': + done='numer' + if i=='denom': + done='denom' + if Is_Div(args[0]) and done!=None: + p1,p2=fraction(expr) + args2=[i for i in args if i!='numer'] + args3=[i for i in args2 if i!='denom'] + if done=='numer': + args3[0]=p1 + kres=dothis(*args3) + kres=unisymbols(Div(kres,p2)) + else: + args3[0]=p2 + kres= dothis(*args3) + kres=unisymbols(Div(p1,kres)) + + return kres + else: + + expr=args[0] + func=args[1] + if len(args)==2: + try: + sexpr=func+'('+str(expr)+')' + kres=eval(sexpr) + return unisymbols(kres) + except: + + return expr + + if len(args)==3: + try : + expr2=args[2] + sexpr=func+'('+str(expr)+','+str(expr2)+')' + return unisymbols(eval(sexpr)) + except: + + return expr + + + + + + + +# CONJUNTOS +def UnionL(A,B): + C=[x for x in A if x not in B] + return C+B +def SubstracL(A,B): + C=[x for x in A if x not in B] + return C +def IntersecL(A,B): + C=[x for x in A if x in B] + return C + +def maxint(sexpr): + sval='ǁ'+sexpr+'ǁ' + return symbols(sval) + +def supersubs(expr,v1,v2): + done_exp=False + sexpr=str(expr) + if 'exp' in sexpr: + done_exp=True + sexpr=sexpr.replace('exp','M') + sv1=str(v1) + sv2='('+str(v2)+')' + sexpr=sexpr.replace(sv1,sv2) + if done_exp: + sexpr=sexpr.replace('M','exp') + return parse_expr(sexpr) + +def trinom2binom(expr,sexpr): + fexpr=factor(sexpr) + expr=expr.subs(sexpr,AA) + expr=expr.subs(AA,fexpr) + return expr + +def float2int(expr): + if type(expr)==list: + kres= [float2int(i) for i in expr] + return kres + elif type(expr)==tuple: + kres= [float2int(i) for i in expr] + return tuple(kres) + elif Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+float2int(i) + return kres + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*float2int(i) + return kres + elif Is_Pow(expr): + bb,ee=partpow(expr) + kres=(float2int(bb))**float2int(ee) + return kres + + else: + sexpr=str(expr) + p1=sexpr.find('.') + sexpr2=sexpr[p1+1::] + sexpr3=sexpr2.replace('0','') + if sexpr3=='': + return int(expr) + return expr + +def realang2point(x1,y1,x2,y2): + xx=x2-x1 + yy=y2-y1 + try: + if xx==0 and yy!=0: + if yy>0: + ang=pi/2 + return ang + else: + ang=-pi/2 + return ang + elif yy==0 and xx!=0: + if xx>0: + ang=0 + else: + ang=pi + else: + ang=atan(float2int(yy/xx)) + if yy>=0 and xx<0: + ang=ang+pi + elif yy<0 and xx<0: + ang=ang+pi + else: + pass + return ang + except: + return atan(yy/xx) + +def get_super(x): + normal = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-=()" + super_s = "ᴬᴮᶜᴰᴱᶠᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾQᴿˢᵀᵁⱽᵂˣʸᶻᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏˡᵐⁿᵒᵖ۹ʳˢᵗᵘᵛʷˣʸᶻ⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾" + res = x.maketrans(''.join(normal), ''.join(super_s)) + return x.translate(res) + +def numbershort(expr,nn=0): + if type(expr)==int or type(expr)==float or type(expr)==Integer or type(expr)==Float: + expr=float2int(expr) + sexpr=str(expr) + if '.' in sexpr: + return expr + else: + qq=len(sexpr) + cc=qq-1 + while sexpr[cc]=='0': + cc=cc-1 + p1=sexpr[0:cc+1] + p2=sexpr[cc+1::] + qq2=len(p2) + sres=p1+'·10'+get_super(str(qq2)) + return sres + else: + return expr + +def disp(*args): + expr='' + for i in args: + if type(i)==str: + sexpr=i + sexpr=sexpr.replace(' ', '\;') + expr=expr+'\;'+sexpr + else: + expr=expr+ latex(i) + + display(Math(expr)) + + +def firstdataname(*args): + kname='' + for i in args: + if type(i)==str: + kname=i + return kname + +def partpow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + return getbase(expr),getexpo(expr) + else: + return expr,1 + +def getbase(expr): # return base in expr + ''' + expr = x**y,x*y + return x ,x*y + ''' + + if Is_Pow(expr): + ee=expr.args[0] + return ee + else: + return expr +def getexpo(expr,op=''): # return exponente in expr + if Is_Pow(expr): + mm=expr.args + return mm[1] + + else: + return 1 + + +def changesignodiv(expr): + expr=unisymbols(expr) + if Is_Div(expr): + kn=numer(expr) + kd=denom(expr) + nkn=kn*-1 + nkd=kd*-1 + return unisymbols(cfrac(nkn,nkd)) + else: + return expr + +def simplifysigno(expr): + return simplify(simplify(expr)) + +def checksvarinexpr(expr,svar): + if not svar in str(expr): + svar=svar[0]+'_'+svar[1::] + return svar + +def vecdeletitem(vec,val): + kres=[] + for i in vec: + if i != val: + kres.append(i) + return kres + + +def additems(vec): + kres=0 + for i in vec: + kres=kres+i + return kres + + +def partPow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + if Is_Root(expr): + p1,p2=expr.args + nP=numer(p2) + dP=denom(p2) + bb=p1 + ee=nP + rr=dP + if Is_Pow(bb): + ff=getexpo(p1) + bb=getbase(p1) + ee=ee*ff + else: + ee=getexpo(expr) + bb=getbase(expr) + rr=1 + else: + bb=expr + ee=1 + rr=1 + return bb,ee,rr + + +def Is_e(ksym): + if type(ksym)==exp: + return True + else: + return False +def sDiv(expr1,expr2): + s1=str(expr1) + s2=str(expr2) + return parse_expr('('+s1+')/('+s2+')') +def sum2div(expr): + dvec=[] + nvec=[] + for i in expr.args: + dvec.append(denom(unisymbols(i))) + nvec.append(numer(unisymbols(i))) + dfactor= list2mul(dvec) + + svec=0 + for i,j in zip(nvec,dvec): + nd=simplify(dfactor/j) + nf=nd*i + svec=svec+nf + return cfrac(svec,dfactor) +def add2mul(expr): + mm=expr.args + cc=1 + for i in mm: + if cc==1: + kres=i + cc=cc+1 + else: + kres=kres*i + return kres +def list2mul(vec): + cc=1 + for i in vec: + if cc==1: + kres=i + cc=cc+1 + else: + kres=kres*i + return kres \ No newline at end of file diff --git a/Libaldo/lib_MyDiff.py b/Libaldo/lib_MyDiff.py new file mode 100644 index 0000000..f55b280 --- /dev/null +++ b/Libaldo/lib_MyDiff.py @@ -0,0 +1,2072 @@ + +from sympy import symbols +from functools import reduce +from IPython.display import Math ,display +import matplotlib.pyplot as plt +from libaldo_math2 import * +#from libaldo_show import * +from lib_MyEq import * +from lib_MyEqEq import * +import copy +s=symbols('s') + +class MyDiff(MyEqEq): + def __init__(self,expr1,expr2,v1,v2,ics=''): + self.expr1=expr1 + self.expr2=expr2 + self.v1=v1 + self.v2=v2 + self.ics=ics + self.tics=False + self.eQics='' + self.symb='=' + + if ics!='': + self.tics=True + self.eQics=parse_expr(get_icsexp(ics,v1,v2)) + self.eQdiff=EqDiff(expr1,expr2,v1,v2,kshow=False) + eQdiff=self.eQdiff + self.Ln=eQdiff.lhs + self.Rn=eQdiff.rhs + self.Lp=sympyEq2prime(self.Ln,v1,v2) + self.Rp=sympyEq2prime(self.Rn,v1,v2) + self.e1=MyEq(0,'e1',var=x,kshow=False) + self.e2=MyEq(0,'e2',var=x,kshow=False) + self.e1.ksym=self.Ln + self.e2.ksym=self.Rn + p1=self.Lp + p2=self.Rp + ps=self.symb + display(Math(latex(p1)+' '+ps+' '+latex(p2))) + def s(self): + v1=self.v1 + v2=self.v2 + p1=sympyEq2prime(self.e1.ksym,v1,v2) + + p2=sympyEq2prime(self.e2.ksym,v1,v2) + + ps=self.symb + display(Math(latex(p1)+' '+ps+' '+latex(p2))) + + def dsolve(self,*args): + eQdiff=Eq(self.e1.ksym,self.e2.ksym) + if self.tics: + eQics=self.eQics + ss=dsolve(eQdiff,ics=eQics) + else: + ss=dsolve(eQdiff) + if len(args)>0: + if type(ss)==list: + vecres=[] + for i in ss: + expr1=args[0] + expr2=i.rhs + vecres.append(MyEqEq(expr1,expr2)) + return vecres + else: + expr1=args[0] + expr2=ss.rhs + if type(expr1)==str: + return MyEq(expr2,kname=expr1,var=self.v1) + else: + return MyEqEq(expr1,expr2) + else: + return ss + +class MyEqDiff(MyEqEq): + def __init__(self,*args,ics='',vfunc=[],mark=True): + + self.type='MD' + if type(args[0])==MyEqEq: + expr=args[0] + self.exp1=expr.L + self.exp2=expr.R + self.ode=Eq(expr.L,expr.R) + self.var=args[1] + self.var1=args[2] + self.func=Function(str(self.var1))(self.var) + if len(args)==4: + self.var2=args[3] + self.func2=Function(str(self.var2))(self.var) + self.e1=MyEq(self.exp1,'e1',kshow=False,vfunc=vfunc) + self.e2=MyEq(self.exp2,'e2',kshow=False,vfunc=vfunc) + self.mark=mark + + self.ics2='' + self.equalityDiff=Eq(expr.L,expr.R) + else: + + if len(args)>4: + self.type=2 + self.sexp1,self.sexp2,self.var,self.var1,self.var2=args + + else: + self.sexp1,self.sexp2,self.var,self.var1=args + self.var2='' + + self.mark=mark + self.ics=ics + + self.equalityDiff=EqDiff(*args,kshow=False) + self.exp1=self.equalityDiff.lhs + self.exp2=self.equalityDiff.rhs + self.e1=MyEq(self.exp1,'e1',kshow=False,vfunc=vfunc) + self.e2=MyEq(self.exp2,'e2',kshow=False,vfunc=vfunc) + var1=self.var1 + var2=self.var2 + var=self.var + self.func=Function(str(var1))(var) + self.func1=Function(str(var1))(var) + self.func2=Function(str(var2))(var) + self.ode=self.equalityDiff + self.ics2='' + if ics!='': + self.ics2=parse_expr(get_icsexp(self.ics,self.var,self.var1)) + + if self.mark: + self.dview() + else: + display(Math(latex(self.equalityDiff))) + + + def __call__(self,*args, **kwargs): + eqDiff=self.equalityDiff + display(Math(lates(eqDiff))) + + def __repr__(self): + kres = self.equalityDiff + return kres + + def _latex(self, obj): + return latex(self.equalityDiff) + def __str__(self): + + return str(self.__repr__()) + + @property + def R(self): + return self.equalityDiff.rhs + + @property + def L(self): + return self.equalityDiff.lhs + + @property + def right(self): + return self.equalityDiff.rhs + + @property + def left(self): + return self.equalityDiff.lhs + + + def s(self): + self.exp1=self.e1.ksym + self.exp2=self.e2.ksym + self.ode=Eq(self.exp1,self.exp2) + self.equalityDiff=Eq(self.exp1,self.exp2) + if self.mark: + self.dview() + else: + display(Math(latex(self.equalityDiff))) + + def dviewF(self,kret=False): + var=self.var + var1=self.var1 + var2=self.var2 + if var2!='': + dexpr=easy_diffviewF(self.ode,var,var1,var2) + else: + dexpr=easy_diffviewF(self.ode,var,var1) + modiexp= dexpr.replace('*','.') + display(Math(dexpr)) + if kret: + return dexpr + + def dview(self): + + display(Math(latex(self.diff2mark()))) + + def diff2mark(self): + ''' + expr= Eq() equation equallity + vx= independ variable x + vy= dependent var y(x) + + diff2mark(diff1=diff2,y,x) + + ''' + self.e1.ksym=self.exp1 + self.e2.ksym=self.exp2 + expr=self.equalityDiff + vx=self.var + vy=symbols(str(self.var1)) + dy=symboldiff(self.var1) + dy2=symboldiff2(self.var1) + Y=Function(str(vy))(vx) + + expr=expr.subs(Y.diff(vx,vx),dy2) + expr=expr.subs(Y.diff(),dy) + expr=expr.subs(Y,vy) + if self.var2!='': + + vz=self.var2 + dz=symboldiff(self.var2) + dz2=symboldiff2(self.var2) + Z=Function(str(vz))(vx) + + expr=expr.subs(Z.diff(vx,vx),dz2) + expr=expr.subs(Z.diff(),dz) + expr=expr.subs(Z,vz) + + return expr + + def convert2MQ(self): + kres=[] + Px=[] + Py=[] + + var=self.var + var1=self.var1 + var2=self.var2 + dx=diffsymbol(str(var1)) + dx2=diffsymbol2(str(var1)) + sdX2=str(var1)+"''" + sdX =str(var1)+"'" + + sres= self.dview(kret=True,kshow=False) + if sdX2 in sres: + sres=sres.replace(sdX2,str(dx2)) + Px.append(dx2) + if sdX in sres: + sres=sres.replace(sdX,str(dx)) + Px.append(dx) + + Px.append(dx) + if var2!='': + dy2=diffsymbol2(str(var2)) + sdY2=str(var2)+"''" + if sdY2 in sres: + sres=sres.replace(sdY2,str(dy2)) + Py.append(dy2) + dy=diffsymbol(str(var2)) + sdY=str(var2)+"'" + if sdY in sres: + sres=sres.replace(sdY,str(dy)) + Py.append(dy) + + p1,p2=sres.split('=') + + QQ=MQ(parse_expr(p1),parse_expr(p2)) + kres.append(QQ) + if len(Px)>0: + for i in Px: + kres.append(i) + if len(Py)>0: + for i in Py: + kres.append(i) + + return kres + + + + + def vecdata(self): + vec=[] + if self.type=='MD': + vec.append([self.exp1,self.var,self.var1]) + vec.append([self.exp2,self.var,self.var1]) + + else: + vec.append([self.exp1,self.var,self.var1,self.var2]) + vec.append([self.exp2,self.var,self.var1,self.var2]) + return vec + + + + ########################################### + # Update # + ########################################### + + def __add__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1+other.left + p2=p2+other.right + elif type(other)==MyEq: + p1=p1+other.ksym + p2=p2+other.ksym + + else: + p1=p1+other + p2=p2+other + + return Eq(p1,p2) + + def __radd__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1+other.left + p2=p2+other.right + elif type(other)==MyEq: + p1=p1+other.ksym + p2=p2+other.ksym + + else: + p1=p1+other + p2=p2+other + + return Eq(p1,p2) + + def __sub__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1-other.left + p2=p2-other.right + elif type(other)==MyEq: + p1=p1-other.ksym + p2=p2-other.ksym + + else: + p1=p1-other + p2=p2-other + + return Eq(p1,p2) + + def __rsub__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1-other.left + p2=p2-other.right + elif type(other)==MyEq: + p1=p1-other.ksym + p2=p2-other.ksym + + else: + p1=p1-other + p2=p2-other + + return Eq(p1,p2) + + def __mul__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1*other.left + p2=p2*other.right + elif type(other)==MyEq: + p1=p1*other.ksym + p2=p2*other.ksym + + else: + p1=p1*other + p2=p2*other + + return Eq(p1,p2) + + def __rmul__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1*other.left + p2=p2*other.right + elif type(other)==MyEq: + p1=p1*other.ksym + p2=p2*other.ksym + + else: + p1=p1*other + p2=p2*other + + return Eq(p1,p2) + + + def __truediv__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1/other.left + p2=p2/other.right + elif type(other)==MyEq: + p1=p1/other.ksym + p2=p2/other.ksym + + else: + p1=p1/other + p2=p2/other + + return Eq(p1,p2) + + def __rtruediv__(self, other): + p1=self.L + p2=self.R + if type(other)==MyEqEq: + p1=p1/other.left + p2=p2/other.right + elif type(other)==MyEq: + p1=p1/other.ksym + p2=p2/other.ksym + + else: + p1=other/p1 + p2=other/p2 + + return Eq(p1,p2) + + def update_expr(self): + self.exp1=self.equalityDiff.lhs + self.exp2=self.equalityDiff.rhs + self.e1=MyEq(self.exp1,'e1',kshow=False,vfunc=vfunc) + self.e2=MyEq(self.exp2,'e2',kshow=False,vfunc=vfunc) + + def update_equalityDiff(self): + self.equalityDiff=Eq(self.exp1,self.exp2) + + def update_sexp(self): + if self.type=='MD': + vec=[self.exp1,self.var,self.var1] + self.sexp1=str_diff(*vec) + vec=[self.exp2,self.var,self.var1] + self.sexp2=str_diff(*vec) + else: + vec=[self.exp1,self.var,self.var1,self.var2] + self.sexp1=str_diff(*vec) + vec=[self.exp2,self.var,self.var1,self.var2] + self.sexp2=str_diff(*vec) + def Add(self, kval,kname='',kshow=True ,kop='LR'): + + p1=self.e1.ksym + p2=self.e2.ksym + + kval=traducediff(kval,self.var,self.var1) + + if 'L' in kop: + p1=p1+kval + self.e1.ksym=p1 + if 'R' in kop: + p2=p2+kval + self.e2.ksym=p2 + if kname!='': + QQ=MyEqEq(p1,p2) + return QQ + else: + self.exp1=p1 + self.exp2=p2 + self.update_equalityDiff() + if kshow: + self.s() + + def Substrac(self, kval,kname='', kop='RL',kshow=True ): + p1=self.e1.ksym + p2=self.e2.ksym + + kval=traducediff(kval,self.var,self.var1) + + if 'L' in kop: + p1=p1-kval + self.e1.ksym=p1 + if 'R' in kop: + p2=p2-kval + self.e2.ksym=p2 + if kname!='': + QQ=MyEqEq(p1,p2) + return QQ + else: + self.exp1=p1 + self.exp2=p2 + self.update_equalityDiff() + if kshow: + self.s() + + def Mul(self, kval,kname='', kop='RL',kshow=True ): + p1=self.e1.ksym + p2=self.e2.ksym + + kval=traducediff(kval,self.var,self.var1) + + if 'L' in kop: + p1=p1*kval + self.e1.ksym=p1 + if 'R' in kop: + p2=p2*kval + self.e2.ksym=p2 + if kname!='': + QQ=MyEqEq(p1,p2) + return QQ + else: + self.exp1=p1 + self.exp2=p2 + self.update_equalityDiff() + if kshow: + self.s() + + def Div(self, kval,kname='', kop='RL',kshow=True ): + p1=self.e1.ksym + p2=self.e2.ksym + + kval=traducediff(kval,self.var,self.var1) + + if 'L' in kop: + p1=p1/kval + self.e1.ksym=p1 + if 'R' in kop: + p2=p2/kval + self.e2.ksym=p2 + if kname!='': + QQ=MyEqEq(p1,p2) + return QQ + else: + self.exp1=p1 + self.exp2=p2 + self.update_equalityDiff() + if kshow: + self.s() + + def Pow(self, kval,kname='', kop='RL',kshow=True ): + p1=self.e1.ksym + p2=self.e2.ksym + + kval=traducediff(kval,self.var,self.var1) + + if 'L' in kop: + p1=p1**kval + self.e1.ksym=p1 + if 'R' in kop: + p2=p2**kval + self.e2.ksym=p2 + if kname!='': + QQ=MyEqEq(p1,p2) + return QQ + else: + self.exp1=p1 + self.exp2=p2 + self.update_equalityDiff() + if kshow: + self.s() + + def Rpow(self, kval=2,kname='', kop='RL',kshow=True ): + p1=self.e1.ksym + p2=self.e2.ksym + + kval=traducediff(kval,self.var,self.var1) + + if 'L' in kop: + p1=p1**cfrac(1,kval) + self.e1.ksym=p1 + if 'R' in kop: + p2=p2**cfrac(1,kval) + self.e2.ksym=p2 + if kname!='': + QQ=MyEqEq(p1,p2) + return QQ + else: + self.exp1=p1 + self.exp2=p2 + self.update_equalityDiff() + if kshow: + self.s() + + def showprimitive(self): + vec1,vec2=self.vecdata() + Eqstr=str_diff(*vec1)+'='+str_diff(*vec2) + return Eqstr + + def solvediff(self,*args,kshow=True): + if self.ics!='': + kres= dsolve(self.equalityDiff,ics=parse_expr(get_icsexp(self.ics,self.var,self.var1))) + else: + kres= dsolve(self.equalityDiff) + if kshow: + display(Math(latex(kres))) + if 'F' in args: + return kres.rhs + if 'Eq' in args: + ee=MyEq(kres.rhs,str(kres.lhs),var=self.var) + return ee + else: + return kres + + def dsolve(self,*args): + + L=4 + Id='' + methW=False + myeq=False + kname=str(self.var1) + for i in args: + if i=='Wolfram': + methW=True + if type(i)==str and len(i)>10: + Id=id + + + + if methW: + return self.dsolveWolfram(id=Id) + else: + if self.ics!='': + kres=dsolve(self.ode,ics=self.ics) + + else: + kres=dsolve(self.ode) + + if 'F' in args: + + ee=MyEq(kres.rhs,kname=str(self.var1),var=self.var) + return ee + elif type(kres)==list: + for i in kres: + display(Math(latex(i))) + return ganswer(kres,'value') + elif 'Eq' in args: + QQ=MQ(self.var1,kres.rhs) + return QQ + else: + return kres + def setL(self,expr): + self.e1.ksym=expr + self.s() + def setR(self,expr): + self.e2.ksym=expr + self.s() + + def set(self,swargs): + P=swargs.split(',') + p1=[] + p1=[] + for i in P: + P2=i.split('=') + p1.append(P2[0]) + p1.append(P2[1]) + sexp1=self.sexp1 + sexp2=self.sexp2 + for i,j in zip(p1,p2): + sexp1=sexp1.replace(i,j) + sexp2=sexp2.replace(i,j) + + self.exp1=pru(sexp1,self.var1,self.var2) + self.exp2=pru(sexp2,self.var1,self.var2) + + + self.update_equalityDiff() + self.s() + + def replacediff2(self,expr): + if type(expr)==MyEq: + expr=expr.ksym + var1=self.var1 + var=self.var + F=Function(str(var1))(var) + p1=self.exp1 + p2=self.exp2 + self.exp1=p1.subs( F.diff(var,var),expr) + self.exp2=p2.subs( F.diff(var,var),expr) + self.update_equalityDiff() + self.s() + + + def replacediff(self,expr): + if type(expr)==MyEq: + expr=expr.ksym + + var1=self.var1 + var=self.var + F=Function(str(var1))(var) + p1=self.exp1 + p2=self.exp2 + self.exp1=p1.subs( F.diff(var),expr) + self.exp2=p2.subs( F.diff(var),expr) + self.update_equalityDiff() + + + self.s() + + def replacefunc(self,expr): + if type(expr)==MyEq: + expr=expr.ksym + + var1=self.var1 + var=self.var + F=Function(str(var1))(var) + p1=self.exp1 + p2=self.exp2 + self.exp1=p1.subs( F,expr) + self.exp2=p2.subs( F,expr) + self.update_equalityDiff() + + + self.s() + + + def simplifyexp(self,op='LR' ,kshow=True): + p1=self.left + if 'L' in op: + p1=simplifyexp(p1) + self.exp1.ksym=p1 + p2=self.right + if 'R' in op: + p2=simplifyexp(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + def basefactor(self,op='LR',kshow=True): + return self.simplifyexp(op=op,kshow=kshow) + + + def simplifyexp(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=simplifyexp(p1) + self.exp1.ksym=p1 + p2=self.right + if 'R' in op: + p2=simplifyexp(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + def div2mulexp(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=div2mulexp(p1) + + self.exp1.ksym=p1 + + p2=self.right + if 'R' in op: + p2=div2mulexp(p2) + + self.exp2.ksym=p2 + + if kshow: + self.s() + + def reducePow(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=reducePow(p1) + + self.exp1.ksym=p1 + + p2=self.right + if 'R' in op: + p2=reducePow(p2) + + self.exp2.ksym=p2 + + if kshow: + self.s() + def simplifyrpow(self,kop='RL',kshow=True): + + + if 'L' in kop : + self.exp1.simplifyrpow(kshow=False) + if 'R' in kop : + self.exp2.simplifyrpow(kshow=False) + + self.s() + def simplify_cero(self,): + kres=self.left-self.right + kres=opemat(kres) + self.exp1.ksym=kres + self.exp2.ksym=0 + self.s() + + def expandexp(self,kop='LR',kshow=True): + op='' + if 'e' in kop: + op='e' + p1=self.left + if 'L' in kop: + p1=expandexp(p1,op=op) + self.exp1.ksym=p1 + p2=self.right + if 'R' in kop: + p2=expandexp(p2,op=op) + self.exp2.ksym=p2 + + if kshow: + self.s() + + + def simplifybase(self,kop='LR',kshow=True): + + p1=self.left + if 'L' in kop: + p1=simplifybase(p1) + self.exp1.ksym=p1 + p2=self.right + if 'R' in kop: + p2=simplifybase(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + def powexpand(self,kop='LR',kshow=True): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + op='' + if 'i' in kop: + op='i' + p1=self.left + if 'L' in kop: + p1=powexpand(p1,op=op) + self.exp1.ksym=p1 + p2=self.right + if 'R' in kop: + p2=powexpand(p2,op=op) + self.exp2.ksym=p2 + + if kshow: + self.s() + + def lexpand(self): + self.e1.ksym=expand_log(self.e1.ksym,force=True) + self.e2.ksym=expand_log(self.e2.ksym,force=True) + self.s() + + + def mulexpo(self,kop='LR',kshow=True): + + + p1=self.left + if 'L' in kop: + p1=mulexpo(p1) + self.exp1.ksym=p1 + p2=self.right + if 'R' in kop: + p2=mulexpo(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + + def factor(self, kop='RL',kshow=True ): + if 'L' in kop: + self.exp1.factor() + if 'R' in kop: + self.exp2.factor() + self.s() + def simplifyexp(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=simplifyexp(p1) + self.exp1.ksym=p1 + p2=self.right + if 'R' in op: + p2=simplifyexp(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + def basefactor(self,op='LR',kshow=True): + return self.simplifyexp(op=op,kshow=kshow) + + + def simplifyexp(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=simplifyexp(p1) + self.exp1.ksym=p1 + p2=self.right + if 'R' in op: + p2=simplifyexp(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + def div2mulexp(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=div2mulexp(p1) + if kope!='': + p1=opemat(p1) + self.exp1.ksym=p1 + + p2=self.right + if 'R' in op: + p2=div2mulexp(p2) + if kope!='': + p2=opemat(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + + def reducePow(self,op='LR',kshow=True): + p1=self.left + if 'L' in op: + p1=reducePow(p1) + if kope!='': + p1=opemat(p1) + self.exp1.ksym=p1 + + p2=self.right + if 'R' in op: + p2=reducePow(p2) + if kope!='': + p2=opemat(p2) + self.exp2.ksym=p2 + + if kshow: + self.s() + def simplifyrpow(self,kop='RL',kshow=True): + + + if 'L' in kop : + self.exp1.simplifyrpow(kshow=False) + if 'R' in kop : + self.exp2.simplifyrpow(kshow=False) + if kope!='': + kres1=self.exp1.ksym + kres2=self.exp2.ksym + + kres1=opemat(kres1) + kres2=opemat(fcc) + self.exp1.ksym=kres1 + self.exp2.ksym=kres2 + self.s() + def expand(self, kop='RL',kshow=True): + if 'L' in kop: + self.exp1=expand(self.exp1) + self.e1.ksym=self.exp1 + + if 'R' in kop: + self.exp2=expand(self.exp2) + self.e2.ksym=self.exp2 + self.s() + def simplify_cero(self ): + kres=self.left-self.right + kres=opemat(kres) + self.exp1.ksym=kres + self.exp2.ksym=0 + self.s() + + def factorSec(self, ksym,kop='RL',kshow=True): + if 'L' in kop: + + self.exp1.factorSec(ksym,kshow=False) + if 'R' in kop: + self.exp2.factorSec(ksym,kshow=False) + self.update_equalityDiff() + self.s(kshow) + + def toMyEqeEq(self): + return MQ(self.exp1,self.exp2) + + def LaplaceEq(self): + ee=LaplaceEq(self.sexp1,self.sexp2,self.var1,self.var,ics=self.ics) + Ls=symbols('L_s') + sLs=str(Ls) + p1=ee.L + sp1=str(p1) + sp1=sp1.replace('L(s)',sLs) + p1=parse_expr(sp1) + p2=ee.R + sp2=str(p2) + sp2=sp2.replace('L(s)',sLs) + p2=parse_expr(sp2) + qq=MQ(p1,p2,kshow=False) + return qq + + def transLaplace(self): + return transLaplace(self) + + + +F,f=symbols('F f') + + +def get_icsexp(*args): + kres=args[0] + var2=args[1] + vecv=args[2:len(args)] + print(vecv) + Ssym=kres.replace('=',':') + vec=Ssym.split(',') + mm=[] + for j in vecv: + var1=j + for i in vec: + smm=i + p1=i.find('(') + p2=i.find(')') + val=i[0:p1+1] + + if "''" in val: + sP1=i[0:p2-1] + + sP2=str(var1)+'.diff('+str(var1)+'('+str(var2)+'), '+str(var2)+', '+str(var2)+').subs('+str(var2)+' ,' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + #mm.append(smm) + if "'" in i: + + sP1=i[0:p2-1] + + sP2=str(var1)+'.diff('+str(var2)+').subs('+str(var2)+' ,' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + #mm.append(smm) + +def get_icskwargs(*args): + kres=args[0] + var2=args[1] + vecv=args[2:len(args)] + print(vecv) + Ssym=kres + vec=Ssym.split(',') + mm=[] + for j in vecv: + var1=j + for i in vec: + smm=i + p1=i.find('(') + p2=i.find(')') + val=i[0:p1+1] + + if "''" in val: + sP1=i[0:p2-1] + + sP2=str(var1)+'.diff('+str(var1)+'('+str(var2)+'), '+str(var2)+', '+str(var2)+').subs('+str(var2)+' ,' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + #mm.append(smm) + if "'" in i: + + sP1=i[0:p2-1] + + sP2=str(var1)+'.diff('+str(var2)+').subs('+str(var2)+' ,' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + #mm.append(smm) + + + Ssym=Ssym.replace(' ,',', ') + Ssym='['+Ssym+']' + return Ssym + # Laplace +def LaplaceEq(kfunc,kfunc2,var1,var2,var3=s,ics='',kshow=True): + + + + L= Function('L')(var3) + + sL=str(L) + kwtru=False + if ics!='': + mList=ics.split(',') + oldv=[] + newv=[] + kwtru=True + for i in mList: + kyt,vv=i.split('=') + if str(var1)+"'(" in kyt: + p1=kyt.find('(') + p2=kyt.find(')') + newt=kyt[p1+1:p2] + kyt= 'Subs(Derivative('+str(var1)+'('+str(var2)+'), '+str(var2)+'), '+str(var2)+', '+newt+')' + + oldv.append(kyt) + newv.append(vv) + P1=pru(kfunc,var1,var2) + Lp1=laplace_transform(P1,var2, var3) + if type(Lp1)==tuple: + Lpp=Lp1[0] + if 'Subs' in str(Lpp): + Lp1=Lp1[1] + else: + Lp1=Lp1[0] + + + + sL1=str(Lp1) + + + P2=pru(kfunc2,var1,var2) + Lp2=laplace_transform(P2,var2, var3) + + + if type(Lp2)==tuple: + + Lpp=Lp2[0] + if 'Subs' in str(Lpp): + Lp2=Lp2[1] + else: + Lp2=Lp2[0] + sL2=str(Lp2) + + sL2=sL2.replace('1','1/s') + sL2=sL2.replace('u','exp(-s)/s') + sL=str(L) + sLP='LaplaceTransform('+str(var1)+'('+str(var2)+'), '+str(var2)+', '+str(var3)+')' + sL1=sL1.replace(sLP,sL) + sL2=sL2.replace(sLP,sL) + if kwtru: + for i,j in zip(oldv,newv): + sL1=sL1.replace(i,j) + sL2=sL2.replace(i,j) + Lp1=parse_expr(sL1) + #Lp1=clean_LC(Lp1,var1,var2) + + Lp2=parse_expr(sL2) + #Lp2=clean_LC(Lp2,var1,var2) + return MyEqEq(Lp1,Lp2,var1=var1,var2=var2,kshow=kshow) + + +s=symbols('s') +def inversa_Ls(Q,kname='',omega=False): + + if type(Q)==MyEq: + s = Q.var + t = Q.var1 + kres=inverse_laplace_transform(Q.ksym, s, t) + + else: + kres=inverse_laplace_transform(Q, var, var1) + + if omega==False: + sres = str(kres) + kfind = 'Heaviside('+str(t)+')' + sres = sres.replace(kfind,'1') + + kres = parse_expr(sres) + try: + kres = apart(expand(simplify(kres))) + except: + pass + if kname=='': + return kres + else: + nname=str(kname) + return MyEq(kres,nname,ktype='F') + + + +def pru(kfunc,var1,var2,var3=''): + sfunc=str(kfunc) + F=Function(str(var1))(var2) + svar=str(var1) + sdvar=svar+"'" + sd2var=svar+"''" + sF=str(var1)+'('+str(var2)+')' + sdiff=str(diff(F,var2)) + s2diff=str(diff(F,var2,var2)) + sfunc=sfunc.replace(sd2var,s2diff) + sfunc=sfunc.replace(sdvar,sdiff) + return parse_expr(sfunc) + + +def creaF(kfunc,kfunc2,var1,var2): + p1=pru(kfunc,var1,var2) + p2=pru(kfunc2,var1,var2) + + return p1,p2 + +def clean_LC(kres,var1,var2): + sres=str(kres) + clean1='Subs(Derivative('+str(var1)+'('+str(var2)+'), '+str(var2)+'), '+str(var2)+', 0)' + sres=sres.replace(clean1,'0') + return parse_expr(sres) + +def solve_LC(obj,var=s): + kname='L(s)' + if type(obj)==MyEqEq: + kres=obj.L-obj.R + elif type(obj)==MyEq: + kres=obj.ksym + else: + kres=obj + + ee=MyEq(kres,'ee',kshow=False) + ss=ee.solve(kname,kshow=False) + ss.expand(kshow=False) + ss.simplify(kshow=False) + ss.factor(kshow=False) + try: + ss.ksym=apart(ss.ksym) + except: + pass + #ss=apart(ss) + Ls=symbols('Ls') + + return MQ(Ls,ss.ksym) + +def func_diff(var1,var2): + try: + var1=Function(var1.name) + except: + vname=str(var1) + var1=Function(vname) + + return var1(var2).diff(var2) + +def fdiff(var1,var2): + try: + var1=Function(var1.name) + except: + vname=str(var1) + var1=Function(vname) + + return var1(var2).diff(var2) + + + +def func_diff2(var1,var2): + var1=Function(var1.name) + return var1(var2).diff(var2,var2) +def fdiff2(var1,var2): + var1=Function(var1.name) + return var1(var2).diff(var2,var2) + + + +def func_var2diff(var1,var2): + var1=Function(var1.name)(var2) + return var1 +def newfunc(var1,var2): + var1=Function(var1.name)(var2) + return var1 + + +def eQdiff(var1,var2,exp1,exp2): + df='d'+str(var1) + df= func_diff(var1,var2) + df2='d'+str(var1)+'2' + df2= func_diff2(var1,var2) + f=func_var2diff(var1,var2) + + v2='d'+str(var1)+'2' + exp1=exp1.replace(v2,str(df2)) + exp2=exp2.replace(v2,str(df2)) + v1='d'+str(var1) + exp1=exp1.replace(v1,str(df)) + exp2=exp2.replace(v1,str(df)) + kres1=parse_expr(exp1) + kres2=parse_expr(exp2) + return kres1,kres2 + +def eQics(var1,var2,exp1): + df='d'+str(var1) + df= func_diff(var1,var2) + df2='d'+str(var1)+'2' + df2= func_diff2(var1,var2) + f=func_var2diff(var1,var2) + + v2='d'+str(var1)+'2' + exp1=exp1.replace(v2,str(df2)) + exp2=exp2.replace(v2,str(df2)) + v1='d'+str(var1) + exp1=exp1.replace(v1,str(df)) + exp2=exp2.replace(v1,str(df)) + kres1=parse_expr(exp1) + kres2=parse_expr(exp2) + return kres1,kres2 + +def get_ics(*args): + fd1=func_var2diff(var1,var2) + + if svar[0]=='d': + if svar[1]==str(var1): + if svar[2]=='(': + p2=svar.find(')') + val1=svar[3:p2] + val2=svar[p2+1::] + val3='diff('+str(var1)+'('+str(var2)+'),'+str(var2)+').subs('+str(var2)+','+val1+')'+val2 + else: + p2=svar.find(')') + val1=svar[4:p2] + val2=svar[p2+1::] + val3='diff('+str(var1)+'('+str(var2)+'),'+str(var2)+','+str(var2)+').subs('+str(var2)+','+val1+')'+val2 + + return val3 + else: + return svar + + + ### Wolfram Alpha + +def pyDiff2wolframDiff(expr,v1,v2): + r""" + translate sympy differential equation sintaxis + to wolgram alpha mathemayicas sintaxis in order + can use in mathemayica API + why..?? because sympy sometimes can not solve differential ecuation + example: + Derivative(y(x), (x, 2)) + Derivative(y(x), x) + y + x return + y''+y'+y+x + + Input(expresi diferential equatin, var depen, var indep. + + """ + sres=str(expr) + + oexp='Derivative('+str(v1)+'('+str(v2)+'), ('+str(v2)+', 2))' + nexp=str(v1)+"''" + sres=sres.replace(oexp,nexp) + + oexp='Derivative('+str(v1)+'('+str(v2)+'), '+str(v2)+')' + nexp=str(v1)+"'" + sres=sres.replace(oexp,nexp) + + oexp=str(v1)+'('+str(v2)+')' + nexp=str(v1) + sres=sres.replace(oexp,nexp) + + oexp='**' + nexp='^' + + sres=sres.replace(oexp,nexp) + return sres + + +def get_icsexp(sexpp,var1,var2): + xx=symbols(str(var1)) + ff=Function(str(var2))(var1) + kres=sexpp + + vecv=[var1] + + Ssym=kres.replace('=',':') + vec=Ssym.split(',') + mm=[] + for j in vecv: + + + for i in vec: + smm=i + p1=i.find('(') + p2=i.find(')') + val=i[0:p1+1] + + if "''" in val: + sP1=i[0:p2-1] + + sP2='Derivative('+str(var2)+'('+str(var1)+'), '+str(var1)+' ,'+str(var1)+').subs('+str(var1)+', ' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + #mm.append(smm) + elif "'" in i: + + sP1=i[0:p2-1] + + sP2='Derivative('+str(var2)+'('+str(var1)+'), '+str(var1)+').subs('+str(var1)+', ' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + else: + sP1=i[0:p2-1] + + sP2=str(var2)+'('+str(var1)+').subs('+str(var1)+',' + + smm=smm.replace(sP1,sP2) + + Ssym=Ssym.replace(i,smm) + + + Ssym=Ssym.replace(' ,',', ') + Ssym='{'+Ssym+'}' + return Ssym + +def traduce_Lc_Diff(expr,var1,var2): + oldd2='d'+str(var1)+'2' + newd2=str(var1)+"''" + + expr=expr.replace(newd2,oldd2) + + oldd1='d'+str(var1) + newd1=str(var1)+"'" + + expr=expr.replace(newd1,oldd1) + return expr + +def traduce_diff_Lc(expr,var1,var2): + newd2='d'+str(var1)+'2' + oldd2=str(var1)+"''" + + expr=expr.replace(newd2,oldd2) + + newd1='d'+str(var1) + oldd1=str(var1)+"'" + + expr=expr.replace(newd1,oldd1) + return expr + + + + +def str_diff(*args): + expr=str(args[0]) + t=args[1] + vecvar=args[2:len(args)] + for i in vecvar: + f=Function(str(i))(t) + sd2f=str(diff(f,t,t)) + sd1f=str(diff(f,t)) + snd2=str(i)+"''" + snd1=str(i)+"'" + expr=expr.replace(sd2f,snd2) + expr=expr.replace(sd1f,snd1) + return expr + + +def EqDiff(*args,kshow=True): + newa1=[args[0]] + for i in range (2,len(args)): + newa1.append(args[i]) + newa2=args[1:len(args)] + p1=traducediff(*newa1) + p2=traducediff(*newa2) + kres=Eq(p1,p2) + if kshow: + display(Math(latex(kres))) + return kres + + def toMyEqeEq(self): + return MQ(self.exp1,self.exp2) + +def traduce_single_ics(sval,v1,v2): + partes=sval.split('=') + p2=partes[1] + ktype=0 + p1=partes[0] + if "''" in p1: + ktype=2 + elif"'" in p1: + ktype=1 + else: + ktype=0 + P1=p1.find("(") + P2=len(p1)-1 + vnum=p1[P1+1:P2] + + X=str(v2) + T=str(v1) + if ktype==2: + sres= 'Subs(Derivative('+X+'('+T+'), '+T+','+T+'), '+T+', '+vnum+')' + elif ktype==1: + sres= 'Subs(Derivative('+X+'('+T+'), '+T+'), '+T+', '+vnum+')' + else: + sres=p1 + + return sres,p2 +## LAPLACE + +def tLaplace(Obj): + L=symbols('L') + mm=laplace_transform(Obj.exp1-Obj.exp2,Obj.var,s) + smm=str(mm) + X=str(Obj.var1) + T=str(Obj.var) + sLap='LaplaceTransform('+X+'('+T+'), '+T+', s)' + smm=smm.replace(sLap,'L') + if Obj.ics!='': + sics=Obj.ics + partes=sics.split(',') + for i in partes: + p1,p2=traduce_single_ics(i,Obj.var,Obj.var1) + smm=smm.replace(p1,p2) + smm=smm[1::] + pp=smm.find(',') + smm=smm[0:pp] + kres=parse_expr(smm) + + return kres +def laplace(*args): + var=t + expr=args[0] + kname=latex2sympy('\mathcal{L}') + if len(args)==1: + if type(expr)==MyEqDiff: + kres=tLaplace(expr) + if 'L' in str(kres): + L=symbols('L') + L=csolve(kres,L) + return L + else: + return kres + + elif type(expr)==MyEqEq: + f1=expr.L + f2=expr.R + var=expr.var + P=laplacetransform(f1-f2,var) + + elif type(expr)==MyEq: + f1=expr.ksym + var=expr.var + P=laplacetransform(f1,var) + + else: + if not 't' in str(expr) and 'x' in str(expr): + var=x + f1=expr + P=laplacetransform(f1,var) + + else: + expr=args[0] + var=args[1] + P=laplacetransform(expr,var) + + return P +def Laplace(*args): + kres=laplace(*args) + P=MQ(latex2sympy('\\mathcal{L}'),kres) + return kres + + + +def transLaplace(Obj,kshow=True): + L=symbols('L') + mm=laplace_transform(Obj.exp1-Obj.exp2,Obj.var,s) + smm=str(mm) + X=str(Obj.var1) + T=str(Obj.var) + sLap='LaplaceTransform('+X+'('+T+'), '+T+', s)' + smm=smm.replace(sLap,'L') + if Obj.ics!='': + sics=Obj.ics + partes=sics.split(',') + for i in partes: + p1,p2=traduce_single_ics(i,Obj.var,Obj.var1) + smm=smm.replace(p1,p2) + ''' + if smm[0]=='(': + smm=smm[1::] + pp=smm.find(',') + smm=smm[0:pp] + ''' + kres=parse_expr(smm) + eL=MyEq(kres,'eL',var=L,ktype='LA') + + return eL +def diff2laplace(Obj,kshow=True): + L=symbols('L') + mm=laplace_transform(Obj.exp1-Obj.exp2,Obj.var,s) + smm=str(mm) + X=str(Obj.var1) + T=str(Obj.var) + sLap='LaplaceTransform('+X+'('+T+'), '+T+', s)' + smm=smm.replace(sLap,'L') + if Obj.ics!='': + sics=Obj.ics + partes=sics.split(',') + for i in partes: + p1,p2=traduce_single_ics(i,Obj.var,Obj.var1) + smm=smm.replace(p1,p2) + + if smm[0]=='(': + smm=smm[1::] + pp=smm.find(',') + smm=smm[0:pp] + + kres=parse_expr(smm) + eL=MyEq(kres,'eL',var=L,ktype='LA',kshow=False) + kres=eL.solve(L,kshow=False) + kres.var=s + P=MQ(latex2sympy('\\mathcal{L}'),kres) + return kres + + +def laplacetransform(func,var=t,var2=s): + kres=laplace_transform(func,var,var2) + try: + return kres[0] + except: + return kres + +def func2laplace(*args,kshow=True): + var=t + expr=args[0] + kname=latex2sympy('\mathcal{L}') + if len(args)==1: + if type(expr)==MyEqDiff: + f1=expr.L + f2=expr.R + var=expr.var + ee=MyEq(f1-f2,'ee',var=var,kshow=False) + return func2laplace(ee) + + + elif type(expr)==MyEqEq: + f1=expr.L + f2=expr.R + var=expr.var + P=laplacetransform(f1-f2,var) + + elif type(expr)==MyEq: + f1=expr.ksym + var=expr.var + P=laplacetransform(f1,var) + + else: + if not 't' in str(expr) and 'x' in str(expr): + var=x + f1=expr + P=laplacetransform(f1,var) + + else: + expr=args[0] + var=args[1] + P=laplacetransform(expr,var) + if kshow: + MQ(kname,P) + return P + +def translaplace(expr,*args): + Lp=func2laplace(expr) + kname='' + vecold=['multt'] + vecnew=[] + for i in args: + if i in vecold: + vecnew.append(i) + else: + kname=i + if kname=='': + return + +def ilaplace(expr,var=s,var1=t,omega=False): + + kres=inverse_laplace_transform(expr, var, var1) + + if omega==False: + sres = str(kres) + kfind = 'Heaviside('+str(t)+')' + sres = sres.replace(kfind,'1') + + kres = parse_expr(sres) + try: + kres = apart(expand(simplify(kres))) + except: + pass + return kres + + +def Ilaplace(expr,var=s,var1=t,omega=False): + if type(expr)==MyEq: + expr=expr.ksym + expr= ilaplace(expr,var=var,var1=var1,omega=omega) + ee=MyEq(expr,'F('+str(var1)+')',var=var1) + return ee + +def dsolvesys(Q1,Q2): + ode=[Q1.ode, Q2.ode] + func= [Q1.func1,Q2.func1] + ics3='' + if Q1.ics2!='': + ics3=Q1.ics2 + if Q2.ics2!='': + ics3={**Q1.ics2,**Q2.ics2} + if Q2.ics2!='': + ics3=Q2.ics2 + if Q1.ics2!='': + ics3={**Q2.ics2,**Q1.ics2} + + if ics3!='': + kres= dsolve(ode, func,ics=ics3) + else: + kres= dsolve(ode, func) + ff1=kres[0].lhs + kres1=kres[0].rhs + var=Q1.var + ff2=kres[1].lhs + kres2=kres[1].rhs + kname1=str(ff1) + kname2=str(ff2) + ee1=MyEq(kres1,kname=kname1,var=var) + ee2=MyEq(kres2,kname=kname2,var=var) + return ee1,ee2 + + +##################### +# view from regular Derivative(x(t)) to x' + +def easy_diffviewF(expr,var,var1,var2=''): + sexpr=preeasyF(expr,var=var,var1=var1) + if var2!='': + sexpr=preeasyF(sexpr,var=var,var1=var2) + if 'Eq(' in sexpr: + sexpr=sexpr[3:-1] + sexpr=sexpr.replace(","," = ") + + return sexpr + +def easy_diffview(expr,var,var1,var2=''): + sexpr=preeasy(expr,var=var,var1=var1) + if var2!='': + sexpr=preeasy(sexpr,var=var,var1=var2) + if 'Eq(' in sexpr: + sexpr=sexpr[3:-1] + sexpr=sexpr.replace(","," = ") + + return sexpr + +def preeasyF(expr,var,var1): + + X=str(var1) + T=str(var) + F=X+'('+T+')' + odX ='Derivative('+F+', '+T+')' + + odX2='Derivative('+F+', ('+T+', 2))' + ndX=X+"'" + ndX2=X+"''" + + sexpr=str(expr) + sexpr=sexpr.replace(odX2,ndX2) + sexpr=sexpr.replace(odX,ndX) + + return sexpr + return sexpr + +def preeasy(expr,var,var1): + + X=str(var1) + T=str(var) + F=X+'('+T+')' + odX ='Derivative('+F+', '+T+')' + + odX2='Derivative('+F+', ('+T+', 2))' + + ndX=X+"'" + ndX2=X+"''" + + sexpr=str(expr) + sexpr=sexpr.replace(odX2,ndX2) + sexpr=sexpr.replace(odX,ndX) + sexpr=sexpr.replace(F,X) + + return sexpr + return sexpr + +def varDiff(*args): + mm=[] + for i in args: + + k=symbols(i+"'") + mm.append(k) + return(mm) +def varDiff2(*args): + mm=[] + for i in args: + + k=symbols(i+"''") + mm.append(k) + return(mm) + + + + + +def subsdiff(expr,vy,vx): + dy=symboldiff(y) + dy2=symboldiff2(y) + Y=Function(str(vy))(vx) + + expr=expr.subs(Y.diff(vx,vx),dy2) + expr=expr.subs(Y.diff(),dy) + expr=expr.subs(Y,vy) + return expr + +def symboldiff(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"'" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff(i)) + return mm + +def symboldiff2(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"''" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff2(i)) + return mm + +def diff_withrespect(*args): + qq=len(args) + expr=args[0] + sres=str(expr) + var=args[1] + if len(args)>2: + vecf=args[2:qq] + svar=[str(i) for i in vecf] + sfun=[str(i)+'('+str(var)+')' for i in vecf] + for i,j in zip(svar,sfun): + sres=sres.replace(i,j) + kres=parse_expr(sres) + return kres.diff(var) + + +def Qdiff_withrespect(self,*args): + p1=self.L + args1=[p1] + for i in args: + args1.append(i) + kres1=diff_withrespect(*args1) + p2=self.R + args2=[p2] + for i in args: + args2.append(i) + + kres2=diff_withrespect(*args2) + QQ=MQ( kres1,kres2,kshow=False) + + argst=[QQ] + for i in args: + argst.append(i) + kres= MyEqDiff(*argst) + return kres + +def strdiff(v1,v2): + v1=Function(str(v1))(v2) + return str(v1.diff(v2)) +def strdiff2(v1,v2): + v1=Function(str(v1))(v2) + return str(v1.diff(v2,v2)) + + + +# remplazar Icss in LaPlace + +def vecics(sexpr,kss): + return sexpr.split(kss) +def typediff(sexpr): + if "''" in sexpr: + return 2 + elif"'" in sexpr: + return 1 + else: + return 0 +def subsdiffexpr(expr,vt,vx,ics1,ics2): #,ics1='x(0)',ics2=0 + sexp=str(expr) + ktype=typediff(ics1) + if ktype==0: + sexp=sexp.replace(ics1,ics2) + elif ktype==1: + xx=str(vx) + tt=str(vt) + olde='Subs(Derivative('+xx+'('+tt+'), '+tt+'), '+tt+', '+'0'+')' + sexp=sexp.replace(olde,ics2) + else: + pass + return parse_expr(sexp) + +def subsics(expr,vt,vx,icss): + ''' + expr= 4*s**2*LaplaceTransform(y(t), t, s) - 4*s*y(0) + LaplaceTransform(y(t), t, s) - + 4*Subs(Derivative(y(t), t), t, 0) + 2/s + ics=x(0)=0,x'(0)=0 + subsics(Ls,t,y,Q.ics) return 4*s**2*LaplaceTransform(y(t), t, s) + LaplaceTransform(y(t), t, s) + 2/s + + + ''' + sexpr=str(expr) + mm=vecics(icss,',') + for i in mm: + ics1,ics2=vecics(i,'=') + expr=subsdiffexpr(expr,vt,vx,ics1,ics2) + return expr + + +def solvelaplace(obj,v1=t,v2=x): + ''' + obj=4*s**2*LaplaceTransform(y(t), t, s) + LaplaceTransform(y(t), t, s) - 2 + 2/s + Lt=solvelaplace(Ls,t,y) return Lt= '(2*s - 2)/(4*s**3 + s)' + ''' + + + tt=str(v1) + xx=str(v2) + Lsexp='LaplaceTransform('+xx+'('+tt+'), '+tt+', s)' + V=parse_expr(Lsexp) + if type(obj)==MyEqEq: + kres=obj.L-obj.R + elif type(obj)==MyEq: + kres=obj.ksym + else: + kres=obj + ee=MyEq(obj,'ee',var=s,kshow=False) + Lt=ee.solve(V,kshow=False) + ee2=MyEq(Lt,'L_t',var=s) + return ee2 + +# laplace of Mul de tLaplace +def Is_tPow(expr): # True if expr=t ,t**2,t**3.... else false + if expr==t: + return True + elif Is_Pow(expr): + bb=getbase(expr) + if bb==t: + return True + else: + return False + else: + return False + +def tpow(expr): # get monomie t**n in a Mul Polynimie retru t, expo of t and thes rest of multwithout t + mm=expr.args + + for i in mm: + if Is_tPow(i) or i=='t': + kres=simplify(expr/i) + if i==t: + return t,1,kres + else: + ee=getexpo(i) + return t,ee,kres + +def translaplacemult(expr): # Laplacen trans of mult t**n + if type(expr)==MyEq: + expr=expr.ksym + tt,ee,expr2=tpow(expr) + Lp=laplace(expr2) + ee=MyEq(Lp,'ee',var=s,kshow=False) + eed=ee.diff() + return eed + +def translaplacedivt(expr): # Laplacen trans of mult t**n + if type(expr)==MyEq: + kres=expr.ksym + expr2=kres*t + kres=laplace(expr2) + + kres2= simplify(integrate(kres,s)) + + return kres2 + +def datadiff(var,*args): + ''' + var=main var t + args=[x,y]= x(t),y(t) + Vs=['x','y'] + Vn=[x,y] + Vf=[x(t),y(t)] + Vd=[dxt,dyt] + Vd2=[dx2t,dy2t] + Pd=[x',y'] + Pd2=[x'',y''] + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2 =[],[],[],[],[],[],[] + P1,P2=[],[] + for i in args: + Vs.append(str(i)) + Vn.append(i) + for i in Vs: + Vf.append(Function(i)(var)) + for i in Vf: + Vd.append(i.diff(var)) + Vd2.append(i.diff(var,var)) + for i in Vn: + Pd.append(symboldiff(i)) + Pd2.append(symboldiff2(i)) + + return Vs,Vn,Vf,Vd,Vd2,Pd,Pd2 + +def hightfunc(expr,var,*args): + ''' + expr=pi*h*r*r*t/3 + var=t + args=h,r + return pi*t*h(t)*r(t)**2/3 + ''' + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vn,Vf): + expr=subsubs(expr,i,j) + return expr + +def hightdiff(expr,var,*args): + ''' + expr=pi*h*r*r*t/3 + var=t + args=h,r + return 2*pi*t*h(t)*r(t)*Derivative(r(t), t)/3 + pi*t*r(t)**2*Derivative(h(t), t)/3 + + pi*h(t)*r(t)**2/3 + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vn,Vf): + expr=subsubs(expr,i,j) + return diff(expr,t) + +def sympyEq2prime(expr,var,*args): + ''' + return expr diff sympy expr whith diff prime symbols + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vd2,Pd2): + expr=expr.subs(i,j) + for i,j in zip(Vd,Pd): + expr=expr.subs(i,j) + for i,j in zip(Vf,Vn): + expr=expr.subs(i,j) + return expr + + +def eQlaplace(*args): + var=t + kname='' + expr=args[0] + for i in args[1::]: + if type(i)==str: + kname=i + else: + var=i + func=expr + if type(expr)==MyEq: + func=expr.ksym + kres=translaplacemult(func) + if kname=='': + return kres + else: + return MyEq(kres,kname=kname,var=s) + +def eQinverselaplace(Q,kname='',omega=False): + s,t=symbols('s t') + if type(Q)==MyEq: + kres=inverse_laplace_transform(Q.ksym, s, t) + else: + kres=inverse_laplace_transform(Q, s, t) + + if omega==False: + sres = str(kres) + kfind = 'Heaviside('+str(t)+')' + sres = sres.replace(kfind,'1') + + kres = parse_expr(sres) + try: + kres = apart(expand(simplify(kres))) + except: + pass + if kname=='': + return kres + else: + return MyEq(kres,kname=kname,var=t) \ No newline at end of file diff --git a/Libaldo/lib_MyEq.py b/Libaldo/lib_MyEq.py new file mode 100644 index 0000000..89737ac --- /dev/null +++ b/Libaldo/lib_MyEq.py @@ -0,0 +1,5755 @@ + + +from sympy import * + +from IPython.display import Math # ,display +from matplotlib.pyplot import ylabel, plot, show, xlabel, title +from libaldo_math2 import * +from libaldo_algorith import * + +from lib_toolsEq import * +from lib_tools import * +from mathbasic import * + +import copy +import numpy as np +import pandas as pd + +import matplotlib.pyplot as plt +# from lib_Func import * +import dill # pip install dill --user +import pickle +filename = 'workspace.pkl' +from lib_funcdiff import * +x1=symbols('x1') + + +nombresdiferen=['dx','dy','dz','du','dv','dw','d2x','d2y','d2z','d2u','d2v','d2w'] + +def savework(): + dill.dump_session(filename='workspace.pkl') + + +def loadwork(): + dill.load_session(filename='workspace.pkl') + + +# and to load the session again: + +25 +C1, C2, C3, C4, t, x, y, z,t1,t2 = symbols('C1 C2 C3 C4 t x y z t1 t2') +dataQ = [] +e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12 = symbols('e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11 e12') +alpha=symbols('alpha') +#direx,direy=symbols('\overrightarrow{x} \overrightarrow{y}') +class MyEq: + def __init__(self, ksym, kname='', var=x,var1=y,var2=t, varx=x, vary=y, varz=z, kp=False, kope='', kshow=True, ktype='P', + xx='', dtype=1, depen=False, x1='', x2='', y1='', y2=0, z1='', z2=0, Pobj='', ee='', ssym='', init=True, + kfull=True, andsolve='',varf=[],diffEq='',eQshow='',vfunc=[],vmain=x,mark=False,link=''): + self.mark=mark + if type(ksym)==str: + self.ksym=traducediff(ksym,var,var1) + + else: + self.ksym=ksym + self.t=ktype + self.pname=kname + self.type=ktype + self.kinte='' + self.ee=ee + self.depen=depen + self.primi=ksym + self.var1=var1 + self.var2=var + self.var=var + self.link=link + + self.x1=x1 + self.x2=x2 + + self.varL='' + + + self.y1=y1 + self.y2=y2 + self.z1=z1 + self.z2=z2 + self.varx=varx + self.vary=vary + self.varz=varz + self.eeq=ksym + self.vmain=vmain + self.diffvar='' + if kname!='' and len(str(kname))==1: + self.vmain=symbols(kname) + + + + + + self.name = alphaname(kname) + self.sname='' + self.kinte='' + self.xx=xx + self.EqDiff='' + self.Adiff='' + self.Bdiff='' + self.EqInte='' + self.iniG=0 + self.odeQ='' + self.ode='' + self.oldprimi='' + self.Pobj=Pobj + self.ssym=ssym + self.father='' + self.backup=[] + self.kshow=kshow + self.init=init + self.histo=ksym + self.primitiva=func2primi(ksym,var2,varf) + self.tipoView=True + try: + self.pdiff=diff(func2primi(ksym,var2,varf),var2) + except: + self.pdiff=0 + try: + self.flatdiff=Diff2diff(diff(func2primi(ksym,var2,varf),var2),var2,varf) + except: + self.flatdiff=0 + + self.varf=varf + self.primi_eq=ksym + self.diff_eq='' + self.primi_diff_eq='' + self.origen=1 + self.var1=var1 + self.var2=var2 + self.diffname='d'+str(var) + if type(ksym)==MyEq: + seq=str(ksym()) + self.ksym = unisymbols(opemat(ksym(), kope=kope)) + self.v = unisymbols(opemat(ksym(), kope=kope)) + self.eeq=ksym + #elif type(ksym)==MyEqMat: + # self.ksym = unisymbols(opemat(ksym(), kope=kope)) + #elif type(ksym)==Equality: + # mm=ksym.e2.ksym + # self.ksym=mm=kQ.e2.ksym + # + # try: + # self.var2=get_varfunc(ksym.lhs) + # except: + # done=False + else: + seq=str(ksym) + #self.ksym = unisymbols( ksym ) + self.v = unisymbols( ksym ) + + if ktype=='F' or ktype=='Ff': + if var2!='': + s1=kname + if type(var2)==list: + s2=alphaname(var2[0])+','+alphaname(var2[1]) + else: + s2=alphaname(var2) + kname=s1+'_{('+s2+')}' + self.name = kname + + + + + + if 'I' in ktype: + ksym=self.ksym + if Is_Number(ksym): + self.ksym=ksym*var+C1 + else: + ddx='d' + str(self.var) + ssym=str(ksym) + + if ddx in ktype: + ssym=str(self.ksym) + ssym=ssym.replace(ddx,'1') + ksym=parse_expr(ssym) + + self.ksym=ksym + self.primi=self.ksym + if self.x1=='': + ksym=self.ksym + if Is_Number(ksym): + self.ksym=ksym*var+C1 + else: + self.ksym=Integral(ksym,var) + else: + self.ksym=Integral(self.ksym, (var,self.x1,self.x2)) + self.histo = unisymbols(opemat(self.ksym, kope=kope)) + if '2I' in ktype or '3I' in ktype: + + if self.y1=='': + self.ksym=Integral(self.ksym, self.vary) + else: + self.ksym=Integral(self.ksym, (self.vary,self.y1,self.y2)) + self.histo = unisymbols(opemat(self.ksym, kope=kope)) + + if '3I' in ktype: + + if self.z1=='': + self.ksym=Integral(self.ksym, self.varz) + else: + self.ksym=Integral(self.ksym, (self.varz,self.z1,self.z2)) + self.histo = unisymbols(opemat(self.ksym, kope=kope)) + + if ktype=='Diff': + + svard='d'+str(var) + sres=str(ksym) + if svard in sres: + sres=sres.replace(svard,'1') + self.ksym=parse_expr(sres) + self.Adiff=Derivative(self.ksym, var) + self.sname='d_'+kname + self.name=kname + self.var2=var + + + + if ktype=='diff' or ktype=='diff2': + f=Function(kname)(var2) + kres=self.ksym + kres=kres.subs(var1,f) + + self.Bdiff=kres + + if ktype=='diff': + self.Adiff=Derivative(f,var1) + + else: + self.Adiff=Derivative(f, var1,var1) + self.EqDiff=Eq(self.Adiff,self.Bdiff) + + + if ktype=='fdiff': + self.name='d'+kname+'_'+str(var2) + nksym=get_diff_name(str(ksym),str(var2)) + + + self.ksym=nksym + self.var1=ksym + + if self.Pobj!='': + self.type='Ph' + + if kshow: + if ktype=='diff' or ktype=='diff2': + display(Math(latex(self.EqDiff))) + elif ktype=='D': + sres=str(ksym) + pdd=['d'+str(self.var),'d_'+str(self.var), 'd'+alphaname(self.var),'d_'+alphaname(self.var)] + for i in pdd: + if i in sres: + sres=sres.replace(i,'1') + fres=parse_expr(sres) + self.ksym=fres + + sR = self.name + ' =' + kres=self.ksym + self.diffname=diff_name(self.var) + display(Math(sR + latex(kres)+' '+self.diffname)) + + + elif self.mark: + ksym=self.ksym + dexpr=diff2mark2(ksym,var,var1) + ee=MyEq(dexpr,kname=self.kname) + + + else: + kres=self.ksym + + if self.name == '': + display(Math(latex(kres))) + else: + sR = self.name + ' =' + display(Math(sR + latex(kres))) + + + if andsolve!='': + kval=andsolve + kname=str(andsolve) + + kres=csolve(self.ksym,kval) + kres=opemat(kres,kope) + andsolve=MyEq(kres,kname) + return (andsolve) + if dtype==1: + if self not in dataQ and self.name!='': + dataQ.append(self) + #self.ksym=sympify(str(self.ksym), locals={str(var2): var2}) + + + + self.primi_eq=ksym + self.diff_eq='' + self.primi_diff_eq='' + self.origen=1 + self.eQshow=eQshow + self.vfunc=vfunc + self.vdf=[] + self.vd2f=[] + self.vdp=[] + self.vd2p=[] + if "'" in str(self.ksym): + self.type='DI' + + + def __call__(self,*args,kshow=True, **kwargs): + op=[] + nargs=[] + vecargs=['value','expand','eval'] + kname='' + if len(args)==0 and len(kwargs)==0: + return self.ksym + if len(args)==1 and len(kwargs)==0: + ksym=self.ksym + var=self.var + valor=args[0] + kres=ksym.subs(var,valor) + + return kres + elif len(kwargs)>0 and len(nargs)==0: + kres=self.ksym + kres=real_subs(kres,**kwargs) + return kres + else: + if len(kwargs)>0 and len(nargs)==0: + kres=self.ksym + kres=real_subs(kres,**kwargs) + return kres + + + for i in args: + if type(i)==str: + if i not in vecargs: + kname=i + else: + op.append(i) + else: + nargs.append[i] + + + if len(kwargs)==0 and len(args)==1: + kvalue=args[0] + expr=self.ksym + expr=expr.subs(str(self.var),kvalue) + + return expr + + + kres=self.ksym + if len(kwargs)==0 and len(args)==0: + return self.ksym + if len(kwargs)>0: + if self.type=='dP': + kres= self.primi_diff_eq + kres=real_subs(kres,**kwargs) + return kres + kres=real_subs(kres,**kwargs) + + if len(args)==1 and len(kwargs)==0 and Is_Number(args[0]): + kres=self.ksym + var=self.var + val=args[0] + return kres.subs(var,val) + if len(args)>0: + if 'float' in args: + try: + kres=float(kres) + except: + pass + if 'value' in args: + return kres + + nname='' + if len(args)==1 and len(kwargs)==0 and type(args[0])!=str: + kres=kres.subs(self.var1,args[0]) + + + + if 'update' in args: + self.ksym=kres + self.s() + return + for i in args: + if i!='float' and i!='update' and type(i)==str: + nname=i + if nname=='': + ee=self.xcopy(self.name,kshow=False) + ee.ksym=kres + ee.s() + return + else: + ee=MyEq(kres,kname=nname,kshow=kshow) + return ee + + + def __repr__(self): + kres = str(self.ksym) + + return kres + + def _latex(self, obj): + return latex(self.ksym) + + def __str__(self): + return self.__repr__() + + ########################################### + # variables # + ########################################### + + def norm_variable(self): + clist = [C1, C2] + m1 = self.free() + s1 = [str(x) for x in m1] + for kvar in clist: + svar = str(kvar) + for i in range(len(s1)): + if s1[i] == svar: + kvar = m1[i] + def validatesymbols(self,svar): + self.ksym=expr2var(self.ksym,svar) + + self.s() + + ########################################### + # Update # + ########################################### + + def __add__(self, other): + """ Returns the vector addition of self and other """ + if type(other) == MyEq : + kres = self.ksym + other.ksym + else: + kres = self.ksym + other + if type(kres) == MyEq: + kres.s() + return kres + + def __radd__(self, other): + if type(other) == MyEq : + kres = self.ksym + other.ksym + else: + kres = self.ksym + other + return kres + + def __sub__(self, other): + if type(other) == MyEq : + kres = self.ksym - other.ksym + else: + kres = self.ksym - other + return kres + + def __rsub__(self, other): + if type(other) == MyEq : + kres = self.ksym - other.ksym + else: + kres = self.ksym - other + return kres + + def __mul__(self, other): + """ Returns the vector addition of self and other """ + if type(other) == MyEq : + kres = self.ksym * other.ksym + else: + kres = self.ksym * other + return kres + + def __rmul__(self, other): + """ Returns the vector addition of self and other """ + if type(other) == MyEq : + kres = self.ksym * other.ksym + else: + kres = self.ksym * other + return kres + + + def __truediv__(self, other): + if type(other)==MyEq: + kres=other.ksym + return self.ksym / kres + else: + return self.ksym / (1*other) + + def __rtruediv__(self, other): + if type(other)==MyEq: + kres=other.ksym + return kres /self.ksym + else: + return (1*other)/self.ksym + + + def Di(self): + if self.varf!=[]: + return self.primi_eq + + ######################################## + # show # + ######################################## + + def s2(self,op=''): + + kres = self.ksym + self.ksym=unisymbols(kres) + if op=='2': + kres=self.eQshow + if self.type == 'Diff': + + ps1 = self.sname + '=' + ps2 = diff_name(self.var) + + display(Math(ps1 + latex(kres) + ps2)) + + + elif self.type == 'D': + sR = self.name + ' =' + kres=self.ksym + display(Math(sR + latex(kres)+' '+self.diffname)) + + elif self.type == 'I': + sR = self.name + ' =' + kres=self.ksym + display(Math(sR + latex(kres))) + + + + elif self.type == 'diff' or self.type == 'diff2': + display(Math(latex(self.EqDiff))) + + elif self.type=='LA': + try: + kres=self(L=latex2sympy('\\mathcal{L}')) + except: + kres=kres.subs('L',latex2sympy('\\mathcal{L}')) + sR = self.name + ' =' + display(Math(sR + latex(kres))) + + else: + if self.name == '': + display(Math(latex(kres))) + else: + sR = self.name + ' =' + display(Math(sR + latex(kres))) + def update(self,kres): + self.ksym=kres + + def ss(self): + sR = self.name + ' =' + display(Math(sR + latex(self.ksym))) + + def s(self,op='', **kwargs): + if type(self.ksym)==UnevaluatedExpr: + self.ksym=unisymbols(self.ksym) + + if self.tipoView: + self.ss() + else: + kres = self.ksym + self.ksym=unisymbols(kres) + if self.type==('dP'): + kres=self.primi_diff_eq + ps1 = self.name + '=' + ps2 = kres + + display(Math(ps1 + latex(ps2))) + else: + #hvar = pickle.load(open("trial.p","rb")) + if self.father=='': + qk = len(kwargs) + if qk > 0: + ee = MyEq(self.v, kshow=False) + for key, value in kwargs.items(): + ee.set(parse_expr(key), value, kshow=False, ktype=self.type) + ee.s2(op=op) + + #hvar.append([type(ee),type(ee.ksym),ee.ksym]) + + else: + self.s2(op=op) + #hvar.append([type(self),type(self.ksym),self.ksym]) + + #pickle.dump(hvar, open("trial.p", "wb")) + + + else: + mQ.s() + if self.link!='': + self.link.s() + def showd(self): + kres=self.ksym + for i in self.vfunc: + kres=show_modefunc(kres,i,ktype=2) + ee=MyEq(kres,kname=self.name) + + def showp(self): + kres=self.ksym + for i in self.vfunc: + kres=show_modefunc(kres,i,ktype=3) + ee=MyEq(kres,kname=self.name) + + + def unisymbols(self): + kres=self.ksym + kres=unisymbols(kres) + self.ksym=kres + ######################################## + # set & update + ######################################## + def MsetValue(self, vknom, vkval, kope=''): + for knom, kval in zip(vknom, vkval): + knom = unisymbols(knom) + kval = unisymbols(kval) + kres = self.ksym + kres = kres.subs(knom, kval) + kres = opemat(kres, kope=kope) + + kres = self.simplify() + #self.ksym=kres + self.s() + + def multiSet(self, vknom, vkval, kope=''): + for knom, kval in zip(vknom, vkval): + knom = unisymbols(knom) + kval = unisymbols(kval) + kres = self.ksym + kres = kres.subs(knom, kval) + kres = opemat(kres, kope=kope) + + kres = self.simplify() + self.ksym=kres + self.s() + + + + + def sset(self,kname='',vmain='',var2='',kshow=True,**kwargs): + if vmain=='': + vmain=self.vmain + if var2=='': + var2=self.var2 + if len(kwargs)>0: + + kres=self.ksym + for key, value in kwargs.items(): + nsym=parse_expr(key) + if nsym not in fpoly(kres,'free'): + kname=str(nsym) + var2=self.var2 + kres=kres.subs(Function(kname)(var2),value) + + else: + kres=kres.subs(parse_expr(key),value) + + if kname!='': + + nQQ=MyEq(kres,kname=kname,vmain=vmain,var2=var,kshow=kshow) + return nQQ + else: + self.ksym=kres + if kshow: + self.s() + + def evalif(self, kname='', **kwargs): + ee = self.xcopy(kname=kname, kshow=False) + + qk = len(kwargs) + if qk > 0: + for key, value in kwargs.items(): + if type(value) == MyEq: + value = value.ksym + ee.set(parse_expr(key), value, kshow=False) + try: + ee.primi = ee.primi.subs(parse_expr(key), value) + except: + done = False + + if kname != '': + ee.s() + return ee + else: + ee.s() + + else: + self.s() + + def set(self,*args, kshow=True,**kwargs): + ksym=self.ksym + if len(kwargs) > 0: + ksym=realsub2(ksym,**kwargs) + if len(args)==2: + if type(args[0])!=MyEq: + p1=args[0] + p2=getdata(args[1]) + try: + ksym=ksym.subs(p1,p2) + except: + ksym=subsubs(ksym,p1,p2) + + + if len(args)>0 and type(args[0])==MyEq: + for i in args: + p1=kname(i) + p2=i.ksym + try: + ksym=ksym.subs(p1,p2) + except: + ksym=subsubs(ksym,p1,p2) + + + self.ksym=ksym + if kshow: + self.s() + + + def setValue(self, knom, kval, kshow=True, kope='', kret=False): + if type(knom) != list: + knom = [knom] + kval = [kval] + for i, j in zip(knom, kval): + i = unisymbols(i) + j = unisymbols(j) + kres = self.ksym + try: + kres = kres.subs(i, j) + except: + pass + kres = opemat(kres, kope) + + self.ksym=kres + + if kret: + return self.ksym + + if kshow: + self.s() + + def setdiff(self, kvar, kval, kshow=True, kope='', kret=False): + try : + kval=alphaname(kval) + except: + done=False + self.set(knom=kvar.diff(), kval=kval, kshow=kshow, kope=kope, kret=kret) + + + def eval(self,*args, **kwargs): + + ksym = self.ksym + ksym=real_subs(ksym,**kwargs) + if 'float' in args: + ksym=float(ksym) + return ksym + + + def set_solve(self, kset, kvset, kvars, knames): + ee = MyEq(self.ksym, kshow=False) + ee.set(kset, kvset, kshow=False) + kres = ee.solve(kvars) + ee2 = MyEq(kres, knames) + return ee2 + + def set_solveR(self, kset, kvset, kvars, knames): + ee = MyEq(self.ksym, kshow=False) + ee.set(kset, kvset, kshow=False) + kres = ee.solveR(kvars) + ee2 = MyEq(kres, knames) + return ee2 + + + + def v(self): + return self.v + def value(self): + return self.ksym + + def update(self, *args): + kres=self.ksym + for i in args: + val=i.ksym + name=i.name + kres=kres.subs(name,val) + self.ksym=kres + self.s() + + + + def upgradeinteger(self,*args,**kwargs): + kres=self.ksym + p1,p2=kres.args + ee=MyEq(p1,'ee',kshow=False) + for i in args: + ee.upgrade(*args,kshow=false) + eres=ee.ksym + eres=real_subs(eres,**kwargs) + return Integral(eres, p2) + + def upgradeintegerdiff(self,newdiff,x1='',x2=''): + + newv=newdiff.var + kres=self.ksym + p1,p2=kres.args + dsym=newdiff.ksym + p1=p1*dsym + p2=(newv,p2[1],p2[2]) + if x1!='': + p2=(newv,x1,x2) + + kres= Integral(p1,p2) + self.var=newv + self.diffname=newdiff.diffname + self.ksym=kres + + + + def up(self,*args,x1='',x2=''): + for i in args: + self.upgrade(i,x1=x1,x2=x2,kshow=False) + self.s() + + def change_integral(self,newval='',nvar='',x1='',x2=''): + kres=self.ksym + p1,p2=kres.args + if newval!='': + p1=newval + var=self.var + if nvar!='': + var=nvar + xx1=self.x1 + xx2=self.x2 + if x1!='': + xx1=x1 + xx2=x2 + p2=(var,xx1,xx2) + self.primi=p1 + self.ksym= Integral(p1,p2) + def get_intedata(self): + kres=self.ksym + p1,p2=kres.args + kres=p1 + var,x1,x2=p2 + return(kres,var,x1,x2) + + ############################################## + ## Transformacion + + def replaceexpr(self,val1,val2): + ssym=str(self.ksym) + ssym=ssym.replace(str(val1),str(val2)) + try: + self.ksym=parse_expr(ssym) + except: + pass + self.s() + + + def replace(self,*args,kshow=True,**kwargs): #@tif + p1=self.ksym + p1=real_subs(p1,**kwargs) + + if len(args)>0: + for i in args: + + if type(i)==MyEq: + sname=i.name + value=i.ksym + else: + sname=str(i) + value=i + p1=p1.subs(sname,value) + + self.ksym=p1 + + if kshow: + self.s() + + + + def upgrade(self, *args,x1='',x2='',kope='', kshow=True, **kwargs): + + if self.type=='I': + + kdiffe=args[0] + ktypo=kdiffe.type + if ktypo=='D': + self.upgradeintegerdiff(args[0],x1=x1,x2=x2) + if ktypo=='P': + kres,var,x1,x2=self.get_intedata() + ee=MyEq(kres,'ee',kshow=False) + ee.upgrade(kdiffe,kshow=False) + kres=ee.ksym + self.change_integral(newval=kres) + + + else: + if len(args) == 1: + if type(args[0]) == list: + args = args[0] + + for i in args: + kname = i.name + if len(kname)==2: + sres=str(self.ksym) + oname=kname[0]+'_'+kname[1] + if oname in sres: + self.set(oname, i, kshow=False, kope=kope) + else: + self.set(kname, i, kshow=False, kope=kope) + else: + self.set(kname, i, kshow=False, kope=kope) + if 'I' in self.type: + ee = MyEq(self.primi, kshow=False) + ee.set(kname, i, kshow=False, kope=kope) + self.primi = ee.ksym + try: + self.primi = self.primi.subs(kname, i) + except: + done = False + if len(kwargs) > 0: + self.set(**kwargs, kshow=False) + if kshow: + self.s() + + def kret(self): + return self.ksym + sR = self.name + ' =' + + ########################################### + # edit copy + ########################################### + + def xcopy(self, kname, kshow=True): + ee = copy.deepcopy(self) + if kname != '': + ee.name = kname + if kshow: + ee.s() + return ee + def sExp(self, kval): + if self.name == '': + display(Math(latex(self.ksym))) + else: + sR = self.name + ' =' + display(Math(sR + latex(kval))) + + def undo(self,kshow=True): + self.ksym = self.histo + self.v = self.histo + if kshow: + self.s() + + def cut_denom(self, kope=''): + kres = numer(self.ksym) + kres = opemat(kres, kope) + self.ksym=kres + return self.ksym + + + + + def reduF(self, kshow=True, kupdate=True): + + kres = self.ksym + kres = factor(kres) + kres2 = 1 + if Is_Mono(kres): + kres = numer(kres) + + mm = fpoly(kres, 'list') + for i in mm: + if Is_Poly(i): + kres2 = kres2 * i + + if kres2 != 0 and kres2 != 1: + self.ksym = kres2 + self.s() + ########################################### + # Math operation + # Add, SUbs, Mul, Div, Pow, Rpow + ########################################### + + ## Add + def add(self,*args,kshow=True,**kwargs): #@tif + return self.Add(*args,kshow=True,**kwargs) + + def Add(self,avar,kname='', kshow=True,**kwargs): #@tif + kres=self.ksym + kres=real_subs(kres,**kwargs) + kres=kres+avar + if kname!='': + + ee=MyEq(kres,kname,var=self.var,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + def Substrac(self,avar,kname='', kshow=True,**kwargs): #@tif + kres=self.ksym + kres=real_subs(kres,**kwargs) + kres=kres-avar + if kname!='': + + ee=MyEq(kres,kname,var=self.var,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + def subsubs(self,*args,force=False,text=False): + expr=self.ksym + if type(args[0])==list: + vec1=args[0] + vec2=args[1] + for i,j in zip(vec1,vec2): + expr=subsubs(expr,i,j,force=force) + else: + expr=subsubs(expr,args[0],args[1],force=force) + + self.ksym=expr + self.s() + + def subs(self,val1,val2,kshow=True): + if type(val1)==MyEq: + val1=val1.ksym + if type(val2)==MyEq: + val2=val2.ksym + kres=self.ksym + kres=kres.subs(val1,val2) + self.ksym=kres + if kshow: + self.s() + + + def Subs(self,*args,kshow=True,**kwargs): #@tif + kres=self.ksym + kres=real_subs(kres,**kwargs) + kname='' + + for i in args: + if type(i)==str: + kname=i + else: + kres=kres-gval(i) + if kname=='': + self.ksym=kres + if kshow: + self.s() + else: + ee=MyEq(kres,kname=kname,kshow=kshow) + return ee + ## Mul + def mul(self,*args,kshow=True,**kwargs): #@tif + return self.Mul(*args,kshow=True,**kwargs) + def Mul(self,*args,ope='',kshow=True,**kwargs): #@tif + kres=self.ksym + kres=real_subs(kres,**kwargs) + kname='' + + for i in args: + if type(i)==str: + kname=i + else: + kres=kres*gval(i) + if ope!='': + kres=opemat(kres,ope) + + if kname=='': + self.ksym=kres + if kshow: + self.s() + else: + ee=MyEq(kres,kname=kname,kshow=kshow) + return ee + + + + ## Mul + def div(self,dval,kshow=True): + return self.Div(dval=dval,kname=kname,kshow=kshow) + + def Div(self,*args ,kshow=True): + vecop=['simplify','factor','expand'] + dval=args[0] + kres=self.ksym + kres=Div(kres,dval) + if 'simplify' in args: + kres=simplify(kres) + if 'factor' in args: + kres=factor(kres) + if 'expand' in args: + kres=expand(kres) + self.ksym=kres + if kshow: + self.s() + + + + def Pow(self,kpo,kname='',ope='',kshow=True,**kwargs): #@tif + kres=self.ksym + kres=real_subs(kres,**kwargs) + kres=kpow(kres,gval(kpo)) + if ope!='': + kres=opemat(kres,ope) + if kname!='': + ee=MyEq(kres,kname=kname,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + + def sqrs(self,*args,ope='',kupdate=True, kshow=True): # #@tif return pow(k1,S('k2')) + k1=self.ksym + k2='' + k3='' + kname='' + qq=len(args) + if qq==0: + kres=sqrs(k1=k1,k2=k2,k3=k3) + + elif qq==1: + if type(args[0])==str: + kname=args[0] + else: + k2=args[0] + elif qq==2: + if type(args[0])==str: + kname=args[0] + k2=args[1] + + else: + k2=args[0] + k3=args[1] + else: + kname=args[0] + k2=args[1] + k3=args[2] + + kres=sqrs(k1=k1,k2=k2,k3=k3) + if ope!='': + kres = opemat(kres, kope=kope) + + if kname!='': + ee=MyEq(kres,kname) + return ee + + if kupdate: + self.ksym=kres + if kshow: + self.s() + else: + return kres + + + def Rpow(self,kpo,kname='',kshow=True): + kres=self.ksym + if kpo==2: + kres=sqrt(kres) + else: + kres=ppow(kres,1,kpo) + self.ksym=kres + self.s() + + ########################################### + # Math operation + # Add, SUbs, Mul, Div, Pow, Rpow + ########################################### + + + def cut_fac(self, kval): + kres = cut_fac(self.ksym, kval) + self.ksym=kres + return kres + + def signo(self): + kres = self.ksym + return signo(kres) + + def partialfraction(self,gen=''): + if gen!='': + var=gen + else: + var=self.var + kres=self.ksym + if Is_Add(kres): + total=0 + mm=fpoly(kres,'list') + for i in mm: + total+=partialfraction(i,var) + return total + kres=partialfraction(kres,var) + self.ksym=kres + self.s() + + + def par_frac(self,var='',kshow=True): + try: + kres=par_frac(self.ksym,var=var) + self.ksym=kres + except: + pass + if kshow: + self.s() + + @property + def float(self): + try: + return float(self.ksym) + except: + return self.ksym + + ########################################### + # get info + ########################################### + + def baselist(self): # if is Monomie return list of bases + kres=self.ksym + return baselist(kres) + + def expolist(self): # if is Monomie return list of exponenets + kres=self.ksym + return expolist(kres) + + + def get_dview(self): + kres=self.ksym + for i in self.vfunc: + kres=show_modefunc(kres,i,ktype=2) + return kres + + def get_pview(self): + kres=self.ksym + for i in self.vfunc: + kres=show_modefunc(kres,i,ktype=3) + return kres + + + def list(self, kopt=''): #@tif + kres = self.ksym + kres = fpoly(kres, 'list') + if kopt != '': + return kres[kopt] + else: + return kres + + def slist(self, kopt=''): # symbols list + kres = self.ksym + kres = fpoly(kres, 'list') + vres=[] + for i in kres: + vres.append(num_ksym2ksym(i)) + if kopt != '': + return vres[kopt] + else: + return vres + + + def free(self): #@tif + kres = self.ksym + kres = fpoly(kres, 'free') + return kres + + def get_args(self,*args): #@tif + kres=self.ksym + for i in args: + kres=kres.args[i] + return kres + + + def args(self,*args,deep=2,format='list'): + if len(args)==0: + showarglist(self.ksym,deep=deep,format=format) + else: + kres=self.ksym + for i in args: + kres=kres.args[i] + return kres + + def get_primitive(self,kname='',kshow=True): + kres=self.ksym + if self.varf!=[]: + + ee=self.xcopy(kname,kshow=False) + nf=[Function(x)(ee.var2) for x in ee.varf] + for i,j in zip(ee.varf,nf): + ee.set(i,j,kshow=False) + + self.primi_eq=ee.ksym + if kname!='': + ee.s() + return ee + else: + return ee.ksym + else: + self.s() + + + + + def forceSetValue(self, knom, kval): + + sknom = str(knom) + skval = str(kval) + skvalue = str(self.ksym) + skvalue.replace(sknom, skval) + kfac = 1 + if skavlue[0] == '-': + skvalue = skvalue[1:-1] + kfac = -1 + kres = parse_expr(skvalue) + kres = kres * kfac + self.ksym=kres + self.s() + + + + def kdiff(self, kval, kope='', kupdate=False): + kres = kdiff(self.ksym, kval) + kres = opemat(kres, kope) + if kupdate: + self.ksym=kres + self.s() + else: + return kres + + + def integrate(self,var1=''): + P1=self.ksym + if var1=='': + var1=self.var + + v1,v2=varDiff(str(var1),'vv') + P1=P1.subs(v1,1) + + sv1='d'+str(v1) + + P1=P1.subs(sv1,1) + + ee1=MyIntg(P1,'ee1',var=var1,kshow=False) + + self.ksym=ee1.ksym + + self.s() + def integral(self,kname='',x1='', x2='', var=''): + from lib_MyIntegral import MyIntg + if kname=='': + name2=self.name + name2=name2.replace('d','') + kname=name2 + var=self.var + obj=obj2func(self) + + ee=MyIntg(obj,kname,var=var,x1=x1,x2=x2) + ee.varc=True + return ee + + + + def modo_integral(self,*args): + Iee=self.xcopy('iee',kshow=False) + kres=Iee.ksym + kname='' + for i in args: + if type(i)==str: + kname=i + else: + ival=i[0] + delI=symbols(diffname(ival)) + Iee.set(delI,1,kshow=False) + kres=Iee.ksym + for i in args: + if type(i)!=str: + if len(i)==1: + kres=Integral(kres,i[0]) + elif len(i)==2: + kres=Integral(kres,(i[0],0,i[1])) + else: + kres=Integral(kres,(i[0],i[1],i[2])) + if kname=='': + self.ksym=kres + self.s() + else: + newee=MyEq(kres,kname=kname) + return newee + + def tintegral_def(self, alpha1, a1, a2, kupdate=False): + keq = self.ksym + kres = tintegral_def(keq, alpha1, a1, a2) + if kupdate: + self.ksym=kres + self.s() + else: + return kres + + def only_nume(self, kope=''): + kres = self.get_nume() + kres = opemat(kres, kope) + self.ksym=kres + self.s() + + def only_deno(self, kope=''): + kres = self.get_deno() + kres = opemat(kres, kope) + self.ksym=kres + rself.s() + + def get_MonoExp(self): + kres2 = self.ksym + kres = kres2.fpoly('get', 1) + return kres + + # def evalue(self, *args, kope='', kshow=False, **kwargs): + # qk = len(kwargs) + # if qk > 0: + # for key, value in kwargs.items(): + # self.set(parse_expr(key), value, kshow=False) + # try: + # self.primi = self.primi.subs(parse_expr(key), value) + # except: + # done = False + # if len(args) == 1: + # var2 = self.var2 + + # kres = self(var2=args[0]) + # return kres + + def evalueArray(self, knom, vkval): + + kres = [self.evalue(knom, xx, kshow=False) for xx in vkval] + return kres + + ########################################### + # Functions + ########################################### + + def rad2sex(self): #convert rad 2 sex + kres=self.ksym + try: + kres=rad2sex(kres) + except: + pass + self.ksym=kres + self.s() + + def sex2rad(self): #convert sex 2 rad + kres=self.ksym + try: + kres=sex2rad(kres) + except: + pass + self.ksym=kres + self.s() + + + + @property + def Type(self): + return type(self.ksym) + + def slope(self, xx, kval='', kope=''): + xExp = self.ksym + + kres = self.kdiff(xx) + if kval != '': + kres = kres.subs(xx, kval) + kres = opemat(kres, kope) + return kres + + def slopeO(self, xx, kval='', kope=''): + xExp = self.ksym + + kres = self.kdiff(xx) + kres = -1 / kres + if kval != '': + kres = kres.subs(xx, kval) + kres = opemat(kres, kope) + return kres + + def get_aTan(self, kname='', **kwargs): + if kname != '': + return MyEq(self.angTan(**kwargs), kname=kname) + + return self.angTan(**kwargs) + + def angTan(self, kname='', **kwargs): + kres = self.ksym + var2 = self.var2 + kres = kres.diff(var2) + if len(kwargs) > 0: + ee = MyEq(kres, kshow=False) + kres = ee(**kwargs) + if len(fpoly(kres, 'list')) > 1: + mm = fpoly(kres, 'list') + qq = len(mm) + kres = mm[qq - 1] + if kname != '': + return MyEq(atan(kres), kname) + else: + return atan(kres) + + def get_aOrto(self, kname='', **kwargs): + if kname != '': + return MyEq(self.angOrto(**kwargs), kname=kname) + return self.angOrto(**kwargs) + + def angOrto(self, kname='', **kwargs): + kres = self.angTan(**kwargs) + if kname != '': + return MyEq(kres, kname) + else: + return (kres + pi / 2) + + def ang_vecTan(self, **kwargs): + kres = ee.diff(**kwargs) + kres = atan(kres) + return kres + + def ang_vecOrto(ee, **kwargs): + kres = ee.diff(**kwargs) + kres = atan(kres) + return kres + pi / 2 + + def Is_Poly(self): + return Is_Poly(self.ksym) + + def Is_Mono(self): + return (Is_Mono(self.ksym)) + + def Is_Add(self): + kres = self.ksym + if type(kres) == Add: + return True + else: + return False + + def Is_Mul(self): + kres = self.ksym + if type(kres) == Mul: + return True + else: + return False + + def Is_Pow(self): + kres = self.ksym + if type(kres) == Pow: + return True + else: + return False + + ########################################### + # Transformation + ########################################### + + def transformada(self,expr0,ssym,kope=''): + kres=self.ksym + try: + kres=transformada(kres,expr0=expr0,ssym=ssym,kope=kope) + self.ksym=kres + except: + pass + self.ksym=kres + self.s() + + def simplifyroot(self,kshow=True): + + kres=self.ksym + kres=simplifyroot(kres) + self.ksym=kres + if kshow: + self.s() + + + def subsnumber(self,val1,val2,kope='',kshow=True): + kres=self.ksym + kres=subsnumber(kres,val1,val2) + if kope!='': + kres=opemat(kres,kope=kope) + self.ksym=kres + if kshow: + self.s() + + def all_type(self): + self.s() + sE(['Monomie= ', self.Is_Mono(), ' ', 'Polynomie = ', self.Is_Poly()]) + sE(['Is Add= ', self.Is_Add(), ' ', 'Is Mul= ', self.Is_Mul()]) + + + def addexpand(self): + self.ksym=addexpand(self.ksym) + self.s() + + + def expand(self, kname='',kshow=True): #@tif + kres = self.ksym + kres=expand(kres) + if kname!='': + ee=MyEq(kres,kname=kname,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + def expanddenom(self, kname='',kshow=True): #@tif + kres = self.ksym + p1=numer(kres) + p2=denom(kres) + p2=expand(p2) + + kres=p1/p2 + if kname!='': + ee=MyEq(kres,kname=kname,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + def expandnumer(self, kname='',kshow=True): #@tif + kres = self.ksym + p1=numer(kres) + p2=denom(kres) + p1=expand(p1) + + kres=p1/p2 + if kname!='': + ee=MyEq(kres,kname=kname,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + def factor(self,*args, kshow=True ): + kres = self.ksym + if 'sqrt' in args: + kres=factor(kres,extension=sqrt(2)) + elif len(args)==1 and type(args[0])!=str: + kres=collect(kres,args[0]) + else: + kres=factor(kres) + self.ksym=kres + if kshow: + self.s() + def apart(self,kshow=True): + + kres=self.ksym + kres=apart(kres) + self.ksym=kres + if kshow: + self.s() + + def inverse(self,kshow=True): + + kres=self.ksym + kres=iinverse(kres) + self.ksym=kres + if kshow: + self.s() + + def simplifybase(self,kname='',kshow=True): # simplify each ecponet in expr + ksym = self.ksym + kres=simplifybase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def simplify(self): + kres = self.ksym + kres = simplify(kres) + self.ksym=kres + self.s() + + def simplify_img(self,kshow=True): + kres = self.ksym + kres = simplify_img(kres) + self.ksym=kres + if kshow: + self.s() + def lmul2lpow(self, kupdate=True, kshow=True, kope=''): + kres = self.ksym + kres = lmul2lpow(kres) + kres = opemat(kres, kope=kope) + if kupdate: + self.ksym=kres + if kshow: + self.s() + + + def lsimplify(self, kupdate=True, kshow=True, kope=''): + kres = self.ksym + kres = lsimplify(kres) + kres = opemat(kres, kope=kope) + if kupdate: + self.ksym=kres + if kshow: + self.s() + + def numerexpand(self): + expr=self.ksym + p1,p2=fraction(expr) + p1=expand(p1) + self.ksym = cfrac(p1,p2) + self.s() + def numerfactor(self): + expr=self.ksym + p1,p2=fraction(expr) + p1=factor(p1) + self.ksym = cfrac(p1,p2) + self.s() + def numersimplify(self): + expr=self.ksym + p1,p2=fraction(expr) + p1=simplify(p1) + self.ksym = cfrac(p1,p2) + self.s() + def denoexpand(self): + expr=self.ksym + p1,p2=fraction(expr) + p2=expand(p2) + self.ksym = cfrac(p1,p2) + self.s() + def denofactor(self): + expr=self.ksym + p1,p2=fraction(expr) + p2=factor(p2) + self.ksym = cfrac(p1,p2) + self.s() + def denosimplify(self): + expr=self.ksym + p1,p2=fraction(expr) + p2=simplify(p2) + self.ksym = cfrac(p1,p2) + self.s() + + + def dfactor(self, var,var1,op=''): + kres=self.ksym + kres = dfactor(kres,var=var,var1=var1,op=op) + + self.ksym=kres + self.s() + + def dsimplify(self, var,var1): + kres=self.ksym + kres = dsimplify(kres,var=var,var1=var) + + self.ksym=kres + self.s() + + def dothis(self,*args): + ksym=self.ksym + args2=[ksym] + for i in args: + args2.append(i) + kres=dothis(*args2) + self.ksym=kres + self.s() + def doindenom (self,*args): + ksym=self.ksym + func=args[0] + if len(args)==1: + kres=doindenom(ksym,func) + else: + expr2=args[1] + kres=doindenom(ksym,func,expr2) + + self.ksym=kres + self.s() + def doinnumer (self,*args): + ksym=self.ksym + func=args[0] + if len(args)==1: + kres=doinnumer(ksym,func) + else: + expr2=args[1] + kres=doinnumer(ksym,func,expr2) + + self.ksym=kres + self.s() + def simplifyexpand(self, kupdate=True, kshow=True, kope=''): + kres = self.ksym + kres = simplifyexpand(kres) + kres = opemat(kres, kope=kope) + if kupdate: + self.ksym=kres + if kshow: + self.s() + + def expandbase(self,kname='',kshow=True): + ksym = self.ksym + kres=expandbase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def disjoinbase(self,kname='',kshow=True): + ksym = self.ksym + kres=disjoinbase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + + def disjoinexpo(self,kname='',kshow=True): + ksym = self.ksym + kres=disjoinexpo(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def joinbase(self,kname='',kshow=True): + ksym = self.ksym + kres=joinbase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def joinexpo(self,kshow=True): + ksym = self.ksym + kres=joinexpo(ksym) + if kshow: + self.s() + def separebase(self,kname='',kshow=True): + ksym = self.ksym + kres=separebase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + + def sum2mulexpo(self,kname='',kshow=True): + ksym = self.ksym + kres=sum2mulexpo(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def expandexpo(self,kname='',kshow=True): + + ksym = self.ksym + kres=expandexpo(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def rsimplify(self,kname='',kshow=True): + + ksym = self.ksym + kres=rsimplify(ksym) + kres=simplify(kres) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def swappow2pow(self,kname='',kshow=True): + + ksym = self.ksym + kres=swapPow2Pow(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def swapPow2Pow(self,kname='',kshow=True): + + ksym = self.ksym + kres=swapPow2Pow(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def pow2powpow(self,*args,kshow=True): + ksym = self.ksym + exp1='' + ktype='out' + kname='' + for i in args: + if type(i)==str: + ktype=i + else: + exp1=i + args=[ksym,exp1,ktype] + kres=pow2powpow(*args) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def packexp(self,kshow=True): + kres=self.ksym + kres=packexp(kres) + self.ksym=kres + if kshow: + self.s() + + def base2frac(self,kshow=True): + kres=self.ksym + kres=base2frac(kres) + self.ksym=kres + if kshow: + self.s() + + def basefactor(self,kope='',kshow=True): + return self.simplifyexp(kope=kope,kshow=kshow) + + + def simplifyexpo(self,kname='',kshow=True): + ksym = self.ksym + kres=simplifyexpo(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + return kres + def primefactors(self,kshow=True): + kres=self.ksym + kres=primefactor(kres) + + self.ksym=kres + if kshow: + self.s() + def primefactor(self,kshow=True): + self.ksym=UnevaluatedExpr(primefactor(self.ksym)) + self.tipoView=True + if kshow: + self.ss() + + + + + + + def div2mulexp(self,kope='',kshow=True): + kres=self.ksym + kres=div2mulexp(kres) + if kope!='': + kres=opemat(kres,kope=kope) + self.ksym=kres + if kshow: + self.s() + + def simplifyrpow(self, kupdate=True, kshow=True, kope=''): + kres = self.ksym + kres = simplifyrpow(kres) + kres = opemat(kres, kope=kope) + if kupdate: + self.ksym=kres + if kshow: + self.s() + def reducePow(self, kupdate=True, kshow=True, kope=''): + kres = self.ksym + kres = reducePow(kres) + kres = opemat(kres, kope=kope) + if kupdate: + self.ksym=kres + if kshow: + self.s() + + def simplify_sec(self,kshow=True): + kres = self.ksym + if self.Is_Add(): + sres = 0 + mm=fpoly(kres, 'list') + for i in mm: + sres += simplify(i) + self.ksym=sres + + self.update(self.ksym) + if kshow: + self.s() + + + def roots(self,kshow=True): + return self.solve(self.var,'all',kshow=kshow) + + def root(self): + return self.solve(self.var,'all') + + def linfactor(self, kvar,kshow=True): + p1=self.ksym + p1=linfactor(p1,kvar) + self.ksym=p1 + if kshow: + self.s() + + + def cancel(self, kvar='', kshow=True, kope=''): + kres = self.ksym + if kvar != '': + g1 = self.fpoly('filt', kvar) + g2 = kres - g1 + g3 = factor(g1) + kres = g3 + g2 + else: + kres = cancel(kres) + kres = opemat(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + + def texpand(self, kshow=True, kope=''): + kres = self.ksym + + + kres = texpand(kres) + kres = opemat(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + + def tsimplify(self, kshow=True, kope=''): + kres = self.ksym + kres = trigsimp(kres) + kres = opemat(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + def tfunc53(self,alpha=alpha,kshow=True): + kres=self.ksym + kres=tfunc53(kres,alpha) + self.ksym=kres + if kshow: + self.s() + + def tfunc37(self,alpha=alpha,kshow=True): + kres=self.ksym + kres=tfunc37(kres,alpha) + self.ksym=kres + if kshow: + self.s() + def tfunc16(self,alpha=alpha,kshow=True): + kres=self.ksym + kres=tfunc16(kres,alpha) + self.ksym=kres + if kshow: + self.s() + + def tfunc74(self,alpha=alpha,kshow=True): + kres=self.ksym + kres=tfunc74(kres,alpha) + self.ksym=kres + if kshow: + self.s() + + def lexpand(self, kshow=True): + kres = self.ksym + kres = lexpand(kres) + self.ksym=kres + if kshow: + self.s() + def lexponent(self): + expr=self.ksym + expr=lexponent(expr) + self.ksym=expr + self.s() + + def lfactor(self, kshow=True, kope=''): + kres = self.ksym + kres = logcombine(kres,force=True) + self.ksym=kres + + if kshow: + self.s() + def positivexpo(self,kname='',kshow=True,force=False): + ksym = self.ksym + kres=positivexpo(ksym,force=force) + if self.get_deno()!=1: + kres=cfrac(positivexpo(self.get_nume(),force=force),positivexpo(self.get_deno(),force=force)) + + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def exp(self, kshow=True, kope=''): + kres = self.ksym + kres = exp(kres) + kres = opemat(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + def lexponent(self,kname='',kshow=True): + ksym = self.ksym + kres=lexponent(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def log(self, kshow=True, kope=''): + kres = self.ksym + kres = log(kres) + try: + kres=lsimplify(kres) + except: + pass + kres = opemat(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + + def opemat(self, kope='', kshow=True): + kres = self.ksym + kres = opemat(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + + def opematsec(self, kope='', kshow=True): # equal to pemat but secuential + kres = unisymbols(self.ksym) + kres = opematsec(kres, kope=kope) + self.ksym=kres + if kshow: + self.s() + + def simplify_Rpow(self, kshow=True): + kres = self.ksym + kres = cut_root_of_pow(kres) + + self.ksym=kres + if kshow: + self.s() + + def sort(self): + kres = self.ksym + klist = self.fpoly('list') + mm = 0 + for i in klist: + mm += i + kres = mm + self.ksym=kres + self.s() + + def expandExp(self): + kres2 = self.ksym + kvar = fpoly(kres2, 'get', 0) + kexp = fpoly(kres2, 'get', 1) + keList = fpoly(kexp, 'list') + mm = 0 + for i in keList: + mm += kpow(kvar, i) + return mm + + def get_inside_root(self, kname=''): + mm = str(self.ksym) + cc = 0 + kk = mm.find('sqrt') + kk2 = kk + 4 + sres = '' + qq = len(mm) + for i in range(kk2, qq): + val = mm[i] + if val == '(': + cc += 1 + if val == ')': + cc -= 1 + sres = sres + val + if cc == 0: + kres = parse_expr(sres) + if kname != '': + ee = MyEq(kres, kname) + return ee + else: + return kres + return self.ksym + def get_type(self): + return type(self.ksym) + + + @property + def numer(self): + kres=self.ksym + return kreturn(numer(kres)) + + @property + def get_nume(self): + return kreturn(numer(self.ksym)) + + + @property + def denom(self): + kres=self.ksym + return kreturn(denom(kres)) + + + def get_deno(self): + return kreturn(denom(self.ksym)) + + def rem(self,val2=''): + if val2!='': + kres=self.ksym + return rem(self.ksym,val2) + else: + p1=self.numer + p2=self.denom + return rem(p1,p2) + + def diffValue(self, kval=''): + if kval == '': + kval = self.var2 + kres = diff(self.ksym, kval) + return kres + + def fpoly(self, kopt='', op2='', op3=''): + kres = self.ksym + return fpoly(kres, kopt=kopt, op2=op2, op3=op3) + + def getexpo(self,kname='',kshow=True): + ksym = self.ksym + kres=getexpo(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + return kres + + def getexponent(self,kname='',kshow=True): + return self.getexpo(kname=kname,kshow=kshow) + + def get_expo(self,kname='',kshow=True): # return exponente from monomie expresion + return self.getexpo(kname=kname,kshow=kshow) + + def getbase(self,kname='',kshow=True): + ksym = self.ksym + kres=getbase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + return kres + + + def get_killexpo(self): + ksym = self.v + if Is_Mono(ksym): + mm = fpoly(ksym, 'list') + return mm[1] + + def get_sitem(self, vv=[]): + mm = self.list() + qq = len(mm) + ksum = 0 + for i in range(qq): + if i in vv: + ksum += mm[i] + return ksum + + def part(self, vec): + + kres = self.ksym + try: + return part(kres, vec) + except: + return kres + + def solvediff(self, kvar, kd='', kremp=False, kope='', korden=''): + return self.solve(kvar=kvar.diff(), kd=kd, kremp=kremp, kope=kope, korden=korden) + + def solve_if_and(self, svar, eqv=0, kope='',korden='',kshow=True, **kwargs): + r''' + solve variable from MyEq + parameters : + svar :type str , variablesin side the Eq taht we will find + eqv :type nemeric or symbols , if the value of all Eq + defaul Eq=0 + kwargs: t=0,g=10... etc + return MyEq of svar + example: + ********** + R(t)= C1 + C2*t + g*sin(t*w)/w**2 + C1= solve_if_and('C1',L,t=0) + return: C1=L + + R.upgrade(C1) + return: C2*t + L + g*sin(t*w)/w**2 + + C2=solve_if_and(R,'C2',t=2) + return:-L/2 - g*sin(2*w)/(2*w**2) + + R.upgrade(C2) + return: L + g*sin(t*w)/w**2 + t*(-L/2 - g*sin(2*w)/(2*w**2)) + + ''' + kres = self.ksym - eqv + if len(kwargs) > 0: + kres = self(**kwargs) - eqv + nee = MyEq(kres, kname=svar, kshow=False, kope=kope,) + kres=nee.ssolve(svar,korden=korden,kshow=kshow,kope=kope) + self.set(svar,kres,kshow=kshow,kope=kope) + return kres + + def solveif(self,var,**kwargs): + kres=self.ksym-parse_expr(self.name) + kres=real_subs(kres,**kwargs) + ee=MyEq(kres,'ee',kshow=False) + rvar=ee.solve(var,kname=str(var)) + return rvar + + def get_symbol_in_ee(self, svar=''): + mm = self.free() + for i in mm: + if i.name == svar: + return i + return svar + + def left(self): + return symbols(self.name) + + def right(self): + return self.ksym + + def ssolve(self, kname,korden='',kshow=True,kope=''): + + kvar = self.get_symbol_in_ee(svar=kname) + return self.solve(kvar, kname=kname,korden=korden,kshow=kshow) + + ########################################### + # SOLVE + ########################################### + + # solve() + + def solve(self,*args,kshow=True,**kwargs): + var=args[0] + kres=self.ksym + + + if len(kwargs)>0: + vecs,vecv=unpack(kwargs) + if self.name in vecs: + Y=0 + for i,j in zip(vecs,vecv): + if i==self.name: + Y=j + kres=kres-Y + kres=real_subs(kres,**kwargs) + ksolu=solve(kres,var) + newargs=[] + if len(args)>1: + newargs=args[1::] + + if 'float' in newargs: + nksolu=[] + for i in ksolu: + try: + nksolu.append(float(i)) + except: + nksolu.append(i) + ksolu=nksolu + if 'signo' in newargs: + nksolu=[] + for i in ksolu: + try: + nksolu.append(-1*i) + except: + nksolu.append(i) + ksolu=nksolu + if 'all' in newargs: + if kshow: + display(Math(latex(ksolu))) + return ksolu + + if 'noimg' in newargs or 'nonimaginary' in newargs: + return [i for i in ksolu if not 'I' in str(i)] + try: + ksolu=ksolu[0] + except: + ksolu=ksolu + if 'value' in newargs: + return ksolu + + + if 'hide' in newargs: + kshow=False + + + var=MyEq(ksolu,str(var),kshow=kshow) + if 'update' in newargs: + self.set(var) + + else: + return var + + + + + # def solve(self,*args,kshow=True,**kwargs): + # if len(args)==0: + # helplib('solve') + # return + # var=args[0] + # args=args[1:len(args)] + # self2=copy.deepcopy(self.ksym) + # kres=self.ksym + # eQ=copy.deepcopy(kres) + # try: + # kname=str(var) + # except: + # kname=str(var) + # if len(kwargs)>0: + + # mm=[] + # for i in kwargs: + # mm.append(i) + + # if self.name in mm: + + # kres=self.ksym-symbols(self.name) + + # if len(kwargs)>0: + # kres=real_subs(kres,**kwargs) + + + # solu=ksolve(kres,var) + + + # if len(args)>0: + # if 'all' in args: + # solu=solve(kres,var) + # if 'float' in args: + # try: + # solu=float(solu) + + # except: + # solu=[float(i) for i in solu] + + # display(Math(latex(solu))) + # return solu + + # return solu + # if 'float' in args: + # try: + # solu=float(solu) + + # except: + + # pass + + # if 'value' in args: + # return solu + # elif'update' in args: + # eQ=self2.subs(var,solu) + # self.ksym=eQ + # self.s() + # ee=MyEq(solu,kname=str(var),kshow=kshow) + # return ee + + + # ee=MyEq(solu,kname=str(var),kshow=kshow) + # return ee + + def solveset(self, *args,kshow=True,**kwargs): + kres=self.solve(*args,kshow=True,**kwargs) + self.upgrade(kres) + return kres + + + def solvediffsymbol(self,var2): + var=self.var + V2=symbols(str(var2)) + dy1,dy2=primesymboldiff(var2) + yy=Function(str(var2))(var) + sv2f=str(var2)+'('+str(self.var)+')' + sv2=str(var2) + kres=self.ksym + dy=yy.diff(var) + ee=self.solve(dy,kshow=False) + ee.name=str(dy1) + + kres=ee.ksym + kres2=subsubs(kres,sv2f,sv2) + ee.ksym=kres + + ee.s() + return ee + + + def solveB(self, kvar, kname='', kremp=False, kope='', korden='', ktype='P', var2='', Bag='',kpositive=False,noncero=False,kshow=True): + mm = self.ksym + self.ksym = opemat(mm, 's') + if type(kvar) == 'str' and kname == '': + kname = kvar + kvar = parse_expr(kname) + + if str(kvar) == 'None': + kname = symbols(kname) + keq = self.ksym + # kvar=unisymbols(kvar) + if noncero and kname!='': + nV=symbols(self.name) + keq=keq-nV + kname=nV.name + kres = csolve(keq, kvar, kope=kope, korden=korden) + if kres == []: + kres = csolve(keq, kname, kope=kope, korden=korden) + if kres == []: + kres = presolve(self.ksym, kvar) + + if self.type == 'Ph': + if not str(kvar) in 'alphaalpha1alpha2alpha3betha1betha2betha3': + self.Pobj.store_val(kvar, kres) + mm = self.Pobj.F + qq = len(mm) + for i in range(qq): + pkres = mm[i][0] + try: + pkres = pkres.subs(kvar, kres) + except: + done = False + mm[i][0] = pkres + self.Pobj.F = mm + if kname != '': + if type(kres) == list: + if len(kres) > 1: + if kpositive: + kres1 = MyEq(kres[1], kname, var2=self.var2) + return kres1 + + cc = 1 + kkres = [] + for i in kres: + kname1 = kname + str(cc) + kres1 = MyEq(i, kname1, kshow=False, var2=self.var2) + if Bag != '': + kres1.upBag(Bag, kope=kope) + + kres1.s() + cc += 1 + kkres.append(kres1) + + return kkres + + else: + + kres = MyEq(kres, kname, kshow=False, var2=self.var2) + if Bag != '': + kres.upBag(Bag, kope=kope) + if kshow: + kres.s() + + return kres + + + else: + return kres + + def ssolveR(self, kname): + kvar = self.get_symbol_in_ee(svar=kname) + return self.solveR(kvar, kd=kname) + + def solveR(self, kvar, kd='', kremp=False, kope='', korden='', Bag=''): + if Bag != '': + self.upBag(Bag=Bag, kshow=False) + keq = self.ksym + + try: + kres = csolveR(keq, kvar, kope=kope) + except: + kres = csolve(keq, kname, kope=kope, korden=korden) + if kd != '': + return MyEq(opemat(kres, kope=kope), kd, var2=self.var2) + else: + return kres + + def toFoat(self): + kres = self.ksym + try: + kres = float(self.ksym) + + self.ksym=kres + self.s() + except: + self.s() + + def toEqual(self, items, kkname=''): + mm = self.list() + kres1 = 0 + kres2 = 0 + qq = len(mm) + for i in range(qq): + if i in items: + kres1 += mm[i] + else: + kres2 += mm[i] + kname = self.name + kname1 = kname + '1' + kname2 = kname + '2' + kname1 = MyEq(kres1, kname1, kshow=False) + kname2 = MyEq(kres2, kname2, kshow=False) + return MyEqEq(kname1, kname2, kname=kkname) + + def opematsec(self, kope=''): # equal to pemat but secuential + kres = unisymbols(self.ksym) + kres = opematsec(kres, kope=kope) + self.ksym=kres + return kres + + def opemat_deno(self, kope=''): + kres = unisymbols(self.ksym) + kres = opemat_deno(kres, kope=kope) + self.ksym=kres + return kres + + def opemat_nume(self, kope=''): + kres = unisymbols(self.ksym) + kres = opemat_nume(kres, kope=kope) + self.ksym=kres + return kres + + def solve_tan(self, alpha): + c = tan(alpha) + + kres = self.ksym + kres.subs(sin(alpha), c / rpow(c * c + 1, 2)) + kres.subs(cos(alpha), 1 / rpow(c * c + 1, 2)) + kres1 = csolve(kres, tan(alpha)) + return kres1 + + def solve_angle(self,angle=alpha,kname='Ang'): + + if type(angle)==str: + kname=angle + angle=alpha + + valor= self.solve(angle,kshow=False) + ee=MyEq(valor.ksym,kname) + return ee + + ########################################### + # Polinomial + ########################################### + def quo(self,val2=''): + if val2!='': + kres=self.ksym + return quo(self.ksym,val2) + else: + p1=self.numer + p2=self.denom + return quo(p1,p2) + def quotient(self,ksym,kname=''): + + P=self.ksym + Q=ksym + if type(Q)==MyEq: + Q=ksym.ksym + kres=quo(P,Q) + if kname!='': + kres=MyEq(kres,kname) + return kres + else: + return kres + + def rem(self,ksym,kname=''): + + P=self.ksym + Q=ksym + if type(Q)==MyEq: + Q=ksym.ksym + kres=rem(P,Q) + if kname!='': + kres=MyEq(kres,kname) + return kres + else: + return kres + + def coef_sum(self,var2=''): + if var2=='': + var2='x' + kres=self.ksym + kres=kres.subs(var2,1) + return kres + + def get_coef(self,ksym,kname=''): # ee= x**2(a+b)+x*4*b+9 + # get_coef(x) return 4*b + mm=self.list() + mmv=[] + sres=str(ksym) + for i in mm: + mmv.append(i/ksym) + for i,j in zip(mmv,mm): + if not sres in str(i): + kres=j + kres=kres.subs(ksym,1) + if kname!='': + return MyEq(kres,kname=kname,var2=self.var2) + else: + return kres + + def get_ter_inde(self,ksym,kname=''): + kres=0 + svar=str(ksym) + mm=self.list() + for i in mm: + if not svar in str(i): + kres+=i + if kname!='': + return MyEq(kres,kname=kname,var2=self.var2) + else: + return kres + + def degree(self, kvar=0): + kres = self.ksym + return degree(kres, gen=kvar) + + def degree_list(self): + kres = self.ksym + return degree_list(kres, gen=kvar) + + + def main_coef(self): + kres = self.ksym + return LC(kres) + + def main_monomio(self): + kres = self.ksym + return LM(kres) + + def main_term(self): + kres = self.ksym + return LT(kres) + + def coef_listK(self,vx=''): + if vx=='': + vx=self.var2 + mm=self.list() + vlist=[] + for i in mm: + kres=i.subs(vx,1) + vlist.append(kres) + return vlist + + + def reduceroot(self,kshow=True): + kres = self.ksym + try: + kres = reduceroot(kres) + self.ksym=kres + + except: + pass + if kshow: + self.s() + + def separable(self): + knumer=numer(self.ksym) + kdenom=denom(self.ksym) + kres=rem(knumer,kdenom) + nnumer=knumer-kres + p1=simplify(nnumer/kdenom) + p2=kres/kdenom + self.ksym=p1+p2 + self.s() + + def reduce(self): + kres = self.ksym + kres = expand(kres) + kres = simplify(kres) + kres = factor(kres) + kres = simplify(kres) + try: + kres = cut_root_of_pow(kres) + self.ksym=kres + except: + self.ksym=kres + return kres + + def reducecero(self,kshow=True): + kres = self.ksym + kres2 = reducecero(kres) + if kres2!=kres: + self.ksym=kres2 + if kshow: + self.s() + + + + + + ########################################### + # Algebra + ########################################### + def squaresum(self,p1=0,p2=0): + kres=self.ksym + if p1!=0: + kres2=squaresum(kres,p1=p1,p2=p2) + self.ksym=kres2 + self.s() + else: + self.s() + + + # def expandexp(self): + # kres=self.ksym + # try: + # kres=expandexp(kres) + # self.ksym=kres + # except: + # pass + # self.s() + + def powexpand(self,op='',kshow=True): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + kres=self.ksym + self.ksym=powexpand(kres,op=op) + if kshow: + self.s() + + def killsqrtpow(self,kshow=True): + + kres=self.ksym + self.ksym=killsqrtpow(kres) + if kshow: + self.s() + + def opematexp(self,kope=''): + ''' + apply opemat only in exponent monomie + ''' + ksym=self.ksym + if Is_Pow(ksym): + mm=self.list() + kres=mm[1] + kres=opemat(kres,kope=kope) + self.ksym=kpow(mm[0],kres) + + if Is_Add(ksym): + mm=self.list() + mkres=0 + for i in mm: + if Is_Pow(i): + mm2=fpoly(i,'list') + kres=mm2[1] + kres=opemat(kres,kope=kope) + kres=kpow(mm2[0],kres) + else: + kres=i + mkres+=kres + + self.ksym=mkres + self.s() + + def mulexpo(self,kname='',kshow=True,force=False): + ksym = self.ksym + kres=mulexpo(ksym,force=force) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + + def expandexpA(self,kope=''): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + ksym=self.ksym + kres=expandexpA(ksym) + self.ksym=kres + if kope!='': + self.opemat(kope=kope) + self.s() + + def factorexpo(self,kname='',kshow=True): + ksym = self.ksym + kres=factorexpo(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def factorbase(self,kname='',kshow=True): + ksym = self.ksym + kres=factorbase(ksym) + if kname!='': + return MyEq(kres,kname,var=self.var,kshow=kshow) + else: + self.ksym=kres + self.s() + def coef_list(self,var2=x): # return coef list complete according max degree + ''' + ee=x*x*a+x*b+c + return [a,b,c] + + ee=a*x*x-b + return [a,0,-b] + + ''' + + kres=self.ksym + return coef_list(kres,var2) + + def get_seudocofactor(self,ksym,kname='',var2=x): + val1=self.ksym + + if type(ksym)==MyEq: + ksym=ksym.ksym + + kres,veccc=get_seudocofactor(val1,ksym,var2) + + + if kname!='': + return MyEq(kres,kname=kname,var2=var2) + else: + return kres + + def sortdegree(self,var2='',kope=''): + ''' + input a*x*x+b*x*x+c*x+d + return (a+b)x*x+c*x+d + ''' + if var2=='': + var2=self.var2 + ksym=self.ksym + kres=sortdegree(ksym,var2=var2) + self.ksym=kres + if kope!='': + self.opemat(kope=kope) + self.s() + + + def addexp(self,kope=''): # input: x**a * x**b return x**(a+b) + kres=self.ksym + kres=addexp(kres) + self.ksym=kres + if kope!='': + self.opemat(kope=kope) + self.s() + + + def insidepar(self,ssym=''): + ''' + args: + ssym dfault is '' return the first () founded + ssym = str( where search..., 'x(', 'sqrt(', 'log(' etc + return expresion inside select function + ''' + ksym=self.ksym + return insidepar(ksym,ssym=ssym) + + + def GCD(self,val1,kname='',kshow=True,var=x): + if type(val1)==MyEq: + val1=val1.ksym + kres=factor(gcd(self.ksym,val1)) + if kname!='': + return MyEq(kres,kname=kname,var=var) + else: + if kshow : + return kres + def MCD(self,val1,kname='',kshow=True,var=x): + if type(val1)==MyEq: + val1=val1.ksym + kres=factor(gcd(self.ksym,val1)) + if kname!='': + return MyEq(kres,kname=kname,var=var) + else: + if kshow : + return kres + def LCM(self,val1,kname='',kshow=True,var=x): + if type(val1)==MyEq: + val1=val1.ksym + kres=factor(lcm(self.ksym,val1)) + if kname!='': + return MyEq(kres,kname=kname,var=var) + else: + if kshow : + return kres + def MCM(self,val1,kname='',kshow=True,var=x): + if type(val1)==MyEq: + val1=val1.ksym + kres=factor(lcm(self.ksym,val1)) + if kname!='': + return MyEq(kres,kname=kname,var=var) + else: + if kshow : + return kres + ########################################### + # Reduccion Algoritmo + ########################################### + + def factorize(self,ksym,kshow=True): + + # ee=3*x**7+2*x**3 + #ee.factorize(x**3) + #return x**3*(3*x**4+2) + + + kres=self.ksym + kres=factorize(kres,ksym) + self.ksym=kres + if kshow: + self.s() + def factoriza(self,ksym,kshow=True): + + # ee=3*x**7+2*x**3 + #ee.factorize(x**3) + #return x**3*(3*x**4+2) + + + kres=self.ksym + kres=factoriza(kres,ksym) + self.ksym=kres + if kshow: + self.s() + + def nformat(self,nd): + ksym=self.ksym + try: + ksym=nformat(ksym,nd) + self.ksym=ksym + self.s() + except: + self.s() + + def reduFac(self, kop='', kshow=True): # retun Eq=0,= a*b+c*b.. = b(a+c)..=0 then return (a+c) + + kres = self.ksym + kres = factor(kres) + kres2 = 1 + if Is_Mono(kres): + kres = numer(kres) + + mm = fpoly(kres, 'list') + for i in mm: + if Is_Poly(i): + kres2 = kres2 * i + + if kres2 != 0 and kres2 != 1: + self.ksym = kres2 + else: + self.ksym = kres + if kshow: + self.s() + + def factorSec(self, *args, kfiltro='.', kshow=True): + kres = self.ksym + for i in args: + kvar=i + kres = factorSec(kEq=kres, ksym=kvar, kfiltro=kfiltro) + self.ksym=kres + if kshow: + self.s() + + def factorSecV(self, *args): + for i in args: + self.factorSec(i, kshow=False) + self.s() + + def get_cofactor(self, kfactor): + mm = self.list() + for i in mm: + j = fpoly(i, 'list') + if kfactor in j: + kres = i / kfactor + return kres + + def grupFac(self, ksym, kfiltro='.', kshow=True): + kres = self.ksym + kres = grupFac(kres, ksym, kfiltro='.') + self.ksym=kres + if kshow: + self.s() + + def get_factor_with(self, kx, kcomple=True): + eqq = self.ksym + return get_factor_with(eqq, kx=kx, kcomple=kcomple) + + def monoFactor(self, kval): + kres = self.ksym + if Is_Poly(kres): + mm1 = 0 + mm2 = 0 + mm = fpoly(kres, 'list') + for i in mm: + if Is_Mono(i) and Is_Mul(i): + + vmm = fpoly(i, 'list') + if kval in vmm: + newm = simplify(i / kval) + mm1 += newm + else: + mm2 += i + kres2 = kval * mm1 + mm2 + self.update(kres2) + return kres2 + + return kres + + def tri2bin(self,sexpr,var=x): + ksym=self.ksym + kres=tri2bin(ksym,sexpr,var=var) + self.ksym=kres + self.s() + + def trinom2binom(self,sexpr,kshow=True): + ksym=self.ksym + kres=trinom2binom(ksym,sexpr) + self.ksym=kres + if kshow: + self.s() + + + + def fixrootpow(self,op='',kshow=True): + p1=self.ksym + p1=fixrootpow(p1) + self.ksym=p1 + if kshow: + self.s() + + + def killroot(self): + ksym=self.ksym + nkasym=simplify_root_exp(ksym) + self.ksym=nkasym + self.s() + + def fixRootPow(self, kksym): + self.setValue(rpow(kpow(kksym, 2), 2), kksym) + + def fix_sqrtPow(self): + ksym=self.ksym + nkasym=fix_sqrt2pow(ksym) + self.ksym=nkasym + self.s() + + def find_root(self, ksym, x1, x2, xx): + xx = np.linspace(x1, x2, xx) + yy = self.evalueArray(ksym, xx) + mm = [] + qq = len(yy) + for i in range(qq - 1): + if (yy[i] > 0 and yy[i + 1] < 0) or (yy[i] < 0 and yy[i + 1] > 0): + mm.append((xx[i] + xx[i + 1]) / 2) + qq = len(mm) + for i in range(qq): + e1 = MyEq(self.v, str(ksym), kshow=False) + e1.setValue(ksym, mm[i]) + + def upBag(self, Bag, kname='', kshow=True, kope=''): + vs = Bag.vmain + vv = Bag.vsolve + + for i, j in zip(vs, vv): + self.set(i, j, kshow=False) + self.opemat(kope, kshow=False) + if kshow: + self.s() + + def upTriang(self, angul, T3, kope=''): + if type(angul) == MyTriang: + angu2 = angul + angul = T3 + T3 = angu + + v1 = [sin(angul), cos(angul), tan(angul), kpow(sin(angul), 2), kpow(cos(angul), 2), kpow(tan(angul), 2)] + v2 = [T3.sin(), T3.cos(), T3.tan(), kpow(T3.sin(), 2), kpow(T3.cos(), 2), kpow(T3.tan(), 2)] + + for i in range(len(v2)): + v2[i] = opemat(v2[i], kope=kope) + + self.set(v1, v2) + + def evalueBag(self, bag, kope=''): + e1 = MyEq(self.v, self.name, kshow=False) + e1.upBag(bag, kope=kope) + + def setVal_from_bag(self, bag, kshow=False, kope=''): + for i, j in zip(bag.dataS, bag.dataV): + self.setValue(i, j, kshow=kshow, kope=kope) + if kshow: + self.s() + + # Algoritmos de reparacion + + def fix_reduc(self): + kres = self.ksym + try: + kres = fix_reduc(kres) + self.ksym=kres + self.s() + except: + self.s() + ############################### + # Diff + ############################### + + def neginverse(self,kname=''): + if kname!='': + return MyEq(-1/self.ksym,kname=kname) + else: + return -1/self.ksym + + def doDiff(self,kname='',var=''): + if kname=='': + kname= self.name + if var=='': + var=self.var + + kres=self.ksym + kres=diff(kres,var) + ee=MyDiffe(kres,kname,var=var) + return ee + + + + + def diffEq(self, kname='', var2='', ktype='P', typeD=1): + self.oldprimi = self.primi + kres = self.ksym + if var2 == '': + var2 = self.var2 + if typeD == 2: + return MyEq(Derivative(kres, var2), kname=kname, var2=var2, ktype='Diff') + + def changediffI(self, newvar2, newvalue='', x1='', x2=''): + kres = self.primi + if newvalue != '': + kres = kres * newvalue + self.primi = kres + self.var2 = newvar2 + if x1 != '': + self.x1 = x1 + self.x2 = x2 + if self.x1 == '': + self.ksym = Integral(self.primi, self.var2) + else: + self.ksym = Integral(self.primi, (self.var2, self.x1, self.x2)) + self.s() + + + def changeDiff(self,ee,x1='',x2=''): + if self.type=='D' and ee.type=='D': + oldv=self.var + newv=ee.var + kres1=self.ksym + kres2=ee.ksym + kres=kres1*kres2 + self.ksym=kres + self.var=newv + self.diffname=ee.diffname + + if self.type=='D' and ee.type=='P': + oldv=self.var + newv=ee.var + kres1=self.ksym + + kres2=ee.ksym + kres1=kres1.subs(oldv,kres2) + kres3=diff(kres2,newv) + kres1=kres1*kres3 + + + self.ksym=kres1 + self.var=newv + self.diffname=diff_name(self.var) + + + if self.type=='I' and ee.type=='P': + self.upgrade(ee,kshow=False) + ksym,oldv,x1,x2=self.get_intedata() + + kdiff=diff(ee.ksym,ee.var) + kres=ksym*kdiff + + xx1=self.x1 + xx2=self.x2 + var=ee.var + + + if x1!='': + xx1=x1 + xx2=x2 + p2=(var,xx1,xx2) + p1=kres + self.primi=kres + ksym= Integral(p1,p2) + self.ksym=ksym + self.x1=xx1 + self.x2=xx2 + self.var=var + + self.s() + + def set_interval(self,x1,x2): + self.change_integral(nvar=self.var,x1=x1,x2=x2) + self.s() + + def changediff(self,newv,expr): + r''' + input, newv= new variable to changediff + expr , is thw value of old main variable 'var' + in function the new variable + ''' + newd=expr.diff(newv) + kres=self.ksym + + + oldv=self.var + + + if self.type=='I': + val=kres.args + eqq=val[0] + eqq=eqq.subs(oldv,expr) + eqq=eqq*newd + # if self.x1!='': + # x1=val[1][1] + # x2=val[1][2] + # qq=MyEq(oldv-expr,'qq',kshow=False) + # valim=qq.solve(newv,kshow=False) + # nx1=valim.ksym.subs(oldv,x1) + # nx2=valim.ksym.subs(oldv,x2) + + # ee=MyEq(eqq,kname=self.name,x1=nx1,x2=nx2,var=newv,ktype='I',kshow=False) + # self.x1=nx1 + # self.x2=nx2 + # self.var=newv + # self.ksym=ee.ksym + # self.s() + # else: + ee=MyEq(eqq,kname=self.name,var=newv,ktype='I',kshow=False,x1=self.x1,x2=self.x2) + + self.var=newv + self.ksym=ee.ksym + self.s() + else: + + kres=kres.subs(oldv,expr) + kres=kres*newd + self.ksym=kres + self.var=newv + self.s() + + ############################### + # traasforma to function + + def transform2(self,sexpr,var=x,kshow=True): + ksym=self.ksym + kres=transform2(ksym,sexpr,var=var) + self.ksym=kres + if kshow: + self.s() + + + + + + ############################### + # inverse function + def inversefunc(self,var=''): + if var=='': + helplib('inversefunc') + return + expr=self.ksym + kres=inversefunc(expr,var) + oldn=self.name + nname=oldn+'^{-1}' + nP=symbols(nname) + Q=Eq(nP,kres) + display(Math(latex(Q))) + return kres + + + + ############################### + # Integral + ####################### + + def solveI(self): + kres=self.ksym + + kres=kres.doit() + kres=fix_otherwise(kres) + rr=ccode(kres) + return rr + + def clean_ccode(self,kstr): + kstr=kstr.replace('{','') + kstr=kstr.replace('}','') + mlist=kstr.split(',') + return mlist + + def clean_solve(self,kstr): + vecc=self.clean_ccode(kstr) + vecr=[] + for i in vecc: + try: + kres=parse_expr(i) + if kres!=True and kres!=False: + vecr.append(kres) + except: + pass + return vecr + + def Isolution(self): + kstr=self.solveI() + vecr=self.clean_solve(kstr) + if len(vecr)==1: + self.ksym=vecr[0] + self.s() + else: + return vecr + + + def soveIntegral(self): + self.ksym=self.ksym.doit() + self.s() + + + + def doitI(self, kname='', kope='', kshow=True,C1=C1, **kwargs): + + kres=self.ksym + + if len(kwargs)>0: + for key, value in kwargs.items(): + kres=kres.subs(parse_expr(key),value) + + kres2=kres.doit() + + kres = opemat(kres2, kope=kope) + kres=fix_otherwise(kres) + + rr=ccode(kres) + + if '\n' in rr: + print('pason') + + + vecs=get_vecposstrfind(rr,'\n') + exp1=rr[vecs[0]+1:vecs[1]] + + if passdoitI(exp1): + kres=parse_expr(exp1) + + else: + exp2=rr[vecs[len(vecs)-2]+3:vecs[len(vecs)-1]] + if passdoitI(exp2):kres=parse_expr(exp2) + + + + + + + if self.name == 'Vo': + if sign(kres) == -1: + kres = -1 * kres + try: + kres=kres+C1 + except: + pass + + if kname != '': + ee = MyEq(kres, kname=kname,kshow=kshow) + return ee + else: + self.ksym=kres + if kshow: + self.s() + + def clearlimit(self,name=''): + if self.type=='I': + expr=self.primi + var=self.var + kres=Integral(expr,var) + if name=='': + return kres + else: + ee=MyIntg(expr,name,var=var) + return ee + + def doit(self, *args,kshow=True, c1=0, C=0,C1=C1,keyAPI='',nolimit=False,**kwargs): + vecpara=['area','positive'] + for i in args: + if i not in vecpara: + kname=i + + + if self.type == 'diff': + if len(kwargs) == 0: + kres = self.ksym + var2 = self.var2 + kres2 = diff(kres, var2) + self.update(kres2) + self.type = 'F' + s1 = self.name + s2 = alphaname(var2) + kname = s1 + '_{(' + s2 + ')}' + self.name = kname + self.s() + return + + if self.type == 'I': + if keyAPI!='': + sexpr=str(self.ksym) + sexpr=sexpr.replace('Integral(','Integrate[') + sexpr=sexpr.replace('), (','), {') + sexpr=sexpr.replace(sexpr[-2::],'}]') + import wolframalpha + client = wolframalpha.Client(keyAPI) + q = sexpr + res = client.query(q) + answer = next(res.results).text + p1=answer.find('=')+2 + p2=answer.find('≈') + if p2!=-1: + sres=answer[p1:p2] + else: + sres=answer[p1::] + self.ksym=parse_expr(sres,evaluate=False) + self.s() + + else: + + kres=self.ksym + if self.x1!='': + c1=0 + C1=0 + c1=0 + if len(kwargs) > 0: + + kres = real_subs(kres,**kwargs) + + + + kres = kres.doit() + if 'positive' in args or 'area' in args: + if signo(kres)==-1: + kres=-1*kres + if kname != '': + ee = MyEq(unisymbols(kres), kname=kname,var=self.var) + ee.type='I' + return ee + else: + return unisymbols(kres) + + + elif self.type == 'Diff': + kres = self.ksym + kres = kres.diff(self.var2) + self.ksym=kres + self.type = 'P' + self.name = 'd' + self.name + self.s() + + + else: + try: + ksym=self.ksym + ksym=ksym.doit() + self.ksym=ksym + self.s() + except: + self.s() + + + def get_diff(self, var2='', kname=''): + if var2 == '' and kname == '': + var2 = self.var2 + if var2 != '': + if type(var2) == str: + kname = var2 + var2 = self.var2 + if type(kname) != str: + var2 = kname + + kres = self.ksym + kres = diff(kres, var2) + if kname != '': + ee = MyEq(kres, kname, var2=var2) + return ee + else: + return kres + def get_primitive(self): + return self.primi_eq + def change_primitive(self,expr): + QQ=MyIntg(expr,self.name,var=self.var,x1=self.x1,x2=self.x2) + self.ksym=QQ.ksym + + + def get_dprimitive(self): + return self.diff_eq + + + def get_primitive(self,kname=''): + if kname!='': + ee=MyEq(self.primi_eq ,kname=kname,var=self.var) + return ee + else: + return self.primi_eq + + def kdiff(self, kname='', var2='', kope='', kupdate=False, ktype=''): + if ktype == '': + ktype = self.type + kres = self.ksym + if var2 == '': + var2 = self.var2 + kres = self.ksym + kres2 = diff(kres, var2) + return kres2 + if kname != '': + ee = MyEq(kres2, kname=kname, var2=var2, ktype=ktype) + return ee + else: + return kres2 + + def update_inte(self): + if self.type == 'I': + kres = self.primi + if self.x1 == '': + self.ksym = Integral(kres, self.var2) + else: + self.ksym = Integral(kres, (self.var2, self.x1, self.x2)) + + def fac_integral(self): + ksym = self.primi + var2 = self.var2 + + if Is_Mono(ksym) and Is_Mul(ksym): + kres = [x for x in ksym.args if str(var2) not in str(x)] + kres2 = [x for x in ksym.args if str(var2) in str(x)] + mono1 = 1 + mono2 = 1 + for i in kres: + mono1 = mono1 * i + for i in kres2: + mono2 = mono2 * i + self.primi = mono2 + kfac = mono1 + self.primi = mono2 + if self.x1 == '': + self.ksym = Integral(mono2, self.var2) + else: + self.ksym = Integral(mono2, (self.var2, self.x1, self.x2)) + self.Mul(mono1) + else: + self.s() + + def maximun(self, ksym, ksave=True): + ''' + Return maxumin value of ksym if self=0 + ''' + if ksave: + savework() + kres = self.ksym + kres = diff(kres, ksym) + kres = solve(kres, ksym) + kname = ksym.name + if len(kres) == 1: + return MyEq(kres[0], kname) + else: + vres = [] + cc = 1 + for i in kres: + nname = kname + str(cc) + vres.append(MyEq(i, kname=nname)) + cc += 1 + return vres + + def plot(self,*args,ymax='',ymin=''): + x1=-1 + x2=1 + x3=100 + if len(args)==2: + x1=args[0] + x2=args[1] + elif len(args)==3: + x1=args[0] + x2=args[1] + x3=args[2] + expr=self.ksym + var =self.var + Pplot(expr,var,x1=x1,x2=x2,x3=x3,ymax=ymax,ymin=ymin) + + + + def kplot(self, ksym, x1, x2, x3): + x = np.linspace(x1, x2, x3) + y = np.array([float(self(x=x)) for x in xx]) + data_plot = pd.DataFrame({str(self.var2):x, self.name:y}) + sns.lineplot(x = str(self.var2), y = self.name, data=data_plot) + plt.show() + + + def length_arc(self, x1='', x2='', x='', ksolve=True): + if x1 == '': + x1 = self.x1 + x2 = self.x2 + if x == '': + x = self.var2 + y = MyEq(self.ksym, 'y', x1=x1, x2=x2, varx=x, ktype='Diff') + y.doit() + if ksolve == 'dL': + y.name = 'dL' + y.s() + return y + y2 = y * y + y2 = opemat(y2, 'ef') + y3 = rpow(1 + y2) + y3 = opemat(y3, 'r') + L = MyEq(y3, 'L', x1=x1, x2=x2, varx=x, ktype='Diff') + + L.integral() + if ksolve: + return L.doitI() + else: + return L + + + ################################################ + ## Diferencial ### + ################################################ + def limit(self,*args): + if len(args)==0: + helplib('limit') + return + ksym=self.ksym + var=self.var + op="" + valr=args[0] + if len(args)==2: + op=args[1] + return limit(ksym, var, valr, dir=op) + else: + return limit(ksym, var, valr) + + def Limit(self,*args): + if len(args)==0: + helplib('limit') + return + ksym=self.ksym + var=self.var + op="" + valr=args[0] + if len(args)==2: + op=args[1] + return Limit(ksym, var, valr, dir=op) + else: + return Limit(ksym, var, valr) + self.type='L' + self.varL=valr + + + def dsolve(self, kname='', C1='', C2=''): + kres = self.EqDiff + dres = dsolve(kres) + mdres = dres.args + kres = mdres[1] + if C1 != '': + kres = kres.subs('C1', C1) + if C2 != '': + kres = kres.subs('C2', C2) + if kname != '': + ee = MyEq(kres, kname=kname, var2=self.var2, ktype='F') + return ee + else: + ee = MyEq(kres, kname=alphaname(self.var1), var2=self.var2, ktype='F') + return ee + def derivada(self,*args): + kname='d'+self.name + kres=diff(self.ksym,self.var) + return MyDiffe(kres,kname,var=self.var) + + def doDiff(self): + + kname='d'+alphaname(self.name) + var=self.var + + + kres=self.ksym + kres=diff(kres,var) + ee=MyEq(kres,kname,var=var,ktype='D') + return ee + + + def Diff(self,*args,kshow=True): + + kres=self.ksym + var=self.var + kname='' + for i in args: + if type(i)==str: + kname=i + if Is_Symbol(i): + var=i + kres=diff(kres,var) + if kname=='': + kname='d_'+self.name + return MyEq(kres,kname=kname,var=var,ktype='D',kshow=kshow) + + + + + + def applyDiff(self, var2=''): + kres = self.ksym + if var2 == '': + var2 = self.var2 + kres = kres.diff(var2) + self.ksym=kres + self.s() + + def fab_diff(self): + var2=self.var2 + kname= self.name + f1,f2,f3=[Function('f1')(var2),Function('f2')(var2),Function('f3')(var2)] + nvarf=['f1','f2','f3'] + vvarf=[f1,f2,f3] + kres= self.ksym + ee2= self.xcopy('ee2',kshow=False) + qq=len( self.varf) + vvarf=vvarf[0:qq] + nvarf=nvarf[0:qq] + varf= self.varf + for i,j in zip(varf,vvarf): + ee2.set(i,j,kshow=False) + kres=ee2.ksym + kres=kres.diff(var2) + ee3=MyEq(kres,'ee3',kshow=False) + ee3.primi_eq=self.primi_eq + + for i,j in zip(vvarf,varf): + ee3.setdiff(i,1,kshow=False) + ee3.set(i,j,kshow=False) + ee3.name= diffname(self.var1,var2) + ee3.primi_diff_eq=diff(ee3.primi_eq,ee3.var2) + + return ee3 + + def Diff2diff(self,kshow=True): + fksym=self.flatdiff + for i in self.varf: + kvar=str(i) + kvar2='d'+kvar + var2=self.var2 + kres=self.primitiva + f=Function(i)(var2) + news=symbols(alphaname(kvar2)) + fksym=fksym.subs(diff(f,var2),news) + return(fksym) + + + def Diff2diff(self,kres): # ksym,kvar,var2 + var2=self.var2 + kvar=self.varf + for i in kvar: + f=Function(str(i))(var2) + df=diff(f) + kname='d'+alphaname(i) + nf=symbols(kname) + kres=kres.subs(df,nf) + return kres + def p(self): + return self.primitiva + + def pf(self): + try: + return primi2func(self.ksym,self.var2,self.varf) + except: + return self.ksym + + def Fdiff(self,*args): + kname='' + kupdate=False + for i in args: + if type(i)==str: + if i=='update': + kupdate=True + else: + kname=i + if self.varf==[]: + kres=diff(self.ksym,self.var2) + primi=0 + else: + primi=diff(self.primitiva,self.var2) + kres=Diff2diff(primi,self.varf,self.var2) + + if kname=='': + if kupdate: + self.ksym=kres + self.primitiva=primi + + self.s() + + else: + + return kres + else: + ee=self.xcopy(kname,kshow=False) + ee.ksym=kres + ee.primitiva=primi + ee.dtype='diff' + ee.s() + return ee + + def diffQ(self,*args,niceview=True): + ''' + + + input: diff(t,x,y,kname='') + return diff(Q, in t and x=func) + + + + input: diff((t,x,y),kname='') + return diff(Q, in t and x,y =func in t) + + args: + if kname=='', self.update, + kname!='' return new Eq named kname + + niceview=True + return example Diferential(x(t),t) = dx/dt but value is original + ''' + exp1=self.ksym + + var=args[0] + var1=args[1] + kname='' + var2='' + if len(args)==3: + kval=args[2] + if type(kval)==str: + kname=kval + + else: + var2=kval + + exp22=diffuntion(self.ksym,var,var1,var2) + if kname!='': + ee=MyEq(exp22,kname=kname,kshow=False) + if niceview: + ee2=MyEq(viewnicediff(exp22,var,var1,var2),kname) + return ee + else: + self.ksym=exp22 + if niceview: + ee2=MyEq(viewnicediff(exp22,var,var1,var2),self.name) + + def diff2(self,*args,kshow=True): + kres=self.ksym + var=self.var + kres=diff(kres,var,var) + if len(args)==0: + return kres + else: + if type(args[0])==str: + return MyEq(kres,kname=args[0],var=var,kshow=kshow) + else: + return kres.subs(var,args[0]) + + def limitdiff(self): + var=self.var + sx='d'+str(var) + dx =symbols(sx) + kres=(self(var+dx)-self(var))/dx + ee=MyEq(kres,kname='d'+self.name ,var=dx) + return ee + + def simplifysum(): + kres=0 + ksym=self.ksym + if Is_Add(ksym): + for i in fpoly(ksym,'list'): + kres=kres+simplify(i) + self.ksym=kres + else: + self.ksym=simplify(ksym) + + self.s() + + def factorsum(): + kres=0 + ksym=self.ksym + if Is_Add(ksym): + for i in fpoly(ksym,'list'): + kres=kres+factor(i) + self.ksym=kres + else: + self.ksym=factor(ksym) + + self.s() + + + self.s() + + def diff(self,*args,func='',kshow=True): + kname='' + var=self.var + vecvar=[] + for i in args: + if type(i)==Symbol: + vecvar.append(i) + if type(i)==str: + kname=i + + if func!='': + dF=functiondiff(self,var,func) + dF=sympydiff2prime(dF,var,func) + elif len(vecvar)==0: + dF=diff(self.ksym,var) + else: + dF=self.ksym + for i in vecvar: + dF=diff(dF,i) + + if kname!='': + ee=MyEq(dF,kname=kname,var=var,kshow=kshow) + return ee + else: + return dF + + + + + def diffFunction(self,var2): + var=self.var + expr=functiondiff(self,var,var2) + kname='d'+self.name + kres=sympydiff2prime(expr,var,var2) + ee=MyEq(expr,kname=kname,var=var,ktype='dP',kshow=False) + ee.primi_diff_eq=kres + ee.s() + return ee + + def tanEq(self,px=''): + var=self.var + if px=='': + svar=str(self.var)+'1' + px=symbols(svar) + df=MyEq(self.diff(),'ee',var=self.var,kshow=False) + + eT=df(px)*(self.var-px)+self(px) + return eT + + + def eQtangent(self,px=''): + return self.tanEq(px) + + + + def eQnormal(self,px=''): + var=self.var + if px=='': + svar=str(self.var)+'1' + px=symbols(svar) + df=MyEq(self.diff(),'ee',var=self.var,kshow=False) + + eT=-1*(self.var-px)/df(px)+self(px) + return eT + + def diffk(self, *args, respect='',kupdate=False,kshow=True,**kwargs): + + if self.varf==[]: + self.primi_eq=self.ksym + self.diff_eq=diff(self.ksym,self.var) + self.primi_diff_eq=diff(self.ksym,self.var) + + if self.varf!=[]: + + + if self.primi_eq=='': + self.primi_eq=self.get_primitive() + + if self.primi_diff_eq=='': + ee=self.xcopy('ee',kshow=False) + kres=ee.primi_eq + kres=kres.diff(ee.var2) + self.primi_diff_eq=kres + + + + + if len(args)==0 and len(kwargs)==0: + self.dtype='diff' + kname=self.name + ee3= self.fab_diff() + self.ksym=ee3.ksym + self.name=diffname(self.name,self.var2) + if respect!='': + self.name= diffname(self.name,respect) + if self.varf!=[]: + self.dtype='diffd' + + self.diff_eq=self.ksym + + self.s() + + return + + elif len(args)==1 and len(kwargs)==0 and type(args[0])==str and self.varf!=[]: + kname=self.name + ee3= self.fab_diff() + ee3.dtype='diff' + ee3.name= diffname(kname,ee3.var2) + if respect!='': + ee3.name= diffname(kname,respect) + ee3.diffEq=self.diffEq + + if ee3.varf!=[]: + ee3.dtype='diffd' + + + ee3.s() + ee3.origen=self.ksym + ee3.origen=self.ksym + ee3.vfunc=self.vfunc + return ee3 + else: + kname = '' + var = self.var2 + kres = self.ksym + for i in args: + if type(i) == str: + kname = i + else: + var = i + kres = diff(kres, var) + if len(kwargs) > 0: + ee = MyEq(kres, kshow=False) + for key, value in kwargs.items(): + ee.set(parse_expr(key), value, kshow=False) + kres = ee.ksym + + if kname != '': + ee = MyEq(kres, kname,var1=self.var1,kshow=kshow) + ee.dtype='diff' + ee.var2=self.var2 + ee.vfunc=self.vfunc + return ee + else: + return kres + + def simple_form(self,kfunc): + self.setdiff(kfunc,1,kshow=False) + self.set(kfunc, self.var1) + + def flatdiff(self,kfunc,kshow=True): + self.setdiff(kfunc,1,kshow=False) + self.set(kfunc, self.var1,kshow=kshow) + + def diff_parcial(self,*args): + kname='' + vdiff=[] + for i in args: + if type(i)==str: + kname=i + else: + vdiff.append(i) + + + kres=self.ksym + var2=self.var2 + mm=vdiff + mm=list(mm) + mm.append(var2) + mm=tuple(mm) + ddiff=sym2Function(*mm) + for i,j in zip(vdiff,ddiff): + kres=kres.subs(i,j) + + kres=diff(kres,var2) + if kname!='': + return MyEq(kres,kname,var2=var2) + else: + self.ksym=kres + self.s() + + def killdiff(self,kfunc): + + self.setdiff(kfunc,1) + + def killfunc(self,kfunc): + + self.set(kfunc, self.var1) + + def killfunc(self,kfunc): + + self.set(kfunc, self.var1) + + def Length(self, kvar): + kres = self.v + kdiff = kres.diff(kvar) + kres = rpow(1 + kpow(kdiff, 2)) + return kres + + # Algoritmos Trigonometricos + def sin2cos(self, angu, korden=2, kope='', kshow=True): + self.set(kpow(sin(angu), 3), (1 - kpow(cos(angu), 2)) * cos(angu), kshow=False) + kres = self.ksym + kres = sin2cos(kres, angu=angu, korden=korden, kope=kope) + self.ksym=kres + if kshow: + self.s() + else: + pass + + def cos2sin(self, angu, korden=2, kope='', kshow=True): + self.set(kpow(cos(angu), 3), (1 - kpow(sin(angu), 2)) * sin(angu), kshow=False) + kres = self.ksym + kres = cos2sin(kres, angu=angu, korden=korden, kope=kope) + self.ksym=kres + if kshow: + self.s() + + def get_diffEq(self, vx=''): + + kname = self.name + 'd' + Vx = self.xx + + if Vx != '': + + kres = self.ksym + + kres = diff(kres, Vx) + kname = kname + '_' + str(Vx) + self.EqDiff = MyDiff(kres, Vx, kname) + return self.EqDiff + elif vx != '': + self.xx = vx + kres = self.ksym + kname = kname + '_' + str(vx) + kres = diff(kres, vx) + self.EqDiff = MyDiff(kres, vx, kname) + return self.EqDiff + else: + sE(['first set variable MyEq.xx= Valeue']) + + def Integral_eQ(self, kname='', var2='', x1='', x2='', ktype='P'): + ksym = self.ksym + + if var2 == '': + var2 == self.var2 + if x1 == '': + x1 = 0 + x2 = var2 + else: + x1 = x1 + x2 = x2 + kres = Integral(ksym, (var2, x1, x2)) + if kname == '': + return kres.doit() + else: + ee = MyEq(kres, kname=kname, var2=var2, ktype='I') + return ee + + def Area(self, kname='', var2='', x1='', x2='', kope=''): + if var2 == '': + var2 = self.var2 + if x1 == '': + x1 = self.x1 + x2 = self.x2 + + ee = MyEq(self.ksym, kname=kname, var2=var2, x1=x1, x2=x2, ktype='I', kshow=False) + if kname != '': + ee.s() + ee.doitI() + return ee + else: + ee.doitI(kshow=False) + return ee.ksym + def func(self,value): + ksym=self.ksym + var=self.var + kres=ksym.subs(var,value) + try: + return float(kres) + except: + return kres + + def area_value(self): + ee = MyEq(self.ksym, var2=self.var2, x1=self.x1, x2=self.x2, kshow=False) + ee.area(kshow=False) + ee.doit(kshow=False) + return ee.ksym + + def area(self, var2='', x1='', x2='', kshow=True): + if x1 != '': + self.x1 = x1 + self.x2 = x2 + if var2 == '': + var2 = self.var2 + else: + self.var2 = var2 + self.primi = self.ksym + + if self.x1 == '': + kres = Integral(self.ksym, self.var2) + else: + kres = Integral(self.ksym, (self.var2, self.x1, self.x2)) + self.type = 'I' + self.ksym=kres + if kshow: + self.s() + + def Integral(self,x1='', x2=''): + ktype=self.type + + if x1=='': + if self.x1!='': + x1=self.x1 + x2=self.x2 + else: + + self.x1=x1 + self.x2=x2 + + if ktype=='I': + self.s() + return + else: + kres=self.ksym + if x1=='': + kres=Integral(kres,self.var) + else: + kres=Integral(kres,(self.var,x1,x2)) + self.ksym=kres + self.type='I' + self.s() + return + + + + + + + + + + def solveIntegral(self, kname='', var2='', x1='', x2='', kupdate=True): + if x1 == '': + x1 = self.x1 + if x2 == '': + x1 = self.x2 + if var2 == '': + var2 = self.var2 + ksym = self.ksym + kres = ksym.doit() + if kname != '': + ee = MyEq(kres, kname=kname, var2=var2) + return ee + else: + if kupdate: + self.ksym = kres + self.s() + else: + return kres + + def get_InteEq(self, vx='', kname=''): + + if kname == '': + kname = 's' + self.name + else: + kname = kname + Vx = self.xx + + if Vx != '': + + kres = self.ksym + + self.EqInte = MyInteger(kres, Vx, kname) + return self.EqInte + elif vx != '': + self.xx = vx + kres = self.ksym + + self.EqInte = MyInteger(kres, vx, kname) + return self.EqInte + else: + sE(['first set variable MyEq.xx= Value']) + + def convMyFunc(self, knom='', vV=''): + ksym = self.v + if vV == '': + vV = self.free() + elif type(vV) == tuple: + vV = list(vV) + ksym = self.v + kk = MyFunc(knom, ksym, vV) + return kk + + def newEq(self, kname='', kope='', **kwargs): + ee = MyEq(self.ksym, kname=kname, kshow=False) + if len(kwargs) > 0: + for key, value in kwargs.items(): + ee.set(parse_expr(key), value, kshow=False, kope=kope) + + ee.s() + return ee + + def findSubFunc(self, sval, inside=''): + ksym = self.ksym + kini = 0 + kini2 = 0 + sroot = [] + done = 0 + while kini < len(str(ksym)) and kini2 != -1: + kini2, sword = in_ope_string(ksym, sval, kini) + if kini2 != -1: + if inside != '': + if inside in sword: + return sword + else: + return sword + kini = kini2 + len(sval) + return sroot + + def killSimpleRoot(self): + ss = self.findSubFunc('sqrt', '**2') + sm = get_midle_str(ss, 'sqrt', '**2') + exp = str(self.ksym) + exp = exp.replace(ss, sm) + self.ksym = parse_expr(exp) + self.s() + ################################################################################ + # alone + ################################################################################# + + def alone(self,ksym): + + newv=symbols(self.name) + ee=MyEq(newv-self.ksym) + kres=ee.solve(str(ksym),kshow=False) + kres.s() + return kres + + def maximize(self,respp=''): + if respp=='': + respp=self.var2 + + dv=MyEq(self.diff(respp),kshow=False) + dv.reducecero(kshow=False) + kres=dv.ksym + kres=numer(kres) + dv.ksym=kres + ksolu=dv.solve(respp) + return ksolu + + # Fourier Serie + + def fourierserie(self,n=''): + s=fourier_series(self.ksym,(self.var,self.x1,self.x2)) + kres=s + if n!='': + kres=s.truncate(n=n) + self.furs=s + return kres + def L(self): + return self.x2-self.x1 + + def an(self,n=''): + if self.furs=='': + s=fourier_series(self.ksym,(self.var,self.x1,self.x2)) + self.furs=s + if n!='': + return s.an[n] + else: + return s.an + + def bn(self,n=''): + if self.furs=='': + s=fourier_series(self.ksym,(self.var,self.x1,self.x2)) + self.furs=s + if n!='': + return s.bn[n] + else: + return s.bn + # LAPLACE + + def laplace(self): + from MyDiff import laplacetransform, func2laplace,laplace, Laplace + return laplace(self) + + + + def Laplace(self): + from MyDiff import laplacetransform, func2laplace,laplace, Laplace + return Laplace(self) + + def ilaplace(self,*args): + kname='Ft' + var=t + for i in args: + if type(i)==str: + kname=i + else: + var=i + from MyDiff import laplacetransform, func2laplace,laplace, Laplace,ilaplace + kres= ilaplace(self.ksym) + if var!=t: + kres=kres.subs(t,var) + return MyEq(kres,kname,var=var) + + +################################################################################ +# END MyEq Class +################################################################################# +# def MyIntg(ksym,kname,var=x,x1='',x2='',kshow=True,ktype='I',value=False): + # if type(ksym)==MyEq: + # ksym=ksym.ksym + + # ssym=str(ksym) + # dsym='d'+str(var) + # if dsym in ssym: + # ssym=ssym.replace(dsym,'1') + # ksym=parse_expr(ssym) + # if value: + # ee=MyEq(ksym,kname,var=var,x1=x1,x2=x2,ktype='I',kshow=False) + # return ee.ksym + # else: + # return MyEq(ksym,kname,var=var,x1=x1,x2=x2,ktype='I',kshow=kshow) + +def MyDiffe(ksym,kname,var=t,ktype='D'): + ssym=str(ksym) + dsym='d'+str(var) + if dsym in ssym: + ssym=ssym.replace(dsym,'1') + ksym=parse_expr(ssym) + + return MyEq(ksym,kname,var=var,ktype='D') + +def MyDiff(ksym,kname,var=t,ktype='D'): + ssym=str(ksym) + dsym='d'+str(var) + if dsym in ssym: + ssym=ssym.replace(dsym,'1') + ksym=parse_expr(ssym) + + return MyEq(ksym,kname,var=var,ktype='D') + +def get_real_value(ee): + if type(ee) == MyEq: + kres = ee.ksym + else: + kres = ee + return kres + + +def show_main(): + for i in dataQ: + i.s() + + + +def upBagSys(ksys, Bag, kope=''): + for i in ksys: + i.upBag(Bag, kope=kope) + + + +########################################### +# END MyIteger Class +########################################### + + + + + + +############################################### +# Mass center Inertia + +def pQ(mm, vv, kope=''): + rho = symbols('rho') + + kres = mm / vv + sE([rho, '=', kres]) + return kres + + +################################################# +# Solve Algorithm + +def solved(*args,**kwargs): + ''' + solved (var,exp1,exp2,**kwargs) + input + var : variable to find + exp1 : math expre or MyEq class that is equation equal= 0 + exp2 (optional): math expre or MyEq class + if exp2 is given then the Eq to evalue is expr1 -expr2 + kwargs : conditions to evalue, example x=1, t=0..etc + return + return a MyEq class with name str(var) + ''' + var=args[0] + ee=args[1] + if type(ee)==MyEq: + ee=ee.ksym + keq=ee + if len(args)==3: + ee2=args[2] + if type(ee2)==MyEq: + ee2=ee2.ksym + keq=ee-ee2 + if len(kwargs)>0: + keq=real_subs(keq,**kwargs) + + kres=solve(keq,var) + if type(kres)==list: + kres=kres[0] + + kname=str(var) + ee0=MyEq(kres,kname=kname) + return ee0 + +def solverSys(*args, Bag=''): + Ke = [] + Kv = [] + Kn = [] + + for i in args: + if type(i) == MyEq: + if Bag != '': + i.upBag(Bag, kshow=False) + Ke.append(i) + if type(i) == Symbol: + Kv.append(i) + Kn.append(i.name) + # return(Ke,Kv,Kn) + + return MyEqSolveLin(Ke, Kv, Kn, Bag=Bag) + + +def MyEqSolveLin(Ke, Kv, Kn, Bag=''): # Solve n MyEq with n unknow variable + ''' + Example + Ke=[e2,e2,e0] MyEqs Matrix + Kv=[N1,T,a] unKnow Vriables + Kn=['N_1','T','a_c'] New Name Eq + + N11,T1,ac = MyEqSolveLin(Ke,Kv,Kn) + returns resepective answer + ''' + vecs = [] + qq = len(Ke) + kres = [] + for i in range(qq): + ee = Ke[i] + ksym = Kv[i] + ks = ee.solve(ksym,kshow=False) + if type(ks) == list: + rr = max(ks) + ks = rr + + vecs.append(ks) + Ker = Ke[i + 1::] + for e1 in Ker: + e1.set(ksym, ks, kshow=False) + e1.reduFac(kshow=False) + e1.simplify(kshow=False) + + for i, kname in zip(vecs, Kn): + ee = MyEq(i, kname, kshow=False) + kres.append(ee) + ueq = kres[-1] + ksym = ueq() + vsym = Kv[-1] + for ee in kres[0:-1]: + ee.set(vsym, ksym, kshow=False) + ee.reduFac(kshow=False) + ee.simplify(kshow=False) + for i in kres: + i.s() + return kres + + +def Solve2Eq(ksym=[], kvar=[], knom=[], kope=''): + e1, e2 = ksym + v1, v2 = kvar + t1, t2 = knom + + r1 = e1.solve(v1) + e2.set(v1, r1, kshow=False) + r2 = e2.solve(v2) + r2 = opemat(r2, kope=kope) + e1.set(v2, r2, kshow=False) + r1 = e1.solve(v1) + r1 = opemat(r1, kope=kope) + aa = MyEq(r1, t1) + bb = MyEq(r2, t2) + return (aa, bb) + + +def Diff(ksym, kvar, kname=''): + kres = ksym + kres = kres.diff(kvar) + if kname == '': + return kres + else: + return MyEq(kres, kname) + + +def Diff2(ksym, kvar, kname=''): + kres = ksym + kres = kres.diff(kvar) + kres = kres.diff(kvar) + if kname == '': + return kres + else: + return MyEq(kres, kname) + + + +def upBag2sys(vecEq, kBag): + for i in vecEq: + i.upBag(kBag) + + + + +def eQSolver(*args): + vec1 = [] + uk1 = [] + for i in args: + if type(i) == list: + for j in i: + if type(j) == MyEq: + vec1.append(j()) + elif fpoly(j, 'n') > 1: + vec1.append(j) + else: + uk1.append(j) + else: + if type(i) == MyEq: + vec1.append(i()) + elif fpoly(i, 'n') > 1: + vec1.append(i) + else: + uk1.append(i) + + vec2 = [] + kres = [] + for i in vec1: + if type(i) == MyEq: + vec2.append(i()) + else: + vec2.append(i) + + mm = solve(vec2, uk1) + if type(mm) == dict: + kk, vv = kunpakDic(mm) + + for i, j in zip(kk, vv): + kres.append(MyEq(j, i)) + return kres + else: + for i, j in zip(mm[0], uk1): + j = MyEq(i, str(j)) + kres.append(j) + return (kres) + + +def solvelin(*args, kope='', Eq=True): # solveLinearSys(e1,e2,mu1,mu2) + mS = [] + mV = [] + + for i in args: + if type(i) == MyEq: + mS.append(i()) + + elif type(i) == str: + kope = i + else: + mV.append(i) + solu = solve(mS, mV) + + display(Math(latex(solu))) + return ganswer(solu,'value') + + + + + + +def get_squareMono(ksym): + if type(ksym) == MyEq: + ksym = ksym.ksym + kres = ksym + mm = fpoly(ksym, 'list') + mr = [] + ms = [] + rr = [] + centra = 0 + ksigno = 1 + for i in mm: + mr.append(opemat(rpow(i, 2), 'r')) + ms.append(str(opemat(rpow(i, 2), 'r'))) + for i, j, k in zip(ms, mr, mm): + if 'sqrt' in i: + central = k + if '-' in str(central): + ksigno = -1 + else: + rr.append(j) + if len(rr) == 2: + kres = kpow(rr[1] + ksigno * rr[0], 2) + return kres + + +####### +def expand2MyEq(ee): + ktype = ee.type + var2 = ee.var2 + mm = ee.list() + cc = 1 + kname = ee.name + kres = [] + for i in mm: + nname = kname + str(cc) + nname = MyEq(i, nname, var2=var2) + kres.append(nname) + cc += 1 + return kres + + +def upgrade(*args, kshow=True, andsolve=[]): + if andsolve != []: + vv = andsolve[0] + ee = andsolve[1] + vv = ee.solve(parse_expr(vv), vv, kope='s') + eev = [] + evv = [] + for i in args: + if type(i) == MyEq: + if i.type == 'C': + eev.append(i) + else: + evv.append(i) + + for i in eev: + for j in evv: + try: + i.upgrade(j, kshow=False) + except: + pass + for i in eev: + if i.ksym != 0: + i.s() + for i in evv: + if type(i) == MyEq: + i.simplify(kshow=False) + if i.ksym != 0: + i.s() + + +def upgradeList(*args, kshow=True, andsolve=[], kope='s'): + eev = [] + evv = [] + for i in args: + if type(i) == MyEq: + if i.type == 'C': + if i != andsolve[1]: + eev.append(i) + + if andsolve != []: + vv = andsolve[0] + ee = andsolve[1] + kres = ee.solve(vv) + kres = opemat(kres, 's') + vv = MyEq(kres, str(vv), ktype='C', kshow=False) + ee.type = 'P' + + for i in eev: + if i.type == 'C': + i.upgrade(vv, kshow=False) + i.simplify(kshow=False) + + for i in eev: + if i.ksym != 0: + i.s() + vv.s() + return vv + + + +def func_sig(kf, x1, x2, var=x): + ee = MyEq(kf, var2=var, kshow=False) + xx = (x2 - x1) / 2 + return ee(xx) + + +def get_intersec_2func(y1, y2, var=x): # y1(x), y2(x), return intersec y1 and y2 + ee = MyEq(y1 - y2, kshow=False) # return vector + return ee.solve(var) + + +def reset_ee(*args): + eeFull = [] + for i in args: + i.init = False + + +def Upgrade(*args, kope='', kshow=True): + newa = [] + for i in args: + if type(i) == MyEq: + + if i.ksym != 0: + newa.append(i) + args = newa + antes = [] + for i in args: + antes.append(str(i)) + qq = len(args) + for i in range(qq): + + mm = [] + for j in range(qq): + if j != i: + mm.append(args[j]) + args[i].upgrade(mm, kshow=False, kope=kope) + if kshow: + for i, j in zip(args, antes): + if str(i) != newa: + if i.ksym != 0: + i.s() + + +def presolve(ksym, val): + kres = solve(ksym, val) + if kres == []: + try: + kres = solve(opemat(ksym, 'esf'), val) + if kres != []: + return kres + else: + ksym = factorSec(ksym, val) + kres = solve(opemat(ksym, 'esf'), val) + if kres != []: + return kres + except: + done = False + return kres + + +def eQsolve(ksym, kname, kope=''): + kval = parse_expr(kname) + kres = csolve(ksym, kval) + kres = opemat(kres, kope) + kval = MyEq(kres, kname) + return kval + +def Qsolve(*args): + ''' + N1,mu1=Qsolve(FxA,FyA,N1,mu1) + ''' + eqq=[] + evv=[] + for i in args: + if type(i)==MyEq: + eqq.append(i) + else: + evv.append(i) + kres=solve(eqq,evv) + try: + vsym,vval=kunpakDic(kres) + except: + vsym=evv + vval=list(kres[0]) + + vres=[] + for i ,j in zip(vsym,vval): + kname=str(i) + ee=MyEq(j,kname=i) + vres.append(ee) + return vres + + + +def Diff2flat(kres,kvar,var2): # ksym,kvar,var2 + + for i in kvar: + f=Function(str(i))(var2) + df=diff(f) + kname='d'+alphaname(i) + nf=symbols(kname) + kres=kres.subs(df,nf) + ee=MyEq(kres,kshow=False) + for i in kvar: + ee.setdiff(i,i,kshow=False) + + return ee.ksym + + + +##################################### +# list +##################################### + +def solvelist(*args): + ''' + input: [vector with all eq=0], variables to find .. + output: MyEq of each variable + example: + a+2*b=0 and 3*a-b=0 + ee=[a+2*b,3*a-b] + then : + a,b=solvelist(ee,a,b) + return a,b in MyEq ecuation class + ''' + vecs=args[1::] + kres= solve(*args) + var,value=kunpakDic(kres) + vres=[] + for i ,j in zip(var,value): + ee=MyEq(j,str(i)) + vres.append(ee) + return vres + +def one_ksym2ksym(ksym): + r''' + return denominator if numerator =1 + input 1/(a+b) return (a+b) + input 3/(a+b) return 3/(a+b) + input c/(a+b) return c/(a+b) + ''' + + if numer(ksym)==1: + return denom(ksym) + else: + return ksym + +def num_ksym2ksym(ksym): + r''' + return denominator if numerator = numeric + input 1/(a+b) return (a+b) + input 3/(a+b) return (a+b) + input c/(a+b) return c/(a+b) + ''' + if Is_Number(numer(ksym)): + return denom(ksym) + else: + return ksym + +##################################### +# real subs +##################################### + +def subskwargs(QQ,**kwargs): + mkey=[] + vvalue=[] + + for key, value in kwargs.items(): + mkey.append(key) + vvalue.append(value) + kres=QQ + for i,j in zip(mkey,vvalue): + valor=j + if type(j)==MyEq: + valor=j.ksym + kres=kres.subs(i,valor) + return kres + +def real_subs(QQ,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + + vvar=fpoly(QQ,'free') + mvar=[] + for i in vvar: + nname=str(i) + nname=nname.replace('_','') + nvar=symbols(nname) + mvar.append(nvar) + + kres=QQ + sres=str(kres) + sres=sres.replace('_','') + kres=parse_expr(sres) + mkey=[] + vvalue=[] + for key, value in kwargs.items(): + mkey.append(key) + vvalue.append(value) + + kres=kres.subs(parse_expr(key),value) + for i,j in zip(mvar,vvar): + kres=kres.subs(i,j) + return (kres) + +##################################### +# algebra +##################################### +def get_seudocofactor(e2,e3,var2): + ''' + tyr to get polynomie complement and multipli complete degree secuence + e1=x*x-2 + e2=x+1 + if e1=e2*k + then k=a*x+b + maybe x*x-2= (x+1)*(a*x+b) + + return (a*x+b),[a,b] + ''' + vecvar=[a,b,c,d] + vecfvar=[] + ee2=e2 + if type(e2)==MyEq: + ee2=e2.ksym + + ee3=e3 + if type(e3)==MyEq: + ee3=e3.ksym + qq=degree(ee2,gen=var2)-degree(ee3,gen=var2) + vres=0 + cc=0 + for i in range(qq+1): + vres+=vecvar[i]*var2**(qq-cc) + vecfvar.append(vecvar[i]) + cc+=1 + return (vres,vecfvar) + + +def passdoitI(kstr): + klist=['>','<','=','True','∧',','] + done=True + for i in klist: + if i in kstr: + done=False + return done +def kreplace(ksym,var1,var2): + if type(var2)==MyEq: + var2=var2.ksym + if type(ksym)==MyEq: + ksym=ksym.ksym + + ksym=ksym.subs(var1.name,var2) + return ksym + +def kreplace(ksym,var1,var2): + if type(var2)==MyEq: + var2=var2.ksym + if type(ksym)==MyEq: + ksym=ksym.ksym + + ksym=ksym.subs(var1,var2) + return ksym +def subskwargs2(ksym,**kwargs): + var,val=unpack(kwargs) + + if type(ksym)==MyEq: + kres=ksym.ksym + for i,j in zip(var,val): + + kres=kreplace(ksym,i,j) + return kres + +def subskwargs(expr,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + key,value=unpack(kwargs) + sres=str(expr) + for i,j in zip(key,value): + svalue=str(j) + skey=i + if len(skey)==2: + nskey=skey[0]+'_'+skey[1] + if nskey in sres: + sres=sres.replace(nskey,svalue) + else: + sres=sres.replace(skey,svalue) + else: + sres=sres.replace(skey,svalue) + + return parse_expr(sres) + +def subskwargs1(expr,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + if len(kwargs)>0: + key,value=unpack(kwargs) + sres=str(expr) + for i,j in zip(key,value): + svalue=str(j) + skey=gval(i) + if len(skey)==2: + nskey=skey[0]+'_'+skey[1] + if nskey in sres: + sres=sres.replace(nskey,svalue) + else: + sres=sres.replace(skey,svalue) + else: + sres=sres.replace(skey,svalue) + + return parse_expr(sres) + else: + return expr +# Tools expr value +def gval(kexpr): + # return value of kexpr if expr is a MuEq type + # ele return kexpr + if type(kexpr)==MyEq: + return kexpr.ksym + else: + return kexpr + +def integerfactor(expr,var,name=''): + # return integral( exp( expr),var) + # if name!='' return MyEq + + iexp=MyIntg(expr,'q',var=var,kshow=False) + + kres=exp(iexp.ksym) + if name=='': + return kres + else: + return MyEq(kres,kname=name) + +def varDiff2(*args): + mm=[] + for i in args: + + k=symbols(i+"''") + mm.append(k) + return(mm) +def varDiff(*args): + mm=[] + for i in args: + + k=symbols(i+"'") + mm.append(k) + return(mm) + +def textpos(ksolu,typos,tsize): + qq=len(ksolu) + mm=[] + for i in range(0,qq-1): + + p1=ksolu[i] + p2=ksolu[i+1] + L=p2-p1 + fac=L/10 + mm.append([p1+fac,typos,tsize,p1,p2]) + return mm + +from matplotlib.patches import Polygon +def Area2(self,*args,typos=-1,tsize=10): + var=self.var + done=False + ksolu=solve(self.ksym,var) + if len(ksolu)>0: + done=True + if len(args)==2: + x1=args[0] + x2=args[1] + x3=100 + X1=args[0] + X2=args[1] + elif len(args)==3: + x1=args[0] + x2=args[1] + x3=args[2] + X1=args[0] + X2=args[1] + else: + + ksolu=solve(self.ksym,var) + x1=min(ksolu) + X1=min(ksolu) + x2=max(ksolu) + X2=max(ksolu) + x3=100 + dx=(x2-x1)/10 + x1=x1-dx + x2=x2+dx + done=True + fac=(x2-x1)/x3 + X=[] + Y=[] + yvalor=self('value',var=fac) + + #for i in range(x3): + #valor=float(x1+fac*i) + #X.append(float(valor)) + #Yvalor=yvalor.subs(var,valor) + + #Y.append(float(Yvalor)) + allvar=[] + if done: + if len(ksolu)>0: + allvar=ksolu + if X1 not in allvar: + allvar.append(X1) + if X2 not in allvar: + allvar.append(X2) + ksolu=allvar + ksolu.sort() + X1=min(ksolu) + X2=max(ksolu) + fig, ax = plt.subplots() + ix,iy =funclist(self,X1,X2,100) + + + verts = [(X1,0),*zip(ix, iy),(X2,0)] + + poly = Polygon(verts, facecolor='0.9', edgecolor='0.5') + ax.add_patch(poly) + ax.grid(True, which='both') + ax.plot(ix, iy) + Lx=[x1,x2] + Ly=[0,0] + ymin,ymax=ax.get_ylim() + ax.plot(Lx, Ly,color='black') + if done: + + ysolu=funclist(self,ksolu) + + for i ,j in zip(ksolu,ysolu): + ax.plot([i,i],[j,ymin],linestyle='-.',color='black') + ax.plot([i],[j],'o',color='red') + tvec=textpos(ksolu,typos,tsize) + tex=f'${latex(Integral(self.primi,self.var))}$' + Yp=1 + for i in tvec: + tx,ty,tf=i + ty=ty*Yp + Yp=-1*Yp + ax.text(tx, ty, tex,fontsize=tf) + + + ax.grid(True, linestyle='-.') + ax.tick_params(labelcolor='r', labelsize='medium', width=3) + + plt.show() + +def funclist(self,*args): + + if len(args)>1: + x1=args[0] + x2=args[1] + qq=50 + if len(args)>2: + qq=args[2] + xr=list(range(qq+1)) + fac=(x2-x1)/qq + xx=[x1+fac*i for i in xr] + else: + xx=args[0] + + kfunc=self.ksym + yy=[kfunc.subs(self.var,i) for i in xx] + if type(args[0])==list: + return yy + else: + return xx,yy + +def textpos(ksolu,typos,tsize): + qq=len(ksolu) + mm=[] + for i in range(0,qq-1): + + p1=ksolu[i] + p2=ksolu[i+1] + L=p2-p1 + fac=L/10 + mm.append([p1+fac,typos,tsize]) + return mm + +def laplaced(f,n): + expr=laplace(f) + expr=diff(expr,s) + expr=(-1**n)*expr + return expr + +def laplaced(func): + expr=laplace(func) + expr2=integrate(expr,(s,s,oo)) + return expr2 + +def Pplot(expr='',var=x,x1=-1,x2=1,x3=100,ymax='',ymin='',*args): + ''' + expr = math function + x1 = x min + x2 = x max + x3 = no point per line + ymax= ymax + ymin = ynim + ''' + maa=getasint(expr,var) + vecx=reparte(x1,x2,maa,x3) + vecy=[] + f = lambdify(var, expr, 'numpy') + for i in vecx: + yres = f(i) + vecy.append(yres) + if ymax!='': + if ymin=='': + ymin=-1*ymax + Vecx=[] + Vecy=[] + for i,j in zip(vecy,vecx): + tempx=[] + tempy=[] + for yy,xx in zip(i,j): + if yyymin: + tempy.append(yy) + tempx.append(xx) + Vecx.append(tempx) + Vecy.append(tempy) + vecx=Vecx + vecy=Vecy + fig, ax = plt.subplots() + ax.grid(True, which='both') + ax.axhline(0,color="black",linestyle='-.',alpha=0.5) #x-axis line + ax.axvline(0,color="black",linestyle='-.',alpha=0.5) + for X,Y in zip(vecx,vecy): + ax.plot(X, Y) + + ax.grid(True, linestyle='-.') + ax.tick_params(labelcolor='r', labelsize='medium', width=3) + + plt.show() + +## fun used by Pplot() +def rrp(x1,x2,x3): + fac=(x2-x1)/x3 + return np.arange(x1,x2+fac,fac) +def getasint(expr,var): + ksolu=[] + if Is_Div(expr): + p1,p2=fraction(expr) + ee=MyEq(p2,'ee',var=var,kshow=False) + ksolu=ee.solve(var,'all') + + return ksolu +def reparte(x1,x2,vec,x3=100): + mm=[] + vec2=[] + + if len(vec)==0: + kres=rrp(x1,x2,x3) + mm.append(kres) + return mm + else: + vec2=[] + for i in vec: + if i>x1 and i","","","",""] +def ruta(expr,infoexpr,infopos,cc): + mm=expr.args + if len(mm)>0: + for i in range(len(mm)): + nexp=mm[i] + npos=cc+str(i) + + if nexp not in infoexpr: + if str(type(nexp)) not in vecreatr : + if nexp not in infoexpr: + if not Is_Number(nexp): + + infoexpr.append(nexp) + infopos.append(npos) + try: + nexp,ninfo,ncc=ruta(nexp,infoexpr,infopos,npos) + return nexp,ninfo,ncc + except: + pass + return expr,infoexpr,infopos,cc + else: + return expr,infoexpr,infopos,cc + +def str2vec(sexpr): + kvec=[] + for i in sexpr: + kvec.append(int(i)) + return kvec + +def argsmap (expr,kname='A',deep=2,data=False): + infoexpr=[] + infopos=[] + cc='' + A,B,C,D=ruta(expr,infoexpr,infopos,cc) + mapval=[] + mappos=[] + for i,j in zip(B,C): + if Is_Div(i): + if numer(i)!=1: + mapval.append(i) + mappos.append(j) + + else: + mapval.append(i) + mappos.append(j) + + mapval,mappos=filterNegPos(mapval,mappos) + mapval,mappos=filterdeep(mapval,mappos,deep) + if len(mapval)==0: + return + if data: + return mapval,mappos + svecargs=[] + sres='' + superres='' + if kname!='': + + for i in mappos: + sres=kname+'.args(' + for k in i: + sres=sres+k+',' + sres=sres[0:-1] + sres=sres+')=' + svecargs.append(sres) + mm='' + for i,j in zip(svecargs,mapval): + mm=mm+ " "+'['+i+latex(j)+'],' + display(Math(mm)) + +def filterNegPos(vecd,vecp): + NegMon=[] + NegPos=[] + OthMon=[] + OthPos=[] + for i,j in zip(vecd,vecp): + if Is_NMono(i): + NegMon.append(i) + NegPos.append(j) + else: + OthMon.append(i) + OthPos.append(j) + for i,j in zip(OthMon,OthPos): + if (-1*i) not in NegMon: + NegMon.append(i) + NegPos.append(j) + return NegMon,NegPos + +def filterdeep(vecd,vecp,deep): + + Othd=[] + Othp=[] + for i,j in zip(vecd,vecp): + if len(j)=','>'] +inesymbol2=['<','≤','=','≥','>'] +C1,C2,C3,C4,C5=symbols('C1 C2 C3 C4 C5') +def creteInt(expr,var,x1='',x2=''): + if var!='': + if x1=='': + kres=Integral(expr,var) + else: + kres=Integral(expr, (var,x1,x2)) + return kres + else: + return expr + + +def MQ(*args, var=x,var1=y,var2=z,kshow=True,ktype='eq',render=True): + return MyEqEq(*args, var=var,var1=var1,var2=var2,kshow=kshow,ktype=ktype,render=render) +class MyEqEq: + def __init__(self, *args, var=x,var1=y,var2=z,kshow=True,ktype='eq',render=True): + ''' + self.insys='' + self.clone='' + self.cloneb='' + self.var=var + self.type=ktype + self.symb="=" + P1=args[1] + self.CC=0 + self.vecCC=[C1,C2,C3,C4,C5] + self.e1=MyEq(0,'e1',var=var,kshow=False) + self.e2=MyEq(0,'e2',var=var,kshow=False) + ineqtype=notaclass=[GreaterThan,LessThan,StrictGreaterThan,StrictLessThan] + ineqsynbo=['>=','<=','>','<'] + if type(P1) in ineqtype: # input one math expr tpe x+3>8 + ksym1,ksym2=P1.args + self.psymb=ineqsynbo[ineqtype.index(type(P1))] + self.symb=nice_iq_symbol(self.psymb) + self.e1.ksym=ksym1 + self.e2.ksym=ksym2 + self.type='IQ' + ''' + + + self.insys='' + self.clone='' + self.cloneb='' + self.var=var + self.type=ktype + self.symb="=" + P1=args[1] + + self.CC=0 + self.vecCC=[C1,C2,C3,C4,C5] + self.e1=MyEq(0,'e1',var=x,kshow=False) + self.e2=MyEq(0,'e2',var=x,kshow=False) + ineqtype=notaclass=[GreaterThan,LessThan,StrictGreaterThan,StrictLessThan] + ineqsynbo=['>=','<=','>','<'] + if P1 in ineqsynbo: # input one math expr tpe x+3>8 + + ksym1,ksym2=args[0],args[2] + self.psymb=args[1] + self.symb=nice_iq_symbol(self.psymb) + self.e1.ksym=ksym1 + self.e2.ksym=ksym2 + self.type='IQ' + elif len(args)==3: # input tree args tpe x+3,'>',8 + ksym1,ksym2=args[0],args[2] + if type(ksym1)==MyEq: + ksym1=ksym1.ksym + if type(ksym2)==MyEq: + ksym2=ksym2.ksym + self.psymb=args[1] + self.symb=nice_iq_symbol(self.psymb) + self.e1.ksym=ksym1 + self.e2.ksym=ksym2 + self.type='IQ' + + + elif len(args)==2: + + ksym1,ksym2=args[0],args[1] + if type(ksym1)==MyEq: + ksym1=ksym1.ksym + if type(ksym2)==MyEq: + ksym2=ksym2.ksym + + + self.psymb='=' + self.symb='=' + self.e1.ksym=ksym1 + self.e2.ksym=ksym2 + self.type='EQ' + + elif len(args)==4: + + ksym1,ksym2=args[0],args[1] + if type(ksym1)==MyEq: + ksym1=ksym1.ksym + if type(ksym2)==MyEq: + ksym2=ksym2.ksym + + + self.psymb='=' + self.symb='=' + self.e1.ksym=ksym1 + self.e1.var=args[2] + self.e2.ksym=ksym2 + self.e2.var=args[3] + self.type='EQ' + + + p1=self.e1.ksym + p2=self.e2.ksym + ps=self.symb + self.render=render + if "'" in str(p1) or "'" in str(p2): + self.type='DI' + if render: + if kshow: + display(Math(latex(p1)+' '+ps+' '+latex(p2))) + + self.lundo=[] + self.lundo.append([self.e1.ksym,self.e2.ksym]) + def __call__(self,*args, **kwargs): + if len(args)==0 and len(kwargs)>0: + + p1=self.L + p1=real_subs(p1,**kwargs) + + p2=self.R + p2=real_subs(p2,**kwargs) + QQ=MQ(p1,p2) + + return + kfloat=False + for i in args: + if i=='float': + kfloat=True + QQ=self.xcopy() + + p1=QQ.left + p2=QQ.right + p11=subskwargs(p1,**kwargs) + p22=subskwargs(p2,**kwargs) + if kfloat: + try: + p11=float(p11) + except: + pass + try: + p22=float(p22) + except: + pass + + QQ.e1.ksym=p11 + QQ.e2.ksym=p22 + QQ.s() + def __repr__(self): + kres = self.eQ + return kres + + def _latex(self, obj): + return latex(self.eQ) + def __str__(self): + + return str(self.__repr__()) + + def up_sides(self,p1='',p2=''): + self.up_ee(p1=p1,p2=p2) + + def up_ee(self,p1='',p2=''): + if p1!='': + self.e1.ksym=p1 + if p2!='': + self.e2.ksym=p2 + def unisymbols(self): + self.e1.ksym=unisymbols(self.e1.ksym) + self.e2.ksym=unisymbols(self.e2.ksym) + ########################################### + # Update # + ########################################### + + def __add__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1+other.left + p2=p2+other.right + elif type(other)==MyEq: + p1=p1+other.ksym + p2=p2+other.ksym + + else: + p1=p1+other + p2=p2+other + + return Eq(p1,p2) + + def __radd__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1+other.left + p2=p2+other.right + elif type(other)==MyEq: + p1=p1+other.ksym + p2=p2+other.ksym + + else: + p1=p1+other + p2=p2+other + + return Eq(p1,p2) + + def __sub__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1-other.left + p2=p2-other.right + elif type(other)==MyEq: + p1=p1-other.ksym + p2=p2-other.ksym + + else: + p1=p1-other + p2=p2-other + + return Eq(p1,p2) + + def __rsub__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1-other.left + p2=p2-other.right + elif type(other)==MyEq: + p1=p1-other.ksym + p2=p2-other.ksym + + else: + p1=p1-other + p2=p2-other + + return Eq(p1,p2) + + def __mul__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1*other.left + p2=p2*other.right + elif type(other)==MyEq: + p1=p1*other.ksym + p2=p2*other.ksym + + else: + p1=p1*other + p2=p2*other + + return Eq(p1,p2) + + def __rmul__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1*other.left + p2=p2*other.right + elif type(other)==MyEq: + p1=p1*other.ksym + p2=p2*other.ksym + + else: + p1=p1*other + p2=p2*other + + return Eq(p1,p2) + + + def __truediv__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1/other.left + p2=p2/other.right + elif type(other)==MyEq: + p1=p1/other.ksym + p2=p2/other.ksym + + else: + p1=p1/other + p2=p2/other + + return Eq(p1,p2) + + def __rtruediv__(self, other): + p1=self.e1.ksym + p2=self.e2.ksym + if type(other)==MyEqEq: + p1=p1/other.left + p2=p2/other.right + elif type(other)==MyEq: + p1=p1/other.ksym + p2=p2/other.ksym + + else: + p1=p1/other + p2=p2/other + + return Eq(p1,p2) + + # Update # + ########################################### + + def add_ics(self,var1,var2,var3): + Vics=self.Vics + + + if 'd2' in var1: + + arma=d2ficc(self.vmain,self.var2,var2,var3) + Vics.append(arma) + elif 'd' in var1 and 'd2' not in var1 : + + arma=dficc(self.vmain,self.var2,var2,var3) + Vics.append(arma) + else: + v1=str(self.vmain)+'('+str(var2)+')' + arma= fics(v1,var3) + Vics.append(arma) + self.Vics=Vics + self.arma_ics() + sE(['ics=',self.ics]) + + def arma_ics(self): + kres='{' + Vics=self.Vics + for i in Vics: + kres+=i+',' + kres=kres[0:-1] + kres+='}' + self.ics=parse_expr(kres) + ################################## + # Apariencia + ################################## + def s2(self): + + self.up_eQshow() + func=self.func + dfunc=self.dfunc + qq=len(func) + kres=self.eQshow + for i in range(qq): + kfunc=func[i] + kdfunc=dfunc[i] + kres=kres.subs(kfunc[0],kdfunc[0]) + #res=kres.subs(kfunc[0],kdfunc[0]) + self.eQshow=kres + self.s('2') + + def s3(self): + + func=self.func + dfunc=self.dfunc + qq=len(func) + kres=self.eQshow + for i in range(qq): + kfunc=func[i] + kdfunc=dfunc[i] + kres=kres.subs(kfunc[1],kdfunc[1]) + #res=kres.subs(kfunc[0],kdfunc[0]) + self.eQshow=kres + self.s('2') + + def save_eQshow(self,keQ): + self.eQshow=keQ + + def up_eQshow(self): + self.eQshow=self.eQ + + + def up2primitiva(self): + eq=self.eQ + self.e1.ksym=eq.lhs + self.e2.ksym=eq.rhs + self.modeNormal=False + + + + def up2normalMode(self): + return self.primitiva2func() + + def primitiva2func(self): + try: + self.e1.ksym=flat_diff(self.left,self.df) + except: + pass + vmain=self.vmain + vmain=antiprimitiva(vmain) + nx=symbols(str(vmain)) + fmain=Function(str(vmain))(self.var2) + if self.modeNormal: + self.primieQ=Eq(self.e1.ksym,self.e2.ksym) + self.modeNormal=False + + try: + ee1=self.e1 + ee1.set(fmain,nx,kshow=False) + self.e1=ee + except: + pass + + try: + ee2=self.e2 + ee2.set(fmain,nx,kshow=False) + self.e2=ee2 + except: + pass + + + self.s() + + def flat_diff(self): + try: + self.e1.ksym=self.e1.ksym.subs(Q.df,flat_diff(Q.df)) + except: + pass + self.s() + def updateEq(self): + p1=self.e1.ksym + p2=self.e2.ksym + self.eQ =Eq(p1,p2) + + + def updatee(self,p1,p2): + self.e1.ksym=p1 + self.e2.ksym=p2 + self.eQ =Eq(p1,p2) + self.exp1=p1 + self.exp2=p2 + + + def update(self): + + self.eQ = Eq(sydem(self.e1.ksym), sydem(self.e2.ksym)) + + def update2 (self,nEq): + kres=nEq + self.e1.ksym=kres.lhs + self.e2.ksym=kres.rhs + self.update() + + def reformate(self,p1,p2,kshow=True): + self.e1.ksym=p1 + self.e2.ksym=e2 + self.s(kshow=kshow) + + ################################## + # Show() + ################################## + + def set_vista(self,ktype): + self.vista=ktype + def swap(self): + ee=self.e2 + self.e2=self.e1 + self.e1=ee + self.s() + def sshow(self,kshow): + if kshow: + self.s() + + def s(self,kshow=True,kclone=True): + if self.render: + if self.insys!='': + self.insys.s() + else: + p1=self.e1.ksym + p2=self.e2.ksym + ps=self.symb + + if kshow: + display(Math(latex(p1)+' '+ps+' '+latex(p2))) + P1,P2=self.lundo[-1] + if P1!=p1 or P2!=p2: + self.lundo.append([self.L,self.R]) + + def xcopy(self,op=''): + kres=copy.deepcopy(self) + if op!='': + kres.s() + + return kres + + @property + def rval(self,**args): # return lhs from Eq + return self.e2.ksym + + @property + def right(self): # return lhs from Eq + return self.e2.ksym + + @property + def R(self): + return unisymbols(self.right) + + @property + def L(self,val=''): + if val=='': + return unisymbols(self.left) + else: + ee=unisymbols(self.e1) + ee.var=unisymbols(self.var) + + return ee(val) + + + def setvarL(self,var): + self.e1.var=var + + + def setvarR(self,var): + self.e2.var=var + + def all2L(self,kshow=True): + p1=self.L + p2=self.R + self.e1.ksym=simplify(p1-p2) + self.e2.ksym=0 + if kshow: + self.s() + def all2R(self,kshow=True): + p1=self.L + p2=self.R + self.e2.ksym=simplify(p2-p1) + self.e1.ksym=0 + if kshow: + self.s() + + @property + def u(self): + self.undo() + + @property + def lval(self): # return lhs from Eq + return self.e1.ksym + @property + def left(self): # return lhs from Eq + return self.e1.ksym + + def getdata(self): + return self.e1.ksym,self.e2.ksym + + def dothis(self,*args): + op='LR' + args3=[] + for i in args: + if i!='L' and i!='R': + args3.append(i) + else: + op=i + if 'L' in op: + ksym=self.L + args2=[ksym] + for i in args3: + args2.append(i) + kres=dothis(*args2) + self.e1.ksym=kres + + if 'R' in op: + ksym=self.R + args2=[ksym] + for i in args3: + args2.append(i) + kres=dothis(*args2) + self.e2.ksym=kres + + + self.s() + def doindenom(self,*args): + op='' + vecL=[self.L] + vecR=[self.R] + for i in args: + if i=='L' or i=='R': + op=i + else: + vecL.append(i) + vecR.append(i) + if op=='L': + self.e1.ksym=doindenom(*vecL) + elif op=='R': + self.e2.ksym=doindenom(*vecR) + else: + self.e1.ksym=doindenom(*vecL) + self.e2.ksym=doindenom(*vecR) + self.s() + + def doinnumer(self,*args): + op='' + vecL=[self.L] + vecR=[self.R] + for i in args: + if i=='L' or i=='R': + op=i + else: + vecL.append(i) + vecR.append(i) + if op=='L': + self.e1.ksym=doinnumer(*vecL) + elif op=='R': + self.e2.ksym=doinnumer(*vecR) + else: + self.e1.ksym=doinnumer(*vecL) + self.e2.ksym=doinnumer(*vecR) + self.s() + + def updata(self,p1,p2): + self.e1.ksym=p1 + self.e2.ksym=p2 + + + def setL(self,ksym='',kshow=True): + ''' + if ksym!='' then self.left will be ksym + else try to replace kwars in left + ''' + + if ksym!='': + self.e1.ksym=ksym + + if kshow: + self.s() + def setR(self,ksym='',kshow=True): + ''' + if ksym!='' then self.left will be ksym + else try to replace kwars in left + ''' + + if ksym!='': + self.e2.ksym=ksym + + if kshow: + self.s() + ################################## + # set() + ################################## + def validatesymbols(self,svar): + self.e1.ksym=expr2var(self.L,svar) + self.e2.ksym=expr2var(self.R,svar) + self.s() + + def set_eQshow(self,*args,kshow=True): + qq=len(args) + ks1=[] + ks2=[] + + for i in range(qq): + if i%2==0: + ks1.append(args[i]) + else: + ks2.append(args[i]) + + eQshow=self.eQshow + for i,j in zip(ks1,ks2): + eQshow=eQshow.subs(i,j) + self.eQshow=eQshow + + if kshow: + self.s('2') + + + def changesigno(self,kshow=True): + self.e1.ksym=-1*self.e1.ksym + self.e2.ksym=-1*self.e2.ksym + if kshow: + self.s() + + def evalue_if(self,*args,kshow=True,kope='',**kwargs): + QQ=self.xcopy('QQ') + margs=args + mkwargs=kwargs + QQ.set(*margs,kshow=kshow,kope=kope,**mkwargs) + + def evalueif(self,*args,kshow=True,kope='',**kwargs): + QQ=self.xcopy('QQ') + margs=args + mkwargs=kwargs + QQ.set(*margs,kshow=kshow,kope=kope,**mkwargs) + + # def set(self,*args,kshow=True,**kwargs): + + + # self.e1.set(*args,kshow=False,**kwargs) + # self.e2.set(*args,kshow=False,**kwargs) + + + + # self.s() + # def set(self,**kwargs): + # p1=self.L + # p1=setpack(p1,**kwargs) + # p2=self.R + # p2=setpack(p2,**kwargs) + # self.e1.ksym=p1 + # self.e2.ksym=p2 + # self.s() + def set(self,*args,**kwargs): + p1=self.L + p2=self.R + if len(kwargs)>0: + p1=realsub2(p1,**kwargs) + p2=realsub2(p2,**kwargs) + + if len(args)>0: + for i in args: + if type(i)==MyEq: + kres=i.ksym + svar=i.name + try: + sp1=str(p1) + p1=p1.subs(svar,kres) + if str(p1)==sp1: + p1=subsubs(p1,str(svar),kres) + except: + pass + try: + sp2=str(p2) + p2=p2.subs(svar,kres) + if str(p2)==sp2: + p2=subsubs(p2,str(svar),kres) + except: + pass + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + + + def undo(self,kshow=True): + qq=len(self.lundo) + if qq>1: + qu=qq-1 + kres=self.lundo[0:qu] + p1,p2=kres[-1] + self.e1.ksym=p1 + self.e2.ksym=p2 + ps=self.symb + self.lundo=kres + + if kshow: + display(Math(latex(p1)+' '+ps+' '+latex(p2))) + else: + self.s() + + + ################################## + # simplify + ################################## + + + + def addexpand(self): + self.e1.ksym=addexpand(self.e1.ksym) + self.e2.ksym=addexpand(self.e2.ksym) + self.s() + + + def expand(self, kop='RL',kshow=True): + if 'L' in kop: + self.e1.expand(kshow=False) + if 'R' in kop: + self.e2.expand(kshow=False) + if kshow: + self.s() + + + + + + def Expand(self,kshow=True,kope=''): + p1=self.left + p2=self.right + p1=factor(p1) + if Is_Mono(p1): + p2=p2*denom(p1) + p2=factor(p2) + p1=numer(p1) + + if Is_Mono(p2): + p1=p1*denom(p2) + p2=numer(p2) + + p1=opemat(p1,kope=kope) + p2=opemat(p2,kope=kope) + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + + + def opemat(self,kope='',op='LR'): + p1=self.left + p2=self.right + + if 'L' in op: + p1=opemat(p1,kope=kope) + if 'R' in op: + p2=opemat(p2,kope=kope) + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + def getpart(self,*args): + return self.get_args(*args) + + def args(self,*args,deep=2,format='list'): + if len(args)==0: + showarglist(self.L,deep=deep,format=format,side='L') + showarglist(self.R,deep=deep,format=format,side='R') + else: + kres=Eq(self.e1.ksym,self.e2.ksym) + for i in args: + kres=kres.args[i] + return kres + + def get_args(self,*args): + self.eQ=Eq(self.L,self.R) + kres=self.eQ + for i in args: + kres=kres.args[i] + return kres + + def kargs(self,*args): + kres=self.eQ + for i in args: + kres=kres.args[i] + return kres + + def exp_alone(self): + eQs=str(self.eQ) + sres='' + try: + smm=between_par(eQs,'exp(') + except: + self.s() + return + smm='exp('+smm+')' + try: + mm=parse_expr(smm) + except: + self.s() + return + self.alone(mm) + + def nformat(self,nd): + self.e1.ksym=nformat(self.e1.ksym,nd) + self.e2.ksym=nformat(self.e2.ksym,nd) + self.s() + + def reducecero(self): + p1=self.L + p2=self.R + if p1==0: + p2=reducecero(p2) + else: + if p2==0: + p1=reducecero(p1) + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + + + + def reduce(self,*args,kshow=True): + + p1=self.e1.ksym + p2=self.e2.ksym + if Is_Pow(self.L) and Is_Pow(self.L): + base1=getbase(p1) + base2=getbase(p2) + ee1=getexpo(p1) + ee2=getexpo(p2) + if base1==base2: + self.e1.ksym=ee1 + self.e2.ksym=ee2 + elif ee1==ee2: + self.e1.ksym=base1 + self.e2.ksym=base2 + elif ee1==base1 and ee2==base2: + self.e1.ksym=base1 + self.e2.ksym=base2 + elif ee1==base1: + self.e1.ksym=base2 + self.e2.ksym=ee2 + elif ee2==base2: + self.e1.ksym=base1 + self.e2.ksym=ee1 + else: + self.s() + return + else: + + + if type(p1)==log and type(p2)==log: + self.e1.ksym=p1.args[0] + self.e2.ksym=p2.args[0] + elif type(p1)==Pow and type(p2)==Pow: + b1=getbase(p1) + b2=getbase(p2) + e1=getexpo(p1) + e2=getexpo(p2) + if b1==b2: + self.e1.ksym=e1 + self.e2.ksym=e2 + if e1==e2: + self.e1.ksym=b1 + self.e2.ksym=b2 + else: + p1=self.e1.ksym + p2=self.e2.ksym + p1=p1.factor() + p1=unisymbols(p1) + p2=self.e2.ksym + p2=p2.factor() + p2=unisymbols(p2) + if len(args)>0: + for i in args: + p1=p1/i + p2=p2/i + self.e1.ksym=p1 + self.e2.ksym=p2 + else: + if Is_Mul(p1) and Is_Mul(p2): + m1=fpoly(p1,'list') + m2=fpoly(p2,'list') + L1=subtrac_list(m1,m2) + pp1=listmul(L1) + L2=subtrac_list(m2,m1) + pp2=listmul(L2) + self.e1.ksym=pp1 + self.e2.ksym=pp2 + + + if kshow: + self.s() + + + def simplifySum(self): + p1=self.e1.ksym + p2=self.e2.ksym + try: + p1,p2=simplifySum(p1,p2) + except: + pass + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + + def simplify(self,*args, kop='RL' ,force=False,kshow=True,ssum=True,smul=True): + + + p1=self.e1.ksym + p2=self.e2.ksym + + if self.type=='iq3': + self.e1.ksym=simplify(p1) + self.e2.ksym=simplify(p2) + if kshow: + self.s() + return + + if Is_Div(p1) and Is_Div(p2): + if denom(p1)==denom(p2): + self.e1.ksym=numer(p1) + self.e2.ksym=numer(p2) + if kshow: + self.s() + return + + if Is_Pow(p1) and Is_Pow(p2): + if getbase(p1)==getbase(p2): + self.e1.ksym=getexpo(p1) + self.e2.ksym=getexpo(p2) + if kshow: + self.s() + return + elif getexpo(p1)==getexpo(p2): + self.e1.ksym=getbase(p1) + self.e2.ksym=getbase(p2) + if kshow: + self.s() + return + + self.e1.ksym=simplify(p1) + self.e2.ksym=simplify(p2) + + if kshow: + self.s() + def lsimplify(self,kop='RL' ,kshow=True): + p1=self.L + p2=self.R + + p1=lsimplify(p1) + p2=lsimplify(p2) + self.e1.ksym=p1 + self.e2.ksym=p2 + + if kshow: + self.s() + + def lcombine(self,kop='RL' ,kshow=True): + p1=self.L + p2=self.R + + p1=logcombine(p1,force=True) + p2=logcombine(p2,force=True) + self.e1.ksym=p1 + self.e2.ksym=p2 + + if kshow: + self.s() + + def expandexpo(self,kop='LR',kshow=True): + p1=self.e1.ksym + if 'L' in kop: + p1=expandexpo(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=expandexpo(p2) + self.e2.ksym=p2 + if kshow: + self.s() + + + def rsimplify(self,kop='LR',kshow=True): + p1=self.e1.ksym + if 'L' in kop: + if 'sqrt' in str(p1): + p1=rsimplify(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + if 'sqrt' in str(p2): + p2=rsimplify(p2) + self.e2.ksym=p2 + if kshow: + self.s() + def simplify_img(self,kop='LR',kshow=True): + p1=self.e1.ksym + if 'L' in kop: + p1=simplify_img(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=simplify_img(p2) + self.e2.ksym=p2 + if kshow: + self.s() + def expandbase(self,kop='LR',kshow=True): + p1=self.e1.ksym + if 'L' in kop: + p1=expandbase(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=expandbase(p2) + self.e2.ksym=p2 + if kshow: + self.s() + def factorbase(self,kop='LR',kshow=True): + p1=self.e1.ksym + if 'L' in kop: + p1=factorbase(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=factorbase(p2) + self.e2.ksym=p2 + if kshow: + self.s() + def simplifybase(self,kop='LR',kshow=True): + + p1=self.left + if 'L' in kop: + p1=simplifybase(p1) + self.e1.ksym=p1 + p2=self.right + if 'R' in kop: + p2=simplifybase(p2) + self.e2.ksym=p2 + + if kshow: + self.s() + def powexpand(self,kop='LR',kshow=True): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + op='' + if 'i' in kop: + op='i' + p1=self.left + if 'L' in kop: + p1=powexpand(p1,op=op) + self.e1.ksym=p1 + p2=self.right + if 'R' in kop: + p2=powexpand(p2,op=op) + self.e2.ksym=p2 + + if kshow: + self.s() + + def mulexpo(self,kop='LR',kshow=True,force=False): + p1=self.e1.ksym + if 'L' in kop: + p1=mulexpo(p1,force=force) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=mulexpo(p2,force=force) + self.e2.ksym=p2 + if kshow: + self.s() + def pow2powpow(self,exp1='',kop='LR',kshow=True): + if exp1!='' and type(exp1)==str: + kop=exp1 + p1=self.e1.ksym + if 'L' in kop: + p1=pow2powpow(p1,exp1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=pow2powpow(p2,exp1) + self.e2.ksym=p2 + if kshow: + self.s() + + def positivexpo(self,kop='LR',kshow=True): + p1=self.e1.ksym + if 'L' in kop: + p1=positivexpo(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in kop: + p2=positivexpo(p2) + self.e2.ksym=p2 + if kshow: + self.s() + def simplifyexpo(self,op='LR',kope='',kshow=True): + p1=self.e1.ksym + if 'L' in op: + p1=simplifyexpo(p1) + self.e1.ksym=p1 + p2=self.e2.ksym + if 'R' in op: + p2=simplifyexpo(p2) + self.e2.ksym=p2 + + if kshow: + self.s() + + + def basefactor(self,op='LR',kope='',kshow=True): + return self.simplifyexp(op=op,kope=kope,kshow=kshow) + + + def simplifyexp(self,op='LR',kope='',kshow=True): + p1=self.left + if 'L' in op: + p1=simplifyexp(p1,kope=kope) + self.e1.ksym=p1 + p2=self.right + if 'R' in op: + p2=simplifyexp(p2,kope=kope) + self.e2.ksym=p2 + + if kshow: + self.s() + + def div2mul(self,ops='LR'): + if 'L' in ops and Is_Div(self.L): + p1=numer(self.L) + p2=denom(self.L) + self.e1.ksym=p1*p2 + if 'R' in ops and Is_Div(self.R): + p1=numer(self.R) + p2=denom(self.R) + self.e2.ksym=p1*p2 + self.s() + + def div2mulexpo(self,op='LR',kope='',kshow=True): + p1=self.left + if 'L' in op: + p1=div2mulexpo(p1) + if kope!='': + p1=opemat(p1,kope=kope) + self.e1.ksym=p1 + + p2=self.right + if 'R' in op: + p2=div2mulexpo(p2) + if kope!='': + p2=opemat(p2,kope=kope) + self.e2.ksym=p2 + + if kshow: + self.s() + + def reducePow(self,op='LR',kope='',kshow=True): + p1=self.left + if 'L' in op: + p1=reducePow(p1) + if kope!='': + p1=opemat(p1,kope=kope) + self.e1.ksym=p1 + + p2=self.right + if 'R' in op: + p2=reducePow(p2) + if kope!='': + p2=opemat(p2,kope=kope) + self.e2.ksym=p2 + + if kshow: + self.s() + def simplifyrpow(self,kope='',kop='RL',kshow=True): + + + if 'L' in kop : + self.e1.simplifyrpow(kshow=False) + if 'R' in kop : + self.e2.simplifyrpow(kshow=False) + if kope!='': + kres1=self.e1.ksym + kres2=self.e2.ksym + + kres1=opemat(kres1,kope=kope) + kres2=opemat(fcc,kope=kope) + self.e1.ksym=kres1 + self.e2.ksym=kres2 + self.s() + def simplify_cero(self): + kres=self.left-self.right + kres=opemat(kres) + self.e1.ksym=kres + self.e2.ksym=0 + self.s() + + + def primefactor(self, *args,kshow=True): + + op='RL' + p1=self.L + p2=self.R + + if 'L' in args: + op='L' + if 'R' in args: + op='R' + if 'L' in op: + p1=primefactor(p1) + self.e1.ksym=p1 + if 'R' in op: + p2=primefactor(p2) + self.e2.ksym=p2 + + if kshow: + self.s() + + + def factor(self,*args, kop='RL',kshow=True): + + if 'L' in kop: + self.e1.factor(*args,kshow=False) + + if 'R' in kop: + self.e2.factor(*args,kshow=False) + + + + if kshow: + self.s() + def apart(self,kop='RL',kshow=True): + + if 'L' in kop: + self.e1.apart(kshow=False) + + if 'R' in kop: + self.e2.apart(kshow=False) + + + + if kshow: + self.s() + def inverse(self,kop='RL',kshow=True): + + if 'L' in kop: + self.e1.inverse(kshow=False) + + if 'R' in kop: + self.e2.inverse(kshow=False) + + + + if kshow: + self.s() + + + def factors(self,kfac, kop='RL',kshow=True): + + if 'L' in kop: + p1=self.L + p1=factors(p1,kfac) + self.e1.ksym=p1 + + if 'R' in kop: + p2=self.R + p2=factors(p2,kfac) + self.e2.ksym=p2 + + + + if kshow: + self.s() + + def dfactor(self,var,var1,op='',side='LR'): + if 'L' in side: + p1=dfactor(self.e1.ksym,var=var,var1=var1,op=op) + self.e1.ksym=p1 + if 'R' in side: + p2=dfactor(self.e2.ksym,var=var,var1=var1,op=op) + self.e2.ksym=p2 + if kshow: + self.s() + + def tsimplify(self, kop='RL',kshow=True,kope=''): + if 'L' in kop: + self.e1.ksym=expand_log(self.e1.ksym) + if 'L' in kop: + self.e2.ksym=expand_log(self.e2.ksym) + if kshow: + self.s() + + def trinom2binom(self,sexpr,kop='RL',kshow=True): + if 'L' in kop: + self.e1.trinom2binom(sexpr,kshow=False) + if 'R' in kop: + self.e2.trinom2binom(sexpr,kshow=False) + if kshow: + self.s() + + def tfactor(self, kop='RL',kshow=True,kope=''): + if 'L' in kop: + self.e1.tfactor(kope=kope,kshow=False) + if 'R' in kop: + self.e2.tfactor(kope=kope,kshow=False) + if kshow: + self.s() + + def texpand(self, kop='RL',kshow=True,kope=''): + if 'L' in kop: + self.e1.texpand(kope=kope,kshow=False) + if 'R' in kop: + self.e2.texpand(kope=kope,kshow=False) + if kshow: + self.s() + + + + # def Add(self,*args,kshow=True): + # vecpara=['simplify','factor','expand'] + # kval1,kval2,kname,op=reparte_param(vecpara,*args) + + # p1=self.left + # p2=self.right + # if 'L' in op: + # p1=fes(self.left+kval1,*args) + # if 'R' in op: + # p2=fes(self.right+kval2,*args) + # if kname!='': + # QQ=MyEqEq(p1,p2) + # return QQ + # else: + # self.e1.ksym=premath(p1,*args) + # self.e2.ksym=premath(p2,*args) + # if kshow: + # self.s() + + + + + # def Substrac(self,*args,kshow=True): + + # vecpara=['simplify','factor','expand'] + # kval1,kval2,kname,op=reparte_param(vecpara,*args) + + # p1=self.left + # p2=self.right + # if 'L' in op: + # p1=fes(self.left-kval1,*args) + # if 'R' in op: + # p2=fes(self.right-kval2,*args) + # if kname!='': + # QQ=MyEqEq(p1,p2) + # return QQ + # else: + # self.e1.ksym=premath(p1,*args) + # self.e2.ksym=premath(p2,*args) + # if kshow: + # self.s() + + # def Mul(self,*args,kshow=True): + + # vecpara=['simplify','factor','expand'] + # kval1,kval2,kname,op=reparte_param(vecpara,*args) + + # p1=self.left + # p2=self.right + # if 'L' in op: + # p1=fes(self.left*kval1,*args) + # p1=premath(p1,*args) + # if 'R' in op: + # p2=fes(self.right*kval2,*args) + # p2=premath(p2,*args) + # if kname!='': + # QQ=MyEqEq(p1,p2) + # return QQ + # else: + # self.e1.ksym=p1 + # self.e2.ksym=p2 + # if kshow: + # self.s() + + # def Div(self,*args,kshow=True,unevaluate=False): + # vecpara=['simplify','factor','expand','nosimplify'] + # kval1,kval2,kname,op=reparte_param(vecpara,*args) + + + + # p1=self.left + # p2=self.right + + + + # if 'L' in op: + + + # p1=simplify(Div(p1,kval1)) + # p1=premath(p1,*args) + # if unevaluate: + # p1=Divunevaluate(p1) + + # if 'R' in op: + # p2=simplify(Div(p2,kval2)) + # p2=premath(p2,*args) + # if unevaluate: + # p2=Divunevaluate(p2) + + + # if kname!='': + # QQ=MyEqEq(p1,p2) + # return QQ + # if self.type=='IQ' and signo(kval)==-1: + # self.e1.ksym=p2 + # self.e2.ksym=p1 + # else: + # self.e1.ksym=p1 + # self.e2.ksym=p2 + + # if kshow: + # self.s() + + # def Pow(self, *args,simplify=True): + # kval=args[0] + # ops,kshow=getops(*args) + # p1,p2=self.getdata() + + # if 'L' in ops: + # p1=ppow(p1,kval) + # p1=premath(p1,*args) + # if simplify: + # p1=mulexpo(p1) + # p1=simplifyexpo(p1) + + # if 'R' in ops: + # p2=ppow(p2,kval) + # p2=premath(p2,*args) + # if simplify: + # p2=mulexpo(p2) + # p2=simplifyexpo(p2) + # premath + # self.e1.ksym=p1 + # self.e2.ksym=p2 + # self.s() + + def Add(self,*args): + P1,P2=getdatain(*args) + + P1=self.e1.ksym+P1 + P2=self.e2.ksym+P2 + if 'simplify' in args: + P1=simplify(P1) + P2=simplify(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + if 'noshow'not in args: + self.s() + def Substrac(self,*args): + P1,P2=getdatain(*args) + + P1=self.e1.ksym-P1 + P2=self.e2.ksym-P2 + if 'simplify' in args: + P1=simplify(P1) + P2=simplify(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + if 'noshow'not in args: + self.s() + def Subs(self,*args): + P1,P2=getdatain(*args) + + P1=self.e1.ksym-P1 + P2=self.e2.ksym-P2 + if 'simplify' in args: + P1=simplify(P1) + P2=simplify(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + if 'noshow'not in args: + self.s() + def Mul(self,*args): + P1,P2=getdatain(*args) + + P1=self.e1.ksym*P1 + P2=self.e2.ksym*P2 + if 'simplify' in args: + P1=simplify(P1) + P2=simplify(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + if 'noshow'not in args: + self.s() + + + def Div(self,*args): + P1,P2=getdatain(*args) + + P1=self.e1.ksym/P1 + P2=self.e2.ksym/P2 + if 'simplify' in args: + P1=simplify(P1) + P2=simplify(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + if 'noshow'not in args: + self.s() + + def Pow(self,*args): + P1,P2=getdatain(*args) + + P1=self.e1.ksym**P1 + P2=self.e2.ksym**P2 + if 'simplify' in args: + P1=simplify(P1) + P2=simplify(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + if 'noshow'not in args: + self.s() + + def Rpow(self,*args): + rr=args[0] + P1=self.L + if not 'R' in args: + + self.e1.ksym=rsimplify(rpow(P1,rr)) + P2=self.R + if not 'L' in args: + self.e2.ksym=rsimplify(rpow(P2,rr)) + + + if 'noshow' not in args: + self.s() + + def lexpand(self,kop='RL',kshow=True): + if 'L' in kop: + self.e1.ksym=lexpand(self.L) + if 'R' in kop: + self.e2.ksym=lexpand(self.R) + if kshow: + self.s() + + + + def lmul2lpow(self, kop='RL',kshow=True): + p1=self.e1.ksym + p2=self.e2.ksym + if 'L' in kop: + p1=lmul2lpow(p1) + if 'R' in kop: + p2=lmul2lpow(p2) + self.e1.ksym=p1 + self.e2.ksym=p2 + if kshow: + self.s() + + def lfactor(self, kop='RL',kshow=True): + if 'L' in kop: + self.e1.lfactor(kshow=False) + if 'R' in kop: + self.e2.lfactor(kshow=False) + self.s() + + def exp(self, kop='RL',kshow=True): + if 'L' in kop: + self.e1.ksym=exp(self.L) + if 'R' in kop: + self.e2.ksym=exp(self.R) + self.s() + def lexponent(self,op='LR'): + if 'L' in op: + p1=self.e1.ksym + expr=p1 + expr=lexponent(expr) + self.e1.ksym=expr + if 'R' in op: + p2=self.e2.ksym + expr=p2 + expr=lexponent(expr) + self.e2.ksym=expr + + self.s() + def log(self, kop='RL',kshow=True): + if 'L' in kop: + kres=self.e1.ksym + self.e1.ksym=log(kres) + + if 'R' in kop: + kres=self.e2.ksym + self.e2.ksym=log(kres) + self.s() + + def factorSec(self, ksym,kop='RL',kshow=True): + if 'L' in kop: + + self.e1.factorSec(ksym,kshow=False) + if 'R' in kop: + self.e2.factorSec(ksym,kshow=False) + self.s() + + def linfactor(self, ksym,kop='RL',kshow=True): + if 'L' in kop: + p1=self.left + p1=linfactor(p1,ksym) + self.e1.ksym=p1 + if 'L' in kop: + p2=self.right + p2=linfactor(p2,ksym) + self.e2.ksym=p2 + if kshow: + self.s() + + def listR(self,op=''): + kres=fpoly(self.right,'list') + if op!='': + return kres[op] + else: + return kres + def listL(self,op=''): + kres=fpoly(self.left,'list') + if op!='': + return kres[op] + else: + return kres + + def list(self,kop='R'): + kres=fpoly(self.right,'list') + if kop=='L': + kres=fpoly(self.left,'list') + return kres + + + def clearUp(self,vv,kshow=True): + p1=0 + p2=0 + for i in self.e1.list(): + mm=fpoly(i,'free') + if vv in mm: + p1+=i + else: + p2-=i + for i in self.e2.list(): + mm=fpoly(i,'free') + if vv in mm: + p1-=i + else: + p2+=i + self.e1=MyEq(p1,'e1',kshow=False) + self.e2=MyEq(p2,'e2',kshow=False) + if kshow: + self.s() + + def clearAlone(self,vv): + self.clearUp(vv=vv,kshow=False) + mm=self.e1.list() + done=True + if len(mm)==2: + if type(self.e1.ksym)==Mul: + if vv in self.e1.list(): + kfac=1 + for i in self.e1.list(): + if i!=vv: + self.Div(i,kshow=False) + self.s() + done=False + if done: + self.s() + + + def sin2cos(self, angu, korden=2, kope='', kop='RL'): + if 'L' in kop: + self.e1.set(kpow(sin(angu), 3), (1 - kpow(cos(angu), 2)) * cos(angu), kshow=False) + kres = self.e1.ksym + kres = sin2cos(kres, angu=angu, korden=korden, kope=kope) + self.e1.update(kres) + if 'R' in kop: + self.e2.set(kpow(sin(angu), 3), (1 - kpow(cos(angu), 2)) * cos(angu), kshow=False) + kres = self.e2.ksym + kres = sin2cos(kres, angu=angu, korden=korden, kope=kope) + self.e2.update(kres) + self.s() + + def cos2sin(self, angu, korden=2, kope='', kop='RL'): + if 'L' in kop: + self.e1.set(kpow(cos(angu), 3), (1 - kpow(sin(angu), 2)) * sin(angu), kshow=False) + kres = self.e1.ksym + kres = cos2sin(kres, angu=angu, korden=korden, kope=kope) + self.e1.update(kres) + if 'R' in kop: + self.e2.set(kpow(cos(angu), 3), (1 - kpow(sin(angu), 2)) * sin(angu), kshow=False) + kres = self.e2.ksym + kres = cos2sin(kres, angu=angu, korden=korden, kope=kope) + self.e2.update(kres) + + self.s() + + ######################################### + # MyEqEq evalue + ########################################## + + def evalue(self,val1,val2,kshow=True): + QQ=self.xcopy() + QQ.e1.ksym=QQ.left.subs(val1,val2) + QQ.e2.ksym=QQ.right.subs(val1,val2) + + if kshow: + QQ.s() + + else: + QQ.s(kshow=False) + return QQ.right + def eval(self,**kwargs): + + QQ=self.xcopy() + QQ.set(**kwargs) + + + ######################################### + # MyEqEq solve + ########################################## + def solve_compare_coef(self,*args,var=''): + lvar=[] + if var=='': + var=self.var + if len(args)==1 and type(args[0])==list: + lvar=args[0] + if len(args)>1: + for i in args: + lvar.append(i) + p1=self.L + cp1=coef_list(p1,var) + p2=self.R + cp2=coef_list(p2,var) + vece=[] + for i,j in zip(cp1,cp2): + vece.append(i-j) + solu=solve(vece,lvar) + display(Math(latex(solu))) + return ganswer(solu,'value') + + + + + + + + + def solve_coef_list(self,*args,var2=x): + r''' + solve variable from two polinomies with tha same coefficient ,grade orden + + example: + ********** + a*x*x+b*x+c= 3*x*x+2*x+7+y + + return: MyEq + a=3 + b=2 + c=7+y + + ''' + vecv=[] + vecq=[] + for i in args: + vecv.append(i) + m1=coef_list( self.left,var2) + m2=coef_list( self.right,var2) + qq1=len(m1) + qq2=len(m2) + + if qq1len( vecv): + vecq=vecq[0:len(vecv)] + vecq=vecq+vecv + kres=solver(*vecq) + eres=[] + for i,j in zip(vecv,kres): + ee=MyEq(j,str(i)) + eres.append(ee) + return eres + + + def alone(self,*args,kshow=True): + if len(args)==0: + helplib('alone') + return + + var=args[0] + + try: + expr=self.L-self.R + ee=MyEq(expr,'ee',var=var,kshow=False) + + kk=ee.solve(var,kshow=False) + self.e1.ksym=var + self.e2.ksym=kk.ksym + if kshow: + self.s() + except: + if kshow: + self.s() + + + + def alone2(self,*args,kshow=True,**kwargs): + + QQ=self.xcopy() + sres1=str(QQ.e1.ksym) + sres2=str(QQ.e2.ksym) + equ=QQ.e1.ksym-QQ.e2.ksym + ee=MyEq(equ,'ee',kshow=False) + ksolu=ee.solve(*args,kshow=False) + + self.e1.ksym=args[0] + self.e2.ksym=ksolu.ksym + if kshow: + self.s() + + + def kisolve(self): + p1=self.L + p2=self.R + ps=self.psymb + var=self.var + P1=eval(str(p1)+ps+str(p2)) + return solve_univariate_inequality(P1,var) + + + def isolve(self,kname='',kshow=True): + expr=self.kisolve() + if kname=='': + if kshow: + display(Math(latex(expr))) + return expr + else: + Qr=MyEq(expr,kname,var=x,ktype='lq') + return Qr + def solve(self,*args,kshow=True,**kwargs): + if len(args)==1: + e1=MyEq(self.L-self.R,'e1',kshow=false) + return e1 + done=False + cvar=args[0] + svar=str(cvar) + allpara=[] + if len(args)>1: + allpara=args[1::] + + kres=self.L-self.R + if len(kwargs)>1: + kres=real_subs(kres,**kwargs) + + ee=MyEq(kres,'ee',var=self.var,kshow=False) + if 'all' in allpara: + return ee.solve(cvar,'all',kshow=False) + + if 'noimg ' in allpara or 'nonimaginary' in allpara: + return ee.solve(cvar,'noimg',kshow=False) + + ksolu=ee.solve(cvar,kshow=kshow) + + ee2= MyEq(ksolu,svar,kshow=False) + if 'update' in allpara: + self.set(ee2) + return ee2 + + # def solve(self,*args,kshow=True,**kwargs): + + # done=False + # cvar=args[0] + # svar=str(cvar) + # allpara=[] + # if len(args)>1: + # allpara=args[1::] + + # kres=self.L-self.R + # if len(kwargs)>1: + # kres=real_subs(kres,**kwargs) + + # ee=MyEq(kres,'ee',var=self.var,kshow=False) + # if 'all' in allpara: + # return ee.solve(cvar,'all',kshow=False) + + # if 'noimg ' in allpara or 'nonimaginary' in allpara: + # return ee.solve(cvar,'noimg',kshow=False) + + # ksolu=ee.solve(cvar,kshow=kshow) + + # ee2= MyEq(ksolu,svar,kshow=False) + # if 'update' in allpara: + # self.set(ee2) + # return ee2 + + + + # def solve(self,*args,kshow=True,**kwargs): + # if len(args)==0: + # helplib('solve') + # return + # ovar=args[0] + # args=args[1:len(args)] + + # expr=self.L-self.R + # if ovar=='' or type(ovar)==tuple: + # if ovar=='': + # solu=solve(expr) + # else: + # solu=solve(expr,ovar) + + # if type(solu)==dict: + # key,value=unpack(solu) + # elif type(solu)==list: + # key,value=unpack(solu[0]) + # vecsol=[] + # for i,j in zip(key,value): + # ee=MyEq(j,kname=str(i)) + # vecsol.append(ee) + # if len(vecsol)==1: + # kres= vecsol[0] + # else: + # kres=vecsol + + + + + + # else: + # if len(args)>0 and 'all' in args: + # kres=solve(expr,ovar) + # if 'nonimaginary' in args: + + # kres2=[x for x in kres if 'I' not in str(x) ] + # return kres2 + # else: + # return kres + # else: + # solu=ksolve(expr,ovar,*args) + # solu=real_subs(solu,**kwargs) + # dvalue=False + # if len(args)>0: + # if 'positive' in args: + # solu=solu*signo(solu) + # if 'value' in args: + # dvalue=True + # if 'float' in args: + # try: + # solu=float(solu) + # except: + # pass + # if dvalue: + # return solu + # else: + # if type(solu)==dict: + # key,value=unpack(solu) + # if len(value)==1: + # solu=value[0] + + # ee=MyEq(solu,kname=ovar.name,kshow=kshow) + # return ee + + + + + def solve_if_and(self, svar, eqv=0, kope='',korden='',kshow=True, **kwargs): + r''' + solve variable from MyEq + parameters : + svar :type str , variablesin side the Eq taht we will find + eqv :type nemeric or symbols , if the value of all Eq + defaul Eq=0 + kwargs: t=0,g=10... etc + return MyEq of svar + example: + ********** + R(t)= C1 + C2*t + g*sin(t*w)/w**2 + C1= solve_if_and('C1',L,t=0) + return: C1=L + + R.upgrade(C1) + return: C2*t + L + g*sin(t*w)/w**2 + + C2=solve_if_and(R,'C2',t=2) + return:-L/2 - g*sin(2*w)/(2*w**2) + + R.upgrade(C2) + return: L + g*sin(t*w)/w**2 + t*(-L/2 - g*sin(2*w)/(2*w**2)) + + ''' + x=self.vmain + ee=MyEq(x-self.e2.ksym,kshow=False) + svar2=ee.solve_if_and(str(svar),eqv=0,kope=kope,korden=korden,kshow=False,**kwargs) + + self.e2.set(svar,svar2,kshow=False) + + self.s() + + def autosolve(self,kvar,**kwargs): + QQ=self.xcopy() + p1=QQ.L + p1=real_subs(p1,**kwargs) + p2=QQ.R + p2=real_subs(p2,**kwargs) + QQ.e1.ksym=p1 + QQ.e2.ksym=p2 + solu=QQ.solve(kvar,kshow=False) + ee=MyEq(solu,kname=str(kvar)) + p1=self.L + p1=subsubs(p1,str(kvar),solu) + self.e1.ksym=p1 + p2=self.R + p2=subsubs(p2,str(kvar),solu) + self.e2.ksym=p2 + + self.s() + return ee + + def autofind(self,*args,**kwargs): + QQ=self.xcopy() + sres1=str(QQ.e1.ksym) + sres2=str(QQ.e2.ksym) + for key, value in kwargs.items(): + sres1=sres1.replace(key,str(value)) + sres2=sres2.replace(key,str(value)) + expr1=parse_expr(sres1)-parse_expr(sres2) + vecres=solve(expr1,args[0]) + + kres=vecres[0] + if 'float' in args: + try: + kres=float(kres) + except: + pass + + var=args[0] + p1=self.L + p1=supersubs(p1,var,kres) + self.e1.ksym=p1 + p2=self.R + p2=supersubs(p2,var,kres) + self.e2.ksym=p2 + self.s() + def solve_if(self,ksym,**kwargs): + + + QQ=self.xcopy() + p1=QQ.left + p2=QQ.right + if len(kwargs)>0: + p1=subskwargs(p1,**kwargs) + p2=subskwargs(p2,**kwargs) + kname=str(ksym) + ee=MyEq(p1-p2,'ee',kshow=False) + nee=ee.solve(ksym,kshow=False) + kres=MyEq(nee,kname) + return kres + + + def solve_if_and_up(self,*args,**kwargs): + QQ=self.xcopy() + sres1=str(QQ.e1.ksym) + sres2=str(QQ.e2.ksym) + for key, value in kwargs.items(): + sres1=sres1.replace(key,str(value)) + sres2=sres2.replace(key,str(value)) + + QQ.e1.ksym=parse_expr(sres1) + QQ.e2.ksym=parse_expr(sres2) + kname='' + qq=len(args) + if qq==1: + vsym=args[0] + elif qq==2: + vsym=args[0] + kname=args[0] + else: + QQ.s() + return + if kname=='': + QQ2=QQ.xcopy() + QQ2.alone(vsym) + nval=QQ2.solve(vsym) + self.set(vsym,nval) + + else: + QQ2=QQ.xcopy() + ee=MyEq(QQ.solve(vsym),kname) + self.set(vsym,ee.ksym) + + return ee + + def solveset(self,var,**kwargs): # solve kmain in Q and set as vmain + kres=self.R-self.L + kres=subskwargs(kres,**kwargs) + ee=MyEq(kres,'ee',kshow=False) + ksolu=ee.solve(var,kshow=False) + ee2=MyEq(ksolu.ksym,kname=str(var)) + self.upgrade(ee2) + return ee2 + + + def solvemain(self): # solve vmain in Q and set final Eq + kres=self.solve(self.vmain) + self.e1.ksym=self.vmain + self.e2.ksym=kres + + self.s() + + def msimplify(self): + return self.solvemain() + + def toMyEq(self, kname): + kname = MyEq(self.e1.ksym - self.e2.ksym, kname=kname) + return kname + + + + + def lock(self,op='RL'): + if 'R' in op: + ksym=self.R + self.e2.ksym=UnevaluatedExpr(ksym) + if 'L' in op: + ksym=self.L + self.e1.ksym=UnevaluatedExpr(ksym) + + ######################################### + # MyEqEq uprade + ########################################## + + def replace(self,*args,kshow=True,**kwargs): + + if len(kwargs)>0: + + p1=self.L + p1=subskwargs1(p1,**kwargs) + self.e1.ksym=p1 + p2=self.R + p2=subskwargs1(p2,**kwargs) + self.e2.ksym=p2 + self.eQ=Eq(p1,p2) + + if len(args)>0: + for i in arg: + p1=self.L + p2=self.R + + if type(i)==MyEq: + sname=i.name + value=i.ksym + else: + sname=str(i) + value=i + p1=p1.subs(sname,value) + p2=p2.subs(sname,value) + self.e1.ksym=p1 + self.e2.ksym=p2 + self.eQ=Eq(p1,p2) + if kshow: + self.s() + + + + def upgrade(self,*args,kshow=True): + + self.e1.upgrade(*args,kshow=False) + self.e2.upgrade(*args,kshow=False) + self.updateEq() + self.s() + + def solveandset(self,*args,kshow=True,name='',**kwargs): + expr1=self.L + expr2=self.R + var1=self.var1 + var2=self.var2 + + QQ=self.xcopy() + kvar=args[0] + QQ.alone(kvar,kshow=False) + p2=QQ.R + p2=subskwargs(p2,**kwargs) + kfloat=False + kupdate=False + for i in args: + if i=='float': + kfloat=True + if i=='update': + kupdate=True + if kfloat: + try: + p2=float(p2) + except: + pass + kvar=MyEq(p2,kname=str(kvar),kshow=False) + kvar.s() + if kupdate: + self.upgrade(kvar) + return kvar + + + def solve_set_if(self,var,korden=0,kope='',kshow=True,**kwargs): + self.upgrade_if(var=var,korden=korden,kope=kope,kshow=kshow,**kwargs) + + def upgrade_if(self,var,korden=0,kope='',kshow=False,**kwargs): + Q2=self.xcopy() + Q2.set(kshow=False,**kwargs) + Q2.simplify(kshow=False) + if monodata(Q1.left,'isexp') or monodata(Q2.right,'isexp'): + Q2.log(kshow=False) + Q2.lexpand(kshow=False) + ee2=MyEq(Q2.right-Q2.left,'ee2',kshow=False,kope=kope) + + try: + ee=ee2.ssolve(str(var),kshow=False,kope=kope) + ee.opemat(kope=kope,kshow=False) + self.eQ=self.eQ.subs(var,ee) + except: + try: + ee=ee2.solve(var,str(var),korden=korden,kope=kope,kshow=kshow) + except: + ee=ee2.solve(var,str(var),kope=kope) + return + if kshow: + ee.s() + self.upgrade(ee,kshow=False) + self.s() + + def clear_exp_QQ(self,kshow=True): + + p1,p2=clear_exp_QQ(self.left,self.right) + self.e1.ksym=p1 + self.e2.ksym=p2 + if kshow: + self.s() + + + + + + def clear(self,ksym): + self.alone(ksym=ksym) + + def nofunc(self): # convert all x(t) in x dx in 1 dx2 in 1 in the Eq + vv=self.var0 + vf=self.ft + vdf=self.df + vd2f=self.d2f + vold=[vd2f,vdf,vf] + vnew=[1,1,vv] + + p1=str(self.left) + p2=str(self.right) + + for i,j in zip(vold,vnew): + p1=p1.replace(str(i),str(j)) + p2=p2.replace(str(i),str(j)) + + + self.e1.ksym=parse_expr(p1) + self.e2.ksym=parse_expr(p2) + self.s() + return self.var0 + + + def prima_func(self): # convert all x(t) in x dx in 1 dx2 in 1 in the Eq + vv=self.f + vf=self.ft + vdf=self.df + vd2f=self.d2f + vold=[vd2f,vdf,vf] + vnew=[self.p2f,self.pf,vv] + + + p1=str(self.left) + p2=str(self.right) + + for i,j in zip(vold,vnew): + p1=p1.replace(str(i),str(j)) + p2=p2.replace(str(i),str(j)) + + + self.e1.ksym=parse_expr(p1) + self.e2.ksym=parse_expr(p2) + self.s() + ######################################### + # MyEqEq dsolve + ########################################## + def dsolve(self,*args,op=''): + expr=self.eQ + kcond=self.ics + var2=self.var2 + vmain=self.vmain + + # if kcond!='': + # Q2=MyEqEq(dsolve(expr,ics=kcond),var2=t,vmain=x,kshow=False) + # else: + # Q2=MyEqEq(dsolve(expr),var2=t,vmain=x,kshow=False) + + if kcond!='': + kres= dsolve(expr,ics=kcond) + else: + kres=dsolve(expr) + + p1=kres.lhs + p2=kres.rhs + kname=str(self.vmain) + if len(args)==1 and type(args[0])==str: + kname=args[0] + nval=symbols(kname) + nval=MyEq(p2,kname,var2=self.var2) + return nval + else: + nval=symbols(kname) + nval=MyEq(p2,kname,var2=self.var2) + return nval + + + def nodiff(self): + df=symbol2diff(self.vmain,self.var2) + d2f=symbol2diff2(self.vmain,self.var2) + p1=self.left + p1=p1.subs(d2f,1) + p1=p1.subs(df,1) + p2=self.right + p2=p2.subs(d2f,1) + p2=p2.subs(df,1) + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + def derivarespect(self,var1,D1,var2='',D2='',kshow=True): + p1=derivarespect(self.L,var1,D1) + if var2=='': + var2=var1 + D2=D1 + p2=derivarespect(self.R,var2,D2) + self.e1.ksym=p1 + self.e2.ksym=p2 + if kshow: + self.s() + def chainrule(self,p1,p2,p3,kshow=True): + PL=self.L + PL=PL.subs(p1/p2,p3) + PR=self.R + PR=PR.subs(p1/p2,p3) + self.e1.ksym=PL + self.e2.ksym=PR + if kshow: + self.s() + + def diffQ(self,*args,niceview=True,update=True): + ''' + input: diff((),()) + return original eQ + + input: diff((x,t),()) + return diff(Q.L, in t and x=func) = Q.R ) + + input: diff((),(t,y)) + return Q.L = diff(Q.R, in t and y=func) + + input: diff((t,x),(t,y)) + return diff(Q.L, in t and x=func) = diff(Q.R, in t and y=func) + + input: diff((t,x,y),(t,x,y)) + return diff(Q.L, in t and x,y =func in t) = diff(Q.R, in t and x,y=func in t) + + args: + update=True, self.update, + update=False return other MQ + + niceview=True + return example Diferential(x(t),t) = dx/dt but value is original + ''' + exp1=self.e1.ksym + exp2=self.e2.ksym + + done1=False + done2=False + + if args[0]!=(): + datax=args[0] + + vart1=datax[0] + varx1=datax[1] + vary1='' + + if len(datax)==3: + vary1=datax[2] + exp11=diffuntion(exp1,vart1,varx1,vary1) + dif1=diffuntion(exp1,vart1,varx1,vary1) + exp1=exp11 + done1=True + if args[1]!=(): + + datay=args[1] + + vart2=datay[0] + varx2=datay[1] + vary2='' + + if len(datay)==3: + vary2=datay[2] + + exp22=diffuntion(exp2,vart2,varx2,vary2) + dif2=diffuntion(exp2,vart2,varx2,vary2) + exp2=exp22 + done2=True + if update: + self.e1.ksym=exp1 + self.e2.ksym=exp2 + rfin=self + else: + rfin=MQ(exp1,exp2,kshow=False) + if niceview: + nexp1=exp1 + if done1: + nexp1=viewnicediff(exp1,vart1,varx1,vary1) + nexp2=exp2 + if done2: + nexp2=viewnicediff(exp2,vart2,varx2,vary2) + if update==False: + MQ(nexp1,nexp2) + return MQ(dif1,dif2,kshow=False) + else: + MQ(nexp1,nexp2) + + else: + rfin.s() + + + def normalizediff(self,sf,var): + + + p1=self.L + P1=normalizediff(p1,sf=sf,var=var) + + p2=self.R + P2=normalizediff(p2,sf=sf,var=var) + sf=symbols(sf) + self.e1.ksym=P1 + self.e2.ksym=P2 + self.s() + + + + def fulldiff(self): + + e1= MyFullDiff(self.e1) + self.e1.ksym=unisymbols(e1.ksym) + self.e1.diffvar=get_diffvar(e1) + e2= MyFullDiff(self.e2) + self.e2.ksym=unisymbols(e2.ksym) + self.e2.diffvar=get_diffvar(e2) + self.s() + + + + def diff2(self,*args): + var=self.var + p1=self.L + P1=functiondiffk(p1,var,*args) + p2=self.R + P2=functiondiffk(p2,var,*args) + self.e1.ksym=P1 + self.e2.ksym=P2 + self.s() + + def diff(self,*args): + var=self.var + p1=self.L + ff1=prime2sympy(p1,var,*args) + dff1=diff(ff1,var) + p2=self.R + ff2=prime2sympy(p2,var,*args) + dff2=diff(ff2,var) + self.e1.ksym=sympyEq2prime(dff1,var,*args) + self.e2.ksym=sympyEq2prime(dff2,var,*args) + self.s() + + def hightdiff(self,vec1='',vec2='',*args): + var=self.var + if vec1!='': + ksym1=self.L + if type(vec1)!=list: + vec1=[vec1] + kres=hightdiff(ksym1,var,*vec1) + if 'nview' in args: + kres=sympyEq2prime(kres,var,*vec1) + self.e1.ksym=kres + if vec2!='': + ksym2=self.R + if type(vec2)!=list: + vec2=[vec2] + kres=hightdiff(ksym2,var,*vec2) + if 'nview' in args: + kres=sympyEq2prime(kres,var,*vec2) + self.e2.ksym=kres + self.s() + def maximize(self,kope=''): + var2=self.var2 + kres=diff(self.right,self.var2) + kres=simplify(kres) + kres=reduFac(kres) + try: + e1=MyEq(kres,kshow=False) + e1.reduFac(kshow=False) + kres=e1.ksym + except: + pass + kres=solve(kres,self.var2) + kres2=[] + for i in kres: + sres=str(i) + if not 'I' in sres: + kres2.append(i) + kres=kres2 + if len(kres)==1: + for i in kres: + MyEq(i,str(var2)) + self.evalue(var2,i) + else: + cc=0 + cc2=0 + qq=len(kres) + fres=self.evalue(var2,kres[0],kshow=False) + for i in range(qq): + ik=kres[i] + val=self.evalue(var2,ik,kshow=False) + val2=val + try: + val=float(val) + except: + pass + if val>fres: + fres=val + cc2=cc + val3=val + cc+=1 + + + MyEq(kres[cc2],str(var2),kope=kope) + self.evalue(var2,opemat(kres[cc2]),kope) + + + def apply_chainRuler(self): + kres1=self.left + try: + kres1=simplify_chain_rule(kres1) + self.e1.ksym=kres1 + except: + pass + + kres2=self.right + try: + kres2=simplify_chain_rule(kres2) + self.e2.ksym=kres2 + except: + pass + self.s() + + + def coef_list(self,var=x): + p1=self.L + p2=self.R + P=p1-p2 + vec=coef_list(P,var) + return vec + + + + ######################################### + # MyEqEq Integral + ########################################## + def mode_integral(self,kname='',kside='LR'): + if 'L' in kside: + p1=self.left + if type(p1)==Derivative: + p1= integrate(self.left) + else: + p1=Integral(p1,self.var0) + self.e1.ksym=p1 + + if 'R' in kside : + p2=self.right + if type(p2)==Derivative: + p2= integrate(self.left) + else: + p2=Integral(p2,self.var2) + self.e2.ksym=p2 + + if kname!='': + kname2=kname + kname2=MyEq(self.right,kname,var2=self.var2) + return kname2 + else: + self.s() + + def applyIntegral(self ): + + kname='' + p1=self.left + if type(p1)==Derivative: + p1=Integral(integrate(Q2.left)) + else: + p1=Integral(p1,self.vmain) + p2=self.right + if type(p2)==Derivative: + p2=Integral(integrate(Q1.right)) + else: + p2=Integral(p2,self.var2) + + self.e1.ksym=p1 + self.e2.ksym=p2 + self.s() + + + def separe_dif(self): + var1=self.vmain + name1='d'+str(var1) + + + var2=self.var2 + name2='d'+str(var2) + + d1=symbols(name1) + d2=symbols(name2) + + self.e1.ksym=d1/self.right + self.e1.var2=var1 + self.e2.ksym=d2 + self.e2.var2=var2 + self.type='eS' + self.s() + + def eQinteger(self,var1,var2): + d1='d'+str(var1) + d2='d'+str(var2) + + d1=symbols(d1) + d2=symbols(d2) + p1=self.L + try: + p1=p1.subs(d1,1) + except: + pass + p2=self.R + try: + p2=p2.subs(d2,1) + except: + pass + if Is_Number(p1): + Q1=MyEq(p1*var1,'Q1',var=var1,kshow=False) + else: + Q1=MyIntg(p1,'Q1',var=var1,kshow=False) + + if Is_Number(p2): + Q2=MyEq(p2*var2+C1 ,'Q2',var=var2,kshow=False) + else: + Q2=MyIntg(p2,'Q2',var=var2,kshow=False) + + return MQ(Q1,Q2) + + # def integrate(self,var1=y,var2=x): + # P1=self.L + # P2=self.R + # v1,v2=varDiff(str(var1),str(var2)) + # P1=P1.subs(v1,1) + # P2=P2.subs(v2,1) + # sv1='d'+str(v1) + # sv2='d'+str(v2) + # P1=P1.subs(sv1,1) + # P2=P2.subs(sv2,1) + # ee1=MyIntg(P1,'ee1',var=var1,kshow=False) + # ee2=MyIntg(P2,'ee2',var=var2,kshow=False) + # self.e1.ksym=ee1.ksym + # self.e1.type='I' + # self.e1.var=var1 + # self.e2.ksym=ee2.ksym + # self.e2.var=var2 + # self.e2.type='I' + # self.s() + + + def factorinte(self,*args): + kfac=args[0] + op='RL' + if 'L'in args: + op='L' + if 'R' in args: + op='R' + p1=self.L + if 'L' in op: + kres=factorinte(p1,kfac) + self.e1.ksym=kres + p2=self.R + if 'R' in op: + kres=factorinte(p2,kfac) + self.e2.ksym=kres + self.s() + + + def integral(self,var1='',var2=''): + sd1=str(var1)+"'" + sd2=str(var2)+"'" + p1=self.L + if var1=='': + iP1=integrate(p1) + else: + p1=p1.subs(sd1,1) + iP1=creteInt(p1,var1) + p2=self.R + if var2=='': + iP2=integrate(p2) + else: + p2=p2.subs(sd2,1) + iP2=creteInt(p2,var2) + + + + try: + ip1=ip1.subs('C1',0) + except: + pass + + + self.e1.ksym=iP1 + self.e2.ksym=iP2 + + + self.e1.type='I' + # self.e1.var=var1 + # self.e2.ksym=ee2.ksym + # self.e2.var=var2 + self.e2.type='I' + self.s() + + + + + def IntegralEq(self,v1='',v2=''): + + x=self.vmain + t=self.var2 + dx=symbol2diff(x,t) + d2x=symbol2diff2(x,t) + p1=self.left + p1=p1.subs(dx,1) + p2=self.right + p2=p2.subs(dx,1) + v11=self.vmain + + if v1!='': + v11=v1 + + v22=self.var2 + if v2!='': + v22=v2 + v11=symbols(str(v11)) + v22=symbols(str(v22)) + p1=func2symbol(p1,self.vmain,self.var2) + p2=func2symbol(p2,self.vmain,self.var2) + if Is_Poly(p1): + mm=0 + for i in fpoly(p1,'list'): + kk=MyEq(i,'',var2=v11,ktype='I',kshow=False) + mm=mm+kk.ksym + p1=mm + else: + kk=MyEq(p1,'p1',var2=v11,ktype='I',kshow=False) + p1=kk.ksym + if Is_Poly(p2): + mm=0 + for i in fpoly(p2,'list'): + kk=MyEq(i,'',var2=v11,ktype='I',kshow=False) + mm=mm+kk.ksym + p2=mm + else: + kk=MyEq(p2,'p2',var2=v22,ktype='I',kshow=False) + p2=kk.ksym + + + self.e1.ksym=p1 + self.e2.ksym=p2 + + self.s() + + # def Integral(self,*args): + + # var21=symbols(args[0]) + # var22=symbols(args[1]) + # # clean + # nd1= 'd'+args[0] + # nd2= 'd'+args[1] + # e1s=str(self.left) + # e1s=e1s.replace(nd1,'1') + # e1s=e1s.replace(nd2,'1') + + # self.e1.ksym=parse_expr(e1s) + + # e2s=str(self.right) + # e2s=e2s.replace(nd1,'1') + # e2s=e2s.replace(nd2,'1') + + # self.e2.ksym=parse_expr(e2s) + # self.s(kshow=False) + + # p1=self.left + # p2=self.right + # x1='' + # x2=0 + # if len(args)==4: + # x1=args[2] + # x2=args[3] + # ne1=MyEq(p1,'e1',var2=var21,x1=x1,x2=x2,ktype='I',kshow=False) + # ne2=MyEq(p2,'e2',var2=var22,x1=x1,x2=x2,ktype='I',kshow=False) + # else: + + # ne1=MyEq(p1,'e1',var2=var21,ktype='Ix2x2',kshow=False) + # ne2=MyEq(p2,'e2',var2=var22,ktype='I',kshow=False) + + + # self.e1=ne1 + # self.e2=ne2 + # self.s() + + + def dointegral(self,*args): + data1='' + data2='' + var1=x + var2=t + x1=0 + x2=x + y1=0 + y2=t + done1=True + done2=True + if len(args)==2 and type(args[0])==Symbol: + + var1=args[0] + x2=var1 + var2=args[1] + y2=var2 + for i in args: + if type(i)==Symbol: + if done1: + var1=i + done1=False + else: + var2=i + + if type(i)==tuple: + if done2: + var1,x1,x2=i + done2=False + else: + var2,y1,y2=i + p1=sympify(self.L) + p2=parse_expr(str(self.e2.ksym)) + self.e1.ksym=Integral(p1,(var1,x1,x2)) + self.e2.ksym=Integral(p2,(var2,y1,y2)) + + self.s() + + + + + + def doit(self,op='RL'): + p1=self.L + if 'L' in op: + p1=p1.doit() + p2=self.R + if 'R' in op: + p2=p2.doit() + try: + if self.e2.type=='I': + newC=self.vecCC[self.CC] + self.CC=self.CC+1 + p2=p2+newC + except: + pass + self.updatee(p1,p2) + self.s() + + def doitI(self,*args): + exp1=self.e1.ksym + var1=self.e1.var + kres1=exp1.doit() + exp2=self.e2.ksym + var2=self.e2.var + kres2=exp2.doit() + self.e1.ksym=kres1 + self.e1.type='P' + self.e2.ksym=kres2+C1 + self.e2.type='P' + + self.s() + + ######################################### + # algebrate transformation + ######################################### + + def transformada(self,expr0,ssym,kope='LR'): + if 'L' in kope: + p1=self.L + try: + p1=transformada(p1,expr0=expr0,ssym=ssym,kope=kope) + except: + pass + self.e1.ksym=p1 + if 'R' in kope: + p2=self.R + try: + p2=transformada(p2,expr0=expr0,ssym=ssym,kope=kope) + except: + pass + self.e2.ksym=p2 + + self.s() + + def format(self,qn,kshow): + p1=self.L + p2=self.R + try: + kres1=format(p1,qn) + self.e1.ksym=kres1 + except: + pass + try: + kres3=format(p2,qn) + self.e2.ksym=kres2 + except: + pass + + if kshow: + self.s() + + def subsubs(self,*args,force=False,op='LR'): + if len(args)==0: + helplib('subsubs') + return + expr1=args[0] + expr2=args[1] + + if 'L' in op: + expr=self.e1.ksym + expr=subsubs(expr,expr1,expr2,force=force) + self.e1.ksym=expr + + if 'R' in op: + expr=self.e2.ksym + expr=subsubs(expr,expr1,expr2,force=force) + self.e2.ksym=expr + self.s() + + def subsnumber(self,val1,val2): + + + p1=self.left + p1=subsnumber(p1,val1,val2) + self.e1.ksym=p1 + + p2=self.right + p2=subsnumber(p2,val1,val2) + self.e2.ksym=p2 + self.s() + + def subs(self,*args,kshow=True): + val1,val2=args[0],args[1] + + p1=self.left + try: + p1=p1.subs(val1,val2) + self.e1.ksym=p1 + except: + pass + + + p2=self.right + try: + p2=p2.subs(val1,val2) + self.e2.ksym=p2 + except: + pass + if kshow: + self.s() + def sortdegree(self,var='LR',kope=''): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + kside='LR' + if type(var)==str: + kside=var + + + if type(var)!=str: + var2=var + else: + var2=x + if 'L' in kside: + p1=self.left + p1=sortdegree(p1,var2=var2) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=sortdegree(p2,var2=var2) + self.e2.ksym=p2 + self.s() + + def powexpand(self,args): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + op='' + kside='LR' + for i in args: + if type(i)==str: + kside=i + if type(i)==Symbol: + op=i + if 'L' in kside: + p1=self.left + p1=powexpand(p1,op=op) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=powexpand(p2,op=op) + self.e2.ksym=p2 + self.s() + + def opematexp(self,kside='LR',kope=''): + ''' + apply opemat only in exponent monomie + ''' + if 'L' in kside: + p1=self.left + p1=opematexp(p1,kope=kope) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=opematexp(p2,kope=kope) + self.e2.ksym=p2 + self.s() + + def mulexpo(self,kside='LR'): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + if 'L' in kside: + p1=self.left + p1=mulexpo(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=mulexpo(p2) + self.e2.ksym=p2 + self.s() + + + def packexp(self,kside='LR'): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + if 'L' in kside: + p1=self.left + p1=packexp(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=packexp(p2) + self.e2.ksym=p2 + self.s() + + + + def base2frac(self,kside='LR'): + + if 'L' in kside: + p1=self.left + p1=base2frac(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=base2frac(p2) + self.e2.ksym=p2 + self.s() + + + + def expandexp(self,kside='LR'): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + if 'L' in kside: + p1=self.left + p1=expandexp(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=expandexp(p2) + self.e2.ksym=p2 + self.s() + + def factorexpo(self,*args): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + + if 'right' not in args: + + p1=self.left + sp1=str(factorexpo(p1)) + + self.e1.ksym=parse_expr(sp1,evaluate=False) + + if 'left' not in args: + p2=self.right + sp2=str(factorexpo(p2)) + + self.e2.ksym=parse_expr(sp2,evaluate=False) + + self.s() + def disjoinbase(self,kside='LR'): + P1=self.e1.ksym + P2=self.e2.ksym + if 'L' in kside: + P1=separebase(P1) + if 'R' in kside: + P2=separebase(P2) + self.e1.ksym=P1 + self.e2.ksym=P2 + self.s() + + def joinbase(self,kside='LR'): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + if 'L' in kside: + p1=self.left + p1=joinbase(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=joinbase(p2) + self.e2.ksym=p2 + self.s() + def disjoinexpo(self,kside='LR'): + if 'L' in kside: + p1=self.left + p1=disjoinexpo(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=disjoinexpo(p2) + self.e2.ksym=p2 + self.s() + def joinexpo(self,kside='LR'): + if 'L' in kside: + p1=self.left + p1=joinexpo(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=joinexpo(p2) + self.e2.ksym=p2 + self.s() + def separebase(self,kside='LR'): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + if 'L' in kside: + p1=self.left + p1=separebase(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=separebase(p2) + self.e2.ksym=p2 + self.s() + + def sum2mulexpo(self,kside='LR'): + ''' + input (x**a)**b + return(x**(a*b)) + ''' + if 'L' in kside: + p1=self.left + p1=sum2mulexpo(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=sum2mulexpo(p2) + self.e2.ksym=p2 + self.s() + def factorize(self,kval,kside='LR'): + if 'L' in kside: + p1=self.left + p1=factorize(p1,kval) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=factorize(p2,kval) + self.e2.ksym=p2 + self.s() + + def factoriza(self,kval,kside='LR'): + if 'L' in kside: + p1=self.left + p1=factoriza(p1,kval) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=factoriza(p2,kval) + self.e2.ksym=p2 + self.s() + + def killsqrtpow(self,kside='LR'): + if 'L' in kside: + p1=self.left + p1=killsqrtpow(p1) + self.e1.ksym=p1 + if 'R' in kside: + p2=self.right + p2=killsqrtpow(p2) + self.e2.ksym=p2 + self.s() + + + def killroot(self): + p1=self.left + p11=simplify_root_exp(p1) + p2=self.right + p22=simplify_root_exp(p2) + self.e1.ksym=p11 + self.e2.ksym=p22 + + self.s() + def killRootPow(self): + p1=self.left + p11=kill_RootPow(p1) + if str(p1)!=str(p11): + self.e1.ksym=p11 + p2=self.right + p22=kill_RootPow(p2) + if str(p2)!=str(p22): + self.e2.ksym=p22 + self.s() + + + def par_frac(self,var=''): + self.e1.par_frac(var=var,kshow=False) + self.e2.par_frac(var=var,kshow=False) + self.s() + + def apply(self,sexpr): + p1=self.e1.ksym + kres1=apply(p1,sexpr) + self.e1.ksym=kres1 + p2=self.e2.ksym + kres2=apply(p2,sexpr) + self.e2.ksym=kres2 + self.s() + def simple_linear(self): + if self.e1.Is_Mono() and self.e2.Is_Mono(): + p1=self.e1.get_nume() + p2=self.e1.get_deno() + p3=self.e2.get_nume() + p4=self.e2.get_deno() + self.e1.ksym=p1/p3 + self.e2.ksym=p2*p4 + mm=fpoly(self.left,'list') + if -1 in mm: + self.Mul(-1) + else: + self.s() + + + def crossmul(self,kshow=True): + p1=factor(self.L) + n1=numer(p1) + d1=denom(p1) + p2=factor(self.R) + n2=numer(p2) + d2=denom(p2) + self.e1.ksym=n1*d2 + self.e2.ksym=n2*d1 + if kshow: + self.s() + + + + + def crossMul(self,*args): + P1=self.L + P2=self.R + if Is_Div(P1): + pa1,pa2=fraction(P1) + else: + pa1,pa2=P1,1 + if Is_Div(P2): + pb1,pb2=fraction(P2) + else: + pb1,pb2=P2,1 + + + Px=unisymbols(pa1*pb2) + Py=unisymbols(pb1*pa2) + + + + Px=premath(Px,*args) + Py=premath(Py,*args) + + + self.e1.ksym=Px + self.e2.ksym=Py + + self.s() + + + +tau,psi,omega=symbols('tau psi omega') +varT=[tau,psi,omega] + + +def eQtools(ee,op=0): + nvar=varT[op] + return MQ(nvar,ee) +def real_subs6(QQ,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + + vvar=fpoly(QQ,'free') + mvar=[] + for i in vvar: + nname=str(i) + nname=nname.replace('_','') + nvar=symbols(nname) + mvar.append(nvar) + + kres=QQ + sres=str(kres) + sres=sres.replace('_','') + kres=parse_expr(sres) + mkey=[] + vvalue=[] + for key, value in kwargs.items(): + mkey.append(key) + if type(value)==MyEq: + vvalue.append(value.ksym) + else: + vvalue.append(value) + + kres=kres.subs(parse_expr(key),value) + for i,j in zip(mvar,vvar): + kres=kres.subs(i,j) + return (kres) + +def real_subs(expr,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + if len(kwargs)>0: + key,value=unpack(kwargs) + kres=expr + for i,j in zip(key,value): + jj=j + if type(j)==MyEq: + jj=j.ksym + kres=kres.subs(i,j) + if len(i)>1: + newi=i[0]+'_'+i[1::] + try: + kres=kres.subs(newi,j) + except: + pass + + return kres + else: + return expr + +def symbol_subs(expr,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + if len(kwargs)>0: + key,value=unpack(kwargs) + kres=expr + sres=str(kres) + for i,j in zip(key,value): + jj=j + sjj=str(j) + if type(j)==MyEq: + jj=j.ksym + sjj=str(j.ksym) + kres=kres.subs(i,j) + sres=sres.replace(str(i),str(j)) + + if len(i)>1: + newi=i[0]+'_'+i[1::] + try: + kres=kres.subs(newi,j) + sres=sres.replace(str(newi),str(j)) + except: + pass + + return parse_expr(sres,evaluate=False) + else: + return expr + +def varDiff(*args): + mm=[] + for i in args: + + k=symbols(i+"'") + mm.append(k) + return(mm) +def varDiff2(*args): + mm=[] + for i in args: + + k=symbols(i+"''") + mm.append(k) + return(mm) + +def nice_iq_symbol(ksymbol): + if ksymbol=='>=' or ksymbol=='=>': + return '≥' + elif ksymbol=='<=' or ksymbol=='=<': + return '≤' + else: + return ksymbol + + +def apply(expr,sexpr): + sres=str(expr) + sres=sexpr+'('+sres+')' + return parse_expr(sres) + +def getops(*args): + ops='LR' + kshow=True + if len(args)>0: + if 'L' in args and not 'R' in args: + ops='L' + elif 'R' in args and not 'L' in args: + ops='R' + else: + ops='LR' + if 'noshow' in args: + kshow=False + return ops,kshow + + +def datacoeff(data,var=x): + if type(data)==list: + return data + elif type(data)==MyEq: + return coef_list(data.ksym,var) + else: + return coef_list(data,var) + +def solvecomparecoef(*args): + val1=args[0] + if type(val1)==MyEqEq: + var=args[1] + vsol=args[2] + p1=coef_list(val1.L,var) + p2=coef_list(val1.R,var) + if type(vsol)!=list: + qq=len(args) + Vsol=[] + for i in args[2::]: + Vsol.append(i) + else: + Vsol=vsol + else: + var=args[2] + p1=datacoeff(args[0],var) + p2=datacoeff(args[1],var) + vsol=args[3] + if type(vsol)!=list: + qq=len(args) + Vsol=[] + for i in args[3::]: + Vsol.append(i) + else: + Vsol=vsol + + + + kres= solve_compare_coef(p1,p2,Vsol) + for i,j in zip(Vsol,kres): + display(Math((latex(i)+'= '+latex(j)))) + #display(Math(latex(i)+'= '+latex(j))) + if len(kres)==1: + kres=kres[0] + + return kres + +def edit_primitive(eQ,F): + expr1=eQ.get_primitive() + Q=MyEqEq(F,expr1) + return Q + +def reparte_param(vecop,*args): + vecexpr=[] + kname='' + op='RL' + for i in args: + if type(i)==str and i not in vecop: + kname=i + if type(i)!=str: + vecexpr.append(i) + if 'R' in args: + op='R' + if 'L' in args: + op='L' + if len(vecexpr)==1: + kres=vecexpr[0] + if type(kres)==MyEqEq: + expr1,expr2=kres.L,kres.R + elif type(kres)==MyEq: + expr1,expr2=kres.ksym,kres.ksym + else: + expr1,expr2=kres,kres + + return expr1,expr2,kname,op + + + +def fes(expr,*args): + + if 'factor' in args: + expr=factor(expr) + if 'simplify' in args: + expr=simplify(expr) + if 'expand' in args: + expr=expand(expr) + return expr + +#### tools Argssss + +vecreatr=["","","","",""] +def ruta(expr,infoexpr,infopos,cc): + mm=expr.args + if len(mm)>0: + for i in range(len(mm)): + nexp=mm[i] + npos=cc+str(i) + + if nexp not in infoexpr: + if str(type(nexp)) not in vecreatr : + if nexp not in infoexpr: + if not Is_Number(nexp): + + infoexpr.append(nexp) + infopos.append(npos) + try: + nexp,ninfo,ncc=ruta(nexp,infoexpr,infopos,npos) + return nexp,ninfo,ncc + except: + pass + return expr,infoexpr,infopos,cc + else: + return expr,infoexpr,infopos,cc + +def str2vec(sexpr): + kvec=[] + for i in sexpr: + kvec.append(int(i)) + return kvec + + +def filterNegPos(vecd,vecp): + NegMon=[] + NegPos=[] + OthMon=[] + OthPos=[] + for i,j in zip(vecd,vecp): + if Is_NMono(i): + NegMon.append(i) + NegPos.append(j) + else: + OthMon.append(i) + OthPos.append(j) + for i,j in zip(OthMon,OthPos): + if (-1*i) not in NegMon: + NegMon.append(i) + NegPos.append(j) + return NegMon,NegPos + + + + + +def realsub2(expr,**kwargs): + vecs,vecv=unpack(kwargs) + for i,j in zip(vecs,vecv): + newj=j + if type(j)==MyEq: + newj=j.ksym + + if i in nombresdiferen: + expr=expr.subs(eval(i),newj) + + else: + expr=expr.subs(i,j) + return expr + + +def argsmap (expr,kname='A',deep=2,data=False,side=''): + infoexpr=[] + infopos=[] + cc='' + A,B,C,D=ruta(expr,infoexpr,infopos,cc) + mapval=[] + mappos=[] + for i,j in zip(B,C): + if Is_Div(i): + if numer(i)!=1: + mapval.append(i) + mappos.append(j) + + else: + mapval.append(i) + mappos.append(j) + + mapval,mappos=filterNegPos(mapval,mappos) + if side!='': + mapL=[side+i for i in mappos] + mappos=mapL + + if len(mapval)==0: + return + if data: + return mapval,mappos + svecargs=[] + sres='' + superres='' + if kname!='': + + for i in mappos: + sres=kname+'.args(' + for k in i: + sres=sres+k+',' + sres=sres[0:-1] + sres=sres+')=' + svecargs.append(sres) + mm='' + for i,j in zip(svecargs,mapval): + mm=mm+ " "+'['+i+latex(j)+'],' + display(Math(mm)) +class MySys(MyEqEq): + def __init__(self, *args,kshow=True): + S=[] + for i in args: + S.append(i) + i.insys=self + self.S=S + cc=1 + for i in self.S: + p1=i.e1.ksym + p2=i.e2.ksym + ps=i.symb + ps2='Q'+str(cc)+' :' + display(Math(ps2+latex(p1)+' '+ps+' '+latex(p2))) + cc=cc+1 + def __call__(self,*args, **kwargs): + pass + def __repr__(self): + return '' + def s2(self): + for i in self.S: + i.s() + + def s(self): + cc=1 + for i in self.S: + p1=i.e1.ksym + p2=i.e2.ksym + ps=i.symb + ps2='Q'+str(cc)+' :' + display(Math(ps2+latex(p1)+' '+ps+' '+latex(p2))) + cc=cc+1 + def factor(self,kshow=True): + S2=[] + for i in range(len(self.S)): + kres=self.S[i] + kres.factor(kshow=False) + S2.append(kres) + self.S=S2 + if kshow: + self.s() + def subs(self,*args,kshow=True): + S2=[] + vecs=self.S + for i in range(len(self.S)): + kres=vecs[i] + kres.subs(*args,kshow=False) + if kres.L!=kres.R: + S2.append(kres) + self.S=S2 + if kshow: + self.s() + def simplesolve(self,*args): + S2=self.S + if len(args)>0: + for i in args: + S2.append(i) + return simplesolve(*S2) + +class MyCelule(MyEqEq): + + def __init__(self, *args,kshow=True): + op=['MQ','EQ'] + vece=[] + vecn=[] + kname='' + self.sp1=args[0] + self.sp2=args[1] + if len(args)>2: + for i in range(2,len(args)): + kres=args[i] + vece.append(kres) + vecn.append(kres.name) + self.vece=vece + self.vecn=vecn + #self.Q=MQ(eval(self.sp1),eval(self.sp2)) + for i in self.vece: + i.link=self + self.e1=MyEq(eval(self.sp1),'e1',kshow=False) + self.e2=MyEq(eval(self.sp2),'e2',kshow=False) + p1=self.e1.ksym + p2=self.e2.ksym + ps='=' + if kshow: + display(Eq(self.e1.ksym,self.e2.ksym)) + def s(self): + self.e1=MyEq(eval(self.sp1),'e1',var=var,kshow=False) + self.e2=MyEq(eval(self.sp2),'e2',var=var,kshow=False) + + ps='=' + display(Math(latex(p1)+' '+ps+' '+latex(p2))) + +def getdatain(*args): + kdata=[ i for i in args if type(i)!=str] + expr=kdata[0] + if type(expr)==MyEqEq: + return expr.L,expr.R + elif type(expr)==MyEq: + return expr.ksym,expr.ksym + else: + return expr,expr + +def doinRL(P1,P2,thisL,thisR,*args): + if 'R' not in args: + P1=thisL + P1=premath(P1,*args) + + if 'L' not in args: + P2=thisR + P2=premath(P2,*args) + + return P1,P2 + +def get_ksym(obj): + if type(obj)==MyEqEq: + return(obj.L-obj.R) + elif type(obj)==MyEq: + return obj.ksym + elif type(obj)==str: + return parse_expr(obj) + else: + return obj +def obj2MyEq(obj,var=x): + ksym=get_ksym(obj) + ee=MyEq(ksym,'ee',var=var,kshow=False) + return ee + +def datadiff(var,*args): + ''' + var=main var t + args=[x,y]= x(t),y(t) + Vs=['x','y'] + Vn=[x,y] + Vf=[x(t),y(t)] + Vd=[dxt,dyt] + Vd2=[dx2t,dy2t] + Pd=[x',y'] + Pd2=[x'',y''] + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2 =[],[],[],[],[],[],[] + P1,P2=[],[] + for i in args: + Vs.append(str(i)) + Vn.append(i) + for i in Vs: + Vf.append(Function(i)(var)) + for i in Vf: + Vd.append(i.diff(var)) + Vd2.append(i.diff(var,var)) + for i in Vn: + Pd.append(symboldiff(i)) + Pd2.append(symboldiff2(i)) + + return Vs,Vn,Vf,Vd,Vd2,Pd,Pd2 + +def hightfunc(expr,var,*args): + ''' + expr=pi*h*r*r*t/3 + var=t + args=h,r + return pi*t*h(t)*r(t)**2/3 + ''' + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vn,Vf): + expr=subsubs(expr,i,j) + return expr + +def hightdiff(expr,var,*args): + ''' + expr=pi*h*r*r*t/3 + var=t + args=h,r + return 2*pi*t*h(t)*r(t)*Derivative(r(t), t)/3 + pi*t*r(t)**2*Derivative(h(t), t)/3 + + pi*h(t)*r(t)**2/3 + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vn,Vf): + expr=subsubs(expr,i,j) + return diff(expr,t) + +def sympyEq2prime(expr,var,*args): + ''' + return expr diff sympy expr whith diff prime symbols + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vd2,Pd2): + expr=expr.subs(i,j) + for i,j in zip(Vd,Pd): + expr=expr.subs(i,j) + for i,j in zip(Vf,Vn): + expr=expr.subs(i,j) + return expr + +def symboldiff(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"'" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff(i)) + return mm + +def symboldiff2(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"''" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff2(i)) + return mm + +def functiondiffk(expr,var,*args): + ''' + if Area= b*h/2 in function of time... + then A(t)=b(t)*h(t)/2... + input : functiondiff(expr, var, varF1, varF2,varF3...etc) + in this case: + A=functiondiff(A,t,A) = dA + R=functiondiff(b*h/2,t,b,h) = b*dh/2 + db*h/2 + + ''' + if len(args)==0: + return diff(expr,var) + else: + v1=[] + for i in args: + v1.append(i) + v2=[] + cc=1 + for i in v1: + F='f'+str(i) + F=Function(str(i))(var) + v2.append(F) + cc=cc+1 + v3=[] + for i in v2: + v3.append(diff(i,var)) + v4=[] + for i in v3: + v4.append(str(i)) + v5=[] + for i in v1: + svar='d'+alphaname(i) + svar=symbols(svar) + v5.append(svar) + + + for i,j in zip(v1,v2): + expr=expr.subs(i,j) + dexpr=diff(expr,var) + for i,j in zip(v3,v5): + dexpr=dexpr.subs(i,j) + for i,j in zip(v2,v1): + dexpr=dexpr.subs(i,j) + return dexpr \ No newline at end of file diff --git a/Libaldo/lib_MyIntegral.py b/Libaldo/lib_MyIntegral.py new file mode 100644 index 0000000..8cc1c11 --- /dev/null +++ b/Libaldo/lib_MyIntegral.py @@ -0,0 +1,479 @@ + +from sympy import * +from lib_MyEqEq import MyEqEq,MQ +from lib_MyEq import * +from libaldo_math2 import * +import copy + + + + + + + + +from sympy import * + +from IPython.display import Math # ,display +from matplotlib.pyplot import ylabel, plot, show, xlabel, title +from libaldo_math2 import * +from libaldo_algorith import * + +from lib_toolsEq import * +from lib_tools import * +from mathbasic import * + +import copy +import numpy as np +import pandas as pd + +import matplotlib.pyplot as plt +# from lib_Func import * +import dill # pip install dill --user +import pickle +filename = 'workspace.pkl' +x1=symbols('x1') + +def savework(): + dill.dump_session(filename='workspace.pkl') + + +def loadwork(): + dill.load_session(filename='workspace.pkl') + + +# and to load the session again: +def creteInt(expr,var,x1='',x2=''): + if x1=='': + kres=Integral(expr,var) + else: + kres=Integral(expr, (var,x1,x2)) + return kres + +#direx,direy=symbols('\overrightarrow{x} \overrightarrow{y}') +class MyIntg (MyEq): + def __init__(self,expr,name,var=x,x1='',x2='',kshow=True,doit=False): + self.type='I' + self.ksym=obj2expr(expr) + self.name=name + self.x1=getdata(x1) + self.x2=getdata(x2) + self.var=var + self.integral1=creteInt(expr,var,x1=x1,x2=x2) + self.varc=False + self.doit=doit + + if kshow: + display(Math(self.name +'='+ latex(self.integral1))) + def __call__(self,doit=False): + if doit: + kres=self.doit() + else: + kres=self.integral1 + + return kres + + + def __repr__(self): + kres = str(self.ksym) + + return kres + + def _latex(self, obj): + return latex(self.ksym) + + def __str__(self): + return self.__repr__() + def rebuild(self): + self.integral1=creteInt(self.ksym,var=self.var,x1=self.x1,x2=self.x2) + + def s(self): + if self.type=='I': + self.rebuild() + display(Math(self.name +'='+ latex(self.integral1))) + else: + display(Math(self.name +'='+ latex(self.ksym))) + def doit(self,*args): + if self.type=='P': + kres=self.ksym + kres=kres.doit() + + else: + Ires=self.integral1 + kres=Ires.doit() + if 'C' in args: + print(1) + kres=kres+C1 + else: + if 'float' in args: + try: + kres=float(kres) + except: + pass + if 'positive' in args: + kres=signo(kres)*kres + if 'up' in args or 'update' in args: + self.ksym=kres + self.type='P' + self.s() + + else: + return kres + + def insideIntg(self): + return self.ksym + + + + + + def getdiffvar(var): + if var==x: + return dx + if var==y: + return dy + if var==z: + return dz + if var==w: + return dw + if var==v: + return dv + if var==u: + return du + if var==t: + return dt + + def changevar(self,*args): + if len(args)==1: + expr1=self.var + expr2=obj2expr(args[0]) + v1=self.var + v2=list(symbolslist(expr2))[0] + elif len(args)==2: + expr1=args[0] + expr2=args[1] + v1=self.var + v2=list(symbolslist(expr2))[0] + if len(args)==3: + expr1=args[0] + expr2=args[1] + v1=self.var + v2=args[2] + + kres=rulerchain(self.ksym,v1,v2,expr1,expr2) + x1=self.x1 + x2=self.x2 + + + if x1!='': + x1=self.x1 + x2=self.x2 + + Q=MQ(expr1,expr2,render=False) + + + V=Q.solve(v2,kshow=False) + V=obj2expr(V) + xx1=V.subs(v1,x1,kshow=False) + xx2=V.subs(v1,x2,kshow=False) + + self.x1=unisymbols(xx1) + self.x2=unisymbols(xx2) + self.var=v2 + self.ksym=unisymbols(kres) + self.s() + + def Area(self): + f=self.ksym + vecx=xlimitplot(f,self.x1,self.x2) + vecp=vecxzonaplot(f,self.x1,self.x2) + At=0 + qq=len(vecx) + for i in range(qq-1): + + At=At+vecp[i]*creteInt(f,self.var,x1=vecx[i],x2=vecx[i+1]) + self.type='P' + self.ksym=At + self.s() + + + +def rulerchain(expr,v1,v2,expr1,expr2): + ee=MyEq(expr1-expr2,'ee',kshow=False) + V1=ee.solve(v1,kshow=False) + nv1=V1.ksym + newd=diff(nv1,v2) + expr=expr.subs(v1,nv1) + expr=expr*newd + return expr + +class My2Intg (MyEq): + def __init__(self,expr,name,varx,vary,x1='',x2='',y1='',y2='',kshow=True): + self.type='II' + self.ksym=expr + self.name=name + self.x1=x1 + self.x2=x2 + self.varx=varx + self.integral1=creteInt(expr,varx,x1=x1,x2=x2) + + self.vary=vary + self.y1=y1 + self.y2=y2 + self.integral2=creteInt(self.integral1,vary,x1=y1,x2=y2) + + if kshow: + display(Math(name +'='+ latex(self.integral2))) + + def rebuild(self): + self.integral1=creteInt(self.ksym,var=self.varx,x1=self.x1,x2=self.x2) + self.integral2=creteInt(self.integral1,var=self.vary,x1=self.y1,x2=self.y2) + def s(self): + self.rebuild() + display(Math(self.name +'='+ latex(self.integral2))) + def doit(self,kname=''): + kres=self.integral2 + kres=kres.doit() + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return kres + + def firstIntg(self,name=''): + kres=self.ksym + if name!='': + ee=MyIntg(kres,name,self.varx, x1=self.x1,x2=self.x2) + return ee + else: + return self.integral1 + def double2simple(self,expr,name=''): + if name=='': + name=self.name+'_1' + ee=MyIntg(getdataexpr(expr),name,self.vary,x1=self.y1,x2=self.y2) + return ee + + + + + def swapIntegral(self): + x1,x2,y1,y2=self.x1,self.x2,self.y1,self.y2 + var1=self.varx + var2=self.vary + + try: + yy2=x1.subs(var2,y2) + except: + yy2=0 + try: + xx2=simplesolve(x1-var1,var2) + if type(xx2)==list: + xx2=xx2[-1] + if xx2==[]: + xx2=0 + except: + xx2=0 + + try: + yy1=x2.subs(var2,y1) + except: + yy1=0 + try: + xx1=simplesolve(x2-var1,var2) + if type(xx1)==list: + xx1=xx1[-1] + if xx1==[]: + xx1=0 + except: + xx1=0 + + self.x1,self.x2,self.y1,self.y2 =xx1,xx2,yy1,yy2 + self.varx=var2 + self.vary=var1 + self.s() + +class My3Intg (MyEq): + def __init__(self,expr,name,varx,vary,varz,x1='',x2='',y1='',y2='',z1='',z2='',kshow=True): + self.ksym=expr + self.name=name + self.x1=x1 + self.x2=x2 + self.varx=varx + self.integral1=creteInt(expr,varx,x1=x1,x2=x2) + + self.vary=vary + self.y1=y1 + self.y2=y2 + self.integral2=creteInt(self.integral1,vary,x1=y1,x2=y2) + + self.varz=varz + self.z1=z1 + self.z2=z2 + self.integral3=creteInt(self.integral2,varz,x1=z1,x2=z2) + + if kshow: + display(Math(name +'='+ latex(self.integral3))) + + def rebuild(self): + self.integral1=creteInt(self.ksym,var=self.varx,x1=self.x1,x2=self.x2) + self.integral2=creteInt(self.integral1,var=self.vary,x1=self.y1,x2=self.y2) + self.integral3=creteInt(self.integral2,var=self.varz,x1=self.z1,x2=self.z2) + def s(self): + self.rebuild() + display(Math(self.name +'='+ latex(self.integral3))) + def doit(self,kname=''): + kres=self.integral3 + kres=kres.doit() + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return kres + + def firstIntg(self,name=''): + kres=self.ksym + if name!='': + ee=MyIntg(self.ksym,name,self.varx ,x1=self.x1,x2=self.x2) + return ee + else: + return self.integral1 + + def secondIntg(self,name=''): + kres=self.ksym + if name!='': + ee=My2Intg(self.ksym,name,self.varx,self.vary,x1=self.x1,x2=self.x2,y1=self.y1,y2=self.y2) + return ee + else: + return self.integral2 + + def triple2double(self,expr,name=''): + if name=='': + name=self.name + ee=My2Intg(getdataexpr(expr),name,self.vary,self.varz,x1=self.y1,x2=self.y2,y1=self.z1,y2=self.z2) + return ee + def triple2simple(self,expr,name=''): + if name=='': + name=self.name + ee=MyIntg(getdataexpr(expr),name,self.varz,x1=self.z1,x2=self.z2) + return ee + + + def swapIntegral(self): + x1,x2,y1,y2=self.x1,self.x2,self.y1,self.y2 + var1=self.varx + var2=self.vary + + try: + yy2=x1.subs(var2,y2) + except: + yy2=0 + try: + xx2=simplesolve(x1-var1,var2) + if type(xx2)==list: + xx2=xx2[-1] + if xx2==[]: + xx2=0 + except: + xx2=0 + + try: + yy1=x2.subs(var2,y1) + except: + yy1=0 + try: + xx1=simplesolve(x2-var1,var2) + if type(xx1)==list: + xx1=xx1[-1] + if xx1==[]: + xx1=0 + except: + xx1=0 + + self.x1,self.x2,self.y1,self.y2 =xx1,xx2,yy1,yy2 + self.varx=var2 + self.vary=var1 + self.s() + + +def obj2str(obj): + if type(obj)==str: + return obj + elif type(obj)==MyEq: + return str(obj.ksym) + elif type(obj)==MyEqEq: + return str(simplify(expand(obj.L-obj.R))) + else: + return str(obj) +def obj2func(obj): + if type(obj)==str: + return parse_expr(obj) + elif type(obj)==MyEq: + return obj.ksym + elif type(obj)==MyEqEq: + return simplify(expand(obj.L-obj.R)) + else: + return obj + +def obj2expr(obj): + if type(obj)==str: + return parse_expr(obj) + elif type(obj)==MyEq: + return obj.ksym + elif type(obj)==MyEqEq: + return simplify(expand(obj.L-obj.R)) + else: + return obj + +def obj2MyEq(obj,var=x): + obj=obj2func(obj) + ee=MyEq(obj,'ee',var=var,kshow=False) + return ee + +def getinterx(obj,var=x): + ee=obj2MyEq(obj,var=var) + vx=ee.roots(kshow=False) + if 'I' in str(vx) and ee.degree()==3: + vec3=ee.coef_list() + vx= list(solve3(*vec3)) + vx2=[] + for i in vx: + if not 'I' in str(i): + vx2.append(i) + + return vx2 + +def zonegraph(f,x1,x2): + expr=obj2expr(f) + x3=(x2+x1)/2 + ee=obj2MyEq(f) + kres=float(simplify(ee(x3))) + + if kres<0: + return -1 + elif kres>0: + return 1 + else: + return 0 + +def xlimitplot(obj,x1,x2): + obj=obj2expr(obj) + vecx=getinterx(obj) + vecp=[x1,x2] + for i in vecx: + if i>x1 and i(x1,y1),v1D:\Libaldo\SolveLib\Fin_F\physic_lib.py + self.y1=y1 # y1 + self.v1=v1 # v1 + self.x2=x2 # x2 finish Point >(x2,y12),v2 + self.y2=y2 # y2 + self.v2=v2 # v2 + self.v=v # Initial Velocity , important in parabolic + self.a=sex2rad_i(a,s) # in parabolic is the shooting angle + self.ac=ac # ac=X acceleration, set ac=0, in parabolic case + self.r=r # Radio in circular movements + self.r1=r1 + self.r2=r2 + self.F=[] #matriz de fuerzas + self.cG=[] # Centro de Gravedad + self.cI=[] # Inerce points + self.Fc=[] # Fuerzas circulares + self.kvalue=([],[]) + self.kvaluen=([],[]) + self.t=t + self.M=[] + self.CG=[] + self.vx=vx + if vx=='': + self.vx=self.v1*cos(self.a) + self.vy=vy + if vy=='': + self.vy=self.v1*sin(self.a) + self.vxy=vxy + self.w=w + self.Po=Po + self.Ti=Ti + self.I_n=Io + self.In=Io + self.Io=Io + self.aw=aw + self.aw=aw + self.ac=ac + self.at=at + self.xI=xI + self.Ima=[] + self.w1=w1 + self.w2=w2 + self.ax=ax + self.ay=ay + self.typeI=typeI + self.mu=mu + self.Nm=Nm + self.dire=dire + self.direx=direx + self.direy=direy + self.vv=vv + self.deltat=deltat + self.posx=posx + self.posy=posy + self.dt=dt + self.Ma=Ma + + + def add_geoforza(self,kmg,kR,a1,a2=0): # ******** Manage Variables ********** + # add_geoforza(Fval,polar ang,angulo whit radio Polar) + xx,yy= polar2xy(kR,a1,op='') + self.add_forza(kmg,a1+a2,xx,yy) + #print(kmg,a2+a3,xx,yy) + + def add_uni_forza(self,U=1,x1=0,y1=0,x2=0 ,y2=0): # (unitare Value,x1,y1,x2,y2) + # add_geoforza(Fval,polar ang,angulo whit radio Polar) + Fx=U*(x2-x1) + self.add_forza(Fx,0) + Fy=U*(y2-y1) + self.add_forza(Fy,pi/2) + #print(kmg,a2+a3,xx,yy) + + def add_forzaP(self,kmg,kang,kR,aRx): + # add_add_pol_forza(Fvalue,angle whit x,Radio,angle Radio x) + xx,yy= polar2xy(kR,aRx) + self.add_forza(kmg,kang,xx,yy) + #print(kmg,a2+a3,xx,yy) + + def addF(self,*args): + mm=[] + mmpar=[] + mmF=self.F + if type(args[0])!=tuple: + for i in args: + mmpar.append(i) + mm.append(mmpar) + else: + for i in args: + mm.append(i) + for i in mm: + if len(i)==2: + kval,kang=i + x=0 + y=0 + mmF.append([kval,kang,x,y]) + else: + kval,kang,x,y=i + mmF.append([kval,kang,x,y]) + + + + + def add(self,*args): + adire=self.dire + done=True + for i in args: + if done: + vv=i + done=False + else: + done=True + self.add_forza(vv,i) + + + + ''' + def add_vector2(self,x=0,y=0,vx=0,vy=0,ang=0): + + x=0,y=0,vx=0,vy=0 + if vx==0 and vy==0: + self.add_forza(mag,ang,x=x,y=y) + else: + self.add_forza(vx,0,x=x,y=y) + self.add_forza(vy,pi/2,x=x,y=y) + ''' + def add_vector(self,*args,ang=0): + ''' + add_vector(x1,y1,x2,y2) + add_vector(x1,y1,magnitud,ang=alpha) + ''' + if len(args)==2: + vx=args[0] + vy=args[1] + x=0 + y=0 + self.add_forza(vx,0,x=x,y=y) + self.add_forza(vy,pi/2,x=x,y=y) + + + elif len(args)==4: + x,y,vx,vy=args + self.add_forza(vx,0,x=x,y=y) + self.add_forza(vy,pi/2,x=x,y=y) + + else: + self.add_forza(args[2],ang,x=args[0],y=args[1]) + + def add_forza(self, kval,kang,x=0,y=0,s='r'): + # fl=self.F + # mm=[ x[0] for x in fl] + # mm=unisymbols(mm) + # if unisymbols(kval) not in mm or krep==True: + + # if s=='s': + # kang=sex2rad(kang) + mm=self.F + + mm.append([kval,kang,x,y]) + self.F=mm + + + def add_weight(self,xx=0,yy=0): # is tha same that add_forza(m*g,-pi/2) + mm=self.m + gg=self.g + ww=mm*gg + self.add_forza(ww,-pi/2,xx,yy) + def add_normal(self,ang=''): # is tha same that add_forza(m*g,-pi/2) + mm=self.m + gg=self.g + ww=mm*gg + if ang=='': + ang=pi/2 + self.add_forza(N1,-pi/2) + + def add_inercia(self,In1,mm=0,rr2=0): + In2=self.I_n + if In2==Io: + In2=0 + In2+=In1+mm*rr2*rr2 + + self.I_n=In2 + self.Io=self.I_n + def get_inercia(self): + return self.I_n + + def add_Inerce(self,mm='',rr='',L=0,ktype='p'): + if mm!='': + self.m=mm + if rr!='': + self.r=rr + if ktype!='p': + kres=self.setIner(ktype) + + kres= self.setIner(ktype)+mm*L*L + vecCi=self.cI + vecCi.append(kres) + self.cI=vecCi + + def addCG(self,*args): + mm=[] + mmpar=[] + mmcG=self.cG + if type(args[0])!=tuple: + for i in args: + mmpar.append(i) + mm.append(mmpar) + else: + for i in args: + mm.append(i) + for i in mm: + kval,x,y=i + mmcG.append([kval,x,y]) + self.cG=mmcG + + + + + def revalue(self,kval): + mm=unisymbols(self.kvalue) + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq==0: + return(kval) + else: + kres=unisymbols(kval) + for i in range(qq): + nnsym=unisymbols(mmsym[i]) + nnval=unisymbols(mmval[i]) + val=kres/10 + val=val*10 + if type(val)!=float: + kres=ksubs(kres,nnsym,nnval) + #kres=fpoly(kres,'forze_subs',nnsym,nnval) + return(kres) + + def store_val(self,nomv,valv,kdisp=False,kpositive=False,kope='',ksymbolic=True,kreturn=False,krevalue=False): + if not self.ksym_in_store(nomv): + mm=self.kvalue + qq=len(mm[0]) + if qq>0: + if not(type(valv)==float or type(valv)==int): + valv=self.evalue_val(valv) + + + mat1=[nomv] + mat2=[valv] + + + + mm1=mat1+mm[0] + mm2=mat2+mm[1] + self.kvalue=(mm1,mm2) + kres=valv + if krevalue: + kres=self.revalue(kres) + + kres=opemat(kres,kope) + if kpositive: + if kres.compare(0)==-1: + kres=-1*kres + if kdisp: + sR=str(nomv)+' =' + display(Math(sR+latex(kres))) + if kreturn: + return(kres) + + def set(self,*args): + mm=self.F + if len(args)==1: + valor=args[0] + if type(valor)==MyEq: + nomv=valor.name + valv=valor.ksym + else: + nomv=str(valor) + valv=valor + else: + nomv=args[0] + valv=args[1] + qq=len(mm) + for i in range(qq): + mm[i][0]=mm[i][0].subs(nomv,valv) + + self.F=mm + + + def setValue(self,nomv,valv,kdisp=False,kpositive=False,kope='',kunisym=True,kreturn=False,krevalue=True,vprimaria=True): + if not self.ksym_in_store(nomv): + mm=self.kvalue + qq=len(mm[0]) + if qq>0: + if not(type(valv)==float or type(valv)==int): + valv=self.evalue_val(valv) + if vprimaria: + if str(nomv)=='m': + self.m=valv + else: + self.m.subs(nomv,valv) + + if str(nomv)=='g': + self.g=valv + else: + self.g.subs(nomv,valv) + if str(nomv)=='x1': + self.x1=valv + if str(nomv)=='x2': + self.x2=valv + if str(nomv)=='y1': + self.y1=valv + if str(nomv)=='y2': + self.y2=valv + if str(nomv)=='v1': + self.v1=valv + if str(nomv)=='v2': + self.v2=valv + else: + self.v2.subs(nomv,valv) + if str(nomv)=='t': + self.t=valv + if str(nomv)=='a': + self.a=valv + if str(nomv)=='ac': + self.ac=valv + else: + kk=self.ac + self.ac=kk.subs(unisymbols(nomv),valv) + if str(nomv)=='v': + self.v=valv + if str(nomv)=='w': + self.w=valv + if str(nomv)=='r': + self.r=valv + if str(nomv)=='w1': + self.w1=valv + if str(nomv)=='w2': + self.w2=valv + + + + + mat1=[nomv] + mat2=[valv] + + + + mm1=mat1+mm[0] + mm2=mat2+mm[1] + self.kvalue=(mm1,mm2) + kres=valv + if kunisym: + kres=unisymbols(kres) + if krevalue: + kres=self.revalue(kres) + + kres=opemat(kres,kope) + if kpositive: + if kres.compare(0)==-1: + kres=-1*kres + if kdisp: + sR=str(nomv)+' =' + display(Math(sR+latex(kres))) + if kreturn: + return(kres) + + def fupdate(self,*args,**kwargs): + + F=self.F + self.F=Lsubs(F,*args,**kwargs) + + def update_kvalue(self): + qq=len(self.kvalue[0]) + for i in range(qq): + ks=self.kvalue[0][i] + kv=self.kvalue[1][i] + for j in range(qq): + + oldVal=self.kvalue[1][j] + self.kvalue[1][j]=oldVal.subs(ks,kv) + + def updatedirec(self): + self.direx=self.x_res() + self.direy=self.y_res() + + + def evalue_val(self,kv, kope=''): + if type(kv)==MyEq: + eq1=kv.ksym + else: + eq1=kv + + mm=self.kvalue + mm1=mm[0] + mm2=mm[1] + qq=len(mm1) + for i in range (qq): + ksym=mm1[i] + kval=mm2[i] + eq1=eq1.subs(ksym,kval) + kres=eq1 + kres=opemat(kres,kope=kope) + return(kres) + + def define_val(self,ksym,kval,kend=False): + + mat1=[ksym] + + mat2=[kval] + kkend=kend + self.add_value(mat1,mat2,kend=kkend) + return(kval) + + def superstore_val(self,knomv,kvalv,kope='',kdisp=True,keval=True): + qq2=len(knomv) + for i in range(qq2): + nomv=knomv[i] + valv=kvalv[i] + self.store_val(nomv,valv) + + if kdisp: + self.disp_solu() + + def redefine(self): + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + for i in range(qq): + kksym=mmsym[i] + mmval=self.value(mmsym) + mm[1][i]=mmval + self.kvalue=mm + + def revalue(self,kval): + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq==0: + return(kval) + else: + kres=kval + for i in range(qq): + nnsym=mmsym[i] + nnval=mmval[i] + + if len(fpoly(kres,'free'))>0: + try: + kres=fpoly(kres,'forze_subs',nnsym,nnval) + except: + try: + kres=kres.subs(nnsym,nnval) + except: + kres=kres + return(kres) + + def value(self,ksymb,keval=True,kope=''): + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq>0: + for i in range(qq): + nnsym=mmsym[i] + nnval=mmval[i] + if ksymb==nnsym: + kres=nnval + break + else: + kres=ksymb + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def disp_solu(self,kunic=False): + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq==0: + return() + else: + sR= '= ' + for i in range(qq): + nnsym=mmsym[i] + nnval=mmval[i] + if kunic: + if len(nnval.free_symbols)==0: + display(Math(latex(nnsym)+sR+latex(nnval))) + else: + display(Math(latex(nnsym)+sR+latex(nnval))) + + def change_store_value(self, ksim,kval): + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq==0: + return(kval) + else: + + for i in range(qq): + nnsym=mmsym[i] + nnval=mmval[i] + if nnsym==ksim: + mmval[i]=kval + mm=[mmsym,mmval] + self.kvalue=mm + + def drop_val(self,ksym): + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq==0: + return() + else: + tsym=[] + tval=[] + + for i in range(qq): + + nsym=mmsym[i] + nval=mmval[i] + if nsym!=ksym: + tsym.append(nsym) + tval.append(nval) + + self.kvalue=(tsym,tval) + + def store_solve(self,ksym,Eq1): + kres=supersolve(ksym,Eq1,kdisp=False,kreturn=True) + qq=len(kres) + for i in range(qq): + self.store_val(ksym[i],kres[i]) + + def copy_symbal(self,obj2,ksymb): + self.store_val(ksymb,obj2.value(ksymb)) + + def solvestore(self,ksym,Eq1,kdisp=True): + if not self.ksym_in_store(ksym): + kres=csolve(Eq1,ksym) + self.store_val(ksym,kres,kdisp=kdisp) + + def ksym_in_store(self,ksym): + allsymb=self.kvalue[0] + if ksym in allsymb: + return(True) + else: + return(False) + + def setval2(self,ksym,newval): + mm=self.F + qq=len(mm) + for i in range(qq): + olds=mm[i][0] + news=olds.subs(ksym,newval) + mm[i][0]=news + self.F=mm + + + + + + def show_store(self,kunic=False): # ******** show() ********** + mm=self.kvalue + mmsym=mm[0] + mmval=mm[1] + qq=len(mmsym) + if qq==0: + return() + else: + sR= '= ' + for i in range(qq): + nnsym=mmsym[i] + nnval=mmval[i] + if kunic: + if len(nnval.free_symbols)==0: + display(Math(latex(nnsym)+sR+latex(nnval))) + else: + display(Math(latex(nnsym)+sR+latex(nnval))) + + + def aX(self,kname='aX'): + return MyEq(self.simple_ac(),kname=kname) + + def aY(self,kname='aY'): + return MyEq(self.simple_ac(ktype='y'),kname=kname) + + def Fx(self,kname='Fx',kshow=True): + ee=MyEq(self.x_res(),kname=kname,kshow=kshow) + return ee + + def x_res(self,kope='',keval=True,kunisym=True,**kwargs): # ******** Static Result sum F + kres=self.resultante(ktype='x',kope=kope,**kwargs) + if kunisym: + kres=unisymbols(kres) + if keval: + kres=self.revalue(kres) + + kres=opemat(kres,kope=kope) + return(kres) + + def fx_relative(self,kang,kope='s'): + return self.x_res_relative(kang=kang,kope=kope) + def xy_accel(self,*args): + mm=self.m + kname='' + kdire=0 + for i in args: + if type(i)==str: + kname=i + else: + kdire=i + kres=self.fx_relative(kdire) + if kname!='': + return MyEq(kres/mm,kname=kname) + else: + return unisymbols(kres/mm) + + def Fx_relative(self,kang,kname='Fx',kope='s',kshow=True): + kres=self.x_res_relative(kang,kshow=kshow) + if kshow: + return MyEq(kres,kname=kname) + else: + return kres + + def x_res_relative(self,kang,kname='',kope='s',kshow=True): + + fx= self.x_res() + fy= self.y_res() + kres=fx *cos(kang)+fy *sin(kang) + kres=opemat(kres,kope=kope) + if kname!='': + return MyEq(kres,kname,kshow=kshow) + else: + return kres + + def modres(self,kname=''): + + kres=self.get_resultante() + try: + kres=killsqrtpow(kres) + except: + pass + if kname!='': + return MyEq(kres,kname) + else: + return kres + + + + + def xy_res(self,kope='',keval=True,kunisym=True): + kres=self.resultante(ktype='xy',kope=kope) + if kunisym: + kres=unisymbols(kres) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def fy_relative(self,kang,kope='s'): + return self.y_res_relative(kang=kang,kope=kope) + + def Fy_relative(self,kang,kname='Fy',kope='s',kshow=True): + kres=self.y_res_relative(kang) + if kshow: + return MyEq(kres,kname=kname) + else: + return kres + def Fy(self,kname='Fy',kshow=True): + ee=MyEq(self.y_res(),kname=kname,kshow=kshow) + return ee + + def y_res(self,kope='',keval=True,kunisym=True): + kres=self.resultante(ktype='y',kope=kope) + if kunisym: + kres=unisymbols(kres) + if keval: + kres=self.revalue(kres) + + kres=opemat(kres,kope=kope) + return(kres) + + def y_res_relative(self,kang,kname='',kope='s',kshow=True): + fx= self.x_res() + fy= self.y_res() + kres=fy *cos(kang)-fx *sin(kang) + kres=opemat(kres,kope=kope) + if kname!='': + return MyEq(kres,kname,kshow=ksow) + else: + return kres + + + def Fxy(self,kname='Fxy',kshow=True): + fx=self.Fx(kshow=False) + fy=self.Fy(kshow=False) + fxy=rsimplify(sqrt(fx.ksym**2+fy.ksym**2)) + ee=MyEq(fxy,kname=kname,kshow=kshow) + return ee + + def tan_res(self): + + xres=self.x_res() + yres=self.y_res() + p1=Point(0, 0) + p2=Point(self.x_res(), self.y_res()) + L = Line(p1, p2) + return(L.slope) + + def ang_res(self,kope=''): + tanr=self.tan_res() + kres=atan(tanr) + kres=opemat(kres,kope=kope) + return(kres) + + def vec_displace(self): + xx=self.x2-self.x1 + yy=self.y2-self.y1 + return([xx,yy]) + + def displacement(self,op='',kope=''): + + if op=='x': + xx=self.x2-self.x1 + kres=xx + + + elif op=='y': + yy=self.y2-self.y1 + kres=yy + else: + xx=self.x2-self.x1 + yy=self.y2-self.y1 + kres=rpow(xx*xx+yy*yy) + + kres=opemat(kres,kope=kope) + return(kres) + + + def y_direRes_from_x1(self,xx2='',kope=''): + xx1=self.x1 + yy1=self.y1 + if xx2=='': + xx2=self.x2 + + Ll=xx2-xx1 + ttg=self.tan_res() + kres=yy1+Ll*ttg + kres=opemat(kres,kope=kope) + return(kres) + + def get_resultante(self): + xx=self.x_res() + yy=self.y_res() + kres=get_hipo(xx,yy) + return kres + + + def resultante(self,keval=True,ktype='x',kope='',**kwargs): # usado x x res y res + if len(kwargs)>0: + mm=subsvec(self.F,**kwargs) + else: + mm=self.F + qq=len(mm) + kresx=0 + kresy=0 + for i in range(qq): + vec=1*mm[i] + kk=1*vec[0] + ka=1*vec[1] + kval=kk*cos(ka) + kresx+=kval + kval=kk*sin(ka) + kresy+=kval + if ktype=='x': + kres=kresx + elif ktype=='y': + kres=kresy + else: + kres=rpow(kpow(kresx,2)+kpow(kresy,2)) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + def mov_Eq(self,ksym,kope=''): + aa=self.a + vv=self.v + gg=self.g + xx=self.x1 + + kres= ksym*tan(aa)-gg*ksym*ksym/(2*vv*vv*cos(aa)*cos(aa))-xx + + kres=unisymbols(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def eQ_trayec(self,ksym,kname='',kope=''): + kres= self.mov_Eq(ksym=ksym,kope=kope) + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return(kres) + + def Fx_direc(self,alpha,kope=''): + fx=self.x_res() + fy=self.y_res() + kres=fy*sin(alpha)+fx*cos(alpha) + kres=opemat(kres,kope=kope) + return kres + def Fy_direc(self,alpha,kope=''): + fx=self.x_res() + fy=self.y_res() + kres=fy*cos(alpha)-fx*sin(alpha) + kres=opemat(kres,kope=kope) + return kres + def Fxy_direc(self,alpha,kope=''): + fx=self.Fx_direc(alpha=alpha,kope=kope) + fy=self.Fy_direc(alpha=alpha,kope=kope) + kres=get_hipo(fx,fy) + kres=opemat(kres,kope=kope) + return kres + def tan_dezplacement(self,kop='tan'): + xx1,xx2,yy1,yy2=self.x1,self.x2,self.y1,self.y2 + ktan=(yy2-yy1)/(xx2-xx1) + if kop=='tan': + return ktan + else: + return atan(ktan) + + def geotorque(self,angle,R,kope='',keval=True): + xx,yy= polar2xy(kR,a1,op='') + return self.torque(x=xx,y=yy,kope=kope,keval=keval) + + + def To(self,*args,**kwargs): + xx='' + yy='' + kname='To' + for i in args: + if type(i)==str: + kname=i + elif xx=='': + xx=i + else: + yy=i + if xx=='': + xx=0 + if yy=='': + yy=0 + + + ktorque=self.torque(xx,yy) + ktorque=real_subs(ktorque,**kwargs) + + + ee= MyEq(ktorque,kname=kname) + return ee + + def Mo(self,kname='Mo',**kwargs): + kres=self.I_n + kres=kres*self.aw + + + if len(kwargs)>0: + for key, value in kwargs.items(): + kres=real_subs(kres,**kwargs) + ee= MyEq(kres,kname=kname) + return ee + + def MoAng(self,kname='Ma', **kwargs): + kres=self.I_n + kres=kres*self.w + + + if len(kwargs)>0: + for key, value in kwargs.items(): + kres=real_subs(kres,**kwargs) + ee= MyEq(kres,kname=kname) + return ee + + + def torque(self,x=0,y=0,kope='',keval=True): + mm=unisymbols(self.F ) + qq=len(mm) + kt=0 + + for i in range(qq): + vec=mm[i] + mk=vec[0] + xx=vec[2] + yy=vec[3] + aa=vec[1] + dx=xx-x + dy=yy-y + fx=-1*mk*cos(aa)*dy + kt+=fx + fy= mk*sin(aa)*dx + kt+=fy + + kres=unisymbols(kt) + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + try: + kres=opemat(kres,'t') + except: + pass + return(kres) + + + + def kine_ac(self,kname='',kope='',keval=True): # return (vf-vi)/t + vv1=unisymbols(self.v1) + vv2=unisymbols(self.v2) + tt=unisymbols(self.t) + kres= (vv2-vv1)/tt + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return(kres) + + def kine_vf_t(self,kname='',kope='',keval=True): # return ac*t +vi + vv1=unisymbols(self.v1) + aac=unisymbols(self.ac) + tt=unisymbols(self.t) + kres= aac*tt+vv1 + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return(kres) + def kine_vf_a_x(self,kname='',kope='',keval=True,ktype='P'): # return ac*t +vi + vv1=unisymbols(self.v1) + aac=unisymbols(self.ac) + x11= unisymbols(self.x2-self.x1) + kres= rpow(2*aac*x11-vv1*vv1) + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname,ktype=ktype) + return ee + else: + return(kres) + def kine_vf_x(self,kname='',kope='',keval=True): # return ac*t +vi + xx1=unisymbols(self.x1) + xx2=unisymbols(self.x2) + aac=unisymbols(self.ac) + vv1=unisymbols(self.v1) + kres= vv1*vv1+2*aac*(xx2-xx1) + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return(kres) + + def kine_x2(self,kname='',kope='',keval=True): # return ac*t +vi + xx1=unisymbols(self.x1) + tt=unisymbols(self.t) + aac=unisymbols(self.ac) + vv1=unisymbols(self.v1) + kres= xx1+vv1*tt+aac*tt*tt/2 + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return(kres) + + def kine_t(self,kname='',kope='',keval=True): # return ac*t +vi + vv1=unisymbols(self.v1) + aac=unisymbols(self.ac) + vv2=unisymbols(self.v2) + kres= (vv2-vv1)/aac + if keval: + kres=self.revalue(unisymbols(kres)) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname) + return ee + else: + return(kres) + + + + def ac_due_Forza(kdire='',kname=''): + if kdire=='': + kdire=self.dire + + frr=self.Fx_relative(dire) + kres=frr/self.m + + if kname!='': + ee=MyEq(kres,kname) + return ee + + return kres + def Xt(self): + x1=self.x1 + + v1=self.v1 + alpha=self.a + ac=self.ac + kres=x1+v1*t*cos(alpha)+ac*t*t/2 + ee=MyEq(kres,'Xt',var=t) + return ee + + + + def relative_aceleration(self,*args,**kwargs): + kname='' + angle=0 + for i in args: + for i in args: + if type(i)==str: + kname=i + else: + angle=i + F=self.x_res_relative(angle) + mm=self.m + return smartreturn(F/mm,kname) + + + + + def simple_ac(self,kdire='',ktype='x',kope='',keval=False): + if ktype=='y': + fr=self.y_res() + elif ktype=='xy': + fr=self.xy_res() + else: + fr=self.x_res() + mm=self.m + kres=fr/mm + kres=opemat(kres,kope=kope) + if keval: + mmval=self.kvalue + kres=s_subs(kres,mmval) + mtype=['','x','y','xy'] + if ktype not in mtype: + ee=MyEq(unisymbols(kres),ktype) + return ee + else: + return(unisymbols(kres)) + + def accele_due_Vels(self,t='',kope='',keval=True): + if t=='': + t=self.t + + kres=(self.v2-self.v1)/t + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + + def work(self,op='',kope=''): + if op=='x': + xx=self.x2-self.x1 + kres=xx*self.xy_res() + elif op=='y': + yy=self.y2-self.y1 + kres=yy*self.xy_res() + else: + xxyy=self.displacement() + kres=xxyy*self.xy_res() + + kres=opemat(kres,kope=kope) + return(kres) + + + def work_X(self): + + Fr=self.resultante(ktype='x') + d1=self.x1 + d2=self.x2 + dd=d2-d1 + kres=Fr*dd + return(kres) + + def work_Y(self): + + Fr=self.resultante(ktype='y') + d1=self.y1 + d2=self.y2 + dd=d2-d1 + kres=Fr*dd + return(kres) + + + def work_due_forza(self, op='',kope=''): + if op=='x': + Fr=self.resultante(ktype='x') + d1=self.x1 + d2=self.x2 + dd=d2-d1 + kres=Fr*dd + elif op=='y': + Fr=self.resultante(ktype='y') + d1=self.y1 + d2=self.y2 + dd=d2-d1 + kres=Fr*dd + else: + wx=self.work_due_forza('x') + wy=self.work_due_forza('y') + kres=rpow(kpow(wx,2)+kpow(wy,2)) + kres=opemat(kres,kope) + return(kres) + + def add_central_force(self,ksym): + self.Ti=ksym + + def add_cg(self, km,x=0,y=0): + + mm=self.cG + mm.append([km,x,y]) + self.cG=mm + + def get_cg(self,ktype='',kope='',kshow=False): + return self.cgravedad(ktype=ktype,kope=kope,kshow=kshow) + + def cgravedad(self,ktype='',kname='',kope='',kshow=False): + + if ktype=='help': + listOfImageNames = ['Phelp/cg1.png','Phelp/cg2.png',] + for imageName in listOfImageNames: + display(Image(filename=imageName)) + return + mm=self.cG + + Tm=0 + Tx=0 + Ty=0 + + for i in mm: + Tm+=i[0] + Tx+=i[0]*i[1] + Ty+=i[0]*i[2] + + if Is_Number(Tx) and Is_Number(Tm): + Cx= unfloatdiv(Tx,Tm) + else: + Cx= Tx/Tm + + if Is_Number(Ty) and Is_Number(Tm): + Cy= unfloatdiv(Ty,Tm) + else: + Cy= Ty/Tm + + + + kres=(Cx,Cy) + if ktype=='x': + kres=Cx + if ktype=='y': + kres=Cy + if kname!='': + ee=MyEq(kres,kname=kname) + return ee + + return kres + + + + def energia_rot(self,*args,In=''): + ww1=self.w1 + ww2=self.w2 + ii=self.I_n + if In!='': + ii=In + er1=ii*ww1*ww1/2 + er2=ii*ww2*ww2/2 + kname='' + kop=0 + for i in args: + if type(i)==str: + kname=i + if type(i)==int: + kop=i + + if kop==1: + kres= er1 + elif kop==2: + kres= er2 + else: + kres=er2-er1 + if kname=='': + return kres + else: + return MyEq(kres,kname=kname) + + def energia_pot(self,*args): + yy1=self.y1 + yy2=self.y2 + mm=self.m + gg=self.g + + ep1=mm*gg*yy1 + ep2=mm*gg*yy2 + + kname='' + kop=0 + for i in args: + if type(i)==str: + kname=i + if type(i)==int: + kop=i + + if kop==1: + kres= ep1 + elif kop==2: + kres= ep2 + else: + kres=ep2-ep1 + if kname=='': + return kres + else: + return MyEq(kres,kname=kname) + + def energia_kin(self,*args): + vv1=self.v1 + vv2=self.v2 + mm=self.m + + + ek1=mm*vv1*vv1/2 + ek2=mm*vv2*vv2/2 + + kname='' + kop=0 + for i in args: + if type(i)==str: + kname=i + if type(i)==int: + kop=i + + if kop==1: + kres= ek1 + elif kop==2: + kres= ek2 + else: + kres=ek2-ek1 + if kname=='': + return kres + else: + return MyEq(kres,kname=kname) + + def eQenergia(self,op='KP'): + res1=0 + if 'K' in op: + res1+=self.energia('k1') + if 'P' in op: + res1+=self.energia('p1') + if 'R' in op: + res1+=self.energia('r1') + res2=0 + if 'P' in op: + res2+=self.energia('p2') + if 'K' in op: + res2+=self.energia('k2') + if 'R' in op: + res2+=self.energia('r1') + return MQ(res1,res2) + + def EnergiaTotal(self,kname='Et',op='KP'): + ee=MyEq(self.energia(op),kname=kname) + return ee + + + def energia(self,ktype='',**kwargs): + kres=0 + mm=self.m + gg=self.g + v1=self.v1 + v2=self.v2 + h1=self.y1 + h2=self.y2 + w1=self.w1 + w2=self.w2 + rr=self.r + Io=self.Io + k1=mm*v1*v1/2 + k2=mm*v2*v2/2 + p1=mm*gg*h1 + p2=mm*gg*h2 + er1=Io*w1*w1/2 + er2=Io*w2*w2/2 + kres=0 + if ktype=='': + kres=k2+p2+er2-k1-p1-er1 + elif ktype=='1': + kres=k1+p1+er1 + elif ktype=='2': + kres=k2+p2+er2 + elif ktype=='k': + kres=k2-k1 + elif ktype=='p': + kres=p2-p1 + elif ktype=='r': + kres=er2-er1 + else: + + if '1' in ktype: + + if 'k' in ktype: + kres+=k1 + if 'p' in ktype: + kres+=p1 + if 'r' in ktype: + kres+=er1 + if '2' in ktype: + if 'k' in ktype: + kres+=k2 + if 'p' in ktype: + kres+=p2 + if 'r' in ktype: + kres+=er2 + if len(kwargs)>0: + kres=subskwargs(kres,**kwargs) + return kres + + + def eQtraslation(self,**kwargs): + if self.dire!=0: + fx=self.x_res_relative(self.dire) + else: + fx=self.x_res() + + aa=self.ac + mm=self.m + p1=real_subs(fx,**kwargs) + p2=mm*aa + p2=real_subs(p2,**kwargs) + + return MyEqEq(p1,p2) + + def eQrotation(self,*args,x=0,y=0,view_diff=False,var1=alpha,var2=t,**kwargs): + + + + aww=self.aw + if aww==aw and view_diff: + aww=anam2 + ww=self.w + if ww==w and view_diff: + ww=anam1 + p1= self.Io*aww + for i in args: + if i=='w': + p1= self.Io*ww + elif i=='a': + p1= self.Io*self.ac/self.r + else: + p1= self.Io*ww + + p2= self.torque(x,y) + print(len(args),args) + if len(args)>0: + print(1) + if 'positive' in args: + print(2) + p2=makepos(p2) + if len(kwargs)>0: + for key, value in kwargs.items(): + p1=real_subs(p1,**kwargs) + p2=real_subs(p2,**kwargs) + qq=MQ(p1,p2,kshow=False) + #ee=Eq(p1,p2) + #init_vprinting() + qq.s() + return qq + + def eQmovradial(self,ang=0,negative=False): + fx=self.Fx_relative(ang,kshow=False) + mm=self.m + rr=self.r + ww=self.w + if negative: + return MQ(mm*rr*ww*ww,fx) + else: + return MQ(-1*mm*rr*ww*ww,fx) + def eQmovtangencial(self,ang=0,negative=False): + fy=self.Fy_relative(ang,kshow=False) + mm=self.m + rr=self.r + aw=self.aw + if negative: + return MQ(1*mm*rr*aw,fy) + else: + return MQ(-1*mm*rr*aw,fy) + + def eRotation(self,ktype='',keval=True,kope=''): + ''' + ktype 'p1' 'p2' 'ro1' 'ro2' '1' '2' 'P' 'R' + ''' + return self.energiaRot(ktype=ktype,keval=keval,kope=kope) + + + def energiaRot(self,ktype=R,keval=True,kope=''): + ''' + ktype 'p1' 'p2' 'ro1' 'ro2' '1' '2' 'P' 'R': + + ''' + mm=self.m + gg=self.g + Ii=self.In + if self.get_InerTotal()!=0: + Ii=self.get_InerTotal() + + ww1=self.w1 + h1=self.y1 + + p1=mm*gg*h1 + ro1=Ii*ww1*ww1/2 + E1=ro1+p1 + + ww2=self.w2 + h2=self.y2 + + p2=mm*gg*h2 + ro2=Ii*ww2*ww2/2 + E2=ro2+p2 + if ktype=='p1': + kres=p1 + elif ktype=='p2': + kres=p2 + elif ktype=='ro1': + kres=ro1 + elif ktype=='ro2': + kres=ro2 + elif ktype=='1': + kres=E1 + elif ktype=='2': + kres=E2 + elif ktype=='P': + kres=p1-p2 + elif ktype=='R': + kres=ro1-ro2 + else: + kres=E2-E1 + + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def eQenergia(self,kops=''): + ee=MyEq(self.energia(ktype=kops),'eE') + return ee + + + def Etotal(self,op=''): + kres=0 + if '1' in op or '2' in op: + if '1' in op: + if 'p' in op: + kres+=self.energia('p1') + if 'k' in op: + kres+=self.energia('k1') + if 'r' in op: + kres+=self.energiaRot('ro1') + if op=='1': + kres+=self.energiaRot('ro1')+self.energia('k1')+self.energia('p1') + + else: + + if 'p' in op: + kres+=self.energia('p2') + if 'k' in op: + kres+=self.energia('k2') + if 'r' in op: + kres+=self.energiaRot('ro2') + if op=='2': + kres+=self.energiaRot('ro2')+self.energia('k2')+self.energia('p2') + if 'K' in op: + kres+=self.energia('K') + if 'P' in op: + kres+=self.energia('P') + if 'R' in op: + kres+=self.energiaRot('R') + if op=='': + kres=self.energia('p2')+self.energia('k2')+self.energiaRot('ro2') + kres=kres-self.energia('p1')-self.energia('k1')-self.energiaRot('ro1') + if op=='Eq': + return MQ(self.energia('p1')+self.energia('k1')+self.energiaRot('ro1'),self.energia('p2')+self.energia('k2')+self.energiaRot('ro2')) + return kres + def simple_Ek(self): + mm=self.m + vv=self.v + kres=mm*vv*vv/2 + return kres + + def simple_Er(self): + ii=self.getInerTotal() + ww=self.w + kres=ii*ww*ww/2 + return kres + + + def work_x(self, kope=''): + Fr=self.resultante('x') + d1=self.x1 + d2=self.x2 + dd=d2-d1 + kres=Fr*dd + kres=opemat(kres,kope) + return(kres) + + + def x_vel(self,t=t,kope='',keval=True): + acc=self.ac + vv=self.v1 + aa=self.a + vv1=vv*cos(aa) + tt=t + kres=tt*acc+vv1 + kres=opemat(kres,kope=kope) + if keval: + kres=self.revalue(kres) + + return(kres) + + def get_yvel(self,**kwargs): + if len(kwargs)>0: + vsym,vval=unpack(kwargs) + if 't' in vsym: + v1=self.vy + gg=self.g + kres=v1-gg*t/2 + kres=real_subs(kres,**kwargs) + return kres + elif 'y2' in vsym: + v1=self.vy + gg=self.g + kres=v1*v1-2*gg*y2 + kres=real_subs(kres,**kwargs) + return sqrt(kres) + else: + return self.y_vel(t=t,kope='',keval=True) + + def y_vel(self,t=t,kope='',keval=True): + + vv=self.v + aa=self.a + vv1=vv*sin(aa) + gg=self.g + kres=-t*gg+vv1 + kres=opemat(kres,kope=kope) + if keval: + kres=self.revalue(kres) + return(kres) + + def y_velfinal(self,kope='',keval=True): + yy=self.y1-self.y2 + gg=self.g + aa=self.a + vv=self.v + zz=gg*yy/(vv*vv) + ss=sin(aa) + ss2=ss*ss + kres=-vv*rpow(ss2+2*zz,2) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def y_v2(self,kope='',keval=True): + kres=self.y_vel(0)+2*self.g*(self.y2-self.y1) + sres=str(kres) + if sres[0]=='-': + kres=-1*rpow(-1*kres) + else: + kres=rpow(kres) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def y2_vel(self,t=t,y2=''): # vel2 in y2 Pos + gg=self.g + yy1=self.y1 + v0=self.v*sin(self.a) + if y2!='': + yy2=y2 + L=yy2-yy1 + kres=rpow(v0*v0-2*gg*L,2) + return kres + else: + tt=t + return self.y_vel(tt) + def parabolicEq(self,**kwargs): + g,v1,a=self.g,self.v1,self.a + kres=x*tan(a)-g*x*x/(2*v1*v1*(cos(a)**2)) + kres=real_subs(kres,**kwargs) + ee=MyEq(kres,'y',var=x) + return ee + + + def vel_final(self,kope='',keval=True): + + + gg=self.g + aa=self.a + vv=self.v + zz=gg*yy/(vv*vv) + ss=sin(aa) + ss2=ss*ss + kres=vv*rpow(1+2*zz,2) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def tan_velfinal(self,kope='',keval=True): + + gg=self.g + aa=self.a + vv=self.v + zz=gg*yy/(vv*vv) + ss=sin(aa) + ss2=ss*ss + kres=-rpow(ss2+22*zz,2)/cos(aa) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + def xy_vel(self,tt='',kope='',keval=True): + if tt=='': + tt=t + vvx=self.x_vel(t=tt) + vvy=self.y_vel(t=tt) + kres=pow(pow(vvx,2) + pow(vvy,2),S('1/2')) + if keval: + kres=self.revalue(kres) + return(kres) + def xyvel(self,*args,**kwargs): + tt=args[0] + vvx=self.x_vel(t=tt) + vvy=self.y_vel(t=tt) + kres=pow(pow(vvx,2) + pow(vvy,2),S('1/2')) + return smartanswer(kres, *args,**kwargs) + def xpos(self,*args,**kwargs): + tt=args[0] + if self.v2!=v2: + ac=(self.v2-self.v1)/tt + else: + ac=self.ac + kres=float2int(self.x1+tt*self.v1*cos(self.a)+ac*tt*tt/2) + return smartanswer(kres, *args,**kwargs) + + def xvel(self,*args,**kwargs): + tt=args[0] + if self.ac!=ac: + kres=self.v1*cos(self.a)+self.ac*tt + else: + kres=2*(self.x2-self.x1)/tt-self.v1*tt + return smartanswer(kres, *args,**kwargs) + + def xacel(self,*args,**kwargs): + return self.acelerationx(*args,**kwargs) + + def acelerationx(self,*args,**kwargs): + kname='' + tt=t + for i in args: + if type(i)==str: + kname=i + else: + tt=i + if self.v2!=0: + if tt==t: + kres=(self.v2**2-self.v1**2)/(2*(self.x2-self.x1)) + else: + kres=(self.v2-self.v1)/tt + else: + kres=((self.x2-self.x1)-self.v1*tt)*2/(tt*tt) + kres=real_subs(kres,**kwargs) + return smartreturn(kres,name=kname,var=t) + + + def ypos(self,*args,**kwargs): + kname='' + tt=t + kres=self.y1+tt*self.v1*sin(self.a)-self.g*tt*tt/2 + return smartanswer(kres, *args,**kwargs) + + def y_pos(self, t=t,kope='',keval=True): + tt=1*t + vvy=self.y_vel(t=0) + gg=self.g + yy1=self.y1 + kres=yy1+vvy*tt-gg*tt*tt/2 + kres=opemat(kres,kope=kope) + if keval: + kres=self.revalue(kres) + + return(kres) + + def yvel(self,*args,**kwargs): + tt=args[0] + kres=self.v1*sin(self.a)-self.g*tt + return smartanswer(kres, *args,**kwargs) + + + + + def angle_pos(self, t=t,kope='',keval=True): + if self.aw==0: + + ww1=self.w1 + else: + ww1=0 + tt=1*t + aaw=self.aw + kres=ww1*t+aaw*t*t/2 + kres=opemat(kres,kope=kope) + return(kres) + + def anglevel_final(self, t=t,kope='',keval=True): + ww1=self.w1 + tt=1*t + aaw=self.aw + kres=ww1+aaw*tt + + kres=opemat(kres,kope=kope) + return(kres) + + def circul_desplace(self, t=t,kope='',keval=True): + ww1=self.w1 + rr=self.r + tt=1*t + aaw=self.aw + kres=ww1*rr*tt+rr*aaw*tt*tt/2 + kres=opemat(kres,kope=kope) + return(kres) + + + def y_max(self,**kwargs): + return self.ymax(**kwargs) + + def ymax(self,**kwargs): + g,a,v1,y1=self.g,self.a,self.v1,self.y1 + kres=rsimplify(y1+(v1**2)*(sin(a)**2)/(2*g)) + kres= real_subs(kres,**kwargs) + return kres + + + def x_max(self,kope='',keval=False): + yy=self.y1-self.y2 + gg=self.g + aa=self.a + vv=self.v + zz=c2c(gg*yy/(vv*vv)) + ss=sin(aa) + ss2=ss*ss + rres=c2c(kpow(ss2+2*zz,frs(1,2))) + + kres=(vv**2)*(ss+ c2c((rpow(ss2+2*zz,2))) )*c2c(cos(aa)/gg) + return(kres) + + def xmax(self,*args,**kwargs): + kname=firstdataname(*args) + tt=self.tfly(*args,**kwargs) + kres= self.xpos(tt) + kres=real_subs(kres,**kwargs) + return smartreturn(kres,name=kname,var=t) + + + + + def t_fly(self,kope='',keval=True): + vv=self.v + gg=self.g + aa=self.a + yy1=self.y1 + yy2=self.y2 + if yy1==0 and yy2==0: + kres=2*vv*sin(aa)/gg + else: + kk=2*gg*yy1 - 2*gg*yy2 + vv**2*sin(aa)**2 + kkk=rpow(kk,2) + kres= (vv*sin(aa)+kkk)/gg + + + return(kres) + def tfly(self,*args,**kwargs): + kname=firstdataname(*args) + tt=t + v1,g,a,y1,y2=self.v1,self.g,self.a,self.y1,self.y2 + kres=rsimplify((v1*sin(a) + sqrt(2*g*y1 - 2*g*y2 + v1**2*sin(a)**2))/g) + kres=real_subs(kres,**kwargs) + return smartreturn(kres,name=kname,var=t) + + + + + def tanVel(self,t=t,keval=True,kope='',ktan=True): + return self.tan_angle_in_t(t=t,keval=keval,kope=kope,ktan=ktan) + + def tan_to_x_max(self,keval=True,kope=''): + yy=self.y1-self.y2 + gg=self.g + vv=self.v + kres=vv/rpow(vv*vv+2*yy*gg) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return(kres) + + + def tan_angle_in_t(self,t=t,keval=True,kope='',ktan=True): + tt=t + vyy=self.y_vel(t=tt) + vxx=self.x_vel() + if ktan: + kres=(vyy/vxx) + else: + kres=atan(vyy/vxx) + kres=opemat(kres,kope=kope) + if keval: + kres=self.revalue(kres) + return(kres) + + def vel_comp(self,op='',kope=''): # find mag vec velocity + vvx=kpow(self.vx,2) + vvy=kpow(self.vy,2) + vvxy=kpow(self.vxy,2) + if op=='x': + kres=rpow(vvxy-vvy) + elif op=='y': + kres=rpow(vvxy-vvx) + else : + kres=rpow(vxy+vvy) + kres=opemat(kres,kope) + return(kres) + + def simple_x_pos(self,v1='',ac='',t='',kope='',keval=True): + if v1=='': + v1=self.v1 + if ac=='': + ac=self.ac + if t=='': + t=self.t + kres=v1*t+ac*t*t/2 + + kres=opemat(kres,kope=kope) + if keval: + kres=self.revalue(kres) + return(kres) + + def x_time(self,t=t): + return csolve(self.x_pos(t)-self.x2,t) + + def y_time(self,t=t): + return csolveR(self.y_pos(t)-self.y2,t) + + + def fradial_ang(self,kope=''): + mm=self.m + aa=self.aw + kres=mm*aa + kres=opemat(kres,kope=kope) + return kres + + def fradial_w(self,kope=''): + mm=self.m + ww=self.w + rr=self.r + kres=mm*ww*ww*rr + kres=opemat(kres,kope=kope) + rr=self.r + return kres + + def fcentripete(self,kang,v='',w='', r='',m='',g='',kop='Fct',direction='In'): + + + if r=='': + r=self.r + if m=='': + m=self.m + if g=='': + ww=self.g + if v=='' and w=='': + v=self.v + if v=='' and w!='': + v=w*r + if kop=='Fcn': + kres=Fin*m*v*v/r + if kop=='Fcx': + kres=kres=self.fcen_res(kang) + if kop=='Fct': + kres=self.fcen_res(kang)+Fin*m*v*v/r + return kres + + + def fcentripeta_res(self,kangle='',keval=True,kope=''): + F1=self.fcentripeta(kangle=kangle,keval=keval,kope=kope) + F2=self.Fc + return F2+F1 + + def set_forza_central(self,fc=0): + self.Fc=fc + + def fradial_res(self,kang=0,kope=''): + fext=self.fcentripeta( kang) + finer=self.Fc + mm=self.m + rr=self.r + vv=self.v + ftang=mm*vv*vv/rr + kres=finer+fext-ftang + kres=opemat(kres,kope=kope) + return kres + + + def add_forzac(self, kval,kang,x=0,y=0,s='r'): + + if s=='s': + kang=sex2rad(kang) + mm=self.Fc + qq=len(mm) + if qq>0: + veri=[] + for i in range(qq): + veri.append(mm[i][0]) + if kval not in veri: + mm.append([kval,kang,x,y]) + else: + mm.append([kval,kang,x,y]) + self.Fc=mm + + + + def fcentripeta(self,kname='',kangle='',keval=True,kope='',kdire=1): + ''' + fcentripeta() , return Radial Force - Forza due Velocity + fcentripeta(alpha), return Sum all Radial Force in alpha pos + fcentripeta('v') , return fcentrip in velocity function m*v*v/R + fcentripeta('w') , return fcentrip in ang velocity function m*v*v*R + ''' + + if kangle=='': + + kres=kdire*self.simple_Fcentripeta() + + + else: + fx=self.x_res()*cos(kangle) + fy=self.y_res()*sin(kangle) + + kres= fx-fy + kres=unisymbols(kres) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + if kname!='': + ee=MyEq(kres,kname=kname) + return ee + else: + return(kres) + + + + def fcirc_res_due_vtan(self,ang): + F1=self.fcentripeta(ang) + F2=self.Ti + F3=F2+F1 + ve=self.v + mm=self.m + rr=self.r + kres=F3- mm*ve*ve/rr + return kres + def fcirc_res_due_w(self,ang): + F1=self.fcentripeta(ang) + F2=self.Ti + F3=F2+F1 + ve=self.w + mm=self.m + rr=self.r + kres=F3- mm*ve*ve*rr + return kres + + + def Fcentrip_v(self,kope='',keval=True): + mm=self.m + rr=self.r + vv=self.v + kres=unisymbols(mm*vv*vv/rr) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return kres + + def Fcentrip_w(self,kope='',keval=True): + mm=self.m + rr=self.r + ww=self.w + kres=unisymbols(mm*ww*ww*rr) + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return kres + + def fcEq(self,a='',kname='eFc'): # return fcentripeta accel centripeta Equation + mm=self.m + ve=self.v + if self.vv=='': + vv=ve*ve + else: + vv=self.vv + + e1=MyEq(self.fcen_res(a)-mm*vv/2,kname) + return e1 + + + def c_res1(self,aac=0): + xr=self.x_res() + yr=self.y_res() + + ffc=-yr*sin(aac)+xr*cos(aac) + ffc=self.revalue(ffc) + fft=-yr*cos(aac)+xr*sin(aac) + fft=self.revalue(fft) + return sE(['ffc=',ffc,' fft=',fft]) + def c_res(self,aac=''): + return self.fcen_res(acc=acc) + + + + def fcen_res(self,aac=''): #return centripete force in pos aac angle due forces added + if aac=='': + beta=symbols('beta') + aac=beta + xr=self.x_res() + yr=self.y_res() + ffc=-yr*sin(aac)+xr*cos(aac) + ffc=self.revalue(ffc) + return ffc+self.Ti + + def Fsum_radial(self,aac=0): #return centripete force in pos aac angle due forces added + if aac=='': + beta=symbols('beta') + aac=beta + xr=self.x_res() + yr=self.y_res() + ffc=-yr*sin(aac)+xr*cos(aac) + ffc=self.revalue(ffc) + return ffc+self.Ti + + def ftan_res(self,aac=0,kabs=False): #return tangential force in pos aac angle due forces added + xr=self.x_res() + yr=self.y_res() + + fft=-yr*cos(aac)+xr*sin(aac) + fft=self.revalue(fft) + if kabs: + + return abs(fft) + + else: + + return fft + + def simple_vtan(self): + ww=self.w + rr=self.r + kres=ww*rr + kres=self.revalue(kres) + + return(kres) + + + def fcen_v(self): + return self.fcen_due_vel_tang() + + def fcen_due_vel_tang(self): + return self.simple_Fcentripeta('v') + + def fcen_w(self): + return self.simple_Fcentripeta('w') + + def fcen_due_vel_ang(self): + return self.simple_Fcentripeta('w') + + def simple_Fcentripeta(self,ktype='w'): + mm=self.m + ww=self.w + rr=self.r + vv=self.v + kres=mm*ww*ww*rr + if ktype=='v': + kres=mm*vv*vv/rr + + + kres=self.revalue(kres) + + return(kres) + + + def Fc_dueV(self,kope='',keval=True): # retun m*v*v/r + mm=self.m + vv=self.v + rr=self.r + kres=mm*vv*vv/rr + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return kres + + def xdueW(self,kope='',keval=True): + mm=self.m + ww=self.w + rr=self.r + kres=mm*ww*ww*rr + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope=kope) + return kres + + + + + + def equiTriangle(self,ksym,kangle,ksym2,ksym3,kstore=False): + kres1=ksym*cos(kangle) + kres1=self.revalue(kres1) + kres2=ksym*sin(kangle) + kres2=self.revalue(kres2) + ktext=' >> not stored ' + if kstore: + self.store_val(ksym2,kres1) + self.store_val(ksym3,kres2) + ktext=' >> was stored ' + sE([ksym2,'=',kres1,ktext]) + sE([ksym3,'=',kres2,ktext]) + + # help + def help(self,op1=''): + if op1=='': + sE([' type .help("kine") to get help with kinematic help']) + sE([' type .help("static") to get help with static help']) + + if op1=='kine': + display(Image(filename="Phelp/help_k1.png")) + display(Image(filename="Phelp/help_k2.png")) + + + + def simplePow(self,t=t,kope='',keval=True,ktype=''): + tt=t + ww=self.energia(ktype) + kres=ww/tt + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + def get_InerTotal(self,kname='',var2=''): + ''' + Return Sum Inercia of all particles in the system + before we need add each inerce point whit: + + add_Inerce(self,mm='',rr='',L=0,ktype='p'): + add_Inerce(mass,radioof mass , L= steiner dist,type Inerce..'p','r'..): + ''' + mm=[] + Ivec=self.cI + for i in Ivec: + mm.append(i) + mms=sum(mm) + if kname=='': + return mms + else: + if var2!='': + return MyEq(mms,kname,var2=var2,ktype='F') + else: + return MyEq(mms,kname) + + + def getInerTotal(self,kname='',var2=''): + mm=[] + Ivec=self.cI + for i in Ivec: + mm.append(i) + mms=sum(mm) + if kname=='': + return mms + else: + if var2!='': + return MyEq(mms,kname,var2=var2,ktype='F') + else: + return MyEq(mms,kname) + + + + + + def setIner(self,kval): + self.I_n=kval + return self.I_n + + + + + def ang_moment(self,op='',kope='',keval=True): + Ia=self.I_n + + if op=='w': + kres=kpow(self.w,2)*Ia/2 + else: + kres=Ia*self.aw + + + + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + def Mo_In_due_geoI(self,kope='',keval=True): + Inn=unisymbols(self.I_n) + aw=unisymbols(self.a_w) + + kres=Inn*aw + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + def Mo_In_due_velang(self,kope='',keval=True): + mm=unisymbols(self.m) + aw=unisymbols(self.a_w) + rr=unisymbols(self.r) + + kres=mm*aw*rr*rr + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + def Mo_In_due_torque(self,kope='',keval=True): + tt=self.torque() + ww=self.a_w + kres=tt/ww + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + + def eCir(self,vv): # Internal use + Ii=self.I_n + rr=self.r + kres=frs(Ii*vv*vv/(rr*rr),2) + return unisymbols(kres) + + def energiaC(self,kv='',keval=True,kope=''): + + if kv=='': + kres=self.eCir(self.v2)-self.eCir(self.v1) + elif kv=='1': + kres=self.eCir(self.v1) + elif kv=='2': + kres=self.eCir(self.v2) + else : + kres=self.eCir(kv) + + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + def energiaCw(self,kv='',keval=True,kope=''): + + if kv=='': + kres=self.eCir(self.w2*self.r)-self.eCir(self.w1*self.r) + elif kv=='1': + kres=self.eCir(self.w1*self.r) + elif kv=='2': + kres=self.eCir(self.w2*self.r) + else : + kres=self.eCir(kv) + + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + def Ener_wrotation(self,kop='',keval=True,kope=''): + Ii=self.I_n + ec1=(Ii/2)*kpow(self.w1,2) + ec2=(Ii/2)*kpow(self.w2,2) + if kop=='1': + kres=ec1 + elif kop=='2': + kres=ec2 + else: + kres=ec2-ec1 + + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + + def torqueC(self,keval=True,kope=''): + Ii=self.I_n + aw=self.a_w + rr=self.r + if self.ac!=ac: + aw=self.ac/rr + kres=Ii*aw + + if keval: + kres=self.revalue(kres) + kres=opemat(kres,kope) + return kres + + def help(self,*args): + if len(args)==0: + mm=[0,1,2,3] + else: + mm=args + istOfImageNames = ['Phelp/HelpPh0.png','Phelp/HelpPh1.png','Phelp/HelpPh2.png','Phelp/HelpPh3.png'] + for kop in mm: + display(Image(filename=istOfImageNames[kop])) + def eQkinematic(self,**kwargs): + v1=self.v1 + v2=self.v2 + ac=self.ac + x1=self.x1 + x2=self.x2 + t=self.t + p1=x1+v1*t+ac*t*t/2 + p1=real_subs(p1,**kwargs) + p2=p2 + p3=real_subs(p2,**kwargs) + QQ=MQ(p1,p2) + + + + def eQdynamicX(self,alpha=0,negative=False): + F=self.Fx_relative(alpha,kshow=False) + mm=self.m + ac=self.ac + if negative: + return MQ(F,-1*mm*ac) + else: + return MQ(F,mm*ac) + + def eQdynamicY(self,alpha=0,negative=False): + F=self.Fy_relative(alpha,kshow=False) + mm=self.m + ac=self.ac + if negative: + return MQ(F,-1*mm*ac) + else: + return MQ(F,mm*ac) + def eQmechanic(self): + kres=[] + are=self.dire + if are==0: + fx=self.x_res() + fy=self.y_res() + else: + fx=self.fx_relative(are) + fy=self.fy_relative(are) + veriV=fx+fy + all_var=fpoly(veriV,'list') + Nm=0 + Nmm='' + + if N1 in all_var: + Nm=N1 + Nmm=str(N1) + if N2 in all_var: + Nm=N2 + Nmm=str(N2) + N0=MyEq(csolve(fy,Nm),kname=Nmm) + kres.append(N0) + + if self.mu!=0: + fr=symbols('fr') + fr=MyEq(Nm*self.mu,kname='fr') + fx.upgrade(fr,kshow=False) + kres.append(fr) + if self.ac!=0: + ac0=symbols(self.ac.name) + + ac0=MyEq(fx/self.m,kname=self.ac.name) + kres.append(ac0) + else: + if T in all_var: + T0=symbols('T') + T0=fx.solve(T,'T') + kres.append(T0) + elif F in all_var: + F0=symbols('F') + F0=fx.solve(F,'F') + kres.append(F0) + return kres + + def eQ_dVx(self,kname='',**kwargs): #retuen dV eQ dynamic due Forze in x + mm=self.m + #Fx=self.x_res(**kwargs) + if self.dire==0: + fx=self.x_res(**kwargs) + else: + fx=self.x_res_relative(self.dire) + fx=real_subs(fx,**kwargs) + tt=self.dt + vv=self.v + kres=fx*tt/mm+vv + kres=real_subs(kres,**kwargs) + if kname=='': + return kres + else: + ee=MyEq(kres,kname) + return ee + + def eQ_dx_ac(self,kname=''): + + tt=self.dt + vv=self.v + acc=self.ac + kres=vv*tt+acc*tt*tt/2 + if kname=='': + kname='dx' + ee=MyEq(kres,kname) + return ee + + def eQ_dx(self,kname='',**kwargs): #retuen dx eQ dynamic due Forze in x + mm=self.m + tt=self.dt + vv=self.v + if self.dire==0: + fx=self.x_res(**kwargs) + else: + fx=self.x_res_relative(self.dire) + fx=real_subs(fx,**kwargs) + + acc=fx/mm + kres=vv*tt+acc*tt*tt/2 + kres=real_subs(kres,**kwargs) + if kname=='': + return kres + else: + ee=MyEq(kres,kname) + return ee + + + + + + +def ToInQ(P,kname='',kope=''): + if kname == '': + return MyEq(P.torque()-P.ang_moment(), 'T_oI_m', kope=kope) + else: + return MyEq(P.torque()-P.ang_moment(),kname, kope=kope) + + +def InToQ(P,kname='',kope=''): + return ToInQ(P=P,kname=kname,kope=kope) + +def WoEn(P,kname='',kope=''): + if kname == '': + return MyEq(P.energia()-P.x_res()*(P.x2-P.x1) , 'W_oE_e', kope=kope) + else: + return MyEq(P.energia()-P.x_res()*(P.x2-P.x1) ,kname, kope=kope) + +def EnWo(P,kname='',kope=''): + return WoEn(P=P,kname=kname,kope=kope) + + +def Eq_aceleration(P,var2=t,kname='',kop='x'): + if type(P)==mparticle: + if kop=='y': + kres=P.y_res()/P.m + else: + kres=P.x_res()/P.m + else: + kres=P + + ee1=MyEq(kres,sD('x',2),ktype='d2',var2=t) + ee2=MyDiff(kres,kvar=var2,kname=kname,ktype='square') + return ee1,ee2 + + + +def accx2diffxQ(ksym,kname='',kope='',Fx=0,m=0): + + if type(ksym)==mparticle: + Fx=ksym.x_res() + m=ksym.m + kres=Fx/m + else: + kres=ksym + + + kres=opemat(kres,kope) + ee1=MyEq(kres,sD('x',2),ktype='d2') + ee2=MyDiff(kres,t,kname=kname,ktype='square') + return [ee1,ee2] +def accy2diffyQ(*args,kope=''): + + qq=len(args) + if qq==1: + P=args[0] + Fy=P.y_res() + mm=P.m + kres=Fy/m + kres=opemat(kres,kope) + ee=MyEq(kres,sD('y',2),type='d2') + return ee + +def sD(kstr,kop=1): #put dot or double dot over symbol name + if kop==2: + sd='d\ddot{'+kstr+'_t}' + else: + sd='d\dot{'+kstr+'_t}' + return sd + + + +def sym2vec(mm): + kres='' + mm2=mm.split() + for i in mm2: + kres+=str(i)+'vec'+' ' + return( symbols(kres)) + + +class mspring: + def __init__(self,K=K,X1=X1,X2=X2,X0=X0): + + self.K=K # posicion 1 + self.X0=X0 + self.X1=X1 # altura 1 + self.X2=X2 # altura 1 + + + def xL(self): + x1=self.X1 + x2=self.X2 + return x2-x1 + + def Fx(self): + kk=self.K + return kk*self.xL() # Function used by physic_lab + + + +def polar2xy(R,alpha,op=''): + xx=R*cos(alpha) + yy=R*sin(alpha) + if op=='x': + return xx + elif op=='y': + return yy + else: + return (xx,yy) + +# Plot + +def eqParametricPlot(e1,e2,ksym,x1,x2,xx): + xxx=np.linspace(x1,x2,xx) + X=e1.evalueArray(ksym,xxx) + Y=e2.evalueArray(ksym,xxx) + plt.plot(X,Y,scalex=True,) + if max(Y)>0 and min(Y)<0: + + x = [int(min(X)),int(max(X))] + y = [0,0] + xres=(x1+x2)/2 + plt.fill_between(x, y, color='0.1') + + +def get_Iner_func(ktype='',mm=0,rr=0): # generar dormula de Inercia + + kres=0 + if ktype=='': + return kres + + elif ktype=='0': # puntual + kres=mm*rr*rr + return kres + + elif ktype=='1': # varilla de radio rr que gira en su centro + kres=mm*rr*rr/12 + return kres + + elif ktype=='2': # varilla de radio rr que gira en su extremo + kres=mm*rr*rr/3 + return kres + + else: + return 0 + +def reset_ee(*args): + + for i in args: + i.init=False + +def DimEq(val='',kname=''): + return setDeQ(val=val,kname=kname) +def setDeQ(val='',kname=''): + if val=="Area" : + kres= L*L + elif val=="Vol": + kres= L*L*L + elif val=="veloc": + kres= L/T + elif val=="accel": + kres= L/T/T + elif val=="Forz": + kres= M*L/T/T + elif val=="Work": + kres= M*L*L/T/T + elif val=="Energy": + kres= M*L*L/T/T + elif val=="Pot": + kres= M*L*L/T/T/T + elif val=="Pres": + kres= M/L/T/T + elif val=="Mom": + kres= M*L*L/T/T + elif val=="Freq": + kres= 1/T + elif val=="Perd": + kres= T + elif val=="Dens": + kres= M/L/L/L + elif val=="AngV": + kres= 1/T + else: + print('options : "Area","Vol","veloc","accel","Forz","Work","Energy","Pot","Pres","Mom","Freq","Perd","Dens","AngV"') + return + if kname=='': + return kres + else: + return MyEq(kres,kname) + +def subsvec(vec,**kwargs): # chage Obj.F data + newk=vec + newv=[] + for i in newk: + newp=[] + for j in i: + j=real_subs(j,**kwargs) + newp.append(j) + newv.append(newp) + return newv + + + +def basicope(kval,*args): + if 'simplify' in args: + kval=simplify(kval) + if 'factor' in args: + kval=factor(kval) + if 'expand' in args: + kval=factor(kval) + return kval + + + +def smartreturn(kres,name='',var=t): + if name=='': + return float2int(kres) + else: + ee=MyEq(float2int(kres),kname=name,var=var) + return ee + + + + + \ No newline at end of file diff --git a/Libaldo/lib_Variables.py b/Libaldo/lib_Variables.py new file mode 100644 index 0000000..2096c33 --- /dev/null +++ b/Libaldo/lib_Variables.py @@ -0,0 +1,70 @@ + + + +from sympy import * +import numpy as np +from lib_Mathematica import frs + + +n,m,m1,m2,m3,m4,M,g,x,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,y,y1,y2,X,Y,a,a1,a2,a3,v,v1,v2,M1,M2,M3, V ,V1 ,V2= symbols('n m m1 m2 m3 m4 M g x x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 y y1 y2 X Y a a1 a2 a3 v v1 v2 M1 M2 M3 V V1 V2 ') +w,w1,w2,aw,aw1,aw2,F,F1,F2,Rx,Ry,r,r1,r2,R,ax,ax1,ax2,ay,ay1,ay2= symbols('w w1 w2 aw aw1 aw2 F F1 F2 Rx Ry r r1 r2 R a_x ax1 ax2 a_y ay1 ay2') +mu,mu1,mu2,fr,fr1,fr2,f1, f2, f3,N1,N2,N3,Nm, L,L1,L2,h,h1,h2,b,H= symbols('mu mu1 mu2 fr fr1 fr2 f1 f2 f3 N1 N2 N3 Nm L L1 L2 h h1 h2 b H') +R1,R2,R3,rx,ry,fx1,fx2,fx3,fy1,fy2,fy3=symbols('R1 R2 R3 rx ry fx1 fx2 fx3 fy1 fy2 fy3') +alpha,tetha,t1, t2=symbols('alpha tetha t1 t2') + +at,an=symbols('a_t a_n') +vx,vy,In ,Fc,ac,aw =symbols('v_x v_y I_n F_c a_c a_w') +t,vxy,Po,Ti,I_n, a_c,a_t, Io=symbols('t vxy Po Ti In ac at Io') +T,T1,T2,t1,t2,t3 =symbols('T T1 T2 t1 t2 t3') +K,k,X1,X2,X0,d,W,P=symbols('K k X1 X2 X0 d W P') +rho,z,z1,z2,A,p=symbols('rho z z1 z2 A p') +xo,yo,zo,beta,xi,xf,x1,x2,y1,y2=symbols('xo yo zo beta xi xf x1 x2 y1 y2') +yp,xp,pp=symbols("y' x' p'") + + +A,A1,A2,B,B1,B2,C,C1,C2,D,D1,D2,Q,Q1,Q2,S,S1,S2,Z,Z1,Z2=symbols('A A1 A2 B B1 B2 C C1 C2 D D1 D2 Q Q1 Q2 S S1 S2 Z Z1 Z2') +# diff variables + +dm,ds,dx,dy,dz,dt,dr,dh,dL,da,dA,dv,dV,dM,=symbols('dm ds dx dy dz dt dr dh dL da dA dv dV dM') + +Vo,Lo,Xo,Yo,Zo=symbols('Vo Lo Xo Yo Zo') +Fx1,Fy1,To1=symbols('Fx1 Fy1 To1') + +# constantes +A53=atan(frs(4,3)) # ang 53 = atan(4/3) +A37=atan(frs(3,4)) # ang 37 = atan(3/4) + +S53=frs(4,5) # ang 53 +C53=frs(3,5) +T53=frs(4,3) + +S37=frs(3,5) # ang 37 +C37=frs(4,5) +T37=frs(3,4) + +S45= sqrt(2)/2 # ang 45 +C45=sqrt(2)/2 +T45=1 + +S30=frs(1,2) # ang 30 +C30=sqrt(3)/2 +T30=sqrt(3)/3 + +S60=sqrt(3)/2 # ang 60 +C60=frs(1,2) +T60=sqrt(3) +from IPython import display + + +import matplotlib.pyplot as plt + +from PIL import Image # to load images +from IPython.display import display # to display images +dx,dy,dz,dw,du,dv=symbols( 'dx dy dz dw du dv') + +def kkdis(sval): + sR = sval+' = ' + sV = eval(sval) + display(Math(sR + latex(sV))) + + \ No newline at end of file diff --git a/Libaldo/lib_funcdiff.py b/Libaldo/lib_funcdiff.py new file mode 100644 index 0000000..0baa9b3 --- /dev/null +++ b/Libaldo/lib_funcdiff.py @@ -0,0 +1,76 @@ + + +from libaldo_math2 import * +from libaldo_algorith import * +from mathexponencial import * +from mathbasic import * +from sympy import * +## PARTIAL FRACTION... + +def primesymboldiff(var): + svar=str(var) + dsvar1=svar+"'" + dsvar2=svar+"''" + kres= dsvar1+' '+dsvar2 + dsvar1=symbols(dsvar1) + dsvar2=symbols(dsvar2) + return dsvar1,dsvar2 + +def functiondiff(QQ,var,var2): + ksym=QQ.ksym + f=Function(str(var2))(var) + ksym2=subsubs(ksym,var2,f) + kres=diff(ksym2,var) + return kres + +def sympydiff2prime(expr,var,var2): + Y=symbols(str(var2)) + p1=str(expr) + svar=str(var2) + dy,dy2=primesymboldiff(var2) + + p2='d'+str(var2) + p3=p2+'2' + + F=Function(str(var2))(var) + df=F.diff(var) + df2=F.diff(var,var) + p4=str(df) + p5=str(df2) + p1=p1.replace(p5,p3) + p1=p1.replace(p4,p2) + p1=p1.replace(str(F),svar) + fres=eval(p1) + fres=fres.subs(p3,dy2) + fres=fres.subs(p2,dy) + fres=fres.subs(F,Y) + return fres + + +def primediff2sympy(expr,var,var2): + dp2=str(var2)+"''" + dp1=str(var2)+"'" + yvar=str(var2) + xvar=str(var) + f=Function(yvar)(var) + df=diff(f,var) + df2=diff(f,var,var) + sf=yvar+'('+xvar+')' + sdf=str(df) + sdf2=str(df2) + sexpr=str(expr) + sexpr=sexpr.replace(dp2,'D2') + sexpr=sexpr.replace(dp1,'D1') + sexpr=sexpr.replace(yvar,sf) + sexpr=sexpr.replace('D2',sdf2) + sexpr=sexpr.replace('D1',sdf) + return parse_expr(sexpr) + + +def changedview(expr,var1,var2): + sexpr=str(expr) + if "'" in sexpr: + return primediff2sympy(expr,var1,var2) + else: + return sympydiff2prime(expr,var1,var2) + \ No newline at end of file diff --git a/Libaldo/lib_tools.py b/Libaldo/lib_tools.py new file mode 100644 index 0000000..a0f5aff --- /dev/null +++ b/Libaldo/lib_tools.py @@ -0,0 +1,2011 @@ +from sympy import * +from lib_Mathematica import * +from lib_Mathbasic import * +from lib_Algorith import * + +from lib_MyEq import * +from lib_MyEqEq import * + + +def getexpr(expr): + if type(expr)==MyEq: + return expr.ksym + elif type(expr)==MyEqEq: + return expr.e1.ksym-expr.e2.ksym + else: + return expr + +def compareandsolve(*args,var=x,eQ=True): + vec,var=presolvecoeff(*args,var=var) + VAR=[] + VSOLU=[] + done=True + while len(vec)>0 and done: + for i in vec: + vS=symbolslist(i) + if len(vS)==1: + var=list(vS) + var=var[0] + kres=solve(i,var) + kres=kres[0] + + VAR.append(var) + VSOLU.append(kres) + break + vec2=[] + for i in vec: + vec2.append(i.subs(var,kres)) + vec3=[] + for i in vec2: + vS=symbolslist(i) + if len(vS)>0: + vec3.append(i) + vec=vec3 + if eQ: + eeres=[] + for i,j in zip(VSOLU,VAR): + ee=MyEq(i,str(j),var=var) + eeres.append(ee) + return eeres + else: + return VAR, VSOLU +def simplecompareandsolve(*args): + VAR=[] + VSOLU=[] + done=True + vec=args[0] + + while len(vec)>0 and done: + for i in vec: + vS=symbolslist(i) + if len(vS)==1: + var=list(vS) + var=var[0] + kres=solve(i,var) + kres=kres[0] + + VAR.append(var) + VSOLU.append(kres) + break + vec2=[] + for i in vec: + vec2.append(i.subs(var,kres)) + vec3=[] + for i in vec2: + vS=symbolslist(i) + if len(vS)>0: + vec3.append(i) + vec=vec3 + + eeres=[] + for i,j in zip(VSOLU,VAR): + ee=MyEq(i,str(j),var=var) + eeres.append(ee) + return eeres +def presolvecoeff(*args,var=x): + vec,vecv=presolvedata(*args,var=var) + vec=vec[0] + kres=expand(vec) + kres=sortdegree(kres,var) + kres=coef_list(kres,var) + + #vec1=coef_list(vec,var) + return kres,vecv + +def presolvedata(*args,var=x): + ''' + return ( vec expr to solve, vec variables)... + ''' + vecf=[] + vecv=[] + for i in args: + if type(i)==MyEqEq: + vecf.append(i.L-i.R) + elif type(i)==MyEq: + vecf.append(i.ksym) + elif Is_Symbol(i): + vecv.append(i) + elif type(i)==list: + if Is_Symbol(i[0]): + vecv=vecv+i + else: + vecf.append(i) + if vecv==[]: + p3=sum(vecf) + vecv=symbolslist(p3,var) + return vecf,vecv + + + +def solveSys(*args,var=x,eQ=True): + ''' + input args[0]= [31𝑎+6𝑏+339, −30𝑎−5𝑏−320] + args[1]=[a,b] + return + a=-9 + b=10 + ''' + done=False + if type(args[0])!=list: + args2=[] + for i in args: + if type(i)!=str: + args2.append(i) + if i=='Eq': + done=True + args=args2 + args=presolvedata(*args,var=var) + + vec=args[0] + vec2=[] + for i in vec: + if type(i)==MyEq: + vec2.append(i.ksym) + elif type(i)==MyEqEq: + vec2.append(i.L-i.R) + else: + vec2.append(i) + + var=args[1] + kres=solve_poly_system(vec2,var) + kres=kres[0] + mm=[] + if eQ: + for i,j in zip(var,kres): + display(Math(str(i)+'= '+latex(j))) + return kres + + + else: + return kres + + +def pre_solvecoef(v1,v2): + V1=[] + V2=[] + for i,j in zip(v1,v2): + if i==0 and j==0: + pass + else: + V1.append(i) + V2.append(j) + return (V1,V2) + + +def MySolve(*args,eQ=True,variables=False): + veceq=[] + vecvar=[] + if len(args)==1 and type(args[0])==list: + args=args[0] + for i in args: + if type(i)==MyEqEq: + veceq.append(i.L-i.R) + elif type(i)==MyEq: + veceq.append(i.ksym) + + elif Is_Symbol(i): + vecvar.append(i) + else: + veceq.append(i) + + if len(vecvar)==0: + for i in veceq: + lsym=symbolslist(i) + for j in lsym: + if j not in vecvar: + vecvar.append(j) + + vecss=[str(k) for k in vecvar] + vecss.sort() + vecvar=[symbols(k) for k in vecss] + + if variables: + return solveSys(veceq,vecvar,eQ=False), vecvar + else: + return solveSys(veceq,vecvar,eQ=eQ) + +# SOLVE OEFFIECIENT LIST ATB + +def pre_vec2compare(vec1,vec2): #atb + + ''' + pre_vec2compare([a,b,c,5,d],[z,1,3,2,x]) =[a,b,c,d],[z,1,3,x]) + preveent that 5=2 + + ''' + nv1=[] + nv2=[] + for i,j in zip(vec1,vec2): + if not Is_Number(i) or not Is_Number(j): + nv1.append(i) + nv2.append(j) + return nv1,nv2 + +def pre_coeff2list(expr1,expr2,var=x): #atb + ''' + match two list of coeff with the same haight degree + input (math exp, math exp) + output( coeff_vec,coeff_vec]) + + pre_coeff2list(x**4+1,a*x**4+b*x+c])= + ([1,0,0,0,1],[a,0,0,b,c]) + + ''' + d1=degree(expr1,var) + d2=degree(expr2,var) + d3=max(d1,d2) + vec1=coef_list(expr1,var,d3) + vec2=coef_list(expr2,var,d3) + vec1,vec2=pre_vec2compare(vec1,vec2) + return vec1,vec2 + +def pre_coeff0(expr,var=x): #atb + ''' + input: mathexp,main var + return: coeffvec + + pre_coeff0((a+1)*x**3+(b-2)*x*x+4,x)= [a+1,b-2] + a+1=0,b+a=0, 4=0??? + + ''' + expv=coef_list(expr,var) + kres=[] + for i in expv: + vres=symbolslist(i,var) + if len(vres)>0: + kres.append(i) + return kres + + +def solvecoefficients(*args,var=x): #atb + ''' + return solutions when compare coeffircient in expr + or between two expr, + the algorith try to get var to solve or + set who var will be solve + + input args: + * MyEqEq + * MyEq + * matexpr + * MyEq,matexpr + * MyEq,MyEq + * matexpr,matexpr + * MyEqEq,var1,var2.. + * MyEq,var1,var2.. + * matexpr,var1,var2.. + * MyEq,matexpr,var1,var2.. + * MyEq,MyEq,var1,var2.. + * matexpr,matexpr ,var1,var2.. + + ''' + vecss=[] + for i in args: + if Is_Symbol(i): + vecss.append(i) + done=False + if len(vecss)>0: + done=True + + if len(args)==1: + data=args[0] + if type(data)==MyEqEq: + p1=data.L + p2=data.R + vec1,vec2=pre_coeff2list(p1,p2,var=var) + vec3=SubstracList(vec1,vec2) + p3=p1+p2 + elif type(data)==MyEq: + p1=data.ksym + #vec3=coef_list(p1,var) + vec3=pre_coeff0(p1,var) + p3=p1 + else: + p1=data + #vec3=coef_list(data,var) + vec3=pre_coeff0(p1,var) + + p3=p1 + elif len(args)>1: + p1=args[0] + if type(p1)==MyEqEq: + P1=p1.L + P2=p1.R + vec1,vec2=pre_coeff2list(P1,P2,var=var) + vec3=SubstracList(vec1,vec2) + p3=P1+P2 + elif type(p1)==MyEq: + p1=p1.ksym + p3=p1 + vec3=pre_coeff0(p1,var) + if type(args[1])!=Symbol: + p2=args[1] + if type(p2)==MyEq: + p2=p2.ksym + p3=p1-p2 + vec1,vec2=pre_coeff2list(p1,p2,var=var) + vec3=SubstracList(vec1,vec2) + else: + vec3=coef_list(p1,var) + p3=p1 + + + if done: + vecv=vecss + else: + vecv=symbolslist(p3,var) + + vecargs=[] + for i in vec3: + vecargs + return solveSys(vec3,vecv,'Eq') + + +def solvecoefflist(*args,var=x): + vecss=[] + for i in args: + if Is_Symbol(i): + vecss.append(i) + done=False + if len(vecss)>0: + done=True + + if len(args)==1: + data=args[0] + if type(data)==MyEqEq: + p1=data.L + p2=data.R + vec1,vec2=pre_coeff2list(p1,p2,var=var) + vec3=SubstracList(vec1,vec2) + p3=p1+p2 + elif type(data)==MyEq: + p1=data.ksym + #vec3=coef_list(p1,var) + vec3=pre_coeff0(p1,var) + p3=p1 + else: + p1=data + #vec3=coef_list(data,var) + vec3=pre_coeff0(p1,var) + + p3=p1 + elif len(args)>1: + p1=args[0] + if type(p1)==MyEqEq: + P1=p1.L + P2=p1.R + vec1,vec2=pre_coeff2list(P1,P2,var=var) + vec3=SubstracList(vec1,vec2) + p3=P1+P2 + elif type(p1)==MyEq: + p1=p1.ksym + p3=p1 + vec3=pre_coeff0(p1,var) + if type(args[1])!=Symbol: + p2=args[1] + if type(p2)==MyEq: + p2=p2.ksym + p3=p1-p2 + vec1,vec2=pre_coeff2list(p1,p2,var=var) + vec3=SubstracList(vec1,vec2) + else: + vec3=coef_list(p1,var) + p3=p1 + + + if done: + vecv=vecss + else: + vecv=symbolslist(p3,var) + + #return vec3,vecv + return solveSys(vec3,vecv,'Eq') +def solvecoeflist(*args): + if len(args)==1 and type(args[0])==MyEqEq: + expr=args[0] + p1=expr.L + p2=expr.R + ce1=coef_list(p1) + ce2=coef_list(p2) + ce1,ce2=pre_solvecoef(ce1,ce2) + vecf=[] + for i, j in zip(ce1,ce2): + vecf.append(i-j) + kres=solve(vecf) + return kres + elif len(args)==2 and type(args[0])==MyEqEq: + expr=args[0] + p1=expr.L + p2=expr.R + ce1=coef_list(p1) + ce2=coef_list(p2) + ce1,ce2=pre_solvecoef(ce1,ce2) + vecf=[] + for i, j in zip(ce1,ce2): + vecf.append(Eq(i,j)) + kres=solve(vecf,args[1]) + if type(kres)==list: + if type(kres[0])==tuple: + kres=kres[0] + for i,j in zip(args[1],kres): + display(Math(str(i)+'= '+latex(str(j)))) + return kres + +def preanswer(*args): + kres=args[0] + rres=kres + if 'real' in args: + rres=[G for G in kres if not 'I' in str(G)] + if type(rres)==list and len(rres)==1: + rres=rres[0] + if type(rres)==dict: + vecs,vval= kunpakDic(rres) + if 'Eq' in args: + mm=[] + for i,j in zip(vecs,vval): + ee=MyEq(j,str(i)) + mm.append(ee) + return mm + else: + return vval + +########################################## +# ALgorith FUnctions + +def inversefunc(*args): + '''return inverse function of expr + resoect var + input(function math, var + inversefunc(x**3+4,x) + return (x - 4)**(1/3) + ''' + if len(args)==0: + helplib('inversefunc') + return + expr=args[0] + var=args[1] + yy=symbols('yy') + + expr=subsubs(expr,var,yy) + + ee=MyEq(var-expr,'ee',var=yy,kshow=False) + + try: + kres=ee.solve(yy,kshow=False) + except: + kres=0 + return kres + +########################################## +# PARTIAL FRACTION RE ULTRA NERD ALGORITH + +def mdaughter(expr,fabr,var=x): + ''' + retunr correspondients momonies that + will be used to create partial fraction.. + exaple: + mdaughter((x+1)) = y1 + mdaughter((x+1)*(x-2)) = y1,y2 + mdaughter((x+1)*(x-2)**3) = y1,y2,y3,y4,y5 + mdaughter((x+1)*(x*x-2)**2) = y1,(x*y2+y3),(x*y3+y4) + ''' + + bb=getbase(expr) + ee=getexpo(expr) + dd=degree(bb,gen=var) + mm2=[] + cc=0 + for i in range(ee): + mm3=0 + for j in range(dd): + mm3=mm3+var**j*fabr[cc] + cc=cc+1 + mm2.append(mm3) + frb2=fabr[cc:len(fabr)] + return mm2,frb2 + + +def vec_daughter(expr2,var=x): # used in partialfracction + # retun vector whit respevctive nuerator formato por mdauther + y1,y2,y3,y4,y5,y6,y7,y8,y9,y10=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10') + y11,y12,y13,y14,y15,y16=symbols('y11 y12 y13 y14 y15 y16') + fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] + if Is_Mul(expr2): + mmm=fpoly(expr2,'list') + else: + mmm=[expr2] + kres=[] + for j in mmm: + exp1,fabr=mdaughter(j,fabr,var=var) + for i in exp1: + kres.append(i) + return kres + +def complete2partfrac(vec): + # complete missing monomies to run partial fracction algorith + vec2=[] + if Is_Mul(vec): + vecmono=fpoly(vec,'list') + else: + vecmono=[vec] + for i in vecmono: + if Is_Pow(i): + ee=getexpo(i) + bb=getbase(i) + + for j in range(1,ee+1): + vec2.append(ppow(bb,j)) + else: + vec2.append(i) + return vec2 + +def partialfraction(expr,var=x): + ''' + input : x/((x+1)*(x-1)) + return :-1/(x - 1) + 2/(x - 2) + ''' + if type(expr)==MyEq: + expr=expr.ksym + Q=0 + kp1,kp2=fraction(expr) + gg1=degree(kp1,gen=var) + gg2=degree(kp2,gen=var) + + if gg1>gg2 or gg1==gg2: + Q=quo(kp1,kp2) + R=rem(kp1,kp2) + + expr=cfrac(R,kp2) + + + + + + p1=numer(expr) + p2=denom(expr) + vec2=complete2partfrac(p2) + vec1=vec_daughter(p2,var=var) + + P=0 + for i,j in zip(vec1,vec2): + P=P+cfrac(i,j) + + P2=factor(P) + pp1,pp2=fraction(P2) + + pp1=sortdegree(pp1,var) + pp2=sortdegree(expand(p1),var) + gg1=degree(pp1,var) + gg2=degree(pp2,var) + ksize=max(gg1,gg2) + PP1=coef_list(pp1,var2=var,size=ksize) + PP2=coef_list(pp2,var2=var,size=ksize) + + masterq=[] + for i,j in zip(PP1,PP2): + masterq.append(i-j) + + vecsolu,vecvar= MySolve(masterq,variables=True) + for i,j in zip(vecvar,vecsolu): + P=P.subs(i,j) + return P+Q + + +# diferential + +def deltasym(var): + #sdx= +str(var) + sdx= +str(var) + dx=symbols(sdx) + return dx + +def solveQ(*args): + vecq=[] + for i in args: + if type(i)!=str: + if type(i)==MyEqEq: + vecq.append(i.L-i.R) + elif type(i)==MyEq: + vecq.append(i.ksym) + + else: + vecq.append(i) + kres=solve(vecq) + + if type(kres)==list: + Kres=[] + fval=kres[0] + kvar,kval=unpack(fval) + for i in kres: + kvar2,kval2=unpack(i) + Kres.append(kval2) + qq=len(kres) + + qq2=len(kvar) + sk=[] + for j in range(qq2): + sk2=[] + for i in range(qq): + sk2.append(Kres[i][j]) + sk.append(sk2) + for i,j in zip(kvar,sk): + display(Math(str(i)+" = "+latex(j))) + return sk + + + + if type(kres)==dict: + kvar,kval=unpack(kres) + + if 'value' in args: + return kval + if 'eQ' in args: + ee=[] + for i,j in zip(kvar,kval): + ee.append(MyEq(j,str(i))) + return ee + + return kres + +def expr2var(expr,svar): + var=symbols(svar) + expr=subsubs(expr,svar,var) + return expr + + +def getdataexpr(expr): + if type(expr)==MyEqEq: + return expr.L-expr.R + elif type(expr)==MyEq: + return expr.ksym + else: + return expr + +def getvecvar(*args): + vecvar=[] + obj=obj2expr(*args) + for i in obj: + if type(i)!=str: + kres=list(i.free_symbols ) + for j in kres: + if type(j)==Symbol: + if j not in vecvar: + vecvar.append(j) + + return vecvar + +def getvecexpr(*args): + vecexpr=[] + for i in args: + if type(i)!=str: + if type(i)==list or type(i)==tuple: + for j in i: + if type(j)!=Symbol: + kres=getdataexpr(j) + if j not in vecexpr: + vecexpr.append(float2int(kres)) + else: + if type(i)!=Symbol: + kres=getdataexpr(i) + if i not in vecexpr: + vecexpr.append(kres) + return vecexpr + +###################### +## SIMPLE SOLVE + +def filtermathexpr(expr): + ''' + return significative math equation in expr + else return '' + ''' + if type(expr)==MyEqEq: + + kres= float2int(expr.L-expr.R) + return kres + elif type(expr)==MyEq: + return float2int(expr.ksym) + elif '+' in str(expr) or '-' in str(expr): + return float2int(expr) + else: + return '' + +def getmatexpr(*args): + ''' + return all posible mathh equation + to will be evaluates in solve + input,list,tuple,MyEq MyEqEq, math expr + ''' + vecexpr=[] + prevec=[] + for i in args: + + if type(i)==Matrix: + H,W=i.shape + for ii in range(H): + for jj in range(W): + kres=filtermathexpr(i[ii,jj]) + if kres!='': + if type(kres)==list: + for j in kres: + vecexpr.append(kres) + else: + vecexpr.append(kres) + + + elif type(i)==list or type(i)==tuple or type(i)==Array: + for j in i: + kres=filtermathexpr(j) + if kres!='': + if type(kres)==list: + for j in kres: + vecexpr.append(float2int(kres)) + else: + vecexpr.append(float2int(kres)) + else: + kres=filtermathexpr(i) + if kres!='': + if type(kres)==list: + for j in kres: + vecexpr.append(float2int(kres)) + else: + vecexpr.append(float2int(kres)) + vecexpr= unisymbols(vecexpr) + return vecexpr + +def presolve(*args): + vecvar=[] + + for i in list(args): + if type(i)==Symbol: + vecvar.append(i) + vecmath=getmatexpr(*args) + vecvar2=[] + for i in list(vecmath): + vtup=i.free_symbols + vlist=list(vtup) + for j in vlist: + if j not in vecvar2: + vecvar2.append(j) + return vecvar,vecvar2,vecmath + +def premath(expr,*args): + ''' + pre trasforms aswer in simplesolve + ''' + if 'factor' in args: + expr=factor(expr) + if 'simplify' in args: + expr=simplify(expr) + if 'expand' in args: + expr=expand(expr) + if 'reduce' in args: + expr=reduce(expr) + if 'unisymbols' in args: + expr=unisymbols(expr) + if 'float' in args: + try: + expr=float(expr) + except: + pass + return expr +def spreanswer(expr): + mm2=str(expr) + smm=mm2.replace(',), (',',') + smm=smm.replace('[(','[') + smm=smm.replace(')]',']') + try: + mm3=parse_expr(smm) + return mm3 + except: + return expr +def prepresolve(*args): + args2=[] + for i in args: + if type(i)==MyEq: + if type(i.ksym)==list or type(i)==Array: + if type(i)==Array: + L=list(i.ksym) + else: + L=i.ksym + for j in L: + args2.append(j) + else: + arg2.append(i) + elif type(i)==MyEqEq: + if type(i.L)==list or type(i.L)==Array: + if type(i.L)==Array: + L=list(i.L-i.R) + else: + L=i.L-i.R + for j in L: + args2.append(j) + else: + arg2.append(i) + elif type(i)==Array: + L=list(i) + for j in L: + args2.append(j) + + elif type(i)==list: + for j in L: + args2.append(j) + else: + args2.append(i) + return args2 + +def prepresolve(*args): + args2=[] + for i in args: + if type(i)==MyEq: + if type(i.ksym)==list or type(i.ksym)==Array: + if type(i)==Array: + L=list(i.ksym) + else: + L=i.ksym + for j in L: + args2.append(j) + else: + args2.append(i) + elif type(i)==MyEqEq: + if type(i.L)==list or type(i.L)==Array: + if type(i.L)==Array: + L=list(i.L-i.R) + else: + L=[p2-p1 for p2,p1 in zip(i.L,i.R)] + for j in L: + args2.append(j) + else: + args2.append(i) + elif type(i)==Array: + L=list(i) + for j in L: + args2.append(j) + + elif type(i)==list: + for j in L: + args2.append(j) + else: + args2.append(i) + + return args2 + +def simplesolve(*args,kshow=True,**kwargs): + ''' + input mathexpr eq, MyE,;yEqEq, tuple or list of math eq + and variables to solve + if not was input variables + the system assum deafult there are in all expr.. + + example: + pp=(x+y-4,3*x-5*y+1) + A=MyEq(z*3+y,'A') + Q=MQ(3*sin(alpha),27) + + x,y,z=simplesolve(pp,A,Q,x,y,z, op= 'factor','simplify','expand','reduce' + 'unisymbols', + 'show'= nice display) + return x,y,x values in solve the eqss + + + ''' + args2=prepresolve(*args) + args=args2 + vecvar,vecvar2,vecexpr=presolve(*args) + vecmath=[] + if vecvar==[]: + vecvar=vecvar2 + qq=len(vecvar) + if len(kwargs)>0: + vecexpr=[real_subs(i,**kwargs) for i in vecexpr] + #return vecmath,vecvar + kres=solve(vecexpr,vecvar) + kres=spreanswer(kres) + + if type(kres)==dict: + svar,valor=unpack(kres) + kres=valor + if 'all' in args: + if 'noimg' in args or 'noimaginary' in args: + kres2=[] + for i in kres: + if not 'I' in str(i): + kres2.append(i) + if kshow: + display(Math(latex(kres2))) + return kres2 + else: + if kshow: + display(Math(latex(kres))) + return kres + elif type(kres)==tuple: + kres=list(kres) + svar=[str(i) for i in vecvar] + + elif type(kres)==list: + if type(kres[0])==tuple: + kres=list(kres[0]) + elif type(kres[0])==list: + kres=kres[0] + svar=[str(i) for i in vecvar] + + else: + kres=[kres] + svar=[str(i) for i in vecvar] + + kres2=[] + for i in kres: + kres2.append(premath(i,*args)) + + if 'all' in args: + return kres2 + + if 'noshow' not in args: + + vecee=[] + for i,j in zip(kres2,svar): + if 'pos' in args or 'positive' in args: + ee=MyEq(i*signo(i),kname=str(j),kshow=kshow) + + else: + ee=MyEq(i,kname=str(j),kshow=kshow) + vecee.append(ee) + kres2=vecee + if 'value' in args: + kres2=[i.ksym for i in kres2] + if len(kres2)==1: + kres2=kres2[0] + + return kres2 +def simplesolves(*args, **kwargs): + + vecexpr, vecvar, vecstr2 = obj2vec3(*args) + ops=['noshow','float'] + ops2=[] + vecstr=[] + for i in vecstr2: + if i not in ops: + vecstr.append(i) + else: + ops2.append(i) + if vecvar == []: + vecvar = getvecvar(*vecexpr) + if len(kwargs)>0: + vecexpr=[real_subs(i,**kwargs) for i in vecexpr] + if vecvar == []: + kres = solve(*vecexpr) + else: + kres = solve(vecexpr, vecvar) + + if type(kres) == dict: + svar, valor = unpack(kres) + kres = valor + if 'float' in args: + kres2=[] + for i in valor: + try: + kres2.append(float(i)) + except: + kres2.append(i) + kres=kres2 + valor=kres2 + elif type(kres)==list: + if type(kres[0])==tuple: + cc=1 + valor=[] + svar=[] + for i in kres: + for j,k in zip(vecvar,i): + svar.append(sympify(str(j))+sympify(str(cc))) + if 'float' in args: + print('a') + try: + valor.append(float(k)) + except: + valor.append(k) + else: + valor.append(k) + cc=cc+1 + kres=valor + + + + + + if 'noshow' not in ops2: + for i,j in zip(svar,valor): + kvar=i + svar=str(i) + svar=svar.replace('_','') + display(Math(svar+'='+latex(j))) + if len(kres)==1: + return kres[0] + return kres +''' +def simplesolve(*args,positive=''): + + input mathexpr eq, MyE,;yEqEq, tuple or list of math eq + and variables to solve + if not was input variables + the system assum deafult there are in all expr.. + + example: + pp=(x+y-4,3*x-5*y+1) + A=MyEq(z*3+y,'A') + Q=MQ(3*sin(alpha),27) + + x,y,z=simplesolve(pp,A,Q,x,y,z, op= 'factor','simplify','expand','reduce' + 'unisymbols', + 'show'= nice display) + return x,y,x values in solve the eqss + + + + + vecvar,vecvar2,vecexpr=presolve(*args) + + vecmath=[] + if vecvar==[]: + vecvar=vecvar2 + qq=len(vecvar) + + #return vecmath,vecvar + if positive!='': + positive=Symbol(positive, positive=True) + kres=solve(float2int(vecexpr),vecvar) + if 'all' in args: + return solve(vecexpr) + + if 'float' in args: + kres2=[] + for i in kres: + try: + kres2.append(float(i)) + except: + kres2.append(i) + kres=kres2 + + if type(kres)==dict: + svar,valor=unpack(kres) + + kres=valor + + + elif type(kres)==tuple: + kres=list(kres) + svar=[str(i) for i in vecvar] + + elif type(kres)==list: + if type(kres[0])==tuple: + kres=list(kres[0]) + if 'pos' in args or 'positive' in args: + kres=kres[1] + + elif type(kres[0])==dict: + kres=kres[0] + if 'pos' in args or 'positive' in args: + kres=kres[1] + + svar=[str(i) for i in vecvar] + + else: + kres=[kres] + svar=[str(i) for i in vecvar] + + kres2=[] + for i in kres: + kres2.append(premath(i,*args)) + + if 'eq' in args or 'Eq' in args: + kres3=[] + for i,j in zip(kres2,svar): + ee= MyEq(i,j) + kres3.append(ee) + if type(kres3)==list and len(kres3)==1: + return kres3[0] + else: + return kres3 + + + + + if 'noshow' not in args: + vecee=[] + for i,j in zip(kres2,svar): + mkres=i + if 'positive' in args: + mkres=signo(i)*i + + ee=MyEq(mkres,kname=str(j)) + + vecee.append(ee) + + if type(kres2)==list and len(kres2)==1: + kres=kres2[0] + if 'positive' in args: + kres=signo(kres)*kres + return kres + return kres2 + +''' +def showtuple(svar,vvar): + for i,j in zip(svar,vvar): + sp1=str(i)+'=' + display(Math(sp1+latex(j))) + +#### tools Argssss + +vecreatr=["","","","",""] +def ruta(expr,infoexpr,infopos,cc): + mm=expr.args + if len(mm)>0: + for i in range(len(mm)): + nexp=mm[i] + npos=cc+str(i) + + if nexp not in infoexpr: + if str(type(nexp)) not in vecreatr : + if nexp not in infoexpr: + if not Is_Number(nexp): + + infoexpr.append(nexp) + infopos.append(npos) + try: + nexp,ninfo,ncc=ruta(nexp,infoexpr,infopos,npos) + return nexp,ninfo,ncc + except: + pass + return expr,infoexpr,infopos,cc + else: + return expr,infoexpr,infopos,cc + +def str2vec(sexpr): + kvec=[] + for i in sexpr: + kvec.append(int(i)) + return kvec + +def argsmap (expr,kname='A',deep=2,data=False): + infoexpr=[] + infopos=[] + cc='' + A,B,C,D=ruta(expr,infoexpr,infopos,cc) + mapval=[] + mappos=[] + for i,j in zip(B,C): + if Is_Div(i): + if numer(i)!=1: + mapval.append(i) + mappos.append(j) + + else: + mapval.append(i) + mappos.append(j) + + mapval,mappos=filterNegPos(mapval,mappos) + if len(mapval)==0: + return + if data: + return mapval,mappos + svecargs=[] + sres='' + superres='' + if kname!='': + + for i in mappos: + sres=kname+'.args(' + for k in i: + sres=sres+k+',' + sres=sres[0:-1] + sres=sres+')=' + svecargs.append(sres) + mm='' + for i,j in zip(svecargs,mapval): + mm=mm+ " "+'['+i+latex(j)+'],' + display(Math(mm)) + +def realsub2(expr,**kwargs): + vecs,vecv=unpack(kwargs) + for i,j in zip(vecs,vecv): + if i in nombresdiferen: + expr=expr.subs(eval(i),j) + elif type(j)==MyEq: + expr=expr.subs(i,j.ksym) + else: + expr=expr.subs(i,j) + return expr + +def transform2(expr1,expr2,var=x): + A,B,C,D=symbols('A B C D') + vecvar=[A,B,C,D] + svecvar=['A','B','C','D'] + sexpr2=str(expr2) + vecres=[] + for i,j in zip(svecvar,vecvar): + if i in sexpr2: + vecres.append(j) + Q=expand(expr1)-expand(parse_expr(sexpr2)) + nvec= coef_list(Q,var) + vecres2=simplesolve(nvec,'noshow') + if type(vecres2)!=list: + vecres2=[vecres2] + expr3=parse_expr(expr2) + for i,j in zip(vecres,vecres2): + expr3=expr3.subs(i,j) + return expr3 + +import math +import numpy as np + +# Main Function takes in the coefficient of the Cubic Polynomial +# as parameters and it returns the roots in form of numpy array. +# Polynomial Structure -> ax^3 + bx^2 + cx + d = 0 + +def solve3(a, b, c, d): + + if (a == 0 and b == 0): # Case for handling Liner Equation + return np.array([(-d * 1.0) / c]) # Returning linear root as numpy array. + + elif (a == 0): # Case for handling Quadratic Equations + + D = c * c - 4.0 * b * d # Helper Temporary Variable + if D >= 0: + D = math.sqrt(D) + x1 = (-c + D) / (2.0 * b) + x2 = (-c - D) / (2.0 * b) + else: + D = math.sqrt(-D) + x1 = (-c + D * 1j) / (2.0 * b) + x2 = (-c - D * 1j) / (2.0 * b) + + return np.array([x1, x2]) # Returning Quadratic Roots as numpy array. + + f = findF(a, b, c) # Helper Temporary Variable + g = findG(a, b, c, d) # Helper Temporary Variable + h = findH(g, f) # Helper Temporary Variable + + if f == 0 and g == 0 and h == 0: # All 3 Roots are Real and Equal + if (d / a) >= 0: + x = (d / (1.0 * a)) ** (1 / 3.0) * -1 + else: + x = (-d / (1.0 * a)) ** (1 / 3.0) + return np.array([x, x, x]) # Returning Equal Roots as numpy array. + + elif h <= 0: # All 3 roots are Real + + i = math.sqrt(((g ** 2.0) / 4.0) - h) # Helper Temporary Variable + j = i ** (1 / 3.0) # Helper Temporary Variable + k = math.acos(-(g / (2 * i))) # Helper Temporary Variable + L = j * -1 # Helper Temporary Variable + M = math.cos(k / 3.0) # Helper Temporary Variable + N = math.sqrt(3) * math.sin(k / 3.0) # Helper Temporary Variable + P = (b / (3.0 * a)) * -1 # Helper Temporary Variable + + x1 = 2 * j * math.cos(k / 3.0) - (b / (3.0 * a)) + x2 = L * (M + N) + P + x3 = L * (M - N) + P + + return np.array([x1, x2, x3]) # Returning Real Roots as numpy array. + + elif h > 0: # One Real Root and two Complex Roots + R = -(g / 2.0) + math.sqrt(h) # Helper Temporary Variable + if R >= 0: + S = R ** (1 / 3.0) # Helper Temporary Variable + else: + S = (-R) ** (1 / 3.0) * -1 # Helper Temporary Variable + T = -(g / 2.0) - math.sqrt(h) + if T >= 0: + U = (T ** (1 / 3.0)) # Helper Temporary Variable + else: + U = ((-T) ** (1 / 3.0)) * -1 # Helper Temporary Variable + + x1 = (S + U) - (b / (3.0 * a)) + x2 = -(S + U) / 2 - (b / (3.0 * a)) + (S - U) * math.sqrt(3) * 0.5j + x3 = -(S + U) / 2 - (b / (3.0 * a)) - (S - U) * math.sqrt(3) * 0.5j + + return np.array([x1, x2, x3]) # Returning One Real Root and two Complex Roots as numpy array. + + +# Helper function to return float value of f. +def findF(a, b, c): + return ((3.0 * c / a) - ((b ** 2.0) / (a ** 2.0))) / 3.0 + + +# Helper function to return float value of g. +def findG(a, b, c, d): + return (((2.0 * (b ** 3.0)) / (a ** 3.0)) - ((9.0 * b * c) / (a **2.0)) + (27.0 * d / a)) /27.0 + + +# Helper function to return float value of h. +def findH(g, f): + return ((g ** 2.0) / 4.0 + (f ** 3.0) / 27.0) + +import math +import numpy as np + +# Main Function takes in the coefficient of the Cubic Polynomial +# as parameters and it returns the roots in form of numpy array. +# Polynomial Structure -> ax^3 + bx^2 + cx + d = 0 + +def solve3(a, b, c, d): + + if (a == 0 and b == 0): # Case for handling Liner Equation + return np.array([(-d * 1.0) / c]) # Returning linear root as numpy array. + + elif (a == 0): # Case for handling Quadratic Equations + + D = c * c - 4.0 * b * d # Helper Temporary Variable + if D >= 0: + D = math.sqrt(D) + x1 = (-c + D) / (2.0 * b) + x2 = (-c - D) / (2.0 * b) + else: + D = math.sqrt(-D) + x1 = (-c + D * 1j) / (2.0 * b) + x2 = (-c - D * 1j) / (2.0 * b) + + return np.array([x1, x2]) # Returning Quadratic Roots as numpy array. + + f = findF(a, b, c) # Helper Temporary Variable + g = findG(a, b, c, d) # Helper Temporary Variable + h = findH(g, f) # Helper Temporary Variable + + if f == 0 and g == 0 and h == 0: # All 3 Roots are Real and Equal + if (d / a) >= 0: + x = (d / (1.0 * a)) ** (1 / 3.0) * -1 + else: + x = (-d / (1.0 * a)) ** (1 / 3.0) + return np.array([x, x, x]) # Returning Equal Roots as numpy array. + + elif h <= 0: # All 3 roots are Real + + i = math.sqrt(((g ** 2.0) / 4.0) - h) # Helper Temporary Variable + j = i ** (1 / 3.0) # Helper Temporary Variable + k = math.acos(-(g / (2 * i))) # Helper Temporary Variable + L = j * -1 # Helper Temporary Variable + M = math.cos(k / 3.0) # Helper Temporary Variable + N = math.sqrt(3) * math.sin(k / 3.0) # Helper Temporary Variable + P = (b / (3.0 * a)) * -1 # Helper Temporary Variable + + x1 = 2 * j * math.cos(k / 3.0) - (b / (3.0 * a)) + x2 = L * (M + N) + P + x3 = L * (M - N) + P + + return np.array([x1, x2, x3]) # Returning Real Roots as numpy array. + + elif h > 0: # One Real Root and two Complex Roots + R = -(g / 2.0) + math.sqrt(h) # Helper Temporary Variable + if R >= 0: + S = R ** (1 / 3.0) # Helper Temporary Variable + else: + S = (-R) ** (1 / 3.0) * -1 # Helper Temporary Variable + T = -(g / 2.0) - math.sqrt(h) + if T >= 0: + U = (T ** (1 / 3.0)) # Helper Temporary Variable + else: + U = ((-T) ** (1 / 3.0)) * -1 # Helper Temporary Variable + + x1 = (S + U) - (b / (3.0 * a)) + x2 = -(S + U) / 2 - (b / (3.0 * a)) + (S - U) * math.sqrt(3) * 0.5j + x3 = -(S + U) / 2 - (b / (3.0 * a)) - (S - U) * math.sqrt(3) * 0.5j + + return np.array([x1, x2, x3]) # Returning One Real Root and two Complex Roots as numpy array. + + +# Helper function to return float value of f. +def findF(a, b, c): + return ((3.0 * c / a) - ((b ** 2.0) / (a ** 2.0))) / 3.0 + + +# Helper function to return float value of g. +def findG(a, b, c, d): + return (((2.0 * (b ** 3.0)) / (a ** 3.0)) - ((9.0 * b * c) / (a **2.0)) + (27.0 * d / a)) /27.0 + + +# Helper function to return float value of h. +def findH(g, f): + return ((g ** 2.0) / 4.0 + (f ** 3.0) / 27.0) + +def fmaxmin(obj,var=x): + ksym=obj2func(obj) + kres=diff(ksym,var) + solu=solve(kres,var) + if type(solu)==list and len(solu)==1: + return solu[0] + return solu +def finflextion(obj,var=x): + ksym=obj2func(obj) + kres=diff(ksym,var,var) + solu=solve(kres,var) + if type(solu)==list and len(solu)==1: + return solu[0] + return solu + + + +### SUPERSOLVE + +def presolvedata(*args): + ''' + input: all diferents exprs..MyEq,MQ, func var..all.. + retur + vecf=[math expre finding] + vecv=[symbols required] + vecs=[str expretions] + ''' + vecf=[] + vecv=[] + vecs=[] + args2=[] + for i in args: + if type(i)==list: + for j in i: + args2.append(j) + else: + args2.append(i) + args=args2 + + for i in args: + if type(i)==MyEqEq: + vecf.append(i.e1.ksym-i.e2.ksym) + elif type(i)==MyEq: + vecf.append(i.ksym) + elif type(i)==Symbol: + vecv.append(i) + elif type(i)==str: + vecs.append(i) + else: + vecf.append(i) + return vecf,vecv,vecs + +def getvecsymbols(*args): + ''' + return symbols finding in whatwvwer expresions + ''' + + vecs=[] + for i in args: + try: + kres=i.free_symbols + kres=list(kres) + for j in kres: + if j not in vecs: + vecs.append(j) + except: + pass + return vecs + +def supersol(*args): + ''' + find answer to eQ + ''' + vecv=None + vecf,vecv,vecs=presolvedata(*args) + if vecv==None or vecv==[]: + vecv=getvecsymbols(*vecf) + + kres=solve(vecf,vecv) + return kres,vecv + +def presolanswer(kres,vecv): + ''' + fix, sort, and interprete the most answer format + ''' + + vecval=[] + vecnam=[] + vecsubname=[] + if len(vecv)==1: + if type(kres)==dict: + vecnam,vecval=unpack(kres) + elif type(kres)==list: + cc=1 + for i in kres: + + il=list(i) + for j,k in zip(il,vecv): + vecval.append(j) + vecnam.append(str(k)+str(cc)) + + cc=cc+1 + return vecval,vecnam + else: + if type(kres)==dict: + vecnam,vecval=unpack(kres) + + elif type(kres)==list: + cc=1 + for i in kres: + + il=list(i) + for j,k in zip(il,vecv): + vecval.append(j) + vecnam.append(str(k)+str(cc)) + + cc=cc+1 + return vecval,vecnam + +def supersolve(*args,kshow=True): + + ''' + supersolve(fumc, Myeq, equations,..etc,,,var1,var2,var3...) + ''' + + kres,vecv=supersol(*args) + valores,nombres=presolanswer(kres,vecv) + + ee=[] + for i,j in zip(valores,nombres): + ee.append(MyEq(i,kname=str(j),kshow=kshow)) + if 'eq' in args or 'Eq' in args: + if type(ee)==list: + return ee + else: + return ee[0] + else: + if type(valores)==list: + return valores + else: + return valores[0] + +def Lsubs(vec,*args,**kwargs): + kres=[] + if type(vec[0])==list: + for i in vec: + kres.append(lsubs(i,*args,**kwargs)) + return kres + else: + return lsubs(vec,*args,**kwargs) + +def lsubs(vec,*args,**kwargs): + vecres=[] + if len(kwargs)>0: + for i in vec: + kres=i + try: + kres=real_subs(kres,**kwargs) + except: + pass + vecres.append(kres) + else: + vecres=vec + for i in args: + if type(i)==MyEq: + sexpr=i.name + expr=unisymbols(i.ksym) + vecres2=[] + for j in vecres: + try: + kres=j.subs(sexpr,expr) + vecres2.append(kres) + except: + vecres2.append(j) + vecres=vecres2 + return vecres + + +def smartanswer(expr, *args,**kwargs): + ops = ['simplify', 'factor', 'float', 'expand','rsimplify'] + kname = '' + kops = [] + kvar = '' + expr=real_subs(expr,**kwargs) + + for i in args: + if type(i) == str: + if i in ops: + kops.append(i) + else: + kname = i + if type(i) == Symbol: + kvar = i + if len(kops)>0: + if 'expand' in kops: + try: + expr = expand(expr) + except: + pass + if 'simplify' in kops: + try: + expr = simplify(expr) + except: + pass + if 'factor' in kops: + try: + expr = factor(expr) + except: + pass + if 'float' in kops: + try: + expr = float(expr) + except: + pass + if 'rsimplify' in kops: + try: + expr = rsimplify(expr) + except: + pass + if kname != '': + if kvar !='': + ee=MyEq(float2int(expr),kname=kname,var=kvar) + else: + ee=MyEq(float2int(expr),kname=kname) + return ee + else: + return float2int(expr) + +def obj2expr(*args): + vecres=[] + for i in args: + if type(i)==MyEq: + vecres.append(i.ksym) + elif type(i)==MyEqEq: + vecres.append(i.L-i.R) + else: + vecres.append(i) + if len(vecres)==1: + return vecres[0] + else: + return vecres + + +def mathobj2expr(obj): + if type(obj)==str: + return None + elif type(obj)==MyEq: + return obj.ksym + elif type(obj)==MyEqEq: + return simplify(expand(obj.L-obj.R)) + else: + return obj + +def realangle(*args): + vx=args[0] + vy=args[1] + vxx=vx*signo(vx) + vyy=vy*signo(vy) + if vxx!=0: + angle=atan(vyy/vxx) + if vx==0: + if vy>=0: + kres= pi/2 + else: + kres= -pi/2 + elif vy==0: + if vx>=0: + kres= 0 + else: + return pi + elif vy>0: + if vx>0: + kres= angle + else: + kres= pi/2+angle + else: + if vx>0: + kres= -angle + else: + kres= pi+angle + if 's' in args: + kres= simplify(rad2sex(kres)) + if 'float' in args: + kres= float(kres) + return kres + +def prime2sympy(expr,var,*args): + ''' + return expr diff prime symbols 2 diff sympy expr + ''' + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Pd2,Vd2): + expr=expr.subs(i,j) + for i,j in zip(Pd,Vd): + expr=expr.subs(i,j) + for i,j in zip(Vn,Vf): + expr=expr.subs(i,j) + return expr + +def pivec(pi1,pi2,pix): + ''' + return vector = [ pi1,pi1+pix,pi1+2*pix,..... pi2] + ''' + done=True + vecpi=[] + cc=0 + while done: + vecpi.append(pi1+pix*cc) + cc=cc+1 + if pix*cc>pi2: + done=False + return vecpi + +def discretesolvefunc(expr,x1,x2,x3,var=x): + ''' + try to retur vector ehit posible solutions of expr for + evaluate range( x1, x2) in x3 spaces... + + ''' + vec=pivec(x1,x2,x3) + ee=obj2MyEq(expr,var=var) + vecres=[] + for i in vec: + try: + solu=simplify(ee(i)) + if solu==0: + vecres.append(i) + except: + pass + if len(vecres)==1: + return vecres[0] + return vecres + +def sympyintgral2expr(expr): + ''' + return sympy integral expreion whitout integral symbols, include dx + ''' + slatex=latex(expr) + dstr=slatex[-2::] + dvar=symbols(dstr) + slatex=slatex.replace('\\int ','') + p1=slatex.find('\\') + slatex=slatex[0:p1] + nexpr=latex2sympy(slatex) + if nexpr==1: + return dvar + else: + return nexpr*dvar + + +def vecsubs(expr,vec1,vec2): + ''' + return subtitutio follow vec1,vec2 indication + ''' + expr=unisymbols(expr) + + for i,j in zip(vec1,vec2): + try: + expr=expr.subs(i,j) + except: + pass + + return expr +def completesquare(expr,var=x): + ''' + expr=x*x+2*x + if x*x+2*x+a=(x+b)**2 + return a,b + ''' + a, b=symbols('a b') + Q=MQ(expr,expand((var+b)**2),kshow=False) + vec1=Q.coef_list(var) + vec2=[] + for i in vec1: + if 'a' in str(i) or 'b' in str(i): + vec2.append(i) + a,b=simplesolve(*vec2,a,b,'noshow') + return -b,a +def coef0(obj): + ''' + return coefficient zero in f(x,y) + ''' + + expr=obj2expr(obj) + w=list(expr.free_symbols) + kres=0 + for i in expr.args: + done=True + for j in w: + if str(j) in str(i): + done=False + if done: + kres=kres+i + return kres +def squarecompletexy(*args,var1=x,var2=y): + var1=symbols(str(var1)) + var2=symbols(str(var2)) + exprx=args[0] + var=var1 + Mx=exprx.subs(var2,0) + Ry=exprx-Mx + Mx2=squarecomplete(Mx,x) + R=coef0(Mx2) + P1=Mx2-R + My=Ry+R + var=y + My2=squarecomplete(My,var) + R=coef0(My2) + P2=My2-R + if 'parts' in args: + return P1,P2,R + else: + return P1+P2+R + +def squarefill(*args): + ''' + squarefill(x*x+2*x+1,x) return (x+1)**2 + squarefill(2*x*x+4*x+1,x,'factor') return 2*(x+1)**2-2 factor + squarefill(2*x*x+4*x+1,x,'factor',parts) return (x+1)**2,-2,2 + + ''' + var=x + vecop=['factor','parts'] + fdone=False + cf=1 + nexpr=args[0] + for i in args: + if type(i)==MyEq: + expr=i.ksym + elif type(i)==Symbol: + var=i + elif i=='factor': + fdone=True + elif type(i)!=str: + expr=i + else: + pass + sresto=0 + w=list(expr.free_symbols) + if len(w)>1: + expr8=expr + for i in w: + if i!=var: + expr8=expr8.subs(i,0) + nexpr=expr8 + sresto=expr-nexpr + + x1,x2,x3=symbols('x1,x2,x3') + vecx=[x1,x2,x3] + + if fdone: + + mm=nexpr.args + mm2=[i.subs(var,j) for i,j in zip(mm,vecx)] + expr2=factor(sum(mm2)) + expr3=reducecero(expr2) + cf=abs(simplify(expr2/expr3)) + nexpr=sum(mm)/cf + clist=coef_list(nexpr,var) + a=sqrt(clist[0]) + b=(clist[1])/(2*a) + c=b*b + d=clist[2]-c + + if 'parts' in args: + return (a*var+c),d*cf+sresto,cf + else: + if fdone: + return cf*(a*var+c)**2+d*cf +sresto + else: + return (a*var+c)**2+d +sresto + + +def square2polar(obj,var=t,kshow=True): + expr=obj2expr(obj) + mm=expr.args + mx=sum([i for i in mm if 'x' in str(i)]) + my=sum([i for i in mm if 'y' in str(i)]) + mz=[mx,my] + Nm=[numer(i) for i in mz] + Dn=[denom(i) for i in mz] + R=[rsimplify(sqrt(i)) for i in Nm] + ss=[Nm[0].subs(x,0),Nm[1].subs(y,0)] + kres=[unisymbols(ss[0]+sqrt(Dn[0])*cos(var)),unisymbols(ss[1]+sqrt(Dn[1])*sin(var))] + if kshow: + display(Math(latex(kres))) + return kres + + +####################### +######## used to rsimplify +################ + +def Is_RootMonoPow(expr): + done=False + if Is_Root(expr): + if Is_Pow(insideroot(expr)): + return True + return False +def Sqrt(val,sq,ee=1): + sexpr='\\sqrt['+str(sq)+']' + if ee==1: + sexpr=sexpr+'{'+str(val)+'}' + else: + sexpr=sexpr+'{'+str(val)+'^{'+str(ee)+'}}' + return latex2sympy(sexpr) + +def fracmixta(expr): + expr=simplify(factor(expr)) + if denom(expr)!=1: + p1=numer(expr) + p2=denom(expr) + P1=1 + K1=1 + if Is_Number(p1): + P1=p1 + + elif Is_Mul(p1): + for i in p1.args: + if Is_Number(i): + P1=i + else: + K1=K1*i + else: + return (0,0,expr) + P2=1 + K2=1 + if Is_Number(p2): + P2=p2 + elif Is_Mul(p2): + for i in p2.args: + if Is_Number(i): + P2=i + else: + K2=K2*i + else: + return (0,0,expr) + + kres=P1%P2 + return (P1-kres)/P2,kres*K1/K2,P2 + + + + else: + return 0,expr,1 +def rsimplifyRPow(expr,*args): + if Is_RootMonoPow(expr): + base,ee,rr=partPow(expr) + p1,p2,p3=fracmixta(ee/rr) + if p1!=0: + P3=Sqrt(base,p3,ee=p2) + if 'parts' in args: + return base,P3 + else: + return Mul(base**p1,P3,evaluate=False) + else: + if 'parts' in args: + return 1,expr + else: + return expr + + if 'parts' in args: + return 1,expr + else: + return expr + +def makethis(expr,*args): + vecveri=['unisymbols','factor','expand','simplify','texpand','rsimplify','Sqrt','reducecero'] + vecop=[i for i in vecveri if i in args] + for i in vecop: + try: + sexpr=i+'('+str(expr)+')' + expr=eval(sexpr) + except: + pass + return expr + + +def solution(obj,var): + kres=obj2expr(obj) + skres=str(kres) + sdone=False + if type(var)==str: + sdone=True + svar=var + var=parse_expr(var) + else: + svar=str(var) + mm=simplesolve(kres,var,'all',kshow=False) + qq=len(mm) + mms=[svar+str(cc) for cc in range(1,qq+1)] + if sdone: + evec=[] + for eval,ename in zip(mm,mms): + evec.append(MyEq(eval,kname=ename)) + return evec + + else: + if qq==1: + display(Math(svar+'='+latex(mm[0]))) + return mm[0] + else: + return mm \ No newline at end of file diff --git a/Libaldo/lib_toolsEq.py b/Libaldo/lib_toolsEq.py new file mode 100644 index 0000000..9651158 --- /dev/null +++ b/Libaldo/lib_toolsEq.py @@ -0,0 +1,838 @@ + + +from sympy import * + +from IPython.display import Math # ,display +from matplotlib.pyplot import ylabel, plot, show, xlabel, title +from libaldo_math2 import * +from libaldo_algorith import * + +import copy +import numpy as np +import pandas as pd + +import matplotlib.pyplot as plt + + + +# from lib_Func import * +import dill # pip install dill --user + +filename = 'workspace.pkl' + + +def savework(): + dill.dump_session(filename='workspace.pkl') + + +def loadwork(): + dill.load_session(filename='workspace.pkl') + + +# and to load the session again: + + + + +def show_main(): + for i in dataQ: + i.s() + + + +def upBagSys(ksys, Bag, kope=''): + for i in ksys: + i.upBag(Bag, kope=kope) + + + +########################################### +# END MyIteger Class +########################################### + + +def get_real_value(ee): + if type(ee) == MyEq: + kres = ee.ksym + else: + kres = ee + return kres + + + +############################################### +# Mass center Inertia + +def pQ(mm, vv, kope=''): + rho = symbols('rho') + + kres = mm / vv + sE([rho, '=', kres]) + return kres + + +################################################# +# Solve Algorithm + +def solved(*args,**kwargs): + ''' + solved (var,exp1,exp2,**kwargs) + input + var : variable to find + exp1 : math expre or MyEq class that is equation equal= 0 + exp2 (optional): math expre or MyEq class + if exp2 is given then the Eq to evalue is expr1 -expr2 + kwargs : conditions to evalue, example x=1, t=0..etc + return + return a MyEq class with name str(var) + ''' + var=args[0] + ee=args[1] + if type(ee)==MyEq: + ee=ee.ksym + keq=ee + if len(args)==3: + ee2=args[2] + if type(ee2)==MyEq: + ee2=ee2.ksym + keq=ee-ee2 + if len(kwargs)>0: + keq=real_subs(keq,**kwargs) + + kres=solve(keq,var) + if type(kres)==list: + kres=kres[0] + + kname=str(var) + ee0=MyEq(kres,kname=kname) + return ee0 + +def solverSys(*args, Bag=''): + Ke = [] + Kv = [] + Kn = [] + + for i in args: + if type(i) == MyEq: + if Bag != '': + i.upBag(Bag, kshow=False) + Ke.append(i) + if type(i) == Symbol: + Kv.append(i) + Kn.append(i.name) + # return(Ke,Kv,Kn) + + return MyEqSolveLin(Ke, Kv, Kn, Bag=Bag) + + +def MyEqSolveLin(Ke, Kv, Kn, Bag=''): # Solve n MyEq with n unknow variable + ''' + Example + Ke=[e2,e2,e0] MyEqs Matrix + Kv=[N1,T,a] unKnow Vriables + Kn=['N_1','T','a_c'] New Name Eq + + N11,T1,ac = MyEqSolveLin(Ke,Kv,Kn) + returns resepective answer + ''' + vecs = [] + qq = len(Ke) + kres = [] + for i in range(qq): + ee = Ke[i] + ksym = Kv[i] + ks = ee.solve(ksym,kshow=False) + if type(ks) == list: + rr = max(ks) + ks = rr + + vecs.append(ks) + Ker = Ke[i + 1::] + for e1 in Ker: + e1.set(ksym, ks, kshow=False) + e1.reduFac(kshow=False) + e1.simplify(kshow=False) + + for i, kname in zip(vecs, Kn): + ee = MyEq(i, kname, kshow=False) + kres.append(ee) + ueq = kres[-1] + ksym = ueq() + vsym = Kv[-1] + for ee in kres[0:-1]: + ee.set(vsym, ksym, kshow=False) + ee.reduFac(kshow=False) + ee.simplify(kshow=False) + for i in kres: + i.s() + return kres + + +def Solve2Eq(ksym=[], kvar=[], knom=[], kope=''): + e1, e2 = ksym + v1, v2 = kvar + t1, t2 = knom + + r1 = e1.solve(v1) + e2.set(v1, r1, kshow=False) + r2 = e2.solve(v2) + r2 = opemat(r2, kope=kope) + e1.set(v2, r2, kshow=False) + r1 = e1.solve(v1) + r1 = opemat(r1, kope=kope) + aa = MyEq(r1, t1) + bb = MyEq(r2, t2) + return (aa, bb) + + +def Diff(ksym, kvar, kname=''): + kres = ksym + kres = kres.diff(kvar) + if kname == '': + return kres + else: + return MyEq(kres, kname) + + +def Diff2(ksym, kvar, kname=''): + kres = ksym + kres = kres.diff(kvar) + kres = kres.diff(kvar) + if kname == '': + return kres + else: + return MyEq(kres, kname) + + + +def upBag2sys(vecEq, kBag): + for i in vecEq: + i.upBag(kBag) + + + + +def eQSolver(*args): + vec1 = [] + uk1 = [] + for i in args: + if type(i) == list: + for j in i: + if type(j) == MyEq: + vec1.append(j()) + elif fpoly(j, 'n') > 1: + vec1.append(j) + else: + uk1.append(j) + else: + if type(i) == MyEq: + vec1.append(i()) + elif fpoly(i, 'n') > 1: + vec1.append(i) + else: + uk1.append(i) + + vec2 = [] + kres = [] + for i in vec1: + if type(i) == MyEq: + vec2.append(i()) + else: + vec2.append(i) + + mm = solve(vec2, uk1) + if type(mm) == dict: + kk, vv = kunpakDic(mm) + + for i, j in zip(kk, vv): + kres.append(MyEq(j, i)) + return kres + else: + for i, j in zip(mm[0], uk1): + j = MyEq(i, str(j)) + kres.append(j) + return (kres) + + +def solvelin(*args, kope='', Eq=True): # solveLinearSys(e1,e2,mu1,mu2) + mS = [] + mV = [] + + for i in args: + if type(i) == MyEq: + mS.append(i()) + elif type(i) == eQ: + ee = MyEq(i.ksym, kname=i.name, kshow=False) + mS.append(ee()) + elif type(i) == str: + kope = i + else: + mV.append(i) + kres = solve(mS, mV) + + kk, vv = kunpakDic(kres) + if kope != '': + vv = opemat_vec(vv, kope) + if Eq: + EqR = [] + for i, j in zip(kk, vv): + EqR.append(MyEq(j, i)) + return EqR + + else: + for i, j in zip(kk, vv): + sE([i, '=', opemat(j, kope=kope)]) + if Eq: + kres = [] + for i, j in zip(kk, vv): + kres.append(MyEq(opemat(j, kope=kope), i, kshow=False)) + return kres + + return vv + + +def get_squareMono(ksym): + if type(ksym) == MyEq: + ksym = ksym.ksym + kres = ksym + mm = fpoly(ksym, 'list') + mr = [] + ms = [] + rr = [] + centra = 0 + ksigno = 1 + for i in mm: + mr.append(opemat(rpow(i, 2), 'r')) + ms.append(str(opemat(rpow(i, 2), 'r'))) + for i, j, k in zip(ms, mr, mm): + if 'sqrt' in i: + central = k + if '-' in str(central): + ksigno = -1 + else: + rr.append(j) + if len(rr) == 2: + kres = kpow(rr[1] + ksigno * rr[0], 2) + return kres + + +####### +def expand2MyEq(ee): + ktype = ee.type + var2 = ee.var2 + mm = ee.list() + cc = 1 + kname = ee.name + kres = [] + for i in mm: + nname = kname + str(cc) + nname = MyEq(i, nname, var2=var2) + kres.append(nname) + cc += 1 + return kres + + +def upgrade(*args, kshow=True, andsolve=[]): + if andsolve != []: + vv = andsolve[0] + ee = andsolve[1] + vv = ee.solve(parse_expr(vv), vv, kope='s') + eev = [] + evv = [] + for i in args: + if type(i) == MyEq: + if i.type == 'C': + eev.append(i) + else: + evv.append(i) + + for i in eev: + for j in evv: + try: + i.upgrade(j, kshow=False) + except: + pass + for i in eev: + if i.ksym != 0: + i.s() + for i in evv: + if type(i) == MyEq: + i.simplify(kshow=False) + if i.ksym != 0: + i.s() + + +def upgradeList(*args, kshow=True, andsolve=[], kope='s'): + eev = [] + evv = [] + for i in args: + if type(i) == MyEq: + if i.type == 'C': + if i != andsolve[1]: + eev.append(i) + + if andsolve != []: + vv = andsolve[0] + ee = andsolve[1] + kres = ee.solve(vv) + kres = opemat(kres, 's') + vv = MyEq(kres, str(vv), ktype='C', kshow=False) + ee.type = 'P' + + for i in eev: + if i.type == 'C': + i.upgrade(vv, kshow=False) + i.simplify(kshow=False) + + for i in eev: + if i.ksym != 0: + i.s() + vv.s() + return vv + + + +def func_sig(kf, x1, x2, var=x): + ee = MyEq(kf, var2=var, kshow=False) + xx = (x2 - x1) / 2 + return ee(xx) + + +def get_intersec_2func(y1, y2, var=x): # y1(x), y2(x), return intersec y1 and y2 + ee = MyEq(y1 - y2, kshow=False) # return vector + return ee.solve(var) + + +def reset_ee(*args): + eeFull = [] + for i in args: + i.init = False + + +def Upgrade(*args, kope='', kshow=True): + newa = [] + for i in args: + if type(i) == MyEq: + + if i.ksym != 0: + newa.append(i) + args = newa + antes = [] + for i in args: + antes.append(str(i)) + qq = len(args) + for i in range(qq): + + mm = [] + for j in range(qq): + if j != i: + mm.append(args[j]) + args[i].upgrade(mm, kshow=False, kope=kope) + if kshow: + for i, j in zip(args, antes): + if str(i) != newa: + if i.ksym != 0: + i.s() + + +def presolve(ksym, val): + kres = solve(ksym, val) + if kres == []: + try: + kres = solve(opemat(ksym, 'esf'), val) + if kres != []: + return kres + else: + ksym = factorSec(ksym, val) + kres = solve(opemat(ksym, 'esf'), val) + if kres != []: + return kres + except: + done = False + return kres + + +def eQsolve(ksym, kname, kope=''): + kval = parse_expr(kname) + kres = csolve(ksym, kval) + kres = opemat(kres, kope) + kval = MyEq(kres, kname) + return kval + +def Qsolve(*args): + ''' + N1,mu1=Qsolve(FxA,FyA,N1,mu1) + ''' + eqq=[] + evv=[] + for i in args: + if type(i)==MyEq: + eqq.append(i) + else: + evv.append(i) + kres=solve(eqq,evv) + try: + vsym,vval=kunpakDic(kres) + except: + vsym=evv + vval=list(kres[0]) + + vres=[] + for i ,j in zip(vsym,vval): + kname=str(i) + ee=MyEq(j,kname=i) + vres.append(ee) + return vres + + + +def Diff2flat(kres,kvar,var2): # ksym,kvar,var2 + + for i in kvar: + f=Function(str(i))(var2) + df=diff(f) + kname='d'+alphaname(i) + nf=symbols(kname) + kres=kres.subs(df,nf) + ee=MyEq(kres,kshow=False) + for i in kvar: + ee.setdiff(i,i,kshow=False) + + return ee.ksym + + + +##################################### +# list +##################################### + +def solvelist(*args): + ''' + input: [vector with all eq=0], variables to find .. + output: MyEq of each variable + example: + a+2*b=0 and 3*a-b=0 + ee=[a+2*b,3*a-b] + then : + a,b=solvelist(ee,a,b) + return a,b in MyEq ecuation class + ''' + vecs=args[1::] + kres= solve(*args) + var,value=kunpakDic(kres) + vres=[] + for i ,j in zip(var,value): + ee=MyEq(j,str(i)) + vres.append(ee) + return vres + +def one_ksym2ksym(ksym): + r''' + return denominator if numerator =1 + input 1/(a+b) return (a+b) + input 3/(a+b) return 3/(a+b) + input c/(a+b) return c/(a+b) + ''' + + if numer(ksym)==1: + return denom(ksym) + else: + return ksym + +def num_ksym2ksym(ksym): + r''' + return denominator if numerator = numeric + input 1/(a+b) return (a+b) + input 3/(a+b) return (a+b) + input c/(a+b) return c/(a+b) + ''' + if Is_Number(numer(ksym)): + return denom(ksym) + else: + return ksym + +##################################### +# real subs +##################################### + +def subskwargs(QQ,**kwargs): + mkey=[] + vvalue=[] + + for key, value in kwargs.items(): + mkey.append(key) + vvalue.append(value) + kres=QQ + for i,j in zip(mkey,vvalue): + valor=j + if type(j)==MyEq: + valor=j.ksym + kres=kres.subs(i,valor) + return kres + +def real_subs(QQ,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + + vvar=fpoly(QQ,'free') + mvar=[] + for i in vvar: + nname=str(i) + nname=nname.replace('_','') + nvar=symbols(nname) + mvar.append(nvar) + + kres=QQ + sres=str(kres) + sres=sres.replace('_','') + kres=parse_expr(sres) + mkey=[] + vvalue=[] + for key, value in kwargs.items(): + mkey.append(key) + vvalue.append(value) + + kres=kres.subs(parse_expr(key),value) + for i,j in zip(mvar,vvar): + kres=kres.subs(i,j) + return (kres) + +##################################### +# algebra +##################################### +def get_seudocofactor(e2,e3,var2): + ''' + tyr to get polynomie complement and multipli complete degree secuence + e1=x*x-2 + e2=x+1 + if e1=e2*k + then k=a*x+b + maybe x*x-2= (x+1)*(a*x+b) + + return (a*x+b),[a,b] + ''' + vecvar=[a,b,c,d] + vecfvar=[] + ee2=e2 + if type(e2)==MyEq: + ee2=e2.ksym + + ee3=e3 + if type(e3)==MyEq: + ee3=e3.ksym + qq=degree(ee2,gen=var2)-degree(ee3,gen=var2) + vres=0 + cc=0 + for i in range(qq+1): + vres+=vecvar[i]*var2**(qq-cc) + vecfvar.append(vecvar[i]) + cc+=1 + return (vres,vecfvar) + + +def passdoitI(kstr): + klist=['>','<','=','True','∧',','] + done=True + for i in klist: + if i in kstr: + done=False + return done + + + +def inversefunc(*args): + '''return inverse function of expr + resoect var + input(function math, var + inversefunc(x**3+4,x) + return (x - 4)**(1/3) + ''' + if len(args)==0: + helplib('inversefunc') + return + expr=args[0] + var=args[1] + yy=symbols('yy') + + expr=subsubs(expr,var,yy) + + + try: + kres=ksolve(var-expr,yy) + except: + kres=0 + + return kres + +## Wolfram solve Tools + +def wolfram_solve_integral(Id,expr,var=x): + + sres='Integrate['+str(expr)+','+str(var)+']' + sres=wolfralan(sres,Id) + + p1=sres.find('=') + sres=sres[p1+1::] + sres=sres.replace('constant','C1') + return wolf2sympy(sres) + + + +def wolfralan(sres,Id): + client = wolframalpha.Client(Id) + q = sres + res = client.query(q) + answer = next(res.results).text + return answer + + +def wolf2sympy(sres): + try: + kres=parse_mathematica(sres) + return kres + except: + try: + kres=parse_expr(sres) + return kres + except: + return sres + + +def Is_Diff_expr(expr): + done=False + if "'" in str(expr): + done= True + return done + + +def dothis(expr,func): + ddone=False + if Is_Diff_expr(expr): + expr=amperdiff2normaldiff(expr) + ddone=True + + kres=expr + try: + sexpr=func+'('+str(expr)+')' + kres=parse_expr(sexpr) + except: + pass + if ddone: + kres=normaldiff2amperdiff(str(kres)) + return kres + +def factorinte(expr,kfac): + if type(expr)==Add: + kres=0 + for i in expr.args: + kres=kres+factorinte(i,kfac) + return kres + done=False + if signo(kfac)==-1: + done=True + kfac=-1*kfac + kres=expr + if type(expr)==Integral: + p1,p2=expr.args + p2=p2.args[0] + if str(p2) not in str(kfac): + if type(p1)==Mul or type(p1)==Pow: + mm=fpoly(p1,'list') + if kfac in mm: + if done: + kfac=-1*kfac + p1=p1/kfac + kres=kfac*Integral(p1, p2) + + return kres + +def datadiff(var,*args): + ''' + var=main var t + args=[x,y]= x(t),y(t) + Vs=['x','y'] + Vn=[x,y] + Vf=[x(t),y(t)] + Vd=[dxt,dyt] + Vd2=[dx2t,dy2t] + Pd=[x',y'] + Pd2=[x'',y''] + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2 =[],[],[],[],[],[],[] + P1,P2=[],[] + for i in args: + Vs.append(str(i)) + Vn.append(i) + for i in Vs: + Vf.append(Function(i)(var)) + for i in Vf: + Vd.append(i.diff(var)) + Vd2.append(i.diff(var,var)) + for i in Vn: + Pd.append(symboldiff(i)) + Pd2.append(symboldiff2(i)) + + return Vs,Vn,Vf,Vd,Vd2,Pd,Pd2 + +def hightfunc(expr,var,*args): + ''' + expr=pi*h*r*r*t/3 + var=t + args=h,r + return pi*t*h(t)*r(t)**2/3 + ''' + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vn,Vf): + expr=subsubs(expr,i,j) + return expr + +def hightdiff(expr,var,*args): + ''' + expr=pi*h*r*r*t/3 + var=t + args=h,r + return 2*pi*t*h(t)*r(t)*Derivative(r(t), t)/3 + pi*t*r(t)**2*Derivative(h(t), t)/3 + + pi*h(t)*r(t)**2/3 + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vn,Vf): + expr=subsubs(expr,i,j) + return diff(expr,t) + +def sympyEq2prime(expr,var,*args): + ''' + return expr diff sympy expr whith diff prime symbols + ''' + + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Vd2,Pd2): + expr=expr.subs(i,j) + for i,j in zip(Vd,Pd): + expr=expr.subs(i,j) + for i,j in zip(Vf,Vn): + expr=expr.subs(i,j) + return expr + + +def prime2sympy(expr,var,*args): + ''' + return expr diff prime symbols 2 diff sympy expr + ''' + Vs,Vn,Vf,Vd,Vd2,Pd,Pd2=datadiff(var,*args) + for i,j in zip(Pd2,Vd2): + expr=expr.subs(i,j) + for i,j in zip(Pd,Vd): + expr=expr.subs(i,j) + for i,j in zip(Vn,Vf): + expr=expr.subs(i,j) + return expr + +def normaldiff(expr,var,*args): + ff=prime2sympy(expr,var,*args) + dff=diff(ff,var) + return dff \ No newline at end of file diff --git a/Libaldo/libaldo_algorith.py b/Libaldo/libaldo_algorith.py new file mode 100644 index 0000000..2455747 --- /dev/null +++ b/Libaldo/libaldo_algorith.py @@ -0,0 +1,2373 @@ +from sympy import * +from libaldo_math2 import * +import sys +sys.path.append('../Libaldo') + + +k,x,t=symbols('k x t') +# Trandformacion de monimios and informacion Funciones +s,v,u,w=symbols('s v u w') + + +def diffsymbolprime(var): + svar=str(var) + dsvar1=svar+"'" + dsvar2=svar+"''" + kres= dsvar1+' '+dsvar2 + + return symbols(kres) + + +dy,d2y=diffsymbolprime(y) +dx,d2x=diffsymbolprime(x) +dz,d2z=diffsymbolprime(z) +dv,d2v=diffsymbolprime(v) +du,d2u=diffsymbolprime(u) +dw,d2w=diffsymbolprime(w) + +def exp_in(ksym): # retorna True si hay una funcion exp en ksym + # exp_in(4*exp(m)) return True + # exp_in(4*m) return False + sres=str(ksym) + if 'exp' in sres: + return True + return False + +def Is_Exp(ksym): + return exp_in(ksym=ksym) + +################################################ + + +def get_exp_Mono(ksym): # retorna la parte exp de un monomio + if exp_in(ksym): # get_exp_Mono(4*exp(x)) return exp(x) + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + for i in mm: + if exp_in(i): + return i + return ksym + +def get_Euler (ksym): + return get_cofac_exp(ksym=ksym) + +########################################## + +def get_cofac_exp(ksym): # retorna la parte no exp de un monomio + kexp=get_exp_Mono(ksym) # get_cofac_exp (4*exp(x)) return 4 + if kexp!=ksym: + return simplify(ksym/kexp) + return 1 + +def get_facEuler(ksym): + return get_cofac_exp(ksym=ksym) + +#################################### + + +def get_expoinexp(ksym): + kres=ksym + if exp_in(ksym): + mm=get_exp_Mono(ksym) + mm2=fpoly(mm,'list') + kres=mm2[0] + return kres + return 1 + +def get_expnEuler(ksym): + return get_expoinexp(ksym=ksym) + + +# LOG + +def log_in(ksym): # retorna True si hay una funcion log en ksym + # log_in(4*exp(m)) return False + sres=str(ksym) # log_in(log(4)*m) return True + if 'log' in sres: + return True + return False + +def get_log_Mono(ksym): # retorna la parte exp de un monomio + if log_in(ksym): # get_exp_Mono(4*exp(x)) return exp(x) + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + for i in mm: + if log_in(i): + return i + return ksym + +def get_cofac_log(ksym): # retorna la parte no exp de un monomio + kexp=get_log_Mono(ksym) # get_cofac_exp (4*exp(x)) return 4 + if kexp!=ksym: + return simplify(ksym/kexp) + return ksym + +def get_insidelog(ksym): # + kexp=get_log_Mono(ksym) # + return simplify(exp(kexp)) + +##################################### +# Monomie Tools +##################################### + +def monodata(*args): + r''' + data_mono(monomie, op1, op2) + inputs args: + op1=='isexp' ,return True if ksym is monomie whit exp factor + op1=='getexp' ,return only exp factor + op1=='getexpfac' ,return all factors less exp fac + + ''' + ksym=args[0] + if len(args)==2: + op1=args[1] + if len(args)==3: + op2=args[1] + + # Exp + if op1=='isexp': + return exp_in(ksym) + + elif op1=='getexp': + return get_exp_Mono(ksym) + elif op1=='getexpfac': + return get_cofac_exp(ksym) + elif op1=='getexpoinexp': + return get_expoinexp(ksym) + + # Log + if op1=='islog': + return log_in(ksym) + + elif op1=='getlog': + return get_log_Mono(ksym) + elif op1=='getlogfac': + return get_cofac_log(ksym) + elif op1=='getinlog': + return get_insidelog(ksym) + + +def clear_exp_QQ(ksym1,ksym2,vmain=k,var2=t): + p2=simplify(ksym2) + p1=simplify(ksym1) + if Is_Add(p2) and Is_Poly(p2): + mm=0 + mmexp=0 + for i in fpoly(p2,'list'): + if exp_in(i): + mmexp+=i + else: + mm+=i + p2=mmexp + p1=p1-mm + if Is_Mono(p2) and denom(p2)!=1: + kdeno=denom(p2) + p1=p1*kdeno + p2=simplify(p2*kdeno) + + mm=get_facEuler(p2) + if mm!=1: + p1=p1/mm + p2=simplify(p2/mm) + + + return (p1,p2) + +def getexponent(ksym): # return only exponente , not sqrt + + kres=ksym + ssym=str(ksym) + if 'sqrt' in ssym: + if 'sqrt'==ssym[0:4]: + nssym=between_par(ssym,'sqrt') + kres=parse_expr(nssym) + if Is_Pow(kres): + mm=fpoly(kres,'list') + return mm[1] + else: + return 1 + +''' +def getexpo(ksym): + return getexponent(ksym) + +def getbase(ksym): # return base from Pow monomie expresion + + input: x**a + return : x + + ksym=ksym*1 + if Is_Pow(ksym): + kres=ksym + ssym=str(ksym) + if 'sqrt' in ssym: + if 'sqrt'==ssym[0:4]: + nssym=between_par(ssym,'sqrt') + kres=parse_expr(nssym) + return getbase(kres) + + mm=fpoly(ksym,'list') + return mm[0] + + + else: + return ksym +''' +def partPow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + if Is_Root(expr): + p1,p2=expr.args + nP=numer(p2) + dP=denom(p2) + bb=p1 + ee=nP + rr=dP + if Is_Pow(bb): + ff=getexpo(p1) + bb=getbase(p1) + ee=ee*ff + else: + ee=getexpo(expr) + bb=getbase(expr) + rr=1 + else: + bb=expr + ee=1 + rr=1 + return bb,ee,rr + +def sqrt2pow(ksym): # convert sqrt(x**y) in x**(y/2) + + b1,e1,r1=partPow(ksym) + return kpow(b1,cfrac(e1,r1)) + +def root2pow(ksym): # convert sqrt(x**y) in x**(y/2) + + b1,e1,r1=partPow(ksym) + return kpow(b1,cfrac(e1,r1)) + +def pow2sqrt(ksym): # convert (x**(y/2)) in sqrt(x**y) + b1,e1,r1=partPow(ksym) + if r1==2: + return sqrt(kpow(b1,e1)) + else: + return ksym + + + b1,e1,r1=partPow(ksym) + return kpow(e1,cfrac(e1,1)) +def modulores(ksym,rr=2): # function use by reduceroot + b,ee,r1=partPow(ksym) + + if denom(ee)!=1: + nn=numer(ee) + dd=denom(ee) + p2=nn%rr + p1=int(nn/rr) + p3=cfrac(p2,dd) + return(b,p1,p3) + else: + nn=ee + dd=r1 + p2=nn%rr + p1=int(nn/rr) + p3=cfrac(p2,r1) + return(b,p1,p3) + +def reduceroot(ksym2,rr=2): + + P1=1 + P2=1 + ksym=kpow(ksym2,rr) + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + for i in mm: + if Is_Pow(i): + b,p1,p2=modulores(i,rr) + + P1=P1*kpow(b,p1) + P2=P2*kpow(b,p2) + else: + P2=P2*i + P3=rpow(P2,rr) + return Mul(P1, P3, evaluate=False) + else: + return ksym +def simplifyroot(ksym): + + ksym=1*ksym + if Is_Pow(ksym): + + kres= root2pow(ksym) + return kres + + elif Is_Add(ksym): + kres=0 + for i in fpoly(ksym,'list'): + kres+=simplifyroot(i) + return kres + elif Is_Mul(ksym): + kres=1 + for i in fpoly(ksym,'list'): + kres=kres*simplifyroot(i) + return kres + else: + return ksym + + +##################################### +# MyEqEq +##################################### + + + + + +##################################### +# str +##################################### +def fix_mulpar(sexp): + vec1='0123456789' + vec2='abcdefghijklmnopqrstuvwxyz' + vec3='ABCDEFGHIJKLMNOPQRSTUVWXYZ' + p1=sexp.find('(') + if p1==-1 or p1==0: + return sexp + elif sexp[p1-1] in vec1 or sexp[p1-1] in vec2 or sexp[p1-1] in vec3: + sexp=sexp[0:p1]+'*'+sexp[p1:len(sexp)] + return sexp + else: + return sexp +def between_par(sall,ssym=''): # between_par('***(12(**)3)***') return '12(**)3' + if ssym!='': + ssym=fix_mulpar(ssym) + mm=str(sall) + if ssym=='': + ssym='(' + q1=mm.find(ssym) + if q1==-1: + return '' + mm2=mm[q1::] + + q2=mm2.find('(') + mm3=mm2[q2::] + + cc=1 + sres='' + p=1 + i=1 + while cc>0: + v=mm3[i] + if v=='(': + cc+=1 + if v==')': + cc-=1 + if cc>0: + sres+=v + i+=1 + return parse_expr(sres) + +def between_func(ksym,sfunc): + ''' + input a function like + ksym=sqrt(y + 4)*sqrt((x - 2)**2) type: symbols o function + sfunc='sqrt(' type=str + return: + vec ['y + 4', '(x - 2)**2'] ,all inside sqrt(*****) in tihs case + + ''' + svar=str(ksym) + qq=svar.count(sfunc) + vecf=[] + posx=0 + for i in range(qq): + ff=between_par(svar,sfunc) + vecf.append(ff) + posx=svar.find(sfunc) + svar=svar[posx+1::] + return vecf + +def fix_str_math_space(ssym): + ''' + input:'3*x*(y+1)' + return 3*x*(y + 1)' + ''' + + kres='' + cc=0 + for i in ssym: + if cc==0: + kres=kres+i + else: + if i=='+' or i=='-': + + if ssym[cc-1]!=' ': + kres+=' ' + kres+=i + if ssym[cc+1]!=' ': + kres+=' ' + else: + kres+=i + cc+=1 + return kres + +def sgetmonofactor(ksym,s1,op=''): + ''' + return valid math expresion when convert math expr in str(expr) + example: + A=x*y*(1+a)*sqrt(z+1)+20*z + sgetmonofactor(A,'x*y') return 'x*y*(1 + a)' + sgetmonofactor(A,'x*y','f') return 'x*y*(1 + a)*sqrt(z + 1)' + ''' + + if type(ksym)!=str: + smm=str(ksym) + else: + smm=ksym + smm=fix_str_math_space(smm) + done=True + pstar=False + if type(op)==int: + nsmm=smm[op::] + p1=nsmm.find(s1) + if p1==-1: + return ksym + p1=p1+op + else: + p1=smm.find(s1) + if p1==-1: + return ksym + sres=s1 + qq=len(s1) + cc=0 + i=p1+qq + while done: + vf=smm[i] + sres+=vf + if vf=='(': + cc+=1 + pstar=True + if vf==')': + cc+=-1 + if pstar and cc==0: + done=False + + i+=1 + if op!='' and type(op)==str: + if smm[i+1]!='': + sres=sgetmonofactor(ksym,sres) + + return sres +##################################### +# polynomie Tools +##################################### + +def getmonoexpr(ksym,sval,op=''): + ''' + return valid math expresion that include sval expr + example: + A=x*y*(1+a)*sqrt(z+1)+20*z + getmonoexpr(A,'x*y') return x*y*(1 + a) + getmonoexpr(A,'x*y','f') return x*y*(1+a)*sqrt(z+1) + ''' + skres=sgetmonofactor(ksym,sval,op=op) + try: + kres=parse_expr(skres) + return kres + except: + return ksym + + +# squaresum() +# ----------- +def squaresum(ksym,p1=0,p2=0): + ''' + sqauresum(ksym,p1=x,p2=1) + input : + ksym = initial function to trasform + p1,p2 = (p1+p2)**2 new formate to get convert + return: + (p1+p2)**2 + K ..such that (p1+p2)**2 + K = ksym + example: + the polynomie 4*x*x+8*x-6 tray transfor to (2*x+2)**2 +K + + squaresum(4*x*x+8*x-6,2*x,2) return (2*x + 2)**2 - 10 + ''' + + vec1=expand((p1+p2)**2) + vec2=ksym-vec1 + kres=kpow((p1+p2),2)+vec2 + return kres + + +def parcial_fraction(x,L,a,b,c,d): + r''' + input L/((a*x+b)*(c*x+d)) + + return A/(a*x+b) + B/(c*x+d) + ''' + A=L*a/(d*(a - c)) + B=-L*c/(d*(a - c)) + p1=(a*x+b) + p2=(a*x+b) + + kres=A/p1+B/p2 + return kres + +def par_frac(ksym,var=''): + r''' + FRACCION PARCIAL + input C/[A+B] + return if it possible C1/A + C2/A que es igula a C/[A+B] + ''' + + + kres=ksym + + if Is_Mono(kres) and Is_Mul(kres): + + p1=numer(kres) + done=False + if var!='': + X=symbols('X') + kres=ksym.subs(var,X) + done=True + + + p2=denom(kres) + + + mm= fpoly(p2,'list') + + qq=len(mm) + A1,A2=symbols('A1 A2') + f1=A1*mm[0] + f2=A2*mm[1] + kres2=simplify(expand(f1+f2)) + kres3=factorSec(kres2,X) + + A22=solve(parse_expr(between_par(str(kres3),'X*(')),A2)[0] + kres4=kres3.subs(A2,A22) + r1=solve(1-kres4,A1)[0] + r2=A22.subs(A1,r1) + dd1=mm[0] + dd2=mm[1] + + if done: + dd1=dd1.subs(X,var) + dd2=dd2.subs(X,var) + + fac1=p1*r1/dd1 + fac2=p1*r2/dd2 + return fac1+fac2 + + else: ksym + + +def real_subs(QQ,**kwargs): + ''' + QQ= symbols function + ** kwargs c7=6,g4=z..etc.. + RETURN real substitucion when variable have underscore name like 'c_7' 'g_4' + ''' + + vvar=fpoly(QQ,'free') + mvar=[] + for i in vvar: + nname=str(i) + nname=nname.replace('_','') + nvar=symbols(nname) + mvar.append(nvar) + + kres=QQ + sres=str(kres) + sres=sres.replace('_','') + kres=parse_expr(sres) + mkey=[] + vvalue=[] + for key, value in kwargs.items(): + mkey.append(key) + vvalue.append(value) + + kres=kres.subs(parse_expr(key),value) + for i,j in zip(mvar,vvar): + kres=kres.subs(i,j) + return (kres) + +def coef_list(*args ,size=''): # return coef list complete according max degree + ''' + ee=x*x*a+x*b+c + return [a,b,c] + + ''' + ksym=args[0] + var2=x + for i in args: + if type(i)==Symbol: + var2=i + vcoef=[] + if str(var2) not in str(ksym): + vcoef=[ksym] + else: + dd=degree(ksym,gen=var2) + + for i in range(1,dd+1): + pe=dd+1-i + xfac=var2**pe + + vcoef.append(ksym.coeff(xfac)) + kres=ksym.subs(var2,0) + vcoef.append(kres) + if size!='': + qq1=degree(expand(ksym),var2) + if size>qq1: + qq2=size-qq1 + vec2=[0]*qq2 + vcoef=vec2+vcoef + return vcoef + + if 'noncero' in args: + kres=[] + for i in vcoef: + if i!=0: + kres.append(i) + return kres + return vcoef + +def sortdegree(ksym,var2=x): + ''' + group polynomies respect main varible + ''' + if str(var2) not in str(ksym): + return ksym + mm=coef_list(ksym,var2) + kres=0 + qq=len(mm) + cc=qq-1 + for i in mm: + kres+=i*var2**cc + cc+=-1 + return kres + +def solve_compare_coef(*args): + ''' + input (Lista de coeficientes del poly1,Lista de coeficientes del poly2) + return solucion al comparar vlores + ejm: + vec1=[x1+3*x2,x2-2*x2] + vec2=[2,3] + devuelve la sol de x1 y x2 en x1+3*x2=1 y x2-2*x2=3 + opcion: + solve_compare_coef([x1+3*x2,x2-2*x2],[2,3],[x2,x1]) + ''' + Vec1=args[0] + Vec2=args[1] + Lv='' + if len(args)==3: + Lv=args[2] + vecQ=[] + Sv=0 + for i,j in zip(Vec1,Vec2): + vecQ.append(Eq(i,j)) + Sv+=i + if Lv=='': + Lv=get_symbols(Vec1) + solu=solve(vecQ,Lv) + try: + key,value=unpack(solu) + return value + except: + return solu +def max_degree(*args,gen=x): + ''' + input (x*x+x+1,x*8+,5) + output 2 + ''' + dmax=0 + if len(args)==1 and type(args[0])==list: + args=args[0] + for i in args: + k=degree(i,gen=gen) + if k>dmax: + dmax=k + return dmax +def algebra_compare_coef(*args,var2=x): + ''' + function that resuelve variables when compare 2 polinomies wits same grade and same coef + input= args: + function,or,symbols + gen= function with defaul gen=x + output: solution all variables possibles + + + ''' + p1='' + p2='' + vsym=[] + for i in args: + if Is_Symbol(i): + vsym.append(i) + else: + if p1=='': + p1=i + else: + p2=i + + + + ql1=coef_list(p1,var2=var2) + ql2=coef_list(p2,var2=var2) + qq=[] + for i,j in zip(ql1,ql2): + qq.append(i-j) + kres=solve(qq,vsym) + if type(kres)==dict: + kres= kunpakDic(kres) + nvar=kres[0] + nval=kres[1] + if type(kres)==list: + kres= kunpakDic(kres) + nvar=kres[0] + nval =kres[1] + + return nval + + + + +##################################### +# functions +##################################### +def subsnumber(ksym,val1,val2): # replace an integer number by symbol + kres=ksym + sres=str(kres) + sv1=str(val1) + sv2=str(val2) + sres=sres.replace(sv1,sv2) + kres2=parse_expr(sres) + return kres2 + +def func2symbol(ksym,y,x): + veri='('+str(x)+')' + sf=str(y) + if veri in sf: + nf=sf.replace(veri,'') + else: + nf=sf + oldf=nf+veri + sres=str(ksym) + sres=sres.replace(oldf,nf) + return parse_expr(sres) + +def unfog(expr,*args): + if type(expr)==MyEq: + expr=expr.ksym + svec=[] + vvec=[] + for i in args: + if type(i)==str: + svec.append(i) + else: + vvec.append(i) + kres=findFunc(expr,svec,vvec) + return kres +#def findFunc(f1,vecf,vecv): +def findFunc(f1,vecf,vecv): + ''' + f((x+1)**2)= 2*x*x+4*x+5 , f1= 2*x+3 + procces, x--> Add(1) -->['A'],[1] -->x+1 -->Pow(2) -->['A','P'],[1,2] --> + vecf = ['A','P'] ,Posibles...>add,'A',mul 'M',divide 'D',sqrt 'R',pow 'P' + vecv = ['A','P'] + findFunc(2*x*x+4*x+5,['A','P'],[1,2]) + + return f(x)= 2*x+3 + ''' + y,z=symbols('y z') + #Q=MyEqEq(y,f1) + xx=solve(y-f1,x) + if type(xx)==list: + xx=xx[0] + for i,j in zip(vecf,vecv): + if i=='R': + xx=sqrs(xx,j) + elif i=='M': + xx=xx*j + elif i=='D': + xx=xx/j + elif i=='P': + xx=xx**j + else: + xx+=j + yy=solve(z-xx,y) + if type(yy)==list: + yy=yy[0] + y=yy.subs(z,x) + + + return y + + + + +##################################### +# monomies tools +##################################### + +def baselist(ksym): # return list of all monomies in Monomie in Mul expr + ''' + input (x+a)**a*(y-2)**b*z**c + return [(x+a),(y-2),z] + ''' + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + vres=[] + for i in mm: + if Is_Pow(i): + vres.append(getbase(i)) + else: + vres.append(i) + return vres + else: + return ksym +def expolist(ksym): # return list of each exponents in Monomie from Mul expr + ''' + input (x+a)**a*(y-2)**b*z**c + return [(a,b,c] + ''' + if Is_Mul(ksym): + mm=fpoly(ksym,'list') + vres=[] + for i in mm: + if Is_Pow(i): + vres.append(getexponent(i)) + else: + vres.append(1) + return vres + else: + return ksym + +def expandfracpart(expr,gen=x): + P1=numer(expr) + P2=denom(expr) + Ng=max_degree(P1,gen=gen) + Dg=max_degree(P2,gen=gen) + if Ng>Dg: + Q=quo(P1,P2,gen) + remain=rem(P1,P2,gen) + mm=[Q,remain/P2] + return mm + else: + return [0,expr] + + + +def powlist(expr): + if Is_Pow(expr): + b,ee,rr=partPow(expr) + mm=[] + for i in range(ee): + mm.append(b**(i+1)) + return mm + else: + return [expr] + +def factorlist3(expr): + ''' + input((x+1)(x-1)) + output[x+1,x-1] + ''' + expr=factor(expr) + + if Is_Pow(expr): + return powlist(expr) + else: + mm=fpoly(expr,'list') + kres=[] + for i in mm: + if Is_Mul(i): + mm1= fpoly(i,'list') + kres=kres+mm1 + elif Is_Pow(i): + kres=kres+ powlist(i) + else: + kres.append(i) + return kres +''' +def partialfraction(*args): # Return divition monimies in partial fraction + y1,y2,y3,y4,y5,y6,y7,y8,y9,y10=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10') + y11,y12,y13,y14,y15,y16=symbols('y11 y12 y13 y14 y15 y16') + fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] + expr=args[0] + if len(args)==2: + var=args[1] + else: + var=x + expr=factor(expr) + p1=numer(expr) + p2=denom(expr) + vec2=complete2partfrac(p2) + vec1=vec_daughter(vec2,fabr,gen=var) + P=0 + for i,j in zip(vec1,vec2): + P=P+cfrac(i,j) + P2=factor(P) + P3=numer(P2) + P4=expand(P3) + dg1=degree(p1,gen=var) + dg2=degree(P4,gen=var) + if dg1dg2: + vec1=coef_list(p1,var2=var) + vec2=coef_list(P4,size=dg1,var2=var) + else: + vec1=coef_list(p1,var2=var) + vec2=coef_list(P4,var2=var) + + vec3=[vec2[i]-vec1[i] for i in range(3)] + kres=solve(vec3) + svar,vval=ganswer(kres,'varname','value') + for i,j in zip(svar,vval): + P=P.subs(i,j) + return P +''' +def swaplist(klist): + qq=len(klist) + mm=[] + for i in range(qq): + mm.append(klist[qq-1-i]) + return mm + +##################################### +# polynomies tools +##################################### + +# simplifysum() +# ----------- +def simplifysum(pval): + ''' + return sum of each monomie of pval but uniformatin each one to get real sum + + + ''' + if Is_Add(pval): + mm=fpoly(pval,'list') + + kk=0 + for i in mm: + k1=simplify(i) + kk+=mulexp(k1) + return kk + else: + return pval + + +# linfactor() +# ----------- +def linfactor(ksym,kvar=''): + ''' + factorize() return personality factorization of Polynomie summ + example: + if kfunc = a*x*x+b*c*x*x+3*x + factorize(kfunc,x*x) + return : + x*x*(x+b*x)+3*x + + ''' + + p1=ksym + if kvar!='' and type(p1)==Add: + oldv=0 + newv=0 + kfac=kvar + mm=fpoly(p1,'list') + for i in mm: + vec=simplify(i/kfac) + if denom(vec)==1: + newv+=vec + else: + oldv+=i + kres=oldv+newv*kfac + return kres + else: + return ksym + + + + +def Area2funcXY(ee1, ee2, var=x, cota='', kope=''): + if type(ee1)==MyEq: + kres1=ee1.ksym + else: + kres1=ee1 + if type(ee2)==MyEq: + kres2=ee2.ksym + else: + kres2=ee2 + kres=solve(kres1-kres2,var) + if cota=='' and len(kres)==2: + segx=kres + else: + x1,x2=cota + segx=[x1] + for i in kres: + if i>x1 and i return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + kres=ksym + if Is_Number(ksym): + + return ksym + + + if Is_Div(ksym): + + p1=powexpand(numer(ksym)) + p2=powexpand(denom(ksym)) + + return p1/p2 + + + elif Is_Mul(ksym): + mm=fpoly(ksym,'list') + kres=1 + for i in mm: + kres=kres*powexpand(i,op=op) + + return kres + + elif type(ksym)==Pow: + mm=fpoly(ksym,'list') + val=mm[0] + vexp=mm[1] + if type(vexp)==Pow: + + return ksym + elif type(vexp)==Mul: + mm2=fpoly(vexp,'list') + if len(mm2)==2: + p1=mm2[0] + p2=mm2[1] + if op!='': + kres=(val**p2) + kres=kres**p1 + else: + kres=(val**p1) + kres=kres**p2 + return kres + + else: + return ksym + + + + elif Is_Add(ksym): + mm=fpoly(ksym,'list') + mmr=0 + for i in mm: + mmr+=powexpand(i,op=op) + return mmr + else: + return ksym + +def div2mulexp(ksym): + ''' + input ((a/b)**x ----> return(a**x)*(b**(-x)) + + ''' + if Is_Div(ksym): + p1=numer(ksym) + p2=denom(ksym) + kres=p1*simplify(p2**(-1)) + return kres + if Is_Pow(ksym): + mm=fpoly(ksym,'list') + vald=mm[0] + vale=mm[1] + if denom(vald)!='1': + p1=numer(vald) + p2=denom(vald) + kres=(p1**vale)*(p2**(-1*vale)) + return kres + else: + return ksym + if Is_Add(ksym): + kres=0 + mm=fpoly(ksym,'list') + for i in mm: + kres+=div2mulexp(i) + return kres + if Is_Mul(ksym): + kres=1 + mm=fpoly(ksym,'list') + for i in mm: + kres=kres*div2mulexp(i) + return kres + else: + return ksym + + + + +def reducePow(ksym): + kres= simplifyexp(mulexpo(div2mulexp(ksym))) + return simplifyexp(kres) +##################################### +# GDC MCM +##################################### + +def GCD(ee1,ee2): # returm GDC between ee1,ee2 Maximo Comun Divisor + b1=baselist(1*ee1) + b2=baselist(1*ee2) + e1=expolist(1*ee1) + e2=expolist(1*ee2) + kres=1 + for v1,ve1 in zip(b1,e1): + for v2,ve2 in zip(b2,e2): + if v2==v1: + if Is_Number(ve1) and Is_Number(ve2): + nexp=min(ve1,ve2) + kres=kres*v1**nexp + return kres + +def LCM(v1,v2): # returm GDC between ee1,ee2 Maximo Comun Divisor + ee1=1*v1 + ee2=1*v2 + b1=baselist(1*ee1) + b2=baselist(1*ee2) + e1=expolist(1*ee1) + e2=expolist(1*ee2) + bb=unionvec(b1,b2) + + kres=1 + for i in bb: + ex1=0 + ex2=0 + ee=[] + if i in b1 : + p1=getindex(i,b1) + ex1=e1[p1] + if i in b2 : + p2=getindex(i,b2) + ex2=e2[p2] + if ex1!=0: + ee.append(ex1) + if ex2!=0: + ee.append(ex2) + + ef=min(ee) + kres=kres*i**ef + return kres + + +def addexpand(expr): # converte in factor inside sum polinomies factor + if Is_Div(expr): + p1=addexpand(numer(expr)) + p2=addexpand(denom(expr)) + + return cfrac(p1,p2) + + elif Is_Pow(expr): + B,ee,rr=partPow(expr) + B=addexpand(B) + + return kpow(B,ee,rr) + + elif Is_Mul(expr): + mm=fpoly(expr,'list') + kres=1 + for i in mm: + kres=kres*addexpand(i) + + return kres + elif Is_Add(expr): + kres=factor(expr) + + return kres + else: + return expr + +########################################## +##### simplify Root !!!!!!!!! + +def lsimplify(expr): + if Is_Add(expr): + expr2=logcombine(expr) + if str(expr2)!=str(expr): + return expr2 + else: + mm=0 + for i in fpoly(expr,'list'): + mm=mm+lsimplify(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=lsimplify(p1) + P2=lsimplify(p2) + + return Div(P1,P2) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*lsimplify(i) + return mm + + else: + return expr +def simplifyroot(expr): + if Is_Pow(expr): + B,ee,rr=partPow(expr) + if Is_Div(B): + p1=numer(B) + p2=denom(B) + P1=kpow(p1,ee,rr) + P2=kpow(p2,ee,rr) + + expr=cfrac(P1,P2) + expr=killroot(expr) + if Is_Mul(B) and not Is_Div(B): + kres=1 + mm=fpoly(B,'list') + for i in mm: + kres=kres*rpow(i**ee,rr) + expr=kres + expr=killroot(expr) + + + + A=0 + B,ee,rr=partPow(expr) + + if Is_Div(ee): + p2=denom(ee) + rr=rr*p2 + ee=numer(ee) + if Is_Pow(B): + B2,ee2,rr2=partPow(B) + + ee=ee*ee2 + rr=rr*rr2 + B=B2 + + + + if Is_Div(ee): + p2=denom(ee) + rr=rr*p2 + ee=numer(ee) + nM,nE=compdiv(ee,rr) + P1=kpow(B,nM) + P2=kpow(B,nE,rr) + if P1==1: + P3=P2 + elif P2==1: + P3=P1 + else: + P3=Mul(P1,P2,evaluate=False) + + return P3 + + +def compdiv(p1,p2): + R=p1%p2 + C=cfrac((p1-R),p2) + return(C,R) + + +def simplify_root_exp(expr): + if Is_Pow(expr): + B,ee,rr=partPow(expr) + if Is_Div(B): + + p1=numer(B) + p2=denom(B) + P1=rpow(p1**ee,rr) + P2=rpow(p2**ee,rr) + expr=cfrac(P1,P2) + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+simplify_root_exp(i) + return mm + elif Is_Div(expr): + p1=simplify_root_exp(numer(expr)) + p2=simplify_root_exp(denom(expr)) + return cfrac(p1,p2) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*simplify_root_exp(i) + return mm + else: + return simplifyroot(expr) + + + + + +def truetable (n): + if n < 1: + return [[]] + subtable = truetable(n-1) + return [ row + [v] for row in subtable for v in [0,1] ] + + +## PLOt + +from matplotlib.patches import Polygon +def Area2(self,*args,typos=-1,tsize=10): + var=self.var + done=False + ksolu=solve(self.ksym,var) + if len(ksolu)>0: + done=True + if len(args)==2: + x1=args[0] + x2=args[1] + x3=100 + X1=args[0] + X2=args[1] + elif len(args)==3: + x1=args[0] + x2=args[1] + x3=args[2] + X1=args[0] + X2=args[1] + else: + + ksolu=solve(self.ksym,var) + x1=min(ksolu) + X1=min(ksolu) + x2=max(ksolu) + X2=max(ksolu) + x3=100 + dx=(x2-x1)/10 + x1=x1-dx + x2=x2+dx + done=True + fac=(x2-x1)/x3 + X=[] + Y=[] + yvalor=self('value',var=fac) + + #for i in range(x3): + #valor=float(x1+fac*i) + #X.append(float(valor)) + #Yvalor=yvalor.subs(var,valor) + + #Y.append(float(Yvalor)) + allvar=[] + if done: + if len(ksolu)>0: + allvar=ksolu + if X1 not in allvar: + allvar.append(X1) + if X2 not in allvar: + allvar.append(X2) + ksolu=allvar + ksolu.sort() + X1=min(ksolu) + X2=max(ksolu) + fig, ax = plt.subplots() + ix,iy =funclist(self,X1,X2,100) + + + verts = [(X1,0),*zip(ix, iy),(X2,0)] + + poly = Polygon(verts, facecolor='0.9', edgecolor='0.5') + ax.add_patch(poly) + ax.grid(True, which='both') + ax.plot(ix, iy) + Lx=[x1,x2] + Ly=[0,0] + ymin,ymax=ax.get_ylim() + ax.plot(Lx, Ly,color='black') + if done: + + ysolu=funclist(self,ksolu) + + for i ,j in zip(ksolu,ysolu): + ax.plot([i,i],[j,0],linestyle='-.',color='black') + ax.plot([i],[j],'o',color='red') + tvec=textpos(ksolu,typos,tsize) + tex=f'${latex(Integral(self.primi,self.var))}$' + Yp=1 + for i in tvec: + tx,ty,tf=i + ty=ty*Yp + Yp=-1*Yp + ax.text(tx, ty, tex,fontsize=tf) + + + ax.grid(True, linestyle='-.') + ax.tick_params(labelcolor='r', labelsize='medium', width=3) + + plt.show() + return ksolu + + +def funclist(self,*args): + + if len(args)>1: + x1=args[0] + x2=args[1] + qq=50 + if len(args)>2: + qq=args[2] + xr=list(range(qq+1)) + fac=(x2-x1)/qq + xx=[x1+fac*i for i in xr] + else: + xx=args[0] + + kfunc=self.ksym + yy=[kfunc.subs(self.var,i) for i in xx] + if type(args[0])==list: + return yy + else: + return xx,yy + +def squarecomplete(expr,var): + ''' + input: + expr= x*x+2*x* + var=x + return: + (x+1)**2 -1 + ''' + + + expr=sortdegree(expr,var) + L1=coef_list(expr,var) + r=L1[2] + p1,p2=L1[0],L1[1] + done=False + if signo(p1)==-1: + L1=[-1*i for i in L1] + done=True + L1[2]=a + p1,p2=L1[0],L1[1] + + b=simplify(sqrt(p1)) + c=p2/(2*b) + + if done: + r2=r+c*c + return -1*(b*var+c)**2+r2 + else: + r2=r-c*c + return (b*var+c)**2+r2 + +def setpack(expr,**kwargs): + ''' + replace value of kwaargs in exprend return expr + ''' + doned=False + if "'" in str(expr): + doned=True + if not Is_Number(expr): + if doned: + expr=amperdiff2normaldiff(expr) + + svec,vvec=unpack(kwargs) + for i,j in zip(svec,vvec): + if doned: + expr=expr.replace(i,str(j)) + else: + expr=expr.subs(i,j) + + if doned: + expr=normaldiff2amperdiff(expr) + return expr + else: + return expr + +def amperdiff2normaldiff(expr): + sQ=str(expr) + vecvaldiff=['d2x','d2y','d2z','d2u','d2v','d2w','dx','dy','dz','du','dv','dw'] + vecvaldiffp=["x''","y''","z''","u''","v''","w''","x'","y'","z'","u'","v'","w'"] + for i,j in zip(vecvaldiff,vecvaldiffp): + sQ=sQ.replace(j,i) + + return sQ + +def normaldiff2amperdiff(expr): + sQ=parse_expr(expr) + vecvaldiff=['d2x','d2y','d2z','d2w','d2u','d2v','dx','dy','dz','dw','du','dv'] + vecvaldiffp=[d2x,d2y,d2z,d2w,d2u,d2v,dx,dy,dz,dw,du,dv] + for i,j in zip(vecvaldiff,vecvaldiffp): + sQ=sQ.subs(i,j) + + return sQ + +def normalizediff(expr,sf,var): + ''' + traduce sympy diff expressions to + MyEqEq diff mat expressions + ''' + B,C=symbols('B C') + t=symbols(var) + f=Function(sf)(t) + expr=expr.subs(f.diff(var),B) + expr=expr.subs(f,C) + f=symbols(sf) + df,d2f=diffsymbolprime(f) + dt,d2t=diffsymbolprime(t) + expr=expr.subs(C,f) + expr=expr.subs(B,df/dt) + x,y,z,u,v,w=symbols('x y z u v w') + mm=normaldiff2amperdiff(amperdiff2normaldiff(expr)) + return mm + +def conjugate(expr): + ''' + if expr=a+b return a-b + if expr=a-b return a+b + ''' + mm=expr.args + return (mm[1]-mm[0]) + +def squareadd2squaremul(expr): + '''' + input (x*x-y*y) + return (x+y)*(x-y) + ''' + var1,var2=expr.free_symbols + svar1=str(var1) + svar2=str(var2) + k1=symbols(svar1,positive=True) + k2=symbols(svar2,positive=True) + expr=expr.subs(var1,k1) + expr=expr.subs(var2,k2) + p1,p2= expr.args + p11=sqrt(p1) + p111=str(p11) + p111=p111.replace('I','1') + p11=parse_expr(p111) + done=False + if signo(p2)==-1: + done=True + p2=-1*p2 + p22=sqrt(p2) + p222=str(p22) + p222=p222.replace('I','1') + p22=parse_expr(p222) + sp1=str(p11) + sp2=str(p22) + sexpr="("+sp2+"+"+sp1+")*("+sp2+"-"+sp1+")" + kres=sympify(sexpr,evaluate=False) + return UnevaluatedExpr(kres) + + +def Divunevaluate(expr): + ''' + expr is a unevaluate expr + expr= a*b/b + Divunevaluate(expr) return a* + ''' + + expr2=expr.args[0] + kn=numer(expr2) + kn=sympify(str(kn)) + kd=denom(expr2) + kd=sympify(str(kd)) + nkn=1 + nkd=1 + if type(kn)==Mul: + nlist=kn.args + else: + nlist=[kn] + if type(kd)==Mul: + dlist=kd.args + else: + dlist=[kd] + for i in nlist: + if i not in dlist: + nkn=nkn*i + for i in dlist: + if i not in nlist: + nkd=nkd*i + return nkn/nkd + + + +def simplifyMul(p1,p2): + P1=p1 + P2=p2 + if Is_Mul(p1) and Is_Mul(p2): + P1=1 + P2=1 + mm1=p1.args + mm2=p2.args + for i in mm1: + if i not in mm2: + P1=P1*i + for j in mm2: + if j not in mm1: + P2=P2*j + + return P1,P2 + + +def simplifySum(p1,p2): + P1=p1 + P2=p2 + if Is_Add(p1) and Is_Add(p2): + P1=0 + P2=0 + mm1=p1.args + mm2=p2.args + for i in mm1: + if i not in mm2: + P1=P1+i + for j in mm2: + if j not in mm1: + P2=P2+j + + return P1,P2 + +def precross(expr): + if Is_Add(expr): + expr=factor(expr) + p1,p2=fraction(expr) + + elif Is_Div(expr): + p1,p2=fraction(expr) + elif Is_Pow(expr): + + bb=getbase(expr) + ee=getexpo(expr) + if Is_Div(bb): + p1,p2=fraction(bb) + p1=p1**ee + p2=p2**ee + else: + p1=expr + p2=1 + return p1,p2 + +def monodegree(obj,var=x): + expr= obj + if not str(var) in str(expr): + return 0 + else: + p=expr.subs(var,1) + p2=simplify(expr/p) + p3=getexpo(p2) + return p3 +def monocoef(obj,var=x): + expr= obj + p=expr.subs(var,1) + return p + +from operator import itemgetter +def infodegreemat(obj,var=x): + kres=[] + expr= obj + mm=expr.args + for i in mm: + coe=monocoef(i,var=var) + gra=monodegree(i,var=var) + kres.append([coe,gra,i]) + kres=sorted(kres, key=itemgetter(1), reverse=True) + vecc=[] + vecg=[] + vece=[] + for i in range(len(kres)): + vec=kres[i] + vecc.append(vec[0]) + vecg.append(vec[1]) + vece.append(vec[2]) + return vecc,vecg,vece + +def trinomio2squarebinomio(obj,var=x): + expr=obj + mm=expr.args + if len(mm)==3: + vecc,vecg,vece=infodegreemat(expr,var=var) + #if (vecg[0]+vecg[2])/2==vecg[1]: + ksigno=signo(vece[1]) + a=rsimplify(sqrt(vece[0])) + b=vece[1]/2/a + + ebin=(a+b)**2 + eebin=expand(ebin) + resto=simplify(eebin-vece[0]-vece[1]-vece[2]) + return ebin+resto + + else: + return expr + +def tri2squ(obj,var=x): + expr=obj + mm=expr.args + if len(mm)==3: + vecc,vecg,vece=infodegreemat(expr,var=var) + #if (vecg[0]+vecg[2])/2==vecg[1]: + ksigno=signo(vece[1]) + a=sqrt(vece[0]) + b=vece[1]/2/a + + ebin=(a+b)**2 + eebin=expand(ebin) + resto=simplify(eebin-vece[0]-vece[1]-vece[2]) + return ebin+resto + + else: + return expr + +def tri2bin(expr,sexpr,var=''): + if var=='': + var=self.var + nexpr=parse_expr(sexpr) + expr2=tri2squ(nexpr,var=var) + msexpr=str(expr) + kres=subsubs(expr,nexpr,expr2) + return kres + +def functiondiff(*args): + ''' + if Area= b*h/2 in function of time... + then A(t)=b(t)*h(t)/2... + input : functiondiff(expr, var, varF1, varF2,varF3...etc) + in this case: + A=functiondiff(A,t,A) = dA + R=functiondiff(b*h/2,t,b,h) = b*dh/2 + db*h/2 + + ''' + expr=args[0] + var=args[1] + if len(args)==2: + return diff(expr,var) + else: + v1=[] + for i in range(2,len(args)): + v1.append(args[i]) + v2=[] + cc=1 + for i in v1: + F='f'+str(i) + F=Function(str(i))(var) + v2.append(F) + cc=cc+1 + v3=[] + for i in v2: + v3.append(diff(i,var)) + v4=[] + for i in v3: + v4.append(str(i)) + v5=[] + for i in v1: + svar='d'+str(i) + svar=symbols(svar) + v5.append(svar) + + + for i,j in zip(v1,v2): + expr=expr.subs(i,j) + dexpr=diff(expr,var) + for i,j in zip(v3,v5): + dexpr=dexpr.subs(i,j) + for i,j in zip(v2,v1): + dexpr=dexpr.subs(i,j) + return dexpr \ No newline at end of file diff --git a/Libaldo/libaldo_math2.py b/Libaldo/libaldo_math2.py new file mode 100644 index 0000000..ae53e54 --- /dev/null +++ b/Libaldo/libaldo_math2.py @@ -0,0 +1,3101 @@ +from sympy import * +from latex2sympy2 import latex2sympy +from functools import reduce +import matplotlib.pyplot as plt +import sys +sys.path.append('../Libaldo') +from IPython.display import Math # ,display + +import re + +# VARIABLE +t,a,b,c,d,x,y,z,w,i,j,k,alpha=symbols('t a b c d x y z w i j k alpha') +AA=symbols('AA') +########################################## +# Variable Crea Transforma +########################################## +def cleanvar(*args): + mm=[] + for i in args: + mm.append(symbols(str(i))) + if len(mm)==1: + return mm[0] + else: + return mm + +def clearvar(*args): + mm=[] + for i in args: + mm.append(symbols(str(i))) + if len(mm)==1: + return mm[0] + else: + return mm +def diffvar(*args): #crea variables dieferenciables + mm=[] + for i in args: + sres='d_'+alphaname(str(i)) + mm.append(symbols(sres)) + if len(mm)==1: + return mm[0] + else: + return mm +def c2c(kval): + if Is_Number(kval) and type(kval)==float and (kval-int(kval))==0: + return int(kval) + return kval + + + +def get_varfunc(ksym): # input symbols 'v(t)' return symbols 't' + sres=str(ksym) # inputs and output are symbols variables + p1=sres.find('(') + p2=sres.find(')') + sres=sres[p1+1:p2] + return parse_expr(sres) + +def antiprimitiva(ksym): # input symbols 'v(t)' return symbols 'v' + # input symbols 'v' return symbols 'v' + + sres=str(ksym) # inputs and output are symbols variables + p1=sres.find('(') + if p1!=-1 and p1>0: + sres=sres[0:p1] + return parse_expr(sres) + else: + return ksym + + + + + +def unisymbols(ksym): + ''' + unisymbols() : this function homegenize diferent variables whit + the same symbolic name in omly one in all symbols expresion + ''' + if type(ksym)==list: + return [unisymbols(i) for i in ksym] + else: + + try: + kres=parse_expr(str(ksym)) + except: + kres=ksym + return(kres) + +def sydem(ksym): + + ''' + sydem() : symbol-idem + try to return the original function + with out auto math transformathis + ''' + kres=UnevaluatedExpr(ksym) + return unisymbols(kres) + +def sym2func(nval,ksym): + ''' + sym2func() + ----------------------- + input : nval = symbolic name function + ksym = posible dependient variable + return : nval function + ''' + return convFunc(nval,ksym) + +def convFunc(nval,ksym): # symbol to Function args=(symbols, var2) + newF=Function(nval)(ksym) + return newF + +def sym2func(nval,ksym): + return convFunc(nval,ksym) + +def primitivename(ksym): + kres=ksym + sres=str(ksym) + if '(' in sres: + nsres=sres[0:sres.find('(')] + kres=symbols(nsres) + return kres + +def get_symbols(*args): + ''' + return vector insode all expr in args + ''' + mm=[] + for i in args: + if type(i)==list: + for j in i: + vecm=fpoly(j,'free') + for k in vecm: + if k not in mm: + mm.append(k) + else: + vecm=fpoly(i,'free') + for k in vecm: + if k not in mm: + mm.append(k) + return mm +def sym2Function(*args): # symbols vector to Function vector *args=(symbols,symbols,......,var2) + + mm=[] + vt=args[-1] + for i in args[:-1]: + mm.append(convFunc(i,vt)) + return mm + +def symboldiff(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"'" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff(i)) + return mm + +def symboldiff2(*args): + if len(args)==1: + svar=str(args[0]) + dsvar=svar+"''" + return symbols(dsvar) + else: + mm=[] + for i in args: + mm.append(symboldiff2(i)) + return mm +################################# +# create list variables +################################# + +def replacestrinvec(vec,val1,val2): + ''' + vec=['1','2','3','4','5'] + we need change '3' by 'x' + replacestrinvec(vec,'3','x') + return ['1','2','x','4','5'] + ''' + kres=[val2 if i==val1 else i for i in vec] + return kres + +def mzero(kval,kop=0): # return list with [kop,kop,kop,.....] kval times + mm=[] + for i in range(kval): + mm.append(kop) + return mm + + +def subtrac_list(lst1, lst2): # return list2 without similares in list2 + lst3 = [value for value in lst1 if value not in lst2] + return lst3 + +def listmul(list1): + kres=1 + for i in list1: + kres=kres*i + return kres + + + +################################# +# Math +################################# +def nformat(ksym,qn): + return N(ksym,qn) + + +def try2float(kk): + if type(kk)==list: + mm=[] + for i in kk: + mm.append(try2float(i)) + return mm + else: + try: + kk2=float(kk) + return kk2 + except: + return kk + + +# cfrac() ***************** +def cfrac(*args,evaluate=False): + if len(args)==0: + helplib('cfrac') + return + if len(args)==1 and type(args[0])!=str: + p1=1 + p2=args[0] + elif len(args)==1: + p1=numer(args[0]) + p2=denom(args[0]) + else: + p1=args[0] + p2=args[1] + + if not evaluate: + return UnevaluatedExpr(UnevaluatedExpr(p1)/(p2)) + else: + try: + return frs(k1=p1,k2=p2) + except: + return p1/p2 + +def frs(k1,k2): # return S('k1/k2') + + if Is_Number(k1) and Is_Number(k2): + return Rational(k1, k2) + else: + return sydem(k1/k2) + +# sqrs() ***************** + +def rpow(*args): + kval=args[0] + if len(args)==1: + kres= sqrt(kval) + else: + rr=args[1] + kres= ppow(kval,cfrac(1,rr)) + return kres + + +def sqrs(k1,k2='',k3=1): # return pow(k1,S('k2')) + ''' + sqrs() + input: sqrs(a) return sqrt(a) + input: sqrs(a,b) return sqrt(b) of (a) + input: sqrs(a,b,c) return sqrt(b) of (a)**c + + ''' + k1=1*k1 + + if k2=='': + k2=2 + else: + k2=1*k2 + v1=str(k2) + if k3!=1: + k3=1*k3 + v2='('+str(k3)+')/('+v1+')' + else: + v2='1/('+v1+')' + kres=pow(k1,S(v2)) + + return(kres) + + +# ppow() ***************** +def ppow(*args): + if len(args)==0: + helplib('ppow') + return + + return kpow(*args) + +def kpow(*args): + ''' + kpow(a) return a**2 + kpow(a,b) return a** b + kpow(a,b,c) return a** (b/c) + + ''' + if len(args)==0: + helplib('kpow') + return + ksym=args[0] + if len( args)==1: + return ksym**2 + elif len( args)==2: + ee=args[1] + return ksym**ee + else: + rr=args[2] + ee=args[1] + if rr==2: + return sqrt(ksym**ee) + else: + return ksym**cfrac(ee,rr) + + + + + +# sex2rad() ***************** +def sex2rad(k): # convert segsadesimal to radial + if k=='': + helplib('sex2rad') + return + k=simplify(pi*k/180) + return(k) + +# rad2sex() ***************** +def rad2sex(k): # convert radial to sexages. + if k=='': + helplib('sex2rad') + return + k=simplify(cfrac(180*k,pi)) + return(k) + +# sex2rad_i() ***************** +def sex2rad_i(kang,s='r'): + if s=='s': + kang=sex2rad(kang) + return(kang) + +# killabs() ***************** +def kilabs(ksym): + if ksym=='': + helplib('killabs') + return + + ''' + input: abs(x) + return : x + ''' + return killAbs(ksym=ksym) + +def killAbs(ksym): + kres=ksym + try: + mm=str(kres) + mm=mm.replace('Abs','') + return parse_expr(mm) + except: + return kres + +# signo() ***************** +def makepos(kres): + return kres*signo(kres) + + +def signo(ksym): + if ksym=='': + helplib('signo') + return + ''' + input: x + return : -1 if x<0 + return : 0 if x=0 + return : 1 if x>0 + + ''' + kres=1*ksym + mm=fpoly(ksym,'free') + for i in mm: + kres=kres.subs(i,1) + + try: + if kres<0: + return -1 + elif kres>0: + return 1 + else: + return 1 + except: + return 1 + +# unfloatdiv() ***************** +def unfloatdiv(p1,p2): # return p1/p2 whitout avaluate + P1=str(p1) + P2=str(p2) + P3='('+P1+')/('+P2+')' + return parse_expr(P3,evaluate=False) + +##################### +# get info +##################### + +# insideroot() ***************** +def insideroot(ksym=''): + ''' + input: x**(a/b) + return : x**a + + + ''' + if ksym=='': + helplib('insideroot') + return + + return get_inside_root(ksym=1*ksym) + +def get_inside_root(ksym): + kres=ksym + if Is_Root(kres): + mm=fpoly(kres,'list') + return mm[0] + return kres + +# insidepow() ***************** +def insidepow(ksym=''): + if ksym=='': + helplib('insidepow') + return + ''' + input: x**(a/b) + return : x**(1/b) + + ''' + return get_inside_Pow(ksym=1*ksym) +def get_inside_Pow(ksym): + kres=ksym + if Is_Pow2(kres): + mm=fpoly(kres,'list') + return mm[0] + return kres + +# getexponent() ***************** + + +# getbase() ***************** + + + +def get_killexpo(ksym): + if Is_Mono(ksym): + mm=fpoly(ksym,'list') + return mm[0] + + +##################### +# get info Geometry +##################### + +# gethipo() ***************** +def gethipo(a,b,kope=''): + if a=='' or b=='': + helplib('gethipo') + return + + a=a*1 + b=b*1 + return get_hipo(a=a,b=b,kope=kope) # return raiz(a*a+b*b) + +def get_hipo(a,b,kope=''): + + kres=rpow(kpow(a,2)+kpow(b,2),2) + kres=opemat(kres,kope=kope) + return kres + +# gethipo() ***************** +def getcateto(a,b,kope=''): + if a=='' or b=='': + helplib('getcateto') + return + a=a*1 + b=b*1 + return get_cateto(a=a,b=b,kope=kope) # return raiz(a*a-b*b) + +def get_cateto(a,b,kope=''): + kres=rpow(kpow(a,2)-kpow(b,2),2) + kres=opemat(kres,kope=kope) + return kres + +# componentx() ***************** +def componentx(kr,kang): + kr=kr*1 + kang=kang*1 + return x_pol(kr=kr,kang=kang) + + +def x_pol(kr,kang): + return kr*cos(kang) + +# componenty() ***************** +def componenty(kr,kang): + kr=kr*1 + kang=kang*1 + return y_pol(kr=kr,kang=kang) +def y_pol(kr,kang): + return kr*sin(kang) + +def lenght2point(x1,y1,x2,y2,kope=''): + x1,y1,x2,y2=1*x1,1*y1,1*x2,1*y2 + + l1=x2-x1 + l2=y2-y1 + kres=rpow(l1*l1-l2*l2) + kres=opemat(kres,kope=kope) + return kres + +# algebra1() ***************** + +def get_sum2(a,b,kope=''): # return a*a+b*b + a=unisymbols(a) + b=unisymbols(b) + kres= kpow(a,2)+kpow(b,2) + kres=opemat(kres,kope=kope) + return kres + +def get_dif2(a,b,kope=''): + a=unisymbols(a) + b=unisymbols(b) + kres= kpow(a,2)-kpow(b,2) + kres=opemat(kres,kope=kope) + return kres + + +##################### +# SOLVE +##################### + +def ksolve(kres,var,*args,**kwargs): + try: + Vk=var.name + except: + Vk=str(var) + + solu=solve(kres,Vk) + if type(solu)==list: + if 'all' in args: + return solu + else: + try: + solu=solu[0] + except: + pass + if len(args)>0: + if 'positive' in args: + solu=solu*signo(solu) + return solu + +def csolve(Eq1,ksym,kd='',korden='',kpositive=False,kope='',kdisp=False,unifique=False): + Eq1=unisymbols(1*Eq1) + ksym=unisymbols(ksym) + + + if not(kd==''): + kdisp=True + + if unifique: + kres=solve(Eq1,sympy_unifiq(Eq1,ksym)) + else: + kres=solve(Eq1,ksym) + qq=len(kres) + if qq==1: + kres=kres[0] + if qq>1: + kres=list(kres) + if kpositive: + kres=[i for i in kres if i>0] + + if len(kres)==1: + kres=kres[0] + if not(korden==''): + if qq>1: + kres=kres[korden] + + kres=opemat(kres,kope) + #qq=len(kres) + #if qq==1: + #kres=kres[0] + if kd!='': + sR=kd+' =' + display(Math(sR+latex(kres))) + #if kreturn: + return(kres) + + + +def csolveR(Eq1,ksym,kd='',kope=''): # solve 2do grade Eq return positive part + nksym=ppow(1*ksym,2) + kres=csolve(1*Eq1,nksym,kope=kope) + kres=opemat(kres,kope) + kres=rpow(kres,2) + if kd!='': + sR=kd+' =' + display(Math(sR+latex(kres))) + + return(kres) + + + +##################### +# Transformation +##################### +def tsimplify(kres): + if kres=='': + helplib('tsimpify') + return + return trigsimp(kres) + + +def subsubs(*args,force=False): + if len(args)==0: + helplib('subsubs') + return + expr,expr1,expr2=args + + sres=str(expr) + sres1=str(expr1) + sres2=str(expr2) + sres=sres.replace(sres1,sres2) + if force: + try: + kres=parse_expr(sres,evaluate=False) + return kres + except: + return expr + else: + try: + kres=parse_expr(sres) + return kres + except: + return expr + +def texpand(kres): + if kres=='': + helplib('texpand') + return + if type(kres)==Add: + rtt=0 + mm=fpoly(kres,'list') + for i in mm: + rtt=rtt+expand_trig(i) + return rtt + else: + return expand_trig(kres) + + +def opemat(ksym,kope=''): + if kope=='': + return ksym + ''' + opemat(Equation,kope=opt) + opt + 'f'= factor(Equation), + 'e'= expand(Equation), + 's'= simplify(Equation), + 't'= trigsimp(Equation) + 'x'= expand trig(Equation) + 'v'= Equation.evalf() + 'a'= apart(Equation) + 'c'= cancel(Equation) + 'E'= Equation.expand(force=True) + '2' = kill sqrt( x^2 ) + ''' + if '(' in kope: + newEq=creaQ(ksym,kope) + return newEq + + kres=unisymbols(ksym) + for i in kope: + + if i=='e' : + try: + kres=expand(kres) + except: + done=True + if i=='f' : + try: + kres=factor(kres) + except: + done=True + if i=='t' : + try: + kres=trigsimp(kres) + except: + done=True + if i=='x' : + try: + kres=expand_trig(kres) + except: + done=True + if i=='s' : + try: + kres=simplify(kres) + except: + done=True + if i=='v' : + + try: + try: + kres=float(evalf(kres)) + float(kres) + return(kres) + except: + try: + kres=float(evalf(kres)) + except: + kres=evalf(kres) + return(kres) + except: + if len(fpoly(kres,'free'))==0: + try: + kres=kres.evalf() + return(kres) + except: + try: + if not(type(kres)==float or type(kres)==int): + kres=kres.evalf() + return(kres) + except: + kres=kres + return(kres) + + + + if i=='a' : + kres=apart(kres) + if i=='c' : + kres=cancel(kres) + if i=='r' : + try: + kres=kill_root_poly(kres) + except: + if Is_Mono(ksym): + kres=kres+1 + kres=kill_root_poly(kres) + kres=kres-1 + else: + kres=kill_root_poly(ksym) + try: + mm=fpoly(kres,'list') + skres=str(kres) + smm=[] + vres=[] + for i in mm: + vres.append(str(opemat(i,'r'))) + smm.append(str(i)) + + for i,j in zip(smm,vres): + skres=skres.replace(i,j) + kres=parse_expr(kres) + except: + done=true + if i=='-' : + kres2=kres + try: + kres2=kpow(kres,-1) + kres2=opemat(kres2,'r') + kres=kpow(kres2,-1) + except: + done=False + + if i=='2' : + kres=kill_RootPow(kres) + + if i=='E' : + kres=kres.expand(force=True) + + if i=='F' : + + kres=nsimplify(kres) + if i=='R' : + kres=reduFac2(kres) + + if i=='C' : + mm=fpoly(kres,'free') + for i in mm: + try: + kres=cut_root2(kres,i) + except: + done=true + if i=='K' or i=='k' : + kres=expand(kres) + if Is_Mono(kres): + kres=signed_sqrt(kres*kres) + if Is_Poly(kres): + kres=kill_root_poly(kres) + if i=='N': + if Is_Number(kres) and not Is_Symbol(kres): + kres=float(kres) + kres=N(kres) + + return(kres) + +def reduFac2(ksym): + kres=ksym + try: + mm=fpoly(factor(kres),'list') + try: + mkres=1 + for i in mm: + if Is_Poly(i): + mkres=mkres*i + return mkres + except: + return kres + + except: + return kres + +def reduMonoFac(ksym): + kres=ksym + nkres=1 + dfactor=False + if Is_Poly(kres): + kres=factor(kres) + if Is_Mono(kres): + dfactor=True + return denom(kres) + if Is_Mono(kres): + mm=fpoly(kres,'list') + + done=False + for i in mm: + done=False + eqs=str(i) + if '+ ' in eqs or '- ' in eqs: + done=True + if done: + nkres=nkres*i + if dfactor: + return expand(nkres) + else: + return nkres + else: + return kres + +def opemat_vec(ksym,kope): + mm=[] + for i in ksym: + kres=opemat(i,kope) + mm.append(kres) + return mm + +def opematsec(ksym,kope=''): # equal to opemat but secuential + kres=unisymbols(ksym) + for op in kope: + kres=opemat(kres,kope=op) + + return kres + +def opematPolySec(ksym,kope=''): + kres=ksym + if Is_Add(kres): + mm=0 + for i in fpoly(kres,'list'): + mm+=opemat(i,kope=kope) + kres=mm + + else: + kres=opemat(kres,kope) + + return kres + +def opemat_deno(ksym,kope=''): + knume=numer(ksym) + kdeno=denom(ksym) + kdeno=opemat(kdeno,kope=kope) + kres=knume/kdeno + return kres + +def opemat_nume(ksym,kope=''): + knume=numer(ksym) + kdeno=denom(ksym) + knume=opemat(knume,kope=kope) + kres=knume/kdeno + return kres + + +##################### +# get info ALgebra +##################### + + +def fpoly(ksym,kopt='',op2='',op3=''): + + ''' + 'n': return number of args + 'list': return list of args + 'get': return args No =op2 in list args + 'get_inv': return inverse of args No=op2 in,list + 'gets': return sum of term(a)+term(b)+... op2= 'ab...' + 'getp': return multi of term(a)+term(b)+... op2= 'ab...' + 'free': return list of all variable symbols in ksym + 'filt': + 'unfilt': + 'frac2sum': + 'lam': return lambdify(op2,ksym) + 'simpow': + 'subs': return(ksym.subs(op2,op3) + 'facmono': factorize ksym whit op2 + 'in_allexp': + 'simp_fac': + 'simp_facs': + ''' + if kopt!='free' and kopt!='n' and kopt!='forze_subs': + if kopt!='forze_subs': + karg=ksym.args + klist=list(karg) + knum=len(klist) + kres=ksym + done=False + if kopt=='h': + kres=kres.subs(op2,op3) + print(op2,op3,kres.subs(op2,op3)) + + + if kopt=='n': + if type(ksym)==int or type(ksym)==float: + kres=0 + done=True + elif type(ksym)==Symbol: + kres=1 + done=True + + else: + kres=len(ksym.args) + done=True + + if kopt=='list': + if type(ksym)==int or type(ksym)==float: + kres=[] + done=True + elif type(ksym)==Symbol: + + mm=[] + mm.append(ksym) + + kres=mm + done=True + elif op2=='poly': + if Is_Mono(ksym): + if not Is_Poly(ksym): + kres=[ksym] + done=True + + else: + karg=ksym.args + kres=list(karg) + done=True + + if kopt=='get': + kres=(klist[op2]) + done=True + if kopt=='get_inv': + kres=(klist[op2]) + kres=kres**-1 + done=True + if kopt=='gets': + done=True + for i in op2: + nsym=klist[int(i)] + if done: + mm=nsym + done=False + else: + mm=mm+nsym + kres=(mm) + done=True + if kopt=='getp': + mm=1 + for i in op2: + nsym=klist[int(i)] + mm=mm*nsym + kres=(mm) + done=True + if kopt=='free': + try: + kres=(list(ksym.free_symbols )) + done=True + except: + kres=[] + done=True + + + if kopt=='frees': + vsym=fpoly(ksym,'free') + vsyms=[] + for i in vsym: + vsyms.append(str(i)) + kres=vsyms + if kopt=='filt' and op2!='': + kres=0 + for i in fpoly(ksym,'list'): + if op2 in fpoly(i,'free'): + kres=kres+i + + if kopt=='filtp' and op2!='': + kres=0 + for i in fpoly(ksym,'list'): + if op2 in fpoly(i,'free'): + kres=kres+i + + if kopt=='unfilt' and op2!='': + kres=0 + for i in fpoly(ksym,'list'): + if op2 not in fpoly(i,'free'): + kres=kres+i + + + if kopt=='frac2sum': + kres=klist + + kq0=klist[0] + kq1=kq0.args[0] + kq2=klist[1] + kres=(kq2,kq1) + + done=True + if kopt=='rqt': + kstr='1/'+str(op2) + kres=Pow(ksym,S(kstr)) + if kopt=='lam': + kres=lambdify(op2,ksym) + if kopt=='simpow': + kres=pow(fpoly(ksym,'get',0).args[0],fpoly(ksym,'list')[0].args[1]*fpoly(ksym,'get',1)) + if kopt=='zubs': + kres=ksym.subs(op2,op3) + if kopt=='zubsV': + for i, j in zip(op2,op3): + kres=kres.subs(i,j) + + if kopt=='facmono': + klist=poly(ksym,'list') + mm=0 + for i in klist: + if op2 in fpoly(i,'free'): + mm=mm+i + kres=mm + if kopt=='in_allexp': + bres=True + klist=fpoly(ksym,'list') + for i in klist: + if op2 not in fpoly(i,'free'): + bres=False + kres=bres + + if kopt=='simp_fac': + newm=0 + oldm=0 + klist=fpoly(ksym,'list') + kvvar=fpoly(ksym,'free') + kvar=fpoly(op2,'free') + kvar=kvar[0] + for i in klist: + kres1=fpoly(i/op2,'free') + if kvar not in kres1: + newm=newm+i/op2 + else: + oldm=oldm+i + if op3==1: + kres=(newm) + elif op3==2: + kres=(oldm) + elif op3==0: + kres=(op2*newm) + else: + kres=op2*(newm)+oldm + + if kopt=='simp_facs': + + kres=ksym + skres=0 + veck=op2 + for op2 in veck: + + klist=fpoly(kres,'list') + km1=0 + km2=0 + for i in klist: + try: + mm= fpoly(i,'list') + if len(mm)>0: + if op2 in mm: + #print(mm) + km1=km1+i/op2 + km2=km2+i + except: + done=False + kres=kres-km2 + skres=skres+op2*km1 + skres=skres+(kres) + kres=skres + + if kopt=='list_tree': + mm=[] + kres=mm + for i in fpoly(ksym,'list'): + mm.append(short_type_name(i)) #mm.append(short_type_name(i)) + kres=mm + + if kopt=='get_type': + kres=short_type_name(ksym) + + + if kopt=='forze_subs': + + kexp=parse_expr(str(ksym)) + ksym=parse_expr(str(op2)) + kval=parse_expr(str(op3)) + kres=kexp.subs(ksym,kval) + + if kopt=='if_have': + + klist=fpoly(ksym,'list') + ksym=unisymbols(op2) + kres=0 + for i in klist: + vsym=fpoly(i,'free') + if unisymbols(ksym) in vsym: + kres+=i + if kopt=='simplypol': + klist=fpoly(ksym,'list') + kres=0 + for i in klist: + kres+=opemat(i,kope=op2) + + + return(kres) + +# # factorizar Polinomios lineales +def getargs(kres,*args): + if kres=='': + helplib('getargs') + return + return get_args(kres=kres,*args) + +def get_args(kres,*args): + + for i in args: + kres=kres.args[i] + return kres +def get_factor_with(eqq,kx,kcomple=True): + mm=fpoly(eqq,'list') # gcf(2*x*x+3*L*x+2*x+4,x) return (3*L+2) + kres=0 + for i in mm: + try : + newm=fpoly(i,'list') + if kx in newm: + if kcomple: + kres+=i/kx + else: + kres+=i + except: + pass + return kres + +def get_rest(eqq,kx): + mm=fpoly(eqq,'list') # gcf(2*x*x+3*L*x+2*x+4,x) return (3*L+2) + kres=0 + for i in mm: + try : + vhay=fpoly(i,'free') + if kx not in vhay: + kres+=i + except: + pass + return kres +def numerexpand(expr): + p1,p2=fraction(expr) + p1=expand(p1) + return cfrac(p1,p2) +def numerfactor(expr): + p1,p2=fraction(expr) + p1=factor(p1) + return cfrac(p1,p2) +def numersimplify(expr): + p1,p2=fraction(expr) + p1=simplify(p1) + return cfrac(p1,p2) +def denoexpand(expr): + p1,p2=fraction(expr) + p2=expand(p2) + return cfrac(p1,p2) +def denofactor(expr): + p1,p2=fraction(expr) + p2=factor(p2) + return cfrac(p1,p2) +def denosimplify(expr): + p1,p2=fraction(expr) + p2=simplify(p2) + return cfrac(p1,p2) + + +def factorize(expr,fexpr): + return factors(expr,fexpr) + +def factors(expr,kfac): + if Is_Add(expr): + p1=0 + p2=0 + for i in expr.args: + kres=simplify(i/kfac) + if denom(kres)==1: + p2=p2+simplify(i/kfac) + else: + p1=p1+i + if type(p2)==Add: + return p1+Mul(kfac,p2,evaluate=False) + else: + return expr + elif Is_Mul(expr): + if not Is_Poly(expr): + kres=1 + for i in expr.args: + if '+' in str(i) or '-' in str(i): + kres=kres*factors(i,kfac) + return kres + else: + return expr + elif Is_Div(expr): + p1,p2=fraction(expr) + return factors(p1,kfac)/factors(p2,kfac) + elif Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb=factors(bb,kfac) + return bb**ee + elif Is_Root(expr): + bb=getbase(expr) + ee=getroot(expr) + bb=factors(bb,kfac) + return rpow(bb,ee) + else: + return expr +def factoriza(expr,fexpr): + if Is_Add(expr): + return factorize(expr,fexpr) + elif Is_Div(expr): + knum,kden=fraction(expr) + p1=factorize(knum,fexpr) + p2=factorize(kden,fexpr) + return p1/p2 + elif Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb2=factorize(bb,fexpr) + return bb2**ee + elif Is_Mul(expr): + if '+' in str(expr): + kres=1 + for i in expr.args: + kres=kres*factorize(i,fexpr) + return kres + else: + return expr + else: + return expr +def dfactor(expr,var,var1,op=''): + ''' + input diff expr( dx/dt then var=t, var1=x + op= like factorize + dD2=diff(x,t,t) + dD1=diff(x,t) + dD=x(t) + + ''' + Da2,Da1,Da=simplediff(var,var1) + sexpr=str(expr) + sD2=str(Da2) + sD1=str(Da1) + sD=str(Da) + sexp=str(expr) + sexp=sexp.replace(sD2,'dD2') + sexp=sexp.replace(sD1,'dD1') + sexp=sexp.replace(sD,'dD') + dD2,dD1,dD=symbols('dD2 dD1 dD') + exp2=parse_expr(sexp) + if op!='': + mode=parse_expr(op) + exp2=factorize(exp2,mode) + else: + exp2=factor(exp2) + + exp2=exp2.subs(dD2,Da2) + exp2=exp2.subs(dD1,Da1) + exp2=exp2.subs(dD,Da) + return(exp2) + +def dsimplify(expr,var,var1): + ''' + input diff expr( dx/dt then var=t, var1=x + op= like factorize + dD2=diff(x,t,t) + dD1=diff(x,t) + dD=x(t) + + ''' + Da2,Da1,Da=simplediff(var,var1) + sexpr=str(expr) + sD2=str(Da2) + sD1=str(Da1) + sD=str(Da) + sexp=str(expr) + sexp=sexp.replace(sD2,'dD2') + sexp=sexp.replace(sD1,'dD1') + sexp=sexp.replace(sD,'dD') + dD2,dD1,dD=symbols('dD2 dD1 dD') + exp2=parse_expr(sexp) + + + exp2=simplify(exp2) + + + exp2=exp2.subs(dD2,Da2) + exp2=exp2.subs(dD1,Da1) + exp2=exp2.subs(dD,D) + return(exp2) +def factorSec(kEq,ksym,kfiltro='.'): + if type(ksym)==list: + return MgrupFac(kEq=kEq,ksym=ksym,kfiltro=kfiltro) + else: + return grupFac(kEq=kEq,ksym=ksym,kfiltro=kfiltro) + +def grupFac(kEq,ksym,kfiltro='.'): + return My_factor(kEq=kEq,ksym=ksym,kfiltro=kfiltro) + + +def part(expr,address): + r""" + Returns part of an expression + + Arguments + --------- + expr : sympy expression + address : (list of integers) indexes of the part + of the expression tree to be recovered + Returns + ------- + requested part of the expression tree + """ + for num in address: + expr = expr.args[num] + return expr + +def inpart(expr,repl,address): + r""" + Replaces a part of the tree of an expression (and returns + the copy) + + Arguments + --------- + expr: (sympy expression) expression to be intervened + repl: (sympy expression) modified part of the expression + address: (list of integers) indexes of the part of the + expression tree to be replaced (see 'part()') + Returns + ------- + new expression with the replacement done + """ + if len(address) == 1: + largs = list(expr.args) + largs[address[0]] = repl + return expr.func(*largs) + else: + largs = list(expr.args) + largs[address[0]] = inpart(expr.args[address[0]],repl,address[1:]) + new = expr.func(*largs) + return new + +def cpart(expr,address): + r""" + makes easier to visualize walking the tree. It returns a set of two expressions: + the original expression with the part located by 'address' substituted + by the symbol 'PIECE' and the part requested. + """ + PART = Symbol(r'{\color{red}{PART}}') + return Set(inpart(expr,PART,address),part(expr,address)) + +def kreturn(ksym): + unisymbols(ksym) + + +##################### +# Differential +##################### + + +# Fix sympy functions to not have problem whit difernet value to same symbols +def kdiff(ksym,kvar,kope=''): # Force differential + + ksym=unisymbols(ksym) + kvar=unisymbols(kvar) + kres=diff(ksym,kvar) + kres=opemat(kres,kope) + return kres + +def kintegrate(ksym,kvar,kope=''): # force integration + ksym=unisymbols(ksym) + kvar=unisymbols(kvar) + + kres=integrate(ksym,kvar) + kres=opemat(kres,kope) + return kres + + +##################### +# Substitution +##################### + + +def ksubs (ksym,kval,nkval,kope=''): + ksym=unisymbols(ksym) + kval=unisymbols(kval) + nkval=unisymbols(nkval) + kres=ksym.subs(kval,nkval) + kres=opemat(kres,kope) + return kres + +def psimplify(ksym,op1='',op2='',kope=''): + ksym=unisymbols(ksym) + kres=operacion(ksym,op1=op1,op2=op2,kope=kope) + return kres + + + +##################### +# Verifica (Is) +##################### +def typedata(ksym): # typedata((x*x*5)/8) return + kres=' ' + if Is_Symbol(ksym): + kres+='Symbol, ' + if Is_Number(ksym): + kres+='Number, ' + if Is_Add(ksym): + kres+='Add, ' + if Is_Mul(ksym): + kres+='Mul, ' + if Is_Pow(ksym): + kres+='Pow, ' + if Is_Div(ksym): + kres+='Div, ' + if Is_Mono(ksym): + kres+='Mono, ' + if Is_Poly(ksym): + kres+='Poly, ' + if Is_Pow2(ksym): + kres+='Pow2, ' + if Is_Root(ksym): + kres+='Root, ' + if Is_Real(ksym): + kres+='Real, ' + if Is_Integer(ksym): + kres+='Integer, ' + if Is_Even(ksym): + kres+='Even, ' + sE([kres]) + + +def allType(ksym,kop='list'): + if kop=='list': + sE([ksym]) + sE(['Is Polynomie = ',Is_Poly(ksym)]); + sE(['Is Symbols= ',Is_Symbol(ksym)]); + sE(['Is Number= ',Is_Number(ksym)]); + sE(['Is Real= ',Is_Real(ksym)]); + sE(['Is Integer= ',Is_Integer(ksym)]); + sE(['Is Even= ',Is_Even(ksym)]); + sE(['Is Odd= ',Is_Odd(ksym)]); + sE(['Is Monomie= ',Is_Mono(ksym)]); + sE(['Is Add= ',Is_Add(ksym)]); + sE(['Is Mul= ',Is_Mul(ksym)]); + sE(['Is Pow=',Is_Pow(ksym)]); + sE(['Is Pow2= ',Is_Pow2(ksym)]); + sE(['Is Root= ',Is_Root(ksym)]) + else: + sE([ksym]) + sE(['Is Polynomie = ',Is_Poly(ksym),' Is Symbols= ',Is_Symbol(ksym),' Is Number= ',Is_Number(ksym)]); + sE(['Is Real= ',Is_Real(ksym),' Is Integer= ',Is_Integer(ksym),' Is Even= ',Is_Even(ksym),' Is Odd= ',Is_Odd(ksym)]); + sE(['Is Monomie= ',Is_Mono(ksym),' Is Add= ',Is_Add(ksym),' Is Mul= ',Is_Mul(ksym)]); + sE(['Is Pow=',Is_Pow(ksym),' Is Pow2= ',Is_Pow2(ksym),' Is Root= ',Is_Root(ksym)]) + sE(['---------------------------------------------------------']) + +def Is_Poly(ksym): + done=True + if Is_Mono(ksym): + done=False + + return done + +def Is_Symbol(ksym): + done=False + if type(ksym)==Symbol: + done=True + if Is_Mono(ksym): + vmm=fpoly(ksym,'free') + for i in vmm: + if type(i)==Symbol: + done=True + + return done + +def Is_notSymbol(ksym): + if Is_Symbol(ksym): + return False + return True + +def Is_Number(ksym): + try: + if ksym.is_number: + return True + else: + return False + except: + return False +def Is_Real(ksym): + return TrFa(sympify(ksym).is_real) + +def Is_Integer(ksym): + return TrFa(sympify(ksym).is_integer) + +def Is_Even(ksym): + return (sympify(ksym).is_even ) + +def Is_Odd(ksym): + return (sympify(ksym).is_odd ) + +def TrFa(kval): # is True False + if kval==True or kval==False: + return(kval) + else: + return False + +def Is_Mono(ksym): + ksym=expand(ksym) + if type(ksym)==Mul or type(ksym)==Pow or type(ksym)==Symbol: + return True + try: + kn=len(fpoly(ksym,'list0')) + if kn==1: + return True + else: + return False + except: + return False + +def Is_Add(ksym): + kres=ksym + if type(kres)==Add: + return True + else: + return False + +def Is_Mul(ksym): + kres=ksym + if type(kres)==Mul: + return True + else: + return False + +def Is_NMul(ksym): + kres=ksym + if Is_Mul(kres): + if ksym.args[0]==-1: + return True + return False + +def Is_PowPow(expr): + if Is_Pow(expr): + base=getbase(expr) + if Is_Pow(base): + return True + return False + +def Is_MulPow(expr): + if Is_Mul(expr): + if 'Pow' in srepr(denom(expr)): + return True + if 'Pow' in srepr(numer(expr)): + return True + return False + +def Is_NPow(ksym): + if type(ksym)==Mul: + if ksym.args[0]==-1: + if Is_Pow(ksym.args[1]): + return True + return False + +def Is_Pow(ksym): + kres=ksym + + + if type(kres)==Mul: + if kres.args[0]==-1: + if Is_Pow(kres.args[1]): + return True + + elif type(kres)==Pow : + return True + else: + return False + +def Is_Pow2(ksym): + try: + mm=fpoly(ksym,'list') + p1=mm[0] + p2=mm[1] + except: + return False + + if type(ksym)==Pow and p2==2: + return True + else: + return False +def Is_NumberPow(expr): + done=False + if Is_Pow(expr): + bb=getbase(expr) + if Is_Number(bb): + done=True + return done + +def Is_Log(ksym): + if type(ksym)==log: + return True + else: + return False + +def Is_Root(ksym): + kres=False + try: + if Is_Pow(ksym): + p1,p2=ksym.args + if Is_Div(p2): + kres=True + return True + except: + return False + return False + + +def Is_MonoMul(ksym): + if type(ksym)==type(expand(ksym)): + return True + else: + return False + +def Is_NMono(expr): + if not Is_Add(expr): + try: + mm=expr.args + if Is_Number(mm[0]) and signo(mm[0])==-1: + return True + except: + return False + return False + +def Is_MonoPoly(ksym): + return not Is_MonoMul(ksym) + +def Is_Integral(ksym): + mm=str(ksym.args) + if (mm[-3::])==',))': + return True + else: + return False + +def Is_Div(ksym): + pi,p2=fraction(ksym) + if p2!=1: + return True + else: + return False + +def Is_Inversa(expr): + if Is_Div(expr): + p1,p2=fraction(expr) + if p1==1 or p1==-1: + return True + return False +def Is_Inverse(expr): + if Is_Div(expr): + p1,p2=fraction(expr) + if p1==1 or p1==-1: + return True + return False + +####################################### +### Fix Trigomo,etrisc subs functions + +def fixremptrig(ksym,alpha,kkval): + valsin=sin(kkval) + valcos=cos(kkval) + msym=[kpow(sin(alpha),x) for x in range(4)] + vsym=[kpow(valsin,x) for x in range(4)] + kres=ksym + for i,j in zip(msym,vsym): + kres=kres.subs(i,j) + msym=[kpow(cos(alpha),x) for x in range(4)] + vsym=[kpow(valcos,x) for x in range(4)] + for i,j in zip(msym,vsym): + kres=kres.subs(i,j) + return kres + valsin=opemat(sin(alpha1),'v') + msym=[kpow(sin(alpha1),x) for x in range(4)] + vsym=[opemat(kpow(valsin,x),'v') for x in range(4)] + +def simplifac(p1,p2): + p1=factor(p1) + p2=factor(p2) + try: + if (Is_Mul(p1) and Is_Symbol(p2)) or (Is_Mul(p2) and Is_Symbol(p2)) or (Is_Mul(p2) and Is_Mul(p2)): + mm1=fpoly(p1,'list') + mm2=fpoly(p2,'list') + P1=p1 + P2=p2 + TF1=False + TF2=False + Nu1=0 + Nu2=0 + for i in mm1: + if Is_Number(i): + TF1=True + Nu1=i + for i in mm2: + if Is_Number(i): + TF2=True + Nu2=i + if TF1 and TF2: + Nu3=min(Nu1,Nu2) + p1=p1/Nu3 + p2=p2/Nu3 + P1=p1 + P2=p2 + mm1=fpoly(P2,'free') + mm2=fpoly(P1,'free') + for i in mm1: + if i in mm2: + grade1=degree(P1,gen=i) + grade2=degree(P2,gen=i) + + grade3=min(grade1,grade2) + nfac=i**grade3 + p1=p1/nfac + p2=p2/nfac + return p1,p2 + else: + return p1,p2 + except: + return p1,p2 +def simpliadd(p1,p2): + P1=p1 + P2=p2 + + if Is_Add(p1) or Is_Add(p2): + mm1=fpoly(p1,'list') + mm2=fpoly(p2,'list') + mm3=fpoly(p1,'list') + + + for i in mm3: + if i in mm1: + p1=p1-i + p2=p2-i + + + return p2,p1 +def simplifyr(ksym): + kres=ksym + kres=simplify(kres*kres) + kres=rpow(kres,2) + return kres + + + + + +def lexp_simplify(ksym): + sksym=str(ksym) + if 'log(exp(' in sksym: + kint=insidepar(insidepar(kk,'log(exp('),'exp(') + skint=str(kint) + tkill='log(exp('+skint+'))' + sksym=sksym.replace(tkill,skint) + return parse_expr(sksym) + else: + return ksym + + + + +def fix_sqrt2pow(ksym): + try: + kres=ksym + mm=str(ksym) + mm1= mm.replace('**2','**1') + mm2=mm1.replace('sqrt(','(') + mm3=parse_expr(mm2) + return mm3 + except: + return ksym + + +def tintegral_def(keq,alpha,a1,a2,kope=''): + kfun=kintegrate(keq,alpha) + val1=fixremptrig(kfun,alpha,a1) + val2=fixremptrig(kfun,alpha,a2) + kres=val2-val1 + kres=opemat(kres,kope=kope) + return kres + + +def change_diff(ksym,y,x,newQ=''): # ksym =Integral func, y old v,x =mew v, new Func + if Is_Integral(ksym): + + Isol=ksym.doit() + if newQ!='': + Isol=Isol.subs(y,newQ) + else: + Isol.subs(y,x) + return Integral(Isol,x) + else: + return ksym + +def cut_fac(ksym,kval): + if type(ksym)==Mul: + return(simplify(unisymbols(ksym/kval))) + elif type(ksym)==Add: + mlist=fpoly(ksym,'list') + mm=0 + for i in mlist: + mm+=cut_fac(i,kval) + return mm + +def cut_root2(ksym,kval): + kk2='sqrt('+str(kval)+'**2)' + if ksym!=0: + try: + if type(ksym)==Mul: + kk= str(ksym) + + kk3=kk.replace(kk2,str(kval)) + ksol=parse_expr(kk3) + return ksol + if type(ksym)==Add: + nksym=0 + mm=fpoly(ksym,'list') + for i in mm: + nksym+=cut_root2(i,kval) + + return nksym + except: + return ksym + else: + return ksym + + + + +class MyTriang: + def __init__(self, hipo='',cat1='',cat2='',kope=''): + + self.khipo=hipo + self.kcat1=cat1 + self.kcat2=cat2 + + if hipo=='': + kres=get_hipo(cat1,cat2) + self.khipo=opemat(kres,kope=kope) + if cat2=='': + kres=get_cateto(hipo,cat1) + self.kcat2=opemat(kres,kope=kope) + if cat1=='': + kres=get_cateto(hipo,cat2) + self.kcat1=opemat(kres,kope=kope) + + def sin(self,kope=''): + hipo=self.khipo + cat1=self.kcat1 + kres=cat1/hipo + kres=opemat(kres,kope=kope) + + return kres + + def cos(self,kope=''): + hipo=self.khipo + cat2=self.kcat2 + kres=cat2/hipo + kres=opemat(kres,kope=kope) + + return kres + + def tan(self,kope=''): + cat1=self.kcat1 + cat2=self.kcat2 + kres=cat1/cat2 + kres=opemat(kres,kope=kope) + + return kres + + def hipo(self,kope=''): + kres=self.khipo + + return kres + + def cat1(self,kope=''): + kres=self.kcat1 + + return kres + + def cat2(self,kope=''): + kres=self.kcat2 + + return kres + + def s(self): + sE(['sin()=',self.sin(),' cos()=',self.cos(),'tan()=',self.tan()]) + + +def sqrt2fracpow(expr): + return(signed_sqrt(expr)) + +def signed_sqrt(expr): # This function from WenyinWei founded in GitHub + """Signed sqrt operator + Args: + expr (sympy.expr): sympy expression + Returns: + sympy.expr: A simplified expression + """ + + + expr = expr.factor() + # recurse the function on each arg if the top function is a multiplication + # e.g. signed_sqrt( 4 * b^2 ) == 2 * b + if expr.func == Mul: + args_signed_sqrt = [signed_sqrt(arg) for arg in expr.args] + return reduce(Mul, args_signed_sqrt) + elif expr.func == Pow: + base, exponent = expr.args + if exponent.is_even: + return base**(exponent/2) + return sqrt(expr) + + +def fixrootpow(expr,k=''): + if k=='': + expr=fixrootpow(expr,2) + expr=fixrootpow(expr,3) + return expr + else: + sres=str(expr) + snum=str(k) + srot='**'+snum+')**(1/'+snum+')' + if srot in sres: + sres=sres.replace(srot,')') + nexpr=parse_expr(sres) + return nexpr + else: + return expr + +def KrP(ksym,kope=''): + return kill_root_mono(ksym,kope=kope) + +def kill_root_mono(ksym,kope=''): # kill root(pow(ksym)) if Is_Mono(ksym) = True + + if Is_Root(ksym): + kres= signed_sqrt(ksym*ksym) + else: + kres= ksym + + return kres + +def kill_root_poly(ksym,kope=''): # kill root(pow(ksym1)) + root(pow(ksym1)) if Is_Poly(ksym) = True + if Is_Poly(ksym): # ksym=ksym1+ksym2+ .... + mm=0 + vksym=fpoly(ksym,'list') + for i in vksym: + mm+=kill_root_poly(i,kope='') + mm=opemat(mm,kope=kope) + return mm + elif Is_Mul(ksym): # ksym=ksym1+ksym2+ .... + kt=1 + vksym=fpoly(ksym,'list') + for i in vksym: + kt*=kill_root_poly(i) + + return kt + else: + kres=kill_root_mono(ksym,kope='') + return kres + + +def sin2cos(ksym,angu,korden=2,kope=''): + e1=unisymbols(ksym) + e1=e1.subs(unisymbols(kpow(sin(angu),4)),(unisymbols(kpow(sin(angu),2)*kpow(sin(angu),2)))) + e1=e1.subs(unisymbols(kpow(sin(angu),3)),(unisymbols(kpow(sin(angu),2)*sin(angu)))) + e1=e1.subs(unisymbols(kpow(sin(angu),2)),(unisymbols(1-kpow(cos(angu),2)))) + if korden==1: + e1=e1.subs(unisymbols(sin(angu)),(unisymbolsrpow(1-kpow(cos(angu),2))) ) + + kres=e1 + kres=opemat(kres,kope=kope) + return kres + +def cos2sin(ksym,angu,korden=2,kope=''): + e1=unisymbols(ksym) + e1=e1.subs(unisymbols(kpow(cos(angu),4)),unisymbols((kpow(cos(angu),2)*kpow(cos(angu),2)))) + e1=e1.subs(unisymbols(kpow(cos(angu),3)),unisymbols((kpow(cos(angu),2)*cos(angu)))) + e1=e1.subs(unisymbols(kpow(cos(angu),2)),unisymbols((1-kpow(sin(angu),2)))) + if korden==1: + e1=e1.sub(unisymbols(cos(angu)),unisymbols(rpow(1-kpow(sin(angu),2)))) + + kres=e1 + kres=opemat(kres,kope=kope) + return kres + +def MaT(x,y=''): + if y=='': + y=x[1] + x=x[0] + return(Matrix([[x,y]])) + +def moduloMat(kMat): + xx1=kMat[0] + yy1=kMat[1] + + return get_hipo(xx1,yy1) + + +# algebra +def sortPoly(ksym,kvar,kindi): + kres=ksym + for i in range(kindi): + kres=factorSec(kres,kpow(kvar,i+1)) + + return kres + + + # Diccionario +def unpack(mm): + return kunpakDic(mm=mm) + +def kunpakDic(mm): + + kkey=list(mm.keys()) + kvalu=list(mm.values()) + + return( kkey,kvalu) + +####################### +## used by MyEq +####################### + +def multiSet(ksym, kval, vecEq=[]): + if type(ksym) == list: + for i, j in zip(ksym, kval): + for kQ in vecEq: + kQ.setValue(i, j, kshow=False) + else: + for kQ in vecEq: + kQ.setValue(ksym, kval, kshow=False) + + for i in vecEq: + i.s() + +def multiRedFac(kvec=[]): + for i in kvec: + i.reduFac() + i.s() + +# convinaciones de soluciones +def solveFrom(eeV,ssV,kope=''): + vec1=[x() for x in eeV] + kres= solve(vec1,ssV) + kres1=[opemat(x,kope=kope) for x in kres] + kres2=kres1[0] + mainres=[] + for i ,j in zip(kres2,ssV): + mainres.append(i) + ee=MyEq(i,j.name,kshow=False,kope=kope) + ee.s() + return mainres +#def solve2sysEq(kvar=[], keq=[], kname=[]): + +def killPwise(sksym): # Kill otherwise answer in simple str + kres=sksym + if 'Piecewise' in kres: + x1=sksym.find('Piecewise(') + x2=x1+len('Piecewise(') + x3=sksym.find(', Ne(') + x4=sksym.find('True)') + x5=x4+len('True)') + kres=sksym[0:x1]+sksym[x2:x3]+sksym[x5::] + return kres + +def fix_otherwise(ksym,kop=''): # Kill otherwise answer in answer + kres2=ksym + if kop=='odb': + ksym=ksym.rhs + + mm=fpoly(ksym,'list') + kres='' + done=True + kk='+' + for i in mm: + ss=str(i) + if done: + kres+=killPwise(ss) + done=False + else: + kres+='+'+killPwise(ss) + try: + return unisymbols(parse_expr (kres)) + except: + return kres2 + + +####################### +## used by MyInteger +####################### + + +def Ope2Inte(e1,e2,kope='Add'): + ope1=e1.kinte + ope2=e2.kinte + if kope=='Mul': + return ope1*ope2 + elif kope=='Div': + return ope1/ope2 + + else: + return ope1+ope2 + +def opeInteSolu(val1,val2,kope='Add'): + if kope=='Mul': + return val1*val2 + elif kope=='Div': + return val1/val2 + + else: + return val1+val2 + +def miniopI(val1,val2,ktype='Add'): + if ktype=='Mul': + return val1.kinte*val2.kinte + elif ktype=='Div': + return val1.kinte/val2.kinte + else: + return val1.kinte+val2.kinte + + + +############## LAtex +def lxprint(*args): + vec='' + for i in args: + if type(i)==str: + vec+= i+'\;' + else: + vec+= latex(i)+'\;' + display(Math(vec)) + +def symb_diff(*args): + kres='' + for i in args: + kres=kres+' d'+alphaname(i) + return kres + +def diff_name(ksym): + kres='d_'+ alphaname(ksym) + return kres + +def diff_name_prima(ksym): + kres=alphaname(ksym)+"'" + return kres + +def diffname(k1,k2): + if type(k1)!=str: + k1=k1.name + k1=alphaname(primitivename(k1)) + k2=alphaname(primitivename(k2)) + xx='d_'+k1 + tt='d_'+k2 + xkname='\\frac{'+xx+'}{'+tt+'}' + return xkname + +def difffuncname(kfunc,ksym): + kres='d'+alphaname(kfunc)+'('+alphaname(ksym)+')' + return kres + +def funcname(kfunc,ksym): + kres=alphaname(kfunc)+'('+alphaname(ksym)+')' + return kres + +# def diffname(ksym): + # kres='d'+ alphaname(ksym) + # return kres +def clean_underline(ksym): + sres=str(ksym) + sres=sres.replace('_','') + return sres + +def alphasubname(ksym,op=1): + aaname=alphaname(ksym) + aaname=aaname+'_'+str(op) + return aaname + + + +def eQrec(x1=0,y1=0,x2=0,y2=0,var2=''): + mm=frs((y2-y1),(x2-x1)) + bb=y2-x2*mm + kres=opemat(var2*mm+bb,'s') + return kres + +def diffvariable(k1,k2): + return get_diff_name(k1,k2) + +def get_diff_name(k1,k2): + k1=alphaname(k1) + k2=alphaname(k2) + xx='d_'+k1 + tt='d_'+k2 + xt='\\frac{'+xx+'}{'+tt+'}' + dxt=symbols(xt) + return dxt + +def difvar(*args): #crea variables dieferenciables + + mm=[] + for i in args: + sres='d'+diffsymbol(i) + mm.append(symbols(sres)) + return mm + + + +def Cg2func(f1,f2,x,x1,x2): + Area=integrate(f1,(x,x1,x2))-integrate(f2,(x,x1,x2)) + X=integrate((f1-f2)*x,(x,x1,x2)) + X=X/Area + + Y=integrate((f1-f2)*(f1+f2)/2,(x,x1,x2)) + Y=Y/Area + return X,Y + +def findSubFunc(ksym,sval,inside=''): + + kini=0 + kini2=0 + sroot=[] + done=0 + while kini","","","",""] +def arglist(expr,deep=3): + + infoexpr=[] + infopos=[] + cc='' + A,B,C,D=ruta(expr,infoexpr,infopos,cc) + BC=[[i,j] for i,j in zip(B,C) if not Is_NMono(i)] + B1,C1=[],[] + for i in BC: + B1.append(i[0]) + C1.append(i[1]) + BC2=[[i,j] for i,j in zip(B1,C1) if len(j)0: + for i in range(len(mm)): + nexp=mm[i] + npos=cc+str(i) + + if nexp not in infoexpr: + if str(type(nexp)) not in vecreatr : + if nexp not in infoexpr: + if not Is_Number(nexp): + + infoexpr.append(nexp) + infopos.append(npos) + try: + nexp,ninfo,ncc=ruta(nexp,infoexpr,infopos,npos) + return nexp,ninfo,ncc + except: + pass + return expr,infoexpr,infopos,cc + else: + return expr,infoexpr,infopos,cc + +def dothis(*args): + if 'numer' in args or 'denom' in args: + args2=args + expr=args[0] + + done=None + for i in args: + if i=='numer': + done='numer' + if i=='denom': + done='denom' + if Is_Div(args[0]) and done!=None: + p1,p2=fraction(expr) + args2=[i for i in args if i!='numer'] + args3=[i for i in args2 if i!='denom'] + if done=='numer': + args3[0]=p1 + kres=dothis(*args3) + kres=unisymbols(Div(kres,p2)) + else: + args3[0]=p2 + kres= dothis(*args3) + kres=unisymbols(Div(p1,kres)) + + return kres + else: + + expr=args[0] + func=args[1] + if len(args)==2: + try: + sexpr=func+'('+str(expr)+')' + kres=eval(sexpr) + return unisymbols(kres) + except: + + return expr + + if len(args)==3: + try : + expr2=args[2] + sexpr=func+'('+str(expr)+','+str(expr2)+')' + return unisymbols(eval(sexpr)) + except: + + return expr + + +def helplib(kimg=''): + if kimg=='': + return get_filesh() + else: + try: + kfile=kimg+'.png' + camino='imghelp/'+kfile + baseA = np.asarray(Image.open(camino)) + plt.imshow(baseA) + plt.axis('off') + plt.gcf().set_facecolor("black") + plt.rcParams['figure.dpi'] = 800 + plt.show() + except: + print( "don't find function, please type helplib() for more options") + +import os + +def helplib(kimg=''): + + if kimg=='': + return get_filesh() + else: + try: + kfile=kimg+'.png' + camino='/imghelp/'+kfile + + baseA = np.asarray(Image.open(camino)) + plt.imshow(baseA) + plt.axis('off') + plt.gcf().set_facecolor("black") + plt.rcParams['figure.dpi'] = 800 + plt.show() + except: + print( "don't find function, please type helplib() for more options") + + +# CONJUNTOS +def UnionL(A,B): + C=[x for x in A if x not in B] + return C+B +def SubstracL(A,B): + C=[x for x in A if x not in B] + return C +def IntersecL(A,B): + C=[x for x in A if x in B] + return C + +def maxint(sexpr): + sval='ǁ'+sexpr+'ǁ' + return symbols(sval) + +def supersubs(expr,v1,v2): + done_exp=False + sexpr=str(expr) + if 'exp' in sexpr: + done_exp=True + sexpr=sexpr.replace('exp','M') + sv1=str(v1) + sv2='('+str(v2)+')' + sexpr=sexpr.replace(sv1,sv2) + if done_exp: + sexpr=sexpr.replace('M','exp') + return parse_expr(sexpr) + +def trinom2binom(expr,sexpr): + fexpr=factor(sexpr) + expr=expr.subs(sexpr,AA) + expr=expr.subs(AA,fexpr) + return expr \ No newline at end of file diff --git a/Libaldo/mathbasic.py b/Libaldo/mathbasic.py new file mode 100644 index 0000000..9f21803 --- /dev/null +++ b/Libaldo/mathbasic.py @@ -0,0 +1,765 @@ + + +from libaldo_math2 import * +from libaldo_algorith import * +from mathexponencial import * +from mathexponencial import getbase,getexpo +from sympy import * +## PARTIAL FRACTION... + +x,s,t,y=symbols('x s t y') +# ussefull variables to use in partial fracction algorith +y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10 y11 y12 y13 y14 y15 y16') +fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] +def getbase(expr): # return base in expr + ''' + expr = x**y,x*y + return x ,x*y + ''' + + if Is_Pow(expr): + ee=expr.args[0] + return ee + else: + return expr + +def getexpo(expr,op=''): # return exponente in expr + if Is_Pow(expr): + mm=expr.args + return mm[1] + + else: + return 1 +def str2mathstr(sexpr): + ''' + input str math expr + return str math expr + this f fix space between + and - symbols + example: + str2mathstr('x**2+z*(x+1)') + return 'x**2 + z*(x + 1)' + ''' + + + qq=len(sexpr) + sres='' + + for i in range(qq): + sval=sexpr[i] + if i==0: + sres=sres+sval + elif sval=='+' or sval=='-': + if sexpr[i-1] != ' ': + sres=sres+' ' + sres=sres+sval + if idg2: + # vec1=coef_list(p1,var2=var) + # vec2=coef_list(P4,size=dg1,var2=var) + # else: + # vec1=coef_list(p1,var2=var) + # vec2=coef_list(P4,var2=var) + + # vec3=[vec2[i]-vec1[i] for i in range(len(vec2))] + # kres=solve(vec3) + # svar,vval=ganswer(kres,'varname','value') + # for i,j in zip(svar,vval): + # P=P.subs(i,j) + # return P + +# getinsidepar + +def vecfind(sexp,sval): + sexp=str(sexp) + mv=[] + qq=len(sexp) + if sexp[-1]==sval: + mv=[qq] + sexp=str(sexp) + mm=[] + done=True + while done: + p=sexp.find(sval) + if p==-1: + done=False + else: + mm.append(p) + sexp=sexp[p+1:-1] + mm=mm+mv + return mm + +def insidepar(expr,svar=''): + if svar=='': + sexpr=str(expr) + p1=sexpr.find('(') + vp2=vecfind(sexpr,')') + qq=len(vp2) + sres=sexpr[p1+1:vp2[qq-1]+1] + return parse_expr(sres) + else: + sexpr=str(expr) + pp=sexpr.find(svar) + sexpr2=sexpr[pp::] + if sexpr2[0]=='(': + sres= sexpr2 + else: + + p3=sexpr2.find('(') + sres=sexpr2[p3::] + + vec1=vecfind(sres,'(') + vec2=vecfind(sres,')') + mm=[] + for i in vec1: + mm.append([i,1]) + for i in vec2: + mm.append([i,-1]) + mm.sort() + qq=len(mm) + p1=0 + p2=mm[qq-1][0] + cc=1 + for i in range(1,qq): + cc=cc+mm[i][1] + if cc==0: + p2=mm[i][0] + break + kres=sres[p1:p2] + return parse_expr(kres) + +## Pprimefactor... + + +def factorp(expr): + kres='' + if Is_Add(expr): + done=True + for i in expr.args: + if done: + kres=factorp(i) + done=False + else: + kres=kres+'+'+factorp(i) + + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=factorp(p1) + P2=factorp(p2) + kres= '('+P1+')/('+P2+')' + elif Is_Mul(expr): + done=True + for i in expr.args: + if done: + kres=factorp(i) + done=False + else: + kres=kres+'*('+factorp(i)+')' + + elif Is_Root(expr): + bb=insideroot(expr) + rr=getroot(expr) + kres=factorp(bb) + kres='('+kres+')**('+str(frs(1,rr))+')' + + + elif Is_NumberPow(expr): + bb=getbase(expr) + ee=getexpo(expr) + vecbase,vecexp=factoresprimosvec(bb) + done=True + for i,j in zip(vecbase,vecexp): + newe=simplify(j*ee) + if done: + kres=str(i)+'**('+str(newe)+')' + done=False + else: + kres=kres+'*'+str(i)+'**('+str(newe)+')' + + elif Is_Number(expr): + mm=factorint(expr) + vecbase,vecexp=unpack(mm) + qq=len(vecbase) + done=True + for i,j in zip(vecbase,vecexp): + if j!=1: + if done: + sres=str(i)+'**'+str(j) + done=False + else: + sres=sres+'*'+str(i)+'**'+str(j) + else: + if done: + sres=str(i) + done=False + else: + sres=sres+'*'+str(i) + kres=sres + + + + else: + kres=str(expr) + return kres + +def factorp(expr): + mm=factorint(expr) + vecbase,vecexp=unpack(mm) + return vecbase,vecexp + + +def getfaclist(expr): + vecb=[] + vece=[] + mm=expr.args + + for i in mm: + try: + base,eee=unpack(factorint(i)) + for k,j in zip(base,eee): + vecb.append(k) + vece.append(j) + except: + vecb.append(i) + vece.append(1) + kres='' + done=True + + for i,j in zip(vecb,vece): + if j==1: + subres=str(i) + else: + subres=str(i)+'**'+str(j) + if done: + kres=subres + done=False + else: + kres=kres+'*'+subres + return sympify( kres,evaluate=False) + + +def primefactor(expr): + if Is_Add(expr): + + kres='' + done=True + for i in expr.args: + if done: + kres=str(primefactor(i)) + done=False + else: + kres=kres+"+"+str(primefactor(i)) + + elif Is_Div(expr): + + p1,p2=fraction(expr) + p1=str(primefactor(p1)) + p2=str(primefactor(p2)) + kres= p1+'/'+p2 + + elif Is_Mul(expr): + + + kres='' + done=True + mm=expr.args + for i in mm: + if done: + kres= str(primefactor(i)) + done=False + else: + kres= kres+'*'+str(primefactor(i)) + elif Is_Log(expr): + + mm=expr.args + expr2=mm[0] + kres=str(primefactor(expr2)) + kres= 'log('+kres+')' + + + + elif type(expr)==Rational: + + knume=numer(expr) + kdeno=denom(expr) + knum=primefactor(knume) + kden=primefactor(kdeno) + return cfrac(knume,kdeno) + + + elif type(expr)==int or type(expr)==Integer: + + if isprime(expr): + kres=str(expr) + else: + val=expr + vecn,vece=kunpakDic(factorint(val)) + newf='' + for i,j in zip(vecn,vece): + if j==1: + newf=str(i)+'*'+newf + else: + newf=str(i)+'**'+str(j)+'*'+newf + newf=newf[0:-1] + newf=str(newf) + kres=sympify(newf,evaluate=False) + + + + + elif type(expr)==Pow: + + base=getbase(expr) + ee=getexpo(expr) + if Is_Symbol(base) or isprime(base): + kres=str(expr) + + else: + if type(base)==Rational: + return (primefactor(base))**ee + + elif not isprime(base): + vec1,vec2=unpack(factorint(base)) + done=True + kres='' + for i,j in zip(vec1,vec2): + if done: + kres= str(i)+'**'+'('+str(j*ee)+')' + done=False + else: + kres=kres+'*'+str(i)+'**'+'('+str(j*ee)+')' + + else: + kres= getfaclist(expr) + elif Is_Root(expr): + + rr=getroot(expr) + B=insideroot(expr) + try: + kres=primefactor(B) + ee=getexpo(kres) + bb=getbase(kres) + return bb**cfrac(ee,rr) + except: + return expr + else: + + kres=expr + return (sympify(kres,evaluate=False)) + + + + + +def superfactor(expr,kdiv,*args): + ''' + superfactor(exp2factorize, factor expr, op) + op = + 'factor',factorize before doit + 'simplify' simplify ... + 'expand'.. + 'expo', applied suerfactor in exponenets + ''' + if 'factor' in args: + expr=factor(expr) + if 'expand' in args: + expr=expand(expr) + if 'simplify' in args: + expr=simplify(expr) + if Is_Pow(expr): + bb=superfactor(getbase(expr),kdiv) + ee=getexpo(expr) + if 'expo' in args: + ee=superfactor(expo,kdiv) + return ppow(bb,ee) + if Is_Div(expr): + p1,p2=fraction(expr) + return cfrac(superfactor(p1,kdiv),superfactor(p2,kdiv)) + + if Is_Add(expr): + P1=0 + P2=0 + + for i in fpoly(expr,'list'): + i=superfactor(i,kdiv) + kres=i/kdiv + p1,p2=fraction(kres) + if p2==1: + P1+=p1 + else: + P2+=i + return P2+P1*kdiv + elif '+' in str(expr) or '-' in str(expr): + kres=1 + for i in fpoly(expr,'list'): + if Is_Add(i): + kres=kres*superfactor(i,kdiv) + else: + kres=kres*i + return kres + else: + return expr + + + +# basic ope + + + +def Div(p1,p2): + kres= p1/p2 + try: + if int(kres)==kres: + return int(kres) + except: + return kres +# math whit list + +def SubstracList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1-a2,b1-b2,...] + ''' + + kres=[] + for i,j in zip(vec1,vec2): + kres.append(i-j) + return kres + +def AddList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1+a2,b1+b2,...] + ''' + kres=[] + for i,j in zip(vec1,vec2): + kres.append(i+j) + return kres + +def MulList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1*a2,b1*b2,...] + ''' + kres=[] + for i,j in zip(vec1,vec2): + kres.append(i*j) + return kres +def DivList(vec1,vec2): + ''' + vec1=[a1,b1,..] + vec2=[a2,b2,..] + return [a1/a2,b1/b2,...] + ''' + kres=[] + for i,j in zip(vec1,vec2): + kres.append(cfrac(i,j)) + return kres + + +def symbolslist(vec,var=''): + ''' + symbolslist(x+a+b+4)=[x,a,b] + symbolslist(x+a+b+4,x)=[a,b] + symbolslist([x+a+b+4,a,z])=[a,b,x,z] + symbolslist([x+a+b+4,a,z],x)=[a,b,xz] + + ''' + if type(vec)==list: + qq=len(vec) + kres=0 + cc=10 + for i in vec: + kres=expand(kres+i/cc) + cc=cc*10 + else: + kres=vec + + slist=kres.free_symbols + vecs=list(slist) + if var!='': + kres=[] + for i in vecs: + if i!=var: + kres.append(i) + else: + kres=slist + return kres + +# DEGREE LIST ALGORTHMICS + +def pre_vec2compare(vec1,vec2): + ''' + filter (0=2) in coefflist + + ''' + nv1=[] + nv2=[] + for i,j in zip(vec1,vec2): + if not Is_Number(i) or not Is_Number(j): + nv1.append(i) + nv2.append(j) + return nv1,nv2 + +def pre_coeff2list(expr1,expr2,var=x): + ''' + prepare 2 coefflist two not generate error + ''' + + d1=degree(expr1,var) + d2=degree(expr2,var) + d3=max(d1,d2) + vec1=coef_list(expr1,var,d3) + vec2=coef_list(expr2,var,d3) + vec1,vec2=pre_vec2compare(vec1,vec2) + return vec1,vec2 + + +# imaginary number +def module_img(expr): + p1=re(expr) + p2=im(expr) + return get_hipo(p1,p2) + +def imodule(expr): + p1=re(expr) + p2=im(expr) + return get_hipo(p1,p2) + +def powi(expr,ee): + return expand(expr**ee) + + +def rpart(expr): + if Is_Div(expr): + p1,p2=fraction + sres=str(expr) + sres=sres.replace('I','0') + kres=parse_expr(sres) + return kres + +def repart(expr): + sres=str(expr) + sres=sres.replace('I','0') + kres=parse_expr(sres) + return kres + + +def imgpart(expr): + p1=expr-repart(expr) + p2=str(p1) + p2=p2.replace('I','1') + p3=parse_expr(p2) + return p3 + +def ipart(expr): + p1=expr-repart(expr) + p2=str(p1) + p2=p2.replace('I','1') + p3=parse_expr(p2) + return p3 + +def simplify_img(expr): + if Is_Add(expr): + kres=(repart(expr))+imgpart(expr)*I + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=simplify_img(p1) + p2=simplify_img(p2) + return cfrac(p1,p2) + elif Is_Mul(expr): + return simplify(expr) + else: + return simplify(expr) + return kres + +def polar2img(*args): + ''' + polar2img(sqrt(2),pi/4) + return 1+i + ''' + p1=args[0] + p2=args[1] + angle=p2 + radio=p1 + if 'pi' in str(p1): + angle=p1 + radio=p2 + pre=radio*cos(angle) + pim=radio*sin(angle) + sres=str(pre)+'+'+str(pim)+'*I' + return parse_expr(sres) + +def img2polar(expr): + ''' + img2polar(1+I) + return sqrt(2),pi/4 + ''' + p1=re(expr) + p2=im(expr) + p3=module_img(expr) + alpha=atan(cfrac(p2/p1)) + alpha=simplify(alpha) + return p3,alpha + +def conjugada(z): + if Is_Pow(z): + bb=getbase(z) + ee=getexponent(z) + bb2=conjugada(bb) + ee2=conjugada(ee) + return bb**ee2 + else: + sz=str(z) + sz=sz.replace('I','-I') + return parse_expr(sz) + +def premath(expr,*args): + ''' + pre trasforms answer in simplesolve + ''' + if len(args)>0: + if 'factor' in args: + try: + expr=factor(expr) + except: + pass + if 'simplify' in args or 'simpli' in args: + try: + expr=simplify(expr) + except: + pass + if 'expand' in args: + try: + expr=expand(expr) + except: + pass + if 'reduce' in args: + try: + expr=reduce(expr) + except: + pass + + if 'unisymbols' in args or 'unisys' in args: + try: + expr=unisymbols(expr) + except: + pass + if 'mulexpo' in args: + try: + expr=mulexpo(expr) + except: + pass + if 'rsimplify' in args: + try: + expr=rsimplify(expr) + except: + pass + return expr + + +def doindenom(*args): + expr=args[0] + func=args[1] + p1,p2=fraction(expr) + if len(args)==3: + expr2=args[2] + p2=dothis(p2,func,expr2) + else: + p2=dothis(p2,func,expr2) + + return unisymbols(Div(p1,p2)) + + +def doinnumer(*args): + expr=args[0] + func=args[1] + p1,p2=fraction(expr) + if len(args)==3: + expr2=args[2] + p1=dothis(p1,func,expr2) + else: + p1=dothis(p1,func,expr2) + + return unisymbols(Div(p1,p2)) + diff --git a/Libaldo/mathexponencial.py b/Libaldo/mathexponencial.py new file mode 100644 index 0000000..205f334 --- /dev/null +++ b/Libaldo/mathexponencial.py @@ -0,0 +1,1104 @@ + + +from libaldo_math2 import * +from libaldo_algorith import * +from mathbasic import * +from sympy import * +## exponenciales functions... + +x,s,t,y=symbols('x s t y') +# ussefull variables to use in partial fracction algorith +y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16=symbols('y1 y2 y3 y4 y5 y6 y7 y8 y9 y10 y11 y12 y13 y14 y15 y16') +fabr=[y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12,y13,y14,y15,y16] + +### CORE +def sfunc2func(expr,kfunc): + ''' + args: + expr=math exprssion + kfunc= str,function name + return: + kfunc(expr) + ''' + sexpr=kfunc+'('+str(expr)+')' + expr2=eval(sexpr) + return expr2 + +def corefunc(expr,kfunc): + ''' + simplify loop of: + Is_Add + Is_Div + Is_Mul + ''' + + expr=unisymbols(expr) + if Is_Add(expr): + kres=0 + for i in expr.args: + kres=kres+sfunc2func(i,kfunc) + elif Is_Div(expr): + p1,p2=fraction(expr) + kres=Div(sfunc2func(p1,kfunc),sfunc2func(p2,kfunc)) + elif Is_Mul(expr): + kres=1 + for i in expr.args: + kres=kres*sfunc2func(i,kfunc) + else: + kres=expr + return kres + +### End Core + + +def getexpo(expr,op=''): # return exponente in expr + if Is_Pow(expr): + mm=expr.args + return mm[1] + + else: + return 1 + +def getpow(expr): # return exponente in expr + ''' + expr = x**y, x*y + return y ,1 + ''' + if Is_Root(expr): + kres=insideroot(expr) + return getexpo(kres) + elif Is_Pow(expr): + ee=expr.args[1] + p1,p2=fraction(ee) + + return p1 + elif Is_Root(expr): + kres=insideroot(expr) + return getexpo(kres) + else: + return 1 + + +def getbase(expr): # return base in expr + ''' + expr = x**y,x*y + return x ,x*y + ''' + + if Is_Pow(expr): + ee=expr.args[0] + return ee + else: + return expr + +# ***Multifunc to Add Div and Mul**** +# ------------------------------ +def getroot(expr): + if Is_Root(expr): + mm=expr.args + kres=mm[1] + p1,p2=fraction(kres) + return p2 + + else: + return 1 + + +''' +def simplifyexpo(expr): # simplify each exponent in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+simplifyexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=simplifyexpo(p1) + P2=simplifyexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*simplifyexpo(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + ee=simplify(ee) + return bb**ee + else: + return expr +''' +def simplifyexpo(expr): # simplify each exponent in expr + kres=corefunc(expr,'simplifyexpo') + if Is_Pow(kres): + kres=getbase(kres)**simplify(getexpo(kres)) + return kres +''' +def expandexpo(expr): # simplify each exponent in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+expandexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=expandexpo(p1) + P2=expandexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*expandexpo(i) + return mm + elif Is_Pow(expr): + + bb=getbase(expr) + ee=getexpo(expr) + ee=expand(ee) + return ppow(bb,ee) + + else: + return expr +''' +def expandexpo(expr): # simplify each exponent in expr + kres=corefunc(expr,'expandexpo') + if Is_Pow(kres): + kres=getbase(kres)**expand(getexpo(kres)) + return kres +def expandexpoexpand(expr): # simplify each exponent in expr + kres=corefunc(expr,'expandexpo') + if Is_Pow(kres): + ee=getexpo(kres) + base=getbase(kres) + if Is_Pow(ee): + ee=expandexpo(ee) + kres= bb**ee + return kres +''' +def factorexpo(expr): + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+factorexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=factorexpo(p1) + P2=factorexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*factorexpo(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + ee=factor(ee) + return bb**ee + else: + return expr +''' +def factorexpo(expr): # simplify each exponent in expr + kres=corefunc(expr,'factorexpo') + if Is_Pow(kres): + kres=getbase(kres)**factor(getexpo(kres)) + return kres + +''' +def simplifybase(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+simplifybase(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=simplifybase(p1) + P2=simplifybase(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*simplifybase(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + bb=simplify(bb) + return bb**ee + else: + return expr +''' +def simplifybase(expr): # simplify each exponent in expr + kres=corefunc(expr,'simplifybase') + if Is_Pow(kres): + kres=getbase(kres)**simplify(getexpo(kres)) + return kres + + +''' +def expandbase(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+expandbase(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=expandbase(p1) + P2=expandbase(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*expandbase(i) + return mm + elif Is_Pow(expr): + return expand_power_base(expr) + else: + return expr +''' +def expandbase(expr): # simplify each exponent in expr + kres=corefunc(expr,'expandbase') + if Is_Pow(kres): + kres=expand(getbase(kres))**getexpo(kres) + return kres +''' +def factorbase(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+factorbase(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=factorbase(p1) + P2=factorbase(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*factorbase(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + bb=factor(bb) + return bb**ee + else: + return expr +''' +def factorbase(expr): # simplify each exponent in expr + kres=corefunc(expr,'factorbase') + if Is_Pow(kres): + kres=factor(getbase(kres))**getexpo(kres) + return kres + +def mulexpo(expr,force=False): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+mulexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=mulexpo(p1) + P2=mulexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*mulexpo(i) + return mm + elif Is_Pow(expr): + if Is_PowPow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb2=getbase(bb) + ee2=getexpo(bb) + return bb2**(ee*ee2) + else: + bb=getbase(expr) + ee=getexpo(expr) + if Is_Mul(bb): + mm=bb.args + kres=1 + for i in mm: + if Is_Pow(i): + bi=getbase(i) + ei=getexpo(i) + kres=kres*bi**(ei*ee) + else: + kres=kres*i**ee + return kres + else: + bb2=mulexpo(bb) + ee2=mulexpo(ee) + return bb2**ee2 + else: + return expr + + + +def lexpand(expr,force=True): # simplify each exponent in expr + + if Is_Add(expr): + mm=0 + for i in expr.args: + mm=mm+lexpand(i) + expr=mm + expr=corefunc(expr,'lexpand') + if Is_Log(expr): + return expand_log(expr, force=True) + + else: + return expr + +def lmul2lpow(expr): + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+lmul2pow(expr) + return kres + elif Is_Div(expr): + p1,p2=fraction(expr) + p1=lmul2pow(p1) + p2=lmul2pow(p2) + return cfrac(p1,p2) + elif Is_Mul(expr): + + if 'log' in str(expr): + ee=1 + vlog=1 + for i in fpoly(expr,'list'): + + if type(i)==log: + vlog=i.args[0] + else: + ee=ee*i + vlog=vlog**ee + return log(vlog) + else: + return expr + +# def lfactor(expr): # expand logaritm + # if Is_Add(expr): + # mm=0 + # for i in fpoly(expr,'list'): + # mm=mm+lfactor(i) + # return mm + # elif Is_Div(expr): + # p1,p2=fraction(expr) + # P1=lfactor(p1) + # P2=lfactor(p2) + # sP='('+str(P1)+')/('+str(P2)+')' + # return mirror_parse_expr(sP) + # elif Is_Mul(expr): + # mm=1 + # for i in fpoly(expr,'list'): + # mm=mm*lfactor(i) + # return mm + + # elif Is_Log(expr): + # return logcombine(expr, force=True) + + # else: + # return expr + +def lfactor(expr): + kres=corefunc(expr,'lexpand') + if Is_Log(kres): + return expand_log(expr, force=True) + + else: + return expr + +def lexponent(expr): + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+lexponent(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=lexponent(p1) + P2=lexponent(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*lexponent(i) + return mm + elif Is_Log(expr): + expr2=expr.args[0] + ee=getexpo(expr2) + bb=getbase(expr2) + + return ee*log(bb) + else: + return expr + +def lcombine(expr): + expr=logcombine(expr,force=True) + return expr + + + + + +def partPow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + if Is_Root(expr): + p1,p2=expr.args + nP=numer(p2) + dP=denom(p2) + bb=p1 + ee=nP + rr=dP + if Is_Pow(bb): + ff=getexpo(p1) + bb=getbase(p1) + ee=ee*ff + else: + ee=getexpo(expr) + bb=getbase(expr) + rr=1 + else: + bb=expr + ee=1 + rr=1 + return bb,ee,rr + +def partpow(expr): # if ksym = sqrt(x**3) x,3,2 , if ksym= x**3, return x,3,1 ,if is x ret x,1,1 + if Is_Pow(expr): + return getbase(expr),getexpo(expr) + else: + return expr,1 + + +def pow2powpow(*args): + expr=args[0] + ktype='out' + exp1='' + if len(args)==2: + exp1=args[1] + if len(args)==3: + ktype=args[2] + + + + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+pow2powpow(i,exp1) + return mm + elif Is_Div(expr): + return cfrac(pow2powpow(numer(expr),exp1),pow2powpow(denom(expr),exp1)) + elif Is_Mul(expr): + + mm=1 + for i in fpoly(expr,'list'): + mm=mm*pow2powpow(i,exp1) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + + if Is_Mul(ee): + + mm2=fpoly(ee,'list') + if exp1!='' and exp1 in mm2: + ee1=exp1 + ee2=simplify(ee/ee1) + if ktype!='out': + return((bb**ee2)**ee1) + else: + return((bb**ee1)**ee2) + else: + + ee1=mm2[0] + ee2=simplify(ee/ee1) + return((bb**ee1)**ee2) + else: + return expr + + else: + return expr + + +def powexpand(ksym,op=''): + ''' + input (x**(a*b)) ----> return(x**a)**b + input (x**(a*b),b) ----> return(x**b)**a + ''' + kres=ksym + if Is_Number(ksym): + + return ksym + + + if Is_Div(ksym): + + p1=powexpand(numer(ksym)) + p2=powexpand(denom(ksym)) + + return p1/p2 + + + elif Is_Mul(ksym): + mm=fpoly(ksym,'list') + kres=1 + for i in mm: + kres=kres*powexpand(i,op=op) + + return kres + + elif type(ksym)==Pow: + mm=fpoly(ksym,'list') + val=mm[0] + vexp=mm[1] + if type(vexp)==Pow: + + return ksym + elif type(vexp)==Mul: + mm2=fpoly(vexp,'list') + if len(mm2)==2: + p1=mm2[0] + p2=mm2[1] + if op!='': + kres=(val**p2) + kres=kres**p1 + else: + kres=(val**p1) + kres=kres**p2 + return kres + + else: + return ksym + + + + elif Is_Add(ksym): + mm=fpoly(ksym,'list') + mmr=0 + for i in mm: + mmr+=powexpand(i,op=op) + return mmr + else: + return ksym + + + +def powsimplifybase(ksym,combine='base'): + ''' + input (x**y*x**z*y**z ----> returnx**(x+y)*y**z + + ''' + expr=ksym + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+powsimp(i, combine='base', force=True) + return mm + if Is_Number(expr): + + return ksym + + + if fraction(expr)[0]==1: + + p1,p2==fraction(expr) + + + return powsimp(p1, combine='base', force=True)/powsimp(p2, combine='base', force=True) + + + elif Is_Mul(ksym): + mm=fpoly(ksym,'list') + kres=1 + for i in mm: + kres=kres*powsimp(p1, combine='base', force=True) + + return kres + + elif type(ksym)==Pow: + mm=fpoly(ksym,'list') + val=mm[0] + vexp=mm[1] + if type(vexp)==Pow: + + return ksym + elif type(vexp)==Mul: + mm2=fpoly(vexp,'list') + if len(mm2)==2: + p1=mm2[0] + p2=mm2[1] + if op!='': + kres=(val**p2) + kres=kres**p1 + else: + kres=(val**p1) + kres=kres**p2 + return kres + + else: + return ksym + + + + elif Is_Add(ksym): + mm=fpoly(ksym,'list') + mmr=0 + for i in mm: + mmr+=powexpand(i,op=op) + return mmr + else: + return ksym + +def div2mulexp(ksym): + ''' + input ((a/b)**x ----> return(a**x)*(b**(-x)) + + ''' + if Is_Div(ksym): + p1=numer(ksym) + p2=denom(ksym) + kres=p1*simplify(p2**(-1)) + return kres + if Is_Pow(ksym): + mm=fpoly(ksym,'list') + vald=mm[0] + vale=mm[1] + if denom(vald)!='1': + p1=numer(vald) + p2=denom(vald) + kres=(p1**vale)*(p2**(-1*vale)) + return kres + else: + return ksym + if Is_Add(ksym): + kres=0 + mm=fpoly(ksym,'list') + for i in mm: + kres+=div2mulexp(i) + return kres + if Is_Mul(ksym): + kres=1 + mm=fpoly(ksym,'list') + for i in mm: + kres=kres*div2mulexp(i) + return kres + else: + return ksym + +def joinbase(expr): + ''' + if expr= x**(a+b)*x(z) joinbase(expr)= x**(a+b+z) + ''' + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+joinbase(i) + return kres + elif Is_Mul(expr) and denom(expr)!=1: + + return simplify(expr) + elif Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb=joinbase(bb) + ee=joinbase(ee) + return ppow(bb,ee) + elif Is_Mul(expr): + kres=1 + mm=fpoly(expr,'list') + bb=[] + ee=[] + for i in mm: + bb1=getbase(i) + ee1=getexpo(i) + if bb1 not in bb: + bb.append(bb1) + ee.append(ee1) + else: + p1=bb.index(bb1) + nexp=ee[p1] + nexp=nexp+ee1 + ee[p1]=nexp + kres=1 + for i,j in zip(bb,ee): + kres=kres*ppow(i,j) + if kres==expr: + return powsimp(kres,force=True) + else: + return kres + else: + return expr + +def disjoinbase(expr): + return separebase(expr) + +def disjoinexpo(expr): + kres=corefunc(expr,'disjoinexpo') + if Is_Pow(expr): + base=getbase(expr) + ee=getexpo(expr) + ee2=disjoinbase(ee) + kres=base**ee2 + return kres + + +def positiveexpo(expr): + return positivexpo(disjoinbase(expr)) + +def positivexpo(expr): + if Is_Mul(expr): + return disjoinbase(expr) + elif Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+positivexpo(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=positivexpo(p1) + P2=positivexpo(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr) and denom(expr)!=1: + + mm=1 + for i in fpoly(expr,'list'): + try: + mm=mm*positivexpo(i) + except: + mm=mm*i + return mm + elif Is_Pow(expr): + + ee=getexpo(expr) + bb=getbase(expr) + if signo(ee)==-1: + if Is_Div(bb): + p1,p2=feaction(bb) + p3=frs(p2,p1) + nee=-1*ee + return p3**nee + else: + return mirror_parse_expr('1/'+str(bb**(-1*ee))) + + else: + return expr + + else: + return expr +def separebase(expr): + ''' + if expr= x**(a*z) expandbasepow(expr)= x**a*x**z + ''' + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+separebase(i) + return kres + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=separebase(p1) + P2=separebase(p2) + return cfrac(P1,P2) + + elif Is_Mul(expr): + kres=1 + for i in expr.args: + if Is_Pow(i): + kres=kres*separebase(i) + else: + kres=kres*i + return kres + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + kk=1 + mm=list(ee.args) + if mm==[]: + mm=[ee] + for i in mm: + kk=kk*ppow(bb,i) + #kk=Mul(kk,ppow(bb,i),evaluate=False) + + return kk + else: + return expr +def sum2mulexpo(expr): + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+sum2mulexpo(i) + return mm + + elif Is_Mul(expr): + + mm=1 + for i in fpoly(expr,'list'): + + mm=mm*sum2mulexpo(i) + return mm + elif Is_Pow(expr): + ee=getexpo(expr) + bb=getbase(expr) + if Is_Add(ee): + kres=1 + for i in fpoly(ee,'list'): + kres=kres*bb**i + return kres + else: + return expr + else: + return expr + + +def rsimplify(expr): + return rsimplify3(expr) + + +def rsimplify3(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+rsimplify3(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=rsimplify3(p1) + P2=rsimplify3(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*rsimplify3(i) + return mm + elif Is_Pow(expr) and not Is_Root(expr): + bb=getbase(expr) + ee=getexpo(expr) + bb=rsimplify3(bb) + return bb**ee + + elif Is_Root(expr): + rr=getroot(expr) + mm=insideroot(expr) + if Is_Pow(mm): + bb=getbase(mm) + ee=getexpo(mm) + return(bb**(simplify(cfrac(ee,rr)))) + elif Is_Mul(mm): + kres=1 + kl=mm.args + for i in kl: + bb=getbase(i) + ee=getexpo(i) + kres=kres*bb**(simplify(cfrac(ee,rr))) + return kres + else: + return expr + + else: + return expr +def krsimplify(expr): + if Is_Root(expr): + r=symbols('r') + rr=getroot(expr) + exp2=insideroot(expr) + nexpr=ppow(exp2,cfrac(1,r)) + nexpr=mulexpo(nexpr) + nexpr=simplifyexpo(nexpr) + nexpr=subsubs(nexpr,r,rr) + return nexpr + else: + return expr + +def rsimplify2(expr): # simplify each ecponet in expr + if Is_Add(expr): + mm=0 + for i in fpoly(expr,'list'): + mm=mm+rsimplify2(i) + return mm + elif Is_Div(expr): + p1,p2=fraction(expr) + P1=rsimplify2(p1) + P2=rsimplify2(p2) + sP='('+str(P1)+')/('+str(P2)+')' + return mirror_parse_expr(sP) + elif Is_Mul(expr): + mm=1 + for i in fpoly(expr,'list'): + mm=mm*rsimplify2(i) + return mm + elif Is_Pow(expr): + return krsimplify(expr) + + else: + return expr + + +def swapPow2Pow(expr): + + if Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + + if Is_Pow(bb): + + bb2=UnevaluatedExpr(getbase(bb)) + ee2=UnevaluatedExpr(getexpo(bb)) + return ppow(bb2**ee,ee2) + +def checkrpow(expr,rval): + if Is_Pow(expr): + bb=getbase(expr) + ee=getexpo(expr) + if rval==ee: + return bb + else: + nee=simplify(frs(ee,rval)) + return ppow(bb,nee) + elif Is_Number(expr): + expr=simplify(ppow(expr,1,rval)) + return expr + else: + return ppow(expr,frs(1,rval)) + + +def joinexpo(expr): + if Is_Add(expr): + kres=0 + for i in expr.args: + if Is_MulPow(i): + kres=kres+joinexpo(i) + else: + kres=kres+i + return kres + elif Is_Div(unisymbols(expr)): + p1,p2=unisymbols(fraction(expr)) + if Is_MulPow(p1): + p1=joinexpo(p1) + if Is_MulPow(p2): + p2=joinexpo(p2) + + kres=Div(p1,p2) + return kres + elif Is_MulPow(unisymbols(expr)): + vecnor=[] + vecpow=[] + for i in expr.args: + if type(i)==Pow: + vecpow.append(i) + else: + vecnor.append(i) + vecee=[] + for i in vecpow: + ee=getexpo(i) + if ee not in vecee: + vecee.append(ee) + vecbases=[] + for i in vecee: + vecbase=[] + for j in vecpow: + base=getbase(j) + ee=getexpo(j) + if ee==i: + vecbase.append(base) + vecbases.append(vecbase) + kres=1 + vecpro=[] + for i in vecbases: + kres=1 + for j in i: + kres=kres*j + vecpro.append(kres) + vecexp=[] + for i in vecpro: + try: + kres=expand(i) + except: + kres=i + vecexp.append(kres) + kres=1 + for i,j in zip( vecexp,vecee): + kres=kres*(i**j) + for i in vecnor: + kres=kres*i + return kres + else: + return expr +''' +def joinexpo(expr,op=''): + if Is_Add(expr): + kres=0 + for i in fpoly(expr,'list'): + kres=kres+joinexpoA(i,op=op) + return kres + elif Is_Mul(expr) or Is_Div(expr): + return joinexpoA(expr,op=op) + else: + return expr +''' + +def joinexpoA(expr,op=''): + ''' + input x**a*z**a/y**a + return (x*z/y)**a + ''' + vecexpo=[] + vecbases=[] + for i in expr.args: + if Is_Pow(i): + bb=getbase(i) + ee=getexpo(i) + if ee in vecexpo: + kpos=getposinvec(vecexpo,ee) + pbase=vecbases[kpos] + pbase.append(bb) + vecbases[kpos]=pbase + elif -1*ee in vecexpo: + kpos=getposinvec(vecexpo,-1*ee) + pbase=vecbases[kpos] + pbase.append(1/bb) + vecbases[kpos]=pbase + + else: + vecexpo.append(ee) + vecbases.append([bb]) + mres=1 + for i,j in zip(vecexpo,vecbases): + kres=1 + for ii in j: + if op=='simplify': + kres=simplify(expand(kres*ii)) + else: + kres=kres*ii + kres=kres**i + mres=mres*kres + return mres + +def getposinvec(vec,expr): + pp=-1 + cc=0 + qq=len(vec) + for i in range(qq): + expr1=vec[i] + if str(expr1)==str(expr): + return cc + cc=cc+1 + return -1 \ No newline at end of file