MaplePrimes Questions

how do i solve a system of PDE's with variable coeffiecients in Maple?

I have some elliptic curve with some points on it:

I would like to give the points some names, P, etc., but cannot figure out how to do that probably simple task. The help pages ?plot,options and ?pointplot do not seem to cover it; I may be mistaken, of course. The above plot is the result of the following code:

curve := y^2 = x^3 - 43*x + 166;
display([
   plot(+sqrt(rhs(curve)),x = -10..12),
   plot(-sqrt(rhs(curve)),x = -10..12),
   pointplot([[3,8],[-5,16],[11,32],[3,-8]],symbol = solidbox)
]);

Update: Using, among other things, the textplot command as suggested below, here, just for the fun of it, a plot illustrating the group 'addition' of points on an elliptic curve, the three lines being tangents to the curve:

Hello everyone,

I have modeled a parallel manipulator using MapleSim 6.4 and it is giving me an error.

ParalelManipulator_v2.msim

The types of joint are shown by the visual below. Note that in my model I have used a universal joint or two coinciding revolute joints instead of a speherical joint.

I really need to factor minus one from -x-yI. I can do -[x+yI] and -{x+yI}. I cannot do -(x+yI).
Well, i really don't have these numbers exactly. They are produced within a Maple program.
I have something like ab, where a is the number x+yI. The little trick -`a`b will not work because
of the rather involved form of "a".
Thank you!

mapleatha

 

 

what package I need to add in order to use commands named "Drawmatrix, Translatemat and Transform" ? I add package named Lamp but it is not working. I have maple 15. Please try to respond as soon as possible because its urgent.

 

Thank you

Hello. Please help me to correct the error. Thank you

lambda := proc (r) options operator, arrow; 3*r end proc;

proc (r) options operator, arrow; 3*r end proc

(1)

mu := proc (r) options operator, arrow; 4*r end proc;

proc (r) options operator, arrow; 4*r end proc

(2)

r1 := 5;

5

(3)

r2 := 3;

3

(4)

omega := 7;

7

(5)

alpha := 1;

1

(6)

beta := 1;

1

(7)

rho := 1;

1

(8)

n := 1;

1

(9)

rho1 := 4;

4

(10)

A := 8;

8

(11)

f11 := proc (r) options operator, arrow; (lambda(r)+2*mu(r))*r^2 end proc;

proc (r) options operator, arrow; (lambda(r)+2*mu(r))*r^2 end proc

(12)

f12 := proc (r) options operator, arrow; [(diff(lambda(r), r)+2*(diff(mu(r), r)))*r^2+(lambda(r)+2*mu(r))*r] end proc

proc (r) options operator, arrow; [(diff(lambda(r), r)+2*(diff(mu(r), r)))*r^2+(lambda(r)+2*mu(r))*r] end proc

(13)

f13 := proc (r) options operator, arrow; -n*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; -n*(lambda(r)+mu(r))*r end proc

(14)

NULL

f14 := proc (r) options operator, arrow; -alpha*(lambda(r)+mu(r))*r^2 end proc;

proc (r) options operator, arrow; -alpha*(lambda(r)+mu(r))*r^2 end proc

(15)

f15 := proc (r) options operator, arrow; [(diff(lambda(r), r))*r-lambda(r)-(n^2+2+alpha^2*r^2)*mu(r)+omega^2*rho*r^2] end proc;

proc (r) options operator, arrow; [(diff(lambda(r), r))*r-lambda(r)-(n^2+2+alpha^2*r^2)*mu(r)+omega^2*rho*r^2] end proc

(16)

f16 := proc (r) options operator, arrow; -n*[(diff(lambda(r), r))*r-lambda(r)-3*mu(r)] end proc;

proc (r) options operator, arrow; -n*[(diff(lambda(r), r))*r-lambda(r)-3*mu(r)] end proc

(17)

f17 := proc (r) options operator, arrow; -alpha*(diff(lambda(r), r))*r^2 end proc;

proc (r) options operator, arrow; -alpha*(diff(lambda(r), r))*r^2 end proc

(18)

