Unanswered Questions

This page lists MaplePrimes questions that have not yet received an answer

How i can find parameter after substitution in our pde 

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(u(x, t))

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

(2)

declare(f(x, t))

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

(3)

pde := diff(u(x, t), `$`(x, 3))+6*u(x, t)*(diff(u(x, t), x))+diff(u(x, t), t) = 0

diff(diff(diff(u(x, t), x), x), x)+6*u(x, t)*(diff(u(x, t), x))+diff(u(x, t), t) = 0

(4)

map(int, diff(diff(diff(u(x, t), x), x), x)+6*u(x, t)*(diff(u(x, t), x))+diff(u(x, t), t) = 0, x)

3*u(x, t)^2+diff(diff(u(x, t), x), x)+int(diff(u(x, t), t), x) = 0

(5)

pde1 := %

3*u(x, t)^2+diff(diff(u(x, t), x), x)+int(diff(u(x, t), t), x) = 0

(6)

Y := u(x, t) = 2*(diff(ln(f(x, t)), `$`(x, 2)))

u(x, t) = 2*(diff(diff(f(x, t), x), x))/f(x, t)-2*(diff(f(x, t), x))^2/f(x, t)^2

(7)

L := eval(pde1, Y)

3*(2*(diff(diff(f(x, t), x), x))/f(x, t)-2*(diff(f(x, t), x))^2/f(x, t)^2)^2+2*(diff(diff(diff(diff(f(x, t), x), x), x), x))/f(x, t)-8*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))/f(x, t)^2+24*(diff(diff(f(x, t), x), x))*(diff(f(x, t), x))^2/f(x, t)^3-6*(diff(diff(f(x, t), x), x))^2/f(x, t)^2-12*(diff(f(x, t), x))^4/f(x, t)^4-2*(diff(f(x, t), x))*(diff(f(x, t), t))/f(x, t)^2+2*(diff(diff(f(x, t), t), x))/f(x, t) = 0

(8)

numer(lhs(3*(2*(diff(diff(f(x, t), x), x))/f(x, t)-2*(diff(f(x, t), x))^2/f(x, t)^2)^2+2*(diff(diff(diff(diff(f(x, t), x), x), x), x))/f(x, t)-8*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))/f(x, t)^2+24*(diff(diff(f(x, t), x), x))*(diff(f(x, t), x))^2/f(x, t)^3-6*(diff(diff(f(x, t), x), x))^2/f(x, t)^2-12*(diff(f(x, t), x))^4/f(x, t)^4-2*(diff(f(x, t), x))*(diff(f(x, t), t))/f(x, t)^2+2*(diff(diff(f(x, t), t), x))/f(x, t) = 0))*denom(rhs(3*(2*(diff(diff(f(x, t), x), x))/f(x, t)-2*(diff(f(x, t), x))^2/f(x, t)^2)^2+2*(diff(diff(diff(diff(f(x, t), x), x), x), x))/f(x, t)-8*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))/f(x, t)^2+24*(diff(diff(f(x, t), x), x))*(diff(f(x, t), x))^2/f(x, t)^3-6*(diff(diff(f(x, t), x), x))^2/f(x, t)^2-12*(diff(f(x, t), x))^4/f(x, t)^4-2*(diff(f(x, t), x))*(diff(f(x, t), t))/f(x, t)^2+2*(diff(diff(f(x, t), t), x))/f(x, t) = 0)) = numer(rhs(3*(2*(diff(diff(f(x, t), x), x))/f(x, t)-2*(diff(f(x, t), x))^2/f(x, t)^2)^2+2*(diff(diff(diff(diff(f(x, t), x), x), x), x))/f(x, t)-8*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))/f(x, t)^2+24*(diff(diff(f(x, t), x), x))*(diff(f(x, t), x))^2/f(x, t)^3-6*(diff(diff(f(x, t), x), x))^2/f(x, t)^2-12*(diff(f(x, t), x))^4/f(x, t)^4-2*(diff(f(x, t), x))*(diff(f(x, t), t))/f(x, t)^2+2*(diff(diff(f(x, t), t), x))/f(x, t) = 0))*denom(lhs(3*(2*(diff(diff(f(x, t), x), x))/f(x, t)-2*(diff(f(x, t), x))^2/f(x, t)^2)^2+2*(diff(diff(diff(diff(f(x, t), x), x), x), x))/f(x, t)-8*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))/f(x, t)^2+24*(diff(diff(f(x, t), x), x))*(diff(f(x, t), x))^2/f(x, t)^3-6*(diff(diff(f(x, t), x), x))^2/f(x, t)^2-12*(diff(f(x, t), x))^4/f(x, t)^4-2*(diff(f(x, t), x))*(diff(f(x, t), t))/f(x, t)^2+2*(diff(diff(f(x, t), t), x))/f(x, t) = 0))

2*f(x, t)^2*(3*(diff(diff(f(x, t), x), x))^2+f(x, t)*(diff(diff(diff(diff(f(x, t), x), x), x), x))+f(x, t)*(diff(diff(f(x, t), t), x))-4*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))-(diff(f(x, t), x))*(diff(f(x, t), t))) = 0

(9)

PP := simplify(2*f(x, t)^2*(3*(diff(diff(f(x, t), x), x))^2+f(x, t)*(diff(diff(diff(diff(f(x, t), x), x), x), x))+f(x, t)*(diff(diff(f(x, t), t), x))-4*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))-(diff(f(x, t), x))*(diff(f(x, t), t))) = 0)

