The code

expr:=1/x*sqrt(x*y);
hastype(expr, radical);
expr:=3*(x*y)^(2/3)+5;
hastype(expr, radical);
expr := sqrt(5);
hastype(expr, radical);
expr:=3+sin(x);
hastype(expr, radical);

returns true, true, true, false

is to use the plottools:-rotate() command. See the last execution group in the attached

Download rotPlot.mw

straight from the first example on the Maple help page accessed by ?Iterative Maps, Bifurcation, that would be the code shown in tha attached.

For some reason, the resulting image does not display here - but it will if you execute the attached in a Maple worksheet, hen you will get the desired image

Download logistic.mw

If you wish to 'hardiwire' the current values in 'Data' into the function Diameters when you define the latter, then

Data := [L=1000, F=1000, E=206000, d0=10];
Diameters:= unapply( eval(piecewise(x<L/2, d0 ,x<2/3*L, 2*d0 ,x>2/3*L, 1.5*d0), Data), x)

is a better option

The most obvious (but undesirable) way to do this is proabably

  restart;
  A:={};
  for k from 1 by 1 to 5 do
      A:= A union {k};
  od;

This is bad practice because sets are not "mutable" - every time you add an element to a set, you are actually creating a new copy of the set, so it is very inefficient, and henc a bad habit to adopt. (For "small" sets, you *proabbly won't see much impact)

A better(?) way in Maple (versions 2016 and later) is to use the MutableSet() command, as in

  restart;
  A:=MutableSet({});
  for k from 1 by 1 to 5 do
        insert(A, k);
  od:
  A;

particularly in a restricted range, it is probably safer to use fsolve(), as in the attached

Download getRoot.mw

solve([a+b, c+b]);
numelems([%]);
solve([a+b, -b^2+c^2]);
numelems([%]);
                     {a = c, b = -c, c = c}
                               1
         {a = -c, b = c, c = c}, {a = c, b = -c, c = c}
                               2

Roots of a cubic equation will be returned using the solve() command

The nature of these roots, for various values of the discriminant are explained here https://en.wikipedia.org/wiki/Discriminant

I'm not sure that this is the best place to gain understanding of basic mathematics - I still favour a textbook for that!. However you *might* gain some insight if you replace the procedure

f := proc(x, y, z)
    (x^2 + y^2 + z^2)^2
end proc;

in your worksheet with

f := proc(x, y, z)
      1
end proc;

Do you recognise the returned value of 'soln'?

If one restricts the problem to matrices with real eigenvalues, then this can be achieved.

However, since one is varying at least one matrix entry, it is "awkward" to ensure that eigenvalues *stay* real, unless the starting matrix is restricted to be of a cerain type - eg symmetric. However with this restriction, it is relatively easy to generate plots showing how the eigenvalues and eigenvectors (plotted as spacecurves) vary as a function of the parameter. See the attached

realEV.mw

It is *possible* to do something similar for the general case - ie where both eigenvalues and eigenvectors are allowed to be complex. The complexplot() command can be used to display how the eigenvalues vary in the complex plane as a function of the parameter.

However it is more difficult to come with a meaningful(?) way of representing complex eigenvectors, since functions in C3 cannot be plotted in R3. The best(?) I could think of, was to use two spacecurves for the real and imaginary parts of each eigenvector. These plots can get a little "messy" and difficult to interpret since any given eigenvalue/eigenvector may fluctuate between real and complex as the parameter i changed. For what it is worth, a worksheet which handles(?) this case is attached

complexEV.mw

For both of these sheets (particularly) the latter), the output can be difficult to interpret for some input matrices. Can only suggest that you re-execute (which will give you a new matrix each time), until "smooth" curves are obtained: these are simpler to grasp, and will probably assist your understanding of the more complicated cases

Use a fairly simple select() command, as in the attached

I commented out a few things in your worksheet which aren't very relevant

NB I did this in Maple 2018. You are using Maple 7 which was superseded in 2002. I cannot guarantee that the following will *work* in a Maple version which is 16 years old. My installed versions only go back about 5 years:-(

Download getReal.mws

of starting a (possibly-tangential?) argument.

In Maple 2016 the MutableSet() command was introduced. This data structure appears to allow all of the operations you require, and promises to do them "efficiently".

1. It is certainly much more 'efficient' than the basic set {} when performing 'mutations'. See the test on the ?MutableSet help page
2. It *seems* to allow all "normal" set operations eg intersect, union, minus, subset etc, although you can't (in general?) mix-and-match ordinary and mutable sets
3. I haven't used this data structure extensively, but on the few occasions where it was appropriate, I don't recall any significant "issues".
4. The one area where one can anticipate problems is with commands which take a normal set as an argument - eg the 'sys' argument to dsolve(). In general these will not accept a MutableSet() - although obviously convert(...,set) can be used. I view this as a trade-off: occasional use of convert() in a program is OK, extensive use of convert() indicates that I picked the wrng data container in the first place!

It is of course true that one really shouldn't use sets (mutable or otherwise) unless one has decided that it is definitely the optimal data container. 1-D arrays will almost always be better bet

seems to be functional.

Not quite sure why one has to use separate dsolve() commands, just because the ODEs are uncoupled

Download odeIter.mw

you want to add 273 to the enries in the second column (without dealing with units), then the following will work

   restart;
#
# Generate a random matrix for test purposes
#
   with(LinearAlgebra):
   M:=RandomMatrix(10,3);
#
#  Add 273 to every entry in column 2
#
   M[..,2]:=273+~M[..,2]:
#
# Display result
#
   M;

1. A rectangle is defined by two points
2. A point is defined by two coordinates
3. Therefore a rectangle is defined by four values - think bottom -left-corner (x1,y1) and top-right -corner (x2,y2)
4. So for 21 rectangles, all I need is a 21x4 matrix, where the entries in each row represent x1, y1, x2, y2

Given the appropriate 21x4 matirx, the attached will generate/plot the rectangles.

NB since you don't provide them, I have generated the coordinates for the rectangles as a random matrix

I could make all the rectangles different colors,different linestyles etc, but let's fix the basics first

Download genRect.mw