Maple 2020 Questions and Posts

These are Posts and Questions associated with the product, Maple 2020

Since we are getting many questions on how to create Math apps to add to the Maple Cloud. I wanted to go over the different GUI aspects of how you go about creating a Math App in Maple. The following Document also includes some code examples that are used in the the Math App but doesn't go into them in detail. For more details on the type of coding you do in a Math App see the DocumentTools package help page.

Some of the graphical features of the Math app don't display on Maple Primes so I'd recommend downloading this worksheet from here: HowToMathApp.mw to follow along.


 

NULL

How to make a Math App (An example of using the Document Tools).

 

This Document will provide a beginners guide on one way to make a Math app in Maple.

It will contain some coding examples as well as where to find different options in the user interface.

Step 1 Insert a Table

 

 

• 

When making a Math App in Maple I often start with a table. You can enter a table by going to Insert > Table...

  

 

• 

I often make the table 1 x 2 to start with as this gives an area for input and an area for the output (such as plots).

NULL

 

Add a plot component to one of the cells of the table

 

 

• 

From the Components  Palette you can add a Plot Component . Add it to the table by clicking and dragging it over.

 

 

NULL

NULL

Add another table inside the other cell

 

 

• 

In the other cell of the table I'll add another table to organize my use of buttons, sliders, and other components.
NULL

NULL

Add some components to the new table

 

 

• 

From the Components Palette I'll add a slider, or dial, or something else for interaction.

 

• 

You may also want a Math region for an area to enter functions and a button to tell Maple to do something with it.

 

NULL

NULL

Arrange the Components to look nice

 

 

• 

You can change how the components are placed either by resizing the tables or changing the text orientation of the contents of the cells.

 

NULL

Write some code for the interaction of the buttons.

 

 

• 

Using the DocumentTools  package there are lots of ways you can use the components. I often will start writing my code using a code edit region  as it provides better visualization for syntax. On MaplePrimes these display as collapsed so I will also include code blocks for the code.

 

NULL

NULL

Let's write something that takes the value of the slider and applies it to the dial

 

 

• 

Note that the names of the components will change in each section as they are copies of the previous section.

 

with(DocumentTools):

14

with(DocumentTools):
sv:=GetProperty('Slider2',value);
SetProperty('Dial2',value,sv);
• 

This code will only execute when run using the  button. Change the value of the slider below then run the code above to see what happens.

 

NULL

NULL

Move the code 'inside' the slider

 

 

• 

Instead of putting the code inside the code edit region where it needs to be executed, we'll next add the code to the value changed code of the slider.

 

• 

Right click the Slider then select "Edit Value Changed Code".

 

 

• 

This will open the code editor for the Slider

 

 

• 

