Fix bug #1848: taytorat leaks internal gensyms from multivar expansions

[maxima.git] / doc / info / ja / Input.texi

@menu
* Comments::
* Files::                       
* Functions and Variables for File Input and Output::  
@end menu

@c -----------------------------------------------------------------------------
@node Comments, Files, File Input and Output, File Input and Output
@section Comments
@c -----------------------------------------------------------------------------

Maximaの入力の中のコメントは、@code{/*}と@code{*/}の間の任意のテキストです。

Maximaのパーサは、コメントを、入力外リームでのトークンを見つけるための空白として扱います;
コメントで常にトークンは終わります。
@code{a/* foo */b}のような入力は、１つのトークン@code{ab}ではなく、２つのトークン、@code{a}と@code{b}を含みます。
そうでなければ、Maximaはコメントを無視します;
コメントの中身も位置もパースされた入力式に残りません。

コメントは任意の深さに入れ子にすることができます。
@code{/*}と@code{*/}の区切り記号はマッチングペアを形作ります。
@code{/*}の数は@code{*/}と同じでなければいけません。

例:

@c ===beg===
@c /* aa is a variable of interest */  aa : 1234;
@c /* Value of bb depends on aa */  bb : aa^2;
@c /* User-defined infix operator */  infix ("b");
@c /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
@c /* Comments /* can be nested /* to any depth */ */ */  1 + xyz;
@c ===end===
@example
(%i1) /* aa is a variable of interest */  aa : 1234;
(%o1)                         1234
(%i2) /* Value of bb depends on aa */  bb : aa^2;
(%o2)                        1522756
(%i3) /* User-defined infix operator */  infix ("b");
(%o3)                           b
(%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
(%o4)                         a b c
(%i5) /* Comments /* can be nested /* to any depth */ */ */  1 + xyz;
(%o5)                        xyz + 1
@end example

@opencatbox
@category{Syntax}
@closecatbox

@c -----------------------------------------------------------------------------
@node Files, Functions and Variables for File Input and Output, Comments, File Input and Output
@section Files
@c -----------------------------------------------------------------------------

ファイルは、単に、データやテキスト含む、特別なストレージデバイスのある領域です。
ディスク上のファイルは、比喩的に「ディレクトリ」の中にグループ化されます。
ディレクトリは、単にファイルのリストです。
ファイルを扱うコマンドは以下の通りです:

@code{save},
@code{load},
@code{loadfile},
@code{stringout},
@code{batch},
@code{demo},
@code{writefile},
@code{closefile},と
@code{appendfile}。

ファイル名が@mref{plot2d}や@mref{save}、@mref{writefile}のような関数に渡され、
ファイル名がパスを含まない時、Maximaは現在のワーキングディレクトリにファイルを保存します。
現在のワーキングディレクトリはWindowsやLinuxのようなシステムと、インストールに依存します。

@c -----------------------------------------------------------------------------
@node Functions and Variables for File Input and Output,  , Files, File Input and Output
@section Functions and Variables for File Input and Output
@c -----------------------------------------------------------------------------

@c -----------------------------------------------------------------------------
@anchor{appendfile}
@deffn {関数} appendfile (@var{filename})
コンソールの筆記録を@var{filename}に追加します。
@code{appendfile}は、
筆記録ファイルが、存在すれば、いつも追加されることを除いて、
@code{writefile}と同じです。

@mref{closefile}は、@code{appendfile}や@code{writefile}によって開かれた筆記録ファイルを閉じます。

@opencatbox
@category{File output}
@category{Console interaction}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{batch}
@deffn  {関数} batch (@var{filename})
@deffnx {関数} batch (@var{filename}, @code{option})

@code{batch(@var{filename})}はMaximaの式を@var{filename}から読み込み、評価します。
@code{batch}は、リスト@mref{file_search_maxima}の中で@var{filename}を検索します。
@mref{file_search}も参照してください。

@code{batch(@var{filename}, @code{demo})}は、
@code{demo(@var{filename})}ようなものです。
この場合、@code{batch}は、リスト@mref{file_search_demo}の中で
@var{filename}を検索します。
@mref{demo}を参照してください。

@code{batch(@var{filename}, @code{test})}は、
オプション@code{display_all=true}を付けた@code{run_testsuite}ようなものです。
この場合、@code{batch}は、
@code{run_testsuite}のようにリスト@code{file_search_tests}ではなく、
リスト@code{file_search_maxima}の中で@var{filename}を検索します。
更に、@code{run_testsuite}はリスト@code{testsuite_files}の中にあるテストを実行します。
@code{batch}を使うと、どんなファイルもテストモードで実行することが可能です。
ファイルはリスト@code{file_search_maxima}の中であってもいいです。
これはテストファイルを書いている時に便利です。

@var{filename}は、一連のMaximaの式より成り、それぞれの式は、@code{;}もしくは@code{$}で終了します。
特殊変数@mref{%}と関数@mref{%th}は、ファイル内での前の結果を参照します。
ファイルは@code{:lisp}構成子を含むかもしれません。
ファイルの中の空白、タブ、改行は無視されます。
適した入力ファイルは、テキストエディタもしくは、@mref{stringout}関数で作ることができます。

@code{batch}は、それぞれの入力式を@var{filename}から読み込み、
入力をコンソールに表示し、
対応する出力式を計算し、
出力式を表示します。
入力ラベルは入力式に割り当てられ、出力ラベルは出力式に割り当てられます。
@code{batch}は、エラーがない限り、ファイルの中のすべての入力式を評価します。
もしユーザー入力が（例えば、@mref{asksign}や@mref{askinteger}によって）要求されたら、
@code{batch}は、ポーズして必要な入力を入手し、続けます。

@c CTRL-C BREAKS batch IN CMUCL, BUT CLISP (ALTHO IT SHOWS "User break")
@c KEEPS GOING !!! DON'T KNOW ABOUT GCL !!!
コンソールで@code{control-C}をタイプすることで、@code{batch}を停止させることが可能かもしれません。
@code{control-C}の効果は、基礎となるLispの実装に依存します。

@code{batch}にはいくつか用法があります。
役立つコマンドラインの蓄積を供給したり、
エラーのないデモンストレーションを与えたり、
複雑な問題を解く時、人の考えを整理するのを助けたり。

@code{batch}は引数を評価します。
第二引数なしで呼び出されたり、オプション@code{demo}で呼び出された時、
@code{batch}は@code{filename}のパスを文字列として返します。
オプション@code{test}で呼び出された時、
戻り値は、空のリスト@code{[]}か、@var{filename}と失敗したテストの数を含むリストです。

@mref{load}, @mref{batchload}, @mref{demo}も参照してください。

@opencatbox
@category{Session management}
@category{File input}
@closecatbox

@end deffn

@c RECOMMEND CUTTING THIS ITEM, AS THE load SUBSUMES FUNCTIONALITY OF batchload

@c -----------------------------------------------------------------------------
@anchor{batchload}
@deffn {関数} batchload (@var{filename})

@var{filename}からMaximaの式を読み込み、評価します。
入力式や出力式を表示しません。
ラベルを出力式に割り当てません。
しかし、（@code{print}や@code{describe}が生成するような)プリント文の出力は表示されます。