2*f(x, t)^2*(3*(diff(diff(f(x, t), x), x))^2+f(x, t)*(diff(diff(diff(diff(f(x, t), x), x), x), x))+f(x, t)*(diff(diff(f(x, t), t), x))-4*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))-(diff(f(x, t), x))*(diff(f(x, t), t))) = 0

(10)

%/(2*f(x, t)^2)

3*(diff(diff(f(x, t), x), x))^2+f(x, t)*(diff(diff(diff(diff(f(x, t), x), x), x), x))+f(x, t)*(diff(diff(f(x, t), t), x))-4*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))-(diff(f(x, t), x))*(diff(f(x, t), t)) = 0

(11)

collect(%, f)

(diff(diff(diff(diff(f(x, t), x), x), x), x)+diff(diff(f(x, t), t), x))*f(x, t)+3*(diff(diff(f(x, t), x), x))^2-4*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))-(diff(f(x, t), x))*(diff(f(x, t), t)) = 0

(12)

pde2 := %

(diff(diff(diff(diff(f(x, t), x), x), x), x)+diff(diff(f(x, t), t), x))*f(x, t)+3*(diff(diff(f(x, t), x), x))^2-4*(diff(diff(diff(f(x, t), x), x), x))*(diff(f(x, t), x))-(diff(f(x, t), x))*(diff(f(x, t), t)) = 0

(13)

N = 1

N = 1

(14)

S := f(x, t) = a[0]+a[1]*exp(t*n[1]+x*k[1])

f(x, t) = a[0]+a[1]*exp(t*n[1]+x*k[1])

(15)

A := eval(pde2, S)

(a[1]*k[1]^4*exp(t*n[1]+x*k[1])+a[1]*n[1]*k[1]*exp(t*n[1]+x*k[1]))*(a[0]+a[1]*exp(t*n[1]+x*k[1]))-a[1]^2*k[1]^4*(exp(t*n[1]+x*k[1]))^2-a[1]^2*k[1]*(exp(t*n[1]+x*k[1]))^2*n[1] = 0

(16)

simplify((a[1]*k[1]^4*exp(t*n[1]+x*k[1])+a[1]*n[1]*k[1]*exp(t*n[1]+x*k[1]))*(a[0]+a[1]*exp(t*n[1]+x*k[1]))-a[1]^2*k[1]^4*(exp(t*n[1]+x*k[1]))^2-a[1]^2*k[1]*(exp(t*n[1]+x*k[1]))^2*n[1] = 0)

a[0]*a[1]*exp(t*n[1]+x*k[1])*k[1]*(k[1]^3+n[1]) = 0

(17)

%/exp(t*n[1]+x*k[1])

(k[1]^3+n[1])*k[1]*a[1]*a[0] = 0

(18)

PPP := %

(k[1]^3+n[1])*k[1]*a[1]*a[0] = 0

(19)

Co := solve(PPP, {a[0], a[1], k[1], n[1]})

{a[0] = a[0], a[1] = a[1], k[1] = k[1], n[1] = -k[1]^3}, {a[0] = a[0], a[1] = a[1], k[1] = 0, n[1] = n[1]}, {a[0] = a[0], a[1] = 0, k[1] = k[1], n[1] = n[1]}, {a[0] = 0, a[1] = a[1], k[1] = k[1], n[1] = n[1]}

(20)

case1 := Co[1]

{a[0] = a[0], a[1] = a[1], k[1] = k[1], n[1] = -k[1]^3}

(21)

F := subs(case1, S)

f(x, t) = a[0]+a[1]*exp(-t*k[1]^3+x*k[1])

(22)

F1 := eval(Y, F)

u(x, t) = 2*a[1]*k[1]^2*exp(-t*k[1]^3+x*k[1])/(a[0]+a[1]*exp(-t*k[1]^3+x*k[1]))-2*a[1]^2*k[1]^2*(exp(-t*k[1]^3+x*k[1]))^2/(a[0]+a[1]*exp(-t*k[1]^3+x*k[1]))^2

(23)

pdetest(F1, pde)

0

(24)

N = 2

N = 2

(25)

S2 := f(x, t) = a[0]+a[1]*exp(t*n[1]+x*k[1])+a[2]*exp(t*n[2]+x*k[2])+a[3]*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])

f(x, t) = a[0]+a[1]*exp(t*n[1]+x*k[1])+a[2]*exp(t*n[2]+x*k[2])+a[3]*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])

(26)

eq5 := normal(eval(pde2, S2))

exp(t*n[1]+x*k[1])*a[0]*a[1]*k[1]^4-4*exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[1]^3*k[2]+6*exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[1]^2*k[2]^2-4*exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[1]*k[2]^3+exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[1]*n[1]-exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[1]*n[2]-exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[2]*n[1]+exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[2]*n[2]+exp(t*n[1]+x*k[1])*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[1]*a[3]*k[2]*n[2]+exp(t*n[2]+x*k[2])*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[2]*a[3]*k[1]*n[1]+exp(t*n[1]+x*k[1])*a[0]*a[1]*k[1]*n[1]+exp(t*n[2]+x*k[2])*a[0]*a[2]*k[2]^4+exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[1]^4+exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[2]^4+exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[1]^4+exp(t*n[1]+x*k[1])*exp(t*n[2]+x*k[2])*a[1]*a[2]*k[2]^4+exp(t*n[1]+x*k[1])*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[1]*a[3]*k[2]^4+exp(t*n[2]+x*k[2])*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[2]*a[3]*k[1]^4+4*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[1]^3*k[2]+6*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[1]^2*k[2]^2+4*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[1]*k[2]^3+exp(t*n[2]+x*k[2])*a[0]*a[2]*k[2]*n[2]+exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[1]*n[1]+exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[1]*n[2]+exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[2]*n[1]+exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])*a[0]*a[3]*k[2]*n[2] = 0

