Rouben Rostamian

MaplePrimes Activity


These are answers submitted by Rouben Rostamian

Ronan gave a link to my post from almost two years ago where I illustrated the use of quaternions in tracking rotations in space.  That motivated me to clean up the code a bit and then apply it to the phenomenon of the flipping T-handle which is the subject of the current thread.  The code, which combines Euler's equations of motion and quaternions, is sufficiently commented to let you adapt it to other situations.

Here is the worksheet T-handle-flip.mw and here is the resulting animation:

 

@ecterrab You are correct in stating that this problem has "no solution".  To be precise, this problem has no classical solution.

A great deal of effort was devoted throughout the 20th century to make sense of exactly such boundary value problems which arise in just about every application, especially in physics.  The concept of generalized derivatives and weak solutions were introduced precisely for that purpose.  If we dismiss weak solutions, we will be throwing away most of the useful applications of the PDEs.

Consider, for instance, a slender (one-dimensional) bar currently at a uniform temperature of 100 degrees.  We bring one end of it in contact with an ice cube.  We want to determine how the bar's temperature evolves in subsequent times.

The temperature, u(x,t), satisfies the PDE u_t = u_xx, where subscripts denote differentiation.  The initial condition is u(x,0)=100.  The boundary condition is u(0,t)=0.  Certainly these two conditions are incompatible but we don't want throw up our hands and say that this problem is not solvable.  True, no classical solution exists, but a weak solution does, and that's what's relevant to this question.

Mathematica's solution that was posted earlier (and is now deleted) expresses the solution of the PDE in the Fourier series.  The Fourier series solution picks up the weak solution, therefore that solution was correct in the sense that it produced the expected weak solution to the problem.  In the worksheet below I show how to reproduce Mathematica's solution with Maple's pdsolve().  The process hits a few snags but eventually we arrive at the desired solution.

P.S.: To be clear, I am not here to berate the terrific job that you have done (and continue doing) with extending Maple's capabilities in many directions.  All I want to point out is that the Fourier series picks up the weak solution, and that it should not be dismissed.

[Worksheet produced in Maple 2018.1]

restart;

pde := diff(u(x,y),x,x) + diff(u(x,y),y,y) = 0;

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

bc := u(0,y)=0, u(Pi,y)=sinh(Pi)*cos(y), u(x,0)=sin(x), u(x,Pi)=-sinh(x);

u(0, y) = 0, u(Pi, y) = sinh(Pi)*cos(y), u(x, 0) = sin(x), u(x, Pi) = -sinh(x)

result := pdsolve({pde,bc});

Snag #1: pdsolve() returns empty.  I follow Robert Lopez's lead and split up

the problem into four problems, then use superposition:

bc1 := u(0,y)=0,  u(Pi,y)=0,  u(x,0)=0,  u(x,Pi)=0;

u(0, y) = 0, u(Pi, y) = 0, u(x, 0) = 0, u(x, Pi) = 0

bc2 := u(0,y)=0,  u(Pi,y)=sinh(Pi)*cos(y),  u(x,0)=0,  u(x,Pi)=0;

u(0, y) = 0, u(Pi, y) = sinh(Pi)*cos(y), u(x, 0) = 0, u(x, Pi) = 0

bc3 := u(0,y)=0,  u(Pi,y)=0,  u(x,0)=sin(x),  u(x,Pi)=0;

u(0, y) = 0, u(Pi, y) = 0, u(x, 0) = sin(x), u(x, Pi) = 0

bc4 := u(0,y)=0,  u(Pi,y)=0,  u(x,0)=0,  u(x,Pi)=-sinh(x);

u(0, y) = 0, u(Pi, y) = 0, u(x, 0) = 0, u(x, Pi) = -sinh(x)

Attempt to solve the problem with bc1:

sol1 := pdsolve({pde,bc1});

Snag #2: The exact solution of {pde,bc1} is u(x,y)=0.  Maple fails to detect that.
I don't know why.  The boundary conditions are certainly compatible.


Here I intervene and set the solution myself:

sol1 := u(x,y) = 0;

u(x, y) = 0

Atempt to solve with bc2:

sol2_tmp := pdsolve({pde,bc2});

u(x, y) = Sum(2*n*sinh(Pi)*((-1)^n+1)*sin(y*n)*(exp(2*x*n)-1)*exp(n*(Pi-x))/(Pi*(exp(2*Pi*n)-1)*(n^2-1)), n = 1 .. infinity)

Snag #3: The first term (n=1) of the summation above evaluates to 0/0.

In fact, all terms with odd n should evaluate to zero.  Here we intervene and

replace n by 2*n:

applyop(eval, [2,1], sol2_tmp, n=2*n):
sol2 := simplify(%) assuming n::posint;

u(x, y) = Sum(8*n*sinh(Pi)*sin(2*y*n)*(exp(4*x*n)-1)*exp(2*n*(Pi-x))/(Pi*(exp(4*Pi*n)-1)*(4*n^2-1)), n = 1 .. infinity)

