This forum question led to a discussion of a bitwise magazine review that compared Mathematica 5.2 and Maple 10. In that review the author struggled to get the following numeric integral to compute accurately and quickly in Maple.

evalf(Int(BesselJ(0, 50001*x)*x*exp(I*(355*x^2*1/2)), x = .35 .. 1));

Below, I reproduce an attempt at computing an accurate result quickly in Maple. I'm copying it here because that thread got quite long and messy.

In the blog  Plots of twisted ribbons, the author gave an interesting description of plotting twisted ribbons. In this blog , we give a similar description of twisted ribbons and give the geometrical interpretations of this definition.

 

Let r(phi)=[a*cos(phi), a*sin(phi), 0] (phi=0..2*Pi) be a circle in the xy-plane, and P be a point on the circle. Let QR be a line segment (with length of 2) passing through the point P and let P be the middle point of QR. Also, QR is coplanar with the z-axis.

Now let P rotate about the z-axis at the angular velocity of phi, where phi is the angle between OP and the x-axis. At the same time, the line segment QR is rotating about its middle point, P, at the angular velocity of theta (where theta is the angle between PQ and the z-axis and theta is dependent on phi, eg, theta=k*phi). In the whole process, QR will remain coplanar with the z-axis.

 

Apparently, the locus of the line segment QR is a twisted ribbon. When theta=phi/2, we have the Mobius strip.

2. The equation of the twisted ribbon

 

Now we try to find the equation of the surface. Clearly,

vector(OP)= [a*cos(phi), a*sin(phi), 0].

And with some geometrical manipulations, we have

vector(PQ)=[sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta)].

So the vector equation of the twisted ribbon is

V(phi, t)=vector(OP)+t*vector(PQ)

And the parametric equation is
x=a*cos(phi)+t*sin(theta)*cos(phi),
y=a*sin(phi)+t*sin(theta)*sin(phi)

z=t*cos(theta)

(where theta=k*phi (k a constant), phi=0..2*Pi and t=-b..b (b determines the width of the ribbon.))

Or
x=(a+t*sin(k*phi))*cos(phi),
y=(a+t*sin(k*phi))*sin(phi)

z=t*cos(k*phi)

(where k a constant, phi=0..2*Pi and t= -b..b)

When we take k=1/2, 1, 3/2, 2,…, we have different twisted ribbons.

When k=1/2, we have the equation of the Mobius strip:
x=(a+t*sin(phi/2))*cos(phi),
y=(a+t*sin(phi/2))*sin(phi)

z=t*cos(ph)/2

(phi=0..2*Pi and t= -b..b) .

 

k=1

 

k=2

John Fredsted suggested using the following procedure (slightly modified) to determine whether an expression was deeply algebraic.

isDeeplyAlgebraic := proc(x)
	if not type(x,'algebraic') then false
	elif type(x,'atomic') then true
	else andmap(procname,x)
	end if
end proc:

TypeTools:-AddType('DeeplyAlgebraic1'
                   , proc(x)
                         if not x :: 'algebraic' then false;
                         elif x :: 'atomic' then true;
                         else andmap(type,x,'DeeplyAlgebraic1');
                         end if;
                     end proc);

The first is a completely flat expression, the second is deeply nested.  The following graphs plot the time required to determine whether each expression is "deeply algebraic" as n increases, with each approach. The graph on the left is the time required to evaluate expr1, the graph on right is for expr2.  The red plot corresponds to the procedure, the green plot corresponds to the type. As you can see, for both flat and nested expressions, the procedure is significantly faster than the type.

 

I then did some testing to see whether the type matching could be improved.  A more efficient use of the type mechanism is to use a structured type rather than a procedure.  Alas, I don't believe that it is possible to create a purely structured type, with no use of 'satisfies', that is equivalent to what we want.  Here is the best I could come up

TypeTools:-AddType('DeeplyAlgebraic3'
                   , 'And'('algebraic'
                           , 'Or'('atomic'
                                  , 'satisfies'(x->andmap(type,x,'DeeplyAlgebraic3'))
                                 )));

Adding that to each graph gives the following two plots

 

The yellow line (p3) corresponds to this new type.  For expr1, the flat expression, it is significantly faster than the previous type, and approaches the speed of the standalone procedure.  Alas, for expr2, the nested expression, it is even slower than the previous type.  However, the reason it is slower is that with a nested expression the 'satisfies' part of the type has to be evaluated, which generates a call to a user-level procedure.

This observation suggests that if the type could be expressed as a structured type, with no use of 'satisfies', it might be significantly more efficient.  While I can see no way to do that with the desired predicate, it is possible to construct a type specific to these two examples:

TypeTools:-AddType('nestedF', 'And(algebraic,Or(atomic,function(Or(atomic,nestedF))))');

This isn't equivalent to the original predicate because it only works with functions, not operators (+, *, etc).

Here are the results with that type

Now we are making progress.  The blue plot (p4) is the time for this restricted type.  It is significantly faster than even the standalone procedure.

Note that if there were a structured type, say allops, that returned true if all of the operands of an expression match the given type, then we would be able to construct a purely structured type that matches our original predicate, that is,

TypeTools:-AddType('DeeplyAlgebraic4'
                   , 'And(algebraic
                          , Or(atomic
                               , allops(DeeplyAlgebraic4)))');

I want to plot the normal vector of the Mobius strip represented by the parametric equations:
x=(2+u*cos(v/2))*cos(v):

What could be done with a module whose ModuleLoad routine redefined itself?

Could such a routine do some action, and then cover its tracks effectively by overwriting itself?

