MaplePrimes Questions

As the code:

poly := x^4 + 8*x + 12:
galois(poly, x)

"4T4", {"A(4)"}, "+", 12, {"(1 2 4)", "(2 3 4)"}

 Then I know it's Galois group has to be (isomorphic to) A4. And I can draw its Subgroup Lattice:

DrawSubgroupLattice(GaloisGroup(poly, x), 'indices')

But according to Galois's theory, each subgroup represents an intermediate field. As far as I know, ⑤⑥⑦⑧ are Q(r1),Q(r2),Q(r3) and Q(r4), respectively, where ri is the root of equation x^4+8x+12. But I have no idea what fields ②③④⑨ means. How do you calculate out those intermediate fields with maple?

I wanted to create an *m file with many @(x)  Matrix(x) , each of these matrices is 6-by-something , the matrices are not big in size, but they contain a LOT of sin/cos functions (of x vector). The only option I found is to use 

str := CodeGeneration:-Matlab(var,resultname = varname,output = string):

However, this takes endless time to execute despite the fact that the Maple operation to generate these matrices is, more or less, takes an acceptable time, but converting it to Matlab and output a string is an endless operation. 

I technically don't know why! These are matrices, they are not code or anything, just matercies. . 

I have a high end pc yet I couldn't get this line above to be executed in reasnable time (up to 30min!)

Dear researchers,

Greetings, I have unable to apply Nonlinear Least-Squares Methods  for an SIR parameter estimation. May you share me your Maple code model as a  sample parameter estimation ?

Thank you in advance!!!


