MaplePrimes Questions

Put x=f1(t1,t2,t3), y=f2(t1,t2,t3), z=f3(t1,t2,t3).  

The question is that: How to plot all points of form [x,y,z] with t1 in [a1,b1], t2 in [a2,b2], t3 in [a3,b3].

Thank you.

hi.

please help me for remover this problem.

''''

-Float(infinity)*signum((5.*A3*A1-24.*A2^2)*A1/A2^2)''''

ReducedCantiler.mw
 

restart

f := -(2/3)*eta^3+(1/2)*eta^2+eta; -1; g := -eta^2+1; -1; h := -eta^2+1; 1; F := proc (eta) options operator, arrow; A1*f end proc; 1; G := proc (eta) options operator, arrow; A2*g end proc; 1; H := proc (eta) options operator, arrow; A3*h end proc

proc (eta) options operator, arrow; A3*h end proc

(1)

Q1 := diff(F(eta), eta, eta, eta)+.5*H(eta)*((diff(F(eta), eta))^2+F(eta)*(diff(F(eta), eta, eta)))/G(eta)^2+2*(diff(G(eta), eta))*(diff(F(eta), eta, eta))/G(eta)-(diff(H(eta), eta))*(diff(F(eta), eta, eta))/H(eta); 1; Q2 := diff(G(eta), eta, eta)+H(eta)*((diff(F(eta), eta))*G(eta)+.5*F(eta)*(diff(eta, eta)))/G(eta)^2+2*(diff(G(eta), eta))^2/G(eta)-((diff(H(eta), eta))*(diff(H(eta), eta)))/H(eta)+(diff(F(eta), eta, eta))^2-(H(eta)/G(eta))^2; 1; Q3 := diff(H(eta), eta, eta)+(.5*1.3)*H(eta)*(5*(diff(F(eta), eta))*H(eta)+F(eta)*(diff(H(eta), eta)))/G(eta)^2+2*(diff(G(eta), eta))*(diff(H(eta), eta))/G(eta)-(diff(H(eta), eta))^2/H(eta)+(1.3*1.44)*H(eta)*(diff(F(eta), eta, eta))/G(eta)-(1.3*1.92)*(H(eta)/G(eta))^3

-2*A3+.65*A3*(5*A1*(-2*eta^2+eta+1)*A3*(-eta^2+1)-2*A1*(-(2/3)*eta^3+(1/2)*eta^2+eta)*A3*eta)/((-eta^2+1)*A2^2)+4*A3*eta^2/(-eta^2+1)+1.872*A3*A1*(-4*eta+1)/A2-2.496*A3^3/A2^3

(2)

Eq1 := int(Q1*f, eta = 0 .. 1);

-0.2600000000e-1*A3*(24.*A1*A2^2-65.*A1*A2*A3+64.*A3^2)/A2^3

(3)

sol := solve({Eq1 = 0, Eq2 = 0, Eq3 = 0}, {A1, A2, A3}); J := min(select(`>`, sol, 0))

Error, invalid input: `>` expects 2 arguments, but received 1

 

A11 := evalf(simplify(sol[1, 1])); A22 := evalf(simplify(sol[1, 2])); A33 := evalf(simplify(sol[1, 3]))

Error, invalid subscript selector

 

``


 

Download ReducedCantiler.mw

 

Hello.

I've just installed Maple 2015 and when I started it, this happened

It seemed that something was wrong with the graphics or java. But I really don't know what to do next.

Please help me, thank you.

Say I define the following variables.

These are all nineth roots of unity. An equivalent definition would be:

 

In fact, the following code shows that aa[i] /a[i] =1 for all i, so one would concluse aa[i]=a[i]:

for i to 9 do 
simplify(a[i]/aa[i])
end do

But when I try to check via "Equal":

I get as output

                              true
                             false
                             false
                             false
                             false
                             false
                              true
                             false
                             false
The problem goes even further since one representation is accepted as a solution of a linear equation system while the other is not.

 

Another curiosity:

gives just the same expression, whereas simplifying the same expression to the third power gives 0.

Guys,

I am not very familiar with Maple and have to solve quite a complex equation.

