Siguiente: Operadores, Anterior: Línea de comandos [Índice general][Índice]
Siguiente: Cadenas de texto, Anterior: Tipos de datos y estructuras, Subir: Tipos de datos y estructuras [Índice general][Índice]
Siguiente: Funciones y variables para los números, Anterior: Números, Subir: Números [Índice general][Índice]
Los cálculos aritméticos con números enteros y racionales son exactos. En principio, los números enteros y racionales admiten una cantidad arbitraria de cifras, con la única limitación que impongan las capacidades de memoria del sistema.
(%i1) 1/3+5/4+3;
55
(%o1) --
12
(%i2) 100!;
(%o2) 9332621544394415268169923885626670049071596826438162146859\
2963895217599993229915608941463976156518286253697920827223758251\
185210916864000000000000000000000000
(%i3) 100!/101!;
1
(%o3) ---
101
Funciones disponibles para los números enteros y racionales:
integerp numberp nonnegintegerp oddp evenp ratnump rationalize
Maxima hace los cálculos con números decimales en coma flotante en doble precisión. Además, Maxima puede hacer cĺculos con números decimales grandes en coma flotante (bigfloats, en inglés), que, en principio, admiten precisión arbitraria.
La coma de los números decimales en coma flotante se escribe con un punto y el exponente se puede indicar con "f", "e" o "d". Por defecto, Maxima hace los cálculos en doble precisión y muestra el exponente como "e" en el resultado, mientras que representa el exponente con la letra "b" en el caso de decimales grandes de precisión arbitraria. Maxima no distingue si la letra del exponente se escribe en minúscula o mayúscula.
(%i1) [2.0,1f10,1,e10,1d10,1d300]; (%o1) [2.0, 1.e+10, 1, e10, 1.e+10, 1.e+300] (%i2) [2.0b0,1b10,1b300]; (%o2) [2.0b0, 1.0b10, 1.0b300]
Si en un cálculo aritmético aparece un número decimal en coma flotante, se producirá un efecto de contagio que hará que el resultado se devuelva también como decimal. Esto también es cierto para el caso de decimales grandes de precisión arbitraria.
(%i1) 2.0+1/2+3; (%o1) 5.5 (%i2) 2.0b0+1/2+3; (%o2) 5.5b0
Con las funciones float y bfloat se puede convertir
un número en decimal de doble precisión, o de precisión
arbitraria, respectivamente:
(%i1) float([2,1/2,1/3,2.0b0]); (%o1) [2.0, 0.5, .3333333333333333, 2.0] (%i2) bfloat([2,1/2,1/3,2.0b0]); (%o2) [2.0b0, 5.0b-1, 3.333333333333333b-1, 2.0b0]
Funciones y variables disponibles para números decimales:
float floatnump bfloat bfloatp fpprec float2bf bftorat ratepsilon number_pbranch m1pbranch
Maxima no tiene un tipo de dato especíco para
números complejos; éstos se representan internamente como
la suma de la parte real y la imaginaria multiplicada por el
símbolo %i, que hace las veces de unidad
imaginaria. Por ejemplo, las raíces de la ecuación
x^2 - 4*x + 13 = 0 se representan como 2 + 3*%i y
2 - 3*%i.
Maxima no simplifica automáticamente productos, cocientes,
raíces y otras expresiones con números complejos.
Por ejemplo, para hacer la multiplicación de números
complejos se puede utilizar la función expand.
Funciones disponibles para los números complejos:
realpart imagpart rectform polarform cabs carg conjugate csign
Anterior: Introducción a los números, Subir: Números [Índice general][Índice]
Convierte todos los números y funciones numéricas a números decimales de punto flotante grandes ("bigfloats").
El número de dígitos significativos de los "bigfloats" resultantes se especifica mediante la variable global fpprec.
Si float2bf vale false se mostrará un mensaje de aviso cuando un número en punto flotante se convierte a decimal de tipo "bigfloats", puesto que tal transformación puede conllevar pérdida de precisión.
Devuelve true si expr es un número decimal en punto flotante grande ("bigfloats"), en caso contrario devuelve false.
Valor por defecto: false
La variable bftorat controla la conversión de números decimales de punto flotante grandes ("bigfloats") a números racionales. Si bftorat vale false, se utilizará ratepsilon para controlar la conversión (lo cual resulta en números racionales relativamente pequeños). Si bftorat vale true, el número racional generado representará exactamente al número decimal de punto flotante grande ("bigfloat").
Valor por defecto: true
La variable bftrunc provoca la eliminación de ceros en números decimales grandes no nulos para que no se muestren. Así, si bftrunc vale false, bfloat (1)
se muestra como 1.000000000000000B0. En otro caso, se mostrará como 1.0B0.
Devuelve true si expr es un entero par y false en cualquier otro caso.
Convierte los enteros, números racionales y los decimales de punto flotante grandes ("bigfloats") que están presentes en expr a números de punto flotante. También actúa como símbolo evflag.
Valor por defecto: true
Si float2bf vale false se mostrará un mensaje de aviso cuando un número
en punto flotante se convierte a decimal de tipo "bigfloats", puesto que tal transformación
puede conllevar pérdida de precisión.
Devuelve true si expr es un número de punto flotante, en caso contario retorna false.
Valor por defecto: 16
La variable fpprec guarda el número de dígitos significativos en la aritmética con números decimales de punto flotante grandes ("bigfloats"). La variable fpprec no afecta a los cálculos con números decimales de punto flotante ordinarios.
Véanse también bfloat y fpprintprec.
Valor por defecto: 0
La variable fpprintprec guarda el número de dígitos
a imprimir de los números decimales en coma flotante, tanto los ordinarios
como los de precisión ilimitada (bigfloats).
En el caso de los decimales ordinarios, si fpprintprec toma un valor
entre 2 y 16 (inclusive), el número de dígitos que se
imprimen es igual a fpprintprec. En caso contrario, fpprintprec es 0
o mayor que 16, siendo el número de dígitos
a imprimir en todos loa casos igual a 16.
En el caso de los decimales de precisión ilimitada (bigfloats),
si fpprintprec toma un valor entre 2 y 16 (inclusive),
el número de dígitos que se imprimen es igual a
fpprintprec. En caso contrario, fpprintprec es 0
o mayor que fpprec, siendo el número de dígitos
a imprimir igual a fpprec.
La variable fpprintprec no admite el valor 1.
Devuelve true si expr es un número entero y false en cualquier otro caso.
La función integerp devuelve false si su argumento es un símbolo, incluso cuando éste ha sido declarado como entero.
Ejemplos:
(%i1) integerp (0); (%o1) true (%i2) integerp (1); (%o2) true (%i3) integerp (-17); (%o3) true (%i4) integerp (0.0); (%o4) false (%i5) integerp (1.0); (%o5) false (%i6) integerp (%pi); (%o6) false (%i7) integerp (n); (%o7) false (%i8) declare (n, integer); (%o8) done (%i9) integerp (n); (%o9) false
Valor por defecto: false
La variable m1pbranch es la rama principal de -1 elevado a una potencia. Cantidades como (-1)^(1/3) (esto es, un exponente racional impar) y (-1)^(1/4) (esto es, un exponente racional par) son tratados como sigue:
dominio real
(-1)^(1/3): -1
(-1)^(1/4): (-1)^(1/4)
dominio complejo
m1pbranch:false m1pbranch:true
(-1)^(1/3) 1/2+%i*sqrt(3)/2
(-1)^(1/4) sqrt(2)/2+%i*sqrt(2)/2
Devuelve true si y solo si n >= 0, siendo n un entero.
Devuelve true si expr es un enúmero entero, racional,
de coma flotante o "bigfloat", en caso contrario devuelve false.
La función numberp devuelve false si su argumento es un símbolo, incluso cuando el argumento es un número simbólico como %pi o %i, o aunque haya sido declarado como even (par), odd (impar), integer (entero), rational (racional), irrational (irracional), real (real), imaginary (imaginario) o complex (complejo).
Ejemplos:
(%i1) numberp (42);
(%o1) true
(%i2) numberp (-13/19);
(%o2) true
(%i3) numberp (3.14159);
(%o3) true
(%i4) numberp (-1729b-4);
(%o4) true
(%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
(%o5) [false, false, false, false, false, false]
(%i6) declare (a, even, b, odd, c, integer, d, rational,
e, irrational, f, real, g, imaginary, h, complex);
(%o6) done
(%i7) map (numberp, [a, b, c, d, e, f, g, h]);
(%o7) [false, false, false, false, false, false, false, false]
La variable numer hace algunas funciones matemáticas
con argumentos numéricos se evalúen como decimales de punto flotante.
También hace que las variables de una expresión a las cuales se les ha
asignado un número sean sustituidas por sus valores.
Además, activa la variable float.
Véase también %enumer.
Ejemplos:
(%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))];
1
(%o1) [sqrt(2), sin(1), -----------]
sqrt(3) + 1
(%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer;
(%o2) [1.414213562373095, .8414709848078965, .3660254037844387]
Valor por defecto: false
La variable opcional numer_pbranch controla la evaluación
numérica de las potencias de números enteros, racionales y
decimales negativos. Si numer_pbranch vale true y el
exponente es decimal o la variable opcional numer vale
true, Maxima evalúa el resultado numérico utilizando la rama
principal. En caso contrario, se devuleve un resultado simplificado pero
no evaluado.
Ejemplos:
(%i1) (-2)^0.75; (%o1) (-2)^0.75 (%i2) (-2)^0.75,numer_pbranch:true; (%o2) 1.189207115002721*%i-1.189207115002721 (%i3) (-2)^(3/4); (%o3) (-1)^(3/4)*2^(3/4) (%i4) (-2)^(3/4),numer; (%o4) 1.681792830507429*(-1)^0.75 (%i5) (-2)^(3/4),numer,numer_pbranch:true; (%o5) 1.189207115002721*%i-1.189207115002721
Declara las variables x_1, ..., x_n asignándoles los valores numéricos expr_1, ..., expr_n.
El valor numérico se evalúa y sustituye a la variable en cualquier expresión en la que ésta aparezca si numer toma el valor true. Véase también ev.
Las expresiones expr_1, ..., expr_n pueden ser expresiones no necesariamente numéricas.
Devuelve true si expr es un entero impar y false en caso contrario.
Valor por defecto: 2.0e-8
La variable ratepsilon guarda la tolerancia utilizada en la conversión de números decimales en coma flotante a números racionales.
Convierte todos los números en coma flotante de doble precisión y grandes (big float) presentes en una expresión expr de Maxima a sus formas racionales exactas equivalentes. Si el usuario no está familiarizado con la representación binaria de números en coma flotante, le puede extrañar que rationalize (0.1) no sea igual que 1/10. Este comportamiento no es único de Maxima, ya que el número 1/10 en su forma binaria es periódico y no exacto.
(%i1) rationalize (0.5);
1
(%o1) -
2
(%i2) rationalize (0.1);
1
(%o2) --
10
(%i3) fpprec : 5$
(%i4) rationalize (0.1b0);
209715
(%o4) -------
2097152
(%i5) fpprec : 20$
(%i6) rationalize (0.1b0);
236118324143482260685
(%o6) ----------------------
2361183241434822606848
(%i7) rationalize (sin (0.1*x + 5.6));
x 28
(%o7) sin(-- + --)
10 5
Devuelve true si expr es un entero literal o una fracción de enteros literales, en caso contrario devuelve false.
Siguiente: Constantes, Anterior: Números, Subir: Tipos de datos y estructuras [Índice general][Índice]
Siguiente: Funciones y variables para las cadenas de texto, Anterior: Cadenas de texto, Subir: Cadenas de texto [Índice general][Índice]
Las cadenas de caracteres deben ir acotadas por comillas dobles (")
al ser introducidas en Maxima, siendo luego mostradas con o sin ellas,
dependiendo del valor de la variable global stringdisp.
Las cadenas pueden contener todo tipo de caracteres, incluyendo tabulaciones,
caracteres de nueva línea y de retorno.
La secuencia \" se reconoce literalmente como una comilla doble, al
tiempo que \\ se interpreta como una barra invertida. Cuando la barra
invertida aparece al final de una línea, tanto la barra como el
final de línea (representado éste bien por el carácter de nueva
línea o el de retorno) son ignorados, de forma que la cadena
continúa en el siguiente renglón. No se reconocen más combinaciones especiales
de la barra invertida con otros caracteres aparte de las comentadas; de modo
que si la barra invertida aparece antes de cualquier otro carácter distinto de
", \, o de un final de línea, dicha barra será
ignorada.
No hay manera de representar los caracteres especiales
(tabulación, nueva línea o retorno) de otra
forma que no sea incluyéndolos literalmente en la cadena.
No existe en Maxima el tipo de variable carácter, debiéndose representar un carácter simple como una cadena de un solo carácter.
El paquete adicional stringproc contiene muchas funciones que
permiten trabajar con cadenas.
Ejemplos:
(%i1) s_1 : "This is a string."; (%o1) This is a string. (%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters."; (%o2) Embedded "double quotes" and backslash \ characters. (%i3) s_3 : "Embedded line termination in this string."; (%o3) Embedded line termination in this string. (%i4) s_4 : "Ignore the \ line termination \ characters in \ this string."; (%o4) Ignore the line termination characters in this string. (%i5) stringdisp : false; (%o5) false (%i6) s_1; (%o6) This is a string. (%i7) stringdisp : true; (%o7) true (%i8) s_1; (%o8) "This is a string."
Anterior: Introducción a las cadenas de texto, Subir: Cadenas de texto [Índice general][Índice]
Concatena sus argumentos, que deben ser todos átomos. El valor devuelto es un símbolo si el primer argumento es a su vez un símbolo, o una cadena en caso contrario.
La función concat evalúa sus argumentos.
El apátrofo ' evita la evaluación.
(%i1) y: 7$
(%i2) z: 88$
(%i3) concat (y, z/2);
(%o3) 744
(%i4) concat ('y, z/2);
(%o4) y44
A un símbolo construido por concat se le puede asignar un valor y ser utilizado posteriormente en expresiones.
La asignación con el operador :: evalúa su expresión izquierda.
(%i5) a: concat ('y, z/2);
(%o5) y44
(%i6) a:: 123;
(%o6) 123
(%i7) y44;
(%o7) 123
(%i8) b^a;
y44
(%o8) b
(%i9) %, numer;
123
(%o9) b
Nótese que aunque concat (1, 2) parezca un número, se trata de una cadena.
(%i10) concat (1, 2) + 3; (%o10) 12 + 3
Concatena sus argumentos para producir una cadena.
Al contrario que concat, sus argumentos no necesitan ser átomos.
El resultado es una cadena.
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
(%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
Convierte expr a la notación lineal de Maxima, tal como si fuese tecleada.
El valor que retorna la función string es una cadena, por lo que no puede ser utilizada en los cálculos.
Valor por defecto: false
Si stringdisp vale true,
las cadenas alfanuméricas se muestran encerradas entre comillas dobles. En caso contrario, no se nuestran las comillas.
La variable stringdisp vale siempre true cuando se muestra la definición de una función.
Ejemplos:
(%i1) stringdisp: false$
(%i2) "This is an example string.";
(%o2) This is an example string.
(%i3) foo () :=
print ("This is a string in a function definition.");
(%o3) foo() :=
print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string.";
(%o5) "This is an example string."
Siguiente: Listas, Anterior: Cadenas de texto, Subir: Tipos de datos y estructuras [Índice general][Índice]
Anterior: Constantes, Subir: Constantes [Índice general][Índice]
El símbolo %e representa a la base de los logaritmos
naturales, también conocido como número de Euler. El valor numérico
de %e es el número decimal en coma flotante 2.718281828459045d0.
El símbolo %i representa la unidad imaginaria, sqrt(- 1).
El símbolo false representa al valor lógico
"falso". Maxima implementa false con el valor NIL de
Lisp.
Es la constante de Euler-Mascheroni, 0.5772156649015329 ....
ind representa un resultado acotado indeterminado.
Véase también limit.
Ejemplo:
(%i1) limit (sin(1/x), x, 0); (%o1) ind
El símbolo inf representa al infinito real positivo.
El símbolo infinity representa al infinito complejo.
El símbolo minf representa al infinito real negativo.
El símbolo %phi representa a la llamada razón áurea,
(1 + sqrt(5))/2.
El valor numérico de %phi es el número decimal en coma flotante 1.618033988749895d0.
La función fibtophi expresa los números de Fibonacci fib(n) en
términos de %phi.
Por defecto, Maxima desconoce las propiedades algebraicas de %phi.
Tras evaluar tellrat(%phi^2 - %phi - 1) y algebraic: true,
ratsimp puede simplificar algunas expresiones que contengan %phi.
Ejemplos:
fibtophi expresa el número de Fibonacci fib(n) en términos de %phi.
(%i1) fibtophi (fib (n));
n n
%phi - (1 - %phi)
(%o1) -------------------
2 %phi - 1
(%i2) fib (n-1) + fib (n) - fib (n+1);
(%o2) - fib(n + 1) + fib(n) + fib(n - 1)
(%i3) fibtophi (%);
n + 1 n + 1 n n
%phi - (1 - %phi) %phi - (1 - %phi)
(%o3) - --------------------------- + -------------------
2 %phi - 1 2 %phi - 1
n - 1 n - 1
%phi - (1 - %phi)
+ ---------------------------
2 %phi - 1
(%i4) ratsimp (%);
(%o4) 0
Por defecto, Maxima desconoce las propiedades algebraicas de %phi.
Después de evaluar tellrat (%phi^2 - %phi - 1) y
algebraic: true, ratsimp puede simplificar algunas expresiones
que contengan %phi.
(%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
2 2
(%o1) %phi A - %phi A - A + %phi - %phi - 1
(%i2) ratsimp (e);
2 2
(%o2) (%phi - %phi - 1) A + %phi - %phi - 1
(%i3) tellrat (%phi^2 - %phi - 1);
2
(%o3) [%phi - %phi - 1]
(%i4) algebraic : true;
(%o4) true
(%i5) ratsimp (e);
(%o5) 0
El símbolo %pi representa la razón entre la longitud de
una circunferencia y su radio.
El valor numérico de %pi es el número decimal en coma flotante 3.141592653589793d0.
El símbolo true representa al valor lógico
"verdadero". Maxima implementa true con el valor T de
Lisp.
und representa un resultado indefinido.
Véase también limit.
Ejemplo:
(%i1) limit (x*sin(x), x, inf); (%o1) und
zeroa representa un infinitesimal mayor que cero.
zeroa puede utilizarse en expresiones. limit
simplifica expresiones que contienen infinitesimales.
Véanse también zerob y limit.
Ejemplo:
limit simplifica expresiones que contienen infinitesimales:
(%i1) limit(zeroa); (%o1) 0 (%i2) limit(x+zeroa); (%o2) x
zerob representa un infinitesimal menor que cero.
zerob puede utilizarse en expresiones. limit
simplifica expresiones que contienen infinitesimales.
Véanse también zeroa y limit.
Siguiente: Arrays, Anterior: Constantes, Subir: Tipos de datos y estructuras [Índice general][Índice]
Siguiente: Funciones y variables para listas, Anterior: Listas, Subir: Listas [Índice general][Índice]
Las listas son bloques de construcción básica para Maxima y Lisp. Todos los tipos de datos diferentes a los arreglos, tablas mixtas o números son representados como listas Lisp, estas listas Lisp tienen la forma
((MPLUS) $A 2)
para indicar la expresión a+2. Al nivel de Maxima se observará
la notación infija a+2. Maxima también tiene listas con el formato
[1, 2, 7, x+y]
para una lista de 4 elementos. Internamente esto se corresponde con una lista Lisp de la forma
((MLIST) 1 2 7 ((MPLUS) $X $Y ))
El elemento que denota el tipo de expresión en Maxima es también una lista, la cual tras ser analizada y simplificada tomará la forma
((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
Anterior: Introducción a las listas, Subir: Listas [Índice general][Índice]
[ y ] marcan, respectivamente, el comienzo y el final de una lista.
[ y ] también se utilizan para indicar los subíndices
de una lista o de un array.
Ejemplos:
(%i1) x: [a, b, c]; (%o1) [a, b, c]
(%i2) x[3]; (%o2) c
(%i3) array (y, fixnum, 3); (%o3) y
(%i4) y[2]: %pi; (%o4) %pi
(%i5) y[2]; (%o5) %pi
(%i6) z['foo]: 'bar; (%o6) bar
(%i7) z['foo]; (%o7) bar
(%i8) g[k] := 1/(k^2+1);
1
(%o8) g := ------
k 2
k + 1
(%i9) g[10];
1
(%o9) ---
101
Devuelve una lista cuyos elementos son los de la lista lista_1 seguidos de los de lista_2, ... La función append también opera con expresiones generales, como la llamada append (f(a,b), f(c,d,e));, de la que se obtiene f(a,b,c,d,e).
Tecléese example(append); para ver un ejemplo.
Esta función busca la clave en el lado derecho de la lista, la cual es de la forma [x,y,z,...], donde cada elemento es una expresión formada por un operador binario y dos elementos. Por ejemplo, x=1, 2^3, [a,b] etc. La clave se compara con el primer operando. La función assoc devuelve el segundo operando si se encuentra con que la clave coincide. Si la clave no coincide entonces devuelve el valor valor_por_defecto. El argumento valor_por_defecto es opcional; en caso de no estar presente, se devolverá false.
Devuelve una nueva lista en la que el elemento expr ocupa la primera posición, seguido de los elementos de lista. La función cons también opera con otro tipo de expresiones, como cons(x, f(a,b,c)); -> f(x,a,b,c).
Devuelve una copia de la lista.
Crea una lista mediante la evaluación de form con x_1 tomando cada uno de los valores de list_1, para cada uno de estos valores liga x_2 con cada elemento de list_2, .... El número de elementos en el resultado será el producto del número de elementos en cada lista. Cada variable x_i debe ser un símbolo y no será evaluado. La lista de argumentos será evaluada una vez al comienzo de la iteración.
Ejemplos:
(%i1) create_list (x^i, i, [1, 3, 7]);
3 7
(%o1) [x, x , x ]
Con una doble iteración:
(%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]]
En lugar de list_i se pueden suministrar dos argumentos cada uno de los cuales debería poder evaluarse a un número, los cuales serán los límites inferior y superior, ambos inclusive, para cada iteración.
(%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]]
Nótese que los límites o lista para la variable j pueden depender
del valor actual de i.
delete(expr_1, expr_2)
elimina de expr_2 cualesquiera argumentos del operador
del nivel superior que sean iguales a expr_1.
Nótese que los argumentos de las subexpresiones no se ven
afectados por esta función.
expr_1 puede ser un átomo o una expresión no
atómica. expr_2 puede ser cualquier expresión no
atómica. La función delete devuelve una
nueva expresión sin modificar expr_2.
delete(expr_1, expr_2, n)
elimina de expr_2 los primeros n argumentos
del operador del nivel superior que sean iguales a expr_1.
Si hay menos de n argumentos iguales, entonces se
eliminan todos ellos.
Ejemplos:
Eliminando elementos de una lista.
(%i1) delete (y, [w, x, y, z, z, y, x, w]); (%o1) [w, x, z, z, x, w]
Eliminando términos de una suma.
(%i1) delete (sin(x), x + sin(x) + y); (%o1) y + x
Eliminando factores de un producto.
(%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z)); (%o1) (u - w) (u - y) (u - z)
Eliminando argumentos de una expresión arbitraria.
(%i1) delete (a, foo (a, b, c, d, a)); (%o1) foo(b, c, d)
Limitando el número de argumentos a eliminar.
(%i1) delete (a, foo (a, b, a, c, d, a), 2); (%o1) foo(b, c, d, a)
Los argumentos se comparan respecto de "=".
Aquellos argumentos que verifiquen la condición equal,
pero no "=" no serán eliminados.
(%i1) [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))]; rat: replaced 0.0 by 0/1 = 0.0 `rat' replaced 0.0B0 by 0/1 = 0.0B0 (%o1) [true, true, true]
(%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)]; (%o2) [true, false, false]
(%i3) delete (0, [0, 0.0, 0b0]); (%o3) [0.0, 0.0b0]
(%i4) is (equal ((x + y)*(x - y), x^2 - y^2)); (%o4) true
(%i5) is ((x + y)*(x - y) = x^2 - y^2); (%o5) false
(%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
2 2
(%o6) [x - y ]
Devuelve el octavo elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve una nueva lista formada por los elementos de lista seguidos de los de expr. La función endcons también opera con expresiones generales, por ejemplo endcons(x, f(a,b,c)); -> f(a,b,c,x).
Devuelve el quinto elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve la primera parte de expr, que puede consistir en el primer elemento de una lista, la primera fila de una matriz, el primer término de una suma, etc. Nótese que tanto first como sus funciones relacionadas, rest y last, operan sobre la forma en la que expr es mostrada por Maxima, no sobre la forma en la que es introducida la expresión. Sin embargo, cuando la variable inflag toma el valor true estas funciones tendrán en cuenta el formato interno de expr. Téngase en cuenta que el simplificador reordena las expresiones. Así, first(x+y) devolverá x si inflag vale true y y cuando inflag tome el valor false (first(y+x) devuelve el mismo resultado). Las funciones second ... tenth devuelven desde el segundo hasta el décimo elemento del argumento de entrada.
Devuelve el cuarto elemento de la lista o expresión expr. Véase first para más detalles.
Crea una nueva lista con los elementos de las listas l y m alternados.
El resultado tiene como elementos [l[1], m[1], l[2], m[2], ...].
Las listas l y m pueden contener cualquier tipo de elementos.
Si las listas son de diferente longitud, join ignora los elementos sobrantes de la lista más larga.
Maxima da error si o bien l o m no son listas.
Ejemplos:
(%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]
Devuelve la última parte (término, fila, elemento, etc.) de expr.
Devuelve (por defecto) el número de partes de que consta expr en la versión correspondiente a la que muestra. En el caso de listas, se devuelve el número de elementos, si se trata de matrices el número de filas y se se trata de sumas el número de términos o sumandos (véase dispform).
La función length se ve afectada por el valor de la variable inflag. Así, length(a/(b*c)); devuelve 2 si inflag vale false (dando por hecho que exptdispflag vale true), pero devuelve 3 si inflag vale true (ya que la representación interna es a*b^-1*c^-1).
Valor por defecto: true
Cuando vale false provoca que no se realicen operaciones aritméticas con listas; cuando vale true, las operaciones con listas y matrices son contagiosas, en el sentido de que las listas se transforman en matrices, retornando resultados de este último tipo. Sin embargo, operaciones que involucren listas con listas devolverán también listas.
Devuelve el valor true si expr es una lista, y false en caso contrario.
El primer formato, makelist (), crea una lista vacía. El
segundo formato, makelist (expr), crea una lista con expr
como único elemento. makelist (expr, n) crea una lista
de n elementos generados a partir de expr.
El formato más general, makelist (expr, i, i_0,
i_max, step), devuelve la lista de elementos obtenidos al
aplicar ev (expr, i=j) a los elementos j
de la secuencia i_0, i_0 + step, i_0 +
2*step, ..., siendo |j| menor o igual que |i_max|.
El incremento step puede ser un número (positivo o negativo) o una expresión. En caso de omitirse, se utilizará 1 como valor por defecto. Si se omiten i_0 y step, se le asignará a ambos 1 como valor por defecto.
makelist (expr, x, list) devuelve una lista, cuyo
j-ésimo elemento es igual a
ev (expr, x=list[j]) tomando j valores desde
1 hasta length (list).
Ejemplos:
(%i1) makelist (concat (x,i), i, 6); (%o1) [x1, x2, x3, x4, x5, x6]
(%i2) makelist (x=y, y, [a, b, c]); (%o2) [x = a, x = b, x = c]
(%i3) makelist (x^2, x, 3, 2*%pi, 2); (%o3) [9, 25]
(%i4) makelist (random(6), 4); (%o4) [2, 0, 2, 5]
(%i5) flatten (makelist (makelist (i^2, 3), i, 4)); (%o5) [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]
(%i6) flatten (makelist (makelist (i^2, i, 3), 4)); (%o6) [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]
Devuelve true si is(expr_1 = a)
para algún elemento a de args(expr_2),
en caso contrario devuelve false.
Normalmente, expr_2 será una lista,
en cuyo caso args(expr_2) = expr_2,
y la comprobación será si is(expr_1 = a) para
algún elemento a de expr_2.
La función member no inspecciona las partes de los argumentos de expr_2,
por lo que puede devolver false si expr_1 es parte de alguno de los argumentos de expr_2.
Véase también elementp.
Ejemplos:
(%i1) member (8, [8, 8.0, 8b0]); (%o1) true
(%i2) member (8, [8.0, 8b0]); (%o2) false
(%i3) member (b, [a, b, c]); (%o3) true
(%i4) member (b, [[a, b], [b, c]]); (%o4) false
(%i5) member ([b, c], [[a, b], [b, c]]); (%o5) true
(%i6) F (1, 1/2, 1/4, 1/8);
1 1 1
(%o6) F(1, -, -, -)
2 4 8
(%i7) member (1/8, %); (%o7) true
(%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
(%o8) true
Devuelve el noveno elemento de la lista o expresión expr. Véase first para más detalles.
Borra el primer elemento de la lista list y devuelve este mismo elemento.
Si el argumento list es una lista vacía, o simplemente no es una lista, Maxima devuelve un mensaje de error.
Véase push para los ejemplos.
Ejecútese load("basic") antes de utilizar esta función.
Añade al comienzo de la lista list el elemento item, devolviendo este mismo elemento. El argumento list debe ser necesariamente una lista, mientras que item puede ser cualquier símbolo o expresión.
Si el argumento list no es una lista, Maxima devuelve un mensaje de error.
Véase pop para eliminar el primer elemento de una lista.
Ejecútese load("basic") antes de utilizar esta función.
Ejemplos:
(%i1) load ("basic")$
(%i2) ll: []; (%o2) []
(%i3) push (x, ll); (%o3) [x]
(%i4) push (x^2+y, ll);
2
(%o4) [y + x , x]
(%i5) a: push ("string", ll);
2
(%o5) [string, y + x , x]
(%i6) pop (ll); (%o6) string
(%i7) pop (ll);
2
(%o7) y + x
(%i8) pop (ll); (%o8) x
(%i9) ll; (%o9) []
(%i10) a;
2
(%o10) [string, y + x , x]
Devuelve expr sin sus primeros n elementos si n es positivo, o sus últimos - n elementos si n es negativo. En caso de que n tome el valor 1 puede ser omitido. La expresión expr puede ser una lista, una matriz o cualquier otra expresión.
Invierte el orden de los elementos de la lista (no los propios elementos). La función reverse también opera sobre expresiones generales, como en reverse(a=b); gives b=a.
Devuelve el segundo elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve el séptimo elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve el sexto elemento de la lista o expresión expr. Véase first para más detalles.
sort(L, P) ordena la lista L de acuerdo con el predicado P
de dos argumentos, el cual define un preorden total sobre los elementos de L.
Si P(a, b) vale true, entonces a aparece antes que b en
el resultado. Si ninguna de las expresiones P(a, b) y P(b, a)
valen true, entonces a y b son equivalentes y aparecen en el
resultado en el mismo orden que a la entrada; esto es, sort es un orden estable.
Si tanto P(a, b) como P(b, a) valen ambos true para
algunos elementos de L, entonces P no es un predicado de orden correcto,
siento entonces el resultado indefinido. Si P(a, b) toma un valor diferente
a true o false, entonces sort devuelve un error.
El predicado puede especificarse como el nombre de una función, de una operación binaria
infija o como una expresión lambda. Si se especifica con el nombre de un operador,
dicho nombre debe encerrarse con comillas dobles.
La lista ordenada se devuelve como un nuevo objeto, no modificándose el argumento L.
sort(L) equivale a sort(L, orderlessp).
La ordenación por defecto es ascendente, tal como queda determinada por orderlessp.
El predicado ordergreatp ordena las listas en orden descendente.
Todos los átomos y expresiones de Maxima son comparables respecto de los predicados
orderlessp y ordergreatp.
Los operadores < y > ordenan números, constantes y expresiones constantes por
magnitud. Nótese que orderlessp y ordergreatp no ordenan números,
constantes y expresiones constantes por magnitud.
ordermagnitudep ordena números, constantes y expresiones constantes de igual modo
que lo hace <, y cualesquiera otros elementos lo hace igual que orderlessp.
Ejemplos:
sort ordena una lista respecto de un predicado de dos argumentos que define un
preorden total en los elementos de la lista.
(%i1) sort ([1, a, b, 2, 3, c], 'orderlessp); (%o1) [1, 2, 3, a, b, c] (%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp); (%o2) [c, b, a, 3, 2, 1]
El predicado puede especificarse con el nombre de una función, de un
operador binario infijo o una expresión lambda. Si se especifica
con el nombre de un operador, dicho nombre debe encerrarse con comillas dobles.
(%i1) L : [[1, x], [3, y], [4, w], [2, z]];
(%o1) [[1, x], [3, y], [4, w], [2, z]]
(%i2) foo (a, b) := a[1] > b[1];
(%o2) foo(a, b) := a > b
1 1
(%i3) sort (L, 'foo);
(%o3) [[4, w], [3, y], [2, z], [1, x]]
(%i4) infix (">>");
(%o4) >>
(%i5) a >> b := a[1] > b[1];
(%o5) a >> b := a > b
1 1
(%i6) sort (L, ">>");
(%o6) [[4, w], [3, y], [2, z], [1, x]]
(%i7) sort (L, lambda ([a, b], a[1] > b[1]));
(%o7) [[4, w], [3, y], [2, z], [1, x]]
sort(L) equivale a sort(L, orderlessp).
(%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi]; (%o1) [a, 2 b, - 5, 7, %e + 1, %pi] (%i2) sort (L); (%o2) [- 5, 7, %e + 1, %pi, a, 2 b] (%i3) sort (L, 'orderlessp); (%o3) [- 5, 7, %e + 1, %pi, a, 2 b]
La ordenación por defecto es ascendente, tal como queda determinada por orderlessp.
El predicado ordergreatp ordena las listas en orden descendente.
(%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi]; (%o1) [a, 2 b, - 5, 7, %e + 1, %pi] (%i2) sort (L); (%o2) [- 5, 7, %e + 1, %pi, a, 2 b] (%i3) sort (L, 'ordergreatp); (%o3) [2 b, a, %pi, %e + 1, 7, - 5]
Todos los átomos y expresiones de Maxima son comparables respecto de los predicados
orderlessp y ordergreatp.
(%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
5
(%o1) [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a]
2
(%i2) sort (L, orderlessp);
5
(%o2) [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)]
2
(%i3) sort (L, ordergreatp);
5
(%o3) [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17]
2
Los operadores < y > ordenan números, constantes y expresiones constantes por
magnitud. Nótese que orderlessp y ordergreatp no ordenan números,
constantes y expresiones constantes por magnitud.
(%i1) L : [%pi, 3, 4, %e, %gamma]; (%o1) [%pi, 3, 4, %e, %gamma] (%i2) sort (L, ">"); (%o2) [4, %pi, 3, %e, %gamma] (%i3) sort (L, ordergreatp); (%o3) [%pi, %gamma, %e, 4, 3]
ordermagnitudep ordena números, constantes y expresiones constantes de igual modo
que lo hace <, y cualesquiera otros elementos lo hace igual que orderlessp.
(%i1) L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
(%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0,
1.0b0]
(%i2) sort (L, ordermagnitudep);
(%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
%i + 1, 2 x]
(%i3) sort (L, orderlessp);
(%o3) [0, 1, 1.0, 2, 3, %e, %i, %i + 1, inf, minf, sin(1),
1.0b0, 2 x]
Devuelve la lista de elementos de list para los cuales el predicado p retorna true.
Ejemplo:
(%i1) L: [1, 2, 3, 4, 5, 6]; (%o1) [1, 2, 3, 4, 5, 6]
(%i2) sublist (L, evenp); (%o2) [2, 4, 6]
Devuelve los índices de los elementos x de la
lista L para la cual el predicado maybe(P(x))
devuelve true, lo que excluye a unknown y a false.
P puede ser el nombre de una función o de una expresión lambda.
L debe ser una lista literal.
Ejemplos:
(%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
lambda ([x], x='b));
(%o1) [2, 3, 7, 9]
(%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
(%o2) [1, 2, 3, 4, 7, 9]
(%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
identity);
(%o3) [1, 4, 5]
(%i4) assume (x < -1); (%o4) [x < - 1]
(%i5) map (maybe, [x > 0, x < 0, x < -2]); (%o5) [false, true, unknown]
(%i6) sublist_indices ([x > 0, x < 0, x < -2], identity); (%o6) [2]
Devuelve la lista L sin redundancias, es decir, sin elementos repetidos
Cuando ninguno de los elementos de L está repetido,
unique devuelve una réplica de L, no la
propia L.
Si L no es una lista, unique devuelve L.
Ejemplo:
(%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]); (%o1) [1, 2, %e, %pi, [1], b + a]
Devuelve el décimo elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve el tercer elemento de la lista o expresión expr. Véase first para más detalles.
Siguiente: Estructuras, Anterior: Listas, Subir: Tipos de datos y estructuras [Índice general][Índice]
Siguiente: Funciones y variables para los arrays, Anterior: Arrays, Subir: Arrays [Índice general][Índice]
Los arrays más flexibles son aquellos que no necesitan ser declarados, llamados
también, en inglés, hashed-arrays, y se basan en que a una variable
subindicada se le puede asignar un valor cualquiera. Los índices
no necesitan ser números enteros, admitiéndose símbolos o
expresiones. Los arrays no declarados crecen dinámicamente según se le van
asignando valores a sus elementos. En el siguiente ejemplo se muestra cómo
se va construyendo un array no declarado a. Para obtener un listado de
los elementos de un array se utiliza la función listarray.
(%i1) a[1,2]: 99;
(%o1) 99
(%i2) a[x,y]: x^y;
y
(%o2) x
(%i3) listarray(a);
y
(%o3) [99, x ]
Otro tipo de arrays son los declarados, los cuales admiten hasta cinco dimensiones
y pueden guardar valores de un tipo concreto, como fixnum para enteros o
flonum para reales de coma flotante. Maxima distingue dos tipos de arrays
declarados; los primeros se pueden definir declarando un símbolo
como array, haciendo uso de la función array; los segundos son arrays
de Lisp, en los que un símbolo se declara como tal con la
función make_array.
En el primer ejemplo se declara el símbolo a como array,
mientras que en el segundo se declara b como array de Lisp.
(%i1) array(a, fixnum, 2, 2);
(%o1) a
(%i2) b: make_array(fixnum, 2, 2);
(%o2) {Array: #2A((0 0) (0 0))}
Cuando a la variable opcional use_fast_arrays se le asigna el valor
true, la función array también generará un array de Lisp.
Tal es lo que sucede en el ejemplo siguiente, en el que el símbolo
c queda declarado como array de Lisp. Téngase en cuenta que por este
método no se puede asignar el tipo de array, ya que al introducirle el tipo
fixnum se genera un mensaje de error.
(%i3) use_fast_arrays: true; (%o3) true (%i4) array(c, 2, 2); (%o4) #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL)) (%i5) c; (%o5) #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL)) (%i6) array(c, fixnum, 2, 2); make_array: dimensions must be integers; found [fixnum + 1, 3, 3] -- an error. To debug this try: debugmode(true);
Maxima también dispone de funciones array, que pueden almacenar valores de funciones, y de funciones subindicadas.
Se puede encontrar más información en las descripciones de las funciones. Los siguientes símbolos y funciones de Maxima permiten trabajar con arrays:
array arrayapply arrayinfo arraymake arrays fillarray listarray make_array rearray remarray subvar subvarp use_fast_arrays
Anterior: Introducción a los arrays, Subir: Arrays [Índice general][Índice]
Crea un array de dimensión n, que debe ser menor o igual que 5. Los subíndices de la i-ésima dimensión son enteros que toman valores entre 0 y dim_i.
La llamada array (nombre, dim_1, ..., dim_n) crea un array de tipo general.
La llamada array (nombre, type, dim_1, ..., dim_n) crea un array con sus elementos del tipo especificado. El tipo type puede ser fixnum para enteros de tamaño limitado o flonum para números decimales en coma flotante.
La llamada array ([nombre_1, ..., nombre_m], dim_1, ..., dim_n)
crea m arrays, todos ellos de igual dimensión.
Si el usuario asigna un valor a una variable subindicada antes de declarar el array correspondiente, entonces se construye un array no declarado. Los arrays no declarados, también conocidos por el nombre de "arrays de claves" (hashed arrays), son más generales que los arrays declarados. El usuario no necesita declarar su tamaño máximo y pueden ir creciendo de forma dinámica. Los subíndices de los arrays no declarados no necesitan ser necesariamente números. Sin embargo, a menos que un array tenga sus elementos dispersos, probablemente sea más eficiente declararlo siempre que sea posible antes que dejarlo como no declarado. La función array puede utilizarse para transformar un array no declarado a a uno declarado.
Evalúa A [i_1, ..., i_n], donde A es un array y i_1, ..., i_n son enteros.
Esto es como apply, excepto por el hecho de que el primer argumento es un array en lugar de una función.
Devuelve información sobre el arrayA. El argumento A puede ser un array declarado o no declarado, una función array o una función subindicada.
En el caso de arrays declarados, arrayinfo devuelve una
lista que contiene el átomo declared, el número de
dimensiones y el tamaño de cada dimensión.
Los elementos del array, tanto los que tienen valores
asignados como los que no, son devueltos por listarray.
En el caso de arrays no declarados (hashed arrays), arrayinfo
devuelve una lista que contiene el átomo hashed, el número
de subíndices y los subíndices de aquellos
elementos que guarden un valor. Los valores son devueltos por listarray.
En el caso de funciones array, arrayinfo devuelve una lista que
contiene el átomo hashed, el número de subíndices
y los subíndices para los que la función tiene valores almacenados.
Los valores almacenados de la función array son devueltos por listarray.
En el caso de funciones subindicadas, arrayinfo devuelve una lista que
contiene el átomo hashed, el número de subíndices y
los subíndices para los que hay expresiones lambda.
Las expresiones lambda son devueltas por listarray.
Ejemplos:
arrayinfo y listarray aplicadas a una array declarado.
(%i1) array (aa, 2, 3);
(%o1) aa
(%i2) aa [2, 3] : %pi;
(%o2) %pi
(%i3) aa [1, 2] : %e;
(%o3) %e
(%i4) arrayinfo (aa);
(%o4) [declared, 2, [2, 3]]
(%i5) listarray (aa);
(%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
#####, #####, #####, %pi]
arrayinfo y listarray aplicadas a una array no declarado (hashed arrays).
(%i1) bb [FOO] : (a + b)^2;
2
(%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3;
3
(%o2) (c - d)
(%i3) arrayinfo (bb);
(%o3) [hashed, 1, [BAR], [FOO]]
(%i4) listarray (bb);
3 2
(%o4) [(c - d) , (b + a) ]
arrayinfo y listarray aplicadas a una función array.
(%i1) cc [x, y] := y / x;
y
(%o1) cc := -
x, y x
(%i2) cc [u, v];
v
(%o2) -
u
(%i3) cc [4, z];
z
(%o3) -
4
(%i4) arrayinfo (cc);
(%o4) [hashed, 2, [4, z], [u, v]]
(%i5) listarray (cc);
z v
(%o5) [-, -]
4 u
arrayinfo y listarray aplicadas a una función subindicada.
(%i1) dd [x] (y) := y ^ x;
x
(%o1) dd (y) := y
x
(%i2) dd [a + b];
b + a
(%o2) lambda([y], y )
(%i3) dd [v - u];
v - u
(%o3) lambda([y], y )
(%i4) arrayinfo (dd);
(%o4) [hashed, 1, [b + a], [v - u]]
(%i5) listarray (dd);
b + a v - u
(%o5) [lambda([y], y ), lambda([y], y )]
El resultado es una referencia a array no evaluada.
Devuelve la expresión name [i_1, ..., i_n].
Esta función es similar a funmake, excepto que el valor retornado es referencia a un array no evaluado, en lugar de una llamada a una función no evaluada.
Ejemplos:
(%i1) arraymake (A, [1]);
(%o1) A
1
(%i2) arraymake (A, [k]);
(%o2) A
k
(%i3) arraymake (A, [i, j, 3]);
(%o3) A
i, j, 3
(%i4) array (A, fixnum, 10);
(%o4) A
(%i5) fillarray (A, makelist (i^2, i, 1, 11));
(%o5) A
(%i6) arraymake (A, [5]);
(%o6) A
5
(%i7) ''%;
(%o7) 36
(%i8) L : [a, b, c, d, e];
(%o8) [a, b, c, d, e]
(%i9) arraymake ('L, [n]);
(%o9) L
n
(%i10) ''%, n = 3;
(%o10) c
(%i11) A2 : make_array (fixnum, 10);
(%o11) {Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o12) {Array: #(1 2 3 4 5 6 7 8 9 10)}
(%i13) arraymake ('A2, [8]);
(%o13) A2
8
(%i14) ''%;
(%o14) 9
Valor por defecto: []
La variable arrays es una lista con todos los arrays que han sido alojados,
lo que comprende a los arrays declarados por array, a los
no declarados (hashed arrays) construidos implícitamente
(asignando algo al elemento de un array) y a las funciones array definidas
mediante := y define.
Los arrays definidos mediante make_array no se incluyen en
este grupo.
Véanse también
array, arrayapply, arrayinfo, arraymake,
fillarray, listarray y rearray.
Ejemplos:
(%i1) array (aa, 5, 7);
(%o1) aa
(%i2) bb [FOO] : (a + b)^2;
2
(%o2) (b + a)
(%i3) cc [x] := x/100;
x
(%o3) cc := ---
x 100
(%i4) dd : make_array ('any, 7);
(%o4) {Array: #(NIL NIL NIL NIL NIL NIL NIL)}
(%i5) arrays;
(%o5) [aa, bb, cc]
Asigna x a A[i_1, ..., i_n],
siendo A un array y i_1, …, i_n enteros.
arraysetapply evalúa sus argumentos.
Rellena el array A con los valores de B, que puede ser una lista o array.
Si se ha declarado A de un determinado tipo en el momento de su creación, sólo podrá contener elementos de ese tipo, produciéndose un error en caso de intentar asignarle un elemento de tipo distinto.
Si las dimensiones de los arrays A y B son diferentes, A se rellena según el orden de las filas. Si no hay suficientes elementos en B el último elemento se utiliza para cubrir el resto de A. Si hay demasiados, los elementos sobrantes son ignorados.
La función fillarray devuelve su primer argumento.
Ejemplos:
Creación de un array de 9 elementos y posterior relleno a partir de una lista.
(%i1) array (a1, fixnum, 8); (%o1) a1 (%i2) listarray (a1); (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0] (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]); (%o3) a1 (%i4) listarray (a1); (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9]
Si no hay suficientes elementos para cubrir el array, se repite el último elemento. Si hay demasiados, los elementos sobrantes son ignorados.
(%i1) a2 : make_array (fixnum, 8);
(%o1) {Array: #(0 0 0 0 0 0 0 0)}
(%i2) fillarray (a2, [1, 2, 3, 4, 5]);
(%o2) {Array: #(1 2 3 4 5 5 5 5)}
(%i3) fillarray (a2, [4]);
(%o3) {Array: #(4 4 4 4 4 4 4 4)}
(%i4) fillarray (a2, makelist (i, i, 1, 100));
(%o4) {Array: #(1 2 3 4 5 6 7 8)}
Arrays multidimensionales se rellenan según el orden de las filas.
(%i1) a3 : make_array (fixnum, 2, 5);
(%o1) {Array: #2A((0 0 0 0 0) (0 0 0 0 0))}
(%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o2) {Array: #2A((1 2 3 4 5) (6 7 8 9 10))}
(%i3) a4 : make_array (fixnum, 5, 2);
(%o3) {Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
(%i4) fillarray (a4, a3);
(%o4) {Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))}
Devuelve una lista con los elementos del array A. El argumento A puede ser un array declarado o no declarado, una función array o una función subindicada.
Los elementos se ordenan en primera instancia respecto del primer
índice, después respecto del segundo índice
y así sucesivamente.
La ordenación de los índices es la misma que la
establecida por orderless.
En el caso de arrays no declarados, funciones array y funciones
subindicadas, los elementos corresponden a los índices
devueltos por arrayinfo.
Los elementos de los arrays declarados que no tienen valores asignados
(excepto fixnum y flonum) se devuelven como #####.
Los elementos sin valores asignados de los arrays fixnum y flonum
son devueltos como 0 y 0.0, respectivamente.
Los elementos sin valor asignado de los arrays no declarados,
funciones array y funciones subindicadas no son devueltos.
Ejemplos:
listarray y arrayinfo aplicadas a un array declarado.
(%i1) array (aa, 2, 3);
(%o1) aa
(%i2) aa [2, 3] : %pi;
(%o2) %pi
(%i3) aa [1, 2] : %e;
(%o3) %e
(%i4) listarray (aa);
(%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
#####, #####, #####, %pi]
(%i5) arrayinfo (aa);
(%o5) [declared, 2, [2, 3]]
listarray y arrayinfo aplicadas a un array no declarado (hashed array).
(%i1) bb [FOO] : (a + b)^2;
2
(%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3;
3
(%o2) (c - d)
(%i3) listarray (bb);
3 2
(%o3) [(c - d) , (b + a) ]
(%i4) arrayinfo (bb);
(%o4) [hashed, 1, [BAR], [FOO]]
listarray y arrayinfo aplicadas a una función array.
(%i1) cc [x, y] := y / x;
y
(%o1) cc := -
x, y x
(%i2) cc [u, v];
v
(%o2) -
u
(%i3) cc [4, z];
z
(%o3) -
4
(%i4) listarray (cc);
z v
(%o4) [-, -]
4 u
(%i5) arrayinfo (cc);
(%o5) [hashed, 2, [4, z], [u, v]]
listarray y arrayinfo aplicadas a una función subindicada.
(%i1) dd [x] (y) := y ^ x;
x
(%o1) dd (y) := y
x
(%i2) dd [a + b];
b + a
(%o2) lambda([y], y )
(%i3) dd [v - u];
v - u
(%o3) lambda([y], y )
(%i4) listarray (dd);
b + a v - u
(%o4) [lambda([y], y ), lambda([y], y )]
(%i5) arrayinfo (dd);
(%o5) [hashed, 1, [b + a], [v - u]]
Construye y devuelve un array de Lisp. El argumento tipo puede ser
any, flonum, fixnum, hashed o functional.
Hay n índices, y el índice i-ésimo
va de 0 a dim_i - 1.
La ventaja de make_array sobre array estriba en que el valor
retornado no tiene nombre, y una vez que un puntero deja de referenciarlo,
el valor desaparece. Por ejemplo, si y: make_array (...) entonces
y apunta a un objeto que ocupa cierto espacio en la memoria, pero
después de y: false, y ya no apunta al objeto, por lo
que éste puede ser considerado basura y posteriormente eliminado.
Ejemplos:
(%i1) A1 : make_array (fixnum, 10);
(%o1) {Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i2) A1 [8] : 1729;
(%o2) 1729
(%i3) A1;
(%o3) {Array: #(0 0 0 0 0 0 0 0 1729 0)}
(%i4) A2 : make_array (flonum, 10);
(%o4) {Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i5) A2 [2] : 2.718281828;
(%o5) 2.718281828
(%i6) A2;
(%o6)
{Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i7) A3 : make_array (any, 10);
(%o7) {Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
(%i8) A3 [4] : x - y - z;
(%o8) - z - y + x
(%i9) A3;
(%o9) {Array: #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
-1 $Y) ((MTIMES SIMP) -1 $Z))
NIL NIL NIL NIL NIL)}
(%i10) A4 : make_array (fixnum, 2, 3, 5);
(%o10) {Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
(%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
(%o11) {Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))}
(%i12) A4 [0, 2, 1];
(%o12) 12
Cambia las dimensiones de un array. El nuevo array será rellenado con los elementos del viejo según el orden de las filas. Si el array antiguo era demasiado pequeño, los elementos restantes se rellenan con false, 0.0 o 0, dependiendo del tipo del array. El tipo del array no se puede cambiar.
Borra los arrays y las funciones relacionadas con ellos, liberando el espacio de memoria ocupado. Los argumentos pueden ser arrays declarados, arrays no declarados (hashed arrays), funciones array y funciones subindicadas.
La llamada remarray (all) borra todos los elementos de la lista global arrays.
La función remarray devuelve la lista de los arrays borrados.
La función remarray no evalúa sus argumentos.
Evalúa la expresión subindicada x[i].
La función subvar evalúa sus argumentos.
La instrucción arraymake (x, [i]) construye la expresión x[i],
pero no la evalúa.
Ejemplos:
(%i1) x : foo $
(%i2) i : 3 $
(%i3) subvar (x, i);
(%o3) foo
3
(%i4) foo : [aa, bb, cc, dd, ee]$
(%i5) subvar (x, i);
(%o5) cc
(%i6) arraymake (x, [i]);
(%o6) foo
3
(%i7) ''%;
(%o7) cc
Devuelve true si expr es una variable subindicada, como a[i].
Valor por defecto: false
Si use_fast_arrays vale true entonces tan solo se reconocen dos tipos de arrays.
Anterior: Arrays, Subir: Tipos de datos y estructuras [Índice general][Índice]
Siguiente: Funciones y variables para las estructuras, Anterior: Estructuras, Subir: Estructuras [Índice general][Índice]
Maxima dispone de estructuras para la agregación de datos. Una estructura es una expresión en la que los argumentos se definen con un nombre (nombre del campo) y la estructura en su conjunto se define por medio de su operador (nombre de la estructura). Los valores dados a los campos pueden ser expresiones cualesquiera.
Una estructura se define con la función defstruct, guardando la
variable structures la lista de todas las estructuras definidas
por el usuario. El operador @ permite hacer referencias a los
campos de la estructura. Con kill(S) se borra la estructura
S completa y kill(x@ a) elimina la asignación
actual del campo a en la estructura x.
En la impresión por consola (con display2d igual a true),
las estructuras se representan con las asignaciones de los campos en forma de ecuación,
con el nombre del campo a la izquierda y su valor asociado a la derecha. En la
impresión unidimensional (mediante grind o dándole a display2d
el valor false), las estructuras se escriben sin los nombres de los campos.
No es posible utilizar el nombre de un campo como nombre de función, pero el valor de un campo sí puede ser una expresión lambda. Tampoco es posible restringir los valores de los campos a tipos de datos concretos, siendo el caso que a cada campo se le puede asignar cualquier tipo de expresión. Por último, no es posible hacer que ciertos campos sean o no accesibles desde determinados contextos, ya que todos los campos son siempre visibles.
Anterior: Introducción a las estructuras, Subir: Estructuras [Índice general][Índice]
structures es la lista que contiene las estructuras definidas por el usuario con defstruct.
Define una estructura, la cual es una lista de nombres de campos a_1, ..., a_n
asociados a un símbolo S.
Todo individuo de una estructura dada consiste en una expresión con operador S
y exactamente n argumentos. La sentencia new(S) crea un nuevo
individuo con estructura S.
Un argumento consistente en un símbolo a especifica el nombre de
un campo. Un argumento consistente en una ecuación a = v especifica
el nombre del campo a junto con su valor por defecto v. El valor por
defecto puede ser cualquier tipo de expresión.
La llamada a defstruct añade S a la lista de estructuras definidas
por el usuario, structures.
La sentencia kill(S) borra S de la lista de estructuras
definidas por el usuario y elimina la definición de la estructura.
Ejemplos:
(%i1) defstruct (foo (a, b, c)); (%o1) [foo(a, b, c)] (%i2) structures; (%o2) [foo(a, b, c)] (%i3) new (foo); (%o3) foo(a, b, c) (%i4) defstruct (bar (v, w, x = 123, y = %pi)); (%o4) [bar(v, w, x = 123, y = %pi)] (%i5) structures; (%o5) [foo(a, b, c), bar(v, w, x = 123, y = %pi)] (%i6) new (bar); (%o6) bar(v, w, x = 123, y = %pi) (%i7) kill (foo); (%o7) done (%i8) structures; (%o8) [bar(v, w, x = 123, y = %pi)]
new crea nuevos individuos de estructuras declaradas.
La sentencia new(S) crea un nuevo individuo de
estructura S en el que cada campo toma su valor por defecto,
si este fue definido, o sin valor alguno en caso de que no se haya
fijado un valor por defecto en la definición de la estructura.
La sentencia new(S(v_1, ..., v_n))
crea un nuevo individuo de estructura S en el que los campos
adquieren los valores v_1, ..., v_n.
Ejemplos:
(%i1) defstruct (foo (w, x = %e, y = 42, z)); (%o1) [foo(w, x = %e, y = 42, z)] (%i2) new (foo); (%o2) foo(w, x = %e, y = 42, z) (%i3) new (foo (1, 2, 4, 8)); (%o3) foo(w = 1, x = 2, y = 4, z = 8)
@ es el operador para acceder a los campos de las estructuras.
La expresión x@ a hace referencia al valor del
campo a del individuo x de una estructura dada. El nombre del campo no se evalúa.
Si el campo a de x no tiene valor asignado, x@ a
se evalúa a sí mismo; es decir, devuelve la propia expresión
x@ a tal cual.
La sentencia kill(x@ a) elimina el valor del campo a de x.
Ejemplos:
(%i1) defstruct (foo (x, y, z)); (%o1) [foo(x, y, z)] (%i2) u : new (foo (123, a - b, %pi)); (%o2) foo(x = 123, y = a - b, z = %pi) (%i3) u@z; (%o3) %pi (%i4) u@z : %e; (%o4) %e (%i5) u; (%o5) foo(x = 123, y = a - b, z = %e) (%i6) kill (u@z); (%o6) done (%i7) u; (%o7) foo(x = 123, y = a - b, z) (%i8) u@z; (%o8) u@z
El nombre del campo no se evalúa.
(%i1) defstruct (bar (g, h)); (%o1) [bar(g, h)] (%i2) x : new (bar); (%o2) bar(g, h) (%i3) x@h : 42; (%o3) 42 (%i4) h : 123; (%o4) 123 (%i5) x@h; (%o5) 42 (%i6) x@h : 19; (%o6) 19 (%i7) x; (%o7) bar(g, h = 19) (%i8) h; (%o8) 123
Siguiente: Operadores, Anterior: Línea de comandos [Índice general][Índice]