(27)

indets(eq5)

{t, x, a[0], a[1], a[2], a[3], k[1], k[2], n[1], n[2], exp(t*n[1]+x*k[1]), exp(t*n[2]+x*k[2]), exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])}

(28)

eq6 := eval(eq5, {t*n[1]+x*k[1] = X, t*n[2]+x*k[2] = Y}); indets(eq6)

Error, invalid input: exp expects its 1st argument, x, to be of type algebraic, but received u(x,t) = 2*diff(diff(f(x,t),x),x)/f(x,t)-2*diff(f(x,t),x)^2/f(x,t)^2

 

{eq6}

(29)

``

NULL

NULL

NULL

NULL

S3 := f(x, t) = a[0]+sum(exp(t*n[i]+x*k[i]), i = 1 .. 3)+a[1]*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])+a[2]*exp(t*n[1]+t*n[3]+x*k[1]+x*k[3])+a[3]*exp(t*n[2]+t*n[3]+x*k[2]+x*k[3])+a[4]*exp(t*n[1]+t*n[2]+t*n[3]+x*k[1]+x*k[2]+x*k[3])

f(x, t) = a[0]+exp(t*n[1]+x*k[1])+exp(t*n[2]+x*k[2])+exp(t*n[3]+x*k[3])+a[1]*exp(t*n[1]+t*n[2]+x*k[1]+x*k[2])+a[2]*exp(t*n[1]+t*n[3]+x*k[1]+x*k[3])+a[3]*exp(t*n[2]+t*n[3]+x*k[2]+x*k[3])+a[4]*exp(t*n[1]+t*n[2]+t*n[3]+x*k[1]+x*k[2]+x*k[3])

(30)

NULL

NULL

eq5 := normal(eval(pde2, S3))

 

``

Download N-soliton.mw

I want to calculate Hodge Star of forms on a solvable Lie algebra L, I have defined a metric tensor g on it. But when I use that g to compute the Hodge Star of an operator it tells me that the g is not a metric tensor.

with(DifferentialGeometry);
with(LieAlgebras);
A := Matrix(4, 4, [[A__11, A__12, A__13, A__14], [A__21, -A__11, A__23, A__24], [-A__24, -A__23, -A__11, A__21], [-A__14, -A__13, A__12, A__11]]);
x := [x__1, x__2, x__3, x__4, x__5, x__6];
StructureEquations := [[x[6], x[1]] = a*x[1], [x[6], x[2]] = add(A[1, i]*x[i + 1], i = 1 .. 4), [x[6], x[3]] = add(A[2, i]*x[i + 1], i = 1 .. 4), [x[6], x[4]] = add(A[3, i]*x[i + 1], i = 1 .. 4), [x[6], x[5]] = add(A[4, i]*x[i + 1], i = 1 .. 4)];
L := LieAlgebraData(StructureEquations, [x[1], x[2], x[3], x[4], x[5], x[6]], Alg1);
DGsetup(L);
with(Tensor);
e := [e1, e2, e3, e4, e5, e6];
theta := [theta1, theta2, theta3, theta4, theta5, theta6];
omega := evalDG(add(theta[i] &wedge theta[7 - i], i = 1 .. 3));
g := evalDG(add(theta[i] &t theta[7 - i], i = 1 .. 3));
HodgeStar(g, theta1)

It is showing the following error,

Error, (in DifferentialGeometry:-Tensor:-HodgeStar) expected 1st argument to be a metric tensor. Received: _DG([["tensor", Alg1, [["cov_bas", "cov_bas"], []]], [`...`]])

How can I correct this? If not is there an alternative of doing what I am trying to do?

I am trying to find the phase portraits of a dynamical system; couples ODE system but it appears in singular form. How can we remove the singularity of coupled ODE system in P and W depending on \xi, where \alpha is scalar and v is velocity.

How remove quadratic singularity to make this system Hamiltonian in below coupled ODE system in P & W.

 singular_system.mw

restart

with(PDEtools):

alias(P = P(xi), W = W(xi))

P, W

(1)

rf1 := diff(P, xi) = W

diff(P, xi) = W

(2)

rf2 := diff(W, xi) = (P-(alpha^2+1)*P*W^2)/(v+(1/2*(alpha^2+1))*P^2)

diff(W, xi) = (P-(alpha^2+1)*P*W^2)/(v+(1/2)*(alpha^2+1)*P^2)

(3)
 

 

Download singular_system.mw

I am trying to look at source code of one Maple application to learn it. The application is old and uses  .lib and .ind files and not the new .mla files to store the code.

When I use the command march('list',path_to_lib), it shows the .m files there OK.

Next, when I use the command march('extractfile',path_to_lib,member_name.m,file_name_to_extract_to.m)

And then look at file_name_to_extract_to.m created in text editor, it is a binary and not plain text.

But when I do print(member_name),  in the worksheet, Maple prints the source code on the screen OK.

Below is worksheet to show this. All what you need to run this is download the zip file to your C:/TMP/ folder (or any other folder of your choice). 

https://www.maplesoft.com/applications/download.aspx?id=123874/an_extension_of_prelle-singer_method_and_maple_implementatio.zip

When you unzip the above file, you will see maple.lib, maple.ind, and maple.hdb files.  

I changed the names to PS.lib, PS.ind and PS.hdb (not to conflict with any maple own files).

