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

If the expression (dependinng on a, b, and c) has been assigned to the name `expr` then you can create an operator from that with,

f := unapply(expr, [a,b,c]);

The assumptions that modify your Int calls -- made using assuming -- don't carry over to the value calls.

Various simplifications can be made on the result of the value or int calls, using the same assumptions, say.

Another possibility is to convert the integrand to expln form prior to using value.

Download integrals_acc.mw

Try this in your Maple 2016, using the name `#msub(mi("n"),mi("r"))` wrapped in a typeset call.

mprime_ac.mw