I have an equation which is complex ,containing I . I split this equation up in Re=0 an Im=0 . I have to get an answer in function of other parameters, in order to plot these... Maybe it s easier if you look at the work sheet


 

restart

with(LinearAlgebra):

Student(NumericalAnalysis)

(module Student () description "a package to assist with the teaching and learning of standard undergraduate mathematics"; local ModuleLoad, localColors, GetColor, SelectColor, UpdateColor, GetCaption, colorNum, colorDefaults, Defaults, PlotOptionsWindow, InitAnimation, EndAnimation, DoPlayPause, IncrSpd, DecrSpd, Colours, CheckPoint, CheckRange, CheckTextField, CleanFloat, CombineRanges, EvaluateFunction, FindHRange, FindHRange3d, FindVRange, FindVRange3d, GetSpecPoints, EvaluateFunctionNumeric, EvaluateFunctionNumeric3d, VRangeCmp, MaximizePointList, MinimizePointList, FindHRange3dCrossSections, FindVRangeSymbolic, SymEvalFunc, SymLimits, FindAllSpecialPoints, FindHRangeRatPoly, GetRealDomain, GetTextField, GetVariable, IsColour, MapletGenericError, MapletNoInputError, MapletTypeError, ProcessCharacter, ProcessVisual, RequiredError, RemovePlotOptions, mapletColor, mapletDarkColor, mapletLightColor, mapletHelpColor, IsMac, ProcessColorNames; export _pexports, SetColors, SetDefault, SetDefaults, Precalculus, MultivariateCalculus, VectorCalculus, LinearAlgebra, Statistics, Calculus1, NumericalAnalysis, Basics; global x, y, z, r, t, p; option package, `Copyright (c) Maplesoft, a division of Waterloo Maple Inc. 2005`; end module)(NumericalAnalysis)

(1)

wn := 50

50

(2)

Np := 2

2

(3)

``

``

w0 := v0*wn

50*v0

(4)

V0 := 230*sqrt(2)

230*2^(1/2)

(5)

Ep0 := 1.5*V0

345.0*2^(1/2)

(6)

NULL

delta := 0

0

(7)

phi[q0] := 0

0

(8)

Iq0 := 0

0

(9)

L := proc (p) options operator, arrow; Ls*(p*tau[r]+1)/(p*tau[r]/sigma+1) end proc

proc (p) options operator, arrow; Ls*(p*tau[r]+1)/(p*tau[r]/sigma+1) end proc

(10)

Rs := 2.43

2.43

(11)

Rr := 2.43

2.43

(12)

Lr := 0.12e-1+.237

.249

(13)

Ls := Lr

.249

(14)

M := sqrt(.92*Ls^2)

.2388324099

(15)

sigma := 1-M^2/(Ls*Lr)

0.799999996e-1

(16)

``

tau[r] := sigma*Lr*wn/Rr

.4098765412

(17)

tau[s] := sigma*Ls*wn/Rs

.4098765412

(18)

alpha := tau[r]/tau[s]

1.000000000

(19)

``

``

``

``

assume(v0, 'real', nu, 'real')

``

345.0*2^(1/2)

(20)

phi[d0] := Ls*Id0-Ep0/w0

.249*Id0-6.900000000*2^(1/2)/v0

(21)

Vd0 := V0*sin(delta)

0

(22)

Vq0 := V0*cos(delta)

230*2^(1/2)

(23)

Id0 := (Rs*Vd0-wn*v0*Ls*(Vq0-Ep0))/(Ls^2*w0^2+Rs^2)

1431.7500*v0*2^(1/2)/(155.002500*v0^2+5.9049)

(24)

Dp := (Rs+p*wn*L(p))^2+v0*wn^2*L(p)^2

(2.43+12.450*p*(.4098765412*p+1)/(5.123456791*p+1))^2+155.002500*v0*(.4098765412*p+1)^2/(5.123456791*p+1)^2

(25)

simplify(Dp)

(26.04023075*p^4+254.1275544*p^3+(644.8103998+26.04023074*v0)*p^2+(121.014+127.0637772*v0)*p+5.9049+155.0025*v0)/(5.123456791*p+1.)^2

(26)

