[edited] The originating point, where the period cycles, is different. In a sense the cross "crosses" there, since it overlaps with itself. I may need to re-implement the approach.

Download intersect2.mw

If I understand you, the query is about deriving/constructing the Sum (since we could always just enter it by hand, but that's not exciting).

I'm not aware of anything like a Split (in SumTools or wherever). So that part is manual (but a procedure for it could be written easily, for re-use).

I would not be surprised it were relatively easy to fix up the sign on -a, or expand wrt a instead, or fix up the binomial to be the prettier equivalent.

Download binomialSum.mw

Why I'd agree with Kitonum that is can often be a way to go with such things, 

verify(2*cos(phi)^2-1, cos(2*phi), simplify);

                   true

Note that verify,equal may rely upon signum, and,

signum(2*cos(phi)^2-1 - cos(2*phi));

              /          2                 \
        signum\2 cos(phi)  - 1 - cos(2 phi)/

simplify(signum(2*cos(phi)^2-1 - cos(2*phi)));

                   0

Here is something, under assumptions like k::posint, x::real, etc.

(Btw, are those Mathematica results valid everywhere? I don't feel like typing them in.)

Download int_k.mw

Download 2d_inert_star_M18.mw

You are incorrectly interpreting the meaning of _nparams. It does not mean the number of passed arguments.

Compare with _npassed .

See the help pages for parameter processing, especially the one entitled Using Parameters within a Procedure and its section Special Sequences.

This all pertains to procedures and how parameter processing works in general, and is not specific to the debugger.

Rouben's solutions is nice and good, provided you are ok with the first frame in the whole collection being the one with m=1. Note that printing an animation (eg, using the plots:-display command) will always place the menubar's play marker at the beginning.

However, if you are looking to have the play marker be initially set to near the middle of all the frames (slider) then that won't get you what you're after. Here is one way to get that alternative. The animation assigned to A is constructed in a usual way. But, instead of showing it in the worksheet by the usual printing mechanism for plots, it is embedded in a borderless Plot Component and then the frame number is advanced to the desired value.

restart;
A:=plots:-animate(plot,[m*x,x=-10..10],m=-10..10,frames=21):
with(DocumentTools):
with(DocumentTools:-Components):
with(DocumentTools:-Layout):
LK:=InsertContent(Worksheet(Group(Input(Textfield(Plot(
         A,
         identity="Plot",showborders=false))))),output=table):
SetProperty(LK["Plot"],frame,12);

There are lots of possible refinements to this idea. For example, one can embed a Plot Component set visible=false, then set the animation as its value property, then advance the frame, and only then set as visible=true. (This may remove any update flash, which I don't see but someone might conceivably notice...)

Why do you say that the plot doesn't look similar to that in the link (in your pdf file)?  https://www.sfu.ca/~ssurjano/shubert.html

Or are you trying to say that the plots on that URL are not what you expect either? There are no plots in the pdf paper you've cited. On precisely what part of that paper, and formula, do you expect us to focus?

Download shubert_plot3d.mw

The supporting code needs to be auto-execute, for it to work in the MaplePlayer.

The easiest way to do this is put all the supporting code in the Startup Code region (ie. from the main menubar, use Edit->Startup Code).

Cassinian_oval_ac.mw

note: I prefer procedures which utilize uses, rather rely on with being run at the top-level. And I prefer not to declare global variables within a procedure if they don't serve a purpose. Not a big deal. Cassinian_oval_ac2.mw

Either of the two first methods below are about 200 times faster than the last two methods below (MapleMathMatt's and Kitonum's suggestions).

Using inert Int (or int with the numeric option) instead of active int prevents Maple from trying to solve the integral symbolically for each value of epsilon.

Using the operator form of the integrand (or using the specified method) prevents `evalf/int` from trying to check for discontinuities at each value of epsilon.

Download plot_integral.mw

For this example it seems that fsolve has trouble without some extra hint of the range for some of the variables.

But solve gets it directly.

Download fsolverng.mw

restart;

L1 := [t-2,(t-2)^2]:        
L2 := [(3*t/2)-4,(3*t/2)-2]:

solve(Equate(L1,L2));

                            {t = 4}

My guess is that you are looking for something like the effect of the plots:-dualaxisplot command.

See this revision: GaußKronrodQuadraturFehlerbehandlung_ac.mw

Don't use the word function like that in relation to Maple. Nobody will know for sure whether you are talking about an expression (which could be evaluated at values for its unknowns) or a procedure (which can be called with values).

I am going to guess that you mean a procedure (of which an arrow-printing operator is one variant).

Have you set up your procedure to do something special (eg, return unevaluated) if it is called with a simple name for its parameter x?

If not, when why not do something like evalf[4](f(x)) where x is some unassigned name?

There is no blazingly simple way to print the body of a procedure and have it be pretty-printed in a modified manner. (There are ways, but advanced.)

Download some_tangents.mw

And for fun,

Explore(plots:-display(
          seq( plot([cos(n*2*Pi/N)-q*sin(n*2*Pi/N),
                     sin(n*2*Pi/N)+q*cos(n*2*Pi/N), q=-2..2]),
               n=0..N-1 ),
          gridlines=false),
        parameters=[N=1..50], initialvalues=[N=30]);

[edited] The original formulation is not efficient. Each line segments really requires only its two end-points. They are lots of ways to accomplish that: plottools:-line, forced numpoints, pointplot with linestyle, etc. So this runs more smoothly,

Explore(plots:-display(
          seq( plot([seq([cos(n*2*Pi/N)-q*sin(n*2*Pi/N),
                          sin(n*2*Pi/N)+q*cos(n*2*Pi/N)],
                         q=[-2,2])]),
               n=0..N-1 ),
          gridlines=false),
        parameters=[N=1..200], initialvalues=[N=30]);

And, even though the earlier code wasn't unbearably slow,

plots:-display(
          seq( plot([seq([cos(n*2*Pi/60)-q*sin(n*2*Pi/60),
                          sin(n*2*Pi/60)+q*cos(n*2*Pi/60)],
                         q=[-2,2])]),
               n=0..60 ),
          gridlines=false);

or (better than the original, but not as quick as that immediately above),

plots:-display(
        seq( plot([cos(t)-q*sin(t), sin(t)+q*cos(t), q=-2..2],
                  adaptive=false, numpoints=2),
             t=0..evalf(2*Pi), evalf(Pi/30) ),
        gridlines=false
              );