[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

38.1 Introduction to Lists | ||

38.2 Definitions for Lists |

[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

Lists are the basic building block for Maxima and Lisp. All data types other than arrays, hash tables, 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)) |

[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

__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)`

.Do

`example(append);`

for an example.

__Function:__**assoc***(*`key`,`list`,`default`)__Function:__**assoc***(*`key`,`list`)This function searches for the

`key`in the left hand side of the input`list`of the form`[x,y,z,...]`

where each of the`list`elements is an expression of a binary operand and 2 elements. For example`x=1`

,`2^3`

,`[a,b]`

etc. The`key`is checked againts the first operand.`assoc`

returns the second operand if the`key`

is found. If the`key`

is not found it either returns the`default`value.`default`is optional and defaults to`false`

.

__Function:__**atom***(*`expr`)Returns

`true`

if`expr`is atomic (i.e. a number, name or string) else`false`

. Thus`atom(5)`

is`true`

while`atom(a[1])`

and`atom(sin(x))`

are`false`

(asuming`a[1]`

and`x`

are unbound).

__Function:__**cons***(*`expr`,`list`)Returns a new list constructed of the element

`expr`as its first element, followed by the elements of`list`.`cons`

also works on other expressions, e.g.`cons(x, f(a,b,c));`

->`f(x,a,b,c)`

.

__Function:__**copylist***(*`list`)Returns a copy of the list

`list`.

__Function:__**create_list***(*`form`,`x_1`,`list_1`, ...,`x_n`,`list_n`)Create a list by evaluating

`form`with`x_1`bound to each element of`list_1`, and for each such binding bind`x_2`to each element of`list_2`, .... The number of elements in the result will be the product of the number of elements in each list. Each variable`x_i`must actually be a symbol - it will not be evaluated. The list arguments will be evaluated once at the beginning of the iteration.(%i1) create_list(x^i,i,[1,3,7]); 3 7 (%o1) [x, x , x ]

With a double iteration:

(%i1) create_list([i,j],i,[a,b],j,[e,f,h]); (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]

Instead of

`list_i`two args may be supplied each of which should evaluate to a number. These will be the inclusive lower and upper bounds for the iteration.(%i1) create_list([i,j],i,[1,2,3],j,1,i); (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]

Note that the limits or list for the

`j`variable can depend on the current value of`i`.

__Function:__**delete***(*`expr_1`,`expr_2`)__Function:__**delete***(*`expr_1`,`expr_2`,`n`)Removes all occurrences of

`expr_1`from`expr_2`.`expr_1`may be a term of`expr_2`(if it is a sum) or a factor of`expr_2`(if it is a product).(%i1) delete(sin(x), x+sin(x)+y); (%o1) y + x

`delete(`

removes the first`expr_1`,`expr_2`,`n`)`n`occurrences of`expr_1`from`expr_2`. If there are fewer than`n`occurrences of`expr_1`in`expr_2`then all occurrences will be deleted.(%i1) delete(a, f(a,b,c,d,a)); (%o1) f(b, c, d) (%i2) delete(a, f(a,b,a,c,d,a), 2); (%o2) f(b, c, d, a)

__Function:__**eighth***(*`expr`)Returns the 8'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**endcons***(*`expr`,`list`)Returns a new list consisting of the elements of

`list`

followed by`expr`.`endcons`

also works on general expressions, e.g.`endcons(x, f(a,b,c));`

->`f(a,b,c,x)`

.

__Function:__**fifth***(*`expr`)Returns the 5'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**first***(*`expr`)Returns the first part of

`expr`which may result in the first element of a list, the first row of a matrix, the first term of a sum, etc. Note that`first`

and its related functions,`rest`

and`last`

, work on the form of`expr`which is displayed not the form which is typed on input. If the variable`inflag`

is set to`true`

however, these functions will look at the internal form of`expr`. Note that the simplifier re-orders expressions. Thus`first(x+y)`

will be`x`

if`inflag`

is`true`

and`y`

if`inflag`

is`false`

(`first(y+x)`

gives the same results). The functions`second`

..`tenth`

yield the second through the tenth part of their input argument.

__Function:__**fourth***(*`expr`)Returns the 4'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**get***(*`a`,`i`)Retrieves the user property indicated by

`i`associated with atom`a`or returns`false`

if a doesn't have property`i`.`get`

evaluates its arguments.(%i1) put (%e, 'transcendental, 'type); (%o1) transcendental (%i2) put (%pi, 'transcendental, 'type)$ (%i3) put (%i, 'algebraic, 'type)$ (%i4) typeof (expr) := block ([q], if numberp (expr) then return ('algebraic), if not atom (expr) then return (maplist ('typeof, expr)), q: get (expr, 'type), if q=false then errcatch (error(expr,"is not numeric.")) else q)$ (%i5) typeof (2*%e + x*%pi); x is not numeric. (%o5) [[transcendental, []], [algebraic, transcendental]] (%i6) typeof (2*%e + %pi); (%o6) [transcendental, [algebraic, transcendental]]

__Function:__**join***(*`l`,`m`)Creates a new list containing the elements of lists

`l`and`m`, interspersed. The result has elements`[`

. The lists`l`[1],`m`[1],`l`[2],`m`[2], ...]`l`and`m`may contain any type of elements.If the lists are different lengths,

`join`

ignores elements of the longer list.Maxima complains if

`L_1`or`L_2`is not a list.Examples:

(%i1) L1: [a, sin(b), c!, d - 1]; (%o1) [a, sin(b), c!, d - 1] (%i2) join (L1, [1, 2, 3, 4]); (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4] (%i3) join (L1, [aa, bb, cc, dd, ee, ff]); (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd]

__Function:__**last***(*`expr`)Returns the last part (term, row, element, etc.) of the

`expr`.

__Function:__**length***(*`expr`)Returns (by default) the number of parts in the external (displayed) form of

`expr`. For lists this is the number of elements, for matrices it is the number of rows, and for sums it is the number of terms (see`dispform`

).The

`length`

command is affected by the`inflag`

switch. So, e.g.`length(a/(b*c));`

gives 2 if`inflag`

is`false`

(Assuming`exptdispflag`

is`true`

), but 3 if`inflag`

is`true`

(the internal representation is essentially`a*b^-1*c^-1`

).

__Option variable:__**listarith**default value:

`true`

- if`false`

causes any arithmetic operations with lists to be suppressed; when`true`

, list-matrix operations are contagious causing lists to be converted to matrices yielding a result which is always a matrix. However, list-list operations should return lists.

__Function:__**listp***(*`expr`)Returns

`true`

if`expr`is a list else`false`

.

__Function:__**makelist***(*`expr`,`i`,`i_0`,`i_1`)__Function:__**makelist***(*`expr`,`x`,`list`)Constructs and returns a list, each element of which is generated from

`expr`.`makelist (`

returns a list, the`expr`,`i`,`i_0`,`i_1`)`j`

'th element of which is equal to`ev (`

for`expr`,`i`=j)`j`

equal to`i_0`through`i_1`.`makelist (`

returns a list, the`expr`,`x`,`list`)`j`

'th element of which is equal to`ev (`

for`expr`,`x`=`list`[j])`j`

equal to 1 through`length (`

.`list`)Examples:

(%i1) makelist(concat(x,i),i,1,6); (%o1) [x1, x2, x3, x4, x5, x6] (%i2) makelist(x=y,y,[a,b,c]); (%o2) [x = a, x = b, x = c]

__Function:__**member***(*`expr`,`list`)Returns

`true`

if`expr`occurs as a member of`list`(not within a member). Otherwise`false`

is returned.`member`

also works on non-list expressions, e.g.`member(b,f(a,b,c));`

->`true`

.

__Function:__**ninth***(*`expr`)Returns the 9'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**rest***(*`expr`,`n`)__Function:__**rest***(*`expr`)Returns

`expr`with its first`n`elements removed if`n`is positive and its last`-`

elements removed if`n``n`is negative. If`n`is 1 it may be omitted.`expr`may be a list, matrix, or other expression.

__Function:__**reverse***(*`list`)Reverses the order of the members of the

`list`(not the members themselves).`reverse`

also works on general expressions, e.g.`reverse(a=b);`

gives`b=a`

.

__Function:__**second***(*`expr`)Returns the 2'nd item of expression or list

`expr`. See`first`

for more details.

__Function:__**seventh***(*`expr`)Returns the 7'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**sixth***(*`expr`)Returns the 6'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**tenth***(*`expr`)Returns the 10'th item of expression or list

`expr`. See`first`

for more details.

__Function:__**third***(*`expr`)Returns the 3'rd item of expression or list

`expr`. See`first`

for more details.

[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

This document was generated on *March, 19 2006* using *texi2html 1.76*.