| blob | 4cba56ec8be29eff206abde37bc059b305ae7821 |
1 @menu
2 * Lisp and Maxima::
3 * Garbage Collection::
4 * Introduction to Program Flow::
5 * Functions and Variables for Program Flow::
6 @end menu
8 @c -----------------------------------------------------------------------------
9 @node Lisp and Maxima, Garbage Collection, Program Flow, Program Flow
10 @section Lisp and Maxima
11 @c -----------------------------------------------------------------------------
13 MaximaはLispで書かれており、
14 Lisp関数や変数をMaximaからアクセスしたり、その逆が簡単にできます。
15 LispとMaximaのシンボルは命名の慣例で区別されます。
16 ドル記号@code{$}で始まるLispシンボルは、ドル記号なしのMaximaシンボルに対応します。
17 @c NEED TO MENTION THIS OR IS IT JUST CLUTTERING ??
18 @c This includes special Maxima variables such as @code{%} and input and output labels,
19 @c which appear as @code{$%}, @code{$%i1}, @code{$%o1}, etc., in Lisp.
20 クエスチョンマーク@code{?}で始まるMaximaシンボルは、クエスチョンマークなしのLispシンボルに対応します。
21 例えば、Maximaシンボル@code{foo}はLispシンボル@code{$FOO}に対応し、
22 Maximaシンボル@code{?foo}はLispシンボル@code{FOO}に対応します。
23 @code{?foo}は、@code{?}と@code{foo}の間にスペースを入れずに書くことに注意してください。でないと、それは@code{describe ("foo")}に間違えられます。
25 Lispシンボルの中に、ハイフン@code{-}やアスタリスク@code{*}、他の特殊文字があれば、
26 Maximaのコードの中では、バックスラッシュ@code{\}でエスケープしないといけません。
27 例えば、Lispの識別子 @code{*foo-bar*}は、Maximaでは、@code{?\*foo\-bar\*}と書きます。
29 Maximaセッションの中で、Lispコードを実行できます。
30 特殊コマンド@code{:lisp}を使って、
31 （１つか複数のフォームを含む）Lispの一行を実行できます。例えば、
33 @example
34 (%i1) :lisp (foo $x $y)
35 @end example
37 @noindent
38 は、Lisp関数@code{foo}をMaxima変数@code{x}, @code{y}を引数としてコールします。
39 @code{:lisp}構成子は
40 対話プロンプトや@code{batch}や@code{demo}によって処理されるファイルの中で使えますが、
41 @code{load}, @code{batchload}, @code{translate_file}, @code{compile_file}が
42 処理するファイルの中では使えません。
44 関数@code{to_lisp()}を実行すると、対話的なLispセッションが始まります。
45 @code{(to-maxima)}を入力すると、Lispセッションを終了してMaximaに戻ります。
46 @c I DON'T EVEN WANT TO MENTION USING CTRL-C TO OPEN A LISP SESSION.
47 @c (1) IT TAKES EXTRA SET UP TO GET STARTED NAMELY :lisp (setq *debugger-hook* nil)
48 @c (2) IT GETS SCREWED UP EASILY -- TYPE SOMETHING WRONG AND YOU CAN'T GET BACK TO MAXIMA
49 @c (3) IT DOESN'T OFFER FUNCTIONALITY NOT PRESENT IN THE to_lisp() SESSION
51 Lispの関数や変数を、Maximaで通常の関数名、変数名(特殊な句読点のない名前)に見せるには、
52 Lispの名前をドル記号@code{$}で始めなければなりません。
54 Maximaでは、識別子の中の大文字、小文字が区別されます。
55 LispとMaximaの間の名前変換を決めるルールがあります。
57 @enumerate
58 @item
59 縦棒で囲まれていないLisp識別子は、Maximaの小文字の識別子に対応します。
60 Lisp識別子が大文字でも小文字でも混ざっていても無視されます。
61 例えば、Lispの@code{$foo}や@code{$FOO}、@code{$Foo}はすべて
62 Maximaの@code{foo}に対応します。
63 でも、これはデフォルトで、
64 Lispリーダが@code{$foo}, @code{$FOO}, @code{$Foo}を
65 Lispシンボル@code{$FOO}に変換するからです。
66 @item
67 すべて大文字かすべて小文字で、縦棒で囲まれたLisp識別子は、大文字小文字を逆にしたMaximaの識別子に対応します。
68 例えば、Lispの@code{|$FOO|}, @code{|$foo|}はそれぞれ、Maximaの@code{foo}, @code{FOO}に対応します。
69 @item
70 大文字小文字が混ざっていて、縦棒で囲まれたLisp識別子は、そのままMaximaの識別子に対応します。
71 例えば、Lispの@code{|$Foo|}はMaximaの@code{Foo}に対応します。
72 @end enumerate
74 @code{#$}Lispマクロを使うと、Maximaの式をLispコードの中で使うことができます。
75 @code{#$@var{expr}$}はMaximaの式@var{expr}と同値なLispの式に展開されます。
77 @example
78 (msetq $foo #$[x, y]$)
79 @end example
81 @noindent
82 これは以下のように入力するのと同じ効果です。
84 @example
85 (%i1) foo: [x, y];
86 @end example
88 @noindent
89 Lisp関数@code{displa}は、Maximaフォーマットで式を表示します。
91 @example
92 (%i1) :lisp #$[x, y, z]$
93 ((MLIST SIMP) $X $Y $Z)
94 (%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z))
95 [x, y, z]
96 NIL
97 @end example
99 Maximaで定義された関数は、通常のLisp関数ではありません。
100 Lisp関数@code{mfuncall}は、Maxima関数をコールします。
101 例えば:
103 @example
104 (%i1) foo(x,y) := x*y$
105 (%i2) :lisp (mfuncall '$foo 'a 'b)
106 ((MTIMES SIMP) A B)
107 @end example
109 以下のLisp関数は、Maximaパッケージの中でシャドウされています。
111 @verbatim
112 complement continue //
113 float functionp array
114 exp listen signum
115 atan asin acos
116 asinh acosh atanh
117 tanh cosh sinh
118 tan break gcd
119 @end verbatim
121 @opencatbox
122 @category{Programming}
123 @closecatbox
125 @c -----------------------------------------------------------------------------
126 @node Garbage Collection, Introduction to Program Flow, Lisp and Maxima, Program Flow
127 @section Garbage Collection
128 @c -----------------------------------------------------------------------------
130 数式処理は膨大なゴミ(最終的には使われない一時的な、もしくは中間の結果)を生む傾向があり、
131 ゴミの効率的な取り扱いは、プログラムをうまく完了させるために非常に重要な場合があります。
133 @c HOW MUCH OF THE FOLLOWING STILL HOLDS ??
134 @c WHAT ABOUT GC IN GCL ON MS WINDOWS ??
135 @c SHOULD WE SAY SOMETHING ABOUT GC FOR OTHER LISPS ??
136 (SunOS 4.0やBSDの幾つかを含む)mprotectシステムコールが利用可能なUNIXシステム
137 上でのGCLでは、階層化(stratified)ガーベッジコレクションが利用可能です。
138 これは、ガーベッジコレクションを最近書き込まれたページに限定します。
139 GCLドキュメントのALLOCATEやGBCを参照してください。
140 Lispレベルで(setq si::*notify-gbc* t)を実行すると、どの領域がより多くの空間を必要としているか決めるのに役立つでしょう。
142 Maximaを走らせる他のLispについては、
143 そのLispのGCの制御の仕方に関するドキュメントを調べてください。
145 @c -----------------------------------------------------------------------------
146 @node Introduction to Program Flow, Functions and Variables for Program Flow, Garbage Collection, Program Flow
147 @section Introduction to Program Flow
148 @c -----------------------------------------------------------------------------
150 Maximaは、
151 @code{go}のようなもっとプリミティブな構成子はもちろん、
152 繰り返しのために@code{do}ループを提供します。
154 @c end concepts Program Flow
156 @c -----------------------------------------------------------------------------
157 @node Functions and Variables for Program Flow, , Introduction to Program Flow, Program Flow
158 @section Functions and Variables for Program Flow
159 @c -----------------------------------------------------------------------------
161 @c -----------------------------------------------------------------------------
162 @anchor{backtrace}
163 @deffn {関数} backtrace ()
164 @deffnx {関数} backtrace (@var{n})
166 コールスタック、すなわち、
167 現在アクティブな関数をコールした関数のリスト、を印字します。
169 @code{backtrace()}はコールスタック全体を印字します。
171 @code{backtrace (@var{n})}は、
172 現在アクティブな関数を含めて、@var{n}個の直近の関数を印字します。
174 @c IS THIS STATMENT REALLY NEEDED ??
175 @c (WHY WOULD ANYONE BELIEVE backtrace CANNOT BE CALLED OUTSIDE A DEBUGGING CONTEXT??)
176 @code{backtrace}は、
177 (デバッグの文脈でだけでなく、)
178 スクリプト、関数、対話プロンプトからコールすることができます。
180 例:
182 @itemize @bullet
183 @item
184 @code{backtrace()}はコールスタック全体を印字します。
186 @example
187 (%i1) h(x) := g(x/7)$
188 (%i2) g(x) := f(x-11)$
189 (%i3) f(x) := e(x^2)$
190 (%i4) e(x) := (backtrace(), 2*x + 13)$
191 (%i5) h(10);
192 #0: e(x=4489/49)
193 #1: f(x=-67/7)
194 #2: g(x=10/7)
195 #3: h(x=10)
196 9615
197 (%o5) ----
198 49
199 @end example
200 @end itemize
202 @itemize @bullet
203 @item
204 @code{backtrace (@var{n})}は、
205 現在アクティブな関数を含めて、@var{n}個の直近の関数を印字します。
207 @example
208 (%i1) h(x) := (backtrace(1), g(x/7))$
209 (%i2) g(x) := (backtrace(1), f(x-11))$
210 (%i3) f(x) := (backtrace(1), e(x^2))$
211 (%i4) e(x) := (backtrace(1), 2*x + 13)$
212 (%i5) h(10);
213 #0: h(x=10)
214 #0: g(x=10/7)
215 #0: f(x=-67/7)
216 #0: e(x=4489/49)
217 9615
218 (%o5) ----
219 49
220 @end example
221 @end itemize
223 @opencatbox
224 @category{Debugging}
225 @closecatbox
226 @end deffn
228 @c -----------------------------------------------------------------------------
229 @anchor{do}
230 @deffn {特殊演算子} do
232 @code{do}文は繰り返しを実行するために使われます。
233 その強力な一般性のために、
234 @code{do}文は２編で記述されます。
235 最初、通常の形式が
236 (Fortran, Algol, PL/I, など)いくつかの他のプログラミング言語の中で使われるそれ
237 との類似で与えられます;
238 それから、他の特長が言及されます。
240 この形式の、終了条件に関してだけ違う３つの別形があります。
241 それらは:
243 @itemize @bullet
244 @item
245 @code{for @var{variable}: @var{initial_value} step @var{increment}
246 thru @var{limit} do @var{body}}
247 @item
248 @code{for @var{variable}: @var{initial_value} step @var{increment}
249 while @var{condition} do @var{body}}
250 @item
251 @code{for @var{variable}: @var{initial_value} step @var{increment}
252 unless @var{condition} do @var{body}}
253 @end itemize
255 @c UGH. DO WE REALLY NEED TO MENTION THIS??
256 (代わりに、@code{step}は終了条件や範囲の後与えられるかもしれません。)
258 @var{initial_value}, @var{increment}, @var{limit}, @var{body}は、
259 任意の式を取り得ます。
260 もし増分が1なら、 "@code{step 1}"は省略できます。
262 @code{do}文の実行は、最初
263 @var{initial_value}を @var{variable} (今後、制御変数と呼びます)
264 に割り当てることによって処理されます。
265 そして:
266 (1) もし制御変数が @code{thru}指定の範囲を越えたら、もしくは、
267 @code{unless}の条件が @code{true}なら、
268 もしくは、 @code{while}の条件が @code{false}なら、
269 @code{do}は終了します。
270 (2) @var{body}が評価されます。
271 (3) 増分が制御変数に足されます。
272 終了条件が満たされるまで、
273 いずれかが満たされる時 @code{do}が終了する複数の終了条件を与えることもできます。
275 一般的に、 @code{thru}テストは、
276 もし @var{increment}が非負なら、制御変数が @var{limit}よりも大きい時、
277 または、もし @var{increment}が負なら、制御変数が @var{limit}よりも小さい時、
278 満たされます。
279 @var{increment}と @var{limit}は、この不等式が決定できる限り、数値でない式も取り得ます。
280 しかしながら、
281 @code{do}文が入力された時
282 @var{increment}が構文法的に負(例えば負の数)でない限り、
283 Maximaは、 @code{do}が実行される時、正と仮定します。
284 もし正でないなら、
285 @code{do}は適切に終了しないかもしれません。
287 @var{limit}, @var{increment}, 終了条件は、ループを通して毎回評価されることに注意してください。
288 もしこれらのいずれかがおおくの計算を含み、
289 @var{body}の実行中すべてで変わらない結果をもたらすなら、
290 @code{do}に先立って変数をそれらの値に設定し、その変数を
291 @code{do}形式の中で使うことはもっと効率的です。
293 @code{do}文が通常返す値は、アトム @code{done}です。
294 しかしながら、
295 早い時点で @code{do}から抜けて任意の望みの値を与えるために、
296 関数 @code{return}を @var{body}の中で使うことができます。
297 しかしながら、 @code{block}の中で起こる @code{do}の中の @code{return}は、
298 @code{do}だけから抜けて、 @code{block}からは抜けないことに注意してください。
299 @code{do}から囲んでいる @code{block}に抜けるために、
300 @code{go}関数は使えないことにも注意してください。
302 制御変数はいつも @code{do}にローカルです。
304 従って、
305 @code{do}の外側の同じ名前を持つ変数の値に影響することなく、任意の変数が使えます。
306 制御変数は、 @code{do}が終了した後、バインドされていません。
308 @example
309 (%i1) for a:-3 thru 26 step 7 do display(a)$
310 a = - 3
312 a = 4
314 a = 11
316 a = 18
318 a = 25
319 @end example
321 @example
322 (%i1) s: 0$
323 (%i2) for i: 1 while i <= 10 do s: s+i;
324 (%o2) done
325 (%i3) s;
326 (%o3) 55
327 @end example
329 条件@code{while i <= 10}は、
330 @code{unless i > 10}と、また、@code{thru 10}と同値であることに注意してください。
332 @example
333 (%i1) series: 1$
334 (%i2) term: exp (sin (x))$
335 (%i3) for p: 1 unless p > 7 do
336 (term: diff (term, x)/p,
337 series: series + subst (x=0, term)*x^p)$
338 (%i4) series;
339 7 6 5 4 2
340 x x x x x
341 (%o4) -- - --- - -- - -- + -- + x + 1
342 90 240 15 8 2
343 @end example
345 以上は、@code{e^sin(x)}のTaylor級数の8項を与えます。
348 @example
349 (%i1) poly: 0$
350 (%i2) for i: 1 thru 5 do
351 for j: i step -1 thru 1 do
352 poly: poly + i*x^j$
353 (%i3) poly;
354 5 4 3 2
355 (%o3) 5 x + 9 x + 12 x + 14 x + 15 x
356 (%i4) guess: -3.0$
357 (%i5) for i: 1 thru 10 do
358 (guess: subst (guess, x, 0.5*(x + 10/x)),
359 if abs (guess^2 - 10) < 0.00005 then return (guess));
360 (%o5) - 3.162280701754386
361 @end example
363 この例は、
364 Newton-Raphson反復を最大10回使って、
365 10の負の平方根を計算します。
366 もし収束基準が満たされないなら、
367 戻り値は@code{done}になります。
369 いつもある量を制御変数に加える代わりに、
370 繰り返しそれぞれで量をある他の方法で換えたい時があるかもしれません。
371 この場合、
372 @code{step @var{increment}}の代わりに
373 @code{next @var{expression}}を使うことができます。
374 これは、ループの間、
375 制御変数が毎回@var{expression}の評価結果に設定されるようにします。
377 @example
378 (%i6) for count: 2 next 3*count thru 20 do display (count)$
379 count = 2
381 count = 6
383 count = 18
384 @end example
386 @c UGH. DO WE REALLY NEED TO MENTION THIS??
387 @code{for @var{variable}: @var{value} ...do...}の代わりとして、
388 構文法@code{for @var{variable} from @var{value} ...do...}が使えます。
389 これは、
390 @code{from @var{value}}を
391 @code{step}や@code{next}値の後や終了条件の後に置くことを許します。
392 もし@code{from @var{value}}が省略されたら、
393 初期値として1が使われます。
395 制御変数が実際には決して使われないような繰り返しを実行することに興味があることがあるかもしれません。
396 それゆえに、
397 貧弱な初期推測を使って5の平方根を計算する以下の例にあるように、
398 初期化と更新情報を省略して終了条件だけ与えることが許されます。
400 @example
401 (%i1) x: 1000$
402 (%i2) thru 20 do x: 0.5*(x + 5.0/x)$
403 (%i3) x;
404 (%o3) 2.23606797749979
405 (%i4) sqrt(5), numer;
406 (%o4) 2.23606797749979
407 @end example
409 もし望むなら、終了条件さえ完全に省略し、
410 無限に@var{body}を評価し続ける@code{do @var{body}}だけを与えることもできます。
411 この場合、関数@code{return}が@code{do}の実行を終了するのに使われるべきです。
413 @example
414 (%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
415 do (y: ev(df), x: x - f(x)/y,
416 if abs (f (x)) < 5e-6 then return (x)))$
417 (%i2) sqr (x) := x^2 - 5.0$
418 (%i3) newton (sqr, 1000);
419 (%o3) 2.236068027062195
420 @end example
422 @c DUNNO IF WE NEED THIS LEVEL OF DETAIL; THIS ARTICLE IS GETTING PRETTY LONG
423 (@code{return}が実行された時、
424 @code{x}の現在値を
425 @code{do}の値として返そうとすることに注意してください。
426 @code{do}がブロックの最後の文なので、
427 @code{block}から抜けて、
428 @code{do}の値が
429 @code{block}の値として返されます。)
431 @code{do}のもう１つ別の形式がMaximaで利用可能です。構文法は:
433 @example
434 for @var{variable} in @var{list} @var{end_tests} do @var{body}
435 @end example
437 @var{list}の要素は、
438 @var{body}の繰り返しのそれぞれで
439 @code{variable}に連続的に割り当てられる任意の式です。
440 オプションの終了テスト@var{end_tests}は、
441 @code{do}の実行を終了するのに使うことができます;
442 そうでなければ、
443 @var{list}が使い果たされた時、または、
444 @var{body}の中で
445 @code{return}が実行された時、
446 終了します。
447 (実際には、@code{list}は非アトムの任意の式を取り得えて、連続的な部分が取られます。)
449 @example
450 (%i1) for f in [log, rho, atan] do ldisp(f(1))$
451 (%t1) 0
452 (%t2) rho(1)
453 %pi
454 (%t3) ---
455 4
456 (%i4) ev(%t3,numer);
457 (%o4) 0.78539816
458 @end example
460 @opencatbox
461 @category{Programming}
462 @closecatbox
463 @end deffn
465 @c -----------------------------------------------------------------------------
466 @anchor{errcatch}
467 @deffn {関数} errcatch (@var{expr_1}, @dots{}, @var{expr_n})
469 @var{expr_1}, @dots{}, @var{expr_n}を１つずつ評価し、
470 もしエラーが起こらないなら、@code{[@var{expr_n}]} (リスト)を返します。
471 もしいずれかの引数の評価中にエラーが起こったら、
472 @code{errcatch} はエラーが伝搬することを抑制し、
473 引数をこれ以上評価せずに空のリスト@code{[]}を返します。
475 @code{errcatch}は
476 もしエラーがチャッチされないなら@code{batch}を終了させるエラーが起こるかもしれないと疑うような
477 @code{batch}ファイルで役立ちます。
479 @opencatbox
480 @category{Programming}
481 @closecatbox
482 @end deffn
484 @c -----------------------------------------------------------------------------
485 @anchor{error}
486 @deffn {関数} error (@var{expr_1}, ..., @var{expr_n})
487 @deffnx {システム変数} error
489 @var{expr_1}, ..., @var{expr_n}を評価して印字します。
490 そして、エラーがあれば、トップレベルMaximaか直近の@code{errcatch}に戻るようにします。
492 変数@code{error}はエラーを記述するリストに設定されます。
493 @code{error}の最初の要素はフォーマット文字列です。
494 引数@var{expr_1}, ..., @var{expr_n}の中の文字列すべてを結合したものです。
495 残りの要素は文字列でない引数の値です。
497 @code{errormsg()}は@code{error}をフォーマットし印字します。
498 これは直近のエラーメッセージを効果的に再印字します。
500 @opencatbox
501 @category{Programming}
502 @closecatbox
503 @end deffn
505 @c -----------------------------------------------------------------------------
506 @anchor{error_size}
507 @defvr {オプション変数} error_size
508 デフォルト値: 10
510 @code{error_size}は、
511 現れる式のサイズに従って、エラーメッセージを変更します。
512 もし式のサイズが、Lisp関数@code{ERROR-SIZE}によって決定されるように）
513 @code{error_size}より大きいなら、
514 式は、メッセージの中で、シンボルで置き換えられ、
515 シンボルは式に割り当てられます。
516 シンボルはリスト@code{error_syms}から取られます。
518 そうでなければ、式は@code{error_size}より小さく、
519 メッセージの中に式が表示されます。
521 @code{error}と@code{error_syms}も参照してください。
523 例:
524 @c OUTPUT GENERATED BY THE FOLLOWING
525 @c U: (C^D^E + B + A)/(cos(X-1) + 1)$
526 @c error_size: 20$
527 @c error ("Example expression is", U);
528 @c errexp1;
529 @c error_size: 30$
530 @c error ("Example expression is", U);
532 @code{U}のサイズは、@code{ERROR-SIZE}で決められるように、24です。
534 @example
535 (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$
537 (%i2) error_size: 20$
539 (%i3) error ("Example expression is", U);
541 Example expression is errexp1
542 -- an error. Quitting. To debug this try debugmode(true);
543 (%i4) errexp1;
544 E
545 D
546 C + B + A
547 (%o4) --------------
548 cos(X - 1) + 1
549 (%i5) error_size: 30$
551 (%i6) error ("Example expression is", U);
553 E
554 D
555 C + B + A
556 Example expression is --------------
557 cos(X - 1) + 1
558 -- an error. Quitting. To debug this try debugmode(true);
559 @end example
561 @opencatbox
562 @category{Debugging}
563 @category{Display flags and variables}
564 @closecatbox
565 @end defvr
567 @c -----------------------------------------------------------------------------
568 @anchor{error_syms}
569 @defvr {オプション変数} error_syms
570 デフォルト値: @code{[errexp1, errexp2, errexp3]}
572 エラーメッセージの中で、
573 @code{error_size}より大きな式はシンボルで置き換えられ、
574 シンボルは式に設定されます。
575 シンボルはリスト@code{error_syms}から取られます。
576 最初の大きすぎる式は、@code{error_syms[1]}で置き換えられ、
577 ２番目は、@code{error_syms[2]}で置き換えられ、などなど。
579 もし大きすぎる式が@code{error_syms}の要素よりもあれば、
580 シンボルは自動的に構成されます。
581 @var{n}番目のシンボルは@code{concat ('errexp, @var{n})}と同値です。
583 @code{error}と@code{error_size}も参照してください。
585 @opencatbox
586 @category{Debugging}
587 @category{Display flags and variables}
588 @closecatbox
589 @end defvr
591 @c -----------------------------------------------------------------------------
592 @anchor{errormsg}
593 @deffn {関数} errormsg ()
595 直近のエラーメッセージを再印字します。
596 変数@code{error}はメッセージを保持し、
597 @code{errormsg}はそれをフォーマットし印字します。
599 @opencatbox
600 @category{Programming}
601 @closecatbox
602 @end deffn
604 @c -----------------------------------------------------------------------------
605 @anchor{option_errormsg}
606 @defvr {オプション変数} errormsg
607 デフォルト値: @code{true}
609 @code{false}の時、エラーメッセージの出力は抑制されます。
611 オプション変数@code{errormsg}は
612 ブロックの中でローカル値に設定することはできません。
613 @code{errormsg}のグローバル値が常に存在します。
615 @c ===beg===
616 @c errormsg;
617 @c sin(a,b);
618 @c errormsg:false;
619 @c sin(a,b);
620 @c ===end===
621 @example
622 (%i1) errormsg;
623 (%o1) true
624 (%i2) sin(a,b);
625 Wrong number of arguments to sin
626 -- an error. To debug this try: debugmode(true);
627 (%i3) errormsg:false;
628 (%o3) false
629 (%i4) sin(a,b);
631 -- an error. To debug this try: debugmode(true);
632 @end example
634 オプション変数@code{errormsg}はブロックの中でローカル値に設定できません。
636 @c ===beg===
637 @c f(bool):=block([errormsg:bool], print ("value of errormsg is",errormsg))$
638 @c errormsg:true;
639 @c f(false);
640 @c errormsg:false;
641 @c f(true);
642 @c ===end===
643 @example
644 (%i1) f(bool):=block([errormsg:bool],
645 print ("value of errormsg is",errormsg))$
646 (%i2) errormsg:true;
647 (%o2) true
648 (%i3) f(false);
649 value of errormsg is true
650 (%o3) true
651 (%i4) errormsg:false;
652 (%o4) false
653 (%i5) f(true);
654 value of errormsg is false
655 (%o5) false
656 @end example
658 @opencatbox
659 @category{Programming}
660 @closecatbox
661 @end defvr
663 @c REPHRASE
664 @c AT LEAST SHOULD LIST VARIANTS HERE
666 @c -----------------------------------------------------------------------------
667 @anchor{for}
668 @deffn {特殊演算子} for
670 繰り返しで使われます。
671 Maximaの繰り返し機能の記述に関しては、@code{do}を参照してください。
673 @opencatbox
674 @category{Programming}
675 @closecatbox
676 @end deffn
678 @c -----------------------------------------------------------------------------
679 @anchor{go}
680 @deffn {関数} go (@var{tag})
682 制御を
683 @code{go}の引数でタグ付けされたブロックの文に移すために
684 @code{block}内部で使われます。
685 文をタグ付けするには、
686 その文の前に、
687 アトムの引数を
688 @code{block}の中の別の文として
689 先行させてください。
690 例えば:
692 @example
693 block ([x], x:1, loop, x+1, ..., go(loop), ...)
694 @end example
696 @code{go}の引数は、同じ@code{block}の中に現れるタグの名前でなければいけません。
697 @code{go}を含む@code{block}以外の@code{block}の中のタグに移るために、
698 @code{go}を使うことはできません。
700 @opencatbox
701 @category{Programming}
702 @closecatbox
703 @end deffn
705 @c NEEDS CLARIFICATION, EXPANSION, EXAMPLES
706 @c THIS ITEM IS IMPORTANT
708 @c -----------------------------------------------------------------------------
709 @anchor{if}
710 @deffn {特殊演算子} if
712 条件評価を表します。
713 @code{if}式の様々な形が認識されます。
715 @code{if @var{cond_1} then @var{expr_1} else @var{expr_0}}
716 は、
717 もし@var{cond_1}が@code{true}評価されたら@var{expr_1}に*評*価*され、
718 そうでなければ式は@var{expr_0}に評価されます。
720 コマンド @code{if @var{cond_1} then @var{expr_1} elseif @var{cond_2} then @var{expr_2} elseif ... else @var{expr_0}}は、
721 もし@var{cond_k}が@code{true}、かつ、先行する条件がすべて@code{false}なら、
722 @var{expr_k}に評価されます。
723 もし条件のいずれも@code{true}でないなら、式は@code{expr_0}に評価されます。
725 もし@code{else}がないなら、
726 最後に@code{else false}が仮定されます。
727 すなわち、コマンド @code{if @var{cond_1} then @var{expr_1}}は、
728 @code{if @var{cond_1} then @var{expr_1} else false}と同値で、
729 コマンド @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n}}は、
730 @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n} else false}と同値です。
732 選択肢@var{expr_0}, @dots{}, @var{expr_n}は、任意のMaxima式を取り得ます。
733 入れ子の@code{if}式もあり得ます。
734 選択肢は、
735 対応する条件が@code{true}でない限り、
736 整理も評価もされません。
738 条件@var{cond_1}, ..., @var{cond_n}は、潜在的に、また、実際に
739 @code{true}か@code{false}に評価される式です。
740 条件が実際には@code{true}にも@code{false}にも評価されない時、
741 @code{if}の振る舞いはグローバルフラグ@code{prederror}で決定されます。
742 @code{prederror}が@code{true}の時、
743 もし評価された条件のいずれかが@code{true}にも@code{false}にもならなかったら
744 、エラーになります。
745 そうでなければ、@code{true}にも@code{false}にも評価されない条件が受け入れられ、
746 結果は条件式になります。
748 条件は以下のように、他の要素間の関係演算子と論理演算子からなります。
750 @c - SEEMS LIKE THIS TABLE WANTS TO BE IN A DISCUSSION OF PREDICATE FUNCTIONS; PRESENT LOCATION IS OK I GUESS
751 @c - REFORMAT THIS TABLE USING TEXINFO MARKUP (MAYBE)
752 @example
753 演算 シンボル タイプ
755 小なり < 関係 中置
756 以下 <= 関係 中置
757 等号 (構文法的) = 関係 中置
758 不等号 (構文法的) # 関係 中置
759 等号 (値) equal 関係 関数
760 不等号 (値) notequal 関係 関数
761 以上 >= 関係 中置
762 大なり > 関係 中置
763 かつ and 論理 中置
764 または or 論理 中置
765 否定 not 論理 前置
766 @end example
768 @opencatbox
769 @category{Programming}
770 @category{Predicate functions}
771 @closecatbox
772 @end deffn
774 @c NEEDS CLARIFICATION
775 @c THIS ITEM IS IMPORTANT
777 @c -----------------------------------------------------------------------------
778 @anchor{map}
779 @deffn {関数} map (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
781 @code{map}は、主演算子（訳注：内部表現の最上位階層のリストに対応する演算子）は
782 式@var{expr_1}, ..., @var{expr_n}のそれと同じ演算子を使い、
783 そのサブパーツは、引数式の対応するサブパーツに@var{f}を適用した結果である式を返します。
784 @var{f}は@math{n}個の引数の関数名か、@math{n}個の引数のラムダ形式です。
785 (訳注：また、@var{expr_1}, @dots{}, @var{expr_n}は内部表現に階層リスト構造を持つ式です。）
787 @code{maperror} - もし@code{maperror}が@code{fals}eなら、
788 マッピング関数のすべては、(1)もし@var{expr_i}のすべてが同じ長さでなければ、
789 最も短い@var{expr_i}が完了した時点で停止し、
790 (2)もし@var{expr_i}が同じタイプのオブジェクトでなければ、
791 @var{f}をリスト[@var{expr_1}, @var{expr_2}, ...]に適用します。
792 もし@code{maperror}が@code{true}なら、上の２つの場合、エラーメッセージを出力します。
794 この関数の用法の１つは、ある関数（例えば、@code{partfrac})を非常に長い式に適用する際、
795 計算の間にリスト保存領域を枯渇させるため式全体に適応するのが不可能な場合に、
796 それぞれの項に関数をマップすることです。
798 @c IN THESE EXAMPLES, SPELL OUT WHAT IS THE MAIN OPERATOR
799 @c AND SHOW HOW THE RESULT FOLLOWS FROM THE DESCRIPTION STATED IN THE FIRST PARAGRAPH
800 @example
801 (%i1) map(f,x+a*y+b*z);
802 (%o1) f(b z) + f(a y) + f(x)
803 (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
804 1 1 1
805 (%o2) ----- - ----- + -------- + x
806 x + 2 x + 1 2
807 (x + 1)
808 (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
809 1
810 (%o3) y + ----- + 1
811 x + 1
812 (%i4) map("=",[a,b],[-0.5,3]);
813 (%o4) [a = - 0.5, b = 3]
816 @end example
818 @opencatbox
819 @category{Function application}
820 @closecatbox
821 @end deffn
823 @c -----------------------------------------------------------------------------
824 @anchor{mapatom}
825 @deffn {関数} mapatom (@var{expr})
827 @var{expr}がマップルーチンでアトムとして扱われる時だけ@code{true}を返します。
828 "Mapatoms"はアトム、(有理数を含む)数、添字付き変数です。
829 @c WHAT ARE "THE MAPPING ROUTINES", AND WHY DO THEY HAVE A SPECIALIZED NOTION OF ATOMS ??
831 @opencatbox
832 @category{Predicate functions}
833 @closecatbox
834 @end deffn
836 @c NEEDS CLARIFICATION
838 @c -----------------------------------------------------------------------------
839 @anchor{maperror}
840 @defvr {オプション変数} maperror
841 デフォルト値: @code{true}
843 @code{maperror}が@code{false}の時は、
844 マップ関数すべてに、以下の例のようにさせます。
846 @example
847 map (@var{f}, @var{expr_1}, @var{expr_2}, @dots{})
848 @end example
850 に対しては、
851 (1) もし@var{expr_i}のすべてが同じ長さでないなら、
852 最も短い@var{expr_i}の終わりまで完了した時、停止するようにさせ、
853 (2) もし@var{expr_i}すべてが同じタイプのオブジェクトでないなら、
854 @var{f}を[@var{expr_1}, @var{expr_2}, ...]に適用するようにさせます。
856 もし@code{maperror}が@code{true}なら、
857 上の２つの例に関して、エラーメッセージが表示されます。
859 @opencatbox
860 @category{Function application}
861 @closecatbox
862 @end defvr
864 @c -----------------------------------------------------------------------------
865 @anchor{mapprint}
866 @defvr {オプション変数} mapprint
867 デフォルト値: @code{true}
869 @code{mapprint}が@code{true}の時、
870 @code{map}, @code{mapl}, @code{fullmap}からの様々な情報メッセージが
871 一定の状況で生成されます。
872 これらは
873 @code{map}が@code{apply}を使ったり、@code{map}が
874 最短のリストで切り詰めているような状況を含みます。
876 もし@code{mapprint}が@code{false}なら、これらのメッセージは抑制されます
878 @opencatbox
879 @category{Function application}
880 @closecatbox
881 @end defvr
883 @c NEEDS CLARIFICATION
885 @c -----------------------------------------------------------------------------
886 @anchor{maplist}
887 @deffn {関数} maplist (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
888 式@var{expr_1}, @dots{}, @var{expr_n}のパーツに@var{f}を適用した結果のリストを返します。
889 @var{f}は、関数名かラムダ式です。
891 @code{maplist}は@code{map (@var{f}, @var{expr_1}, ..., @var{expr_n})}とは違います。
892 mapは主演算子が@var{expr_i}と同じ式を返します。
893 (整理と@code{map}が@code{apply}を行う場合は例外です。)
896 @opencatbox
897 @category{Function application}
898 @closecatbox
899 @end deffn
901 @c NEEDS CLARIFICATION
903 @c -----------------------------------------------------------------------------
904 @anchor{prederror}
905 @defvr {オプション変数} prederror
906 デフォルト値: @code{false}
908 @code{prederror}が@code{true}の時、
909 @code{if}文の述語論理か@code{is}関数が
910 @code{true}か@code{false}に評価されるのに失敗した時はいつでも
911 エラーメッセージが表示されます。
913 もし@code{false}なら、この場合，代わりに@code{unknown}が返されます。
914 @code{prederror: false}モードは翻訳コードではサポートされません;
915 しかしながら、@code{maybe}は翻訳コードでサポートされます。
917 @code{is}と@code{maybe}も参照してください。
919 @opencatbox
920 @category{Programming}
921 @category{Predicate functions}
922 @closecatbox
923 @end defvr
925 @deffn {関数} return (@var{value})
926 引数を連れて、陽にブロックから抜けるために使われます。
927 もっと情報を知るには、@code{block}も参照してください。
929 @opencatbox
930 @category{Programming}
931 @closecatbox
932 @end deffn
934 @c NEEDS CLARIFICATION
935 @deffn {関数} scanmap (@var{f}, @var{expr})
936 @deffnx {関数} scanmap (@var{f}, @var{expr}, bottomup)
937 トップダウン法で、@var{f}を@var{expr}に再帰的に適用します。
938 完全な因数分解が望まれる時、これは最も役に立ちます。
939 例えば:
941 @example
942 (%i1) exp:(a^2+2*a+1)*y + x^2$
943 (%i2) scanmap(factor,exp);
944 2 2
945 (%o2) (a + 1) y + x
946 @end example
948 Note the way in which
949 @code{scanmap}が与えられた関数@code{factor}を
950 @var{expr}の構成部分式に適用する方法に注意してください;
951 もし
952 @var{expr}の別の形がscanmapに適用されるなら、結果は異なるかもしれません。
953 従って、
954 @code{scanmap}が
955 @code{exp}の展開形に適用される時、
956 @code{%o2}が再現されません:
958 @example
959 (%i3) scanmap(factor,expand(exp));
960 2 2
961 (%o3) a y + 2 a y + y + x
962 @end example
964 @code{scanmap}が
965 与えられた関数を指数関数を含む部分式すべてに再帰的に適用する方法の別の例です:
967 @example
968 (%i4) expr : u*v^(a*x+b) + c$
969 (%i5) scanmap('f, expr);
970 f(f(f(a) f(x)) + f(b))
971 (%o5) f(f(f(u) f(f(v) )) + f(c))
972 @end example
974 @code{scanmap (@var{f}, @var{expr}, bottomup)}は、
975 ボトムアップ法で
976 @var{f}を
977 @var{expr}に適用します。
978 例えば、未定義@code{f}に関して、
980 @example
981 scanmap(f,a*x+b) ->
982 f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
983 scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
984 -> f(f(a)*f(x))+f(b) ->
985 f(f(f(a)*f(x))+f(b))
986 @end example
988 この場合、両方の方法で同じ答えを得ます。
990 @opencatbox
991 @category{Function application}
992 @closecatbox
993 @end deffn
995 @c -----------------------------------------------------------------------------
996 @anchor{throw}
997 @deffn {関数} throw (@var{expr})
999 @var{expr}を評価し、
1000 直近の@code{catch}に値を投げ戻します。
1001 @code{throw}は、
1002 @code{catch}と一緒に、非ローカルリターンメカニズムとして使われます。
1004 @opencatbox
1005 @category{Programming}
1006 @closecatbox
1007 @end deffn
1009 @c NEED MORE HERE !!
1010 @c AT LEAST SHOULD LIST ACCEPTABLE VARIANTS
1012 @c -----------------------------------------------------------------------------
1013 @anchor{while}
1014 @anchor{unless}
1015 @deffn {特殊演算子} while
1016 @deffnx {特殊演算子} unless
1017 @code{do}を参照してください。
1019 @opencatbox
1020 @category{Programming}
1021 @closecatbox
1022 @end deffn
1024 @c -----------------------------------------------------------------------------
1025 @anchor{outermap}
1026 @deffn {関数} outermap (@var{f}, @var{a_1}, @dots{}, @var{a_n})
1028 関数@var{f}を
1029 外積@var{a_1}掛ける@var{a_2} ... 掛ける@var{a_n}の要素のそれぞれに適用します。
1031 @var{f}は
1032 @math{n}個の引数の関数の名前か、
1033 @math{n}個の引数のラムダ式
1034 です。
1036 それぞれの引数@var{a_k}は、
1037 リストか、入れ子のリストか、行列か、他の任意の種類の式を取り得ます。
1039 @code{outermap}戻り値は、入れ子の構造です。
1040 @var{x}を戻り値とします。
1041 すると、
1042 @var{x}は最初のリストか入れ子のリストか行列引数と同じ構造を持ち、
1043 @code{@var{x}[i_1]...[i_m]}は、
1044 二番目のリストか入れ子のリストか行列引数と同じ構造を持ち、
1045 @code{@var{x}[i_1]...[i_m][j_1]...[j_n]}は、
1046 三番目のリストか入れ子のリストか行列引数と同じ構造を持ち、
1047 以下同様。
1048 ここで、@var{m}, @var{n}, ...は、
1049 引数それぞれの要素
1050 をアクセスするために要求される
1051 インデックスの数(リストには１つ、行列には２つ、入れ子のリストには１つ以上)です。
1052 リストや行列でない引数は戻り値の構造に影響を与えません。
1054 Note that the effect of
1055 @code{outermap}の効果は
1056 @var{f}を
1057 @code{cartesian_product}によって返される
1058 外積の要素のそれぞれに適用することのそれと違います。
1060 @code{outermap}は、戻り値で引数の構造を保ちますが、
1061 @code{cartesian_product}は違います。
1063 @code{outermap}は引数を評価します。
1065 @code{map}, @code{maplist}, @code{apply}も参照してください。
1066 @c CROSS REF OTHER FUNCTIONS HERE ??
1068 例:
1070 @code{outermap}の初等的な例。
1071 よりはっきり引数の組み合わせを示すために、
1072 @code{F}は未定義のままです。
1074 @c ===beg===
1075 @c outermap (F, [a, b, c], [1, 2, 3]);
1076 @c outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
1077 @c outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
1078 @c outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
1079 @c outermap ("+", [a, b, c], [1, 2, 3]);
1080 @c ===end===
1081 @example
1082 (%i1) outermap(F, [a, b, c], [1, 2, 3]);
1083 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
1084 [F(c, 1), F(c, 2), F(c, 3)]]
1085 (%i2) outermap(F, matrix([a, b],[c, d]), matrix([1, 2],[3, 4]));
1086 [ [ F(a, 1) F(a, 2) ] [ F(b, 1) F(b, 2) ] ]
1087 [ [ ] [ ] ]
1088 [ [ F(a, 3) F(a, 4) ] [ F(b, 3) F(b, 4) ] ]
1089 (%o2) [ ]
1090 [ [ F(c, 1) F(c, 2) ] [ F(d, 1) F(d, 2) ] ]
1091 [ [ ] [ ] ]
1092 [ [ F(c, 3) F(c, 4) ] [ F(d, 3) F(d, 4) ] ]
1093 (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
1094 [ F(a, x, 1) F(a, x, 2) ] [ F(b, x, 1) F(b, x, 2) ]
1095 (%o3) [[ ], [ ]]
1096 [ F(a, x, 3) F(a, x, 4) ] [ F(b, x, 3) F(b, x, 4) ]
1097 (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
1098 [ [ F(a, 1, x) ] [ F(a, 2, x) ] ]
1099 (%o4) [[ [ ] [ ] ],
1100 [ [ F(a, 1, y) ] [ F(a, 2, y) ] ]
1101 [ [ F(b, 1, x) ] [ F(b, 2, x) ] ]
1102 [ [ ] [ ] ]]
1103 [ [ F(b, 1, y) ] [ F(b, 2, y) ] ]
1104 (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
1105 (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
1106 [c + 1, c + 2, c + 3]]
1107 @end example
1109 @code{outermap}の戻り値のより密な検査。
1110 最初の、二番目の、三番目の引数は、それぞれ、行列、リスト、行列です。
1111 戻り値は行列です。
1112 その行列の要素それぞれはリストで、
1113 それぞれのリストの要素それぞれは行列です。
1115 @c ===beg===
1116 @c arg_1 : matrix ([a, b], [c, d]);
1117 @c arg_2 : [11, 22];
1118 @c arg_3 : matrix ([xx, yy]);
1119 @c xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1,
1120 @c arg_2, arg_3);
1121 @c xx_1 : xx_0 [1][1];
1122 @c xx_2 : xx_0 [1][1] [1];
1123 @c xx_3 : xx_0 [1][1] [1] [1][1];
1124 @c [op (arg_1), op (arg_2), op (arg_3)];
1125 @c [op (xx_0), op (xx_1), op (xx_2)];
1126 @c ===end===
1127 @example
1128 (%i1) arg_1 : matrix ([a, b], [c, d]);
1129 [ a b ]
1130 (%o1) [ ]
1131 [ c d ]
1132 (%i2) arg_2 : [11, 22];
1133 (%o2) [11, 22]
1134 (%i3) arg_3 : matrix ([xx, yy]);
1135 (%o3) [ xx yy ]
1136 (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
1137 arg_2, arg_3);
1138 [ [ a a ] [ a a ] ]
1139 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1140 [ [ 11 11 ] [ 22 22 ] ]
1141 (%o4) Col 1 = [ ]
1142 [ [ c c ] [ c c ] ]
1143 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1144 [ [ 11 11 ] [ 22 22 ] ]
1145 @group
1146 [ [ b b ] [ b b ] ]
1147 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1148 [ [ 11 11 ] [ 22 22 ] ]
1149 Col 2 = [ ]
1150 [ [ d d ] [ d d ] ]
1151 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1152 [ [ 11 11 ] [ 22 22 ] ]
1153 @end group
1154 (%i5) xx_1 : xx_0 [1][1];
1155 [ a a ] [ a a ]
1156 (%o5) [[ xx + -- yy + -- ], [ xx + -- yy + -- ]]
1157 [ 11 11 ] [ 22 22 ]
1158 (%i6) xx_2 : xx_0 [1][1] [1];
1159 [ a a ]
1160 (%o6) [ xx + -- yy + -- ]
1161 [ 11 11 ]
1162 (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
1163 a
1164 (%o7) xx + --
1165 11
1166 (%i8) [op (arg_1), op (arg_2), op (arg_3)];
1167 (%o8) [matrix, [, matrix]
1168 (%i9) [op (xx_0), op (xx_1), op (xx_2)];
1169 (%o9) [matrix, [, matrix]
1170 @end example
1172 @code{outermap}は、戻り値の中で引数の構造を保持します。
1173 @code{cartesian_product}は保持しません。
1175 @c ===beg===
1176 @c outermap (F, [a, b, c], [1, 2, 3]);
1177 @c setify (flatten (%));
1178 @c map (lambda ([L], apply (F, L)),
1179 @c cartesian_product ({a, b, c}, {1, 2, 3}));
1180 @c is (equal (%, %th (2)));
1181 @c ===end===
1182 @example
1183 (%i1) outermap (F, [a, b, c], [1, 2, 3]);
1184 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
1185 [F(c, 1), F(c, 2), F(c, 3)]]
1186 (%i2) setify (flatten (%));
1187 (%o2) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
1188 F(c, 1), F(c, 2), F(c, 3)@}
1189 (%i3) map(lambda([L], apply(F, L)),
1190 cartesian_product(@{a, b, c@}, @{1, 2, 3@}));
1191 (%o3) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
1192 F(c, 1), F(c, 2), F(c, 3)@}
1193 (%i4) is (equal (%, %th (2)));
1194 (%o4) true
1195 @end example
1197 @opencatbox
1198 @category{Function application}
1199 @closecatbox
1200 @end deffn