Assuming that h, aa, and bb are suitably defined functions of c, then you need to add undefined at the end of the piecewise. It becomes the "otherwise" clause, thus taking care of the regions that are not covered by your ranges. Then, include the discont option to plot. So,

BB:= piecewise(
     -1.57 < c and c < -1.56, h,
     -0.06< c and  c < -0.05, aa,
     -0.5< c and c < 0.04, bb,
    undefined
);
plot(BB, c= -2..2, discont);

Regarding your first question, see ?piecewise. But your inequalities are nonsense: they imply -2 < -3 and -1 < -2.

Regarding your second question, you'll need to show the code that gives that error.

Statistics:-Sample returns a Vector, even if you ask for a sample of size 1. So, you need to index for the element before you subtract it from 200.

X[1]:= Statistics:-Sample(Binomial(200, .5), 1)[1];
for i to 10 do  X[i+1]:= Statistics:-Sample(Binomial(200-X[i], .5), 1)[1]  end do;

AFAIK, Maple's for loop syntax is pretty much the same as most other languages. It's done like this:

list_A:= table():  list_B:= table():  list_C:= table():
more:= true:
for k while more do
     #Do computation that computes A, B, and C and sets the
     #boolean value `more`.
     list_A[k]:= A;  list_B[k]:= B;  list_C[k]:= C
end do:
list_A:= convert(list_A, list);
list_B:= convert(list_B, list);
list_C:= convert(list_C, list);

You'll get a much smoother ellipsoid if you use regular plot3d and parametric plotting, like this:

plot3d(
     [2*sin(t)*cos(u), 3*cos(t)*cos(u), 4*sin(u)], t= 0..2*Pi, u= -Pi/2..Pi/2,
     scaling= constrained
);

cos(2*t) is the same thing as 2*cos(t)^2 - 1.

You need more points. One thousand points is a very small amount for an implicitplot. Use numpoints= 10000 and also add gridrefine= 3.

The student[showtangent] command is old and deprecated. It's better to use Student:-Calculus1:-Tangent, which automatically shows the point of tangency and puts a good caption on the plot.

f:= x-> x^2-2*x:
a:= 1.5:
T:= Student:-Calculus1:-Tangent(
     f(x), x= a, -10..10, output= plot,
     pointoptions= [symbol= diamond, symbolsize= 24, color= red]
):
N:= plot(-1/D(f)(a)*(x-a)+f(a), x= -10..10, color= black, legend= ["the normal"]):
plots:-display(
     [subs(" and a tangent line."= " and a tangent line and a normal line.", T), N],
     view= [-10..10, -10..10], scaling= constrained
);

You can cut and paste to MaplePrimes plaintext (1D) Maple input and most 2D Maple output. It won't work for Matrices, Vectors, and plots. For plots, you can Export them using a right-click context menu. I always export to PNG (except for animations, for which I use GIF). Then upload them to MaplePrimes using the green uparrow tool, which is the last item on the second row of the toolbar in the MaplePrimes editor. You can also use this tool to upload entire worksheets.

First question: Click on the Edit menu, select Execute, then select either Selection or Worksheet.

Second question: Use the time() command. The most common way is to place

st:= time():

at the beginning of the block of code that you want to time. Also place

time()-st;

at the end of the block.

The two-argument form of map is called zip. So, for that command that doesn't work, change map to zip.

Here is an implementation of your algorithm for the univariate case. I show Examples 1, 3, and 4 from your paper. I don't understand Example 2; please explain it further.

If you like the below, I'll try to work on the multivariate case.

Download Biazar-Shafiof_Adomian.mw

Generate the animations of each curve separately, then merge the animations with plots:-display. Here is an example with basic animations:

A1:= plots:-animate(plot, [x, x= 0..T, color= blue], frames= 5, T= 1..5):
A2:= plots:-animate(plot, [-x, x= 0..T, color= green], frames= 5, T= 1..5):
plots:-display([A1,A2]);

If you still need help, please post the complete code for your pdsolve command.

Your original expression contains integral expressions of the form Int(f(N), 1). That's nonsense to Maple. The second argument, "1", means nothing. Unfortunately, the plot command's response to nonsense is often to return an empty plot rather than a meaningful error message.

I tried to keep it as much the same as the Matlab code as I could. But I can't abide by repetitious code or a needless lack of generality, so I made it a procedure. Note that I made the number of steps, n, the parameter rather than making the stepsize, h, the parameter.

EulersMethod:= proc(
     Yprime::algebraic, Yt::function, y0::numeric, R::range(numeric), n::posint
)
local
     h:= -`-`(op(R))/n, #Independent variable step
     a:= op(1,R),       #Initial value of independent variable
     T:= Vector(n+1, k-> a+(k-1)*h),
     Ystar:= Vector(n+1, [y0]), #Preallocate array (good coding practice)
     t:= op(Yt), #Independent variable
     i, k1
;
     for i from 1 to n do
          #Previous approx for y gives approx for derivative.
          k1:= eval(Yprime, [Yt= Ystar[i], t= T[i]]);
          #Approximate solution for next value of y
          Ystar[i+1]:= Ystar[i] + k1*h
     end do;
     plot(<T | Ystar>, args[6..])
end proc:
       
ode:= 0.0207*V(t)^2 - 893.58:
EulersMethod(ode, V(t), 0, 0..5, 50);
EulersMethod(ode, V(t), 0, 0..1, 100);

Well, two commands that will be useful for that are plots:-animate and sum. The first argument to animate is another plot command. In this case, that should be plot. The second argument is a list that contains the arguments to that plot command, except that there's an animation parameter somewhere. In this case, the animation parameter will be your N. The third argument specifies the range of the animation parameter. In this case, that'll be N= 1..10. The next argument, in this case, must be frames= 10 (because this can't be a continuous animation; only integer values of the parameter make sense).