- !
  (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
  .
- ?
  1. (syntax)
     a suffix character for Boolean-valued
     function
     names, e.g.
     odd?
     .
  2. Suffix character for pattern variables.
  3. 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
  1. (actual argument) a value passed to a function at the time of a function call application; also called an
     actual parameter
     .
  2. (formal argument) a variable used in the definition of a function to denote the actual argument passed when the function is called.
- arity
  1. (function) the number of arguments.
  2. (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,
  commutative(
  "*"
  )
  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
  1. (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).
  2. (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
  1. an element of a character set, as represented by a keyboard key.
  2. 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.
  1. A
     graphics compiler
     converts graphical formulas to a compiled subroutine so that points can be rapidly produced for graphics commands.
  2. An
     interpreter compiler
     optionally compiles user functions when first invocation (use
     )set functions compile
     to turn this feature on).
  3. 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)
  1. 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
     .
  2. 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
  1. on-line or hard copy descriptions of Axiom;
  2. 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.
  1. If the domain itself implements a function for the operation, that function is returned.
  2. Each of the domains in the add-chain are searched for one which implements the function; if found, the function is returned.
  3. 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.
  4. 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.
  5. 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
  1. (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
  2. (of a category
     C
     ) any attribute, operation, or category explicitly mentioned in the type specification part
     T
     for the domain constructor definition
     C: Category == T
- 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
  1. any syntactically correct program fragment.
  2. 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
  1. a variable that counts the number of times a loop is repeated.
  2. 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:
  1. 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
     .
  2. any other variable is regarded as a free variable.
  3. 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
  1. an expression containing a
     repeat
  2. 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
  1. (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.
  2. 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
  1. a symbol denoting a variable, i.e. the variable
     x
     .
  2. 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
  1. (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.
  2. 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
  1. (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.
  2. (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:
  1. x : Vector Integer := [1, 4, 7]
  2. y := x
  3. 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
  1. a Boolean valued function, e.g.
     odd: Integer -> Boolean
     .
  2. 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
  1. A function that calls itself, either directly or indirectly through another function.
  2. 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
  1. the result of evaluating an expression.
  2. 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.