So my C:/TMP/ folder now have these 3 files PS.lib, PS.ind and PS.hdb in it. 

Then I opened worksheet and did the following

restart;

libname := "C:/TMP",libname;

"C:/TMP", "C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib", "C:\Program Files\Maple 2024\lib"

march('list',"C:/TMP/PS.lib");

[["PSsolve.m", [2001, 11, 22, 12, 23, 49], 15008, 59], ["PSIntFac.m", [2001, 11, 22, 12, 23, 50], 15067, 517], ["polygen.m", [2001, 11, 22, 12, 23, 55], 16722, 433], ["Signature.m", [2001, 11, 22, 12, 23, 56], 17155, 404], ["dPSBasis.m", [2001, 11, 22, 12, 23, 51], 16267, 55], ["powerN.m", [2001, 11, 22, 12, 24, 19], 18866, 200], ["PS.m", [2001, 11, 22, 12, 6, 33], 1, 15007], ["Darboux.m", [2001, 11, 22, 12, 23, 50], 15584, 269], ["PSDop.m", [2001, 11, 22, 12, 23, 52], 16322, 335], ["typos.m", [2001, 11, 22, 12, 23, 57], 17559, 749], ["EigenPval.m", [2001, 11, 22, 12, 23, 51], 15853, 273], ["PSBasis.m", [2001, 11, 22, 12, 23, 51], 16126, 141], ["nothas.m", [2001, 11, 22, 12, 23, 55], 16657, 65], ["unknownfunc.m", [2001, 11, 22, 12, 24, 16], 18308, 464], ["int.m", [2001, 11, 22, 12, 24, 18], 18772, 94]]

march('extractfile',"C:/TMP/PS.lib","PSIntFac.m","C:/TMP/PSIntFac.m")

interface(verboseproc=3);

1

print(PSIntFac)

proc (ode, n) local base, intfac, subs_Us_by_func, x, y, M, N, eq; n; base := PS(args, PSBasis); subs_Us_by_func := map(proc (u) options operator, arrow; rhs(u) = lhs(u) end proc, base); intfac := [PS(args, PSIntFac)]; if intfac = [`We could not find an integrating factor.`] then RETURN(`We could not find an integrating factor.`) end if; x := intfac[2]; y := intfac[3]; M := subs(subs_Us_by_func, intfac[4]); N := subs(subs_Us_by_func, intfac[5]); eq := diff(y(x), x) = subs(y = y(x), M/N); print(`For the FOODE in the form`); print(eq); print(`the integrating factor will be`); intfac := normal(subs(subs_Us_by_func, intfac[1])) end proc

 

 

Download why_extract_not_working.mw

Now when opening the extracted file PSIntFac.m it shows this (in the folder C:/TMP/)

