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

Using Maple 2020.1

Download import_url.mw

There are a few different effects.

There's the collecting of terms in the denominator, which I'm guessing is important for you.

And then there's the ordering of terms in products and sums. I'm supposing that you care more about the order of terms in sums, as that can affect whether there are unwanted leading minus-signs.

This is close, except for the order of the multiplicands (X__1-I__11) and (X__2-I__22).

Download simplif_sort_ex.mw

Download test_units_int_ac.mw

Change the evalf(int(...)) calls to evalf(Int(...)) with capitalized Int.

[edit] On my machine that change alone is enough to bring the timing for the cited problematic example down to under 2 seconds. [end of edit]

The lowercase int attempts symbolic integration, and if that fails then wrapping evalf call induce numeric integration. But you may not wish to expend unnecessary effort on the symbolic attempt.

The capitalized Int is an inert placeholder, and evalf(Int(...)) goes directly to an attempt at numeric integration.

You could normalize the vector magnitude (according to the max over the given ranges, say), to get hue values between 0 and 1, and then scale by a factor to avoid the roll-over in the upper end of the hue.

Or you could cook up a similar thing for RGB instead of HSV.

There are other ways, but this could give you some ideas to play with.

Download color_formula.mw

I included that surface plot3d to illustrate that one of those formulas make it behave something like this:

plot3d(LinearAlgebra:-Norm(<[1,y^2+x]>,2),x=-10..10,y=-6..6,
       colorscheme=["zgradient",[Red,Magenta],colorspace="HSV"]);

And I chose 0.833 for the scaling because that approximates magenta as an upper value for hue.

ColorTools:-Color("HSV", "Magenta")[];
     0.8333333333, 1.000000000, 1.00000000

Here is one way,

V1 := Vector[column](8, [1,2,2,1,3,A,B,1/(A + B)^2]):
V2 := Vector[column](8, [1,2,2,1,3,A,B,1/(A^2 + 2*A*B + B^2)]):

verify( V1, V2, 'Vector(simplify)' );

                 true

How about,

foo:=proc(ode::{`=`, set(`=`), list(`=`)},func::`function`,$)
   print("ode=",ode);
   print("func=",func);
end proc:

Or, shorter,

foo:=proc(ode::{`=`, {set,list}(`=`)},func::`function`,$)
   print("ode=",ode);
   print("func=",func);
end proc:

Or, excluding the empty cases,

foo:=proc(ode::{`=`, And({set,list}(`=`),Not(identical([],{})))},
          func::`function`,$)
   print("ode=",ode);
   print("func=",func);
end proc:

There is no direct LaTeX parser in Maple.

But there is support for mixed plaintext and marked up (typeset) 2D Math in plot titles, captions, legends, etc.

You can enter the 2D Math directly, manually, by operating in 2D Math mode (Ctl-R) and selecting special characters, accents, etc, from the left palettes.

Or you can enter it all in plaintext code using a sort of XML/HTML markup (undocumented, but not overly difficult). That can be accomplished programatically. For example,

Download plot_typemk.mw

For fun, a few more ways that ought to run in Maple 2017.2 (the second is rather slower).

restart;
f := x->18*log10(x):
g := x->1/2*x^3-8*x^2+69/2*x-27:

[fsolve(f-g, 0..12, maxsols=5)];

     [0.03721465484, 1.000000000, 4.506164928, 10.00000000]

sort(remove(type,[solve(f(x)-1.0*g(x))], nonreal));

         [0.03721465485, 1., 4.506164928, 10.00000000]

Here is one way. There are others. I think that it's useful that these render in upright Roman rather than as italics.

Download sci_not.mw

The command assigned provides functionality that can be used to test whether a value is being used as index for a given table (ie, that the table reference evaluates to something else).

restart;                                                                           

L["hello"]:=funny:

assigned(L["hello"]);

                true

You can use the ExcelTools:-Export command.

If you export a list to .xls file then the entries should appear as a row within your spreadsheet application (eg. Excel).

If you export a column Vector to .xls file then the entries should appear as a column within your spreadsheet application. When you call the Vector command in Maple the default for it to act like the Vector[column] command and to produce a column Vector.

For example,

L := [seq(fsolve(x*y=1),x=1..2,0.2)];

V := Vector(L);

ExcelTools:-Export(L, "f1.xls");

ExcelTools:-Export(V, "f2.xls");

You will find that even the basics commands of the Maple programming language allow for much more power and flexibility than the right-click or context-menu actions ever can. It's worthwhile figuring out how to do such things purely programmatically.

Here are two (related) ways to obtain your other solutions, that involve first isolating or eliminating the y from F.

(I broke it into two steps, to try and make it more clear.)

restart;
F,G := x*y^2-x,x*sin(Pi*y):

W := solve(F,{y});

                W := {y = 1}, {y = -1}

seq(u union solve(eval({F,G},u),{x}), u=W);

             {x = x, y = 1}, {x = x, y = -1}

restart;                                                                           
F,G := x*y^2-x,x*sin(Pi*y):                                                        

T := eliminate({F,G}, {y});

           T := [{y = -1}, {}], [{y = 1}, {}]

seq(u[1] union solve(eval({F,G},u[1]),{x}), u=T);

             {x = x, y = -1}, {x = x, y = 1}

You can use 2-argument eval to get at the values.

You can use an assignment statement (ie,:= the colon-equals) or the assign command.

For example,

sol := solve({x+y=3,x-y=-2});

          sol := {x = 1/2, y = 5/2}

eval(x, sol);

                     1/2

eval(y, sol);

                     5/2

assign('A', eval(x, sol));

A;

                     1/2

A := eval(x, sol);

                   A := 1/2

B := eval(y, sol);

                   B := 5/2

If you use the rhs command, or index into the solution by position, then you're doing it wrongly.