Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

The linked worksheet displays the geodesic between two points on a surface z(x,y).

Surfacepath.mw

Gradient descent will find a stepped approximate path of fastest descent between the points, but is there a way to find a function defining an exact i.e. smooth path of fastest descent? If so, how can a precise time of fastest descent be determined?

Namely, I mean

solve({y >= 4*x^4+4*x^2*y+1/2, sqrt((1/2)*(x-y)^2-(x-y)^4) = -2*x^2+y^2}, [x, y]);
                               []

The answer (no solution) is not correct in view of 

eval({y >= 4*x^4+4*x^2*y+1/2, sqrt((1/2)*(x-y)^2-(x-y)^4) = -2*x^2+y^2}, [x = 0, y = 1/2]);
      {(1/8)*sqrt(4) = 1/4, 1/2 <= 1/2}
eval({y >= 4*x^4+4*x^2*y+1/2, sqrt((1/2)*(x-y)^2-(x-y)^4) = -2*x^2+y^2}, [x = -1, y = -3/2]);
      {(1/8)*sqrt(4) = 1/4, -3/2 <= -3/2}            

 

Hi all, I want to ask how to use for loop reverse in Maple.

Example, i have array . In Java then

for(int i = arr.size(); i > 0; i--) {

    //do something

}

What is simillar for loop in Maple?

Thank you very much.

Hi, when I wan to generate results, it shows this; What should I do?

Error, (in solve) a constant is invalid as a variable, I. 

I have a system of equations that can't be solved analytically, but can be solved using fsolve. I would like to plot the solution for one of the unknowns as a function of a parameter "DV" that is in a few of the equations. There are two issues at hand. First, even if I give DV a numerical value, the solutions are of the form { x = 0.23, y = 4.56 }, a form that plot( ) obviously can't handle directly. Generally I have dealt with this by using the op( ) command to pick out the solution I want; is there a better way?

But even after I have the solution I want, fsolve( ) won't work until I give it a value for DV. Thus a plot( ) command like

   plot(op(2, op(2, fsolve({e1, e2}, {x, y})), DV = -1 .. 1)

fails with an "Error, (in fsolve) DV is in the equation, and is not solved for" error.

There's got to be an esy way to do this!

Here Maple treats the intervals as independent, as I think it should:

INTERVAL(1 .. 2)+INTERVAL(1 .. 2);
              INTERVAL(1 .. 2) + INTERVAL(1 .. 2)

INTERVAL(1 .. 2)-INTERVAL(1 .. 2);
              INTERVAL(1 .. 2) - INTERVAL(1 .. 2)

(even though for the first one an autosimplification to 2*INTERVAL(1..2) wouldn't matter). But as soon as there are non-linear terms, Maple ignores that rule:

INTERVAL(1 .. 2)^2-INTERVAL(1 .. 2)^2;
                               0

INTERVAL(1 .. 2)/INTERVAL(1 .. 2);
                               1

INTERVAL(-1 .. 1)*INTERVAL(-1 .. 1);
                                        2
                       INTERVAL(-1 .. 1) 

That means I cannot substitute intervals for variables in a formula. In fact, I don't know how INTERVAL(-1 .. 1)*INTERVAL(-1 .. 1) can be computed as a product of two independent intervals at all, there doesn't seem to be any way to pass it to evalr.

 


 

Maple 2017.1 and 2017.2 introduced several improvements in the solution of PDE & Boundary conditions problems (exact solutions).  Maple 2017.3 includes more improvements in this same area.

 

The following is a set of 25 examples of different PDE & Boundary Conditions problems that are solvable in Maple 2017.3 but not in Maple 2017.2 or previous releases. In the examples that follow, in some cases the PDE is different, in other cases the boundary conditions are of a different kind or solving the problem involves different computational strategies.

As usual, at the end there is a link pointing to the corresponding worksheet.

 

pde[1] := diff(u(x, t), t) = k*(diff(u(x, t), x, x)); bc[1] := u(x, 0) = 6+4*cos(3*Pi*x/L), (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))

 

u(x, 0) = 6+4*cos(3*Pi*x/L), (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0

(1)

`assuming`([pdsolve([pde[1], bc[1]], u(x, t))], [L > 0, k > 0])

u(x, t) = 6+4*cos(3*Pi*x/L)*exp(-9*k*Pi^2*t/L^2)

(2)

pde[2] := diff(g(t, x), t) = diff(g(t, x), x, x)+a*g(t, x); bc[2] := g(0, x) = 1

diff(g(t, x), t) = diff(diff(g(t, x), x), x)+a*g(t, x)

 

g(0, x) = 1

(3)

pdsolve([pde[2], bc[2]])

g(t, x) = exp(a*t)

(4)

pde[3] := diff(u(x, t), t) = diff(u(x, t), x, x)

bc[3] := u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

diff(u(x, t), t) = diff(diff(u(x, t), x), x)

 

u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

(5)

pdsolve([pde[3], bc[3]], u(x, t))

u(x, t) = Sum((Int(f(x)*sin(n*Pi*x), x = -1 .. 1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)

(6)

pde[4] := diff(u(x, t), t) = k*(diff(u(x, t), x, x)); bc[4] := u(0, t) = 0, u(L, t) = 0, u(x, 0) = piecewise(0 < x and x <= (1/2)*L, 1, (1/2)*L < x and x < L, 2)

pde[4] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))

 

u(0, t) = 0, u(L, t) = 0, u(x, 0) = piecewise(0 < x and x <= (1/2)*L, 1, (1/2)*L < x and x < L, 2)

(7)

`assuming`([pdsolve([pde[4], bc[4]], u(x, t))], [L > 0])

u(x, t) = Sum((2*cos((1/2)*Pi*n)+2+4*(-1)^(1+n))*sin(n*Pi*x/L)*exp(-k*Pi^2*n^2*t/L^2)/(Pi*n), n = 1 .. infinity)

(8)

pde[5] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))