M7R0
I)PSIntFacf*6$%$odeG%"nG6*%%baseG%'intfacG%0subs_Us_by_funcG%"xG%"yG%"MG%"NG%#e
qG6"F0C09%>8$-%#PSG6$9"%(PSBasisG>8&-%$mapG6$f*6#%"uGF06$%)operatorG%&arrowGF0/
-%$rhsG6#9$-%$lhsGFHF0F0F0F4>8%7#-F66$F8F"@$/FM7#%IWe~could~not~find~an~integra
ting~factor.G-%'RETURNG6#FT>8'&FM6#""#>8(&FM6#""$>8)-%%subsG6$F;&FM6#""%>8*-F_o
6$F;&FM6#""&>8+/-%%diffG6$-Fhn6#FYFY-F_o6$/FhnFap*&F]o"""Feo!""-%&printG6#%:For
~the~FOODE~in~the~formG-Fjp6#F\p-Fjp6#%?the~integrating~factor~will~beG>FM-%'no
rmalG6#-F_o6$F;&FM6#FgpF0F0F0F0

It seems Maple kepts the .m file in binary form.   Is it not supposed to convert it to plain text readable form, as the one which shows when using the command print() on the screen?  

Is there another march command to extract the .m files in plain text form? I looked at help of march, but see nothing so far.

If this is how march extractfile is supposed to work, then is there another way to extract in plain text?

Is there any function that returns a boolean value that tells me if a point is within a polygon or not?

I tried to contact an author using the menu item more->contact autor.

I got the following back from postmaster@maplesoft.com

The IP-adress 199.71.183.16 (domain maplesoft.com) does not match the IP-adress of my mailprovider.

The authentification of the mailprovider works when I send directly from this mailprovider to gmail accounts.

Is this a known issue when sending via maplesoft.com or only temporary?

Is gmail too restrictive?

There seems to be parsing problem with ODESteps. This input diff(y(x),x)=x^2*sqrt(y(x)) -  y(x) gives invalid input error, but diff(y(x),x)=x^2*sqrt(y(x)) does not.  

Everything else the same.

Worksheet below. 

restart;

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 1841 and is the same as the version installed in this computer, created 2025, January 3, 8:59 hours Pacific Time.`

ode:=diff(y(x),x)=x^2*sqrt(y(x)) -  y(x);
IC:=y(0)=1;
Student:-ODEs:-ODESteps([ode,IC]);

diff(y(x), x) = x^2*y(x)^(1/2)-y(x)

y(0) = 1

Error, (in Student:-ODEs:-Test) invalid input

ode:=diff(y(x),x)=x^2*sqrt(y(x)) ;
IC:=y(0)=1;
Student:-ODEs:-ODESteps([ode,IC])

ode := diff(y(x), x) = x^2*sqrt(y(x))

IC := y(0) = 1

"[[,,"Let's solve"],[,,[(ⅆ)/(ⅆx) y(x)=x^2 sqrt(y(x)),y(0)=1]],["•",,"Highest derivative means the order of the ODE is" 1],[,,(ⅆ)/(ⅆx) y(x)],["•",,"Solve for the highest derivative"],[,,(ⅆ)/(ⅆx) y(x)=x^2 sqrt(y(x))],["•",,"Separate variables"],[,,((ⅆ)/(ⅆx) y(x))/(sqrt(y(x)))=x^2],["•",,"Integrate both sides with respect to" x],[,,∫((ⅆ)/(ⅆx) y(x))/(sqrt(y(x))) ⅆx=∫x^2 ⅆx+`c__1`],["•",,"Evaluate integral"],[,,2 sqrt(y(x))=(x^3)/3+`c__1`],["•",,"Solve for" y(x)],[,,y(x)=1/36 x^6+1/6 x^3 `c__1`+1/4 `c__1`^2],["•",,"Simplify"],[,,y(x)=((x^3+3 `c__1`)^2)/36],["•",,"Redefine the integration constant(s)"],[,,y(x)=((x^3+`c__1`)^2)/36],["•",,"Use initial condition" y(0)=1],[,,1=(`c__1`^2)/36],["•",,"Solve for" `c__1`],[,,{`c__1`=-6,`c__1`=6}],["•",,"Remove solutions that don't satisfy the ODE"],[,,`∅`],["•",,"Solution does not satisfy initial condition"]]"

 


 

Download ode_steps_parsing_problem_jan_17_2025.mw

I need assistance with building the homotopy analysis method to solve the system of odes. here is the attempt to do it. I'm still new to maple restart; # Declare functions for the system PDEtools[declare]([f(x), g(x)], prime = x): # Order of expansion N := 4; # Define series for each function f1(x) := sum(p^i*f[i](x), i = 0..N): f2(x) := sum(p^i*g[i](x), i = 0..N): # Define the system of ODEs using Homotopy HPMEq1 := (1-p)*(diff(f1(x), x$3)) + p*(diff(f1(x), x) + f2(x)): HPMEq2 := (1-p)*(diff(f2(x), x$3)) + p*(diff(f2(x), x) - f1(x)): # Extract coefficients for the system for i from 0 to N do equl[1][i] := coeff(HPMEq1, p, i) = 0: equl[2][i] := coeff(HPMEq2, p, i) = 0: end do: # Define boundary conditions for the system cond= 0, D(f1[0])(5) = 1]: cond = 0, D(f2[0])(0) 1]: for j from 1 to N do cond = 0, D(f1[j])(0) = 0, D(f1[j])(5) , D(f2[j])(0) = 0, D(f2[j])(5) = 0]: end do: # Solve the system iteratively for each order for k from 0 to N do dsolve([equl[1][k], cond[1][k]], f1[k](x)): dsolve([equl[2][k], cond[2][k]], f2[k](x)): end do:

i try to get same result by substituation but i don't know what is mistake after i take second derivative is wronge i don't know how get same result as in paper did can anyone help  to calculate this part is not hard but is complicated ,How calculated second derivative and put in our ode to get the parameters?

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)

"          with(Student[ODEs][Solve]):"

_local(gamma)

declare(Omega(x, y, t)); declare(U(xi)); declare(u(x, y, t)); declare(Q(xi)); declare(V(xi)); declare(W(xi)); declare(f(xi))

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

 

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

 

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

 

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

 

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

 

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

 

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

(2)

NULL

ode := -delta*(diff(diff(U(xi), xi), xi))+U(xi)*(w^2-gamma*U(xi)-beta-alpha) = 0

-delta*(diff(diff(U(xi), xi), xi))+U(xi)*(w^2-gamma*U(xi)-beta-alpha) = 0

(3)

ode1 := -delta*(diff(diff(f(xi), xi), xi))+f(xi)*(w^2-gamma*f(xi)-beta-alpha) = 0

-delta*(diff(diff(f(xi), xi), xi))+f(xi)*(w^2-gamma*f(xi)-beta-alpha) = 0

(4)

F := U(xi) = sum(tanh(xi)^(i-1)*(B[i]*sech(xi)+A[i]*tanh(xi)), i = 1 .. n)+A[0]

U(xi) = sum(tanh(xi)^(i-1)*(B[i]*sech(xi)+A[i]*tanh(xi)), i = 1 .. n)+A[0]

(5)

S := U(f(xi)) = sum(cos(f(xi))^(i-1)*(B[i]*sin(f(xi))+A[i]*cos(f(xi))), i = 1 .. n)+A[0]

U(f(xi)) = sum(cos(f(xi))^(i-1)*(B[i]*sin(f(xi))+A[i]*cos(f(xi))), i = 1 .. n)+A[0]

(6)

``

n := 2

2

(7)

eval(ode1, S)

-delta*(diff(diff(f(xi), xi), xi))+f(xi)*(w^2-gamma*f(xi)-beta-alpha) = 0

(8)

Download complex-issue.mw

Maple dsolve hangs (mserver.exe runs with high CPU for long time, had to stop it). 

This question is, why does it hang? As this can indicate internal logic bug.

This question is not why Maple can't solve this ode (taken from old textbook) as not solving an ode is not a bug (even though it should, as Maple is very good in solving ode's) but hanging is a bug.

infolvel shows it hangs when it reaches

<- Abel successful
         equivalence to an Abel ODE successful, Abel ODE has been solved

And stops here. 

Here is worksheet, showing the attempts made, and verifying book solution is correct using Maple with change of variable.

Make sure to save all your work before trying this just to be safe.

restart;

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 1841 and is the same as the version installed in this computer, created 2025, January 3, 8:59 hours Pacific Time.`

original_ode :=(diff(y(x),x)*x-y(x))*(x-diff(y(x),x)*y(x))=2*diff(y(x),x);

((diff(y(x), x))*x-y(x))*(x-(diff(y(x), x))*y(x)) = 2*(diff(y(x), x))

#infolevel[dsolve]:=5;
dsolve(original_ode); #hangs

restart;

original_ode :=(diff(y(x),x)*x-y(x))*(x-diff(y(x),x)*y(x))=2*diff(y(x),x);
dsolve(original_ode,'implicit'); #hangs

restart;  #ONE SOLUTION IS:

original_ode:=(diff(y(x),x)*x-y(x))*(x-diff(y(x),x)*y(x))=2*diff(y(x),x);
book_sol:=y(x)=sqrt(x^2*c__1+2*c__1/(c__1-1));
odetest(book_sol,original_ode)

((diff(y(x), x))*x-y(x))*(x-(diff(y(x), x))*y(x)) = 2*(diff(y(x), x))

y(x) = (x^2*c__1+2*c__1/(c__1-1))^(1/2)

0

workaround to solve, by change of variables

 

restart;

original_ode :=(diff(y(x),x)*x-y(x))*(x-diff(y(x),x)*y(x))=2*diff(y(x),x);
ode2:=PDEtools:-dchange({x=sqrt(u),y(x)=sqrt(v(u))},original_ode,[v(u),u]):
sol:=dsolve(ode2):
sol:=map(X->eval(X,[v(u)=y(x)^2,u=x^2]),[sol]);
map(X->odetest(X,original_ode),sol)

((diff(y(x), x))*x-y(x))*(x-(diff(y(x), x))*y(x)) = 2*(diff(y(x), x))

[y(x)^2 = x^2+2-2*2^(1/2)*(x^2)^(1/2), y(x)^2 = x^2+2+2*2^(1/2)*(x^2)^(1/2), y(x)^2 = c__1*x^2+2*c__1/(c__1-1)]

[0, 0, 0]

 


 

Download why_dsolve_hangs_jan_17_2025.mw

 

The maple worksheet shows an incorrect evaluation of the integral in (1) which is a standard integral representation of a Bessel function.  Equations (2)-(5) along with the graph show the incorrectness of the evaluation.  What is going on?

Bessel.mw

Found this old procedure code and revived it
Trying to include an Exploreplot as well
a0,a1,a2,b1,b2 are coeifficents in a ode to construct 
How about odetype when constructing a ode is this correct in code?


 

restart;

Odegenerator := proc(V, x, y, df, const_values)
    local input_args, xi, F, result, a0, a1, a2, b0, b1, sol, Fsol, rows, numrows, eq, count, odeplot_cmd, ode_type, row_number, values;
    uses plots, PDEtools;
       if nargs = 1 and V = "help" then
        printf("Use this procedure as follows:\n");
        printf("Define an ODE template:\n");
        printf("Odegenerator(V, x, y, df, const_values)\n");
        printf("V: A set of values for iteration over constants (if df > 0)\n");
        printf("x: The independent variable\n");
        printf("y: The function\n");
        printf("df: The row number in the DataFrame or 0 for manual input\n");
        printf("const_values: A list of values for the constants (used if df = 0)\n");
        return;
    end if;

    if nargs < 4 or nargs > 5 then
        error "Incorrect number of arguments. Expected: V, x, y, df, [const_values (optional)]";
    end if;

    # Determine the ODE type using odeadvisor for the global eq_template
    ode_type := odeadvisor(eq_template);

    # Display the ODE and its type
    print(eq_template, ode_type);

    rows := [];
    count := 0;
    ###################### BOF manuele invoer ###################
    if df = 0 then
    # If df = 0, use const_values for substitution
    if nargs < 5 or not type(const_values, list) then
        error "When df = 0, a list of constant values must be provided as the fifth argument.";
    end if;

    # Assign constant values
    if nops(const_values) <> 5 then
        error "The list of constant values must contain exactly 5 elements.";
    end if;

    # Find the corresponding row number by unique identification
    count := 1;
    for a0 in V do
        for a1 in V do
            for a2 in V do
                for b0 in V do
                    for b1 in V do
                        if [a0, a1, a2, b0, b1] = const_values then
                            row_number := sprintf("%d", count);  # Convert to string
                        end if;
                        count := count + 1;
                    end do;
                end do;
            end do;
        end do;
    end do;

    if not assigned(row_number) then
        row_number := "Unique (outside iterative rows)";  # Mark as unique
    end if;

    # Substitute the given values
    eq := subs({'a__0' = const_values[1], 'a__1' = const_values[2], 'a__2' = const_values[3], 'b__0' = const_values[4], 'b__1' = const_values[5]}, eq_template);

    # Solve the equation
    sol := dsolve(eq, y(x));
    if type(sol, `=`) then
        Fsol := rhs(sol);
    else
        Fsol := "No explicit solution";
    end if;

    # Display the solution and its row number
    odeplot_cmd := DEtools[DEplot](eq, y(x), x = 0 .. 2, y = -10 .. 10, [[y(0) = 1]]);
    print(plots:-display(odeplot_cmd, size = [550, 550]));

    printf("The found function is:\n");
    print(Fsol);
    printf("The corresponding row number is: %s\n", row_number);

    # -- Start of Additional Functionality --
    # Optionally display the simplified ODE
    printf("The simplified ODE using the given coefficients is:\n");
    print(eq, ode_type);
    # -- End of Additional Functionality --

    return Fsol;
     ################# EOF manuele berekening ##################
     ############## BOF iterative berekening##############
    else
        # Iterative approach for DataFrame generation
        for a0 in V do
            for a1 in V do
                for a2 in V do
                    for b0 in V do
                        for b1 in V do
                            xi := x;
                            F := y;

                            # Substitute constant values into the ODE
                            eq := subs({'a__0' = a0, 'a__1' = a1, 'a__2' = a2, 'b__0' = b0, 'b__1' = b1}, eq_template);

                            sol := dsolve(eq, F(xi));
                            if type(sol, `=`) then
                                Fsol := rhs(sol);
                            else
                                Fsol := "No explicit solution";
                            end if;

                            rows := [op(rows), [a0, a1, a2, b0, b1, Fsol]];
                        end do;
                    end do;
                end do;
            end do;
        end do;

        numrows := nops(rows);
        result := DataFrame(Matrix(numrows, 6, rows), columns = ['a__0', 'a__1', 'a__2', 'b__0', 'b__1', y(x)]);

        interface(rtablesize = numrows + 10);

        if df > 0 and df <= numrows then
            a0 := result[df, 'a__0'];
            a1 := result[df, 'a__1'];
            a2 := result[df, 'a__2'];
            b0 := result[df, 'b__0'];
            b1 := result[df, 'b__1'];

            eq := subs({'a__0' = a0, 'a__1' = a1, 'a__2' = a2, 'b__0' = b0, 'b__1' = b1}, eq_template);

            # Display the additional parameters
            print(eq, ode_type, [df], [a0, a1, a2, b0, b1]);

            # Retrieve the solution
            Fsol := result[df, y(x)];

            # Display the solution in DEplot
            odeplot_cmd := DEtools[DEplot](eq, y(x), x = 0 .. 2, y = -10 .. 10, [[y(0) = 1]]);
            print(plots:-display(odeplot_cmd, size = [550, 550]));

            printf("The found function for row number %d is:\n", df);
            print(Fsol);

        else
            printf("The specified row (%d) is out of bounds for the DataFrame.\n", df);
        end if;

        return result;
     ########## EOF iteratief bwrekening ########################
    end if;

end proc:


# Test cases
V := {0, 1};
eq_template := diff(y(t), t) = 'a__0'*sin(t) + 'a__1'*y(t) + 'a__2'*y(t)^2 + 'b__0'*exp(-t);



 

{0, 1}

 

diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t)