f21 := proc (r) options operator, arrow; (lambda(r)+2*mu(r))*r^2 end proc;

proc (r) options operator, arrow; (lambda(r)+2*mu(r))*r^2 end proc

(19)

f22 := proc (r) options operator, arrow; [(diff(lambda(r), r)+2*(diff(mu(r), r)))*r^2+(lambda(r)+2*mu(r))*r] end proc

proc (r) options operator, arrow; [(diff(lambda(r), r)+2*(diff(mu(r), r)))*r^2+(lambda(r)+2*mu(r))*r] end proc

(20)

f23 := proc (r) options operator, arrow; n*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; n*(lambda(r)+mu(r))*r end proc

(21)

f24 := proc (r) options operator, arrow; alpha*(lambda(r)+mu(r))*r^2 end proc;

proc (r) options operator, arrow; alpha*(lambda(r)+mu(r))*r^2 end proc

(22)

f25 := proc (r) options operator, arrow; [(diff(lambda(r), r))*r-lambda(r)-(n^2+2+alpha^2*r^2)*mu(r)+omega^2*rho*r^2] end proc;

proc (r) options operator, arrow; [(diff(lambda(r), r))*r-lambda(r)-(n^2+2+alpha^2*r^2)*mu(r)+omega^2*rho*r^2] end proc

(23)

f26 := proc (r) options operator, arrow; n*[(diff(lambda(r), r))*r-lambda(r)-3*mu(r)] end proc;

proc (r) options operator, arrow; n*[(diff(lambda(r), r))*r-lambda(r)-3*mu(r)] end proc

(24)

f27 := proc (r) options operator, arrow; alpha*(diff(lambda(r), r))*r^2 end proc;

proc (r) options operator, arrow; alpha*(diff(lambda(r), r))*r^2 end proc

(25)

f31 := proc (r) options operator, arrow; mu(r)*r^2 end proc;

proc (r) options operator, arrow; mu(r)*r^2 end proc

(26)

f32 := proc (r) options operator, arrow; -n*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; -n*(lambda(r)+mu(r))*r end proc

(27)

f33 := proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc;

proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc

(28)

f34 := proc (r) options operator, arrow; -n*((diff(mu(r), r))*r+lambda(r)+3*mu(r)) end proc;

proc (r) options operator, arrow; -n*((diff(mu(r), r))*r+lambda(r)+3*mu(r)) end proc

(29)

f35 := proc (r) options operator, arrow; [-(diff(mu(r), r))*r-n^2*lambda(r)-(2*n^2+alpha^2*r^2+1)*mu(r)+omega^2*rho*r^2] end proc;

proc (r) options operator, arrow; [-(diff(mu(r), r))*r-n^2*lambda(r)-(2*n^2+alpha^2*r^2+1)*mu(r)+omega^2*rho*r^2] end proc

(30)

f36 := proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc

(31)

f41 := proc (r) options operator, arrow; mu(r)*r^2 end proc;

proc (r) options operator, arrow; mu(r)*r^2 end proc

(32)

f42 := proc (r) options operator, arrow; n*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; n*(lambda(r)+mu(r))*r end proc

(33)

f43 := proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc;

proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc

(34)

f44 := proc (r) options operator, arrow; n*((diff(mu(r), r))*r+lambda(r)+3*mu(r)) end proc;

proc (r) options operator, arrow; n*((diff(mu(r), r))*r+lambda(r)+3*mu(r)) end proc

(35)

f45 := proc (r) options operator, arrow; [-(diff(mu(r), r))*r-n^2*lambda(r)-(2*n^2+alpha^2*r^2+1)*mu(r)+omega^2*rho*r^2] end proc;

proc (r) options operator, arrow; [-(diff(mu(r), r))*r-n^2*lambda(r)-(2*n^2+alpha^2*r^2+1)*mu(r)+omega^2*rho*r^2] end proc

(36)

f46 := proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc

(37)

f51 := proc (r) options operator, arrow; mu(r)*r^2 end proc;

proc (r) options operator, arrow; mu(r)*r^2 end proc

(38)

