Minimal Maxima

本文作者：Robert Dodier

翻译：dbzhang800

适用版本：

文章状态：整理中...

Maxima 是什么?

Maxima 是一个处理数学表达式的系统,例如x + y, sin(a + bπ)以及u · v − v · u

Maxima 并不太关心表达式的含义,一个表达式是否有意义由使用者来判断。

有时你想给未知数赋值并且要计算表达式的值。Maxima 很善长做这件事。但是Maxima 也很 善长推迟赋值;你可以先对表达式做一番处理,然后才给(也许永远不给)未知数赋值。

我们先看几个例子:

1.我想计算球的体积。

(%i1) V: 4/3 * %pi * r^3;
                                  3
                          4 %pi r
(%o1)                     --------
                             3

2.半径是10。

(%i2) r: 10;
(%o2)        10

3.V的值和前面一样;在我们下令以前,Maxima不会改变V的值。

(%i3) V;
                  3
         4 %pi r
(%o3)    --------
            3

4.Maxima,重新计算一下V。

(%i4) ’’V;
           4000 %pi
(%o4)      --------
              3

5.我想看到一个具体的数值而不是一个表达式。

(%i5) ’’V, numer;
(%o5)             4188.79020478639

表达式

Maxima 中所有的东西都是表达式,包括数学表达式、对象、程序结构等。表达式要么是原子,要么是操作符与它的自变量。

原子是一个符号(名字),一个用引号括起来的字符串,或者是一个数(整数或浮点数)。

所有非原子表达式都表示为op(a1 , . . . , an ),其中op是操作符的名字,a1 , . . . , an 是自变。(表达式的显示形式可能不太一致,但内部表示都是一样的。)表达式中的自变量可以是原子或非原子表达式。

数学表达式中含有一个操作符,比如+ − ∗/ < = > 或者一个函数,比如sin(x),bessel_j(n, x)。在这种情况下操作符就是函数。

对象在Maxima 中是表达式。列表[a1 , . . . , an ]就是表达式list(a1 , . . . , an )。矩阵就是表达式

   matrix(list(a1,1 , . . . , a1,n ), . . . ,list(am,1 , . . . , am,n ))

程 序 构 造 是 表 达 式 。 一 个 代 码 块block(a1 , . . . , an )是 操 作 符 为block自 变 量 为a1 , . . . , an 的表 达 式 。 条 件 语 句if a then b elseif c then d是 表 达 式if(a, b, c, d)。 循 环for a in L do S是 类 似于do(a, L, S)的表达式。

Maxima 函数op返回一个非原子表达式的操作符。函数args返回非原子表达式的自变量。函数atom判断一个表达式是不是原子。

让我们看几个例子。

1. 符号、字符串和数字都是原子。为了一次能看到它们,我把几个例子凑到时了一个列表里面。

(%i2) [a, foo, foo_bar, "Hello, world!", 42, 17.29];
(%o2)      [a, foo, foo_bar, Hello, world!, 42, 17.29]

2. 数学表达式。

(%i1) [a + b + c, a * b * c, foo = bar, a*b < c*d];
(%o1)       [c + b + a, a b c, foo = bar, a b < c d]

3. 列表和矩阵。列表和矩阵的元可以是任何表达式,甚至是其它列表或矩阵。

(%i1) L: [a, b, c, %pi, %e, 1729, 1/(a*d - b*c)];
                                                   1
(%o1)                 [a, b, c, %pi, %e, 1729, ---------]
                                               a d - b c
(%i2) L2: [a, b, [c, %pi, [%e, 1729], 1/(a*d - b*c)]];
                                                    1
(%o2)               [a, b, [c, %pi, [%e, 1729], ---------]]
                                                a d - b c
(%i3) L [7];
                                       1
(%o3)                              ---------
                                   a d - b c
(%i4) L2 [3];
                                                 1
(%o4)                   [c, %pi, [%e, 1729], ---------]
                                             a d - b c
(%i5) M: matrix ([%pi, 17], [29, %e]);
                                  [ %pi  17 ]
(%o5)                             [         ]
                                  [ 29   %e ]
(%i6) M2: matrix([[%pi,17],a*d - b*c],[matrix([1,a],[b,7]),%e]);
                           [ [%pi, 17]  a d - b c ]
                           [                      ]
(%o6)                      [ [ 1  a ]             ]
                           [ [      ]      %e     ]
                           [ [ b  7 ]             ]
(%i7) M [2][1];
(%o7)                                 29
(%i8) M2 [2][1];
                                   [ 1  a ]
(%o8)                              [      ]
                                   [ b  7 ]

4. 程序构造是表达式。x : y表示把y赋给x;这个赋值表达式的值是y。block把几个表达式组合为一个块,然后依次求各个表达式的值;最后一个表达式的值即是块的值。

(%o1)                                 25
(%i2) [a, b];
(%o2)                              [42, 17]
(%i3) block ([a], a: 42, a^2 - 1600) + block ([b], b: 5, %pi^b);
                                     5
(%o3)                             %pi  + 164
(%i4) (if a > 1 then %pi else %e) + (if b < 0 then 1/2 else 1/7);
                                          1
(%o4)                               %pi + -
                                          7

5. op返回操作符,args返回自变量,atom判断一个表达式是不是原子。

(%i1) op (p + q);
(%o1)                                  +
(%i2) op (p + q > p*q);
(%o2)                                  >
(%i3) op (sin (p + q));
(%o3)                                 sin
(%i4) op (foo (p, q));
(%o4)                                 foo
(%i5) op (foo (p, q) := p - q);
(%o5)                                 :=
(%i6) args (p + q);
(%o6)                               [q, p]
(%i7) args (p + q > p*q);
(%o7)                            [q + p, p q]
(%i8) args (sin (p + q));
(%o8)                               [q + p]
(%i9) args (foo (p, q));
(%o9)                              [p, - q]
(%i10) args (foo (p, q) := p - q);
(%o10)                        [foo(p, q), p - q]
(%i11) atom (p);
(%o11)                               true
(%i12) atom (p + q);
(%o12)                               false
(%i13) atom (sin (p + q));
(%o13)                               false

6. 程序构造的操作符和自变量。单引号告诉Maxima构造表达式,但不求值。这点我们后面会涉及。

(%o0)                                done
(%i1) op ('(block ([a], a: 42, a^2 - 1600)));
(%o1)                                block
(%i2) op (' (if p > q then p else q));
(%o2)                                 if
(%i3) op ('(for x in L do print (x)));
(%o3)                                mdoin
(%i4) args (' (block ([a], a: 42, a^2 -1600)));
                                         2
(%o4)                      [[a], a : 42, a  - 1600]
(%i5) args (' (if p > q then p else q));
(%o5)                         [p > q, p, true, q]
(%i6) args (' (for x in L do print (x)));
(%o6)            [x, L, false, false, false, false, print(x)]