2 * Introduction to operators::
3 * Arithmetic operators::
4 * Relational operators::
6 * Operators for Equations::
7 * Assignment operators::
8 * User defined operators::
11 @c -----------------------------------------------------------------------------
12 @node Introduction to operators, Arithmetic operators, Operators, Operators
13 @section Introduction to operators
14 @c -----------------------------------------------------------------------------
16 指定された優先順位を持つ新しい演算子を定義したり、
17 既存の演算子を未定義にしたり、既存の演算子の優先順位を再定義することが可能です。
18 演算子は単項前置、単項後置、二項中置、n項中置、マッチフィックスか無項でありえます。
19 「マッチフィックス」は引数を括るシンボルの対を意味し、
20 「無項」は引数を取らない演算子を意味します。
21 異なるタイプの演算子の例として、以下があります。
29 exponentiation @code{a^b}
33 list construction @code{[a, b]}
36 (組み込みの無項演算子はありません; そんな演算子の例は、@code{nofix}を参照してください。.)
38 新しい演算子を定義するメカニズムはわかりやすいものです。
39 関数を演算子として宣言することだけが必要です;
40 演算子関数は定義されることもされないこともあります。
43 明示的な関数コール @code{"dd" (a)}は @code{dd a}と同値であり、また、
44 @code{"<-" (a, b)}は @code{a <- b}と同値であることに注意してください。
45 この例で、 @code{"dd"}と @code{"<-"}は未定義です。
53 @c "<-" (a, "dd" (b));
66 (%i6) "<-" (a, "dd" (b));
70 新しい演算子を定義するMaxima関数はこの表にまとめられます。
71 デフォルトの左と右の結合力(それぞれlbpとrbp)を記載します。
72 @c REWORK FOLLOWING COMMENT.
73 @c IT'S NOT CLEAR ENOUGH, GIVEN THAT IT'S FAIRLY IMPORTANT
75 しかしながら、左と右の結合力は異なることがあり、
77 演算定義関数のいくつかは追加の引数を取ります;
80 @c MAKE ANCHORS FOR ALL 6 FUNCTIONS AND CHANGE @code TO @ref ACCORDINGLY
91 (binding power not applicable)
93 (binding power not applicable)
96 比較のために、いくつかの組み込み演算子と左右結合力を上げます。
127 @mref{remove}と @mref{kill}は演算子プロパティをアトムから削除します。
128 @code{remove ("@var{a}", op)}は @var{a}の演算子プロパティだけを削除します。
129 @code{kill ("@var{a}")}は 演算子プロパティを含む@var{a}のすべてのロパティを削除します。
130 演算子名はクォーテーションマークで括らないといけないことに注意してください。
132 @c MAYBE COPY THIS EXAMPLE TO remove AND/OR kill
135 @c "##" (a, b) := a^b;
137 @c remove ("##", op);
149 (%i2) "##" (a, b) := a^b;
154 (%i4) remove ("##", op);
157 Incorrect syntax: # is not a prefix operator
169 Incorrect syntax: # is not a prefix operator
181 @c -----------------------------------------------------------------------------
182 @node Arithmetic operators, Relational operators, Introduction to operators, Operators
183 @section Arithmetic operators
184 @c -----------------------------------------------------------------------------
186 @c -----------------------------------------------------------------------------
213 シンボル @code{+} @code{*} @code{/} @code{^}はそれぞれ、
214 足し算、かけ算、割り算、べき乗を表します。
215 これらの演算子の名前は @code{"+"} @code{"*"} @code{"/"} @code{"^"}です。
216 これらは関数や演算子の名前が求められるところで使います。
218 シンボル @code{+}や @code{-}はそれぞれ、プラスとマイナスの単項演算子を示し、
219 それらの名前はそれぞれ @code{"+"}と@code{"-"}です。
221 引き算 @code{a - b}はMaximaの中では足し算 @code{a + (- b)}として表されます。
222 @code{a + (- b)}のような式は引き算として表示されます。
223 Maximaは @code{"-"}を足し算の単項逆元演算子の名前としてのみ認識して、
226 Maximaの中では割り算@code{a / b}をかけ算@code{a * b^(- 1)}として表現します。
227 @code{a * b^(- 1)}のような式は割り算として表示されます。
228 Maximaは@code{"/"}を割り算演算子の名前として認識します。
233 Maximaは正準表現を構成するために可換演算子のオペランド(訳注:引数)を並べ替えます。
234 順序は内部的には @code{orderlessp}で決定します。
235 表示のためには、足し算の順序は @code{ordergreatp}で決定し、
238 算術計算は、数リテラル(整数、有理数、通常の浮動小数点、多倍長浮動小数点)上で実行されます。
239 べき乗を除いて、数に対するすべての算術演算子は数に整理されます。
240 べき乗は、オペランドが通常の浮動小数点か多倍長浮動小数点の時、もしくは結果が厳密に整数もしくは有理数の時、数に整理されます;
241 そうでなければ、べき乗は @code{sqrt}か他のべき乗に整理されるか、そのまま残されます。
243 浮動小数点の伝搬が算術計算に適用されます:
244 もしどれか1つでもオペランドが多倍長浮動小数点なら、結果は多倍長浮動小数点です;
245 そうでなければ、もしどれか1つでもオペランドが通常の浮動小数点なら、結果は通常の浮動小数点です;
246 そうでなければオペランドは有理数か整数であり、結果は有理数か整数です。
248 算術計算は式整理であって、評価ではありません。
249 従って、クォートされた(しかし整理される)式の中で算術計算は実行されます。
252 グローバルフラグ @code{listarith}が @code{true}の時
255 オペランドの1つがリストか行列であり、もう1つのオペランドが別のタイプの時、
256 他のオペランドはリストか行列の要素のそれぞれに組み合わされます。
261 Maximaは、正準表現を構成するために、可換演算子のオペランドを並べ替えます。
262 それらの名前はそれぞれ @code{"+"}と @code{"*"}です。
265 @c c + g + d + a + b + e + f;
266 @c [op (%), args (%)];
267 @c c * g * d * a * b * e * f;
268 @c [op (%), args (%)];
269 @c apply ("+", [a, 8, x, 2, 9, x, x, a]);
270 @c apply ("*", [a, 8, x, 2, 9, x, x, a]);
273 (%i1) c + g + d + a + b + e + f;
274 (%o1) g + f + e + d + c + b + a
275 (%i2) [op (%), args (%)];
276 (%o2) [+, [g, f, e, d, c, b, a]]
277 (%i3) c * g * d * a * b * e * f;
279 (%i4) [op (%), args (%)];
280 (%o4) [*, [a, b, c, d, e, f, g]]
281 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
283 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
288 割り算とべき乗は、二項の非可換演算子です。
289 それらの名前はそれぞれ @code{"/"}と @code{"^"}です。
293 @c [map (op, %), map (args, %)];
294 @c [apply ("/", [a, b]), apply ("^", [a, b])];
297 (%i1) [a / b, a ^ b];
301 (%i2) [map (op, %), map (args, %)];
302 (%o2) [[/, ^], [[a, b], [a, b]]]
303 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
309 引き算と割り算は内部的にはそれぞれ、足し算とかけ算を使って表現されます。
312 @c [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
313 @c [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
316 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
318 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
328 @c 17 + b - (1/2)*29 + 11^(2/4);
329 @c [17 + 29, 17 + 29.0, 17 + 29b0];
332 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
334 (%o1) b + sqrt(11) + -
336 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
337 (%o2) [46, 46.0, 4.6b1]
340 算術計算は式整理であって、評価ではありません。
344 @c '(17 + 29*11/7 - 5^3);
346 @c '(17 + 29*11/7 - 5^3);
351 (%i2) '(17 + 29*11/7 - 5^3);
357 (%i4) '(17 + 29*11/7 - 5^3);
363 算術計算は(@code{listarith}に依存して)リストや行列に対して要素毎に実行されます。
366 @c matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
367 @c 5 * matrix ([a, x], [h, u]);
368 @c listarith : false;
369 @c [a, c, m, t] / [1, 7, 2, 9];
372 @c [a, c, m, t] / [1, 7, 2, 9];
376 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
382 (%i2) 5 * matrix ([a, x], [h, u]);
387 (%i3) listarith : false;
389 (%i4) [a, c, m, t] / [1, 7, 2, 9];
393 (%i5) [a, c, m, t] ^ x;
396 (%i6) listarith : true;
398 (%i7) [a, c, m, t] / [1, 7, 2, 9];
402 (%i8) [a, c, m, t] ^ x;
404 (%o8) [a , c , m , t ]
412 @c -----------------------------------------------------------------------------
417 Maximaは入力の中で @code{**}を @code{^}と同じ演算子と認識し、
418 1次元出力の中では @code{^}として表示し、
419 また、2次元出力の中では指数を上付き添字として配置します。
421 @mref{fortran}関数は、入力が @code{**}でも @code{^}でも、
422 べき乗演算子を @code{**}として表示します。
429 @c string (x**y + x^z);
430 @c fortran (x**y + x^z);
433 (%i1) is (a**b = a^b);
438 (%i3) string (x**y + x^z);
440 (%i4) fortran (x**y + x^z);
450 @c -----------------------------------------------------------------------------
458 ちょうど可換なかけ算 @code{*}に通常のべき乗演算子 @code{^}が対応するように、
459 @code{^^}は非可換かけ算 @code{.}に対応するべき乗演算子です。
461 非可換べき乗演算子は、1次元出力では @code{^^}で表示され、
462 2次元出力では、指数をかっこ @code{< >}で囲まれた上付き添字として置きます。
467 @c a . a . b . b . b + a * a * a * b * b;
468 @c string (a . a . b . b . b + a * a * a * b * b);
471 (%i1) a . a . b . b . b + a * a * a * b * b;
474 (%i2) string (a . a . b . b . b + a * a * a * b * b);
475 (%o2) a^3*b^2+a^^2 . b^^3
483 @c -----------------------------------------------------------------------------
490 行列(非可換)かけ算のためのドット演算子。
491 @code{"."}をこの意味で用いる時、
492 例えば @code{A . B}のように両側にスペースを置かなければいけません。
500 @code{dotconstrules},
512 @c -----------------------------------------------------------------------------
513 @node Relational operators, Logical operators, Arithmetic operators, Operators
514 @section Relational operators
515 @c -----------------------------------------------------------------------------
517 @c -----------------------------------------------------------------------------
539 シンボル @code{<} @code{<=} @code{>=} @code{>}はそれぞれ、小なり、以下、以上、大なり、を表します。
540 これらの演算子の名前は、 @code{"<"}、 @code{"<="}、 @code{">="}、 @code{">"}です。
541 それらは関数や演算子の名前が求められるところで使われます。
543 これらの関係演算子はすべて二項演算子です;
544 @code{a < b < c}のような構成をMaximaは認識しません。
546 関数 @mref{is}や @mref{maybe}、
547 プログラミング構成子 @mref{if}, @mref{while}, @mref{unless}が
549 そうでなければ、関係式はブーリアン値に評価されたり整理されたりしませんが、
550 関係式の引数は(評価がクォーテーションによって妨げられないかぎり)評価されます。
552 関係式が @code{true}もしくは @code{false}に評価できない時、
553 @code{is}や @code{if}の振る舞いは、グローバルフラグ @mref{prederror}が決定します。
554 @code{prederror}が @code{true}の時、 @code{is}や @code{if}はエラーをトリガーします。
555 @code{prederror}が @code{false}の時、
556 @code{is}は @code{unknown}を返し、
557 @code{if}は部分的に評価された条件式を返します。
559 @code{maybe}はいつも、 @code{prederror}が @code{false}であるかのように振る舞い、
560 @code{while}や @code{unless}はいつも、 @code{prederror}が @code{true}であるかのように振る舞います。
562 関係演算子はリストやほかの集合上で展開されることはありません。
564 @mref{=}や @mref{#}、 @mref{equal}、 @mref{notequal}も参照してください。
568 いくつかの関数やプログラミング構成子が関係式をブーリアン値に評価します。
571 @c [x, y, z] : [123, 456, 789];
574 @c if x >= z then 1 else 0;
575 @c block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
579 (%i1) [x, y, z] : [123, 456, 789];
580 (%o1) [123, 456, 789]
585 (%i4) if x >= z then 1 else 0;
587 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
592 そうでなければ関係式はブーリアン値に評価されたり整理されたりしませんが、
596 @c [x, y, z] : [123, 456, 789];
597 @c [x < y, y <= z, z >= y, y > z];
601 (%o1) [123, 456, 789]
602 (%i2) [x < y, y <= z, z >= y, y > z];
603 (%o2) [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
605 (%o3) [true, true, true, false]
613 @c -----------------------------------------------------------------------------
614 @node Logical operators, Operators for Equations, Relational operators, Operators
615 @section Logical operators
616 @c -----------------------------------------------------------------------------
620 @c -----------------------------------------------------------------------------
628 @code{and}は、n項中置演算子です;
629 オペランドはブーリアン値で、結果もブーリアン値です。
631 @code{and}は、(@code{is}のように)1以上のオペランドの評価を強制し、
632 すべてのオペランドの評価を強制するかもしれません。
635 @code{and}は、結果を決定するのに必要なだけオペランドを評価します。
636 もし任意のオペランドが@code{false}なら、結果は@code{false}であり、
639 グローバルフラグ@code{prederror}は、
640 評価されたオペランドが@code{true}か@code{false}に決定できない時の@code{and}の振る舞いを決定します。
641 @code{prederror}が@code{true}の時、@code{and}は、エラーメッセージを出力します。
642 そうでなければ、@code{true}か@code{false}に評価されないオペランドを受け付け、
645 @code{and}は可換ではありません:
646 @code{a and b}は、不定のオペランドの扱いのため、@code{b and a}と同値ではないかもしれません。
655 @c -----------------------------------------------------------------------------
664 オペランドはブーリアン値で、結果もブーリアン値です。
666 @code{or}は、(@code{is}のように)オペランドの評価を強制します。
668 グローバルフラグ@code{prederror}は、
669 評価されたオペランドが@code{true}か@code{false}に決定できない時の@code{not}の振る舞いを決定します。
670 @code{prederror}が@code{true}の時、@code{not}は、エラーメッセージを出力します。
671 そうでなければ、@code{true}か@code{false}に評価されないオペランドを受け付け、
681 @c -----------------------------------------------------------------------------
689 @code{or}は、n項中置演算子です;
690 オペランドはブーリアン値で、結果もブーリアン値です。
692 @code{or}は、(@code{is}のように)1以上のオペランドの評価を強制し、
693 すべてのオペランドの評価を強制するかもしれません。
696 @code{and}は、結果を決定するのに必要なだけオペランドを評価します。
697 もし任意のオペランドが@code{true}なら、結果は@code{true}であり、
700 グローバルフラグ@code{prederror}は、
701 評価されたオペランドが@code{true}か@code{false}に決定できない時の@code{or}の振る舞いを決定します。
702 @code{prederror}が@code{true}の時、@code{or}は、エラーメッセージを出力します。
703 そうでなければ、@code{true}か@code{false}に評価されないオペランドを受け付け、
707 @code{a or b}は、不定のオペランドの扱いのため、@code{b or a}と同値ではないかもしれません。
714 @c -----------------------------------------------------------------------------
715 @node Operators for Equations, Assignment operators, Logical operators, Operators
716 @section Operators for Equations
717 @c -----------------------------------------------------------------------------
719 @c -----------------------------------------------------------------------------
725 構文的等号@code{=}の否定を表します。
728 (特に @code{not @var{expr}}は @var{expr}の評価を伴うので)、
729 @code{not @var{a} = @var{b}}は、 @code{@var{a} # @var{b}}ではなく、
730 @code{is(@var{a} # @var{b})}と同値です。
753 (%i6) is (not a = b);
762 @c -----------------------------------------------------------------------------
767 @fnindex 等号 (構文法的に等しい)
772 式@code{@var{a} = @var{b}}は、それ自身、未評価の等式を表します。
773 等式は成り立つかもしれませんし、成り立たないかもしれません。
774 未評価の等式は、@mref{solve}や@mref{algsys}や他の関数の引数として用いられます。
776 関数@mref{is}は、@code{=}をブーリアン値に評価します。
777 @code{is(@var{a} = @var{b})}は、@var{a}と@var{b}が同一のとき、
778 @code{@var{a} = @var{b}}を@code{true}に評価します。
779 すなわち、@var{a}と@var{b}が同一のアトムであるか、もしくは、それらはアトムではなく、
780 それらの演算子が同一で、演算子の引数が同一です。
781 そうでなければ、@code{is(@var{a} = @var{b})}は@code{false}に評価されます;
782 決して、@code{unknown}には評価されません。
783 @code{is(@var{a} = @var{b})}が@code{true}の時、
784 @var{a}と@var{b}は、同値の式と対照的に、構文法的に等しいと言われます。
785 同値の式は、@code{is(equal(@var{a}, @var{b}))}が@code{true}の式です。
786 式は、同値だが構文法的に等しくないことが起こりえます。
788 @code{=}の否定は、@mref{#}で表されます。
789 @code{=}と同様、式@code{@var{a} # @var{b}}は、それ自身、評価されません。
790 @code{is(@var{a} # @var{b})}は、@code{@var{a} # @var{b}}を@code{true}もしくは@code{false}に評価します。
792 @code{is}に加えて、他のいくつかの演算子が@code{=}と@code{#}を@code{true}もしくは@code{false}に評価します。@mref{if}, @mref{and}, @mref{or}, @mref{not}という演算子です。
795 (特に、@code{not @var{expr}}は@var{expr}の評価を起こすため)、
796 @code{not @var{a} = @var{b}}は、@code{@var{a} # @var{b}}ではなく、
797 @code{is(@var{a} # @var{b})}と同値になります。
799 @mref{rhs}と@mref{lhs}は、それぞれ、等式、不等式の右辺と左辺を返します。
801 @mref{equal}や@mref{notequal}も参照してください。
805 式@code{@var{a} = @var{b}}は、それ自身、未評価の等式であり、成り立つことも成り立たないこともあります。
808 @c eq_1 : a * x - 5 * y = 17;
809 @c eq_2 : b * x + 3 * y = 29;
810 @c solve ([eq_1, eq_2], [x, y]);
811 @c subst (%, [eq_1, eq_2]);
815 (%i1) eq_1 : a * x - 5 * y = 17;
817 (%i2) eq_2 : b * x + 3 * y = 29;
819 (%i3) solve ([eq_1, eq_2], [x, y]);
821 (%o3) [[x = ---------, y = -----------]]
823 (%i4) subst (%, [eq_1, eq_2]);
824 196 a 5 (29 a - 17 b)
825 (%o4) [--------- - --------------- = 17,
827 196 b 3 (29 a - 17 b)
828 --------- + --------------- = 29]
831 (%o5) [17 = 17, 29 = 29]
834 @code{is(@var{a} = @var{b})}は、
835 @var{a}と@var{b}が構文法的に等しい(すなわち、同一の)時
836 式は、同値だが構文法的に等しくないことがありえます。
839 @c a : (x + 1) * (x - 1);
841 @c [is (a = b), is (a # b)];
842 @c [is (equal (a, b)), is (notequal (a, b))];
845 (%i1) a : (x + 1) * (x - 1);
846 (%o1) (x - 1) (x + 1)
850 (%i3) [is (a = b), is (a # b)];
852 (%i4) [is (equal (a, b)), is (notequal (a, b))];
856 いくつかの演算子は、@code{=}と@code{#}を@code{true}もしくは@code{false}に評価します。
859 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
861 @c eq_3 : 2 * x = 3 * x;
862 @c eq_4 : exp (2) = %e^2;
863 @c [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
866 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
869 (%i2) eq_3 : 2 * x = 3 * x;
871 (%i3) eq_4 : exp (2) = %e^2;
874 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
875 (%o4) [false, true, true]
878 @code{not @var{expr}}は@var{expr}の評価をするので、
879 @code{not @var{a} = @var{b}}は、@code{is(@var{a} # @var{b})}と同値です。
882 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
883 @c is (2 * x # 3 * x);
886 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
887 (%o1) [2 x # 3 x, true]
888 (%i2) is (2 * x # 3 * x);
897 @c -----------------------------------------------------------------------------
898 @node Assignment operators, User defined operators, Operators for Equations, Operators
899 @section Assignment operators
900 @c -----------------------------------------------------------------------------
902 @c -----------------------------------------------------------------------------
911 左辺が(添字のない)単純変数の時、 @code{:}は右辺を評価し、その値を左辺に関連づけます。
913 左辺がリストや行列、宣言されたMaxima配列、Lisp配列の添字指定された要素の時、
915 添字は存在している要素を示していなければなりません;
916 先に列挙した対象は、存在していない要素を名付けることで拡張することはできません。
918 左辺が未宣言のMaxima配列の添字指定された要素の時、
919 もし既に存在しているなら、右辺はその要素に割り当てられ、
920 もしまだ存在していなければ新しい要素が確保されます。
922 左辺が単純変数や添字あり変数のリストの時、
923 右辺はリストに評価されなければなりません。
924 そして、右辺の要素が左辺の要素に平行に割り当てられます。
926 @mref{kill}や@mref{remvalue}も参照してください。
927 それらは左辺とその値の関連をアンドゥします。
980 (%o4) [hashed, 1, [99]]
988 @c [a, b, c] : [45, 67, 89];
994 (%i1) [a, b, c] : [45, 67, 89];
1005 この例では@code{a}と@code{b}の値が置換されます。
1008 @c [a, b] : [33, 55];
1014 (%i1) [a, b] : [33, 55];
1016 (%i2) [a, b] : [b, a];
1025 @category{Evaluation}
1026 @category{Operators}
1030 @c -----------------------------------------------------------------------------
1035 @fnindex 割り当て演算子 (左辺を評価する)
1040 @code{::}は、@code{::}は右辺はもちろん左辺も評価することを除いて、@mref{:}と同じです。
1049 @c x :: [11, 22, 33];
1061 (%i4) x : '[a, b, c];
1063 (%i5) x :: [11, 22, 33];
1074 @category{Evaluation}
1075 @category{Operators}
1079 @c -----------------------------------------------------------------------------
1083 @fnindex マクロ関数定義の演算子
1087 @code{::=}は、引数をクォートする関数(歴史的理由によりマクロと呼ばれる)を定義します。
1088 そして、それが返す式(マクロ展開と呼ばれる)はマクロが呼ばれた文脈の中で評価されます。
1089 それ以外はマクロ関数は通常の関数と同じです。
1091 @mref{macroexpand}は(評価せずに)マクロ展開を返します。
1093 @code{macroexpand (foo (x))}に続けて @code{``%}を実行すると、
1094 それは @code{foo (x)}と同値です。
1096 @code{::=}は、新しいマクロ関数の名前をグローバルリスト @mref{macros}に追加します。
1097 @mref{kill}や @mref{remove}, @mref{remfunction}は、マクロ関数定義をアンバインドし、
1098 @code{macros}から名前を削除します。
1100 @mref{fundef}や @mref{dispfun}はそれぞれマクロ関数定義を返し、
1104 マクロ関数は一般的に@mref{buildq}, @mref{splice}式を含みます。
1109 だから、メッセージ(1)は @code{y - z}の値ではなく、 @code{y - z}を示します。
1110 マクロ展開(クォートされた式 @code{'(print ("(2) x is equal to", x)})は、
1111 マクロが呼ばれた文脈(表示メッセージ(2))の中で評価されます。
1117 @c printq1 (x) ::= block (print ("(1) x is equal to", x),
1118 @c '(print ("(2) x is equal to", x)))$
1125 (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
1126 '(print ("(2) x is equal to", x)))$
1127 (%i5) printq1 (y - z);
1128 (1) x is equal to y - z
1129 (2) x is equal to %pi
1133 通常の関数は引数を評価します。だから、メッセージ(1)は @code{y - z}の値を示します。
1134 戻り値は評価されず、従って、メッセージ(2)は @code{``%}で陽に評価されるまで出力されません。
1140 @c printe1 (x) := block (print ("(1) x is equal to", x),
1141 @c '(print ("(2) x is equal to", x)))$
1149 (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
1150 '(print ("(2) x is equal to", x)))$
1151 (%i5) printe1 (y - z);
1152 (1) x is equal to 1234 - 1729 w
1153 (%o5) print((2) x is equal to, x)
1155 (2) x is equal to %pi
1159 @code{macroexpand}はマクロ展開を返します。
1161 @code{macroexpand (foo (x))}の後 @code{``%}を実行すると、@code{foo (x)}と同値です。
1167 @c g (x) ::= buildq ([x], print ("x is equal to", x))$
1168 @c macroexpand (g (y - z));
1176 (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
1177 (%i5) macroexpand (g (y - z));
1178 (%o5) print(x is equal to, y - z)
1180 x is equal to 1234 - 1729 w
1183 x is equal to 1234 - 1729 w
1188 @category{Function definition}
1189 @category{Operators}
1193 @c -----------------------------------------------------------------------------
1201 @code{f(@var{x_1}, .., @var{x_n}) := @var{expr}}は、
1202 引数が@var{x_1}, ..., @var{x_n}で関数本体が@var{expr}の、@var{f}という名前の関数を定義します。
1203 @code{:=}は(クォートクォート@code{`@w{}`}で陽に評価されない限り)関数本体は評価しません。
1204 定義される関数は(引数をかっこでくくる)通常のMaxima関数か、(引数をかぎかっこでくくる)配列関数です。
1206 最後の引数@var{x_n}が要素1つのリストの時、@code{:=}で定義された関数は可変の数の引数をとります。
1207 実際の引数は、形式的な引数@var{x_1}, @dots{}, @var{x_(n - 1)}に一対一に割り当てられ、
1208 さらに引数があれば、@var{x_n}にリストとして割り当てられます。
1210 関数定義すべては、同じ名前空間を使います;
1211 別の関数@code{g}の中で関数@code{f}を定義することは、@code{f}のスコープを@code{g}に限定しません。
1212 しかし、@code{local(f)}は、関数@code{f}の定義を@mref{local}が現れたブロックや他の合成式内に限定します。
1214 もしある形式引数@var{x_k}がクォートされたシンボルなら、@code{:=}で定義された関数は対応する実際の引数を評価しません。
1215 それ以外の場合、実際の引数はすべて評価されます。
1217 @mref{define}や@mref{::=}も参照してください。
1221 @code{:=}は(クォートクォートで陽に評価されない限り)関数本体を評価しません。
1224 @c expr : cos(y) - sin(x);
1225 @c F1 (x, y) := expr;
1227 @c F2 (x, y) := ''expr;
1231 (%i1) expr : cos(y) - sin(x);
1232 (%o1) cos(y) - sin(x)
1233 (%i2) F1 (x, y) := expr;
1234 (%o2) F1(x, y) := expr
1236 (%o3) cos(y) - sin(x)
1237 (%i4) F2 (x, y) := ''expr;
1238 (%o4) F2(x, y) := cos(y) - sin(x)
1240 (%o5) cos(b) - sin(a)
1243 @code{:=}で定義された関数は、通常のMaxima関数か、配列関数です。
1246 @c G1 (x, y) := x.y - y.x;
1247 @c G2 [x, y] := x.y - y.x;
1250 (%i1) G1 (x, y) := x.y - y.x;
1251 (%o1) G1(x, y) := x . y - y . x
1252 (%i2) G2 [x, y] := x.y - y.x;
1253 (%o2) G2 := x . y - y . x
1257 最後の引数@var{x_n}が要素1つのリストの時、
1258 @code{:=}で定義された関数は、可変の数の引数を取ります。
1261 @c H ([L]) := apply ("+", L);
1265 (%i1) H ([L]) := apply ("+", L);
1266 (%o1) H([L]) := apply("+", L)
1271 @code{local}はローカル関数定義を可能にします。
1274 @c foo (x) := 1 - x;
1276 @c block (local (foo), foo (x) := 2 * x, foo (100));
1280 (%i1) foo (x) := 1 - x;
1281 (%o1) foo(x) := 1 - x
1284 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1291 @category{Function definition}
1292 @category{Operators}
1296 @c -----------------------------------------------------------------------------
1297 @node User defined operators, , Assignment operators, Operators
1298 @section User defined operators
1299 @c -----------------------------------------------------------------------------
1301 @c -----------------------------------------------------------------------------
1303 @deffn {関数} infix (@var{op})
1304 @deffnx {関数} infix (@var{op}, @var{lbp}, @var{rbp})
1305 @deffnx {関数} infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})
1307 @var{op}を中置演算子に宣言します。
1308 中置演算子は2つの引数の関数で、引数の間に関数名が来ます。
1309 例えば、引き算演算子@code{-}は中置演算子です。
1311 @code{infix (@var{op})}は、デフォルトの結合力(左右両方とも180)と品詞
1312 (左右両方とも@code{any})に等しい)で@var{op}を中置演算子に宣言します。
1313 @c HOW IS pos DIFFERENT FROM lpos AND rpos ??
1315 @code{infix (@var{op}, @var{lbp}, @var{rbp})}は、
1317 とデフォルトの品詞(左右両方とも@code{any})に等しい)で、
1318 @var{op}を中置演算子に宣言します。
1320 @code{infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})}は、
1322 左オペランド、右オペランド、演算子結果それぞれについて、
1323 品詞を@var{lpos}, @var{rpos}, @var{pos}に設定して、
1324 @var{op}を中置演算子に宣言します。
1326 (演算子宣言に関係して)「品詞」は、式のタイプを意味します。
1327 3つのタイプが認識されます; @code{expr}, @code{clause}, @code{any}。それぞれは、
1328 代数式、ブーリアン式、任意の種類の式を示します。
1329 Maximaは、宣言された品詞を実際の式に比較することで、
1332 他の演算子に関する@var{op}の優先順位は、問題となっている演算子の左右結合力から演繹されます。
1333 もし@var{op}の左右結合力のどちらもある他の演算子の左右結合力より大きいなら、
1334 @var{op}は、他の演算子より高い優先順位をとります。
1335 もし結合力がどちらも大きくも、どちらも小さくもなければ、
1338 @var{op}の結合性は結合力に依存します。
1339 より大きな左結合力(@var{lbp})は、@var{op}のインスタンスが
1340 式の中で左にある他の演算子の前に評価されることを示し、
1341 より大きな右結合力(@var{rbp})は、@var{op}のインスタンスが
1342 式の中で右にある他の演算子の前に評価されることを示します。
1343 このように、より大きな@var{lbp}は@var{op}を右結合にし、
1344 より大きな@var{rbp}は@var{op}を左結合にします。
1345 もし@var{lbp}が@var{rbp}と等しいなら、
1348 @code{Syntax}も参照してください。
1352 もし@var{op}左右結合力それぞれが、他の演算子のそれより大きいなら、
1353 @var{op}は他の演算子より高い優先順位をとります。
1356 @c :lisp (get '$+ 'lbp)
1357 @c :lisp (get '$+ 'rbp)
1358 @c infix ("##", 101, 101);
1359 @c "##"(a, b) := sconcat("(", a, ",", b, ")");
1361 @c infix ("##", 99, 99);
1365 (%i1) :lisp (get '$+ 'lbp)
1367 (%i1) :lisp (get '$+ 'rbp)
1369 (%i1) infix ("##", 101, 101);
1371 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
1372 (%o2) (a ## b) := sconcat("(", a, ",", b, ")")
1373 (%i3) 1 + a ## b + 2;
1375 (%i4) infix ("##", 99, 99);
1377 (%i5) 1 + a ## b + 2;
1381 より大きな@var{lbp}は@var{op}を右結合にし、
1382 より大きな@var{rbp}は@var{op}を左結合にします。
1385 @c infix ("##", 100, 99);
1386 @c "##"(a, b) := sconcat("(", a, ",", b, ")")$
1387 @c foo ## bar ## baz;
1388 @c infix ("##", 100, 101);
1389 @c foo ## bar ## baz;
1392 (%i1) infix ("##", 100, 99);
1394 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
1395 (%i3) foo ## bar ## baz;
1396 (%o3) (foo,(bar,baz))
1397 (%i4) infix ("##", 100, 101);
1399 (%i5) foo ## bar ## baz;
1400 (%o5) ((foo,bar),baz)
1403 Maximaは、宣言された品詞を実際の式と比較することで、
1407 @c infix ("##", 100, 99, expr, expr, expr);
1408 @c if x ## y then 1 else 0;
1409 @c infix ("##", 100, 99, expr, expr, clause);
1410 @c if x ## y then 1 else 0;
1413 (%i1) infix ("##", 100, 99, expr, expr, expr);
1415 (%i2) if x ## y then 1 else 0;
1416 Incorrect syntax: Found algebraic expression where logical
1420 (%i2) infix ("##", 100, 99, expr, expr, clause);
1422 (%i3) if x ## y then 1 else 0;
1423 (%o3) if x ## y then 1 else 0
1427 @category{Operators}
1428 @category{Declarations and inferences}
1434 @c -----------------------------------------------------------------------------
1436 @deffn {関数} matchfix (@var{ldelimiter}, @var{rdelimiter})
1437 @deffnx {関数} matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})
1439 左と右の区切り記号@var{ldelimiter}と@var{rdelimiter}を持つ
1444 任意の数の引数の関数で、引数は左と右の区切り記号をマッチする間で現れます。
1445 パーサがオペランドや他の式や演算子から区切り記号を区別できる限り
1447 実際には、これは、@code{%}, @code{,}, @code{$}, @code{;}のような
1448 パースできない区切り記号を除外し、空白を持つ区切り記号を分離することを要求するかもしれません。
1449 右区切り記号は、左区切り記号と同じかもしれませんし、違うかもしれません。
1451 左区切り記号は、たった1つの右区切り記号と関連づけられることができます;
1452 2つの異なるmatchfix演算子は同じ左区切り記号を持つことはできません。
1456 matchfix演算子として再宣言することができます。
1457 特に、足し算@code{+}のような組み込み演算子が
1458 matchfixに宣言されることが可能ですが、
1459 演算子関数は組み込み演算子に関して定義できません。
1461 コマンド@code{matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos},
1463 引数品詞@var{arg_pos}と結果品詞@var{pos}、区切り記号
1464 @var{ldelimiter}と@var{rdelimiter}を宣言します。
1466 演算子宣言に関して、「品詞」は式のタイプを意味します。
1468 それぞれ、代数式、ブーリアン式、任意の種類の式を示す、
1469 @code{expr}, @code{clause}, @code{any}。
1471 宣言された品詞を実際の式と比較することで、
1474 @c DUNNO IF WE REALLY NEED TO MENTION BINDING POWER HERE -- AS NOTED IT'S IRRELEVANT
1475 @c An operator declared by @code{matchfix} is assigned a low binding power.
1476 @c Since a matchfix operator must be evaluated before any expression
1477 @c which contains it,
1478 @c binding power is effectively irrelevant
1479 @c to the declaration of a matchfix operator.
1481 matchfix演算を実行する関数は通常のユーザー定義関数です。
1483 関数定義演算子@code{:=}や@code{define}を使って
1486 クォートされた文字列としての左区切り記号と括弧の中で続く引数を使って書かれます。
1487 @code{dispfun (@var{ldelimiter})}は関数定義を表示します。
1489 唯一の組み込みmatchfix演算子はリスト構成子@code{[ ]}です。
1490 括弧@code{( )}とダブルクォート@code{" "}はmatchfix演算子のように振る舞いますが、
1491 Maximaパーサによってそのようには扱われません。
1493 @code{matchfix}は引数を評価します。
1494 @code{matchfix}は最初の引数@var{ldelimiter}を返します。
1495 @c HOW TO TAKE AWAY THE MATCHFIX PROPERTY ??
1499 区切り記号はほとんど任意の文字列を取り得ます。
1502 @c matchfix ("@@", "~");
1504 @c matchfix (">>", "<<");
1506 @c matchfix ("foo", "oof");
1508 @c >> w + foo x, y oof + z << / @@ p, q ~;
1511 (%i1) matchfix ("@@@@", "~");
1513 (%i2) @@@@ a, b, c ~;
1515 (%i3) matchfix (">>", "<<");
1517 (%i4) >> a, b, c <<;
1519 (%i5) matchfix ("foo", "oof");
1521 (%i6) foo a, b, c oof;
1523 (%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
1524 >>z + foox, yoof + w<<
1525 (%o7) ----------------------
1529 Matchfix演算子は通常のユーザー定義関数です。
1532 (%i1) matchfix ("!-", "-!");
1534 (%i2) !- x, y -! := x/y - y/x;
1536 (%o2) !-x, y-! := - - -
1538 (%i3) define (!-x, y-!, x/y - y/x);
1540 (%o3) !-x, y-! := - - -
1542 (%i4) define ("!-" (x, y), x/y - y/x);
1544 (%o4) !-x, y-! := - - -
1546 (%i5) dispfun ("!-");
1548 (%t5) !-x, y-! := - - -
1564 @category{Operators}
1568 @c -----------------------------------------------------------------------------
1569 @anchor{operator_nary}
1570 @deffn {関数} nary (@var{op})
1571 @deffnx {関数} nary (@var{op}, @var{bp}, @var{arg_pos}, @var{pos})
1574 任意の数の引数の関数を示すのに使われます。
1575 引数それぞれは、例えば、A+BやA+B+Cように演算子の出現で分離されます。
1577 @code{x}を @code{nary}演算子に宣言する構文拡張関数です。
1578 関数は @code{nary}であると宣言されるかもしれません。
1579 もし @code{declare(j,nary);}が実行されたら、
1581 例えば、@code{j(j(a,b),j(c,d))}を @code{j(a, b, c, d)}に整理するよう指示します。
1583 @ref{Introduction to operators}も参照してください。
1586 @category{Operators}
1591 @c -----------------------------------------------------------------------------
1593 @deffn {関数} nofix (@var{op})
1594 @deffnx {関数} nofix (@var{op}, @var{pos})
1596 @code{nofix}演算子は引数のない関数を示すのに使われます。
1599 例えば、Maximaブレイクから抜けるために"exit;"とタイプする時、
1600 "exit"は@code{nofix}演算子と似たように振る舞います。
1601 関数 @code{nofix("x")}は
1602 @code{x}を @code{nofix}演算子に宣言する構文拡張関数です。
1604 @ref{Introduction to operators}も参照してください。
1607 @category{Operators}
1612 @c -----------------------------------------------------------------------------
1614 @deffn {関数} postfix (@var{op})
1615 @deffnx {関数} postfix (@var{op}, @var{lbp}, @var{lpos}, @var{pos})
1617 @code{prefix}変種のような@code{postfix}演算子は引数一つの関数を示しますが、
1618 この場合、例えば3!のように、入力文字列の中で引数が演算子に先行します。
1619 @code{postfix("x")}関数は @code{x}を@code{postfix}演算子に宣言する構文拡張関数です。
1621 @ref{Introduction to operators}も参照してください。
1624 @category{Operators}
1629 @c -----------------------------------------------------------------------------
1631 @deffn {関数} prefix (@var{op})
1632 @deffnx {関数} prefix (@var{op}, @var{rbp}, @var{rpos}, @var{pos})
1634 @code{prefix}演算子は引数一つの関数であり、
1635 その引数は演算子のすぐ後ろに置かれます。
1636 @code{prefix("x")}は @code{x}を@code{prefix}演算子に宣言する構文拡張関数です。
1638 @ref{Introduction to operators}も参照してください。
1641 @category{Operators}