If f and g are lists, then you may do, simply,

plot([f,g], style= point);

For f and g any indexed structures (list, array, table, sequence), you can do

plot([[seq(f[k], k= 1..10)], [seq(g[k], k= 1..10)]], style= point);

You may add nondefault colors, point shapes, and point sizes by using the options color, symbol, and symbolsize, respectively. For example,

plot([f,g], style= point, color= [green, red], symbol= [cross, diamond], symbolsize= 24);

Every occurence of c() in your code is a separate invocation (or call) of the random-number-generating procedure created by rand(0..1). If you need a stable value, then assign it to a variable (such as your d) and just use that variable.

It's impossible. Applying factor to the polynomial proves that it has no rational roots.

Try this. I've made several simplifications to your code.

restart:
X:= Vector([1, 2, 3, 4, 5, 6], datatype= float[8]):
Y:= Vector([2, 3, 4, 3.5, 5.8, 7], datatype= float[8]):

SLRrepeatedsample:= proc(X,Y,N,CI)
uses ArrayTools, Statistics, RandomTools;
local x, y, n, ymu, ySE, yvar, x2, b, bCI, i;
     n:= Size(X,1);
     b:= LinearFit([1,t], X, Y, t, output= parametervalues);
     ySE:= LinearFit([1,t], X, Y, t, output= residualstandarddeviation);
     x2:= X^~2;
     for i from 1 by 1 to N do
          x:= Generate(float(range= min(X)..max(X)));
          ymu:= b[1]+b[2]*x;
          ySE:= (1+1/n+sqrt(((x-Mean(X))^2)/(add(x2[j],j=1..n)-n*(Mean(X))^2)));
          yvar:= RandomVariable(Normal(ymu, ySE));
          y:= Sample(yvar, 1)[1];
          X(n+1):= x;
          x2:= X^~2;
          Y(n+1):= y;
          b:= LinearFit([1,t], X, Y, t, output= parametervalues);
          ySE:= LinearFit([1,t], X, Y, t, output= residualstandarddeviation);
          n:= Size(X, 1);
     od;
     bCI:= LinearFit([1, t], X, Y, t, confidencelevel= CI, output= confidenceintervals);
     return b, bCI;
end proc:

SLRrepeatedsample(X, Y, 2, .95);

For large A, it's much faster to compute the orbit without computing the powers of A. Also, this solution avoids the list-building-by-appending technique, which takes time O(n^2) where n is the list length.

Orbit:= proc(A::Matrix, V::Vector, n::nonnegint)
# returns [seq(A^k.V, k= 0..n)] without explicitly computing powers of A
local O:= Array(0..n, [V]), k;
     for k to n do O[k]:= A.O[k-1] end do;
     convert(O, list)
end proc:

If you want to apply it to a list of Vectors, use map2. I don't see any significant reason why returning a list of lists is better than returning a list of Vectors; plots:-pointplot will accept both.

Here's one way to do it. While building each A[k+1], I limit lookup access to A[k] to a procedure that traps index-out-of-bounds errors, which are diverted to value 0.

restart:
a:= 1:  b:= -1: #For example
N:= 100:
A:= Array(1..N):
AA:= proc(k,i,j) try A[k][i,j] catch: 0 end try end proc:
A[1]:= < < -1, 1 > | < 0, 1 > >:
for k to N-1 do
     A[k+1]:= Matrix(
          k+2, k+2,
          (i,j)-> a*(k+1)*AA(k,i,j) + b*((1+j)*AA(k,i-1,j) - j*AA(k, i-1, j-1))
     )
end do:    

You are making a mistake with your for-loop syntax. You have

for i= 1..r do ... end do;

but that should be

for i from 1 to r do ... end do;

You're not ruining my vacation. I love nothing more than showing people how to use my LogicProblem package, and I only worked on these at night when there wasn't anything local to do. Besides, I did most of this one while waiting for my flight in the San Jose, Costa Rica airport.

You made two mistakes in coding this problem (the "Meet the Challenge" or "Book Swap" problem). The first is that you need to make the surnames a separate variable. The second is that all of the constants' names need to be unique. So, even though the books brought are the same as the books borrowed, I make the names distinct by prepending br_ or bo_.

After defining the variables and constants thus, all of the constraints except #20 are straightforward equalities. #20 needs to be specified in a procedural form accepted by the package. I too tired right now to explain in detail how these procedures work, but I urge you to read my comments to the code of the package, especially the long comment preceding procedure `Know/Proc`.

Please make a separate thread for each new logic problem.

Download BookSwap_LP.mw

If you try to pass a sequence to convert it mistakes that as mulitple arguments, which it doesn't know how to handle. It is easier to work with lists than sequences.

a:= [seq(taylor(cos(x),x=0,i),i=[2,4,6])]:
convert(a, polynom);

The soccer problem is very easy with my LogicProblem package because all of the constraints translate directly to equalities and inequalities.  Your file did not attach, so I can't see what you did wrong.

Download Soccer_LP.mw

I can't reproduce your problem, so I am not sure this will fix it. In procedure `*`, you should refer to global `*` as :-`*`. You should also make i local.

m:= module() option package; export `*`;
    `*`:= proc( a::list, b::list) option overload;
     local i;
        return add(i, i  in zip(:-`*`, a, b));
    end proc;    
end module;

Let me know if that helps. And if you can get a reproducible example of the problem, please post it.

Your data are too large. Try scaling down by a factor of 1000.

F1 := Vector([1500, 1750, 2250, 4000, 4300, 5000, 7000]):
Statistics:-MaximumLikelihoodEstimate(Weibull(beta, eta), F1 /~ 1000);

Weibull has a linear scaling property for the first parameter, so the answer using your original data is

applyop(x-> 1000*x, [1,2], %);

I used solve to solve the resulting n^2 x n^2 system of linear equations. There may be a more-efficient method.

restart:

The procedure:
Solve:= proc(A::Matrix(square), B::Matrix(square), C::Matrix(square))
# Solves matrix equation A.X + X.B = C for X.
local
     i, j, x,
     X:= Matrix(rtable_dims(A), symbol= x),
     xs:= {seq(seq(x[i,j], j= rtable_dims(X)[2]), i= rtable_dims(X)[1])}
;
     if [rtable_dims(A)] <> [rtable_dims(B)] or [rtable_dims(B)] <> [rtable_dims(C)] then
          error "Incompatible matrix dimensions"
     end if;
     eval(X, solve(convert(A.X+X.B =~ C, set), xs));
end proc:

Example of use:
(A,B,C):= ('LinearAlgebra:-RandomMatrix(3,3)' $ 3);

x:= Solve(A,B,C);

Verification:
A.x + x.B;

LinearAlgebra:-Equal(%, C);      

                                       true

Download Matrix_equation.mw

restart:
5*sqrt(1-sb^2) = 6*sqrt(1-sb^2)*sa*sqrt(1-sa^2)+4*sb,
42*sqrt(1-sa^2) = 3*sqrt(1-sa^2)*sb*sqrt(1-sb^2)+4*sa:
fsolve({%}, {sa=.995, sb=.743});

Next time, please post your equations in plaintext form so that I do not need to type them in.

There is a huge variety of nonsensical input that you can give to Maple for which it does not issue an error message. Don't try to ascribe meaning to the output. (There is an old saying of computer science: GIGO---Garbage In, Garbage Out.) As far as I know, there is never a reason to give FAIL as input. See ?FAIL and ?boolean .

According to the technical definitions of bug and feature, a situation which is not described in a program's documentation cannot be considered as either one. A bug is a situation where a program acts contrary to its documentation; a feature is a useful situation where a program acts in accordance with its documentation.