## 261 Reputation

18 years, 305 days

## Beware that log == ln != log10...

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

## Taylor Approximation interactive tutor m...

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

## Maple V R4 Demo ( mvr4demo.exe) still av...

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

## You could start by posting them...

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

## You could start by posting them...

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

## Volume of revolution, perhaps?...

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

## Consitently get 2.700548143...

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 u...

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

## Does not work here either (Maple 11.01 W...

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

## Set _EnvFormal to false...

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

## Classic interface pasts a matrix in conv...

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

## Ctrl + Home / End work with Firefox too...

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

## Array (with a capital 'a') has supersede...

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

## Graphs side by side...

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

## Display plots several plots together...

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

 First 11 12 13 14 15 Page 13 of 15
﻿