Your code falls into the well-known mistake sometimes called premature evaluation. The problem is that you need to guard against the evaluation of T before c gets any numeric value.

The seq command has special evaluation rules, and that's why it works when you use that as your "trick". The normal evaluation rules for Maple is that procedure calls evaluate their arguments up front.

A simple approach is to delay evaluation using single right-quotes (a.k.a. unevaluation quotes) around the calls to X,Y in the second argument passed to the animate command.   cardioidfamily_ac.mw

There are other ways to deal with this issue.

Another way is to construct the procedures so that they return unevaluated if the relevant arguments are not numeric.   cardioidfamily_ac2.mw

Yet another way to construct the animations is to use two procedures which each make a whole frame.   cardioidfamily_ac3.mw

I'll add that the collection of point-plots (for all c values) could also be constructed in a single call to pointplot. (I haven't done that.) I also didn't change the over all approaches, or put in any efficiency improvements to re-use previously computed values.

You might also see this page.

I added the missing with(plots) to all the worksheets.

[edit] Since it is only procedure T which requires any guard against unwanted evaluation at non-numeric argument, here are revised versions which do only that. I've also added option remember to T, so as to gain efficiency by avoiding duplicate fsolve work.
cardioidfamily_ac_rev.mw
cardioidfamily_ac2_rev.mw
cardioidfamily_ac3_rev.mw

So this is a followup (duplicate topic) of your earlier Question here? (If so then please, next time add your followup query to the original Question thread. That keeps the whole topic together, which helps all the readership.)

Is this what you want? This is one of the least graceful ways of doing it:  both_of_them_ac_huh.mw

If that's not what you want then please add more complete and explicit details of your query.

I tagged this Question as Maple 17, since you didn't make the effort to do that.

It is a bug that plottools:-extrude produces a VIEW substructure in its result.

A simple way to deal with it is to immediately clobber any VIEW substructure that extrude produces. Ie, something like,

    plots:-shadebetween(x^2, 2-x^2, x=-1..1, color=red, transparency=0):
    p1 := eval(plottools:-extrude(%, 0..0.3),VIEW=NULL):

Or you could use subsindets to get the same effect. It's also wrong that extrude generates any axis lablels.

Download bug-in-3D-view_ac.mw

I'll submit a bug report.

sum(sin(Pi*n/2)*sin(n*Pi*(x + 1)/2)*cos(n*Pi*t/2),n=1..infinity,formal);

                0

Have you tried giving parameter t a default value which is an integer?

Eg,        t::{integer,name}:=0

This kind of optional parameter is called a positional parameter (as opposed to a keyword parameter).

Download param_default.mw

Of course there are other ways to accomplish the same effect. You could have used it as, say,       t::{truefalse,name}:=false

restart;
graph2 := proc(fn::anything, t::{truefalse, name}:=false)
   if t=false then return fn;
   else return plot(fn, gridlines);
   end if;
end proc:
graph2(x^2);
graph2(x^2,g);
graph2(x^2,false);
graph2(x^2,true);

You could also utilize a keyword parameter.

What purpose do you want the name to serve, when you pass that instead? For example, is passing the extra name g supposed to do something different than passing the extra name w? (If not then this definition might not seem graceful to everyone...)

I supplied the missing definition of the list xx of x-values.

This also runs about 3-3.5 times faster than the original, on my machine, but requests the same accuracy for computing the two final lists.

I also fixed the operator assignment syntax so that it wouldn't pester each time about operator-definition versus remember-table.

I used Maple 18.02, since the OP's original attachment was last saved in that version. (I suspect that the OP confuses Maple 18 with Maple 2018, which are two totally different versions, with their release dates separated by four years.)

Download permanouuuuuuuuuuuuuuuuuun_ac.mw

The following runs around 4 times faster than the original, as another variant. permanouuuuuuuuuuuuuuuuuun_ac2.mw

Here is interpolation by piecewise splines. Using Maple 2019.1.

The interpolated curve is red. The first derivative of that interpolated curve is black. The orange diamonds indicate interior inflection points of that interpolated curve.

If you use a different method of curve-fitting then your interpolant (and its inflection points) may not be the same. That's a mathematical consequence, not a Maple quirk.

Download spline_interp.mw

Assigning values to some of the variables is not necessary for your problem. It is not really "substitution", nor does it create equations. It often just gets in the way or, in your case, leads to a circular muddle.

Equations are perfectly good expressions in Maple, and very useful. For example, step by step,

Download substitutions_eval.mw

Above, I used an equation for the solving step. And the substitutions were done using the other equations (with the eval command). None of your key variables profit, tax, or totalsalesx had to be assigned. Even the result from solve is an equation, which in turn can be used in eval.

There are lots of ways to do this. Here's another variant.

Download substitutions_eval2.mw

This is not expert stuff. It is basic Maple praxis, worth learning.

If you want the same color scheme for both, and if you're willing to accept more of a density-plot style, then here is an easy way.

You could, of course, also merge the bottom 2D layer with contour lines, and also raise that to the height of the surface. (Neither of those is especially complicated -- Kitonum's shown you that way.)

Download denseasy.mw

Some other, fancier alternatives are here.

The taylor command produces the same sort of beast as the series command, and returns a special structure (which merely pretty-prints as you see it).

You can utilize the convert command to turn the result from taylor (or series) into simple sum of terms.

You can also use the series command to merge the difference into a new series structure.

Download seriesconvert.mw

Another way to get a simlar effect is to call   taylor(E1-E2,x) . Christian's Answer did that last call with the option 4 passed for the order. But that 3rd argument may be omitted on the comparison; you can compare the difference between E1 generated with 6 as third argument, and E2 generated with 5 as 3rd argument).

Download seriesconvert2.mw

plots:-animate(plot, [[cos(x+2*a), cos(x-2*a)], x = 0 .. 4*Pi],
               a = 1 .. 10, frames=117);

You have used the syntax for function application, rather than multiplication.

You are missing multiplication symbols between your brackets, if your code was entered as (plaintext) 1D Maple Notation.

Even in 2D Input mode you'd still need either explicit multiplication symbols or spaces between the brackets to denote multiplication implicitly.

Download syntaxmult.mw

Perhaps it will help you a little to go through it a step at a time.

Notice that I'm only using the formula on the right hand side of each equation returned by solve. (There are other ways to accomplish the goal, but this might make it a little more clear.)

Download tima_inv.mw

This question is vague and underspecified, because it only gives two examples, which both happen to have 1 nonzero digit on the left of the decimal point in the input as well as the output under default display.

So about the only way that I can make sense of the request is that the OP wants 1 leading nonzero digits to the left of the decimal place, and no trailing zeros after the right-most nonzero digit.

Download leaddig.mw

The RiemannSum command accepts an option partition which can be used to specify the partition values as a list.

For example,

restart;

f := x^2:

P := [-1, -1/4, 1/4, 3/4, 1]:

Student:-Calculus1:-RiemannSum(f, x=-1..1,
                               method=lower, partition=P);

               0.2187500000

For this example it's easy enough to check that result,

add(minimize(f,x=P[i]..P[i+1])*(P[i+1]-P[i]), i=1..nops(P)-1);

                  7 
                  --
                  32
evalf(%);

               0.2187500000