The boundary conditions bc3 and bc4 give no problem:

sol3 := pdsolve({pde,bc3});

u(x, y) = sin(x)*(exp(2*Pi-y)-exp(y))/(exp(2*Pi)-1)

sol4 := pdsolve({pde,bc4});

u(x, y) = Sum((-1)^n*n*(exp(2*Pi)-1)*sin(x*n)*(exp(2*y*n)-1)*exp((-y+Pi)*n-Pi)/(Pi*(n^2+1)*(exp(2*Pi*n)-1)), n = 1 .. infinity)

The original problem's weak solution is obtained as a superposition

of the previously solved four sub-problems.  Ideally, Maple's pdsolve()

should obtain this solution in one shot and I am confident that at some future time it will:

sol := rhs(sol1) + rhs(sol2) + rhs(sol3) + rhs(sol4);

Sum(8*n*sinh(Pi)*sin(2*y*n)*(exp(4*x*n)-1)*exp(2*n*(Pi-x))/(Pi*(exp(4*Pi*n)-1)*(4*n^2-1)), n = 1 .. infinity)+sin(x)*(exp(2*Pi-y)-exp(y))/(exp(2*Pi)-1)+Sum((-1)^n*n*(exp(2*Pi)-1)*sin(x*n)*(exp(2*y*n)-1)*exp((-y+Pi)*n-Pi)/(Pi*(n^2+1)*(exp(2*Pi*n)-1)), n = 1 .. infinity)

We truncate the series:

my_sol := eval(sol, infinity=50);

Sum(8*n*sinh(Pi)*sin(2*y*n)*(exp(4*x*n)-1)*exp(2*n*(Pi-x))/(Pi*(exp(4*Pi*n)-1)*(4*n^2-1)), n = 1 .. 50)+sin(x)*(exp(2*Pi-y)-exp(y))/(exp(2*Pi)-1)+Sum((-1)^n*n*(exp(2*Pi)-1)*sin(x*n)*(exp(2*y*n)-1)*exp((-y+Pi)*n-Pi)/(Pi*(n^2+1)*(exp(2*Pi*n)-1)), n = 1 .. 50)

and plot the result:

plot3d(my_sol, x=0..Pi, y=0..Pi,
    style=patchcontour, contours=20);

Download pde-bc.mw

I don't quite understand what you mean by "link a worksheet written in Maple 16 into WordPress" but let me try.

WordPress can display HTML code as well as images.  In Malpe's menubar select File->Print and save your worksheet as a graphics image.  On my Maple 2018 on Linux the image is saved in the PostScript format.  In your Maple 16 it may be something else, but it does not matter much.  You may convert one image into any other image format such as PNG, which then you pass on to WordPress.

 

plot([0, sin(x)], x=0..2*Pi, axes=boxed, color=[black,blue]);

 

In the Layout palette pick the entry that consists of a green "A" on top of a red "b".  Then edit to replace the "A" with "max" and the "B" with the desired subscript.  Here is what we get:

 

This works in Maple 2018.  I don't have Maple 2015 to test.

Download worksheet: mw.mw

The answer depends on what you assume about x.

Is x itself bounded?  If yes, then cos(i*x) is bounded.

Is x imaginary and unbounded?  If yes, then i*x is real, and therefore cos(i*x) is bounded because sin(i*x)^2 + cos(i*x)^2 = 1.

Is x real and unbounded? If so, then:

convert(cos(I*x), exp) assuming x::real;

shows that cos(i*x) is 1/2 exp(x) + 1/2 exp(-x), and therefore cos(i*x) is unbounded.

 

