Just an after thought, but beware that in Maple syntax ln or log both stand for the natural logarithm (base e) whereas log10 (or log[10]) stands for the decimal logarithm (base 10). So be sure to check what kind of logarithms your problem requires.

> evalf(map(ln, [1, 2, 10]));
                       [0., 0.6931471806, 2.302585093]
> evalf(map(log, [1, 2, 10]));
                       [0., 0.6931471806, 2.302585093]
> evalf(map(log10, [1, 2, 10]));
                           [0., 0.3010299957, 1.]
> evalf(map(log[10], [1, 2, 10]));
                           [0., 0.3010299957, 1.]

Regards, -- Jean-Marc

You will find it at menu Tools -> Tutors -> Calculus Single Variable -> Taylor Approximation. Regards, -- Jean-Marc

A free demo version of Maple V R4 (mvr4demo.exe) is available at ftp://ftp.maplesoft.com/pub/maple/demo/windows/ (there exists a version for UNIX too). For more recent versions of Maple, as already indicated in this thread, Maplesoft does not provide trial versions anymore and has removed any of them from their ftp server if they have ever existed. Regards, -- Jean-Marc

It's hard to tell anything without knowing more about your problem. Also, it might be wise to start a new thread when posting your inequalities. Regards, -- Jean-Marc

It's hard to tell anything without knowing more about your problem. Also, it might be wise to start a new thread when posting your inequalities. Regards, -- Jean-Marc

If I understand you correctly, more inputs are needed, such as the definition of the cylinder (height and diameter) in which the hole is made. (I believe that what you are looking for is a volume of revolution, but only you can tell for sure.) The first plot has been generated by the command given by Robert Israel. The second plot shows a cross-section of the surface in the (x,y)-plane, and the third one was produced with the help of the "Volume of Revolution" interactive tutor.

> plot3d([[r, theta, 9/(4*r^2+36)], [r, theta, -9/(4*r^2+36)]], r = 0 .. 10,
theta = 0 .. 2*Pi, coords = cylindrical);

> plot(9/(4*r^2+36), r = 0 .. 10);

> Student[Calculus1][VolumeOfRevolutionTutor]();

HTH, -- Jean-Marc

On my system, the last two lines you mentioned always give me the same wrong result: at least, the system seems to be consistent :-) > restart; _Envformal := true; evalf(Sum((1+exp(n))/(exp(n)-1), n = 5 .. infinity)); 2.700548143 > restart; _Envformal := true; evalf(Sum((1+exp(n))/(exp(n)-1), n = 5 .. infinity)); 2.700548143 > restart; _Envformal := true; evalf(Sum((1+exp(n))/(exp(n)-1), n = 5 .. infinity)); 2.700548143 > restart; _Envformal := true; evalf(Sum((1+exp(n))/(exp(n)-1), n = 5 .. infinity)); 2.700548143 Regards, -- Jean-Marc

We are using the same version of Maple under the same operating system (Windows XP SP2), still we get different results. Is it possible that something else must be taken in account (say, hardware architecture -- Intel Pentium 4HT in my case --, 32 vs 64 bit, hardware vendor -- Intel vs AMD, or something else)?

> kernelopts(version);
            Maple 11.01, IBM INTEL NT, Jun 8 2007 Build ID 296069
> version();
 User Interface: 303882
         Kernel: 296069
        Library: 296069
                                   303882

Thanks for the pointer to the very informative thread about version numbering. Regards, -- Jean-Marc

FWIW, Although Maple 11.01 seems to be correctly installed on my Windows box (kernelopts(version) is in agreement with what is displayed in the dialog box Help -> About Maple...), I still do not get DJKeenan's results: f does not evaluate to infinity when _EnvFormal is not set, and g with k == 5 evaluates to the erroneous 2.700548143. (The code below ran from a fresh session.)

> kernelopts(version);

            Maple 11.01, IBM INTEL NT, Jun 8 2007 Build ID 296069

> f := proc (k) options operator, arrow; sum((1+exp(n))/(exp(n)-1), 
         n = k .. infinity) end proc; 
seq(f(i), i = 1 .. 9);

     infinity          
      -----            
       \               
        )    1 + exp(n)
k ->   /     ----------
      -----  exp(n) - 1
      n = k            
       infinity            infinity            infinity            
        -----               -----               -----              
         \                   \                   \                 
          )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)  
         /     ----------,   /     ----------,   /     ----------, 
        -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1  
        n = 1               n = 2               n = 3              

         infinity            infinity            infinity            
          -----               -----               -----              
           \                   \                   \                 
            )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)  
           /     ----------,   /     ----------,   /     ----------, 
          -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1  
          n = 4               n = 5               n = 6              

         infinity            infinity            infinity          
          -----               -----               -----            
           \                   \                   \               
            )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)
           /     ----------,   /     ----------,   /     ----------
          -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1
          n = 7               n = 8               n = 9            

