The following works as expected:

with(plots):

p1:=pointplot([[0, 3.9], [10, 5.3], [20, 7.2], [30, 9.6], 
[40, 12.9], [50, 17.1], [60, 23.1], [70, 31.4], [80, 38.6], 
[90, 50.2], [100, 62.9]]):

p2:=pointplot([[110, 76.0], [120, 92.0], [130, 105.7], 
[140, 122.8], [150, 131.7], [160, 150.7], [170, 179.0], 
[180, 205.0], [190, 226.5], [200, 248.7]]):

p3:=plot(50*abs(sin(x))+100,x=0..200):

p4:=plot(10*log,0..100):

display(p1,p2,p3,p4);

Regards, -- Jean-Marc

plot3d comes to mind, (see ?plot3d for more info), though you could also find insightful a density plot, for instance.

> plots:-densityplot((x*y^3)/(x^2+y^6),x=-1..1,y=-1..1);

Regards, -- Jean-Marc

A possible way (note that I have imagined than by "loop" you actually meant procedural way of looping ---rather than using seq--- and that Xlocal is the result of some computations):

arr := []:
for n from 1 to 3 do
  for m from 1 to 3 do
    arr := [op(arr), n + 10*m];
  end do;
end do;
arr;
ArrayTools:-Reshape(convert(arr,Vector),3,3);
LinearAlgebra:-Transpose(%);

                    [11, 21, 31, 12, 22, 32, 13, 23, 33]

                                [11  12  13]
                                [          ]
                                [21  22  23]
                                [          ]
                                [31  32  33]

                                [11  21  31]
                                [          ]
                                [12  22  32]
                                [          ]
                                [13  23  33]

Regards, -- Jean-Marc

parameterranges = list(name=range), list(range) -- Specify the allowable range for each parameter.

Among many other things, one can also specify to name a few. See help("Statistics/Regression/Options") for more info. HTH, -- Jean-Marc

To generate a list of 1000 random numbers, you could use the function Generate() (and others) from the RandomTools package. For example, the following expression will return a list of 10 random numbers, normally distributed with mu[1] = 10 and sigma[1] = 2:

> RandomTools:-Generate(list(distribution(Normal(10,2)),10));

      [10.8035543086250261, 11.0693009333449570, 8.84111155385993186, 

        10.9491378604286176, 8.41342656810022582, 11.4489341784171934, 

        8.24150149794155595, 10.7169260498370598, 9.39638715425653004, 

        8.83492577717805716]

Regards, -- Jean-Marc

Assuming I have correctly understood what you try to achieve, the function listdensityplot(), fed with a custom color function, should do it. See help("plots[listdensityplot]") and help("color") for more info.

> data := RandomTools:-Generate(listlist(integer(range = 1 .. 4), 100));
> plots:-listdensityplot(data);

Regards, -- Jean-Marc