特殊変数@mref{%}や関数@mref{%th}は、
ファイルの中の結果ではなく、対話インタープリタからの以前の結果を参照します。
ファイルは@code{:lisp}構成子を含むことはできません。

@code{batchload}は、@var{filename}のパスを文字列として返します。
@code{batchload}は引数を評価します。

@mref{batch}や@mref{load}も参照してください。
@c batchload APPEARS TO HAVE THE SAME EFFECT AS load. WHY NOT GET RID OF batchload ???

@opencatbox
@category{Session management}
@category{File input}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{closefile}
@deffn {関数} closefile ()

@mref{writefile}や@mref{appendfile}で開いたトランスクリプトファイルを閉じます。

@opencatbox
@category{File output}
@category{Console interaction}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{file_output_append}
@defvr {オプション変数} file_output_append
デフォルト値: @code{false}

@code{file_output_append}は、
ファイル出力関数が出力ファイルに追加するか、ファイルを切り詰めるか決めます。
@code{file_output_append}が@code{true}の時、
ファイル出力関数は出力ファイルに追加します。
そうでなければ，出力ファイルは切り詰められます。

@mref{save}, @mref{stringout}, @mref{with_stdout}は、@code{file_output_append}を考慮します。
出力ファイルを書き出す他の関数は@code{file_output_append}を考慮しません。
特に、プロット感巣や変換関数は常に出力ファイルを切り詰め、
@mref{tex}や@mref{appendfile}はいつも追加します。
@c WHAT ABOUT WRITEFILE ??

@opencatbox
@category{File output}
@category{Global flags}
@closecatbox
@end defvr


@c NEEDS EXAMPLES

@c -----------------------------------------------------------------------------
@anchor{filename_merge}
@deffn {関数} filename_merge (@var{path}, @var{filename})

