A mathematical, rather than programmatical, approach is the simpler

SplitPolynomialEvenOdd := proc(poly::polynom(anything,v), v)
description "return the even and odd parts of a polynomial in v";
local p,m;
    p := collect(poly,v);
    m := subs(v=-v,p);
    return ((p+m)/2, (p-m)/2);
end proc:

Here's one approach.

assume(p::positive,l::positive,a::positive,q::positive);
eqn :=-p*(l^2-a^2)^(3/2)+a^3*q;
                                   2     2 (3/2)     3
                     eqn := -p~ (l~  - a~ )      + a~  q~

eqn2 := isolate(eqn,a^3);
                                            2     2 3/2
                                  3   p~ (l~  - a~ )
                        eqn2 := a~  = -----------------
                                             q~

map(x -> x^(2/3), %);
                                  /      2     2 3/2\(2/3)
                        3 (2/3)   |p~ (l~  - a~ )   |
                     (a~ )      = |-----------------|
                                  \       q~        /

combine(%,power);
                              /      2     2 3/2\(2/3)
                          2   |p~ (l~  - a~ )   |
                        a~  = |-----------------|
                              \       q~        /

# At this point it is tricky to get Maple to distribute
# the power.  Easier just to do it by hand:
eqn3 := a^2 = (p/q)^(2/3)*(l^2-a^2);
                               2   / p~ \(2/3)    2     2
                     eqn3 := a~  = |----|      (l~  - a~ )
                                   \ q~ /

sol := solve(eqn3,a):
sol[1];
                     //    / p~ \(2/3)\ / p~ \(2/3)\1/2
                     ||1 + |----|     | |----|     |    l~
                     \\    \ q~ /     / \ q~ /     /
                     -------------------------------------
                                    / p~ \(2/3)
                                1 + |----|
                                    \ q~ /

Again, distribute the power by hand. Is there a command that does that? It's easy to write one, though it won't be rigorous. You could try using the RealDomain package; that nearly solved the problem in one go but I couldn't figure out a clever way to factor out the common terms in the numerator and denominator.

You write "maxima", meaning more than one maximum. What do expect to get for the given expression, assuming the chosen component is one? That is, do you want to get the indices 1 and 2, corresponding to the two components whose first element is 8? If that is what you want, then the following will return the list of indices: maxima_indices := proc(indx::posint, lst::list) local elem,i,val; val := max(seq(op(indx,elem),elem in lst)); return [seq](`if`(op([i,indx],lst)=val,i,NULL) ,i = 1..nops(lst)) end proc: H1 := [[8,9,11],[8,10,11],[5,10,6]]: map(maxima_indices,[1,2,3],H1); [[1, 2], [2, 3], [1, 2]]

I'm unsure as to the precise mechanism, however, this is probably caused by the assuming keyword making a substitution into the table (a local variable z~ with assumptions replacing z), the result evaluated, then the original z replacing the z~. At the conclusion of this we are left with a different table, identical to the original. It has no name and must be displayed as a table. I don't know what your second question means.

I'm not sure what you want. Currently, the only way for users to generate help pages is by writing them in the Maple gui (templates are available), saving them as worksheets, then using Maple commands (makehelp and INTERFACE_HELP) to save the worksheets as help pages in a help database. This is acceptable for a small package with a few help pages but is cumbersome for larger packages with many help pages. I wrote a small package, generichelp, that can be used to strip the user style table from a user created help-page/worksheet. The reason for doing this is that it ensures that the created help pages behave like the ones supplied by Maplesoft; that is, they do not contain character and paragraph styles that are specific to the creator. The original version is available at my home page. I've recently revised it to be compatible with Maple 10 but need to finish it. About a year ago I began work on a package for generating Maple help pages from text files using a custom markup language. Alas, it is not ready for release and I haven't been motivated to work on it for awhile.

1. Not sure. 2. Tools > Options > Display > Input Notation = Maple Notation 3. To change colors you want to create a custom default style, modifying, in particular, the character styles "Maple Input" and "2D output" (there are other output styles that you will probably want to modify as well). I described the basics here.