And here is an exercise for you: Suppose x is complex.  What can you tell about the boundedness of cos((i*x)?

 

From the first differential equation, that is,

"Nb*((ⅆ)^2)/((ⅆ)^( )y^2)sigma(y)+Nt*((ⅆ)^2)/((ⅆ)^( )y^2)theta(y)=0 , "
it follows that Nb*sigma(y)+Nt*theta(y) = c__1*y+c__2. Applying the
boundary conditions we see that c__1 and c__2 are zero, and herefore
Nb*sigma(y)+Nt*theta(y) = 0.
The second equation, that is
"((ⅆ)^2)/((ⅆ)^( )y^2)theta(y)+Nb*(ⅆ)/(ⅆ y)sigma(y)*(ⅆ)/(ⅆ y)theta(y)+Nt*((ⅆ)/(ⅆ y)theta(y))^(2)=0, "
may be rearranged into

"((ⅆ)^2)/((ⅆ)^( )y^2)theta(y)+(Nb*(ⅆ)/(ⅆ y)sigma(y)+Nt*(ⅆ)/(ⅆ y)theta(y))*(ⅆ)/(ⅆ y)theta(y)=0,  "
which, in view of the red equation, reduces to
diff(theta(y), y, y) = 0.
Applying the boundary conditions we get
`≡`(theta(y), 0.)
Then from the red equation we conclude that
"sigma(y)≡0.  "

The purpose of phaseportrait is to plot solutions of a system of differential equations.  There is no differential equation in what you have shown.

Suggestion: Maple's help page on phaseportrait is quite limited and not very instructive.  To its credit, it refer the reader to DEplot's help page which does what phaseportrait is supposed to do, and is much better documented.  Look up the examples in DEplot's help page and come back here if you still have questions.

The abs(t) seems to confuse Maple. The following equivalent alternative works:

restart;

with(inttrans):

h := piecewise(t < -2*Pi*n, 0, t < 2*Pi*n, cos(t), 0);

h := piecewise(t < -2*Pi*n, 0, t < 2*Pi*n, cos(t), 0)

fourier(h, t, w) assuming n::posint;

2*w*sin(2*Pi*n*w)/((w+1)*(w-1))

 

Download mw.mw

restart:

eq[1]:=diff(x[1](t), t)-2*x[1](t)*(N1*N2*N3-x[1](t)*x[3](t))/(N1*N2*N6):

eq[2]:=diff(x[2](t), t)+((1-N1*N2*N6/x[1](t))*(N1*N2*N3-x[2](t)*x[3](t))/((N1*N2+x[2](t)*(1-N1*N2*N6/x[1](t)))*N1*N2)-2*x[2](t)*(1-N1*N2*N6/x[1](t))*(N1*N2*N3-x[1](t)*x[3](t))/(x[1](t)*N1*N2*(N1*N2+x[2](t)*(1-N1*N2*N6/x[1](t)))))/((1-N1*N2*N6/x[1](t))/(x[2](t)*(N1*N2+x[2](t)*(1-N1*N2*N6/x[1](t))))-ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/x[2](t)^2):

eq[3]:=diff(x[3](t), t)-(-(-2*N1*N2*N3*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))*(N1*N2*N3-x[1](t)*x[3](t))/x[1](t)-N3*(x[3](t)*N2*N1*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/x[2](t)+N3*N2*N1*(1-N1*N2*N6/x[1](t)-N2*N1*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/x[2](t))/x[2](t))-N5*(x[3](t)^2*N2*N1*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/x[2](t)+2*x[3](t)*N3*N2*N1*(1-N1*N2*N6/x[1](t)-N2*N1*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/x[2](t))/x[2](t)+N3^2*N2*N1*((1/2)*(1-N1*N2*N6/x[1](t))^2-N2*N1*(1-N1*N2*N6/x[1](t)-N2*N1*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/x[2](t))/x[2](t))/x[2](t))-N2*N1*ln(1+(1-N1*N2*N6/x[1](t))*x[2](t)/(N1*N2))/(x[2](t)*F1)-Kin*x[3](t)^2-Kex*N1*N2*(x[3](t)+N3*(1-N1*N2*N6/x[1](t)))^2/(N1*N2+x[2](t)*(1-N1*N2*N6/x[1](t))))*x[1](t)*(N1*N2*N6*x[2](t)-N1*N2*x[1](t)-x[2](t)*x[1](t))*F1/(N1*N2)-Aol^2*Dol*F1*LR*N5*N3^2*N1^2*N2^2*N6^2+2*Aol^2*Dol*F1*LR*N5*N3^2*N1*N2*N6*x[1](t)+2*Aol^2*Dol*F1*LR*N5*N3*N1*N2*N6*x[1](t)*x[3](t)-Aol^2*Dol*F1*LR*N5*N3^2*x[1](t)^2-2*Aol^2*Dol*F1*LR*N5*N3*x[1](t)^2*x[3](t)-Aol^2*Dol*F1*LR*N5*x[1](t)^2*x[3](t)^2-2*Aol*F1*LR*N3^2*N1*N2*x[1](t)+2*Aol*F1*LR*N3*x[1](t)^2*x[3](t)-LR*x[1](t)^2+F1*N4*N1*N2*N6^2*x[3](t)^2*x[2](t)-F1*N4*N1*N2*N6*x[1](t)*x[3](t)^2-F1*N4*N6*x[1](t)*x[3](t)^2*x[2](t)+N1*N2*N6^2*x[2](t)-N1*N2*N6*x[1](t)-N6*x[1](t)*x[2](t))/(Aol*F1*LR*x[1](t)^2+F1*N6*x[1](t)*x[2](t)+F1*ln(-(N1*N2*N6*x[2](t)-N1*N2*x[1](t)-x[2](t)*x[1](t))/(N1*N2*x[1](t)))*x[1](t)^2*x[2](t)-F1*N1*N2*N6^2*x[2](t)+F1*N1*N2*N6*x[1](t)+F1*N1*N2*ln(-(N1*N2*N6*x[2](t)-N1*N2*x[1](t)-x[2](t)*x[1](t))/(N1*N2*x[1](t)))*x[1](t)^2-F1*N1*N2*N6*ln(-(N1*N2*N6*x[2](t)-N1*N2*x[1](t)-x[2](t)*x[1](t))/(N1*N2*x[1](t)))*x[1](t)*x[2](t)):