> _EnvFormal := true; 
seq(f(i), i = 1 .. 9);

       infinity            infinity            infinity            
        -----               -----               -----              
         \                   \                   \                 
          )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)  
         /     ----------,   /     ----------,   /     ----------, 
        -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1  
        n = 1               n = 2               n = 3              

         infinity            infinity            infinity            
          -----               -----               -----              
           \                   \                   \                 
            )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)  
           /     ----------,   /     ----------,   /     ----------, 
          -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1  
          n = 4               n = 5               n = 6              

         infinity            infinity            infinity          
          -----               -----               -----            
           \                   \                   \               
            )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)
           /     ----------,   /     ----------,   /     ----------
          -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1
          n = 7               n = 8               n = 9            

> g := proc (k) options operator, arrow; evalf(Sum((1+exp(n))/(exp(n)-1), 
         n = k .. infinity)) end proc; 
seq(g(i), i = 1 .. 9);

          /infinity          \
          | -----            |
          |  \               |
          |   )    1 + exp(n)|
k -> evalf|  /     ----------|
          | -----  exp(n) - 1|
          \ n = k            /
 infinity            infinity            infinity            
  -----               -----               -----              
   \                   \                   \                 
    )    1 + exp(n)     )    1 + exp(n)     )    1 + exp(n)  
   /     ----------,   /     ----------,   /     ----------, 
  -----  exp(n) - 1   -----  exp(n) - 1   -----  exp(n) - 1  
  n = 1               n = 2               n = 3              

   infinity                         infinity            infinity            
    -----                            -----               -----              
     \                                \                   \                 
      )    1 + exp(n)                  )    1 + exp(n)     )    1 + exp(n)  
     /     ----------, 2.700548143,   /     ----------,   /     ----------, 
    -----  exp(n) - 1                -----  exp(n) - 1   -----  exp(n) - 1  
    n = 4                            n = 6               n = 7              

   infinity            infinity          
    -----               -----            
     \                   \               
      )    1 + exp(n)     )    1 + exp(n)
     /     ----------,   /     ----------
    -----  exp(n) - 1   -----  exp(n) - 1
    n = 8               n = 9            

Regards, -- Jean-Marc

Glancing at the help page for sum, one can find that the setting of the system variable _EnvFormal to false should work in your case since 1) the series is divergent and 2) no closed form seems to exist.

> sum(1/ln(n), n = 2 .. infinity);
                                infinity     
                                 -----       
                                  \          
                                   )      1  
                                  /     -----
                                 -----  ln(n)
                                 n = 2       
> _EnvFormal := false;
                                    false
> sum(1/ln(n), n = 2 .. infinity);
                                  infinity

Also, you may want to investigate the SumTools[IndefiniteSum] Subpackage. (Note that I am pretty sure to have read a reply to a similar query lately, however, I cannot find the thread now. If that was a reply to a post of yours, well, you know what I am talking about; otherwise you may be more successful in finding it). Regards, -- Jean-Marc

I do not know if there is a better way, but copying a matrix from within the classic interface allows to past it in a more conventional form. (I believe that the command line interface should do the same thing.) For instance, here is your example copied from the classic interface:

> m1:=Matrix([[1.1,2.1,3.1],[4.1,5.1,6.1]]):
> m2:=Matrix([[1.2,2.2,3.2],[4.2,5.2,6.2]]):
> m3:=Matrix([[1.3,2.3,3.3],[4.3,5.3,6.3]]):
> m4:=Matrix([[1.4,2.4,3.4],[4.4,5.4,6.4]]):
> Matrix([[m1,m2],[m3,m4]]);

               [1.1    2.1    3.1    1.2    2.2    3.2]
               [                                      ]
               [4.1    5.1    6.1    4.2    5.2    6.2]
               [                                      ]
               [1.3    2.3    3.3    1.4    2.4    3.4]
               [                                      ]
               [4.3    5.3    6.3    4.4    5.4    6.4]

Regards, -- Jean-Marc

Just to say/confirm that these control sequences can be use with Firefox. Regards, -- Jean-Marc

Array (with a capital 'a') has superseded the older array structure, which has been kept for backward compatibility only. Therefore, except if you have a very compelling reason to do so, I strongly urge you not to use array, but the newer Array instead. (Similarly, use the LinearAlgebra package that superseded the older linalg.) About your second point (reverse ranges), I have not yet giving it any thought, I must admit. I know how to do it with another CAS (not very helpful in your case though) and it is not clear to me how I can transpose the method into Maple code. I will try to come up with something if, meanwhile, nobody has posted a solution. Regards, -- Jean-Marc

Sorry, I did not look at the Word document you posted. So, now I believe that what you are looking for is still the display command but with an array as argument. For instance,

> with(plots);
> A := Array(1 .. 2);
> A[1] := plot(sin(x), x = 0 .. 2*Pi, color = red);
> A[2] := plot(cos(y), y = -Pi .. Pi, color = blue);
> display(A);

From the online help, "The second calling sequence allows plots to be displayed in a tabular format. If A is a one-dimensional Array of plot structures, then a row of plots is displayed. If A is a two-dimensional m-by-n Array, then an m-by-n table of plots is displayed. A can contain a combination of 2-D and 3-D plots, including animations." Regards, -- Jean-Marc

Look at the help page for the function display. For instance,

> with(plots);
> p1 := plot(sin(x), x = 0 .. 2*Pi, color = red);
> p2 := plot(cos(y), y = -Pi .. Pi, color = blue);
> display({p1, p2});

Regards, -- Jean-Marc