Maple 2024 Questions and Posts

These are Posts and Questions associated with the product, Maple 2024

Is there a trick to make Maple give same result below when using eval and limit?  

Attached worksheet. This comes in context of solving ode  using Laplace. Initial conditions are at zero. And need to solve for the constant of integration. 

It works when using eval, since Dirac(t) becomes Dirac(0), but when using Limit, Dirac(t) becomes zero and the _C1 is lost. I was wondering if limit should also return Dirac(0) like eval?

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1838 and is the same as the version installed in this computer, created 2024, December 2, 10:11 hours Pacific Time.`

restart;

e:=1/2*t+_C1*Dirac(t);

(1/2)*t+_C1*Dirac(t)

eval(e,t=0)

_C1*Dirac(0)

limit(e,t=0)

0

 

 

Download dirac_limit_dec_13_2024.mw

In Latest Maple 2024.2, I found that when doing z:=%  where % is result on integration, causes internal error 

          Error, unexpected result from Typesetting

But when the interface is set to standard, no such error.

This not only happen in worksheet, but also when code is run in command line!

Worksheet below.

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1837 and is the same as the version installed in this computer, created 2024, December 2, 10:11 hours Pacific Time.`

Example using extended

 

restart;

interface(typesetting=extended):

int(exp(-int(b(t),t))*t^4*csc(t)^2,t);

int(exp(-(int(b(t), t)))*t^4*csc(t)^2, t)

z:=%;

Error, (in Risch:-Norman) too many levels of recursion

` `

Error, unexpected result from Typesetting

 

Example using standard

 

restart;

interface(typesetting=standard):

int(exp(-int(b(t),t))*t^4*csc(t)^2,t);

int(exp(-(int(b(t), t)))*t^4*csc(t)^2, t)

z:=%;

int(exp(-(int(b(t), t)))*t^4*csc(t)^2, t)

 

 

Example using direct assignment also

 

restart;

interface(typesetting=extended):

z:=int(exp(-int(b(t),t))*t^4*csc(t)^2,t);

Error, (in Risch:-Norman) too many levels of recursion

` `

Error, unexpected result from Typesetting

Download extended_interface_causes_internal_bug_dec_13_2024.mw

ps. also reported to Maple support

I was rejected because the editor said my equation is too long. My question is: Is there a way to rewrite the equation in a more concise form? Additionally, is there a package in Maple that allows for automatic simplification or collection of terms without using specific commands? Any suggestions for addressing this issue would be appreciated.

restart

``