A differential equation is expected to be something of the form dx/dt = F(x(t)).  That is, one defines the function F first, and then defines the differential equation afterwards in terms of F.  In your equations the function F is hidden, so we first untangle your notation to set things straight.  This should not have been necessary if you had done things correctly in the beginning by defining the F functions first.

isolate(eq[1], diff);
eval(rhs(%), [x[1](t)=x[1], x[2](t)=x[2], x[3](t)=x[3]]);
F[1] := unapply(%, [x[1], x[2], x[3]]);  # here is F
Eq[1] := diff(x[1](t),t) = F[1](x[1](t), x[2](t), x[3](t));  # here is the DE

diff(x[1](t), t) = 2*x[1](t)*(N1*N2*N3-x[1](t)*x[3](t))/(N1*N2*N6)

 

2*x[1]*(N1*N2*N3-x[1]*x[3])/(N1*N2*N6)

 

proc (x_1, x_2, x_3) options operator, arrow; 2*x_1*(N1*N2*N3-x_1*x_3)/(N1*N2*N6) end proc

 

diff(x[1](t), t) = 2*x[1](t)*(N1*N2*N3-x[1](t)*x[3](t))/(N1*N2*N6)

(1)

Similarly, we untangle the notation for eq[2] and eq[3]:

isolate(eq[2], diff):
eval(rhs(%), [x[1](t)=x[1], x[2](t)=x[2], x[3](t)=x[3]]):
F[2] := unapply(%, [x[1], x[2], x[3]]):  # here is F
Eq[2] := diff(x[1](t),t) = F[2](x[1](t), x[2](t), x[3](t)):  # here is the DE

 

isolate(eq[3], diff):
eval(rhs(%), [x[1](t)=x[1], x[2](t)=x[2], x[3](t)=x[3]]):
F[3] := unapply(%, [x[1], x[2], x[3]]):  # here is F
Eq[3] := diff(x[1](t),t) = F[3](x[1](t), x[2](t), x[3](t)):  # here is the DE

 

Find the equilibria:

solve({F[1](x[1],x[2],x[3])=0,
       F[2](x[1],x[2],x[3])=0,
       F[3](x[1],x[2],x[3])=0}, {x[1],x[2],x[3]});