N := -(3/2)*Np*[[L(p)^2*(Id0*phi[d0]+Iq0*phi[q0])-L(p)*(phi[d0]^2-phi[q0]^2)]*(p^2+v0^2)*wn^2+Rs*[p*L(p)^2*(Id0^2+Iq0^2)-p*(phi[d0]^2+phi[q0]^2)]*wn+Rs^2*[L(p)*Iq0^2+L(p)*Id0^2-Id0*phi[d0]-Iq0*phi[q0]]]

[-7500*[88.76993175*(.4098765412*p+1)^2*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/((5.123456791*p+1)^2*(155.002500*v0^2+5.9049))-.249*(.4098765412*p+1)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2/(5.123456791*p+1)]*(p^2+v0^2)+[-18084126.16*(.4098765412*p+1)*v0^2/((5.123456791*p+1)*(155.002500*v0^2+5.9049)^2)+25363.02172*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(155.002500*v0^2+5.9049)-92653238.97*p*(.4098765412*p+1)^2*v0^2/((5.123456791*p+1)^2*(155.002500*v0^2+5.9049)^2)+364.5000000*p*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2]]

(27)

char := (p*J*wn^2/Np*p)*Dp+N

1250*p^2*J*((2.43+12.450*p*(.4098765412*p+1)/(5.123456791*p+1))^2+155.002500*v0*(.4098765412*p+1)^2/(5.123456791*p+1)^2)+[-7500*[88.76993175*(.4098765412*p+1)^2*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/((5.123456791*p+1)^2*(155.002500*v0^2+5.9049))-.249*(.4098765412*p+1)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2/(5.123456791*p+1)]*(p^2+v0^2)+[-18084126.16*(.4098765412*p+1)*v0^2/((5.123456791*p+1)*(155.002500*v0^2+5.9049)^2)+25363.02172*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(155.002500*v0^2+5.9049)-92653238.97*p*(.4098765412*p+1)^2*v0^2/((5.123456791*p+1)^2*(155.002500*v0^2+5.9049)^2)+364.5000000*p*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2]]

(28)

eval(char)

1250*p^2*J*((2.43+12.450*p*(.4098765412*p+1)/(5.123456791*p+1))^2+155.002500*v0*(.4098765412*p+1)^2/(5.123456791*p+1)^2)+[-7500*[88.76993175*(.4098765412*p+1)^2*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/((5.123456791*p+1)^2*(155.002500*v0^2+5.9049))-.249*(.4098765412*p+1)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2/(5.123456791*p+1)]*(p^2+v0^2)+[-18084126.16*(.4098765412*p+1)*v0^2/((5.123456791*p+1)*(155.002500*v0^2+5.9049)^2)+25363.02172*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(155.002500*v0^2+5.9049)-92653238.97*p*(.4098765412*p+1)^2*v0^2/((5.123456791*p+1)^2*(155.002500*v0^2+5.9049)^2)+364.5000000*p*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2]]

(29)

p := I*nu

I*nu

(30)

R := Re(char)

Re(-1250*nu^2*J*((2.43+(12.450*I)*nu*((.4098765412*I)*nu+1)/((5.123456791*I)*nu+1))^2+155.002500*v0*((.4098765412*I)*nu+1)^2/((5.123456791*I)*nu+1)^2)+[-7500*[88.76993175*((.4098765412*I)*nu+1)^2*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(((5.123456791*I)*nu+1)^2*(155.002500*v0^2+5.9049))-.249*((.4098765412*I)*nu+1)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2/((5.123456791*I)*nu+1)]*(-nu^2+v0^2)+[-18084126.16*((.4098765412*I)*nu+1)*v0^2/(((5.123456791*I)*nu+1)*(155.002500*v0^2+5.9049)^2)+25363.02172*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(155.002500*v0^2+5.9049)-(92653238.97*I)*nu*((.4098765412*I)*nu+1)^2*v0^2/(((5.123456791*I)*nu+1)^2*(155.002500*v0^2+5.9049)^2)+(364.5000000*I)*nu*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2]])

(31)

im := Im(char)

