If you want to avoid the use of a custom (user-defined) procedure (ie. to have it use only kernel builtins for efficiency) then you could use the shorter syntax,

map2(`.`,A,LM)

FWIW, the call,

[A,A] .~ LM;

is more like the following,

zip(`.`,[A,A],LM);

I note that `zip` does have a nicer error message when the container types do not agree. (In a sense your original attempt using .~ is a bit more like the next failing example below.)

zip(`.`,A,LM);
Error, (in zip) both arguments being zipped must be of the same type

zip(`*`,[1,2,3,4],A);
Error, (in zip) both arguments being zipped must be of the same type

If you are willing to allow all the computations to be done within a single procedure call (ie. you don't need to quit early if, say, some target value is attained) then you could construct such a procedure and utilize the codegen[optimize] command.

You can try it with and without the option `tryhard` to that command. It can sometimes produce better results, but with a longer runtime to produce it.

Naturally, you'd likely want to automate the steps which generate all the variable names (and the placeholders for the high and low values, etc). You may already ha a mechanism for that.

Download opt.mw

Here are a few ideas. (I used Maple 2016.)

wideoutput.mw

[edited] In at least Maple 2017.0 the first of the four methods in the attachment (interface labelling, etc) also requires interface(typesetting=standard) in order to work.

In a paragraph (Document Block) of a Document the left-hend-side of an assignment is not echoed. But it is echoed when done in an Execution Group (whether done in 2-D Math input mode or 1-D Maple Notation input mode).

The simplest way to get (all) Execution Groups for your inputs is to use the main menubar File->New->Worksheet Mode, rather than the normal new-user default File->New->Document Mode. (You can also set that preference for new sheets, under Tools->Options.)

But even in a Document you can still force open an Execution Group using the menubar item Insert->Execution Group.

As I mentioned, inside an Execution Group you have the choice of 2-D or 1-D input modes. The F5 key toggles between them.

In 2-D Math input mode (in the Standard GUI of recent Maple versions) that is available by command-completion on the name eval (or its inert variant Eval).

For example, on MS-Windows, in 2-D Math input mode, type as input the word eval and then hit the Esc (Escape) key. That should bring up a popup dialogue menu, the first item of which is the one you are after.

See also the Help Topic worksheet,expressions,completecommand

For your example the active variant with lowercase eval will compute eval(H1, t=0.45) which evaluates H1 at t=0.45.

The active variant eval and the inert variant Eval differ in how they look in this 2-D Math format: the active eval form has a black vertical bar and the inert Eval form has a gray vertical bar.

If you decrease the grid size by using, say, the option grid=[10,10] then there will be less hatching but also the surface with be less accurate.

So, instead, use the option style=patchnogrid or style=surface which will make maple utilize the same grid size but not show the hatching.

See the help page topic  plot3d,options 

@tsunamiBTP At least one of your attached worksheets seems to have been last saved with Maple 12.02. If that is the version you are using then you could use the zip command.

M := Matrix([[1,2],[3,5]]):

N := Matrix([[3,7],[-1,-2]]):

zip(`*`,M,N);

                                    [ 3     14]
                                    [         ]
                                    [-3    -10]

It bothers me (a little bit) when people use constructions like rhs(TOV[1]) and rhs(TOV[5]) for TOV the result from numeric dsolve with option output=listprocedure. It's awkward, because it forces the user to remember (or check) the order of the items in TOV.

In my opinion it is better to do it like,

  TOVv := eval(v(r),TOV):

than

  TOVv := rhs(TOV[5])):

It is better because it explicitly details that the procedure for v(r) is obtained.

As for your question, you could do it like so,

TOVv := eval(v(r),TOV);
offset := TOVv(608529.7)+.36555;
odeplot(TOV, [r, v(r) - offset ]);

# or even
plot(TOVv-offset, 0.0 .. 600000.0);

How about combining the trig terms, before solving?

restart:
 
eq1 := cos(lambda*ln(r1))*cos(lambda*ln(r2))
       + sin(lambda*ln(r1))*sin(lambda*ln(r2)) - 1 = 0:

combine(eq1);

                  cos(lambda ln(r1) - lambda ln(r2)) - 1 = 0

solve( combine(eq1), lambda, allsolutions );

                                2 Pi _Z1~
                             ---------------
                             ln(r1) - ln(r2)

You could also utilize those assumptions. For example, using them at the combining stage, before solving.

alt := combine(eq1) assuming r1>0, r2>r1;

                                              r1
                        alt := cos(lambda ln(----)) - 1 = 0
                                              r2

solve( alt, lambda, allsolutions );

                                     2 Pi _Z3~
                                     ---------
                                         r1
                                     ln(----)
                                         r2

Or you could use them afterwards, for this particular problem.

solve( combine(eq1), lambda, allsolutions ):

combine(%) assuming r1>0, r2>r1;

                                      2 Pi _Z5~
                                    - ---------
                                          r2
                                      ln(----)
                                          r1

And you could also do it this way,

solve( combine(eq1), lambda, allsolutions ) assuming r1>0, r2>r1;

You could also pick off the (introduced) parameter name programmatically.

Download pdex1_1.mw

Here is one way. I assigned Expression Label (3) to `targ`, and then "simplified" expression `FD` to that.
 

Download Help_ans.mw

This also seems ok:

  collect(radnormal(FD),x,normal@expand);

On some machines Maple's Standard GUI has trouble with the rendering of spacecurves unless the option linestyle=solid is supplied to the command that generates the plot.

If adding that option fixes the problem then could you add the details of your graphics chipset on the problem machine?

One way this can happen is if you are in 2D Input mode, trying to make multiple statements in a single paragraph, and forget the trailing semicolon (or colon) at the end of a line (not the last one).

For example,

Download illegal.mw

But that's just a guess. There are other ways to generate that error message. We cannot diagnose the particular problem unless you upload a worksheet that exhibits it.

Try the commands DocumentTools:-RemoveTask or DocumentTools:-RemovePaletteEntry .

You can use fdiff or evalf(D(...)) as a means to get numeric differentiation of the procedure returned by your pds:-value(T(x,y), x=0) call.

It is more efficient to call pds:-value(T(x,y), x=0) just once, before forming procedure Ty, than to have Ty form it for each input y0.

Here are some variants:

Download fyp3_1.mw