Your problem can be easily solved without Maple by using an iteration method for solving equation  x=f(x)  (problem on fixed point of mapping  f ). Here  f:=x->(x+2)/(x+3) .  See  http://en.wikipedia.org/wiki/Fixed_point_(mathematics) 

All conditions for the convergence of your iterations  a_n = (a_(n-1) +2)/(a_(n-1) + 3),  a_1 =2   performed:

1) Function  f  maps a closed segment  [0, 2]  into itself.

2) On this segment  [0, 2]  mapping  f  is a contraction, since  |f'(x)|=1/(x+3)^2<=1/9

So your iteration converges to the unique root of the equation   x=(x+2)/(x+3)  on the segment  [0, 2], ie to the number  sqrt(3)-1 .

By default, the  Vector  command means a column vector. Even shorter, you can specify it if you use angle brackets instead Vector  command:

Nr:=5:

p:=2*<(5-i $ i=0..Nr)> + <(1 $ Nr+1)>;

Painting.mw

restart;

with(DEtools): with(plots): Nsols := 5; Ntstep := 10;

 k := 0; A := 0.37e-1; B := 0.2e-6;

ode0 := diff(U(t), t) = -(A+B*U(t))*U(t);

 ic[1] := U(365*k) = 1000;

sol[0] := dsolve({ode0, ic[1]}, U(t), range = 365*k .. 365*k+365, numeric);

p[0] := odeplot(sol[0], [[t, U(t)]], t = 365*k .. 365*k+365, colour = blue, legend='p[0]'):

display(p[0]);

ode1 := diff(U(t), t) = -(A+r(t)+B*U(t))*U(t);

R := RandomTools:-Generate(distribution(Normal(-0.2e-1, 0.4e-1)), makeproc = true);

r := proc (t) if not type(t, numeric) then return 'procname(args)' end if; R() end proc;

for i to Nsols do

sol[i] := dsolve({ode1, ic[1]}, numeric, known = r(t), method = classical[foreuler], stepsize = 0.1e-1):

p[i] := odeplot(sol[i], [[t, U(t)]], t = 365*k .. 365*k+365, colour = red)

 end do:

display(seq(p[i], i = 1 .. Nsols));

for j to Ntstep do

 for i to Nsols do

x[i] := proc (t) options operator, arrow; rhs(sol[i](t)[2]) end proc;

y[i] := x[i](j):

end do:

ymaxval[j] := max([seq(y[i], i = 1 .. Nsols)]):

end do:

S1:=[seq(ymaxval[j], j=1..Ntstep)];

for j to Ntstep do

 for i to Nsols do

x[i] := proc (t) options operator, arrow; rhs(sol[i](t)[2]) end proc;

y[i] := x[i](j):

end do:

yminval[j] := min([seq(y[i], i = 1 .. Nsols)]):

end do:

S2:=[seq(yminval[j], j=1..Ntstep)];

plotofmax:= plot([seq(j, j=1..Ntstep)], S1, color=red, legend="plotofmax"):

plotofmin:= plot([seq(j, j=1..Ntstep)], S2, color=black, legend="plotofmin"):

display(plotofmax, plotofmin, p[0], view=[1..Ntstep, min(S2, rhs(sol[0](10)[2]))..max(S1, rhs(sol[0](0)[2]))]);

Now all works:

restart;

with(DEtools): with(plots):

k := 0; A := 0.37e-1; B := 0.2e-6;

ode1 := diff(U(t), t) = -(A+r(t)+B*U(t))*U(t);

ic[1] := U(365*k) = 1000;

R := RandomTools:-Generate(distribution(Normal(-0.2e-1, 0.4e-1)), makeproc = true);

r := proc (t) if not type(t, numeric) then return 'procname(args)' end if; R() end proc;

for i to 5 do

sol[i] := dsolve({ode1, ic[1]}, numeric, known = r(t), method = classical[foreuler], stepsize = 0.1e-1):

p[i] := odeplot(sol[i], [[t, U(t)]], t = 365*k .. 365*k+365, colour = red) end do:

display(seq(p[i], i = 1 .. 5));

for i to 5 do x[i] := proc(t) options operator, arrow; rhs(sol[i](t)[2]) end proc:

y[i] := x[i](2) end do:

seq(y[i], i=1..5);

max(seq(y[i], i=1..5));

If you want a vector to be argument in your function, you can use the  unapply  command:

F:=unapply(6*x[1]^2 + 3*x[2]^2 - 1.5*x[3]^3, x::Vector):

Examples:

F(<1,2,3>);

H:=unapply(Student[VectorCalculus][Hessian](F(<X[1], X[2], X[3]>), [X[1], X[2], X[3]]), X::Vector):

H(<x,y,z>);

H(<1,2,3>);

To draw a phase curve, you must:

1) Set the value of the parameter  k .
2) Specify the initial condition.

If you interested of changing of the curve in response to changes  k , you can make animation with the parameter  k .

Example (for greater clarity, the ranges of  k  and  t  are reduced):

