There are several ways to get such a result.

Download coeff_T.mw

Here's one way (which works whether your lprime is itself even, or odd).

Download sum_even_terms.mw

Here's another way, using inert multiplication.

The marked-up display of the result is done differently than working with the value of the result.

(In the actual Maple GUI the space between LongExpression and the x-dot is more apparent. You could also throw another %* in there too.)

Download inert_mult_examp.mw

It appears as if your goal might be simply to keep the coefficients of the Vectors from being distributed throughout their respective elements.

In that case you'd be ok with active operations within the Vector elements, in addition to active Vector calls.

Download inert_Vector.mw

I'm not sure why some parts of the following attached worksheet appear like blocked yellow when rendered on this site. In the actual Maple GUI they are highlighted, but their foreground math is visible. (This site uses an old MapleNet...)

Download Help_derivative_and_limit_ac.mw

1D Vectors and 2D Matrices can be converted to list and listlist, respectively, before being embedded in a command-string passed to Maple's bundled python interpreter.

And CodeGeneration:-Python might be able to convert your Maple expression into Python syntax,

For example,

Download python_ex.mw

I am not sure why the array result from Python is not better converted back to a Maple data structure.

What about invoking it as,

   p:-process(p, p)

and avoiding overhead of construction?

Download obj_own.mw

It's not clear how much detail you want in the steps.

I put some settings and the source for the show procedure (used below) in the Startup Code section of the worksheet. I used Maple 2021.2.

Download trap_simp_steps.mw

Your code is calling PRoc with argument s=94.24777963 .

And then, inside PRoc, m=s/A is 90.00000001. And then k=trunc(m)+1 is 91. And then in the call to pointplot you reference varphi[k]=varphi[91]. But the earlier code has only assigned varphi for indices from 1 to 90, and varphi[91] is unassigned and not numeric. So the pointplot call generates an error, because not all the points's coordinates are numeric.

So your problem seems (at least partly) due to a flaw in the animate routine, where it passes a value slightly outside your supplied range. That value of 94.24777963 is greater than the upper end-point of the range 0..Pieces*v*A that you passed to animate. (It's due to numeric roundoff error, I think, but not just because the value A contains the symbolic value Pi.)

You might try constructing your animation as follows. This does not call PRoc with a value higher than the upper end-point. (It's not the only way around your problem, but it avoids fiddling with PRoc.)

plots:-display([seq(PRoc(h),h=0..evalhf(Pieces*v*A),
                    numelems=110)],
               insequence=true);

reproduce_issue_ac.mw

For fun (done in Maple 2022.1).

Download SolveSteps_twice.mw

Writing a procedure for Newton's method is easy, and you should be able to find several implementations with a quick search of this forum. That kind of functionality is also provided by some stock Library commands, eg,

with(Student):
Calculus1:-NewtonsMethod( x^3+x+1, x=-1,
                          iterations=4, output=sequence );

  -1, -0.7500000000, -0.6860465116, -0.6823395824, -0.6823278040

NumericalAnalysis:-Roots( x^3+x+1, x=-1, method=newton,
                          tolerance=1e-09, output=sequence);

  -1., -0.7500000000, -0.6860465116, -0.6823395824, -0.6823278040, -0.6823278040

Instead, I will show below a scheme that reproduces the step-by-step computations as shown in your image. After all, that is what you specifically requested in your Question. (Done in Maple 2019)

Download NewtStep.mw

The first argument (a string) needs to keep its double-quotes inside the constructed name. So you could use the %a modifier for it, in nprintf.

Your problem is the disappearance of those quotes, in the name construction. That first use in your nprintf call of the %A modifier -- without any wrapping, escaped, double-quotes in the format -- is the mistake.

Also, technically the constructed name should end with a semicolon. (In modern version it can work without it for regular output, but there are some scenarios in plotting where it is necessary to get the typeset effect.)

One solution is:

cprint:=proc(s::string,c)
  nprintf("#mo(%a,mathcolor=\"%a\");",s,c);
end proc:

cprint("this is green",green);

cprint("this is green",red);

Another solution (which handles both strings and plain names as the first argument) is:

cprint:=proc(s,c)
  nprintf("#mo(\"%A\",mathcolor=\"%a\");",s,c);
end proc:

cprint("this is green",green);

cprint("this is green",red);

cprint(soliton,purple);

There are various other alternatives.

You mentioned the TangentLine command, so here's one way to use that.

I'll include two examples: one implicit in both x & y, and one explicit in y. You didn't mention which your "curve" might be. The Calculus1:-Tangent command is an alternative for explicit examples.

Download TangentLine_ex.mw

I could have used the plot command for the lines, but I thought it looked slightly simpler with passing both the line and the curve's expression to implicitplot.

You could choose to work consistently with either all floats or all exact values, when calling Rank.

In the float case you may need all the floats to have at least the same accuracy up to the working precision with which Rank is performed. (In other examples or scenarios that can get trickier.)

For your particular example, you could get by with these:

Download bas.mw

You had also tried using the plot command, so I'll show how alternatively you could use that command.

Note that I use the axiscoordinates=polar option as well as the coords=polar option.

Note that it still helps to restrict the coordinateview, so that the horizontal offset of the vertical line is clear.

plot( 2/cos(theta), coordinateview=[0..4,0..2*Pi],
      coords = polar, axiscoordinates=polar );