Im(-1250*nu^2*J*((2.43+(12.450*I)*nu*((.4098765412*I)*nu+1)/((5.123456791*I)*nu+1))^2+155.002500*v0*((.4098765412*I)*nu+1)^2/((5.123456791*I)*nu+1)^2)+[-7500*[88.76993175*((.4098765412*I)*nu+1)^2*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(((5.123456791*I)*nu+1)^2*(155.002500*v0^2+5.9049))-.249*((.4098765412*I)*nu+1)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2/((5.123456791*I)*nu+1)]*(-nu^2+v0^2)+[-18084126.16*((.4098765412*I)*nu+1)*v0^2/(((5.123456791*I)*nu+1)*(155.002500*v0^2+5.9049)^2)+25363.02172*v0*2^(1/2)*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)/(155.002500*v0^2+5.9049)-(92653238.97*I)*nu*((.4098765412*I)*nu+1)^2*v0^2/(((5.123456791*I)*nu+1)^2*(155.002500*v0^2+5.9049)^2)+(364.5000000*I)*nu*(356.5057500*v0*2^(1/2)/(155.002500*v0^2+5.9049)-6.900000000*2^(1/2)/v0)^2]])

(32)

``

simplify(im)

Im(((32550.28842*nu^4*J-(158829.7215*I)*nu^3*J-193753.125*nu^2*J)*v0-32550.28844*nu^6*J+(317659.4430*I)*nu^5*J+806012.9998*nu^4*J-(151267.5000*I)*nu^3*J+(-7381.125*J+[196873.5712*[-177.5398635*((.4098765412*I)*nu+1.)^2*(713.0115000*v0^2+40.74381000)/(((5.123456791*I)*nu+1.)^2*(155.002500*v0^2+5.9049)*(155.0025000*v0^2+5.904900000))-.4979999998*((.4098765412*I)*nu+1)*(713.0115*v0^2+40.74381)^2/(((5.123456791*I)*nu+1.)*v0^2*(155.0025*v0^2+5.9049)^2)]*(-nu^2+v0^2)+[474704866.5*((.4098765412*I)*nu+1)*v0^2/(((5.123456791*I)*nu+1.)*(155.002500*v0^2+5.9049)^2)-26.24980949*(-36168252.32*v0^2-2066772.276)/(155.0025*v0^2+5.9049)^2+(2432129872.*I)*nu*((.4098765412*I)*nu+1.)^2*v0^2/(((5.123456791*I)*nu+1.)^2*(155.002500*v0^2+5.9049)^2)-(19136.11111*I)*nu*(713.0115*v0^2+40.74381)^2/(v0^2*(155.0025*v0^2+5.9049)^2)]])*nu^2+(10.24691358*I)*[-7500*[-177.5398635*((.4098765412*I)*nu+1.)^2*(713.0115000*v0^2+40.74381000)/(((5.123456791*I)*nu+1.)^2*(155.002500*v0^2+5.9049)*(155.0025000*v0^2+5.904900000))-.4979999998*((.4098765412*I)*nu+1)*(713.0115*v0^2+40.74381)^2/(((5.123456791*I)*nu+1.)*v0^2*(155.0025*v0^2+5.9049)^2)]*(-nu^2+v0^2)+[-18084126.16*((.4098765412*I)*nu+1)*v0^2/(((5.123456791*I)*nu+1.)*(155.002500*v0^2+5.9049)^2)+(-36168252.32*v0^2-2066772.276)/(155.0025*v0^2+5.9049)^2-(92653238.97*I)*nu*((.4098765412*I)*nu+1.)^2*v0^2/(((5.123456791*I)*nu+1.)^2*(155.002500*v0^2+5.9049)^2)+(728.9999996*I)*nu*(713.0115*v0^2+40.74381)^2/(v0^2*(155.0025*v0^2+5.9049)^2)]]*nu+[-7500*[-177.5398635*((.4098765412*I)*nu+1.)^2*(713.0115000*v0^2+40.74381000)/(((5.123456791*I)*nu+1.)^2*(155.002500*v0^2+5.9049)*(155.0025000*v0^2+5.904900000))-.4979999998*((.4098765412*I)*nu+1)*(713.0115*v0^2+40.74381)^2/(((5.123456791*I)*nu+1.)*v0^2*(155.0025*v0^2+5.9049)^2)]*(-nu^2+v0^2)+[-18084126.16*((.4098765412*I)*nu+1)*v0^2/(((5.123456791*I)*nu+1.)*(155.002500*v0^2+5.9049)^2)+(-36168252.32*v0^2-2066772.276)/(155.0025*v0^2+5.9049)^2-(92653238.97*I)*nu*((.4098765412*I)*nu+1.)^2*v0^2/(((5.123456791*I)*nu+1.)^2*(155.002500*v0^2+5.9049)^2)+(728.9999996*I)*nu*(713.0115*v0^2+40.74381)^2/(v0^2*(155.0025*v0^2+5.9049)^2)]])/((5.123456791*I)*nu+1.)^2)

