Using Digits:=15 my 64bit Maple 2017.1 for Linux obtained a solution with a pretty good residual, in not so bad time.

Download bigSys_dig15.mw

Try adding the option,

tickmarks=[piticks,default]

to your call to implicitplot.

You might also wish to force the full horizontal view from 0 to Pi/2, say by also adding the option.

view=[0..Pi/2,default]

Execute the statement,

randomize():

at the start of your worksheet.

Q:=Matrix(Q, datatype=float[8]);

or,

Q:=Matrix(5,5,(i,j)->simplify(Q[i,j],zero));

or several other variants.

Similarly,

H:=Vector(H,datatype=float[8]);

or,

H:=Vector(5,(j)->simplify(H[j],zero));

or variants. As you've seen in other message threads, small nonzero imaginary components can be handled with `fnormal`, before calling `simplify`. Or you can be more forcing and use the `Re` command. 

nb.Without running your code in Maple, your Matrix K looks purely real, symmetric, and your Matrix M looks purely real, symmetric, positive-definite. If so then the eigen-solution should have all-zero imaginary components.

Are you using an older version of Maple? If I recall then in recent Maple version the zero imaginary components of complex[8] rtables are suppressed on printing.

The fnormal command let's you replace small floating-point values with 0.0 or 0.0+0.0*I, etc. This command allows you to control the fineness, optionally. See its Help page.

As Kitonum has shown, the command simplify(expr, zero) removes the 0.0 occurences (real or imaginary) from the expression `expr`.

Are you looking for plots:-implicitplot3d, where its first argument might be f(x,y,z)=K for K numeric?

Let's try an example with more corrner cases in it.

Below I use uneval quotes (single right-quotes) because neither typefunc nor last_name_eval is a protected name.

restart;

eq := diff(x(t), t) = t + x(t) - 1 + sin(x(t))
      + cos(t) + G(t, x(t), v(t)):

indets(eq,{name,'typefunc(name,Non(last_name_eval))'});

                               {t, v(t), x(t)}

indets(eq,'typefunc(name,Non(last_name_eval))');

                                {v(t), x(t)}

indets(eq, {name, function(name)});

                           {t, cos(t), v(t), x(t)}

indets(eq,function(name));

                            {cos(t), v(t), x(t)}

How about handling F(t), where F is a user-defined procedure which returns unevaluated if its argument is not numeric? (Think of using the known option of dsolve/numeric, and other similar situations.) For unassigned argument t, calling F(t) returns the unevaluated function call F(t) itself.

Since F is a known procedure, which is already defined to compute an output number from an input number, then neither F nor F(t) is a "dependent variable" of the DE.

# In general F may be a black-box procedure, whose workings
# are not explicitly known.
F:=proc(u)
  if not type(u,numeric) then
    return 'procname'(u);
  else
    tan(u)+u^2;
  end if;
end proc:

F(t); # returns unevaluated for unassigned t

                                    F(t)

F(0.1); # returns a number. we won't "solve for F".

                                0.1103346721

eq2 := diff(x(t), t) = t + x(t) - 1 +  sin(x(t))
       + cos(t) + G(t, x(t), v(t)) + F(t):

indets(eq2,{name,'typefunc(name,Non(last_name_eval))'});

                               {t, v(t), x(t)}

indets(eq2,'typefunc(name,Non(last_name_eval))');

                                {v(t), x(t)}

indets(eq2, {name, function(name)});

                        {t, F(t), cos(t), v(t), x(t)}

indets(eq2,function(name));

                         {F(t), cos(t), v(t), x(t)}

procedures (of which operators are a subset) are of type last_name_eval.

Try it with eval(f) instead of just f, in the line where you augment nonIdMaps.

Otherwise, as seen, you're just building up a list of repeats of the name `f`  (and by the time you get around to mapping f->f(y) over the list you've finished the loop, and all the f's evaluate to its last iterated value).

ps. `select` is a better choice for this task than is looping and augmenting a list, IMO. Say,

select(f->f(__y)<>__y,
       [x->x, x->2*x, x->3*x]);

I notice that all the code posted so far does not protect against y being assigned. Perhaps your situation is in a context where y is local and you know it is unassigned. I use __y just in case. You could also make y local to the predicate operator/procedure.

You could try DocumentTools:-Tabulate. The caveat is that command only allows for one such plot (or collection/Table of plots) printed immediately after each paragraph or execution group.

P1:=plot(sin(x),x=-Pi..Pi,size=[300,300]):
DocumentTools:-Tabulate([P1],alignment=left,exterior=none,
                        width=300,widthmode=pixels):

P2:=plot(sin(x),x=-Pi..Pi,size=[500,500]):
DocumentTools:-Tabulate([P2],alignment=left,exterior=none,
                        width=500,widthmode=pixels):

You can also do the above all manually, by inserting GUI Tables, toggling off their borders, making them left aligned, and using DocumentTools:-SetProperty to put plots into them programatically.

You can also force the output of a regular printing of a plot to be left-aligned using the main menubar. But as far as I know that quality is not persistent and is undone by re-execution. The same goes for plots:-display(Array([....]) where you weight the right portion with an empty plot and then toggle all the qualities of the inserted Table (which also don't persist upon re-execution).

By default the caret is too narrow, and is rendered to the left (perhaps not only because of the italic slant).

Two other ways to accomodate this are:

1) Augment the base symbol with an invisible space, so that the caret gets stretched and shifted right. This pushes the subscript slightly to the right, but the overall effect is still better than the original caret misplacement, IMO.

2) Use double-underscore rather than square-bracket indexing for the subscripting. This also shifts and strectches the caret. But (see below) the effect may be too much when the subscript is itself wide.

nb. In My Maple 2017.1 for Linux the carets looks a little narrower and sharper than they do as rendered inline below (by this site). But the placement and width effects are essential similiar.

Download overcaret.mw

Add the option phi = 0 .. infinity to your fsolve call, to avoid negative values for this example.

You can also use Student:-Calculus1:-Roots to get multiple roots within a finite range. Results may vary according to your Maple version, though. The first attachment below was run in Maple 2017.0, and you are using what, Maple 13.00 still?

ANALYTIC_1.mw

Here's an attachment that was run in Maple 13.00.

ANALYTIC_1_M13.00.mw

nb. Your original worksheet returned calls to Analytic, unevaluated, because you didn't first load the RootFinding package. You also failed to supply it with a (thin, complex) range for phi. [edited] See below for more, including another attachment by me.

Q2: For this example, you can obtain the desired simplification with just,

  simplify(ap2, size)

or,

  numer(ap2)/denom(ap2);

or,

  frontend(simplify, [ap2]);

Q3: note the t1(T) in the lhs of ap3 (as opposed to just your original t1 ).

ap3 := Diff(t1(T), T) = (m-T)/(m-t1(T));

ap4 := Diff(lhs(ap3), T) = subs(value(ap3), diff(rhs(ap3), T));

Q5: I don't understand why you thing that the originally supplied ap6 and ap7 are always equal.

Try the command `timelimit` which can wrap around another procedure call.

The `timelimit` command is intended for exactly the kind of situation you describe.

You can use the try...catch mechanism to control this flow.

When `timelimit` times out it emits an error, and your code can catch that, and proceed.

The command LinearAlgebra:-GenerateMatrix should be able to do that.

It's awkward to do, and not general, but... you can alter the Typesetting so that the exponent is smaller.

Making this more precise, say to affect only powers within sqrts, would be more involved.

Using labelfont=[...,bold,N] might make the two sizes appear more similar in weight.

cust_label.mw