If i have understood you correctly, you are looking for an analytic solution to your system (note that you do not have a system of ode since r'(x) depends on r(x) only and can be substituted in y'(x), which depends on r(x) and r'(x)). Now if you are looking for an expression for y'(x), you could proceed by steps, first solving for r'(x), then substituting r(x) and r'(x) into y'(x). (Or perhaps you should look for a numeric answer, see help("dsolve/numeric") ).

> sys := [diff(y(x), x) = sqrt((1-(diff(r(x), x))^2)/(r(x)^4+r(x)^2)), 
diff(r(x), x) = sqrt((2+1/r(x)^4-1/r(x)^2)/(1/r(x)^4-1)^2)];

       [                            (1/2)                                (1/2)]
       [           /              2\                  /      1       1  \     ]
       [           |    / d      \ |                  |2 + ----- - -----|     ]
       [           |1 - |--- r(x)| |                  |        4       2|     ]
       [ d         |    \ dx     / |        d         |    r(x)    r(x) |     ]
sys := [--- y(x) = |---------------|     , --- r(x) = |-----------------|     ]
       [ dx        |     4       2 |        dx        |             2   |     ]
       [           \ r(x)  + r(x)  /                  |  /  1      \    |     ]
       [                                              |  |----- - 1|    |     ]
       [                                              |  |    4    |    |     ]
       [                                              \  \r(x)     /    /     ]

> algsubs(sys[2], sys[1]);

                                                          (1/2)
                         /    /      4           2\     4\     
                         |    \2 r(x)  + 1 - r(x) / r(x) |     
                         |1 - ---------------------------|     
                         |                       2       |     
                         |           /         4\        |     
               d         |           \-1 + r(x) /        |     
              --- y(x) = |-------------------------------|     
               dx        |             4       2         |     
                         \         r(x)  + r(x)          /     

> dsolve(sys[2], r(x), useint);

    /     /                                (1/2) 
    |     |/          2           2  (1/2)\      
x - |r(x) |\4 - 2 r(x)  - 2 I r(x)  7     /      
    \     \                                      

                                  (1/2)               /
  /          2           2  (1/2)\                    |
  \4 - 2 r(x)  + 2 I r(x)  7     /      r(x) EllipticF|
                                                      \

                         (1/2)                   (1/2)\   
  1      /         (1/2)\       1 /        (1/2)\     |   
  - r(x) \2 + 2 I 7     /     , - \-3 - I 7     /     | - 
  2                             2                     /   

                                  (1/2)                                 (1/2) 
  /          2           2  (1/2)\      /          2           2  (1/2)\      
  \4 - 2 r(x)  - 2 I r(x)  7     /      \4 - 2 r(x)  + 2 I r(x)  7     /      

                /                       (1/2)                   (1/2)\
                |1      /         (1/2)\       1 /        (1/2)\     |
  r(x) EllipticE|- r(x) \2 + 2 I 7     /     , - \-3 - I 7     /     |
                \2                             2                     /

                       (1/2)                         (1/2)
       /         (1/2)\          4   /         (1/2)\     
   - 2 \2 + 2 I 7     /      r(x)  - \2 + 2 I 7     /     

                     (1/2)                                     (1/2)
     /         (1/2)\          2           4 /           (1/2)\     
   + \2 + 2 I 7     /      r(x)  + 2 I r(x)  \14 + 14 I 7     /     

                                                                  //   
                         (1/2)                             (1/2)\\ |   
       /           (1/2)\              2 /           (1/2)\     || |/  
   + I \14 + 14 I 7     /      - I r(x)  \14 + 14 I 7     /     || |\-1
                                                                // |   
                                                                   |   
                                                                   \   

                                                         (1/2) 
                            //      4           2\     4\      
         4\ /        (1/2)\ |\2 r(x)  + 1 - r(x) / r(x) |      
   + r(x) / \-1 + I 7     / |---------------------------|      
                            |                   2       |      
                            |       /         4\        |      
                            \       \-1 + r(x) /        /      

                       \          
                  (1/2)|          
  /         (1/2)\     |          
  \2 + 2 I 7     /     | + _C1 = 0
                       |          
                       |          
                       /          
> help("dsolve/numeric");

HTH, -- Jean-Marc

On my system, the images are not displayed. If I try to load/open the images I am directed to an unexpected web page, to say the least. (I believe the problem arises from MaplePrimes side). It might be more efficient to copy and past your code (and its output) in a message and wrap them in directive such as "pre" or "code". Regards, -- Jean-Marc

Another possible approach could be to use the piecewise() function. For instance,

f := proc (x, y) options operator, arrow; piecewise(x <> 0 and y <> 0,
x*y/(x^2+y^2), 0) end proc

Regards, -- Jean-Marc

The solve() function solves inequalities and returns intervals. Depending on your functions, you may have to use assuming and/or split the codomain in several intervals. For instance, Regards, --Jean-Marc

[Edited: changed b to op(b)]

> a := [[1, 2], [3, 4]];
  b := [[5, 6], [7, 8], [9, 10]];
  c := [op(a), op(b)];

                            a := [[1, 2], [3, 4]]
                       b := [[5, 6], [7, 8], [9, 10]]
               c := [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]

Regards, --Jean-Marc

You could the option tickmarks with the function spacing(). For instance,

plot(sin(x), x = 0 .. 2*Pi, tickmarks = [spacing((1/2)*Pi), default]);

Regards, --Jean-Marc

S :=[seq(seq(fsolve({eq1,eq2},{x,y}), beta=0..10),alpha=0..157)]:

EDITED: Here is an example with few points only (easier to test and debug). Regards, --Jean-Marc

For instance, use the palettes on the LHS of the screen to enter your equation in the document; then, right click on choose solve, plot, or limit in the contextual menu. Regards, --Jean-Marc

Note that := is the assignment operator; for an equation, you want to use the = sign. The function diff() must have its argument wrapped within parentheses, and if the x1 is a function of the variable t, you should write explicitly x1(t) (you will have time later on to tweak the typesetting). For instance, Regards, --Jean-Marc