File: x809.html

package info (click to toggle)
gambit-doc 0.97.0-1
links: PTS
area: main
in suites: etch, etch-m68k, lenny, sarge, squeeze
size: 1,344 kB
sloc: makefile: 19; sh: 10
file content (1884 lines) | stat: -rw-r--r-- 32,949 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<HTML
><HEAD
><TITLE
>Functions</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.59"><LINK
REL="HOME"
TITLE="Gambit"
HREF="gambit.html"><LINK
REL="UP"
TITLE="The Gambit Command Language"
HREF="c524.html"><LINK
REL="PREVIOUS"
TITLE="Expressions"
HREF="x799.html"><LINK
REL="NEXT"
TITLE="Getting and suppressing console output"
HREF="x1198.html"></HEAD
><BODY
CLASS="SECT1"
BGCOLOR="#FFFFFF"
TEXT="#000000"
LINK="#0000FF"
VLINK="#840084"
ALINK="#0000FF"
><DIV
CLASS="NAVHEADER"
><TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TH
COLSPAN="3"
ALIGN="center"
>Gambit: Software Tools for Game Theory</TH
></TR
><TR
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="bottom"
><A
HREF="x799.html"
>&#60;&#60;&#60; Previous</A
></TD
><TD
WIDTH="80%"
ALIGN="center"
VALIGN="bottom"
>The Gambit Command Language</TD
><TD
WIDTH="10%"
ALIGN="right"
VALIGN="bottom"
><A
HREF="x1198.html"
>Next &#62;&#62;&#62;</A
></TD
></TR
></TABLE
><HR
ALIGN="LEFT"
WIDTH="100%"></DIV
><DIV
CLASS="SECT1"
><H1
CLASS="SECT1"
><A
NAME="AEN809"
>Functions</A
></H1
><P
>Functions in the GCL are rules for taking objects of specified data
types, and using them to construct and return an object of a (possibly
different) specified data type.  All statements in the GCL are built
up out of function calls.  In this section, we desribe the rules for
using functions in the GCL.</P
><P
>A function call consists of the name of a function followed (if the
function has parameters) by a list of parameters to the function,
enclosed in brackets.  Functions return a value, which may in turn
be used as a parameter to another function call, allowing more complex
computations to be expressed.</P
><P
>Functions in the GCL can be either built-in or user defined.  Also
functions can either require arguments or not.  This leads to four
combinations.  We label these as follows
<DIV
CLASS="TABLE"
><A
NAME="AEN814"
></A
><P
><B
>Table 3. Function types</B
></P
><TABLE
BORDER="1"
BGCOLOR="#E0E0E0"
CELLSPACING="0"
CELLPADDING="4"
CLASS="CALSTABLE"
><THEAD
><TR
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Description</TH
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Built-in</TH
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Parameters</TH
></TR
></THEAD
><TBODY
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Constant</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Yes</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>No</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Built-in Function</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Yes</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Yes</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Variable</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>No</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>No</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
>User-defined Function</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>No</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>Yes</TD
></TR
></TBODY
></TABLE
></DIV
></P
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN839"
>Constants</A
></H2
><P
>The simplest type of a function in the GCL is a constant.  A constant
is a built-in function that has no arguments, and returns the same
value whenever it is called.  How to construct constants for the basic
data types is described in the section on data types.  Some examples
of constants follow:
<DIV
CLASS="TABLE"
><A
NAME="AEN842"
></A
><P
><B
>Table 4. Constants</B
></P
><TABLE
BORDER="1"
BGCOLOR="#E0E0E0"
CELLSPACING="0"
CELLPADDING="4"
CLASS="CALSTABLE"
><THEAD
><TR
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Data type</TH
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Constant</TH
></TR
></THEAD
><TBODY
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><SPAN
CLASS="TYPE"
>BOOLEAN</SPAN
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>True, False</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><SPAN
CLASS="TYPE"
>NUMBER</SPAN
> (rational precision)</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>1, -1234567/563</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><SPAN
CLASS="TYPE"
>NUMBER</SPAN
> (float precision)</TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>1., -1.234567</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><SPAN
CLASS="TYPE"
>TEXT</SPAN
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>"Hello, world!"</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><SPAN
CLASS="TYPE"
>OUTPUT</SPAN
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>StdOut, NullOut</TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><SPAN
CLASS="TYPE"
>INPUT</SPAN
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
>StdIn</TD
></TR
></TBODY
></TABLE
></DIV
></P
><P
>You typically don't think of a constant as a function, but it is.  It
is a function with no arguments, whose name is the constant itself.
You can ``execute'' a constant by simply typing its name.  When you do
so, it returns a value, corresponding to the object that the constant
represents.  </P
><P
>You are now ready to write your first GCL program:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>GCL1:= &#60;&#60; "Hello, world!"
"Hello, world!"</PRE
></TD
></TR
></TABLE
></P
><P
>It is important to note that like all functions in the GCL, constants
have a data type, which is determined by the function name.  If
you try and use a <SPAN
CLASS="TYPE"
>NUMBER</SPAN
> constant, say <TT
CLASS="LITERAL"
>123</TT
>, where a
<SPAN
CLASS="TYPE"
>TEXT</SPAN
> or other data type is expected, you will get an error.</P
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN881"
>Variables</A
></H2
><P
>A variable is like a constant in that it has no arguments.  It stores
one object of a particular data type, and returns it when called. The
difference between a constant and a variable is that a variable must
be created before it can be used, and once it is created, it can be
deleted or redefined if you want.  To create a new variable, or to
redefine an existing variable, one can use the built-in function,
<TT
CLASS="FUNCTION"
>Assign</TT
>, which has the prototype:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Assign[name-&#62;TEXT, value&#60;-&#62;T] =: T</PRE
></TD
></TR
></TABLE
>
for any type <SPAN
CLASS="TYPE"
>T</SPAN
>.  (How to read a function's prototype is
described in more detail in the section of function calls.  For now,
suffice it to say that <TT
CLASS="FUNCTION"
>Assign</TT
> takes two parameters, the first of
which is the name of the variable, and the second of which is the
value to be assigned to the variable.)  The variable name can be any
string of alphanumeric characters (<TT
CLASS="LITERAL"
>a-z</TT
>, <TT
CLASS="LITERAL"
>A-Z</TT
>, or
<TT
CLASS="LITERAL"
>0-9</TT
>) beginning with a letter.  So, to create a variable with
name <TT
CLASS="LITERAL"
>x</TT
> which returns the <SPAN
CLASS="TYPE"
>NUMBER</SPAN
> <TT
CLASS="LITERAL"
>1</TT
>, we can use
<TT
CLASS="FUNCTION"
>Assign</TT
> as follows:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>GCL1:= &#60;&#60; Assign["x",1]
1</PRE
></TD
></TR
></TABLE
>
The <TT
CLASS="FUNCTION"
>Assign</TT
> function also has an infix operator form, written
<TT
CLASS="LITERAL"
>:=</TT
>.  In this form, the quotes are not needed around the variable
name, and the function is not ``listable'' (see the section on Lists,
later in this chapter).  So, equivalently, and more compactly,
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>GCL1:= &#60;&#60; x := 1
1</PRE
></TD
></TR
></TABLE
></P
><P
>The <TT
CLASS="FUNCTION"
>Assign</TT
> function can be used to either create a new variable or
modify an existing one.  However, it cannot be used to change the type
of a variable.  Consider the sequence
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>y:=2
y:=3
y:="3"</PRE
></TD
></TR
></TABLE
>
The first call creates a new variable <TT
CLASS="LITERAL"
>y</TT
> of type 
<SPAN
CLASS="TYPE"
>NUMBER</SPAN
>, with value of <TT
CLASS="LITERAL"
>2</TT
>.
The second modifies \verb+y+ to
have value <TT
CLASS="LITERAL"
>3</TT
>.  Since the new assignment does not change the
type of \verb+y+, this command is fine.  The third statement attempts
to change the data type of \verb+y+.  This statement will result in an
error, since <TT
CLASS="FUNCTION"
>Assign</TT
> cannot be used to change the type of a
variable.  To change the data type of a variable, it must first be
deleted, and then reassigned.  </P
><P
>An existing variable may be deleted by the use of the 
<TT
CLASS="FUNCTION"
>UnAssign</TT
>
function, with the following prototype:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>UnAssign[name-&#62;TEXT] =: BOOLEAN</PRE
></TD
></TR
></TABLE
>
After <TT
CLASS="FUNCTION"
>UnAssign</TT
> is called on a variable, the variable
is no longer defined.  A subsequent call of <TT
CLASS="FUNCTION"
>Assign</TT
>
may redefine
the variable to be of any type.  <TT
CLASS="FUNCTION"
>UnAssign</TT
> has a short form of
<TT
CLASS="LITERAL"
>:=</TT
> followed immediately by a linefeed or semicolon.  Hence, if
\verb+y+ is a variable of type <SPAN
CLASS="TYPE"
>BOOLEAN</SPAN
> you can change it to
<SPAN
CLASS="TYPE"
>NUMBER</SPAN
> with value <TT
CLASS="LITERAL"
>3.0</TT
> in two steps as follows:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>y:=
y:= 3.0</PRE
></TD
></TR
></TABLE
></P
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="AEN918"
>Global and static variables</A
></H3
><P
>Variables in the GCL are by default only visible in the the part of
the program in which they are defined.  In otherwords, a variable
defined outside of a function will not be visible inside a GCL
function (unless it is passed by reference), and a variable defined in
a function will not be visible from outside the function.  Secondly,
variables defined inside a function are deallocated when control
leaves the function.  Thus, when a function is called a second time,
variables defined within that function will not ``remember'' the
values they were assigned in the last call to the function.  </P
><P
>To modify the default scope and visibility of variables, the GCL uses
the prefix <TT
CLASS="LITERAL"
>$</TT
> in a variable name to represent a ``static''
variable and the prefix <TT
CLASS="LITERAL"
>$$</TT
> to represent
a global variable.  A static variable
is only visible in the function in which it is defined, but remains
allocated after program control leaves the function, and retains its
last value when the function is called again.  A global variable
remains allocated and visible when control passes to any function.  The
following example illustrates the use of static variables:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>NewFunction[Foo[x-&#62;NUMBER]=:NUMBER,If[!IsDefined[$y],$y:=x];$y;];
GCL2:= &#60;&#60; Foo[3]
3
GCL3:= &#60;&#60; Foo[2]
3</PRE
></TD
></TR
></TABLE
>
and the following illustrates the use of global variables:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>$$x:=5
NewFunction[Foo[],$$x;];
GCL1:= &#60;&#60; Foo[]
5</PRE
></TD
></TR
></TABLE
></P
></DIV
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN926"
>Built-in functions</A
></H2
><P
>Built-in functions in the GCL are just like the mathematical notion of
a function.  They are rules which associate with each point in the  
domain, a point in the range.  In the case of the GCL functions, each
function has a list of arguments.  Each argument must be of a specific
data type.  A point in the domain is specified by specifying a value
of the correct data type for each argument of the function.  </P
><P
>To execute a GCL function you write the function name, followed
(if the function is not a constant) by a comma separated list of the
arguments, enclosed in square brackets.  </P
><P
>All of the built-in functions in the GCL are listed in the Function
Reference section of the manual.  For each function, the function
prototype is listed.  The function prototype is a template that is
used to remind you of the correct syntax for each function.  </P
><P
>A function call consists of the name of a function, and a list of
parameters upon which the function is to operate.  Functions return a
value, which may in turn be used as a parameter to another function
call, allowing more complex computations to be expressed.</P
><P
>A simple example of a function call is
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[x-&#62;1, y-&#62;2]</PRE
></TD
></TR
></TABLE
>

This calls the function named <TT
CLASS="FUNCTION"
>Plus</TT
>, 
with parameter \verb+x+ set
to the value 1 and \verb+y+ set to the value 2.  Since <TT
CLASS="FUNCTION"
>Plus</TT
> is
the function for addition of two integers, the value returned would
be, as you might expect, 3.</P
><P
>In the addition example above, we called a function which is listed in
the function reference as
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[x-&#62;NUMBER, y-&#62;NUMBER] =: NUMBER</PRE
></TD
></TR
></TABLE
>
This listing of a function is called its {\it prototype}.  
It contains the function's name, its list of parameters, and its return
value.  In this case, the function <TT
CLASS="FUNCTION"
>Plus</TT
> takes two
parameters, the
first named \verb+x+ and taking a value of type <SPAN
CLASS="TYPE"
>NUMBER</SPAN
> and the
second named \verb+y+ and taking a value of type <SPAN
CLASS="TYPE"
>NUMBER</SPAN
>, and
returns a value of type <SPAN
CLASS="TYPE"
>NUMBER</SPAN
>.</P
><P
>Because the parameters have explicit names, it is possible to rearrange
the order in which parameters are listed when a function is called.
Thus, we could write out sample call equivalently as
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[y-&#62;2, x-&#62;1]</PRE
></TD
></TR
></TABLE
>
and achieve the same effect.</P
><P
>Explicitly specifying the formal names for parameters all the time
will prove tedious and can hinder readability.  For these reasons, it is
also legal to specify parameters without their associated formal names.
These are called passing {\it anonymous} parameters.  Our addition
example could thus also be written
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[1, 2]</PRE
></TD
></TR
></TABLE
></P
><P
>When used without specifying the formal names, however, function
calls are restricted to specifying parameters in exactly the same
order as listed in the function prototype.  In our example, the GCL
interpreter would have no way of distinguishing whether we meant 1 to
be the value of \verb+x+ or the value of \verb+y+, and vice versa.
While in the case of addition we may flip the values of the parameters
without having an effect on the result, in general this is not the
case.</P
><P
>It is permitted to mix the two styles of parameter specification,
subject to the following rules:

\begin{itemize}
\item All anonymous parameters must be specified before any named
parameters
\item No parameters may be omitted in the anonymous parameter list.
If $k$ parameters are specified anonymously, they must match
one-for-one the first $k$ parameters in the function's prototype.
\item Once a named parameter has been specified, all succeeding
parameters must be named, even if the first named parameter appeared
in the same place in the parameter list as it does in the prototype.
\end{itemize}

\noindent Therefore, it would be legal to write
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[1, y-&#62;2]</PRE
></TD
></TR
></TABLE
>
but
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[x-&#62;1, 2]</PRE
></TD
></TR
></TABLE
>
is illegal since it violates the third condition.</P
><P
>To be more precise, the function <TT
CLASS="FUNCTION"
>Plus</TT
> comes in several different
variations listed in the function reference:

\begin{verbatim}
Plus[x-&#62;NUMBER, y-&#62;NUMBER] =: NUMBER
Plus[x-&#62;TEXT, y-&#62;TEXT] =: TEXT
Plus[x-&#62;MIXED, y-&#62;MIXED] =: MIXED
Plus[x-&#62;BEHAV, y-&#62;BEHAV] =: BEHAV 
\end{verbatim}
This is an example of function {\it overloading}.  This
means that one function name may have several possible parameter
lists, sometimes called {\it signatures}.  The GCL interpreter is
capable of determining which version of the function to use by
analyzing the names and types of the parameters used.</P
><P
>Since a function may have multiple signatures, it is conceivable that
a function call might be ambiguous, in the sense that its parameters
match more than one signature for that function.  However, no function
call that is complete may be ambiguous from the way that signatures
have been chosen for the predefined functions.  Any function call
flagged by the interpreter as ambiguous must be missing at least one
parameter.</P
><P
>Some functions have parameters which are optional, in the sense that
they need not be specified in order to call the function.  These
parameters are indicated in the function's prototype by being
surrounded by curly braces.  (Note that these braces should not be
included in the function call when specifying an optional parameter.)
If an optional parameter is left unspecified in a function call, a
default value is assumed, as given in the function's documentation.</P
><P
>For a function, all required parameters always precede any optional
parameters.  Optional parameters may also be specified anonymously,
subject to the above rules on parameter specification.</P
><P
>All parameters so far have been passed by {\it value}, that is, a copy
of the value of the parameter is given to the function to which it is
passed.  These parameters may not be modified by the function.  It is
also possible to have parameters to a function passed by {\it
reference}.  This means that the function does not receive a copy of
the value, but rather the memory location of the value itself.  Thus,
the function may modify the value of a parameter passed by reference.</P
><P
>The symbol for passing a parameter by reference, both in a function's
prototype and in a function call, is <TT
CLASS="LITERAL"
>&#60;-&#62;</TT
>.  Constants may not be
passed by reference.  Reference parameters may be specified
anonymously just like a value parameter, subject to the usual rules.
It is a run-time error to attempt to pass a value to a reference
parameter, or vice versa.</P
><P
>In the case where functions have parameters which are subtypes, 
it is preferred to match to the subtype over the parent type.  For example,
suppose the following two signatures have been defined:

\begin{verbatim}
Foo[x-&#62;INTEGER] =: INTEGER
Foo[x-&#62;NUMBER] =: NUMBER
\end{verbatim}

Then, a call of <TT
CLASS="LITERAL"
>Foo[3]</TT
> resolves to the first signature (since the
value passed is an integer), and <TT
CLASS="LITERAL"
>Foo[3.5]</TT
>
resolves to the second
(since it is a number, but not specifically an integer).</P
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN961"
>User-defined functions</A
></H2
><P
>As GCL programs become more and more complex, frequently there are
complicated operations which must be performed repeatedly.  The
command language therefore supports user-defined functions, which
allow for defining sections of code which may be called later.</P
><P
>A new function can be created using the function <TT
CLASS="FUNCTION"
>NewFunction</TT
>.
For example, one might define a function to compute the absolute value
of an <SPAN
CLASS="TYPE"
>NUMBER</SPAN
> 
as such:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>NewFunction[Abs[n-&#62;NUMBER],
  If[n &#62; 0, n, If[n &#60; 0, -n, 0]];
];</PRE
></TD
></TR
></TABLE
>
After defining the <TT
CLASS="FUNCTION"
>Abs</TT
> function, it may be called in
exactly the same way a system-supplied predefined function may.  The
return value of the function is the value of the last statement
executed.</P
><P
>Parameter type matching rules apply to user defined functions in
exactly the same way as to predefined functions.  From the function's
point of view, the parameter list is a list of variables on which
assignments are automatically done at the beginning of the function
execution.  So, taking the <TT
CLASS="FUNCTION"
>Abs</TT
> example above, in executing the
call
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Abs[42]</PRE
></TD
></TR
></TABLE
>

\noindent an assignment \verb+n := 42+ is implicitly performed before
the body of the function is executed.</P
><P
>It is also possible to pass variables by ``reference'' to a
user-defined function in the same way as a predefined function.  In
this case, the function's ``local'' variable is stored in the same
physical location in the computer, and modifying the value locally
also takes effect on the variable passed to the function.  For
example, it might be useful instead to define \verb+Abs+ as:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>NewFunction[Abs[n&#60;-&#62;NUMBER],
		 If[n &#62; 0, n, If[n &#60; 0, n := -n, 0]]]</PRE
></TD
></TR
></TABLE
>
in which case the function would still return the absolute
value of \verb+n+, but also modify the variable passed to \verb+n+ to
be the absolute value of the input \verb+n+.  So,
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>q := -37;
Abs[q]</PRE
></TD
></TR
></TABLE
>
would result in the variable \verb+q+ containing the value
37 at the conclusion of execution.</P
><P
>Each function has its own ``scope'', or set of variables.  Within a
function body, the only variables which are visible are those which
are declared in the parameter list of the function (this is \verb+n+
in the <TT
CLASS="FUNCTION"
>Abs</TT
> example above), and those which are created during
the function's execution.  That is, no ``global'' or outside variables
may be accessed directly by the function.  For example, if the user
typed in the following:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>i := 4;
NewFunction[FooFunc[x-&#62;NUMBER], x * i]</PRE
></TD
></TR
></TABLE
>
later execution of the <TT
CLASS="FUNCTION"
>FooFunc</TT
> would yield an
``undefined variable i'' error message, since \verb+i+ is never
defined within the function.  If instead <TT
CLASS="FUNCTION"
>FooFunc</TT
> had been
defined as follows:
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>NewFunction[FooFunc[x-&#62;NUMBER], i := 13, x * i]</PRE
></TD
></TR
></TABLE
>
<TT
CLASS="FUNCTION"
>FooFunc</TT
> would always return 13 times the value of the
parameter \verb+x+, since the value of \verb+i+ inside <TT
CLASS="FUNCTION"
>FooFunc</TT
> is always 13, regardless of the value of \verb+i+ outside of the
function.</P
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN983"
>Aliases for function calls</A
></H2
><P
>There are several functions which are so commonly used that special
``short forms'' are defined for them.  We already saw one example with
the function <TT
CLASS="FUNCTION"
>Assign</TT
>, which has the short form
<TT
CLASS="LITERAL"
>:=</TT
>.  Most
functions with short forms are the standard arithmetic and logic
operators, for which the usual binary infix or unary prefix notations
are supported.  The example of addition used in a previous section may
more familiarly be written
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>1 + 2</PRE
></TD
></TR
></TABLE
>
which expression is converted to the ``long form'' function
call by the interpreter.  Note that formal names may not be specified
in a ``short form'' call, and the order of parameters is therefore
significant.</P
><P
>Here is a list of the functions thus abbreviated, and their ``short
form'' equivalents:

<DIV
CLASS="TABLE"
><A
NAME="AEN990"
></A
><P
><B
>Table 5. Operators in GCL</B
></P
><TABLE
BORDER="1"
BGCOLOR="#E0E0E0"
CELLSPACING="0"
CELLPADDING="4"
CLASS="CALSTABLE"
><THEAD
><TR
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Function</TH
><TH
ALIGN="LEFT"
VALIGN="TOP"
>Operator(s)</TH
></TR
></THEAD
><TBODY
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>And[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#38;&#38; y</TT
>, <TT
CLASS="LITERAL"
>x AND y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Assign[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x := y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Concat[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#38; y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Divide[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x / y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Dot[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x . y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Equal[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x = y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Greater[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#62; y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>GreaterEqual[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#62;= y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>IntegerDivide[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x DIV y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Less[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#60; y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>LessEqual[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#60;= y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Minus[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x - y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Modulus[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x &#38; y</TT
>, <TT
CLASS="LITERAL"
>x MOD y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Not[x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>NOT x</TT
>, <TT
CLASS="LITERAL"
>!x</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>NotEqual[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x != y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>NthChar[text,n]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>text[[n]]</TT
>, <TT
CLASS="LITERAL"
>text_n</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>NthChild[node,n]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>node#n</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>NthElement[list,n]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>list[[n]]</TT
>, <TT
CLASS="LITERAL"
>list_n</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Or[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x || y</TT
>, <TT
CLASS="LITERAL"
>x OR y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Parentheses[x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>(x)</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Plus[x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x + y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Power[x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x ^ y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Print[x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>&#60;&#60; x</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Read[in,x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>in &#62;&#62; x</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Times[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x * y</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>UnAssign[x,y]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>x :=</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="FUNCTION"
>Write[out,x]</TT
></TD
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>out &#60;&#60; x</TT
></TD
></TR
></TBODY
></TABLE
></DIV
></P
><P
>When functions are written in their canonical forms, no ambiguity
arises in the order of evaluation: In order to evaluate a function,
all arguments must be evaluated first.  Arguments are evaluated from
left-to-right as specified in the function call.  This leads to a
recursive structure of evaluation, which stops only when an argument
being evaluated is a constant function (i. e., a function with no
arguments).</P
><P
>When short form forms are used, then ambiguity can arise in the
intended order of evaluation.  For example, the statement \verb &#38; a + b * c&#38; , 
could be meant as \verb+Plus[a,Times[b,c]]+ or as
\verb+Times[Plus[a,b],c]+.  In order to resolve such ambiguities, all
functions that have a short form representation are given an order of
precedence.  When a statement is parsed by the GCL, it is first
scanned from left to right, replacing each short form expression at
the top level of precedence with its canonical form.  Then it is
scanned again replacing each short form expression at the second level
of precedence with its canonical form, and so on, until all short form
expressions have been eliminated.</P
><P
>The order of precedence for built-in functions is as follows:

<DIV
CLASS="TABLE"
><A
NAME="AEN1142"
></A
><P
><B
>Table 6. Order of precedence</B
></P
><TABLE
BORDER="1"
BGCOLOR="#E0E0E0"
CELLSPACING="0"
CELLPADDING="4"
CLASS="CALSTABLE"
><TBODY
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>()</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>:=</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>&#62;&#62;</TT
> <TT
CLASS="LITERAL"
>&#60;&#60;</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>||</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>&#38;&#38;</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>NOT</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>=</TT
> <TT
CLASS="LITERAL"
>!=</TT
>
            <TT
CLASS="LITERAL"
>&#60;</TT
> <TT
CLASS="LITERAL"
>&#60;=</TT
>
            <TT
CLASS="LITERAL"
>&#62;</TT
> <TT
CLASS="LITERAL"
>&#62;=</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>+</TT
> <TT
CLASS="LITERAL"
>-</TT
> <TT
CLASS="LITERAL"
>&#38;</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>*</TT
> <TT
CLASS="LITERAL"
>.</TT
>
            <TT
CLASS="LITERAL"
>/</TT
> <TT
CLASS="LITERAL"
>DIV</TT
>
            <TT
CLASS="LITERAL"
>MOD</TT
> <TT
CLASS="LITERAL"
>^</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
>(unary) <TT
CLASS="LITERAL"
>+</TT
> <TT
CLASS="LITERAL"
>-</TT
></TD
></TR
><TR
><TD
ALIGN="LEFT"
VALIGN="TOP"
><TT
CLASS="LITERAL"
>[[ ]]</TT
> <TT
CLASS="LITERAL"
>_</TT
></TD
></TR
></TBODY
></TABLE
></DIV
>
Thus, the statement \verb &#38; a + b * c&#38; would become 
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Plus[a,b*c]
Plus[a,Times[b,c]]</PRE
></TD
></TR
></TABLE
>
On the other hand, the statement \verb&#38;( a + b ) * c&#38; would become 
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Parentheses[a+b]*c
Parentheses[Plus[a,b]]*c
Times[Parentheses[Plus[a,b]],c]</PRE
></TD
></TR
></TABLE
>
which, since <TT
CLASS="FUNCTION"
>Parentheses</TT
> is just the identity mapping, is
equivalent to
<TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Times[Plus[a,b],c]</PRE
></TD
></TR
></TABLE
></P
></DIV
></DIV
><DIV
CLASS="NAVFOOTER"
><HR
ALIGN="LEFT"
WIDTH="100%"><TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
><A
HREF="x799.html"
>&#60;&#60;&#60; Previous</A
></TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="gambit.html"
>Home</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
><A
HREF="x1198.html"
>Next &#62;&#62;&#62;</A
></TD
></TR
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
>Expressions</TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="c524.html"
>Up</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
>Getting and suppressing console output</TD
></TR
></TABLE
></DIV
></BODY
></HTML
>