(33)

solve(im = 0)

Warning, solve may be ignoring assumptions on the input variables.

 

Error, (in Engine:-Dispatch) badly formed input to solve: not fully algebraic

 

``

``

Error, (in fsolve) b is in the equation, and is not solved for

 

-I*b/l

(34)

``


 

Download operationele_inductanties.mwoperationele_inductanties.mw
 

How to find the integral of (x+y)/(x+y+z) over the part of the unit ball  centered at the origin which lies in the positive octant { x>=0 , y>=0, z>=0 } ? Numeric calculations suggest Pi/9.

How to find the double integral of sin(x^2)*cos(y^2) over the disk of radius R which is centered at the origin? 

Here is my try 

restart; evalf(VectorCalculus:-int(sin(x^2)*cos(y^2), [x, y] = Circle(`<,>`(0, 0), 1), inert), 15);
                       0.722091449378409
identify(%);
                       0.722091449378409

 

Hello people in mapleprimes,

I want to modify the following expression a to b. For it, I used c code.
But, as seen in d, just using c returns a. Originally, I intended phi being between 0 and 1, so
that 1-phi >0. Isn't any better way to modify a to b? and it is better to have maple sort expression remembering 1-phi to be positive, and to have maple give any priority to it in modifying a to b.

a:=(-2*theta+1)*phi/(phi-1)+theta;
b:=(2*theta-1)*phi/(-phi+1)+theta;
c:=simplify(-1*numer(op(1,aa)))/simplify((-1)*denom(op(1,aa)))+theta;
d:=simplify(c)
(-2*theta+1)*phi/(phi-1) + theta

I will be very glad if you borrow me your idea.

Thank you in advance.

Dear all, 

We are trying to use a fortran subroutine in maple using external calling. I was able to get the 'multiply' example working. i.e. through the steps descibed here: http://www.mapleprimes.com/questions/203646-External-Calling-FORTRAN-Dll--Error 

My mult.f looks like this: 

    subroutine multiply(a,b)
    real a,b,mult
    mult=a*b
    return 
    end

It simply takes two arguments (Real), and returns the product. I used the following commands to build the dll: 

1. gfortran -c mult.f        ## This creates the object file mult.o, which is used later. 

2. gfortran -shared -mrtd -o mult.dll mult.o ## This creates the dll and can be used in maple. 

The command in maple looks like this : 

mult := define_external("multiply",LIB="C:/shared/mult.dll",FORTRAN,'a'::(float[4]),'b'::(float[4]), RETURN::(float[4]));

And finally, 

mult(3., 3.) ## works, if it gives the correct output. 

Few things to note here are: 

1. The dll has to be generated from inside the Cygwin64 shell, with cygwin64/bin in the system path. 

2. This only worked for (some) 64-bit Maple version (Maple 2016 Standard). 

The reason, I repeated a working example, was because I tried following the same steps for the more complicated case, however without success so far.  This post explains an approach on how to pass a subroutine as an argument to a fortran subroutine in the dll. http://www.mapleprimes.com/posts/37031-Calling-An-External-Routine-That-Needs However the post is old and the steps did not work for me. 

My system is as follows: 

1. Fortran file to generate the dll, takefunc.f , takes a subroutine as an argument and calls it. 

    subroutine take(func)
    external func
    call func()
    end

2. Fortran driver file to verify that the dll generated through this program works: 

    PROGRAM main
    external take, fun
    call take(fun)
    END
    
    SUBROUTINE fun()
    PRINT *, "This is a nice one"
    END

I want the step 2 to be performed in maple, i.e. fun() should be a maple procedure, and we should be able to use either WRAPPER or second dll to use take() in maple. 

