8. Glossary

This is a short glossary of terms frequently used in the Yacas documentation.

arity

"Arity" is the number of arguments of a function. For example, the function Cos(x) has one argument and so we say that "Cos has arity 1". Arity of a function can be 0, 1, 2, ...

Yacas allows to define functions with the same name but different arities, and different rules corresponding to these arities will be used. Also, it is possible to define a function with optional arguments, for example, Plot2D is one such function. Such functions can have any arity larger or equal to a certain minimum arity (the number of non-optional arguments).

See also:
Function , OpPrecedence , Rule .

array

An array is a container object that can hold a fixed number of other Yacas objects in it. Individual elements of an array can be accessed using the [] operation. Most list operations also work on arrays.

Arrays are faster than lists but the array size cannot be changed.

See also:
Array'Create .

atoms

Atoms are basic Yacas objects that are used to represent symbols, numbers, and function names. An atom has a string representation which is shown when it is displayed. For example, 3.14159, x, A123, +, "good morning" are atoms.

Atoms can be of type string, number, or symbol. For example, y1 is a symbolic atom, 954 is a number atom, and "" is an (empty) string atom. Symbolic atoms are normally used in Yacas to denote mathematical unknowns and function names. Number and string atoms are used to denote values.

A symbolic atom can be bound to a value (in which case it becomes a variable), or to a rule or several rules (in which case it becomes a function). An atom can also have a property object.

See also:
Atom , String .

CAS

Abbreviation for "computer algebra system". Yacas is a CAS.

constants

Constants such as I, Pi or GoldenRatio are symbolic atoms that are specially interpreted by Yacas. For example, there are simplification rules that transform expressions such as Sin(Pi) into 0. When requesting a numerical evaluation of a constant, the numerical value is given to the current value as set with N.

Some constants take a long time to compute and therefore they are cached at the highest precision computed so far. These are the "cached constants".

See also:
N , CachedConstant , Pi , GoldenRatio , CatalanConstant , gamma , I .

equations

To denote symbolic equations, the operator == is used. This operator does not assign or compare its sides. For example, the expression Sin(x)==1 is kept unevaluated and can be passed as argument to functions. For example, 
In> Solve(Sin(x)==1, x)
Out> {x==Pi/2};

The symbolic equation operator == is also useful to represent solutions of equations or to specify substitutions, give options, and so on.

See also:
Solve , Where , Plot2D .

functions

A function is a symbolic atom that is bound to a rule or several rules. A function can have none, one, or more arguments. Functions can also have a variable number of arguments. Arguments of functions are arbitrary Yacas objects.

Functions can be evaluated, that is, the rules bound to them may be executed. For example, Cos(Pi+0) is an expression that contains two functions and four atoms. The atom Pi is a symbolic atom which is normally not bound to anything. The atom 0 is a numeric atom.

The atoms Cos and + are symbolic atoms which are bound to appropriate simplification rules. So these two atoms are functions. Note that these functions have different syntax. Cos is a normal function which takes its arguments in parentheses. The atom + is a function with special syntax because "+" is placed between its arguments and no parentheses are used.

The rules to which + is bound are such that the expression Pi+0 is evaluated to the symbolic atom Pi. The rules for Cos are such that the expression Cos(Pi) is evaluated to the numeric atom -1. The example Yacas session is: 
In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written as e.g. {a, b, c} or {} (empty list). Individual elements of a list can be accessed using the [] operation. Lists can be concatenated, and individual elements can be removed or inserted.

an be 

In> Cos(Pi+0)
Out> -1;

Some functions are built-in and implemented in C++, while others are library functions.

The built-in functions are usually less flexible than the library functions because they cannot be left unevaluated. Given incorrect arguments, a built-in function will generate an error. However, a user-defined function may simply return unevaluated in such cases.

See also:
Function , Rule , <-- .

lists

A list is a basic Yacas container object. A list is written a