| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 5.1 Numbers | ||
| 5.2 Strings | ||
| 5.3 Constants | ||
| 5.5 Lists | ||
| 5.6 Arrays | ||
| 5.8 Structures |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 5.1.1 Introduction to Numbers | ||
| 5.1.2 Functions and Variables for Numbers |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Maximaでは複素数式を式の実部と%iかける虚部の足し算で指定します。
例えば、等式 x^2 - 4*x + 13 = 0の根は
2 + 3*%iと 2 - 3*%iです。
複素数式の積の整理は積を展開することで影響を受けるかもしれないことに注意してください。
複素数式の商や根、他の関数の整理は普通、
realpart, imagpart, rectform, polarform,
abs, carg関数を使って達成することができます。
Categories: Complex variables
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
exprの中のすべての数や数の関数を多倍長浮動小数点に変換します。
戻り値の多倍長浮動小数点の有効桁数は、
グローバル変数fpprecによって規定されます。
float2bfがfalseの場合、
浮動小数点が多倍長浮動小数点に変換される時
（精度が落ちることを意味するので）警告メッセージが出力されます。
Categories: Numerical evaluation
もしexprが多倍長浮動小数点数ならtrueを、そうでなければfalseを返します。
Categories: Numerical evaluation · Predicate functions
デフォルト値: 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
デフォルト値: true
bftruncは、非ゼロの多倍長浮動小数点数の中のずるずる続くゼロを表示しないようにします。
例えば、もしbftruncがfalseなら、
bfloat (1)は1.000000000000000B0と表示されます。
そうでなければ、これは、1.0B0と表示されます。
Categories: Numerical evaluation
もし exprが偶数なら trueを、そうでなければ falseを返します。
たとえ exprが evenと宣言されていても
もし exprがシンボルなら、evenpは falseを返します。
Categories: Predicate functions
exprの中の整数、有理数、多倍長浮動小数点を浮動小数点に変換します。
floatはevflagでもあり、
非整数有理数と多倍長浮動小数点を浮動小数点に変換します。
Categories: Numerical evaluation · Evaluation flags
デフォルト値: true
float2bfがfalseの場合、
浮動小数点が多倍長浮動小数点に変換される時、
（これは精度の無駄使いとなるかもしれないので、）
警告メッセージが表示されます。
Categories: Numerical evaluation
もしexprが浮動小数点なら
trueを返し、そうでないなら
falseを返します。
Categories: Numerical evaluation · Predicate functions
デフォルト値: 16
fpprecは多倍長浮動小数点上の代数のための有効桁数です。
fpprecは通常の浮動小数点上の計算に影響を与えません。
bfloatとfpprintprecも参照してください。
Categories: Numerical evaluation
デフォルト値: 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
もし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
デフォルト値: 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
n >= 0かつ nが整数の時だけtrueを返します。
Categories: Package linearalgebra · Predicate functions
もし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は数値の引数を持つ（指数関数を含む）いくつかの数学関数を
浮動小数点に評価するようにします。
数値が与えられた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
デフォルト値: 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
変数x_1, …, x_nを
expr_1, …, expr_nに等しい数値を持つ変数だと宣言します。
もし numerフラグが trueなら、
変数が現れる任意の式にて、数値は評価され、変数に代入されます。
evも参照してください。
式expr_1, …, expr_nは、任意の式を取り得ます。数値である必要はありません。
Categories: Declarations and inferences · Numerical evaluation
もし expが奇数リテラルであれば trueを、そうでなければ falseを返します。
たとえ exprが oddと宣言されていても
もし exprがシンボルなら
oddpは falseを返します。
Categories: Predicate functions
デフォルト値: 2.0e-15
オプション変数 bftoratが値 falseを持つ時、
ratepsilonは浮動小数点数を有理数に変換する際に使われる許容誤差です。
例はbftoratを参照してください。
Categories: Numerical evaluation · Rational expressions
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
もしexprが整数リテラルもしくは整数リテラルの比なら trueを返し、
そうでなければ falseを返します。
Categories: Predicate functions · Rational expressions
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 5.2.1 Introduction to Strings | ||
| 5.2.2 Functions and Variables for Strings |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
文字列(クォートされた文字の列)は入力の際にはダブルクォートマーク "で括り、
グローバル変数 stringdispに依存して、クォートマークありだったりなしだったりで
表示されます。
文字列は、埋め込みタブ、改行、キャリッジリターン文字を含む任意の文字を含み得ます。
列 \"は文字通りダブルクォートとして認識され、
\\は文字通りバックスラッシュとして認識されます。
バックスラッシュが行の終わりに現れる時、
バックスラッシュと(改行かキャリッジリターンと改行かいずれかの)行終端を無視します。
そして、文字列は次の行に続きます。
他にバックスラッシュともう一つの文字の組み合わせで特殊なものはありません;
"か, \, 行終端以外の任意の文字の前にバックスラッシュが現れる時、
バックスラッシュは無視されます。
文字列の中に文字リテラルを埋め込むことを除いて
(タブ、改行、キャリッジリターンのような)特殊文字を表す方法はありません。
Maximaでは文字タイプはありません; 文字単体は1文字の文字列として表されます。
stringprocアドオンパッケージは文字列に機能する多くの関数を含みます。
例:
(%i1) s_1 : "This is a string."; (%o1) This is a string. (%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters."; (%o2) Embedded "double quotes" and backslash \ characters. (%i3) s_3 : "Embedded line termination (%o3) Embedded line termination in this string. (%i4) in this string."; (%o4) Ignore the line termination characters in this string. (%i5) s_4 : "Ignore the \ (%o5) false (%i6) line termination \ (%o6) This is a string. (%i7) characters in \ (%o7) true (%i8) this string."; (%o8) "This is a string." (%i9) stringdisp : false; |
Categories: Syntax
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
引数を連結します。 引数はアトムに評価されなければいけません。 もし最初の引数がシンボルなら戻り値はシンボルで、 そうでなければ文字列です。
concatは引数を評価します。
シングルクォート'は評価を抑制します。
sconcatと eval_stringも参照してください。
(%i1) y: 7$
(%i2) z: 88$
(%i3) concat (y, z/2);
(%o3) 744
(%i4) concat ('y, z/2);
(%o4) y44
|
concatによって組み立てられたシンボルは値に割り当てられたり、式の中に現れたりします。
:: (ダブルコロン)割り当て演算子は左辺を評価します。
(%i5) a: concat ('y, z/2);
(%o5) y44
(%i6) a:: 123;
(%o6) 123
(%i7) y44;
(%o7) 123
(%i8) b^a;
y44
(%o8) b
(%i9) %, numer;
123
(%o9) b
|
concat (1, 2)は数のように見えますが、文字列であることに注意してください。
(%i10) concat (1, 2) + 3; (%o10) 12 + 3 |
Categories: Expressions · Strings
引数を文字列に連結します。
concatと違い、引数はアトムである必要はありません。
concatと eval_stringも参照してください。
複雑な文字列変換については printfも参照してください。
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
(%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
|
Another purpose for sconcat is to convert arbitrary objects to strings.
(%i1) sconcat (x); (%o1) x (%i2) stringp(%); (%o2) true |
Categories: Expressions · Strings
exprを、ただまるでタイプされたようにMaximaの線形表記に変換します。
stringの戻り値は文字列であり、
計算の中で使うことはできません。
Categories: Strings
デフォルト値: false
stringdispがtrueの時、
文字列はダブルクォートマークで囲まれて表示されます。
そうでなければクォートマークは表示されません。
関数定義を表示する時はいつも、stringdispは trueです。
例:
(%i1) stringdisp: false$
(%i2) "This is an example string.";
(%o2) This is an example string.
(%i3) foo () :=
print ("This is a string in a function definition.");
(%o3) foo() :=
print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string.";
(%o5) "This is an example string."
|
Categories: Display flags and variables
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 5.4 Functions and Variables for Constants |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
%eはEuler数としても知られる自然対数の基数を表します。
%eの数値は倍精度浮動小数点数2.718281828459045d0です。
Categories: Constants
%iは虚数単位sqrt(- 1)を表します。
Categories: Constants
falseは同じ名前のブーリアン定数を表します。
Maximaは、Lispの値NILでfalseを実装しています。
Categories: Constants
Euler-Macheroni定数0.5772156649015329 ....
Categories: Constants
indは有界で不定の結果を表します。
limitも参照してください。
例:
(%i1) limit (sin(1/x), x, 0); (%o1) ind |
Categories: Constants
infは実数の正の無限大を表します。
Categories: Constants
infinityは複素数の無限大を表します。
Categories: Constants
minfは実数のマイナスの（すなわち負の）無限大を表します。
Categories: Constants
%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の数値は倍精度浮動小数点数3.141592653589793d0です。
Categories: Constants
trueは同じ名前のブーリアン定数を表します。
MaximaはLispの値Tでtrueを実装しています。
Categories: Constants
undは未定義の結果を表します。
limitも参照してください。
例:
(%i1) limit (x*sin(x), x, inf); (%o1) und |
Categories: Constants
zeroaはゼロの上の無限小を表します。
zeroaは式の中で使うことができます。
limitは無限小を含む式を整理します。
例:
limitは無限小を含む式を整理します:
(%i1) limit(zeroa); (%o1) 0 (%i2) limit(x+zeroa); (%o2) x |
Categories: Constants
zerobはゼロの下の無限小を表します。
zerobは式の中で使うことができます。
limitは無限小を含む式を整理します。
Categories: Constants
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 5.5.1 Introduction to Lists | ||
| 5.5.2 Functions and Variables for Lists | ||
| 5.5.3 Performance considerations for Lists |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
リストはMaximaとLispにとって基本的な構成要素です。
配列、 hashed arrays、数以外のデータタイプすべてはLispのリストとして表現されます。
これらのLispのリストは
式 a+2を示すために以下の形式を取ります。
((MPLUS) $A 2) |
Maximaレベルでは中置表記a+2を見ることになるでしょう。
Maximaには、以下のようにプリントされるリストもあります。
[1, 2, 7, x+y] |
これは4要素のリストの場合の例です。 内部的には、これは以下の形式のLispのリストに対応します。
((MLIST) 1 2 7 ((MPLUS) $X $Y)) |
Maxima式のタイプフィールドを意味するフラグはそれ自体リストです。 整理器を通った後、上のリストは以下のようになるでしょう。
((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y)) |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
[と ]は、それぞれ、リストの始まりと終わりをマークします。
[と]は、リスト、配列、 hashed array,、 memoizing functionの添字もくくります。
配列と違い、リストの n番目の要素にアクセスすることは
おおよそ nに比例する時間が必要かもしれないことに注意してください。
See section Performance considerations for Lists.
もし添字された変数の要素がこの名前のリストか配列が宣言される前に書き込まれたら、
リストではなく、 hashed array See section Arrays)が生成されることに注意してください。
例:
(%i1) x: [a, b, c];
(%o1) [a, b, c]
(%i2) x[3];
(%o2) c
(%i3) array (y, fixnum, 3);
(%o3) y
(%i4) y[2]: %pi;
(%o4) %pi
(%i5) y[2];
(%o5) %pi
(%i6) z['foo]: 'bar;
(%o6) bar
(%i7) z['foo];
(%o7) bar
(%i8) g[k] := 1/(k^2+1);
1
(%o8) g := ------
k 2
k + 1
(%i9) g[10];
1
(%o9) ---
101
|
list_1の要素のあとに
list_2の要素が続き、…
という１つのリストを返します。
appendは一般式上でも機能します。
例えば、 append (f(a,b), f(c,d,e));は
f(a,b,c,d,e)をもたらします。
addrow, addcol, joinも参照してください。
例を見るには、 example(append);を実行してください。
Categories: Lists · Expressions
この関数は入力 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 (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
リスト listのコピーを返します。
Categories: Lists
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)は、
expr_2から
そのトップレベル演算子の引数のうち、
expr_1と("="で決定される意味で)同じ引数を取り除きます。
"="は、同値ではなく、形式的な同一をテストすることに注意してください。
部分式の引数には影響しないことにも注意してください。
expr_1はアトムか、非アトムの式を取り得ます。
expr_2は任意の非アトムの式を取り得ます。
deleteは新しい式を返します;
expr_2を変更しません。
delete(expr_1, expr_2, n)は、
expr_2から そのトップレベル演算子の引数のうち、 expr_1と同じ最初の n個の引数を取り除きます。 もしそんな引数が n個より少ないなら、 該当するすべての引数が取り除かれます。
例:
リストから要素を削除。
(%i1) delete (y, [w, x, y, z, z, y, x, w]); (%o1) [w, x, z, z, x, w] |
和から項を削除。
(%i1) delete (sin(x), x + sin(x) + y); (%o1) y + x |
積から因子を削除。
(%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z)); (%o1) (u - w) (u - y) (u - z) |
任意の式から引数を削除。
(%i1) delete (a, foo (a, b, c, d, a)); (%o1) foo(b, c, d) |
削除する引数の数を制限。
(%i1) delete (a, foo (a, b, a, c, d, a), 2); (%o1) foo(b, c, d, a) |
引数が expr_1と同じかどうかは"="で決定されます。
equalですが、"="でない引数は取り除かれません。
(%i1) [is(equal(0, 0)), is(equal(0, 0.0)), is(equal(0, 0b0))];
(%o1) [true, true, true]
(%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
(%o2) [true, false, false]
(%i3) delete (0, [0, 0.0, 0b0]);
(%o3) [0.0, 0.0b0]
(%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
(%o4) true
(%i5) is ((x + y)*(x - y) = x^2 - y^2);
(%o5) false
(%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
2 2
(%o6) [x - y ]
|
Categories: Lists · Expressions
式またはリスト exprの8番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
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
式またはリスト exprの5番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
リストの最初の要素、行列の最初の行、和の最初の項などに帰着する、 exprの最初の部分を返します:
(%i1) matrix([1,2],[3,4]);
[ 1 2 ]
(%o1) [ ]
[ 3 4 ]
(%i2) first(%);
(%o2) [1,2]
(%i3) first(%);
(%o3) 1
(%i4) first(a*b/c+d+e/x);
a b
(%o4) ---
c
(%i5) first(a=b/c+d+e/x);
(%o5) a
|
firstとその関連関数 restと lastは、
入力時にタイプした形式ではなく、 exprの表示形式上で機能することに注意してください。
しかしながら、もし変数 inflagが trueに設定されているなら、
これらの関数は exprの内部形式を見ます。
これが違いを生む理由の1つは、整理器が式を並べ替えするからです:
(%i1) x+y; (%o1) y+1 (%i2) first(x+y),inflag : true; (%o2) x (%i3) first(x+y),inflag : false; (%o3) y |
関数 second … tenthは
入力引数の二番目から十番目の部分をもたらします。
Categories: Lists · Expressions
もし exprが少なくとも count個の引数を持つなら、 exprの、先頭から count個のの引数を返します。 もし expr count個より少ないの引数を持つなら、 exprを返します。
exprはノンアトミックな任意の式です。
exprがリスト以外の何かの時、
firstnは
exprと同じ演算子を持つ式を返します。
countは非負整数でなければいけません。
firstnは、
式の内部形式が処理されるか(inflagがtrueの時)、
表示形式が処理されるか(inflagがfalseの時)を決定する
大域フラグ inflagに従います。
firstn(expr, 1)は最初の引数を含むノンアトミックな式を返しますが、
それは、
最初の引数そのものを返す first(expr)とは同じでないことに
注意してください。
例:
もし exprが少なくとも count個の引数を持つなら、
firstnは
、exprの先頭から count個の要素を返します。
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)] (%i2) firstn (mylist, 0); (%o2) [] (%i3) firstn (mylist, 1); (%o3) [1] (%i4) firstn (mylist, 2); (%o4) [1, a] (%i5) firstn (mylist, 7); (%o5) [1, a, 2, b, 3, x, 4 - y] |
もし expr count個より少ないの引数を持つなら、 exprを返します。
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)] (%i2) firstn (mylist, 100); (%o2) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)] |
exprはノンアトミックな任意の式です。
(%i1) myfoo : foo(1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
(%o1) foo(1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
(%i2) firstn (myfoo, 4);
(%o2) foo(1, a, 2, b)
(%i3) mybar : bar[m, n](1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
(%o3) bar (1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
m, n
(%i4) firstn (mybar, 4);
(%o4) bar (1, a, 2, b)
m, n
(%i5) mymatrix : genmatrix (lambda ([i, j], 10*i + j), 10, 4) $
(%i6) firstn (mymatrix, 3);
[ 11 12 13 14 ]
[ ]
(%o6) [ 21 22 23 24 ]
[ ]
[ 31 32 33 34 ]
|
firstnは大域フラグ inflagに従います。
(%i1) myexpr : a + b + c + d + e; (%o1) e + d + c + b + a (%i2) firstn (myexpr, 3), inflag=true; (%o2) c + b + a (%i3) firstn (myexpr, 3), inflag=false; (%o3) e + d + c |
firstn(expr, 1)は
first(expr)と同じじゃないことに注意してください。。
(%i1) firstn ([w, x, y, z], 1); (%o1) [w] (%i2) first ([w, x, y, z]); (%o2) w |
Categories: Lists · Expressions
式またはリスト exprの4番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
リストlとmの要素を交互に含む新しいリストを生成します。
結果は、要素 [l[1], m[1], l[2], m[2], ...]を持ちます。
リスト lと mは、任意のタイプの要素を含めます。
もしリストの長さが違ったら、
joinは長いリストの要素を無視します。
もし lか mがリストでなかったら、 Maximaは文句を言います。
appendも参照してください。
例:
(%i1) L1: [a, sin(b), c!, d - 1]; (%o1) [a, sin(b), c!, d - 1] (%i2) join (L1, [1, 2, 3, 4]); (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4] (%i3) join (L1, [aa, bb, cc, dd, ee, ff]); (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd] |
Categories: Lists
expr最後の(項、行、要素など）部分を返します。
lastnも参照してください。
Categories: Lists · Expressions
もし exprが少なくとも count個の引数をもつなら、 exprの後ろからcount個の引数を返します。 もし exprが count個より少ない引数をもつなら、 exprを返します。
exprはノンアトミックな任意の式です。
exprがリスト以外の何かの時、
lastnはexprと同じ演算子を持つ式を返します。
countは非負の整数でなければいけません。
lastnは
式の内部形式が処理されるか(inflagがtrueの時)、
表示形式が処理されるか(inflagがfalseの時)を決定する
大域フラグ inflagに従います。
Note that
lastn(expr, 1)は最後の引数を含むノンアトミックな式を返しますが、
それは、
最後の引数自体を返す last(expr)とは同じでないことに注意してください。
例:
もし exprが少なくとも count個の引数をもつなら、 exprの後ろからcount個の要素を返します。
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)] (%i2) lastn (mylist, 0); (%o2) [] (%i3) lastn (mylist, 1); (%o3) [2 z + sin(u)] (%i4) lastn (mylist, 2); (%o4) [4 - y, 2 z + sin(u)] (%i5) lastn (mylist, 7); (%o5) [a, 2, b, 3, x, 4 - y, 2 z + sin(u)] |
もし exprが count個より少ない引数をもつなら、 exprを返します。
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)] (%i2) lastn (mylist, 100); (%o2) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)] |
exprはノンアトミックな任意の式です。
(%i1) myfoo : foo(1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
(%o1) foo(1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
(%i2) lastn (myfoo, 4);
(%o2) foo(3, x, 4 - y, 2 z + sin(u))
(%i3) mybar : bar[m, n](1, a, 2, b, 3, x, 4 - y, 2*z + sin(u));
(%o3) bar (1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
m, n
(%i4) lastn (mybar, 4);
(%o4) bar (3, x, 4 - y, 2 z + sin(u))
m, n
(%i5) mymatrix : genmatrix (lambda ([i, j], 10*i + j), 10, 4) $
(%i6) lastn (mymatrix, 3);
[ 81 82 83 84 ]
[ ]
(%o6) [ 91 92 93 94 ]
[ ]
[ 101 102 103 104 ]
|
lastnは大域フラグ inflagに従います。
(%i1) myexpr : a + b + c + d + e; (%o1) e + d + c + b + a (%i2) lastn (myexpr, 3), inflag=true; (%o2) e + d + c (%i3) lastn (myexpr, 3), inflag=false; (%o3) c + b + a |
lastn(expr, 1)は last(expr)と同じでないことに注意してください。
(%i1) lastn ([w, x, y, z], 1); (%o1) [z] (%i2) last ([w, x, y, z]); (%o2) z |
Categories: Lists · Expressions
(デフォルトでは) exprの外部(表示)形式の部分の数を返します。
リストに関しては、これは要素の数を返し、
行列に関しては行数であり、
和に関しては項数です。
(dispformを参照してください。)
lengthコマンドは inflagスイッチに影響されます。
だから例えば、 length(a/(b*c));は、
(exptdispflagが trueと仮定して)
もし inflagが falseなら2を与えますが、
もし inflagが trueなら3を与えます。
(内部表現は本質的には a*b^-1*c^-1です。)
リストの長さを決定するには通常リストの要素の数に比例する時間が必要です。 なので、もしループの中でリストの長さを使っているなら、ループの外で長さを計算させれば 劇的にパフォーマンスが改善されるかもしれません。
Categories: Lists · Expressions
デフォルト値: true - もし falseなら、
リストを伴う任意の算術演算が抑制されるようになります;
trueの時、リスト-行列演算では、
リストが行列に変換されるようになり、いつも行列の結果をもたらすよう連鎖します。
しかしながら、リスト-リスト演算はリストを返します。
Categories: Lists · Global flags
もし exprがリストなら true、
そうでなければ falseを返します。
Categories: Lists · Predicate functions
2項関数 Fを合成で n項関数に拡張します。 sはリストです。
lreduce(F, s)は
F(... F(F(s_1, s_2), s_3), ... s_n)を返します。
オプション引数 s_0を与えた時には、
結果は lreduce(F, cons(s_0, s))と同値です。
関数 Fはリストのleftmost要素に最初に適用されるので "lreduce"という名前です。
rreduce, xreduce, tree_reduceも参照してください。
例:
オプション引数なしの lreduce。
(%i1) lreduce (f, [1, 2, 3]); (%o1) f(f(1, 2), 3) (%i2) lreduce (f, [1, 2, 3, 4]); (%o2) f(f(f(1, 2), 3), 4) |
オプション引数ありの lreduce。
(%i1) lreduce (f, [1, 2, 3], 4); (%o1) f(f(f(4, 1), 2), 3) |
組み込み2項演算子に適用された lreduce。
/は除算演算子です。
(%i1) lreduce ("^", args ({a, b, c, d}));
b c d
(%o1) ((a ) )
(%i2) lreduce ("/", args ({a, b, c, d}));
a
(%o2) -----
b c d
|
Categories: Lists
一番目の形 makelist ()は空のリストを生成します。
二番目の形 makelist (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
もし
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
式またはリスト exprの9番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
popは、リスト listから最初の要素を取り除き、返します。
引数 listは空でないリストにバインドされたmapatomでなければいけません。
もし引数 listが空でないリストにバインドされてなければ、
Maximaはエラーシグナルを発します。
例には pushも参照してください。
Categories: Lists · Expressions
pushは項目 itemをリスト listの先頭に追加し、
新しいリストのコピーを返します。
2番目の引数 listは空でないリストにバインドされたmapatomでなければいけません。
1番目の引数 itemは任意のMaximaシンボルや式が使えます。
もし引数 listが空でないリストにバインドされてなければ、 Maximaはエラーシグナルを発します。
リストから最初の項目を取り除くには popを参照してください。
例:
(%i1) ll: [];
(%o1) []
(%i2) push (x, ll);
(%o2) [x]
(%i3) push (x^2+y, ll);
2
(%o3) [y + x , x]
(%i4) a: push ("string", ll);
2
(%o4) [string, y + x , x]
(%i5) pop (ll);
(%o5) string
(%i6) pop (ll);
2
(%o6) y + x
(%i7) pop (ll);
(%o7) x
(%i8) ll;
(%o8) []
(%i9) a;
2
(%o9) [string, y + x , x]
|
Categories: Lists · Expressions
もし nが正なら、
頭の n個の要素を取り除いた
exprを返し、
もし nが負なら、
お尻の - n個の要素を取り除いた
exprを返します。
もし nが1なら、省略できます。
1番目の引数 exprは、リスト、行列、他の式を取り得ます。
exprがアトムの時、 restはエラーシグナルを発します;
exprが 空のリストで partswitchが真の時、 restは endを返します。
restを f(a,b,c)のような式に適用すると f(b,c)を返します。
一般的には、リストでないものに restを適用することは意味がありません。
例えば、 '^'は2つの引数を要求するので、
rest(a^b)はエラーメッセージを出力します。
args(a^b)は [a,b]を返し、 op(a^b)は ^を返すので
関数 argsと opも役に立つかもしれません
(%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
list のメンバーの順序を逆にします。
(メンバー自身は変えません。)
reverseは、一般式でも機能します。
例えば、 reverse(a=b);は b=aを与えます。
Categories: Lists · Expressions
2項関数 Fを合成でn項関数に拡張します。 sはリストです。
rreduce(F, s)は
F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n)))を返します。
オプション引数 s_{n + 1}を与えた時には、
結果は
rreduce(F, endcons(s_{n + 1}, s))と同値です。
関数 Fはリストのrightmost要素に最初に適用されるので "rreduce"という名前です。
lreduce, tree_reduce, xreduceも参照してください。
例:
オプション引数なしの rreduce。
(%i1) rreduce (f, [1, 2, 3]); (%o1) f(1, f(2, 3)) (%i2) rreduce (f, [1, 2, 3, 4]); (%o2) f(1, f(2, f(3, 4))) |
オプション引数ありの rreduce。
(%i1) rreduce (f, [1, 2, 3], 4); (%o1) f(1, f(2, f(3, 4))) |
組み込み2項演算子に適用された rreduce。
/は除算演算子です。
(%i1) rreduce ("^", args ({a, b, c, d}));
d
c
b
(%o1) a
(%i2) rreduce ("/", args ({a, b, c, d}));
a c
(%o2) ---
b d
|
Categories: Lists
式またはリスト exprの二番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
式またはリスト exprの7番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
式またはリスト exprの6番目の項を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
sort(L, P)は
２つの引数の述語論理Pに従ってリストLをソートします。
PはLの要素上で厳密で弱い順序を定義します。
もし [P(a, b)が trueなら、
結果の中でaは bより先に現れます。
もし [P(a, b)も [P(b, a)も trueでないなら、
aと bは等価で、入力と同じ順序で結果の中に現れます。
すなわち、 sortは安定ソートです。
もしLの中のある要素で
[P(a, b)と [P(b, a)両方とも trueなら、
Pは有効なソート述語論理ではなく、結果は未定義です。
もし P(a, b)が trueでも falseでもない別の何かなら、
sortはエラーをシグナルします。
述語論理は関数や２値中値演算子の名前として、lambda式として指定されるかもしれません。
もし演算子名として指定するなら、名前を「ダブルクォート」でくくらなければいけません。
ソートされたリストは新しいオブジェクトとして返されます; Lは変更されません。
sort(L)は (L, ordderlessp)と同値です。
orderlesspが決定するように、デフォルトのソート順序は昇順です。
述語論理 ordergreatpはリストを降順にソートします。
Maximaのアトムと式すべては、orderlesspと ordergreatpの下で比較可能です。
演算子 <と >は数、定数、定数式を大きさで順序付けします。
orderlesspと
ordergreatpは数、定数、定数式を大きさで順序付けしないことに注意してください。
述語論理 ordermagnitudepは <と同じように
数や定数、定数式の順序付けし、
他の要素すべてをorderlesspと同じように順序付けします。
例:
sortは
リストの要素上で厳密で弱い順序を定義する
引数2つの述語論理Pに従ってリストLをソートします。
(%i1) sort ([1, a, b, 2, 3, c], 'orderlessp); (%o1) [1, 2, 3, a, b, c] (%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp); (%o2) [c, b, a, 3, 2, 1] |
述語論理は関数や２値中値演算子の名前として、lambda式として指定されるかもしれません。
もし演算子名として指定するなら、名前を「ダブルクォート」でくくらなければいけません。
(%i1) L : [[1, x], [3, y], [4, w], [2, z]];
(%o1) [[1, x], [3, y], [4, w], [2, z]]
(%i2) foo (a, b) := a[1] > b[1];
(%o2) foo(a, b) := a > b
1 1
(%i3) sort (L, 'foo);
(%o3) [[4, w], [3, y], [2, z], [1, x]]
(%i4) infix (">>");
(%o4) >>
(%i5) a >> b := a[1] > b[1];
(%o5) (a >> b) := a > b
1 1
(%i6) sort (L, ">>");
(%o6) [[4, w], [3, y], [2, z], [1, x]]
(%i7) sort (L, lambda ([a, b], a[1] > b[1]));
(%o7) [[4, w], [3, y], [2, z], [1, x]]
|
sort(L)は sort(L, orderlessp)と同値です。
(%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi]; (%o1) [a, 2 b, - 5, 7, %e + 1, %pi] (%i2) sort (L); (%o2) [- 5, 7, %e + 1, %pi, a, 2 b] (%i3) sort (L, 'orderlessp); (%o3) [- 5, 7, %e + 1, %pi, a, 2 b] |
orderlesspが決めるようにデフォルトのソート順は昇順です。
述語論理 ordergreatpはリストを降順にソートします。
(%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi]; (%o1) [a, 2 b, - 5, 7, %e + 1, %pi] (%i2) sort (L); (%o2) [- 5, 7, %e + 1, %pi, a, 2 b] (%i3) sort (L, 'ordergreatp); (%o3) [2 b, a, %pi, %e + 1, 7, - 5] |
Maximaのアトムや式すべては orderlesspや ordergreatpの下で比較可能です。
(%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
5
(%o1) [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a]
2
(%i2) sort (L, orderlessp);
5
(%o2) [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)]
2
(%i3) sort (L, ordergreatp);
5
(%o3) [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17]
2
|
演算子 <と >は数、定数、定数式を大きさで順序付けします。
orderlesspと
ordergreatpは数、定数、定数式を大きさで順序付けしないことに注意してください。
(%i1) L : [%pi, 3, 4, %e, %gamma]; (%o1) [%pi, 3, 4, %e, %gamma] (%i2) sort (L, ">"); (%o2) [4, %pi, 3, %e, %gamma] (%i3) sort (L, ordergreatp); (%o3) [%pi, %gamma, %e, 4, 3] |
述語論理 ordermagnitudepは <と同じように
数や定数、定数式の順序付けし、
他の要素すべてをorderlesspと同じように順序付けします。
(%i1) L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
(%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0,
1.0b0]
(%i2) sort (L, ordermagnitudep);
(%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
%i + 1, 2 x]
(%i3) sort (L, orderlessp);
(%o3) [0, 1, 1.0, 2, 3, sin(1), 1.0b0, %e, %i, %i + 1, inf,
minf, 2 x]
|
Categories: Lists
述語論理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
述語論理 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
式かリスト exprの10番目の項目を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
式かリスト exprの3番目の項目を返します。
詳細は firstを参照してください。
Categories: Lists · Expressions
2項関数 Fを合成で n項関数に拡張します。 sは集合かリストです。
tree_reduceは以下と同値です:
隣同士の要素のペアに Fを適用して、
新たなリスト [F(s_1, s_2), F(s_3, s_4), ...]を形成します。
もし要素の数が奇数なら最後の要素はそのままリストに載ります。
そして、リストが要素1つになるまで繰り返します。その結果が戻り値です。
オプション引数 s_0を与えた時には、
結果は tree_reduce(F, cons(s_0, s))と同値です。
浮動小数点数の加算に関して、
tree_reduceは、rreduceや
lreduceよりも小さな丸め誤差の和を返すことができます。
sの要素と部分的な結果を深さ最小2分木で整理できるので、 "tree_reduce"という名前です。
例:
偶数個の要素を持つリストに適用された tree_reduce。
(%i1) tree_reduce (f, [a, b, c, d]); (%o1) f(f(a, b), f(c, d)) |
奇数個の要素を持つリストに適用された tree_reduce。
(%i1) tree_reduce (f, [a, b, c, d, e]); (%o1) f(f(f(a, b), f(c, d)), e) |
リスト 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] |
関数 Fを合成で n項関数に拡張します。
もしくはもし Fが既に n項関数なら Fを sに適用します。
Fがn項関数でない時、
xreduceは lreduceと同じです。
sは集合かリストです。
n項関数と知られている関数は
加算 +, 乗算 *, and, or, max,
min, と appendです。
declare(F, nary)で関数が宣言されているかもしれません。
これらの関数に関して、
xreduceは rreduceや lreduceより速いことが期待できます。
オプション引数 s_0を与えた場合、
結果は xreduce(s, cons(s_0, s))と同値です。
浮動小数点加算は厳密には結合的ではないです;
それはともかく
sが浮動小数点数を含む時、
xreduceは Maximaの n項加算を適用します。
例:
n項関数と知られている関数へ適用された xreduce。
Fはすべての引数で1度だけ呼ばれます。
(%i1) declare (F, nary); (%o1) done (%i2) F ([L]) := L; (%o2) F([L]) := L (%i3) xreduce (F, [a, b, c, d, e]); (%o3) [a, b, c, d, e] |
n項関数と知られていない関数へ適用された xreduce。
Gは2つの引数を与えられながら数回呼ばれます。
(%i1) G ([L]) := L; (%o1) G([L]) := L (%i2) xreduce (G, [a, b, c, d, e]); (%o2) [[[[a, b], c], d], e] (%i3) lreduce (G, [a, b, c, d, e]); (%o3) [[[[a, b], c], d], e] |
c h---------------------------------------------------
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
リストは要素を追加したり削除したりする効率的な方法を提供します。 最終的な次元を知ることなしに生成することができます。 リストはリストをコピーしたり扱ったりする効率的な手段を提供します。 また、入れ子のリストは厳格に矩形である必要はありません。 宣言された配列に対するこれらの利点の代わりに、 リスト内のランダムな要素へのアクセスに必要な時間がランダムな要素の頭からの距離におおよそ比例するかもしれない欠点があります。 しかし、リストをスタックやFIFOとして使うことで、リストを効率的に横断することは可能です:
(%i1) l:[Test,1,2,3,4];
(%o1) [Test, 1, 2, 3, 4]
(%i2) while l # [] do
disp(pop(l));
Test
1
2
3
4
(%o2) done
|
別のより速い例:
(%i1) l:[Test,1,2,3,4];
(%o1) [Test, 1, 2, 3, 4]
(%i2) for i in l do
disp(pop(l));
Test
1
2
3
4
(%o2) done
|
reverse ()を使ってリストを逆順にすれば、
リストの最後の要素から横断を始められます。
もし長いリストの要素を違った順序で処理するなら、
初めにリストを宣言された配列に変換することで
パフォーマンスを向上させられるかもしれません。
forループの終了条件は毎回テストされることにも注意してください。
それは、 終了条件で lengthの結果が使われるなら、それはキャッシュすべきということを意味します:
(%i1) l:makelist(i,i,1,100000)$
(%i2) lngth:length(l);
(%o2) 100000
(%i3) x:1;
(%o3) 1
(%i4) for i:1 thru lngth do
x:x+1$
(%i5) x;
(%o5) 100001
|
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Maximaは3つの配列のような構成体をサポートします:
(%i1) a["feww"]:1; (%o1) 1 (%i2) a[qqwdqwd]:3; (%o2) 3 (%i3) a[5]:99; (%o3) 99 (%i4) a[qqwdqwd]; (%o4) 3 (%i5) a[5]; (%o5) 99 (%i6) a["feww"]; (%o6) 1 |
lispはハッシュ配列と配列に似た memoizing functionsを扱うので、
配列に適用できる関数の多くはそれらにも適用可能です。
makelistを参照してください)は要素の拘束な追加削除ができ、
最終的なサイズを知らずに生成することができます。
| 5.7 Functions and Variables for Arrays |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
n次元の配列を生成します。 nは5以下を取り得ます。 i番目の次元のための添字は0からdim_iまで動く整数です。
array (name, dim_1, ..., dim_n)は
一般的な配列を生成します。
array (name, type, dim_1, ..., dim_n)は
指定されたタイプの要素を持つ配列を生成します。
typeには
制限されたサイズの整数にはfixnumが使え、
また、浮動小数点にはflonumが使えます。
array ([name_1, ..., name_m], dim_1, ..., dim_n)
は同じ次元のm個の配列を生成します。
arraymakeと arrayinfo, make_arrayも参照してください。
Categories: Arrays
A [i_1, ..., i_n]を評価します。
ここで、Aは配列、i_1, …, i_nは整数です。
これは、最初の引数が関数の代わりに配列だということを除いて、
applyを連想させます。
Categories: Expressions · Arrays
配列Aに関する情報を返します。
引数Aは、宣言配列、hashed array、memoizing function、または添字付き関数を取り得ます。
宣言配列では、
arrayinfoは、
アトムdeclaredと、次元数、それぞれの次元のサイズを含むリストを返します。
配列の要素は、バインドされたものもそうでないものも、listarrayで返されます。
未宣言配列(ハッシュド配列)では、
arrayinfoは、
アトムhashedと、添字の数、値を持つすべての要素の添字を含むリストを返します。
値は listarrayで返されます。
memoizing functionsでは、
arrayinfoは、
アトムhashedと、添字の数、
記憶された関数値がある添字の値すべてを含むリストを返します。
記憶された関数値は、listarrayで返されます。
添字付き関数では、
arrayinfoは、
アトムhashedと、添字の数、
ラムダ式がある添字の値すべてを含むリストを返します。
ラムダ式は listarrayで返されます。
listarrayも参照してください。
例:
宣言配列に適用されたarrayinfoとlistarray。
(%i1) array (aa, 2, 3);
(%o1) aa
(%i2) aa [2, 3] : %pi;
(%o2) %pi
(%i3) aa [1, 2] : %e;
(%o3) %e
(%i4) arrayinfo (aa);
(%o4) [declared, 2, [2, 3]]
(%i5) listarray (aa);
(%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
#####, #####, #####, %pi]
|
未宣言配列 (hashed array)に適用されたarrayinfoとlistarray。
(%i1) bb [FOO] : (a + b)^2;
2
(%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3;
3
(%o2) (c - d)
(%i3) arrayinfo (bb);
(%o3) [hashed, 1, [BAR], [FOO]]
(%i4) listarray (bb);
3 2
(%o4) [(c - d) , (b + a) ]
|
memoizing functionに適用された arrayinfoと listarray。
(%i1) cc [x, y] := y / x;
y
(%o1) cc := -
x, y x
(%i2) cc [u, v];
v
(%o2) -
u
(%i3) cc [4, z];
z
(%o3) -
4
(%i4) arrayinfo (cc);
(%o4) [hashed, 2, [4, z], [u, v]]
(%i5) listarray (cc);
z v
(%o5) [-, -]
4 u
|
未宣言配列を宣言配列に変換するために arrayinfoの使用:
(%i1) for i:0 thru 10 do a[i]:i^2$ (%i2) indices:map(first,rest(rest(arrayinfo(a)))); (%o2) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] (%i3) array(A,fixnum,length(indices)-1)$ (%i4) fillarray(A,map(lambda([x],a[x]),indices))$ (%i5) listarray(A); (%o5) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] |
添字付き関数に適用されたarrayinfoとlistarray。
(%i1) dd [x] (y) := y ^ x;
x
(%o1) dd (y) := y
x
(%i2) dd [a + b];
b + a
(%o2) lambda([y], y )
(%i3) dd [v - u];
v - u
(%o3) lambda([y], y )
(%i4) arrayinfo (dd);
(%o4) [hashed, 1, [b + a], [v - u]]
(%i5) listarray (dd);
b + a v - u
(%o5) [lambda([y], y ), lambda([y], y )]
|
Categories: Arrays
式A[i_1, ..., i_n]を返します。
結果は未評価の配列参照です。
arraymakeは、
戻り値は、未評価関数コールの代わりに未評価の配列参照だということを除いて、
funmakeを連想させます。
例:
(%i1) arraymake (A, [1]);
(%o1) A
1
(%i2) arraymake (A, [k]);
(%o2) A
k
(%i3) arraymake (A, [i, j, 3]);
(%o3) A
i, j, 3
(%i4) array (A, fixnum, 10);
(%o4) A
(%i5) fillarray (A, makelist (i^2, i, 1, 11));
(%o5) A
(%i6) arraymake (A, [5]);
(%o6) A
5
(%i7) ''%;
(%o7) 36
(%i8) L : [a, b, c, d, e];
(%o8) [a, b, c, d, e]
(%i9) arraymake ('L, [n]);
(%o9) L
n
(%i10) ''%, n = 3;
(%o10) c
(%i11) A2 : make_array (fixnum, 10);
(%o11) {Lisp Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o12) {lisp Array: #(1 2 3 4 5 6 7 8 9 10)}
(%i13) arraymake ('A2, [8]);
(%o13) A2
8
(%i14) ''%;
(%o14) 9
|
Categories: Expressions · Arrays
デフォルト値: []
arraysは割り当てられた配列のリストです。
これらは、 arrayで宣言された配列、
(リストや配列としてまだ宣言されていない要素に何かを割り当てられた)
暗黙の定義で構成された hashed arrays、
:=とdefineで定義された memoizing functionsを含みます。
make_arrayで定義された配列は含まれません。
array, arrayapply, arrayinfo, arraymake,
fillarray, listarray, rearrayも参照してください。
例:
(%i1) array (aa, 5, 7);
(%o1) aa
(%i2) bb [FOO] : (a + b)^2;
2
(%o2) (b + a)
(%i3) cc [x] := x/100;
x
(%o3) cc := ---
x 100
(%i4) dd : make_array ('any, 7);
(%o4) {Lisp Array: #(NIL NIL NIL NIL NIL NIL NIL)}
(%i5) arrays;
(%o5) [aa, bb, cc]
|
Categories: Arrays · Global variables
xをA[i_1, ..., i_n]に割り当てます。
ここで、Aは配列で、i_1, …, i_nは整数です。
arraysetapplyは引数を評価します。
Categories: Expressions · Arrays
配列AをBから埋めます。 ここで、Bはリストか配列です。
もし生成時に特定のタイプがAのために宣言されたら、 その同じタイプの要素でだけ埋めることができます; もし違ったタイプの要素をコピーする試みがなされたらエラーです。
もし配列AとBの次元が違ったら、 Aは行優先順で埋められます。 もしBの中の要素が十分でないなら、 Aの残りを埋めるのに最後の要素が使われます。 もし多すぎるなら、残りは無視されます。
fillarrayは最初の引数を返します。
例:
9個の要素の配列を生成し、リストから埋めます。
(%i1) array (a1, fixnum, 8); (%o1) a1 (%i2) listarray (a1); (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0] (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]); (%o3) a1 (%i4) listarray (a1); (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9] |
配列を埋めるのに要素が足らない時、 最後の要素が繰り返されます。 要素が多すぎる時、余分の要素は無視されます。
(%i1) a2 : make_array (fixnum, 8);
(%o1) {Lisp Array: #(0 0 0 0 0 0 0 0)}
(%i2) fillarray (a2, [1, 2, 3, 4, 5]);
(%o2) {Lisp Array: #(1 2 3 4 5 5 5 5)}
(%i3) fillarray (a2, [4]);
(%o3) {Lisp Array: #(4 4 4 4 4 4 4 4)}
(%i4) fillarray (a2, makelist (i, i, 1, 100));
(%o4) {Lisp Array: #(1 2 3 4 5 6 7 8)}
|
多次元配列は行優先順に埋められます。
(%i1) a3 : make_array (fixnum, 2, 5);
(%o1) {Lisp Array: #2A((0 0 0 0 0) (0 0 0 0 0))}
(%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o2) {Lisp Array: #2A((1 2 3 4 5) (6 7 8 9 10))}
(%i3) a4 : make_array (fixnum, 5, 2);
(%o3) {Lisp Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
(%i4) fillarray (a4, a3);
(%o4) {Lisp Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))}
|
Categories: Arrays
配列Aの要素のリストを返します。
引数Aは、配列、未宣言配列 (hashed array)、 memoizing function 、添字付き関数を取り得ます。
要素は行優先順にリストされます。
すなわち、要素は、最初のインデックスに従って振り分けられ、次に二番目のインデックスに従って、などなど。
インデックス値の振り分け順は、
orderlessが確立する順と同じです。
未宣言配列(hashed arrays)や、 memoizing functions、添字付き関数では、
要素はarrayinfoが返すインデックス値に対応します。
一般的な配列のバインドされていない要素(すなわち、fixnumでもflonumでもない要素)は、 #####として返されます。
fixnum配列またはflonum配列のバイドされていない要素は、
それぞれ0または0.0として返されます。
ハッシュ配列、 memoizing functions、添字付き関数のバインドされていない要素は返されません。
例:
宣言配列に適用されたlistarrayとarrayinfo。
(%i1) array (aa, 2, 3);
(%o1) aa
(%i2) aa [2, 3] : %pi;
(%o2) %pi
(%i3) aa [1, 2] : %e;
(%o3) %e
(%i4) listarray (aa);
(%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
#####, #####, #####, %pi]
(%i5) arrayinfo (aa);
(%o5) [declared, 2, [2, 3]]
|
未宣言配列(hashed array)に適用されたlistarrayとarrayinfo。
(%i1) bb [FOO] : (a + b)^2;
2
(%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3;
3
(%o2) (c - d)
(%i3) listarray (bb);
3 2
(%o3) [(c - d) , (b + a) ]
(%i4) arrayinfo (bb);
(%o4) [hashed, 1, [BAR], [FOO]]
|
memoizing functionに適用されたlistarrayとarrayinfo。
(%i1) cc [x, y] := y / x;
y
(%o1) cc := -
x, y x
(%i2) cc [u, v];
v
(%o2) -
u
(%i3) cc [4, z];
z
(%o3) -
4
(%i4) listarray (cc);
z v
(%o4) [-, -]
4 u
(%i5) arrayinfo (cc);
(%o5) [hashed, 2, [4, z], [u, v]]
|
添字付き関数に適用されたlistarrayとarrayinfo。
(%i1) dd [x] (y) := y ^ x;
x
(%o1) dd (y) := y
x
(%i2) dd [a + b];
b + a
(%o2) lambda([y], y )
(%i3) dd [v - u];
v - u
(%o3) lambda([y], y )
(%i4) listarray (dd);
b + a v - u
(%o4) [lambda([y], y ), lambda([y], y )]
(%i5) arrayinfo (dd);
(%o5) [hashed, 1, [b + a], [v - u]]
|
Categories: Arrays
Lisp配列を生成し、返します。
typeは、any, flonum, fixnum, hashed,
functionalを取り得ます。
n個のインデックスがあり、
i番目のインデックスは0からdim_i - 1まで動きます。
make_arrayのarrayに対する利点は、
戻り値が名前を持たないことであり、
一旦、それへのポインタが消えると、それも消えます。
例えば、もしy: make_array (...)なら、
yは領域を取るオブジェクトを指しますが、
y: falseの後、yはそのオブジェクトをもはや指さないので、
オブジェクトはガーベッジコレクトされることができます。
例:
(%i1) A1 : make_array (fixnum, 10);
(%o1) {Lisp Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i2) A1 [8] : 1729;
(%o2) 1729
(%i3) A1;
(%o3) {Lisp Array: #(0 0 0 0 0 0 0 0 1729 0)}
(%i4) A2 : make_array (flonum, 10);
(%o4) {Lisp Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i5) A2 [2] : 2.718281828;
(%o5) 2.718281828
(%i6) A2;
(%o6)
{Lisp Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i7) A3 : make_array (any, 10);
(%o7) {Lisp Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
(%i8) A3 [4] : x - y - z;
(%o8) (- z) - y + x
(%i9) A3;
(%o9) {Lisp Array: #(NIL NIL NIL NIL
((MPLUS SIMP) $X ((MTIMES SIMP) -1 $Y) ((MTIMES S\
IMP) -1 $Z))
NIL NIL NIL NIL NIL)}
(%i10) A4 : make_array (fixnum, 2, 3, 5);
(%o10) {Lisp Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0))
((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
(%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
(%o11) {Lisp Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 1\
5))
((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29\
30)))}
(%i12) A4 [0, 2, 1];
(%o12) 12
|
Categories: Arrays
配列の次元を変えます。
新しい配列は
行優先順に古いものの配列で埋められます。
もし古い配列が小さすぎるなら、
残りの要素は、
配列のタイプに依って、
false, 0.0または0で埋められます。
配列のタイプは変えられません。
Categories: Arrays
配列と関数に関連づけられた配列を削除し、占められた領域を開放します。
引数は、宣言配列、 hashed arrays、配列関数、添字付き関数を取り得ます。
remarray (all)は、
グローバルリストarraysの中の項目すべてを削除します。
もし memoizing functionのキャッシュをクリアすることが望ましいなら、この関数を使うことが必要になるかもしれません。
remarrayは削除された配列のリストを返します。
remarrayはクォートします。
Categories: Arrays
添字付き式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
もしexprが例えばa[i]のように添字された変数なら、trueを返します。
Categories: Predicate functions
デフォルト値: false
use_faset_arraysが trueの時、
arrayが宣言した配列はプロパティでなく値であり、
非宣言配列 (hashed arrays)は Lispハッシュ配列として実装されます。
use_faset_arraysが falseの時、
非宣言の配列と arrayが宣言した配列はプロパティであり、
非宣言の配列は Maxima自身のハッシュ配列実装で実装されます。
use_fast_arraysが切り替えるコードは必ずしもデフォルトのものより速くはないことに注意してください;
make_arrayが生成した配列はuse_fast_arraysに影響されません。
translate_fast_arraysも参照してください。
Categories: Arrays · Global flags
デフォルト値: false
translate_fast_arraysが trueの時、
Maxima-to-Lispトランスレータが、
use_fast_arraysが trueであるかのように
配列がプロパティでなく値であると仮定したコードを生成します。
translate_fast_arraysが falseの時、
Maxima-to-Lispトランスレータが、
use_fast_arraysが falseであるかのように
配列がプロパティであると仮定したコードを生成します。
Categories: Arrays · Translation flags and variables
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 5.8.1 Introduction to Structures | ||
| 5.8.2 Functions and Variables for Structures |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Maximaは構造体と呼ばれる簡単なデータ集合体を提供します。 構造体は 引数が名前(フィールド名)によって識別され、式全体が演算子(構造体名)によって識別される式です。 フィールド名は任意の式を取り得ます。
構造体はdefstruct関数によって定義されます;
グローバル変数structuresはユーザー定義の構造体のリストです。
関数newは構造体のインスタンスを生成します。
@演算子はフィールドを参照します。
kill(S)は構造体定義Sを取り除き、
kill(x@ a)は
構造体インスタンスxのフィールドaをアンバインドします。
(display2dをtrueで使う)プリティプリンティングのコンソール表示では、
構造体インスタンスは、
左辺側にフィールド名、右辺側に値の式として表されたそれぞれのフィールドの値と一緒に
表示されます。
(等式は単に表示物です; 値だけが実際に保存されます。)
(grindを介してか、display2dをfalseで使う)1次元表示では
構造体はフィールド名ないで表示されます。
フィールド値はラムダ式でありえますが、フィールド名を関数名として使う方法はありません。 フィールドの値はあるタイプに制約することもできません; 任意のフィールドにはどんな種類の式に割り当てることができます。 フィールドを、違った文脈でアクセス可能にしたり不可能する方法はありません; すべてのフィールドはいつも可視です。
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
structuresは
defstructで定義されたユーザー定義の構造体のリストです。
Categories: Structures · Global variables
構造体を定義します。 構造体はシンボル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)は
構造体Sの新しいインスタンスを生成します。
それぞれのフィールドは、もしデフォルト値があればデフォルト値を割り当てられ、
もしデフォルト値が構造体定義で指定されなかったなら、割り当てなしになります。
new(S(v_1, ..., v_n))は
フィールドが値v_1, …, v_nに割り当てられた
構造体Sの新しいインスタンスを生成します。
例:
(%i1) defstruct (foo (w, x = %e, y = 42, z)); (%o1) [foo(w, x = %e, y = 42, z)] (%i2) new (foo); (%o2) foo(w, x = %e, y = 42, z) (%i3) new (foo (1, 2, 4, 8)); (%o3) foo(w = 1, x = 2, y = 4, z = 8) |
Categories: Structures
@構造体フィールドアクセス演算子です。
式x@ aは
構造体インスタンスxのフィールドaの値を参照します。
フィールド名は評価されません。
もしxのフィールドaが値を割り当てられていないなら、
x@ aはそれ自身に評価されます。
kill(x@ a)は
xのフィールド値aを値を取り除きます。
例:
(%i1) defstruct (foo (x, y, z)); (%o1) [foo(x, y, z)] (%i2) u : new (foo (123, a - b, %pi)); (%o2) foo(x = 123, y = a - b, z = %pi) (%i3) u@z; (%o3) %pi (%i4) u@z : %e; (%o4) %e (%i5) u; (%o5) foo(x = 123, y = a - b, z = %e) (%i6) kill (u@z); (%o6) done (%i7) u; (%o7) foo(x = 123, y = a - b, z) (%i8) u@z; (%o8) u@z |
フィールド名は評価されません。
(%i1) defstruct (bar (g, h)); (%o1) [bar(g, h)] (%i2) x : new (bar); (%o2) bar(g, h) (%i3) x@h : 42; (%o3) 42 (%i4) h : 123; (%o4) 123 (%i5) x@h; (%o5) 42 (%i6) x@h : 19; (%o6) 19 (%i7) x; (%o7) bar(g, h = 19) (%i8) h; (%o8) 123 |
Categories: Structures · Operators
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by 市川雄二 on February, 2 2019 using texi2html 1.76.