| blob | 5a493b428b9f84e6e07c7092facf97684d858e49 |
1 @menu
2 * Introduction to operators::
3 * Arithmetic operators::
4 * Relational operators::
5 * Logical operators::
6 * Operators for Equations::
7 * Assignment operators::
8 * User defined operators::
9 @end menu
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 異なるタイプの演算子の例として、以下があります。
23 @table @asis
24 @item unary prefix
25 negation @code{- a}
26 @item unary postfix
27 factorial @code{a!}
28 @item binary infix
29 exponentiation @code{a^b}
30 @item n-ary infix
31 addition @code{a + b}
32 @item matchfix
33 list construction @code{[a, b]}
34 @end table
36 (組み込みの無項演算子はありません; そんな演算子の例は、@code{nofix}を参照してください。.)
38 新しい演算子を定義するメカニズムはわかりやすいものです。
39 関数を演算子として宣言することだけが必要です;
40 演算子関数は定義されることもされないこともあります。
42 ユーザー定義の演算子の例は以下の通りです。
43 明示的な関数コール @code{"dd" (a)}は @code{dd a}と同値であり、また、
44 @code{"<-" (a, b)}は @code{a <- b}と同値であることに注意してください。
45 この例で、 @code{"dd"}と @code{"<-"}は未定義です。
47 @c ===beg===
48 @c prefix ("dd");
49 @c dd a;
50 @c "dd" (a);
51 @c infix ("<-");
52 @c a <- dd b;
53 @c "<-" (a, "dd" (b));
54 @c ===end===
55 @example
56 (%i1) prefix ("dd");
57 (%o1) dd
58 (%i2) dd a;
59 (%o2) dd a
60 (%i3) "dd" (a);
61 (%o3) dd a
62 (%i4) infix ("<-");
63 (%o4) <-
64 (%i5) a <- dd b;
65 (%o5) a <- dd b
66 (%i6) "<-" (a, "dd" (b));
67 (%o6) a <- dd b
68 @end example
70 新しい演算子を定義するMaxima関数はこの表にまとめられます。
71 デフォルトの左と右の結合力(それぞれlbpとrbp)を記載します。
72 @c REWORK FOLLOWING COMMENT.
73 @c IT'S NOT CLEAR ENOUGH, GIVEN THAT IT'S FAIRLY IMPORTANT
74 (結合力は演算子の優先順位を決めます。
75 しかしながら、左と右の結合力は異なることがあり、
76 結合力は優先順位より幾分複雑です。)
77 演算定義関数のいくつかは追加の引数を取ります;
78 詳細は関数記述を参照してください。
80 @c MAKE ANCHORS FOR ALL 6 FUNCTIONS AND CHANGE @code TO @ref ACCORDINGLY
81 @table @code
82 @item prefix
83 rbp=180
84 @item postfix
85 lbp=180
86 @item infix
87 lbp=180, rbp=180
88 @item nary
89 lbp=180, rbp=180
90 @item matchfix
91 (binding power not applicable)
92 @item nofix
93 (binding power not applicable)
94 @end table
96 比較のために、いくつかの組み込み演算子と左右結合力を上げます。
98 @example
99 Operator lbp rbp
101 : 180 20
102 :: 180 20
103 := 180 20
104 ::= 180 20
105 ! 160
106 !! 160
107 ^ 140 139
108 . 130 129
109 * 120
110 / 120 120
111 + 100 100
112 - 100 134
113 = 80 80
114 # 80 80
115 > 80 80
116 >= 80 80
117 < 80 80
118 <= 80 80
119 not 70
120 and 65
121 or 60
122 , 10
123 $ -1
124 ; -1
125 @end example
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
133 @c ===beg===
134 @c infix ("##");
135 @c "##" (a, b) := a^b;
136 @c 5 ## 3;
137 @c remove ("##", op);
138 @c 5 ## 3;
139 @c "##" (5, 3);
140 @c infix ("##");
141 @c 5 ## 3;
142 @c kill ("##");
143 @c 5 ## 3;
144 @c "##" (5, 3);
145 @c ===end===
146 @example
147 (%i1) infix ("##");
148 (%o1) ##
149 (%i2) "##" (a, b) := a^b;
150 b
151 (%o2) a ## b := a
152 (%i3) 5 ## 3;
153 (%o3) 125
154 (%i4) remove ("##", op);
155 (%o4) done
156 (%i5) 5 ## 3;
157 Incorrect syntax: # is not a prefix operator
158 5 ##
159 ^
160 (%i5) "##" (5, 3);
161 (%o5) 125
162 (%i6) infix ("##");
163 (%o6) ##
164 (%i7) 5 ## 3;
165 (%o7) 125
166 (%i8) kill ("##");
167 (%o8) done
168 (%i9) 5 ## 3;
169 Incorrect syntax: # is not a prefix operator
170 5 ##
171 ^
172 (%i9) "##" (5, 3);
173 (%o9) ##(5, 3)
174 @end example
176 @opencatbox
177 @category{Operators}
178 @category{Syntax}
179 @closecatbox
181 @c -----------------------------------------------------------------------------
182 @node Arithmetic operators, Relational operators, Introduction to operators, Operators
183 @section Arithmetic operators
184 @c -----------------------------------------------------------------------------
186 @c -----------------------------------------------------------------------------
187 @anchor{+}
188 @anchor{-}
189 @anchor{*}
190 @anchor{/}
191 @anchor{^}
192 @deffn {演算子} +
193 @ifinfo
194 @fnindex 足し算
195 @end ifinfo
196 @deffnx {演算子} -
197 @ifinfo
198 @fnindex 引き算
199 @end ifinfo
200 @deffnx {演算子} *
201 @ifinfo
202 @fnindex かけ算
203 @end ifinfo
204 @deffnx {演算子} /
205 @ifinfo
206 @fnindex 割り算
207 @end ifinfo
208 @deffnx {演算子} ^
209 @ifinfo
210 @fnindex べき乗
211 @end ifinfo
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{"-"}を足し算の単項逆元演算子の名前としてのみ認識して、
224 二項引き算演算子としては認識しません。
226 Maximaの中では割り算@code{a / b}をかけ算@code{a * b^(- 1)}として表現します。
227 @code{a * b^(- 1)}のような式は割り算として表示されます。
228 Maximaは@code{"/"}を割り算演算子の名前として認識します。
230 足し算とかけ算はn項可換演算子です。
231 割り算とべき乗は二項の非可換演算子です。
233 Maximaは正準表現を構成するために可換演算子のオペランド(訳注：引数)を並べ替えます。
234 順序は内部的には @code{orderlessp}で決定します。
235 表示のためには、足し算の順序は @code{ordergreatp}で決定し、
236 かけ算は内部的な順序と同じです。
238 算術計算は、数リテラル（整数、有理数、通常の浮動小数点、多倍長浮動小数点）上で実行されます。
239 べき乗を除いて、数に対するすべての算術演算子は数に整理されます。
240 べき乗は、オペランドが通常の浮動小数点か多倍長浮動小数点の時、もしくは結果が厳密に整数もしくは有理数の時、数に整理されます;
241 そうでなければ、べき乗は @code{sqrt}か他のべき乗に整理されるか、そのまま残されます。
243 浮動小数点の伝搬が算術計算に適用されます:
244 もしどれか１つでもオペランドが多倍長浮動小数点なら、結果は多倍長浮動小数点です;
245 そうでなければ、もしどれか１つでもオペランドが通常の浮動小数点なら、結果は通常の浮動小数点です;
246 そうでなければオペランドは有理数か整数であり、結果は有理数か整数です。
248 算術計算は式整理であって、評価ではありません。
249 従って、クォートされた（しかし整理される）式の中で算術計算は実行されます。
251 算術演算は、
252 グローバルフラグ @code{listarith}が @code{true}の時
253 リストに対して要素毎に適用され、
254 行列に対しては常に要素毎に適用されます。
255 オペランドの１つがリストか行列であり、もう１つのオペランドが別のタイプの時、
256 他のオペランドはリストか行列の要素のそれぞれに組み合わされます。
258 例:
260 足し算とかけ算は、n項可換演算子です。
261 Maximaは、正準表現を構成するために、可換演算子のオペランドを並べ替えます。
262 それらの名前はそれぞれ @code{"+"}と @code{"*"}です。
264 @c ===beg===
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]);
271 @c ===end===
272 @example
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;
278 (%o3) a b c d e f g
279 (%i4) [op (%), args (%)];
280 (%o4) [*, [a, b, c, d, e, f, g]]
281 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
282 (%o5) 3 x + 2 a + 19
283 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
284 2 3
285 (%o6) 144 a x
286 @end example
288 割り算とべき乗は、二項の非可換演算子です。
289 それらの名前はそれぞれ @code{"/"}と @code{"^"}です。
291 @c ===beg===
292 @c [a / b, a ^ b];
293 @c [map (op, %), map (args, %)];
294 @c [apply ("/", [a, b]), apply ("^", [a, b])];
295 @c ===end===
296 @example
297 (%i1) [a / b, a ^ b];
298 a b
299 (%o1) [-, a ]
300 b
301 (%i2) [map (op, %), map (args, %)];
302 (%o2) [[/, ^], [[a, b], [a, b]]]
303 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
304 a b
305 (%o3) [-, a ]
306 b
307 @end example
309 引き算と割り算は内部的にはそれぞれ、足し算とかけ算を使って表現されます。
311 @c ===beg===
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)];
314 @c ===end===
315 @example
316 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
317 (%o1) [+, a, - b]
318 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
319 1
320 (%o2) [*, a, -]
321 b
322 @end example
324 計算は数リテラルに対して実行されます。
325 浮動小数点伝搬が適用されます。
327 @c ===beg===
328 @c 17 + b - (1/2)*29 + 11^(2/4);
329 @c [17 + 29, 17 + 29.0, 17 + 29b0];
330 @c ===end===
331 @example
332 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
333 5
334 (%o1) b + sqrt(11) + -
335 2
336 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
337 (%o2) [46, 46.0, 4.6b1]
338 @end example
340 算術計算は式整理であって、評価ではありません。
342 @c ===beg===
343 @c simp : false;
344 @c '(17 + 29*11/7 - 5^3);
345 @c simp : true;
346 @c '(17 + 29*11/7 - 5^3);
347 @c ===end===
348 @example
349 (%i1) simp : false;
350 (%o1) false
351 (%i2) '(17 + 29*11/7 - 5^3);
352 29 11 3
353 (%o2) 17 + ----- - 5
354 7
355 (%i3) simp : true;
356 (%o3) true
357 (%i4) '(17 + 29*11/7 - 5^3);
358 437
359 (%o4) - ---
360 7
361 @end example
363 算術計算は（@code{listarith}に依存して）リストや行列に対して要素毎に実行されます。
365 @c ===beg===
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];
370 @c [a, c, m, t] ^ x;
371 @c listarith : true;
372 @c [a, c, m, t] / [1, 7, 2, 9];
373 @c [a, c, m, t] ^ x;
374 @c ===end===
375 @example
376 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
377 @group
378 [ a - 1 x - 2 ]
379 (%o1) [ ]
380 [ h - 3 u - 4 ]
381 @end group
382 (%i2) 5 * matrix ([a, x], [h, u]);
384 [ 5 a 5 x ]
385 (%o2) [ ]
386 [ 5 h 5 u ]
387 (%i3) listarith : false;
388 (%o3) false
389 (%i4) [a, c, m, t] / [1, 7, 2, 9];
390 [a, c, m, t]
391 (%o4) ------------
392 [1, 7, 2, 9]
393 (%i5) [a, c, m, t] ^ x;
394 x
395 (%o5) [a, c, m, t]
396 (%i6) listarith : true;
397 (%o6) true
398 (%i7) [a, c, m, t] / [1, 7, 2, 9];
399 c m t
400 (%o7) [a, -, -, -]
401 7 2 9
402 (%i8) [a, c, m, t] ^ x;
403 x x x x
404 (%o8) [a , c , m , t ]
405 @end example
407 @opencatbox
408 @category{Operators}
409 @closecatbox
410 @end deffn
412 @c -----------------------------------------------------------------------------
413 @anchor{**}
414 @deffn {演算子} **
416 べき乗演算子。
417 Maximaは入力の中で @code{**}を @code{^}と同じ演算子と認識し、
418 1次元出力の中では @code{^}として表示し、
419 また、2次元出力の中では指数を上付き添字として配置します。
421 @mref{fortran}関数は、入力が @code{**}でも @code{^}でも、
422 べき乗演算子を @code{**}として表示します。
424 例:
426 @c ===beg===
427 @c is (a**b = a^b);
428 @c x**y + x^z;
429 @c string (x**y + x^z);
430 @c fortran (x**y + x^z);
431 @c ===end===
432 @example
433 (%i1) is (a**b = a^b);
434 (%o1) true
435 (%i2) x**y + x^z;
436 z y
437 (%o2) x + x
438 (%i3) string (x**y + x^z);
439 (%o3) x^z+x^y
440 (%i4) fortran (x**y + x^z);
441 x**z+x**y
442 (%o4) done
443 @end example
445 @opencatbox
446 @category{Operators}
447 @closecatbox
448 @end deffn
450 @c -----------------------------------------------------------------------------
451 @anchor{^^}
452 @deffn {演算子} ^^
453 @ifinfo
454 @fnindex 非可換べき乗
455 @end ifinfo
457 非可換べき乗演算子。
458 ちょうど可換なかけ算 @code{*}に通常のべき乗演算子 @code{^}が対応するように、
459 @code{^^}は非可換かけ算 @code{.}に対応するべき乗演算子です。
461 非可換べき乗演算子は、１次元出力では @code{^^}で表示され、
462 ２次元出力では、指数をかっこ @code{< >}で囲まれた上付き添字として置きます。
464 例:
466 @c ===beg===
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);
469 @c ===end===
470 @example
471 (%i1) a . a . b . b . b + a * a * a * b * b;
472 3 2 <2> <3>
473 (%o1) a b + a . b
474 (%i2) string (a . a . b . b . b + a * a * a * b * b);
475 (%o2) a^3*b^2+a^^2 . b^^3
476 @end example
478 @opencatbox
479 @category{Operators}
480 @closecatbox
481 @end deffn
483 @c -----------------------------------------------------------------------------
484 @anchor{.}
485 @deffn {演算子} .
486 @ifinfo
487 @fnindex 非可換かけ算
488 @end ifinfo
490 行列（非可換）かけ算のためのドット演算子。
491 @code{"."}をこの意味で用いる時、
492 例えば @code{A . B}のように両側にスペースを置かなければいけません。
493 これで浮動小数点の小数点と区別します。
495 @code{dot}や
496 @code{dot0nscsimp},
497 @code{dot0simp},
498 @code{dot1simp},
499 @code{dotassoc},
500 @code{dotconstrules},
501 @code{dotdistrib},
502 @code{dotexptsimp},
503 @code{dotident},
504 @code{dotscrules}.
505 も参照してください。
507 @opencatbox
508 @category{Operators}
509 @closecatbox
510 @end deffn
512 @c -----------------------------------------------------------------------------
513 @node Relational operators, Logical operators, Arithmetic operators, Operators
514 @section Relational operators
515 @c -----------------------------------------------------------------------------
517 @c -----------------------------------------------------------------------------
518 @anchor{<}
519 @anchor{<=}
520 @anchor{>=}
521 @anchor{>}
522 @deffn {演算子} <
523 @ifinfo
524 @fnindex 小なり
525 @end ifinfo
526 @deffnx {演算子} <=
527 @ifinfo
528 @fnindex 以下
529 @end ifinfo
530 @deffnx {演算子} >=
531 @ifinfo
532 @fnindex 以上
533 @end ifinfo
534 @deffnx {演算子} >
535 @ifinfo
536 @fnindex 大なり
537 @end ifinfo
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}が
548 関係式をブーリアン値に評価します。
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}も参照してください。
566 例:
568 いくつかの関数やプログラミング構成子が関係式をブーリアン値に評価します。
570 @c ===beg===
571 @c [x, y, z] : [123, 456, 789];
572 @c is (x < y);
573 @c maybe (y > z);
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,
576 @c return (S));
577 @c ===end===
578 @example
579 (%i1) [x, y, z] : [123, 456, 789];
580 (%o1) [123, 456, 789]
581 (%i2) is (x < y);
582 (%o2) true
583 (%i3) maybe (y > z);
584 (%o3) false
585 (%i4) if x >= z then 1 else 0;
586 (%o4) 0
587 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
588 return (S));
589 (%o5) 5050
590 @end example
592 そうでなければ関係式はブーリアン値に評価されたり整理されたりしませんが、
593 関係式の引数は評価されます。
595 @c ===beg===
596 @c [x, y, z] : [123, 456, 789];
597 @c [x < y, y <= z, z >= y, y > z];
598 @c map (is, %);
599 @c ===end===
600 @example
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]
604 (%i3) map (is, %);
605 (%o3) [true, true, true, false]
606 @end example
608 @opencatbox
609 @category{Operators}
610 @closecatbox
611 @end deffn
613 @c -----------------------------------------------------------------------------
614 @node Logical operators, Operators for Equations, Relational operators, Operators
615 @section Logical operators
616 @c -----------------------------------------------------------------------------
618 @c NEEDS EXAMPLES
620 @c -----------------------------------------------------------------------------
621 @anchor{and}
622 @deffn {演算子} and
623 @ifinfo
624 @fnindex 論理積
625 @end ifinfo
627 論理積演算子。
628 @code{and}は、n項中置演算子です;
629 オペランドはブーリアン値で、結果もブーリアン値です。
631 @code{and}は、（@code{is}のように）１以上のオペランドの評価を強制し、
632 すべてのオペランドの評価を強制するかもしれません。
634 オペランドは、出現順に評価されます。
635 @code{and}は、結果を決定するのに必要なだけオペランドを評価します。
636 もし任意のオペランドが@code{false}なら、結果は@code{false}であり、
637 ほかのオペランドは評価されません。
639 グローバルフラグ@code{prederror}は、
640 評価されたオペランドが@code{true}か@code{false}に決定できない時の@code{and}の振る舞いを決定します。
641 @code{prederror}が@code{true}の時、@code{and}は、エラーメッセージを出力します。
642 そうでなければ、@code{true}か@code{false}に評価されないオペランドを受け付け、
643 結果はブーリアン式になります。
645 @code{and}は可換ではありません:
646 @code{a and b}は、不定のオペランドの扱いのため、@code{b and a}と同値ではないかもしれません。
648 @opencatbox
649 @category{Operators}
650 @closecatbox
651 @end deffn
653 @c NEEDS EXAMPLES
655 @c -----------------------------------------------------------------------------
656 @anchor{not}
657 @deffn {演算子} not
658 @ifinfo
659 @fnindex 論理否定
660 @end ifinfo
662 論理否定演算子。
663 @code{not}は、接頭演算子です;
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}に評価されないオペランドを受け付け、
672 結果はブーリアン式になります。
674 @opencatbox
675 @category{Operators}
676 @closecatbox
677 @end deffn
679 @c NEEDS EXAMPLES
681 @c -----------------------------------------------------------------------------
682 @anchor{or}
683 @deffn {演算子} or
684 @ifinfo
685 @fnindex 論理和
686 @end ifinfo
688 論理和演算子。
689 @code{or}は、n項中置演算子です;
690 オペランドはブーリアン値で、結果もブーリアン値です。
692 @code{or}は、（@code{is}のように）１以上のオペランドの評価を強制し、
693 すべてのオペランドの評価を強制するかもしれません。
695 オペランドは、出現順に評価されます。
696 @code{and}は、結果を決定するのに必要なだけオペランドを評価します。
697 もし任意のオペランドが@code{true}なら、結果は@code{true}であり、
698 ほかのオペランドは評価されません。
700 グローバルフラグ@code{prederror}は、
701 評価されたオペランドが@code{true}か@code{false}に決定できない時の@code{or}の振る舞いを決定します。
702 @code{prederror}が@code{true}の時、@code{or}は、エラーメッセージを出力します。
703 そうでなければ、@code{true}か@code{false}に評価されないオペランドを受け付け、
704 結果はブーリアン式になります。
706 @code{or}は可換ではありません:
707 @code{a or b}は、不定のオペランドの扱いのため、@code{b or a}と同値ではないかもしれません。
709 @opencatbox
710 @category{Operators}
711 @closecatbox
712 @end deffn
714 @c -----------------------------------------------------------------------------
715 @node Operators for Equations, Assignment operators, Logical operators, Operators
716 @section Operators for Equations
717 @c -----------------------------------------------------------------------------
719 @c -----------------------------------------------------------------------------
720 @anchor{#}
721 @deffn {演算子} #
722 @ifinfo
723 @fnindex 不等号（構文的不等号）
724 @end ifinfo
725 構文的等号@code{=}の否定を表します。
727 述語論理式の評価のルールのため
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})}と同値です。
732 例:
734 @c ===beg===
735 @c a = b;
736 @c is (a = b);
737 @c a # b;
738 @c not a = b;
739 @c is (a # b);
740 @c is (not a = b);
741 @c ===end===
742 @example
743 (%i1) a = b;
744 (%o1) a = b
745 (%i2) is (a = b);
746 (%o2) false
747 (%i3) a # b;
748 (%o3) a # b
749 (%i4) not a = b;
750 (%o4) true
751 (%i5) is (a # b);
752 (%o5) true
753 (%i6) is (not a = b);
754 (%o6) true
755 @end example
757 @opencatbox
758 @category{Operators}
759 @closecatbox
760 @end deffn
762 @c -----------------------------------------------------------------------------
763 @anchor{=}
764 @deffn {演算子} =
765 @ifinfo
766 @fnindex 等式演算子
767 @fnindex 等号 (構文法的に等しい)
768 @end ifinfo
770 等式演算子。
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}という演算子です。
794 述語論理式の評価規則のため
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}も参照してください。
803 例:
805 式@code{@var{a} = @var{b}}は、それ自身、未評価の等式であり、成り立つことも成り立たないこともあります。
807 @c ===beg===
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]);
812 @c ratsimp (%);
813 @c ===end===
814 @example
815 (%i1) eq_1 : a * x - 5 * y = 17;
816 (%o1) a x - 5 y = 17
817 (%i2) eq_2 : b * x + 3 * y = 29;
818 (%o2) 3 y + b x = 29
819 (%i3) solve ([eq_1, eq_2], [x, y]);
820 196 29 a - 17 b
821 (%o3) [[x = ---------, y = -----------]]
822 5 b + 3 a 5 b + 3 a
823 (%i4) subst (%, [eq_1, eq_2]);
824 196 a 5 (29 a - 17 b)
825 (%o4) [--------- - --------------- = 17,
826 5 b + 3 a 5 b + 3 a
827 196 b 3 (29 a - 17 b)
828 --------- + --------------- = 29]
829 5 b + 3 a 5 b + 3 a
830 (%i5) ratsimp (%);
831 (%o5) [17 = 17, 29 = 29]
832 @end example
834 @code{is(@var{a} = @var{b})}は、
835 @var{a}と@var{b}が構文法的に等しい（すなわち、同一の）時
836 式は、同値だが構文法的に等しくないことがありえます。
838 @c ===beg===
839 @c a : (x + 1) * (x - 1);
840 @c b : x^2 - 1;
841 @c [is (a = b), is (a # b)];
842 @c [is (equal (a, b)), is (notequal (a, b))];
843 @c ===end===
844 @example
845 (%i1) a : (x + 1) * (x - 1);
846 (%o1) (x - 1) (x + 1)
847 (%i2) b : x^2 - 1;
848 2
849 (%o2) x - 1
850 (%i3) [is (a = b), is (a # b)];
851 (%o3) [false, true]
852 (%i4) [is (equal (a, b)), is (notequal (a, b))];
853 (%o4) [true, false]
854 @end example
856 いくつかの演算子は、@code{=}と@code{#}を@code{true}もしくは@code{false}に評価します。
858 @c ===beg===
859 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
860 @c BAR;
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];
864 @c ===end===
865 @example
866 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
867 BAR;
868 (%o1) FOO
869 (%i2) eq_3 : 2 * x = 3 * x;
870 (%o2) 2 x = 3 x
871 (%i3) eq_4 : exp (2) = %e^2;
872 2 2
873 (%o3) %e = %e
874 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
875 (%o4) [false, true, true]
876 @end example
878 @code{not @var{expr}}は@var{expr}の評価をするので、
879 @code{not @var{a} = @var{b}}は、@code{is(@var{a} # @var{b})}と同値です。
881 @c ===beg===
882 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
883 @c is (2 * x # 3 * x);
884 @c ===end===
885 @example
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);
889 (%o2) true
890 @end example
892 @opencatbox
893 @category{Operators}
894 @closecatbox
895 @end deffn
897 @c -----------------------------------------------------------------------------
898 @node Assignment operators, User defined operators, Operators for Equations, Operators
899 @section Assignment operators
900 @c -----------------------------------------------------------------------------
902 @c -----------------------------------------------------------------------------
903 @anchor{:}
904 @deffn {演算子} :
905 @ifinfo
906 @fnindex 割り当て演算子
907 @end ifinfo
909 割り当て演算子。
911 左辺が（添字のない）単純変数の時、 @code{:}は右辺を評価し、その値を左辺に関連づけます。
913 左辺がリストや行列、宣言されたMaxima配列、Lisp配列の添字指定された要素の時、
914 右辺がその要素に割り当てられます。
915 添字は存在している要素を示していなければなりません;
916 先に列挙した対象は、存在していない要素を名付けることで拡張することはできません。
918 左辺が未宣言のMaxima配列の添字指定された要素の時、
919 もし既に存在しているなら、右辺はその要素に割り当てられ、
920 もしまだ存在していなければ新しい要素が確保されます。
922 左辺が単純変数や添字あり変数のリストの時、
923 右辺はリストに評価されなければなりません。
924 そして、右辺の要素が左辺の要素に平行に割り当てられます。
926 @mref{kill}や@mref{remvalue}も参照してください。
927 それらは左辺とその値の関連をアンドゥします。
929 例:
931 単純変数への割り当て
933 @c ===beg===
934 @c a;
935 @c a : 123;
936 @c a;
937 @c ===end===
938 @example
939 (%i1) a;
940 (%o1) a
941 (%i2) a : 123;
942 (%o2) 123
943 (%i3) a;
944 (%o3) 123
945 @end example
947 リストの要素への割り当て
949 @c ===beg===
950 @c b : [1, 2, 3];
951 @c b[3] : 456;
952 @c b;
953 @c ===end===
954 @example
955 (%i1) b : [1, 2, 3];
956 (%o1) [1, 2, 3]
957 (%i2) b[3] : 456;
958 (%o2) 456
959 (%i3) b;
960 (%o3) [1, 2, 456]
961 @end example
963 割り当ては未宣言配列を生成する。
965 @c ===beg===
966 @c c[99] : 789;
967 @c c[99];
968 @c c;
969 @c arrayinfo (c);
970 @c listarray (c);
971 @c ===end===
972 @example
973 (%i1) c[99] : 789;
974 (%o1) 789
975 (%i2) c[99];
976 (%o2) 789
977 (%i3) c;
978 (%o3) c
979 (%i4) arrayinfo (c);
980 (%o4) [hashed, 1, [99]]
981 (%i5) listarray (c);
982 (%o5) [789]
983 @end example
985 多重割り当て
987 @c ===beg===
988 @c [a, b, c] : [45, 67, 89];
989 @c a;
990 @c b;
991 @c c;
992 @c ===end===
993 @example
994 (%i1) [a, b, c] : [45, 67, 89];
995 (%o1) [45, 67, 89]
996 (%i2) a;
997 (%o2) 45
998 (%i3) b;
999 (%o3) 67
1000 (%i4) c;
1001 (%o4) 89
1002 @end example
1004 多重割り当ては平行に実行されます。
1005 この例では@code{a}と@code{b}の値が置換されます。
1007 @c ===beg===
1008 @c [a, b] : [33, 55];
1009 @c [a, b] : [b, a];
1010 @c a;
1011 @c b;
1012 @c ===end===
1013 @example
1014 (%i1) [a, b] : [33, 55];
1015 (%o1) [33, 55]
1016 (%i2) [a, b] : [b, a];
1017 (%o2) [55, 33]
1018 (%i3) a;
1019 (%o3) 55
1020 (%i4) b;
1021 (%o4) 33
1022 @end example
1024 @opencatbox
1025 @category{Evaluation}
1026 @category{Operators}
1027 @closecatbox
1028 @end deffn
1030 @c -----------------------------------------------------------------------------
1031 @need 900
1032 @anchor{::}
1033 @deffn {演算子} ::
1034 @ifinfo
1035 @fnindex 割り当て演算子 (左辺を評価する)
1036 @end ifinfo
1038 割り当て演算子。
1040 @code{::}は、@code{::}は右辺はもちろん左辺も評価することを除いて、@mref{:}と同じです。
1042 例:
1044 @c ===beg===
1045 @c x : 'foo;
1046 @c x :: 123;
1047 @c foo;
1048 @c x : '[a, b, c];
1049 @c x :: [11, 22, 33];
1050 @c a;
1051 @c b;
1052 @c c;
1053 @c ===end===
1054 @example
1055 (%i1) x : 'foo;
1056 (%o1) foo
1057 (%i2) x :: 123;
1058 (%o2) 123
1059 (%i3) foo;
1060 (%o3) 123
1061 (%i4) x : '[a, b, c];
1062 (%o4) [a, b, c]
1063 (%i5) x :: [11, 22, 33];
1064 (%o5) [11, 22, 33]
1065 (%i6) a;
1066 (%o6) 11
1067 (%i7) b;
1068 (%o7) 22
1069 (%i8) c;
1070 (%o8) 33
1071 @end example
1073 @opencatbox
1074 @category{Evaluation}
1075 @category{Operators}
1076 @closecatbox
1077 @end deffn
1079 @c -----------------------------------------------------------------------------
1080 @anchor{::=}
1081 @deffn {演算子} ::=
1082 @ifinfo
1083 @fnindex マクロ関数定義の演算子
1084 @end ifinfo
1086 マクロ関数定義の演算子。
1087 @code{::=}は、引数をクォートする関数（歴史的理由によりマクロと呼ばれる）を定義します。
1088 そして、それが返す式（マクロ展開と呼ばれる）はマクロが呼ばれた文脈の中で評価されます。
1089 それ以外はマクロ関数は通常の関数と同じです。
1091 @mref{macroexpand}は（評価せずに）マクロ展開を返します。
1092 @code{foo}がマクロ関数の時、
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}はそれぞれマクロ関数定義を返し、
1101 それをラベルに割り当てます。
1103 評価対象となる式を構成するために、
1104 マクロ関数は一般的に@mref{buildq}, @mref{splice}式を含みます。
1106 例
1108 マクロ関数は引数をクォートします。
1109 だから、メッセージ(1)は @code{y - z}の値ではなく、 @code{y - z}を示します。
1110 マクロ展開（クォートされた式 @code{'(print ("(2) x is equal to", x)}）は、
1111 マクロが呼ばれた文脈（表示メッセージ(2)）の中で評価されます。
1113 @c ===beg===
1114 @c x: %pi$
1115 @c y: 1234$
1116 @c z: 1729 * w$
1117 @c printq1 (x) ::= block (print ("(1) x is equal to", x),
1118 @c '(print ("(2) x is equal to", x)))$
1119 @c printq1 (y - z);
1120 @c ===end===
1121 @example
1122 (%i1) x: %pi$
1123 (%i2) y: 1234$
1124 (%i3) z: 1729 * w$
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
1130 (%o5) %pi
1131 @end example
1133 通常の関数は引数を評価します。だから、メッセージ(1)は @code{y - z}の値を示します。
1134 戻り値は評価されず、従って、メッセージ(2)は @code{``%}で陽に評価されるまで出力されません。
1136 @c ===beg===
1137 @c x: %pi$
1138 @c y: 1234$
1139 @c z: 1729 * w$
1140 @c printe1 (x) := block (print ("(1) x is equal to", x),
1141 @c '(print ("(2) x is equal to", x)))$
1142 @c printe1 (y - z);
1143 @c ''%;
1144 @c ===end===
1145 @example
1146 (%i1) x: %pi$
1147 (%i2) y: 1234$
1148 (%i3) z: 1729 * w$
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)
1154 (%i6) ''%;
1155 (2) x is equal to %pi
1156 (%o6) %pi
1157 @end example
1159 @code{macroexpand}はマクロ展開を返します。
1160 @code{foo}がマクロ関数の時、
1161 @code{macroexpand (foo (x))}の後 @code{``%}を実行すると、@code{foo (x)}と同値です。
1163 @c ===beg===
1164 @c x: %pi$
1165 @c y: 1234$
1166 @c z: 1729 * w$
1167 @c g (x) ::= buildq ([x], print ("x is equal to", x))$
1168 @c macroexpand (g (y - z));
1169 @c ''%;
1170 @c g (y - z);
1171 @c ===end===
1172 @example
1173 (%i1) x: %pi$
1174 (%i2) y: 1234$
1175 (%i3) z: 1729 * w$
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)
1179 (%i6) ''%;
1180 x is equal to 1234 - 1729 w
1181 (%o6) 1234 - 1729 w
1182 (%i7) g (y - z);
1183 x is equal to 1234 - 1729 w
1184 (%o7) 1234 - 1729 w
1185 @end example
1187 @opencatbox
1188 @category{Function definition}
1189 @category{Operators}
1190 @closecatbox
1191 @end deffn
1193 @c -----------------------------------------------------------------------------
1194 @anchor{:=}
1195 @deffn {演算子} :=
1196 @ifinfo
1197 @fnindex 関数定義演算子
1198 @end ifinfo
1200 関数定義の演算子。
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}が要素１つのリストの時、@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{::=}も参照してください。
1219 例:
1221 @code{:=}は（クォートクォートで陽に評価されない限り）関数本体を評価しません。
1223 @c ===beg===
1224 @c expr : cos(y) - sin(x);
1225 @c F1 (x, y) := expr;
1226 @c F1 (a, b);
1227 @c F2 (x, y) := ''expr;
1228 @c F2 (a, b);
1229 @c ===end===
1230 @example
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
1235 (%i3) F1 (a, b);
1236 (%o3) cos(y) - sin(x)
1237 (%i4) F2 (x, y) := ''expr;
1238 (%o4) F2(x, y) := cos(y) - sin(x)
1239 (%i5) F2 (a, b);
1240 (%o5) cos(b) - sin(a)
1241 @end example
1243 @code{:=}で定義された関数は、通常のMaxima関数か、配列関数です。
1245 @c ===beg===
1246 @c G1 (x, y) := x.y - y.x;
1247 @c G2 [x, y] := x.y - y.x;
1248 @c ===end===
1249 @example
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
1254 x, y
1255 @end example
1257 最後の引数@var{x_n}が要素１つのリストの時、
1258 @code{:=}で定義された関数は、可変の数の引数を取ります。
1260 @c ===beg===
1261 @c H ([L]) := apply ("+", L);
1262 @c H (a, b, c);
1263 @c ===end===
1264 @example
1265 (%i1) H ([L]) := apply ("+", L);
1266 (%o1) H([L]) := apply("+", L)
1267 (%i2) H (a, b, c);
1268 (%o2) c + b + a
1269 @end example
1271 @code{local}はローカル関数定義を可能にします。
1273 @c ===beg===
1274 @c foo (x) := 1 - x;
1275 @c foo (100);
1276 @c block (local (foo), foo (x) := 2 * x, foo (100));
1277 @c foo (100);
1278 @c ===end===
1279 @example
1280 (%i1) foo (x) := 1 - x;
1281 (%o1) foo(x) := 1 - x
1282 (%i2) foo (100);
1283 (%o2) - 99
1284 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1285 (%o3) 200
1286 (%i4) foo (100);
1287 (%o4) - 99
1288 @end example
1290 @opencatbox
1291 @category{Function definition}
1292 @category{Operators}
1293 @closecatbox
1294 @end deffn
1296 @c -----------------------------------------------------------------------------
1297 @node User defined operators, , Assignment operators, Operators
1298 @section User defined operators
1299 @c -----------------------------------------------------------------------------
1301 @c -----------------------------------------------------------------------------
1302 @anchor{infix}
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 中置演算子は２つの引数の関数で、引数の間に関数名が来ます。
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})}は、
1316 記述された左右の結合力
1317 とデフォルトの品詞（左右両方とも@code{any})に等しい）で、
1318 @var{op}を中置演算子に宣言します。
1320 @code{infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})}は、
1321 記述された左右の結合力と、
1322 左オペランド、右オペランド、演算子結果それぞれについて、
1323 品詞を@var{lpos}, @var{rpos}, @var{pos}に設定して、
1324 @var{op}を中置演算子に宣言します。
1326 （演算子宣言に関係して）「品詞」は、式のタイプを意味します。
1327 ３つのタイプが認識されます; @code{expr}, @code{clause}, @code{any}。それぞれは、
1328 代数式、ブーリアン式、任意の種類の式を示します。
1329 Maximaは、宣言された品詞を実際の式に比較することで、
1330 いくつかの構文法エラーを検出します。
1332 他の演算子に関する@var{op}の優先順位は、問題となっている演算子の左右結合力から演繹されます。
1333 もし@var{op}の左右結合力のどちらもある他の演算子の左右結合力より大きいなら、
1334 @var{op}は、他の演算子より高い優先順位をとります。
1335 もし結合力がどちらも大きくも、どちらも小さくもなければ、
1336 あるもっと複雑な関係が成り立ちます。
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}と等しいなら、
1346 @var{op}は左結合です。
1348 @code{Syntax}も参照してください。
1350 例:
1352 もし@var{op}左右結合力それぞれが、他の演算子のそれより大きいなら、
1353 @var{op}は他の演算子より高い優先順位をとります。
1355 @c ===beg===
1356 @c :lisp (get '$+ 'lbp)
1357 @c :lisp (get '$+ 'rbp)
1358 @c infix ("##", 101, 101);
1359 @c "##"(a, b) := sconcat("(", a, ",", b, ")");
1360 @c 1 + a ## b + 2;
1361 @c infix ("##", 99, 99);
1362 @c 1 + a ## b + 2;
1363 @c ===end===
1364 @example
1365 (%i1) :lisp (get '$+ 'lbp)
1366 100
1367 (%i1) :lisp (get '$+ 'rbp)
1368 100
1369 (%i1) infix ("##", 101, 101);
1370 (%o1) ##
1371 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
1372 (%o2) (a ## b) := sconcat("(", a, ",", b, ")")
1373 (%i3) 1 + a ## b + 2;
1374 (%o3) (a,b) + 3
1375 (%i4) infix ("##", 99, 99);
1376 (%o4) ##
1377 (%i5) 1 + a ## b + 2;
1378 (%o5) (a+1,b+2)
1379 @end example
1381 より大きな@var{lbp}は@var{op}を右結合にし、
1382 より大きな@var{rbp}は@var{op}を左結合にします。
1384 @c ===beg===
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;
1390 @c ===end===
1391 @example
1392 (%i1) infix ("##", 100, 99);
1393 (%o1) ##
1394 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
1395 (%i3) foo ## bar ## baz;
1396 (%o3) (foo,(bar,baz))
1397 (%i4) infix ("##", 100, 101);
1398 (%o4) ##
1399 (%i5) foo ## bar ## baz;
1400 (%o5) ((foo,bar),baz)
1401 @end example
1403 Maximaは、宣言された品詞を実際の式と比較することで、
1404 いくつかの構文法エラーを検出します。
1406 @c ===beg===
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;
1411 @c ===end===
1412 @example
1413 (%i1) infix ("##", 100, 99, expr, expr, expr);
1414 (%o1) ##
1415 (%i2) if x ## y then 1 else 0;
1416 Incorrect syntax: Found algebraic expression where logical
1417 expression expected
1418 if x ## y then
1419 ^
1420 (%i2) infix ("##", 100, 99, expr, expr, clause);
1421 (%o2) ##
1422 (%i3) if x ## y then 1 else 0;
1423 (%o3) if x ## y then 1 else 0
1424 @end example
1426 @opencatbox
1427 @category{Operators}
1428 @category{Declarations and inferences}
1429 @category{Syntax}
1430 @closecatbox
1432 @end deffn
1434 @c -----------------------------------------------------------------------------
1435 @anchor{matchfix}
1436 @deffn {関数} matchfix (@var{ldelimiter}, @var{rdelimiter})
1437 @deffnx {関数} matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})
1439 左と右の区切り記号@var{ldelimiter}と@var{rdelimiter}を持つ
1440 matchfix演算子を宣言します
1441 区切り記号は文字列として指定されます。
1443 "matchfix"演算子は、
1444 任意の数の引数の関数で、引数は左と右の区切り記号をマッチする間で現れます。
1445 パーサがオペランドや他の式や演算子から区切り記号を区別できる限り
1446 区切り記号は任意の文字列を取り得ます。
1447 実際には、これは、@code{%}, @code{,}, @code{$}, @code{;}のような
1448 パースできない区切り記号を除外し、空白を持つ区切り記号を分離することを要求するかもしれません。
1449 右区切り記号は、左区切り記号と同じかもしれませんし、違うかもしれません。
1451 左区切り記号は、たった１つの右区切り記号と関連づけられることができます;
1452 ２つの異なるmatchfix演算子は同じ左区切り記号を持つことはできません。
1454 存在する演算子は、
1455 他のプロパティを変えることなく、
1456 matchfix演算子として再宣言することができます。
1457 特に、足し算@code{+}のような組み込み演算子が
1458 matchfixに宣言されることが可能ですが、
1459 演算子関数は組み込み演算子に関して定義できません。
1461 コマンド@code{matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos},
1462 @var{pos})} は、
1463 引数品詞@var{arg_pos}と結果品詞@var{pos}、区切り記号
1464 @var{ldelimiter}と@var{rdelimiter}を宣言します。
1466 演算子宣言に関して、「品詞」は式のタイプを意味します。
1467 ３つのタイプが認識されます:
1468 それぞれ、代数式、ブーリアン式、任意の種類の式を示す、
1469 @code{expr}, @code{clause}, @code{any}。
1470 Maximaは、
1471 宣言された品詞を実際の式と比較することで、
1472 いくつかの構文法エラーを検知します。
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演算を実行する関数は通常のユーザー定義関数です。
1482 演算子関数は、
1483 関数定義演算子@code{:=}や@code{define}を使って
1484 普通の方法で定義されます。
1485 引数は、区切り記号の間に書かれるか、
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 ??
1497 例:
1499 区切り記号はほとんど任意の文字列を取り得ます。
1501 @c ===beg===
1502 @c matchfix ("@@", "~");
1503 @c @@ a, b, c ~;
1504 @c matchfix (">>", "<<");
1505 @c >> a, b, c <<;
1506 @c matchfix ("foo", "oof");
1507 @c foo a, b, c oof;
1508 @c >> w + foo x, y oof + z << / @@ p, q ~;
1509 @c ===end===
1510 @example
1511 (%i1) matchfix ("@@@@", "~");
1512 (%o1) @@@@
1513 (%i2) @@@@ a, b, c ~;
1514 (%o2) @@@@a, b, c~
1515 (%i3) matchfix (">>", "<<");
1516 (%o3) >>
1517 (%i4) >> a, b, c <<;
1518 (%o4) >>a, b, c<<
1519 (%i5) matchfix ("foo", "oof");
1520 (%o5) foo
1521 (%i6) foo a, b, c oof;
1522 (%o6) fooa, b, coof
1523 (%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
1524 >>z + foox, yoof + w<<
1525 (%o7) ----------------------
1526 @@@@p, q~
1527 @end example
1529 Matchfix演算子は通常のユーザー定義関数です。
1531 @example
1532 (%i1) matchfix ("!-", "-!");
1533 (%o1) "!-"
1534 (%i2) !- x, y -! := x/y - y/x;
1535 x y
1536 (%o2) !-x, y-! := - - -
1537 y x
1538 (%i3) define (!-x, y-!, x/y - y/x);
1539 x y
1540 (%o3) !-x, y-! := - - -
1541 y x
1542 (%i4) define ("!-" (x, y), x/y - y/x);
1543 x y
1544 (%o4) !-x, y-! := - - -
1545 y x
1546 (%i5) dispfun ("!-");
1547 x y
1548 (%t5) !-x, y-! := - - -
1549 y x
1551 (%o5) done
1552 (%i6) !-3, 5-!;
1553 16
1554 (%o6) - --
1555 15
1556 (%i7) "!-" (3, 5);
1557 16
1558 (%o7) - --
1559 15
1560 @end example
1562 @opencatbox
1563 @category{Syntax}
1564 @category{Operators}
1565 @closecatbox
1566 @end deffn
1568 @c -----------------------------------------------------------------------------
1569 @anchor{operator_nary}
1570 @deffn {関数} nary (@var{op})
1571 @deffnx {関数} nary (@var{op}, @var{bp}, @var{arg_pos}, @var{pos})
1573 @code{nary}演算子は
1574 任意の数の引数の関数を示すのに使われます。
1575 引数それぞれは、例えば、A+BやA+B+Cように演算子の出現で分離されます。
1576 @code{nary("x")}関数は
1577 @code{x}を @code{nary}演算子に宣言する構文拡張関数です。
1578 関数は @code{nary}であると宣言されるかもしれません。
1579 もし @code{declare(j,nary);}が実行されたら、
1580 これは整理器に
1581 例えば、@code{j(j(a,b),j(c,d))}を @code{j(a, b, c, d)}に整理するよう指示します。
1583 @ref{Introduction to operators}も参照してください。
1585 @opencatbox
1586 @category{Operators}
1587 @category{Syntax}
1588 @closecatbox
1589 @end deffn
1591 @c -----------------------------------------------------------------------------
1592 @anchor{nofix}
1593 @deffn {関数} nofix (@var{op})
1594 @deffnx {関数} nofix (@var{op}, @var{pos})
1596 @code{nofix}演算子は引数のない関数を示すのに使われます。
1597 コマンドにそんな演算子が存在すると、
1598 対応する関数が評価されるだけです。
1599 例えば、Maximaブレイクから抜けるために"exit;"とタイプする時、
1600 "exit"は@code{nofix}演算子と似たように振る舞います。
1601 関数 @code{nofix("x")}は
1602 @code{x}を @code{nofix}演算子に宣言する構文拡張関数です。
1604 @ref{Introduction to operators}も参照してください。
1606 @opencatbox
1607 @category{Operators}
1608 @category{Syntax}
1609 @closecatbox
1610 @end deffn
1612 @c -----------------------------------------------------------------------------
1613 @anchor{postfix}
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}も参照してください。
1623 @opencatbox
1624 @category{Operators}
1625 @category{Syntax}
1626 @closecatbox
1627 @end deffn
1629 @c -----------------------------------------------------------------------------
1630 @anchor{prefix}
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}も参照してください。
1640 @opencatbox
1641 @category{Operators}
1642 @category{Syntax}
1643 @closecatbox
1644 @end deffn