doc/info/ja/Program.texi

   1 @menu
   2 * Lisp and Maxima::
   3 * Garbage Collection::
   4 * Introduction to Program Flow::
   5 * Functions and Variables for Program Flow::
   6 @end menu
   7
   8 @c -----------------------------------------------------------------------------
   9 @node Lisp and Maxima, Garbage Collection, Program Flow, Program Flow
  10 @section Lisp and Maxima
  11 @c -----------------------------------------------------------------------------
  12
  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")}に間違えられます。
  24
  25 Lispシンボルの中に、ハイフン@code{-}やアスタリスク@code{*}、他の特殊文字があれば、
  26 Maximaのコードの中では、バックスラッシュ@code{\}でエスケープしないといけません。
  27 例えば、Lispの識別子 @code{*foo-bar*}は、Maximaでは、@code{?\*foo\-bar\*}と書きます。
  28
  29 Maximaセッションの中で、Lispコードを実行できます。
  30 特殊コマンド@code{:lisp}を使って、
  31 （１つか複数のフォームを含む）Lispの一行を実行できます。例えば、
  32
  33 @example
  34 (%i1) :lisp (foo $x $y)
  35 @end example
  36
  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 処理するファイルの中では使えません。
  43
  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
  50
  51 Lispの関数や変数を、Maximaで通常の関数名、変数名(特殊な句読点のない名前)に見せるには、
  52 Lispの名前をドル記号@code{$}で始めなければなりません。
  53
  54 Maximaでは、識別子の中の大文字、小文字が区別されます。
  55 LispとMaximaの間の名前変換を決めるルールがあります。
  56
  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
  73
  74 @code{#$}Lispマクロを使うと、Maximaの式をLispコードの中で使うことができます。
  75 @code{#$@var{expr}$}はMaximaの式@var{expr}と同値なLispの式に展開されます。
  76
  77 @example
  78 (msetq $foo #$[x, y]$)
  79 @end example
  80
  81 @noindent
  82 これは以下のように入力するのと同じ効果です。
  83
  84 @example
  85 (%i1) foo: [x, y];
  86 @end example
  87
  88 @noindent
  89 Lisp関数@code{displa}は、Maximaフォーマットで式を表示します。
  90
  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
  98
  99 Maximaで定義された関数は、通常のLisp関数ではありません。
 100 Lisp関数@code{mfuncall}は、Maxima関数をコールします。
 101 例えば:
 102
 103 @example
 104 (%i1) foo(x,y) := x*y$
 105 (%i2) :lisp (mfuncall '$foo 'a 'b)
 106 ((MTIMES SIMP) A B)
 107 @end example
 108
 109 以下のLisp関数は、Maximaパッケージの中でシャドウされています。
 110
 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
 120
 121 @opencatbox
 122 @category{Programming}
 123 @closecatbox
 124
 125 @c -----------------------------------------------------------------------------
 126 @node Garbage Collection, Introduction to Program Flow, Lisp and Maxima, Program Flow
 127 @section Garbage Collection
 128 @c -----------------------------------------------------------------------------
 129
 130 数式処理は膨大なゴミ(最終的には使われない一時的な、もしくは中間の結果)を生む傾向があり、
 131 ゴミの効率的な取り扱いは、プログラムをうまく完了させるために非常に重要な場合があります。
 132
 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)を実行すると、どの領域がより多くの空間を必要としているか決めるのに役立つでしょう。
 141
 142 Maximaを走らせる他のLispについては、
 143 そのLispのGCの制御の仕方に関するドキュメントを調べてください。
 144
 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 -----------------------------------------------------------------------------
 149
 150 Maximaは、
 151 @code{go}のようなもっとプリミティブな構成子はもちろん、
 152 繰り返しのために@code{do}ループを提供します。
 153
 154 @c end concepts Program Flow
 155
 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 -----------------------------------------------------------------------------
 160
 161 @c -----------------------------------------------------------------------------
 162 @anchor{backtrace}
 163 @deffn  {関数} backtrace ()
 164 @deffnx {関数} backtrace (@var{n})
 165
 166 コールスタック、すなわち、
 167 現在アクティブな関数をコールした関数のリスト、を印字します。
 168
 169 @code{backtrace()}はコールスタック全体を印字します。
 170
 171 @code{backtrace (@var{n})}は、
 172 現在アクティブな関数を含めて、@var{n}個の直近の関数を印字します。
 173
 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 スクリプト、関数、対話プロンプトからコールすることができます。
 179
 180 例:
 181
 182 @itemize @bullet
 183 @item
 184 @code{backtrace()}はコールスタック全体を印字します。
 185
 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
 201
 202 @itemize @bullet
 203 @item
 204 @code{backtrace (@var{n})}は、
 205 現在アクティブな関数を含めて、@var{n}個の直近の関数を印字します。
 206
 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
 222
 223 @opencatbox
 224 @category{Debugging}
 225 @closecatbox
 226 @end deffn
 227
 228 @c -----------------------------------------------------------------------------
 229 @anchor{do}
 230 @deffn {特殊演算子} do
 231
 232 @code{do}文は繰り返しを実行するために使われます。
 233 その強力な一般性のために、
 234 @code{do}文は２編で記述されます。
 235 最初、通常の形式が
 236 (Fortran, Algol, PL/I, など)いくつかの他のプログラミング言語の中で使われるそれ
 237 との類似で与えられます;
 238 それから、他の特長が言及されます。
 239
 240 この形式の、終了条件に関してだけ違う３つの別形があります。
 241 それらは:
 242
 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
 254
 255 @c UGH. DO WE REALLY NEED TO MENTION THIS??
 256 (代わりに、@code{step}は終了条件や範囲の後与えられるかもしれません。)
 257
 258 @var{initial_value}, @var{increment}, @var{limit}, @var{body}は、
 259 任意の式を取り得ます。
 260 もし増分が1なら、 "@code{step 1}"は省略できます。
 261
 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}が終了する複数の終了条件を与えることもできます。
 274
 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}は適切に終了しないかもしれません。
 286
 287 @var{limit}, @var{increment}, 終了条件は、ループを通して毎回評価されることに注意してください。
 288 もしこれらのいずれかがおおくの計算を含み、
 289 @var{body}の実行中すべてで変わらない結果をもたらすなら、
 290 @code{do}に先立って変数をそれらの値に設定し、その変数を
 291 @code{do}形式の中で使うことはもっと効率的です。
 292
 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}関数は使えないことにも注意してください。
 301
 302 制御変数はいつも @code{do}にローカルです。
 303
 304 従って、
 305 @code{do}の外側の同じ名前を持つ変数の値に影響することなく、任意の変数が使えます。
 306 制御変数は、 @code{do}が終了した後、バインドされていません。
 307
 308 @example
 309 (%i1) for a:-3 thru 26 step 7 do display(a)$
 310                              a = - 3
 311
 312                               a = 4
 313
 314                              a = 11
 315
 316                              a = 18
 317
 318                              a = 25
 319 @end example
 320
 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
 328
 329 条件@code{while i <= 10}は、
 330 @code{unless i > 10}と、また、@code{thru 10}と同値であることに注意してください。
 331
 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
 344
 345 以上は、@code{e^sin(x)}のTaylor級数の8項を与えます。
 346
 347
 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
 362
 363 この例は、
 364 Newton-Raphson反復を最大10回使って、
 365 10の負の平方根を計算します。
 366 もし収束基準が満たされないなら、
 367 戻り値は@code{done}になります。
 368
 369 いつもある量を制御変数に加える代わりに、
 370 繰り返しそれぞれで量をある他の方法で換えたい時があるかもしれません。
 371 この場合、
 372 @code{step @var{increment}}の代わりに
 373 @code{next @var{expression}}を使うことができます。
 374 これは、ループの間、
 375 制御変数が毎回@var{expression}の評価結果に設定されるようにします。
 376
 377 @example
 378 (%i6) for count: 2 next 3*count thru 20 do display (count)$
 379                             count = 2
 380
 381                             count = 6
 382
 383                            count = 18
 384 @end example
 385
 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が使われます。
 394
 395 制御変数が実際には決して使われないような繰り返しを実行することに興味があることがあるかもしれません。
 396 それゆえに、
 397 貧弱な初期推測を使って5の平方根を計算する以下の例にあるように、
 398 初期化と更新情報を省略して終了条件だけ与えることが許されます。
 399
 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
 408
 409 もし望むなら、終了条件さえ完全に省略し、
 410 無限に@var{body}を評価し続ける@code{do @var{body}}だけを与えることもできます。
 411 この場合、関数@code{return}が@code{do}の実行を終了するのに使われるべきです。
 412
 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
 421
 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}の値として返されます。)
 430
 431 @code{do}のもう１つ別の形式がMaximaで利用可能です。構文法は:
 432
 433 @example
 434 for @var{variable} in @var{list} @var{end_tests} do @var{body}
 435 @end example
 436
 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}は非アトムの任意の式を取り得えて、連続的な部分が取られます。)
 448
 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
 459
 460 @opencatbox
 461 @category{Programming}
 462 @closecatbox
 463 @end deffn
 464
 465 @c -----------------------------------------------------------------------------
 466 @anchor{errcatch}
 467 @deffn {関数} errcatch (@var{expr_1}, @dots{}, @var{expr_n})
 468
 469 @var{expr_1}, @dots{}, @var{expr_n}を１つずつ評価し、
 470 もしエラーが起こらないなら、@code{[@var{expr_n}]} (リスト)を返します。
 471 もしいずれかの引数の評価中にエラーが起こったら、
 472 @code{errcatch} はエラーが伝搬することを抑制し、
 473 引数をこれ以上評価せずに空のリスト@code{[]}を返します。
 474
 475 @code{errcatch}は
 476 もしエラーがチャッチされないなら@code{batch}を終了させるエラーが起こるかもしれないと疑うような
 477 @code{batch}ファイルで役立ちます。
 478
 479 @opencatbox
 480 @category{Programming}
 481 @closecatbox
 482 @end deffn
 483
 484 @c -----------------------------------------------------------------------------
 485 @anchor{error}
 486 @deffn  {関数} error (@var{expr_1}, ..., @var{expr_n})
 487 @deffnx {システム変数} error
 488
 489 @var{expr_1}, ..., @var{expr_n}を評価して印字します。
 490 そして、エラーがあれば、トップレベルMaximaか直近の@code{errcatch}に戻るようにします。
 491
 492 変数@code{error}はエラーを記述するリストに設定されます。
 493 @code{error}の最初の要素はフォーマット文字列です。
 494 引数@var{expr_1}, ..., @var{expr_n}の中の文字列すべてを結合したものです。
 495 残りの要素は文字列でない引数の値です。
 496
 497 @code{errormsg()}は@code{error}をフォーマットし印字します。
 498 これは直近のエラーメッセージを効果的に再印字します。
 499
 500 @opencatbox
 501 @category{Programming}
 502 @closecatbox
 503 @end deffn
 504
 505 @c -----------------------------------------------------------------------------
 506 @anchor{error_size}
 507 @defvr {オプション変数} error_size
 508 デフォルト値: 10
 509
 510 @code{error_size}は、
 511 現れる式のサイズに従って、エラーメッセージを変更します。
 512 もし式のサイズが、Lisp関数@code{ERROR-SIZE}によって決定されるように）
 513 @code{error_size}より大きいなら、
 514 式は、メッセージの中で、シンボルで置き換えられ、
 515 シンボルは式に割り当てられます。
 516 シンボルはリスト@code{error_syms}から取られます。
 517
 518 そうでなければ、式は@code{error_size}より小さく、
 519 メッセージの中に式が表示されます。
 520
 521 @code{error}と@code{error_syms}も参照してください。
 522
 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);
 531
 532 @code{U}のサイズは、@code{ERROR-SIZE}で決められるように、24です。
 533
 534 @example
 535 (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$
 536
 537 (%i2) error_size: 20$
 538
 539 (%i3) error ("Example expression is", U);
 540
 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$
 550
 551 (%i6) error ("Example expression is", U);
 552
 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
 560
 561 @opencatbox
 562 @category{Debugging}
 563 @category{Display flags and variables}
 564 @closecatbox
 565 @end defvr
 566
 567 @c -----------------------------------------------------------------------------
 568 @anchor{error_syms}
 569 @defvr {オプション変数} error_syms
 570 デフォルト値: @code{[errexp1, errexp2, errexp3]}
 571
 572 エラーメッセージの中で、
 573 @code{error_size}より大きな式はシンボルで置き換えられ、
 574 シンボルは式に設定されます。
 575 シンボルはリスト@code{error_syms}から取られます。
 576 最初の大きすぎる式は、@code{error_syms[1]}で置き換えられ、
 577 ２番目は、@code{error_syms[2]}で置き換えられ、などなど。
 578
 579 もし大きすぎる式が@code{error_syms}の要素よりもあれば、
 580 シンボルは自動的に構成されます。
 581 @var{n}番目のシンボルは@code{concat ('errexp, @var{n})}と同値です。
 582
 583 @code{error}と@code{error_size}も参照してください。
 584
 585 @opencatbox
 586 @category{Debugging}
 587 @category{Display flags and variables}
 588 @closecatbox
 589 @end defvr
 590
 591 @c -----------------------------------------------------------------------------
 592 @anchor{errormsg}
 593 @deffn {関数} errormsg ()
 594
 595 直近のエラーメッセージを再印字します。
 596 変数@code{error}はメッセージを保持し、
 597 @code{errormsg}はそれをフォーマットし印字します。
 598
 599 @opencatbox
 600 @category{Programming}
 601 @closecatbox
 602 @end deffn
 603
 604 @c -----------------------------------------------------------------------------
 605 @anchor{option_errormsg}
 606 @defvr {オプション変数} errormsg
 607 デフォルト値: @code{true}
 608
 609 @code{false}の時、エラーメッセージの出力は抑制されます。
 610
 611 オプション変数@code{errormsg}は
 612 ブロックの中でローカル値に設定することはできません。
 613 @code{errormsg}のグローバル値が常に存在します。
 614
 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);
 630
 631  -- an error. To debug this try: debugmode(true);
 632 @end example
 633
 634 オプション変数@code{errormsg}はブロックの中でローカル値に設定できません。
 635
 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
 657
 658 @opencatbox
 659 @category{Programming}
 660 @closecatbox
 661 @end defvr
 662
 663 @c REPHRASE
 664 @c AT LEAST SHOULD LIST VARIANTS HERE
 665
 666 @c -----------------------------------------------------------------------------
 667 @anchor{for}
 668 @deffn {特殊演算子} for
 669
 670 繰り返しで使われます。
 671 Maximaの繰り返し機能の記述に関しては、@code{do}を参照してください。
 672
 673 @opencatbox
 674 @category{Programming}
 675 @closecatbox
 676 @end deffn
 677
 678 @c -----------------------------------------------------------------------------
 679 @anchor{go}
 680 @deffn {関数} go (@var{tag})
 681
 682 制御を
 683 @code{go}の引数でタグ付けされたブロックの文に移すために
 684 @code{block}内部で使われます。
 685 文をタグ付けするには、
 686 その文の前に、
 687 アトムの引数を
 688 @code{block}の中の別の文として
 689 先行させてください。
 690 例えば:
 691
 692 @example
 693 block ([x], x:1, loop, x+1, ..., go(loop), ...)
 694 @end example
 695
 696 @code{go}の引数は、同じ@code{block}の中に現れるタグの名前でなければいけません。
 697 @code{go}を含む@code{block}以外の@code{block}の中のタグに移るために、
 698 @code{go}を使うことはできません。
 699
 700 @opencatbox
 701 @category{Programming}
 702 @closecatbox
 703 @end deffn
 704
 705 @c NEEDS CLARIFICATION, EXPANSION, EXAMPLES
 706 @c THIS ITEM IS IMPORTANT
 707
 708 @c -----------------------------------------------------------------------------
 709 @anchor{if}
 710 @deffn {特殊演算子} if
 711
 712 条件評価を表します。
 713 @code{if}式の様々な形が認識されます。
 714
 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}に評価されます。
 719
 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}に評価されます。
 724
 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}と同値です。
 731
 732 選択肢@var{expr_0}, @dots{}, @var{expr_n}は、任意のMaxima式を取り得ます。
 733 入れ子の@code{if}式もあり得ます。
 734 選択肢は、
 735 対応する条件が@code{true}でない限り、
 736 整理も評価もされません。
 737
 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 結果は条件式になります。
 747
 748 条件は以下のように、他の要素間の関係演算子と論理演算子からなります。
 749
 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 演算                 シンボル     タイプ
 754
 755 小なり                <           関係 中置
 756 以下                  <=          関係 中置
 757 等号 (構文法的)        =           関係 中置
 758 不等号 (構文法的)      #           関係 中置
 759 等号 (値)             equal       関係 関数
 760 不等号 (値)           notequal    関係 関数
 761 以上                  >=          関係 中置
 762 大なり                >           関係 中置
 763 かつ                  and         論理 中置
 764 または                or          論理 中置
 765 否定                  not         論理 前置
 766 @end example
 767
 768 @opencatbox
 769 @category{Programming}
 770 @category{Predicate functions}
 771 @closecatbox
 772 @end deffn
 773
 774 @c NEEDS CLARIFICATION
 775 @c THIS ITEM IS IMPORTANT
 776
 777 @c -----------------------------------------------------------------------------
 778 @anchor{map}
 779 @deffn {関数} map (@var{f}, @var{expr_1}, @dots{}, @var{expr_n})
 780
 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}は内部表現に階層リスト構造を持つ式です。）
 786
 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}なら、上の２つの場合、エラーメッセージを出力します。
 793
 794 この関数の用法の１つは、ある関数（例えば、@code{partfrac})を非常に長い式に適用する際、
 795 計算の間にリスト保存領域を枯渇させるため式全体に適応するのが不可能な場合に、
 796 それぞれの項に関数をマップすることです。
 797
 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]
 814
 815
 816 @end example
 817
 818 @opencatbox
 819 @category{Function application}
 820 @closecatbox
 821 @end deffn
 822
 823 @c -----------------------------------------------------------------------------
 824 @anchor{mapatom}
 825 @deffn {関数} mapatom (@var{expr})
 826
 827 @var{expr}がマップルーチンでアトムとして扱われる時だけ@code{true}を返します。
 828 "Mapatoms"はアトム、(有理数を含む)数、添字付き変数です。
 829 @c WHAT ARE "THE MAPPING ROUTINES", AND WHY DO THEY HAVE A SPECIALIZED NOTION OF ATOMS ??
 830
 831 @opencatbox
 832 @category{Predicate functions}
 833 @closecatbox
 834 @end deffn
 835
 836 @c NEEDS CLARIFICATION
 837
 838 @c -----------------------------------------------------------------------------
 839 @anchor{maperror}
 840 @defvr {オプション変数} maperror
 841 デフォルト値: @code{true}
 842
 843 @code{maperror}が@code{false}の時は、
 844 マップ関数すべてに、以下の例のようにさせます。
 845
 846 @example
 847 map (@var{f}, @var{expr_1}, @var{expr_2}, @dots{})
 848 @end example
 849
 850 に対しては、
 851 (1) もし@var{expr_i}のすべてが同じ長さでないなら、
 852 最も短い@var{expr_i}の終わりまで完了した時、停止するようにさせ、
 853 (2) もし@var{expr_i}すべてが同じタイプのオブジェクトでないなら、
 854 @var{f}を[@var{expr_1}, @var{expr_2}, ...]に適用するようにさせます。
 855
 856 もし@code{maperror}が@code{true}なら、
 857 上の２つの例に関して、エラーメッセージが表示されます。
 858
 859 @opencatbox
 860 @category{Function application}
 861 @closecatbox
 862 @end defvr
 863
 864 @c -----------------------------------------------------------------------------
 865 @anchor{mapprint}
 866 @defvr {オプション変数} mapprint
 867 デフォルト値: @code{true}
 868
 869 @code{mapprint}が@code{true}の時、
 870 @code{map}, @code{mapl}, @code{fullmap}からの様々な情報メッセージが
 871 一定の状況で生成されます。
 872 これらは
 873 @code{map}が@code{apply}を使ったり、@code{map}が
 874 最短のリストで切り詰めているような状況を含みます。
 875
 876 もし@code{mapprint}が@code{false}なら、これらのメッセージは抑制されます
 877
 878 @opencatbox
 879 @category{Function application}
 880 @closecatbox
 881 @end defvr
 882
 883 @c NEEDS CLARIFICATION
 884
 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}は、関数名かラムダ式です。
 890
 891 @code{maplist}は@code{map (@var{f}, @var{expr_1}, ..., @var{expr_n})}とは違います。
 892 mapは主演算子が@var{expr_i}と同じ式を返します。
 893 (整理と@code{map}が@code{apply}を行う場合は例外です。)
 894
 895
 896 @opencatbox
 897 @category{Function application}
 898 @closecatbox
 899 @end deffn
 900
 901 @c NEEDS CLARIFICATION
 902
 903 @c -----------------------------------------------------------------------------
 904 @anchor{prederror}
 905 @defvr {オプション変数} prederror
 906 デフォルト値: @code{false}
 907
 908 @code{prederror}が@code{true}の時、
 909 @code{if}文の述語論理か@code{is}関数が
 910 @code{true}か@code{false}に評価されるのに失敗した時はいつでも
 911 エラーメッセージが表示されます。
 912
 913 もし@code{false}なら、この場合，代わりに@code{unknown}が返されます。
 914 @code{prederror: false}モードは翻訳コードではサポートされません;
 915 しかしながら、@code{maybe}は翻訳コードでサポートされます。
 916
 917 @code{is}と@code{maybe}も参照してください。
 918
 919 @opencatbox
 920 @category{Programming}
 921 @category{Predicate functions}
 922 @closecatbox
 923 @end defvr
 924
 925 @deffn {関数} return (@var{value})
 926 引数を連れて、陽にブロックから抜けるために使われます。
 927 もっと情報を知るには、@code{block}も参照してください。
 928
 929 @opencatbox
 930 @category{Programming}
 931 @closecatbox
 932 @end deffn
 933
 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 例えば:
 940
 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
 947
 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}が再現されません:
 957
 958 @example
 959 (%i3) scanmap(factor,expand(exp));
 960                            2                  2
 961 (%o3)                      a  y + 2 a y + y + x
 962 @end example
 963
 964 @code{scanmap}が
 965 与えられた関数を指数関数を含む部分式すべてに再帰的に適用する方法の別の例です:
 966
 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
 973
 974 @code{scanmap (@var{f}, @var{expr}, bottomup)}は、
 975 ボトムアップ法で
 976 @var{f}を
 977 @var{expr}に適用します。
 978 例えば、未定義@code{f}に関して、
 979
 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
 987
 988 この場合、両方の方法で同じ答えを得ます。
 989
 990 @opencatbox
 991 @category{Function application}
 992 @closecatbox
 993 @end deffn
 994
 995 @c -----------------------------------------------------------------------------
 996 @anchor{throw}
 997 @deffn {関数} throw (@var{expr})
 998
 999 @var{expr}を評価し、
