| blob | 8bf02f76b24667cab268681d542a0e5118214bcb |
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} @category{Display flags and variables}
563 @closecatbox
564 @end defvr
566 @c -----------------------------------------------------------------------------
567 @anchor{error_syms}
568 @defvr {オプション変数} error_syms
569 デフォルト値: @code{[errexp1, errexp2, errexp3]}
571 エラーメッセージの中で、
572 @code{error_size}より大きな式はシンボルで置き換えられ、
573 シンボルは式に設定されます。
574 シンボルはリスト@code{error_syms}から取られます。
575 最初の大きすぎる式は、@code{error_syms[1]}で置き換えられ、
576 ２番目は、@code{error_syms[2]}で置き換えられ、などなど。
578 もし大きすぎる式が@code{error_syms}の要素よりもあれば、
579 シンボルは自動的に構成されます。
580 @var{n}番目のシンボルは@code{concat ('errexp, @var{n})}と同値です。
582 @code{error}と@code{error_size}も参照してください。
584 @opencatbox
585 @category{Debugging} @category{Display flags and variables}
586 @closecatbox
587 @end defvr
589 @c -----------------------------------------------------------------------------
590 @anchor{errormsg}
591 @deffn {関数} errormsg ()
593 直近のエラーメッセージを再印字します。
594 変数@code{error}はメッセージを保持し、
595 @code{errormsg}はそれをフォーマットし印字します。
597 @opencatbox
598 @category{Programming}
599 @closecatbox
600 @end deffn
602 @c -----------------------------------------------------------------------------
603 @anchor{option_errormsg}
604 @defvr {オプション変数} errormsg
605 デフォルト値: @code{true}
607 @code{false}の時、エラーメッセージの出力は抑制されます。
609 オプション変数@code{errormsg}は
610 ブロックの中でローカル値に設定することはできません。
611 @code{errormsg}のグローバル値が常に存在します。
613 @c ===beg===
614 @c errormsg;
615 @c sin(a,b);
616 @c errormsg:false;
617 @c sin(a,b);
618 @c ===end===
619 @example
620 (%i1) errormsg;
621 (%o1) true
622 (%i2) sin(a,b);
623 Wrong number of arguments to sin
624 -- an error. To debug this try: debugmode(true);
625 (%i3) errormsg:false;
626 (%o3) false
627 (%i4) sin(a,b);
629 -- an error. To debug this try: debugmode(true);
630 @end example
632 オプション変数@code{errormsg}はブロックの中でローカル値に設定できません。
634 @c ===beg===
635 @c f(bool):=block([errormsg:bool], print ("value of errormsg is",errormsg))$
636 @c errormsg:true;
637 @c f(false);
638 @c errormsg:false;
639 @c f(true);
640 @c ===end===
641 @example
642 (%i1) f(bool):=block([errormsg:bool],
643 print ("value of errormsg is",errormsg))$
644 (%i2) errormsg:true;
645 (%o2) true
646 (%i3) f(false);
647 value of errormsg is true
648 (%o3) true
649 (%i4) errormsg:false;
650 (%o4) false
651 (%i5) f(true);
652 value of errormsg is false
653 (%o5) false
654 @end example
656 @opencatbox
657 @category{Programming}
658 @closecatbox
659 @end defvr
661 @c REPHRASE
662 @c AT LEAST SHOULD LIST VARIANTS HERE
664 @c -----------------------------------------------------------------------------
665 @anchor{for}
666 @deffn {特殊演算子} for
668 繰り返しで使われます。
669 Maximaの繰り返し機能の記述に関しては、@code{do}を参照してください。
671 @opencatbox
672 @category{Programming}
673 @closecatbox
674 @end deffn
676 @c -----------------------------------------------------------------------------
677 @anchor{go}
678 @deffn {関数} go (@var{tag})
680 制御を
681 @code{go}の引数でタグ付けされたブロックの文に移すために
682 @code{block}内部で使われます。
683 文をタグ付けするには、
684 その文の前に、
685 アトムの引数を
686 @code{block}の中の別の文として
687 先行させてください。
688 例えば:
690 @example
691 block ([x], x:1, loop, x+1, ..., go(loop), ...)
692 @end example
694 @code{go}の引数は、同じ@code{block}の中に現れるタグの名前でなければいけません。
695 @code{go}を含む@code{block}以外の@code{block}の中のタグに移るために、
696 @code{go}を使うことはできません。
698 @opencatbox
699 @category{Programming}
700 @closecatbox
701 @end deffn
703 @c NEEDS CLARIFICATION, EXPANSION, EXAMPLES
704 @c THIS ITEM IS IMPORTANT
706 @c -----------------------------------------------------------------------------
707 @anchor{if}
708 @deffn {特殊演算子} if
710 条件評価を表します。
711 @code{if}式の様々な形が認識されます。
713 @code{if @var{cond_1} then @var{expr_1} else @var{expr_0}}
714 は、
715 もし@var{cond_1}が@code{true}評価されたら@var{expr_1}に*評*価*され、
716 そうでなければ式は@var{expr_0}に評価されます。
718 コマンド @code{if @var{cond_1} then @var{expr_1} elseif @var{cond_2} then @var{expr_2} elseif ... else @var{expr_0}}は、
719 もし@var{cond_k}が@code{true}、かつ、先行する条件がすべて@code{false}なら、
720 @var{expr_k}に評価されます。
721 もし条件のいずれも@code{true}でないなら、式は@code{expr_0}に評価されます。
723 もし@code{else}がないなら、
724 最後に@code{else false}が仮定されます。
725 すなわち、コマンド @code{if @var{cond_1} then @var{expr_1}}は、
726 @code{if @var{cond_1} then @var{expr_1} else false}と同値で、
727 コマンド @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n}}は、
728 @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n} else false}と同値です。
730 選択肢@var{expr_0}, @dots{}, @var{expr_n}は、任意のMaxima式を取り得ます。
731 入れ子の@code{if}式もあり得ます。
732 選択肢は、
733 対応する条件が@code{true}でない限り、
734 整理も評価もされません。
736 条件@var{cond_1}, ..., @var{cond_n}は、潜在的に、また、実際に
737 @code{true}か@code{false}に評価される式です。
738 条件が実際には@code{true}にも@code{false}にも評価されない時、
739 @code{if}の振る舞いはグローバルフラグ@code{prederror}で決定されます。
740 @code{prederror}が@code{true}の時、
741 もし評価された条件のいずれかが@code{true}にも@code{false}にもならなかったら
742 、エラーになります。
743 そうでなければ、@code{true}にも@code{false}にも評価されない条件が受け入れられ、
744 結果は条件式になります。
746 条件は以下のように、他の要素間の関係演算子と論理演算子からなります。
748 @c - SEEMS LIKE THIS TABLE WANTS TO BE IN A DISCUSSION OF PREDICATE FUNCTIONS; PRESENT LOCATION IS OK I GUESS
749 @c - REFORMAT THIS TABLE USING TEXINFO MARKUP (MAYBE)
750 @example
751 演算 シンボル タイプ
753 小なり < 関係 中置
754 以下 <= 関係 中置
755 等号 (構文法的) = 関係 中置
756 不等号 (構文法的) # 関係 中置
757 等号 (値) equal 関係 関数
758 不等号 (値) notequal 関係 関数
759 以上 >= 関係 中置
760 大なり > 関係 中置
761 かつ and 論理 中置
762 または or 論理 中置
763 否定 not 論理 前置
764 @end example
766 @opencatbox
767 @category{Programming} @category{Predicate functions}
768 @closecatbox
769 @end deffn
771 @c NEEDS CLARIFICATION
772 @c THIS ITEM IS IMPORTANT
774 @c -----------------------------------------------------------------------------
775 @anchor{map}
776 @deffn {関数} map (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
778 @code{map}は、主演算子（訳注：内部表現の最上位階層のリストに対応する演算子）は
779 式@var{expr_1}, ..., @var{expr_n}のそれと同じ演算子を使い、
780 そのサブパーツは、引数式の対応するサブパーツに@var{f}を適用した結果である式を返します。
781 @var{f}は@math{n}個の引数の関数名か、@math{n}個の引数のラムダ形式です。
782 (訳注：また、@var{expr_1}, @dots{}, @var{expr_n}は内部表現に階層リスト構造を持つ式です。）
784 @code{maperror} - もし@code{maperror}が@code{fals}eなら、
785 マッピング関数のすべては、(1)もし@var{expr_i}のすべてが同じ長さでなければ、
786 最も短い@var{expr_i}が完了した時点で停止し、
787 (2)もし@var{expr_i}が同じタイプのオブジェクトでなければ、
788 @var{f}をリスト[@var{expr_1}, @var{expr_2}, ...]に適用します。
789 もし@code{maperror}が@code{true}なら、上の２つの場合、エラーメッセージを出力します。
791 この関数の用法の１つは、ある関数（例えば、@code{partfrac})を非常に長い式に適用する際、
792 計算の間にリスト保存領域を枯渇させるため式全体に適応するのが不可能な場合に、
793 それぞれの項に関数をマップすることです。
795 @c IN THESE EXAMPLES, SPELL OUT WHAT IS THE MAIN OPERATOR
796 @c AND SHOW HOW THE RESULT FOLLOWS FROM THE DESCRIPTION STATED IN THE FIRST PARAGRAPH
797 @example
798 (%i1) map(f,x+a*y+b*z);
799 (%o1) f(b z) + f(a y) + f(x)
800 (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
801 1 1 1
802 (%o2) ----- - ----- + -------- + x
803 x + 2 x + 1 2
804 (x + 1)
805 (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
806 1
807 (%o3) y + ----- + 1
808 x + 1
809 (%i4) map("=",[a,b],[-0.5,3]);
810 (%o4) [a = - 0.5, b = 3]
813 @end example
815 @opencatbox
816 @category{Function application}
817 @closecatbox
818 @end deffn
820 @c -----------------------------------------------------------------------------
821 @anchor{mapatom}
822 @deffn {関数} mapatom (@var{expr})
824 @var{expr}がマップルーチンでアトムとして扱われる時だけ@code{true}を返します。
825 "Mapatoms"はアトム、(有理数を含む)数、添字付き変数です。
826 @c WHAT ARE "THE MAPPING ROUTINES", AND WHY DO THEY HAVE A SPECIALIZED NOTION OF ATOMS ??
828 @opencatbox
829 @category{Predicate functions}
830 @closecatbox
831 @end deffn
833 @c NEEDS CLARIFICATION
835 @c -----------------------------------------------------------------------------
836 @anchor{maperror}
837 @defvr {オプション変数} maperror
838 デフォルト値: @code{true}
840 @code{maperror}が@code{false}の時は、
841 マップ関数すべてに、以下の例のようにさせます。
843 @example
844 map (@var{f}, @var{expr_1}, @var{expr_2}, @dots{})
845 @end example
847 に対しては、
848 (1) もし@var{expr_i}のすべてが同じ長さでないなら、
849 最も短い@var{expr_i}の終わりまで完了した時、停止するようにさせ、
850 (2) もし@var{expr_i}すべてが同じタイプのオブジェクトでないなら、
851 @var{f}を[@var{expr_1}, @var{expr_2}, ...]に適用するようにさせます。
853 もし@code{maperror}が@code{true}なら、
854 上の２つの例に関して、エラーメッセージが表示されます。
856 @opencatbox
857 @category{Function application}
858 @closecatbox
859 @end defvr
861 @c -----------------------------------------------------------------------------
862 @anchor{mapprint}
863 @defvr {オプション変数} mapprint
864 デフォルト値: @code{true}
866 @code{mapprint}が@code{true}の時、
867 @code{map}, @code{mapl}, @code{fullmap}からの様々な情報メッセージが
868 一定の状況で生成されます。
869 これらは
870 @code{map}が@code{apply}を使ったり、@code{map}が
871 最短のリストで切り詰めているような状況を含みます。
873 もし@code{mapprint}が@code{false}なら、これらのメッセージは抑制されます
875 @opencatbox
876 @category{Function application}
877 @closecatbox
878 @end defvr
880 @c NEEDS CLARIFICATION
882 @c -----------------------------------------------------------------------------
883 @anchor{maplist}
884 @deffn {関数} maplist (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
885 式@var{expr_1}, @dots{}, @var{expr_n}のパーツに@var{f}を適用した結果のリストを返します。
886 @var{f}は、関数名かラムダ式です。
888 @code{maplist}は@code{map (@var{f}, @var{expr_1}, ..., @var{expr_n})}とは違います。
889 mapは主演算子が@var{expr_i}と同じ式を返します。
890 (整理と@code{map}が@code{apply}を行う場合は例外です。)
893 @opencatbox
894 @category{Function application}
895 @closecatbox
896 @end deffn
898 @c NEEDS CLARIFICATION
900 @c -----------------------------------------------------------------------------
901 @anchor{prederror}
902 @defvr {オプション変数} prederror
903 デフォルト値: @code{false}
905 @code{prederror}が@code{true}の時、
906 @code{if}文の述語論理か@code{is}関数が
907 @code{true}か@code{false}に評価されるのに失敗した時はいつでも
908 エラーメッセージが表示されます。
910 もし@code{false}なら、この場合，代わりに@code{unknown}が返されます。
911 @code{prederror: false}モードは翻訳コードではサポートされません;
912 しかしながら、@code{maybe}は翻訳コードでサポートされます。
914 @code{is}と@code{maybe}も参照してください。
916 @opencatbox
917 @category{Programming} @category{Predicate functions}
918 @closecatbox
919 @end defvr
921 @deffn {関数} return (@var{value})
922 引数を連れて、陽にブロックから抜けるために使われます。
923 もっと情報を知るには、@code{block}も参照してください。
925 @opencatbox
926 @category{Programming}
927 @closecatbox
928 @end deffn
930 @c NEEDS CLARIFICATION
931 @deffn {関数} scanmap (@var{f}, @var{expr})
932 @deffnx {関数} scanmap (@var{f}, @var{expr}, bottomup)
933 トップダウン法で、@var{f}を@var{expr}に再帰的に適用します。
934 完全な因数分解が望まれる時、これは最も役に立ちます。
935 例えば:
937 @example
938 (%i1) exp:(a^2+2*a+1)*y + x^2$
939 (%i2) scanmap(factor,exp);
940 2 2
941 (%o2) (a + 1) y + x
942 @end example
944 Note the way in which
945 @code{scanmap}が与えられた関数@code{factor}を
946 @var{expr}の構成部分式に適用する方法に注意してください;
947 もし
948 @var{expr}の別の形がscanmapに適用されるなら、結果は異なるかもしれません。
949 従って、
950 @code{scanmap}が
951 @code{exp}の展開形に適用される時、
952 @code{%o2}が再現されません:
954 @example
955 (%i3) scanmap(factor,expand(exp));
956 2 2
957 (%o3) a y + 2 a y + y + x
958 @end example
960 @code{scanmap}が
961 与えられた関数を指数関数を含む部分式すべてに再帰的に適用する方法の別の例です:
963 @example
964 (%i4) expr : u*v^(a*x+b) + c$
965 (%i5) scanmap('f, expr);
966 f(f(f(a) f(x)) + f(b))
967 (%o5) f(f(f(u) f(f(v) )) + f(c))
968 @end example
970 @code{scanmap (@var{f}, @var{expr}, bottomup)}は、
971 ボトムアップ法で
972 @var{f}を
973 @var{expr}に適用します。
974 例えば、未定義@code{f}に関して、
976 @example
977 scanmap(f,a*x+b) ->
978 f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
979 scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
980 -> f(f(a)*f(x))+f(b) ->
981 f(f(f(a)*f(x))+f(b))
982 @end example
984 この場合、両方の方法で同じ答えを得ます。
986 @opencatbox
987 @category{Function application}
988 @closecatbox
989 @end deffn
991 @c -----------------------------------------------------------------------------
992 @anchor{throw}
993 @deffn {関数} throw (@var{expr})
995 @var{expr}を評価し、
996 直近の@code{catch}に値を投げ戻します。
997 @code{throw}は、
998 @code{catch}と一緒に、非ローカルリターンメカニズムとして使われます。
1000 @opencatbox
1001 @category{Programming}
1002 @closecatbox
1003 @end deffn
1005 @c NEED MORE HERE !!
1006 @c AT LEAST SHOULD LIST ACCEPTABLE VARIANTS
1008 @c -----------------------------------------------------------------------------
1009 @anchor{while}
1010 @anchor{unless}
1011 @deffn {特殊演算子} while
1012 @deffnx {特殊演算子} unless
1013 @code{do}を参照してください。
1015 @opencatbox
1016 @category{Programming}
1017 @closecatbox
1018 @end deffn
1020 @c -----------------------------------------------------------------------------
1021 @anchor{outermap}
1022 @deffn {関数} outermap (@var{f}, @var{a_1}, @dots{}, @var{a_n})
1024 関数@var{f}を
1025 外積@var{a_1}掛ける@var{a_2} ... 掛ける@var{a_n}の要素のそれぞれに適用します。
1027 @var{f}は
1028 @math{n}個の引数の関数の名前か、
1029 @math{n}個の引数のラムダ式
1030 です。
1032 それぞれの引数@var{a_k}は、
1033 リストか、入れ子のリストか、行列か、他の任意の種類の式を取り得ます。
1035 @code{outermap}戻り値は、入れ子の構造です。
1036 @var{x}を戻り値とします。
1037 すると、
1038 @var{x}は最初のリストか入れ子のリストか行列引数と同じ構造を持ち、
1039 @code{@var{x}[i_1]...[i_m]}は、
1040 二番目のリストか入れ子のリストか行列引数と同じ構造を持ち、
1041 @code{@var{x}[i_1]...[i_m][j_1]...[j_n]}は、
1042 三番目のリストか入れ子のリストか行列引数と同じ構造を持ち、
1043 以下同様。
1044 ここで、@var{m}, @var{n}, ...は、
1045 引数それぞれの要素
1046 をアクセスするために要求される
1047 インデックスの数(リストには１つ、行列には２つ、入れ子のリストには１つ以上)です。
1048 リストや行列でない引数は戻り値の構造に影響を与えません。
1050 Note that the effect of
1051 @code{outermap}の効果は
1052 @var{f}を
1053 @code{cartesian_product}によって返される
1054 外積の要素のそれぞれに適用することのそれと違います。
1056 @code{outermap}は、戻り値で引数の構造を保ちますが、
1057 @code{cartesian_product}は違います。
1059 @code{outermap}は引数を評価します。
1061 @code{map}, @code{maplist}, @code{apply}も参照してください。
1062 @c CROSS REF OTHER FUNCTIONS HERE ??
1064 例:
1066 @code{outermap}の初等的な例。
1067 よりはっきり引数の組み合わせを示すために、
1068 @code{F}は未定義のままです。
1070 @c ===beg===
1071 @c outermap (F, [a, b, c], [1, 2, 3]);
1072 @c outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
1073 @c outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
1074 @c outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
1075 @c outermap ("+", [a, b, c], [1, 2, 3]);
1076 @c ===end===
1077 @example
1078 (%i1) outermap(F, [a, b, c], [1, 2, 3]);
1079 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
1080 [F(c, 1), F(c, 2), F(c, 3)]]
1081 (%i2) outermap(F, matrix([a, b],[c, d]), matrix([1, 2],[3, 4]));
1082 [ [ F(a, 1) F(a, 2) ] [ F(b, 1) F(b, 2) ] ]
1083 [ [ ] [ ] ]
1084 [ [ F(a, 3) F(a, 4) ] [ F(b, 3) F(b, 4) ] ]
1085 (%o2) [ ]
1086 [ [ F(c, 1) F(c, 2) ] [ F(d, 1) F(d, 2) ] ]
1087 [ [ ] [ ] ]
1088 [ [ F(c, 3) F(c, 4) ] [ F(d, 3) F(d, 4) ] ]
1089 (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
1090 [ F(a, x, 1) F(a, x, 2) ] [ F(b, x, 1) F(b, x, 2) ]
1091 (%o3) [[ ], [ ]]
1092 [ F(a, x, 3) F(a, x, 4) ] [ F(b, x, 3) F(b, x, 4) ]
1093 (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
1094 [ [ F(a, 1, x) ] [ F(a, 2, x) ] ]
1095 (%o4) [[ [ ] [ ] ],
1096 [ [ F(a, 1, y) ] [ F(a, 2, y) ] ]
1097 [ [ F(b, 1, x) ] [ F(b, 2, x) ] ]
1098 [ [ ] [ ] ]]
1099 [ [ F(b, 1, y) ] [ F(b, 2, y) ] ]
1100 (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
1101 (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
1102 [c + 1, c + 2, c + 3]]
1103 @end example
1105 @code{outermap}の戻り値のより密な検査。
1106 最初の、二番目の、三番目の引数は、それぞれ、行列、リスト、行列です。
1107 戻り値は行列です。
1108 その行列の要素それぞれはリストで、
1109 それぞれのリストの要素それぞれは行列です。
1111 @c ===beg===
1112 @c arg_1 : matrix ([a, b], [c, d]);
1113 @c arg_2 : [11, 22];
1114 @c arg_3 : matrix ([xx, yy]);
1115 @c xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1,
1116 @c arg_2, arg_3);
1117 @c xx_1 : xx_0 [1][1];
1118 @c xx_2 : xx_0 [1][1] [1];
1119 @c xx_3 : xx_0 [1][1] [1] [1][1];
1120 @c [op (arg_1), op (arg_2), op (arg_3)];
1121 @c [op (xx_0), op (xx_1), op (xx_2)];
1122 @c ===end===
1123 @example
1124 (%i1) arg_1 : matrix ([a, b], [c, d]);
1125 [ a b ]
1126 (%o1) [ ]
1127 [ c d ]
1128 (%i2) arg_2 : [11, 22];
1129 (%o2) [11, 22]
1130 (%i3) arg_3 : matrix ([xx, yy]);
1131 (%o3) [ xx yy ]
1132 (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
1133 arg_2, arg_3);
1134 [ [ a a ] [ a a ] ]
1135 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1136 [ [ 11 11 ] [ 22 22 ] ]
1137 (%o4) Col 1 = [ ]
1138 [ [ c c ] [ c c ] ]
1139 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1140 [ [ 11 11 ] [ 22 22 ] ]
1141 @group
1142 [ [ b b ] [ b b ] ]
1143 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1144 [ [ 11 11 ] [ 22 22 ] ]
1145 Col 2 = [ ]
1146 [ [ d d ] [ d d ] ]
1147 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
1148 [ [ 11 11 ] [ 22 22 ] ]
1149 @end group
1150 (%i5) xx_1 : xx_0 [1][1];
1151 [ a a ] [ a a ]
1152 (%o5) [[ xx + -- yy + -- ], [ xx + -- yy + -- ]]
1153 [ 11 11 ] [ 22 22 ]
1154 (%i6) xx_2 : xx_0 [1][1] [1];
1155 [ a a ]
1156 (%o6) [ xx + -- yy + -- ]
1157 [ 11 11 ]
1158 (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
1159 a
1160 (%o7) xx + --
1161 11
1162 (%i8) [op (arg_1), op (arg_2), op (arg_3)];
1163 (%o8) [matrix, [, matrix]
1164 (%i9) [op (xx_0), op (xx_1), op (xx_2)];
1165 (%o9) [matrix, [, matrix]
1166 @end example
1168 @code{outermap}は、戻り値の中で引数の構造を保持します。
1169 @code{cartesian_product}は保持しません。
1171 @c ===beg===
1172 @c outermap (F, [a, b, c], [1, 2, 3]);
1173 @c setify (flatten (%));
1174 @c map (lambda ([L], apply (F, L)),
1175 @c cartesian_product ({a, b, c}, {1, 2, 3}));
1176 @c is (equal (%, %th (2)));
1177 @c ===end===
1178 @example
1179 (%i1) outermap (F, [a, b, c], [1, 2, 3]);
1180 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
1181 [F(c, 1), F(c, 2), F(c, 3)]]
1182 (%i2) setify (flatten (%));
1183 (%o2) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
1184 F(c, 1), F(c, 2), F(c, 3)@}
1185 (%i3) map(lambda([L], apply(F, L)),
1186 cartesian_product(@{a, b, c@}, @{1, 2, 3@}));
1187 (%o3) @{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 (%i4) is (equal (%, %th (2)));
1190 (%o4) true
1191 @end example
1193 @opencatbox
1194 @category{Function application}
1195 @closecatbox
1196 @end deffn