(1)

 

 

# Iterative test
result := Odegenerator(V, t, y, 25);

diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t))

 

diff(y(t), t) = sin(t)+y(t), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t)), [25], [1, 1, 0, 0, 0]

 

 

The found function for row number 25 is:

 

-(1/2)*cos(t)-(1/2)*sin(t)+c__1*exp(t)

 

module DataFrame () description "two-dimensional rich data container"; local columns, rows, data, binder; option object(BaseDataObject); end module

(2)

 

# Manual input test
Odegenerator(V, t, y, 0, [1, 1, 0, 0, 0]); #0 after y is rownumber = 0 and [1, 1, 0, 0, 0] are coeifficents

diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t))

 

 

The found function is:

 

-(1/2)*cos(t)-(1/2)*sin(t)+c__1*exp(t)

 

The corresponding row number is: 25
The simplified ODE using the given coefficients is:

 

diff(y(t), t) = sin(t)+y(t), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t))

 

-(1/2)*cos(t)-(1/2)*sin(t)+c__1*exp(t)

(3)
 

 

 


Download ODEGENERATORFUNCTIE_opgepakt-uitgebreid_naar_MprimesDEF_14-1-2025.mw

This is a very serious problem. Maple 2024.2 on windows 10.

I noticed, may be starting 2-3 weeks now, that sometimes when I do File->Open , and the Open dialogue opens, I am not able to use the mouse to select the .mw file I want to open. 

