Advanced Search

Maple Questions and Posts

These are Posts and Questions associated with the product, Maple
View unanswered posts
Maple Questions and Posts Feed

How to pull the number and type of operations from...

Asked by: Christopher2222 6030
November 06 2017
1  3

I think I've seen this somewhere in Mapleprimes but I can't locate it. How do you pull the type and number of operations from an equation? 

a:=3*x^3-5*x^2+3*y

                   " *,^,-,*,^,+,* "

 

Invisible Components...

Asked by: Adam Ledger 360
embedded-components
November 06 2017
1  2

If i have made a component invisible for asthetic reasons, (eg a text box) how can i undo this to edit its contents?

How to export plots using OpenMaple in Java...

Asked by: Lawful_good 10
November 06 2017
1  0

How can i export a plot using open maple in java?

engine.evaluate("Export(\"D:\\MyGraph.jpeg\", plot(sin(x)));");

and 

engine.evaluate("exportplot(\"D:\\MyGraph.jpeg\", plot(sin(x)));");

doesn't work,

exception - com.maplesoft.externalcall.MapleException: Error, (in Export) exported file D:MyGraph.jpeg could not be createdError, plotting was not implemented by the application

 

Thanks.

applyrule and hypergeom...

Asked by: _Maxim_ 734
applyrule patmatch type
November 06 2017
0  1

1. This seems wrong:

applyrule(x::symbol+y::symbol = 0, a+b);
                             a + b

2. Should these two match f(a)?

applyrule((h::anything)(a) = 0, f(a));
                              f(a)
applyrule(x::f(x1::anything) = 0, f(a));
                              f(a)

3. hypergeom will give an error if the arguments are not lists, so how to write a pattern that will match hypergeom(anything, anything, a)? This works but is... skittish:

applyrule('''hypergeom'''(x1::anything, x2::anything, a) = 0, hypergeom([], [], a));
                               0

How do i solve the distance of quasi cyclic codes ...

Asked by: Prateek 5
November 06 2017
1  0

How do i find the distance between the quasi cyclic codes in maple ?

how do i solve a system of PDE's with variable coe...

Asked by: radhika 30
differential-equations
November 06 2017
0  2

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

Designating names to points in a plot...

Asked by: John Fredsted 2253
plot points
November 06 2017
2  11

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:

Why is Maple giving me -x-yI when I want -(x+yI)?...

Asked by: mapleatha 160
November 05 2017
0  2

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 command...

Asked by: ahmer 10
November 05 2017
2  7

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

Error, (in fproc) unable to store '[0.183848448391...

Asked by: DimaBrt 105
dsolve numeric bvp
November 05 2017
1  4

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

 

matrix matrix multiplication non-conformable matri...

Asked by: Harry Garst 269
multiplication matrix linearalgebra
November 05 2017
1  1

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

What is the expected correct outcome of the follow...

Asked by: Christian Wolinski 1650
typematch
November 05 2017
0  3
 

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

 

Problem to evaluate inverse transfrom...

Asked by: Muhammad Usman 240
inverse laplace-transform
November 05 2017
0  1

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

Congruent subsquares...

Asked by: Gonzalo Garcia 155
procedure list
November 05 2017
0  10

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!!

how can i plot optimal values of a function respec...

Asked by: arjangash 25
plot optimization explore
November 05 2017
0  4

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!

First 889 890 891 892 893 894 895 Last Page 891 of 2215