bc[5] := (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0, u(x, 0) = -3*cos(8*Pi*x/L)

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))

 

(D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0, u(x, 0) = -3*cos(8*Pi*x/L)

(9)

`assuming`([pdsolve([pde[5], bc[5]], u(x, t))], [0 < L, 0 < k])

u(x, t) = -3*cos(8*Pi*x/L)*exp(-64*k*Pi^2*t/L^2)

(10)

pde[6] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))+f(x, t); bc[6] := u(0, t) = 0, u(l, t) = 0, u(x, 0) = g(x)

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))+f(x, t)

 

u(0, t) = 0, u(l, t) = 0, u(x, 0) = g(x)

(11)

pdsolve([pde[6], bc[6]], u(x, t))

u(x, t) = Sum(2*(Int(g(tau1)*sin(Pi*n1*tau1/l), tau1 = 0 .. l))*sin(Pi*n1*x/l)*exp(-k*Pi^2*n1^2*t/l^2)/l, n1 = 1 .. infinity)+Int(Sum(2*(Int(f(x, tau1)*sin(Pi*n*x/l), x = 0 .. l))*sin(Pi*n*x/l)*exp(-k*Pi^2*n^2*(t-tau1)/l^2)/l, n = 1 .. infinity), tau1 = 0 .. t)

(12)

pde[7] := diff(u(x, t), t) = diff(u(x, t), x, x); bc[7] := u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

diff(u(x, t), t) = diff(diff(u(x, t), x), x)

 

u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

(13)

pdsolve([pde[7], bc[7]], u(x, t))

u(x, t) = Sum((Int(f(x)*sin(n*Pi*x), x = -1 .. 1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)

(14)

pde[8] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))-h*u(x, t); bc[8] := u(x, 0) = sin(x), u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))-h*u(x, t)

 

u(x, 0) = sin(x), u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

(15)

pdsolve([pde[8], bc[8]], u(x, t))

u(x, t) = sin(x)*exp(-t*(k+h))

(16)

pde[9] := diff(u(x, t), t) = diff(u(x, t), x, x)

bc[9] := u(0, t) = 20, u(1, t) = 50, u(x, 0) = 0

diff(u(x, t), t) = diff(diff(u(x, t), x), x)

 

u(0, t) = 20, u(1, t) = 50, u(x, 0) = 0

(17)

pdsolve([pde[9], bc[9]], u(x, t))

u(x, t) = 20+Sum((-40+100*(-1)^n)*sin(n*Pi*x)*exp(-Pi^2*n^2*t)/(Pi*n), n = 1 .. infinity)+30*x

(18)

pde[10] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0; bc[10] := u(x, 0) = 0, u(x, 1) = 0, u(0, y) = y^2-y, u(1, y) = 0

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

 

u(x, 0) = 0, u(x, 1) = 0, u(0, y) = y^2-y, u(1, y) = 0

(19)

pdsolve([pde[10], bc[10]], u(x, y))

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

(20)

pde[11] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[11] := (D[1](u))(0, y) = 0, (D[1](u))(L, y) = 0, u(x, H) = f(x), u(x, 0) = 0

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

 

(D[1](u))(0, y) = 0, (D[1](u))(L, y) = 0, u(x, H) = f(x), u(x, 0) = 0

(21)

`assuming`([pdsolve([pde[11], bc[11]], u(x, y))], [0 < L, 0 < H])

u(x, y) = Sum(2*(Int(cos(Pi*x*n/L)*f(x), x = 0 .. L))*cos(Pi*x*n/L)*exp(Pi*n*(H-y)/L)*(exp(2*Pi*y*n/L)-1)/(L*(exp(2*Pi*H*n/L)-1)), n = 1 .. infinity)

(22)

pde[12] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[12] := (D[1](u))(L, y) = 0, u(x, H) = 0, u(x, 0) = 0, (D[1](u))(0, y) = g(y)

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

 

(D[1](u))(L, y) = 0, u(x, H) = 0, u(x, 0) = 0, (D[1](u))(0, y) = g(y)

(23)

`assuming`([pdsolve([pde[12], bc[12]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

u(x, y) = Sum(-2*(Int(sin(Pi*y*n/H)*g(y), y = 0 .. H))*sin(Pi*y*n/H)*(exp(-Pi*n*(L-2*x)/H)+exp(Pi*L*n/H))*exp(Pi*n*(L-x)/H)/(Pi*n*(exp(2*Pi*L*n/H)-1)), n = 1 .. infinity)

(24)

pde[13] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[13] := (D[1](u))(0, y) = 0, u(x, 0) = 0, u(x, H) = 0, u(L, y) = g(y)

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

 

(D[1](u))(0, y) = 0, u(x, 0) = 0, u(x, H) = 0, u(L, y) = g(y)

(25)

`assuming`([pdsolve([pde[13], bc[13]], u(x, y))], [0 < L, 0 < H])

u(x, y) = Sum(2*(Int(sin(Pi*y*n/H)*g(y), y = 0 .. H))*sin(Pi*y*n/H)*exp(Pi*n*(L-x)/H)*(exp(2*Pi*x*n/H)+1)/(H*(exp(2*Pi*L*n/H)+1)), n = 1 .. infinity)

(26)

pde[14] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[14] := u(0, y) = g(y), u(L, y) = 0, (D[2](u))(x, 0) = 0, u(x, H) = 0

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

 

u(0, y) = g(y), u(L, y) = 0, (D[2](u))(x, 0) = 0, u(x, H) = 0

(27)

`assuming`([pdsolve([pde[14], bc[14]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

u(x, y) = Sum(-2*(exp(-(L-2*x)*(1/2+n)*Pi/H)-exp((1/2)*Pi*(1+2*n)*L/H))*cos((1/2)*Pi*(1+2*n)*y/H)*(Int(cos((1/2)*Pi*(1+2*n)*y/H)*g(y), y = 0 .. H))*exp((1/2)*Pi*(1+2*n)*(L-x)/H)/(H*(exp(Pi*(1+2*n)*L/H)-1)), n = 0 .. infinity)

(28)

pde[15] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[15] := u(0, y) = 0, u(L, y) = 0, u(x, 0) = (D[2](u))(x, 0), u(x, H) = f(x)

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

 

u(0, y) = 0, u(L, y) = 0, u(x, 0) = (D[2](u))(x, 0), u(x, H) = f(x)

(29)

`assuming`([pdsolve([pde[15], bc[15]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

u(x, y) = Sum(2*exp(Pi*n*(H-y)/L)*sin(Pi*x*n/L)*((Pi*n+L)*exp(2*Pi*y*n/L)+Pi*n-L)*(Int(sin(Pi*x*n/L)*f(x), x = 0 .. L))/(L*((Pi*n+L)*exp(2*Pi*H*n/L)+Pi*n-L)), n = 1 .. infinity)

(30)

pde[16] := diff(u(x, t), t, t) = c^2*(diff(u(x, t), x, x))

bc[16] := u(0, t) = 0, (D[1](u))(L, t) = 0, (D[2](u))(x, 0) = 0, u(x, 0) = f(x)

diff(diff(u(x, t), t), t) = c^2*(diff(diff(u(x, t), x), x))

 

u(0, t) = 0, (D[1](u))(L, t) = 0, (D[2](u))(x, 0) = 0, u(x, 0) = f(x)

(31)

`assuming`([pdsolve([pde[16], bc[16]], u(x, t))], [0 < x, x <= L])

u(x, t) = Sum(2*cos((1/2)*c*Pi*(1+2*n)*t/L)*(Int(sin((1/2)*Pi*(1+2*n)*x/L)*f(x), x = 0 .. L))*sin((1/2)*Pi*(1+2*n)*x/L)/L, n = 0 .. infinity)

(32)

pde[17] := diff(w(x1, x2, x3, t), t) = diff(w(x1, x2, x3, t), x1, x1)+diff(w(x1, x2, x3, t), x2, x2)+diff(w(x1, x2, x3, t), x3, x3)

bc[17] := w(x1, x2, x3, 0) = exp(x1)+x2*x3^5

diff(w(x1, x2, x3, t), t) = diff(diff(w(x1, x2, x3, t), x1), x1)+diff(diff(w(x1, x2, x3, t), x2), x2)+diff(diff(w(x1, x2, x3, t), x3), x3)

 

w(x1, x2, x3, 0) = exp(x1)+x2*x3^5

(33)

pdsolve([pde[17], bc[17]])

w(x1, x2, x3, t) = Sum(t^n*((proc (U) options operator, arrow; diff(diff(U, x1), x1)+diff(diff(U, x2), x2)+diff(diff(U, x3), x3) end proc)@@n)(exp(x1)+x2*x3^5)/factorial(n), n = 0 .. infinity)

(34)

pde[18] := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = -x

bc[18] := u(x, 0) = x

diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = -x

 

u(x, 0) = x

(35)

pdsolve([pde[18], bc[18]], u(x, t))

u(x, t) = x/tan(t+(1/4)*Pi)

(36)

pde[19] := diff(u(x, t), t)-u(x, t)^2*(diff(u(x, t), x)) = 3*u(x, t)

bc[19] := u(x, 0) = x

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

 

u(x, 0) = x

(37)

pdsolve([pde[19], bc[19]], u(x, t))

u(x, t) = -exp(3*t)*((-6*exp(6*t)*x+6*x+9)^(1/2)-3)/(exp(6*t)-1)

(38)

pde[20] := diff(u(x, t), t)-x*u(x, t)*(diff(u(x, t), x)) = 0

bc[20] := u(x, 0) = x

diff(u(x, t), t)-x*u(x, t)*(diff(u(x, t), x)) = 0

 

u(x, 0) = x

(39)

pdsolve([pde[20], bc[20]], u(x, t))

u(x, t) = -LambertW(-t*x)/t

(40)

pde[21] := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = 0

bc[21] := u(x, 0) = x

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

 

u(x, 0) = x

(41)

pdsolve([pde[21], bc[21]], u(x, t))

u(x, t) = x/(t+1)

(42)

pde[22] := (t+u(x, t))*(diff(u(x, t), x))+t*(diff(u(x, t), t)) = 0; bc[22] := u(x, 1) = x

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

 

u(x, 1) = x

(43)

pdsolve([pde[22], bc[22]], u(x, t))

u(x, t) = (t-x-1)/(ln(1/t)-1)

(44)

pde[23] := (diff(r*(diff(u(r, theta), r)), r))/r+(diff(u(r, theta), theta, theta))/r^2 = 0; bc[23] := u(a, theta) = f(theta), u(r, -Pi) = u(r, Pi), (D[2](u))(r, -Pi) = (D[2](u))(r, Pi)

(diff(u(r, theta), r)+r*(diff(diff(u(r, theta), r), r)))/r+(diff(diff(u(r, theta), theta), theta))/r^2 = 0

 

u(a, theta) = f(theta), u(r, -Pi) = u(r, Pi), (D[2](u))(r, -Pi) = (D[2](u))(r, Pi)

(45)

`assuming`([pdsolve([pde[23], bc[23]], u(r, theta), HINT = boundedseries)], [a > 0])

u(r, theta) = (1/2)*(2*(Sum(r^n*(sin(n*theta)*(Int(f(theta)*sin(n*theta), theta = -Pi .. Pi))+cos(n*theta)*(Int(f(theta)*cos(n*theta), theta = -Pi .. Pi)))*a^(-n)/Pi, n = 1 .. infinity))*Pi+Int(f(theta), theta = -Pi .. Pi))/Pi

(46)

pde[24] := diff(g(t, x), t) = diff(g(t, x), x, x)+a*g(t, x); bc[24] := g(0, x) = f(x)

diff(g(t, x), t) = diff(diff(g(t, x), x), x)+a*g(t, x)

 

g(0, x) = f(x)

(47)

pdsolve([pde[24], bc[24]])

g(t, x) = exp(a*t)*invfourier(fourier(f(x), x, s1)*exp(-t*s1^2), s1, x)

(48)

pde[25] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0; bc[25] := u(0, y) = y*(-y+1), u(1, y) = 0, (D[2](u))(x, 0) = 0, (D[2](u))(x, 1) = 0

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

 

u(0, y) = y*(-y+1), u(1, y) = 0, (D[2](u))(x, 0) = 0, (D[2](u))(x, 1) = 0

(49)

pdsolve([pde[25], bc[25]], u(x, y))

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

(50)

``


 

Download ImprovementsInPdsolve.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Hello,

This is a problem encountered in most engineering equations. An equation is given with some variables very small that they can be ignored. Basically the mathematical equivalent of an engineering approximation.

 

Below is a very simple example:

 

Both R and r are between 10E3 and 50E3. 
gm is between 1 and 10.

So regardless of actual values the answer to 4significant figures can always be approximated by:

eqn1~ R*gm*r

 

Is there any way to tell MAPLE to approximate an equation such that it is only accurate to certain decimal places? I have tried using "fnormal()" with "assuming"  statements but it always requires some of the variables be assigned actual numeric values.

I was wondering if there was a way to get this approximation without having to assign values to any of the variables but only by specifying the range of values for each variable.

 

Thanks.

 

 

 

How can ı write 3d^2+f^2-4e^2+2td^2-4te^2+2tf^2+3f^2+4td^2+....... as  (.......)d^2 +(......)e^2+ (.......)f^2 

so

3d^2+f^2-4e^2+2td^2-4te^2+2tf^2+3f^2+4td^2+....... = (.......)d^2 +(......)e^2+ (.......)f^2  ??????

 


 

hi

i have an Integral equation like below

now i want to use Parts That u=op(1,A), but when I use Parts it dont work properly, actually i want to get

but when i use 

A := Expand(Parts(Int(A, x), op(1, A)))

maple solve it like bellow 

i know that i can separate these terms One by one, but there are many functions like this in my code , so i want to know if there is any way to solve this function.

thank you.

Hi!
I am quite new to maple. 
I have uploaded two printscreens of two similar procedures. The only difference is that in prosedure nr. 2 the number "a"(rate of change given in the exercise), is supposed to variate in term of k.

I assume that i have to define an if-sentence that will tell the procedure to use a=0.15 when, n=0, and a1:=a(1-(k/Km)) when n>0.  Can someone please help me with solving this? 

Regards Paul

 

 

I am now working on differential equations like the following, and wonder how I can deal with diff(C(x,t),x).  In particular, I would like to know the values of diff(C(x,t),x) at specific sets of (x, t).  I also would like to know how to integrate diff(C(x,t),x) for a time period (at x = 0.5L or x = L).

 

restart;

C0 := 10;

K  := 3.0e6;

d  := 5.0E-14;

hm := 5.0E-4;

L  := 0.001;

 

DE1 := diff(C(x, t), t) = d*diff(C(x,t), x, x);

IC := C(x, 0) = piecewise(x < 0, 0, 0 <=x <= L, C0, L < x, 0);

BC1 := D[1](C)(0, t) = 0;

BC2 := -d*D[1](C)(L, t) = hm * C(L, t) / K;

 

pds:=pdsolve(DE1, {IC, BC1, BC2}, type=numeric, spacestep=L/10000, timestep=10000);

 

T := 60*60*24*100;

pds:-plot(t=T, x=0..L);

 

#I tried the following, but these seem to always return zero (while the plot suggests some negative value of diff(C(x, t), x));

v1 := pds:-value(diff(C(x, t), x));

v1(L, T);

v2 := pds:-value(int(diff(C(x, t), x), t = 0 .. T));

v2(L, 0);

Hello all,

I really don't know what is going on with my code but I think I can use some help. I'm new to Maple and to parallel programmimg. What I would to understand is why the following code is simply not working.

 

evList := seq(seq([i,j],j=i..6),i=1..6):
M := Matrix(6,shape=symmetric):
integMult := proc(kIni::integer, kFin::integer)
  local i, j, k, l, kk;
  global evList, M;
  for kk from kIni to kFin do
     i := evList[kk][1]:
     j := evList[kk][2]:
     M[i,j] := Matrix(3*n,(k,l)->evalf(int(expand(N[i][k]*N[j][l]),x[1]=0..a,x[2]=0..b)));
  od:
end proc:
Start(null, Task=[integMult,1,10],Task=[integMult,11,21]);

When I consider one single Thread (i.e. 1 to 21), it works like a charm. But the code written above gives me a kernel lost. I don't know if it is the shared variable "M" (matrices of matrices) or if it is the shared parameter (vector of vectors) , or both. But I've tested duplicating both and nothing different happens.

Can anyone help me?

hi 

i have an equation like thes:

i want to classify Coefficients of F & H like this:

anybody can help me to how i do it?

thank you.

I can solve three equations for x like this

restart:
x := y/p:
z := x*a+y*(1-b):
x := 100*z/(p*r+r);

                            /y a            \
                        100 |--- + y (1 - b)|
                            \ p             /
                   x := ---------------------
                              p r + r      

However, I dont like the fact that x is a function of y. I just want x to be a function of a, b, p and r. So I try to expreses the equations as follows:

restart;
y := p*x;
x := 100*z/(p*r+r);
z := x*a+y*(1-b);
solve(z, x);

Error, recursive assignment
Warning, solving for expressions other than names or functions is not recommended.

Any idea how I can get an equation for x that only depend on a, b, p and r? 
 

First 907 908 909 910 911 912 913 Last Page 909 of 2219