Enter your code (ensuring you're using the correct name for the slider and dial).

 

• 

Notice that you don't need to use the with(DocumentTools): command as "use DocumentTools in ... end use;" is already filled in for you.

 

• 

Save the code in the Slider and hit the  button inside it once.

• 

Now move the slider.

 

• 

On future uses of the App you won't need to hit  as the code will be run on startup.

``

NULL

NULL

Add some more details to your App

 

 

• 

Let's make this app do something a bit more interesting than change the contents of a dial when a slider moves.

 

• 

The plan in the next few steps is to make this app allow a user to explore parameters changing in a sinusoidal expression.

 

• 

I'm going to add a second Math Component, put the expression A*sin(t*theta+phi)into both then uncheck the box in the context panel that says "Editable".

 

• 

To make the Math containers fit nicely I'll check the Auto-fit container box and set the Minimum Width Pixels to 200.

 

``

Add code to change the value of phi in the second Math Container when the Slider changes

 

 

Note: Maple uses Radians for trigonometric functions so we should convert the value of phi to Radians.

use DocumentTools in

 

use DocumentTools in 
phi_s:=GetProperty(Slider5,value);
expr:= GetProperty(MathContainer6,expression);
new_expr:=algsubs(phi=phi_s*Pi/180,expr);

SetProperty(MathContainer7,expression,new_expr);
end use:

``

``

Make the Dial go from 0 to 360°

 

 

• 

Click the Dial and look at the options in the context panel on the right.

 

• 

Update the values in the Dial so that the highest position is 360 and the spacing makes sense for the app.

  NULL

``

Have the Dial update the theta value of the expression

 

 

• 

Add the following code to the Dial

 

use DocumentTools in
use DocumentTools in 
theta_d:=GetProperty(Dial7,value);
phi_s:=GetProperty(Slider7,value); #This is added so that phi also has the value updated

expr:= GetProperty(MathContainer10,expression);
new_expr0:=algsubs(theta=theta_d*Pi/180,expr);
new_expr:=algsubs(phi=phi_s*Pi/180,new_expr0);  #This is added so that phi also has the value updated

SetProperty(MathContainer11,expression,new_expr);
end use:

 

• 

Update the value in the slider to include the value from the dial

 

use DocumentTools in

 

use DocumentTools in 

theta_d:=GetProperty(Dial7,value); #This is added so that theta also has the value updated
phi_s:=GetProperty(Slider7,value); 

expr:= GetProperty(MathContainer10,expression);
new_expr0:=algsubs(theta=theta_d*Pi/180,expr); #This is added so that theta also has the value updated
new_expr:=algsubs(phi=phi_s*Pi/180,new_expr0);  

SetProperty(MathContainer11,expression,new_expr);

end use:

 

``

``

Notice that the code in the Dial and Slider are the same

 

 

• 

Since the code in the Dial and Slider are the same it makes sense to put the code into a procedure that can be called from multiple places.

 

Note: The changes in the code such as local and the single quotes are not needed but make the code easier to read and less likely to run into errors if edited in the future (for example if you create a variable called dial8 it won't interfere now that the names are in quotes).

 

 

UpdateMath:=proc() 

UpdateMath:=proc()
local theta_d, phi_s, expr, new_expr, new_expr0;
use DocumentTools in 
theta_d:=GetProperty('Dial8','value'); #Get value of theta from Dial
phi_s:=GetProperty('Slider8','value'); #Get value of phi from slider

expr:= GetProperty('MathContainer12','expression');
new_expr0:=algsubs('theta'=theta_d*Pi/180,expr);  # Put value of theta in expression
new_expr:=algsubs('phi'=phi_s*Pi/180,new_expr0);  # Put value of phi in expression
SetProperty('MathContainer13','expression',new_expr); # Update expression
end use:
end proc:

 

• 

Now change the code in the components to call the function using UpdateMath().

 

• 

Since the code above is only defined there it will need to be run once (but only once) before moving the components. Instead of leaving it here you can add it to the Startup code by clicking  or going to Edit > Startup code.  This code will run every time you open the Math App ensuring that it works right away.

 

• 

The startup code isn't defined in this document to allow progression of these steps.

 

``

Make the button initialize the app

 

 

• 

Since the startup code isn't defined in this document we are going to move this function into the button.

 

UpdateMath:=proc()

 

UpdateMath:=proc()
local theta_d, phi_s, expr, new_expr, new_expr0;
use DocumentTools in 
theta_d:=GetProperty('Dial9','value'); #Get value of theta from Dial
phi_s:=GetProperty('Slider9','value'); #Get value of phi from slider

expr:= GetProperty('MathContainer14','expression');
new_expr0:=algsubs('theta'=theta_d*Pi/180,expr);  # Put value of theta in expression
new_expr:=algsubs('phi'=phi_s*Pi/180,new_expr0);  # Put value of phi in expression
SetProperty('MathContainer15','expression',new_expr); # Update expression
end use:
end proc:
• 

First click the button to rename it, you'll see the  option in the context panel on the right. Then add the code above to the button in the same way as the Slider an Dial (Right click and select Edit Click Code).

 

``

``

Now it is easy to add new components

 

 

• 

Now if we want to add new components we just have to change the one procedure.  Let's add a Volume Gauge to change the value of A.

 

• 

Click in the cell containing the Dial, the context panel will show the option to Insert a row below the Dial.

• 

Now drag a Volume Gauge into the new cell.

 

• 

Click in the cell and choose the alignment (from the context panel) that looks best to you. In this case I chose center:

 

``

 

NULL

``

Update the procedure code for the Gauge

 

 

• 

Add two lines for the volume gauge to get the value and sub it into the expression

UpdateMath:=proc()

UpdateMath:=proc()
local theta_d, phi_s, expr, new_expr, new_expr0;
use DocumentTools in 
theta_d:=GetProperty('Dial11','value'); #Get value of theta from the Dial
phi_s:=GetProperty('Slider11','value'); #Get value of phi from the Slider
A_g:=GetProperty('VolumeGauge1','value'); #Get value of A from the Guage

expr:= GetProperty('MathContainer18','expression');
new_expr0:=algsubs('theta'=theta_d*Pi/180,expr);  # Put value of theta in expression
new_expr1:=algsubs('phi'=phi_s*Pi/180,new_expr0);  # Put value of phi in expression
new_expr:=algsubs('A'=A_g,new_expr1);  # Put value of A in expression

SetProperty('MathContainer19','expression',new_expr); # Update expression
end use:
end proc:
• 

Now add

UpdateMath();

  to the Gauge.

  ``

``

Plot the changing expression

 

 

• 

Make a procedure to get the value in the second Math Container and plot it

 

PlotMath:=proc()

PlotMath:=proc()
	local expr, p;
	use DocumentTools in 

	expr:=GetProperty('MathContainer21','expression'); 

	p:=plot(expr,'t'=-Pi/2..Pi/2,'view'=[-Pi/2..Pi/2,-100..100]):

	SetProperty('Plot14','value',p)
	end use:
end proc:
• 

Put this procedure in the Initialize button and the call to it in the components.

 

NULL

``

Tidy up the app

 

 

• 

Now that we have an interactive app let's tidy it up a bit.

 

• 

The first thing I'd recommend in your own app is moving the code from the initialize button to startup code. In this document we choose to use the button instead to preserve earlier versions.

 

• 

You can also remove the borders around the components by clicking in the table and selecting "Interior Borders" > "None" and "Exterior Borders" > "None" from the context panel.

NULL

``

``

Now you have a Math App

 

 

• 

You can upload your Math App to the Maple Cloud to share with others by going to "File" > "Save to Cloud".

 

• 

I'd recommend also including a description of what your app does. You can do this nicely using another table and Text mode.

 

 

 

``

``

NULL

HowToMathApp.mw

How I can determine the trace of the matrix.

My answer has a lot of differences comparing the result provided in the pdf file (end of the file).

Also, I think we should use from  EQ(4).

what is the problem?

Please help me..

Best

Doc2.pdf

1111.mw


 

restart; x__2 := beta*gamma+2*beta+delta*gamma+delta-alpha-sqrt(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)/(2*(beta+delta))

y__2 := 1-x__2

J := Matrix([[1-2*x__2-y__2, -x__2], [beta*y__2^2/x__2^2, delta-2*beta*y__2/x__2-alpha*gamma/(gamma+y__2)^2]])

 

 

                            

and y__2*(delta-beta*y__2/x__2)-alpha*y__2/(gamma+y__2) = 0``

Error, reserved word `and` unexpected

 
  NULL

 

 

NULL

TTR := Trace(J)

TTR := 1-2*x__2-y__2+delta-2*beta*y__2/x__2-alpha*gamma/(gamma+y__2)^2

-beta*gamma-2*beta-delta*gamma+alpha+(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta)-2*beta*(1-beta*gamma-2*beta-delta*gamma-delta+alpha+(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))/(beta*gamma+2*beta+delta*gamma+delta-alpha-(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))-alpha*gamma/(gamma+1-beta*gamma-2*beta-delta*gamma-delta+alpha+(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))^2

(1)

s := diff(TTR, alpha)

1+(1/2)*(-2*beta*gamma-2*delta*gamma+2*alpha-4*beta-2*delta)/((alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)*(2*beta+2*delta))-2*beta*(1+(1/2)*(-2*beta*gamma-2*delta*gamma+2*alpha-4*beta-2*delta)/((alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)*(2*beta+2*delta)))/(beta*gamma+2*beta+delta*gamma+delta-alpha-(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))+2*beta*(1-beta*gamma-2*beta-delta*gamma-delta+alpha+(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))*(-1-(1/2)*(-2*beta*gamma-2*delta*gamma+2*alpha-4*beta-2*delta)/((alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)*(2*beta+2*delta)))/(beta*gamma+2*beta+delta*gamma+delta-alpha-(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))^2-gamma/(gamma+1-beta*gamma-2*beta-delta*gamma-delta+alpha+(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))^2+2*alpha*gamma*(1+(1/2)*(-2*beta*gamma-2*delta*gamma+2*alpha-4*beta-2*delta)/((alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)*(2*beta+2*delta)))/(gamma+1-beta*gamma-2*beta-delta*gamma-delta+alpha+(alpha^2-2*alpha*(beta*gamma+delta*gamma+2*beta+delta)+(beta*gamma+delta*gamma+delta)^2)^(1/2)/(2*beta+2*delta))^3

(2)

NULL

NULL


 

Download 1111.mw

The help for option threadsafe (on page ?option) includes this sentence: 

  • Portions of the kernel may recognize this option and allow the procedure to be called in multiple threads simultaneously.

Huh? What exactly does that mean? Isn't it already capable of being called in multiple threads simultaneously?

I understand the significance of this option for procedures to be compiled, mentioned later in the same paragraph. But is there any benefit for a non-compiled procedure that will be used in multithreaded code? If my code has numerous one-liner arrow procedures, is there any point to cluttering up my code by turning them all into procs with option threadsafe? (Y'all know how I hate cluttered code.)

 

Friends, as above in the picture,I want T to differentiate diff(x,t),taken diff(x,t) as a variable.

The answer is m*diff(x,t)+m__1/2 

Is there any way to do that? Substitute diff(x,t) with another variable and then substitute back isn't convenient.

differential_question.mw

Hello,friends.I want to know is there any maple command that can change the order of integral?I searched the Student package and the DEtools,can not find it.

for instance,there is an integral 

int(f(x,y),y=sqrt(4*x-x^2)..2*sqrt(x),x=0..4), 

it first integral y then integral x.I want the integral order be x then y. I appreciate your help!

 

restart;

kernelopts(version);

`Maple 2020.0, X86 64 LINUX, Mar 4 2020, Build ID 1455132`

convert([1,2,3], Vector[row]);

Vector[row](3, {(1) = 1, (2) = 2, (3) = 3})

convert([1,2,3], Vector[col]);

This worksheet shows an unexpected behavior of pdsolve().  It solves the heat equation on the interval (−1,1) but fails on the interval (0,1).  I see no technical reason for this happening — it's probably due to a little bug lurking somewhere.

restart;

kernelopts(version);

`Maple 2020.0, X86 64 LINUX, Mar 4 2020, Build ID 1455132`

Physics:-Version();

`The "Physics Updates" package is not installed`

Solve the heat equation on the interval -1 < x and x < 1 and

boundary conditions u(-1, t) = 0, u(1, t) = 0.

pde := diff(u(x,t),t) = diff(u(x,t),x,x);

diff(u(x, t), t) = diff(diff(u(x, t), x), x)

bc := u(-1,t)=0, u(1,t)=0;

u(-1, t) = 0, u(1, t) = 0

ic := u(x,0) = cos(Pi/2*x);

u(x, 0) = cos((1/2)*Pi*x)

pdsol := expand(pdsolve({pde,bc,ic}));

u(x, t) = cos((1/2)*Pi*x)*exp(-(1/4)*t*Pi^2)

That's good.  Apply pdetest to verify it:

pdetest(pdsol, [pde,bc,ic]);

[0, 0, 0, 0]

Now, solve the same problem on the interval 0 < x and x < 1 and

boundary condition u__x(0, t) = 0 and u(1, t) = 0.  It should be

evident that the solution remains the same as the one calculated

above, due to symmetry, and here is the verification:

bc_new := D[1](u)(0,t)=0, u(1,t)=0;

(D[1](u))(0, t) = 0, u(1, t) = 0

pdetest(pdsol, [pde,bc_new,ic]);

[0, 0, 0, 0]

But for some reason Maple's pdsolve fails to solve the PDE.  Actually

its response is somewhat erratic -- sometimes it returns nothing at all,

and sometimes it exits with an error message.

pdsolve({pde,bc_new,ic});

 

Download pdsolve-fails.mw

 

I need to solve general linear programming problem with multi-precision support. What are my options with Maple 2020?

 

THE ISSUE: It's returning a list of [1] when it should be returning [1,1,1,7]

##Find remainder##
rm := proc(a, b) local n; n := 0; while 0 <= b - n*a do n := n + 1; end do; b - (n - 1)*a; end proc;
rm := proc (a, b) local n; n := 0; while 0 <= b-n*a do n := n+1 

   end do; b-(n-1)*a end proc


rm(8, 3657);
                               1

rm(16, 12345);
                               9

##FINDING THE WHOLE NUMBER PORTION ##
whole := proc(a, b) local r, i; r := 0; i := 0; if a < b then r := rm(a, b); i := (b - r)/a; else 0; end if; end proc;
whole := proc (a, b) local r, i; r := 0; i := 0; if a < b then 

   r := rm(a, b); i := (b-r)/a else 0 end if end proc


whole(8, 3657);
                              457

whole(16, 12345);
                              771

 


j = whole(8, 3657);
                            j = 457

k = rm(8, 3657);
                             k = 1

L := [];
                            L := []

L := [op(L), rm(8, 8657)];
                            L := [1]

j = whole(8, 457);
                             j = 57


##GETTING THE LIST OF DIGITS (BEFORE REVERSING)##
HELPER := proc(a, b, L) local j; j := whole(a, b); [op(L), rm(a, b)]; if 0 < j then HELPER(a, j, L); else ; end if; L; end proc;
HELPER := proc (a, b, L) local j; j := whole(a, b); [op(L), 

   rm(a, b)]; if 0 < j then HELPER(a, j, L) else  end if; L end 

   proc


CNS := proc(a, b) HELPER(a, b, L); end proc;
          CNS := proc (a, b) HELPER(a, b, L) end proc

 

CNS(8, 3657);
                              [1]

 

HELPER(8, 3657, L);
                              [1]

 

Hello

I wonder if someone on the list can give me some guidelines on how to use Grid:-Seq.

I have applied Grid:-Set and Grid:-Seq to one of my problems where parallelization is a possibility.   In this problem, I have a massive list of lists that needs to be processed in chunks and then a new list is returned.

What I've found so far:

1) Grid-Seq won't work if I use a procedure from a private module that calls local (or exported) functions of the same module.  Solution:  I need to use savelib (there is a bug in Grid:-Seq)

2) Grid-Seqs seems to be working fine up to a point where it simply stops.  For example:   Starting with 431895 sets, the procedure divides them into 864 sets of 500 elements (the last one does not usually contain 500 elements).  Then I use res:=Grid:-Seq['tasksize'=9](myFunction(newSets[i],...,....),i=1..864).   The messages sent out by Grid:-Seq are 

Seq: using tasksize=9; number of elements= 864, number of partitions = 96

......

Seq: done sending all partitions

Seq: received results from all nodes; collating results

After two hours running and using 36 cores, the result is available in res.  The next step is to use the results in res for another cycle of calculations.  1503462 sets = 3007 sets of 500 elements.  The messages sent out by Grid:Seq are 

Seq: using tasksize=9; number of elements= 3007, number of partitions = 335

......

Seq: done sending all partitions

The last message showed up on the screen after an hour. During the process, I saw the current tasks finishing and new ones starting.  However I could not see "Seq: received results from all nodes; collating result" after a day running.  I am using timelimit to be sure that all calculations will finish no matter what.  

I have checked the system information and found that: 1) all 72 cores are running but they are jumping from 0% to 100% (in the example that works I could see all of them in 100% solid), 2) Memory is at 156 GB (200 Gb is the limit) and no swap to disk.