with(DEtools):
for k from 1 to 2 by 0.01 do
DE := diff(x(t), t) = x(t):
DF := diff(y(t), t) = k*y(t):
A[k]:=phaseportrait([DE, DF], [y, x], t = 0 .. 0.5, [[y(0)=1, x(0)=1]], color=black, linecolor = red):
od:
plots[display](seq(A[k], k=1..2, 0.01), insequence=true);

To construct the phase curves you need:

1) Increase the range for the variable t .

2) Set the initial conditions.

Example (plotting of two phase curves):

with(DEtools):
sys := diff(x(t), t) = y(t), diff(y(t), t) = x(t)*(1-x(t)*x(t))+y(t);
DEplot([sys], [x(t), y(t)], t = 0 .. 3, x = -3 .. 3, y = -3 .. 3, [[x(0)=1, y(0)=2], [x(0)=-2, y(0)=1]],color = black);

P:=combinat[powerset]({a, b, c, d, e}):

m:=0:  n:=0:  k:=0:

for i in P do

for j in P do

if nops(i union j)=5 and nops(i intersect j)=3 then m:=m+1: fi:

if nops(i union j)=5 and nops(i intersect j)=4 then n:=n+1: fi:

if nops(i union j)=5 and nops(i intersect j)=5 then k:=k+1: fi:

od: od:

binomial(30, 5)*(m+n*binomial(4, 3)+k*binomial(5, 3))*2^(30-3);

                                                     1721414839173120

Your code has 3 errors:

1) Instead posint should be positive.

2) The condition a+b>c is only necessary but not sufficient for a, b, c to be lengths of a triangle. Should be

a+b>c and a+c>b and b+c>a

3) Conditions of the type  a+b>c  should be given in the form  is(a+b>c)  

limit(exp(-a*x), x = infinity) assuming a>0;

                              0

x[n]:=e[n]+w;

f(w):=0;

fxn:=convert(series(f(x[n]), e[n]=0, 10), polynom);

subs(seq(((D@@i)(f))(w) = c[{i}], i = 2 .. 9), fxn);

To build a contourplot you need to specify the range for the second variable  y . It's better  to output  both  graphics separately.

with(plots):

F:= x^2+2*y^3+Q:

Q:=1:  contourplot( F, x=0..1, y=0..1,color=red);

Q:=2:  contourplot( F, x=0..10, y=0..10,color=blue);

Done in Maple 14 Classic Worksheet.

A:=plottools[curve]([[1,-1], [1,1], [-1,1], [-1,-1], [1,-1]], style=line, thickness=5):

B:=plottools[circle]([0,0], 1, thickness=5):

A1:=plottools[homothety](A, sqrt(2)/2):

A2:=plottools[homothety](A, 1/2):

A3:=plottools[homothety](A2, sqrt(2)/2):

B1:=plottools[homothety](B, sqrt(2)/2):

B2:=plottools[homothety](B1, sqrt(2)/2):

U:=plots[display](A, A1, A2, A3, B, B1, B2):

C:=plot([1,-1], x=-1..1, filled=true, color=yellow, numpoints=10000):

C1:=plot([cos(t), sin(t), t=0..2*Pi], filled=true, color=white):

E:=plot([1/sqrt(2),-1/sqrt(2)], x=-1/sqrt(2)..1/sqrt(2), filled=true, color="DarkOrange", numpoints=10000):

E1:=plot([cos(t)/sqrt(2), sin(t)/sqrt(2), t=0..2*Pi], filled=true, color=white):

F:=plot([1/2,-1/2], x=-1/2..1/2, filled=true, color="HotPink", numpoints=10000):

F1:=plot([cos(t)/2, sin(t)/2, t=0..2*Pi], filled=true, color=white):

X:=plots[display](F1, F, E1, E, C1, C):

G:=plot([cos(t), sin(t), t=-Pi/4..Pi/4], filled=true, color=gold):

G1:=plottools[rotate](G, Pi/2):

G2:=plottools[rotate](G, Pi):

G3:=plottools[rotate](G, 3*Pi/2):

H:=plot([cos(t)/sqrt(2), sin(t)/sqrt(2), t=-Pi/4..Pi/4], filled=true, color="IndianRed"):

H1:=plottools[rotate](H, Pi/2):

H2:=plottools[rotate](H, Pi):

H3:=plottools[rotate](H, 3*Pi/2):

K:=plot([cos(t)/2, sin(t)/2, t=-Pi/4..Pi/4], filled=true, color="Crimson"):

K1:=plottools[rotate](K, Pi/2):

K2:=plottools[rotate](K, Pi):

K3:=plottools[rotate](K, 3*Pi/2):

Y:=plots[display](G, G1, G2, G3, H, H1, H2, H3, K, K1, K2, K3):

V:=plottools[polygon]([[sqrt(2)/4,sqrt(2)/4], [-sqrt(2)/4,sqrt(2)/4], [-sqrt(2)/4,-sqrt(2)/4], [sqrt(2)/4,-sqrt(2)/4]], color="DarkMagenta"):

plots[display](V, Y, X, U, axes=none);

The answer to the question b) is quite simple (the area of the yellow square is 8 ), as each next smaller square has an area of ​​two times less than the previous one.

To answer to the question a) it takes a bit of work.