@var{path}と@var{filename}から修正されたパスを構成します。
もし、@var{path}の最後の構成要素が形式@code{###.@var{something}}なら、
構成要素は、@code{@var{filename}.@var{something}}に置き換えられます。
そうでなければ、最後の構成要素は単に@var{filename}に置き換えられます。

結果はLispのパス名オブジェクトです。

@opencatbox
@category{File input}
@category{File output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{file_search}
@deffn  {関数} file_search (@var{filename})
@deffnx {関数} file_search (@var{filename}, @var{pathlist})

@code{file_search}は、ファイル@var{filename}を検索し、
もし見つかれば、（文字列として）ファイルへのパスを返します;
そうでなければ、@code{file_search}は@code{false}を返します。
@code{file_search (@var{filename})}は、
デフォルトのサーチディレクトリを検索します。
デフォルトのサーチディレクトリは、@mref{file_search_maxima},
@mref{file_search_lisp}, @mref{file_search_demo}変数によって指定されます。

@code{file_search}は、
名前を「ワイルドカード」ファイルサーチパターンにマッチさせようとする前に、
最初に、渡された実際の名前が存在するかチェックします。
ファイルサーチパターンに関連した@mref{file_search_maxima}を参照してください。

引数@var{filename}は、パスとファイル名、もしくは単にファイル名、もしくは、
もしファイルサーチディレクトリがファイルサーチパターンを含むなら、単にファイル名のベース（拡張子なし）、を取り得ます。
例えば、

@example
file_search ("/home/wfs/special/zeta.mac");
file_search ("zeta.mac");
file_search ("zeta");
@end example

ファイルが存在していて、@code{/home/wfs/special/###.mac}が@code{file_search_maxima}に中にあるという仮定の下で、上記すべては同じファイルを見つけます。

@code{file_search (@var{filename}, @var{pathlist})}は、
@var{pathlist}によって指定されたディレクトリの中だけを検索します。
ここで、@var{pathlist}は文字列のりすとです。
引数@var{pathlist}は、デフォルトの検索ディレクトリに取って代わります。
だから、もしパスリストが与えられたら、デフォルトの検索ディレクトリのいずれでもなく、@code{file_search}は指定されたところだけを検索します。
@var{pathlist}の中に１つのディレクトリだけしかない場合でさえ、まだ、
それは、要素１つのリストとして与えられなければいけません。

ユーザーはデフォルト検索ディレクトリを修正できます。
@mref{file_search_maxima}を参照してください。

@code{file_search}は、@code{file_search_maxima}と@mref{file_search_lisp}を
を検索ディレクトリとして、
@mref{load}によって呼び出されます。

@opencatbox
@category{File input}
@closecatbox

@end deffn

@c -----------------------------------------------------------------------------
@anchor{file_search_maxima}
@anchor{file_search_lisp}
@anchor{file_search_demo}
@anchor{file_search_usage}
@anchor{file_search_tests}
@defvr  {オプション変数} file_search_maxima
@defvrx {オプション変数} file_search_lisp
@defvrx {オプション変数} file_search_demo
@defvrx {オプション変数} file_search_usage
@defvrx {オプション変数} file_search_tests

これらの変数は、@mref{load}, @mref{demo}や他のいくつかのMaximaの関数が検索する
ディレクトリのリストを指定します。
これらの変数のデフォルト値は、Maxima員ストレーションの様々なディレクトリを名指ししています。

ユーザーは、
デフォルト値を置き換えるか、ディレクトリを追加することで、
これらの変数を変更できます
例えば、

@example
file_search_maxima: ["/usr/local/foo/###.mac",
    "/usr/local/bar/###.mac"]$
@end example

は、@code{file_search_maxima}のデフォルト値を置き換える一方、

@example
file_search_maxima: append (file_search_maxima,
    ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$
@end example

は、２つのディレクトリを追加します。
ファイル@code{maxima-init.mac}に
Maximaが起動した時にファイル検索パスが自動的に割り当てられるような式を入れておくと便利かもしれません。
@ref{Introduction for Runtime Environment}も参照してください。

特別な「ワイルドカード」構造によって、ファイル名の拡張子やパスを多重にしてすることができます。
文字列@code{###}は、求められている名前に拡張される一方、
カーリ括弧@code{@{foo,bar,baz@}}で囲まれた、コンマで分離されたリストは多重文字列に拡張されます。
例えば、求められてる名前が@code{neumann}とすると、

@example
"/home/@{wfs,gcj@}/###.@{lisp,mac@}"
@end example

@flushleft
は、@code{/home/wfs/neumann.lisp}, @code{/home/gcj/neumann.lisp},
@code{/home/wfs/neumann.mac}, @code{/home/gcj/neumann.mac}に展開されます。
@end flushleft

@opencatbox
@category{File input}
@category{Global variables}
@closecatbox
@end defvr

@c -----------------------------------------------------------------------------
@anchor{file_type}
@deffn {関数} file_type (@var{filename})

@var{filename}の中身について、ファイル名拡張子を下に、推測を返します。
@var{filename}は、実際のファイルを参照する必要はありません;
ファイルを開いたり、中身を探索したりはしません。

戻り値はシンボルであり、@code{object}, @code{lisp}, @code{maxima}のいずれかです。
もし拡張子が@code{file_type_maxima}の中の値の1つと一致したら、
@code{file_type}は@code{maxima}を返します。
もし拡張子が"@code{file_type_lisp}の中の値の1つと一致したら、
@code{file_type}は@code{lisp}を返します。
上のいずれでもないなら、@code{file_type}は@code{object}を返します。

@mref{pathname_type}も参照してください。

デフォルト値に関しては、@mref{file_type_maxima}と@mref{file_type_lisp}を
参照してください。

例:

@c ===beg===
@c map('file_type,
@c     ["test.lisp", "test.mac", "test.dem", "test.txt"]);
@c ===end===
@example
(%i2) map('file_type,
          ["test.lisp", "test.mac", "test.dem", "test.txt"]);
(%o2)            [lisp, maxima, maxima, object]
@end example

@opencatbox
@category{File input}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{file_type_lisp}
@defvr {オプション変数} file_type_lisp
デフォルト値:  @code{[l, lsp, lisp]}

@code{file_type_lisp}は、
maximaがLispソースファイルの印として認識するファイル拡張子のリストです。

@mref{file_type}も参照してください。
@end defvr

@c -----------------------------------------------------------------------------
@anchor{file_type_maxima}
@defvr {オプション変数} file_type_maxima
デフォルト値:  @code{[mac, mc, demo, dem, dm1, dm2, dm3, dmt]}

@code{file_type_maxima}は、
maximaがMaximaソースファイルの印として認識するファイル拡張子のリストです。

@mref{file_type}も参照してください。
@end defvr

@c -----------------------------------------------------------------------------
@anchor{load}
@deffn {関数} load (@var{filename})

@var{filename}の中の式を評価します。
そして、変数、関数、他のオブジェクトをMaximaにもたらします。
、@var{filename}から再生されたバインドは存在するオブジェクトのバインドを上書きします(clobber)。
ファイルを見つけるために、
@code{load}は、探索ディレクトリとして@code{file_search_maxima}と@code{file_search_lisp}を引数として@code{file_search}をコールします。
もし@code{load}が成功したら
ファイルの名前を返します。
そうでなければ、@code{load}はエラーメッセージを出力します。

@code{load}は、LispコードでもMaximaコードでも等しく機能します。
@mref{save}, @mref{translate_file}, @mref{compile_file}―これらはLispコードを生成します―が生成したファイルはすべて@code{load}によって処理できます。
@code{load}は、Lispファイルをロードするために@code{loadfile}をコールし、
Maximaファイルをロードするために@mref{batchload}をコールします。

@code{load}は、Maximaファイルの中で@code{:lisp}構成子を認識しません。
@var{filename}を処理する時、
グローバル変数@code{_}, @code{__}, @code{%}, @code{%th}は、
@code{load}がコールされた時バインドされていた値を持ちます。

@mref{loadfile}, @mref{batch}, @mref{batchload}, @mref{demo}も参照してください。
@code{loadfile}はLispファイルを処理します;
@code{batch}, @code{batchload}, @code{demo}はMaximaファイルを処理します。

ファイル探索メカニズムについてもっと詳しいことは@mref{file_search}を参照してください。

@code{load}は引数を評価します。

@opencatbox
@category{Session management}
@category{File input}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{load_pathname}
@defvr {システム変数} load_pathname
デフォルト値: @code{false}

関数@mref{load}や、@mref{loadfile}、@mref{batchload}を使ってファイルがロードされる時、
システム変数@code{load_pathname}は処理するファイルのパス名を示します。

変数@code{load_pathname}はロード中にファイルからアクセスすることができます。

例:

ディレクトリ
@flushleft
@code{"/home/dieter/workspace/mymaxima/temp/"}に、以下のコマンドを含む
@end flushleft
バッチファイル@code{test.mac}があるとしましょう。

@example
print("The value of load_pathname is: ", load_pathname)$
print("End of batchfile")$
@end example

すると、以下の出力を得ます。

@example
(%i1) load("/home/dieter/workspace/mymaxima/temp/test.mac")$
The value of load_pathname is:  
                   /home/dieter/workspace/mymaxima/temp/test.mac 
End of batchfile
@end example

@opencatbox
@category{File input}
@closecatbox
@end defvr

@c RECOMMEND CUTTING THIS ITEM, AS THE load SUBSUMES FUNCTIONALITY OF loadfile

@c -----------------------------------------------------------------------------
@anchor{loadfile}
@deffn {関数} loadfile (@var{filename})

@var{filename}の中のLisp式を評価します。
@code{loadfile}は、@code{file_search}を呼び出しません。
だから、@code{filename}はファイル拡張子とファイルを見つけるのに必要なパスも含まなければいけません。

@code{loadfile}は、@mref{save}, @mref{translate_file}, @mref{compile_file}によって生成されたファイルを処理できます。
ユーザーは、@code{loadfile}の代わりに@mref{load}を使うほうが便利だと気づくでしょう。

@opencatbox
@category{Session management}
@category{File input}
@closecatbox
@end deffn

@c loadprint DOESN'T EXACTLY WORK LIKE THIS, BUT IT HARDLY SEEMS WORTH FIXING
@c I GUESS THIS COULD BE UPDATED TO DESCRIBE THE WAY IT ACTUALLY WORKS

@c -----------------------------------------------------------------------------
@anchor{loadprint}
@defvr {オプション変数} loadprint
デフォルト値: @code{true}

@code{loadprint}は、ファイルがロードされた時、メッセージを表示するかどうか告げます。

@itemize @bullet
@item
@code{loadprint}が@code{true}の時, いつもメッセージを表示します。
@item
@code{loadprint}が@code{'loadfile}の時, ファイルが関数@code{loadfile}によってロードされた時だけメッセージを表示します。
@item
@code{loadprint}が@code{'autoload}の時、
ファイルが自動的にロードされた時だけメッセージを表示します。
@mref{setup_autoload}を参照してください。
@item
@code{loadprint}が@code{false}の時, メッセージは決して表示されません。
@end itemize

@opencatbox
@category{File input}
@category{Global flags}
@closecatbox
@end defvr

@c STILL EXISTS, NEEDS CLARIFICATION !!!

@c -----------------------------------------------------------------------------
@anchor{packagefile}
@defvr {オプション変数} packagefile
デフォルト値: @code{false}

他の人が使うパッケージ（ファイル）を生成するために@mref{save}や@mref{translate}を使う
パッケージデザイナは、
ファイルがロードされる時必要な場合を除いて、
Maximaの情報リスト（例えば、@mref{values}, @mref{functions}）に情報が追加されることを抑制するために、@code{packagefile: true}を設定したいかもしれません。
この方法によれば、
ユーザーが自身のデータを追加した時ユーザーの方法では
パッケージの中身は、得られないでしょう。
これは、起こりうる名前衝突の問題を解決はしないことに注意してください。
このフラグは、パッケージファイルへの出力であるものに素直に影響することにも注意してください。
フラグを@code{true}に設定することは、
Maxima初期化ファイルを生成するにも役に立ちます。

@opencatbox
@category{Translation flags and variables}
@closecatbox
@end defvr

@c -----------------------------------------------------------------------------
@anchor{pathname_directory}
@anchor{pathname_name}
@anchor{pathname_type}
@deffn  {関数} pathname_directory (@var{pathname})
@deffnx {関数} pathname_name (@var{pathname})
@deffnx {関数} pathname_type (@var{pathname})

これらの関数は@var{pathname}の構成要素を返します。

例:

@c ===beg===
@c pathname_directory("/home/dieter/maxima/changelog.txt");
@c pathname_name("/home/dieter/maxima/changelog.txt");
@c pathname_type("/home/dieter/maxima/changelog.txt");
@c ===end===
@example 
(%i1) pathname_directory("/home/dieter/maxima/changelog.txt");
(%o1)                 /home/dieter/maxima/
(%i2) pathname_name("/home/dieter/maxima/changelog.txt");
(%o2)                       changelog
(%i3) pathname_type("/home/dieter/maxima/changelog.txt");
(%o3)                          txt
@end example

@opencatbox
@category{File input}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{printfile}
@deffn {関数} printfile (@var{path})

@var{path}という名前のファイルをコンソールに表示します。
@var{path}は、文字列もしくはシンボルです;
もしシンボルなら、文字列に変換されます。

もし@var{path}が現在のワーキングディレクトリからアクセス可能なファイル名なら、
そのファイルがコンソールに表示されます。
そうでなければ、
@code{printfile}は、
@mref{filename_merge}を介して@mref{file_search_usage}の要素のそれぞれに
@var{path}を追加することでファイルを見つけようとします。

@code{printfile}は、もし@var{path}が存在しているファイルを示しているなら、
@var{path}を返し、そうでなければ、
成功したファイル名マージの結果を返します。

@opencatbox
@category{File input}
@category{Console interaction}
@closecatbox
@end deffn

@c RECOMMEND CUTTING THIS ITEM AND CUTTING $tcl_output IN src/plot.lisp
@c THIS REALLY, REALLY SEEMS LIKE CRUFT:
@c $tcl_output IS NEVER CALLED WITHIN MAXIMA SOURCE,
@c AND THIS EXTREMELY NARROW, LIMITED FUNCTIONALITY ISN'T USEFUL TO USERS
@c AND IT'S BROKEN: INCORRECT OUTPUT FOR CLISP, DIES ON GCL

@c -----------------------------------------------------------------------------
@anchor{tcl_output}
@deffn  {関数} tcl_output (@var{list}, @var{i0}, @var{skip})
@deffnx {関数} tcl_output (@var{list}, @var{i0})
@deffnx {関数} tcl_output ([@var{list_1}, @dots{}, @var{list_n}], @var{i})

リストの要素を、
カーリ括弧@code{@{ @}}で囲んで表示します。
Tcl/Tk言語でプログラムの一部として適した形です。

@code{tcl_output (@var{list}, @var{i0}, @var{skip})}
は、
要素@var{i0}で始まり、要素@code{@var{i0} + @var{skip}}, @code{@var{i0} + 2 @var{skip}}, などを表示するよう、@var{list}を表示します。

@code{tcl_output (@var{list}, @var{i0})}は、
@code{tcl_output (@var{list}, @var{i0}, 2)}と同値です。

@code{tcl_output ([@var{list_1}, ..., @var{list_n}], @var{i})}は、
@var{list_1}, @dots{}, @var{list_n}の@var{i}番目の要素を表示します。

例:
@c EXAMPLE INPUT
@c tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$
@c tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$
@c tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$
@c tcl_output ([x1, y1, x2, y2, x3, y3], 2)$
@c tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

@c EXAMPLE OUTPUT: CLISP
@c OUTPUT IS OK FOR FIRST TWO, BROKEN FOR OTHERS
@c GCL OUTPUT: SAME FOR FIRST TWO
@c GCL FAILS ON OTHERS (IN EACH CASE COMPLAINING ELEMENTS ARE "not of type (OR RATIONAL LISP:FLOAT)"
@example
(%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$

 @{1.000000000     4.000000000     
 @}
(%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$

 @{2.000000000     5.000000000     
 @}
(%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$

 @{((RAT SIMP) 3 7) ((RAT SIMP) 11 13) 
 @}
(%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$

 @{$Y1 $Y2 $Y3 
 @}
(%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

 @{SIMP 1.000000000     11.00000000     
 @}
@end example
@end deffn

@c NEEDS EXAMPLES
@c -----------------------------------------------------------------------------
@anchor{save}
@deffn  {関数} save (@var{filename}, @var{name_1}, @var{name_2}, @var{name_3}, @dots{})
@deffnx {関数} save (@var{filename}, values, functions, labels, @dots{})
@deffnx {関数} save (@var{filename}, [@var{m}, @var{n}])
@deffnx {関数} save (@var{filename}, @var{name_1}=@var{expr_1}, @dots{})
@deffnx {関数} save (@var{filename}, all)
@deffnx {関数} save (@var{filename}, @var{name_1}=@var{expr_1}, @var{name_2}=@var{expr_2}, @dots{})

@var{filename}に、@var{name_1}, @var{name_2}, @var{name_3}, @dots{},の現在値を
保存します。
引数は、変数、関数、他のオブジェクトの名前です。
もし名前が関連づけられた値や関数を持たないなら、無視されます。
@code{save}は、@var{filename}を返します。

@code{save}は、データをLisp式の形式で保存します。
@code{save}で保存されたデータは、@code{load (@var{filename})}によって回復できます。
@mref{load}を参照してください。

グローバルフラグ @mref{file_output_append}は、
@code{save}が出力ファイルに追加するか、切り詰めるか決めます。
@code{file_output_append}が@code{true}の時、
@code{save}は出力ファイルに追加します。
そうでなければ、@code{save}は出力ファイルを切り詰めます。
どちらの場合も、もしファイルが存在しなければ、@code{save}はファイルを生成します。

特殊形式@code{save (@var{filename}, values, functions, labels, ...)}
は、@mref{values}, @mref{functions}, @mref{labels}, などと名付けられた項目を
保存します。
名前は、変数@mref{infolists}によって指定された任意のものです。
@mref{values}は、ユーザー定義変数すべてから成ります。

特殊形式@code{save (@var{filename}, [@var{m}, @var{n}])}は、
@var{m}から@var{n}までの入力ラベル、出力ラベルの値を保存します。
@var{m}と@var{n}は、整数リテラルでなければならないことに注意してください。
例えば、@code{save ("foo.1", %i42, %o42)}のように、
入力ラベル、出力ラベルは１つ１つ保存することもできます。
@code{save (@var{filename}, labels)}は、
入力ラベル出力ラベルすべてを保存します。
保存されたラベルが回復された時、それらは存在していたラベルを負かします。

特殊形式@code{save (@var{filename}, @var{name_1}=@var{expr_1}, @var{name_2}=@var{expr_2}, ...)}は、
@var{expr_1}, @var{expr_2}, @dots{},の値を@var{name_1}, @var{name_2}, @dots{}という名前で保存します。
例えば、@code{save ("foo.1", aa=%o88)}のように、
この形式を入力ラベル出力ラベルに適用することは便利です。
この形式の等式の右辺は任意の式であり、その式は評価されます。
この形式は、新しい名前を現在のMaximaの環境に導入はせず、
ただ、@var{filename}にそれらを保存します。

これらの特殊形式と@code{save}の一般形式は自由に混在させることができます。
例えば、@code{save (@var{filename}, aa, bb, cc=42, functions, [11, 17])}。

特殊形式@code{save (@var{filename}, all)}は、Maximaの現在の状態を保存します。
これは、自動的に定義された項目はもちろん、ユーザー定義の変数、関数、配列などすべてを
含みます。
保存される項目は、
もしそれらがユーザーによって新しい値を割り当てられたなら、
@mref{file_search_maxima}や@mref{showtime}のようなシステム変数を含みます。
@mref{myoptions}を参照してください。

@code{save}は@var{filename}を評価し、他の引数すべてをクォートします。

@opencatbox
@category{Session management}
@category{File output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{stringout}
@deffn  {関数} stringout (@var{filename}, @var{expr_1}, @var{expr_2}, @var{expr_3}, @dots{})
@deffnx {関数} stringout (@var{filename}, [@var{m}, @var{n}])
@deffnx {関数} stringout (@var{filename}, input)
@deffnx {関数} stringout (@var{filename}, functions)
@deffnx {関数} stringout (@var{filename}, values)

@code{stringout}は、
式が入力としてタイプされたのと同じ形式で、式をファイルに書き込みます。
なので、ファイルは@mref{batch}や@mref{demo}コマンドの入力として使えますし、
どんな目的のためでも編集できます。
@code{stringout}は、@mref{writefile}が進行中の間に実行することができます。

グローバルフラグ@mref{file_output_append}は、
@code{stringout}が出力ファイルに追加するか、切り詰めるか決めます。
@code{file_output_append}が@code{true}の時、
@code{stringout}は、出力ファイルに追加します。
そうでなければ、@code{stringout}は出力ファイルを切り詰めます。
どちらの場合も、もしファイルが存在しなければ，@code{stringout}はファイルを生成します。

@code{stringout}の一般形式は、１つ以上の式の値を出力ファイルに書き込みます。
もし式が変数なら、変数の値だけが書き込まれ、変数名は書き込まれないことに注意してください。
役に立つ特殊な場合として、式は、
入力ラベル(@code{%i1}, @code{%i2}, @code{%i3}, @dots{})もしくは出力ラベル(@code{%o1}, @code{%o2}, @code{%o3}, @dots{})でもよいです。
）

もし@mref{grind}が@code{true}なら、
@code{stringout}は、@code{grind}フォーマットを使って出力をフォーマットします。
そうでなければ、@code{string}フォーマットが使われます。
@code{grind}と@code{string}を参照してください。

特殊形式@code{stringout (@var{filename}, [@var{m}, @var{n}])}は、
mからnまでの入力ラベルの値を書き込みます。

特殊形式 @code{stringout (@var{filename}, input)}は、
入力ラベルすべてをファイルに書き込みます。

特殊形式@code{stringout (@var{filename}, functions)}は、
（グローバルリスト@mref{functions}で名付けられた）ユーザー定義関数すべてをファイルに書き込みます。

特殊形式@code{stringout (@var{filename}, values)}は、
（グローバルリスト@mref{values}で名付けられた）ユーザーが割り当てた変数すべてをファイルに書き込みます。
変数それぞれは、変数名とコロンとその値という割り当て文として出力されます。
@code{stringout}の一般形式は変数を割り当て文として出力しないことに注意してください。

@opencatbox
@category{Session management}
@category{File output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{tex}
@deffn  {関数} tex (@var{expr})
@deffnx {関数} tex (@var{expr}, @var{destination})
@deffnx {関数} tex (@var{expr}, false)
@deffnx {関数} tex (@var{label})
@deffnx {関数} tex (@var{label}, @var{destination})
@deffnx {関数} tex (@var{label}, false)

TeXドキュメントの準備に適した式の表現を出力します。
結果は、ドキュメントの断片です。
それは、より大きなドキュメントにコピーすることができますが、それ自身では処理されません。

@code{tex (@var{expr})}は、@var{expr}のTeX表現をコンソールに出力します。

@code{tex (@var{label})}は、@var{label}で名付けられた式のTeX表現を出力し、
（式の左に表示されるよう）等式ラベルをそれに割り当てます。
TeX等式ラベルは、Maximaラベルと同じです。

@var{destination}は、出力ストリームもしくはファイル名です。
@var{destination}がファイル名の時、
@code{tex}は、ファイルに出力を追加します。
関数@code{openw}と@code{opena}は、出力ストリームを生成します。

@code{tex (@var{expr}, false)}と@code{tex (@var{label}, false)}は、
TeX出力を文字列として返します。

@code{tex}は、最初の引数がラベルかどうか見るためにテストした後、最初の引数を評価します。
クォートクォート@code{''}は、引数の評価を強制し、
その結果、テストをだめにして、ラベルを妨げます。

@mref{texput}も参照してください。

例:

@example
(%i1) integrate (1/(1+x^3), x);
                                    2 x - 1
                  2            atan(-------)
             log(x  - x + 1)        sqrt(3)    log(x + 1)
(%o1)      - --------------- + ------------- + ----------
                    6             sqrt(3)          3
(%i2) tex (%o1);
$$-@{@{\log \left(x^2-x+1\right)@}\over@{6@}@}+@{@{\arctan \left(@{@{2\,x-1
 @}\over@{\sqrt@{3@}@}@}\right)@}\over@{\sqrt@{3@}@}@}+@{@{\log \left(x+1\right)
 @}\over@{3@}@}\leqno@{\tt (\%o1)@}$$
(%o2)                          (\%o1)
(%i3) tex (integrate (sin(x), x));
$$-\cos x$$
(%o3)                           false
(%i4) tex (%o1, "foo.tex");
(%o4)                          (\%o1)
@end example

@code{tex (@var{expr}, false)}はTeX出力を文字列として返します。

@c ===beg===
@c S : tex (x * y * z, false);
@c S;
@c ===end===
@example
(%i1) S : tex (x * y * z, false);
(%o1) $$x\,y\,z$$
(%i2) S;
(%o2) $$x\,y\,z$$
@end example

@opencatbox
@category{TeX output}
@category{File output}
@closecatbox

@end deffn

@c -----------------------------------------------------------------------------
@anchor{tex1}
@deffn {関数} tex1 (@var{e})

式@var{e}のTeX出力を表現する文字列を返します。
TeX出力は、等式や他の任意の環境のため、区切り記号で囲まれません。

例:

@c ===beg===
@c tex1 (sin(x) + cos(x));
@c ===end===
@example
(%i1) tex1 (sin(x) + cos(x));
(%o1)                     \sin x+\cos x
@end example
@end deffn

@c -----------------------------------------------------------------------------
@anchor{texput}
@deffn  {関数} texput (@var{a}, @var{s})
@deffnx {関数} texput (@var{a}, @var{f})
@deffnx {関数} texput (@var{a}, @var{s}, @var{operator_type})
@deffnx {関数} texput (@var{a}, [@var{s_1}, @var{s_2}], matchfix)
@deffnx {関数} texput (@var{a}, [@var{s_1}, @var{s_2}, @var{s_3}], matchfix)

アトム@var{a}のためのTeX出力を割り当てます。
ここで@var{a}はシンボルもしくは演算子名です。

@code{texput (@var{a}, @var{s})}は、
@code{tex}関数に、
@var{a}の代わりに文字列@var{s}をTeX出力に入れるようにさせます。

@code{texput (@var{a}, @var{f})}は、
@code{tex}関数に、
TeX出力を生成するために関数@var{f}をコールさせます。
@var{f}は、１つの引数を受け入れなければいけません。
ここで、引数は、演算子@var{a}を持つ式で、文字列（TeX出力）を返さなければいけません。
@var{f}は、入力式の引数のためにTeX出力を生成するよう、@code{tex1}をコールするかもしれません。

@var{operator_type}が@code{prefix}, @code{infix}, @code{postfix}, @code{nary}, もしくは @code{nofix},として、
@code{texput (@var{a}, @var{s}, @var{operator_type})}は、
@code{tex}関数に
@var{a}の代わりに@var{s}をTeX出力に入れるようにさせ、
適切な位置に挿入された手キスを置くようにさせます。

@code{texput (@var{a}, [@var{s_1}, @var{s_2}], matchfix)}は、
@code{tex}関数に、
@var{a}の引数のそれぞれの側に@var{s_1}と@var{s_2}を
TeX出力に入れるようにさせます。
（もし複数なら）引数はコンマで分離されます。

@code{texput (@var{a}, [@var{s_1}, @var{s_2}, @var{s_3}], matchfix)}は、
@code{tex}関数に、
引数を分離する@var{s_3}と一緒に
@var{a}の引数のそれぞれの側に@var{s_1}と@var{s_2}をTeX出力に入れるようにさせます。

例:

変数にTeX出力を割り当てます。

@c ===beg===
@c texput (me,"\\mu_e");
@c tex (me);
@c ===end===
@example
(%i1) texput (me,"\\mu_e");
(%o1)                         \mu_e
(%i2) tex (me);
$$\mu_e$$
(%o2)                         false
@end example

任意の関数（演算子ではない）にTeX出力を割り当てます。

@c ===beg===
@c texput (lcm, "\\mathrm{lcm}");
@c tex (lcm (a, b));
@c ===end===
@example
(%i1) texput (lcm, "\\mathrm@{lcm@}");
(%o1)                     \mathrm@{lcm@}
(%i2) tex (lcm (a, b));
$$\mathrm@{lcm@}\left(a , b\right)$$
(%o2)                         false
@end example

TeX出力を生成する関数をコールします。

@c ===beg===
@c texfoo (e) := block ([a, b], [a, b] : args (e),
@c   concat ("\\left[\\stackrel{",tex1(b),"}{",tex1(a),"}\\right]"))$
@c texput (foo, texfoo);
@c tex (foo (2^x, %pi));
@c ===end===
@example
(%i1) texfoo (e) := block ([a, b], [a, b] : args (e),
  concat ("\\left[\\stackrel@{",tex1(b),"@}@{",tex1(a),"@}\\right]"))$
(%i2) texput (foo, texfoo);
(%o2)                        texfoo
(%i3) tex (foo (2^x, %pi));
$$\left[\stackrel@{\pi@}@{2^@{x@}@}\right]$$
(%o3)                         false
@end example

前置演算子にTeX出力を割り当てます。

@c ===beg===
@c prefix ("grad");
@c texput ("grad", " \\nabla ", prefix);
@c tex (grad f);
@c ===end===
@example
(%i1) prefix ("grad");
(%o1)                         grad
(%i2) texput ("grad", " \\nabla ", prefix);
(%o2)                        \nabla 
(%i3) tex (grad f);
$$ \nabla f$$
(%o3)                         false
@end example

中置演算子にTeX出力を割り当てます。

@c ===beg===
@c infix ("~");
@c texput ("~", " \\times ", infix);
@c tex (a ~ b);
@c ===end===
@example
(%i1) infix ("~");
(%o1)                           ~
(%i2) texput ("~", " \\times ", infix);
(%o2)                        \times 
(%i3) tex (a ~ b);
$$a \times b$$
(%o3)                         false
@end example

後置演算子にTeX出力を割り当てます。

@c ===beg===
@c postfix ("##");
@c texput ("##", "!!", postfix);
@c tex (x ##);
@c ===end===
@example
(%i1) postfix ("##");
(%o1)                          ##
(%i2) texput ("##", "!!", postfix);
(%o2)                          !!
(%i3) tex (x ##);
$$x!!$$
(%o3)                         false
@end example

n項演算子にTeX出力を割り当てます。

@c ===beg===
@c nary ("@@");
@c texput ("@@", " \\circ ", nary);
@c tex (a @@ b @@ c @@ d);
@c ===end===
@example
(%i1) nary ("@@@@");
(%o1)                          @@@@
(%i2) texput ("@@@@", " \\circ ", nary);
(%o2)                         \circ 
(%i3) tex (a @@@@ b @@@@ c @@@@ d);
$$a \circ b \circ c \circ d$$
(%o3)                         false
@end example

無項演算子にTeX出力を割り当てます。

@c ===beg===
@c nofix ("foo");
@c texput ("foo", "\\mathsc{foo}", nofix);
@c tex (foo);
@c ===end===
@example
(%i1) nofix ("foo");
(%o1)                          foo
(%i2) texput ("foo", "\\mathsc@{foo@}", nofix);
(%o2)                     \mathsc@{foo@}
(%i3) tex (foo);
$$\mathsc@{foo@}$$
(%o3)                         false
@end example

マッチフィックス演算子にTeX出力を割り当てます。

@c ===beg===
@c matchfix ("<<", ">>");
@c texput ("<<", [" \\langle ", " \\rangle "], matchfix);
@c tex (<<a>>);
@c tex (<<a, b>>);
@c texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"], 
@c       matchfix);
@c tex (<<a>>);
@c tex (<<a, b>>);
@c ===end===
@example
(%i1) matchfix ("<<", ">>");
(%o1)                          <<
(%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
(%o2)                [ \langle ,  \rangle ]
(%i3) tex (<<a>>);
$$ \langle a \rangle $$
(%o3)                         false
(%i4) tex (<<a, b>>);
$$ \langle a , b \rangle $$
(%o4)                         false
(%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
      matchfix);
(%o5)           [ \langle ,  \rangle ,  \, | \,]
(%i6) tex (<<a>>);
$$ \langle a \rangle $$
(%o6)                         false
(%i7) tex (<<a, b>>);
$$ \langle a \, | \,b \rangle $$
(%o7)                         false
@end example

@opencatbox
@category{TeX output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{get_tex_environment}
@deffn  {関数} get_tex_environment (@var{op})
@deffnx {関数} set_tex_environment (@var{op}, @var{before}, @var{after})

@code{tex}によって出力されるTeX環境をカスタマイズします。
これらの関数によって保持されるように、TeX環境は２つの文字列から成ります;
１つは他の任意のTeX出力に前もって出力されるもの、もう１つは後に出力されるものです。

式のトップレベル演算子のTeX環境だけが、出力されます;
他の演算子に関連づけられたTeX環境は無視されます。

@code{get_tex_environment}は、
演算子@var{op}に適用されたTeX環境を返します;
もし他の環境が割り当てられていなければ、デフォルトを返します。

@code{set_tex_environment}は、
演算子@var{op}のためのTeX環境を割り当てます。

例:

@c ===beg===
@c get_tex_environment (":=");
@c tex (f (x) := 1 - x);
@c set_tex_environment (":=", "$$", "$$");
@c tex (f (x) := 1 - x);
@c ===end===
@example
(%i1) get_tex_environment (":=");
(%o1) [
\begin@{verbatim@}
, ;
\end@{verbatim@}
]
(%i2) tex (f (x) := 1 - x);

\begin@{verbatim@}
f(x):=1-x;
\end@{verbatim@}

(%o2)                         false
(%i3) set_tex_environment (":=", "$$", "$$");
(%o3)                       [$$, $$]
(%i4) tex (f (x) := 1 - x);
$$f(x):=1-x$$
(%o4)                         false
@end example

@opencatbox
@category{TeX output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{get_tex_enviroment_default}
@deffn  {関数} get_tex_environment_default ()
@deffnx {関数} set_tex_environment_default (@var{before}, @var{after})

@code{tex}によって出力されるTeX環境をカスタマイズします。
これらの関数によって保持されるように、TeX環境は２つの文字列から成ります;
１つは他の任意のTeX出力に前もって出力されるもの、もう１つは後に出力されるものです。

@code{get_tex_environment_default}は、
トップレベル演算子が（@code{set_tex_environment}で割り当てられたような）特定のTeX環境を持たない式に適用されたTeX環境を返します。

@code{set_tex_environment_default}は、デフォルトのTeX環境を割り当てます。

例:

@c ===beg===
@c get_tex_environment_default ();
@c tex (f(x) + g(x));
@c set_tex_environment_default ("\\begin{equation}
@c ", "
@c \\end{equation}");
@c tex (f(x) + g(x));
@c ===end===
@example
(%i1) get_tex_environment_default ();
(%o1)                       [$$, $$]
(%i2) tex (f(x) + g(x));
$$g\left(x\right)+f\left(x\right)$$
(%o2)                         false
(%i3) set_tex_environment_default ("\\begin@{equation@}
", "
\\end@{equation@}");
(%o3) [\begin@{equation@}
, 
\end@{equation@}]
(%i4) tex (f(x) + g(x));
\begin@{equation@}
g\left(x\right)+f\left(x\right)
\end@{equation@}
(%o4)                         false
@end example

@opencatbox
@category{TeX output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{with_stdout}
@deffn  {関数} with_stdout (@var{f}, @var{expr_1}, @var{expr_2}, @var{expr_3}, @dots{})
@deffnx {関数} with_stdout (@var{s}, @var{expr_1}, @var{expr_2}, @var{expr_3}, @dots{})

@var{expr_1}, @var{expr_2}, @var{expr_3}, ...を評価し、
生成された出力すべてをファイル@var{f}もしくは出力ストリーム@var{s}に書き込みます。
評価される式は出力に書き込まれません。
出力は、@mref{print}, @mref{display}, @mref{grind}や他の関数によって生成されたものです。

グローバルフラグ @mref{file_output_append}は、
@code{with_stdout}が出力ファイル@var{f}に追加するか切り詰めるか決めます。
@code{file_output_append}が@code{true}の時、
@code{with_stdout}は出力ファイルに追加します。
そうでなければ、@code{with_stdout}は出力ファイルを切り詰めます。
どちらの場合も、もしファイルが存在しないなら、@code{with_stdout}はファイルを生成します。

@code{with_stdout}は最後の引数の値を返します。

@mref{writefile}も参照してください。

@c THIS DOESN'T SEEM VERY IMPORTANT TO MENTION ...
@c Note the binding of display2d to be
@c false, otherwise the printing will have things like "- 3" instead
@c of "-3".
@c
@example
@c THIS EXAMPLE USES SOME UNIX-ISH CONSTRUCTS -- WILL IT WORK IN WINDOWS ???
@c ALSO IT'S SORT OF COMPLICATED AND THE SIMPLER SECOND EXAMPLE ILLUSTRATES with_stdout BETTER !!!
@c mygnuplot (f, var, range, number_ticks) :=
@c  block ([numer:true, display2d:false],
@c  with_stdout("tmp.out",
@c    dx: (range[2]-range[1])/number_ticks,
@c    for x: range[1] thru range[2] step dx
@c       do print (x, at (f, var=x))),
@c  system ("echo \"set data style lines; set title '", f,"' ;plot '/tmp/gnu'
@c ;pause 10 \" | gnuplot"))$
(%i1) with_stdout ("tmp.out", for i:5 thru 10 do
      print (i, "! yields", i!))$
(%i2) printfile ("tmp.out")$
5 ! yields 120 
6 ! yields 720 
7 ! yields 5040 
8 ! yields 40320 
9 ! yields 362880 
10 ! yields 3628800
@end example

@opencatbox
@category{File output}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{writefile}
@deffn {関数} writefile (@var{filename})

Maximaセッションのトランスクリプトを@var{filename}に書き込むことを開始します。
ユーザーとMaximaの間の対話すべてが、ちょうどコンソールに現れるように、このファイルに記録されます。
@c FOLLOWING CLAIM PROBABLY NEEDS TO BE QUALIFIED

トランスクリプトがコンソール出力フォーマットで出力されるので、
それはMaximaに再ロードすることはできません。
最ロード可能な式を含むファイルを作るには、
@mref{save}と@mref{stringout}を参照してください。
@code{save}は、Lisp形式の式を保存する一方、@code{stringout}は、Maxima形式
の式を保存します。

@var{filename}が既に存在している時、@code{writefile}の実行の効果は、
基礎となるLisp実装に依存します;
トランスクリプファイルは負かされるかもしれませんし、ファイルは追加されるかもしれません。
@mref{appendfile}は、いつもトランスクリプトファイルに追加します。

以前の対話の表示を保存するために@code{writefile}の後、
@mref{playback}を実行するのが便利かもしれません。
@code{playback}は入力と出力変数(@code{%i1}, @code{%o1}, など)だけを表示し、
（戻り値と対照的に）関数の中のプリント文によって生成された任意の出力は@code{playback}によって表示されません。

@mref{closefile}は、@code{writefile}や@code{appendfile}が開いたトランスクリプトファイルを閉じます。

@opencatbox
@category{File output}
@category{Console interaction}
@closecatbox
@end deffn