I have also noticed:

  1. If I use Maple 2017, not even the first example works.
  2. tasksize=9 somehow helps with similar problems.  If the size is left for Maple to decide, it seems that the problem happens for sets of smaller size.
  3. On linux I had to use "kill -9" to remove maple from every single core. My impression is that Grid:-Seq does not clean up the processes after they finished.  
  4.  The problem seems to be on "results from all nodes; collating result".

 

I know that the explanation above in rather vague, but if someone has any clue or guidelines on how to solve this problem, please share it with me.

 

Many thanks

 

Ed

 

 

 

I think the Maple Physics package has the promise to revolutionize the teaching of physics. Two recent tutorials have been very helpful (“Vectors in Spherical coordinates using tensor notation” and “A Complete Guide for performing Tensors computations using Physics”).   Unfortunately, despite these, I still have problems even when trying to use it for simple things. No doubt this is primarily a sign of my limitations. However, in the hope that others might share this, I have the following question.

As an exercise, I would like to use the Maple Physics Tensor notation to derive the expression for acceleration in spherical coordinates – identifying Coriolis force, etc.  I can’t get past the first step – how to define the tensor dx/dt.   That is, how do I write the time derivative of the Maple space coordinates [X].  I assume that this can be done in about 3 steps, if someone would be kind enough to humor my ignorance. Thanks in advance.

I am trying to  find the funtion of this graph 

I tried
f := x -> a12*x^12 + a1*x^11 + a2*x^10 + a3*x^9 + a4*x^8 + a5*x^7 + a6*x^6 + a7*x^5 + a8*x^4 + a9*x^3 + a10*x^2 + a11*x + a13;
solve([f(-4) = 3, f(-3) = 1, f(-2) = 1, f(-1) = 1, f(0) = 0, f(1) = -1, f(3) = -5, f(4) = -5, f(5) = 1, eval(diff(f(x), x), x = -2.5) = 0, eval(diff(f(x), x), x = -1.5) = 0, eval(diff(f(x), x), x = 3.5) = 0, f(6) = 3], [a12, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a13]);

I got

[[a12 = 4.697405911*10^(-6), a1 = -0.00006250181861, a2 = -1.444112429*10^(-6), a3 = 0.002660698702, a4 = -0.004689494622, a5 = -0.04291772722, a6 = 0.08407481146, a7 = 0.3251529098, a8 = -0.4752692626, a9 = -1.066462933, a10 = 0.3958806924, a11 = -0.2183704462, a13 = 0.]]

plot(4.697405911*10^(-6)*x^12 - 0.00006250181861*x^11 - 1.444112429*10^(-6)*x^10 + 0.002660698702*x^9 - 0.004689494622*x^8 - 0.04291772722*x^7 + 0.08407481146*x^6 + 0.3251529098*x^5 - 0.4752692626*x^4 - 1.066462933*x^3 + 0.3958806924*x^2 - 0.2183704462*x, x = -4 .. 5)

