[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
39.1 Introducción a los conjuntos | ||
39.2 Definiciones para los conjuntos |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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) set (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) set(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) set((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) set((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) set(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: set (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
provocarán un error si alguno de sus argumentos es una lista. 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], set (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]), set (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 (set (x + y + z, x - y + 4, x + y - 5), lambda ([e], freeof (z, e))); (%o1) {- y + x + 4, y + x - 5} |
La sección Definiciones para los conjuntos
incluye una lista completa de funciones para operar con conjuntos en Maxima.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Hay dos formas para operar iterativamente sobre los elementos de un conjunto. Una es utilizar map
; por ejemplo:
(%i1) map (f, set (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: set (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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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 CRE. Un ejemplo es
(%i1) set ([x], [rat (x)]); Maxima encountered a Lisp error: CAR: #:X13129 is not a LIST Automatically continuing. To reenable the Lisp debugger set *debugger-hook* to nil. |
Esta instrucció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: CAR: #:A13129 is not a 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 instrucciones
(%i1) orderlessp ([rat(a)], [rat(b)]); Maxima encountered a Lisp error: CAR: #:B13130 is not a 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) set (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 si todos los elementos del conjunto están en la forma CRE o han sido simplificados con ratsimp
, entonces el fallo no se manifiesta.
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
.
La función sign
de Maxima tiene un fallo que puede causar que la función delta de Kronecker trabaje incorrectamente; por ejemplo:
(%i1) kron_delta (1/sqrt(2), sqrt(2)/2); (%o1) 0 |
El valor correcto es 1. El fallo está causado por el de la función sign
(%i1) sign (1/sqrt(2) - sqrt(2)/2); (%o1) pos |
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
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Stavros Macrakis de Cambridge, Massachusetts y Barton Willis de la University of Nebraska at Kearney (UNK).
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Incorpora x al conjunto a y devuelve el nuevo conjunto. Así, adjoin(x, a)
y union(set(x),a)
son equivalentes; sin embargo, haciendo adjoin
puede ser algo más rápido que utilizando union
. Si a no es un conjunto, se emite un error.
(%i1) adjoin (c, set (a, b)); (%o1) {a, b, c} (%i2) adjoin (a, set (a, b)); (%o2) {a, b} |
Véase también disjoin
.
Para el entero no negativo integers n, devuelve el n-ésimo número de Bell. Si s
es un conjunto con n
elementos, belln(n)
es el número de particiones de s
. Por ejemplo:
(%i1) makelist (belln (i), i, 0, 6); (%o1) [1, 1, 2, 5, 15, 52, 203] (%i2) is (cardinality (set_partitions (set ())) = belln (0)); (%o2) true (%i3) is (cardinality (set_partitions (set (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.
(%i1) cardinality (set ()); (%o1) 0 (%i2) cardinality (set (a, a, b, c)); (%o2) 3 (%i3) cardinality (set (a, a, b, c)), simp: false; (%o3) 3 |
En la salida (%o3) se observa que la cardinalidad trabaja correctamente incluso cuando la simplificación se ha desactivado.
Devuelve un conjunto formado por listas de la forma [x_1, ..., x_n]
, donde x_1 in b_1
, ..., x_n in b_n
. Envía un error si cualquiera de los b_k no es un conjunto.
(%i1) cartesian_product (set (0, 1)); (%o1) {[0], [1]} (%i2) cartesian_product (set (0, 1), set (0, 1)); (%o2) {[0, 0], [0, 1], [1, 0], [1, 1]} (%i3) cartesian_product (set (x), set (y), set (z)); (%o3) {[x, y, z]} (%i4) cartesian_product (set (x), set (-1, 0, 1)); (%o4) {[x, - 1], [x, 0], [x, 1]} |
Elimina x del conjunto a y devuelve un conjunto. Si x no es elemento de a, devuelve a. Cada una de las siguientes llamadas hace lo mismo: disjoin(x, a)
, delete(x, a)
y
setdifference(a,set(x))
; sin embargo, disjoin
es generalmente el método más rápido para eliminar un elemento de un conjunto. Devuelve un error en caso de que a no sea un conjunto.
Devuelve true
si los conjuntos a y b son disjuntos. Envía un mensaje de error si bien a o bien b no son conjuntos.
Si n es un entero no nulo, devuelve el conjunto de sus divisores. El conjunto de divisores incluye los elementos 1 y n. Los divisores de un entero negativo son los divisores de su valor absoluto.
Se puede comprobar que 28 es un número perfecto.
(%i1) s: divisors(28); (%o1) {1, 2, 4, 7, 14, 28} (%i2) lreduce ("+", args(s)) - 28; (%o2) 28 |
La función divisors
opera por simplificación; no es necesario volver a evaluar tras una sustitución. Por ejemplo:
(%i1) divisors (a); (%o1) divisors(a) (%i2) subst (8, a, %); (%o2) {1, 2, 4, 8} |
La función divisors
se distribuye respecto de igualdades, listas, matrices y conjuntos. He aquí un ejemplo de distribución sobre una lista y una igualdad.
(%i1) divisors ([a, b, c=d]); (%o1) [divisors(a), divisors(b), divisors(c) = divisors(d)] |
Devuelve true
si y sólo si x es un elemento del conjunto a. Envía un error si a no es un conjunto.
Devuelve true
si y sólo si a es el conjunto vacío o la lista vacía.
(%i1) map (emptyp, [set (), []]); (%o1) [true, true] (%i2) map (emptyp, [a + b, set (set ()), %pi]); (%o2) [false, false, false] |
Devuelve el conjunto de las clases de equivalencia de s respecto de la relación de equivalencia f. La función f debe ser booleana y definida sobre el producto cartesiano de s por s. Además, la función f debe ser una relación de equivalencia, debiéndose tener en cuenta que equiv_classes
no chequea esta propiedad.
(%i1) equiv_classes (set (a, b, c), lambda ([x, y], is (x=y))); (%o1) {{a}, {b}, {c}} |
En este momento, equiv_classes (s, f)
aplica automáticamente la función is
de Maxima después de aplicar la función f; por lo tanto, se puede volver a hacer el ejemplo anterior de forma más breve.
(%i1) equiv_classes (set (a, b, c), "="); (%o1) {{a}, {b}, {c}} |
Aquí otro ejemplo.
(%i1) equiv_classes (set (1, 2, 3, 4, 5, 6, 7), lambda ([x, y], remainder (x - y, 3) = 0)); (%o1) {{1, 4, 7}, {2, 5}, {3, 6}} |
El primer argumento f debe ser un predicado (es decir, una función que toma cualquiera de los valores true
, false
, or unknown
).
Dado un conjunto como segundo argumento, every (f, a)
devuelve true
si f(a_i)
devuelve también true
para todo a_i de a. Puesto que los conjuntos no están ordenados, every
puede evaluar f(a_i)
en cualquier orden. La función every
puede que no evalúe f para todo a_i de a. Devido a que el orden de evaluación no está especificado, el predicado f no debe tener efectos secundarios ni emitir señales de error para ninguna entrada.
Dada una o más listas como argumentos, every (f, L_1, ..., L_n)
devuelve true
si f(x_1, ..., x_n)
devuelve true
para cada x_1, ..., x_n de L_1, ..., L_n, respectivamente. La función every
puede que no evalúe f para todas las combinaciones x_1, ..., x_n. Puesto que las listas están ordenadas, every
evalúa en el orden del índice creciente.
Para usar every
con múltiples conjuntos como argumentos, deberían convertirse primero en una secuencia ordenada, de manera que su alineación relativa quede bien definida.
Si la variable global maperror
vale true
(su valor por defecto), todas las listas L_1, ..., L_n deben tener igual número de miembros; en otro caso, every
envia un mensaje de error. Cuando maperror
vale false
, las listas son truncadas cada una a la longitud de la lista más corta.
La función is
se aplica automáticamente tras cada evaluación del predicado f.
(%i1) every ("=", [a, b], [a, b]); (%o1) true (%i2) every ("#", [a, b], [a, b]); (%o2) false |
Cuando el tercer argumento es max
, devuelve el subconjunto del conjunto o lista s para cuyos elementos la función real f toma su valor mayor; cuando el tercer argumento es min
, devuelve el subconjunto para el cual f toma su valor menor.
(%i1) extremal_subset (set (-2, -1, 0, 1, 2), abs, max); (%o1) {- 2, 2} (%i2) extremal_subset (set (sqrt(2), 1.57, %pi/2), sin, min); (%o2) {sqrt(2)} |
La función flatten
evalúa una expresión como si su operador principal hubiese sido declarado n-ario; hay sin embargo una diferencia, flatten
no es recursiva para otros argumentos de la función. Por ejemplo:
(%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))) |
Aplicada a un conjunto, flatten
reune todos los elementos de los conjuntos que son a su vez elementos; por ejemplo:
(%i1) flatten (set (a, set (b), set (set (c)))); (%o1) {a, b, c} (%i2) flatten (set (a, set ([a], set (a)))); (%o2) {a, [a]} |
La función flatten
trabaja correctamente cuando el operador principal es una función con subíndices
(%i1) flatten (f[5] (f[5] (x))); (%o1) f (x) 5 |
Para alisar (flatten) una expresión, el operador principal debe estar definido para cero o más argumentos; si no es éste el caso, Maxima se detendrá con un error. Expresiones con representaciones especiales, como expresiones CRE, no pueden ser alisadas; en este caso, flatten
devuelve su argumento sin cambios.
Si a es un conjunto, convierte a en una lista y aplica full_listify
a cada miembro de la lista.
Para convertir sólo el operador de mayor nivel de un conjunto a una lista, véase listify
.
Si a es una lista, convierte a en un conjunto y aplica fullsetify
a cada elemento del conjunto.
(%i1) fullsetify ([a, [a]]); (%o1) {a, {a}} (%i2) fullsetify ([a, f([b])]); (%o2) {a, f([b])} |
En la salida (%o2) el argumento de f
no se convierte en conjunto porque el operador principal de f([b])
no es una lista.
Para convertir el operador de mayor nivel de una lista a un conjunto véase setify
.
La función identity
devuelve su argumento cualquiera que sea éste. Para determinar si todos los elementos de un conjunto son true
, se puede hacer lo siguiente
(%i1) every (identity, [true, true]); (%o1) true |
Si el segundo argumento opcional len no se especifica, devuelve el conjunto de todas las particiones del entero n. Cuando se especifica 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, a fin de que cada partición tenga exactamente los len términos. En cualquier caso las particiones son listas ordenadas de mayor a menor.
Se dice que la lista [a_1, ..., a_m] es una partición del entero no negativo n si (1) cada a_i es un entero no nulo y (2) a_1 + ... + a_m = n. De donde se deduce que 0 carece de particiones.
(%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) xprimep(x) := integerp(x) and (x > 1) and primep(x)$ (%i3) subset (s, lambda ([x], every (xprimep, x))); (%o3) {[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. La función intersect
debe recibir uno o más argumentos. Muestra un mensaje de error en caso de que cualquiera de los
a_i no sea un conjunto. Véase también intersection
.
Es la función delta de Kronecker; la llamada kron_delta (x, y)
devuelve la unidad cuando is(x = y)
es verdadero y cero cuando sign (|x - y|)
vale pos
(es decir, cuando es positivo). Si sign (|x - y|)
es nulo y x - y
no es un número en coma flotante (ni de doble precisión ni del tipo bfloat
), devuleve 0. En otro caso devuelve una forma nominal.
La función kron_delta
es simétrica; así por ejemplo, kron_delta(x, y) - kron_delta(y, x)
devuelve cero.
A continuación algunos ejemplos.
(%i1) [kron_delta (a, a), kron_delta (a + 1, a)]; (%o1) [1, 0] (%i2) kron_delta (a, b); (%o2) kron_delta(a, b) |
Bajo la hipótesis a > b
se obtiene que sign (|a - b|)
sea pos
(positivo),
(%i1) assume (a > b)$ (%i2) kron_delta (a, b); (%o2) 0 |
Si se da por válida la hipótesis x >= y
, entonces sign (|x - y|)
se vuelve pz
(es decir, cero o positivo); en este caso, kron_delta (x, y)
no devuelve resultado alguno,
(%i1) assume(x >= y)$ (%i2) kron_delta (x, y); (%o2) kron_delta(x, y) |
Por último, puesto que 1/10 - 0.1
devuelve un número en coma flotante, se tiene
(%i1) kron_delta (1/10, 0.1); 1 (%o1) kron_delta(--, 0.1) 10 |
Si se quiere que kron_delta (1/10, 0.1)
devuelva la unidad, hágase uso de float
.
(%i1) float (kron_delta (1/10, 0.1)); (%o1) 1 |
Si a es un conjunto, devuelve una lista con los elementos de a; si a no es un conjunto, devuelve a. Para convertir un conjunto y todos sus elementos a listas, véase full_listify
.
La función lreduce
(left reduce, o reducir por la izquierda) convierte una función binaria en n-aria por composición; un ejemplo hará esto más claro. Cuando no se define el argumento opcional init se tiene
(%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) |
Nótese que la función f se aplica en primer lugar a los elementos que están más a la izquierda (de ahí el nombre lreduce
). Cuando se define init, se tiene
(%i1) lreduce (f, [1, 2, 3], 4); (%o1) f(f(f(4, 1), 2), 3) |
La función lreduce
facilita calcular el producto o suma de los miembros de una lista.
(%i1) lreduce ("+", args (set (a, b))); (%o1) b + a (%i2) lreduce ("*", args (set (1, 2, 3, 4, 5))); (%o2) 120 |
Véase también rreduce
, xreduce
y tree_reduce
.
Esta función es similar a makelist
, con la salvedad de que makeset
permite sustituciones múltiples. El primer argumento e es una expresión, el segundo argumento v es una lista de variables y s es una lista o conjunto de valores para las variables v. Cada miembro de s debe tener la misma longitud que v. Así se tiene que makeset (e, v, s)
es el conjunto {z | z = substitute(v -> s_i) and s_i in s}
.
(%i1) makeset (i/j, [i, j], [[a, b], [c, d]]); a c (%o1) {-, -} b d (%i2) ind: set (0, 1, 2, 3)$ (%i3) makeset (i^2 + j^2 + k^2, [i, j, k], cartesian_product (ind, ind, ind)); (%o3) {0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 17, 18, 19, 22, 27} |
Es la función de Moebius; si n es el producto de k primos diferentes, moebius(n)
devuelve (-1)^k, retornando 1 si n = 1 0 para cualesquiera otros enteros positivos. La función de Moebius se distribuye respecto de igualdades, listas, matrices y conjuntos.
Devuelve 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 (a_1, ..., a_n)
calcula (a_1 + ... + a_n)!/(a_1! ... a_n!)
. Si no se dan argumentos, multinomial()
devuelve 1. Se puede usar
minfactorial
para simplificar el valor devuelto por multinomial_coeff
; por ejemplo,
(%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 diferentes de n.
Si el argumento opcional a es list
, devuelve a su vez una lista del número de particiones de 1,2,3, ... , n. Si n no es un entero no negativo, devuelve una forma nominal.
Definición: si n = k_1 + ... + k_m, siendo los k_1 a k_m enteros positivos distintos, se llama a k_1 + ... + k_m una partición de n.
Si n es un entero no negativo, devuelve el número de particiones de n. Si el argumento opcional a es list
, devuelve a su vez otra lista con los números de particiones de 1,2,3, ... , n. Si n no es un entero no negativo, devuelve una forma nominal.
(%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) |
Para un entero no negativo n, num_partitions (n)
equivale a cardinality (integer_partitions (n))
; sin embargo, num_partitions
es más rápido.
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 es el subconjunto de a para el cual f devuelve true
. Si a no es un conjunto, se envía un mensaje de error. Véase también subset
.
(%i1) partition_set (set (2, 7, 1, 8, 2, 8), evenp); (%o1) [{1, 7}, {2, 8}] (%i2) partition_set (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. Así,
(%i1) permutations ([a, a]); (%o1) {[a, a]} (%i2) permutations ([a, a, b]); (%o2) {[a, a, b], [a, b, a], [b, a, a]} |
Si a no es una lista o conjunto, se muestra un mensaje de error.
Si no se define el segundo argumento opcional n, devuelve el conjunto de todos los subconjuntos del conjunto a.
La llamada powerset(a)
tiene 2^cardinality(a)
miembros. Dado un segundo argumento,
powerset(a,n)
devuelve el conjunto de todos los subconjuntos de a que tienen cardinalidad n. Muestra un error si a no es un conjunto; muestra otro error si n no es un positivo entero.
La función rreduce
(right reduce, reducir por la derecha) extiende una función binaria a n-aria por composición; un ejemplo hará esto m'as claro. Si el argumento opcional init no está definido, se tiene
(%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))) |
Nótese que la función f se aplica en primer lugar al elemento que está más a la derecha en la lista, de ahí el nombre rreduce
. Si init está definido,
(%i1) rreduce (f, [1, 2, 3], 4); (%o1) f(1, f(2, f(3, 4))) |
La función rreduce
permite calcular fácilmente el producto o suma de los miembros de una lista.
(%i1) rreduce ("+", args (set (a, b))); (%o1) b + a (%i2) rreduce ("*", args (set (1, 2, 3, 4, 5))); (%o2) 120 |
Véase también lreduce
, tree_reduce
y xreduce
.
Devuelve in conjunto con los elementos del conjunto a que no pertenecen al conjunto b. Envía un mensaje de error si a o b no son conjuntos.
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
.
La función setequalp
muestra un mensaje de error si cualquiera de
las expresiones a o b no es conjunto.
Construye un conjunto con los miembros de la lista a. Los elementos duplicados de la lista a son borrados y lordenados de acuerdo con el predicado orderlessp
. Envía un mensaje de error si a
no es una lista.
Devuelve true
si y sólo si a es un conjunto de Maxima. La función setp
chequea si el operador de su argumento es el de los conjuntos; no chequea si el argumento es un conjunto simplificado. Así,
(%i1) setp (set (a, a)), simp: false; (%o1) true |
La función setp
podría haberse programado en Maxima como setp(a) := is (inpart (a, 0) = set)
.
Si est'a definido el argumento opcional n, devuelve el conjunto de todas las descomposiciones de a en n subconjuntos disjuntos no vacíos. Si n no está definido, devuelve el conjunto de todas las particiones.
Se dice que un conjunto P es una partición del conjunto S si verifica
El conjunto vacío forma una partición de sí mismo, así,
(%i1) set_partitions (set ()); (%o1) {{}} |
El cardinal del conjunto de particiones de un conjunto puede calcularse con stirling2
; así
(%i1) s: set (0, 1, 2, 3, 4, 5)$ (%i2) p: set_partitions (s, 3)$ (%o3) 90 = 90 (%i4) cardinality(p) = stirling2 (6, 3); |
Cada elemento de p
debería tener 3 miembros:
(%i1) s: set (0, 1, 2, 3, 4, 5)$ (%i2) p: set_partitions (s, 3)$ (%o3) {3} (%i4) map (cardinality, p); |
Por último, para cada elemento de p
, la unión de sus miembros debe ser igual a s
:
(%i1) s: set (0, 1, 2, 3, 4, 5)$ (%i2) p: set_partitions (s, 3)$ (%o3) {{0, 1, 2, 3, 4, 5}} (%i4) map (lambda ([x], apply (union, listify (x))), p); |
El primer argumento de f debe ser un predicado (esto es, una función que devuelve true
, false
, or unknown
).
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.
Puesto que los conjuntos no están ordenados, some
puede evaluar f(a_i)
en cualquier orden. La función some
puede que no evalúe f para todos los a_i de a. Devido a que el orden de evaluación no está especificado, el predicado f no debería tener efectos secundarios ni mostrar mensajes de error.
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. La función some
puede que no evalúe f para todas las combinaciones x_1, ..., x_n.
Si la variable global maperror
vale true
(su valor por defecto), todas las listas L_1, ..., L_n deben tener igual número de elementos, en caso contrario, some
muestra un error.
Si maperror
vale false
, los argumentos se truncan para tener todos el número de elementos de la lista más corta.
La función is
de Maxima se aplica automáticamente tras la evaluación del predicado f.
(%i1) some ("<", [a, b, 5], [1, 2, 8]); (%o1) true (%i2) some ("=", [2, 3], [2, 7]); (%o2) 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. Se 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
opera por simplificación, utilizando valores básicos especiales (véase Donald Knuth, The Art of Computer Programming, tercera edición, Volumen 1, Sección 1.2.6, ecuaciones 48, 49 y 50).
Para que Maxima aplique estas reglas, los argumentos deben declararse como enteros y el primer argumento debe ser no negativo. Por ejemplo:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling1 (n, n); (%o3) 1 |
La función stirling1
no se evalúa para argumentos no enteros.
(%i1) stirling1 (sqrt(2), sqrt(2)); (%o1) stirling1(sqrt(2), sqrt(2)) |
Maxima conoce algunos valores especiales,
(%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 especia. 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. Se 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 stirling1
opera por simplificación, utilizando valores básicos especiales (véase Donald Knuth, The Art of Computer Programming, tercera edición, Volumen 1, Sección 1.2.6, ecuaciones 48, 49 y 50).
Para que Maxima aplique estas reglas, los argumentos deben declararse como enteros y el primer argumento debe ser no negativo. Por ejemplo:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling2 (n, n); (%o3) 1 |
La función stirling2
no se evalúa para argumentos no enteros.
(%i1) stirling2 (%pi, %pi); (%o1) stirling2(%pi, %pi) |
Maxima conoce algunos valores especiales,
(%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. Por ejemplo:
(%i1) subset (set (1, 2, x, x + y, z, x + y + z), atom); (%o1) {1, 2, x, z} (%i2) subset (set (1, 2, 7, 8, 9, 14), evenp); (%o2) {2, 8, 14} |
El segundo argumento de subset
debe ser un predicado (una función booleana con un argumento); si el primer argumento de subset
no es un conjunto, envía un mensaje de error. Véase también partition_set
.
Devuelve true
si y sólo si el conjunto a es un subconjunto de b. Muestra un mensaje de error si a o b no son conjuntos.
Devuelve el conjunto de elementos que pertenecen a un único conjunto de los a_k. Muestra un mensaje de error si cualquiera de los argumentos a_k no es un conjunto. Con dos argumentos, symmdifference (a, b)
equivale a union (setdifference (a, b), setdifference (b, a))
.
La función tree_reduce
amplía un operador binario asociativo f : S x S -> S a otro de cualquier número de argumentos utilizando un árbol de mínima profundidad. Un ejemplo aclarará esto,
(%i1) tree_reduce (f, [a, b, c, d]); (%o1) f(f(a, b), f(c, d)) |
Dado un número impar de argumentos, tree_reduce
favorecerá la parte izquierda del árbol; por ejemplo,
(%i1) tree_reduce (f, [a, b, c, d, e]); (%o1) f(f(f(a, b), f(c, d)), e) |
Para la suma de números en coma flotante, la utilización de tree_reduce
puede redundar en una disminución del error de redondeo frente a funciones como rreduce
o lreduce
.
Return the union of the sets a_1 through a_n.
When union
receives no arguments, it returns the
empty set. Signal an error when one or more arguments to
union
is not a set.
Esta función es similar a lreduce
y a rreduce
, excepto que xreduce
puede utilizar tanto la asociatividad por la izquierda como por la derecha; en particular, si f es una función asociativa y Maxima la tiene implementada, xreduce
puede utilizar la función n-aria, como la suma +
, la multiplicación *
, and
, or
, max
, min
y append
. Para estos operadores, se espera que en general que xreduce
sea mas rápida que rreduce
o lreduce
. Si f no es n-aria, xreduce
utiliza la asociatividad por la izquierda.
La suma de números en coma flotante no es asociativa; sin embargo, xreduce
utiliza la suma n-aria de Maxima cuando el conjunto o lista s contiene números en coma flotante.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by root on octubre, 3 2006 using texi2html 1.76.