- !
(syntax)
Suffix character for
destructive operations.
- ,
(syntax)
a separator for items in a
tuple, e.g. to separate arguments of a function
f(x, y)
.
- =>
(syntax)
the expression
a => b
is equivalent to
if a then
exit
b
.
- ?
-
(syntax)
a suffix character for
Boolean-valued function
names,
e.g. odd?
.
-
Suffix character for pattern variables.
- The special type
?
means
don't care
. For example, the declaration
x : Polynomial ?
means that
values assigned to x
must be polynomials over
an arbitrary underlying domain.
- abstract datatype
a programming language principle used in Axiom where a datatype is
defined in two parts: (1) a
public
part
describing a set of exports, principally operations
that apply to objects of that type, and (2) a
private
part describing the implementation of
the datatype usually in terms of a representation for
objects of the type. Programs which create and otherwise manipulate objects
of the type may only do so through its exports. The representation and
other implementation information is specifically hidden.
- abstraction
described functionally or conceptually without regard to implementation
- accuracy
the degree of exactness of an approximation or measurement. In computer
algebra systems, computations are typically carried out with complete
accuracy using integers or rational numbers of indefinite size. Domain
Float
provides a function
precision
from
Float
to change the precision for floating point
computations. Computations using DoubleFloat
have a fixed precision but uncertain accuracy.
- add-chain
a hierarchy formed by domain extensions. If domain
A
extends domain B
and
domain B
extends domain C
,
then A
has add-chain
B
-C
.
- aggregate
a data structure designed to hold multiple values. Examples of aggregates
are
List
, Set
,
Matrix
and Bits
.
- AKCL
Austin Kyoto Common LISP, a version of
KCL
produced by
William Schelter, Austin, Texas.
- algorithm
a step-by-step procedure for a solution of a problem; a program
- ancestor
(of a domain) a category which is a parent of the
domain, or a parent of a
parent and so on.
- application
(syntax)
an expression denoting "application"
of a function to a set of argument parameters.
Applications are written as a parameterized form.
For example, the form f(x, y)
indicates the
"application of the function f
to the tuple of
arguments x
and y
".
See also evaluation and
invocation.
- apply
See application.
- argument
-
(actual argument) a value passed to a function at the time of a
function call application; also called an
actual parameter
.
-
(formal argument) a variable used in the definition of a function
to denote the actual argument passed when the function is called.
- arity
-
(function) the number of arguments.
-
(operator or operation) corresponds to the arity of a function
implementing the operator or operation.
- assignment
(syntax)
an expression of the form
x := e
, meaning "assign the value of
e
to x"
. After
evaluation, the variable
x
pointer to an object
obtained by evaluating the expression e
. If
x
has a type as a result
of a previous declaration, the object assigned to
x
must have that type. An interpreter must often
coercion the value of e
to make that happen. For example, in the interpreter,
x : Float := 11
first
declaration x
to be a float.
This declaration causes the interpreter to coerce 11 to 11.0 in order to
assign a floating point value to x
.
- attribute
a name or functional form denoting
any
useful
computational property. For example,
asserts that "*
is commutative". Also,
finiteAggregate
is used to assert that an
aggregate has a finite number of immediate components.
- basis
(algebra)
S
is a
basis of a module M
over a
ring if S
generates
M
, and S
is linearly
independent
- benefactor
(of a given domain) a domain or package that the given domain explicitly
references (for example, calls functions from) in its implementation
- binary
operation or function with arity 2
- binding
the association of a variable with properties such as
value and type. The
top-level environment in the interpreter consists
of bindings for all user variables and functions. Every
function has an associated set of bindings, one
for each formal argument and
local variable.
- block
(syntax)
a control structure where
expressions are sequentially evaluation.
- body
a function body or loop body.
- boolean
objects denoted by the literals
true
and false
;
elements of domain Boolean
.
See also Bits
.
- built-in function
a function in the standard Axiom library.
Contrast user function.
- cache
-
(noun) a mechanism for immediate retrieval of previously computed data.
For example, a function which does a lengthy computation might store
its values in a hash table using argument as a
key. The hash table then serves as a cache for the function (see also
)set function cache
). Also, when
recurrence relations which depend upon
n
previous values are compiled, the previous
n
values are normally cached
(use )set functions recurrence
to change this).
-
(verb) to save values in a cache.
- capsule
the part of the function body of a
domain constructor that defines the functions
implemented by the constructor.
- case
(syntax)
an operator used to
conditionally evaluate code based on the branch of a
Union. For example, if value
u
is
Union(Integer, "failed")
, the conditional
expression if u case Integer then A else B
evaluate A
if u
is
an integer and B
otherwise.
- Category
the distinguished object denoting the type of a category; the class of
all categories.
- category
(basic concept)
second-order types which
serve to define useful "classification worlds" for domains, such as
algebraic constructs (e.g. groups, rings, fields), and data structures
(e.g. homogeneous aggregates, collections, dictionaries). Examples of
categories are Ring
("the class of all
rings") and Aggregate
("the class of all
aggregates"). The categories of a given world are arranged in a
hierarchy (formally, a directed acyclic graph). Each category inherits
the properties of all its ancestors. Thus, for example, the category
of ordered rings (OrderedRing
) inherits the
properties of the category of rings (Ring
)
and those of the ordered sets
(OrderedSet
). Categories provide a database of
algebraic knowledge and ensure mathematical correctness, e.g. that
"matrices of polynomials" is correct but "polynomials of hash tables"
is not, that the multiply operation for "polynomials of continued
fractions" is commutative, but that for "matrices of power series" is
not. optionally provide "default definitions" for operations they
export. Categories are defined in Axiom by functions called
category constructors. Technically, a category
designates a class of domains with common
operations and attributes but
usually with different functions and
representations for its constituent
objects. Categories are always defined using the
Axiom library language (see also
category extension).
See also file catdef.spad
for definitions of basic algebraic categories in Axiom .
- category constructor
a function that creates categories, described by an abstract
datatype in the Axiom programming language. For example, the category
constructor
Module
is a function which takes
a domain parameter R
and creates the category
"modules over R
".
- category extension
created by a category definition, an expression usually of the form
A == B with ...
. In English, this means
"category A is a B
with the new operations
and attributes as given by ... . See, for example, file
catdef.spad
for a definitions of the algebra
categories in Axiom , aggcat.spad
for data
structure categories.
- category hierarchy
hierarchy formed by category extensions. The root category is
Object
. A category can be defined as a
Join of two or more categories so as to have
multiple parents. Categories may also have
parameterized so as to allow conditional inheritance.
- character
-
an element of a character set, as represented by a keyboard key.
-
a component of a string. For example, the 0th element of the string
"hello there"
is the character
h
.
- client
(of a given domain) any domain or package that explicitly calls
functions from the given domain
- coercion
an automatic transformation of an object of one
type to an object of a similar or desired target
type. In the interpreter, coercions and
retractions are done automatically by the
interpreter when a type mismatch occurs. Compare
conversion.
- comment
textual remarks imbedded in code. Comments are preceded by a double
dash (
--
). For Axiom library code,
stylized comments for on-line documentation are preceded by a two plus
signs (++
).
- Common LISP
A version of LISP adopted as an informal
standard by major users and suppliers of LISP
- compile-time
the time when category or domain constructors are compiled. Contrast
run-time.
- compiler
a program that generates low-level code from a higher-level source
language. Axiom has three compilers.
-
A
graphics
compiler
converts graphical formulas to a compiled subroutine so
that points can be rapidly produced for graphics commands.
-
An
interpreter compiler
optionally compiles
user functions when first
invocation
(use )set functions compile
to turn this feature on).
-
A
library compiler
compiles all
constructors.
- computational object
In Axiom , domains are objects. This term is used to distinquish the
objects which are members of domains rather than domains themselves.
- conditional
a control structure of the form
if A then B else C
; The
evaluation of A
produces
true
or false
. If
true
, B
evaluates to
produce a value; otherwise C
evaluates to
produce a value. When the value is not used,
else C
part can be omitted.
- constant
(syntax)
a reserved word used in
signatures in Axiom programming language to signify
that mark an operation always returns the same value. For example, the
signature 0: constant -> $
in the source code
of AbelianMonoid
tells the Axiom compiler
that 0
is a constant so that suitable
optimizations might be performed.
- constructor
a function which creates a
category, domain, or
package.
- continuation
when a line of a program is so long that it must be broken into
several lines, then all but the first line are called
continuation lines
. If such a line is given
interactively, then each incomplete line must end with an underscore.
- control structure
program structures which can specify a departure from normal
sequential execution. Axiom has four kinds of control structures:
blocks, case statements,
conditionals, and loops.
- conversion
the transformation of an object on one type to
one of another type. Conversions performed automatically are called
coercions. These happen when the interpreter has a
type mismatch and a similar or declared target type is needed. In
general, the user must use the infix operation
::
to cause this transformation.
- copying semantics
the programming language semantics used in Pascal but
not
in Axiom . See also
pointer semantics for details.
- data structure
a structure for storing data in the computer. Examples are
lists and hash tables.
- datatype
equivalent to domain in Axiom .
- declaration
(syntax)
an expression of the form
x : T
where T
is some
type
. A declaration forces all values
assigned to T
to be of that
type. If a value is of a different type, the interpreter will try to
coerce the value to type
T
. Declarations are necessary in case of
ambiguity or when a user wants to introduce an an
unexposed domain.
- default definition
a function defined by a category. Such
definitions appear category definitions of the form
C: Category == T add I
in an optional
implmentation part I
to the right of the
keyword add
.
- default package
a optional package of
functions associated with a category. Such
functions are necessarily defined in terms over other functions
exported by the category.
- definition
(syntax)
-
An expression of the form
f(a) == b
defining function
f
with formal arguments
a
and body
b
; equivalent to the statement
f == (a) +-> b
.
-
An expression of the form
a == b
where a
is a
symbol, equivalent to
a() == b
.
See also macro where a similar
substitution is done at parse time.
- delimiter
a character which marks the beginning or end of
some syntactically correct unit in the language, e.g. " for strings,
blanks for identifiers.
- destructive operation
An operation which changes a component or structure of a value. In
Axiom , all destructive operations have names which end with an
exclamation mark (
!
). For example, domain
List
has two operations to reverse the
elements of a list, one named reverse
from List
which returns a copy of the
original list with the elements reversed, another named
reverse!
from List
which reverses the elements in place
thus
destructively changing the original list.
- documentation
-
on-line or hard copy descriptions of Axiom;
-
text in library code preceded by
++
comments as opposed to general comments
preceded by --
.
- domain
(basic concept)
a domain corresponds to
the usual notion of abstract datatypes: that of a set of values and a
set of "exported operations" for the creation and manipulation of
these values. Datatypes are parameterized, dynamically constructed,
and can combine with others in any meaningful way, e.g. "lists of
floats" (List Float
), "fractions of
polynomials with integer coefficients"
(Fraction Polynomial Integer
),
"matrices of infinite streams of cardinal numbers"
(Matrix Stream CardinalNumber
). The term
domain
is actually abbreviates
domain of computation
. Technically, a domain
denotes a class of objects, a class of
operations for creating and other manipulating
these objects, and a class of attributes
describing computationally useful properties. Domains also provide
functions for each operation often in terms of some
representation for the objects. A domain itself
is an object created by a
function called a domain
constructor.
- domain constructor
a function that creates domains, described by an abstract datatype in
the Axiom programming language. Simple domains like
Integer
and Boolean
are
created by domain constructors with no arguments. Most domain
constructors take one or more parameters, one usually denoting an
underlying domain. For example, the domain
Matrix(R)
denotes "matrices over
R"
. Domains Mapping
,
Record
, and
Union
are primitive domains. All other domains
are written in the Axiom programming language and can be modified by
users with access to the library source code.
- domain extension
a domain constructor
A
is said to
extend
a domain constructor
B
if A
's
definition has the form
A == B add ...
.
This intuitively means "functions not defined by A
are assumed to come from
B
". Successive domain extensions form
add-chains affecting the the
search order for functions not implemented directly
by the domain during dynamic lookup.
- dot notation
using an infix dot (
.
) for function
application. If u
is the list
[7, 4, -11]
then both
u(2)
and u.2
return
4. Dot notation nests to left. Thus f . g . h
is equivalent to (f . g) . h
.
- dynamic
that which is done at run-time as opposed to
compile-time. For example, the interpreter will
build the domain "matrices over integers" dynamically in response to
user input. However, the compilation of all functions for matrices and
integers is done during compile-time. Constrast
static.
- dynamic lookup
In Axiom , a domain may or may not explicitly
provide function definitions for all of its
exported operations. These definitions may
instead come from domains in the add-chain or
from default packages. When a
function call is made for an operation in the
domain, up to five steps are carried out.
-
If the domain itself implements a function for the operation,
that function is returned.
-
Each of the domains in the add-chain are searched
for one which implements the function; if found, the function is returned.
-
Each of the default packages for the domain are
searched in order of the lineage. If any of the
default packages implements the function, the first one found is
returned.
-
Each of the default packages for each of the
domains in the add-chain are searched in the
order of their lineage. If any of the default
packages implements the function, the first one found is returned.
- If all of the above steps fail, an error message is reported.
- empty
the unique value of objects with type
Void
.
- environment
a set of bindings.
- evaluation
a systematic process which transforms an
expression into an object called the
value of the expression. Evaluation may produce
side effects.
- exit
(reserved word)
an
operator which forces an exit from the current
block. For example, the block
(a := 1; if i > 0 then exit a; a := 2)
will
prematurely exit at the second statement with value 1 if the value of
i
is greater than 0. See
=>
for an alternate syntax.
- explicit export
-
(of a domain
D
) any
attribute, operation, or
category explicitly mentioned in the
type specification part T
for the domain constructor definition D: T == I
-
(of a category
C
) any
attribute, operation, or
category explicitly mentioned in the
type specification part T
for the domain constructor definition
- export
explicit export or implicit
export of a domain or category
- expose
some constructors are
exposed
, others
unexposed
. Exposed domains and packages
are recognized by the interpreter. Use
)set expose
to control change what is exposed. To see both exposed
and unexposed constructors, use the browser with give the system
command )set hyperdoc browse exposure
on
. Unexposed constructors will now appear prefixed by star
(*
).
- expression
- any syntactically correct program fragment.
- an element of domain
Expression
- extend
see category extension or domain
extension
- field
(algebra)
a domain
which is ring where every non-zero element is
invertible and where xy=yx
; a member of
category Field
. For a complete list of
fields, click on Domains
under
Cross Reference
for
Field
.
- file
a program or collection of data stored on disk, tape or other medium.
- float
a floating-point number with user-specified precision; an element of
domain
Float
. Floats are
literals which are written two ways: without an
exponent (e.g. 3.1416
), or with an exponent
(e.g. 3.12E-12
). Use function
precision to change the precision of the mantissage
(20 digits by default). See also small float.
- formal parameter
(of a function) an identifier bound to the value
of an actual argument on
invocation. In the function definition
f(x, y) == u
, for example,
x
and y
are the formal
parameter.
- frame
the basic unit of an interactive session; each frame has its own
step number, environment, and
history. In one interactive session, users can
can create and drop frames, and have several active frames simultaneously.
- free
(syntax)
A keyword used in user-defined
functions to declare that a variable is a
free variable of that function.
For example, the statement
free x
declares the variable
x
within the body of a function
f
to be a free variable in
f
. Without such a declaration, any variable
x
which appears on the left hand side of an
assignment is regarded as a local variable of
that function. If the intention of the assignment is to give an value
to a global variable x
,
the body of that function must contain the statement
free x
.
- free variable
(of a function) a variable which appears in a body of a function but
is not bound by that function. See
local variable by default.
- function
implementation of operation; it takes zero or
more argument parameters and produces zero or
more values. Functions are objects which can be passed as parameters
to functions and can be returned as values of functions. Functions can
also create other functions (see also
InputForm
). See also
application and
invocation. The terms
operation
and
function
are distinct notions in Axiom . An
operation is an abstraction of a function, described by declaring a
signature. A function is created by providing an
implementation of that operation by some piece of Axiom code. Consider
the example of defining a user-function fact
to compute the factorial
of a nonnegative
integer. The Axiom statement
fact: Integer -> Integer
describes the operation, whereas the statement
fact(n) = reduce(*, [1..n])
defines the
functions. See also generic function.
- function body
the part of a function
's
definition which is evaluated when the function
is called at run-time; the part of the function
definition to the right of the ==
.
- function call
(syntax)
an expression denoting
"application" of a function to a set of argument
parameters. Applications are written as a
parameterized form. For example, the form
f(x, y)
indicates the "application of the function
f
to the tuple of arguments
x
and y
". See also
evaluation and invocation.
- garbage collection
a system function that automatically recycles memory cells from the
heap. Axiom is built upon
Common LISP which provides this facility.
- garbage collector
a mechanism for reclaiming storage in the heap.
- Gaussian
a complex-valued expression, e.g. one with both a real and imaginary
part; a member of a
Complex
domain.
- generic function
the use of one function to operate on objects of different types; One
might regard Axiom as supporting generic
operations but not generic functions. One operation
+: (D, D) -> D
exists for adding elements in
a ring; each ring however provides its own type-specific function for
implementing this operation.
- global variable
A variable which can be referenced freely by functions. In Axiom ,
all top-level user-defined variables defined during an interactive
user session are global variables. Axiom does not allow
fluid variables
, that is, variables
bound by functions which can be referenced by
functions those functions call.
- Groebner basis
(algebra)
a special basis for a
polynomial ideal that allows a simple test for membership. It is
useful in solving systems of polynomial equations.
- group
(algebra)
a monoid
where every element has a multiplicative inverse.
- hash table
A data structure that efficiency maps a given object to another. A
hash table consists of a set of
entries
,
each of which associates a key
with a
value
. Finding the object stored under a key
can be very fast even if there are a large number of entries since
keys are hashed
into numerical codes for
fast lookup.
- heap
an area of storage used by data in programs. For example, AXIOM will
use the heap to hold the partial results of symbolic
computations. When cancellations occur, these results remain in the
heap until garbage collected.
- history
a mechanism which records the results for an interactive
computation. Using the history facility, users can save computations,
review previous steps of a computation, and restore a previous
interactive session at some later time. For details, issue the system
command
)history ?
to the interpreter. See
also frame.
- ideal
(algebra)
a subset of a ring that is
closed under addition and multiplication by arbitrary ring elements,
i.e. it's
a module over the ring.
- identifier
(syntax)
an Axiom name; a
literal of type Symbol
. An
identifier begins with an alphabetical character or % and may be
followed by alphabetic characters, digits, ? or !. Certain
distinquished reserved words are not allowed as
identifiers but have special meaning in the Axiom .
- immutable
an object is immutable if it cannot be changed by an
operation; not a mutable
object. Algebraic objects generally immutable: changing an
algebraic expression involves copying parts of the original
object. One exception is a matrix object of type
Matrix
. Examples of mutable objects are data
structures such as those of type List
. See
also pointer semantics.
- implicit export
(of a domain or category) any attribute or
operation which is either an explicit export or
else an explicit export of some category which an explicit category
export extends.
- index
-
a variable that counts the number of times a
loop is repeated.
-
the "address" of an element in a data structure (see also category
LinearAggregate
).
- infix
(syntax)
an
operator placed between two
operands; also called a
binary operator
, e.g.
a + b
. An infix operator may also be used as a
prefix, e.g. +(a, b)
is
also permissable in the Axiom language. Infix operators have a
relative precedence.
- input area
a rectangular area on a screen into which users can enter text.
- instantiate
to build a category, domain,
or package at run-time
- integer
a literal object of domain
Integer
, the class of integers with an unbounded
number of digits. Integer literals consist of one or more consecutive
digits (0-9) with no embedded blanks. Underscores can be used to
separate digits in long integers if desirable.
- interactive
a system where the user interacts with the computer step-by-step
- interpreter
the subsysystem of Axiom responsible for handling user input during
an interactive session. The following somewhat simplified description
of the typical action of the interpreter. The interpreter parsers the
user
's
input expression to create an
expression tree then does a bottom-up traversal of the tree. Each
subtree encountered which is not a value consists of a root node
denoting an operation name and one or more leaf nodes denoting
operands. The interpreter resolves type mismatches
and uses type-inferencing and a library database to determine
appropriate types of the operands and the result, and an operation to
be performed. The interpreter then builds a domain to perform the
indicated operation, then invokes a function from the domain to
compute a value. The subtree is then replaced by that value and the
process continues. Once the entire tree has been processed, the value
replacing the top node of the tree is displayed back to the user as
the value of the expression.
- invocation
(of a function) the run-time process involved in
evaluating a function
application. This process has two steps. First, a
local environment is created where
formal arguments are locally
bound by assignment to their
respective actual argument. Second, the
function body is evaluated in that local
environment. The evaluation of a function is terminated either by
completely evaluating the function body or by the evaluation of a
return
expression.
- iteration
repeated evaluation of an expression or a sequence of
expressions. Iterations use the reserved words
for
, while
, and
repeat
.
- Join
a primitive Axiom function taking two or more categories as arguments
and producing a category containing all of the operations and
attributes from the respective categories.
- KCL
Kyoto Common LISP, a version of Common LISP
which features compilation of the compilation of LISP into the
C
Programming Language
- library
In Axiom , a coolection of compiled modules respresenting the a
category or domain
constructor.
- lineage
the sequence of default packages for a given
domain to be searched during
dynamic lookup.
This sequence is computed first by ordering the category
ancestors of the domain according to their
level number
, an integer equal to to the
minimum distance of the domain from the category. Parents have level
1, parents of parents have level 2, and so on. Among categories with
equal level numbers, ones which appear in the left-most branches of
Join
s
in the
source code come first. See also dynamic lookup.
- LISP
acronymn for List Processing Language, a language designed for the
manipulation of nonnumerical data. The Axiom library is translated
into LISP then compiled into machine code by an underlying LISP.
- list
an object of a
List
domain.
- literal
an object with a special syntax in the language. In Axiom , there are
five types of literals: booleans,
integers, floats,
strings, and symbols.
- local
(syntax)
A keyword used in user-defined
functions to declare that a variable is a
local variable of that function.
Because of default assumptions on
variables, such a declaration is not necessary but is available to the
user for clarity when appropriate.
- local variable
(of a function) a variable bound by that
function and such that its binding is invisible to any function that
function calls. Also called a
lexical
variable. By default in the interpreter:
-
any variable
x
which appears on the left hand
side of an assignment is regarded a local variable of that
function. If the intention of an assignment is to change the value of
a global variable x
,
the body of the function must then contain the statement
free x
.
-
any other variable is regarded as a free variable.
-
An optional declaration
local x
is available
to explicitly declare a variable to be a local variable. All
formal parameters to the function can be regarded
as local variables to the function.
- loop
- an expression containing a
repeat
-
a collection expression having a
for
or a
while
, e.g.
[f(i) for i in S]
.
- loop body
the part of a loop following the
repeat
that tells what to do each iteration. For example, the body of the
loop for x in S repeat B
is
B
. For a collection expression, the body of the
loop precedes the initial for
or
while
.
- macro
-
(syntax)
An expression of the form
macro a == b
where a
is a
symbol causes a
to be
textually replaced by the expression b
at
parse time.
-
An expression of the form
macro f(a) == b
defines a parameterized macro expansion for a parameterized form
f
This macro causes a form
f
(x
) to be textually
replaced by the expression c
at parse time,
where c
is the expression obtained by
replacing a
by x
everywhere in b
. See also
definition where a similar substitution is done
during evaluation.
- mode
a type expression containing a question-mark
(
?
). For example, the mode
P ?
designates the class
of all polynomials over an arbitrary ring
.
- monoid
is a set with a single, associative operation and an identity element
- mutable
objects which contain pointers to other objects
and which have operations defined on them which alter these
pointers. Contrast immutable. Axiom uses
pointer semantics as does
LISP in contrast with many other languages such as
Pascal which use copying semantics. See
pointer semantics for details.
- name
-
a symbol denoting a variable,
i.e. the variable
x
.
-
a symbol denoting an
operation, i.e. the operation
divide: (Integer, Integer) -> Integer
.
- nullary
a function with no arguments,
e.g.
characteristic
.
- nullary
operation or function with arity 0
- Object
a category with no operations or attributes, from which most categories
in Axiom are category extensions.
- object
a data entity created or manipulated by programs. Elements of
domains, functions, and domains themselves are objects. Whereas
categories are created by functions, they cannot be dynamically
manipulated in the current system and are thus not considered as
objects. The most basic objects are literals;
all other objects must be created
functions. Objects can refer to other objects using
pointers. Axiom language uses
pointer semantics when dealing with
mutable objects.
- object code
code which can be directly executed by hardware; also known as
machine language
.
- operand
an argument of an operator (regarding an
operator as a function).
- operation
an abstraction of a function, described by a
signature. For example,
fact: NonNegativeInteger -> NonNegativeInteger
describes an operation for "the factorial of a (non-negative) integer".
- operator
special reserved words in the language such as
+
and *
;
operators can be either prefix or
infix and have a relative
precedence.
- overloading
the use of the same name to denote distinct functions; a function is
identified by a signature identifying its name,
the number and types of its arguments, and its return types. If two
functions can have identical signatures, a
package call must be made to distinquish the two.
- package
a domain whose exported operations depend solely on the parameters
and other explicit domains, e.g. a package for solving systems of
equations of polynomials over any field, e.g. floats, rational
numbers, complex rational functions, or power series. Facilities for
integration, differential equations, solution of linear or polynomial
equations, and group theory are provided by "packages". Technically, a
package is a domain which has no signature
containing the symbol $. While domains intuitively provide
computational objects you can compute with, packages intuitively
provide functions (polymorphic functions) which
will work over a variety of datatypes.
- package call
(syntax)
an expression of the form
e $ D
where e
is an
application and D
denotes
some package (or domain).
- package call
(syntax)
an expression of the form
f(x, y)$D
used to identify that the function
f
is to be one from D
.
- package constructor
same as domain constructor.
- parameter
see argument
- parameterized datatype
a domain that is built on another, for example, polynomials with
integer coefficients.
- parameterized form
a expression of the form
f(x, y)
, an
application of a function.
- parent
(of a domain) a category which is explicitly declared in the source
code definition for the domain to be an export
of the domain.
- parse
-
(verb) to produce an internal representation of a user input string;
the resultant internal representation is then "interpreted" by Axiom
to perform some indicated action.
-
the transformation of a user input string representing a valid Axiom
expression into an internal representation as a tree-structure.
- partially ordered set
a set with a reflexive, transitive and antisymetric
binary operation.
- pattern
The left hand side of a rewrite rule is called a pattern. Rewrite rules
can be used to perform pattern matching, usually for simplification.
The right hand side of a rule is called the
substitution.
- pattern match
-
(on expressions) Given a expression called a "subject"
u
, the attempt to rewrite
u
using a set of "rewrite rules". Each rule has
the form A == B
where
A
indicates a expression called a "pattern" and
B
denotes a "replacement". The meaning of
this rule is "replace A
by
B"
. If a given pattern A
matches a subexpression of u
, that
subexpression is replaced by B
. Once
rewritten, pattern matching continues until no further changes occur.
-
(on strings) the attempt to match a string indicating a "pattern" to
another string called a "subject", for example, for the purpose of
identifying a list of names. In a browser, users may enter
search strings for the purpose of identifying
constructors, operations, and attributes.
- pattern variable
In a rule a symbol which is not a recognized function acts as a
pattern variable and is free to match any subexpression.
- pile
alternate syntax for a block, using indentation and column alignment
(see also block).
- pointer
a reference implemented by a link directed from one object to another
in the computer memory. An object is said to
refer
to another if it has a pointer to that
other object. Objects can also refer to themselves (cyclic references
are legal). Also more than one object can refer to the same
object. See also pointer semantics.
- pointer semantics
the programming language semantics used in languages such as LISP
which allow objects to be mutable. Consider the
following sequence of Axiom statements:
-
x : Vector Integer := [1, 4, 7]
-
y := x
-
swap!(x, 2, 3)
The function swap!
from
Vector
is used to interchange the 2nd and 3rd
value in the list x
producing the value
[1, 7, 4]
. What value does
y
have after evaluation of the third statement?
The answer is different in Axiom than it is in a language with
copying semantics. In Axiom , first the vector
[1, 2, 3] is created and the variable x
set to
point to this object. Let
's
call this object
V
. Now V
refers to its
immutable components 1, 2, and 3. Next, the
variable y
is made to point to
V
just as x
does. Now the
third statement interchanges the last 2 elements of
V
(the !
at the end of
the name swap!
from
Vector
tells you that this operation is
destructive, that is, it changes the elements in
place
). Both x
and
y
perceive this change to
V
. Thus both x
and
y
then have the value
[1, 7, 4]
.
In Pascal, the second statement causes a copy of
V
to be stored under
y
. Thus the change to V
made by the third statement does not affect
y
.
- polymorphic
a function parameterized by one or more
domains; a algorithm defined
categorically. Every function defined in a domain
or package constructor with a domain-valued parameter is
polymorphic. For example, the same matrix
*
function is used to multiply "matrices over
integers" as "matrices over matrices over integers"
- postfix
an operator that follows its single
operand. Postfix operators are not available in
Axiom.
- precedence
(syntax)
refers to the so-called
binding power
of an operator. For example,
*
has higher binding power than
+
so that the expression
a + b * c
is equivalent to
a + (b * c)
.
- precision
the number of digits in the specification of a number, e.g. as set by
precision
from Float
.
- predicate
- a Boolean valued function, e.g.
odd: Integer -> Boolean
.
- an Boolean valued expression
- prefix
(syntax)
an
operator such as -
and
not
that is written
before
its single
operand. Every function of one argument can be used
as a prefix operator. For example, all of the following have
equivalent meaning in Axiom : f(x)
,
f x
, and f.x
. See also
dot notation.
- quote
the prefix operator
'
meaning do not
evaluate
.
- Record
(basic domain constructor) a domain constructor used to create a
inhomogeneous aggregate composed of pairs of "selectors" and
values. A Record domain is written in the form
Record(a1:D1, ..., an:Dn)
(n
> 0) where a1
, ...,
an
are identifiers called the
selectors
of the record, and
D1
, ..., Dn
are domains
indicating the type of the component stored under selector
an
.
- recurrence relation
A relation which can be expressed as a function
f
with some argument n
which depends on the value of f
at
k
previous values. In many cases, Axiom will
rewrite a recurrence relation on compilation so as to
cache its previous k
values
and therefore make the computation significantly more efficient.
- recursion
use of a self-reference within the body of a function. Indirect
recursion is when a function uses a function below it in the call
chain.
- recursive
- A function that calls itself, either directly or indirectly through
another function.
- self-referential. See also recursive.
- reference
see pointer
- Rep
a special identifier used as local variable of
a domain constructor body to denote the representation domain for
objects of a domain.
- representation
a domain providing a data structure for
elements of a domain; generally denoted by the special identifier
Rep in the Axiom programming language. As domains
are abstract datatypes, this representation is not
available to users of the domain, only to functions defined in the
function body for a domain constructor. Any domain
can be used as a representation.
- reserved word
a special sequence of non-blank characters with special meaning in
the Axiom language. Examples of reserved words are names such as
for
, if
, and
free
, operator names such as
+
and mod
, special
character strings such as ==
and
:=
.
- retraction
to move an object in a parameterized domain back to the underlying
domain, for example to move the object
7
from
a "fraction of integers"
(domain Fraction Integer
) to
"the integers" (domain Integer
).
- return
when leaving a function, the value of the expression following
return
becomes the value of the function.
- ring
a set with a commutative addition, associative multiplication, a unit
element, and multiplication distributes over addition and subtraction.
- rule
(syntax)
1. An expression of the form
rule A == B
indicating a "rewrite
rule". 2. An expression of the form
rule(R1;...;Rn)
indicating a set of "rewrite rules"
R1
, ..., Rn
. See
pattern matching for details.
- run-time
the time of doing a computation. Contrast
compile-time. rather than prior to it;
dynamic as opposed to
static. For example, the decision of the intepreter
to build a structure such as "matrices with power series entries" in
response to user input is made at run-time.
- run-time check
an error-checking which can be done only when the program receives
user input; for example, confirming that a value is in the proper
range for a computation.
- search order
the sequence of default packages for a given
domain to be searched during dynamic
lookup. This sequence is computed first by ordering the category
ancestors of the domain according to their
level number
, an integer equal to to the
minimum distance of the domain from the category. Parents have level
1, parents of parents have level 2, and so on. Among categories with
equal level numbers, ones which appear in the left-most branches of
Join
s
in the
source code come first. See also dynamic lookup.
- search string
a string entered into an input area on a screen
- selector
an identifier used to address a component value of a
Record datatype.
- semantics
the relationships between symbols and their meanings. The rules for
obtaining the
meaning
of any syntactically
valid expression.
- semigroup
(algebra)
a monoid
which need not have an identity; it is closed and associative.
- side effect
action which changes a component or structure of a value. See
destructive operation for details.
- signature
(syntax)
an expression describing an
operation. A signature has the form as
name : source -> target
, where
source
gives the type of the arguments of the
operation, and target
gives the type of the
result.
- small float
the domain for hardware floating point arithmetic as provided by the
computer hardware.
- small integer
the domain for hardware integer arithmetic. as provided by the computer
hardware.
- source
the type of the argument of a
function; the type expression before the
->
in a signature. For
example, the source of
f : (Integer, Integer) -> Integer
is (Integer, Integer)
.
- sparse
data structure whose elements are mostly identical (a sparse matrix
is one filled with mostly zeroes).
- static
that computation done before run-time, such as compilation. Contrast
dynamic.
- step number
the number which precedes user input lines in an interactive session;
the output of user results is also labeled by this number.
- stream
an object of
Stream(R)
, a generalization of
a list to allow an infinite number of
elements. Elements of a stream are computed "on demand". Strings are
used to implement various forms of power series.
- string
an object of domain
String
. Strings are
literals consisting of an arbitrary sequence of
characters surrounded by double-quotes
("
), e.g.
"Look here!"
.
- subdomain
(basic concept)
a
domain together with a
predicate characterizing which members of the
domain belong to the subdomain. The exports of a subdomain are usually
distinct from the domain itself. A fundamental assumption however is
that values in the subdomain are automatically
coerceable to values in the domain. For example, if
n
and m
are declared
to be members of a subdomain of the integers, then
any
binary operation from
Integer
is available on
n
and m
. On the other
hand, if the result of that operation is to be assigned to, say,
k
, also declared to be of that subdomain, a
run-time check is generally necessary to ensure
that the result belongs to the subdomain.
- substitution
The right hand side of a rule is called the substitution.
The left hand side of a rewrite rule is called a
pattern. Rewrite rules
can be used to perform pattern matching, usually for simplification.
- such that clause
the use of
|
followed by an expression
to filter an iteration.
- suffix
(syntax)
an
operator which placed after its operand. Suffix
operators are not allowed in the Axiom language.
- symbol
objects denoted by identifier
literals; an element of domain
Symbol
. The interpreter defaultly converts a
symbol x
into
Variable(x)
.
- syntax
rules of grammar, punctuation etc. for forming correct expressions.
- system commands
top-level Axiom statements that begin with
)
. System commands allow users to query the
database, read files, trace functions, and so on.
- tag
an identifier used to discriminate a branch of a
Union type.
- target
the type of the result of a
function; the type expression following the
->
in a signature.
- top-level
refers to direct user interactions with the Axiom interpreter.
- totally ordered set
(algebra)
a partially ordered set where
any two elements are comparable.
- trace
use of system function
)trace
to track the
arguments passed to a function and the values returned.
- tuple
an expression of two or more other expressions separated by commas,
e.g.
4, 7, 11
. Tuples are also used for
multiple arguments both for applications
(e.g. f(x, y)
) and in
signatures (e.g.
(Integer, Integer) -> Integer
).
A tuple is not a data structure, rather a
syntax mechanism for grouping expressions.
- type
The type of any subdomain is the unique symbol
Category
. The type of a
domain is any category that
domain belongs to. The type of any other object is either the (unique)
domain that object belongs to or any subdomain
of that domain. The type of objects is in general not unique.
- type checking
a system function which determines whether the datatype of an object is
appropriate for a given operation.
- type constructor
a domain constructor or
category constructor.
- type inference
when the interpreter chooses the type for an object based on
context. For example, if the user interactively issues the definition
f(x) == (x + %i)**2
then
issues f(2)
, the interpreter will infer the
type of f
to be
Integer -> Complex Integer
.
- unary
operation or function with arity 1
- underlying domain
for a domain that has a single domain-valued
parameter, the
underlying domain
refers to
that parameter. For example, the domain "matrices of integers"
(Matrix Integer
) has underlying domain
Integer
.
- Union
(basic domain constructor)
a domain
constructor used to combine any set of domains into a single domain. A
Union domain is written in the form
Union(a1:D1,..., an:Dn)
(n
> 0) where
a1
, ..., an
are
identifiers called the tags
of the union,
and D1
, ..., Dn
are
domains called the branches
of the
union. The tags ai
are optional, but required
when two of the Di
are equal, e.g.
Union(inches:Integer, centimeters:Integer)
. In the
interpreter, values of union domains are automatically coerced to
values in the branches and vice-versa as appropriate. See also
case.
- unit
(algebra)
an invertible element.
- user function
a function defined by a user during an interactive session. Contrast
built-in function.
- user variable
a variable created by the user at top-level during an interactive session
- value
-
the result of evaluating an expression.
-
a property associated with a variable in a
binding in an environment.
- variable
a means of referring to an object but itself is not an object. A
variable has a name and an associated binding
created by evaluation of Axiom expressions such
as declarations,
assignments, and
definitions. In the top-level
environment of the interpreter, variables are
global variables. Such variables can be freely
referenced in user-defined functions although a
free declaration is needed to assign values to
them. See local variable for details.
- Void
the type given when the value and type of an expression are not needed. Also used
when there is no guarantee at run-time that a value and predictable
mode will result.
- wild card
a symbol which matches any substring including the empty string; for
example, the search string
*an*
matches an
word containing the consecutive letters a
and n
- workspace
an interactive record of the user input and output held in an
interactive history file. Each user input and corresponding output
expression in the workspace has a corresponding step
number. The current output expression in the workspace is referred
to as
%
. The output expression associated
with step number n
is referred to by %%(n)
. The k
-th previous
output expression relative to the current step number n
is referred to by %%(-
k)
. Each interactive frame has its own
workspace.