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

# 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

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

### 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`を返します。

  ·

  Categories: Predicate functions

関数: float (expr)

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

  ·

  Categories: Numerical evaluation ·Evaluation flags

オプション変数: float2bf

  デフォルト値: `true`

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

  ·

  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`は1にはできません。

  ·

  Categories: Numerical evaluation ·Display flags and variables

関数: integerp (expr)

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

  もし引数がシンボルならたとえ引数が宣言された整数でも、 `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`を返します。

  もし引数がシンボルなら、 たとえ引数が`%pi`や`%i`のようなシンボリックな数でも、また、 `even`, `odd`, `integer`, `rational`, `irrational`, `real`, `imaginary`, `complex`のいずれかに宣言されていても、 `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;
      (%o1) (-2)^0.75

      (%i2) (-2)^0.75,numer_pbranch:true;
      (%o2) 1.189207115002721*%i-1.189207115002721

      (%i3) (-2)^(3/4);
      (%o3) (-1)^(3/4)*2^(3/4)

      (%i4) (-2)^(3/4),numer;
      (%o4) 1.681792830507429*(-1)^0.75

      (%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`を返します。

  ·

  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);
                                     1
      (%o2)                          --
                                     10
      (%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));
                                    x    28
      (%o7)                     sin(-- + --)
                                    10   5

  使用例:

      (%i1) unitfrac(r) := block([uf : [], q],
          if not(ratnump(r)) then
             error("The input to 'unitfrac' must be a rational number"),
          while r # 0 do (
              uf : cons(q : 1/ceiling(1/r), uf),
              r : r - q),
          reverse(uf))$
      (%o1) unitfrac(r) := block([uf : [], q],
      if not ratnump(r) then
         error("The input to 'unitfrac' must be a rational number"),
                                        1
      while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
                                            1
                                    ceiling(-)
                                            r
      reverse(uf))
      (%i2) unitfrac (9/10);
                                  1  1  1
      (%o2)                      [-, -, --]
                                  2  3  15
      (%i3) apply ("+", %);
                                     9
      (%o3)                          --
                                     10
      (%i4) unitfrac (-9/10);
                                        1
      (%o4)                       [- 1, --]
                                        10
      (%i5) apply ("+", %);
                                      9
      (%o5)                         - --
                                      10
      (%i6) unitfrac (36/37);
                              1  1  1  1    1
      (%o6)                  [-, -, -, --, ----]
                              2  3  8  69  6808
      (%i7) apply ("+", %);
                                     36
      (%o7)                          --
                                     37

  ·

  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
    in this string.";
    (%o3) Embedded line termination
    in this string.
    (%i4) s_4 : "Ignore the \
    line termination \
    characters in \
    this string.";
    (%o4) Ignore the line termination characters in this string.
    (%i5) stringdisp : false;
    (%o5)                         false
    (%i6) s_1;
    (%o6)                   This is a string.
    (%i7) stringdisp : true;
    (%o7)                         true
    (%i8) s_1;
    (%o8)                  "This is a string."

·

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 (key, list, default)
関数: assoc (key, list)

  この関数は 形式 `[x,y,z,...]`の入力 listの左辺の中で keyを探します。 ここで listの要素のそれぞれは二項演算子と２つの要素の式です。 例えば、 `x=1`, `2^3`, `[a,b]`など。 最初のオペランドに対して keyがチェックされます。 もし `key`が見つかったら、 `assoc`は二番目のオペランドを返します。 もし `key`が見つからなかったら、 default値を返します。 defaultはオプションで、省略すると `false`に設定されます。

  ·

  Categories: Lists ·Expressions

関数: cons (expr, list)

  最初の要素として要素 exprで構成され、 listの要素が続く新しいリストを返します。 `cons`は他の式上でも機能します。 例えば、 `cons(x, f(a,b,c));` -> `f(x,a,b,c)`。

  ·

  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 (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 (expr, list)

  exprが続く `list`の要素から成る新しいリストを返します。 `endcons`は一般式上でも機能します。 例えば、 `endcons(x, f(a,b,c));` -> `f(a,b,c,x)`。

  ·

  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 (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はリストそのものではなく、リストにバインドされたシンボルでなければいけません。

  もし引数 listがリストにバインドされていないかリストが空なら、 Maximaはエラーメッセージを生成します。

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

  この関数を使うには、追加のパッケージ "basic"をロードしなければいけません。 `load("basic")`はこの関数をロードします。

  ·

  Categories: Lists ·Expressions

関数: push (item, list)

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

  もし引数 listがリストにバインドされていないかリストが空なら、 Maximaはエラーメッセージを生成します。

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

  `load("basic")`はこの関数をロードします。

  例:

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

  ·

  Categories: Lists ·Expressions

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

  もし nが正なら、 頭の n個の要素を取り除いた exprを返し、 もし nが負なら、 お尻の `- n`個の要素を取り除いた exprを返します。 もし nが1なら、省略できます。 exprは、リスト、行列、他の式を取り得ます。

  ·

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

  もし`true`なら、配列の２つのタイプだけが認識されます:

  1. 整数でインデックスされたいくつかの次元を持つができ、 情報入力としてLispまたはMaximaオブジェクトを保てるart-q配列(Common Lispでのt)。 そんな配列を構成するには、 `a:make_array(any,3,4);`を入力してください。 `a`は、12個の枠を持つ配列を値として持ち、インデックスはゼロベースです
  2. もし`b[x+1]:y^2`を実行したら、生成された配列のデフォルト値でハッシュテーブル配列 (`b`はまだ配列でもリストでも行列でもありません – もしこれらの１つなら、`x+1`は、art-q配列やリスト、行列の有効な添字ではないので 、エラーが起こります。) (キーとしても知られている)インデックスは、任意のオブジェクトを取り得ます。 一度の１つのキーだけを取ります((`b[x+1,u]:y`は`u`を無視します。)。 参照は、`b[x+1] ==> y^2`によってされます。 もちろん、キーは、例えば、 `b[[x+1,u]]:y`が有効なように リストを取り得ます。 これは古いMaximaハッシュ配列と非互換ですが、コンシングを保ちます。

  配列をシンボルの値として記憶することの利点は、 関数のローカル変数についての普通の慣例が配列にも適用することです。 ハッシュテーブルタイプは、 Maximaハッシャの古いタイプよりも 少ないコンシングを使い、もっと効率的です。 翻訳され、コンパイルされたコードに関する一貫した振る舞いを得るためには、 `translate_fast_arrays`を`true`に設定してください。

  ·

  Categories: Arrays ·Global flags

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

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

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

この文書は市川 雄二によって2012年12月月12日にtexi2html 1.82を用いて生成されました。