{x[1] = N1*N2*N6+N1*N2*exp(RootOf(6*LR*N6+2*F1*Kex*N3^2*(exp(_Z))^3+F1*N3^2*N5*(exp(_Z))^3-2*F1*Kex*N3^2*(exp(_Z))^2+2*F1*Kin*N3^2*(exp(_Z))^2+2*F1*N3^2*N6*(exp(_Z))^2-2*F1*Kin*N3^2*exp(_Z)-F1*N3^2*N5*exp(_Z)-2*F1*N3^2*N6*exp(_Z)+2*F1*Kin*N3^2*N6*exp(_Z)+2*F1*N3^2*N4*N6*exp(_Z)+2*F1*Kex*N3^2*N6*(exp(_Z))^2-2*LR+2*Aol^2*Dol*F1*LR*N3^2*N5*(exp(_Z))^3-2*Aol^2*Dol*F1*LR*N3^2*N5*(exp(_Z))^2+2*(exp(_Z))^3*_Z-4*(exp(_Z))^2*_Z+2*_Z*exp(_Z)+2*N6*(exp(_Z))^3-6*LR*(exp(_Z))^2-4*N6^2*exp(_Z)-4*N6*(exp(_Z))^2+6*LR*exp(_Z)+2*N6*exp(_Z)+2*LR*(exp(_Z))^3+2*N6^3*exp(_Z)+4*N6^2*(exp(_Z))^2+2*Aol^2*Dol*F1*LR*N3^2*N5*N6*(exp(_Z))^2+2*LR*N6^3-6*LR*N6^2+2*F1*N3^2*(exp(_Z))^3-4*F1*N3^2*(exp(_Z))^2+2*F1*N3^2*exp(_Z)+6*LR*N6^2*exp(_Z)+6*LR*N6*(exp(_Z))^2-12*LR*N6*exp(_Z)+2*N6^2*exp(_Z)*_Z+4*N6*(exp(_Z))^2*_Z-4*N6*exp(_Z)*_Z))-N1*N2, x[2] = N1*N2*N6+N1*N2*exp(RootOf(6*LR*N6+2*F1*Kex*N3^2*(exp(_Z))^3+F1*N3^2*N5*(exp(_Z))^3-2*F1*Kex*N3^2*(exp(_Z))^2+2*F1*Kin*N3^2*(exp(_Z))^2+2*F1*N3^2*N6*(exp(_Z))^2-2*F1*Kin*N3^2*exp(_Z)-F1*N3^2*N5*exp(_Z)-2*F1*N3^2*N6*exp(_Z)+2*F1*Kin*N3^2*N6*exp(_Z)+2*F1*N3^2*N4*N6*exp(_Z)+2*F1*Kex*N3^2*N6*(exp(_Z))^2-2*LR+2*Aol^2*Dol*F1*LR*N3^2*N5*(exp(_Z))^3-2*Aol^2*Dol*F1*LR*N3^2*N5*(exp(_Z))^2+2*(exp(_Z))^3*_Z-4*(exp(_Z))^2*_Z+2*_Z*exp(_Z)+2*N6*(exp(_Z))^3-6*LR*(exp(_Z))^2-4*N6^2*exp(_Z)-4*N6*(exp(_Z))^2+6*LR*exp(_Z)+2*N6*exp(_Z)+2*LR*(exp(_Z))^3+2*N6^3*exp(_Z)+4*N6^2*(exp(_Z))^2+2*Aol^2*Dol*F1*LR*N3^2*N5*N6*(exp(_Z))^2+2*LR*N6^3-6*LR*N6^2+2*F1*N3^2*(exp(_Z))^3-4*F1*N3^2*(exp(_Z))^2+2*F1*N3^2*exp(_Z)+6*LR*N6^2*exp(_Z)+6*LR*N6*(exp(_Z))^2-12*LR*N6*exp(_Z)+2*N6^2*exp(_Z)*_Z+4*N6*(exp(_Z))^2*_Z-4*N6*exp(_Z)*_Z))-N1*N2, x[3] = N3/(N6+exp(RootOf(6*LR*N6+2*F1*Kex*N3^2*(exp(_Z))^3+F1*N3^2*N5*(exp(_Z))^3-2*F1*Kex*N3^2*(exp(_Z))^2+2*F1*Kin*N3^2*(exp(_Z))^2+2*F1*N3^2*N6*(exp(_Z))^2-2*F1*Kin*N3^2*exp(_Z)-F1*N3^2*N5*exp(_Z)-2*F1*N3^2*N6*exp(_Z)+2*F1*Kin*N3^2*N6*exp(_Z)+2*F1*N3^2*N4*N6*exp(_Z)+2*F1*Kex*N3^2*N6*(exp(_Z))^2-2*LR+2*Aol^2*Dol*F1*LR*N3^2*N5*(exp(_Z))^3-2*Aol^2*Dol*F1*LR*N3^2*N5*(exp(_Z))^2+2*(exp(_Z))^3*_Z-4*(exp(_Z))^2*_Z+2*_Z*exp(_Z)+2*N6*(exp(_Z))^3-6*LR*(exp(_Z))^2-4*N6^2*exp(_Z)-4*N6*(exp(_Z))^2+6*LR*exp(_Z)+2*N6*exp(_Z)+2*LR*(exp(_Z))^3+2*N6^3*exp(_Z)+4*N6^2*(exp(_Z))^2+2*Aol^2*Dol*F1*LR*N3^2*N5*N6*(exp(_Z))^2+2*LR*N6^3-6*LR*N6^2+2*F1*N3^2*(exp(_Z))^3-4*F1*N3^2*(exp(_Z))^2+2*F1*N3^2*exp(_Z)+6*LR*N6^2*exp(_Z)+6*LR*N6*(exp(_Z))^2-12*LR*N6*exp(_Z)+2*N6^2*exp(_Z)*_Z+4*N6*(exp(_Z))^2*_Z-4*N6*exp(_Z)*_Z))-1)}

(2)

That's a mess.  We back up and do things manually as much as possible.  We have:

F[1](x[1],x[2],x[3]) = 0;
solve(%, x[1]);
tmp1 := %[2];  # ignore the solution x[1]=0; pick the other one and call it tmp1

2*x[1]*(N1*N2*N3-x[1]*x[3])/(N1*N2*N6) = 0

 

0, N1*N2*N3/x[3]

 

N1*N2*N3/x[3]

(3)

Similarly, solve F[2] =0 for x[2]:

simplify(F[2](tmp1,x[2],x[3]));
tmp2 := solve(%, x[2]);  # solve for x[2] and call the solution tmp2

(-N6*x[3]+N3)*(N1*N2*N3-x[2]*x[3])*x[2]^2/(N2*N1*((N1*N2*N3+x[2]*(-N6*x[3]+N3))*ln(((N1*N2+x[2])*N3-N6*x[2]*x[3])/(N1*N2*N3))-x[2]*(-N6*x[3]+N3)))

 

N1*N2*N3/x[3]

(4)

It remians to solve the equation F[3]=0.  But it does not have a solution in terms of elementary function:

simplify(F[3](tmp1, tmp2, x[3]));

(((-N6+1)*x[3]+N3)*ln((-N6*x[3]+N3+x[3])/x[3])-(N6-1)*((1/2)*N5*N6+N4-N5)*N6*F1*x[3]^3+N3*((1+Kex+(3/2)*N5+Aol^2*Dol*LR*N5)*N6^2+(-2*Aol^2*Dol*LR*N5-2*Kex-Kin+N4-3*N5-1)*N6+Aol^2*Dol*LR*N5+Kex+Kin+N5)*F1*x[3]^2+(-2*((Aol^2*Dol*LR*N5+Kex+(3/4)*N5+1)*N6+(-Aol^2*Dol*LR-3/4)*N5-Kex-(1/2)*Kin-1/2)*F1*N3^2-N6^2+N6)*x[3]+N3*(F1*(Aol^2*Dol*LR*N5+Kex+(1/2)*N5+1)*N3^2+LR+N6))*x[3]/(F1*(((N6-1)*x[3]-N3)*N3*N1*N2*ln((-N6*x[3]+N3+x[3])/x[3])+((N6^2-N6)*x[3]-N3*(Aol*LR+N6))*x[3]))

