Here's one way. I tried to focus on making it easier to understand, instead of using fancy terse syntax or making it super efficient.

Download minhthien_s1.mw

[edit] This is also not efficient. But, since you asked, it uses the prime notation for differentiation in 2D Input, and applies at argument 2 (instead of evaluating at point x=2).
minhthien_s2.mw

I did not look for any pattern in the entries of mylist (as a possible shortcut to the solutions, say). I don't know whether you have any rules for forming those entries.

Here's one way to get a more accurate plot. See attachment.

This is an interesting plot. (Is it meaningful, in terms of the as-yet unstated background theory here?)

Reza_Tchno_v3_ac.mw

Have you investigated the system symbolically, possibly using exact rationals? That might possible be able to demonstrate the feasible bounds for alpha, or piecewise explicit formulae, etc.

Do you know whether there is only ever a single solution that satisfies all the constraints?

Do you know for sure that it wouldn't be possible to churn out a relatively simple piecewise solution (in terms of alpha, say), that might be super fast to compute/plot?

Are you interested in finding the critical alpha values?

Have you considered trying to use purely floating-point optimization (eg. alpha->1 as constant objective, and the rest as mixed equality/inequating constraints, thus leveraging Optimization:-Minimize to compute/find a feasible point), for better speed?

Here's one way to handle your given polynomial example.

Download sgn_ex.mw

ps. You gave the target form as x^3 - (m-1) x^2 - (4m + 3) which isn't equivalent to your input expression. And so I have guessed as to what you wanted to accomplish with the coefficients.

Download Applying_identities_from_FunctionAdivisor_ac.mw

Download auto_simp_ex.mw

note: A little bit more on automatic simplification can be had in Section 3.4 "Unevaluated Expressions" of Chapter 3 of the Programming Guide, in the subsection "Evaluation and Automatic Simplification".

This question pops up now and then. This old Reply contains a couple of other approaches, including using MakeInert instead of %*.

Another alternative is to wrap one of the factors in a call to ``(...). For example,
   content(expr) %* ``(primpart(expr))
as shown also in that very same linked old Reply of mine. I don't generally prefer that approach over using InertForm. I also dislike how its results can sometimes get display with extra brackets in output, even though that doesn't occur for this particular example. I generally prefer how InertForm works, over the ``(...) approach.

With so many floating-point evaluations of those special functions the internal memory management system (gc) may collect some of the computed results from evalf's remember table.

But your expressions have two pairs of repeated special-function calls, ie. to WeierstrassZeta and to WeierstrassPPrime.

By forcing the computed values to be remembered (even when gc occurs) I get about another factor of two speed up here.

Download WZ.mw

An alternative way to speed it up would be to parallelize the population of the float[8] Array inside the resulting MESH plotting structure. [see below]

Here is the most that I am able to recover.

Basismat_2_noter_acc.mw

I suspect that it is missing just two inputs, which I'd guess are 2D Math Matrices that occurred here:
1) just after "Løsning er da:"
2) just before "Bytter række 2 og 3:"

I suggest that you try to use Maple 2023 instead of your current Maple 2022. This kind of worksheet corruption appears (so far) to be much less common in 2023.

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