Here is a way to substitute names c[i] for the _Cn constants, which also forces the reordering so that specified names c[i] are first in the product subterms. It uses subs for the substitution, as opposed to alias.

This uses sort, and can forcibly correct the example even when the "uniquified" expression (stored by the kernel as the sole representation) has been inadvertantly reordered in a manner contrary to your goal.

sorting_fun.mw

Unfortunately inlining of uploaded worksheets is currently broken on Mapleprimes.

It also finds the _Cn names as they appear, alleviating need to hard code a fixed number of replacements up front. (Other Answers hard-coded 10 substitutions.)

If you come across an example which it cannot handle directly then the procedure could be adjusted accordingly.

Some of the other suggestions (in other Answers) are not always assured to produce the desired ordering of the terms, eg. in cases where the misordered expression have previously existed in the session. So the ability to force the ordering seems useful.

The vertical view is negative, ie. the squares are placed with position at negative y-values. That why you don't see your y-tickmarks, which you've created to be placed at positive vertical postions. They are out of viewing range.

You can adjust this, naturally.

Download sparsematrixplot_yticks.mw

If you are allowed to let Maple do all the work, then you could get by with something short, eg.

is( sin(2*x) = 2*sin(x)*cos(x) );

           true

simplify( sin(2*x) - 2*sin(x)*cos(x) );

             0

Let's suppose that you don't want the work to be hidden in calls to combine and expand or other powerful simplification commands, but that you do know and are allowed to use the sum rule for sin(A+B). Then you can get by with only making various kinds of substitutions.

Download double_angle_sine.mw

Your expression assigned to A is a product of terms.

I believe that the only one of those multiplicative terms which attains zero for real-valued lambda (if evaluated at adequate working precision to avoid spurious roots due to numeric roundoff error) is this one. This behaves well even at default Digits=10.

restart;
p:=-.1141301418e17*lambda^9+.9737052862e16*lambda^8
   -.3682582968e16*lambda^7+.8102838405e15*lambda^6
   -.1142983789e15*lambda^5+.1071802621e14*lambda^4
   -.6680654662e12*lambda^3+.2668788927e11*lambda^2
   -619949976.6*lambda+6379681.930:

fsolve(p);
           0.07016568203, 0.07350618818, 0.1121166384

You can also achieve those with the following, using your A, even at default Digits=10,

Digits := 10;
sols := [fsolve(numer(A), lambda = -0.1 .. 1, maxsols = 4)];

  sols := [0.07016568203, 0.07350618818, 0.1121166384]

You can use higher working precision to show accurately the residual errors.

forget(evalf);
seq(evalf[max(20, Digits)](A), lambda = sols);

                            -9                           -8  
   -7.4318703347473954061 10  , -1.2463236113255786800 10  , 

                             -8
     3.8410294096271317263 10  

I get the following, in Maple 2019.0 or Maple 2019.2.

restart;
kernelopts(version);

   Maple 2019.2, X86 64 LINUX, Oct 30 2019, Build ID 1430966

assume(x, 'real'); assume(y, 'real');
verify(x^2 + y^2, 0, {'greater_equal'});

                    true

restart;
verify(x^2 + y^2, 0, {'greater_equal'}) assuming x::real, y::real;

                    true

Download simp_ex_2.mw

