To get exact solutions, simply use solve instead of fsolve.

To extract the exact positive solutions, do

Sol:= [solve(30+1144*r^4-832*r^2=0)];
select(x-> is(x>0), Sol);

Your solution does not fulfill the exercise because your integral is being done symbolically, not numerically. It's rather tricky to get Maple's numeric differential equation solver (dsolve(..., numeric)) to use a numeric integral. You have to encapsulate the integral in a procedure and then use dsolve's rather arcane protocol for specifying an IVP via a procedure. I wouldn't expect any beginning Maple user to figure it out. So, here's how to do it.

Download dsolve_int_proc.mw

There is hardly any difference in the graphs, so I fail to see the pedagogical value of this exercise.

Maple can almost do the integral symbolically: It can do it in exact numeric values if you change your constants to exact values. Once we do that, it is easy to see where the problem is: erf(10) is extremely close to 1; so close that it takes 45 Digits to discern any difference.

Download cata_cancel.mw

If f(x) = r*(8-2*x^2) = r*2*(2-x)*(2+x), then |(f@@n)(x)| -> infinity as n -> infinity, for r > 1 and 0 < x < 1. ((f@@n)(x) denotes the nth iterate of f, e.g., (f@@3)(x) = f(f(f(x))).)

The trick is to apply eval to count whenever its value (as opposed to its name) is required. Like this,

xcp:= proc(count)
local i;
     print("nargs=", nargs, "args=", args);
     count:= 0;
     for i from 2 to nargs do
          if isprime(args[i]) then
               count:= eval(count)+1
          end if;
          print("i=", i, "count=", eval(count))
     end do;
     print("count=", eval(count))
end proc ;

Please don't conclude from this exercise that the above is a good way to write Maple code. The purpose of the exercise is, IMO, to show you what one-argument eval is good for. I'd much rather read the original cp procedure.

One error is that you need with(combstruct) before your first call to iterstructs.

Download Leontief1.mw

Running your code in Maple 17, I get 7 solutions for [A,B], one real and six complex.

What result did you get?

The command that you want is select. See ?select .

Example:

Even:= n-> irem(n,2) = 0:
select(Even, [$1..10]);
                        [2, 4, 6, 8, 10]

Sol:= dsolve({diff(y(x),x)=y(x), y(0)=1}, numeric, output= listprocedure):
theta:= eval(y(x), Sol):
evalf(Int(ln@theta, 0..2));
                   1.999999704723899

The exact answer is 2. So the accuracy is limited to the accuracy of dsolve not the accuracy of numerical integration.

Is this what you had in mind for the second plot?

restart:
b:= 100:
plot([seq(BesselJ(0, BesselJZeros(0,n)*sqrt(z/b)), n= 1..4)], z= 0..100);

And for the animation, I had to assume some values for your constants.

restart:
A:= K[n]*cos(BesselJZeros(0,n)^2/4/b*sqrt(g)*t - sigma[n])*BesselJ(0, BesselJZeros(0,n)*sqrt(z/b)):
n:= 3: K[n]:= 1: b:= 100: g:= 1: sigma[3]:= Pi/3:
plots:-animate(plot, [A, z= 0..100], t= 0..20);

The closest thing to that that is possible is

(A,C,B,F):= convert(Q, list)[];

Note that the order is not (A,B,C,F).

Your list6 is too big to generate the permutations all at once, which is what combinat:-permute does. You need to use the iterator commands, which generate them one at a time. These are combinat:-firstperm, combinat:-nextperm, etc.

You must mean for the cumulative probability to be greater than 0.95, not the one-point probability. For the cumulative probability, you need the sum of the one-point probabilities from k = 0 to n.

restart:
lambda:= 2:
sum(exp(-lambda)*lambda^k/k!, k= 0..n):
fsolve(% = .95, n);
                        4.04766491450491

Since n must be integer, we take n = 5.

Download dchange.mw