(maxima.info)Assignment operators
7.6 Assignment operators
========================
-- Operator: :
Assignment operator.
When the left-hand side is a simple variable (not subscripted), ':'
evaluates its right-hand side and associates that value with the
left-hand side.
When the left-hand side is a subscripted element of a list, matrix,
declared Maxima array, or Lisp array, the right-hand side is
assigned to that element. The subscript must name an existing
element; such objects cannot be extended by naming nonexistent
elements.
When the left-hand side is a subscripted element of a 'hashed
array', the right-hand side is assigned to that element, if it
already exists, or a new element is allocated, if it does not
already exist.
When the left-hand side is a list of simple and/or subscripted
variables, the right-hand side must evaluate to a list, and the
elements of the right-hand side are assigned to the elements of the
left-hand side, in parallel.
See also 'kill' and 'remvalue', which undo the association between
the left-hand side and its value.
Examples:
Assignment to a simple variable.
(%i1) a;
(%o1) a
(%i2) a : 123;
(%o2) 123
(%i3) a;
(%o3) 123
Assignment to an element of a list.
(%i1) b : [1, 2, 3];
(%o1) [1, 2, 3]
(%i2) b[3] : 456;
(%o2) 456
(%i3) b;
(%o3) [1, 2, 456]
Assignment to a variable that neither is the name of a list nor of
an array creates a 'hashed array'.
(%i1) c[99] : 789;
(%o1) 789
(%i2) c[99];
(%o2) 789
(%i3) c;
(%o3) c
(%i4) arrayinfo (c);
(%o4) [hashed, 1, [99]]
(%i5) listarray (c);
(%o5) [789]
Multiple assignment.
(%i1) [a, b, c] : [45, 67, 89];
(%o1) [45, 67, 89]
(%i2) a;
(%o2) 45
(%i3) b;
(%o3) 67
(%i4) c;
(%o4) 89
Multiple assignment is carried out in parallel. The values of 'a'
and 'b' are exchanged in this example.
(%i1) [a, b] : [33, 55];
(%o1) [33, 55]
(%i2) [a, b] : [b, a];
(%o2) [55, 33]
(%i3) a;
(%o3) 55
(%i4) b;
(%o4) 33
-- Operator: ::
Assignment operator.
'::' is the same as ':' (which see) except that '::' evaluates its
left-hand side as well as its right-hand side.
Examples:
(%i1) x : 'foo;
(%o1) foo
(%i2) x :: 123;
(%o2) 123
(%i3) foo;
(%o3) 123
(%i4) x : '[a, b, c];
(%o4) [a, b, c]
(%i5) x :: [11, 22, 33];
(%o5) [11, 22, 33]
(%i6) a;
(%o6) 11
(%i7) b;
(%o7) 22
(%i8) c;
(%o8) 33
-- Operator: ::=
Macro function definition operator. '::=' defines a function
(called a "macro" for historical reasons) which quotes its
arguments, and the expression which it returns (called the "macro
expansion") is evaluated in the context from which the macro was
called. A macro function is otherwise the same as an ordinary
function.
'macroexpand' returns a macro expansion (without evaluating it).
'macroexpand (foo (x))' followed by '''%' is equivalent to 'foo
(x)' when 'foo' is a macro function.
'::=' puts the name of the new macro function onto the global list
'macros'. 'kill', 'remove', and 'remfunction' unbind macro
function definitions and remove names from 'macros'.
'fundef' or 'dispfun' return a macro function definition or assign
it to a label, respectively.
Macro functions commonly contain 'buildq' and 'splice' expressions
to construct an expression, which is then evaluated.
Examples
A macro function quotes its arguments, so message (1) shows 'y -
z', not the value of 'y - z'. The macro expansion (the quoted
expression ''(print ("(2) x is equal to", x))') is evaluated in the
context from which the macro was called, printing message (2).
(%i1) x: %pi$
(%i2) y: 1234$
(%i3) z: 1729 * w$
(%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
'(print ("(2) x is equal to", x)))$
(%i5) printq1 (y - z);
(1) x is equal to y - z
(2) x is equal to %pi
(%o5) %pi
An ordinary function evaluates its arguments, so message (1) shows
the value of 'y - z'. The return value is not evaluated, so
message (2) is not printed until the explicit evaluation '''%'.
(%i1) x: %pi$
(%i2) y: 1234$
(%i3) z: 1729 * w$
(%i4) printe1 (x) := block (print ("(1) x is equal to", x),
'(print ("(2) x is equal to", x)))$
(%i5) printe1 (y - z);
(1) x is equal to 1234 - 1729 w
(%o5) print((2) x is equal to, x)
(%i6) ''%;
(2) x is equal to %pi
(%o6) %pi
'macroexpand' returns a macro expansion. 'macroexpand (foo (x))'
followed by '''%' is equivalent to 'foo (x)' when 'foo' is a macro
function.
(%i1) x: %pi$
(%i2) y: 1234$
(%i3) z: 1729 * w$
(%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
(%i5) macroexpand (g (y - z));
(%o5) print(x is equal to, y - z)
(%i6) ''%;
x is equal to 1234 - 1729 w
(%o6) 1234 - 1729 w
(%i7) g (y - z);
x is equal to 1234 - 1729 w
(%o7) 1234 - 1729 w
-- Operator: :=
The function definition operator.
'<f>(<x_1>, ..., <x_n>) := <expr>' defines a function named <f>
with arguments <x_1>, ..., <x_n> and function body <expr>. ':='
never evaluates the function body (unless explicitly evaluated by
quote-quote ''''). The function body is evaluated every time the
function is called.
'<f>[<x_1>, ..., <x_n>] := <expr>' defines a so-called 'memoizing
function'. Its function body is evaluated just once for each
distinct value of its arguments, and that value is returned,
without evaluating the function body, whenever the arguments have
those values again. (A function of this kind is also known as a
"array function".)
'<f>[<x_1>, ..., <x_n>](<y_1>, ..., <y_m>) := <expr>' is a special
case of a 'memoizing function'. '<f>[<x_1>, ..., <x_n>]' is a
'memoizing function' which returns a lambda expression with
arguments '<y_1>, ..., <y_m>'. The function body is evaluated once
for each distinct value of '<x_1>, ..., <x_n>', and the body of the
lambda expression is that value.
When the last or only function argument <x_n> is a list of one
element, the function defined by ':=' accepts a variable number of
arguments. Actual arguments are assigned one-to-one to formal
arguments <x_1>, ..., <x_(n - 1)>, and any further actual
arguments, if present, are assigned to <x_n> as a list.
All function definitions appear in the same namespace; defining a
function 'f' within another function 'g' does not automatically
limit the scope of 'f' to 'g'. However, 'local(f)' makes the
definition of function 'f' effective only within the block or other
compound expression in which 'local' appears.
If some formal argument <x_k> is a quoted symbol, the function
defined by ':=' does not evaluate the corresponding actual
argument. Otherwise all actual arguments are evaluated.
See also 'define' and '::='.
Examples:
':=' never evaluates the function body (unless explicitly evaluated
by quote-quote).
(%i1) expr : cos(y) - sin(x);
(%o1) cos(y) - sin(x)
(%i2) F1 (x, y) := expr;
(%o2) F1(x, y) := expr
(%i3) F1 (a, b);
(%o3) cos(y) - sin(x)
(%i4) F2 (x, y) := ''expr;
(%o4) F2(x, y) := cos(y) - sin(x)
(%i5) F2 (a, b);
(%o5) cos(b) - sin(a)
'f(<x_1>, ..., <x_n>) := ...' defines an ordinary function.
(%i1) G1(x, y) := (print ("Evaluating G1 for x=", x, "and y=", y), x.y - y.x);
(%o1) G1(x, y) := (print("Evaluating G1 for x=", x, "and y=",
y), x . y - y . x)
(%i2) G1([1, a], [2, b]);
Evaluating G1 for x= [1, a] and y= [2, b]
(%o2) 0
(%i3) G1([1, a], [2, b]);
Evaluating G1 for x= [1, a] and y= [2, b]
(%o3) 0
'f[<x_1>, ..., <x_n>] := ...' defines a 'memoizing function'.
(%i1) G2[a] := (print ("Evaluating G2 for a=", a), a^2);
2
(%o1) G2 := (print("Evaluating G2 for a=", a), a )
a
(%i2) G2[1234];
Evaluating G2 for a= 1234
(%o2) 1522756
(%i3) G2[1234];
(%o3) 1522756
(%i4) G2[2345];
Evaluating G2 for a= 2345
(%o4) 5499025
(%i5) arrayinfo (G2);
(%o5) [hashed, 1, [1234], [2345]]
(%i6) listarray (G2);
(%o6) [1522756, 5499025]
'<f>[<x_1>, ..., <x_n>](<y_1>, ..., <y_m>) := <expr>' is a special
case of a 'memoizing function'.
(%i1) G3[n](x) := (print ("Evaluating G3 for n=", n), diff (sin(x)^2, x, n));
(%o1) G3 (x) := (print("Evaluating G3 for n=", n),
n
2
diff(sin (x), x, n))
(%i2) G3[2];
Evaluating G3 for n= 2
2 2
(%o2) lambda([x], 2 cos (x) - 2 sin (x))
(%i3) G3[2];
2 2
(%o3) lambda([x], 2 cos (x) - 2 sin (x))
(%i4) G3[2](1);
2 2
(%o4) 2 cos (1) - 2 sin (1)
(%i5) arrayinfo (G3);
(%o5) [hashed, 1, [2]]
(%i6) listarray (G3);
2 2
(%o6) [lambda([x], 2 cos (x) - 2 sin (x))]
When the last or only function argument <x_n> is a list of one
element, the function defined by ':=' accepts a variable number of
arguments.
(%i1) H ([L]) := apply ("+", L);
(%o1) H([L]) := apply("+", L)
(%i2) H (a, b, c);
(%o2) c + b + a
'local' makes a local function definition.
(%i1) foo (x) := 1 - x;
(%o1) foo(x) := 1 - x
(%i2) foo (100);
(%o2) - 99
(%i3) block (local (foo), foo (x) := 2 * x, foo (100));
(%o3) 200
(%i4) foo (100);
(%o4) - 99
automatically generated by info2www version 1.2.2.9