There is also this (but it's easier to let evala figure it out.

factor(T__e_np, sqrt(r^2 + 1));
1/factor(1/T__e_np, sqrt(r^2 + 1));

See https://oeis.org/A000399 which gives several formulations, eg.

seq(coeff(expand(mul((x+i),i=1..n)),x,2), n=1..10);

    0, 1, 6, 35, 225, 1624, 13132, 118124, 1172700, 12753576

seq(1/2*n!*(harmonic(n)^2+Psi(1,n+1)-1/6*Pi^2), n=1..10);

    0, 1, 6, 35, 225, 1624, 13132, 118124, 1172700, 12753576

seq((-1)^n*(Stirling1(n+1, 3)), n=1..10);

    0, 1, 6, 35, 225, 1624, 13132, 118124, 1172700, 12753576

Also,

1/2*(Sum(1/i,i = 1 .. n)^2-Sum(1/i^2,i = 1 .. n))*n!

If it doesn't both you that the result is not always true (and you could lose a sign, etc),

Download rad_rat.mw

That was a problem in Maple 2015, and that particular issue was corrected by Maple 2016.2.

As a kind of workaround you could pass the inert=false option to InertForm:-Display here. I prefer that option because operators get rendered in the usual color of output, rather than in dull gray. For this example the separating brackets get properly shown (though the output appears as implicit multiplication in Maple 2015.2 so it's not quite perfect).

ps. I added the Maple 2015 product marker on your Question, since that's the version in which your atteched worksheet was saved. It might be helpful if you could add that yourself when asking about problems when running in older versions.

These may be close enough to your goals, that you can adjust to taste.

Download Static_Array_Heat-map_test_ac.mw

A proper fix consists of teaching Tabulate:-CellHandler and Layout:-Plot about the _DUALAXES plotting substructure and where to find the ROOT substructure within it.

But, for now, this might serve as terse workaround (Maple 2015.2 or Maple 2020.1, say).

dualaxes_size_Tabulate.mw

(I will file a bug report.)

Your aux2 equation does not look quite right, for your suggested "desired" expression. Or perhaps your "desired" expression is not quite right.

Download subst_ex.mw

Here are a few ideas for inspiration.

The computation of
    n_error[0]:=1.5-newt(1.5);
does not make much sense, if it is intended to mean a comparsion of x[0] and f(x[0]).

The computations of
   nerror[count]:=abs(x[count]-x[count-1]);
make sense, but aren't very meaningful as estimates of error in f.

If you have 10 x-values, then you only have 9 incremental changes. There is no first n_error[0] really (or no last one, depending how you want to write it down).

You might want to end the loop if the x-increment gets too small, or if the f(x) evaluation gets acceptably close to zero.

There's not much benefit in storing rt as well as x.

I'm not sure that DataFrames are the best for the task, or at least I'd suggest that the given Append use is a little awkweard. Here's one way with a DataFrame augmented within the loop, and one without.

Download newt_DF.mw

It has to be either a name or a string, since the literal input literal 46th by itself isn't valid Maple syntax for anything. That's also why your string won't parse.

It would be better if you explained clearly what you mean when you write that you want to "get 46th". What do you mean by "get"? Do you mean you want to be able to display something that looks like that, without the double-quotes showing? If so then in what context? Do you mean that you want a Maple expression? What do you mean by 46th, without the string quotes?

Here is one way to obtain it as a name.
   convert(46,compose,ordinal,name)
That prints in italics.

The following produces a name that prints in the Standard GUI in upright Roman.
  nprintf(`#mn(%a);`,convert(46,ordinal));

Here is one way. You can either call `k` with a single t-value, or with both a t-value and a new a-value.

After the plotting, you can call `k` at whatever t-values you wish.

>  restart; >  xodephi := {diff(x(t), t) = 16250.25391*(1 - (487*x(t))/168 + 4*Pi*x(t)^(3/2) + (274229*x(t)^2)/72576 - (254*Pi*x(t)^(5/2))/21 + (119.6109573 - (856*ln(16*x(t)))/105)*x(t)^3 + (30295*Pi*x(t)^(7/2))/1728 + (7.617741607 - 23.53000000*ln(x(t)))*x(t)^4 + (535.2001594 - 102.446*ln(x(t)))*x(t)^(9/2) + (413.8828821 + 323.5521650*ln(x(t)))*x(t)^5 + (1533.899179 - 390.2690000*ln(x(t)))*x(t)^(11/2) + (2082.250556 + 423.6762500*ln(x(t)) + 33.2307*ln(x(t)^2))*x(t)^6)*x(t)^5, diff(xphi(t), t) = 5078.204347*x(t)^(3/2), x(0) = 0.03369973351, xphi(0) = a}:  #xphi(10.92469316) = 0}: >  sol := dsolve(xodephi, parameters=[a], numeric): >  # # Calling k(anything, numeric) sets the `a` parameter # to the second argument. # # Calling k(anything, nonnumeric) #      or k(nonnumeric, anything) #      or k(nonnumeric) # returns unevaluated. # # Calling k(numeric) computes xphi at that value, # using the current parameter setting. # # Calling k(numeric, numeric) computes xphi at the 1st argument, # after setting the `a` parameter to the second argument. # k := proc(tt, A)   if nargs=2 then     if A::numeric and A<>eval(':-a',sol(parameters)) then       sol(parameters=[A]);     elif not A::numeric then       return 'procname'(args);     end if;   end if;   if not tt::numeric then return 'procname'(args); end if;   eval(xphi(':-t'), sol(tt)); end: >    >  k(10, 100); >  k(10); >  Afound := fsolve(k(10.92469316, A)); >  sol(parameters=[Afound]); >  k(10); >  k(10, Afound); >  #plot( k(10, AA), AA=-500..100, size=[200,200] ); >  plots:-display(Array([   plots:-odeplot(sol, [t,xphi(t)], t=0..11),   plots:-odeplot(sol, [t,k(t)], t=0..11, labels=["",xphi]),   plot(k(t), t=0..11, labels=["",xphi]) ]), size=[200,200]);         >  seq(k(i), i=0..11.0, 0.5); >  seq([i, k(i)], i=0..11.0, 0.5); >

Download ds_param_easy.mw