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.

You have mixed up the allowed format for the data passed as a the first argument to the LeastSquaresPlot command.

You could pass a list of lists for the points, as is documented in the Help page for that command. But you passed a 10-element Array where each entry is a list of two values, which is not accepted by the command.

Try these:

   LL := convert(points, list);
   LeastSquaresPlot(LL, x, curve = c*x, boxoptions = [color = magenta],
                                 view = [default, (min .. max)(LL[.., 2])]);

   LeastSquaresPlot(LL, x, curve = c*x, boxoptions = [color = magenta]);

It's not clear to me what you are trying to accomplish, since there is only one free variable in the example you gave.

Could you explain what you want to be the second independent variable? I am going to guess that you mean the upper value of the index of summation.

Download contourplot_sum.mw

Or possibly this (though not so interesting...)

plots:-contourplot(sum(BesselJ(n,r),n=0..floor(i)),
                   r=-10..10,i=0..5,grid=[51,201],
                   contourlabels=false,
                   filled, coloring=["Navy", "Orange"]);

My oracle came up with these.

You'll have to judge whether the author's of these textbook examples might consider the solutions to be real, or what you think of squaring (or apply exp to)  both sides of an intermediate equation, etc.

Download examples_of_odes_that_do_not_odetest_ac_pt1.mw

[edit. 23/12/2020] Partially addressing a followup example. (End-points can be examined separately.)

# 3647
restart;
ode :=diff(y(x),x)=2*(x*sqrt(y(x))-1)*y(x):
ic  :=y(0)=1:
sol :=dsolve([ode,ic]):
res :=odetest(sol,ode):
solve(simplify(res)) assuming real;
                 RealRange(Open(-1), infinity)

Here is another way that happens to work for this example.

Using allvalues on the RootOfs is a better/stronger idea. It's a shame that a single solve call cannot find the exact real solution directly, even with its explicit option (and possibly with some mechanism to denote realness).

Download solve_exp_poly_ex.mw

There are also some slightly more general but uglier variants which utilize frontend (as if temporarily freezing the exp call) and pass an inequality to solve to denote realness.

There is the iscont command. Its Help page is linked from the "See Also" part of the discont command's Help page.

There will always be problematic examples, however.

Download iscont.mw

There is also fdiscont, which can be finicky but may offer some recourse for examples for which symbolic analysis is problematic. It doesn't go well on your piecewise example, though.

The first thing is that you have a syntax mistake. You have,
    S*`union`(T intersect R);
which ought to be,
    S union (T intersect R);
It's possible that was an implicit multiplication mistake made in 2D Input mode.

Download logic_set.mw

There are several ways to do this. Here is but one of them,

Download CAP13CombinatoireQuestion_ac.mw

I'm not sure why you want them in a set at the end (instead of a list or Vector). When you put them into a set you may lose duplicates.