Can not even close the dialogue by clicking X. Even clickiing on cancel does nothing.  Basically the mouse seems not doing anything.

Only way is to type using the keyboard the file name. Eveything else does not work.

Not only that, the mouse is trapped in the dialogue.

I can't even get it out of Maple to go to another application. AT first, I had to do CTRL-ALT-DEL to get out and use the task manager to kill Maple. Then later I found if I type the file name I can get out.

Here is a movie.  

I do not understand what is causing this. This only happens in Maple for me. Neven seen anything like this before.

Any suggestions what to look for?

I just remembered. 2-3 weeks ago, I closed the left panel. As you see above.

I just tried now, and expanded it again, and guess what, the mouse seems to be working now!

Can someone conform this?  Here is a movie with the panel expanded again:

You see, the mouse now works and can select files.

When I minimize the left panel, the mouse sometimes stops working in file dialogue.

Here is another movie showing this problem much more clearly.

When closing the left panel, the open file dialogue stops working (mouse not working), and when expanding it again, it starts to work!

This can not be a feature right? it must be a bug in the Java interface?

every thing is correct but i dont know why my PDE is not be zero, i did by another way is satidy but i change whole equation by sabstitutiin then i did ode test is satisfy by putting case in equation and solution with condition but when i want to use pdetest  test in pde is not satisfy ?

restart

_local(gamma)

with(PDEtools)

NULL

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)); declare(V(xi)); declare(Theta(x, t))

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

 

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

 

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

 

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

(2)

xi := -t*tau+x

-t*tau+x

(3)

NULL

NULL

lambda := -tau/c; epsilon := -tau/c; delta := (2*c^2-gamma*tau)/(gamma-2*tau)

