Data Types and Structures (Maxima 5.42.455.gc5fa8d39c Manual)

5 Data Types and Structures

5.1 Numbers

5.1.1 Introduction to Numbers

Complex numbers

A complex expression is specified in Maxima by adding the real part of the expression to %i times the imaginary part. Thus the roots of the equation x^2 - 4*x + 13 = 0 are 2 + 3*%i and 2 - 3*%i. Note that simplification of products of complex expressions can be effected by expanding the product. Simplification of quotients, roots, and other functions of complex expressions can usually be accomplished by using the realpart, imagpart, rectform, polarform, abs, carg functions.

Categories: Complex variables

5.1.2 Functions and Variables for Numbers

Function: bfloat (expr)

Converts all numbers and functions of numbers in expr to bigfloat numbers. The number of significant digits in the resulting bigfloats is specified by the global variable fpprec.

When float2bf is false a warning message is printed when a floating point number is converted into a bigfloat number (since this may lead to loss of precision).

Categories: Numerical evaluation

Function: bfloatp (expr)

Returns true if expr is a bigfloat number, otherwise false.

Categories: Numerical evaluation Predicate functions

Option variable: bftorat

Default value: false

bftorat controls the conversion of bfloats to rational numbers. When bftorat is false, ratepsilon will be used to control the conversion (this results in relatively small rational numbers). When bftorat is true, the rational number generated will accurately represent the bfloat.

Note: bftorat has no effect on the transformation to rational numbers with the function rationalize.

Example:

(%i1) ratepsilon:1e-4;
(%o1)                         1.e-4
(%i2) rat(bfloat(11111/111111)), bftorat:false;
`rat' replaced 9.99990999991B-2 by 1/10 = 1.0B-1
                               1
(%o2)/R/                       --
                               10
(%i3) rat(bfloat(11111/111111)), bftorat:true;
`rat' replaced 9.99990999991B-2 by 11111/111111 = 9.99990999991B-2
                             11111
(%o3)/R/                     ------
                             111111

Categories: Numerical evaluation

Option variable: bftrunc

Default value: true

bftrunc causes trailing zeroes in non-zero bigfloat numbers not to be displayed. Thus, if bftrunc is false, bfloat (1) displays as 1.000000000000000B0. Otherwise, this is displayed as 1.0B0.

Categories: Numerical evaluation

Function: evenp (expr)

Returns true if expr is a literal even integer, otherwise false.

evenp returns false if expr is a symbol, even if expr is declared even.

Categories: Predicate functions

Function: float (expr)

Converts integers, rational numbers and bigfloats in expr to floating point numbers. It is also an evflag, float causes non-integral rational numbers and bigfloat numbers to be converted to floating point.

Categories: Numerical evaluation Evaluation flags

Option variable: float2bf

Default value: true

When float2bf is false, a warning message is printed when a floating point number is converted into a bigfloat number (since this may lead to loss of precision).

Categories: Numerical evaluation

Function: floatnump (expr)

Returns true if expr is a floating point number, otherwise false.

Categories: Numerical evaluation Predicate functions

Option variable: fpprec

Default value: 16

fpprec is the number of significant digits for arithmetic on bigfloat numbers. fpprec does not affect computations on ordinary floating point numbers.

5.2 Strings

5.2.1 Introduction to Strings

Strings (quoted character sequences) are enclosed in double quote marks " for input, and displayed with or without the quote marks, depending on the global variable stringdisp.

Strings may contain any characters, including embedded tab, newline, and carriage return characters. The sequence \" is recognized as a literal double quote, and \\ as a literal backslash. When backslash appears at the end of a line, the backslash and the line termination (either newline or carriage return and newline) are ignored, so that the string continues with the next line. No other special combinations of backslash with another character are recognized; when backslash appears before any character other than ", \, or a line termination, the backslash is ignored. There is no way to represent a special character (such as tab, newline, or carriage return) except by embedding the literal character in the string.

There is no character type in Maxima; a single character is represented as a one-character string.

The stringproc add-on package contains many functions for working with strings.

Examples:

(%i1) s_1 : "This is a string.";
(%o1)                   This is a string.