Assuming that the constraint expression, g, is supposed to be equal to zero, f := 1000*x+7500*y: g := 10000000-(20000*x^0.8)*y^1.2: Student:-MultivariateCalculus:-LagrangeMultipliers(f,[g],[x,y]); [58.73094715, 11.74618943], [-58.73094715-.3095363126e-18*I, -11.74618943-.6190726252e-19*I] You can use fnormal and simplify/zero to remove the vestigial complex part.

I cannot reproduce that,

restart;
a := 4;
anames(user)[1];
                    a

What do you want to do with the list? You can always convert the names to strings:

map(convert,[anames](user),string);

I'm not sure that you have completely described the problem. Your procedure does not declare k as local, so if A, B, or C are in terms of the global k, they will be summed accordingly:

> sums([k,k^2,k^3],[[ku1,kl1],[ku2,kl2],[ku3,kl3]]);
         2                  2                  3            2            3
(ku1 + 1)    ku1         kl1    kl1   (ku2 + 1)    (ku2 + 1)    ku2   kl2
---------- - --- - 1/3 - ---- + --- + ---------- - ---------- + --- - ----
    2         2           2      2        3            2         6     3

          2                  4            3            2      4      3      2
       kl2    kl2   (ku3 + 1)    (ku3 + 1)    (ku3 + 1)    kl3    kl3    kl3
     + ---- - --- + ---------- - ---------- + ---------- - ---- + ---- - ----
        2      6        4            2            4         4      2      4

Is that what you want? If not, that is, if you meant k to be local, then just do

adds := proc(a,b)
local j;
    add(a[j]*(b[j,1]-b[j,2]+1),j=1..nops(a));
end proc:

Use a print statement in the loop to print intermediate results. You might also want to consider terminating the for loop with a colon so that the final result is not displayed twice. Using your example, for i from 0 to 10 do print(f(i) mod 11); end do:

p := (n+2 -k)*(n+1-k): sort(collect(p,k),k,ascending); 2 (n + 2) (n + 1) + (-2 n - 3) k + k The k^0 term is not shown.

I'm not sure what you want. Something like the following, where x is the variable name and 1,2,3, and 4 are sample indices (this doesn't render very well in html: ¹₂x³₄. I don't believe that is any good way to do this in Maple, particularly the indices at the 1 and 2 slots. You can fake the index at the 3 slot using a power, however, that invariably causes problems. I believe we are stuck with subscripted indices only.

One approach is to use fsolve. Its default is to restrict the solution to the real axis.

fsolve(subs(U(t)=x,e1), x);
                                  2.018196123

That is a good question. The call to sum returns 0 because it is summing 0. That is, the call to G is evaluated before it is passed to sum. With symbolic arguments i and j G returns 0. There are two ways to avoid that: (1) modify G so that it returns unevaluated unless its arguments are numeric; and (2) modify the usage of G so that it doesn't get fully evaluated until being passed to sum. Let's tackle these in order. Modify G Modifying G is the more useful technique. Change it so that it returns an unevaluated call to itself when it arguments are not numeric.

G := proc(i,j)
  if not [args]::list(numeric) then return 'G'(i,j) fi;
  if [i,j]::list(even) then return 1 else return 0 end if;
end proc:
sum( sum( G(i,j), i=0..5 ), j=0..5 );
                                       9

Modify the call to sum The usual way to do this is to enclose the argument in forward quotes. At the user level you will need two pairs of forward quotes:

G := (i,j) -> if is(i,even) and is(j,even) then 1; else 0; end if;
sum( sum( ''G''(i,j), i=0..5 ), j=0..5 );
                                      9

You might be wondering why sum isn't designed to work like add, which avoids these problems. Add is able to avoid them because it uses special evaluation rules. Doing the equivalent with sum would not be useful, the reason being that sum is intended to evaluate summations and must be able to operate on expression generated outside the sum function. The summation index is not local to the sum. To see the problem do

proc()
local y,i;
  y := i^2;
  return [add,sum](y, i = 1..3);
end proc();
                                      2
                                  [3 i , 14]

The sum returns the intended value, the add does not. Joe

There are opportunities to embed information within an mws file, however, as Alec mentions, it is not clear that this buys you much. For example, one possibility is to create an unnamed and unused paragraph/character style and give it unique identifier. Working on the file won't delete this style, so it should show up in the returned worksheet. Of course, the clever student (who is undoubtedly reading MaplePrimes) will know of your ploy and be able to circumvent it.