Would there be any way to use march() to examine the .mla archive member, in which that ModuleLoad routine is stored, without accessing the name of the module? Presumably any invocation of the actual module name would result in its being accessed from the library and hence trigger its ModuleLoad routine.

Maple's foldl and foldr procedures provide a convenient means to generate an n-ary function from a binary operator. For example, from another thread, one can use foldl to create an n-ary and procedure from Maple's binary `and` function:

There are some routines in Maple's library which, when called the first time, redefine themselves.

One plausible explanation for this is that the new versions are session dependent (external calls, say) while also more efficient to call (repeatedly).

For example, consider StringTools:-Join which seems typical of that package. First, consider it before it's been called at all.

> restart:
> showstat(StringTools:-Join);
 
StringTools:-Join := proc(...

In Maple we can easily plot a space curve if it is given by a parametric form:

x=x(t), y=y(t), z=z(t) (t=a..b).

However, Maple does not give a easy way to plot a space curve if it is given by the intersection of two surfaces:
F(x,y,z)=0, G(x,y,z)=0.

 So, I wonder if there are easy ways to solve this plotting problem?

For example, I'd like to know how to plot the following space curve In Maple :
x^2+y^2+3*z^2=1, 2*x+3*y+z=0.

Example 1  The region between y=x and y=x^2.

 

with(plots):

f:=x->x: g:=x->x^2:

F:=spacecurve([x,f(x),0],x=-0.2..1.2,color=blue, thickness=3):

G:=spacecurve([x,g(x),0],x=-0.2..1.2,color=red, thickness=3):

region:=plot3d([x,y,0],x=0..1,y=g(x)..f(x),color=grey, style=patchnogrid):

display(region,F,G,axes=normal,orientation=[270,0], scaling=constrained);

 

 

Example 2 The region between y=sin(x) and y=cos(x).

with(plots):

f:=x->sin(x): g:=x->cos(x):

F:=spacecurve([x,f(x),0], x=-0.5..6.5,color=blue,thickness=3):

G:=spacecurve([x,g(x),0], x=-0.5..6.5,color=red,thickness=3):

Region:=plot3d([x,y,0], x=0..6, y=g(x)..f(x), color=green,style=contour):

display(Region, F, G, axes=normal, orientation=[270,0],scaling=constrained);

 

Example 3  The region between x=y^2/2 and x=y^4/4-y^2/2.

with(plots):

f:=y->y^2/2: g:=y->y^4/4-y^2/2:

F:=spacecurve([f(y), y, 0], y=-0.1..2.1, color=blue, thickness=3):

G:=spacecurve([g(y), y, 0], y=-0.2..2.1, color=red, thickness=3):

Region:=plot3d([x, y, 0], y=0..2, x=g(y)..f(y), color=gray, style=patch,grid=[10,10]):

display(Region, F, G, axes=normal, orientation=[270,0], scaling=constrained);

 

Example 4  Bird’s eye view of Example 3 (Just change the orientation.)
with(plots):

f:=y->y^2/2: g:=y->y^4/4-y^2/2:

F:=spacecurve([f(y), y, 0], y=-0.1..2.1, color=blue, thickness=3):

G:=spacecurve([g(y), y, 0], y=-0.2..2.1, color=red, thickness=3):

Region:=plot3d([x, y, 0], y=0..2, x=g(y)..f(y), color=gray, style=patch,grid=[10,10]):

display(Region, F, G, axes=normal, orientation=[300,55], scaling=constrained);

 

 

 

 

 

I use Maple primarily in a Unix text window (TTY or "command-line" Maple), so I am used to seeing common subexpression labeling in the output of my computations. However, in Maple 11, GUI users don't see subexpression labeling by default.  I'll begin by talking about subexpression labeling as it appears in TTY Maple, then I'll talk about it in the GUI.

For starters lets look at an example in which a single subexpression is labeled:

There are a number of facilities in Maple which may be extended. Included amongst those are `type`, `print`, `evalf`, and `latex`. The help-page ?extension_mechanism claims that all the built-in functions allow for extension. It also mentions a few system Library routines such as `verify` (but does not mention `latex`).

There are some descriptions of varying completeness in a few...

The third example on the Plot Tickmarks and Gridlines help page - ?plot,tickmarks(tickmarks) - shows how to put labels at specific locations on a plot axis. But I couldn't find anything in the help pages about altering their font. However by changing the labels to names (enclose in left quotes, instead of double quotes) their font could be set using the axesfont option.

Perhaps something could be added to the example mentioned above. In the longer run though, all the help pages for plots need to be re-written: at present they resemble an untidy scrapbook.

J. Tarr

The command > contourplot(-1,x=0..1,y=0..1,contours=[0],filled=true); is supposed to fill the whole space with red (color for negative values) but it does nothing this is also problem once I need to define a piecewise function which is constant according to some condition, e.g. > f:=(x,y)->piecewise(x>1/2,x*y,-1); > contourplot(f(x,y),x=0..1,y=-1..1,contours=[0],filled=true); this should fill the entire half plane x>1/2 with red, it fills only part of the first quadrant...

The simpliest version of my problem is this: > f:=(x,y)->fsolve(sin(x+y+z)=1,z) > f(5,5); still ok but now: > plot(f(x,5),x=5..10); sais: "Error, (in fsolve) x is in the equation, and is not solved for" it seems as Maple would not first evaluate x:=5 and then solve f(x) :'(

I've made up a worksheet of the Top Ten Maple Errors, containing some of the common mistakes I often see newcomers to Maple commit (especially in the setting of my Introduction to Mathematical Computing class). I hope you will find it useful in trying to avoid those mistakes. Of course this is only a personal list, and not exhaustive. Please feel free to argue the merits of other items that should be included in the list. Here is the link: Download 4541_topten.mw