MaplePrimes Questions

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?

restart

RationalTrigonometry:=module()
    option package;
    
    export
        AcuteObstuseQ,
        AcuteObstuseS,
        AltitudeQ,
        CircleParm,
        CircumCirQ,
        CfstoLeqn,
        CrossLaw,
        LinePrll,
        LinePrpnd,
        LinePts,
        LPproj,
        MedianQ,
        #QPrj,
        Quadrance,
        Quadrea,
        QQF,
        SolidSpread,
        SpreadLawQuadrea,
        SpreadLaw,
        SpreadPoly,
        Spread,
        Spreads123,
        TQF,
        TSF,
        UHG;

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;
          GeomClr:="Blue";
          Prntmsg:="y";
          prjpsn:=3;

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

     ModuleLoad:= proc()
     local
          g, #iterator over module globals
          e
     ;
          
          ModuleUnload();
          #op([2,6], ...) of a module is its globals.
          for g in op([2,6], thismodule) do
               e:= eval(g);
               #print("e",e);
               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);
          return
     end proc;
export
     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[])))
         fi
      end proc;
export    
     Dsp:= proc(msg:=" empty",prnt:=Prntmsg )
          if prnt = "y" then print(msg); end if;
     end proc;

     ModuleLoad()    
     end module;

ppp:=proc(prjpsn)
     description " the position x,y,z or z,x,y in a Vector";   
     if prjpsn=1 then   
        xpsn:=2;
        ypsn:=3;
        zpsn:=1;
      else  
        xpsn:=1;
        ypsn:=2;
        zpsn:=3;  
     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");
                                        2*p0[1]*p0[2];
                end if;
        end proc,
# 7 Quadrances Point to Plane and intersection point 3D
        proc(p0::{_T3L,_T3V},pl::{_T4L,`+`,procedure},var::_T3L:=[x,y,z],$)
        option overload;
                local i, dlambda,nlambda,lambda,Q   ,intrP,  Vpn  ,f1  ;
                if pl::_T4L then
                        Vpn:=convert(pl,Vector[row]);
                 elif pl::{`+`,procedure} then
                        f1 := `if`(pl::procedure, pl(vars[]), pl);
                        Vpn:=<coeff(f1,var[1]),coeff(f1,var[2]),coeff(f1,var[3]),coeff(coeff(coeff(f1,var[3],0),var[2],0),var[1],0)>;
                end  if;
                
                nlambda:=(Vpn[1]*p0[1]+Vpn[2]*p0[2]+Vpn[3]*p0[3]+Vpn[4]);
                dlambda:=Vpn[1]^2+Vpn[2]^2+Vpn[3]^2;
                lambda:=nlambda/dlambda;
                intrP:=`<|>`(seq(p0[i]+lambda*Vpn[i],i=1..3));
                Q:=nlambda^2/dlambda;
                MyModule:-WhichMyType(pl);
                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
                        P1:=l1;
                 else
                        f1 := `if`(l1::procedure, l1(vars[]), l1);
                        P1:=[coeff(f1,vars[1]),coeff(f1,vars[2]),coeff(coeff(f1,vars[1],0),vars[2],0)];
                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)];
                                
                         else
                                "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";
                         else
                                 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;
                 else
                        "Input ERROR Green";  
                end if;
        end proc,
        
        # 6 Quadrances Point to Line and intersection point 3D
        proc(p0::{_T3L,_T3V},lP::{_T3L,_T3V},lV::{_T3V},$)
                option overload;
                local lambda , Q ,intrP ;
                lambda:=((p0[1]-lP[1])*lV[1]+(p0[2]-lP[2])*lV[2]+(p0[3]-lP[3])*lV[3])/(lV[1]^2+lV[2]^2+lV[3]^2);
                print(lambda);
                Q:=((p0[1]-lP[1]-lambda*lV[1])^2+(p0[2]-lP[2]-lambda*lV[2])^2+(p0[3]-lP[3]-lambda*lV[3])^2);
                
                intrP:=lP+lambda*lV;
                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:

 

RationalTrigonometry:-Quadrance([0,2,3],<3,1,-1>,<2,1,2>);

1/3

"Quadrance Point to 3D Line and Intersect Point"

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

RationalTrigonometry:-Quadrance([4,-4,3],2*x-2*y+5*z+8,[x,y,z]);

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

"Quadrance Point to Plane & intersect Point"

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

RationalTrigonometry:-Quadrance([4,-4,3],[2,-2,5,8]);

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

"Quadrance Point to Plane & intersect Point"

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

Qb:=RationalTrigonometry:-Quadrance([a,b],[c,d],"b");

"Quadrance between two 2D Points Blue"

(-c+a)^2+(-d+b)^2

RationalTrigonometry:-QQF(a,b,c,d)

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

RationalTrigonometry:-QQF(10^2,5^2,2^2,3^2)

5760000 = 5760000

restart

with(RationalTrigonometry)

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

Quadrance([4,-4,3],2*x-2*y+5*z+8,[x,y,z])

Error, type `_T3L` does not exist

QQF(10^2,5^2,2^2,3^2)
                       5760000 = 5760000

 


 

Download Q_2023-01-14_Package_not_Recognising_Types.mw

please help, thank you!

restart

with(LinearAlgebra)

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

u, ub

(1)

``

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

(2)

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;"

 

NULL

Download compare.mw

Hi,

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

Thanks

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!

``

restart

M := 3:

JJ := 5

II := 5

with(ArrayTools):

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

 

``

``

Download integralproblem.mw

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)?

Thanks.

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)

(1)

"f(t):=t/(2);seq(f(t),t=2..6);Sum(f(t),t=2..6)=sum(f(t),t=2..6)"

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

(2)

10*(1/5)

2

(3)

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

4.36

(4)

4.36*(1/5)

.8720000000

(5)

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

7.80000000000000071

(6)

"f(t):=(t/(2))^(2);seq(f(t),t=2..6);Sum(f(t),t=2..6)=sum(f(t),t=2..6)"

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

(7)

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

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

(8)

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

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

(9)

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

 

f(1)

18.68

(10)

``

Maybe someone knows an answer to this. 

Thank you!

Greetings,

The Function 

Download Mapleprimes_Question_Book_2_Paragraph_5.12_Question_3.mw

The result is wrong and I want to know the reason. the dot is the  Matrix multiplication.


I cannot find documentation on Typesetting commands that can explain the following

From the help page of apply:

lprint(Typesetting[Typeset](sqrt(x)));

Typesetting:-msqrt(Typesetting:-mi("x"))

 

The first argument to Typeset has type uneval , signifying that it is not evaluated before being passed to Typesetting[Typeset].

Questions:

Where can I see  in the lprint output that the first argument is of type uneval?
Is sqrt(x) the first argument?
What does mi do?

Download help_page_apply.mw

I was introduced to DataFrame by some kind people here the other day and I thought I understood.  Then I tried this

M := DataFrame(<0,0,0;0,1,a;0,a,1>,rows=[0,1,a],columns=[0,1,a])

Now M[1, a] returns 0.  What's going on here? 

do not accept substitution after line EQ
restart;
with(LinearAlgebra);
A := [1, -2];
B := [-2, 3];
C := [1, 1];
M := [x, y];
ProjPL := proc(C, A, B) local M, AB, AM, Q, eq, EQ, eq1, a, b, c, t, tt, n, dist, x, y, xH, yH, H, CH, no; M := [x, y]; AM := M - A; AB := B - A; Q := Matrix(2, [AM, AB]); eq := Determinant(Q); a := coeff(eq, x); b := coeff(eq, y); c := tcoeff(eq); dist := abs(a + b + c)/sqrt(a^2 + b^2); n := [a, b]; x := C[1] + n[1]*t; y := C[2] + n[2]*t; EQ := eq = 0; tt := solve(subs(x = C[1] + n[1]*t, y = C[2] + n[2]*t, EQ), t); xH := subs(t = tt, x); yH := subs(t = tt, y); H := [xH, yH]; CH := H - C; no := sqrt(CH[1]^2 + CH[2]^2); RETURN(EQ, dist, H, no); end proc;
ProjPL(C, A, B);
Thank you for your help.

