doc/info/ja/Function.texi

   1 @menu
   2 * Introduction to Function Definition::
   3 * Function::
   4 * Macros::
   5 * Functions and Variables for Function Definition::
   6 @end menu
   7
   8 @c -----------------------------------------------------------------------------
   9 @node Introduction to Function Definition, Function, Function Definition, Function Definition
  10 @section Introduction to Function Definition
  11 @c -----------------------------------------------------------------------------
  12
  13 @c -----------------------------------------------------------------------------
  14 @node Function, Macros, Introduction to Function Definition, Function Definition
  15 @c NEEDS WORK, THIS TOPIC IS IMPORTANT
  16 @c MENTION DYNAMIC SCOPE (VS LEXICAL SCOPE)
  17 @section Function
  18 @c -----------------------------------------------------------------------------
  19
  20 @opencatbox
  21 @category{Function definition} @category{Programming}
  22 @closecatbox
  23
  24 @c -----------------------------------------------------------------------------
  25 @subsection Ordinary functions
  26 @c -----------------------------------------------------------------------------
  27
  28 Maximaの中で関数を定義するためには、
  29 @code{:=}演算子を使います。
  30 例えば、
  31
  32 @example
  33 f(x) := sin(x)
  34 @end example
  35
  36 @noindent
  37 は関数 @code{f}を定義します。
  38 匿名関数も @code{lambda}を使って生成することができます。
  39 例えば、
  40
  41 @example
  42 f(i,j) := block ([], ...);
  43 map (lambda ([i], i+1), l)
  44 @end example
  45
  46 @noindent
  47 は、項それぞれに1を足したリストを返しますが、
  48
  49 @example
  50 lambda ([i, j], ...)
  51 @end example
  52
  53 @noindent
  54 を@code{f}の代わりに使うことができます。
  55
  56 (訳注: 元マニュアルの編集ミスでしょうか。以下の内容が一貫すると思います。
  57 @example
  58 f(i) := i+1;
  59 map (f, l)
  60 @end example
  61
  62 @noindent
  63 は、項それぞれに1を足したリストを返しますが、
  64
  65 @example
  66 lambda ([i], i+1)
  67 @end example
  68
  69 @noindent
  70 を@code{f}の代わりに使うことができます。)
  71
  72
  73
  74 余分な引数のリストに割り当てられる最後の引数を持つことで、
  75 引数が可変の関数も定義できます:
  76
  77 (訳注:
  78 最後の引数変数を@code{[]}でくくると、残りの引数のリストがその引数変数に割り当てられます。)
  79
  80 @example
  81 (%i1) f ([u]) := u;
  82 (%o1)                      f([u]) := u
  83 (%i2) f (1, 2, 3, 4);
  84 (%o2)                     [1, 2, 3, 4]
  85 (%i3) f (a, b, [u]) := [a, b, u];
  86 (%o3)               f(a, b, [u]) := [a, b, u]
  87 (%i4) f (1, 2, 3, 4, 5, 6);
  88 (%o4)                 [1, 2, [3, 4, 5, 6]]
  89 @end example
  90
  91 関数の右辺は式です。
  92 従って、もし一連の式が欲しいなら、
  93
  94 @example
  95 f(x) := (expr1, expr2, ...., exprn);
  96 @end example
  97
  98 とします。 @var{exprn}の値が関数が返すものになります。
  99
 100 もし関数内部のある式から@code{return}したいなら、
 101 @code{block}と@code{return}を使わなければいけません。
 102
 103 @example
 104 block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)
 105 @end example
 106
 107 はそれ自身式で、関数定義の右辺にとって代わることができます。
 108 この際、最後の式よりも早くreturnが起こるかもしれません。
 109
 110 @c COPY THIS STUFF TO @defun block AS NEEDED
 111 @c ESPECIALLY STUFF ABOUT LOCAL VARIABLES
 112 ブロックの中の最初の@code{[]}は、
 113 @code{[a: 3, b, c: []]}のように、変数と変数割り当てのリストを含むかもしれません。
 114 @code{[a: 3, b, c: []]}は、３つの変数@code{a},@code{b},@code{c}が
 115 コードが、@code{block}内部や@code{block}内部からコールされた関数内部で実行される限り、
 116 グローバル値を参照しないように、しかしむしろ特別な値を持つようにします。
 117 変数がブロックの開始から抜ける時間まで続くので、これは、@i{動的}バインドと呼ばれます。
 118 一旦@code{block}から戻るか、そこから出ると、(もし存在するなら）変数の古い値が戻されます。
 119 この方法で変数を保護することは確かによい考えです。
 120 ブロック変数に関する割り当ては、並列に行われることに注意してください。
 121 これは、もし先に@code{c: a}を使ったら、@code{c}の値はブロックにちょうど入った時、まだ
 122 @code{a}がバインドされる前の@code{a}の値であることを意味します。
 123 例えば、
 124
 125 @example
 126 block ([a: a], expr1, ... a: a+3, ..., exprn)
 127 @end example
 128
 129 のような何かを実行することは、
 130 @code{a}の外部の値を変更されないよう保護しますが、その値がなんだったかアクセス可能にします。
 131 割り当ての右辺は、バインドが起こる前に入る文脈の中で評価されます。
 132 Using just
 133 ただ@code{block ([x], ...}を使うことは、
 134 ちょうどまるで新しいMaximaセッションに入ったかのように、@code{x}がそれ自身を値として持つようにします。
 135
 136 関数の実際の引数は、ブロックの変数と厳密に同じ方法で扱われます。
 137 例えば、
 138
 139 @example
 140 f(x) := (expr1, ..., exprn);
 141 @end example
 142
 143 と
 144
 145 @example
 146 f(1);
 147 @end example
 148
 149 では、式の評価に関して、まるで
 150
 151 @example
 152 block ([x: 1], expr1, ..., exprn)
 153 @end example
 154
 155 を実行したかのような類似の文脈を持ちます。
 156
 157 定義の右辺がランタイムで計算される時、
 158 関数内部では、@code{define}とたぶん@code{buildq}を使うことが役に立ちます。
 159
 160 Inside functions, when the right hand side of a definition, may be computed at runtime, it is useful to use @code{define} and possibly @code{buildq}.
 161
 162 @c -----------------------------------------------------------------------------
 163 @subsection Array functions
 164 @c -----------------------------------------------------------------------------
 165
 166 配列関数は、初めて与えられた引数でコールされた時、関数値を記憶し、
 167 同じ引数が与えられた時、再計算することなしに記憶した値を返します。
 168 そんな関数はしばしば@i{メモ化関数}と呼ばれます。
 169
 170 配列関数名は、(グローバルリスト@code{functions}ではなく)
 171 グローバルリスト@code{arrays}に追加されます。
 172
 173 @code{arrayinfo}は
 174 記憶された値を持つ引数のリストを返し、
 175 @code{listarray}は記憶された値を返します。
 176 @code{dispfun}と@code{fundef}は配列関数の定義を返します。
 177
 178 @code{arraymake}は、通常の関数に対する@code{funmake}のように、
 179 配列関数コールを構成します。
 180 @code{arrayapply}は、
 181 通常の関数に対する@code{apply}のように、
 182 配列関数をその引数に適用します。
 183 配列関数に対して、@code{map}に厳密に似たものはありません。
 184 @code{map(lambda([@var{x}], @var{a}[@var{x}]), @var{L})}または
 185 @code{makelist(@var{a}[@var{x}], @var{x}, @var{L})}
 186 ―@var{L}はリストです―は、目的からそれほど遠くありませんけれども。
 187
 188 @code{remarray}は、
 189 通常の関数に対する@code{remfunction}のように、
 190 (記憶された関数値も含めて、)配列関数の定義を削除します。
 191
 192 @code{kill(@var{a}[@var{x}])}は、配列関数@var{a}の引数@var{x}に関して記憶された
 193 値を削除します;
 194 次回、引数@var{x}で@var{a}がコールされた時、
 195 関数値は再計算されます。
 196 しかしながら、
 197 関数定義も削除する@code{kill(@var{a})}または@code{remarray(@var{a})}を除いて、
 198 記憶された値すべてを一度に削除する方法はありません。
 199
 200 @c -----------------------------------------------------------------------------
 201 @node Macros, Functions and Variables for Function Definition, Function, Function Definition
 202 @section Macros
 203 @c -----------------------------------------------------------------------------
 204
 205 @c -----------------------------------------------------------------------------
 206 @anchor{buildq}
 207 @deffn {関数} buildq (@var{L}, @var{expr})
 208
 209 リスト@var{L}で指名された変数を式 @var{expr}に
 210 並列に代入します。@var{expr}は評価しません。
 211 @code{buildq}が代入を実行した後、
 212 結果の式は整理はされますが、評価されません。
 213
 214 @var{L}の要素はシンボルまたは割り当て式@code{@var{symbol}: @var{value}}です。
 215 割り当て式は並列に評価されます。
 216 すなわち、ある変数が割り当ての右辺へバインドされるのは、
 217 @code{buildq}がコールされた文脈でのバインドです。
 218 変数リスト@var{L}内でその変数がバインドされるのではありません。
 219 もし@var{L}の中のある変数に明示的な割り当てがないなら、
 220 @code{buildq}でのバインドは、
 221 @code{buildq}がコールされた文脈でのそれと同じです。
 222
 223 そして、@var{L}で指名された変数は並列に@var{expr}に代入されます。
 224 すなわち、すべての変数への代入は他の代入がされる前に決まります。
 225 だから、１つの変数の代入は他には一切効果を持ちません。
 226
 227 もし
 228 任意の変数 @var{x}が @var{expr}の中で @code{splice (@var{x})}のように現れるなら、
 229 @var{x}はリストにバインドされなければいけませんし、
 230 リストは、代入の代わりに@var{expr} に接合(内挿)されます。
 231
 232 @var{expr}の中の@var{L}に現れない任意の変数は、
 233 たとえそれらが@code{buildq}がコールされた文脈の中でバインドを持っていても、
 234 逐語的に結果に繰り越されます。
 235
 236 例
 237
 238 @code{a}は明示的に @code{x}にバインドされ、
 239 一方で @code{b}は、コールする文脈で同じバインド(すなわち29)を持ち、
 240 @code{c}は逐語的に繰り越されます。
 241 結果の式は、明示的な評価 @code{''%}まで評価されません。
 242
 243 @c ===beg===
 244 @c (a: 17, b: 29, c: 1729)$
 245 @c buildq ([a: x, b], a + b + c);
 246 @c ''%;
 247 @c ===end===
 248 @example
 249 (%i1) (a: 17, b: 29, c: 1729)$
 250 (%i2) buildq ([a: x, b], a + b + c);
 251 (%o2)                      x + c + 29
 252 (%i3) ''%;
 253 (%o3)                       x + 1758
 254 @end example
 255
 256 @code{e}はリストにバインドされ、
 257 @code{foo}の引数の中でそのように現れ、
 258 @code{bar}の引数の中に内挿されます。
 259
 260 @c ===beg===
 261 @c buildq ([e: [a, b, c]], foo (x, e, y));
 262 @c buildq ([e: [a, b, c]], bar (x, splice (e), y));
 263 @c ===end===
 264 @example
 265 (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
 266 (%o1)                 foo(x, [a, b, c], y)
 267 (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
 268 (%o2)                  bar(x, a, b, c, y)
 269 @end example
 270
 271 代入の後、結果は整理されます。
 272 もし代入の前に整理が適用されたら、これら２つの結果は同じになったはずです。
 273 @c ===beg===
 274 @c buildq ([e: [a, b, c]], splice (e) + splice (e));
 275 @c buildq ([e: [a, b, c]], 2 * splice (e));
 276 @c ===end===
 277 @example
 278 (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
 279 (%o1)                    2 c + 2 b + 2 a
 280 (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
 281 (%o2)                        2 a b c
 282 @end example
 283
 284 @var{L}の中の変数は並列にバインドされます;
 285 もし順次バインドされたなら、
 286 最初の結果は、@code{foo (b, b)}になったはずです。
 287 代入は並列に実行されます;
 288 二番目の結果を@code{subst}の結果と比較してください。
 289 @code{subst}は代入を順次実行します。
 290
 291 @c ===beg===
 292 @c buildq ([a: b, b: a], foo (a, b));
 293 @c buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
 294 @c               bar (u, v, w, x, y, z));
 295 @c subst ([u=v, v=w, w=x, x=y, y=z, z=u],
 296 @c              bar (u, v, w, x, y, z));
 297 @c ===end===
 298 @example
 299 (%i1) buildq ([a: b, b: a], foo (a, b));
 300 (%o1)                       foo(b, a)
 301 (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
 302               bar (u, v, w, x, y, z));
 303 (%o2)                 bar(v, w, x, y, z, u)
 304 (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u],
 305              bar (u, v, w, x, y, z));
 306 (%o3)                 bar(u, u, u, u, u, u)
 307 @end example
 308
 309 変数や式が左辺に、それらの値が右辺にある等式のリストを構成します。
 310 @code{macroexpand}は@code{show_values}が返す式を表示します。
 311
 312 @c ===beg===
 313 @c show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
 314 @c (a: 17, b: 29, c: 1729)$
 315 @c show_values (a, b, c - a - b);
 316 @c macroexpand (show_values (a, b, c - a - b));
 317 @c ===end===
 318 @example
 319 (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
 320 (%o1)   show_values([L]) ::= buildq([L], map("=", 'L, L))
 321 (%i2) (a: 17, b: 29, c: 1729)$
 322 (%i3) show_values (a, b, c - a - b);
 323 (%o3)          [a = 17, b = 29, c - b - a = 1683]
 324 (%i4) macroexpand (show_values (a, b, c - a - b));
 325 (%o4)    map(=, '([a, b, c - b - a]), [a, b, c - b - a])
 326 @end example
 327
 328 複数の引数を持つ関数が与えられたとして、
 329 引数のいくつかが固定されたもう１つの関数を生成します。
 330
 331 @c ===beg===
 332 @c curry (f, [a]) :=
 333 @c         buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
 334 @c by3 : curry ("*", 3);
 335 @c by3 (a + b);
 336 @c ===end===
 337 @example
 338 (%i1) curry (f, [a]) :=
 339         buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
 340 (%i2) by3 : curry ("*", 3);
 341 (%o2)        lambda([[x]], apply(*, append([3], x)))
 342 (%i3) by3 (a + b);
 343 (%o3)                       3 (b + a)
 344 @end example
 345
 346 @opencatbox
 347 @category{Function definition}
 348 @closecatbox
 349 @end deffn
 350
 351 @c -----------------------------------------------------------------------------
 352 @anchor{macroexpand}
 353 @deffn {関数} macroexpand (@var{expr})
 354
 355 @code{expr}がマクロ関数コールの時、
 356 @var{expr}のマクロ展開を、評価はせずに、返します。
 357 そうでなければ、@code{macroexpand}は@var{expr}を返します。
 358
 359 もし@var{expr}の展開が別のマクロ関数コールをもたらすなら、
 360 そのマクロ関数コールも展開されます。
 361
 362 @code{macroexpand}は引数をクォートします。
 363 しかしながら、もしマクロ関数コールの展開が副作用を持つなら，
 364 それらの副作用が実行されます。
 365
 366 @code{::=}, @code{macros}, @code{macroexpand1}も参照してください。
 367
 368 例
 369
 370 @c ===beg===
 371 @c g (x) ::= x / 99;
 372 @c h (x) ::= buildq ([x], g (x - a));
 373 @c a: 1234;
 374 @c macroexpand (h (y));
 375 @c h (y);
 376 @c ===end===
 377 @example
 378 (%i1) g (x) ::= x / 99;
 379                                     x
 380 (%o1)                      g(x) ::= --
 381                                     99
 382 (%i2) h (x) ::= buildq ([x], g (x - a));
 383 (%o2)            h(x) ::= buildq([x], g(x - a))
 384 (%i3) a: 1234;
 385 (%o3)                         1234
 386 (%i4) macroexpand (h (y));
 387                               y - a
 388 (%o4)                         -----
 389                                99
 390 (%i5) h (y);
 391                             y - 1234
 392 (%o5)                       --------
 393                                99
 394 @end example
 395
 396 @opencatbox
 397 @category{Function application}
 398 @closecatbox
 399 @end deffn
 400
 401 @c -----------------------------------------------------------------------------
 402 @anchor{macroexpand1}
 403 @deffn {関数} macroexpand1 (@var{expr})
 404
 405 @code{expr}がマクロ関数コールの時、
 406 @var{expr}のマクロ展開を、評価せずに、返します。
 407 そうでなければ、@code{macroexpand1}は@var{expr}を返します。
 408
 409 @code{macroexpand}は引数をクォートします。
 410 しかしながら、もしマクロ関数コールの展開が副作用を持つなら，
 411 それらの副作用が実行されます。
 412
 413 もし@var{expr}の展開が別のマクロ関数コールをもたらすなら、
 414 そのマクロ関数コールは展開されません。
 415
 416 @code{::=}, @code{macros}, @code{macroexpand}も参照してください。
 417
 418 例
 419
 420 @c ===beg===
 421 @c g (x) ::= x / 99;
 422 @c h (x) ::= buildq ([x], g (x - a));
 423 @c a: 1234;
 424 @c macroexpand1 (h (y));
 425 @c h (y);
 426 @c ===end===
 427 @example
 428 (%i1) g (x) ::= x / 99;
 429                                     x
 430 (%o1)                      g(x) ::= --
 431                                     99
 432 (%i2) h (x) ::= buildq ([x], g (x - a));
 433 (%o2)            h(x) ::= buildq([x], g(x - a))
 434 (%i3) a: 1234;
 435 (%o3)                         1234
 436 (%i4) macroexpand1 (h (y));
 437 (%o4)                       g(y - a)
 438 (%i5) h (y);
 439                             y - 1234
 440 (%o5)                       --------
 441                                99
 442 @end example
 443
 444 @opencatbox
 445 @category{Function application}
 446 @closecatbox
 447 @end deffn
 448
 449 @c -----------------------------------------------------------------------------
 450 @anchor{macros}
 451 @defvr {Global variable} macros
 452 デフォルト値: @code{[]}
 453
 454 @code{macros}は、ユーザー定義のマクロ関数のリストです。
 455 マクロ関数定義演算子@code{::=}は、このリストに新しいマクロ関数を入れ、
 456 @code{kill}, @code{remove}, @code{remfunction}はリストからマクロ関数を削除します。
 457
 458 @code{infolists}も参照してください。
 459
 460 @opencatbox
 461 @category{Function definition} @category{Global variables}
 462 @closecatbox
 463 @end defvr
 464
 465 @c -----------------------------------------------------------------------------
 466 @anchor{splice}
 467 @deffn {関数} splice (@var{a})
 468
 469 @code{splice}が@code{buildq}内部に現れた時だけ、
 470 アトム@var{a}で指名されたリストを式に接合(内挿)します;
 471 そうでなければ、@code{splice}は未定義関数として扱われます。
 472 もし
 473 @code{buildq}内部で
 474 @var{a}単独として(@code{splice}なしに)現れたら、
 475 @var{a}はリストとして、結果の中に代入されます(内挿されません)。
 476 @code{splice}の引数はアトムだけを取り得ます;
 477 リストリテラルやリストをもたらす式を取ることはできません。
 478
 479 通常、@code{splice}は、関数や演算子の引数を提供します。
 480 関数@code{f}に対して、
 481 @code{buildq}内部の式@code{f (splice (@var{a}))}は、
 482 @code{f (@var{a}[1], @var{a}[2], @var{a}[3], ...)}に展開されます。
 483 演算子@code{o}に対して、
 484 @code{buildq}内部の式@code{"o" (splice (@var{a})}は、
 485 @code{"o" (@var{a}[1], @var{a}[2], @var{a}[3], ...)}に展開されます。
 486 ここで@code{o}は、任意のタイプの演算子を取り得ます(通常は複数の引数を取るものです)。
 487 演算子はダブルクォート@code{"}でくくられなければいけないことに注意してください。
 488
 489 例
 490
 491 @c ===beg===
 492 @c buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
 493 @c buildq ([x: [1, %pi]], "/" (splice (x)));
 494 @c matchfix ("<>", "<>");
 495 @c buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
 496 @c ===end===
 497 @example
 498 (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
 499                        foo(1, %pi, z - y)
 500 (%o1)                -----------------------
 501                      length([1, %pi, z - y])
 502 (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
 503                                 1
 504 (%o2)                          ---
 505                                %pi
 506 (%i3) matchfix ("<>", "<>");
 507 (%o3)                          <>
 508 (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
 509 (%o4)                   <>1, %pi, z - y<>
 510 @end example
 511
 512 @opencatbox
 513 @category{Function definition}
 514 @closecatbox
 515 @end deffn
 516
 517 @c end concepts Function Definition
 518
 519 @c -----------------------------------------------------------------------------
 520 @node Functions and Variables for Function Definition,  , Macros, Function Definition
 521 @section Functions and Variables for Function Definition
 522 @c -----------------------------------------------------------------------------
 523
 524 @c -----------------------------------------------------------------------------
 525 @anchor{apply}
 526 @deffn {関数} apply (@var{F}, [@var{x_1}, ..., @var{x_n}])
 527
 528 @code{@var{F}(@var{x_1}, ..., @var{x_n})}を構成、評価します。
 529
 530 @code{apply}は、配列関数を通常の関数と区別しようとはしません;
 531 @var{F}が配列関数の名前の時、@code{apply}は@code{@var{F}(...)}(カギ括弧の代わりに括弧での関数コール）を評価します。
 532 @code{arrayapply}は、この場合、カギ括弧ありで関数コールを評価します。
 533
 534 例:
 535
 536 @code{apply}は、引数を評価します。
 537 この例では、@code{min}が@code{L}の値に適用されます。
 538
 539 @c ===beg===
 540 @c L : [1, 5, -10.2, 4, 3];
 541 @c apply (min, L);
 542 @c ===end===
 543 @example
 544 (%i1) L : [1, 5, -10.2, 4, 3];
 545 (%o1)                 [1, 5, - 10.2, 4, 3]
 546 (%i2) apply (min, L);
 547 (%o2)                        - 10.2
 548 @end example
 549
 550 @code{apply}は、たとえ関数@var{F}が引数をクォートする場合でも、引数を評価します。
 551
 552 @c ===beg===
 553 @c F (x) := x / 1729;
 554 @c fname : F;
 555 @c dispfun (F);
 556 @c dispfun (fname);
 557 @c apply (dispfun, [fname]);
 558 @c ===end===
 559 @example
 560 (%i1) F (x) := x / 1729;
 561                                    x
 562 (%o1)                     F(x) := ----
 563                                   1729
 564 (%i2) fname : F;
 565 (%o2)                           F
 566 (%i3) dispfun (F);
 567                                    x
 568 (%t3)                     F(x) := ----
 569                                   1729
 570
 571 (%o3)                         [%t3]
 572 (%i4) dispfun (fname);
 573 fname is not the name of a user function.
 574  -- an error.  Quitting.  To debug this try debugmode(true);
 575 (%i5) apply (dispfun, [fname]);
 576 @group
 577                                    x
 578 (%t5)                     F(x) := ----
 579                                   1729
 580 @end group
 581 (%o5)                         [%t5]
 582 @end example
 583
 584 @code{apply}は関数名@var{F}を評価します。
 585 シングルクオート@code{'}は評価を無効にします。
 586 @code{demoivre}はグローバル変数の名前であり、また、関数でもあります。
 587
 588 @c ===beg===
 589 @c demoivre;
 590 @c demoivre (exp (%i * x));
 591 @c apply (demoivre, [exp (%i * x)]);
 592 @c apply ('demoivre, [exp (%i * x)]);
 593 @c ===end===
 594 @example
 595 (%i1) demoivre;
 596 (%o1)                         false
 597 (%i2) demoivre (exp (%i * x));
 598 (%o2)                  %i sin(x) + cos(x)
 599 (%i3) apply (demoivre, [exp (%i * x)]);
 600 demoivre evaluates to false
 601 Improper name or value in functional position.
 602  -- an error.  Quitting.  To debug this try debugmode(true);
 603 (%i4) apply ('demoivre, [exp (%i * x)]);
 604 (%o4)                  %i sin(x) + cos(x)
 605 @end example
 606
 607 @opencatbox
 608 @category{Function application}
 609 @closecatbox
 610 @end deffn
 611
 612 @c -----------------------------------------------------------------------------
 613 @anchor{block}
 614 @deffn  {関数} block ([@var{v_1}, ..., @var{v_m}], @var{expr_1}, ..., @var{expr_n})
 615 @deffnx {関数} block (@var{expr_1}, ..., @var{expr_n})
 616
 617 @code{block}は@var{expr_1}, ..., @var{expr_n}を順に評価し、評価された最後の式の値を返します。
 618 順序は@code{go}, @code{throw}, @code{return}関数によって変更することができます。
 619 最後の式は、@code{return}もしくは@code{throw}を含む式が評価されないなら、@var{expr_n}です。
 620 いくつかの変数@var{v_1}, ..., @var{v_m}がブロックにローカルに宣言できます;
 621 これらは同じ名前のグローバル変数と区別されます。
 622 変数がローカルに宣言されないなら、リストは省略できます。
 623 ブロック内では、@var{v_1}, ..., @var{v_m}以外の変数はグローバル変数です。
 624
 625 @code{block}は（存在するなら）変数@var{v_1}, ..., @var{v_m}の現在の値を保存し、
 626 変数がそれ自身に評価されるよう変数のバインドを解除します。
 627 ローカル変数はブロック内部で任意の値にバインドできますが、
 628 ブロックが終了するとき保存された値が戻され、
 629 ブロック内で割り当てられた値は失われます。
 630
 631 @code{block}内部の宣言@code{local(@var{v_1}, ..., @var{v_m})}は
 632 シンボル@var{v_1}, ..., @var{v_m}に関連付けられた性質を保存し、
 633 他の式を評価する前に、性質を取り除き、ブロック終了時に元に戻します。
 634 いくつかの宣言は、@code{:=}、@code{array}, @code{dependencies}, @code{atvalue}, @code{matchdeclare},
 635 @code{atomgrad}, @code{constant}, @code{nonscalar}その他を含むシンボルの性質として実装されます。
 636 @code{local}の効果は、ブロック内部のみで有効な宣言を作ります;
 637 そうでなければ、ブロック内部の宣言は実際にグローバル宣言となります。
 638
 639 @code{block}は他の@code{block}内部でも現れます。
 640 ローカル変数が、新しいブロックが評価されるたびに確立されます。
 641 ローカル変数は、内包するブロックではグローバルです。
 642 ブロックの中で、変数がローカルでないなら、その値は内包するブロックによって割り当てられた最新の値です。
 643 そうでなければ、グローバル環境の変数の値になります。
 644 このポリシーは「動的スコープ」の普通の理解と一致します。
 645
 646 ブロックの値は、最後の文もしくはブロックから陽に終了するのに使われる関数@code{function}の引数の値です。
 647 関数@code{go}は、@code{go}の引数でタグされたブロックの文に制御を移すのに使われます。
 648 例えば、@code{block ([x], x:1, loop, x: x+1, ..., go(loop), ...)}。
 649 @code{go}の引数はブロック内部に現れるタグの名前でなければなりません。
 650 @code{go}を含んだブロック以外のブロック内部のタグへ飛ぶのに@code{go}を使うことはできません。
 651
 652 ブロックは、典型的な場合、関数定義の右辺に現れますが、他の場所でも使うことができます。
 653
 654 @opencatbox
 655 @category{Expressions} @category{Programming}
 656 @closecatbox
 657 @end deffn
 658
 659 @c REPHRASE, NEEDS EXAMPLE
 660
 661 @c -----------------------------------------------------------------------------
 662 @anchor{break}
 663 @deffn {関数} break (@var{expr_1}, ..., @var{expr_n})
 664
 665 @var{expr_1}, ..., @var{expr_n}を評価し、印字し、それから
 666 ユーザーが環境を検査し変更できるところでMaximaブレイクを引き起こします。
 667 @code{exit;}をタイプすると、計算が再開されます。
 668
 669 @opencatbox
 670 @category{Debugging}
 671 @closecatbox
 672 @end deffn
 673
 674 @c FOR SOME REASON throw IS IN SOME OTHER FILE. MOVE throw INTO THIS FILE.
 675 @c NEEDS CLARIFICATION
 676
 677 @c -----------------------------------------------------------------------------
 678 @anchor{catch}
 679 @deffn {関数} catch (@var{expr_1}, ..., @var{expr_n})
 680
 681 @var{expr_1}, ..., @var{expr_n}を１つずつ評価します;
 682 もしどれかが形式@code{throw (arg)}の式の評価に至るなら、
 683 @code{catch}の値は@code{throw (arg)}の値であり、もう式は評価されません。
 684 これの「非局所的リターン」は
 685 入れ子の任意の深さを通過して、@code{throw}を含む最も近い@code{catch}に飛びます。
 686 もし@code{throw}を含む@code{catch}がないなら、
 687 エラーメッセージが印字されます。
 688
 689 もし引数の評価が
 690 いかなる@code{throw}の評価にも至らないなら、
 691 @code{catch}の値は@var{expr_n}の値です。
 692
 693 @example
 694 (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
 695 (%i2) g(l) := catch (map (''%, l))$
 696 (%i3) g ([1, 2, 3, 7]);
 697 (%o3)               [f(1), f(2), f(3), f(7)]
 698 (%i4) g ([1, 2, -3, 7]);
 699 (%o4)                          - 3
 700 @end example
 701
 702 @c REWORD THIS PART.
 703 もし@code{l}が非負数だけから成るなら、
 704 @code{l}の要素それぞれの@code{f}のリストを返します;
 705 そうでなければ、@code{g}は "catches" the
 706 first negative element of
 707 @code{l}の最初の負の要素を「キャッチ」して、それを「スロー」します。
 708
 709 @opencatbox
 710 @category{Programming}
 711 @closecatbox
 712 @end deffn
 713
 714 @c -----------------------------------------------------------------------------
 715 @anchor{compfile}
 716 @deffn  {関数} compfile (@var{filename}, @var{f_1}, @dots{}, @var{f_n})
 717 @deffnx {関数} compfile (@var{filename}, functions)
 718 @deffnx {関数} compfile (@var{filename}, all)
 719
 720 Maxima関数をLispに翻訳し、翻訳したコードをファイル@var{filename}に書き込みます。
 721
 722 @code{compfile(@var{filename}, @var{f_1}, ..., @var{f_n})}は
 723 指定された関数を翻訳します。
 724 @code{compfile (@var{filename}, functions)}と
 725 @code{compfile (@var{filename}, all)}はユーザー定義関数をすべて翻訳します。
 726
 727 Lisp翻訳は評価されず、出力ファイルはLispコンパイラによって処理もされません。
 728 @c SO LET'S CONSIDER GIVING THIS FUNCTION A MORE ACCURATE NAME.
 729 @code{translate}はLisp翻訳を生成し評価します。
 730 @code{compile_file}はMaximaをLispに翻訳し、Lispコンパイラを実行します。
 731
 732 @code{translate}, @code{translate_file}, @code{compile_file}も参照してください。
 733
 734 @opencatbox
 735 @category{Translation and compilation}
 736 @closecatbox
 737 @end deffn
 738
 739 @c THIS VARIABLE IS OBSOLETE: ASSIGNING compgrind: true CAUSES compfile
 740 @c TO EVENTUALLY CALL AN OBSOLETE FUNCTION SPRIN1.
 741 @c RECOMMENDATION IS TO CUT THIS ITEM, AND CUT $compgrind FROM src/transs.lisp
 742 @c @defvar compgrind
 743 @c デフォルト値: @code{false}
 744 @c
 745 @c When @code{compgrind} is @code{true}, function definitions printed by
 746 @c @code{compfile} are pretty-printed.
 747 @c
 748 @c @end defvar
 749
 750 @c -----------------------------------------------------------------------------
 751 @anchor{compile}
 752 @deffn  {関数} compile (@var{f_1}, ..., @var{f_n})
 753 @deffnx {関数} compile (functions)
 754 @deffnx {関数} compile (all)
 755
 756 Maxima関数@var{f_1}, ..., @var{f_n}をLispに翻訳し、
 757 Lisp翻訳を評価し、
 758 翻訳された関数それぞれについてLisp関数@code{COMPILE}をコールします。
 759 @code{compile}は、コンパイルされた関数名のリストを返します。
 760
 761 @code{compile (all)}や@code{compile (functions)}は、
 762 ユーザー定義関数すべてをコンパイルします。
 763
 764 @code{compile}は引数をクォートします;
 765 クォートクォート演算子@code{'@w{}'}はクォートに優先します。
 766
 767 @opencatbox
 768 @category{Translation and compilation}
 769 @closecatbox
 770 @end deffn
 771
 772 @c -----------------------------------------------------------------------------
 773 @anchor{define}
 774 @deffn  {関数} define (@var{f}(@var{x_1}, @dots{}, @var{x_n}), @var{expr})
 775 @deffnx {関数} define (@var{f}[@var{x_1}, @dots{}, @var{x_n}], @var{expr})
 776 @deffnx {関数} define (funmake (@var{f}, [@var{x_1}, @dots{}, @var{x_n}]), @var{expr})
 777 @deffnx {関数} define (arraymake (@var{f}, [@var{x_1}, @dots{}, @var{x_n}]), @var{expr})
 778 @deffnx {関数} define (ev (@var{expr_1}), @var{expr_2})
 779
 780 引数@var{x_1}, @dots{}, @var{x_n}を持ち、
 781 @var{expr}の中身を持つ@var{f}という名前の関数を定義します。
 782 @code{define}は、いつも（陽にクオートされていない限り）、２番目の引数を評価します。
 783 定義された関数は、（かっこでくくられた引数を持つ）通常のMaxima関数
 784 もしくは（カギ括弧でくくられた引数を持つ）配列関数です。
 785
 786 最後の関数の引数@var{x_n}が要素１つのリストの時、
 787 @code{define}によって定義される関数は、可変な数の引数を受け入れます。
 788 実際の引数は、形式的な引数, @var{x_1}, ..., @var{x_(n - 1)}に１対１に割り当てられます。
 789 実際の引数がさらに存在するなら@var{x_n}にリストとして割り当てられます。
 790
 791 @code{define}の最初の引数が@code{@var{f}(@var{x_1}, ..., @var{x_n})}もしくは
 792 @code{@var{f}[@var{x_1}, ..., @var{x_n}]}の形の式の時、
 793 関数の引数は評価されますが、既にその名前の関数や変数があったとしても@var{f}は評価されません。
 794
 795 最初の引数が演算子@code{funmake}もしくは@code{arraymake}, @code{ev}を伴う式の時、
 796 最初の引数は評価されます；これは、本体だけでなく、関数名が計算されることを許します。
 797
 798 すべての関数定義は同じ名前空間で現れます;
 799 関数gの中で関数@code{f}を定義することは、@code{f}のスコープを@code{g}に自動的に限定することにはなりません。
 800 しかしながら、@code{local(f)}は、関数@code{f}の定義を、
 801 @code{local}が現れたブロックや他の合成式内部でのみ有効とします。
 802
 803 もしある形式的な引数@var{x_k}が（評価の後）クォートされたシンボルならば、
 804 @code{define}によって定義される関数は、対応する実際の引数を評価しません。
 805 そうでければ、すべての実際の引数は評価されます。
 806
 807 @code{:=}や@code{::=}も参照してください。
 808
 809 例:
 810
 811 @code{define}は、(陽にクォートされない限り)いつも二番目の引数を評価します
 812
 813 @c ===beg===
 814 @c expr : cos(y) - sin(x);
 815 @c define (F1 (x, y), expr);
 816 @c F1 (a, b);
 817 @c F2 (x, y) := expr;
 818 @c F2 (a, b);
 819 @c ===end===
 820 @example
 821 (%i1) expr : cos(y) - sin(x);
 822 (%o1)                    cos(y) - sin(x)
 823 (%i2) define (F1 (x, y), expr);
 824 (%o2)              F1(x, y) := cos(y) - sin(x)
 825 (%i3) F1 (a, b);
 826 (%o3)                    cos(b) - sin(a)
 827 (%i4) F2 (x, y) := expr;
 828 (%o4)                   F2(x, y) := expr
 829 (%i5) F2 (a, b);
 830 (%o5)                    cos(y) - sin(x)
 831 @end example
 832
 833 @code{define}が定義する関数は、通常のMaxima関数も配列関数も取り得ます。
 834
 835 @c ===beg===
 836 @c define (G1 (x, y), x.y - y.x);
 837 @c define (G2 [x, y], x.y - y.x);
 838 @c ===end===
 839 @example
 840 (%i1) define (G1 (x, y), x.y - y.x);
 841 (%o1)               G1(x, y) := x . y - y . x
 842 (%i2) define (G2 [x, y], x.y - y.x);
 843 (%o2)                G2     := x . y - y . x
 844                        x, y
 845 @end example
 846
 847 最後の、または唯一の引数@var{x_n}が１要素のリストの時、
 848 @code{define}が定義した関数は可変の数の引数を受け付けます。
 849
 850 @c ===beg===
 851 @c define (H ([L]), '(apply ("+", L)));
 852 @c H (a, b, c);
 853 @c ===end===
 854 @example
 855 (%i1) define (H ([L]), '(apply ("+", L)));
 856 (%o1)                H([L]) := apply("+", L)
 857 (%i2) H (a, b, c);
 858 (%o2)                       c + b + a
 859 @end example
 860
 861 最初の引数が
 862 演算子@code{funmake}, @code{arraymake}, または@code{ev}を含む式なら、
 863 最初の引数は評価されます。
 864
 865 @c ===beg===
 866 @c [F : I, u : x];
 867 @c funmake (F, [u]);
 868 @c define (funmake (F, [u]), cos(u) + 1);
 869 @c define (arraymake (F, [u]), cos(u) + 1);
 870 @c define (foo (x, y), bar (y, x));
 871 @c define (ev (foo (x, y)), sin(x) - cos(y));
 872 @c ===end===
 873 @example
 874 (%i1) [F : I, u : x];
 875 (%o1)                        [I, x]
 876 (%i2) funmake (F, [u]);
 877 (%o2)                         I(x)
 878 (%i3) define (funmake (F, [u]), cos(u) + 1);
 879 (%o3)                  I(x) := cos(x) + 1
 880 (%i4) define (arraymake (F, [u]), cos(u) + 1);
 881 (%o4)                   I  := cos(x) + 1
 882                          x
 883 (%i5) define (foo (x, y), bar (y, x));
 884 (%o5)                foo(x, y) := bar(y, x)
 885 (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
 886 (%o6)             bar(y, x) := sin(x) - cos(y)
 887 @end example
 888
 889 @opencatbox
 890 @category{Function definition}
 891 @closecatbox
 892 @end deffn
 893
 894 @c SEE NOTE BELOW ABOUT THE DOCUMENTATION STRING
 895 @c @deffn {関数} define_variable (@var{name}, @var{default_value}, @var{mode}, @var{documentation})
 896
 897 @c -----------------------------------------------------------------------------
 898 @anchor{define_variable}
 899 @deffn {関数} define_variable (@var{name}, @var{default_value}, @var{mode})
 900
 901 グローバル変数をMaxima環境に導入します。
 902 @c IMPORT OF FOLLOWING STATEMENT UNCLEAR: IN WHAT WAY IS define_variable
 903 @c MORE USEFUL IN TRANSLATED CODE ??
 904 @code{define_variable}は、ユーザーが書いたパッケージで役に立ちます。
 905 パッケージはしばしば翻訳されたりコンパイルされたりします。
 906
 907 @code{define_variable}は以下のステップを実行します:
 908
 909 @enumerate
 910 @item
 911 @code{mode_declare (@var{name}, @var{mode})}は、
 912 @var{name}のモードを翻訳器に宣言します。
 913 可能なモードのリストについては、@code{mode_declare}を参照してください。
 914
 915 @item
 916 もし変数がバインドされていなければ、@var{default_value}が@var{name}に割り当てられます。
 917
 918 @item
 919 @code{declare (@var{name}, special)}はそれをspecialと宣言します。
 920 @c CLARIFY THE MEANING OF SPECIAL FOR THE BENEFIT OF READERS OTHER THAN LISP PROGRAMMERS
 921
 922 @item
 923 @var{name}が宣言されたモードのただ１つの割り当てられた値であることを
 924 保証するために、
 925 @var{name}をテスト関数に関連づけます。
 926
 927 @end enumerate
 928
 929
 930 @c FOLLOWING STATEMENT APPEARS TO BE OUT OF DATE.
 931 @c EXAMINING DEFMSPEC $DEFINE_VARIABLE AND DEF%TR $DEFINE_VARIABLE IN src/trmode.lisp,
 932 @c IT APPEARS THAT THE 4TH ARGUMENT IS NEVER REFERRED TO.
 933 @c EXECUTING translate_file ON A MAXIMA BATCH FILE WHICH CONTAINS
 934 @c define_variable (foo, 2222, integer, "THIS IS FOO");
 935 @c DOES NOT PUT "THIS IS FOO" INTO THE LISP FILE NOR THE UNLISP FILE.
 936 @c The optional 4th argument is a documentation string.  When
 937 @c @code{translate_file} is used on a package which includes documentation
 938 @c strings, a second file is output in addition to the Lisp file which
 939 @c will contain the documentation strings, formatted suitably for use in
 940 @c manuals, usage files, or (for instance) @code{describe}.
 941
 942 @code{value_check}プロパティは、
 943 @code{define_variable}を介して
 944 @code{any}以外のモードに定義された任意の変数に割り当てられることができます。
 945 @code{value_check}プロパティは、１変数のラムダ式または関数名です。
 946 それは値を変数に割り当てようとする時にコールされます。
 947 @code{value_check}関数の引数は期待値です。
 948
 949 @code{define_variable}は@code{default_value}を評価し、
 950 @code{name}と@code{mode}をクォートします。
 951 @code{define_variable}は@code{name}の現在値を返します。
 952 それは、もし@code{name}がそこでバインドされてないなら@code{default_value}で
 953 そうでないなら@code{name}の以前の値です。
 954
 955 例:
 956
 957 @code{foo}はブーリアン変数で、初期値@code{true}を持ちます。
 958
 959 @c ===beg===
 960 @c define_variable (foo, true, boolean);
 961 @c foo;
 962 @c foo: false;
 963 @c foo: %pi;
 964 @c foo;
 965 @c ===end===
 966 @example
 967 (%i1) define_variable (foo, true, boolean);
 968 (%o1)                         true
 969 (%i2) foo;
 970 (%o2)                         true
 971 (%i3) foo: false;
 972 (%o3)                         false
 973 (%i4) foo: %pi;
 974 Error: foo was declared mode boolean, has value: %pi
 975  -- an error.  Quitting.  To debug this try debugmode(true);
 976 (%i5) foo;
 977 (%o5)                         false
 978 @end example
 979
 980 @code{bar}は整数変数で、素数でなければいけません。
 981
 982 @c ===beg===
 983 @c define_variable (bar, 2, integer);
 984 @c qput (bar, prime_test, value_check);
 985 @c prime_test (y) := if not primep(y) then
 986 @c                            error (y, "is not prime.");
 987 @c bar: 1439;
 988 @c bar: 1440;
 989 @c bar;
 990 @c ===end===
 991 @example
 992 (%i1) define_variable (bar, 2, integer);
 993 (%o1)                           2
 994 (%i2) qput (bar, prime_test, value_check);
 995 (%o2)                      prime_test
 996 (%i3) prime_test (y) := if not primep(y) then
 997                            error (y, "is not prime.");
 998 (%o3) prime_test(y) := if not primep(y)
 999
1000                                    then error(y, "is not prime.")
1001 (%i4) bar: 1439;
1002 (%o4)                         1439
1003 (%i5) bar: 1440;
1004 1440 is not prime.
1005 #0: prime_test(y=1440)
1006  -- an error.  Quitting.  To debug this try debugmode(true);
1007 (%i6) bar;
1008 (%o6)                         1439
1009 @end example
1010
1011 @code{baz_quux}は、値を割り当てられない変数です。
1012 モード@code{any_check}は@code{any}のようですが、
1013 @code{any_check}は@code{value_check}メカニズムを可能にしますが、
1014 @code{any}はそうしません。
1015
1016 @c ===beg===
1017 @c define_variable (baz_quux, 'baz_quux, any_check);
1018 @c F: lambda ([y], if y # 'baz_quux then
1019 @c                  error ("Cannot assign to `baz_quux'."));
1020 @c qput (baz_quux, ''F, value_check);
1021 @c baz_quux: 'baz_quux;
1022 @c baz_quux: sqrt(2);
1023 @c baz_quux;
1024 @c ===end===
1025 @example
1026 (%i1) define_variable (baz_quux, 'baz_quux, any_check);
1027 (%o1)                       baz_quux
1028 (%i2) F: lambda ([y], if y # 'baz_quux then
1029                  error ("Cannot assign to `baz_quux'."));
1030 (%o2) lambda([y], if y # 'baz_quux
1031
1032                         then error(Cannot assign to `baz_quux'.))
1033 (%i3) qput (baz_quux, ''F, value_check);
1034 (%o3) lambda([y], if y # 'baz_quux
1035
1036                         then error(Cannot assign to `baz_quux'.))
1037 (%i4) baz_quux: 'baz_quux;
1038 (%o4)                       baz_quux
1039 (%i5) baz_quux: sqrt(2);
1040 Cannot assign to `baz_quux'.
1041 #0: lambda([y],if y # 'baz_quux then
1042                  error("Cannot assign to `baz_quux'."))(y=sqrt(2))
1043  -- an error.  Quitting.  To debug this try debugmode(true);
1044 (%i6) baz_quux;
1045 (%o6)                       baz_quux
1046 @end example
1047
1048 @opencatbox
1049 @category{Translation and compilation}
1050 @closecatbox
1051 @end deffn
1052
1053 @c -----------------------------------------------------------------------------
1054 @anchor{dispfun}
1055 @deffn  {関数} dispfun (@var{f_1}, @dots{}, @var{f_n})
1056 @deffnx {関数} dispfun (all)
1057
1058 ユーザー定義関数@var{f_1}, ..., @var{f_n}の定義を表示します。
1059 引数それぞれは、(@code{::=}で定義された)マクロ名、
1060 (@code{:=}や@code{define}で定義された)通常の関数、
1061 (@code{:=}y@code{define}で定義された、しかし引数をカギ括弧@code{[ ]}でくくった)
1062 配列関数、
1063 (@code{:=}y@code{define}で定義された、しかしいくつかの引数をカギ括弧@code{[ ]}で、他の引数を括弧@code{( )}でくくった)添字付き関数、
1064 特別な添字の値で選択された添字付き関数の族の１つ、
1065 定数添字で定義された添字付き関数、
1066 のいずれかを取り得ます。
1067
1068 @code{dispfun (all)}は、
1069 @code{functions}, @code{arrays}, @code{macros}リストで与えられた中で、
1070 定数添字で定義された添字付き関数を除いたユーザー定義関数すべてを表示します。
1071
1072 @code{dispfun}は
1073 表示された関数それぞれのために
1074 (@code{%t1}, @code{%t2}, など)
1075 中間式ラベルを生成し、関数定義をラベルに割り当てます。
1076 対照的に、@code{fundef}は関数定義を返します。
1077
1078 @code{dispfun}は引数をクォートします;
1079 クォートクォート演算子@code{'@w{}'}はクォートに優先します。
1080 @code{dispfun}は表示された関数に対応する中間式ラベルのリストを返します。
1081
1082 例:
1083
1084 @c ===beg===
1085 @c m(x, y) ::= x^(-y);
1086 @c f(x, y) :=  x^(-y);
1087 @c g[x, y] :=  x^(-y);
1088 @c h[x](y) :=  x^(-y);
1089 @c i[8](y) :=  8^(-y);
1090 @c dispfun (m, f, g, h, h[5], h[10], i[8]);
1091 @c ''%;
1092 @c ===end===
1093 @example
1094 (%i1) m(x, y) ::= x^(-y);
1095                                      - y
1096 (%o1)                   m(x, y) ::= x
1097 (%i2) f(x, y) :=  x^(-y);
1098                                      - y
1099 (%o2)                    f(x, y) := x
1100 (%i3) g[x, y] :=  x^(-y);
1101                                     - y
1102 (%o3)                     g     := x
1103                            x, y
1104 (%i4) h[x](y) :=  x^(-y);
1105                                     - y
1106 (%o4)                     h (y) := x
1107                            x
1108 (%i5) i[8](y) :=  8^(-y);
1109                                     - y
1110 (%o5)                     i (y) := 8
1111                            8
1112 (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
1113                                      - y
1114 (%t6)                   m(x, y) ::= x
1115 @group
1116                                      - y
1117 (%t7)                    f(x, y) := x
1118 @end group
1119
1120                                     - y
1121 (%t8)                     g     := x
1122                            x, y
1123
1124                                     - y
1125 (%t9)                     h (y) := x
1126                            x
1127
1128                                     1
1129 (%t10)                     h (y) := --
1130                             5        y
1131                                     5
1132
1133                                      1
1134 (%t11)                    h  (y) := ---
1135                            10         y
1136                                     10
1137
1138                                     - y
1139 (%t12)                    i (y) := 8
1140                            8
1141
1142 (%o12)       [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
1143 (%i12) ''%;
1144                      - y              - y            - y
1145 (%o12) [m(x, y) ::= x   , f(x, y) := x   , g     := x   ,
1146                                             x, y
1147                   - y           1              1             - y
1148         h (y) := x   , h (y) := --, h  (y) := ---, i (y) := 8   ]
1149          x              5        y   10         y   8
1150                                 5             10
1151 @end example
1152
1153 @opencatbox
1154 @category{Function definition} @category{Display functions}
1155 @closecatbox
1156 @end deffn
1157
1158 @c -----------------------------------------------------------------------------
1159 @anchor{fullmap}
1160 @deffn {関数} fullmap (@var{f}, @var{expr_1}, @dots{})
1161
1162 @code{map}と似ていますが、@code{fullmap}は、主演算子が同じでなくなるまで、
1163 部分式すべてに再帰的にマッピングを続けます。
1164
1165 @code{fullmap}は、ある行列操作のための整理に使われています;
1166 このように、Maximaは時々、たとえ@code{fullmap}がユーザーに陽にコールされなくても、
1167 @code{fullmap}に関係したエラーメッセージを生成します。
1168
1169 例:
1170
1171 @c ===beg===
1172 @c a + b * c;
1173 @c fullmap (g, %);
1174 @c map (g, %th(2));
1175 @c ===end===
1176 @example
1177 (%i1) a + b * c;
1178 (%o1)                        b c + a
1179 (%i2) fullmap (g, %);
1180 (%o2)                   g(b) g(c) + g(a)
1181 (%i3) map (g, %th(2));
1182 (%o3)                     g(b c) + g(a)
1183 @end example
1184
1185 @opencatbox
1186 @category{Function application} @category{Expressions}
1187 @closecatbox
1188 @end deffn
1189
1190 @c -----------------------------------------------------------------------------
1191 @anchor{fullmapl}
1192 @deffn {関数} fullmapl (@var{f}, @var{list_1}, @dots{})
1193
1194 @code{fullmap}に似ていますが、@code{fullmapl}はリストや行列にのみマップします。
1195
1196 例:
1197
1198 @c ===beg===
1199 @c fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1200 @c ===end===
1201 @example
1202 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1203 (%o1)                [[a + 3, 4], [4, 3.5]]
1204 @end example
1205
1206 @opencatbox
1207 @category{Function application} @category{Expressions}
1208 @closecatbox
1209 @end deffn
1210
1211 @c -----------------------------------------------------------------------------
1212 @anchor{functions}
1213 @defvr {システム変数} functions
1214 デフォルト値: @code{[]}
1215
1216 @code{functions}は、現在のセッションでの通常のMaxima関数のリストです。
1217 通常の関数は、@code{define}や@code{:=}で構成された関数であり、
1218 括弧@code{()}でコールされます。
1219 関数はMaximaプロンプトで定義することができ、また、
1220 @code{load}や@code{batch}がロードするMaximaファイルの中で定義することができます。
1221
1222 (例えば@code{F[x]}のように、カギ括弧でコールされる)配列関数と
1223 (例えば@code{F[x](y)}のように、カギ括弧と括弧でコールされる)添字付き関数は、
1224 @code{functions}ではなくグローバル変数@code{arrays}にリストされます。
1225
1226 Lisp関数はどのリストにも保持されません。
1227
1228 例:
1229
1230 @c ===beg===
1231 @c F_1 (x) := x - 100;
1232 @c F_2 (x, y) := x / y;
1233 @c define (F_3 (x), sqrt (x));
1234 @c G_1 [x] := x - 100;
1235 @c G_2 [x, y] := x / y;
1236 @c define (G_3 [x], sqrt (x));
1237 @c H_1 [x] (y) := x^y;
1238 @c functions;
1239 @c arrays;
1240 @c ===end===
1241 @example
1242 (%i1) F_1 (x) := x - 100;
1243 (%o1)                   F_1(x) := x - 100
1244 (%i2) F_2 (x, y) := x / y;
1245                                       x
1246 (%o2)                    F_2(x, y) := -
1247                                       y
1248 (%i3) define (F_3 (x), sqrt (x));
1249 (%o3)                   F_3(x) := sqrt(x)
1250 (%i4) G_1 [x] := x - 100;
1251 (%o4)                    G_1  := x - 100
1252                             x
1253 (%i5) G_2 [x, y] := x / y;
1254                                      x
1255 (%o5)                     G_2     := -
1256                              x, y    y
1257 (%i6) define (G_3 [x], sqrt (x));
1258 (%o6)                    G_3  := sqrt(x)
1259                             x
1260 (%i7) H_1 [x] (y) := x^y;
1261                                       y
1262 (%o7)                     H_1 (y) := x
1263                              x
1264 (%i8) functions;
1265 (%o8)              [F_1(x), F_2(x, y), F_3(x)]
1266 (%i9) arrays;
1267 (%o9)                 [G_1, G_2, G_3, H_1]
1268 @end example
1269
1270 @opencatbox
1271 @category{Function definition} @category{Global variables}
1272 @closecatbox
1273 @end defvr
1274
1275 @c -----------------------------------------------------------------------------
1276 @anchor{fundef}
1277 @deffn {関数} fundef (@var{f})
1278
1279 関数@var{f}の定義を返します。
1280
1281 @c PROBABLY THIS WOULD BE CLEARER AS A BULLET LIST
1282 引数は、(@code{::=}で定義された）マクロの名前か、
1283 (@code{:=}もしくは@code{define}で定義された）通常の関数か、
1284 (@code{:=}や@code{define}で定義され、引数がカギ括弧でくくられた）配列関数か、
1285 (@code{:=}や@code{define}で定義され、いくつかの引数がカギ括弧でくくられ、残りがかっこでくくられた）添字関数か、
1286 特別な添字の値によって選択された添字関数族の１つか、一定の添字で定義された添字関数です。
1287
1288 @code{fundef}は引数をクォートします;
1289 クォートクォート演算子@code{'@w{}'}はクォートに優先します。
1290
1291 @code{fundef (@var{f})}は@var{f}の定義を返します。
1292 対照的に、@code{dispfun (@var{f})}は中間式ラベルを生成し、ラベルに定義を割り当てます。
1293
1294 @c PROBABLY NEED SOME EXAMPLES HERE
1295 @opencatbox
1296 @category{Function definition}
1297 @closecatbox
1298 @end deffn
1299
1300 @c -----------------------------------------------------------------------------
1301 @anchor{funmake}
1302 @deffn {関数} funmake (@var{F}, [@var{arg_1}, @dots{}, @var{arg_n}])
1303
1304 式@code{@var{F}(@var{arg_1}, ..., @var{arg_n})}を返します。
1305 戻り値は整理されますが、評価されません。
1306 だから関数@var{F}はたとえ存在してもコールされません。
1307
1308 @code{funmake}は配列関数と通常の関数を区別しようとしません;
1309 @var{F}が配列関数名の時、
1310 @code{funmake}は@code{@var{F}(...)}を返します
1311 (すなわち、カギ括弧の代わりに括弧での関数コール)。
1312 @code{arraymake}は、この場合，カギ括弧での関数コールを返します。
1313
1314 @code{funmake}は引数を評価します。
1315
1316 例:
1317
1318 通常のMaxima関数に適用された@code{funmake}。
1319
1320 @c ===beg===
1321 @c F (x, y) := y^2 - x^2;
1322 @c funmake (F, [a + 1, b + 1]);
1323 @c ''%;
1324 @c ===end===
1325 @example
1326 (%i1) F (x, y) := y^2 - x^2;
1327                                    2    2
1328 (%o1)                  F(x, y) := y  - x
1329 (%i2) funmake (F, [a + 1, b + 1]);
1330 (%o2)                    F(a + 1, b + 1)
1331 (%i3) ''%;
1332                               2          2
1333 (%o3)                  (b + 1)  - (a + 1)
1334 @end example
1335
1336 マクロに適用された@code{funmake}。
1337
1338 @c ===beg===
1339 @c G (x) ::= (x - 1)/2;
1340 @c funmake (G, [u]);
1341 @c ''%;
1342 @c ===end===
1343 @example
1344 (%i1) G (x) ::= (x - 1)/2;
1345                                   x - 1
1346 (%o1)                    G(x) ::= -----
1347                                     2
1348 (%i2) funmake (G, [u]);
1349 (%o2)                         G(u)
1350 (%i3) ''%;
1351                               u - 1
1352 (%o3)                         -----
1353                                 2
1354 @end example
1355
1356 添字付き関数に適用された@code{funmake}。
1357
1358 @c ===beg===
1359 @c H [a] (x) := (x - 1)^a;
1360 @c funmake (H [n], [%e]);
1361 @c ''%;
1362 @c funmake ('(H [n]), [%e]);
1363 @c ''%;
1364 @c ===end===
1365 @example
1366 (%i1) H [a] (x) := (x - 1)^a;
1367                                         a
1368 (%o1)                   H (x) := (x - 1)
1369                          a
1370 (%i2) funmake (H [n], [%e]);
1371                                        n
1372 (%o2)               lambda([x], (x - 1) )(%e)
1373 (%i3) ''%;
1374                                     n
1375 (%o3)                       (%e - 1)
1376 (%i4) funmake ('(H [n]), [%e]);
1377 (%o4)                        H (%e)
1378                               n
1379 (%i5) ''%;
1380                                     n
1381 (%o5)                       (%e - 1)
1382 @end example
1383
1384 いかなる種類の関数にも定義されていないシンボルへ適用された
1385 @code{funmake}
1386
1387 @c ===beg===
1388 @c funmake (A, [u]);
1389 @c ''%;
1390 @c ===end===
1391 @example
1392 (%i1) funmake (A, [u]);
1393 (%o1)                         A(u)
1394 (%i2) ''%;
1395 (%o2)                         A(u)
1396 @end example
1397
1398 @code{funmake}は引数を評価しますが、戻り値を評価しません。
1399
1400 @c ===beg===
1401 @c det(a,b,c) := b^2 -4*a*c;
1402 @c (x : 8, y : 10, z : 12);
1403 @c f : det;
1404 @c funmake (f, [x, y, z]);
1405 @c ''%;
1406 @c ===end===
1407 @example
1408 (%i1) det(a,b,c) := b^2 -4*a*c;
1409                                     2
1410 (%o1)              det(a, b, c) := b  - 4 a c
1411 (%i2) (x : 8, y : 10, z : 12);
1412 (%o2)                          12
1413 (%i3) f : det;
1414 (%o3)                          det
1415 (%i4) funmake (f, [x, y, z]);
1416 (%o4)                    det(8, 10, 12)
1417 (%i5) ''%;
1418 (%o5)                         - 284
1419 @end example
1420
1421 Maximaは@code{funmake}の戻り値を整理します。
1422
1423 @c ===beg===
1424 @c funmake (sin, [%pi / 2]);
1425 @c ===end===
1426 @example
1427 (%i1) funmake (sin, [%pi / 2]);
1428 (%o1)                           1
1429 @end example
1430
1431 @opencatbox
1432 @category{Function application} @category{Expressions}
1433 @closecatbox
1434 @end deffn
1435
1436 @c -----------------------------------------------------------------------------
1437 @anchor{lambda}
1438 @deffn  {関数} lambda ([@var{x_1}, ..., @var{x_m}], @var{expr_1}, ..., @var{expr_n})
1439 @deffnx {関数} lambda ([[@var{L}]], @var{expr_1}, ..., @var{expr_n})
1440 @deffnx {関数} lambda ([@var{x_1}, ..., @var{x_m}, [@var{L}]], @var{expr_1}, ..., @var{expr_n})
1441 ラムダ式 (すなわち、匿名関数)を定義し返します。
1442 関数は要求された引数@var{x_1}, ..., @var{x_m}を持ち、
1443 また、オプション引数@var{L}を持つかもしれません。オプション引数は関数本体の中にリストとして現れます。
1444 関数の戻り値は@var{expr_n}です。
1445 ラムダ式は変数に割り当てることができ、通常の関数のように評価できます。
1446 ラムダ式は関数名が期待されるいくつかのコンテキストで現れるかもしれません。
1447
1448 関数が評価される時、
1449 バインドされていないローカル変数@var{x_1}, ..., @var{x_m}が生成されます。
1450 @code{lambda}は
1451 @code{block}の中や別の@code{lambda}の中で現れるかもしれません;
1452 ローカル変数は、別の@code{block}や@code{lambda}が評価される度に毎回確立されます。
1453 ローカル変数は内包する@code{block}や@code{lambda}にはグローバルのように見えます。
1454 もし変数がローカルでないなら、
1455 その値は、(もし割り当てられたなら)内包する@code{block}や@code{lambda}で直近に割り当てられた値です。
1456 そうでなければ、グローバル環境での変数の値です。
1457 このポリシーは「動的スコープ」の普通の理解と一致するかもしれません。
1458
1459 ローカル変数が確立された後、
1460 @var{expr_1}から@var{expr_n}までが順に評価されます。
1461 特殊変数@code{%%}―直前の式の値を表します―が認識されます。
1462 @code{throw}と@code{catch}も式のリストの中に現れるかもしれません。
1463
1464 @code{block}で囲まれない限り
1465 @code{return}はラムダ式の中には現れません。
1466 @code{block}で囲まれた場合、
1467 ブロックがたまたま @var{expr_n}に至るということでない限り、
1468 @code{return}はラムダ式の戻り値ではなくブロックの戻り値を定義します。
1469 同様に、@code{go}は、@code{block}で囲まれない限りラムダ式の中に現れません。
1470
1471 @code{lambda}は引数をクォートします;
1472 クォートクォート演算子@code{'@w{}'}はクォートに優先します。
1473
1474 例:
1475
1476 @itemize @bullet
1477 @item
1478 ラムダ式は変数に割り当てることができ、通常の関数のように評価できます。
1479 @end itemize
1480
1481 @c ===beg===
1482 @c f: lambda ([x], x^2);
1483 @c f(a);
1484 @c ===end===
1485 @example
1486 (%i1) f: lambda ([x], x^2);
1487                                       2
1488 (%o1)                    lambda([x], x )
1489 (%i2) f(a);
1490                                 2
1491 (%o2)                          a
1492 @end example
1493 @itemize @bullet
1494 @item
1495 ラムダ式は
1496 関数評価が期待される文脈で現れるかもしれません。
1497 @end itemize
1498
1499 @c ===beg===
1500 @c lambda ([x], x^2) (a);
1501 @c apply (lambda ([x], x^2), [a]);
1502 @c map (lambda ([x], x^2), [a, b, c, d, e]);
1503 @c ===end===
1504 @example
1505 (%i3) lambda ([x], x^2) (a);
1506                                 2
1507 (%o3)                          a
1508 (%i4) apply (lambda ([x], x^2), [a]);
1509                                 2
1510 (%o4)                          a
1511 (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
1512                         2   2   2   2   2
1513 (%o5)                 [a , b , c , d , e ]
1514 @end example
1515 @itemize @bullet
1516 @item
1517 引数変数はローカル変数です。
1518 他の変数はグローバル変数のように見えます。
1519 ある特殊な評価が@code{'@w{}'}のようにある方法で強制されない限り、
1520 グローバル変数はラムダ式が評価される時評価されます。
1521 @end itemize
1522
1523 @c ===beg===
1524 @c a: %pi$
1525 @c b: %e$
1526 @c g: lambda ([a], a*b);
1527 @c b: %gamma$
1528 @c g(1/2);
1529 @c g2: lambda ([a], a*''b);
1530 @c b: %e$
1531 @c g2(1/2);
1532 @c ===end===
1533 @example
1534 (%i6) a: %pi$
1535 (%i7) b: %e$
1536 (%i8) g: lambda ([a], a*b);
1537 (%o8)                   lambda([a], a b)
1538 (%i9) b: %gamma$
1539 (%i10) g(1/2);
1540                              %gamma
1541 (%o10)                       ------
1542                                2
1543 (%i11) g2: lambda ([a], a*''b);
1544 (%o11)                lambda([a], a %gamma)
1545 (%i12) b: %e$
1546 (%i13) g2(1/2);
1547                              %gamma
1548 (%o13)                       ------
1549                                2
1550 @end example
1551 @itemize @bullet
1552 @item
1553 ラムダ式は入れ子にできます。
1554 外側のラムダ式の中のローカル変数は、
1555 同じ名前のローカル変数がマスクしない限り、
1556 内側の式にはグローバルに見えます。
1557 @end itemize
1558
1559 @c ===beg===
1560 @c h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1561 @c h(%pi, %gamma);
1562 @c ===end===
1563 @example
1564 (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1565                                                    1
1566 (%o14)    lambda([a, b], h2 : lambda([a], a b), h2(-))
1567                                                    2
1568 (%i15) h(%pi, %gamma);
1569                              %gamma
1570 (%o15)                       ------
1571                                2
1572 @end example
1573 @itemize @bullet
1574 @item
1575 @code{lambda}は引数をクォートするので、
1576 以下のラムダ式@code{i}は
1577 "@code{a}を掛ける"関数を定義しません。
1578 以下のラムダ式@code{i2}のように、
1579 そんな関数は@code{buildq}を介して定義することができます。
1580 @end itemize
1581
1582 @c ===beg===
1583 @c i: lambda ([a], lambda ([x], a*x));
1584 @c i(1/2);
1585 @c i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1586 @c i2(1/2);
1587 @c i2(1/2)(%pi);
1588 @c ===end===
1589 @example
1590 (%i16) i: lambda ([a], lambda ([x], a*x));
1591 (%o16)            lambda([a], lambda([x], a x))
1592 (%i17) i(1/2);
1593 (%o17)                  lambda([x], a x)
1594 (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1595 (%o18)    lambda([a], buildq([a : a], lambda([x], a x)))
1596 (%i19) i2(1/2);
1597                                      x
1598 (%o19)                   lambda([x], -)
1599                                      2
1600 (%i20) i2(1/2)(%pi);
1601                                %pi
1602 (%o20)                         ---
1603                                 2
1604 @end example
1605 @itemize @bullet
1606 @item
1607 ラムダ式は、可変の数の引数を取ることができます。
1608 それは、唯一のまたは最後の引数として@code{[@var{L}]}で指定されます。
1609 引数は関数本体の中にリストとして現れます。
1610 @end itemize
1611
1612 @c ===beg===
1613 @c f : lambda ([aa, bb, [cc]], aa * cc + bb);
1614 @c f (foo, %i, 17, 29, 256);
1615 @c g : lambda ([[aa]], apply ("+", aa));
1616 @c g (17, 29, x, y, z, %e);
1617 @c ===end===
1618 @example
1619 (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
1620 (%o1)          lambda([aa, bb, [cc]], aa cc + bb)
1621 (%i2) f (foo, %i, 17, 29, 256);
1622 (%o2)       [17 foo + %i, 29 foo + %i, 256 foo + %i]
1623 (%i3) g : lambda ([[aa]], apply ("+", aa));
1624 (%o3)             lambda([[aa]], apply(+, aa))
1625 (%i4) g (17, 29, x, y, z, %e);
1626 (%o4)                  z + y + x + %e + 46
1627 @end example
1628
1629 @opencatbox
1630 @category{Function definition}
1631 @closecatbox
1632 @end deffn
1633
1634 @c NEEDS CLARIFICATION AND EXAMPLES
1635
1636 @c -----------------------------------------------------------------------------
1637 @anchor{local}
1638 @deffn {関数} local (@var{v_1}, @dots{}, @var{v_n})
1639
1640 シンボル@var{v_1}, ..., @var{v_n}に関連付けられた性質を保存し、
1641 他の式を評価する前にすべての性質を取り除き、
1642 @code{local}が現れたブロックや他の合成式の終了時に保存した性質を元に戻します。
1643
1644 いくつかの宣言は、@code{:=}、@code{array}, @code{dependencies}, @code{atvalue}, @code{matchdeclare},
1645  @code{atomgrad}, @code{constant}, @code{nonscalar}その他を含むシンボルの性質として実装されます。
1646 @code{local}の効果は、ブロック内部のみで有効な宣言を作ります;
1647 そうでなければ、ブロック内部の宣言は実際にグローバル宣言となります。
1648
1649 @code{local}は、@code{block}や関数定義の本体や@code{lambda}式の中に現れます。
1650 それぞれの中で１カ所だけ許されます。
1651
1652 @code{local}は引数をクォートします。
1653 @code{local}は@code{done}を返します。
1654
1655 例:
1656
1657 ローカル関数定義。
1658
1659 @c ===beg===
1660 @c foo (x) := 1 - x;
1661 @c foo (100);
1662 @c block (local (foo), foo (x) := 2 * x, foo (100));
1663 @c foo (100);
1664 @c ===end===
1665 @example
1666 (%i1) foo (x) := 1 - x;
1667 (%o1)                    foo(x) := 1 - x
1668 (%i2) foo (100);
1669 (%o2)                         - 99
1670 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1671 (%o3)                          200
1672 (%i4) foo (100);
1673 (%o4)                         - 99
1674 @end example
1675
1676 @opencatbox
1677 @category{Function definition} @category{Programming}
1678 @closecatbox
1679 @end deffn
1680
1681 @c -----------------------------------------------------------------------------
1682 @anchor{macroexpansion}
1683 @defvr {オプション変数} macroexpansion
1684 デフォルト値: @code{false}
1685
1686 @code{macroexpansion}は
1687 マクロ関数コールを
1688 マクロ関数の展開(すなわち戻り値)で
1689 置き換えるかどうかを制御します。
1690 展開を記憶する代価で、置き換えは次の式評価をスピードアップするかもしれません。
1691
1692 @table @code
1693 @item false
1694 マクロ関数コールをマクロ関数の展開で置き換えられません。
1695
1696 @item expand
1697 マクロ関数コールが初めて評価された時、展開が記憶されます。
1698 展開は次のコール時に再計算されません;
1699 (@code{print}やグローバル変数への割り当てのような)いかなる副作用も
1700 最初にマクロ関数コールが評価された時だけ起こります。
1701 式の中の展開は、同じマクロ関数コールを持つ他の式に影響を与えません。
1702 @item displace
1703 マクロ関数コールが初めて評価された時、展開でコールを置き換え、
1704 マクロ関数がコールされた式を変更します。
1705 展開は次のコールで再計算されません;
1706 (@code{print}やグローバル変数への割り当てのような)いかなる副作用も
1707 最初にマクロ関数コールが評価された時だけ起こります。
1708 式の中の展開は、同じマクロ関数コールを持つ他の式に影響を与えません。
1709 @end table
1710
1711 例
1712
1713 @code{macroexpansion}が@code{false}の時、
1714 コールする式が評価される時毎回マクロ関数がコールされ、
1715 コールする式は変更されません。
1716
1717 @c ===beg===
1718 @c f (x) := h (x) / g (x);
1719 @c g (x) ::= block (print ("x + 99 is equal to", x),
1720 @c                        return (x + 99));
1721 @c h (x) ::= block (print ("x - 99 is equal to", x),
1722 @c                        return (x - 99));
1723 @c macroexpansion: false;
1724 @c f (a * b);
1725 @c dispfun (f);
1726 @c f (a * b);
1727 @c ===end===
1728 @example
1729 (%i1) f (x) := h (x) / g (x);
1730                                   h(x)
1731 (%o1)                     f(x) := ----
1732                                   g(x)
1733 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
1734                        return (x + 99));
1735 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1736                                                   return(x + 99))
1737 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
1738                        return (x - 99));
1739 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1740                                                   return(x - 99))
1741 (%i4) macroexpansion: false;
1742 (%o4)                         false
1743 (%i5) f (a * b);
1744 x - 99 is equal to x
1745 x + 99 is equal to x
1746                             a b - 99
1747 (%o5)                       --------
1748                             a b + 99
1749 (%i6) dispfun (f);
1750                                   h(x)
1751 (%t6)                     f(x) := ----
1752                                   g(x)
1753
1754 (%o6)                         done
1755 (%i7) f (a * b);
1756 x - 99 is equal to x
1757 x + 99 is equal to x
1758                             a b - 99
1759 (%o7)                       --------
1760                             a b + 99
1761 @end example
1762
1763 @code{macroexpansion}が@code{expand}の時、
1764 マクロ関数は一度コールされ、
1765 コールする式は変更されません。
1766
1767 @c ===beg===
1768 @c f (x) := h (x) / g (x);
1769 @c g (x) ::= block (print ("x + 99 is equal to", x),
1770 @c                        return (x + 99));
1771 @c h (x) ::= block (print ("x - 99 is equal to", x),
1772 @c                        return (x - 99));
1773 @c macroexpansion: expand;
1774 @c f (a * b);
1775 @c dispfun (f);
1776 @c f (a * b);
1777 @c ===end===
1778 @example
1779 (%i1) f (x) := h (x) / g (x);
1780                                   h(x)
1781 (%o1)                     f(x) := ----
1782                                   g(x)
1783 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
1784                        return (x + 99));
1785 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1786                                                   return(x + 99))
1787 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
1788                        return (x - 99));
1789 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1790                                                   return(x - 99))
1791 (%i4) macroexpansion: expand;
1792 (%o4)                        expand
1793 (%i5) f (a * b);
1794 x - 99 is equal to x
1795 x + 99 is equal to x
1796                             a b - 99
1797 (%o5)                       --------
1798                             a b + 99
1799 (%i6) dispfun (f);
1800                                   h(x)
1801 (%t6)                     f(x) := ----
1802                                   g(x)
1803
1804 (%o6)                         done
1805 (%i7) f (a * b);
1806                             a b - 99
1807 (%o7)                       --------
1808                             a b + 99
1809 @end example
1810
1811 @code{macroexpansion}が@code{expand}の時、
1812 マクロ関数は一度コールされ、
1813 コールする式が変更されます。
1814
1815 @c ===beg===
1816 @c f (x) := h (x) / g (x);
1817 @c g (x) ::= block (print ("x + 99 is equal to", x),
1818 @c                        return (x + 99));
1819 @c h (x) ::= block (print ("x - 99 is equal to", x),
1820 @c                        return (x - 99));
1821 @c macroexpansion: displace;
1822 @c f (a * b);
1823 @c dispfun (f);
1824 @c f (a * b);
1825 @c ===end===
1826 @example
1827 (%i1) f (x) := h (x) / g (x);
1828                                   h(x)
1829 (%o1)                     f(x) := ----
1830                                   g(x)
1831 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
1832                        return (x + 99));
1833 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1834                                                   return(x + 99))
1835 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
1836                        return (x - 99));
1837 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1838                                                   return(x - 99))
1839 (%i4) macroexpansion: displace;
1840 (%o4)                       displace
1841 (%i5) f (a * b);
1842 x - 99 is equal to x
1843 x + 99 is equal to x
1844                             a b - 99
1845 (%o5)                       --------
1846                             a b + 99
1847 (%i6) dispfun (f);
1848                                  x - 99
1849 (%t6)                    f(x) := ------
1850                                  x + 99
1851
1852 (%o6)                         done
1853 (%i7) f (a * b);
1854                             a b - 99
1855 (%o7)                       --------
1856                             a b + 99
1857 @end example
1858
1859 @opencatbox
1860 @category{Function application} @category{Global flags}
1861 @closecatbox
1862
1863 @end defvr
1864
1865 @c -----------------------------------------------------------------------------
1866 @anchor{mode_checkp}
1867 @defvr {オプション変数} mode_checkp
1868 デフォルト値: @code{true}
1869
1870 @c WHAT DOES THIS MEAN ??
1871 @code{mode_checkp}が@code{true}の時、
1872 @code{mode_declare}はバインドされた変数のモードをチェックします。
1873 @c NEED SOME EXAMPLES HERE.
1874
1875 @opencatbox
1876 @category{Translation flags and variables}
1877 @closecatbox
1878 @end defvr
1879
1880 @c -----------------------------------------------------------------------------
1881 @anchor{mode_check_errorp}
1882 @defvr {オプション変数} mode_check_errorp
1883 デフォルト値: @code{false}
1884
1885 @c WHAT DOES THIS MEAN ??
1886 @code{mode_check_errorp}が@code{true}の時、
1887 @code{mode_declare}はエラーをコールします。
1888 @c NEED SOME EXAMPLES HERE.
1889
1890 @opencatbox
1891 @category{Translation flags and variables}
1892 @closecatbox
1893
1894 @end defvr
1895
1896 @c -----------------------------------------------------------------------------
1897 @anchor{mode_check_warnp}
1898 @defvr {オプション変数} mode_check_warnp
1899 デフォルト値: @code{true}
1900
1901 @c WHAT DOES THIS MEAN ??
1902 @code{mode_check_warnp}が@code{true}の時、
1903 モードエラーが記述されます。
1904 @c NEED SOME EXAMPLES HERE.
1905
1906 @opencatbox
1907 @category{Translation flags and variables}
1908 @closecatbox
1909 @end defvr
1910
1911 @c NEEDS CLARIFICATION AND EXAMPLES
1912
1913 @c -----------------------------------------------------------------------------
1914 @anchor{mode_declare}
1915 @deffn {関数} mode_declare (@var{y_1}, @var{mode_1}, @dots{}, @var{y_n}, @var{mode_n})
1916
1917 @code{mode_declare}は、
1918 その後の関数の翻訳やコンパイルのために
1919 変数と関数のモードを宣言するのに使われます。
1920 @code{mode_declare}は、通常、
1921 関数定義の始めやMaximaスクリプトの始めに置かれたり、対話プロンプトで実行されたりします。
1922
1923 @code{mode_declare}の引数は、
1924 変数とモードから成る対です。
1925 モードは
1926 @code{boolean}, @code{fixnum}, @code{number}, @code{rational}, @code{float}のいずれか１つです。
1927 変数それぞれは、
1928 同じモードを持つように宣言される変数すべてのリストも取り得ます。
1929
1930 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1931 もし変数が配列で、かつ、参照される配列のすべての要素が値を持つなら、
1932 なら、
1933 @example
1934 array(yi, dim1, dim2, ...)
1935 @end example
1936 よりむしろ@code{array (yi, complete, dim1, dim2, @dots{})}を
1937 最初に配列のバインドを宣言する時に使うべきです。
1938 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1939 もし配列の要素すべてが
1940 モード@code{fixnum} (@code{float})なら、
1941 @code{complete}の代わりに@code{fixnum} (@code{float})を使ってください。
1942 @c WHAT DOES THE FOLLOWING STATEMENT MEAN ???
1943 もし配列のすべての要素が同じモード―@code{m}としましょう―なら、
1944 効率的な翻訳のためには、
1945
1946 @example
1947 mode_declare (completearray (yi), m))
1948 @end example
1949
1950 を使うべきです。
1951
1952 配列を使う数値コードは、例えば、10 x 10の浮動小数点配列のために
1953
1954 @example
1955 mode_declare (completearray (a [10, 10]), float)
1956 @end example
1957
1958 というように、期待される配列サイズを宣言することでより速く実行されるかもしれません
1959
1960 引数として@code{function (f_1, f_2, ...)}を使うことで
1961 関数の結果のモードを宣言することができます;
1962 ここで@code{f_1}, @code{f_2}, @dots{}は関数名です。
1963 例えば、式
1964
1965 @example
1966 mode_declare ([function (f_1, f_2, ...)], fixnum)
1967 @end example
1968
1969 は、
1970 @code{f_1}, @code{f_2}, ...が返す値が1ワード整数であることを宣言します。
1971
1972 @code{modedeclare}は@code{mode_declare}と同義です。
1973
1974 @opencatbox
1975 @category{Translation and compilation}
1976 @closecatbox
1977 @end deffn
1978
1979 @c WHAT IS THIS ABOUT ??
1980 @c NEEDS CLARIFICATION AND EXAMPLES
1981
1982 @c -----------------------------------------------------------------------------
1983 @anchor{mode_identity}
1984 @deffn {関数} mode_identity (@var{arg_1}, @var{arg_2})
1985
1986 @code{mode_declare}と@code{macros}で
1987 例えば、flonumsのリストのリストや他の合成データオブジェクトを宣言するのに
1988 使われる特殊形式。
1989 @code{mode_identity}の最初の引数は、@code{mode_declare}に与えられるような
1990 プリミティブな値モード名(すなわち、@code{float}, @code{fixnum}, @code{number},
1991 @code{list}, @code{any}のいずれか)であり、
1992 二番目の引数は、評価され、@code{mode_identity}の値として返される式です。
1993 しかしながら、もし戻り値が最初の引数で宣言されたモードによって許されていないなら、
1994 エラーか警告がシグナルされます。
1995 重要なことは、MaximaによってLisp翻訳器に命じた式のモードが、二番目の引数のなかで続く一切から独立して、最初の引数として与えられるそれだということです。
1996 例えば、@code{x: 3.3; mode_identity (fixnum, x);}はエラーをもたらします。
1997 @code{mode_identity (flonum, x)}は3.3を返します。
1998 これは多くの使い道があります。例えば、もし@code{first (l)}が数を返すと知っていたなら、
1999 @code{mode_identity (number, first (l))}と書くかもしれません。
2000 しかしながら、それをするもっと効率的な方法は、
2001
2002 @example
2003 firstnumb (x) ::= buildq ([x], mode_identity (number, first(x)));
2004 @end example
2005
2006 のように新しいプリミティブを定義し、
2007 そして数のリストの最初の要素を取る時毎回@code{firstnumb}を使うことです。
2008
2009 @opencatbox
2010 @category{Translation and compilation}
2011 @closecatbox
2012 @end deffn
2013
2014 @c -----------------------------------------------------------------------------
2015 @anchor{remfunction}
2016 @deffn  {関数} remfunction (@var{f_1}, ..., @var{f_n})
2017 @deffnx {関数} remfunction (all)
2018
2019 シンボル@var{f_1}, ..., @var{f_n}の関数定義をアンバインドします。
2020 引数は、（@code{:=}もしくは@code{define}で生成された）通常の関数名もしくは（@code{::=}で生成された）マクロ関数をとります。
2021
2022 @code{remfunction (all)}は関数定義すべてをアンバインドします。
2023
2024 @code{remfunction}は引数をクォートします。
2025
2026 @code{remfunction}は、関数定義はアンバインドされたシンボルのリストを返します。
2027 シンボルに関数定義がなければ、シンボルの代わりに@code{false}を返します。
2028
2029 @code{remfunction}は配列関数すなわち添字付き関数には適用されません。
2030 これらのタイプの関数には@code{remarray}を適用します。
2031
2032 @opencatbox
2033 @category{Function definition}
2034 @closecatbox
2035 @end deffn
2036
2037 @c NEEDS MORE WORK !!!
2038 @defvr {オプション変数} savedef
2039 デフォルト値: @code{true}
2040
2041 @code{savedef}が@code{true}の時、
2042 関数が解釈される時に
2043 ユーザー関数のMaximaバージョンが保持されます。
2044 これは、定義が@code{dispfun}によって表示されることを許し、
2045 関数が編集されることを許します。
2046
2047 @code{savedef}が@code{false}の時、
2048 解釈された関数の名前は、@code{functions}リストから取り除かれます。
2049
2050 @opencatbox
2051 @category{Translation flags and variables}
2052 @closecatbox
2053
2054 @end defvr
2055
2056 @c IS THERE ANY REASON TO SET transcompile: false ??
2057 @c MAYBE THIS VARIABLE COULD BE PERMANENTLY SET TO true AND STRUCK FROM THE DOCUMENTATION.
2058
2059 @c -----------------------------------------------------------------------------
2060 @anchor{transcompile}
2061 @defvr {オプション変数} transcompile
2062 デフォルト値: @code{true}
2063
2064 @code{transcompile}が@code{true}の時、
2065 @code{translate}と@code{translate_file}は
2066 翻訳コードをコンパイルにより適したものにする宣言を生成します。
2067 @c BUT THE DECLARATIONS DON'T SEEM TO BE NECESSARY, SO WHAT'S THE POINT AGAIN ??
2068
2069 @code{compfile}は実行中@code{transcompile: true}を設定します。
2070
2071 @opencatbox
2072 @category{Translation flags and variables}
2073 @closecatbox
2074 @end defvr
2075
2076 @c -----------------------------------------------------------------------------
2077 @anchor{translate}
2078 @deffn {関数} translate (@var{f_1}, @dots{}, @var{f_n})
2079 @deffnx {関数} translate (functions)
2080 @deffnx {関数} translate (all)
2081
2082 ユーザー定義関数@var{f_1}, @dots{}, @var{f_n}をMaxima言語からLispに翻訳し、
2083 Lisp翻訳を評価します。
2084 通常、翻訳された関数は元の関数より速く実行されます。
2085
2086 @code{translate (all)}や@code{translate (functions)}は、
2087 ユーザー定義関数すべてを翻訳します。
2088
2089 翻訳される関数は、
2090 より効率的なコードを生成するために可能な時は
2091 先頭に@code{mode_declare}コールを含むべきです。
2092 例えば:
2093
2094 @example
2095 f (x_1, x_2, ...) := block ([v_1, v_2, ...],
2096     mode_declare (v_1, mode_1, v_2, mode_2, ...), ...)
2097 @end example
2098
2099 @noindent
2100
2101 ここで、@var{x_1}, @var{x_2}, ... は関数のパラメータであり、
2102 @var{v_1}, @var{v_2}, ...はローカル変数です。
2103
2104 もし@code{savedef}が@code{false}なら(以下を参照してください)
2105 翻訳された関数の名前は、@code{functions}リストから削除され、
2106 @code{props}リストに加えられます。
2107
2108 完全にデバッグされない限り、関数は翻訳すべきではありません。
2109
2110 式は整理されていると仮定されます;
2111 もしされていないなら、厳密ですが、最適でないコードが生成されます。
2112 従って、
2113 ユーザーは
2114 @code{simp}スイッチを@code{false}―翻訳される式の整理を抑制します―
2115 に設定すべきではありません。
2116
2117 スイッチ@code{translate}は、もし@code{true}なら、
2118 ユーザー関数のLispへの自動翻訳をもたらします。
2119
2120 LispとMaximaのバージョンの間である非互換性が存在する可能性があるので、
2121 翻訳された関数は
2122 翻訳前にした方法を同一に動作するわけではないことに注意してください。
2123 原則として、
2124 もし変数のいずれかが@code{mode_declare}された標準有理式(CRE)なら
2125 複数の引数を取る@code{rat}関数と@code{ratvars}関数は使うべきではありません。
2126 また、
2127 @code{prederror: false}設定は翻訳されません。
2128 @c WHAT ABOUT % AND %% ???
2129
2130 @code{savedef} - もし@code{true}なら、
2131 関数が@code{translate}された時、Maximaバージョンのユーザー関数を残すようにします。
2132 これは、定義を@code{dispfun}で表示することを可能にし、
2133 関数を編集することを可能にします。
2134
2135 @code{transrun} - もし@code{false}なら、
2136 すべての関数について、翻訳バージョンではなく、
2137 インタープリトされるバージョン(まだあると仮定して)が実行されるようにします。
2138
2139 @code{translate}が返す結果は、翻訳された関数名のリストです。
2140
2141 @opencatbox
2142 @category{Translation and compilation}
2143 @closecatbox
2144 @end deffn
2145
2146 @c -----------------------------------------------------------------------------
2147 @anchor{translate_file}
2148 @deffn  {関数} translate_file (@var{maxima_filename})
2149 @deffnx {関数} translate_file (@var{maxima_filename}, @var{lisp_filename})
2150
2151 MaximaコードのファイルをLispコードのファイルに翻訳します。
2152 @code{translate_file}は３つのファイル名のリストを返します:
2153 Maximaファイル名、Lispファイル名、翻訳についての追加情報を含むファイル名。
2154 @code{translate_file}は引数を評価します。
2155
2156 @code{translate_file ("foo.mac"); load("foo.LISP")}は、
2157 例えば、@code{'@w{}'}と@code{%}の利用といった若干の制約を除いて、
2158 コマンド@code{batch ("foo.mac")}と同じです。
2159 @c FIGURE OUT WHAT THE RESTRICTIONS ARE AND STATE THEM
2160
2161 @code{translate_file (@var{maxima_filename})}は
2162 Maximaファイル@var{maxima_filename}を
2163 同様に名付けらたLispファイルに翻訳します。
2164 例えば、@code{foo.mac}は@code{foo.LISP}に翻訳されます。
2165 Maximaのファイル名はディレクトリ名を含むかもしれません。
2166 その場合、Lisp出力ファイルは、Maxima入力が来たのと同じディレクトリに書かれます。
2167
2168 @code{translate_file (@var{maxima_filename}, @var{lisp_filename})}は、
2169 Maximaファイル@var{maxima_filename}をLispファイル@var{lisp_filename}に翻訳します。
2170 @code{translate_file}は、どんなものでも、@code{lisp_filename}の
2171 ファイル名の拡張子を無視します;
2172 Lisp出力ファイルのファイル名の拡張子は、いつも@code{LISP}です。
2173 Lispファイル名はディレクトリ名を含むかもしれません。
2174 その場合、Lisp出力ファイルは指定されたディレクトリに書かれます。
2175
2176 @code{translate_file}は、翻訳器のファイル
2177 様々な度合いの厳しさの翻訳器警告メッセージのファイルも書き出します。
2178 このファイルのファイル名拡張子は @code{UNLISP}です。
2179 このファイルは、翻訳されたコードの中のバグを追跡するために、
2180 あいまいかもしれませんが、価値ある情報を含むかもしれません。
2181 @code{UNLISP}ファイルはいつもMaxima入力が来るのと同じディレクトリに書かれます。
2182
2183 @code{translate_file}は
2184 Lispコードがコンパイルされるすぐに宣言や定義が効力を発揮するようにするLispコードを発行します。
2185 このトピックに関してさらに知るには@code{compile_file}を参照してください。
2186
2187 @c CHECK ALL THESE AND SEE WHICH ONES ARE OBSOLETE
2188 @flushleft
2189 @code{tr_array_as_ref},
2190 @c tr_bind_mode_hook EXISTS BUT IT APPEARS TO BE A GROTESQUE UNDOCUMENTED HACK
2191 @c WE DON'T WANT TO MENTION IT
2192 @c @code{tr_bind_mode_hook},
2193 @code{tr_bound_function_applyp},
2194 @c tr_exponent EXISTS AND WORKS AS ADVERTISED IN src/troper.lisp
2195 @c NOT OTHERWISE DOCUMENTED; ITS EFFECT SEEMS TOO WEAK TO MENTION
2196 @code{tr_exponent},
2197 @code{tr_file_tty_messagesp},
2198 @code{tr_float_can_branch_complex},
2199 @code{tr_function_call_default},
2200 @code{tr_numer},
2201 @code{tr_optimize_max_loop},
2202 @code{tr_semicompile},
2203 @code{tr_state_vars},
2204 @code{tr_warnings_get},
2205 @code{tr_warn_bad_function_calls},
2206 @code{tr_warn_fexpr},
2207 @code{tr_warn_meval},
2208 @code{tr_warn_mode},
2209 @code{tr_warn_undeclared},
2210 @code{tr_warn_undefined_variable}
2211 @end flushleft
2212 も参照してください。
2213
2214 @opencatbox
2215 @category{Translation and compilation}
2216 @closecatbox
2217 @end deffn
2218
2219 @c -----------------------------------------------------------------------------
2220 @anchor{transrun}
2221 @defvr {オプション変数} transrun
2222 デフォルト値: @code{true}
2223
2224 @code{transrun}が@code{false}の時、
2225 すべての関数について、翻訳バージョンではなく、
2226 インタープリトされるバージョン(まだあると仮定して)が実行されるようにします。
2227
2228 @opencatbox
2229 @category{Translation flags and variables}
2230 @closecatbox
2231 @end defvr
2232
2233 @c IN WHAT CONTEXT IS tr_array_as_ref: false APPROPRIATE ??? NOT SEEING THE USEFULNESS HERE.
2234 @c ALSO, I GUESS WE SHOULD HAVE AN ITEM FOR translate_fast_arrays, ANOTHER CONFUSING FLAG ...
2235
2236 @c -----------------------------------------------------------------------------
2237 @anchor{tr_array_as_ref}
2238 @defvr {オプション変数} tr_array_as_ref
2239 デフォルト値: @code{true}
2240
2241 もし@code{translate_fast_arrays}が@code{false}なら、
2242 @code{translate_file}が発行するLispコードの中の配列参照は、
2243 @code{tr_array_as_ref}によって影響されます。
2244 @code{tr_array_as_ref}が@code{true}の時、
2245 配列名は評価されます。
2246 そうでなければ、配列名は翻訳されたコードの中で文字リテラルとして現れます。
2247
2248 もし@code{translate_fast_arrays}が@code{true}なら、
2249 @code{tr_array_as_ref}は効果を持ちません。
2250
2251 @opencatbox
2252 @category{Translation flags and variables}
2253 @closecatbox
2254 @end defvr
2255
2256 @c WHY IS THIS FLAG NEEDED ??? UNDER WHAT CIRCUMSTANCES CAN TRANSLATION
2257 @c OF A BOUND VARIABLE USED AS A FUNCTION GO WRONG ???
2258
2259 @c -----------------------------------------------------------------------------
2260 @anchor{tr_bound_function_applyp}
2261 @defvr {オプション変数} tr_bound_function_applyp
2262 デフォルト値: @code{true}
2263
2264 @code{tr_bound_function_applyp}が@code{true}の時、
2265 もし(関数引数のような)バインドされた変数が関数として使われていることが見つかったら
2266 Maximaは警告を与えます。
2267 @c WHAT DOES THIS MEAN ??
2268 @code{tr_bound_function_applyp}は、
2269 そんな場合に生成されたコードに影響しません。
2270
2271 例えば、
2272 @code{g (f, x) := f (x+1)}のような式は警告メッセージをトリガーします。
2273
2274 @opencatbox
2275 @category{Translation flags and variables}
2276 @closecatbox
2277 @end defvr
2278
2279 @c -----------------------------------------------------------------------------
2280 @anchor{tr_file_tty_message}
2281 @defvr {オプション変数} tr_file_tty_messagesp
2282 デフォルト値: @code{false}
2283
2284 @code{tr_file_tty_messagesp}が@code{true}の時、
2285 ファイルの翻訳中に
2286 @code{translate_file}が生成するメッセージがコンソールに表示され、
2287 @code{false}の時、ファイルの翻訳に関するメッセージは
2288 UNLISPファイルに挿入されるだけです。
2289
2290 @opencatbox
2291 @category{Translation flags and variables}
2292 @closecatbox
2293 @end defvr
2294
2295 @c THIS FLAG APPEARS TO HAVE NO EFFECT. SHOULD CUT OUT THIS ITEM AND RELATED CODE.
2296 @c NOTE THAT THERE IS CODE IN src/transf.lisp WHICH USES THIS FLAG BUT THE MODE
2297 @c FLAG IS LOST SOMEWHERE ALONG THE WAY TO THE LISP OUTPUT FILE.
2298
2299 @c -----------------------------------------------------------------------------
2300 @anchor{tr_float_can_branch_complex}
2301 @defvr {オプション変数} tr_float_can_branch_complex
2302 デフォルト値: @code{true}
2303
2304 Maxima-to-Lisp翻訳器に
2305  translator to assume that
2306 関数@code{acos}, @code{asin}, @code{asec}, @code{acsc}が複素数の結果を返すことができることを仮定するように命じます。
2307
2308 @code{tr_float_can_branch_complex}の表面上の効果は以下の通りです。
2309 しかしながら、このフラグは翻訳器出力上の効果を持ちません。
2310
2311 @code{true}の時、
2312 たとえ (@code{mode_declare}が設定したように)@code{x}がモード@code{float}でも
2313 @code{acos(x)}はモード@code{any}です。
2314 @code{false}の時、
2315 @code{x}がモード@code{float}の時だけ
2316 @code{acos(x)}はモード@code{float}です。
2317
2318 @opencatbox
2319 @category{Translation flags and variables}
2320 @closecatbox
2321 @end defvr
2322
2323 @c -----------------------------------------------------------------------------
2324 @anchor{tr_function_call_default}
2325 @defvr {オプション変数} tr_function_call_default
2326 デフォルト値: @code{general}
2327
2328 @code{false}は、あきらめて@code{meval}をコールすることを意味し、
2329 @code{expr}は、引数が固定されたLisp関数を仮定することを意味します。
2330 @code{general}、デフォルトは
2331 @code{mexprs}や@code{mlexprs}にはよいが@code{macros}にはよくないコードを与えます。
2332 @code{general}は、コンパイルされたコードの中で変数バインドが正確であることを保証します。
2333 @code{general}モードでは、
2334 F(X)を翻訳する時、もしFがバインドされた変数なら、
2335 @code{apply (f, [x])}を意味すると仮定され、適切な警告と合わせてそのように翻訳されます。
2336 これをオフにする必要はありません。
2337 デフォルト設定で警告メッセージがないことは、
2338 Maximaインタープリタと、翻訳、コンパイルされたコードの完全互換性を意味します。
2339
2340 @opencatbox
2341 @category{Translation flags and variables}
2342 @closecatbox
2343 @end defvr
2344
2345 @c -----------------------------------------------------------------------------
2346 @anchor{tr_numer}
2347 @defvr {オプション変数} tr_numer
2348 デフォルト値: @code{false}
2349
2350 @code{tr_numer}が@code{true}の時、
2351 @code{numer}プロパティは
2352 それらを持つアトム、例えば、@code{%pi}に使われます。
2353
2354 @opencatbox
2355 @category{Translation flags and variables}
2356 @closecatbox
2357 @end defvr
2358
2359 @c -----------------------------------------------------------------------------
2360 @anchor{tr_optimize_max_loop}
2361 @defvr {オプション変数} tr_optimize_max_loop
2362 デフォルト値: 100
2363
2364 @code{tr_optimize_max_loop}は、
2365 翻訳器のマクロ展開と最適化パスが形式を検討する際繰り返す最大回数です。
2366 これはマクロ展開エラーや終了しない最適化プロパティをキャッチします。
2367
2368 @opencatbox
2369 @category{Translation flags and variables}
2370 @closecatbox
2371 @end defvr
2372
2373 @c -----------------------------------------------------------------------------
2374 @anchor{tr_semicompile}
2375 @defvr {オプション変数} tr_semicompile
2376 デフォルト値: @code{false}
2377
2378 @code{tr_semicompile}が@code{true}の時、
2379 @code{translate_file}と@code{compfile}は、
2380 マクロ展開されたが、Lispコンパイラによって機械語にコンパイルされない形式を出力します。
2381
2382 @opencatbox
2383 @category{Translation flags and variables}
2384 @closecatbox
2385
2386 @end defvr
2387
2388 @c ARE ANY OF THESE OBSOLETE ??
2389
2390 @c -----------------------------------------------------------------------------
2391 @anchor{tr_state_vars}
2392 @defvr {システム変数} tr_state_vars
2393 デフォルト値:
2394 @example
2395 [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
2396 tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
2397 tr_function_call_default, tr_array_as_ref,tr_numer]
2398 @end example
2399
2400 翻訳された出力の形式に影響するスイッチのリスト。
2401 @c DOES THE GENERAL USER REALLY CARE ABOUT DEBUGGING THE TRANSLATOR ???
2402 翻訳器をデバッグしようとする時
2403 この情報はシステムの人たちに役に立ちます。
2404 翻訳された生成物を与えられた状態で生成されるべきだったものと比較することによって、
2405 バグを追跡することが可能です。
2406
2407 @opencatbox
2408 @category{Translation flags and variables}
2409 @closecatbox
2410
2411 @end defvr
2412
2413 @c tr_warnings_get EXISTS AND FUNCTIONS AS ADVERTISED (SORT OF) -- RETURNS *tr-runtime-warned*
2414 @c WHICH HAS ONLY A FEW KINDS OF WARNINGS PUSHED ONTO IT; IT'S CERTAINLY NOT COMPREHENSIVE
2415 @c DO WE REALLY NEED THIS SLIGHTLY WORKING FUNCTION ??
2416
2417 @c -----------------------------------------------------------------------------
2418 @anchor{tr_warnings_get}
2419 @deffn {関数} tr_warnings_get ()
2420
2421 現在の翻訳の間に翻訳器が与える警告のリストを印字します。
2422
2423 @opencatbox
2424 @category{Translation and compilation}
2425 @closecatbox
2426 @end deffn
2427
2428 @c -----------------------------------------------------------------------------
2429 @defvr {オプション変数} tr_warn_bad_function_calls
2430 デフォルト値: @code{true}
2431
2432 - 翻訳時にされた不適切な宣言のせいで正確でないかもしれない関数コールが行われている時、
2433 警告を与えます。
2434
2435 @opencatbox
2436 @category{Translation flags and variables}
2437 @closecatbox
2438 @end defvr
2439
2440 @c -----------------------------------------------------------------------------
2441 @anchor{tr_warn_fexpr}
2442 @defvr {オプション変数} tr_warn_fexpr
2443 デフォルト値: @code{compfile}
2444
2445 - もしFEXPRに遭遇したら、警告を与えます。
2446 FEXPRは、通常、翻訳コードの中で出力されるべきではありません。
2447 合法で特殊なプログラム形式はすべて翻訳されます。
2448
2449 @opencatbox
2450 @category{Translation flags and variables}
2451 @closecatbox
2452 @end defvr
2453
2454 @c -----------------------------------------------------------------------------
2455 @anchor{tr_warn_meval}
2456 @defvr {オプション変数} tr_warn_meval
2457 デフォルト値: @code{compfile}
2458
2459 - もし関数@code{meval}がコールされたら、警告を与えます。
2460 もし@code{meval}がコールされたら、それは翻訳の中の問題を示します。
2461
2462 @opencatbox
2463 @category{Translation flags and variables}
2464 @closecatbox
2465 @end defvr
2466
2467 @c -----------------------------------------------------------------------------
2468 @anchor{tr_warn_mode}
2469 @defvr {オプション変数} tr_warn_mode
2470 デフォルト値: @code{all}
2471
2472 - 変数がそのモードに不適切な値を割り当てられた時、警告を与えます。
2473
2474 @opencatbox
2475 @category{Translation flags and variables}
2476 @closecatbox
2477 @end defvr
2478
2479 @c -----------------------------------------------------------------------------
2480 @anchor{tr_warn_undeclared}
2481 @defvr {オプション変数} tr_warn_undeclared
2482 デフォルト値: @code{compile}
2483
2484 - 未宣言変数についての警告をいつTTYに送るかを決めます。
2485
2486 @opencatbox
2487 @category{Translation flags and variables}
2488 @closecatbox
2489 @end defvr
2490
2491 @c -----------------------------------------------------------------------------
2492 @anchor{tr_warn_undefined_variable}
2493 @defvr {オプション変数} tr_warn_undefined_variable
2494 デフォルト値: @code{all}
2495
2496 - 未定義のグローバル変数が見られた時、警告を与えます。
2497
2498 @opencatbox
2499 @category{Translation flags and variables}
2500 @closecatbox
2501 @end defvr
2502
2503 @c -----------------------------------------------------------------------------
2504 @anchor{compile_file}
2505 @deffn  {関数} compile_file (@var{filename})
2506 @deffnx {関数} compile_file (@var{filename}, @var{compiled_filename})
2507 @deffnx {関数} compile_file (@var{filename}, @var{compiled_filename}, @var{lisp_filename})
2508
2509 Maximaファイル@var{filename}をLispに翻訳し、Lispコンパイラを実行し、
2510 もし翻訳とコンパイルが成功したら、コンパイルされたコードをMaximaにロードします。
2511
2512 @code{compile_file}は４つのファイル名のリストを返します:
2513 元のMaximaファイル、Lisp翻訳、翻訳時ノート、コンパイルされたコード。
2514 もしコンパイルが失敗したら、4番目の項目は@code{false}です。
2515
2516 Lispコードがコンパイルされると(コンパイルされたコードをロードすることなしに)すぐに
2517 いくつかの宣言と定義は効力を発揮します。
2518 これらは@code{:=}演算子で定義された関数、
2519 @code{::=}演算子で定義されたマクロ、
2520 @c HEDGE -- DON'T KNOW IF THERE IS ANOTHER WAY
2521 @code{alias}, @code{declare},
2522 @code{define_variable},  @code{mode_declare},
2523 @code{infix}, @code{matchfix},
2524 @code{nofix}, @code{postfix}, @code{prefix},
2525 @code{compfile}
2526 を含みます。
2527
2528 コンパイルされたコードがロードされるまで
2529 割り当てと関数コールは評価されません。
2530 特に、Maximaファイルの中で、
2531 (@code{tr_numer}, など)翻訳フラグへの割り当ては翻訳時に効果を持ちません。
2532
2533 @c @code{compile_file} may mistake warnings for errors and
2534 @c return @code{false} as the name of the compiled code when, in fact,
2535 @c the compilation succeeded. This is a bug.
2536 @c REPORTED AS SOURCEFORGE BUG # 1103722.
2537
2538 @var{filename}は@code{:lisp}文を含むことができません。
2539
2540 @code{compile_file}は引数を評価します。
2541
2542 @opencatbox
2543 @category{Translation and compilation}
2544 @closecatbox
2545 @end deffn
2546
2547 @c NEEDS CLARIFICATION
2548
2549 @c -----------------------------------------------------------------------------
2550 @anchor{declare_translated}
2551 @deffn {関数} declare_translated (@var{f_1}, @var{f_2}, @dots{})
2552
2553 MaximaコードのファイルをLispに翻訳する時、
2554 ファイルの中で見る関数が翻訳された関数としてコールされるか、コンパイルされた関数としてコールされるか、また、どの関数がMaxima関数か未定義なのか、翻訳器が知ることは重要です。
2555 この宣言をファイルの先頭に置くことは、
2556 たとえまだLisp関数値を持たないシンボルがコール時にそれを持つだろうが、
2557 それを知らせます。
2558 @code{fn}がLisp関数になるつもりであることを翻訳器が知らない時、
2559 @code{(MFUNCTION-CALL fn arg1 arg2 ...)}が生成されます。
2560
2561 @opencatbox
2562 @category{Translation and compilation}
2563 @closecatbox
2564 @end deffn