[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

# 5. Data Types and Structures

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 5.1 Numbers

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 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

### Floating point numbers

Maximaには2つのタイプの浮動小数点数があります。 1番目はただ "float"とだけ呼ぶものです(が、曖昧さを避けるため、この章では以後、"machine float"と呼びます)。 これは、背後にあるlispのDOUBLE-FLOATタイプに保存されます。DOUBLE-FLOATタイプはIEEE 754倍精度浮動小数点とほとんど同じです。 リテラルの浮動小数点数をタイプするには、(例えば、 `0.01`というように)ただ10進文字列をタイプするか、 (`1e-2` や `0.1e-1`というぐあいに)明示的な指数と合わせてタイプしします。

Maximaでの浮動小数点数の2番目は "bigfloat"と呼ぶものです。 bigfloatは、machine floatと同様に仮数と指数を保存しますが、指数が任意精度の整数です。 なので、任意に大きな、あるいは小さな数を表現できます。 ユーザーは、bigfloat算術の精度をカスタマイズできます。(それは仮数の範囲を選ぶことに対応します。) 詳しくは `fpprec` を参照してください。 リテラルの bigfloat をタイプするには、前述のような指数記法を使いますが、 `e` の代わりに文字 `b` を使います。 前述の `0.01` の例は、 `1b-2` もしくは `0.01b0` と書くことで bigfloat として入力できます。

現代のコンピュータのプロセッサは専用のハードを内蔵しているので、 machine floatを使った計算は bigfloatを使うよりかなり速いです。 これは特にコンパイルされた Maxima コードで顕著です。 しかし、 machine floatはオーバーフローの問題を抱えます。 指数が利用可能なビットで表現できないほど数が大きくなり過ぎると、オーバーフローが起こります。 インタープレトされるコードでは、浮動小数点オーバーフローを起こす計算は、代わりにbigfloat数を生成するのが デフォルトの振る舞いです。 これを設定するには、 `promote_float_to_bigfloat` 変数を参照してください。

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 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

オプション変数: promote_float_to_bigfloat

  デフォルト値: `true`

  `promote_float_to_bigfloat` がtrueの時、 いつも浮動小数点オーバーフローを起こる浮動小数点計算の結果はどんなものでも、bigfloatに置き換えられます。 自動置き換えは、インタープレトされるコードでのみ行われることに注意してください: コンパイルされたコードには影響しません。

  この自動変換は便利なことが多いですが、いくつかの場合役に立たない可能性があります。 例えば、`fpprec`が浮動小数点数の精度より低い時、実際には精度の低下を起こします。 この振る舞いをディセーブルにするには、 `promote_float_to_bigfloat` を false に設定してください。

  Categories: Numerical evaluation

オプション変数: 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

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 5.2 Strings

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 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

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 5.2.2 Functions and Variables for Strings

関数: concat (arg_1, arg_2, …)

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

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

      (%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`と違い、引数はアトムである必要はありません。

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

  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

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 5.3 Constants

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 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

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 5.5 Lists

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 5.5.1 Introduction to Lists

リストはMaximaとLispにとって基本的な構成要素です。 配列、ハッシュテーブル、数以外のデータタイプすべては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))

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 5.5.2 Functions and Variables for Lists

演算子: [
演算子: ]

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

  `[`と`]`は、リスト、配列、ハッシュ配列、配列関数の添字もくくります。

  例:

      (%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)`をもたらします。

  例を見るには、 `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))];

      `rat' replaced 0.0 by 0/1 = 0.0
      `rat' replaced 0.0B0 by 0/1 = 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の最初の部分を返します。 `first`とその関連関数 `rest`と `last`は、 入力時にタイプした形式ではなく、 exprの表示形式上で機能することに注意してください。 しかしながら、もし変数 `inflag`が `true`に設定されているなら、 これらの関数は exprの内部形式を見ます。 整理器は式を再配置することに注意してください。 例えば、 `first(x+y)`は、 もし `inflag`が `true`なら `x`で、 もし `inflag`が `false`なら `y` です。 (`first(y+x)`は同じ結果を与えます。) 関数 `second` .. `tenth`は 入力引数の二番目から十番目の部分をもたらします。

  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は文句を言います。

  例:

      (%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最後の(項、行、要素など）部分を返します。

  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

関数: 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) 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)

  Categories: Lists · Expressions

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

  もし nが正なら、 頭の n個の要素を取り除いた exprを返し、 もし nが負なら、 お尻の `- n`個の要素を取り除いた exprを返します。 もし nが1なら、省略できます。 1番目の引数 exprは、リスト、行列、他の式を取り得ます。 exprが mapatomの時、 `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`も役に立つかもしれません

      (%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

関数: 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, %e, %i, %i + 1, inf, minf, sin(1),
                                                            1.0b0, 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

関数: 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]

関数: tenth (expr)

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

  Categories: Lists · Expressions

関数: third (expr)

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

  Categories: Lists · Expressions

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 5.6 Arrays

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 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個の配列を生成します。

  もしユーザーが対応する配列を宣言する前に添字付き変数に割り当てたら、 未宣言配列が生成されます。 (ハッシュコーディングが添字上でされるので)別名ハッシュド配列と知られる未宣言配列は、 宣言配列よりもっと一般的です。 ユーザーは最大サイズを宣言せず、さらなる要素が値に割り当てられる時、ハッシュすることで それらは動的に成長します。 未宣言配列の添字は数である必要すらありません。 しかしながら、 配列がむしろ疎でないなら、 未宣言のまま放っておくより、可能な時に宣言した方がおそらく効率的です。 `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は、宣言配列、未宣言(ハッシュド)配列、配列関数、または添字付き関数を取り得ます。

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

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

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

  添字付き関数では、、 `arrayinfo`は、 returns a list comprising the アトム`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]

  未宣言(ハッシュド)配列に適用された`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) ]

  配列関数に適用された`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`と`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)          {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)          {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`で宣言された配列、 (なにかw配列要素に割り当てられた)陰の定義で構成されたハッシュド配列、 `:=`と`define`で定義された配列関数を含みます。 `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)       {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)             {Array:  #(0 0 0 0 0 0 0 0)}
      (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
      (%o2)             {Array:  #(1 2 3 4 5 5 5 5)}
      (%i3) fillarray (a2, [4]);
      (%o3)             {Array:  #(4 4 4 4 4 4 4 4)}
      (%i4) fillarray (a2, makelist (i, i, 1, 100));
      (%o4)             {Array:  #(1 2 3 4 5 6 7 8)}

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

      (%i1) a3 : make_array (fixnum, 2, 5);
      (%o1)        {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)        {Array:  #2A((1 2 3 4 5) (6 7 8 9 10))}
      (%i3) a4 : make_array (fixnum, 5, 2);
      (%o3)     {Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
      (%i4) fillarray (a4, a3);
      (%o4)     {Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))}

  Categories: Arrays

関数: listarray (A)

  配列Aの要素のリストを返します。 引数Aは、宣言配列、未宣言(ハッシュド)配列、配列関数、添字付き関数を取り得ます。

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

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

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

  例:

  宣言配列に適用された`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]]

  未宣言(ハッシュド)配列に適用された`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]]

  配列関数に適用された`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)           {Array:  #(0 0 0 0 0 0 0 0 0 0)}
      (%i2) A1 [8] : 1729;
      (%o2)                         1729
      (%i3) A1;
      (%o3)          {Array:  #(0 0 0 0 0 0 0 0 1729 0)}
      (%i4) A2 : make_array (flonum, 10);
      (%o4) {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)
           {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) {Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
      (%i8) A3 [4] : x - y - z;
      (%o8)                      - z - y + x
      (%i9) A3;
      (%o9) {Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
       -1 $Y) ((MTIMES SIMP) -1 $Z))
        NIL NIL NIL NIL NIL)}
      (%i10) A4 : make_array (fixnum, 2, 3, 5);
      (%o10) {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) {Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
          ((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)

  配列と関数に関連づけられた配列を削除し、占められた領域を開放します。 引数は、宣言配列、未宣言(ハッシュド)配列、配列関数、添字付き関数を取り得ます。

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

  もしハッシュド配列の中の値を再定義することが望ましいなら、この関数を使うことが必要になるかもしれません。

  `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`が宣言した配列はプロパティでなく値であり、 非宣言の配列は Lispハッシュテーブルとして実装されます。

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

  `use_fast_arrays`は`make_array`が生成した配列には影響しません。

  `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

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 5.8 Structures

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 5.8.1 Introduction to Structures

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

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

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

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

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

### 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

[ << ] | [ >> ] |  |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

この文書は市川 雄二によって10月, 18 2015にtexi2html 1.76を用いて生成されました。