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