eq3 := -6*lambda*beta[0]^2*alpha[1]^2*a[3]-2*lambda*beta[0]^2*a[5]*alpha[0]+6*mu*beta[0]*alpha[1]^2*a[2]+3*mu*beta[0]*a[5]*alpha[0]^2+(10*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*alpha[1]^2*alpha[0]^3*a[4]+(6*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*alpha[1]^2*alpha[0]^2*a[3]+(4*(-(2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*lambda+4*mu^2))*alpha[1]^2*a[5]*alpha[0]-12*mu^2*alpha[1]^2*a[5]*alpha[0]+(3*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*alpha[1]^2*alpha[0]*a[2]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*k^2*a[1]*alpha[1]^2+(1/2)*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[1]+(5*(-(2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*lambda+4*mu^2))*alpha[1]^4*alpha[0]*a[4]+(4*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*alpha[1]^2*lambda*a[5]*alpha[0]-k^2*a[1]*beta[0]^2+10*beta[0]^2*alpha[0]^3*a[4]+6*beta[0]^2*alpha[0]^2*a[3]+3*beta[0]^2*alpha[0]*a[2]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*w*alpha[1]^2-(1/4)*lambda*beta[0]^2*a[1]-9*mu^2*alpha[1]^2*a[1]*(1/4)+3*mu*a[1]*alpha[0]*beta[0]*(1/2)+(1/4)*(3*(-(2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*lambda+4*mu^2))*alpha[1]^2*a[1]+(-(2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda))*lambda+4*mu^2)*alpha[1]^4*a[3]-w*beta[0]^2-30*lambda*beta[0]^2*alpha[1]^2*alpha[0]*a[4]-20*mu*beta[0]*lambda*alpha[1]^4*a[4]-7*mu*beta[0]*lambda*a[5]*alpha[1]^2+24*mu*beta[0]*alpha[1]^2*alpha[0]*a[3]+60*mu*beta[0]*alpha[1]^2*alpha[0]^2*a[4] = 0

-k^2*a[1]*beta[0]^2+4*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[5]*alpha[0]-30*lambda*beta[0]^2*alpha[1]^2*alpha[0]*a[4]-20*mu*beta[0]*lambda*alpha[1]^4*a[4]+60*mu*beta[0]*alpha[1]^2*alpha[0]^2*a[4]-7*mu*beta[0]*lambda*a[5]*alpha[1]^2+24*mu*beta[0]*alpha[1]^2*alpha[0]*a[3]-w*beta[0]^2-(9/4)*mu^2*alpha[1]^2*a[1]+6*beta[0]^2*alpha[0]^2*a[3]-(1/4)*lambda*beta[0]^2*a[1]+3*beta[0]^2*alpha[0]*a[2]+(3/4)*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[1]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*w*alpha[1]^2+10*beta[0]^2*alpha[0]^3*a[4]+(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*a[3]+6*mu*beta[0]*alpha[1]^2*a[2]+3*mu*beta[0]*a[5]*alpha[0]^2+(3/2)*mu*a[1]*alpha[0]*beta[0]-6*lambda*beta[0]^2*alpha[1]^2*a[3]-2*lambda*beta[0]^2*a[5]*alpha[0]-12*mu^2*alpha[1]^2*a[5]*alpha[0]+3*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]*a[2]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*k^2*a[1]*alpha[1]^2+(1/2)*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[1]+5*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*alpha[0]*a[4]+10*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^3*a[4]+6*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^2*a[3]+4*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[5]*alpha[0] = 0

(1)

numer(lhs(3*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]*a[2]+5*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*alpha[0]*a[4]+10*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^3*a[4]+6*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^2*a[3]+4*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[5]*alpha[0]-6*lambda*beta[0]^2*alpha[1]^2*a[3]-2*lambda*beta[0]^2*a[5]*alpha[0]+6*mu*beta[0]*alpha[1]^2*a[2]+3*mu*beta[0]*a[5]*alpha[0]^2+(3/2)*mu*a[1]*alpha[0]*beta[0]-12*mu^2*alpha[1]^2*a[5]*alpha[0]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*k^2*a[1]*alpha[1]^2+(1/2)*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[1]-w*beta[0]^2+4*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[5]*alpha[0]-30*lambda*beta[0]^2*alpha[1]^2*alpha[0]*a[4]-20*mu*beta[0]*lambda*alpha[1]^4*a[4]-7*mu*beta[0]*lambda*a[5]*alpha[1]^2+24*mu*beta[0]*alpha[1]^2*alpha[0]*a[3]+60*mu*beta[0]*alpha[1]^2*alpha[0]^2*a[4]+(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*a[3]+(3/4)*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[1]-k^2*a[1]*beta[0]^2+10*beta[0]^2*alpha[0]^3*a[4]+6*beta[0]^2*alpha[0]^2*a[3]+3*beta[0]^2*alpha[0]*a[2]-(9/4)*mu^2*alpha[1]^2*a[1]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*w*alpha[1]^2-(1/4)*lambda*beta[0]^2*a[1] = 0))*denom(rhs(3*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]*a[2]+5*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*alpha[0]*a[4]+10*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^3*a[4]+6*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^2*a[3]+4*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[5]*alpha[0]-6*lambda*beta[0]^2*alpha[1]^2*a[3]-2*lambda*beta[0]^2*a[5]*alpha[0]+6*mu*beta[0]*alpha[1]^2*a[2]+3*mu*beta[0]*a[5]*alpha[0]^2+(3/2)*mu*a[1]*alpha[0]*beta[0]-12*mu^2*alpha[1]^2*a[5]*alpha[0]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*k^2*a[1]*alpha[1]^2+(1/2)*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[1]-w*beta[0]^2+4*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[5]*alpha[0]-30*lambda*beta[0]^2*alpha[1]^2*alpha[0]*a[4]-20*mu*beta[0]*lambda*alpha[1]^4*a[4]-7*mu*beta[0]*lambda*a[5]*alpha[1]^2+24*mu*beta[0]*alpha[1]^2*alpha[0]*a[3]+60*mu*beta[0]*alpha[1]^2*alpha[0]^2*a[4]+(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*a[3]+(3/4)*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[1]-k^2*a[1]*beta[0]^2+10*beta[0]^2*alpha[0]^3*a[4]+6*beta[0]^2*alpha[0]^2*a[3]+3*beta[0]^2*alpha[0]*a[2]-(9/4)*mu^2*alpha[1]^2*a[1]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*w*alpha[1]^2-(1/4)*lambda*beta[0]^2*a[1] = 0)) = numer(rhs(3*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]*a[2]+5*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*alpha[0]*a[4]+10*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^3*a[4]+6*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^2*a[3]+4*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[5]*alpha[0]-6*lambda*beta[0]^2*alpha[1]^2*a[3]-2*lambda*beta[0]^2*a[5]*alpha[0]+6*mu*beta[0]*alpha[1]^2*a[2]+3*mu*beta[0]*a[5]*alpha[0]^2+(3/2)*mu*a[1]*alpha[0]*beta[0]-12*mu^2*alpha[1]^2*a[5]*alpha[0]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*k^2*a[1]*alpha[1]^2+(1/2)*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[1]-w*beta[0]^2+4*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[5]*alpha[0]-30*lambda*beta[0]^2*alpha[1]^2*alpha[0]*a[4]-20*mu*beta[0]*lambda*alpha[1]^4*a[4]-7*mu*beta[0]*lambda*a[5]*alpha[1]^2+24*mu*beta[0]*alpha[1]^2*alpha[0]*a[3]+60*mu*beta[0]*alpha[1]^2*alpha[0]^2*a[4]+(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*a[3]+(3/4)*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[1]-k^2*a[1]*beta[0]^2+10*beta[0]^2*alpha[0]^3*a[4]+6*beta[0]^2*alpha[0]^2*a[3]+3*beta[0]^2*alpha[0]*a[2]-(9/4)*mu^2*alpha[1]^2*a[1]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*w*alpha[1]^2-(1/4)*lambda*beta[0]^2*a[1] = 0))*denom(lhs(3*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]*a[2]+5*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*alpha[0]*a[4]+10*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^3*a[4]+6*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*alpha[0]^2*a[3]+4*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[5]*alpha[0]-6*lambda*beta[0]^2*alpha[1]^2*a[3]-2*lambda*beta[0]^2*a[5]*alpha[0]+6*mu*beta[0]*alpha[1]^2*a[2]+3*mu*beta[0]*a[5]*alpha[0]^2+(3/2)*mu*a[1]*alpha[0]*beta[0]-12*mu^2*alpha[1]^2*a[5]*alpha[0]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*k^2*a[1]*alpha[1]^2+(1/2)*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[1]-w*beta[0]^2+4*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*alpha[1]^2*lambda*a[5]*alpha[0]-30*lambda*beta[0]^2*alpha[1]^2*alpha[0]*a[4]-20*mu*beta[0]*lambda*alpha[1]^4*a[4]-7*mu*beta[0]*lambda*a[5]*alpha[1]^2+24*mu*beta[0]*alpha[1]^2*alpha[0]*a[3]+60*mu*beta[0]*alpha[1]^2*alpha[0]^2*a[4]+(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^4*a[3]+(3/4)*(-2*(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*lambda+4*mu^2)*alpha[1]^2*a[1]-k^2*a[1]*beta[0]^2+10*beta[0]^2*alpha[0]^3*a[4]+6*beta[0]^2*alpha[0]^2*a[3]+3*beta[0]^2*alpha[0]*a[2]-(9/4)*mu^2*alpha[1]^2*a[1]-(lambda*B[1]^2-lambda*B[2]^2-mu^2/lambda)*w*alpha[1]^2-(1/4)*lambda*beta[0]^2*a[1] = 0))

-40*lambda^3*B[1]^2*a[4]*alpha[0]*alpha[1]^4+40*lambda^3*B[2]^2*a[4]*alpha[0]*alpha[1]^4-8*lambda^3*B[1]^2*a[3]*alpha[1]^4+8*lambda^3*B[2]^2*a[3]*alpha[1]^4+40*lambda^2*B[1]^2*a[4]*alpha[0]^3*alpha[1]^2-40*lambda^2*B[2]^2*a[4]*alpha[0]^3*alpha[1]^2-4*k^2*lambda^2*B[1]^2*a[1]*alpha[1]^2+4*k^2*lambda^2*B[2]^2*a[1]*alpha[1]^2-16*lambda^3*B[1]^2*a[5]*alpha[0]*alpha[1]^2+16*lambda^3*B[2]^2*a[5]*alpha[0]*alpha[1]^2-80*lambda^2*mu*a[4]*alpha[1]^4*beta[0]+24*lambda^2*B[1]^2*a[3]*alpha[0]^2*alpha[1]^2-24*lambda^2*B[2]^2*a[3]*alpha[0]^2*alpha[1]^2+120*lambda*mu^2*a[4]*alpha[0]*alpha[1]^4-4*lambda^3*B[1]^2*a[1]*alpha[1]^2+4*lambda^3*B[2]^2*a[1]*alpha[1]^2+12*lambda^2*B[1]^2*a[2]*alpha[0]*alpha[1]^2-12*lambda^2*B[2]^2*a[2]*alpha[0]*alpha[1]^2-120*lambda^2*a[4]*alpha[0]*alpha[1]^2*beta[0]^2+24*lambda*mu^2*a[3]*alpha[1]^4+240*lambda*mu*a[4]*alpha[0]^2*alpha[1]^2*beta[0]-40*mu^2*a[4]*alpha[0]^3*alpha[1]^2+4*k^2*mu^2*a[1]*alpha[1]^2-28*lambda^2*mu*a[5]*alpha[1]^2*beta[0]-4*lambda^2*w*B[1]^2*alpha[1]^2+4*lambda^2*w*B[2]^2*alpha[1]^2-24*lambda^2*a[3]*alpha[1]^2*beta[0]^2+32*lambda*mu^2*a[5]*alpha[0]*alpha[1]^2+96*lambda*mu*a[3]*alpha[0]*alpha[1]^2*beta[0]+40*lambda*a[4]*alpha[0]^3*beta[0]^2-24*mu^2*a[3]*alpha[0]^2*alpha[1]^2-4*k^2*lambda*a[1]*beta[0]^2-8*lambda^2*a[5]*alpha[0]*beta[0]^2+7*lambda*mu^2*a[1]*alpha[1]^2+24*lambda*mu*a[2]*alpha[1]^2*beta[0]+12*lambda*mu*a[5]*alpha[0]^2*beta[0]+24*lambda*a[3]*alpha[0]^2*beta[0]^2-12*mu^2*a[2]*alpha[0]*alpha[1]^2-lambda^2*a[1]*beta[0]^2+6*lambda*mu*a[1]*alpha[0]*beta[0]+12*lambda*a[2]*alpha[0]*beta[0]^2+4*mu^2*w*alpha[1]^2-4*lambda*w*beta[0]^2 = 0

(2)

simplify(-40*lambda^3*B[1]^2*a[4]*alpha[0]*alpha[1]^4+40*lambda^3*B[2]^2*a[4]*alpha[0]*alpha[1]^4-8*lambda^3*B[1]^2*a[3]*alpha[1]^4+8*lambda^3*B[2]^2*a[3]*alpha[1]^4+40*lambda^2*B[1]^2*a[4]*alpha[0]^3*alpha[1]^2-40*lambda^2*B[2]^2*a[4]*alpha[0]^3*alpha[1]^2-4*k^2*lambda^2*B[1]^2*a[1]*alpha[1]^2+4*k^2*lambda^2*B[2]^2*a[1]*alpha[1]^2-16*lambda^3*B[1]^2*a[5]*alpha[0]*alpha[1]^2+16*lambda^3*B[2]^2*a[5]*alpha[0]*alpha[1]^2-80*lambda^2*mu*a[4]*alpha[1]^4*beta[0]+24*lambda^2*B[1]^2*a[3]*alpha[0]^2*alpha[1]^2-24*lambda^2*B[2]^2*a[3]*alpha[0]^2*alpha[1]^2+120*lambda*mu^2*a[4]*alpha[0]*alpha[1]^4-4*lambda^3*B[1]^2*a[1]*alpha[1]^2+4*lambda^3*B[2]^2*a[1]*alpha[1]^2+12*lambda^2*B[1]^2*a[2]*alpha[0]*alpha[1]^2-12*lambda^2*B[2]^2*a[2]*alpha[0]*alpha[1]^2-120*lambda^2*a[4]*alpha[0]*alpha[1]^2*beta[0]^2+24*lambda*mu^2*a[3]*alpha[1]^4+240*lambda*mu*a[4]*alpha[0]^2*alpha[1]^2*beta[0]-40*mu^2*a[4]*alpha[0]^3*alpha[1]^2+4*k^2*mu^2*a[1]*alpha[1]^2-28*lambda^2*mu*a[5]*alpha[1]^2*beta[0]-4*lambda^2*w*B[1]^2*alpha[1]^2+4*lambda^2*w*B[2]^2*alpha[1]^2-24*lambda^2*a[3]*alpha[1]^2*beta[0]^2+32*lambda*mu^2*a[5]*alpha[0]*alpha[1]^2+96*lambda*mu*a[3]*alpha[0]*alpha[1]^2*beta[0]+40*lambda*a[4]*alpha[0]^3*beta[0]^2-24*mu^2*a[3]*alpha[0]^2*alpha[1]^2-4*k^2*lambda*a[1]*beta[0]^2-8*lambda^2*a[5]*alpha[0]*beta[0]^2+7*lambda*mu^2*a[1]*alpha[1]^2+24*lambda*mu*a[2]*alpha[1]^2*beta[0]+12*lambda*mu*a[5]*alpha[0]^2*beta[0]+24*lambda*a[3]*alpha[0]^2*beta[0]^2-12*mu^2*a[2]*alpha[0]*alpha[1]^2-lambda^2*a[1]*beta[0]^2+6*lambda*mu*a[1]*alpha[0]*beta[0]+12*lambda*a[2]*alpha[0]*beta[0]^2+4*mu^2*w*alpha[1]^2-4*lambda*w*beta[0]^2 = 0, 'symbolic')

-40*(B[1]-B[2])*((a[4]*alpha[0]+(1/5)*a[3])*alpha[1]^2+(2/5)*a[5]*alpha[0]+(1/10)*a[1])*alpha[1]^2*(B[1]+B[2])*lambda^3+4*(-20*a[4]*beta[0]*alpha[1]^4*mu+(10*(B[1]^2-B[2]^2)*a[4]*alpha[0]^3+6*a[3]*(B[1]^2-B[2]^2)*alpha[0]^2+3*(B[1]^2*a[2]-B[2]^2*a[2]-10*a[4]*beta[0]^2)*alpha[0]-6*beta[0]^2*a[3]-7*a[5]*beta[0]*mu-(B[1]-B[2])*(B[1]+B[2])*(k^2*a[1]+w))*alpha[1]^2-2*(a[5]*alpha[0]+(1/8)*a[1])*beta[0]^2)*lambda^2+(120*(a[4]*alpha[0]+(1/5)*a[3])*mu^2*alpha[1]^4+(240*a[4]*beta[0]*alpha[0]^2*mu+32*(mu^2*a[5]+3*mu*a[3]*beta[0])*alpha[0]+24*beta[0]*mu*a[2]+7*mu^2*a[1])*alpha[1]^2-4*(-10*a[4]*beta[0]*alpha[0]^3+3*(-mu*a[5]-2*a[3]*beta[0])*alpha[0]^2+3*(-beta[0]*a[2]-(1/2)*mu*a[1])*alpha[0]+beta[0]*(k^2*a[1]+w))*beta[0])*lambda+4*alpha[1]^2*mu^2*(-10*a[4]*alpha[0]^3+k^2*a[1]-6*a[3]*alpha[0]^2-3*a[2]*alpha[0]+w) = 0

 

 

 

Error, (in collect) invalid input: collect uses a 2nd argument, x, which is missing

 

Q1 := collect(%, {B__1, B__2})

-40*(B[1]-B[2])*((a[4]*alpha[0]+(1/5)*a[3])*alpha[1]^2+(2/5)*a[5]*alpha[0]+(1/10)*a[1])*alpha[1]^2*(B[1]+B[2])*lambda^3+4*(-20*a[4]*beta[0]*alpha[1]^4*mu+(10*(B[1]^2-B[2]^2)*a[4]*alpha[0]^3+6*a[3]*(B[1]^2-B[2]^2)*alpha[0]^2+3*(B[1]^2*a[2]-B[2]^2*a[2]-10*a[4]*beta[0]^2)*alpha[0]-6*beta[0]^2*a[3]-7*a[5]*beta[0]*mu-(B[1]-B[2])*(B[1]+B[2])*(k^2*a[1]+w))*alpha[1]^2-2*(a[5]*alpha[0]+(1/8)*a[1])*beta[0]^2)*lambda^2+(120*(a[4]*alpha[0]+(1/5)*a[3])*mu^2*alpha[1]^4+(240*a[4]*beta[0]*alpha[0]^2*mu+32*(mu^2*a[5]+3*mu*a[3]*beta[0])*alpha[0]+24*beta[0]*mu*a[2]+7*mu^2*a[1])*alpha[1]^2-4*(-10*a[4]*beta[0]*alpha[0]^3+3*(-mu*a[5]-2*a[3]*beta[0])*alpha[0]^2+3*(-beta[0]*a[2]-(1/2)*mu*a[1])*alpha[0]+beta[0]*(k^2*a[1]+w))*beta[0])*lambda+4*alpha[1]^2*mu^2*(-10*a[4]*alpha[0]^3+k^2*a[1]-6*a[3]*alpha[0]^2-3*a[2]*alpha[0]+w) = 0

(3)

latex(Q1)

-40 \left(B_{1}-B_{2}\right) \left(\left(a_{4} \alpha_{0}+\frac{a_{3}}{5}\right) \alpha_{1}^{2}+\frac{2 a_{5} \alpha_{0}}{5}+\frac{a_{1}}{10}\right) \alpha_{1}^{2} \left(B_{1}+B_{2}\right) \lambda^{3}+4 \left(-20 a_{4} \beta_{0} \alpha_{1}^{4} \mu +\left(10 \left(B_{1}^{2}-B_{2}^{2}\right) a_{4} \alpha_{0}^{3}+6 a_{3} \left(B_{1}^{2}-B_{2}^{2}\right) \alpha_{0}^{2}+3 \left(B_{1}^{2} a_{2}-B_{2}^{2} a_{2}-10 a_{4} \beta_{0}^{2}\right) \alpha_{0}-6 \beta_{0}^{2} a_{3}-7 a_{5} \beta_{0} \mu -\left(B_{1}-B_{2}\right) \left(B_{1}+B_{2}\right) \left(k^{2} a_{1}+w \right)\right) \alpha_{1}^{2}-2 \left(a_{5} \alpha_{0}+\frac{a_{1}}{8}\right) \beta_{0}^{2}\right) \lambda^{2}+\left(120 \left(a_{4} \alpha_{0}+\frac{a_{3}}{5}\right) \mu^{2} \alpha_{1}^{4}+\left(240 a_{4} \beta_{0} \alpha_{0}^{2} \mu +32 \left(\mu^{2} a_{5}+3 \mu  a_{3} \beta_{0}\right) \alpha_{0}+24 \beta_{0} \mu  a_{2}+7 \mu^{2} a_{1}\right) \alpha_{1}^{2}-4 \left(-10 a_{4} \beta_{0} \alpha_{0}^{3}+3 \left(-\mu  a_{5}-2 a_{3} \beta_{0}\right) \alpha_{0}^{2}+3 \left(-\beta_{0} a_{2}-\frac{\mu  a_{1}}{2}\right) \alpha_{0}+\beta_{0} \left(k^{2} a_{1}+w \right)\right) \beta_{0}\right) \lambda +4 \alpha_{1}^{2} \mu^{2} \left(-10 a_{4} \alpha_{0}^{3}+k^{2} a_{1}-6 a_{3} \alpha_{0}^{2}-3 a_{2} \alpha_{0}+w \right)
 = 0

 
 

NULL

Download coment.mw

Major deficiency in Physics[Vectors]; Distinct sets of basis vectors are not recognized!

You can't define vectors in alternative bases like: {\hat{i}',\hat{j}',\hat{k}'} or {\hat{i}_{1},\hat{j}_{2},\hat{k}_{3}}.

This deficiency has been around for a while. I have found other posts regarding this problem.

The deficiency greatly reduces the allowable calculations with Physics[Vector].

Are there any plans to fix this?

Here is my example which shows this deficiency in more detail.

physics_vectors_and_multiple_unit_vectors.mw
 

restart

NULL

NULL

with(Physics[Vectors])

[`&x`, `+`, `.`, Assume, ChangeBasis, ChangeCoordinates, CompactDisplay, Component, Curl, DirectionalDiff, Divergence, Gradient, Identify, Laplacian, Nabla, Norm, ParametrizeCurve, ParametrizeSurface, ParametrizeVolume, Setup, Simplify, `^`, diff, int]

(1)

NULL

Crucial Deficiency in Physics[Vectors]

 

NULL

I can only guess the purpose of the Physics[Vectors] package from reviewing it's corresponding help documentation. My interpretation of the documentation leads me to believe that the package is best used for generating vector equation formulas in different coordinate bases of a SINGLE coordinate system.

 

This means one can easily generate position vector expressions such as:

 

r_ = _i*x+_j*y+_k*z

r_ = _i*x+_j*y+_k*z

(1.1)

Cylindrical Position Vector

 

The position vector in a cylindrical basis is given by:

 

r_ = ChangeBasis(rhs(r_ = _i*x+_j*y+_k*z), 2)

r_ = (x*cos(phi)+y*sin(phi))*_rho+(cos(phi)*y-sin(phi)*x)*_phi+z*_k

(1.1.1)

r_ = ChangeBasis(rhs(r_ = _i*x+_j*y+_k*z), 2, alsocomponents)

r_ = _k*z+_rho*rho

(1.1.2)

NULL

NULLNULLNULL

Spherical Position Vector

 

NULL

r_ = ChangeBasis(rhs(r_ = _i*x+_j*y+_k*z), 3)

r_ = (y*sin(phi)*sin(theta)+x*sin(theta)*cos(phi)+z*cos(theta))*_r+(y*sin(phi)*cos(theta)+x*cos(phi)*cos(theta)-z*sin(theta))*_theta+(cos(phi)*y-sin(phi)*x)*_phi

(1.2.1)

r_ = ChangeBasis(rhs(r_ = _i*x+_j*y+_k*z), 3, alsocomponents)

r_ = r*_r

(1.2.2)

NULL

NULL

As is known from the vector analysis of curvilinear coordinate systems the basis vectors can depend on the coordinates in question.

 

In cylindrical, the basis vectors are

 

_rho = ChangeBasis(_rho, 1)

_rho = _i*cos(phi)+sin(phi)*_j

(1.2)

_phi = ChangeBasis(_phi, 1)

_phi = -sin(phi)*_i+cos(phi)*_j

(1.3)

and in spherical, the basis vectors are

 

_r = ChangeBasis(_r, 1)

_r = sin(theta)*cos(phi)*_i+sin(theta)*sin(phi)*_j+cos(theta)*_k

(1.4)

_theta = ChangeBasis(_theta, 1)

_theta = cos(theta)*cos(phi)*_i+cos(theta)*sin(phi)*_j-sin(theta)*_k

(1.5)

_phi = ChangeBasis(_phi, 1)

_phi = -sin(phi)*_i+cos(phi)*_j

(1.6)

NULL

NULL

NULL

Example of this Deficiency using Biot-Savart Law

 

NULL

Biot-Savart law can be used to calculate a magnetic field due to a current carrying wire. The deficiency in question can be observed by explicity constructing the integrand in the Biot-Savart integral defined below.

NULL

NULL

NULL

In electrodynamics, quantum mechanics and applied mathematics, it is common practice to define a position of observation by a vector `#mover(mi("r"),mo("→"))` and a position of the source responsible for generating the field by a vector diff(`#mover(mi("r"),mo("→"))`(x), x).

 

It is just as common to define the difference in these vectors as

 

l_ = r_-(diff(r(x), x))*_

l_ = r_-`r'_`

(1.3.1)

and thus

 

dl_ = dr_-(diff(dr(x), x))*_

dl_ = dr_-`dr'_`

(1.3.2)

as found in the integrand of the Biot-Savart integral.

NULL

It suffices to consider `#mover(mi("l"),mo("→"))` = `#mover(mi("r"),mo("→"))`-`#mover(mi("r'"),mo("→"))` in a cylindrical basis for this argument.

 

The observation position is:

 

`#mover(mi("r"),mo("→"))` = rho*`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`+z*`#mover(mi("k"),mo("∧"))`

NULL

The source position is:

 

diff(`#mover(mi("r"),mo("→"))`(x), x) = (diff(z(x), x))*(diff(`#mover(mi("k"),mo("∧"))`(x), x))+(diff(rho(x), x))*(diff(`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`(x), x))

NULL

`#mover(mi("l"),mo("→"))` = `#mover(mi("r"),mo("→"))`-(diff(`#mover(mi("r"),mo("→"))`(x), x)) and `#mover(mi("r"),mo("→"))`-(diff(`#mover(mi("r"),mo("→"))`(x), x)) = z(x)*`#mover(mi("k"),mo("∧"))`-(diff(z(x), x))*(diff(`#mover(mi("k"),mo("∧"))`(x), x))+rho*`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`-(diff(rho(x), x))*(diff(`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`(x), x))

NULL

The deficiency in question arises because MAPLE cannot define multiple unit vectors in distinct bases such as {`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`, diff(`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`(x), x)} or {`#mscripts(mi("ρ",fontstyle = "normal"),mn("1"),none(),none(),mo("∧"),none(),none())`, `#mscripts(mi("ρ",fontstyle = "normal"),mn("2"),none(),none(),mo("∧"),none(),none())`}.  These pairs of unit vectors arise naturally, as shown above in Biot-Savart law.

NULL

If we look at `#mover(mi("ρ",fontstyle = "normal"),mo("ˆ"))` and  diff(`#mover(mi("ρ",fontstyle = "normal"),mo("ˆ"))`(x), x) generally, they look like:

NULL

`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))` = `#mover(mi("i"),mo("∧"))`*cos(phi)+sin(phi)*`#mover(mi("j"),mo("∧"))`

NULL

diff(`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`(x), x) = (diff(`#mover(mi("i"),mo("∧"))`(x), x))*cos(diff(phi(x), x))+sin(diff(phi(x), x))*(diff(`#mover(mi("j"),mo("∧"))`(x), x))

NULL

If the bases vectors {`#mover(mi("i"),mo("∧"))`, `#mover(mi("j"),mo("∧"))`, `#mover(mi("k"),mo("∧"))`} and {diff(`#mover(mi("i"),mo("∧"))`(x), x), diff(`#mover(mi("j"),mo("∧"))`(x), x), diff(`#mover(mi("k"),mo("∧"))`(x), x)} are Cartesian and are not related related through rotations so that

NULL

"(i)*i' =(|i|)*|i'|*cos(0)=1"``NULL

NULL

"(j)*(j)' =(|j|)*|(j)'|*cos(0)=1"NULL

NULL

"(k)*(k)' =(|k|)*|(k)'|*cos(0)=1 "

NULL

and so,NULL

 

`#mover(mi("i"),mo("ˆ"))` = diff(`#mover(mi("i"),mo("ˆ"))`(x), x)

NULL

`#mover(mi("j"),mo("ˆ"))` = diff(`#mover(mi("j"),mo("ˆ"))`(x), x)

NULL

`#mover(mi("k"),mo("ˆ"))` = diff(`#mover(mi("k"),mo("ˆ"))`(x), x)

NULL

the radial unit vectors in cylindrical are then,

 

`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))` = `#mover(mi("i"),mo("∧"))`*cos(phi)+sin(phi)*`#mover(mi("j"),mo("∧"))`

NULL

diff(`#mover(mi("ρ",fontstyle = "normal"),mo("∧"))`(x), x) = `#mover(mi("i"),mo("∧"))`*cos(diff(phi(x), x))+sin(diff(phi(x), x))*`#mover(mi("j"),mo("∧"))`

NULL

In typical problems, the anglular location of the observation point, φ, is distinct from the angular location of the source, diff(phi(x), x) and so under this condition, `#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))` <> diff(`#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))`(x), x).

 

Consider the classic problem of the magnetic field due to a circular current carrying wire. Surely, the angular coordinate of one location of the current carrying wire  is different from the angular coordinate  of an observation point hovering above and off-axis on the other side of the current carrying wire. See figure below.

NULL

NULL

NULL

NULL

Therefore,

 

`#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))` <> diff(`#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))`(x), x)

NULL

NULL

What happens in MAPLE when you try to define a second distinct unit vector diff(`#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))`(x), x)?

NULL

One can easily find `#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))`.

NULL

_rho

_rho

(1.3.3)

NULL

NULLIf you try to define diff(`#mover(mi("&rho;",fontstyle = "normal"),mo("&and;"))`(x), x) ...

 

 

diff(_rho(x), x)

`_rho'`

(1.3.4)

So using a prime doesn't work.

NULL

You could try a numbered subscript...

`_&rho;__2`

_rho__2

(1.3.5)

but that doesn't work.

 

You could try an indexed unit vector...

NULL

_rho[2]

_rho[2]

(1.3.6)

which can be define but is not recognized by Physics[Vectors] since...

 

NULL

ChangeBasis(_rho[2], 1)

Error, (in Physics:-Vectors:-Identify) incorrect indexed use of a unit vector: _rho[2]

 

NULL

And so it's just not possible with the current implementation.

``

``

NULL

NULL


 

Download physics_vectors_and_multiple_unit_vectors.mw

 

 

This is my first time solving an equation where the solution includes a function W(t). I'm not sure how to work with it. Does anyone have insights about this function? I also don't have much knowledge about stochastic processes, which I think might be related. How can I gather enough information to understand and plot such a function?
in that paper i saw he talk about wiener process!

restart;

local gamma;

gamma

(1)

``

T3 := (B[1]*(coth(2*n^2*(delta^2-w)*k*t/((k*n-1)*(k*n+1))+x)-1))^(1/(2*n))*exp(I*(-k*x+w*t+delta*W(t)-delta^2*t))

(B[1]*(coth(2*n^2*(delta^2-w)*k*t/((k*n-1)*(k*n+1))+x)-1))^((1/2)/n)*exp(I*(-k*x+w*t+delta*W(t)-delta^2*t))

(2)

``

params := {B[1]=1,n=2,delta=1,w=1,k=3 };

{delta = 1, k = 3, n = 2, w = 1, B[1] = 1}

(3)

``

insert numerical values

solnum :=subs(params, T3);

(coth(x)-1)^(1/4)*exp(I*(-3*x+W(t)))

(4)

``

P := Array(1 .. 2); P[1] := plot3d(map(Re, solnum), x = -2 .. 2, t = 0 .. 10, title = Re); P[2] := plot3d(map(Im, solnum), x = -20 .. 20, t = -10 .. 10, title = Im); plots:-display(P)

 

 

 

 

 

plot3d(map(abs, solnum), x = -10 .. 10, t = 0 .. 5)

 

 

Download graph-stochastic.mw

I'm having trouble solving this system of differential equations. I haven't solved systems of differential equations before but i tried defining the system and then using dsolve, but it couldn't solve all the equations.

Hope you can help.

NULL

diff(Q1(t), t) = -k1*Q1(t)

 

diff(Q2(t), t) = k1*Q1+k3/Q2(t)-k2*Q2(t)-k4*Q2(t)

 

diff(Q3(t), t) = k4*Q2

 

diff(Q4(t), t) = k2*Q2-k3/Q2

 

NULL

Download System_Of_Differential_Equations.mw

I'm trying to transform a partial differential equation (PDE) into an ordinary differential equation (ODE) as demonstrated in the paper. However, I find some steps confusing and difficult to follow. The process often feels chaotic, and managing the complexity of the equations is overwhelming. Could you suggest an effective and systematic method to handle such transformations more easily?

restart

with(PDEtools)

with(LinearAlgebra)

NULL

with(SolveTools)

undeclare(prime)

`There is no more prime differentiation variable; all derivatives will be displayed as indexed functions`

(1)

declare(Omega(x, t)); declare(U(xi))

Omega(x, t)*`will now be displayed as`*Omega

 

U(xi)*`will now be displayed as`*U

(2)

tr := {t = tau, x = tau*c[0]+xi, Omega(x, t) = U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))}

{t = tau, x = tau*c[0]+xi, Omega(x, t) = U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))}

(3)

P1 := diff(Omega(x, t)^m, t)

Omega(x, t)^m*m*(diff(Omega(x, t), t))/Omega(x, t)

(4)

L1 := PDEtools:-dchange(tr, P1, [xi, tau, U])

(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m*(-((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))*c[0]+I*U(xi)*(-k*c[0]+w+delta*(diff(W(tau), tau))-delta^2)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))/(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))

(5)
 

pde1 := I*(diff(Omega(x, t)^m, t))+alpha*(diff(Omega(x, t)^m, `$`(x, 2)))+I*beta*(diff(abs(Omega(x, t))^(2*n)*Omega(x, t)^m, x))+m*sigma*Omega(x, t)^m*(diff(W(t), t)) = I*gamma*abs(Omega(x, t))^(2*n)*(diff(Omega(x, t)^m, x))+delta*abs(Omega(x, t))^(4*n)*Omega(x, t)^m

I*Omega(x, t)^m*m*(diff(Omega(x, t), t))/Omega(x, t)+alpha*(Omega(x, t)^m*m^2*(diff(Omega(x, t), x))^2/Omega(x, t)^2+Omega(x, t)^m*m*(diff(diff(Omega(x, t), x), x))/Omega(x, t)-Omega(x, t)^m*m*(diff(Omega(x, t), x))^2/Omega(x, t)^2)+I*beta*(2*abs(Omega(x, t))^(2*n)*n*(diff(Omega(x, t), x))*abs(1, Omega(x, t))*Omega(x, t)^m/abs(Omega(x, t))+abs(Omega(x, t))^(2*n)*Omega(x, t)^m*m*(diff(Omega(x, t), x))/Omega(x, t))+m*sigma*Omega(x, t)^m*(diff(W(t), t)) = I*gamma*abs(Omega(x, t))^(2*n)*Omega(x, t)^m*m*(diff(Omega(x, t), x))/Omega(x, t)+delta*abs(Omega(x, t))^(4*n)*Omega(x, t)^m

(6)

NULL

L1 := PDEtools:-dchange(tr, pde1, [xi, tau, U])

I*(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m*(-((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))*c[0]+I*U(xi)*(-k*c[0]+w+delta*(diff(W(tau), tau))-delta^2)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))/(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))+alpha*((U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m^2*((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^2/(U(xi)^2*(exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^2)+(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m*((diff(diff(U(xi), xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-(2*I)*(diff(U(xi), xi))*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-U(xi)*k^2*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))/(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))-(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m*((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^2/(U(xi)^2*(exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^2))+I*beta*(2*(abs(U(xi))*exp(-Im(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^(2*n)*n*((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))*abs(1, U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))*(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m/(abs(U(xi))*exp(-Im(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))+(abs(U(xi))*exp(-Im(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^(2*n)*(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m*((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))/(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))))+m*sigma*(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*(diff(W(tau), tau)) = I*gamma*(abs(U(xi))*exp(-Im(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^(2*n)*(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m*m*((diff(U(xi), xi))*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau))-I*U(xi)*k*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))/(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))+delta*(abs(U(xi))*exp(-Im(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^(4*n)*(U(xi)*exp(I*(-k*(tau*c[0]+xi)+w*tau+delta*W(tau)-delta^2*tau)))^m

(7)

``

``

(8)

Download transform-pde-to-ode-hard_example.mw

Is there a way to determine how we can construct a system of equations from this complex PDE? Also, moderator, you mentioned I could create a new question using the branch option, but you deleted my previous question, which led me to delete my earlier post. don't delete this one.

Download PDE-Hard.mw

The output RealDomain:-solve(x**2 + 2*cos(x) = (Pi/3)**2 + 1, [x]) means that there is no real solution, but clearly, both x = -Pi/3 and x = +Pi/3 satisfy the original equation: 

So, why does `solve` lose the real solutions without any warning messages? 
Code: 

restart;
eq := 9*(x^2 + 2*cos(x)) = Pi^2 + 9;
RealDomain:-solve(eq, [x]);
                               []

:-solve({eq, x >= 0}, [x]); # as (lhs - rhs)(eq) is an even function 
                               []


this equation will be solve by changing variable but when  i found the function and substitute the ODE is not zero where  is mistake?

restart

with(PDEtools); _local(gamma)

Warning, A new binding for the name `gamma` has been created. The global instance of this name is still accessible using the :- prefix, :-`gamma`.  See ?protect for details.

 

undeclare(prime)

`There is no more prime differentiation variable; all derivatives will be displayed as indexed functions`

(1)

declare(phi(x, t)); declare(psi(x, t)); declare(U(xi))

phi(x, t)*`will now be displayed as`*phi

 

psi(x, t)*`will now be displayed as`*psi

 

U(xi)*`will now be displayed as`*U

(2)

with(PDEtools)

with(LinearAlgebra)

NULL

with(SolveTools)

undeclare(prime)

`There is no more prime differentiation variable; all derivatives will be displayed as indexed functions`

(3)

ode := (diff(diff(U(xi), xi), xi))*lambda^2+(diff(diff(diff(diff(U(xi), xi), xi), xi), xi))*lambda*k^3-6*(diff(diff(U(xi), xi), xi))*k^2*(diff(U(xi), xi))*lambda = 0

(diff(diff(U(xi), xi), xi))*lambda^2+(diff(diff(diff(diff(U(xi), xi), xi), xi), xi))*lambda*k^3-6*(diff(diff(U(xi), xi), xi))*k^2*(diff(U(xi), xi))*lambda = 0

(4)

W := diff(U(xi), xi) = T(xi)

diff(U(xi), xi) = T(xi)

(5)

ode1 := lambda^2*T(xi)+lambda*k^3*(diff(diff(T(xi), xi), xi))-3*k^2*lambda*T(xi)^2 = 0

lambda^2*T(xi)+lambda*k^3*(diff(diff(T(xi), xi), xi))-3*k^2*lambda*T(xi)^2 = 0

(6)

K := T(xi) = A[0]+A[1]*(exp(2*xi)-1)/(exp(2*xi)+1)+A[2]*(exp(2*xi)-1)^2/(exp(2*xi)+1)^2+B[1]*(exp(2*xi)+1)/(exp(2*xi)-1)+B[2]*(exp(2*xi)+1)/(exp(2*xi)-1)

T(xi) = A[0]+A[1]*(exp(2*xi)-1)/(exp(2*xi)+1)+A[2]*(exp(2*xi)-1)^2/(exp(2*xi)+1)^2+B[1]*(exp(2*xi)+1)/(exp(2*xi)-1)+B[2]*(exp(2*xi)+1)/(exp(2*xi)-1)

(7)

case1 := [k = (1/2)*A[2], lambda = -(1/2)*A[2]^3, A[0] = -A[2], A[1] = 0, A[2] = A[2], B[1] = -B[2], B[2] = B[2]]

[k = (1/2)*A[2], lambda = -(1/2)*A[2]^3, A[0] = -A[2], A[1] = 0, A[2] = A[2], B[1] = -B[2], B[2] = B[2]]

(8)

F1 := subs(case1, K)

T(xi) = -A[2]+A[2]*(exp(2*xi)-1)^2/(exp(2*xi)+1)^2

(9)

F2 := subs(case1, ode1)

(1/4)*A[2]^6*T(xi)-(1/16)*A[2]^6*(diff(diff(T(xi), xi), xi))+(3/8)*A[2]^5*T(xi)^2 = 0

(10)

odetest(F1, F2)

0

(11)

subs(F1, W)

diff(U(xi), xi) = -A[2]+A[2]*(exp(2*xi)-1)^2/(exp(2*xi)+1)^2

(12)

E := map(int, diff(U(xi), xi) = -A[2]+A[2]*(exp(2*xi)-1)^2/(exp(2*xi)+1)^2, xi)

U(xi) = A[2]*((1/2)*ln(exp(2*xi))+2/(exp(2*xi)+1))-A[2]*xi

(13)

odetest(E, ode)

32*A[2]*exp(8*xi)*lambda*k^3/(exp(2*xi)+1)^5-352*A[2]*exp(6*xi)*lambda*k^3/(exp(2*xi)+1)^5+192*A[2]^2*exp(6*xi)*lambda*k^2/(exp(2*xi)+1)^5+8*A[2]*exp(8*xi)*lambda^2/(exp(2*xi)+1)^5+352*A[2]*exp(4*xi)*lambda*k^3/(exp(2*xi)+1)^5-192*A[2]^2*exp(4*xi)*lambda*k^2/(exp(2*xi)+1)^5+8*A[2]*exp(6*xi)*lambda^2/(exp(2*xi)+1)^5-32*A[2]*exp(2*xi)*lambda*k^3/(exp(2*xi)+1)^5-8*A[2]*exp(4*xi)*lambda^2/(exp(2*xi)+1)^5-8*A[2]*exp(2*xi)*lambda^2/(exp(2*xi)+1)^5

(14)
 

NULL

Download problem.mw

I'm trying to solve system of ODE (Temperature changing with time) which are going to use the heat capacity obtained from thermophysical package (heat capacity is changing with temperature).

In the support page there is an example in which they were able to integrate the heat capacity from the package. So I wondering if it is possible to include it in an ODE system.

I used their same approach, I tried defining the call to the package as a function but I'm getting an error:

"Error, (in dsolve/numeric/process_input) input system must be an ODE system, found {ThermophysicalData:-CoolProp:-PropsSI(C,P,101325,T,T1(t),"hydrogen"), T1(t), T2(t), T3(t)}"

Attached question.mw

restart:
with(ThermophysicalData):
with(CoolProp):
with(plots):

#I would like to get the heat capacity from this package. Heat capacity is a function of temperature and pressure.
CP:=T1->PropsSI(C, P, 101325, T, T1, "hydrogen")/10000:

#Parameters
UA:=10:T0:=20:TS:=250:W:=100:M:=1000:

#The temperature is changing in this system of ODE with time. I would like to have the heat capacity value changing with temperature using the values obtained from the package.
EQ1:=diff(T1(t),t)=(W*CP(T1(t))*(T0-T1(t))+UA*(TS-T1(t)))/M/CP(T1(t)):
EQ2:=diff(T2(t),t)=(W*CP(T1(t))*(T1(t)-T2(t))+UA*(TS-T2(t)))/M/CP(T1(t)):
EQ3:=diff(T3(t),t)=(W*CP(T1(t))*(T2(t)-T3(t))+UA*(TS-T3(t)))/M/CP(T1(t)):

sol:=dsolve({EQ1,EQ2,EQ3,T1(0)=25,T2(0)=25,T3(0)=25},[T1(t),T2(t),T3(t)],numeric):
odeplot(sol,[[t,T1(t)],[t,T2(t)],[t,T3(t)]],t=0..140,legend=[T1,T2,T3],labels = ["time [min]", "Ti [C]"],axes=boxed)
sol(57.7);

Hello sir, how are you?
Sorry to bother you, I needed your help. I have the script from your textbook "3D Graph Equation of Motorcycle run on Maple Software". It's not working. I'd appreciate it if you could take a look.

with(plots);
implicitplot3d(((49.80*x + 19.44*y + 133.2300 - 19.08*sqrt(x^2 + 8.30*x + 19.8469 + y^2 + 3.24*y) - 66.6150*abs(-3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42) + 0.5625*abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2) = ((((((((((((2 + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42) + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(x^2 + 8.30) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(y^2 + 3.24)) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(x^2 + 8.30) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42) + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(x^2 + 3.24) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(y^2 - 3.18)) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(x^2 + 8.30) - 3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42) + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(x^2 + 8.30) - 3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(x^2 + 3.24)) - 3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(y^2 + 3.24) + 0.42*abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2) and ((((((((((((2 + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42) + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(x^2 + 8.30) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(y^2 + 3.24)) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(x^2 + 8.30) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42) + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(x^2 + 3.24) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(y^2 - 3.18)) + abs(3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2))) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(x^2 + 8.30) - 3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42) + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(x^2 + 8.30) - 3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y - 2)*(x^2 + 3.24)) - 3.9*sqrt((x - 1.7)^2 + (y - 1.35)^2)) + 0.42 + abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2)*(y^2 + 3.24) + 0.42*abs(0.00390625*(x^8 + y^8) - 0.5*x + 2*y + 2) = 0, x = -7 .. 7, y = -4 .. 3, z = -3 .. 3, numpoints = 350000, style = surface, color = "Niagara Azure");

evalindets API says 

             evalindets( expr, atype, transformer, rest )

Where the transformer will be applied on any indents of atype.

But I want to be able to do the opposit, i.e. 

             evalindets( expr, except_this_atype, transformer, rest )

ie. apply the transformer on everything except those of atype.

Here is a concrete example and what I tried.

I get result of apply inverse Fourier transform which can have some terms in it which can not be evaluated. Like this

Y:=(s+1)/s^2+Int(sqrt(s^2),s);
expr:=inttrans:-invlaplace(Y,s,t);

Now I want to evaluate the above at some specific value of t, say t=0 but I do not want change/touch any "t" inside invlaplace(....) function. 

If I just do 

eval(expr,t=0)

So I tried evalindets with flat option and used for atype anything, then inside the transformer, check if op(0,X) is invlaplace (i.e the head), and if so, skip it. But it did not work

Y:=(s+1)/s^2+Int(sqrt(s^2),s);
expr:=inttrans:-invlaplace(Y,s,t);
evalindets[flat](expr,anything,X->`if`( evalb(op(0,X)='invlaplace'),X,eval(X,t=0)));
evalindets[flat](expr,anything,X->`if`( op(0,X)='invlaplace',X,eval(X,t=0)));



Currently what I do to make this to work, is to first replace the "t" inside invlaplace by another unused symbol, then do the eval to change t, then replace the symbol back to t.

Like this, and this works:

Y:=(s+1)/s^2+Int(sqrt(s^2),s);
expr:=inttrans:-invlaplace(Y,s,t);
expr:=evalindets[flat](expr,'specfunc(anything,invlaplace)',X->eval(X,t=T));
expr:=eval(expr,t=0);
expr:=eval(expr,T=t);

Is it possible to do the above using one call to evalindets?  Why did the check I had the above using `if`(...) not work?

It will be really useful if evalindets had option NOT atype,  in addition of just atype.

i.e. tell it to do the transformation on everything except the type given.

Maple 2024.2

 

I am trying to animate images generated in a do loop using display and insequence. I get an output but there is no flipping of the image even while I see the frames count flip through the frames. What am I doing wrong? See attached code. Thanks!

Why_cant_I_animate_still_images_like_this.mw

This is about delayed input after executing this file Campo_Médio_spin_7_2_-_Forum_optimize_02.mw

from annother question dealing with very large physics expressions (containing about 100000 exponential functions).

The GUI shows but when I place the cursor in an inputline and type, characters are sometimes displayed with a huge delay (about 20 seconds). This is from time to time, i.e. not always. All on Windows 10, 64 Gb memory and 4 Gb graphic card memory.

Can someone reproduce this?

Has anybody experienced the same (kernel with large expressions & GUI not responsive)?

Anything that I can test or try?

(I had a similar question about file size but this time the file size is small 150 kB and no big plots are made.

Only the kernel has to deal with the large expression. Output displayed on the GUI is negligible.)

1 2 3 4 5 6 7 Last Page 1 of 27