OpenXM/src/asir-doc/parts/builtin/io.texi - diff

Return to io.texi CVS log

Up to [local] / OpenXM / src / asir-doc / parts / builtin

Diff for /OpenXM/src/asir-doc/parts/builtin/io.texi between version 1.1.1.1 and 1.2

version 1.1.1.1, 1999/12/08 05:47:44

version 1.2, 1999/12/21 02:47:33

Line 1

@comment $OpenXM$

\BJP

@node $BF~=PNO(B,,, $BAH$_9~$_H!?t(B

@section $BF~=PNO(B

\BEG

@node Inputs and Outputs,,, Built-in Function

@section Inputs and Outputs

@menu

* end quit::

Line 11

Line 18

* print::

@end menu

@node end quit,,, $BF~=PNO(B

\JP @node end quit,,, $BF~=PNO(B

\EG @node end quit,,, Inputs and Outputs

@subsection @code{end}, @code{quit}

@findex end

@findex quit

@table @t

@item end, quit

\BJP

:: $B8=:_FI$_9~$_Cf$N%U%!%$%k$rJD$8$k(B.

$B%H%C%W%l%Y%k$K$*$$$F$O%;%C%7%g%s$r=*N;$9$k$3$H$K$J$k(B.

\BEG

:: Close the currently reading file.

At the top level, terminate the @b{Asir} session.

@end table

@itemize @bullet

\BJP

@item

@code{end}, @code{quit} $B$H$b$KL50z?t$NH!?t$G$"$k$,(B, @samp{()} $B$J$7$G(B

$B8F$S=P$9$3$H$,$G$-$k(B. $B$$$:$l$b8=:_FI$_9~$_Cf$N%U%!%$%k$rJD$8$k(B.

Line 31

Line 46

$B%U%!%$%k$N>l9g(B, $B%U%!%$%k$N=*C<$^$GFI$a$P(B, $B<+F0E*$K%U%!%$%k$OJD$8$i$l$k(B

$B$,(B, $B%H%C%W%l%Y%k$N>l9g%W%m%s%W%H$,=P$J$$$^$^(B, $BF~NOBT$A$K$J$k$N$G(B,

$B%U%!%$%k$N=*C<$K$O(B @code{end$} $B$r=q$/$N$,K>$^$7$$(B.

\BEG

@item

These two functions take no arguments. These functions can be called

without a @samp{()}. Either function close the current input file.

This means the termination of the @b{Asir} session at the top level.

@item

An input file will be automatically closed if it is read to its end.

However, if no @code{end$} is written at the last of the input file,

the control will be returned to the top level and @b{Asir} will be

waiting for an input without any prompting.

Thus, in order to avoid confusion, putting a @code{end$} at the last

line of the input file is strongly recommended.

@end itemize

@example

Line 39

Line 68

@end example

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

\EG @item References

@fref{load}.

@end table

@node load,,, $BF~=PNO(B

\JP @node load,,, $BF~=PNO(B

\EG @node load,,, Inputs and Outputs

@subsection @code{load}

@findex load

@table @t

@item load("@var{filename}")

:: @var{filename} $B$rFI$_9~$`(B.

\JP :: @var{filename} $B$rFI$_9~$`(B.

\EG :: Read a program file @var{filename}.

@end table

@table @var

@item return

(1|0)

@item filename

$B%U%!%$%kL>(B ($B%Q%9L>(B)

\JP $B%U%!%$%kL>(B ($B%Q%9L>(B)

\EG file (path) name

@end table

@itemize @bullet

\BJP

@item

$B<B:]$N%W%m%0%i%`$N=q$-J}$O(B, @xref{$B%f!<%68@8l(B Asir}.

$B%F%-%9%H%U%!%$%k$rFI$_9~$`>l9g(B, @code{cpp}

Line 73

Line 107

$B%5!<%A$9$k(B. $B$=$l$i$K3:Ev$9$k%U%!%$%k$,B8:_$7$J$$>l9g(B, $BI8=`%i%$%V%i%j(B

$B%G%#%l%/%H%j(B ($B$"$k$$$O4D6-JQ?t(B @code{ASIR_LIBDIR} $B$K@_Dj$5$l$F$$$k(B

$B%G%#%l%/%H%j(B) $B$b%5!<%A$9$k(B.

Windows $BHG$N>l9g(B, @code{ASIR_LIBDIR} $B$,@_Dj$5$l$F$$$J$$>l9g$K$O(B, @code{get_rootdir()/lib}

Windows $BHG$N>l9g(B, @code{ASIR_LIBDIR} $B$,@_Dj$5$l$F$$$J$$>l9g$K$O(B,

$B$r%5!<%A$9$k(B.

@code{get_rootdir()/lib} $B$r%5!<%A$9$k(B.

@item

$BFI$_9~$`%U%!%$%k$N:G8e$K(B, @code{end$} $B$,$J$$$H(B @code{load()}

$B=*N;8e$K%W%m%s%W%H$,$G$J$$$,(B, $B<B:]$K$OF~NO$r<u$1IU$1$k(B. $B$7$+$7(B,

Line 83 Windows $BHG$N>l9g(B, @code{ASIR_LIBDIR} $B$,@_Dj$5

Line 117 Windows $BHG$N>l9g(B, @code{ASIR_LIBDIR} $B$,@_Dj$5

$B$?$a(B, @code{end$} $B$r$*4+$a$9$k(B. )

@item

Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp{/} $B$rMQ$$$k(B.

\BEG

@item

@xref{User language Asir} for practical programming.

Since text files are read through @code{cpp},

the user can use, as in C programs, @code{#include} and @code{#define}

in @b{Asir} program source codes.

@item

It returns 1 if the designated file exists, 0 otherwise.

@item

If the @var{filename} begins with @samp{/}, it is understood as an

absolute path name; with @samp{.}, relative path name from current

directory; otherwise, the file is searched first from directories

assigned to an environmental variable @code{ASIRLOADPATH}, then

if the search ends up in failure, the standard library directory

(or directories assigned to @code{ASIR_LIBDIR}) shall be searched.

On Windows, @code{get_rootdir()/lib} is searched if

@code{ASIR_LIBDIR} is not set.

@item

We recommend to write an @code{end} command at the last line of

your program. If not, @b{Asir} will not give you a prompt after it

will have executed @code{load} command.

(Escape with an interrupt character (@pxref{Interruption}),

if you have lost yourself.)

Even in such a situation,

@b{Asir} itself is still ready to read keyboard inputs as usual.

It is, however, embarrassing and may cause other errors.

Therefore, to put an @code{end$} at the last line is desirable.

(Command @code{end;} will work as well,

but it also returns and displays verbose.)

@item

On Windows one has to use @samp{/} as the separator of directory names.

@end itemize

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

\EG @item References

@fref{end quit}, @fref{which}, @fref{get_rootdir}.

@end table

@node which,,, $BF~=PNO(B

\JP @node which,,, $BF~=PNO(B

\EG @node which,,, Inputs and Outputs

@subsection @code{which}

@findex which

@table @t

@item which("@var{filename}")

:: $B0z?t(B @var{filename} $B$KBP$7(B, @code{load()} $B$,FI$_9~$`%Q%9L>$rJV$9(B.

\JP :: $B0z?t(B @var{filename} $B$KBP$7(B, @code{load()} $B$,FI$_9~$`%Q%9L>$rJV$9(B.

\EG :: This returns the path name for the @var{filename} which @code{load()} will read.

@end table

@table @var

@item return

$B%Q%9L>(B

\JP $B%Q%9L>(B

\EG path name

@item filename

$B%U%!%$%kL>(B ($B%Q%9L>(B) $B$^$?$O(B 0

\JP $B%U%!%$%kL>(B ($B%Q%9L>(B) $B$^$?$O(B 0

\EG filename (path name) or 0

@end table

@itemize @bullet

\BJP

@item

@code{load()} $B$,%U%!%$%k$r%5!<%A$9$k<j=g$K=>$C$F%5!<%A$7(B,

$B%U%!%$%k$,B8:_$9$k>l9g$K$O%Q%9L>$rJ8;zNs$H$7$F(B, $BB8:_$7$J$$>l9g(B

Line 115 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

Line 188 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

$B%5!<%A$N<j=g$K$D$$$F$O(B @code{load()} $B$r;2>H(B.

@item

Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp{/} $B$rMQ$$$k(B.

\BEG

@item

This function searches directory trees according to the same procedure

as @code{load()} will do. Then, returns a string, the path name to the

file if the named file exists; 0 unless otherwise.

@item

For details of searching procedure,

refer to the description about @code{load()}.

@item

On Windows one has to use @samp{/} as the separator of directory names.

@end itemize

@example

Line 127 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

Line 212 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

@end example

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

\EG @item References

@fref{load}.

@end table

@node output,,, $BF~=PNO(B

\JP @node output,,, $BF~=PNO(B

\EG @node output,,, Inputs and Outputs

@subsection @code{output}

@findex output

@table @t

@item output(["@var{filename}"])

:: $B0J9_$N=PNO@h$r(B @var{filename}$B$^$?$OI8=`=PNO$K@ZBX$($k(B.

\JP :: $B0J9_$N=PNO@h$r(B @var{filename}$B$^$?$OI8=`=PNO$K@ZBX$($k(B.

\EG :: Writes the return values and prompt onto file @var{filename}.

@end table

@table @var

@item return

@item filename

$B%U%!%$%kL>(B

\JP $B%U%!%$%kL>(B

\EG filename

@end table

@itemize @bullet

\BJP

@item

@b{Asir} $B$N=PNO$rI8=`=PNO$+$i(B, $B%U%!%$%k$X$N=PNO$K@ZBX$($k(B.

$B$J$*(B, $B%U%!%$%k=PNO$N4V$O(B, $BI8=`=PNO$K$O%-!<%\!<%I$+$i$NF~NO0J30(B,

Line 174 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

Line 264 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

@code{bload()}, @code{bsave()} $B$r;H$&$N$,(B, $B;~4V(B, $B6u4V$H$b$K8zN($,$h$$(B.

@item

Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp{/} $B$rMQ$$$k(B.

\BEG

@item

Standard output stream of @b{Asir} is redirected to the specified file.

While @b{Asir} is writing its outputs onto a file, no outputs, except for

keyboard inputs and some of error messages, are written onto the standard

output. (You cannot see the result on the display.)

@item

To direct the @b{Asir} outputs to the standard output, issue the command

without argument, i.e., @code{output()}.

@item

If the specified file already exists, new outputs will be added to the

tail of the file. If not, a file is newly created and the outputs

will be written onto the file.

@item

When file name is specified without double quotes (@code{""}), or

when protected file is specified, an error occurs and the system returns

to the top level.

@item

If you want to write inputs from the key board onto the file as well

as @b{Asir} outputs, put command @code{ctrl("echo",1)}, and then

redirect the standard output to your desired file.

@item

Contents which are written onto the standard error output, CPU time etc.,

are not written onto the file.

@item

Reading and writing algebraic expressions which contain neither

functional forms nor unknown coefficients (@code{vtype()} References)

are performed more efficiently, with respect to both time and space,

by @code{bload()} and @code{bsave()}.

@item

On Windows one has to use @samp{/} as the separator of directory names.

@end itemize

@example

Line 192 output();

Line 315 output();

@end example

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

\EG @item References

@fref{ctrl}, @fref{bsave bload}.

@end table

@node bsave bload,,, $BF~=PNO(B

\JP @node bsave bload,,, $BF~=PNO(B

\EG @node bsave bload,,, Inputs and Outputs

@subsection @code{bsave}, @code{bload}

@findex bsave

@findex bload

@table @t

@item bsave(@var{obj},"@var{filename}")

:: @var{filename} $B$K(B @var{obj} $B$r%P%$%J%j7A<0$G=q$-9~$`(B.

\JP :: @var{filename} $B$K(B @var{obj} $B$r%P%$%J%j7A<0$G=q$-9~$`(B.

\EG :: This function writes @var{obj} onto @var{filename} in binary form.

@item bsave("@var{filename}")

:: @var{filename} $B$+$i?t<0$r%P%$%J%j7A<0$GFI$_9~$`(B.

\JP :: @var{filename} $B$+$i?t<0$r%P%$%J%j7A<0$GFI$_9~$`(B.

\EG :: This function reads an expression from @var{filename} in binary form.

@end table

@table @var

@item return

@code{bsave()} : 1, @code{bload()} : $BFI$_9~$s$@?t<0(B

\JP @code{bsave()} : 1, @code{bload()} : $BFI$_9~$s$@?t<0(B

\EG @code{bsave()} : 1, @code{bload()} : the expression read

@item obj

$BH!?t7A<0(B, $BL$Dj78?t$r4^$^$J$$G$0U$N?t<0(B

\JP $BH!?t7A<0(B, $BL$Dj78?t$r4^$^$J$$G$0U$N?t<0(B

\BEG

arbitrary expression which does not contain neither function forms

nor unknown coefficients.

@item filename

$B%U%!%$%kL>(B

\JP $B%U%!%$%kL>(B

\EG filename

@end table

@itemize @bullet

\BJP

@item

@code{bsave()} $B$OFbIt7A<0$r$[$\$=$N$^$^%P%$%J%j7A<0$G%U%!%$%k$K=q$-9~$`(B.

@code{bload()} $B$O(B, @code{bsave()} $B$G=q$-9~$s$@?t<0$rFI$_9~$s$GFbIt7A<0(B

Line 233 output();

Line 367 output();

$B$=$N>l9g$K$O(B, $B<+F0E*$K8=:_$NJQ?t=g=x$K$*$1$kFbIt7A<0$KJQ49$5$l$k(B.

@item

Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp{/} $B$rMQ$$$k(B.

\BEG

@item

Function @code{bsave()} writes an object onto a file in its internal

form (not exact internal form but very similar).

Function @code{bload()} read the expression from files

which is written by @code{bsave()}.

Current implementation support arbitrary expressions, including

lists, arrays (i.e., vectors and matrices), except for function forms

and unknown coefficients (@code{vtype()} References.)

@item

The parser is activated to retrieve expressions written by

@code{output()} , whereas internal forms are directly reconstructed

by @code{bload()} from the @code{bsave()}'ed object in the file.

The latter is much more efficient with respect to both time and space.

@item

It may happen that the variable ordering at reading is changed from

that at writing. In such a case, the variable ordering in the internal

expression is automatically rearranged according to the current

variable ordering.

@item

On Windows one has to use @samp{/} as the separator of directory names.

@end itemize

@example

Line 253 y^2+2*x*y+x^2

Line 410 y^2+2*x*y+x^2

@end example

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

\EG @item References

@fref{output}.

@end table

@node bload27,,, $BF~=PNO(B

\JP @node bload27,,, $BF~=PNO(B

\EG @node bload27,,, Inputs and Outputs

@subsection @code{bload27}

@findex bload27

@table @t

@item xxx(@var{filename})

:: $B5lHG$G:n$i$l$?(B bsave file $B$NFI$_9~$_(B

\JP :: $B5lHG$G:n$i$l$?(B bsave file $B$NFI$_9~$_(B

\EG :: Reads bsaved file created by older version of @b{Asir}.

@end table

@table @var

@item return

$BFI$_9~$s$@?t<0(B

\JP $BFI$_9~$s$@?t<0(B

\EG expression read

@item filename

$B%U%!%$%kL>(B

\JP $B%U%!%$%kL>(B

\EG filename

@end table

@itemize @bullet

\BJP

@item

$B5lHG$G$O(B, $BB?G\D9@0?t$,(B, 1 $B%o!<%I(B 27 bit $B$GI=8=$5$l$F$$$?$,(B, $B?7HG$G$O(B 1 $B%o!<%I(B 32 bit

$B$KJQ99$5$l$?(B. $B$3$N$?$a(B, $B5lHG$G(B @code{bsave} $B$5$l$?%P%$%J%j%U%!%$%k$O$=$N$^$^$G$O(B

$BFI$_9~$a$J$$(B. $B$3$N$h$&$J%U%!%$%k$rFI$_9~$`$?$a$K(B @code{bload27} $B$rMQ$$$k(B.

@item

Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp{/} $B$rMQ$$$k(B.

\BEG

@item

In older versions an arbitrary precision integer is represented as

an array of 27bit integers. In the current version it is represented

as an array of 32bit integers. By this incompatibility the bsaved

file created by older versions cannot be read in the current version

by @code{bload}.

@code{bload27} is used to read such files.

@item

On Windows one has to use @samp{/} as the separator of directory names.

@end itemize

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

\EG @item References

@fref{bsave bload}.

@end table

@node print,,, $BF~=PNO(B

\JP @node print,,, $BF~=PNO(B

\EG @node print,,, Inputs and Outputs

@subsection @code{print}

@findex print

@table @t

@item print(@var{obj} [,@var{nl}])

:: @var{obj} $B$rI=<($9$k(B.

\JP :: @var{obj} $B$rI=<($9$k(B.

\EG :: Displays (or outputs) @var{obj}.

@end table

@table @var

@item return

@item obj

$BG$0U(B

\JP $BG$0U(B

\EG arbitrary

@item nl

$B%U%i%0(B ($BG$0U(B)

\JP $B%U%i%0(B ($BG$0U(B)

\EG flag (arbitrary)

@end table

@itemize @bullet

\BJP

@item

@var{obj} $B$rI>2A$7$FI=<($9$k(B.

@item

Line 319 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

Line 500 Windows $BHG$b%G%#%l%/%H%j$N%;%Q%l!<%?$H$7$F(B @samp

@code{print()$} $B$H$9$l$P(B, $B:G8e$N(B 0 $B$O=PNO$5$l$J$$(B.

@item

$BJ#?t$N(B @var{obj} $B$rF1;~$K=PNO$7$?$$;~$O(B @var{obj} $B$r%j%9%H$K$9$k$H$h$$(B.

\BEG

@item

Displays (or outputs) @var{obj}.

@item

It normally adds linefeed code to cause the cursor moving to the next

line. If 0 or 2 is given as the second argument, it does not add a linefeed.

If the second argument is 0, the output is simply written in the buffer.

If the second argument is 2, the output is flushed.

@item

The return value of this function is 0.

If command @code{print(@var{rat});} is performed at the top level,

first the value of @var{rat} will be printed,

followed by a linefeed, followed by a 0 which is the value of the

function and followed by a linefeed and the next prompt.

(If the command is terminated by a `$', e.g., @code{print(@var{rat})$},

The last 0 will not be printed. )

@item

Formatted outputs are not currently supported.

If one wishes to output multiple objects by a single @code{print()} command,

use list like @code{[@var{obj1,...}]}, which is not so beautiful, but

convenient to minimize programming efforts.

@end itemize

@example

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>