-tau/c

 

-tau/c

 

(2*c^2-gamma*tau)/(gamma-2*tau)

(4)

NULL

case1 := [c = RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)/gamma, A[0] = 0, A[1] = RootOf(_Z^2*gamma+2*tau), B[1] = 0]

[c = RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)/gamma, A[0] = 0, A[1] = RootOf(_Z^2*gamma+2*tau), B[1] = 0]

(5)

K := Omega(x, t) = RootOf(_Z^2*gamma+2*tau)*tanh(xi)*exp(I*gamma*(delta*t+x))

Omega(x, t) = -RootOf(_Z^2*gamma+2*tau)*tanh(t*tau-x)*exp(I*gamma*((2*c^2-gamma*tau)*t/(gamma-2*tau)+x))

(6)

NULL

pde1 := I*(diff(Omega(x, t), `$`(t, 2))-c^2*(diff(Omega(x, t), `$`(x, 2))))+diff(U(-t*tau+x)^2*Omega(x, t), t)-lambda*c*(diff(U(-t*tau+x)^2*Omega(x, t), x))+(1/2)*(diff(Omega(x, t), `$`(x, 2), t))-(1/2)*epsilon*c*(diff(Omega(x, t), `$`(x, 3))) = 0

I*(diff(diff(Omega(x, t), t), t)-c^2*(diff(diff(Omega(x, t), x), x)))-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0

(7)

NULL

subs(case1, pde1)

I*(diff(diff(Omega(x, t), t), t)-RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)^2*(diff(diff(Omega(x, t), x), x))/gamma^2)-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0

(8)

T := simplify(I*(diff(diff(Omega(x, t), t), t)-RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)^2*(diff(diff(Omega(x, t), x), x))/gamma^2)-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0)

(1/2)*(2*gamma^2*(tau*(diff(Omega(x, t), x))+diff(Omega(x, t), t))*U(-t*tau+x)^2+(diff(diff(diff(Omega(x, t), t), x), x))*gamma^2+tau*(diff(diff(diff(Omega(x, t), x), x), x))*gamma^2-(4*I)*((1/4)*gamma^3+tau-(1/2)*gamma)*tau*(diff(diff(Omega(x, t), x), x))+(2*I)*(diff(diff(Omega(x, t), t), t))*gamma^2)/gamma^2 = 0

(9)

pdetest(K, T)

-(1/2)*2^(1/2)*(-tau/gamma)^(1/2)*(-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau)))/(gamma^2*(gamma-2*tau)^2*(exp(2*t*tau)+exp(2*x))^3)

(10)

simplify(-(1/2)*2^(1/2)*(-tau/gamma)^(1/2)*((8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau)))/(gamma^2*(gamma-2*tau)^2*(exp(2*tau*t)+exp(2*x))^3))

-(-tau/gamma)^(1/2)*((I*gamma^3*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2-((1/8)*I)*tau*gamma^7+(((1/4)*I)*c^2+((1/2)*I)*tau^2-tau)*gamma^6+(4*tau^2+(-((3/2)*I)*c^2-(3/4)*I)*tau+2*c^2)*gamma^5+(-4*tau^3+((5/2)*I)*tau^2+(-8*c^2+2)*tau+I*(c^2+2)*c^2)*gamma^4-4*(((5/4)*I)*tau^2+(-2*c^2+3)*tau+I*c^2-(1/2)*I)*tau*gamma^3+6*(I*tau^2-2*I+4*tau)*tau^2*gamma^2+((24*I)*tau^3-16*tau^4)*gamma-(16*I)*tau^4)*exp((I*(t*tau-x)*gamma^2+2*((I*x-t)*tau-I*c^2*t-2*x)*gamma+4*t*tau^2+8*x*tau)/(-gamma+2*tau))+(-I*gamma^3*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2+((1/8)*I)*tau*gamma^7+(-((1/4)*I)*c^2-((1/2)*I)*tau^2-tau)*gamma^6+(4*tau^2+(((3/2)*I)*c^2+(3/4)*I)*tau+2*c^2)*gamma^5+(-4*tau^3-((5/2)*I)*tau^2+(-8*c^2+2)*tau-I*(c^2+2)*c^2)*gamma^4+4*(((5/4)*I)*tau^2+tau*(2*c^2-3)+I*c^2-(1/2)*I)*tau*gamma^3-6*(I*tau^2-2*I-4*tau)*tau^2*gamma^2+(-(24*I)*tau^3-16*tau^4)*gamma+(16*I)*tau^4)*exp((I*(t*tau-x)*gamma^2+2*((I*x-2*t)*tau-I*c^2*t-x)*gamma+8*t*tau^2+4*x*tau)/(-gamma+2*tau))+I*gamma^2*(exp((I*(t*tau-x)*gamma^2+2*(-I*c^2*t+I*x*tau-3*x)*gamma+12*x*tau)/(-gamma+2*tau))-exp((I*(t*tau-x)*gamma^2+2*((I*x-3*t)*tau-I*c^2*t)*gamma+12*t*tau^2)/(-gamma+2*tau)))*(gamma*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2-(1/8)*tau*gamma^5+((1/4)*c^2+(1/2)*tau^2)*gamma^4+tau*(-(3/2)*c^2+1/4)*gamma^3+(c^4-(3/2)*tau^2)*gamma^2+3*tau^3*gamma-2*tau^4))*2^(1/2)/(gamma^2*(exp(2*t*tau)+exp(2*x))^3*(-(1/2)*gamma+tau)^2)

(11)
 

 

Download pdetest.mw

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