(5)

So we seek a numerical solution.  Toward that end, we make a list of the problem's parameters:

indets({F[1](x[1],x[2],x[3]), F[2](x[1],x[2],x[3]), F[3](x[1],x[2],x[3])}, name);

{Aol, Dol, F1, Kex, Kin, LR, N1, N2, N3, N4, N5, N6, x[1], x[2], x[3]}

(6)

Pick numerical values for the parameters:

params:= F1=1.493520000, LR=0.3178477690, Aol=0.7843287882, Dol= 0.5128205128e-1, N4= 3.670047218, N5= 7.340094435, N1= 1.054254618, N2= 0.5146253739e-1, N6=0.650636, N3=2.64407, Kin=42.48, Kex=0.68

F1 = 1.493520000, LR = .3178477690, Aol = .7843287882, Dol = 0.5128205128e-1, N4 = 3.670047218, N5 = 7.340094435, N1 = 1.054254618, N2 = 0.5146253739e-1, N6 = .650636, N3 = 2.64407, Kin = 42.48, Kex = .68

(7)

Let's see what F[3] looks like as a function of x[3]:

plot(eval(F[3](tmp1, tmp2, x[3]), {params}), x[3]=0..200);

 

We see that there is a root near x[3]=150.  We apply fsolve() to obtain the precise value.  We call it X[3]:

eval(F[3](tmp1, tmp2, x[3]), {params}):
X[3] := fsolve(%, x[3]);

141.8570556

(8)

With that in hand, we may evaluate the other two coordinates of the equilibrium:

X[1] := eval(tmp1, {params, x[3]=X[3]});

0.1011250420e-2

(9)

X[2] := eval(tmp2, {params, x[3]=X[3]});

0.1011250420e-2

(10)

Sanity check: Let's verify that we have made no mistakes:

eval([F[1](X[1],X[2],X[3]),
      F[2](X[1],X[2],X[3]),
      F[3](X[1],X[2],X[3])], {params});

[-0.5729462929e-11, -0.4460049627e-11, 0.5576334169e-4]

(11)

That's not bad.  The third value is not as small as it can be, but if necessary, we may increase the Digits value in order to obtain greater accuracy.

Aside: With the hindsight obtained from our manual calculation above, we may ask Maple to find the equilibrium at once through a single application of the fsolve() command:

eval({F[1](x[1],x[2],x[3])=0,
      F[2](x[1],x[2],x[3])=0,
      F[3](x[1],x[2],x[3])=0}, {params}):
fsolve(%, {x[1]=0..1e-2,x[2]=0..1e-2,x[3]=140..160});

{x[1] = 0.1011250419e-2, x[2] = 0.1011250419e-2, x[3] = 141.8570556}

(12)

which is identical to what we obtained earlier.

 

Now we linearize the system about the equilibrium.  We begin by evaluating  F[1], F[2] and F[3] at the parameter values:

G := eval([F[1](x[1],x[2],x[3]),
           F[2](x[1],x[2],x[3]),
           F[3](x[1],x[2],x[3])], {params}):

Here is the Jacobian matrix at any x[1], x[2], x[3]:

J := < diff(G[1],x[1]), diff(G[1],x[2]), diff(G[1],x[3]);
       diff(G[2],x[1]), diff(G[2],x[2]), diff(G[2],x[3]);
       diff(G[3],x[1]), diff(G[3],x[2]), diff(G[3],x[3]) >:

Evaluate the Jacobian at the equilibrium to obtain the linearized matrix:

A := eval(J, {x[1]=X[1], x[2]=X[2], x[3]=X[3]});

_rtable[18446883888842582486]

(13)

Find the eigenvalues of the linearized matrix

LinearAlgebra:-Eigenvalues(A);

_rtable[18446883888835980694]

(14)

We have two positive eigenvalues, indicating that the equilibrium is unstable.

 

 

 

Download mw2.mw

Let me write L instead of LL for greater legibility.  By differentiating your expression for L we get:

Solve this as a differential equation:
dsol := dsolve({de, ic}, numeric);

Then plot it:

plots:-odeplot(dsol), phi=0..2*Pi);

To read of the value of the solution at phi=4, do:

dsol(4);

 

 

iR := rand(1..nR):
iC := rand(1..nC):
C(iR(),iC());  # pick a random element of C

C(iR(),iC());  # pick another random element of C

To define the matrices A[k]:

assign(seq(A[k] = <k,k^2;2*k,2*k^2>, k=1..10));