1000 直近の@code{catch}に値を投げ戻します。
1001 @code{throw}は、
1002 @code{catch}と一緒に、非ローカルリターンメカニズムとして使われます。
1003
1004 @opencatbox
1005 @category{Programming}
1006 @closecatbox
1007 @end deffn
1008
1009 @c NEED MORE HERE !!
1010 @c AT LEAST SHOULD LIST ACCEPTABLE VARIANTS
1011
1012 @c -----------------------------------------------------------------------------
1013 @anchor{while}
1014 @anchor{unless}
1015 @deffn  {特殊演算子} while
1016 @deffnx {特殊演算子} unless
1017 @code{do}を参照してください。
1018
1019 @opencatbox
1020 @category{Programming}
1021 @closecatbox
1022 @end deffn
1023
1024 @c -----------------------------------------------------------------------------
1025 @anchor{outermap}
1026 @deffn {関数} outermap (@var{f}, @var{a_1}, @dots{}, @var{a_n})
1027
1028 関数@var{f}を
1029 外積@var{a_1}掛ける@var{a_2} ... 掛ける@var{a_n}の要素のそれぞれに適用します。
1030
1031 @var{f}は
1032 @math{n}個の引数の関数の名前か、
1033 @math{n}個の引数のラムダ式
1034 です。
1035
1036 それぞれの引数@var{a_k}は、
1037 リストか、入れ子のリストか、行列か、他の任意の種類の式を取り得ます。
1038
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 リストや行列でない引数は戻り値の構造に影響を与えません。
1053
1054 Note that the effect of
1055 @code{outermap}の効果は
1056 @var{f}を
1057 @code{cartesian_product}によって返される
1058 外積の要素のそれぞれに適用することのそれと違います。
1059
1060 @code{outermap}は、戻り値で引数の構造を保ちますが、
1061 @code{cartesian_product}は違います。
1062
1063 @code{outermap}は引数を評価します。
1064
1065 @code{map}, @code{maplist}, @code{apply}も参照してください。
1066 @c CROSS REF OTHER FUNCTIONS HERE ??
1067
1068 例:
1069
1070 @code{outermap}の初等的な例。
1071 よりはっきり引数の組み合わせを示すために、
1072 @code{F}は未定義のままです。
1073
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
1108
1109 @code{outermap}の戻り値のより密な検査。
1110 最初の、二番目の、三番目の引数は、それぞれ、行列、リスト、行列です。
1111 戻り値は行列です。
1112 その行列の要素それぞれはリストで、
1113 それぞれのリストの要素それぞれは行列です。
1114
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
1171
1172 @code{outermap}は、戻り値の中で引数の構造を保持します。
1173 @code{cartesian_product}は保持しません。
1174
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
1196
1197 @opencatbox
1198 @category{Function application}
1199 @closecatbox
1200 @end deffn