The thing is that your T function above returns `T = ...`

as its value. In other words, it is a function call (to the function =) with 2 arguments.
You need to wrap a call to `rhs`

in your definition of T and L and all should work. ie
`T := (w, r) -> rhs(Maximize(Profit(T, L, w, r), assume = nonnegative)[2][1]);`

One minor point: for long-term maintainability of your code, I suggest you use Optimization:-Maximize rather than relying on having a 'with' being done first.

When you make a mistake in a post, please edit the previous one instead of simply creating a new one!
With R=10, r=2, n=11, I get a nice picture from
`plots[spacecurve]([R + r*cos(n*theta), theta, r*sin(n*theta)], theta=0..2*Pi, coords=cylindrical, numpoints=200,scaling=constrained);`

I will attempt to use your formulas above to show what I mean. First, I would define the main formula as
`a1f := -(PSX*sin(s1)*tr-RT_FR+mb*tr*vHn*v1)/(mb*tr^2+Ic);`

Then, if I have values for some of the parameters, I would go
`a1_1 := eval(a1f, {s1=...,tr=...,Ic=...}):`

and use a1_1 from now on.
If you then want to instantiate RT_FR, you can do
`a1_2 := eval(a1_1, RT_FR = RTFR(v1));`

In the first case, when a1 is created, RT_FR has a value, and so this value is used in a1. In the second case, when a1 is created, RT_FR has no value, so the **expression** for a1 contains a reference for RT_FR. Now, when the value of a1 is printed, the value of RT_FR is looked up and used.
In certain procedures that use non-standard evaluation rules, the difference between an expression and its value starts to be noticeable (and indeed confusing).
Personally I use assignment to define abbreviations (ie give names to formulas), and always use 2-argument eval to give values to parameters in formulas (when they are expressions). Counting on the side-effects of assignment to ``do the right thing'' fails just often enough to be irritating.
That and I am a bit of a purist: assignment is a CS thing, while formulas and evaluation are mathematical concepts.

Take a look at ?define. Also, depending on whether you want general non-commutativity or if you're in a semi-classical setting (like Weyl, Ore or Clifford) algebras, then there are specific packages that exist for those cases.

Maple likes to see "inside" a function, to know how many variables it depends on and much more. What are called functions in Maple (really a special case of procedures) is ``supposed'' to be a black box[1], and you are not supposed to look inside.
So, in Maple, most things work best with expressions, as those are completely transparent. Some things require functions, but those are easy to create (via `unapply`

).
If it happens that your students already know some logic, you can explain it to them as the difference between syntax and semantics: expressions are purely syntactic, while ``functions'' are (semi-)semantic. The various manipulations are correspondingly different.
[1] that functions in Maple are not pure black boxes is one of the features that Maple has borrowed from Lisp. This is both wonderful and annoying, all at the same time. It makes writing program manipulation code very easy, but also makes explaining Maple to beginners very tricky, at least if you do not want to lie and/or over-simplify things.

[I am not reply-ing to the above message, because things have gotten too squeezed onto the RHS of the screen].
You need to set the variable 'libname' to include that directory. Take a look at the help pages for `libname`

and `LibraryTools`

.

Axel's recommendation is a good one. I would also look in ToMS (Transactions on Mathematical Software), which publishes many numerical evaluation algorithms.
In this particular case, a combination of series expansions at z=0, z=1 and asymptotic expansions at z=infinity will probably work well. Maple should be able to derive all of these (from the differential equation).

From the title, it seems you are trying to combine Maple, Fortran and Elliptic integrals. This is a non-trivial endeavour (which Maple will not quite do automatically), but one which is well within reach. If you give us just a bit more details, I think we can help, and this can be done.

You used a raw < (or >) in your post, which causes it to be cut off (it is treated as html). You need to write < for < and > for >.

Using the context menus with the right options turned on, you should be able to create a Document (not a worksheet) that looks like that. Context menu usage implies that this is done by hand, by the user, and not automated.

You can use a raw < in a post, that is interpreted as HTML - use < instead.
Maple does not tend to say how it solves most problems (exception: the Student package). You can ask it to give you some information via `infolevel[all] := 1;`

(or more), but
1) be prepared to be flooded with information
2) be prepared to be puzzled by the results.
The way Maple solves a lot of problems uses far more advanced mathematics than is usually taught in undergraduate courses, even to solve simple problems. So the way Maple solves something may not enlighten you much, other than to tell you about some mathematics you might be interested in learning.

If you do it via the GUI in Standard, in Classic, or via a maple command, there are actually 3 completely different ways that this gets done (and so different results, with pros and cons to each).
[And yes, 3 different ways to get the same thing done is, shall we say, sub-optimal!]

Do it via a book page posting -- you'll leap right over the magic 80. And it will force you to think of something that makes you happy to have passed that threshold.

If you need to write NthWord yourself, then the answer to your question is

> convert("abc", list);
["a", "b", "c"]