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

The eigenvectors associated with eigenvalue evals[i] can be computed as the Null Space of the Characteristic Matrix using at lambda = evals[i] .

Download eigenvects.mw

There are various ways to simplify your examples. Presumably you want approaches which are understandable and less ad hoc. (In the first examples in this attachment, the evala command does as well as radnormal.)

If the denominators (of the arguments of the ln calls) are factored after expanding, then one of the factors will cancel automatically with part of the corresponding numerator, for your examples. See the last two lines in this attachment, for insight on that as well as expansion without that factoring.

Download targeted.mw

The procedure Mutate acts in-place on the particleposition Array, so it seems like you want that Array to be a running state of the updated values.

But inside your procedure Mutate there is a statement y :=x .Perhaps you intended y:=copy(x), and to have the last line of that procedure be return y ?

If L2 is very large then you might want to ascertain a true result as soon as any element of L2 is found to be in the union of the L1 sets.

In other words, you may find it too costly to compute a full set intersection (or minus) involving examining all of L2, or a full seq of tests over all of L2.

In such a case you could try ormap , which will return true as soon as it finds its first true result. Ie.

   ormap(member,L2,`union`(L1[]));

There may, however, be some function-call overhead for calling member many times. (There are some kinds of calculation where it matters whether you want to focus on worst possible vs best average behavior, etc, in which case deciding what's best can entail figuring out what's likely as well as what you want.)
 

That do is our of place. That keyword is not part of an if..then..end if.

You likely don't want a loop here.

Are you trying to get something like this?

Here I use to frontend to suppress/freeze the derivatives, while using eliminate on the variable m, and then consider the remaining conditions (implied equations, the second part of what eliminate returns).

Download eliminate_examp.mw

You can substitute for m+F(xi) using freeze and algsubs, and then collect, and then resubstitute using thaw.

You have a variety of ways to simplify, or not, the coefficients (of the m+F(xi) powers). Below I show two ways, one with some simplification.

Download collect_freeze.mw

I don't know of a way to accomplish what you want using a legend per se, especially if the font size and dimensions have to be as you have them.

But what about a combination of shorter line segments alongside textplot, inlined into the plot? It's more effort to set up just right, but gives more flexibility to correct for the linestyles. legendwidth.mw