You can supply an option to the call to the plot command, for specifying the relative location of the first axis.

And you can change the size option below, to get dimensions more to your liking.

Download time-dependent_aerodynamic_pressure_ac.mw

See the Help page for topic  plot,options  for more details on 2D plotting choices.

The following reuable procedure P produces an expression (which is intended as pretty-printing in Maple's GUI similarly as does the the unevaluated ContinuedFraction function call).

Are you able to utilize the following expression assigned to res (either by copying its pretty-printed 2D output as special, rich-text, etc, or as generated MathML?)

Download ContFrac_MathML.mw

Your worksheet has some coding mistakes.

1) The definition of prof1 has some function calls where multiplcation was likely intended. Eg,
   (...)(ps - s)
is is a function call, and not a product of two brackets terms. For multiplication you'd need either an explicit multiplication symbol, or (in 2D Input) a space, between the adjacent closing&opening brackets )( .  This occurs a few times.

2) The attempted multiple assignments like,
   [p,q] := solve(...)
is invalid. This occurs a few times.

It's often useful to test your procedure with some actual float arguments, before trying to plot it. That would reveal to you that WhyNot3 wasn't working at all.

I've corrected those aspects, in this attachment.  HmaxProc_ac.mw

Here's another approach.

If you'd prefer the result as just a list of two numbers then you could leave off the [a,b]=~ bit at the start.

L := [a,b]=~applyrule(a::numeric*f^b::numeric=[a,-b],X1);

          L := [a = 1.234, b = 6.789]

A couple of other examples,

[a,b]=~applyrule(a::numeric*f^b::numeric=[a,-b],-1/(f^6.789));
                      [a = -1, b = 6.789]

[a,b]=~applyrule(a::numeric*f^b::numeric=[a,-b],f^6.789);
                      [a = 1, b = -6.789]

Here's your original example, round-tripped,

Download rt.mw

ps. The order of terms in the result is forced by us, here, since the order of terms in the returned list is specified in the code.

pps. You could also tweak the specified types, eg. only looking for negative b, etc. You could also wrap it up in a reusable procedure. You could also use indets (and a structured type) to yank out multiple such subexpressions from a larger expression. Hard to say more because we don't yet know exactly how you intend to utilize this.

@Samuel Hesselberg Any new document will have its own Startup code region (which is empty, at first). The Startup code is not automatically inherited from any other already opened sheet.

Your original .mw file is a document with its own, separate Startup code.

So if you copy&paste the main body of that older document then you'll also have to provide access to the code in the older document's Startup region as well. The embedded components you're pasting in rely upon and call that code.

You can add it to the Startup code region of your newly opened document, or you can add in somewhere else in your new document's body (any document block, or even a code-edit-region).

First, find the Startup code in your original. Then figure out how you want your new document to be able to also use it. The easiest way is also to copy the older document's Startup code to the new document's Startup code region.

I am not sure about a good approach for Maple 2015.

In Maple 2018 and later you could use plots:-textplot with its rotation option.

An example is given below.

Note that I did not have the lines extend down to y=0, since your image didn't either. I also didn't make it handle the lines if f(x) becomes negative. I figure that if you want such a more general example or different behaviour you would provide it -- and all your requirements -- explicitly and clearly.

Download rotated_textplot_ex2.mw

Are you asking about codegen:-optimize? You haven't usefully provided an example of what exactly you're trying to accomplish.

If it's replacing generated names in results from codegen:-optimize then it's not clear to me whether you're dealing with Maple expressions of procedures. Also, while codegen:-optimize does have a documented mechanism to utilize a given list of preferred names, it's somewhat awkward IMO.

Perhaps something like the following might serve:

Download cg_rep.mw

You have p(lambda__1 + p) which is a function call (to p), and not a multiplication. Perhaps you intended that as p*(lambda__1 + p) instead.

Download nima_ac.mw

To prevent  -2*x-3*x from automatically simplifying to -5*x, etc, you can use an inert form.

Here, the inert form only needs to retain inert `%+`.

You can also force the visual display to have + in the usual black, instead of the gray that denotes the inert operator.

Download inert_ex2.mw

If you add
   option remember;
to FirmModelFC and FirmModelPP then it won't waste as much time in duplicate computations, generating both the 3rd and 4th items of their returned expression sequences.

Also, you can guard against premature evaluation by having diffr1 and diffr2 return unevaluated when passed mere symbolic names (not yet numbers) as its arguments. That allows you to use the expression form calling sequence of plots:-inequal, as opposed to operator form calling sequence.

I removed the commented stuff, just to make it more legible to me.

I changed the range for delta to 0..1/2, since I myself didn't see too much of great interest for delta>1/2. Change that back if wanted, of course.

Download Code_JN_major_ac.mw

I didn't bother rewriting FirmModelPP and FirmModelAC altogether (eg. making evalhf'able counterparts, resolving the integration steps, etc). I suspect it could be faster still...

You appear to have used Maple 2021, and in that version the above all executed in about 9 seconds on my machine.

Do you mean something like the following?

I also added some sorting of the terms in the generated results, which I think makes the effect clearer.

note: Your given example might be handled by dealing merely with the second index j of the y[i,j] names. And the highest index accepted happens to match your example N values. But I deliberately put in the test of the first index, as well as sorting by the second index, so that it'd also handle a more general example (as you described it in words).

Download sorty_thing.mw

Your given example could also be handled by the following simpler approach. But I think that the sorted effect is nicer. And if this is run in a separate session from the above code then the addends are not necessarily sorted so nicely (IMO), in each result.

Download sorty_thing2.mw

You could get it with calls to GAMMA instead of WhittakerM.

Download Wh_ex.mw

You could further collect on, say, exp, GAMMA, beta, etc. But mostly that just rearranges those terms. You haven't said what exactly you mean by less "complicated".

You can use the so-called 2-argument calling sequence of the eval command, to evaluate the expression at specific values for names upon which it depends.

If you are already have the lists of values then you can do it all programmatically, instead of typing out all those individual equations. That'd let you do it more easily if you have further collections of values to use.

Download eval_ex_1.mw

note. You could also construct a reusable procedure to do the substitutions, by using unapply on the expression (w.r.t. all those names). That doesn't really seem better to me, especially if you're only going to use it once.

Download eval_ex_2.mw

Hopefully I haven't misunderstood all your goals.

I did the first attempt (with a finer resolution of points) in two ways: one like your original, and one more efficient that stops (for each X value) when it finds the first W value that succeeds.

At the end I also threw in some stuff with going straight for a curve (finding the first W value of equality, for the given range). And also a bit with some extended ranges. Might be useful; I'm not sure. I don't know what the end-point -1.7 might mean to you, as a restriction...

Download NumericScale_ac.mw

By "Gauss-Jordan form" do you mean reduced row echelon form, as produced by Gauss-Jordan elimination?

If so, then consider computing the r.r.e.f. of the Matrix augmented by the identity-matrix. The row operations that take the Matrix to its r.r.e.f. would then also be done to the identity matrix.

Below, if B the r.r.e.f. of M turns out to be the identity-matrix, then A (the result of the same row operations, but done to the identity matrix) is the inverse of M.

See also the subsection "Finding the inverse of a matrix" of this page on Gaussian elimination.

Download some_la.mw