I want the process to work with latest maple versions and compilers, Windows7 64-bit or 32-bit (and hopefully later). F77 is fine. 

Regret the long post, will keep this post updated if I make any progress. Any guidance in this matter is highly appreciated. Anyway to make define_external spew more debug information will also help. 

- Chintan Pathak 

Research Scientist,

ChemE, University of Washington. 

Hi All,

To get EOM of a specific type of vibrating shell structure, I constructed the Hamilton equation of the system with messy and complex integrand (so many derivatives and variables are included). Now I have to calculate the variation of the Hamilton equation (del(int((T+U-V),t=t0..t1)=0) to get the EOMs and BCs of the system.

Is there anybody to know how to take a variation of such bulky integral in Maple?

Is there anyone to have experience in finding the EOM of shell structure using variational calculus in Maple?

Any comment will be useful.

Regards,

 

restart;
with(Statistics):
with(LinearAlgebra):
with(Optimization):
Digits:=10:

                      #********************************************#
lambda:=6328*10^(-10);
w0:=0.0005;
a0:=0.0004; 
z0:= a0^2/(4*lambda);  
N:=(a0^2)/(z0*lambda); 

                      #*********************************************#


u0:=x->((2/(w0*sqrt(2)))*sqrt(1./Pi))*LaguerreL(0,0.,2.*(x*a0)^2/w0^2)*exp(-(x*a0)^2/w0^2);

                                 
           #*****************************************************************
u1:=y->evalf(I*2*Pi*N*exp(-I*Pi*N*((a0*y)/a0)^2)*evalf(int(x*u0(x)*exp(-I*Pi*N*x^2)*BesselJ(0,2*Pi*N*(a0*y)*x/a0),x=0..1)));

          #*****************************************************************

u2:=r2->evalf(I*2*Pi*N*exp(-I*Pi*N*(r2/a0)^2)*evalf(int(y*u1(y)*exp(-I*Pi*N*y^2)*BesselJ(0,2*Pi*N*r2*y/a0),y=0..1)));

          #*****************************************************************
u3:=r3->evalf(I*2*Pi*N*exp(-I*Pi*N*(r3/a0)^2)*evalf(int(z*u2(z)*exp(-I*Pi*N*z^2)*BesselJ(0,2*Pi*N*r3*z/a0),z=0..1)));

 plot(abs(u3(r3)),r3=-0.0008..0.0008);

 

I have a code to write the equation of the plane passing through three points

restart:
with(geom3d):
point(A,1,-1,3):
point(B,-15,-17,11):
point(C,2,1,0):
plane(P,[A,B,C],[x,y,z]):
n:=NormalVector(P):
cdn:=ilcm(op(denom~(n))):
n:=cdn*n:
k:=igcd(n[1],n[2],n[3]):
if n[1]<>0 then sign(n[1])*cdn/k*sort(Equation(P))
elif n[2] <> 0 then sign(n[2])*cdn/k*sort(Equation(P))
else sign(n[3])*cdn/k*sort(Equation(P))
end;

How do I write the equation of the plane passing through list of following three points?
L := [[[-12, 2, -1], [-11, 1, -5], [-10, -2, 3]], [[-12, 2, -1], [-11, 1, -5], [-10, 6, 3]], [[-12, 2, -1], [-11, 1, -5], [-9, 5, -7]], [[-12, 2, -1], [-11, 1, -5], [-9, 8, -4]], [[-12, 2, -1], [-11, 1, -5], [-7, -6, -2]], [[-12, 2, -1], [-11, 1, -5], [-7, -2, -8]], [[-12, 2, -1], [-11, 1, -5], [-7, -2, 6]], [[-12, 2, -1], [-11, 1, -5], [-7, 3, -9]], [[-12, 2, -1], [-11, 1, -5], [-7, 3, 7]], [[-12, 2, -1], [-11, 1, -5], [-7, 6, -8]], [[-12, 2, -1], [-11, 1, -5], [-7, 9, 3]], [[-12, 2, -1], [-11, 1, -5], [-7, 10, -2]], [[-12, 2, -1], [-11, 1, -5], [-6, -4, -7]], [[-12, 2, -1], [-11, 1, -5], [-6, -4, 5]], [[-12, 2, -1], [-11, 1, -5], [-6, 8, -7]], [[-12, 2, -1], [-11, 1, -5], [-6, 8, 5]], [[-12, 2, -1], [-11, 1, -5], [-4, -6, 3]], [[-12, 2, -1], [-11, 1, -5], [-4, -2, -9]], [[-12, 2, -1], [-11, 1, -5], [-4, -2, 7]], [[-12, 2, -1], [-11, 1, -5], [-4, 6, -9]], [[-12, 2, -1], [-11, 1, -5], [-4, 6, 7]], [[-12, 2, -1], [-11, 1, -5], [-4, 10, 3]], [[-12, 2, -1], [-11, 1, -5], [-2, -6, 3]], [[-12, 2, -1], [-11, 1, -5], [-2, 6, -9]], [[-12, 2, -1], [-11, 1, -5], [-2, 6, 7]], [[-12, 2, -1], [-11, 1, -5], [-2, 10, 3]], [[-12, 2, -1], [-11, 1, -5], [3, 5, -7]], [[-12, 2, -1], [-11, 1, -5], [3, 8, -4]], [[-12, 2, -1], [-11, 1, -5], [4, -2, 3]], [[-12, 2, -1], [-11, 1, -5], [4, 6, 3]], [[-12, 2, -1], [-11, 1, -5], [5, 6, -2]], [[-12, 2, -1], [-11, 1, 3], [-10, -2, -5]], [[-12, 2, -1], [-11, 1, 3], [-10, 6, -5]], [[-12, 2, -1], [-11, 1, 3], [-9, 5, -7]], [[-12, 2, -1], [-11, 1, 3], [-9, 8, -4]], [[-12, 2, -1], [-11, 1, 3], [-7, -6, -2]], [[-12, 2, -1], [-11, 1, 3], [-7, -2, -8]], [[-12, 2, -1], [-11, 1, 3], [-7, -2, 6]], [[-12, 2, -1], [-11, 1, 3], [-7, 6, -8]], [[-12, 2, -1], [-11, 1, 3], [-7, 9, -5]]]

Friends

I have plotted some figures and saved them yesterfay!

now once i opened them some nonsence digits appear on the figure! see the picture please. anyone has similar experience? how to solve it!

Dont make me disappointed maple! two days work is invain now !

 

**I am trying write a procedure (bit(n,k)) that print all the binary sequences with 2 following conditions:
  - Each of the sequences has the length of 'n'. (n elements)
 - k bits of n elements have the value 1. (all the remains have the value 0)
   Example: bit(3,2) and the result is ((101),(110),(011)).
**My code:
bit := proc (n, k)
     local one, index, i, d;
     global A;
     one := 0;
     index := 1;
     A := [seq(0, i = 1 .. n)];
     d := proc (index)
        if one = k or index = n+1 then return NULL; end if;
        for i from 0 to 1 do
              A[index] := i;
              if i = 1 then one := one+1; end if;
              if one = k then print(op(A)); end if;
             d(index+1);
             if i = 1 then one := one-1; A[index] := 0; end if;
        end do;
     end proc;
     d(1);
end proc;
>bit(5,1);
result:
0, 0, 0, 0, 1
That 's not the answer for the excercise. What is the problem?

 

I have a question that I hope someone can help with. We perform extreme value analysis on expressions. My this I mean that we evaluate expressions for each combination of min or max values of each variable in the expression. For example, the expression a*b+c*d has 4 variables and we would evaluate the expression for all of the 16 combinations of a,b,c, and d to determine the worst-case result. I understand that the worst case results may not occur at the extreme values of the variables, but that is a different question.

 What I would like to know is if there is a way to reduce the number of calculations by splitting the expression into independent parts. In the example above, the expression consists of 2 parts a*b and c*d. These parts could be evaluated separately. Each has 2 variables, and each would therefore requires  4 combinations of variables to determine the extreme values of the results. So in this case, the number of calculations is 4+4=8, which is half of the initial 16  runs as would be done with a full-factorial analysis. Also, because each calculation is done on only part of the original expression, each calculation takes less time.

Is there a way to find the independent parts of an arbitrary expression so that each independent part could be evaluated separately to speed processing?

Thanks

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