f52 := proc (r) options operator, arrow; -alpha*(lambda(r)+mu(r))*r^2 end proc;

proc (r) options operator, arrow; -alpha*(lambda(r)+mu(r))*r^2 end proc

(39)

f53 := proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc;

proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc

(40)

f54 := proc (r) options operator, arrow; -alpha*[(diff(mu(r), r))*r^2+(lambda(r)+mu(r))*r] end proc;

proc (r) options operator, arrow; -alpha*[(diff(mu(r), r))*r^2+(lambda(r)+mu(r))*r] end proc

(41)

f55 := proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc

(42)

f56 := proc (r) options operator, arrow; [-(n^2+2*alpha^2*r^2)*mu(r)-alpha^2*lambda(r)*r^2+omega^2*rho*r^2] end proc;

proc (r) options operator, arrow; [-(n^2+2*alpha^2*r^2)*mu(r)-alpha^2*lambda(r)*r^2+omega^2*rho*r^2] end proc

(43)

f61 := proc (r) options operator, arrow; mu(r)*r^2 end proc;

proc (r) options operator, arrow; mu(r)*r^2 end proc

(44)

f62 := proc (r) options operator, arrow; alpha*(lambda(r)+mu(r))*r^2 end proc;

proc (r) options operator, arrow; alpha*(lambda(r)+mu(r))*r^2 end proc

(45)

f63 := proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc;

proc (r) options operator, arrow; (diff(mu(r), r))*r^2+mu(r)*r end proc

(46)

f64 := proc (r) options operator, arrow; alpha*[(diff(mu(r), r))*r^2+(lambda(r)+mu(r))*r] end proc;

proc (r) options operator, arrow; alpha*[(diff(mu(r), r))*r^2+(lambda(r)+mu(r))*r] end proc

(47)

f65 := proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc;

proc (r) options operator, arrow; -n*alpha*(lambda(r)+mu(r))*r end proc

(48)

f66 := proc (r) options operator, arrow; [-(n^2+2*alpha^2*r^2)*mu(r)-alpha^2*lambda(r)*r^2+omega^2*rho*r^2] end proc;

proc (r) options operator, arrow; [-(n^2+2*alpha^2*r^2)*mu(r)-alpha^2*lambda(r)*r^2+omega^2*rho*r^2] end proc

(49)

``

DJ := proc (x, n) options operator, arrow; diff(BesselJ(n, x), x) end proc;

proc (x, n) options operator, arrow; diff(BesselJ(n, x), x) end proc

(50)

DY := proc (x, n) options operator, arrow; diff(BesselY(n, x), x) end proc;

proc (x, n) options operator, arrow; diff(BesselY(n, x), x) end proc

(51)

``

g11 := proc (r) options operator, arrow; (lambda(r)+2*mu(r))*subs(x = beta*r1, DJ(x, n)) end proc;

proc (r) options operator, arrow; (lambda(r)+2*mu(r))*subs(x = beta*r1, DJ(x, n)) end proc

(52)

g12 := proc (r) options operator, arrow; -(lambda(r)+2*mu(r))*subs(x = beta*r1, DY(x, n)) end proc;

proc (r) options operator, arrow; -(lambda(r)+2*mu(r))*subs(x = beta*r1, DY(x, n)) end proc

(53)

````

g13 := proc (r) options operator, arrow; lambda(r)*subs(x = beta*r1, DJ(x, n))/r+omega^2*rho1*subs(x = beta*r1, BesselJ(n, x))/beta end proc;

proc (r) options operator, arrow; lambda(r)*subs(x = beta*r1, DJ(x, n))/r+omega^2*rho1*subs(x = beta*r1, BesselJ(n, x))/beta end proc

(54)

g14 := proc (r) options operator, arrow; -lambda(r)*subs(x = beta*r1, DY(x, n))/r-omega^2*rho1*subs(x = beta*r1, BesselY(n, x))/beta end proc;

proc (r) options operator, arrow; -lambda(r)*subs(x = beta*r1, DY(x, n))/r-omega^2*rho1*subs(x = beta*r1, BesselY(n, x))/beta end proc