(%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
(%o2) Embedded "double quotes" and backslash \ characters.

(%i3) s_3 : "Embedded line termination
(%o3) Embedded line termination
in this string.

(%i4) in this string.";
(%o4) Ignore the line termination characters in this string.

(%i5) s_4 : "Ignore the \
(%o5)                         false

(%i6) line termination \
(%o6)                   This is a string.

(%i7) characters in \
(%o7)                         true

(%i8) this string.";
(%o8)                  "This is a string."

(%i9) stringdisp : false;

Categories: Syntax

5.2.2 Functions and Variables for Strings

Function: concat (arg_1, arg_2, …)

Concatenates its arguments. The arguments must evaluate to atoms. The return value is a symbol if the first argument is a symbol and a string otherwise.

concat evaluates its arguments. The single quote ' prevents evaluation.

5.3 Constants

5.3.1 Functions and Variables for Constants

Constant: %e

%e represents the base of the natural logarithm, also known as Euler’s number. The numeric value of %e is the double-precision floating-point value 2.718281828459045d0.

Categories: Constants

Constant: %i

%i represents the imaginary unit, sqrt(- 1).

Categories: Constants

Constant: false

false represents the Boolean constant of the same name. Maxima implements false by the value NIL in Lisp.

Categories: Constants

Constant: %gamma

The Euler-Mascheroni constant, 0.5772156649015329 ....

Categories: Constants

Constant: ind

ind represents a bounded, indefinite result.

5.4 Lists

5.4.1 Introduction to Lists

Lists are the basic building block for Maxima and Lisp. All data types other than arrays, hashed arrays and numbers are represented as Lisp lists, These Lisp lists have the form

((MPLUS) $A 2)

to indicate an expression a+2. At Maxima level one would see the infix notation a+2. Maxima also has lists which are printed as

[1, 2, 7, x+y]

for a list with 4 elements. Internally this corresponds to a Lisp list of the form

((MLIST) 1 2 7 ((MPLUS) $X $Y))

The flag which denotes the type field of the Maxima expression is a list itself, since after it has been through the simplifier the list would become

((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))

5.4.2 Functions and Variables for Lists

Operator: [

Operator: ]

[ and ] mark the beginning and end, respectively, of a list.

[ and ] also enclose the subscripts of a list, array, hashed array, or memoizing function. Note that other than for arrays accessing the nth element of a list may need an amount of time that is roughly proportional to n, See Performance considerations for Lists.

Note that if an element of a subscripted variable is written to before a list or an array of this name is declared a hashed array (see Arrays) is created, not a list.

Examples:

(%i1) x: [a, b, c];
(%o1)                       [a, b, c]

(%i2) x[3];
(%o2)                           c

(%i3) array (y, fixnum, 3);
(%o3)                           y

(%i4) y[2]: %pi;
(%o4)                          %pi

(%i5) y[2];
(%o5)                          %pi

(%i6) z['foo]: 'bar;
(%o6)                          bar

(%i7) z['foo];
(%o7)                          bar

(%i8) g[k] := 1/(k^2+1);
                                  1
(%o8)                     g  := ------
                           k     2
                                k  + 1

(%i9) g[10];
                                1
(%o9)                          ---
                               101

Categories: Lists Operators

Function: append (list_1, …, list_n)

Returns a single list of the elements of list_1 followed by the elements of list_2, … append also works on general expressions, e.g. append (f(a,b), f(c,d,e)); yields f(a,b,c,d,e).

5.4.3 Performance considerations for Lists

Lists provide efficient ways of appending and removing elements. They can be created without knowing their final dimensions. Lisp provides efficient means of copying and handling lists. Also nested lists do not need to be strictly rectangular. These advantages over declared arrays come with the drawback that the amount of time needed for accessing a random element within a list may be roughly proportional to the element’s distance from its beginning. Efficient traversal of lists is still possible, though, by using the list as a stack or a fifo:

(%i1) l:[Test,1,2,3,4];
(%o1)                  [Test, 1, 2, 3, 4]

(%i2) while l # [] do
   disp(pop(l));
                              Test

                                1

                                2

                                3

                                4

(%o2)                         done

Another even faster example would be:

(%i1) l:[Test,1,2,3,4];
(%o1)                  [Test, 1, 2, 3, 4]

(%i2) for i in l do
   disp(pop(l));
                              Test

                                1

                                2

                                3

                                4

(%o2)                         done

Beginning traversal with the last element of a list is possible after reversing the list using reverse (). If the elements of a long list need to be processed in a different order performance might be increased by converting the list into a declared array first.

It is also to note that the ending condition of for loops is tested for every iteration which means that the result of a length should be cached if it is used in the ending condition:

(%i1) l:makelist(i,i,1,100000)$

(%i2) lngth:length(l);
(%o2)                        100000

(%i3) x:1;
(%o3)                           1

(%i4) for i:1 thru lngth do
    x:x+1$

(%i5) x;
(%o5)                        100001

5.5 Arrays

Maxima supports 3 array-like constructs:

If one tries to write to an indexed variable without creating a list first an undeclared array (also named hashed array) is created that grows dynamically and allows numbers, symbols and strings as indices:
```
(%i1) a["feww"]:1;
(%o1)                           1
```
```
(%i2) a[qqwdqwd]:3;
(%o2)                           3
```
```
(%i3) a[5]:99;
(%o3)                          99
```
```
(%i4) a[qqwdqwd];
(%o4)                           3
```
```
(%i5) a[5];
(%o5)                          99
```
```
(%i6) a["feww"];
(%o6)                           1
```
Since lisp handles hashed arrays and memoizing functions similar to arrays many of the functions that can be applied to arrays can be applied to them, as well.
Lists (see makelist allow for fast addition and removal of elements, can be created without knowing their final size.
Declared arrays that allow fast access to random elements at the cost that their size needs to be known at construction time. (See Performance considerations for Lists.)

5.5.1 Functions and Variables for Arrays

Function: array
    array (name, dim_1, …, dim_n)
    array (name, type, dim_1, …, dim_n)
    array ([name_1, …, name_m], dim_1, …, dim_n)

Creates an n-dimensional array. n may be less than or equal to 5. The subscripts for the i’th dimension are the integers running from 0 to dim_i.

array (name, dim_1, ..., dim_n) creates a general array.

array (name, type, dim_1, ..., dim_n) creates an array, with elements of a specified type. type can be fixnum for integers of limited size or flonum for floating-point numbers.

array ([name_1, ..., name_m], dim_1, ..., dim_n) creates m arrays, all of the same dimensions.

See also arraymake, arrayinfo and make_array.

Categories: Arrays

Function: arrayapply (A, [i_1, …, i_n])

Evaluates A [i_1, ..., i_n], where A is an array and i_1, …, i_n are integers.

This is reminiscent of apply, except the first argument is an array instead of a function.

Categories: Expressions Arrays

Function: arrayinfo (A)

Returns information about the array A. The argument A may be a declared array, a hashed array, a memoizing function, or a subscripted function.

For declared arrays, arrayinfo returns a list comprising the atom declared, the number of dimensions, and the size of each dimension. The elements of the array, both bound and unbound, are returned by listarray.

For undeclared arrays (hashed arrays), arrayinfo returns a list comprising the atom hashed, the number of subscripts, and the subscripts of every element which has a value. The values are returned by listarray.

For memoizing functions, arrayinfo returns a list comprising the atom hashed, the number of subscripts, and any subscript values for which there are stored function values. The stored function values are returned by listarray.

For subscripted functions, arrayinfo returns a list comprising the atom hashed, the number of subscripts, and any subscript values for which there are lambda expressions. The lambda expressions are returned by listarray.

5.6 Structures

5.6.1 Introduction to Structures

Maxima provides a simple data aggregate called a structure. A structure is an expression in which arguments are identified by name (the field name) and the expression as a whole is identified by its operator (the structure name). A field value can be any expression.

A structure is defined by the defstruct function; the global variable structures is the list of user-defined structures. The function new creates instances of structures. The @ operator refers to fields. kill(S) removes the structure definition S, and kill(x@ a) unbinds the field a of the structure instance x.

In the pretty-printing console display (with display2d equal to true), structure instances are displayed with the value of each field represented as an equation, with the field name on the left-hand side and the value on the right-hand side. (The equation is only a display construct; only the value is actually stored.) In 1-dimensional display (via grind or with display2d equal to false), structure instances are displayed without the field names.

There is no way to use a field name as a function name, although a field value can be a lambda expression. Nor can the values of fields be restricted to certain types; any field can be assigned any kind of expression. There is no way to make some fields accessible or inaccessible in different contexts; all fields are always visible.

5.6.2 Functions and Variables for Structures

Global variable: structures

structures is the list of user-defined structures defined by defstruct.

Categories: Structures Global variables

Function: defstruct
defstruct (S(a_1, …, a_n))
defstruct (S(a_1 = v_1, …, a_n = v_n))

Define a structure, which is a list of named fields a_1, …, a_n associated with a symbol S. An instance of a structure is just an expression which has operator S and exactly n arguments. new(S) creates a new instance of structure S.

An argument which is just a symbol a specifies the name of a field. An argument which is an equation a = v specifies the field name a and its default value v. The default value can be any expression.

defstruct puts S on the list of user-defined structures, structures.

kill(S) removes S from the list of user-defined structures, and removes the structure definition.

Examples:

(%i1) defstruct (foo (a, b, c));
(%o1)                    [foo(a, b, c)]
(%i2) structures;
(%o2)                    [foo(a, b, c)]
(%i3) new (foo);
(%o3)                     foo(a, b, c)
(%i4) defstruct (bar (v, w, x = 123, y = %pi));
(%o4)             [bar(v, w, x = 123, y = %pi)]
(%i5) structures;
(%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
(%i6) new (bar);
(%o6)              bar(v, w, x = 123, y = %pi)
(%i7) kill (foo);
(%o7)                         done
(%i8) structures;
(%o8)             [bar(v, w, x = 123, y = %pi)]

Categories: Structures

Function: new
new (S)
new (S (v_1, …, v_n))

new creates new instances of structures.

new(S) creates a new instance of structure S in which each field is assigned its default value, if any, or no value at all if no default was specified in the structure definition.

new(S(v_1, ..., v_n)) creates a new instance of S in which fields are assigned the values v_1, …, v_n.

Examples:

(%i1) defstruct (foo (w, x = %e, y = 42, z));
(%o1)              [foo(w, x = %e, y = 42, z)]
(%i2) new (foo);
(%o2)               foo(w, x = %e, y = 42, z)
(%i3) new (foo (1, 2, 4, 8));
(%o3)            foo(w = 1, x = 2, y = 4, z = 8)

Categories: Structures

Operator: @

@ is the structure field access operator. The expression x@ a refers to the value of field a of the structure instance x. The field name is not evaluated.

If the field a in x has not been assigned a value, x@ a evaluates to itself.

kill(x@ a) removes the value of field a in x.

Examples:

(%i1) defstruct (foo (x, y, z));
(%o1)                    [foo(x, y, z)]
(%i2) u : new (foo (123, a - b, %pi));
(%o2)           foo(x = 123, y = a - b, z = %pi)
(%i3) u@z;
(%o3)                          %pi
(%i4) u@z : %e;
(%o4)                          %e
(%i5) u;
(%o5)            foo(x = 123, y = a - b, z = %e)
(%i6) kill (u@z);
(%o6)                         done
(%i7) u;
(%o7)              foo(x = 123, y = a - b, z)
(%i8) u@z;
(%o8)                          u@z

The field name is not evaluated.

(%i1) defstruct (bar (g, h));
(%o1)                      [bar(g, h)]
(%i2) x : new (bar);
(%o2)                       bar(g, h)
(%i3) x@h : 42;
(%o3)                          42
(%i4) h : 123;
(%o4)                          123
(%i5) x@h;
(%o5)                          42
(%i6) x@h : 19;
(%o6)                          19
(%i7) x;
(%o7)                    bar(g, h = 19)
(%i8) h;
(%o8)                          123

Categories: Structures Operators

• Numbers:
• Strings:
• Constants:
• Lists:
• Arrays:
• Structures:

• Introduction to Numbers:
• Functions and Variables for Numbers:

• Introduction to Strings:
• Functions and Variables for Strings:

• Introduction to Lists:
• Functions and Variables for Lists:
• Performance considerations for Lists:

• Introduction to Structures:
• Functions and Variables for Structures: