See the help-page for the interface command, and in particular the setting for warnlevel on thay page.

By invoking interface(warnlevel=1) or interface(warnlevel=0) the warnings about implicitly declared locals should be suppressed.

It's a better idea to declare your locals explicitly, rather than to suppress such warnings. If you leave them only implicitly declared then future readers of your code (a course instructor, colleague, or even you) may be left wondering whether you intended them as locals or as globals and whether your code functions as intended.

acer

You can comstruct an assembly of Embedded Components (Sliders, etc) which does this.

A worksheet with such components can also be run in the free MaplePlayer. Perhaps you can convince your administrator to allow the free player to be installed on the computer connected to the classroom's overhead projector.

One convenient way to construct such Embedded Components in Maple 17, as in your simple case, is to use the Explore command with the invocation shown below.

The attached worksheet looks better in Maple (than it does with its picture inlined into this Answer). It has three Sliders in its bottom half.

Download simplecircle.mw

The worksheet that uses Explore for Maple 17 is at the link above.

You could also build such a simple assembly by hand. It's very similar to some introductory examples on Embedded Components in the Help system. Here is one version as another attachment, in the link below. It's assembly of components was constructed by hand. This should run, as is, in Maple 17, 16,.. ,13, 12.

manualcircle.mw

acer

I'm not completely sure how your data is meant to be interpreted. Perhaps I've understood your intention, for what I show below.

I don't show how to obtain an interpolatory bivariate polynomial in the explicit sense. Instead I show how to create a procedure `f` which can be used to interpolate at any (x,y) point. Hence you should be able to call `f` at points of your own choice. I show how it can be used to produce a 3D plot, for example.

Is there a typo in your list `c`? Did you mean for its second entry to be -0.87 say?

(For some reason only the first portion of my attached worksheet is being inlined into this answer. Let me know if you cannot load and see the whole thing.)

acer

I'm not sure whether this is coursework, and whether you are supposed to be able to show it manually (ie. without using Maple). If so, then you may be able to do these steps by hand.

restart:

# For posint N, you could try showing this manually.
b := Product(5^(1/2^k)+1, k=1..N) = Sum(5^((i-1)/(2^N)),i=1..2^N):

XN := 4/Product(5^(1/2^k)+1, k= 1..N);

                                         4          
                         XN := ---------------------
                                   N     / /1 \    \
                               ,--------'| |--|    |
                                  |  |   | | k|    |
                                  |  |   | \2 /    |
                                  |  |   \5     + 1/
                                  |  |              
                                 k = 1  
            
subs(b,XN);

                                     4       
                               --------------
                                  N          
                                 2    /i - 1\
                               -----  |-----|
                                \     |  N  |
                                 )    \ 2   /
                                /    5       
                               -----         
                               i = 1 
        
# But now that's just a simple geometric sum.
# You should be able to get the following without Maple.
simplify(value(%)) assuming N::posint;

                                 / (-N)\    
                                 \2    /    
                                5        - 1

x := eval(%, N=4);
                                    (1/16)    
                              x := 5       - 1

(%+1)^48;
                                     125

acer

restart:
en:=Sum((sqrt(a*k^3+b*k^2+c*k+1)-sqrt(a*k^3+b*k^2+c*k))^(1/3),k=0..n-1):

# First, find a,b,c

value(eval(en-sqrt(n),n=2)):
s2:=solve(%):
e2:=simplify(eval(en,s2)):
value(eval(e2-sqrt(n),n=3)):
s3:=simplify(solve(%)):
e3:=simplify(eval(e2,s3)):
value(eval(e3-sqrt(n),n=4)):
s4:=simplify(solve({%})):
sol:=solve(s2 union s3 union s4);
                    {a = 16, b = 24, c = 9}
Z:=eval(en,sol):

# And now, by induction, show true for all n::posint

value( eval(Z-sqrt(n),n=1) );

                               0

value( combine( (Z=sqrt(n)) - eval(Z=sqrt(n),n=n-1) ) ):
lhs(%)^3 - rhs(%)^3:
simplify(%) assuming n::posint, n>1;

                               0

acer

Unprotecting system names is very rarely a sound approach. If one is not crystal clear about how to do it, what it entails, or what the consequences might be, then it's often a bad idea.

In Maple 17 one can declare a local version of a name... at the top level! Ie, outside of any procedure. This allows a name such as gamma to be used in a variety of common and useful ways (eg. assigned to) without the need to unprotect and overwrite the global of the same name.

In the following code the global name `:-gamma` retains its original meaning, which can be very important. eg. in cases where the special meaning is intended when it occurs in the return value of some computation by the system.

restart:

local gamma;

gamma := 4;

                                 gamma := 4

evalf(gamma);

                                     4.

evalf(:-gamma);

                                0.5772156649

kernelopts(version);

          Maple 17.01, X86 64 WINDOWS, Jun 25 2013, Build ID 849430

I expect that there are wrinkles to be ironed out. But this looks like a step forward.

Does your data form a grid in the x-y plane? Or do you have only an irregular collection of x-y point pairs?

You could look at the following (which covers the case of a grid), here. The constructred procedure `B` can be used to compute f(X,Y) for any given X,Y point. It does not return a bivariate picewise polynomial (formula). But it is possible that you might not actually need a formulaic result, if you have a procedure such as `B` which can be polled at any arbitrary point (X,Y).

There is also an Example worksheet in the Maple help system or recent versions, under the topic examples,Interpolation_and_Smoothing (using underscore for the two spaces between words).

acer

To create a system which is like SI except that the dimension of "action" is given in terms of MeV*s you could try,

Units:-AddSystem('Accelerator',Units:-GetSystem('SI'),'MeV*second'); 
Units:-UseSystem('Accelerator');

You could compare the output of, say, simplify( Unit('h_bar') ) both with and without the above.

nb. You could also use ScientificConstants:-Constant('hbar') and test with ScientificConstants:-GetUnit(...) etc.

Your original definition of system 'Accelerator' associated units with the (separate, simple) dimensions of energy, length, and time, but not with others dimensions. In the call to `AddSystem` that I have above the new system 'Accelerator' comprises all that Maple understands for the 'SI' system as well as a new override for the dimension of action=energy*time.

I don't understand what you've written about contexts, sorry.

acer

Try the GenerateMatrix command in the LinearAlgebra package.

makefill:=(z1,z2,a,b)->plottools:-transform(
(x,y)->[x,y+z1])(plot(z2-z1,x=a..b,filled=true,thickness=0,_rest)):

plots:-display(makefill(2,5,-3,3,color=blue),view=0..10,gridlines=true);

Another way is,

plots:-display(plottools:-rectangle([-3,2],[3,5],color=blue,
thickness=0,transparency=0.35),view=0..10,gridlines=true);

With your original approach I don't see how you can make the white layer opaque so as to mask the underlying blue while still being transparent so as to not mask the underlying gridlines.

acer

Don't reduce Digits the working precision. Reduce the tolerance (accuracy target) for the numeric integration. If you're "only plotting" then you likely don't need results more accurate than about 1e-3 or 1e-4.

Also, the `_dcuhre` method may do better than an iterated 1-D method (since the latter can involve as many evaluations of the integrand as approximately the number of points required for the 1-D case raised to the number of dimensions; here two). 

Also, you could turn off adaptive plotting in the `plot` case. And a coarser grid in the `plot3d` case might still produce a smooth surface; eg. 25-by-25 grid points is about 4 times as few evaluations as Maple 17's default 49-by-49 grid points, but might still be enough for your surface.

test3modif.mw

With all of the above changes the `plot` took less than 2 seconds and the `plot3d` about 15 seconds on my Intel i7 64bit Linux machine. But with Digits=8 your original code took 13 seconds and 200 seconds.

acer

When the procedure `BlocksLSymm` is defined as you've shown then the following message should be seen,

   Warning, `x` is implicitly declared local to procedure `BlocksLSymm`

This means that within your procedure the name `x` used for building up `vars_set` is the implicitly declared local name `x`. With your original code the `x` instances inside `vars_set` -- following the call to the procedure -- are so-called "escaped locals"

That occurs because you assigned to x[1] using a colon-equals assignment statement and `x` was not declared as a global of procedure `BlocksLSymm`.

You have several choices of how to make this code work, even when the statement x[1]:=x[2] is present. Here are a few ways:

One way is to declare `x` as a global of that procedure.

Another way is to change instances of `x` to `:-x` (the global name reference) in the procedure, such as in the line which augments the set assigned to `vars_set`.

Yet another (probably less generally useful) was is to convert `vars_set`, after the computation (either inside the proc, or after it is called). Eg.

  BlocksLSymm(5);
  vars_set := convert(vars_set, `global`);
  `minus`(vars_set, {x[1], x[2]})

My personal preference is to not declare globals in a procedure if it can be sensibly avoided. An alternative method would be to pass in the name as an argument of the procedure. This makes the procedure nicely independent of that particular name to be used later, when calling it. In a somewhat related way there is no clear reason why `vars_set` should be declared as a global of the procedure, since it could simply be used for the return value.

restart:

BlocksLSymm:=proc(stringLength, nm::name) 
local i, j, V, vars_set;
V:=Vector(2^(stringLength)+1,symbol=nm):
# Create List
vars_set:={};
nm[1]:=nm[2];
for i from 0 to stringLength do 
 for j from 0 to i do
  vars_set:={op(vars_set), nm[2^i-2^j+1]};
 end do; 
end do;
return vars_set;
end proc: 

res := BlocksLSymm(5, x):

res minus {x[1],x[2]};

       {x[3], x[4], x[5], x[7], x[8], x[9], x[13], x[15], x[16], x[17], x[25], x[29], 

        x[31], x[32]}

In other words: I suggest getting values (including symbolic names, as well as computed sets) both into and out from procedures by using passed arguments (procedure parameters) and return values. Using declared globals for such things, as a usual way of operating, is not great.

acer

I don't know much about the Calculus Study Guide you mentioned, but even without it I was able to do that problem very easily in Maple 17's Integration Tutor.

I launched it from the main menubar, Tools->Tutors-Calculus -Single Variable->Integration Methods...

I could also have launched it with the command call,

Student[Calculus1][IntTutor]();

In the Function input box I typed,

        cos(5*x)

The syntax has to be valid 1D Maple Notation input.

Both cos5x or cos(5x) are incorrect as 1D Maple Notation for the problem you've described.

Entering cos5x will make Maple think that you've entered the single five character name `cos5x`. It'd be like asking for int(K,x) where the answer is K*x and of course only the Comstant Multiple rule could be used.

And cos(5x) is not valid 1D Maple Notation syntax. As 1D Maple Notation it needs the multiplication sign between the "5" and the "x".

inttutor.mw

There is also an entirely point-and-click mouse driven way to launch the tutor for an expression entered in 2D Math.

* First, load the Student Calculus 1 package using the main menubar. That is, Tools->Load Package->Student Calculus 1  which is the Clickable Math equivalent to the command with(Student:-Calculus1) 

* Next, enter your nicely typeset math expression as 2D Math and right-click on it with the mouse pointer to get the context-sentitive menus. It should be possible to do this for either 2D Math output or input.

* Next, in the popup context-menu, select the Tutors -> Calculus - Single Variable -> Integration Methods

Doing the steps above should launch the Integration Tutor with the given math expression as the Function to be integrated.

acer

One way to go about this is to create an interpolatory procedure. By that I mean a procedure which takes an (x,y) point and returns the interpolated height. With linear interpolation you can thus mimic the `matrixplot` result. And with a procedure you can then easily make an implicit plot of the intersection with z=3.5 say.

Download 3dinterp.mw

You might also consider using a higher order interpolation, by changing `linear` in this code to `cubic` or `spline`. And you can make it finer by using different grids.

And of course you can fiddle with options to plots:-implicitplot, etc.

That technique of obtaining an interpolatory procedure is in the example worksheet Interpolated Plotting and Smoothing.

acer

The Explore command is not deducing that the special words on the right-hand-side of optional plot arguments are not parameters.

There are two ways to deal with this, one of which continues to give you the pop-up window and another which does not. [edited] Neither of these two approaches will work with versions earlier than Maple 17. [/edited]

By creating a procedure or operator `F` which returns your plots then you can call `Explore` on a function call to `F`. The effect here is that only the names of your desired parameters appear in the `Explore` call, and hence only those names appear in the popup window too. But you can still get the popup window.

Another way is to specify all the desired parameters and their ranges by passing an additonal `parameters` argument to the `Explore` command. This bypasses the popup window altogether. The optional `parameters` argument for the `Explore` command was added in Maple 17, so this approach won't work in earlier versions.

[edited] When I originally answered in this thread I had forgotten that I once posted an answer to another, similar question. In that earlier answer I gave some code which would redefine the Explore command in Maple 16 so that the variable (parameter) names could be specified right in the `Explore` call. This is a way to get something like the 2nd approach above (which Maple 17 allows without modification). [/edited]

I've put both of these in the attached worksheet.

Adding_Col_modif.mw

ps. You could also just do it as you had before, and click the "skip" checkboxes in the popup for all names you want ignored.

acer