(55)

g15 := proc (r) options operator, arrow; -n*lambda(r)*subs(x = beta*r1, DY(x, n))/r end proc;

proc (r) options operator, arrow; -n*lambda(r)*subs(x = beta*r1, DY(x, n))/r end proc

(56)

BesselY(0, 5)-(1/5)*BesselY(1, 5)

(57)

g16 := proc (r) options operator, arrow; -n*lambda(r)*subs(x = beta*r1, DJ(x, n))/r end proc;

proc (r) options operator, arrow; -n*lambda(r)*subs(x = beta*r1, DJ(x, n))/r end proc

(58)

 

g17 := proc (r) options operator, arrow; -alpha*lambda(r)*subs(x = beta*r1, DY(x, n)) end proc;

proc (r) options operator, arrow; -alpha*lambda(r)*subs(x = beta*r1, DY(x, n)) end proc

(59)

g18 := proc (r) options operator, arrow; -alpha*lambda(r)*subs(x = beta*r1, DJ(x, n)) end proc

proc (r) options operator, arrow; -alpha*lambda(r)*subs(x = beta*r1, DJ(x, n)) end proc

(60)

q1 := proc (r) options operator, arrow; piecewise(`mod`(n, 2) = 0, 2*i^n*A*omega*rho1/(Pi*beta*r1), `mod`(n, 2) <> 0, 0) end proc

proc (r) options operator, arrow; piecewise(`mod`(n, 2) = 0, 2*i^n*A*omega*rho1/(Pi*beta*r1), `mod`(n, 2) <> 0, 0) end proc

(61)

g21 := proc (r) options operator, arrow; (lambda(r)+2*mu(r))*subs(x = beta*r1, DY(x, n)) end proc;

proc (r) options operator, arrow; (lambda(r)+2*mu(r))*subs(x = beta*r1, DY(x, n)) end proc

(62)

g22 := proc (r) options operator, arrow; (lambda(r)+2*mu(r))*subs(x = beta*r1, DJ(x, n)) end proc;

proc (r) options operator, arrow; (lambda(r)+2*mu(r))*subs(x = beta*r1, DJ(x, n)) end proc

(63)

g23 := proc (r) options operator, arrow; lambda(r)*subs(x = beta*r1, DY(x, n))/r+omega^2*rho1*subs(x = beta*r1, BesselY(n, x))/beta end proc;

proc (r) options operator, arrow; lambda(r)*subs(x = beta*r1, DY(x, n))/r+omega^2*rho1*subs(x = beta*r1, BesselY(n, x))/beta end proc

(64)

g24 := proc (r) options operator, arrow; -lambda(r)*subs(x = beta*r1, DJ(x, n))/r-omega^2*rho1*subs(x = beta*r1, BesselJ(n, x))/beta end proc;

proc (r) options operator, arrow; -lambda(r)*subs(x = beta*r1, DJ(x, n))/r-omega^2*rho1*subs(x = beta*r1, BesselJ(n, x))/beta end proc

(65)

g25 := proc (r) options operator, arrow; n*lambda(r)*subs(x = beta*r1, DJ(x, n))/r end proc;

proc (r) options operator, arrow; n*lambda(r)*subs(x = beta*r1, DJ(x, n))/r end proc

(66)

g26 := proc (r) options operator, arrow; -n*lambda(r)*subs(x = beta*r1, DY(x, n))/r end proc;

proc (r) options operator, arrow; -n*lambda(r)*subs(x = beta*r1, DY(x, n))/r end proc

(67)

g27 := proc (r) options operator, arrow; alpha*lambda(r)*subs(x = beta*r1, DJ(x, n)) end proc;

proc (r) options operator, arrow; alpha*lambda(r)*subs(x = beta*r1, DJ(x, n)) end proc

(68)

g28 := proc (r) options operator, arrow; -alpha*lambda(r)*subs(x = beta*r1, DY(x, n)) end proc

proc (r) options operator, arrow; -alpha*lambda(r)*subs(x = beta*r1, DY(x, n)) end proc

(69)

