How about this?

degrees:= m-> map(x-> x=degree(m,x), indets(m)):
degrees(x*y^2);

Here's an object-oriented implementation of circular lists that allows for all of the multitude of types of indexing that ordinary lists allow (including unevaluated indices) and has as transparent an interface as I could manage. That is, I tried to make everything look like ordinary lists.

Download CircularLists.mw

Replace solve with eliminate. (The arguments can stay the same.) Remove the assign command. The solution returned by eliminate comes in two parts, each a set. The first set is the solutions for variables that you specified in the second argument. Inspect it very carefully. Is the form what you expected? Make sure that you spelled the variable names the same in all use instances. Maple is case sensitive. I'm somewhat skeptical that you spelled them all correctly because the solution looks weird to me. The second set returned by eliminate is a set of expressions which must be equal to 0 in order for the first set to actually be a solution.

It is only slow if you try to display the results in the Standard GUI. There is no reason to display 17550 3x3 listlists. Just end your statement with a colon rather than a semicolon (to suppress display) and the allstructs will run in 0.1 seconds.

There are very small discontinuities in the piecewise function due to roundoff errors during its creation. The solution is to create the piecewise function at a higher Digits setting than is used during the fsolve. For example, setting Digits:= 20 before defining the function and then changing to Digits:= 15 before doing the fsolve works.

What have you tried?? The obvious thing to try is factor, which will tell you immediately that the polynomial can't be factored.

Several other points:

• The polynomial isn't huge by Maple standards.
• I don't think that you know what it means to know something a priori. It means to know something because it has been proven in the mathematical (or pure logic) sense of proof. That seems to be precisely what you don't have in this case. To know something by experience or by observation is to know it a posteriori.
• There's no need to attempt a partial factorization in this case. The command factor will tell you in a blink of an eye that the polynomial can't be factored at all.
• Please post your expressions with explicit multiplication signs--- * ---so that they can be copy-and-pasted directly into Maple.

In Maple 18, if you omit the boundary conditions (Venkat's suggestion) and cancel the extraneous exponential factor in the first ODE, then dsolve will return a solution. In the worksheet below, the single line of 1-D input is my addition to cancel the factor. 

Note that dsolve's solution is explicit although at first glance it may seem implicit.

Download Parallel_flow.mw

It's all about the order of evaluation. One way around the problem is to exploit the "special evaluation rules" of seq by simply replacing eval with seq:

seq(g(x), n= 3);

You could just as well use add or mul. These will work in Maple versions older than eval[recurse].

member(4, A);

Suppose that your list of equations is copied from Matlab as a single string, which I'll call MS (Matlab String), like this

MS:= "C_p_e = C_state/C_c;
C_p_f = I_state/I_i;
R_p_e = R_r*C_p_f;
I_p_e = (Se_p_e-R_p_e)-C_p_e;";

The presence of newline characters in the string is insigificant---Maple ignores them. The semicolons, however, are necessary. Then do

eq:= parse~(StringTools:-Split(MS, ";"));

Now eq is a list of all the equations, so eq[1] is C_p_e = C_state/C_c, etc. You just need to use subs once, on all of eq. It's more efficient than calling allsubs repeatedly.

eq_a:= subs(
     C_p_e=fs(t), C_p_f=v(t), R_p_e=fd(t), I_p_e=fm(t), C_c=1/k, I_i=m, 
     R_r=c, Se_p_e=fe(t), I_state=int(fm(t),t), C_state=int(v(t),t),
     eq
);

The solutions are not necessarily real in your example. If the solutions were necessarily real, you could use syntax almost identical to the Mathematica:

a:= INTERVAL(2..4):
b:= INTERVAL(10..11):
c:= INTERVAL(1..3):
evalr~([solve(a*x^2+b*x+c)]);

If you want to do complex range arithmetic with your original example, you could do this:

a:= INTERVAL(2,0,4,0):
b:= INTERVAL(1,0,3,0):
c:= INTERVAL(1,0,3,0):
evalrC~([solve(a*x^2+b*x+c)]);

However, the results are not perfect, because they are in floating point. Note how a complex interval is specified with four numbers. See ?evalrC and ?evalr.

simplify(x1=a-y1-d*y2, {a-y2-d*y1= x2, 1-d^2= b, a-a*d= c});

Note that the three substitution equations must be written with the expressions on the left and the single variables on the right.

Don't use map when applying expand or simplify to a single expression. Use map to distribute these operations over a Matrix, but not on an single entry extracted from a Matrix.

There are also "tutors" for this in the Student package, but I think that it's instructive to see the components of a plot command.

Download RatFuncPlot.mw

In the future, you should show what you tried. Here's how to plot it.

f:= x-> 2*cos(x)-x^2:  a:= 2:  r:= 3:
plot([f(x), D(f)(a)*(x-a)+f(a)], x= a-r..a+r, color= [red,blue], linestyle= [solid,dot]);

I hope that you can generalize it from there.