Below is the parametric identity, which i have found empirically: sqrt[pi] =(1/(2^j) ((k*gamma[5 + 2 j] gamma[ 1 + l] hypergeometricpfq[{1, 5/2 + j, 3 + j}, {3 + j + l/2, 7/2 + j + l/2}, -1])/ gamma[6 + 2 j + l] + ((k + m) gamma[7 + 2 j] gamma[ 1 + l] hypergeometricpfq[{1, 7/2 + j, 4 + j}, {4 + j + l/2, 9/2 + j + l/2}, -1])/gamma[8 + 2 j + l]))/(2^(-5 - 3 j - l) gamma[ 5 + 2 j] gamma[ 1 + l] (k hypergeometricpfqregularized[{1, 5/2 + j, 3 + j}, {3 + j + l/2, 7/2 + j + l/2}, -1] + 1/2 (3 + j) (5 + 2 j) (k + m) hypergeometricpfqregularized[{1, 7/2 + j, 4 + j}, {4 + j + l/2, 9/2 + j + l/2}, -1]

It seems to be true for arbitrary j,k,l,m parameters where j, k, l and m are signed integer

For all tried specific sets of {j,k,l,m} above identity was confirmed by both mathematica based wolframalpha and maple.

Could this identity be simplified?

How this identity could be proven either by using mathematica and/or analyticall


Best regards,

Alexander R. Povolotsky 

Is there any reason why the intersectplot can't plot the following curve?

plots:-intersectplot( x^2 + b*x + c , b^2 - 4*c , b = -4..4, c = -4..4, x = -4..4, color = red );

But it can plot the next one!

plots:-intersectplot( x , b^2 - 4*c , b = -4..4, c = -4..4, x = -4..4, color = red );

The output in the two cases respectively are shown below.

I am a bit confused that why the color option in the following plot3d does not work.

plot3d( [ b, ( b^2 ) / 4, -b / 2 ], b = -4 .. 4, c = -4 .. 4, thickness = 5, color = red  ); 

The output is the following.

I remember that once there was an option to provide to maple a given function and it produced a suitable DE that this function solves.

Can you remind me how to do it?

I remember there was such an option in the previous versions of maple.

Thanks in advance!

Dear people,

I have resolved the primitives of the equation of the odometric model.

I have plotted them to the Maple interface and I was thinking that it can have been done by the solver.

Nevertheless it has not been possible to do it.

Can you tell me if a package of Maple can resolve it ?

Best regards,

Edern Ollivier.

This is part of a package I put together in VScode. Testing it using CMaple.exe worked fine from the code editor. Then I imported it into Maple and saved it as a package, After ra restart  using using with(....) to load it, the special types defined in the package are not recognised. Procedures that don't check for the special types work ok. I have included one of each in the worksheet. 

If I just read in the .mpl file things do work.

What is the cause of this problem?

A secondary question. If I use the same special types in another package. Would that cause a conflict if both are loaded together?


    option package;

local MyModule,RelDPxyz,ppp,xpsn,ypsn,zpsn;

MyModule:= module()
uses TT= TypeTools;
global _T1, _T2L, _T2V, _T2VR, _T3L, _T3V, _T3VC, _T3VR, _T4L, _MyType,GeomClr,Prntmsg, prjpsn;

     MyTypes:= {_T1, _T2L, _T2V, _T2VR, _T3L, _T3V, _T3VC, _T3VR, _T4L},
     AllMyTypes:= MyTypes union {_MyType},
      ModuleUnload:= proc()
     local T;
          for T in AllMyTypes do if TT:-Exists(T) then TT:-RemoveType(T) end if; end do;
     end proc;

     ModuleLoad:= proc()
          g, #iterator over module globals
          #op([2,6], ...) of a module is its globals.
          for g in op([2,6], thismodule) do
               e:= eval(g);
               if g <> e and e in AllMyTypes then
                    error "The name %1 must be globally available.", g
               end if
          end do;
          TT:-AddType(_T1, algebraic);
          TT:-AddType(_T2V, 'Vector(2, algebraic)');
          TT:-AddType(_T2VR, 'Vector[row](2, algebraic)');
          TT:-AddType(_T2L, [algebraic $ 2]);
          TT:-AddType(_T3V, 'Vector(3, algebraic)');
          TT:-AddType(_T3VC, 'Vector[column](3, algebraic)');
          TT:-AddType(_T3VR, 'Vector[row](3, algebraic)');
          TT:-AddType(_T3L, [algebraic $ 3]);
          TT:-AddType(_T4L, [algebraic $ 4]);
          TT:-AddType(_MyType, MyTypes);
     end proc;
     WhichMyType:= proc(X)
     local S:= select(T-> X::T, MyTypes), n:= nops(S);
         printf("%a is ", X);
         if n=0 then printf("not any of the special types.\n")
         else printf("type %a.\n", `if`(n=1, S[], Amd(S[])))
      end proc;
     Dsp:= proc(msg:=" empty",prnt:=Prntmsg )
          if prnt = "y" then print(msg); end if;
     end proc;

     end module;

     description " the position x,y,z or z,x,y in a Vector";   
     if prjpsn=1 then   
     end if;
    return xpsn, ypsn, zpsn
end proc;

#$include "Rational_Trigonometry\Quadruple Quad Formula.mpl"
#$include "Rational_Trigonometry\Quadrances_Overload_procs.mpl"

Quadrance :=overload([
   # 1 Quadrances p0 [x,y]
        proc(p0::{_T2L,_T2V}, clr := GeomClr,$)
                option overload;
                description "Calculates Quadrance of a [x,y] point";
                uses LinearAlgebra;         
                if clr = "b" or clr = "B" or clr = "blue" or clr = "Blue" then
                                MyModule:-Dsp(" Blue");
                                        BilinearForm(p0, p0, conjugate = false) ;
                        elif clr = "r" or clr = "R" or clr = "red" or clr = "Red" then
                                MyModule:-Dsp(" Red");
                                        p0[1]^2 - p0[2]^2 ;
                        elif clr = "g" or clr = "G" or clr = "green" or clr = "Green" then
                                MyModule:-Dsp(" Green");
                end if;
        end proc,
# 7 Quadrances Point to Plane and intersection point 3D
        option overload;
                local i, dlambda,nlambda,lambda,Q   ,intrP,  Vpn  ,f1  ;
                if pl::_T4L then
                 elif pl::{`+`,procedure} then
                        f1 := `if`(pl::procedure, pl(vars[]), pl);
                end  if;
                MyModule:-Dsp("Quadrance Point to Plane & intersect Point");
                return Q,intrP
                end proc,

        # 2 Quadrances p0 [x,y,z]
        proc(p0::{_T3L,_T3V}, clr := GeomClr,$)
                option overload;
                description "Calculates Quadrance of a [x,y,z] point Blue only";
                uses LinearAlgebra;         
                if clr = "b" or clr = "B" or clr = "blue" or clr = "Blue" then
                         MyModule:-Dsp("Quadrance 3D Point Blue");
                                BilinearForm(p0, p0, conjugate = false);
                        else print("3D Not yet implimented for Red or Green Geometry" );        
                end if;
        end proc,

        # 3 Quadrances P0-P1 [x,y]
         proc(p0::{_T2L,_T2V},p1::{_T2L,_T2V}, clr := GeomClr,$)
                option overload;
                description "Quadrance between two [x,y] points";        
                uses LinearAlgebra;                                
                if clr = "b" or clr = "B" or clr = "blue" or clr = "Blue" then                  
                                MyModule:-Dsp( "Quadrance between two 2D Points Blue") ;
                                 BilinearForm(p0 - p1, p0 - p1, conjugate = false);                        
                        elif clr = "r" or clr = "R" or clr = "red" or clr = "Red" then
                                        MyModule:-Dsp( "Quadrance between two 2D Points Red") ;
                                         (p0[1] - p1[1])^2 - (p0[2] - p1[2])^2;                         
                        elif clr = "g" or clr = "G" or clr = "green" or clr = "Green" then                         
                                        MyModule:-Dsp( "Quadrance between two 2D Points Green") ;
                                         (2*p1[1] - 2*p0[1])*(p1[2] - p0[2]);                        
                end if;
        end proc,

        # 4 Quadrances p0-p1 [x,y,z]
        proc(p0::{_T3L,_T3V},p1::{_T3L,_T3V}, clr::string := GeomClr,$)
                option overload;
                description "Calculates Quadrance of between two points/vectors [x,y,z] Blue only";
                uses LinearAlgebra;         
                if clr = "b" or clr = "B" or clr = "blue" or clr = "Blue" then
                                        MyModule:-Dsp( "Quadrance between two 3D Points Blue") ;
                                        BilinearForm(p0 - p1, p0 - p1, conjugate = false);
                        else print("Not at this point  implimented for Red or Green Geometry" );        
                end if;
        end proc,

        # 5 Quadrances Point to Line and intersection point 2D
        proc(p0::_T2L, l1::{_T3L,`+`,procedure}, vars::_T2L:=[x,y],clr:=GeomClr)
                option overload;
                local f1,P0:=p0,P1;
                if l1::_T3L then
                        f1 := `if`(l1::procedure, l1(vars[]), l1);
                end if;
                if  clr = "b" or clr = "B" or clr = "blue" or clr = "Blue"  then
                        MyModule:-Dsp( "Quadrance 2D Point to Line & intersect Point Blue") ;
                        return (P0[1]*P1[1] + P0[2]*P1[2] + P1[3])^2/(P1[1]^2 + P1[2]^2),
                        [((-P0[2]*P1[2] - P1[3])*P1[1] + P0[1]*P1[2]^2)/(P1[1]^2 + P1[2]^2),
                        ((-P0[1]*P1[1] - P1[3])*P1[2] + P0[2]*P1[1]^2)/(P1[1]^2 + P1[2]^2)];
                 elif clr = "r" or clr = "R" or clr = "red" or clr = "Red"  then
                        if P1[1]^2 - P1[2]^2 <> 0 then
                                MyModule:-Dsp( "Quadrance 2D Point to Line & intersect Point Red") ;
                                return (P0[1]*P1[1] + P0[2]*P1[2] + P1[3])^2/(P1[1]^2 - P1[2]^2),
                                [((-P0[2]*P1[2] - P1[3])*P1[1] - P0[1]*P1[2]^2)/(P1[1]^2 - P1[2]^2),
                                ((P0[1]*P1[1] + P1[3])*P1[2] + P0[2]*P1[1]^2)/(P1[1]^2 - P1[2]^2)];
                                "Null Red"
                        end if;
                        #"Input ERROR "Red"";         
                 elif clr = "g" or clr = "G" or clr = "green" or clr = "Green" then
                        if P1[1]*P1[2] = 0 then
                                "Null Green";
                                 MyModule:-Dsp( "Quadrance 2D Point to Line & intersect Point Green") ;
                                return 1/2*(P0[1]*P1[1] + P0[2]*P1[2] + P1[3])^2/(P1[1]*P1[2]),
                                [1/2*(P0[1]*P1[1] - P0[2]*P1[2] - P1[3])/P1[1],
                                1/2*(-P0[1]*P1[1] + P0[2]*P1[2] - P1[3])/P1[2]];
                        end if;
                        "Input ERROR Green";  
                end if;
        end proc,
        # 6 Quadrances Point to Line and intersection point 3D
                option overload;
                local lambda , Q ,intrP ;
                MyModule:-Dsp("Quadrance Point to 3D Line and Intersect Point");

                return Q,intrP
        end proc




QQF := proc(Q1, Q2, Q3, Q4)
 ((Q1 + Q2 + Q3 + Q4)^2 - 2*Q1^2 - 2*Q2^2 - 2*Q3^2 - 2*Q4^2)^2 = 64*Q2*Q1*Q3*Q4;
 end proc;


end module:




"Quadrance Point to 3D Line and Intersect Point"

25, Vector[column](%id = 36893489965928498348)


2*x-2*y+5*z+8 is type _T1.

"Quadrance Point to Plane & intersect Point"

507/11, Vector[row](%id = 36893489965928500148)


[2, -2, 5, 8] is type _T4L.

"Quadrance Point to Plane & intersect Point"

507/11, Vector[row](%id = 36893489965928493652)


"Quadrance between two 2D Points Blue"



((a+b+c+d)^2-2*a^2-2*b^2-2*c^2-2*d^2)^2 = 64*b*a*c*d


5760000 = 5760000



[AcuteObstuseQ, AcuteObstuseS, AltitudeQ, CfstoLeqn, CircleParm, CircumCirQ, CrossLaw, LPproj, LinePrll, LinePrpnd, LinePts, MedianQ, QQF, Quadrance, Quadrea, SolidSpread, Spread, SpreadLaw, SpreadLawQuadrea, SpreadPoly, Spreads123, TQF, TSF, UHG]


Error, type `_T3L` does not exist

                       5760000 = 5760000




please help, thank you!



alias(u = u(x, t), ub = ub(x, t))

u, ub



z1 := (2*I)*u*(2*gamma*lambda^2+alpha*lambda-1/4)*(diff(ub, x))+(2*I)*ub*(-2*gamma*lambda^2+alpha*lambda-1/4)*(diff(u, x))+I*ub*gamma*(diff(u, x, x, x))+Typesetting[delayDotProduct](4*u*gamma, lambda*ub.u.ub, true)+Typesetting[delayDotProduct](4*ub*gamma, lambda*u.ub.u, true)+Typesetting[delayDotProduct]((3*I)*gamma, ub.u.ub.(diff(u, x)), true)+Typesetting[delayDotProduct]((3*I)*gamma, ub.u.(diff(ub, x)).u, true)+Typesetting[delayDotProduct]((3*I)*gamma, ub.(diff(u, x)).ub.u, true)+Typesetting[delayDotProduct]((3*I)*gamma, (diff(ub, x)).u.ub.u, true)+Typesetting[delayDotProduct](I*gamma, (diff(u, x)).(diff(ub, x, x)), true)-Typesetting[delayDotProduct](I*gamma, (diff(ub, x, x)).(diff(u, x)), true)+Typesetting[delayDotProduct](I*gamma, u.(diff(ub, x, x, x)), true)+Typesetting[delayDotProduct](I*gamma, ub.(diff(u, x, x, x)), true)-Typesetting[delayDotProduct]((2*I)*u*gamma, ub.(3*u.(diff(ub, x))-(4*I)*lambda^3), true)+Typesetting[delayDotProduct]((2*I)*ub*gamma, u.(3*ub.(diff(u, x))-(4*I)*lambda^3), true)+(1/2)*Typesetting[delayDotProduct](-4*gamma*lambda-2*alpha, u.(diff(ub, x, x)), true)+(1/2)*Typesetting[delayDotProduct](4*gamma*lambda+2*alpha, ub.(diff(u, x, x)), true)+(1/2)*Typesetting[delayDotProduct](-4*gamma*lambda-2*alpha, (diff(u, x)).(diff(ub, x)), true)+(1/2)*Typesetting[delayDotProduct](4*gamma*lambda+2*alpha, (diff(ub, x)).(diff(u, x)), true)+(1/2)*Typesetting[delayDotProduct](-(8*I)*gamma*lambda^2-(4*I)*alpha*lambda+I, (diff(ub, x)).u, true)+(1/2)*Typesetting[delayDotProduct](-(8*I)*gamma*lambda^2-(4*I)*alpha*lambda+I, ub.(diff(u, x)), true)-ub*(-2*gamma*lambda+alpha)*(diff(u, x, x))+u*(2*gamma*lambda+alpha)*(diff(ub, x, x))+Typesetting[delayDotProduct](2*u, u.ub.u, true)*alpha-Typesetting[delayDotProduct](2*ub, ub.u.ub, true)*alpha-I*u*gamma*(diff(ub, x, x, x)) = 0

(1/2)*(4*gamma*lambda+2*alpha)*((diff(ub, x)).(diff(u, x)))-ub*(-2*gamma*lambda+alpha)*(diff(diff(u, x), x))+u*(2*gamma*lambda+alpha)*(diff(diff(ub, x), x))+(3*I)*gamma*(`.`(ub, diff(u, x), ub, u))+(3*I)*gamma*(`.`(diff(ub, x), u, ub, u))+I*gamma*((diff(u, x)).(diff(diff(ub, x), x)))+I*gamma*(u.(diff(diff(diff(ub, x), x), x)))+(3*I)*gamma*(`.`(ub, u, ub, diff(u, x)))+(3*I)*gamma*(`.`(ub, u, diff(ub, x), u))+4*ub*gamma*(`.`(lambda*u, ub, u))+4*u*gamma*(`.`(lambda*ub, u, ub))+I*gamma*(ub.(diff(diff(diff(u, x), x), x)))+2*u*(`.`(u, ub, u))*alpha-2*ub*(`.`(ub, u, ub))*alpha-I*gamma*((diff(diff(ub, x), x)).(diff(u, x)))+(1/2)*(-4*gamma*lambda-2*alpha)*((diff(u, x)).(diff(ub, x)))+(1/2)*(4*gamma*lambda+2*alpha)*(ub.(diff(diff(u, x), x)))+(1/2)*(-4*gamma*lambda-2*alpha)*(u.(diff(diff(ub, x), x)))+(1/2)*(-(8*I)*gamma*lambda^2-(4*I)*alpha*lambda+I)*(ub.(diff(u, x)))+(2*I)*u*(2*gamma*lambda^2+alpha*lambda-1/4)*(diff(ub, x))+(2*I)*ub*(-2*gamma*lambda^2+alpha*lambda-1/4)*(diff(u, x))-I*u*gamma*(diff(diff(diff(ub, x), x), x))+(2*I)*ub*gamma*(u.(3*(ub.(diff(u, x)))-(4*I)*lambda^3))+I*ub*gamma*(diff(diff(diff(u, x), x), x))-(2*I)*u*gamma*(ub.(3*(u.(diff(ub, x)))-(4*I)*lambda^3))+(1/2)*(-(8*I)*gamma*lambda^2-(4*I)*alpha*lambda+I)*((diff(ub, x)).u) = 0


Parse:-ConvertTo1D, "first argument to _Inert_ASSIGN must be assignable"

Error, illegal use of an object as a name

"for m from 0 to 5 do  lambda^m:=coeff(lhs(z1),lambda,m)=0;  od;"





May  I please get a Maple code to solve the below Perturbation Iteration Solutions for Volterra Integral Equations? 

I shall be very much grateful if I can get the Maple Code.

And possible plotting


Any comment, idea or innovation to calculate this parametric integral?

Note M, II, JJ are arbitrary positive integers (0<M, II, JJ<11).

F must be a function of Pm at the final!



M := 3:

JJ := 5

II := 5


W := RandomArray(II, JJ, M):

V := ArrayTools:-RandomArray(II, JJ, M):

w := add(add(add(W[i, j, m]*LegendreP(i-1, x)*LegendreP(j-1, y)*p[m], i = 1 .. II), j = 1 .. JJ), m = 1 .. M):

v := add(add(add(V[i, j, m]*LegendreP(i-1, x)*LegendreP(j-1, y)*p[m], i = 1 .. II), j = 1 .. JJ), m = 1 .. M):

L := add(add((LegendreP(i-1, x)*LegendreP(j-1, y))^2, i = 1 .. II), j = 1 .. JJ):

H := 1+tanh(w-v)

F := int(H*L, [y = -1 .. 1, x = -1 .. 1])

Warning,  computation interrupted





What does the following message imply?

"Error, (in Engine:-Dispatch) invalid boolean expression: 0"

For a vector of floats like this:

v := < 4,3,2>;

How do I get the 24 (=4*3*2)?


Now, there are two unknows, and i cant seem to get it right. 

Its "the method of the least squares", and it has gone wrong. How terrible, now ive made many books, but this book always sets me up, you may have guessed it: the Dutch Math book strikes again... 

Ive tried to use a value, it looks like i used the rights steps, but the wrong input, the solution does not give me anything that looks like it is doing the rigth thing. Checking the new formula does not give the solution it is suppose to give. Now i know they mentioned that x=1/I but that does not give the right answer either. 

Okey the question states: "A battery delivers a current I to a circuit with an external(not inside the battery) resistance Ry. The battery has an internal resistance Ri and delivers a source tension (voltage) U. These are the formulas U=(Ry+Ri)*I, of which follows: Ry+Ri=U/I. We state that x= 1/I and then we get Ry+Ri=U*x, of which follows: Ry=U*x-Ri. 

That last formula gives a linear conjunction between x and Ry. There are a couple of measurements done, of which different values of the resistance Ry and the current I is measured (look at table 5.4). The value of x is determined by the smallest squares method." 

While i did not use x instead of I, it made no difference. I was no where close to the results. I think i am misschien something.

`<,>`(`<|>`(1, 1.5, 2, 2.5, 3), `<|>`(1.31, 1.01, .81, .67, .56))

Matrix(%id = 18446745647253576510)



proc (t) options operator, arrow, function_assign; (1/2)*t end proc


1, 3/2, 2, 5/2, 3


Sum((1/2)*t, t = 2 .. 6) = 10





convert(`<,>`(1.31, 1.01, .81, .67, .56), `+`)






`<,>`(1, 1.5, 2, 2.5, 3).`<,>`(1.31, 1.01, .81, .67, .56)




proc (t) options operator, arrow, function_assign; (1/4)*t^2 end proc


1, 9/4, 4, 25/4, 9


Sum((1/4)*t^2, t = 2 .. 6) = 45/2


solve([(45/2)*a+10*b = 7.80000000000000071, 2*a+b = 4.36], [a, b])

[[a = -14.32000000, b = 33.00000000]]


"f(t):=-14.32 t+33"

proc (t) options operator, arrow, function_assign; -14.32*t+33 end proc


plot(proc (t) options operator, arrow, function_assign; -14.32*t+33 end proc)






Maybe someone knows an answer to this. 

Thank you!


The Function 


First 110 111 112 113 114 115 116 Last Page 112 of 2297