q2 := proc (r) options operator, arrow; piecewise(`mod`(n, 2) <> 0, 2*i^n*A*omega*rho1/(i*Pi*beta*r1), `mod`(n, 2) = 0, 0) end proc

proc (r) options operator, arrow; piecewise(`mod`(n, 2) <> 0, 2*i^n*A*omega*rho1/(i*Pi*beta*r1), `mod`(n, 2) = 0, 0) end proc

(70)

g31 := proc (r) options operator, arrow; mu(r) end proc;

proc (r) options operator, arrow; mu(r) end proc

(71)

g32 := proc (r) options operator, arrow; -n*mu(r)/r end proc;

proc (r) options operator, arrow; -n*mu(r)/r end proc

(72)

g33 := proc (r) options operator, arrow; -mu(r)/r end proc;

proc (r) options operator, arrow; -mu(r)/r end proc

(73)

g41 := proc (r) options operator, arrow; mu(r) end proc;

proc (r) options operator, arrow; mu(r) end proc

(74)

g42 := proc (r) options operator, arrow; n*mu(r)/r end proc;

proc (r) options operator, arrow; n*mu(r)/r end proc

(75)

g43 := proc (r) options operator, arrow; -mu(r)/r end proc;

proc (r) options operator, arrow; -mu(r)/r end proc

(76)

g51 := proc (r) options operator, arrow; mu(r) end proc;

proc (r) options operator, arrow; mu(r) end proc

(77)

g52 := proc (r) options operator, arrow; -alpha*mu(r) end proc;

proc (r) options operator, arrow; -alpha*mu(r) end proc

(78)

g61 := proc (r) options operator, arrow; mu(r) end proc;

proc (r) options operator, arrow; mu(r) end proc

(79)

g62 := proc (r) options operator, arrow; alpha*mu(r) end proc;

proc (r) options operator, arrow; alpha*mu(r) end proc

(80)

``

sys := (diff(x1(r), `$`(r, 2)))*f11(r)+(diff(x1(r), r))*f12(r)+(diff(y2(r), r))*f13(r)+(diff(y3(r), y3))*f14(r)+x1(r)*f15(r)+y2(r)*f16(r)+y3(r)*f17(r) = 0, (diff(y1(r), `$`(r, 2)))*f21(r)+(diff(y1(r), r))*f22(r)+(diff(x2(r), `$`(r, 1)))*f23(r)+(diff(x3(r), r))*f24(r)+y1(r)*f25(r)+x2(r)*f26(r)+x3(r)*f27(r) = 0, (diff(x2(r), `$`(r, 2)))*f31(r)+(diff(y1(r), r))*f32(r)+(diff(x2(r), `$`(r, 1)))*f33(r)+y1(r)*f34(r)+x2(r)*f35(r)+x3(r)*f36(r) = 0, (diff(y2(r), `$`(r, 2)))*f41(r)+(diff(x1(r), r))*f42(r)+(diff(y2(r), r))*f43(r)+x1(r)*f44(r)+y2(r)*f45(r)+y3(r)*f46(r) = 0, (diff(x3(r), `$`(r, 2)))*f51(r)+(diff(y1(r), r))*f52(r)+(diff(x3(r), r))*f53(r)+y1(r)*f54(r)+x2(r)*f55(r)+x3(r)*f56(r) = 0, (diff(y3(r), `$`(r, 2)))*f61(r)+(diff(x1(r), r))*f62(r)+(diff(y3(r), r))*f63(r)+x1(r)*f64(r)+y2(r)*f65(r)+y3(r)*f66(r) = 0;

11*(diff(diff(x1(r), r), r))*r^3+(diff(x1(r), r))*[22*r^2]-7*(diff(y2(r), r))*r^2+x1(r)*[-4*(3+r^2)*r+49*r^2]+y2(r)*[12*r]-3*y3(r)*r^2 = 0, 11*(diff(diff(y1(r), r), r))*r^3+(diff(y1(r), r))*[22*r^2]+7*(diff(x2(r), r))*r^2+7*(diff(x3(r), r))*r^3+y1(r)*[-4*(3+r^2)*r+49*r^2]+x2(r)*[-12*r]+3*x3(r)*r^2 = 0, 4*(diff(diff(x2(r), r), r))*r^3-7*(diff(y1(r), r))*r^2+8*(diff(x2(r), r))*r^2-19*y1(r)*r+x2(r)*[-7*r-4*(3+r^2)*r+49*r^2]-7*x3(r)*r^2 = 0, 4*(diff(diff(y2(r), r), r))*r^3+7*(diff(x1(r), r))*r^2+8*(diff(y2(r), r))*r^2+19*x1(r)*r+y2(r)*[-7*r-4*(3+r^2)*r+49*r^2]-7*y3(r)*r^2 = 0, 4*(diff(diff(x3(r), r), r))*r^3-7*(diff(y1(r), r))*r^3+8*(diff(x3(r), r))*r^2+y1(r)*[-11*r^2]-7*x2(r)*r^2+x3(r)*[-4*(1+2*r^2)*r-3*r^3+49*r^2] = 0, 4*(diff(diff(y3(r), r), r))*r^3+7*(diff(x1(r), r))*r^3+8*(diff(y3(r), r))*r^2+x1(r)*[11*r^2]-7*y2(r)*r^2+y3(r)*[-4*(1+2*r^2)*r-3*r^3+49*r^2] = 0

(81)

a11 := (D(x1))(r1);

(D(x1))(5)

(82)

a12 := (D(y1))(r1);

(D(y1))(5)

(83)

a21 := (D(x2))(r1);

(D(x2))(5)

(84)

a22 := (D(y2))(r1);

(D(y2))(5)

(85)

a31 := (D(x3))(r1);

(D(x3))(5)

(86)

a32 := (D(y3))(r1);

(D(y3))(5)

(87)

Inits := a11*evalf(g11(r1))+a12*evalf(g12(r1))+x1(r1)*evalf(g13(r1))+y1(r1)*evalf(g14(r1))+x2(r1)*evalf(g15(r1))+y2(r1)*evalf(g16(r1))+x3(r1)*evalf(g17(r1))+y3(r1)*evalf(g18(r1)) = evalf(q1(r1)), a11*evalf(g21(r1))+a12*evalf(g22(r1))+x1(r1)*evalf(g23(r1))+y1(r1)*evalf(g24(r1))+x2(r1)*evalf(g25(r1))+y2(r1)*evalf(g26(r1))+x3(r1)*evalf(g27(r1))+y3(r1)*evalf(g28(r1)) = evalf(q2(r1)), a21*g31(r1)+y1(r1)*g32(r1)+x2(r1)*g33(r1) = 0, a22*g41(r1)+x1(r1)*g42(r1)+y2(r1)*g43(r1) = 0, a31*g51(r1)+y1(r1)*g52(r1) = 0, a32*g61(r1)+x1(r1)*g62(r1) = 0, x1(r2) = 0, x2(r2) = 0, x3(r2) = 0, y1(r2) = 0, y2(r2) = 0, y3(r2) = 0;

-6.164451908*(D(x1))(5)+18.59496397*(D(y1))(5)-64.54175380*x1(5)-27.96690534*y1(5)+1.014270762*x2(5)+.3362428313*y2(5)+5.071353808*x3(5)+1.681214157*y3(5) = 0., -18.59496397*(D(x1))(5)-6.164451908*(D(y1))(5)+27.96690534*x1(5)+64.54175380*y1(5)-.3362428313*x2(5)+1.014270762*y2(5)-1.681214157*x3(5)+5.071353808*y3(5) = 28.52056579, 20*(D(x2))(5)-4*y1(5)-4*x2(5) = 0, 20*(D(y2))(5)+4*x1(5)-4*y2(5) = 0, 20*(D(x3))(5)-20*y1(5) = 0, 20*(D(y3))(5)+20*x1(5) = 0, x1(3) = 0, x2(3) = 0, x3(3) = 0, y1(3) = 0, y2(3) = 0, y3(3) = 0

(88)

dde := dsolve({Inits, sys}, numeric)

Error, (in fproc) unable to store '[0.183848448391796e-1]+0.389981557194716e-2' when datatype=float[8]

 

NULL


 

Download ODU.mw

 

Dear maple experts,

as far as I know premultiplication of matrix A with matrix B is only possible if the number of columns of A is equal to the number of rows of B (matrices are conformable). Not so in Maple: strange.mw

I expected an error message, so I would receive feedback that I made an error.

what's going on?

kind regards,

Harry Garst

 

typematch({2}, set({x :: integer, y :: even}), 's'), s;

 

Hello dear!

Hope everyone is fine. I am facing problem to fins the inverse transfrom in the attached file. Please find the attachment and fix the problem. Thanks in advance

Help.mw

Dears,

Let C a square in the n-diemnsional Euclidean space. Somebody know how to divide C into 2^{n} congruent subsquares? 

For instance, for n=2 and  say C:=[0,1]x[0,1], the unit closed square, we will obtain the 2^{2}=4 subsquares [0,1/4]x[0,1/4], [0,1/4]x[1/2], [1/2,1]x[0,1/4] and [1/2,1]x[1/2,1].  

Many thanks in advance for your comments!!

Hello everybody!

I have Z which is a function of (b,p)! and two parameters g and d :

Z=p*b*d+2*g^p^2*b^2-2*sqrt(p*g*(b-1)*(b*g*p-b*p-g*p-4*d+p))

I want to plot Z vs. g (1<g<4) and explore with d, note that in plot i want Z to be maximum (it is obvious that we must find b and p optimal and then find Z optimal). in maximization consider we have this constraints: {b <= 1, 1-2*d/(p*(sqrt(g)+1)) <= b}

thank you in advance for your help!

I just started using Maple for civil engineering calculations and cant figure out how to manage units.  And all of the civil engineering Maple document examples I have seen are done as unitless calculations, sidestepping that issue.  Are there any examples available that show how to manage units to be more usable for civil engineering?  An example where I am having trouble involves pressure:

If I define f:=60 ksi; the result is displayed as 60,000 lbf/in^2

But if I apply that pressure over an area,

F:= f * 1 inch^2;   the result is displayed as "1930442.91 poundals"  And poundals is a totally foreign unit to me and anyone who might look at my calculations.

I would like to be able to display that as either lbf or kip but neither is on the list of options if I right click 'poundals' and try to 'affix units'.  I'm hoping there is an easy way to do this.  It was extremely easy in mathcad but I had to ditch mathcad because it is now crazy expensive.

thanks

Nick

 

 

 

Hi everyone

I have a problem with differentiating an equation. I have the following code:


(sum((x(i)-M)^3, i = 1 .. n))/(n*((sum((x(i)-M)^2, i = 1 .. n))/(n-1))^(3/2));


The values of x(i) is available in Excel and I want to import that. For this case, I copy the column and paste in maple and it seems work fine. But, I want to calculate the differentiate of the summation with respect to x(i) and M and find the answer. I don't know how to write the code appropriately.

In other words, how could I differetiate the following function with respect to x(i) and put the values from excel into it.

(sum((x(i)-M)^3, i = 1 .. n))/(n*((sum((x(i)-M)^2, i = 1 .. n))/(n-1))^(3/2));

 

Thank you so much for your kind attentions  in advance

 

I have been working some plots using piecewise, and this seem to always result in graphs with very jagged edges

Example: https://i.imgur.com/ZBOSDsL.png

The function its plotting is this one:

f:=unapply(piecewise(x^2+y^2 <= 1 and x>=0, 4*x*y^2-x^2, undefined),x,y):

Now I assume this happens because of the piecewise part. How do I smoothen the edges?

Hi there,

I am doing an exercise which asked me to perform a taylor expansion for an arbitrary function of 2 variables (x,y) around an arbitrary point (x0,y0). Here's what I've got:
Question.mw


In the above,s and u are any 2 functions of interest.x0 and y0 are the coordinates of the point of expansion.I guess there was something wrong with s and u.What should I type in,in order to make any bi-variate functions as parameters in my procedure?
 

First 910 911 912 913 914 915 916 Last Page 912 of 2428