It doesn't like the graph of the first picture. 

Since Maple comes with source code that one can display. Even though it is stripped of all comments, which makes it hard to follow sometimes, I was wondering if there are any tools to help one get the large picture of what is there without having to step and go through all the thousands and thousands of the help pages jumping from one to another and losing the path.

I am looking for something similar to the tree program one finds on Unix, but applied to Maple's logical package hierarchy.

Since Maple has thousands of packages and subpackages and some has sub subpackages and then thousands of commands below all these, such an automated tool will be useful.

For example, I could ask it to show me top level packages and subpackages only (and not show the names of all the functions below that). This will help one see what is out there at a glance. i.e. see the big picture.

Here is an example of tree command I found on the net. But instead of looking at directories, the maple one will look at logical package tree.

 

For example, I just made short example for the Student package now

 

But doing the above by hand for everything is not practical. The above is just partial view of one package, and there are hundreds others. 

It will be nice if there is a tool, where one can tell to show the Maple package tree and the level of details to show. This will help one learn Maple better also.

The output of such tool does not even have to graphical. It could plain text, something like this

 

Student
      LinearAlgebra
               Basis
               IntersectionBasis
               etc.....
      Calculus1
               ......
               ......
Physics
DataSets
.....

      
       

   

Alignment is done using tabs for example to help show the structure.

Any suggestions?

 

Taking the example below from the help page, showstat displays the content of a procedure. This is convenient when writing code. However, to perform copy & paste, I would like to get rid of the displayed line number. Is that possible?

f := proc(x) if x <= 2 then print(x); print(x^2) end if; print(-x); x^3 end proc:
showstat(f);

f := proc(x)
   1   if x <= 2 then
   2       print(x);
   3       print(x^2)
       end if;
   4   print(-x);
   5   x^3
end proc

 

The uploaded worksheet contains an apparently unsolvable ode.

Please see the text in the worksheet for a description of the problem.

Roller_coaster_loop.mw

First 51 52 53 54 55 56 57 Page 53 of 57