Siguiente: Definición de Funciones, Anterior: Reglas y patrones [Índice general][Índice]
Siguiente: Funciones y variables para los conjuntos, Anterior: Conjuntos, Subir: Conjuntos [Índice general][Índice]
Maxima dispone de funciones para realizar operaciones con conjuntos, como la intersección o la unión. Los conjuntos deben ser finitos y definidos por enumeración. Maxima trata a los conjuntos y a las listas como objectos de distinta naturaleza, lo que permite trabajar con conjuntos cuyos elementos puedan ser también conjuntos o listas.
Además de funciones para operar con conjuntos finitos, Maxima dispone también de algunas funciones sobre combinatoria, como los números de Stirling de primera y segunda especie, números de Bell, coeficientes multinomiales, particiones de enteros no negativos y algunos otros. Maxima también define la función delta de Kronecker.
Para construir un conjunto cuyos elementos sean a_1, ..., a_n, se utiliza la instrucción set(a_1, ..., a_n) o {a_1, ..., a_n}; para formar un conjunto vacío, basta con hacer set() o {}. Para introducir conjuntos en Maxima, set (...) y { ... } son equivalentes. Los conjuntos se muestran siempre con llave.
Si un elemento se indica más de una vez, el proceso de simplificación elimina los elementos redundantes.
(%i1) set();
(%o1) {}
(%i2) set(a, b, a);
(%o2) {a, b}
(%i3) set(a, set(b));
(%o3) {a, {b}}
(%i4) set(a, [b]);
(%o4) {a, [b]}
(%i5) {};
(%o5) {}
(%i6) {a, b, a};
(%o6) {a, b}
(%i7) {a, {b}};
(%o7) {a, {b}}
(%i8) {a, [b]};
(%o8) {a, [b]}
Dos elementos candidatos a formar parte de un conjunto, x e y,
son redundantes, esto es, se consideran el mismo elemento a
efectos de consruir el conjunto, si y sólo si is (x = y)
devuelve el valor true. Nótese que is (equal (x, y))
puede devolver true y is (x = y) retornar
false; en cuyo caso los elementos x e y se
considerarían distintos.
(%i1) x: a/c + b/c;
b a
(%o1) - + -
c c
(%i2) y: a/c + b/c;
b a
(%o2) - + -
c c
(%i3) z: (a + b)/c;
b + a
(%o3) -----
c
(%i4) is (x = y);
(%o4) true
(%i5) is (y = z);
(%o5) false
(%i6) is (equal (y, z));
(%o6) true
(%i7) y - z;
b + a b a
(%o7) - ----- + - + -
c c c
(%i8) ratsimp (%);
(%o8) 0
(%i9) {x, y, z};
b + a b a
(%o9) {-----, - + -}
c c c
Para formar un conjunto a partir de los miembros de una lista úsese setify.
(%i1) setify([b, a]);
(%o1) {a, b}
Los elementos x e y de un conjunto se consideran iguales si is(x = y) devuelve el valor true. Así, rat(x) y x se consideran el mismo elemento de un conjunto; consecuentemente,
(%i1) {x, rat(x)};
(%o1) {x}
Además, puesto que is((x-1)*(x+1) = x^2 - 1) devuelve false, (x-1)*(x+1) y x^2-1 se consideran elementos diferentes; así
(%i1) {(x - 1)*(x + 1), x^2 - 1};
2
(%o1) {(x - 1) (x + 1), x - 1}
Para reducir este conjunto a otro unitario, aplicar rat a cada elemento del conjunto:
(%i1) {(x - 1)*(x + 1), x^2 - 1};
2
(%o1) {(x - 1) (x + 1), x - 1}
(%i2) map (rat, %);
2
(%o2)/R/ {x - 1}
Para eliminar redundancias con otros conjuntos, será necesario utilizar otras funciones de simplificación. He aquí un ejemplo que utiliza trigsimp:
(%i1) {1, cos(x)^2 + sin(x)^2};
2 2
(%o1) {1, sin (x) + cos (x)}
(%i2) map (trigsimp, %);
(%o2) {1}
Se entiende que un conjunto está simplificado cuando entre sus elementos no hay redundancias y se hayan ordenados. La versión actual de las funciones para conjuntos utiliza la función orderlessp de Maxima para ordenar sus elementos; sin embargo, futuras versiones de las funciones para operar con conjuntos podrán utilizar otras funciones de ordenación.
Algunas operaciones con conjuntos, tales como la sustitución, fuerzan automáticamente una re-simplificación; por ejemplo,
(%i1) s: {a, b, c}$
(%i2) subst (c=a, s);
(%o2) {a, b}
(%i3) subst ([a=x, b=x, c=x], s);
(%o3) {x}
(%i4) map (lambda ([x], x^2), set (-1, 0, 1));
(%o4) {0, 1}
Maxima considera a las listas y conjuntos como objetos diferentes;
funciones tales como union y intersection emitirán
un error si alguno de sus argumentos no es un conjunto. Si se
necesita aplicar una función de conjunto a una lista, se deberá
utilizar la función setify para convertirla previamente en conjunto.
Así,
(%i1) union ([1, 2], {a, b});
Function union expects a set, instead found [1,2]
-- an error. Quitting. To debug this try debugmode(true);
(%i2) union (setify ([1, 2]), {a, b});
(%o2) {1, 2, a, b}
Para extraer todos los elementos de un conjunto s que satisfagan un predicado f, úsese subset(s,f). (Un predicado es una función booleana.) Por ejemplo, para encontrar las ecuaciones en un conjunto dado que no dependan de la variable z, se hará
(%i1) subset ({x + y + z, x - y + 4, x + y - 5},
lambda ([e], freeof (z, e)));
(%o1) {- y + x + 4, y + x - 5}
La sección Funciones y variables para los conjuntos incluye una lista completa de funciones para operar con conjuntos en Maxima.
Hay dos formas para operar iterativamente sobre los elementos de un conjunto. Una es utilizar map; por ejemplo:
(%i1) map (f, {a, b, c});
(%o1) {f(a), f(b), f(c)}
La otra forma consiste en hacer uso de la construcción for x in s do
(%i1) s: {a, b, c};
(%o1) {a, b, c}
(%i2) for si in s do print (concat (si, 1));
a1
b1
c1
(%o2) done
Las funciones de Maxima first y rest funcionan también con conjuntos. En este caso, first devuelve el primer elemento que se muestra del conjunto, el cual puede depender de la implementación del sistema. Si s es un conjunto, entonces rest(s) equivale a disjoin (first(s), s). Hay otras funciones que trabajan correctamente con conjuntos. En próximas versiones de las funciones para operar con conjuntos es posible que first y rest trabajen de modo diferente o que ya no lo hagan en absoluto.
Las funciones para operar con conjuntos utilizan la función orderlessp
de Maxima para ordenar los elementos de los conjuntos, así
como la función like de Lisp para decidir sobre la igualdad de dichos
elementos. Ambas funciones tienen fallos que son conocidos y que pueden
aflorar si se trabaja con conjuntos que tengan elementos en formato de
listas o matrices y que contengan expresiones racionales canónicas (CRE).
Un ejemplo es
(%i1) {[x], [rat (x)]};
Maxima encountered a Lisp error:
The value #:X1440 is not of type LIST.
Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
Esta expresión provoca una parada de Maxima junto con la emisión de un mensaje de error, el cual dependerá de la versión de Lisp que utilice Maxima. Otro ejemplo es
(%i1) setify ([[rat(a)], [rat(b)]]); Maxima encountered a Lisp error: The value #:A1440 is not of type LIST. Automatically continuing. To reenable the Lisp debugger set *debugger-hook* to nil.
Estos fallos son causados por fallos en orderlessp y like,
no por fallos cuyo origen se encuentre en las funciones para conjuntos.
Para ilustrarlo, se pueden ejecutar las siguientes expresiones
(%i1) orderlessp ([rat(a)], [rat(b)]); Maxima encountered a Lisp error: The value #:B1441 is not of type LIST. Automatically continuing. To reenable the Lisp debugger set *debugger-hook* to nil. (%i2) is ([rat(a)] = [rat(a)]); (%o2) false
Hasta que estos errores no se corrijan, no es aconsejable construir conjuntos que tengan por elementos listas o matrices que contengan expresiones en forma CRE; sin embargo, un conjunto con elementos de la forma CRE no deberían dar problemas:
(%i1) {x, rat (x)};
(%o1) {x}
La función orderlessp de Maxima tiene otro fallo que puede causar problemas con las funciones para conjuntos, en concreto, que el predicado de ordenación orderlessp no es transitivo. El ejemplo más simple que ilustra este punto es
(%i1) q: x^2$ (%i2) r: (x + 1)^2$ (%i3) s: x*(x + 2)$ (%i4) orderlessp (q, r); (%o4) true (%i5) orderlessp (r, s); (%o5) true (%i6) orderlessp (q, s); (%o6) false
El fallo puede causar problemas con todas las funciones para conjuntos,
así como también con otras funciones de Maxima.
Es probable, pero no seguro, que este fallo se puede evitar si todos
los elementos del conjunto están en la forma de expresión racional
canónica (CRE) o han sido simplificados con ratsimp.
Los mecanismos orderless y ordergreat de Maxima son incompatibles
con las funciones para conjuntos. Si se necesitan utilizar orderless o
ordergreat, hágase antes de construir los conjuntos y no se utilice
la instrucción unorder.
Se ruega a todo usuario que crea haber encontrado un fallo en las funciones para conjuntos que lo comunique en la base de datos de Maxima. Véase bug_report.
Stavros Macrakis de Cambridge, Massachusetts y Barton Willis de la University of Nebraska at Kearney (UNK).
Anterior: Introducción a los conjuntos, Subir: Conjuntos [Índice general][Índice]
Calcula la unión del conjunto a y {x}.
La función adjoin emite un mensaje de error si a
no es un conjunto literal.
Las sentencias adjoin(x, a) y
union(set(x), a) son equivalentes, aunque
adjoin puede ser algo más rápida que union.
Véase también disjoin.
Ejemplos:
(%i1) adjoin (c, {a, b});
(%o1) {a, b, c}
(%i2) adjoin (a, {a, b});
(%o2) {a, b}
Representa el n-ésimo número de Bell, de
modo que belln(n) es el número de particiones de un conjunto de
n elementos.
El argumento n debe ser un entero no negativo.
La función belln se distribuye sobre ecuaciones, listas,
matrices y conjuntos.
Ejemplos:
belln se aplica a enteros no negativos,
(%i1) makelist (belln (i), i, 0, 6);
(%o1) [1, 1, 2, 5, 15, 52, 203]
(%i2) is (cardinality (set_partitions ({})) = belln (0));
(%o2) true
(%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6}))
= belln (6));
(%o3) true
Si n no es un entero no negativo, la función belln(n) no hace cálculo alguno.
(%i1) [belln (x), belln (sqrt(3)), belln (-9)]; (%o1) [belln(x), belln(sqrt(3)), belln(- 9)]
Devuelve el número de elementos del conjunto a.
La función cardinality ignora los elementos
redundantes, incluso cuando la simplificación está
desabilitada.
Ejemplos:
(%i1) cardinality ({});
(%o1) 0
(%i2) cardinality ({a, a, b, c});
(%o2) 3
(%i3) simp : false;
(%o3) false
(%i4) cardinality ({a, a, b, c});
(%o4) 3
Devuelve un conjunto formado por listas de la forma [x_1, ..., x_n],
siendo x_1, ..., x_n elementos de los conjuntos b_1, ... , b_n,
respectivamente.
La función cartesian_product emite un mensaje de error si alguno
de sus argumentos no es un conjunto literal.
Ejemplos:
(%i1) cartesian_product ({0, 1});
(%o1) {[0], [1]}
(%i2) cartesian_product ({0, 1}, {0, 1});
(%o2) {[0, 0], [0, 1], [1, 0], [1, 1]}
(%i3) cartesian_product ({x}, {y}, {z});
(%o3) {[x, y, z]}
(%i4) cartesian_product ({x}, {-1, 0, 1});
(%o4) {[x, - 1], [x, 0], [x, 1]}
Devuelve el conjunto a sin el elemento x. Si x no es elemento de a, entonces el resultado es el propio a.
La función disjoin emite un mensaje de error si
a no es un conjunto literal.
Las sentencias disjoin(x, a), delete(x, a)
y setdifference(a, set(x)) son todas ellas equivalentes;
pero en general, disjoin será más rápida que las otras.
Ejemplos:
(%i1) disjoin (a, {a, b, c, d});
(%o1) {b, c, d}
(%i2) disjoin (a + b, {5, z, a + b, %pi});
(%o2) {5, %pi, z}
(%i3) disjoin (a - b, {5, z, a + b, %pi});
(%o3) {5, %pi, b + a, z}
Devuelve true si y sólo si los conjuntos a y b
son disjuntos.
La función disjointp emite un mensaje de error si
a o b no son conjuntos literales.
Ejemplos:
(%i1) disjointp ({a, b, c}, {1, 2, 3});
(%o1) true
(%i2) disjointp ({a, b, 3}, {1, 2, 3});
(%o2) false
Calcula el conjunto de divisores de n.
La sentencia divisors(n) devuelve un conjunto
de enteros si n es un entero no nulo.
El conjunto de divisores incluye los elementos 1 y n.
Los divisores de un entero negativo son los divisores de su
valor absoluto.
La función divisors se distribuye sobre las ecuaciones,
listas, matrices y conjuntos.
Ejemplos:
Se puede comprobar que 28 es un número perfecto: la suma de sus divisores (excepto él mismo) es 28.
(%i1) s: divisors(28);
(%o1) {1, 2, 4, 7, 14, 28}
(%i2) lreduce ("+", args(s)) - 28;
(%o2) 28
La función divisors es simplificadora.
Haciendo la sustitución de a por 8 en divisors(a)
devuelve los divisores sin tener que reevaluar divisors(8),
(%i1) divisors (a);
(%o1) divisors(a)
(%i2) subst (8, a, %);
(%o2) {1, 2, 4, 8}
La función divisors se distribuye sobre ecuaciones, listas,
matrices y conjuntos.
(%i1) divisors (a = b);
(%o1) divisors(a) = divisors(b)
(%i2) divisors ([a, b, c]);
(%o2) [divisors(a), divisors(b), divisors(c)]
(%i3) divisors (matrix ([a, b], [c, d]));
[ divisors(a) divisors(b) ]
(%o3) [ ]
[ divisors(c) divisors(d) ]
(%i4) divisors ({a, b, c});
(%o4) {divisors(a), divisors(b), divisors(c)}
Devuelve true si y sólo si x es miembro del
conjunto a.
La función elementp emite un mensaje de error si
a no es un conjunto literal.
Ejemplos:
(%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
(%o1) true
(%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
(%o2) false
Devuelve true si y sólo si a es el conjunto vacío o la lista vacía.
Ejemplos:
(%i1) map (emptyp, [{}, []]);
(%o1) [true, true]
(%i2) map (emptyp, [a + b, {{}}, %pi]);
(%o2) [false, false, false]
Devuelve el conjunto de las clases de equivalencia del conjunto s respecto de la relación de equivalencia F.
El argumento F es una función de dos variables definida sobre
el producto cartesiano s por s.
El valor devuelto por F debe ser true o false,
o bien una expresión expr tal que is(expr)
tome el valor true o false.
Si F no es una relación de equivalencia, equiv_classes
la acepta sin emitir ningún mensaje de error, pero el resultado
será incorrecto en general.
Ejemplos:
La relación de equivalencia es una expresión lambda que devuelve
true o false,
(%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
lambda ([x, y], is (equal (x, y))));
(%o1) {{1, 1.0}, {2, 2.0}, {3, 3.0}}
La relación de equivalencia es el nombre de una función relacional
en la que is evalúa a true o false,
(%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
(%o1) {{1, 1.0}, {2, 2.0}, {3, 3.0}}
Las clases de equivalencia son números que difieren en un múltiplo de 3.
(%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7},
lambda ([x, y], remainder (x - y, 3) = 0));
(%o1) {{1, 4, 7}, {2, 5}, {3, 6}}
Devuelve true si el predicado f vale true
para todos los argumentos dados.
Dado un conjunto como segundo argumento,
every(f, s) devuelve true
si is(f(a_i)) devuelve true para todos los
a_i pertenecientes s.
La función every puede evaluar o no f para todos los
a_i pertenecientes s.
Puesto que los conjuntos no están ordenados, every
puede evaluar f(a_i) en cualquier orden.
Dada una o más listas como argumentos,
every(f, L_1, ..., L_n) devuelve true
si is(f(x_1, ..., x_n)) devuelve true
para todo x_1, ..., x_n en L_1, ..., L_n, respectivamente.
La función every puede evaluar o no
f para cualquier combinación de x_1, ..., x_n; además,
every evalúa las listas en el orden creciente del índice.
Dado un conjunto vacío {} o lista vacía
[] como argumentos, every devuelve false.
Si la variable global maperror vale true, todas las listas
L_1, ..., L_n deben ser de igual longitud.
Si maperror vale false, los argumentos en forma de listas
se truncan para igualar sus longitudes a la de la lista más corta.
Los valores que devuelve el predicado f cuando toman
(mediante is) un valor diferente a true y false
se controlan con la variable global prederror.
Si prederror vale true, tales valores se
consideran como false y la respuesta de every es false.
Si prederror vale false, tales valores se
consideran como desconocidos (unknown) y la respuesta de
every es unknown.
Ejemplos:
Se aplica every a un único conjunto.
El predicado es una función de un argumento.
(%i1) every (integerp, {1, 2, 3, 4, 5, 6});
(%o1) true
(%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
(%o2) false
Se aplica every a dos listas.
El predicado es una función de dos argumentos.
(%i1) every ("=", [a, b, c], [a, b, c]);
(%o1) true
(%i2) every ("#", [a, b, c], [a, b, c]);
(%o2) false
Las respuestas del predicado f que se evalúan
a cualquier cosa diferente de true y false
están controlados por la variable global prederror.
(%i1) prederror : false;
(%o1) false
(%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
[x^2, y^2, z^2]);
(%o2) [unknown, unknown, unknown]
(%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
(%o3) unknown
(%i4) prederror : true;
(%o4) true
(%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
(%o5) false
Calcula el subconjunto de s para el cual la función f toma sus valores mayor y menor.
La sentencia extremal_subset(s, f, max)
devuelve el subconjunto del conjunto o lista s para el cual
la función real f toma su valor máximo.
La sentencia extremal_subset(s, f, min)
devuelve el subconjunto del conjunto o lista s para el cual
la función real f toma su valor mínimo.
Ejemplos
(%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
(%o1) {- 2, 2}
(%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
(%o2) {sqrt(2)}
Recoge los argumentos de subexpresiones con el mismo operador que expr y construye con ellas otra expresión a partir de estos argumentos.
Aquellas subexpresiones en las que el operador es diferente del operador
principal de expr se copian sin modificarse, incluso cuando ellas
mismas contengan subexpresiones en las que el operador sea el mismo
que el de expr.
Es posible que flatten construya expresiones en las que el número
de argumentos difiera del número admitido por el operador, lo cual
hará que se emita un mensaje de error. La función flatten
no intentará detectar estas situaciones.
Las expresiones que tengan representaciones especiales, por ejemplo las racionales
canónicas (CRE), no admiten que se aplique sobre ellas la función flatten;
en tales casos se devuelve el argumento sin modificación.
Ejemplos:
Aplicada a una lista, flatten reune todos los elementos que son a su vez listas.
(%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]); (%o1) [a, b, c, d, e, f, g, h, i, j]
Aplicado a un conjunto, flatten reune todos los elementos que son a su vez conjuntos.
(%i1) flatten ({a, {b}, {{c}}});
(%o1) {a, b, c}
(%i2) flatten ({a, {[a], {a}}});
(%o2) {a, [a]}
La función flatten es similar a la declaración del operador
principal como n-ario. Sin embargo, flatten no tiene efecto alguno
sobre subexpresiones que tengan un operador diferente del principal, mientras
que sí lo tiene una declaración n-aria.
(%i1) expr: flatten (f (g (f (f (x))))); (%o1) f(g(f(f(x)))) (%i2) declare (f, nary); (%o2) done (%i3) ev (expr); (%o3) f(g(f(x)))
La función flatten trata las funciones subindicadas como
a cualquier otro operador.
(%i1) flatten (f[5] (f[5] (x, y), z));
(%o1) f (x, y, z)
5
Es posible que flatten construya expresiones en las que el número
de argumentos difiera del número admitido por el operador.
(%i1) 'mod (5, 'mod (7, 4)); (%o1) mod(5, mod(7, 4)) (%i2) flatten (%); (%o2) mod(5, 7, 4) (%i3) ''%, nouns; Wrong number of arguments to mod -- an error. Quitting. To debug this try debugmode(true);
Sustituye los operadores de conjunto presentes en a
por operadores de listas, devolviendo el resultado.
La función full_listify sustituye operadores de
conjuntos en subexpresiones anidadas, incluso cuando
el operador principal no es set.
La función listify sustituye únicamente el
operador principal.
Ejemplos:
(%i1) full_listify ({a, b, {c, {d, e, f}, g}});
(%o1) [a, b, [c, [d, e, f], g]]
(%i2) full_listify (F (G ({a, b, H({c, d, e})})));
(%o2) F(G([a, b, H([c, d, e])]))
Si a es una lista, sustituye el operador de lista por el
de conjunto, aplicando posteriormente fullsetify a todos
los elementos que son a su vez conjuntos.
Si a no es una lista, se devuelve sin cambio alguno.
La función setify sustituye solamente el operador principal.
Ejemplos:
En la salida (%o2) el argumento de f no se convierte en
conjunto porque el operador principal de f([b]) no es una lista.
(%i1) fullsetify ([a, [a]]);
(%o1) {a, {a}}
(%i2) fullsetify ([a, f([b])]);
(%o2) {a, f([b])}
La función identity devuelve su argumento cualquiera que sea éste.
Ejemplos:
La función identity puede utilizarse como predicado cuando
los argumentos ya son valores booleanos.
(%i1) every (identity, [true, true]); (%o1) true
Devuelve particiones enteras de n, esto es, listas de enteros cuyas sumas son n.
La sentencia integer_partitions(n)
devuelve el conjunto de todas las particiones del entero n.
Cada partición es una lista ordenada de mayor a menor.
La sentencia integer_partitions(n, len)
devuelve todas las particiones de longitud len o menor;
en este caso, se añaden ceros a cada partición con menos
de len términos para que todas ellas sean de longitud
len. Las particiones son listas ordenadas de mayor a menor.
Una lista [a_1, ..., a_m] es una partición de un entero no negativo n si (1) cada a_i es entero no nulo y (2) a_1 + ... + a_m = n. Así, 0 no tiene particiones.
Ejemplos:
(%i1) integer_partitions (3);
(%o1) {[1, 1, 1], [2, 1], [3]}
(%i2) s: integer_partitions (25)$
(%i3) cardinality (s);
(%o3) 1958
(%i4) map (lambda ([x], apply ("+", x)), s);
(%o4) {25}
(%i5) integer_partitions (5, 3);
(%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
(%i6) integer_partitions (5, 2);
(%o6) {[3, 2], [4, 1], [5, 0]}
Para encontrar todas las particiones que satisfagan cierta
condición, utilícese la función subset;
he aquí un ejemplo que encuentra todas las
particiones de 10 formadas por números primos.
(%i1) s: integer_partitions (10)$
(%i2) cardinality (s);
(%o2) 42
(%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
(%i4) subset (s, lambda ([x], every (xprimep, x)));
(%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}
Es una forma abreviada de la función intersection.
Devuelve el conjunto de todos los elementos que son comunes a los conjuntos a_1 a a_n.
Emite un mensaje de error en caso de que cualquiera de los a_i no sea un conjunto.
Ejemplos:
(%i1) S_1 : {a, b, c, d};
(%o1) {a, b, c, d}
(%i2) S_2 : {d, e, f, g};
(%o2) {d, e, f, g}
(%i3) S_3 : {c, d, e, f};
(%o3) {c, d, e, f}
(%i4) S_4 : {u, v, w};
(%o4) {u, v, w}
(%i5) intersection (S_1, S_2);
(%o5) {d}
(%i6) intersection (S_2, S_3);
(%o6) {d, e, f}
(%i7) intersection (S_1, S_2, S_3);
(%o7) {d}
(%i8) intersection (S_1, S_2, S_3, S_4);
(%o8) {}
Es la función delta de Kronecker.
La función kron_delta devuelve 1 cuando xi y
yi son iguales para todos los pares, devolviendo 0 si existe
un par en el que xi y yi no sean iguales. La igualdad
se determina utilizando is(equal(xi,xj)) y la desigualdad
con is(notequal(xi,xj)). En caso de un solo argumento,
kron_delta devuelve un mensaje de error.
Ejemplos:
(%i1) kron_delta(a,a); (%o1) 1 (%i2) kron_delta(a,b,a,b); (%o2) kron_delta(a, b) (%i3) kron_delta(a,a,b,a+1); (%o3) 0 (%i4) assume(equal(x,y)); (%o4) [equal(x, y)] (%i5) kron_delta(x,y); (%o5) 1
Si a es un conjunto, devuelve una lista con los elementos de a; si a no es un conjunto, devuelve a.
La función full_listify sustituye todos los operadores
de conjunto en a por operadores de lista.
Ejemplos:
(%i1) listify ({a, b, c, d});
(%o1) [a, b, c, d]
(%i2) listify (F ({a, b, c, d}));
(%o2) F({a, b, c, d})
Amplía la función binaria F a n-aria mediante composición, siendo s una lista.
La sentencia lreduce(F, s) devuelve
F(... F(F(s_1, s_2), s_3), ... s_n).
Si se incluye el argumento opcional s_0,
el resultado equivale a lreduce(F, cons(s_0, s)).
La función F se aplica primero a los elementos del
extremo izquierdo de la lista, de ahí el nombre
lreduce, (left reduce).
Véanse también rreduce, xreduce y tree_reduce.
Ejemplos:
La función lreduce sin el argumento opcional,
(%i1) lreduce (f, [1, 2, 3]); (%o1) f(f(1, 2), 3) (%i2) lreduce (f, [1, 2, 3, 4]); (%o2) f(f(f(1, 2), 3), 4)
La función lreduce con el argumento opcional,
(%i1) lreduce (f, [1, 2, 3], 4); (%o1) f(f(f(4, 1), 2), 3)
La función lreduce aplicada a operadores binarios de Maxima.
El símbolo / es el operador división.
(%i1) lreduce ("^", args ({a, b, c, d}));
b c d
(%o1) ((a ) )
(%i2) lreduce ("/", args ({a, b, c, d}));
a
(%o2) -----
b c d
Genera un conjunto cuyos miembros se generan a partir de la expresión expr, siendo x una lista de variables de expr y s un conjunto o lista de listas. Para generar los elementos del conjunto, se evalúa expr asignando a las variables de x los elementos de s en paralelo.
Los elementos de s deben tener la misma longitud que x. La lista de variables x debe ser una lista de símbolos sin subíndices. Cuando se trate de un único símbolo, x debe expresarse como una lista de un elemento y cada elemento de s debe ser una lista de un sólo elemento.
Véase también makelist.
Ejemplos:
(%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1 2 3 4
(%o1) {-, -, -, -}
a b c d
(%i2) S : {x, y, z}$
(%i3) S3 : cartesian_product (S, S, S);
(%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
[x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
[y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
[y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
[z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
[z, z, y], [z, z, z]}
(%i4) makeset (i + j + k, [i, j, k], S3);
(%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
z + 2 y, 2 z + x, 2 z + y}
(%i5) makeset (sin(x), [x], {[1], [2], [3]});
(%o5) {sin(1), sin(2), sin(3)}
Representa la función de Moebius.
Si n es el producto de k números primos diferentes,
moebius(n) devuelve (-1)^k, retornando 1 si
n = 1 y 0 para cualesquiera otros enteros positivos.
La función de Moebius se distribuye respecto de ecuaciones, listas, matrices y conjuntos.
Ejemplos:
(%i1) moebius (1);
(%o1) 1
(%i2) moebius (2 * 3 * 5);
(%o2) - 1
(%i3) moebius (11 * 17 * 29 * 31);
(%o3) 1
(%i4) moebius (2^32);
(%o4) 0
(%i5) moebius (n);
(%o5) moebius(n)
(%i6) moebius (n = 12);
(%o6) moebius(n) = 0
(%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
(%o7) [- 1, 1, 1]
(%i8) moebius (matrix ([11, 12], [13, 14]));
[ - 1 0 ]
(%o8) [ ]
[ - 1 1 ]
(%i9) moebius ({21, 22, 23, 24});
(%o9) {- 1, 0, 1}
Calcula el coeficiente multinomial.
Si todos los a_k son enteros no negativos, el coeficiente multinomial
es el número de formas de colocar a_1 + ... + a_n
objetos diferentes en n cajas con a_k elementos en la
k-ésima caja. En general,
multinomial_coeff (a_1, ..., a_n) calcula
(a_1 + ... + a_n)!/(a_1! ... a_n!).
Si no se dan argumentos, multinomial_coeff() devuelve 1.
Se puede usar minfactorial para simplificar el valor
devuelto por multinomial_coeff.
Ejemplos:
(%i1) multinomial_coeff (1, 2, x);
(x + 3)!
(%o1) --------
2 x!
(%i2) minfactorial (%);
(x + 1) (x + 2) (x + 3)
(%o2) -----------------------
2
(%i3) multinomial_coeff (-6, 2);
(- 4)!
(%o3) --------
2 (- 6)!
(%i4) minfactorial (%);
(%o4) 10
Si n es un entero no negativo, devuelve el número de
particiones enteras distintas de n, en caso contrario
num_distinct_partitions devuelve una forma nominal.
La sentencia num_distinct_partitions(n, list)
devuelve una lista con el número de particiones distintas
de 1, 2, 3, ..., n.
Una partición distinta de n es una lista de números enteros positivos distintos k_1, ..., k_m tales que n = k_1 + ... + k_m.
Ejemplos:
(%i1) num_distinct_partitions (12); (%o1) 15 (%i2) num_distinct_partitions (12, list); (%o2) [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15] (%i3) num_distinct_partitions (n); (%o3) num_distinct_partitions(n)
Si n es un entero no negativo, devuelve el número de
particiones enteras de n, en caso contrario num_partitions
devuelve una expresión nominal.
La sentencia num_partitions(n, list) devuelve una lista
con los números de particiones enteras de 1, 2, 3, ..., n.
Siendo n un entero no negativo, num_partitions(n)
es igual a cardinality(integer_partitions(n)); sin
embargo, num_partitions no construye el conjunto de
particiones, por lo que es más rápido.
Ejemplos:
(%i1) num_partitions (5) = cardinality (integer_partitions (5)); (%o1) 7 = 7 (%i2) num_partitions (8, list); (%o2) [1, 1, 2, 3, 5, 7, 11, 15, 22] (%i3) num_partitions (n); (%o3) num_partitions(n)
Particiona el conjunto a respecto del predicado f.
La función partition_set devuelve una lista con dos conjuntos;
el primer conjunto es el subconjunto de a para el cual el predicado
f devuelve false y el segundo contiene al resto de elementos de a.
La función partition_set no aplica is al valor devuelto
por f.
La función partition_set emite un mensaje de error si a
no es un conjunto literal.
Véase también subset.
Ejemplos:
(%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
(%o1) [{1, 7}, {2, 8}]
(%i2) partition_set ({x, rat(y), rat(y) + z, 1},
lambda ([x], ratp(x)));
(%o2)/R/ [{1, x}, {y, y + z}]
Devuelve un conjunto con todas las permutaciones distintas de los miembros de la lista o conjunto a. Cada permutación es una lista, no un conjunto.
Si a es una lista, sus miembros duplicados no son eliminados antes de buscar sus permutaciones.
Si a no es una lista o conjunto, permutations emite
un mensaje de error.
Véase también random_permutation.
Ejemplos:
(%i1) permutations ([a, a]);
(%o1) {[a, a]}
(%i2) permutations ([a, a, b]);
(%o2) {[a, a, b], [a, b, a], [b, a, a]}
Devuelve el conjunto de todos los subconjuntos del conjunto a o un sunconjunto de ellos.
La sentencia powerset(a) devuelve el conjunto de todos
los subconjuntos de a, que contendrá 2^cardinality(a)
elementos.
La sentencia powerset(a, n) devuelve el conjunto de todos
los subconjuntos de a de cardinalidad n.
La función powerset emite un mensaje de error si a no
es un conjunto literal o si n no es un entero no negativo.
Ejemplos:
(%i1) powerset ({a, b, c});
(%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
(%i2) powerset ({w, x, y, z}, 4);
(%o2) {{w, x, y, z}}
(%i3) powerset ({w, x, y, z}, 3);
(%o3) {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
(%i4) powerset ({w, x, y, z}, 2);
(%o4) {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
(%i5) powerset ({w, x, y, z}, 1);
(%o5) {{w}, {x}, {y}, {z}}
(%i6) powerset ({w, x, y, z}, 0);
(%o6) {{}}
Devuelve una permutación aleatoria del conjunto o lista a, siguiendo el algoritmo de Knuth.
El valor devuelto es una lista nueva distinta del argumento, incluso cuando todos los elementos son iguales. Sin embargo, los elementos del argumento no se copian.
Ejemplos:
(%i1) random_permutation ([a, b, c, 1, 2, 3]);
(%o1) [c, 1, 2, 3, a, b]
(%i2) random_permutation ([a, b, c, 1, 2, 3]);
(%o2) [b, 3, 1, c, a, 2]
(%i3) random_permutation ({x + 1, y + 2, z + 3});
(%o3) [y + 2, z + 3, x + 1]
(%i4) random_permutation ({x + 1, y + 2, z + 3});
(%o4) [x + 1, y + 2, z + 3]
Amplía la función binaria F a n-aria mediante composición, siendo s una lista.
La sentencia rreduce(F, s) devuelve
F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n))).
Si se incluye el argumento opcional s_{n + 1},
el resultado equivale a rreduce(F, endcons(s_{n + 1}, s)).
La función F se aplica primero a los elementos del
extremo derecho de la lista, de ahí el nombre
rreduce, (right reduce).
Véanse también lreduce, xreduce y tree_reduce.
Ejemplos:
La función rreduce sin el argumento opcional,
(%i1) rreduce (f, [1, 2, 3]); (%o1) f(1, f(2, 3)) (%i2) rreduce (f, [1, 2, 3, 4]); (%o2) f(1, f(2, f(3, 4)))
La función rreduce con el argumento opcional,
(%i1) rreduce (f, [1, 2, 3], 4); (%o1) f(1, f(2, f(3, 4)))
La función rreduce aplicada a operadores binarios de Maxima.
El símbolo / es el operador división.
(%i1) rreduce ("^", args ({a, b, c, d}));
d
c
b
(%o1) a
(%i2) rreduce ("/", args ({a, b, c, d}));
a c
(%o2) ---
b d
Devuelve el conjunto con los elementos del conjunto a que no pertenecen al conjunto b.
La función setdifference emite un mensaje de error si
a o b no son conjuntos.
Ejemplos:
(%i1) S_1 : {a, b, c, x, y, z};
(%o1) {a, b, c, x, y, z}
(%i2) S_2 : {aa, bb, c, x, y, zz};
(%o2) {aa, bb, c, x, y, zz}
(%i3) setdifference (S_1, S_2);
(%o3) {a, b, z}
(%i4) setdifference (S_2, S_1);
(%o4) {aa, bb, zz}
(%i5) setdifference (S_1, S_1);
(%o5) {}
(%i6) setdifference (S_1, {});
(%o6) {a, b, c, x, y, z}
(%i7) setdifference ({}, S_1);
(%o7) {}
Devuelve true si los conjuntos a y b tienen
el mismo número de elementos
y is (x = y) vale true
para x perteneciente a a
e y perteneciente a b,
considerados en el orden que determina la función
listify. En caso contrario, setequalp
devuelve false.
Ejemplos:
(%i1) setequalp ({1, 2, 3}, {1, 2, 3});
(%o1) true
(%i2) setequalp ({a, b, c}, {1, 2, 3});
(%o2) false
(%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
(%o3) false
Construye un conjunto con los miembros de la lista a.
Los elementos duplicados de la lista a son borrados
y ordenados de acuerdo con el predicado orderlessp.
La función setify emite un mensaje de error si
a no es un conjunto literal.
Ejemplos:
(%i1) setify ([1, 2, 3, a, b, c]);
(%o1) {1, 2, 3, a, b, c}
(%i2) setify ([a, b, c, a, b, c]);
(%o2) {a, b, c}
(%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
(%o3) {1, 3, 5, 7, 9, 11, 13}
Devuelve true si y sólo si a es un conjunto de Maxima.
La función setp devuelve true tanto cuando el conjunto
tiene como cuando no tiene elementos repetidos.
La función setp is equivalent to the Maxima function
setp(a) := not atom(a) and op(a) = 'set.
Ejemplos:
(%i1) simp : false;
(%o1) false
(%i2) {a, a, a};
(%o2) {a, a, a}
(%i3) setp (%);
(%o3) true
Devuelve el conjunto de todas las particiones de a o un subconjunto de ellas.
La sentencia set_partitions(a, n)
devuelve un conjunto con todas las descomposiciones de a
en n conjuntos no vacíos disjuntos.
La sentencia set_partitions(a) devuelve el
conjunto de todas las particiones.
La función stirling2 devuelve la cardinalidad del conjunto
de las particiones de un conjunto.
Se dice que un conjunto P es una partición del conjunto S si verifica
Ejemplos:
El conjunto vacío forma una partición de sí mismo,
(%i1) set_partitions ({});
(%o1) {{}}
La cardinalidad del conjunto de particiones de un conjunto puede calcularse con stirling2,
(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$
(%i3) cardinality(p) = stirling2 (6, 3);
(%o3) 90 = 90
Cada elemento de p debería tener n = 3 miembros,
(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$
(%i3) map (cardinality, p);
(%o3) {3}
Por último, para cada miembro de p, la unión de sus elementos
debe ser igual a s,
(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$
(%i3) map (lambda ([x], apply (union, listify (x))), p);
(%o3) {{0, 1, 2, 3, 4, 5}}
Devuelve true si el predicado f devuelve true
para al menos uno de sus argumentos.
Si el segundo argumento es un conjunto, some (f, a)
devuelve true si f(a_i) devuelve también
true para alguno de los a_i en a; puede ser que
some no evalúe f para todos los a_i de s.
Puesto que los conjuntos no están ordenados, some puede evaluar
f(a_i) en cualquier orden.
Dada una o más listas como argumentos,
some (f, L_1, ..., L_n) devuelve true
si f(x_1, ..., x_n) devuelve también
true para al menos un x_1, ..., x_n de
L_1, ..., L_n, respectivamente; puede ser que
some no evalúe f para todos las combinaciones
x_1, ..., x_n. La función some evalúa
las listas en el orden creciente de su índice
Dado un conjunto vacío {} o una lista
vacía como argumentos, some devuelve false.
Si la variable global maperror vale true,
todas las listas L_1, ..., L_n deben tener
igual número de elementos. Si maperror vale
false, los argumentos se truncan para tener todos
el número de elementos de la lista más corta.
Los valores que devuelve el predicado f cuando toman
(mediante is) un valor diferente a true y false
se controlan con la variable global prederror.
Si prederror vale true, tales valores se
consideran como false.
Si prederror vale false, tales valores se
consideran como desconocidos (unknown).
Ejemplos:
La función some aplicada a un único conjunto.
El predicado es una función de un argumento,
(%i1) some (integerp, {1, 2, 3, 4, 5, 6});
(%o1) true
(%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
(%o2) true
La función some aplicada a dos listas.
El predicado es una función de dos argumentos,
(%i1) some ("=", [a, b, c], [a, b, c]);
(%o1) true
(%i2) some ("#", [a, b, c], [a, b, c]);
(%o2) false
Las respuestas del predicado f que se evalúan
a cualquier cosa diferente de true y false
están controlados por la variable global prederror.
(%i1) prederror : false;
(%o1) false
(%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
[x^2, y^2, z^2]);
(%o2) [unknown, unknown, unknown]
(%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
(%o3) unknown
(%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
(%o4) true
(%i5) prederror : true;
(%o5) true
(%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
(%o6) false
(%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
(%o7) true
Es el número de Stirling de primera especie.
Si tanto n como m son enteros no negativos,
el valor que toma stirling1 (n, m)
es el número de permutaciones de un conjunto de
n elementos con m ciclos. Para más detalles,
véase Graham, Knuth and Patashnik Concrete Mathematics.
Maxima utiliza una relación recursiva para definir
stirling1 (n, m) para m menor
que 0; no está definida para n menor que 0 ni
para argumentos no enteros.
La función stirling1 es simplificadora. Maxima
reconoce las siguientes identidades:
Estas identidades se aplican cuando los argumentos son enteros
literales o símbolos declarados como enteros y
el primer argumento es no negativo. La función stirling1
no simplifica para argumentos no enteros.
Referencias:
[1] Donald Knuth, The Art of Computer Programming, Tercera Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50.
Ejemplos:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling1 (n, n); (%o3) 1
La función stirling1 no simplifica en caso de argumentos no enteros,
(%i1) stirling1 (sqrt(2), sqrt(2)); (%o1) stirling1(sqrt(2), sqrt(2))
Maxima aplicas algunas identidades a stirling1,
(%i1) declare (n, integer)$
(%i2) assume (n >= 0)$
(%i3) stirling1 (n + 1, n);
n (n + 1)
(%o3) ---------
2
(%i4) stirling1 (n + 1, 1);
(%o4) n!
Es el número de Stirling de segunda especie.
Si n y m son enteros no negativos,
stirling2 (n, m) es el número
de formas en las que se puede particionar un conjunto
de cardinal n en m subconjuntos disjuntos.
Maxima utiliza una relación recursiva para definir
stirling2 (n, m) con m menor
que 0; la función no está definida para n
menor que 0 ni para argumentos no enteros.
La función stirling2 es simplificadora. Maxima
reconoce las siguientes identidades:
Estas identidades se aplican cuando los argumentos son enteros
literales o símbolos declarados como enteros y
el primer argumento es no negativo. La función stirling2
no simplifica para argumentos no enteros.
Referencias:
[1] Donald Knuth. The Art of Computer Programming, Tercera Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50.
[2] Graham, Knuth y Patashnik. Concrete Mathematics, Tabla 264.
[3] Abramowitz y Stegun. Handbook of Mathematical Functions, Sección 24.1.4.
Ejemplos:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling2 (n, n); (%o3) 1
La función stirling2 no simplifica en caso de argumentos no enteros,
(%i1) stirling2 (%pi, %pi); (%o1) stirling2(%pi, %pi)
Maxima aplicas algunas identidades a stirling2,
(%i1) declare (n, integer)$
(%i2) assume (n >= 0)$
(%i3) stirling2 (n + 9, n + 8);
(n + 8) (n + 9)
(%o3) ---------------
2
(%i4) stirling2 (n + 1, 2);
n
(%o4) 2 - 1
Devuelve el subconjunto del conjunto a que satisface el predicado f.
La función subset devuelve el conjunto que contiene a los
elementos de a para los cuales f devuelve un resultado
diferente de false. La función subset no aplica
is al valor retornado por f.
La función subset emite un mensaje de error si a
no es un conjunto literal.
Véase también partition_set.
Ejemplos:
(%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
(%o1) {1, 2, x, z}
(%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
(%o2) {2, 8, 14}
Devuelve true si y sólo si el conjunto a es un subconjunto de b.
La función subsetp emite un mensaje de error si
cualesquiera a o b no es un conjunto literal.
Ejemplos:
(%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
(%o1) true
(%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
(%o2) false
Devuelve la diferencia simétrica de los conjuntos a_1, …, a_n.
Dados dos argumentos, symmdifference (a, b) equivale a
union (setdifference (a, b), setdifference (b, a)).
La función symmdifference emite un mensaje de error si alguno de
su argumentos no es un conjunto literal.
Ejemplos:
(%i1) S_1 : {a, b, c};
(%o1) {a, b, c}
(%i2) S_2 : {1, b, c};
(%o2) {1, b, c}
(%i3) S_3 : {a, b, z};
(%o3) {a, b, z}
(%i4) symmdifference ();
(%o4) {}
(%i5) symmdifference (S_1);
(%o5) {a, b, c}
(%i6) symmdifference (S_1, S_2);
(%o6) {1, a}
(%i7) symmdifference (S_1, S_2, S_3);
(%o7) {1, b, z}
(%i8) symmdifference ({}, S_1, S_2, S_3);
(%o8) {1,b, z}
Amplía la función binaria F a n-aria, siendo s una lista.
La función tree_reduce equivale a lo suguiente:
Aplicar F a pares sucesivos de elementos para formar
una nueva lista [F(s_1, s_2), F(s_3, s_4), ...],
llevando el elemento final sin cambiar si el número de elementos es impar;
después repetir hasta que la lista se reduzca a un único elemento,
que es el valor de retorno.
Cuando está presente el argumento opcional s_0,
el resultado equivale a tree_reduce(F, cons(s_0, s).
Para la suma de números decimales en coma flotante,
tree_reduce puede devolver una suma que tenga un error
de redondeo menor que el conseguido por rreduce o lreduce.
Los elementos de s y los resultados parciales pueden colocarse en un árbol binario de mínima profundidad, de ahí el nombre de tree_reduce.
Ejemplos:
La función tree_reduce aplicada a una lista con un número
par de elementos,
(%i1) tree_reduce (f, [a, b, c, d]); (%o1) f(f(a, b), f(c, d))
La función tree_reduce aplicada a una lista con un número
impar de elementos,
(%i1) tree_reduce (f, [a, b, c, d, e]); (%o1) f(f(f(a, b), f(c, d)), e)
Devuelve la unión de los conjuntos a_1 hasta a_n.
La sentencia union() (sin argumentos) devuelve el
conjunto vacío.
La función union emite un mensaje de error si alguno
de sus argumentos no es un conjunto literal.
Ejemplos:
(%i1) S_1 : {a, b, c + d, %e};
(%o1) {%e, a, b, d + c}
(%i2) S_2 : {%pi, %i, %e, c + d};
(%o2) {%e, %i, %pi, d + c}
(%i3) S_3 : {17, 29, 1729, %pi, %i};
(%o3) {17, 29, 1729, %i, %pi}
(%i4) union ();
(%o4) {}
(%i5) union (S_1);
(%o5) {%e, a, b, d + c}
(%i6) union (S_1, S_2);
(%o6) {%e, %i, %pi, a, b, d + c}
(%i7) union (S_1, S_2, S_3);
(%o7) {17, 29, 1729, %e, %i, %pi, a, b, d + c}
(%i8) union ({}, S_1, S_2, S_3);
(%o8) {17, 29, 1729, %e, %i, %pi, a, b, d + c}
Amplía la función F a n-aria mediante
composición; si F ya es n-aria, aplica F a s.
Si F no es n-aria, xreduce equivale a lreduce.
El argumento s debe ser una lista.
Funciones n-arias reconocidas por Maxima son la suma +, la
multiplicación *, and, or, max,
min y append. Las funciones también se pueden
declarar n-arias mediante declare(F, nary);
para estas funciones, xreduce será más rápida que
rreduce o lreduce.
Cuando está presente el argumento opcional s_0,
el resultado equivale a xreduce(s, cons(s_0, s)).
La suma de números decimales en coma flotante no es exactamente asociativa;
aún así, xreduce aplica la suma n-aria cuando s
contiene números en coma flotante.
Ejemplos:
La función xreduce aplicada a una función n-aria;
F es invocada una sóla vez, con todos sus argumentos,
(%i1) declare (F, nary);
(%o1) done
(%i2) F ([L]) := L;
(%o2) F([L]) := L
(%i3) xreduce (F, [a, b, c, d, e]);
(%o3) [[[[[("[", simp), a], b], c], d], e]
La función xreduce aplicada a una función que se desconoce si
es n-aria; G es invocada varias veces, con dos argumentos de cada vez,
(%i1) G ([L]) := L;
(%o1) G([L]) := L
(%i2) xreduce (G, [a, b, c, d, e]);
(%o2) [[[[[("[", simp), a], b], c], d], e]
(%i3) lreduce (G, [a, b, c, d, e]);
(%o3) [[[[a, b], c], d], e]
Siguiente: Definición de Funciones, Anterior: Reglas y patrones [Índice general][Índice]