To make a block-diagonal matrix out of these:

M := LinearAlgebra:-DiagonalMatrix([seq(A[k], k=1..10)]);

To view M:

evalm(M);

Aside: If you have no need to refer to the individual matrices A[k], then you may bypass the middleman and make the block-diagonal matrix directly:

M := LinearAlgebra:-DiagonalMatrix([seq(<k,k^2;2*k,2*k^2>, k=1..10)]);

 

The differential equation itself expresses y''(t) in terms of y(t) and y'(t).  Therefore once you have obtained y(t) and y'(t), you can evaluate y''(t) directly, like this.

de := -diff(y(t),t,t) +  y(t) = t*sin(5*t);

-(diff(diff(y(t), t), t))+y(t) = t*sin(5*t)

bc := y(0)=0.2, y(1)=1;

y(0) = .2, y(1) = 1

dsol := dsolve({de, bc}, numeric);

proc (x_bvp) local res, data, solnproc, _ndsol, outpoint, i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; _EnvDSNumericSaveDigits := Digits; Digits := 15; if _EnvInFsolve = true then outpoint := evalf[_EnvDSNumericSaveDigits](x_bvp) else outpoint := evalf(x_bvp) end if; data := Array(1..4, {(1) = proc (outpoint) local X, Y, YP, yout, errproc, L, V, i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; X := Vector(8, {(1) = .0, (2) = .13356755121790845, (3) = .30430039984542584, (4) = .4711335427102931, (5) = .6262694366777036, (6) = .7636417442240576, (7) = .8856536401001731, (8) = 1.0}, datatype = float[8], order = C_order); Y := Matrix(8, 2, {(1, 1) = .2, (1, 2) = .6355472386901964, (2, 1) = .28679901058587776, (2, 2) = .6642172351157226, (3, 1) = .4026629349647905, (3, 2) = .6898565048786539, (4, 1) = .5191388059317775, (4, 2) = .7087686351481234, (5, 1) = .6327422107075403, (5, 2) = .7672375606410581, (6, 1) = .745854892367845, (6, 2) = .8933518491303937, (7, 1) = .8652730228741763, (7, 2) = 1.0741950607628237, (8, 1) = 1.0, (8, 2) = 1.2869514632712835}, datatype = float[8], order = C_order); YP := Matrix(8, 2, {(1, 1) = .6355472386901964, (1, 2) = .2, (2, 1) = .6642172351157226, (2, 2) = .2040819987788216, (3, 1) = .6898565048786539, (3, 2) = 0.987321747068094e-1, (4, 1) = .7087686351481234, (4, 2) = .18582163798963208, (5, 1) = .7672375606410581, (5, 2) = .6263258981104891, (6, 1) = .8933518491303937, (6, 2) = 1.2240154135287016, (7, 1) = 1.0741950607628237, (7, 2) = 1.7154194632259072, (8, 1) = 1.2869514632712835, (8, 2) = 1.9589242746631386}, datatype = float[8], order = C_order); errproc := proc (x_bvp) local outpoint, X, Y, yout, L, V, i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; Digits := 15; outpoint := evalf(x_bvp); X := Vector(8, {(1) = .0, (2) = .13356755121790845, (3) = .30430039984542584, (4) = .4711335427102931, (5) = .6262694366777036, (6) = .7636417442240576, (7) = .8856536401001731, (8) = 1.0}, datatype = float[8], order = C_order); Y := Matrix(8, 2, {(1, 1) = .0, (1, 2) = 0.13030464384801514e-6, (2, 1) = 0.1302535103026619e-7, (2, 2) = 0.14221614646911444e-6, (3, 1) = -0.4128469958203856e-7, (3, 2) = 0.15918945269923148e-6, (4, 1) = -0.7225809617070991e-7, (4, 2) = 0.11203207102741712e-6, (5, 1) = -0.5203959916725329e-7, (5, 2) = 0.648213485009814e-7, (6, 1) = -0.26104233388354814e-7, (6, 2) = 0.4841390359814309e-7, (7, 1) = -0.10238961917655763e-7, (7, 2) = 0.4628901322935305e-7, (8, 1) = .0, (8, 2) = 0.48876597274231683e-7}, datatype = float[8], order = C_order); if not type(outpoint, 'numeric') then if outpoint = "start" or outpoint = "left" then return X[1] elif outpoint = "right" then return X[8] elif outpoint = "order" then return 6 elif outpoint = "error" then return HFloat(1.5918945269923148e-7) elif outpoint = "errorproc" then error "this is already the error procedure" elif outpoint = "rawdata" then return [2, 8, [y(t), diff(y(t), t)], X, Y] else return ('procname')(x_bvp) end if end if; if outpoint < X[1] or X[8] < outpoint then error "solution is only defined in the range %1..%2", X[1], X[8] end if; V := array([1 = 4, 2 = 0]); if Digits <= trunc(evalhf(Digits)) then L := Vector(4, 'datatype' = 'float'[8]); yout := Vector(2, 'datatype' = 'float'[8]); evalhf(`dsolve/numeric/lagrange`(8, 2, X, Y, outpoint, var(yout), var(L), var(V))) else L := Vector(4, 'datatype' = 'sfloat'); yout := Vector(2, 'datatype' = 'sfloat'); `dsolve/numeric/lagrange`(8, 2, X, Y, outpoint, yout, L, V) end if; [t = outpoint, seq('[y(t), diff(y(t), t)]'[i] = yout[i], i = 1 .. 2)] end proc; if not type(outpoint, 'numeric') then if outpoint = "start" or outpoint = "left" then return X[1] elif outpoint = "method" then return "bvp" elif outpoint = "right" then return X[8] elif outpoint = "order" then return 6 elif outpoint = "error" then return HFloat(1.5918945269923148e-7) elif outpoint = "errorproc" then return eval(errproc) elif outpoint = "rawdata" then return [2, 8, "depnames", X, Y, YP] else error "non-numeric value" end if end if; if outpoint < X[1] or X[8] < outpoint then error "solution is only defined in the range %1..%2", X[1], X[8] end if; if Digits <= trunc(evalhf(Digits)) and (_EnvInFsolve <> true or _EnvDSNumericSaveDigits <= trunc(evalhf(Digits))) then V := array( 1 .. 6, [( 1 ) = (7), ( 2 ) = (0), ( 3 ) = (false), ( 4 ) = (false), ( 5 ) = (false), ( 6 ) = (false)  ] ); L := Matrix(7, 2, {(1, 1) = .0, (1, 2) = .0, (2, 1) = .0, (2, 2) = .0, (3, 1) = .0, (3, 2) = .0, (4, 1) = .0, (4, 2) = .0, (5, 1) = .0, (5, 2) = .0, (6, 1) = .0, (6, 2) = .0, (7, 1) = .0, (7, 2) = .0}, datatype = float[8], order = C_order); yout := Vector(2, {(1) = .0, (2) = .0}, datatype = float[8]); evalhf(`dsolve/numeric/hermite`(8, 2, X, Y, YP, outpoint, var(yout), var(L), var(V))) else if _EnvInFsolve = true then Digits := _EnvDSNumericSaveDigits end if; V := array( 1 .. 6, [( 1 ) = (7), ( 2 ) = (0), ( 3 ) = (false), ( 4 ) = (false), ( 5 ) = (false), ( 6 ) = (false)  ] ); L := Matrix(7, 2, {(1, 1) = 0., (1, 2) = 0., (2, 1) = 0., (2, 2) = 0., (3, 1) = 0., (3, 2) = 0., (4, 1) = 0., (4, 2) = 0., (5, 1) = 0., (5, 2) = 0., (6, 1) = 0., (6, 2) = 0., (7, 1) = 0., (7, 2) = 0.}, order = C_order); yout := Vector(2, {(1) = 0., (2) = 0.}); `dsolve/numeric/hermite`(8, 2, X, Y, YP, outpoint, yout, L, V) end if; [outpoint, seq(yout[i], i = 1 .. 2)] end proc, (2) = Array(0..0, {}), (3) = [t, y(t), diff(y(t), t)], (4) = 0}); solnproc := data[1]; if not type(outpoint, 'numeric') then if outpoint = "solnprocedure" then return eval(solnproc) elif member(outpoint, ["start", "left", "right", "errorproc", "rawdata", "order", "error"]) then return solnproc(x_bvp) elif outpoint = "sysvars" then return data[3] elif procname <> unknown then return ('procname')(x_bvp) else _ndsol := pointto(data[2][0]); return ('_ndsol')(x_bvp) end if end if; try res := solnproc(outpoint); [t = res[1], seq('[y(t), diff(y(t), t)]'[i] = res[i+1], i = 1 .. 2)] catch: error  end try end proc

plots:-odeplot(dsol, [t,y(t)], t=0..1);

plots:-odeplot(dsol, [t,D(y)(t)], t=0..1);

de_biz := isolate(de, diff(y(t),t,t));

diff(diff(y(t), t), t) = y(t)-t*sin(5*t)

plots:-odeplot(dsol, [t,rhs(de_biz)], t=0..1);

 

 

 

Download mw.mw

Regarding your statement:
I know function f(x) for y>1.4266 is monotically decreasing and there is no turning points,(actually i can compute infection points of above function: y=1.4266 and x=4/5 ).

That's correct but the calculation in your worksheet may be simplified to one line:
solve({diff(F(x,y),x) = 0, diff(F(x,y),x,x) = 0});

As to your statement:
I know function for 1.4266>y>1.0144 has two turning points a minimum for x<4/5 and a maximum for x>4/5.

I don't see the significance of the 1.0144.  The function has a minimum and a maximum for all values of y in 0 < y < 1.4266.  You can see that by letting
F := (x,y) ->
x^2+y*(1-x)^(3/4);
and then plotting F(x,y) for 0 < x < 1 and various values of y.

 

 

 

First 32 33 34 35 36 37 38 Last Page 34 of 58