[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 5. Data Types and Structures

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.1 Numbers

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.1.1 Introduction to Numbers

### Complex numbers

Maximaでは複素数式を式の実部と`%i`かける虚部の足し算で指定します。 例えば、等式 `x^2 - 4*x + 13 = 0`の根は `2 + 3*%i`と `2 - 3*%i`です。 複素数式の積の整理は積を展開することで影響を受けるかもしれないことに注意してください。 複素数式の商や根、他の関数の整理は普通、 `realpart`, `imagpart`, `rectform`, `polarform`, `abs`, `carg`関数を使って達成することができます。

Categories: Complex variables

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.1.2 Functions and Variables for Numbers

関数: bfloat (expr)

  exprの中のすべての数や数の関数を多倍長浮動小数点に変換します。 戻り値の多倍長浮動小数点の有効桁数は、 グローバル変数`fpprec`によって規定されます。

  `float2bf`が`false`の場合、 浮動小数点が多倍長浮動小数点に変換される時 （精度が落ちることを意味するので）警告メッセージが出力されます。

  Categories: Numerical evaluation

関数: bfloatp (expr)

  もしexprが多倍長浮動小数点数なら`true`を、そうでなければ`false`を返します。

  Categories: Numerical evaluation · Predicate functions

オプション変数: bftorat

  デフォルト値: `false`

  `bftorat`は多倍長浮動小数点の有理数への変換を制御します。 `bftorat`が`false`の時、 `ratepsilon`が変換を制御するのに使われます。 (これは比較的小さな有理数になります。) `bftorat`が`true`の時、 生成された有理数は多倍長浮動小数点を正確に表します。

  注意: `bftorat`は関数 `rationalize`を使った有理数への変換に関して効果を持ちません。

  例:

      (%i1) ratepsilon:1e-4;
      (%o1)                         1.e-4
      (%i2) rat(bfloat(11111/111111)), bftorat:false;
      `rat' replaced 9.99990999991B-2 by 1/10 = 1.0B-1
                                     1
      (%o2)/R/                       --
                                     10
      (%i3) rat(bfloat(11111/111111)), bftorat:true;
      `rat' replaced 9.99990999991B-2 by 11111/111111 = 9.99990999991B-2
                                   11111
      (%o3)/R/                     ------
                                   111111

  Categories: Numerical evaluation

オプション変数: bftrunc

  デフォルト値: `true`

  `bftrunc`は、非ゼロの多倍長浮動小数点数の中のずるずる続くゼロを表示しないようにします。 例えば、もし`bftrunc`が`false`なら、 `bfloat (1)`は`1.000000000000000B0`と表示されます。 そうでなければ、これは、`1.0B0`と表示されます。

  Categories: Numerical evaluation

関数: evenp (expr)

  もし exprが偶数なら `true`を、そうでなければ `false`を返します。

  たとえ exprが `even`と宣言されていても もし exprがシンボルなら、`evenp`は `false`を返します。

  Categories: Predicate functions

関数: float (expr)

  exprの中の整数、有理数、多倍長浮動小数点を浮動小数点に変換します。 `float`は`evflag`でもあり、 非整数有理数と多倍長浮動小数点を浮動小数点に変換します。

  Categories: Numerical evaluation · Evaluation flags

オプション変数: float2bf

  デフォルト値: `true`

  `float2bf`が`false`の場合、 浮動小数点が多倍長浮動小数点に変換される時、 （これは精度の無駄使いとなるかもしれないので、） 警告メッセージが表示されます。

  Categories: Numerical evaluation

関数: floatnump (expr)

  もしexprが浮動小数点なら `true`を返し、そうでないなら `false`を返します。

  Categories: Numerical evaluation · Predicate functions

オプション変数: fpprec

  デフォルト値: 16

  `fpprec`は多倍長浮動小数点上の代数のための有効桁数です。 `fpprec`は通常の浮動小数点上の計算に影響を与えません。

  `bfloat`と`fpprintprec`も参照してください。

  Categories: Numerical evaluation

オプション変数: fpprintprec

  デフォルト値: 0

  `fpprintprec`は、通常の浮動小数点もしくは多倍長浮動小数点を表示する時の 表示する桁数です。

  通常の浮動小数点に関しては、 `fpprintprec`が2から16までの値を持つ時、 表示されるディジット数は`fpprintprec`に等しいです。 そうでなければ、`fpprintprec`は0もしくは16より大きく、 表示されるディジット数は16です。

  多倍長浮動小数点に関しては、 `fpprintprec`が2から`fpprec`までの値を持つ時、 表示される桁数は、`fpprintprec`に等しいです。 そうでなければ、`fpprintprec`は、0もしくは`fpprec`より大きく、 表示される桁数は`fpprec`に等しいです。

  通常の浮動小数点でも多倍長浮動小数点でも、後置ゼロは抑制されます。 もし後置ゼロがあれば、表示される実際の桁数は `fpprintprec`を小さくなります。

  `fpprintprec`は1にはできません。

  Categories: Numerical evaluation · Display flags and variables

関数: integerp (expr)

  もしexprが整数リテラルなら `true`を、 そうでないなら `false`を返します。

  たとえ exprが `integer`と宣言されていても、もし exprがシンボルなら `integerp`は `false`を返します。

  例:

      (%i1) integerp (0);
      (%o1)                         true
      (%i2) integerp (1);
      (%o2)                         true
      (%i3) integerp (-17);
      (%o3)                         true
      (%i4) integerp (0.0);
      (%o4)                         false
      (%i5) integerp (1.0);
      (%o5)                         false
      (%i6) integerp (%pi);
      (%o6)                         false
      (%i7) integerp (n);
      (%o7)                         false
      (%i8) declare (n, integer);
      (%o8)                         done
      (%i9) integerp (n);
      (%o9)                         false

  Categories: Predicate functions

オプション変数: m1pbranch

  デフォルト値: `false`

  `m1pbranch`は `-1`のべき乗の主枝です。 `(-1)^(1/3)`(すなわち、「奇」の有理指数)や `(-1)^(1/4)`(すなわち、「偶」の有理指数) のような量は以下のように扱われます:

                    domain:real

      (-1)^(1/3):      -1
      (-1)^(1/4):   (-1)^(1/4)

                   domain:complex
      m1pbranch:false          m1pbranch:true
      (-1)^(1/3)               1/2+%i*sqrt(3)/2
      (-1)^(1/4)              sqrt(2)/2+%i*sqrt(2)/2

  Categories: Expressions · Global flags

関数: nonnegintegerp (n)

  `n >= 0`かつ nが整数の時だけ`true`を返します。

  Categories: Package linearalgebra · Predicate functions

関数: numberp (expr)

  もしexprが文字リテラルか、有理数か、浮動小数点数か、多倍長浮動小数点なら `true`を、 そうでなければ `false`を返します。

  たとえ exprが `%pi`や `%i`のようなシンボリックな数でも、また、 `even`, `odd`, `integer`, `rational`, `irrational`, `real`, `imaginary`, `complex`のいずれかに宣言されていても、 もし exprがシンボルなら `numberp`は `false`を返します。

  例:

      (%i1) numberp (42);
      (%o1)                         true
      (%i2) numberp (-13/19);
      (%o2)                         true
      (%i3) numberp (3.14159);
      (%o3)                         true
      (%i4) numberp (-1729b-4);
      (%o4)                         true
      (%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
      (%o5)      [false, false, false, false, false, false]
      (%i6) declare (a, even, b, odd, c, integer, d, rational,
           e, irrational, f, real, g, imaginary, h, complex);
      (%o6)                         done
      (%i7) map (numberp, [a, b, c, d, e, f, g, h]);
      (%o7) [false, false, false, false, false, false, false, false]

  Categories: Predicate functions

特殊シンボル: numer

  `numer`は数値の引数を持つ（指数関数を含む）いくつかの数学関数を 浮動小数点に評価するようにします。 数値が与えられた`expr`の中の変数を値に置き換えるようにします。 それは `float`スイッチをオンにもします。

  `%enumer`も参照してください。

  例:

      (%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))];
                                              1
      (%o1)            [sqrt(2), sin(1), -----------]
                                         sqrt(3) + 1
      (%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer;
      (%o2) [1.414213562373095, .8414709848078965, .3660254037844387]

  Categories: Numerical evaluation · Evaluation flags

オプション変数: numer_pbranch

  デフォルト値: `false`

  オプション変数`numer_pbranch`は 負の整数、有理数、または浮動小数点数のべきの数値評価を制御します。 `numer_pbranch`が`true`でかつ、指数が浮動小数点数であるか オプション変数`numer`も`true`の時、 Maximaは主枝を使って数値結果を評価します。 そうでなければ、式整理されたが未評価の結果が返されます。

  例:

      (%i1) (-2)^0.75;
                                       0.75
      (%o1)                       (- 2)
      (%i2) (-2)^0.75,numer_pbranch:true;
      (%o2)       1.189207115002721 %i - 1.189207115002721
      (%i3) (-2)^(3/4);
                                     3/4  3/4
      (%o3)                     (- 1)    2
      (%i4) (-2)^(3/4),numer;
                                                0.75
      (%o4)              1.681792830507429 (- 1)
      (%i5) (-2)^(3/4),numer,numer_pbranch:true;
      (%o5)       1.189207115002721 %i - 1.189207115002721

  Categories: Numerical evaluation

関数: numerval (x_1, expr_1, …, x_n, expr_n)

  変数`x_1`, …, `x_n`を `expr_1`, …, `expr_n`に等しい数値を持つ変数だと宣言します。 もし `numer`フラグが `true`なら、 変数が現れる任意の式にて、数値は評価され、変数に代入されます。 `ev`も参照してください。

  式`expr_1`, …, `expr_n`は、任意の式を取り得ます。数値である必要はありません。

  Categories: Declarations and inferences · Numerical evaluation

関数: oddp (expr)

  もし expが奇数リテラルであれば `true`を、そうでなければ `false`を返します。

  たとえ exprが `odd`と宣言されていても もし exprがシンボルなら `oddp`は `false`を返します。

  Categories: Predicate functions

オプション変数: ratepsilon

  デフォルト値: `2.0e-15`

  オプション変数 `bftorat`が値 `false`を持つ時、 `ratepsilon`は浮動小数点数を有理数に変換する際に使われる許容誤差です。 例は`bftorat`を参照してください。

  Categories: Numerical evaluation · Rational expressions

関数: rationalize (expr)

  Maximaの式exprの中の倍精度浮動小数点やビッグフローすべてを同値の有理数に変換します。 もし浮動小数点の２値表現に詳しくなれば、`rationalize (0.1)`が1/10に等しくないことに 驚くかもしれません。 この振る舞いはMaximaに特別なわけではありません。―1/10は２値の循環小数表現を持ちます。

      (%i1) rationalize (0.5);
                                      1
      (%o1)                           -
                                      2
      (%i2) rationalize (0.1);
                              3602879701896397
      (%o2)                   -----------------
                              36028797018963968
      (%i3) fpprec : 5$
      (%i4) rationalize (0.1b0);
                                   209715
      (%o4)                        -------
                                   2097152
      (%i5) fpprec : 20$
      (%i6) rationalize (0.1b0);
                           236118324143482260685
      (%o6)                ----------------------
                           2361183241434822606848
      (%i7) rationalize (sin (0.1*x + 5.6));
                     3602879701896397 x   3152519739159347
      (%o7)      sin(------------------ + ----------------)
                     36028797018963968    562949953421312

  Categories: Numerical evaluation

関数: ratnump (expr)

  もしexprが整数リテラルもしくは整数リテラルの比なら `true`を返し、 そうでなければ `false`を返します。

  Categories: Predicate functions · Rational expressions

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.2 Strings

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.2.1 Introduction to Strings

文字列(クォートされた文字の列)は入力の際にはダブルクォートマーク `"`で括り、 グローバル変数 `stringdisp`に依存して、クォートマークありだったりなしだったりで 表示されます。

文字列は、埋め込みタブ、改行、キャリッジリターン文字を含む任意の文字を含み得ます。 列 `\"`は文字通りダブルクォートとして認識され、 `\\`は文字通りバックスラッシュとして認識されます。 バックスラッシュが行の終わりに現れる時、 バックスラッシュと(改行かキャリッジリターンと改行かいずれかの)行終端を無視します。 そして、文字列は次の行に続きます。 他にバックスラッシュともう一つの文字の組み合わせで特殊なものはありません; `"`か, `\`,　行終端以外の任意の文字の前にバックスラッシュが現れる時、 バックスラッシュは無視されます。 文字列の中に文字リテラルを埋め込むことを除いて (タブ、改行、キャリッジリターンのような)特殊文字を表す方法はありません。

Maximaでは文字タイプはありません; 文字単体は1文字の文字列として表されます。

`stringproc`アドオンパッケージは文字列に機能する多くの関数を含みます。

例:

    (%i1) s_1 : "This is a string.";
    (%o1)                   This is a string.
    (%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
    (%o2) Embedded "double quotes" and backslash \ characters.
    (%i3) s_3 : "Embedded line termination
    (%o3) Embedded line termination
    in this string.
    (%i4) in this string.";
    (%o4) Ignore the line termination characters in this string.
    (%i5) s_4 : "Ignore the \
    (%o5)                         false
    (%i6) line termination \
    (%o6)                   This is a string.
    (%i7) characters in \
    (%o7)                         true
    (%i8) this string.";
    (%o8)                  "This is a string."
    (%i9) stringdisp : false;

Categories: Syntax

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.2.2 Functions and Variables for Strings

関数: concat (arg_1, arg_2, …)

  引数を連結します。 引数はアトムに評価されなければいけません。 もし最初の引数がシンボルなら戻り値はシンボルで、 そうでなければ文字列です。

  `concat`は引数を評価します。 シングルクォート`'`は評価を抑制します。

  `sconcat`と `eval_string`も参照してください。

      (%i1) y: 7$
      (%i2) z: 88$
      (%i3) concat (y, z/2);
      (%o3)                          744
      (%i4) concat ('y, z/2);
      (%o4)                          y44

  `concat`によって組み立てられたシンボルは値に割り当てられたり、式の中に現れたりします。 `::` (ダブルコロン)割り当て演算子は左辺を評価します。

      (%i5) a: concat ('y, z/2);
      (%o5)                          y44
      (%i6) a:: 123;
      (%o6)                          123
      (%i7) y44;
      (%o7)                          123
      (%i8) b^a;
                                     y44
      (%o8)                         b
      (%i9) %, numer;
                                     123
      (%o9)                         b

  `concat (1, 2)`は数のように見えますが、文字列であることに注意してください。

      (%i10) concat (1, 2) + 3;
      (%o10)                       12 + 3

  Categories: Expressions · Strings

関数: sconcat (arg_1, arg_2, ...)

  引数を文字列に連結します。 `concat`と違い、引数はアトムである必要はありません。

  `concat`と `eval_string`も参照してください。 複雑な文字列変換については `printf`も参照してください。

      (%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
      (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3

  Another purpose for `sconcat` is to convert arbitrary objects to strings.

      (%i1) sconcat (x);
      (%o1)                           x
      (%i2) stringp(%);
      (%o2)                         true

  Categories: Expressions · Strings

関数: string (expr)

  `expr`を、ただまるでタイプされたようにMaximaの線形表記に変換します。

  `string`の戻り値は文字列であり、 計算の中で使うことはできません。

  Categories: Strings

オプション変数: stringdisp

  デフォルト値: `false`

  `stringdisp`が`true`の時、 文字列はダブルクォートマークで囲まれて表示されます。 そうでなければクォートマークは表示されません。

  関数定義を表示する時はいつも、`stringdisp`は `true`です。

  例:

      (%i1) stringdisp: false$
      (%i2) "This is an example string.";
      (%o2)              This is an example string.
      (%i3) foo () :=
            print ("This is a string in a function definition.");
      (%o3) foo() :=
                    print("This is a string in a function definition.")
      (%i4) stringdisp: true$
      (%i5) "This is an example string.";
      (%o5)             "This is an example string."

  Categories: Display flags and variables

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.3 Constants

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.4 Functions and Variables for Constants

定数: %e

  `%e`はEuler数としても知られる自然対数の基数を表します。 `%e`の数値は倍精度浮動小数点数2.718281828459045d0です。

  Categories: Constants

定数: %i

  `%i`は虚数単位sqrt(- 1)を表します。

  Categories: Constants

定数: false

  `false`は同じ名前のブーリアン定数を表します。 Maximaは、Lispの値`NIL`で`false`を実装しています。

  Categories: Constants

定数: %gamma

  Euler-Macheroni定数0.5772156649015329 ....

  Categories: Constants

定数: ind

  `ind`は有界で不定の結果を表します。

  `limit`も参照してください。

  例:

      (%i1) limit (sin(1/x), x, 0);
      (%o1)                          ind

  Categories: Constants

定数: inf

  `inf`は実数の正の無限大を表します。

  Categories: Constants

定数: infinity

  `infinity`は複素数の無限大を表します。

  Categories: Constants

定数: minf

  `minf`は実数のマイナスの（すなわち負の）無限大を表します。

  Categories: Constants

定数: %phi

  `%phi`は黄金比と呼ばれる(1 + sqrt(5))/2を表します。 `%phi`の数値は倍精度浮動小数点数1.618033988749895d0です。

  `fibtophi`は、`%phi`を使って フィボナッチ数`fib(n)`を表現します。

  デフォルトでは、Maximaは `%phi`の代数的プロパティを知りません。 `tellrat(%phi^2 - %phi - 1)`と`algebraic: true`を評価した後、 `ratsimp`は `%phi`を含むいくつかの式を整理できます。

  例:

  `fibtophi`は、`%phi`を使って フィボナッチ数`fib(n)`を表現します。

      (%i1) fibtophi (fib (n));
                                 n             n
                             %phi  - (1 - %phi)
      (%o1)                  -------------------
                                 2 %phi - 1
      (%i2) fib (n-1) + fib (n) - fib (n+1);
      (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
      (%i3) fibtophi (%);
                  n + 1             n + 1       n             n
              %phi      - (1 - %phi)        %phi  - (1 - %phi)
      (%o3) - --------------------------- + -------------------
                      2 %phi - 1                2 %phi - 1
                                                n - 1             n - 1
                                            %phi      - (1 - %phi)
                                          + ---------------------------
                                                    2 %phi - 1
      (%i4) ratsimp (%);
      (%o4)                           0

  デフォルトでは、Maximaは `%phi`の代数的プロパティを知りません。 `tellrat(%phi^2 - %phi - 1)`と`algebraic: true`を評価した後、 `ratsimp`は `%phi`を含むいくつかの式を整理できます。

      (%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                       2                      2
      (%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
      (%i2) ratsimp (e);
                        2                     2
      (%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
      (%i3) tellrat (%phi^2 - %phi - 1);
                                  2
      (%o3)                  [%phi  - %phi - 1]
      (%i4) algebraic : true;
      (%o4)                         true
      (%i5) ratsimp (e);
      (%o5)                           0

  Categories: Constants

定数: %pi

  `%pi`は直径に体する円周の比を表します。 `%pi`の数値は倍精度浮動小数点数3.141592653589793d0です。

  Categories: Constants

定数: true

  `true`は同じ名前のブーリアン定数を表します。 MaximaはLispの値`T`で`true`を実装しています。

  Categories: Constants

定数: und

  `und`は未定義の結果を表します。

  `limit`も参照してください。

  例:

      (%i1) limit (x*sin(x), x, inf);
      (%o1)                          und

  Categories: Constants

定数: zeroa

  `zeroa`はゼロの上の無限小を表します。 `zeroa`は式の中で使うことができます。 `limit`は無限小を含む式を整理します。

  `zerob`と`limit`も参照してください。

  例:

  `limit`は無限小を含む式を整理します:

      (%i1) limit(zeroa);
      (%o1)                           0
      (%i2) limit(x+zeroa);
      (%o2)                           x

  Categories: Constants

定数: zerob

  `zerob`はゼロの下の無限小を表します。 `zerob`は式の中で使うことができます。 `limit`は無限小を含む式を整理します。

  `zeroa`と`limit`も参照してください。

  Categories: Constants

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.5 Lists

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.5.1 Introduction to Lists

リストはMaximaとLispにとって基本的な構成要素です。 配列、 `hashed arrays`、数以外のデータタイプすべてはLispのリストとして表現されます。 これらのLispのリストは 式 `a+2`を示すために以下の形式を取ります。

    ((MPLUS) $A 2)

Maximaレベルでは中置表記`a+2`を見ることになるでしょう。 Maximaには、以下のようにプリントされるリストもあります。

    [1, 2, 7, x+y]

これは4要素のリストの場合の例です。 内部的には、これは以下の形式のLispのリストに対応します。

    ((MLIST) 1 2 7 ((MPLUS) $X $Y))

Maxima式のタイプフィールドを意味するフラグはそれ自体リストです。 整理器を通った後、上のリストは以下のようになるでしょう。

    ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.5.2 Functions and Variables for Lists

演算子: [
演算子: ]

  `[`と `]`は、それぞれ、リストの始まりと終わりをマークします。

  `[`と`]`は、リスト、配列、 `hashed array`,、 `memoizing function`の添字もくくります。 配列と違い、リストの `n`番目の要素にアクセスすることは おおよそ `n`に比例する時間が必要かもしれないことに注意してください。 See section Performance considerations for Lists.

  もし添字された変数の要素がこの名前のリストか配列が宣言される前に書き込まれたら、 リストではなく、 `hashed array` See section Arrays)が生成されることに注意してください。

  例:

      (%i1) x: [a, b, c];
      (%o1)                       [a, b, c]
      (%i2) x[3];
      (%o2)                           c
      (%i3) array (y, fixnum, 3);
      (%o3)                           y
      (%i4) y[2]: %pi;
      (%o4)                          %pi
      (%i5) y[2];
      (%o5)                          %pi
      (%i6) z['foo]: 'bar;
      (%o6)                          bar
      (%i7) z['foo];
      (%o7)                          bar
      (%i8) g[k] := 1/(k^2+1);
                                        1
      (%o8)                     g  := ------
                                 k     2
                                      k  + 1
      (%i9) g[10];
                                      1
      (%o9)                          ---
                                     101

  Categories: Lists · Operators

関数: append (list_1, …, list_n)

  list_1の要素のあとに list_2の要素が続き、… という１つのリストを返します。 `append`は一般式上でも機能します。 例えば、 `append (f(a,b), f(c,d,e));`は `f(a,b,c,d,e)`をもたらします。

  `addrow`, `addcol`, `join`も参照してください。

  例を見るには、 `example(append);`を実行してください。

  Categories: Lists · Expressions

関数: assoc
`assoc` (key, list, default)
`assoc` (key, list)

  この関数は入力 listの左辺の中で keyを探します。 list引数はリストでなければならず、その要素のそれぞれは正確に２つの部分を持つ式です。 最も普通には、listの要素はそれ自身リストで、それぞれが2つの要素を持ちます。

  `assoc`関数は listに従って、それぞれの要素の最初の部分が keyと等しいかチェックを 繰り返します。 もし比較が真になる要素が見つかったら、 `assoc`はその要素の二番目の部分を返します。 もしリストの中にそんな要素が存在しなければ、 `assoc`は `false`か、もし与えられていれば defaultを返します。

  例えば、 式 `assoc (y, [[x,1], [y,2], [z,3]])`の場合、 `assoc`関数はリスト `[[y,1],[x,2]]`の左辺に `y`を探して、第二項にそれを見つけて、 `2`を返します。 `assoc (z, [[x,1], [z,2], [z,3]])`の場合、 探索は `z`で始まる最初の項で止まり、 `2`を返します。 `assoc(x, [[y,1]])`の場合、マッチする要素がないので、 `assoc`は `false`を返します。

      (%i1) assoc (y, [[x,1], [y,2],[z,3]]);
      (%o1)                           2
      (%i2) assoc (z, [[x,1], [z,2], [z,3]]);
      (%o2)                           2
      (%i3) assoc (x, [[y,1]]);
      (%o3)                         false

  Categories: Lists · Expressions

関数: cons
`cons` (expr, list)
`cons` (expr_1, expr_2)

  `cons (expr, list)` は 要素 exprを一番目の要素とし、listの要素が続くように構成された新しいリストを返します。 これは Lisp言語の構成演算 "cons"に類似したものです。

  Maxima 関数 `cons`は二番目の引数がリストとは別のものであるような使い方もでき、役に立つかもしれません。 この場合、 `cons (expr_1, expr_2)`は expr_2と同じ演算子に引数 `cons(expr_1, args(expr_2))`を渡した式を返します。 例:

      (%i1) cons(a,[b,c,d]);
      (%o1)                     [a, b, c, d]
      (%i2) cons(a,f(b,c,d));
      (%o2)                     f(a, b, c, d)

  一般的にはリストでないものに適用した `cons`は意味がありません。 例えば、'^'は3つの引数を取れないので `cons(a,b^c)`は違法な式になります。

  `inflag`が真の時、 `cons`は式の内部構造上に演算し、そうでなければ `cons`は表示形式上に演算します。 特に `inflag`が真の時、リストでないものに適用されあt `cons`は時々驚くべき結果を与えます; 例えば

      (%i1) cons(a,-a), inflag : true;
                                       2
      (%o1)                         - a
      (%i2) cons(a,-a), inflag : false;
      (%o2)                           0

  Categories: Lists · Expressions

関数: copylist (list)

  リスト listのコピーを返します。

  Categories: Lists

関数: create_list (form, x_1, list_1, …, x_n, list_n)

  list_1の要素それぞれにバインドされた x_1で、 また、それぞれのバインドに対して、 x_2を list_2の要素それぞれにバインドして、... それらのバインドを使って formを評価することによって リストを生成します。 結果の要素の数はそれぞれのリストの要素の数の積です。 それぞれの変数 x_iは実際に、シンボルでなければいけません。ーそれは評価されません。 リスト引数は繰り返しの始めに一度だけ評価されます。

      (%i1) create_list(x^i,i,[1,3,7]);
                       3   7
      (%o1)       [x, x , x ]

  二重の繰り返しで:

      (%i1) create_list([i,j],i,[a,b],j,[e,f,h]);
      (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]

  list_iの代わりに、 それぞれが数に評価される２つの引数を供給することもできます。 これらは繰り返しの下限と上限になります。

      (%i1) create_list([i,j],i,[1,2,3],j,1,i);
      (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]

  `j`変数の範囲やリストは `i`の現在値に依存することができることに注意してください。

  Categories: Lists

関数: delete
`delete` (expr_1, expr_2)
`delete` (expr_1, expr_2, n)

  `delete(expr_1, expr_2)`は、 expr_2から そのトップレベル演算子の引数のうち、 expr_1と("="で決定される意味で)同じ引数を取り除きます。 "="は、同値ではなく、形式的な同一をテストすることに注意してください。 部分式の引数には影響しないことにも注意してください。

  expr_1はアトムか、非アトムの式を取り得ます。 expr_2は任意の非アトムの式を取り得ます。 `delete`は新しい式を返します; expr_2を変更しません。

  `delete(expr_1, expr_2, n)`は、

  expr_2から そのトップレベル演算子の引数のうち、 expr_1と同じ最初の n個の引数を取り除きます。 もしそんな引数が n個より少ないなら、 該当するすべての引数が取り除かれます。

  例:

  リストから要素を削除。

      (%i1) delete (y, [w, x, y, z, z, y, x, w]);
      (%o1)                  [w, x, z, z, x, w]

  和から項を削除。

      (%i1) delete (sin(x), x + sin(x) + y);
      (%o1)                         y + x

  積から因子を削除。

      (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
      (%o1)                (u - w) (u - y) (u - z)

  任意の式から引数を削除。

      (%i1) delete (a, foo (a, b, c, d, a));
      (%o1)                     foo(b, c, d)

  削除する引数の数を制限。

      (%i1) delete (a, foo (a, b, a, c, d, a), 2);
      (%o1)                    foo(b, c, d, a)

  引数が expr_1と同じかどうかは"="で決定されます。 `equal`ですが、"="でない引数は取り除かれません。

      (%i1) [is(equal(0, 0)), is(equal(0, 0.0)), is(equal(0, 0b0))];
      (%o1)                  [true, true, true]
      (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
      (%o2)                 [true, false, false]
      (%i3) delete (0, [0, 0.0, 0b0]);
      (%o3)                     [0.0, 0.0b0]
      (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
      (%o4)                         true
      (%i5) is ((x + y)*(x - y) = x^2 - y^2);
      (%o5)                         false
      (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
                                    2    2
      (%o6)                       [x  - y ]

  Categories: Lists · Expressions

関数: eighth (expr)

  式またはリスト exprの8番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: endcons
`endcons` (expr, list)
`endcons` (expr_1, expr_2)

  `endcons (expr, list)`はlistの要素に exprが続くように構成された新しいリストを返します。 Maxima 関数 `endcons`は二番目の引数がリストとは別のものであるような使い方もでき、役に立つかもしれません。 この場合、 `endcons (expr_1, expr_2)`は expr_2と同じ演算子に引数 `endcons(expr_1, args(expr_2))`を渡した式を返します。 例:

      (%i1) endcons(a,[b,c,d]);
      (%o1)                     [b, c, d, a]
      (%i2) endcons(a,f(b,c,d));
      (%o2)                     f(b, c, d, a)

  一般的にはリストでないものに適用した `endcons`は意味がありません。 例えば、'^'は3つの引数を取れないので `endcons(a,b^c)`は違法な式になります。

  `inflag`が真の時、 `endcons`は式の内部構造上に演算し、そうでなければ `endcons`は表示形式上に演算します。 特に `inflag`が真の時、リストでないものに適用されあt `endcons`は時々驚くべき結果を与えます; 例えば

      (%i1) endcons(a,-a), inflag : true;
                                       2
      (%o1)                         - a
      (%i2) endcons(a,-a), inflag : false;
      (%o2)                           0

  Categories: Lists · Expressions

関数: fifth (expr)

  式またはリスト exprの5番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: first (expr)

  リストの最初の要素、行列の最初の行、和の最初の項などに帰着する、 exprの最初の部分を返します:

      (%i1) matrix([1,2],[3,4]);
                                         [ 1  2 ]
      (%o1)                              [      ]
                                         [ 3  4 ]
      (%i2) first(%);
      (%o2)                              [1,2]
      (%i3) first(%);
      (%o3)                              1
      (%i4) first(a*b/c+d+e/x);
                                         a b
      (%o4)                              ---
                                          c
      (%i5) first(a=b/c+d+e/x);
      (%o5)                              a

  `first`とその関連関数 `rest`と `last`は、 入力時にタイプした形式ではなく、 exprの表示形式上で機能することに注意してください。 しかしながら、もし変数 `inflag`が `true`に設定されているなら、 これらの関数は exprの内部形式を見ます。 これが違いを生む理由の1つは、整理器が式を並べ替えするからです:

      (%i1) x+y;
      (%o1)                              y+1
      (%i2) first(x+y),inflag : true;
      (%o2)                              x
      (%i3) first(x+y),inflag : false;
      (%o3)                              y

  関数 `second` … `tenth`は 入力引数の二番目から十番目の部分をもたらします。

  `firstn`, `part`も参照してください。

  Categories: Lists · Expressions

関数: firstn (expr, count)

  もし exprが少なくとも count個の引数を持つなら、 exprの、先頭から count個のの引数を返します。 もし expr count個より少ないの引数を持つなら、 exprを返します。

  exprはノンアトミックな任意の式です。 exprがリスト以外の何かの時、 `firstn`は exprと同じ演算子を持つ式を返します。 countは非負整数でなければいけません。

  `firstn`は、 式の内部形式が処理されるか(`inflag`がtrueの時)、 表示形式が処理されるか(`inflag`がfalseの時)を決定する 大域フラグ `inflag`に従います。

  `firstn(expr, 1)`は最初の引数を含むノンアトミックな式を返しますが、 それは、 最初の引数そのものを返す `first(expr)`とは同じでないことに 注意してください。

  `lastn`, `rest`も参照してください。

  例:

  もし exprが少なくとも count個の引数を持つなら、 `firstn`は 、exprの先頭から count個の要素を返します。

      (%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)];
      (%o1)        [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
      (%i2) firstn (mylist, 0);
      (%o2)                          []
      (%i3) firstn (mylist, 1);
      (%o3)                          [1]
      (%i4) firstn (mylist, 2);
      (%o4)                        [1, a]
      (%i5) firstn (mylist, 7);
      (%o5)               [1, a, 2, b, 3, x, 4 - y]

  もし expr count個より少ないの引数を持つなら、 exprを返します。

      (%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)];
      (%o1)        [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
      (%i2) firstn (mylist, 100);
      (%o2)        [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]

  exprはノンアトミックな任意の式です。

      (%i1) myfoo : foo(1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
      (%o1)      foo(1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
      (%i2) firstn (myfoo, 4);
      (%o2)                    foo(1, a, 2, b)
      (%i3) mybar : bar[m, n](1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
      (%o3)    bar    (1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
                  m, n
      (%i4) firstn (mybar, 4);
      (%o4)                  bar    (1, a, 2, b)
                                m, n
      (%i5) mymatrix : genmatrix (lambda ([i, j], 10*i + j), 10, 4) $
      (%i6) firstn (mymatrix, 3);
                             [ 11  12  13  14 ]
                             [                ]
      (%o6)                  [ 21  22  23  24 ]
                             [                ]
                             [ 31  32  33  34 ]

  `firstn`は大域フラグ `inflag`に従います。

      (%i1) myexpr : a + b + c + d + e;
      (%o1)                   e + d + c + b + a
      (%i2) firstn (myexpr, 3), inflag=true;
      (%o2)                       c + b + a
      (%i3) firstn (myexpr, 3), inflag=false;
      (%o3)                       e + d + c

  `firstn(expr, 1)`は `first(expr)`と同じじゃないことに注意してください。。

      (%i1) firstn ([w, x, y, z], 1);
      (%o1)                          [w]
      (%i2) first ([w, x, y, z]);
      (%o2)                           w

  Categories: Lists · Expressions

関数: fourth (expr)

  式またはリスト exprの4番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: join (l, m)

  リストlとmの要素を交互に含む新しいリストを生成します。 結果は、要素 `[l[1], m[1], l[2], m[2], ...]`を持ちます。 リスト lと mは、任意のタイプの要素を含めます。

  もしリストの長さが違ったら、 `join`は長いリストの要素を無視します。

  もし lか mがリストでなかったら、 Maximaは文句を言います。

  `append`も参照してください。

  例:

      (%i1) L1: [a, sin(b), c!, d - 1];
      (%o1)                [a, sin(b), c!, d - 1]
      (%i2) join (L1, [1, 2, 3, 4]);
      (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
      (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
      (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]

  Categories: Lists

関数: last (expr)

  expr最後の(項、行、要素など）部分を返します。

  `lastn`も参照してください。

  Categories: Lists · Expressions

関数: lastn (expr, count)

  もし exprが少なくとも count個の引数をもつなら、 exprの後ろからcount個の引数を返します。 もし exprが count個より少ない引数をもつなら、 exprを返します。

  exprはノンアトミックな任意の式です。 exprがリスト以外の何かの時、 `lastn`はexprと同じ演算子を持つ式を返します。 countは非負の整数でなければいけません。

  `lastn`は 式の内部形式が処理されるか(`inflag`がtrueの時)、 表示形式が処理されるか(`inflag`がfalseの時)を決定する 大域フラグ `inflag`に従います。

  Note that `lastn(expr, 1)`は最後の引数を含むノンアトミックな式を返しますが、 それは、 最後の引数自体を返す `last(expr)`とは同じでないことに注意してください。

  `firstn`と `rest`も参照してください。

  例:

  もし exprが少なくとも count個の引数をもつなら、 exprの後ろからcount個の要素を返します。

      (%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)];
      (%o1)        [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
      (%i2) lastn (mylist, 0);
      (%o2)                          []
      (%i3) lastn (mylist, 1);
      (%o3)                    [2 z + sin(u)]
      (%i4) lastn (mylist, 2);
      (%o4)                 [4 - y, 2 z + sin(u)]
      (%i5) lastn (mylist, 7);
      (%o5)         [a, 2, b, 3, x, 4 - y, 2 z + sin(u)]

  もし exprが count個より少ない引数をもつなら、 exprを返します。

      (%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)];
      (%o1)        [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
      (%i2) lastn (mylist, 100);
      (%o2)        [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]

  exprはノンアトミックな任意の式です。

      (%i1) myfoo : foo(1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
      (%o1)      foo(1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
      (%i2) lastn (myfoo, 4);
      (%o2)            foo(3, x, 4 - y, 2 z + sin(u))
      (%i3) mybar : bar[m, n](1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
      (%o3)    bar    (1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
                  m, n
      (%i4) lastn (mybar, 4);
      (%o4)          bar    (3, x, 4 - y, 2 z + sin(u))
                        m, n
      (%i5) mymatrix : genmatrix (lambda ([i, j], 10*i + j), 10, 4) $
      (%i6) lastn (mymatrix, 3);
                           [ 81   82   83   84  ]
                           [                    ]
      (%o6)                [ 91   92   93   94  ]
                           [                    ]
                           [ 101  102  103  104 ]

  `lastn`は大域フラグ `inflag`に従います。

      (%i1) myexpr : a + b + c + d + e;
      (%o1)                   e + d + c + b + a
      (%i2) lastn (myexpr, 3), inflag=true;
      (%o2)                       e + d + c
      (%i3) lastn (myexpr, 3), inflag=false;
      (%o3)                       c + b + a

  `lastn(expr, 1)`は `last(expr)`と同じでないことに注意してください。

      (%i1) lastn ([w, x, y, z], 1);
      (%o1)                          [z]
      (%i2) last ([w, x, y, z]);
      (%o2)                           z

  Categories: Lists · Expressions

関数: length (expr)

  (デフォルトでは) exprの外部(表示)形式の部分の数を返します。 リストに関しては、これは要素の数を返し、 行列に関しては行数であり、 和に関しては項数です。 (`dispform`を参照してください。)

  `length`コマンドは `inflag`スイッチに影響されます。 だから例えば、 `length(a/(b*c));`は、 (`exptdispflag`が `true`と仮定して) もし `inflag`が `false`なら2を与えますが、 もし `inflag`が `true`なら3を与えます。 (内部表現は本質的には `a*b^-1*c^-1`です。)

  リストの長さを決定するには通常リストの要素の数に比例する時間が必要です。 なので、もしループの中でリストの長さを使っているなら、ループの外で長さを計算させれば 劇的にパフォーマンスが改善されるかもしれません。

  Categories: Lists · Expressions

オプション変数: listarith

  デフォルト値: `true` - もし `false`なら、 リストを伴う任意の算術演算が抑制されるようになります; `true`の時、リスト-行列演算では、 リストが行列に変換されるようになり、いつも行列の結果をもたらすよう連鎖します。 しかしながら、リスト-リスト演算はリストを返します。

  Categories: Lists · Global flags

関数: listp (expr)

  もし exprがリストなら `true`、 そうでなければ `false`を返します。

  Categories: Lists · Predicate functions

関数: lreduce
`lreduce` (F, s)
`lreduce` (F, s, s_0)

  2項関数 Fを合成で n項関数に拡張します。 sはリストです。

  `lreduce(F, s)`は `F(... F(F(s_1, s_2), s_3), ... s_n)`を返します。 オプション引数 s_0を与えた時には、 結果は `lreduce(F, cons(s_0, s))`と同値です。

  関数 Fはリストのleftmost要素に最初に適用されるので "lreduce"という名前です。

  `rreduce`, `xreduce`, `tree_reduce`も参照してください。

  例:

  オプション引数なしの `lreduce`。

      (%i1) lreduce (f, [1, 2, 3]);
      (%o1)                     f(f(1, 2), 3)
      (%i2) lreduce (f, [1, 2, 3, 4]);
      (%o2)                  f(f(f(1, 2), 3), 4)

  オプション引数ありの `lreduce`。

      (%i1) lreduce (f, [1, 2, 3], 4);
      (%o1)                  f(f(f(4, 1), 2), 3)

  組み込み2項演算子に適用された `lreduce`。 `/`は除算演算子です。

      (%i1) lreduce ("^", args ({a, b, c, d}));
                                     b c d
      (%o1)                       ((a ) )
      (%i2) lreduce ("/", args ({a, b, c, d}));
                                      a
      (%o2)                         -----
                                    b c d

  Categories: Lists

関数: makelist
`makelist` ()
`makelist` (expr, n)
`makelist` (expr, i, i_max)
`makelist` (expr, i, i_0, i_max)
`makelist` (expr, i, i_0, i_max, step)
`makelist` (expr, x, list)

  一番目の形 `makelist ()`は空のリストを生成します。 二番目の形 `makelist (expr)`は exprを1つの要素とするリストを生成します。 `makelist (expr, n)`は exprから生成される n個の要素のリストを生成します。

  最も一般的な形 `makelist (expr, i, i_0, i_max, step)`は i_0から i_1に等しい `j`に対して `ev (expr, i=j)`が以下の数列の要素 `j`に 適用された時得られる要素のリストを返します: i_0, i_0 + step, i_0 + 2*step, ..., ただし、|j|は|i_max|以下。

  増分 stepは(正でも負でも)数であったり、式であったりします。 もし省略されたら、デフォルト値 1が使われます。 もし i_0と stepの両方が省略されたら、 それらはデフォルト値 1を取ります。

  `makelist (expr, x, list)`は、 1から `length (list)`に等しい `j`に対して、 `j`番目の要素が `ev (expr, x=list[j])`に等しい リストを返します。

  例:

      (%i1) makelist (concat (x,i), i, 6);
      (%o1)               [x1, x2, x3, x4, x5, x6]
      (%i2) makelist (x=y, y, [a, b, c]);
      (%o2)                 [x = a, x = b, x = c]
      (%i3) makelist (x^2, x, 3, 2*%pi, 2);
      (%o3)                        [9, 25]
      (%i4) makelist (random(6), 4);
      (%o4)                     [2, 0, 2, 5]
      (%i5) flatten (makelist (makelist (i^2, 3), i, 4));
      (%o5)        [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]
      (%i6) flatten (makelist (makelist (i^2, i, 3), 4));
      (%o6)         [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]

  Categories: Lists

関数: member (expr_1, expr_2)

  もし `args(expr_2)`の中のある要素aに対して `is(expr_1 = a)`なら `true`を返し、 そうでなければ `false`を返します。

  `expr_2`は通常リストです。 その場合、 `args(expr_2) = expr_2`かつ `expr_2`の中のある要素 aに対して、 `is(expr_1 = a)`であることがテストです。

  `member`は `expr_2`の引数の部分を検査しません。 だから、 たとえ `expr_1`が `expr_2`のある引数の部分であっても `false`を返すかもしれません。

  `elementp`も参照してください。

  例:

      (%i1) member (8, [8, 8.0, 8b0]);
      (%o1)                         true
      (%i2) member (8, [8.0, 8b0]);
      (%o2)                         false
      (%i3) member (b, [a, b, c]);
      (%o3)                         true
      (%i4) member (b, [[a, b], [b, c]]);
      (%o4)                         false
      (%i5) member ([b, c], [[a, b], [b, c]]);
      (%o5)                         true
      (%i6) F (1, 1/2, 1/4, 1/8);
                                     1  1  1
      (%o6)                     F(1, -, -, -)
                                     2  4  8
      (%i7) member (1/8, %);
      (%o7)                         true
      (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
      (%o8)                         true

  Categories: Lists · Expressions · Predicate functions

関数: ninth (expr)

  式またはリスト exprの9番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: pop (list)

  `pop`は、リスト listから最初の要素を取り除き、返します。 引数 listは空でないリストにバインドされたmapatomでなければいけません。 もし引数 listが空でないリストにバインドされてなければ、 Maximaはエラーシグナルを発します。

  例には `push`も参照してください。

  Categories: Lists · Expressions

関数: push (item, list)

  `push`は項目 itemをリスト listの先頭に追加し、 新しいリストのコピーを返します。 2番目の引数 listは空でないリストにバインドされたmapatomでなければいけません。 1番目の引数 itemは任意のMaximaシンボルや式が使えます。

  もし引数 listが空でないリストにバインドされてなければ、 Maximaはエラーシグナルを発します。

  リストから最初の項目を取り除くには `pop`を参照してください。

  例:

      (%i1) ll: [];
      (%o1)                          []
      (%i2) push (x, ll);
      (%o2)                          [x]
      (%i3) push (x^2+y, ll);
                                       2
      (%o3)                      [y + x , x]
      (%i4) a: push ("string", ll);
                                           2
      (%o4)                  [string, y + x , x]
      (%i5) pop (ll);
      (%o5)                        string
      (%i6) pop (ll);
                                        2
      (%o6)                        y + x
      (%i7) pop (ll);
      (%o7)                           x
      (%i8) ll;
      (%o8)                          []
      (%i9) a;
                                           2
      (%o9)                  [string, y + x , x]

  Categories: Lists · Expressions

関数: rest
`rest` (expr, n)
`rest` (expr)

  もし nが正なら、 頭の n個の要素を取り除いた exprを返し、 もし nが負なら、 お尻の `- n`個の要素を取り除いた exprを返します。 もし nが1なら、省略できます。 1番目の引数 exprは、リスト、行列、他の式を取り得ます。 exprがアトムの時、 `rest`はエラーシグナルを発します; exprが 空のリストで `partswitch`が真の時、 `rest`は `end`を返します。

  `rest`を `f(a,b,c)`のような式に適用すると `f(b,c)`を返します。 一般的には、リストでないものに `rest`を適用することは意味がありません。 例えば、 '^'は2つの引数を要求するので、 `rest(a^b)`はエラーメッセージを出力します。 `args(a^b)`は `[a,b]`を返し、 `op(a^b)`は ^を返すので 関数 `args`と `op`も役に立つかもしれません

  `firstn`と `lastn`も参照してください。

      (%i1) rest(a+b+c);
      (%o1) b+a
      (%i2) rest(a+b+c,2);
      (%o2) a
      (%i3) rest(a+b+c,-2);
      (%o3) c

  Categories: Lists · Expressions

関数: reverse (list)

  list のメンバーの順序を逆にします。 (メンバー自身は変えません。) `reverse`は、一般式でも機能します。 例えば、 `reverse(a=b);`は `b=a`を与えます。

  Categories: Lists · Expressions

関数: rreduce
`rreduce` (F, s)
`rreduce` (F, s, s_{n + 1})

  2項関数 Fを合成でn項関数に拡張します。 sはリストです。

  `rreduce(F, s)`は `F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n)))`を返します。 オプション引数 s_{n + 1}を与えた時には、 結果は `rreduce(F, endcons(s_{n + 1}, s))`と同値です。

  関数 Fはリストのrightmost要素に最初に適用されるので "rreduce"という名前です。

  `lreduce`, `tree_reduce`, `xreduce`も参照してください。

  例:

  オプション引数なしの `rreduce`。

      (%i1) rreduce (f, [1, 2, 3]);
      (%o1)                     f(1, f(2, 3))
      (%i2) rreduce (f, [1, 2, 3, 4]);
      (%o2)                  f(1, f(2, f(3, 4)))

  オプション引数ありの `rreduce`。

      (%i1) rreduce (f, [1, 2, 3], 4);
      (%o1)                  f(1, f(2, f(3, 4)))

  組み込み2項演算子に適用された `rreduce`。 `/`は除算演算子です。

      (%i1) rreduce ("^", args ({a, b, c, d}));
                                       d
                                      c
                                     b
      (%o1)                         a
      (%i2) rreduce ("/", args ({a, b, c, d}));
                                     a c
      (%o2)                          ---
                                     b d

  Categories: Lists

関数: second (expr)

  式またはリスト exprの二番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: seventh (expr)

  式またはリスト exprの7番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: sixth (expr)

  式またはリスト exprの6番目の項を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: sort
`sort` (L, P)
`sort` (L)

  `sort(L, P)`は ２つの引数の述語論理`P`に従ってリストLをソートします。 `P`はLの要素上で厳密で弱い順序を定義します。 もし `[P(a, b)`が `true`なら、 結果の中で`a`は `b`より先に現れます。 もし `[P(a, b)`も `[P(b, a)`も `true`でないなら、 `a`と `b`は等価で、入力と同じ順序で結果の中に現れます。 すなわち、 `sort`は安定ソートです。

  もしLの中のある要素で `[P(a, b)`と `[P(b, a)`両方とも `true`なら、 Pは有効なソート述語論理ではなく、結果は未定義です。 もし `P(a, b)`が `true`でも `false`でもない別の何かなら、 `sort`はエラーをシグナルします。

  述語論理は関数や２値中値演算子の名前として、`lambda`式として指定されるかもしれません。 もし演算子名として指定するなら、名前を「ダブルクォート」でくくらなければいけません。

  ソートされたリストは新しいオブジェクトとして返されます; Lは変更されません。

  `sort(L)`は `(L, ordderlessp)`と同値です。

  `orderlessp`が決定するように、デフォルトのソート順序は昇順です。 述語論理 `ordergreatp`はリストを降順にソートします。

  Maximaのアトムと式すべては、`orderlessp`と `ordergreatp`の下で比較可能です。

  演算子 `<`と `>`は数、定数、定数式を大きさで順序付けします。 `orderlessp`と `ordergreatp`は数、定数、定数式を大きさで順序付けしないことに注意してください。

  述語論理 `ordermagnitudep`は `<`と同じように 数や定数、定数式の順序付けし、 他の要素すべてを`orderlessp`と同じように順序付けします。

  例:

  `sort`は リストの要素上で厳密で弱い順序を定義する 引数2つの述語論理`P`に従ってリストLをソートします。

      (%i1) sort ([1, a, b, 2, 3, c], 'orderlessp);
      (%o1)                  [1, 2, 3, a, b, c]
      (%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp);
      (%o2)                  [c, b, a, 3, 2, 1]

  述語論理は関数や２値中値演算子の名前として、`lambda`式として指定されるかもしれません。 もし演算子名として指定するなら、名前を「ダブルクォート」でくくらなければいけません。

      (%i1) L : [[1, x], [3, y], [4, w], [2, z]];
      (%o1)           [[1, x], [3, y], [4, w], [2, z]]
      (%i2) foo (a, b) := a[1] > b[1];
      (%o2)                 foo(a, b) := a  > b
                                          1    1
      (%i3) sort (L, 'foo);
      (%o3)           [[4, w], [3, y], [2, z], [1, x]]
      (%i4) infix (">>");
      (%o4)                          >>
      (%i5) a >> b := a[1] > b[1];
      (%o5)                  (a >> b) := a  > b
                                          1    1
      (%i6) sort (L, ">>");
      (%o6)           [[4, w], [3, y], [2, z], [1, x]]
      (%i7) sort (L, lambda ([a, b], a[1] > b[1]));
      (%o7)           [[4, w], [3, y], [2, z], [1, x]]

  `sort(L)`は `sort(L, orderlessp)`と同値です。

      (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
      (%o1)             [a, 2 b, - 5, 7, %e + 1, %pi]
      (%i2) sort (L);
      (%o2)             [- 5, 7, %e + 1, %pi, a, 2 b]
      (%i3) sort (L, 'orderlessp);
      (%o3)             [- 5, 7, %e + 1, %pi, a, 2 b]

  `orderlessp`が決めるようにデフォルトのソート順は昇順です。 述語論理 `ordergreatp`はリストを降順にソートします。

      (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
      (%o1)             [a, 2 b, - 5, 7, %e + 1, %pi]
      (%i2) sort (L);
      (%o2)             [- 5, 7, %e + 1, %pi, a, 2 b]
      (%i3) sort (L, 'ordergreatp);
      (%o3)             [2 b, a, %pi, %e + 1, 7, - 5]

  Maximaのアトムや式すべては `orderlessp`や `ordergreatp`の下で比較可能です。

      (%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
                                                       5
      (%o1)  [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a]
                                                       2
      (%i2) sort (L, orderlessp);
                      5
      (%o2)  [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)]
                      2
      (%i3) sort (L, ordergreatp);
                                                        5
      (%o3)  [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17]
                                                        2

  演算子 `<`と `>`は数、定数、定数式を大きさで順序付けします。 `orderlessp`と `ordergreatp`は数、定数、定数式を大きさで順序付けしないことに注意してください。

      (%i1) L : [%pi, 3, 4, %e, %gamma];
      (%o1)                [%pi, 3, 4, %e, %gamma]
      (%i2) sort (L, ">");
      (%o2)                [4, %pi, 3, %e, %gamma]
      (%i3) sort (L, ordergreatp);
      (%o3)                [%pi, %gamma, %e, 4, 3]

  述語論理 `ordermagnitudep`は `<`と同じように 数や定数、定数式の順序付けし、 他の要素すべてを`orderlessp`と同じように順序付けします。

      (%i1) L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
      (%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0,
                                                                 1.0b0]
      (%i2) sort (L, ordermagnitudep);
      (%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
                                                           %i + 1, 2 x]
      (%i3) sort (L, orderlessp);
      (%o3) [0, 1, 1.0, 2, 3, sin(1), 1.0b0, %e, %i, %i + 1, inf,
                                                             minf, 2 x]

  Categories: Lists

関数: sublist (list, p)

  述語論理`p`が`true`を返すlistの要素のリストを返します。

  例:

      (%i1) L: [1, 2, 3, 4, 5, 6];
      (%o1)                  [1, 2, 3, 4, 5, 6]
      (%i2) sublist (L, evenp);
      (%o2)                       [2, 4, 6]

  Categories: Lists

関数: sublist_indices (L, P)

  述語論理 `maybe(P(x))`が `true`を返す、 リスト Lの要素 `x`のインデックスを返します; これは `false`はもちろん `unknown`も除外します。 Pは関数名かラムダ式を取り得ます。 Lはリストリテラルでなければいけません。

  例:

      (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
                             lambda ([x], x='b));
      (%o1)                     [2, 3, 7, 9]
      (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
      (%o2)                  [1, 2, 3, 4, 7, 9]
      (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
                             identity);
      (%o3)                       [1, 4, 5]
      (%i4) assume (x < -1);
      (%o4)                       [x < - 1]
      (%i5) map (maybe, [x > 0, x < 0, x < -2]);
      (%o5)                [false, true, unknown]
      (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
      (%o6)                          [2]

  Categories: Lists

関数: tenth (expr)

  式かリスト exprの10番目の項目を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: third (expr)

  式かリスト exprの3番目の項目を返します。 詳細は `first`を参照してください。

  Categories: Lists · Expressions

関数: tree_reduce
`tree_reduce` (F, s)
`tree_reduce` (F, s, s_0)

  2項関数 Fを合成で n項関数に拡張します。 sは集合かリストです。

  `tree_reduce`は以下と同値です: 隣同士の要素のペアに Fを適用して、 新たなリスト `[F(s_1, s_2), F(s_3, s_4), ...]`を形成します。 もし要素の数が奇数なら最後の要素はそのままリストに載ります。 そして、リストが要素1つになるまで繰り返します。その結果が戻り値です。

  オプション引数 s_0を与えた時には、 結果は `tree_reduce(F, cons(s_0, s))`と同値です。

  浮動小数点数の加算に関して、 `tree_reduce`は、`rreduce`や `lreduce`よりも小さな丸め誤差の和を返すことができます。

  sの要素と部分的な結果を深さ最小2分木で整理できるので、 "tree_reduce"という名前です。

  例:

  偶数個の要素を持つリストに適用された `tree_reduce`。

      (%i1) tree_reduce (f, [a, b, c, d]);
      (%o1)                  f(f(a, b), f(c, d))

  奇数個の要素を持つリストに適用された `tree_reduce`。

      (%i1) tree_reduce (f, [a, b, c, d, e]);
      (%o1)               f(f(f(a, b), f(c, d)), e)

  Categories: Sets · Lists

関数: unique (L)

  リスト Lの重複しない要素を返します。

  Lの要素すべてが重複しない時、 `unique`は、 L自身ではなく、 Lの浅いコピーを返します。

  もし Lがリストでないなら、 `unique`はLを返します。

  例:

      (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
      (%o1)              [1, 2, %e, %pi, [1], b + a]

関数: xreduce
`xreduce` (F, s)
`xreduce` (F, s, s_0)

  関数 Fを合成で n項関数に拡張します。 もしくはもし Fが既に n項関数なら Fを sに適用します。 Fがn項関数でない時、 `xreduce`は `lreduce`と同じです。 sは集合かリストです。

  n項関数と知られている関数は 加算 `+`, 乗算 `*`, `and`, `or`, `max`, `min`, と `append`です。 `declare(F, nary)`で関数が宣言されているかもしれません。 これらの関数に関して、 `xreduce`は `rreduce`や `lreduce`より速いことが期待できます。

  オプション引数 s_0を与えた場合、 結果は `xreduce(s, cons(s_0, s))`と同値です。

  浮動小数点加算は厳密には結合的ではないです; それはともかく sが浮動小数点数を含む時、 `xreduce`は Maximaの n項加算を適用します。

  例:

  n項関数と知られている関数へ適用された `xreduce`。 `F`はすべての引数で1度だけ呼ばれます。

      (%i1) declare (F, nary);
      (%o1)                         done
      (%i2) F ([L]) := L;
      (%o2)                      F([L]) := L
      (%i3) xreduce (F, [a, b, c, d, e]);
      (%o3)                    [a, b, c, d, e]

  n項関数と知られていない関数へ適用された `xreduce`。 `G`は2つの引数を与えられながら数回呼ばれます。

      (%i1) G ([L]) := L;
      (%o1)                      G([L]) := L
      (%i2) xreduce (G, [a, b, c, d, e]);
      (%o2)                 [[[[a, b], c], d], e]
      (%i3) lreduce (G, [a, b, c, d, e]);
      (%o3)                 [[[[a, b], c], d], e]

  Categories: Sets · Lists

c h---------------------------------------------------

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.5.3 Performance considerations for Lists

リストは要素を追加したり削除したりする効率的な方法を提供します。 最終的な次元を知ることなしに生成することができます。 リストはリストをコピーしたり扱ったりする効率的な手段を提供します。 また、入れ子のリストは厳格に矩形である必要はありません。 宣言された配列に対するこれらの利点の代わりに、 リスト内のランダムな要素へのアクセスに必要な時間がランダムな要素の頭からの距離におおよそ比例するかもしれない欠点があります。 しかし、リストをスタックやFIFOとして使うことで、リストを効率的に横断することは可能です:

    (%i1) l:[Test,1,2,3,4];
    (%o1)                  [Test, 1, 2, 3, 4]
    (%i2) while l # [] do
       disp(pop(l));
                                  Test

                                    1

                                    2

                                    3

                                    4

    (%o2)                         done

別のより速い例:

    (%i1) l:[Test,1,2,3,4];
    (%o1)                  [Test, 1, 2, 3, 4]
    (%i2) for i in l do
       disp(pop(l));
                                  Test

                                    1

                                    2

                                    3

                                    4

    (%o2)                         done

`reverse ()`を使ってリストを逆順にすれば、 リストの最後の要素から横断を始められます。 もし長いリストの要素を違った順序で処理するなら、 初めにリストを宣言された配列に変換することで パフォーマンスを向上させられるかもしれません。

`for`ループの終了条件は毎回テストされることにも注意してください。 それは、 終了条件で `length`の結果が使われるなら、それはキャッシュすべきということを意味します:

    (%i1) l:makelist(i,i,1,100000)$
    (%i2) lngth:length(l);
    (%o2)                        100000
    (%i3) x:1;
    (%o3)                           1
    (%i4) for i:1 thru lngth do
        x:x+1$
    (%i5) x;
    (%o5)                        100001

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.6 Arrays

Maximaは3つの配列のような構成体をサポートします:

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.7 Functions and Variables for Arrays

関数: array
`array` (name, dim_1, …, dim_n)
`array` (name, type, dim_1, …, dim_n)
`array` ([name_1, …, name_m], dim_1, …, dim_n)

  n次元の配列を生成します。 nは5以下を取り得ます。 i番目の次元のための添字は0からdim_iまで動く整数です。

  `array (name, dim_1, ..., dim_n)`は 一般的な配列を生成します。

  `array (name, type, dim_1, ..., dim_n)`は 指定されたタイプの要素を持つ配列を生成します。 typeには 制限されたサイズの整数には`fixnum`が使え、 また、浮動小数点には`flonum`が使えます。

  `array ([name_1, ..., name_m], dim_1, ..., dim_n)` は同じ次元のm個の配列を生成します。

  `arraymake`と `arrayinfo`, `make_array`も参照してください。

  Categories: Arrays

関数: arrayapply (A, [i_1, … i_n])

  `A [i_1, ..., i_n]`を評価します。 ここで、Aは配列、i_1, …, i_nは整数です。

  これは、最初の引数が関数の代わりに配列だということを除いて、 `apply`を連想させます。

  Categories: Expressions · Arrays

関数: arrayinfo (A)

  配列Aに関する情報を返します。 引数Aは、宣言配列、`hashed array`、`memoizing function`、または添字付き関数を取り得ます。

  宣言配列では、 `arrayinfo`は、 アトム`declared`と、次元数、それぞれの次元のサイズを含むリストを返します。 配列の要素は、バインドされたものもそうでないものも、`listarray`で返されます。

  未宣言配列(ハッシュド配列)では、 `arrayinfo`は、 アトム`hashed`と、添字の数、値を持つすべての要素の添字を含むリストを返します。 値は `listarray`で返されます。

  `memoizing functions`では、 `arrayinfo`は、 アトム`hashed`と、添字の数、 記憶された関数値がある添字の値すべてを含むリストを返します。 記憶された関数値は、`listarray`で返されます。

  添字付き関数では、 `arrayinfo`は、 アトム`hashed`と、添字の数、 ラムダ式がある添字の値すべてを含むリストを返します。 ラムダ式は `listarray`で返されます。

  `listarray`も参照してください。

  例:

  宣言配列に適用された`arrayinfo`と`listarray`。

      (%i1) array (aa, 2, 3);
      (%o1)                          aa
      (%i2) aa [2, 3] : %pi;
      (%o2)                          %pi
      (%i3) aa [1, 2] : %e;
      (%o3)                          %e
      (%i4) arrayinfo (aa);
      (%o4)                 [declared, 2, [2, 3]]
      (%i5) listarray (aa);
      (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
                                              #####, #####, #####, %pi]

  未宣言配列 (`hashed array`)に適用された`arrayinfo`と`listarray`。

      (%i1) bb [FOO] : (a + b)^2;
                                         2
      (%o1)                       (b + a)
      (%i2) bb [BAR] : (c - d)^3;
                                         3
      (%o2)                       (c - d)
      (%i3) arrayinfo (bb);
      (%o3)               [hashed, 1, [BAR], [FOO]]
      (%i4) listarray (bb);
                                    3         2
      (%o4)                 [(c - d) , (b + a) ]

  `memoizing function`に適用された `arrayinfo`と `listarray`。

      (%i1) cc [x, y] := y / x;
                                           y
      (%o1)                      cc     := -
                                   x, y    x
      (%i2) cc [u, v];
                                      v
      (%o2)                           -
                                      u
      (%i3) cc [4, z];
                                      z
      (%o3)                           -
                                      4
      (%i4) arrayinfo (cc);
      (%o4)              [hashed, 2, [4, z], [u, v]]
      (%i5) listarray (cc);
                                    z  v
      (%o5)                        [-, -]
                                    4  u

  未宣言配列を宣言配列に変換するために `arrayinfo`の使用:

      (%i1) for i:0 thru 10 do a[i]:i^2$
      (%i2) indices:map(first,rest(rest(arrayinfo(a))));
      (%o2)          [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      (%i3) array(A,fixnum,length(indices)-1)$
      (%i4) fillarray(A,map(lambda([x],a[x]),indices))$
      (%i5) listarray(A);
      (%o5)       [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

  添字付き関数に適用された`arrayinfo`と`listarray`。

      (%i1) dd [x] (y) := y ^ x;
                                           x
      (%o1)                     dd (y) := y
                                  x
      (%i2) dd [a + b];
                                          b + a
      (%o2)                  lambda([y], y     )
      (%i3) dd [v - u];
                                          v - u
      (%o3)                  lambda([y], y     )
      (%i4) arrayinfo (dd);
      (%o4)             [hashed, 1, [b + a], [v - u]]
      (%i5) listarray (dd);
                               b + a                v - u
      (%o5)      [lambda([y], y     ), lambda([y], y     )]

  Categories: Arrays

関数: arraymake (A, [i_1, …, i_n])

  式`A[i_1, ..., i_n]`を返します。 結果は未評価の配列参照です。

  `arraymake`は、 戻り値は、未評価関数コールの代わりに未評価の配列参照だということを除いて、 `funmake`を連想させます。

  例:

      (%i1) arraymake (A, [1]);
      (%o1)                          A
                                      1
      (%i2) arraymake (A, [k]);
      (%o2)                          A
                                      k
      (%i3) arraymake (A, [i, j, 3]);
      (%o3)                       A
                                   i, j, 3
      (%i4) array (A, fixnum, 10);
      (%o4)                           A
      (%i5) fillarray (A, makelist (i^2, i, 1, 11));
      (%o5)                           A
      (%i6) arraymake (A, [5]);
      (%o6)                          A
                                      5
      (%i7) ''%;
      (%o7)                          36
      (%i8) L : [a, b, c, d, e];
      (%o8)                    [a, b, c, d, e]
      (%i9) arraymake ('L, [n]);
      (%o9)                          L
                                      n
      (%i10) ''%, n = 3;
      (%o10)                          c
      (%i11) A2 : make_array (fixnum, 10);
      (%o11)          {Lisp Array:  #(0 0 0 0 0 0 0 0 0 0)}
      (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o12)          {lisp Array:  #(1 2 3 4 5 6 7 8 9 10)}
      (%i13) arraymake ('A2, [8]);
      (%o13)                         A2
                                       8
      (%i14) ''%;
      (%o14)                          9

  Categories: Expressions · Arrays

システム変数: arrays

  デフォルト値: `[]`

  `arrays`は割り当てられた配列のリストです。 これらは、 `array`で宣言された配列、 (リストや配列としてまだ宣言されていない要素に何かを割り当てられた) 暗黙の定義で構成された `hashed arrays`、 `:=`と`define`で定義された `memoizing functions`を含みます。 `make_array`で定義された配列は含まれません。

  `array`, `arrayapply`, `arrayinfo`, `arraymake`, `fillarray`, `listarray`, `rearray`も参照してください。

  例:

      (%i1) array (aa, 5, 7);
      (%o1)                          aa
      (%i2) bb [FOO] : (a + b)^2;
                                         2
      (%o2)                       (b + a)
      (%i3) cc [x] := x/100;
                                         x
      (%o3)                      cc  := ---
                                   x    100
      (%i4) dd : make_array ('any, 7);
      (%o4)       {Lisp Array:  #(NIL NIL NIL NIL NIL NIL NIL)}
      (%i5) arrays;
      (%o5)                     [aa, bb, cc]

  Categories: Arrays · Global variables

関数: arraysetapply (A, [i_1, …, i_n], x)

  xを`A[i_1, ..., i_n]`に割り当てます。 ここで、Aは配列で、i_1, …, i_nは整数です。

  `arraysetapply`は引数を評価します。

  Categories: Expressions · Arrays

関数: fillarray (A, B)

  配列AをBから埋めます。 ここで、Bはリストか配列です。

  もし生成時に特定のタイプがAのために宣言されたら、 その同じタイプの要素でだけ埋めることができます; もし違ったタイプの要素をコピーする試みがなされたらエラーです。

  もし配列AとBの次元が違ったら、 Aは行優先順で埋められます。 もしBの中の要素が十分でないなら、 Aの残りを埋めるのに最後の要素が使われます。 もし多すぎるなら、残りは無視されます。

  `fillarray`は最初の引数を返します。

  例:

  9個の要素の配列を生成し、リストから埋めます。

      (%i1) array (a1, fixnum, 8);
      (%o1)                          a1
      (%i2) listarray (a1);
      (%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
      (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
      (%o3)                          a1
      (%i4) listarray (a1);
      (%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]

  配列を埋めるのに要素が足らない時、 最後の要素が繰り返されます。 要素が多すぎる時、余分の要素は無視されます。

      (%i1) a2 : make_array (fixnum, 8);
      (%o1)             {Lisp Array:  #(0 0 0 0 0 0 0 0)}
      (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
      (%o2)             {Lisp Array:  #(1 2 3 4 5 5 5 5)}
      (%i3) fillarray (a2, [4]);
      (%o3)             {Lisp Array:  #(4 4 4 4 4 4 4 4)}
      (%i4) fillarray (a2, makelist (i, i, 1, 100));
      (%o4)             {Lisp Array:  #(1 2 3 4 5 6 7 8)}

  多次元配列は行優先順に埋められます。

      (%i1) a3 : make_array (fixnum, 2, 5);
      (%o1)        {Lisp Array:  #2A((0 0 0 0 0) (0 0 0 0 0))}
      (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o2)        {Lisp Array:  #2A((1 2 3 4 5) (6 7 8 9 10))}
      (%i3) a4 : make_array (fixnum, 5, 2);
      (%o3)     {Lisp Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
      (%i4) fillarray (a4, a3);
      (%o4)     {Lisp Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))}

  Categories: Arrays

関数: listarray (A)

  配列Aの要素のリストを返します。 引数Aは、配列、未宣言配列 (`hashed array`)、 `memoizing function` 、添字付き関数を取り得ます。

  要素は行優先順にリストされます。 すなわち、要素は、最初のインデックスに従って振り分けられ、次に二番目のインデックスに従って、などなど。 インデックス値の振り分け順は、 `orderless`が確立する順と同じです。

  未宣言配列(`hashed arrays`)や、 `memoizing functions`、添字付き関数では、 要素は`arrayinfo`が返すインデックス値に対応します。

  一般的な配列のバインドされていない要素(すなわち、`fixnum`でも`flonum`でもない要素)は、 `#####`として返されます。 `fixnum`配列または`flonum`配列のバイドされていない要素は、 それぞれ0または0.0として返されます。 ハッシュ配列、 `memoizing functions`、添字付き関数のバインドされていない要素は返されません。

  例:

  宣言配列に適用された`listarray`と`arrayinfo`。

      (%i1) array (aa, 2, 3);
      (%o1)                          aa
      (%i2) aa [2, 3] : %pi;
      (%o2)                          %pi
      (%i3) aa [1, 2] : %e;
      (%o3)                          %e
      (%i4) listarray (aa);
      (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
                                              #####, #####, #####, %pi]
      (%i5) arrayinfo (aa);
      (%o5)                 [declared, 2, [2, 3]]

  未宣言配列(`hashed array`)に適用された`listarray`と`arrayinfo`。

      (%i1) bb [FOO] : (a + b)^2;
                                         2
      (%o1)                       (b + a)
      (%i2) bb [BAR] : (c - d)^3;
                                         3
      (%o2)                       (c - d)
      (%i3) listarray (bb);
                                    3         2
      (%o3)                 [(c - d) , (b + a) ]
      (%i4) arrayinfo (bb);
      (%o4)               [hashed, 1, [BAR], [FOO]]

  `memoizing function`に適用された`listarray`と`arrayinfo`。

      (%i1) cc [x, y] := y / x;
                                           y
      (%o1)                      cc     := -
                                   x, y    x
      (%i2) cc [u, v];
                                      v
      (%o2)                           -
                                      u
      (%i3) cc [4, z];
                                      z
      (%o3)                           -
                                      4
      (%i4) listarray (cc);
                                    z  v
      (%o4)                        [-, -]
                                    4  u
      (%i5) arrayinfo (cc);
      (%o5)              [hashed, 2, [4, z], [u, v]]

  添字付き関数に適用された`listarray`と`arrayinfo`。

      (%i1) dd [x] (y) := y ^ x;
                                           x
      (%o1)                     dd (y) := y
                                  x
      (%i2) dd [a + b];
                                          b + a
      (%o2)                  lambda([y], y     )
      (%i3) dd [v - u];
                                          v - u
      (%o3)                  lambda([y], y     )
      (%i4) listarray (dd);
                               b + a                v - u
      (%o4)      [lambda([y], y     ), lambda([y], y     )]
      (%i5) arrayinfo (dd);
      (%o5)             [hashed, 1, [b + a], [v - u]]

  Categories: Arrays

関数: make_array (type, dim_1, ..., dim_n)

  Lisp配列を生成し、返します。 typeは、`any`, `flonum`, `fixnum`, `hashed`, `functional`を取り得ます。 n個のインデックスがあり、 i番目のインデックスは0からdim_i - 1まで動きます。

  `make_array`の`array`に対する利点は、 戻り値が名前を持たないことであり、 一旦、それへのポインタが消えると、それも消えます。 例えば、もし`y: make_array (...)`なら、 `y`は領域を取るオブジェクトを指しますが、 `y: false`の後、`y`はそのオブジェクトをもはや指さないので、 オブジェクトはガーベッジコレクトされることができます。

  例:

      (%i1) A1 : make_array (fixnum, 10);
      (%o1)           {Lisp Array:  #(0 0 0 0 0 0 0 0 0 0)}
      (%i2) A1 [8] : 1729;
      (%o2)                         1729
      (%i3) A1;
      (%o3)          {Lisp Array:  #(0 0 0 0 0 0 0 0 1729 0)}
      (%i4) A2 : make_array (flonum, 10);
      (%o4) {Lisp Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
      (%i5) A2 [2] : 2.718281828;
      (%o5)                      2.718281828
      (%i6) A2;
      (%o6)
           {Lisp Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
      (%i7) A3 : make_array (any, 10);
      (%o7) {Lisp Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
      (%i8) A3 [4] : x - y - z;
      (%o8)                     (- z) - y + x
      (%i9) A3;
      (%o9) {Lisp Array: #(NIL NIL NIL NIL
                     ((MPLUS SIMP) $X ((MTIMES SIMP) -1 $Y) ((MTIMES S\
      IMP) -1 $Z))
                     NIL NIL NIL NIL NIL)}
      (%i10) A4 : make_array (fixnum, 2, 3, 5);
      (%o10) {Lisp Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0))
                       ((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
      (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
      (%o11) {Lisp Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 1\
      5))
                       ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29\
       30)))}
      (%i12) A4 [0, 2, 1];
      (%o12)                         12

  Categories: Arrays

関数: rearray (A, dim_1, ..., dim_n)

  配列の次元を変えます。 新しい配列は 行優先順に古いものの配列で埋められます。 もし古い配列が小さすぎるなら、 残りの要素は、 配列のタイプに依って、 `false`, `0.0`または`0`で埋められます。 配列のタイプは変えられません。

  Categories: Arrays

関数: remarray
`remarray` (A_1, …, A_n)
`remarray` (all)

  配列と関数に関連づけられた配列を削除し、占められた領域を開放します。 引数は、宣言配列、 `hashed arrays`、配列関数、添字付き関数を取り得ます。

  `remarray (all)`は、 グローバルリスト`arrays`の中の項目すべてを削除します。

  もし `memoizing function`のキャッシュをクリアすることが望ましいなら、この関数を使うことが必要になるかもしれません。

  `remarray`は削除された配列のリストを返します。

  `remarray`はクォートします。

  Categories: Arrays

関数: subvar (x, i)

  添字付き式`x[i]`を評価します。

  `subvar`は引数を評価します。

  `arraymake (x, [i])`は 式`x[i]`を構成しますが、 それを評価はしません。

  例:

      (%i1) x : foo $
      (%i2) i : 3 $
      (%i3) subvar (x, i);
      (%o3)                         foo
                                       3
      (%i4) foo : [aa, bb, cc, dd, ee]$
      (%i5) subvar (x, i);
      (%o5)                          cc
      (%i6) arraymake (x, [i]);
      (%o6)                         foo
                                       3
      (%i7) ''%;
      (%o7)                          cc

  Categories: Expressions · Arrays

関数: subvarp (expr)

  もしexprが例えば`a[i]`のように添字された変数なら、`true`を返します。

  Categories: Predicate functions

オプション変数: use_fast_arrays

  デフォルト値: `false`

  `use_faset_arrays`が `true`の時、 `array`が宣言した配列はプロパティでなく値であり、 非宣言配列 (`hashed arrays`)は Lispハッシュ配列として実装されます。

  `use_faset_arrays`が `false`の時、 非宣言の配列と `array`が宣言した配列はプロパティであり、 非宣言の配列は Maxima自身のハッシュ配列実装で実装されます。

  `use_fast_arrays`が切り替えるコードは必ずしもデフォルトのものより速くはないことに注意してください; `make_array`が生成した配列は`use_fast_arrays`に影響されません。

  `translate_fast_arrays`も参照してください。

  Categories: Arrays · Global flags

オプション変数: translate_fast_arrays

  デフォルト値: `false`

  `translate_fast_arrays`が `true`の時、 Maxima-to-Lispトランスレータが、 `use_fast_arrays`が `true`であるかのように 配列がプロパティでなく値であると仮定したコードを生成します。

  `translate_fast_arrays`が `false`の時、 Maxima-to-Lispトランスレータが、 `use_fast_arrays`が `false`であるかのように 配列がプロパティであると仮定したコードを生成します。

  Categories: Arrays · Translation flags and variables

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.8 Structures

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.8.1 Introduction to Structures

Maximaは構造体と呼ばれる簡単なデータ集合体を提供します。 構造体は 引数が名前(フィールド名)によって識別され、式全体が演算子(構造体名)によって識別される式です。 フィールド名は任意の式を取り得ます。

構造体は`defstruct`関数によって定義されます; グローバル変数`structures`はユーザー定義の構造体のリストです。 関数`new`は構造体のインスタンスを生成します。 `@`演算子はフィールドを参照します。 `kill(S)`は構造体定義Sを取り除き、 `kill(x@ a)`は 構造体インスタンスxのフィールドaをアンバインドします。

(`display2d`を`true`で使う)プリティプリンティングのコンソール表示では、 構造体インスタンスは、 左辺側にフィールド名、右辺側に値の式として表されたそれぞれのフィールドの値と一緒に 表示されます。 (等式は単に表示物です; 値だけが実際に保存されます。) (`grind`を介してか、`display2d`を`false`で使う)1次元表示では 構造体はフィールド名ないで表示されます。

フィールド値はラムダ式でありえますが、フィールド名を関数名として使う方法はありません。 フィールドの値はあるタイプに制約することもできません; 任意のフィールドにはどんな種類の式に割り当てることができます。 フィールドを、違った文脈でアクセス可能にしたり不可能する方法はありません; すべてのフィールドはいつも可視です。

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.8.2 Functions and Variables for Structures

グローバル変数: structures

  `structures`は `defstruct`で定義されたユーザー定義の構造体のリストです。

  Categories: Structures · Global variables

関数: defstruct
`defstruct` (S(a_1, …, a_n))
`defstruct` (S(a_1 = v_1, …, a_n = v_n))

  構造体を定義します。 構造体はシンボルSと関連付けられた名前フィールドのリストa_1, …, a_nです。

  構造体のインスタンスは演算子Sと正確に`n`個の引数を持つただの式です。 `new(S)`は構造体Sの新しいインスタンスを生成します。

  ただのシンボルaである引数はフィールド名を指定します。 等式`a = v`である引数は フィールド名aとデフォルト値vを指定します。 デフォルト値は任意の式を取り得ます。

  `defstruct`は ユーザー定義の構造体のリスト`structures`上にSを入れます。

  `kill(S)`は ユーザー定義の構造体のリストからSを取り除き、構造体定義を取り除きます。

  例:

      (%i1) defstruct (foo (a, b, c));
      (%o1)                    [foo(a, b, c)]
      (%i2) structures;
      (%o2)                    [foo(a, b, c)]
      (%i3) new (foo);
      (%o3)                     foo(a, b, c)
      (%i4) defstruct (bar (v, w, x = 123, y = %pi));
      (%o4)             [bar(v, w, x = 123, y = %pi)]
      (%i5) structures;
      (%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
      (%i6) new (bar);
      (%o6)              bar(v, w, x = 123, y = %pi)
      (%i7) kill (foo);
      (%o7)                         done
      (%i8) structures;
      (%o8)             [bar(v, w, x = 123, y = %pi)]

  Categories: Structures

関数: new
`new` (S)
`new` (S (v_1, …, v_n))

  `new`は構造体の新しいインスタンスを生成します。

  `new(S)`は 構造体Sの新しいインスタンスを生成します。 それぞれのフィールドは、もしデフォルト値があればデフォルト値を割り当てられ、 もしデフォルト値が構造体定義で指定されなかったなら、割り当てなしになります。

  `new(S(v_1, ..., v_n))`は フィールドが値v_1, …, v_nに割り当てられた 構造体Sの新しいインスタンスを生成します。

  例:

      (%i1) defstruct (foo (w, x = %e, y = 42, z));
      (%o1)              [foo(w, x = %e, y = 42, z)]
      (%i2) new (foo);
      (%o2)               foo(w, x = %e, y = 42, z)
      (%i3) new (foo (1, 2, 4, 8));
      (%o3)            foo(w = 1, x = 2, y = 4, z = 8)

  Categories: Structures

演算子: @

  `@`構造体フィールドアクセス演算子です。 式`x@ a`は 構造体インスタンスxのフィールドaの値を参照します。 フィールド名は評価されません。

  もしxのフィールドaが値を割り当てられていないなら、 `x@ a`はそれ自身に評価されます。

  `kill(x@ a)`は xのフィールド値aを値を取り除きます。

  例:

      (%i1) defstruct (foo (x, y, z));
      (%o1)                    [foo(x, y, z)]
      (%i2) u : new (foo (123, a - b, %pi));
      (%o2)           foo(x = 123, y = a - b, z = %pi)
      (%i3) u@z;
      (%o3)                          %pi
      (%i4) u@z : %e;
      (%o4)                          %e
      (%i5) u;
      (%o5)            foo(x = 123, y = a - b, z = %e)
      (%i6) kill (u@z);
      (%o6)                         done
      (%i7) u;
      (%o7)              foo(x = 123, y = a - b, z)
      (%i8) u@z;
      (%o8)                          u@z

  フィールド名は評価されません。

      (%i1) defstruct (bar (g, h));
      (%o1)                      [bar(g, h)]
      (%i2) x : new (bar);
      (%o2)                       bar(g, h)
      (%i3) x@h : 42;
      (%o3)                          42
      (%i4) h : 123;
      (%o4)                          123
      (%i5) x@h;
      (%o5)                          42
      (%i6) x@h : 19;
      (%o6)                          19
      (%i7) x;
      (%o7)                    bar(g, h = 19)
      (%i8) h;
      (%o8)                          123

  Categories: Structures · Operators

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by 市川雄二 on October, 4 2018 using texi2html 1.76.