Here is a graph (g.txt) in Graphlet (gml) format that I threw up with another program. I want to import it by maple. 

I am expecting to do two things:

  • Import the graph correctly;
  • draw the graph according to the vertex position, vertex color, vertex shape and edge color etc. in the file.

This question may come from https://www.mapleprimes.com/questions/235457-How-To-Draw-A-Directed-but-Maybe-Not-Acyclic. My intention is to use this format to efficiently pass graphs and other attributes such as vertex positions, vertex colors, and edge colors. 

However maple doesn't seem to be able to handle them even it cannot handle  the above first point well.

Import ("G:\\test\\g.gml");
# or 
GraphTheory:-ImportGraph ("G:\\test\\g.gml",graphlet)

Error, (in Import) incorrect syntax in parse: unexpected number (near 12th character of parsed string)

Error, (in GraphTheory:-ImportGraph) incorrect syntax in parse: unexpected number (near 12th character of parsed string)

I'm not sure what type of the mistake is here.

 

Mathematica can do it nicely:

g=Import["G:\\test\\g.gml"]

List @@@ PropertyValue[g, VertexLabels]
GraphEmbedding[g]

 

{{8, "x8"}, {12, "b3"}, {14, "x14"}, {2, "b2"}, {13, "x13"}, {5, 
  "r3"}, {7, "r5"}, {9, "r6"}, {11, "x11"}, {6, "r4"}, {1, "b1"}, {15,
   "x15"}, {3, "r1"}, {4, "r2"}, {10, "x10"}}

{{1080, 1440}, {480, 320}, {660, 560}, {420, 160}, {1380, 880}, {1020,
   720}, {720, 880}, {660, 800}, {2160, 0}, {0, 0}, {1500, 
  480}, {1320, 800}, {1800, 240}, {900, 1120}, {1080, 1360}}

PropertyValue[g, VertexStyle]

 

Is there a way to write a function definition that involves multiple cases so that it looks nice with braces as one would write on paper. 
For example, the function $f(x)=|x|$ which is $f(x)=x$ if $x>0$ and $f(x)=-x$ if $x<0$.

First of all, I'd like to be able to write this out with braces in non-executable math in my worksheet. This would already be great.

Then, is it possible to actually define a function this way (ie, not just display the braces in non-executable, but actually run in executable math and have a defined function)?

I would like to create a fuction from the values in a vector. Say I have a 3 vectors , A,F,Theta.

A=col vect of Amplitudes (order n)
F=col vector of Frequecies (order n)
Theta=col vector of phases (order n)

I want to create a function 

f(x):=x->A[0]*cos(F[0]*x+Theta[0] + A[1]*cos(F[1]*x+Theta[1] + ... + A[n]*cos(F[n]*x+Theta[n]

I would then like to create a vector x, and get the values for f(x). I am trying to create a function that is a sum of sinusoids that I can then create data from using a vector x.

I have tried many things but I can't seem to get it right. Can anyone help me with this.

Thanks

Hello guys,

I created a palette, but when I click on an entry, the following occurs:

If the entry line, where the mouse cursor is, is empty, insertion takes place on this line.
If the input line has any expression and the mouse cursor is to the left of the expression, insertion takes place on the line above.

If the input line has any expression and the mouse cursor is to the right of the expression, insertion takes place on the line below.

Does anyone know how to fix this?

Sincerely,

Oliveira

First 227 228 229 230 231 232 233 Last Page 229 of 2414