This is maxima.info, produced by makeinfo version 6.6 from maxima.texi. Este es el Manual de Maxima en versión Texinfo Copyright 1994, 2001 William F. Schelter START-INFO-DIR-ENTRY * Maxima: (maxima). Un sistema de cálculo simbólico END-INFO-DIR-ENTRY  File: maxima.info, Node: Simplificación, Next: Funciones matemáticas, Prev: Expresiones, Up: Top 9 Simplificación **************** * Menu: * Introducción a la simplificación:: * Funciones y variables para simplificación::  File: maxima.info, Node: Introducción a la simplificación, Next: Funciones y variables para simplificación, Prev: Simplificación, Up: Simplificación 9.1 Introducción a la simplificación ==================================== Tras la evaluación de una expresión se procede a su simplificación. Las funciones matemáticas que involucran cálculos simbólicos y las expresiones con operadores aritméticos no son evaluadas, sino simplificadas, para lo cual Maxima las representa internamente en forma nominal; de ahí que el cálculo numérico de una suma o de una multiplicación no se considera una evaluación, sino una simplificación. La evaluación de una expresión puede inhibirse con el operador de comilla simple (''') y su simplificación se puede controlar con el valor asignado a la variable opcional 'simp'. En el siguiente ejemplo, se evita la simplificación con el operador de comilla simple, siendo el resultado una expresión nominal. A continuación, se inhibe la simplificación tras la evaluación de la derivada, dejando sin reducir el resultado a '2*x'. (%i1) 'diff(x*x,x); d 2 (%o1) -- (x ) dx (%i2) simp:false; (%o2) false (%i3) diff(x*x,x); (%o3) 1 x + 1 x Para cada función u operador matemático dispone Maxima de una rutina interna que será utilizada para su simplificación siempre que se la encuentre en una expresión. Estas rutinas implementan propiedades simétricas, valores especiales de las funciones y otras propiedades y reglas. La gran cantidad de variables opcionales permiten mantener bajo control la simplificación de funciones y operadores. Veamos un ejemplo. La simplificación de la función exponencial 'exp' se controla con las siguientes variables opcionales: '%enumer', '%emode', '%e_to_numlog', 'code', 'logsimp' y 'demoivre'. En el primer caso la expresión con la función exponencial no se simplifica, pero en el segundo se reduce a '%i*%pi/2'. (%i1) exp(x+%i*%pi/2), %emode:false; %i %pi x + ------ 2 (%o1) %e (%i2) exp(x+%i*%pi/2), %emode:true; x (%o2) %i %e Junto con la simplificación aislada de funciones y operadores que Maxima realiza de forma automática, existen también funciones como 'expand' o 'radcan' que realizan sobre las expresiones simplificaciones especiales. Sigue un ejemplo: (%i1) (log(x+x^2)-log(x))^a/log(1+x)^(a/2); 2 a (log(x + x) - log(x)) (%o1) ----------------------- a/2 log(x + 1) (%i2) radcan(%); a/2 (%o2) log(x + 1) A un operador o función se le pueden asignar propiedades tales como la linealidad, la simetría u otras. Maxima tiene en cuenta estas propiedades durante la simplificación. Por ejemplo, la instrucción 'declare(f, oddfun)' declara la función como impar, con lo que Maxima sabrá que las formas 'f(-x)' y '-f(x)' son equivalentes, llevando a cabo la reducción oportuna. Las siguientes propiedades están en la lista 'opproperties' y controlan la simplificación de funciones y operadores: additive lassociative oddfun antisymmetric linear outative commutative multiplicative rassociative evenfun nary symmetric Tanto las propiedades como los hechos (o hipótesis) establecidos por el usuario dentro de un contexto influyen sobre el proceso de simplificación. Para más detalles véase el capítulo sobre la base de datos de Maxima. La función seno reduce los múltiplos enteros de '%pi' al valor cero. En este ejemplo se muestra cómo al dotar al símbolo 'n' de la propiedad de ser entero, la función se simplifica de la forma apropiada. (%i1) sin(n*%pi); (%o1) sin(%pi n) (%i2) declare(n, integer); (%o2) done (%i3) sin(n*%pi); (%o3) 0 Si las técnicas anteriores no devuelven el resultado esperado por el usuario, éste puede extender a voluntad las reglas que pueda aplicar Maxima; para más información al respecto, véase el capítulo dedicado a las reglas y patrones.  File: maxima.info, Node: Funciones y variables para simplificación, Prev: Introducción a la simplificación, Up: Simplificación 9.2 Funciones y variables para simplificación ============================================= -- Propiedad: additive Si 'declare(f,additive)' ha sido ejecutado, entonces: (1) Si 'f' es univariado, cada vez que el simplificador encuentre 'f' aplicada a una suma, 'f' será distribuida bajo esta suma. Por ejemplo, 'f(x+y)' se simplificará a 'f(x)+f(y)'. (2) Si 'f' es una función de 2 o más argumentos, aditivamente es definida como aditiva en el primer argumento de 'f', como en el caso de 'sum' o 'integrate'. Por ejemplo, 'f(h(x)+g(x),x)' se simplificará a 'f(h(x),x)+f(g(x),x)'. Esta simplificación no ocurre cuando 'f' se aplica a expresiones de la forma 'sum(x[i],i,lower-limit,upper-limit)'. Ejemplo: (%i1) F3 (a + b + c); (%o1) F3(c + b + a) (%i2) declare (F3, additive); (%o2) done (%i3) F3 (a + b + c); (%o3) F3(c) + F3(b) + F3(a) -- Propiedad: antisymmetric Si 'declare(h,antisymmetric)' es ejecutado, esto dice al simplificador que 'h' es antisimétrico. E.g. 'h(x,z,y)' será simplificado a '-h(x,y,z)'. Que es, el producto de (-1)^n por el resultado dado por 'symmetric' o 'commutative', donde n es el número de intercambios necesarios de dos argumentos para convertirle a esta forma. Ejemplos: (%i1) S (b, a); (%o1) S(b, a) (%i2) declare (S, symmetric); (%o2) done (%i3) S (b, a); (%o3) S(a, b) (%i4) S (a, c, e, d, b); (%o4) S(a, b, c, d, e) (%i5) T (b, a); (%o5) T(b, a) (%i6) declare (T, antisymmetric); (%o6) done (%i7) T (b, a); (%o7) - T(a, b) (%i8) T (a, c, e, d, b); (%o8) T(a, b, c, d, e) -- Función: combine () Simplifica la suma combinando términos de con igual denominador reduciéndolos a un único término. -- Propiedad: commutative Si 'declare(h,commutative)' es ejecutado, le dice al simplificador que 'h' es una función conmutaiva. Por ejemplo, 'h(x,z,y)' se simplificará a 'h(x,y,z)'. Esto es lo mismo que 'symmetric'. -- Función: demoivre () -- Variable opcional: demoivre La función 'demoivre (expr)' convierte una expresión sin modificar la variable global 'demoivre'. Cuando 'demoivre' vale 'true', los exponenciales complejos se convierten en expresiones equivalentes pero en términos de las funciones trigonométricas: 'exp (a + b*%i)' se reduce a '%e^a * (cos(b) + %i*sin(b))' si 'b' no contiene a '%i'. Las expresiones 'a' y 'b' no se expanden. El valor por defecto de 'demoivre' es 'false'. La función 'exponentialize' convierte funciones trigonométricas e hiperbólicas a la forma exponencial, por lo que 'demoivre' y 'exponentialize' no pueden valer 'true' al mismo tiempo. -- Función: distrib () Distribuye sumas sobre productos. Difiere de 'expand' en que trabaja sólo al nivel superior de una expresión, siendo más rápida que 'expand'. Difiere de 'multthru' en que expande todas las sumas del nivel superior. Ejemplos: (%i1) distrib ((a+b) * (c+d)); (%o1) b d + a d + b c + a c (%i2) multthru ((a+b) * (c+d)); (%o2) (b + a) d + (b + a) c (%i3) distrib (1/((a+b) * (c+d))); 1 (%o3) --------------- (b + a) (d + c) (%i4) expand (1/((a+b) * (c+d)), 1, 0); 1 (%o4) --------------------- b d + a d + b c + a c -- Variable opcional: distribute_over Valor por defecto: 'true' 'distribute_over' controla la distribución de funciones sobre estructuras como listas, matrices y ecuaciones. Actualmente, no todas las funciones de Maxima tienen esta propiedad. Es posible consultar si una función tiene esta propiedad con la instrucción 'properties'. La propiedad distributiva se desactiva asignándole a 'distribute_over' el valor 'false'. Ejemplos: La función 'sin' se distribuye sobre una lista: (%i1) sin([x,1,1.0]); (%o1) [sin(x), sin(1), .8414709848078965] 'mod' es una función de dos argumentos que se distribuye sobre listas. La distribución sobre listas anidadas también es posible. (%i2) mod([x,11,2*a],10); (%o2) [mod(x, 10), 1, 2 mod(a, 5)] (%i3) mod([[x,y,z],11,2*a],10); (%o3) [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)] Distribución de la función 'floor' sobre una matriz y una ecuación. (%i4) floor(matrix([a,b],[c,d])); [ floor(a) floor(b) ] (%o4) [ ] [ floor(c) floor(d) ] (%i5) floor(a=b); (%o5) floor(a) = floor(b) Funciones con más de un argumento se distribuyen sobre cualquiera de sus argumentos, o sobre todos ellos. (%i6) expintegral_e([1,2],[x,y]); (%o6) [[expintegral_e(1, x), expintegral_e(1, y)], [expintegral_e(2, x), expintegral_e(2, y)]] Comprueba si una función tiene la propiedad 'distribute_over': (%i7) properties(abs); (%o7) [integral, distributes over bags, noun, rule, gradef] -- Variable opcional: domain Valor por defecto: 'real' Si 'domain' vale 'complex', 'sqrt (x^2)' permanecerá como 'sqrt (x^2)' en lugar de devolver 'abs(x)'. -- Propiedad: evenfun -- Propiedad: oddfun 'declare(f, evenfun' o 'declare(f, oddfun)' indican a Maxima que reconozca la función 'f' como par o impar, respectivamente. Ejemplos: (%i1) o (- x) + o (x); (%o1) o(x) + o(- x) (%i2) declare (o, oddfun); (%o2) done (%i3) o (- x) + o (x); (%o3) 0 (%i4) e (- x) - e (x); (%o4) e(- x) - e(x) (%i5) declare (e, evenfun); (%o5) done (%i6) e (- x) - e (x); (%o6) 0 -- Función: expand () -- Función: expand (,

, ) Expande la expresión . Los productos de sumas y de sumas con exponentes se multiplican, los numeradores de las expresiones racionales que son sumas se separan en sus respectivos términos, y las multiplicaciones (tanto las que son conmutativas como las que no) se distribuyen sobre las sumas en todos los niveles de . En el caso de los polinomios es más aconsejable utilizar 'ratexpand', que utiliza un algoritmo más eficiente. Las variables 'maxnegex' y 'maxposex' controlan los máximos exponentes negativos y positivos que se van a expandir. La llamada 'expand (,

, )' expande asignando a 'maxposex' el valor

y a 'maxnegex' el . Esto es útil para expandir sólo parte de la expresión. La variable 'expon' guarda el mayor exponente negativo que será expandido automáticamente, independientemente de 'expand'. Por ejemplo, si 'expon' vale 4 entonces '(x+1)^(-5)' no se expandirá automáticamente. La variable 'expop' guarda el mayor exponente positivo que será expandido automáticamente. Así, '(x+1)^3' se expandirá automáticamente sólo si 'expop' es mayor o igual que 3. Si se quiere expandir '(x+1)^n', siendo 'n' mayor que 'expop', entonces 'expand ((x+1)^n)' se desarrollará sólo si 'maxposex' no es menor que 'n'. 'expand(expr, 0, 0)' provoca que se vuelva a simplificar 'expr'. 'expr' no se vuelve a evaluar. A diferencia de 'ev(expr, noeval)', se elimina la representación canónica de la expresión. Véase también 'ev'. La variable 'expand' utilizada con 'ev' provocará una expansión. El fichero 'share/simplification/facexp.mac' contiene algunas funciones relacionadas con 'expand' (en concreto, 'facsum', 'factorfacsum' y 'collectterms', que se cargan automáticamente) y variables ('nextlayerfactor' y 'facsum_combine') que permiten al usuario estructurar las expresiones controlando la expansión. En 'simplification/facexp.usg' se pueden encontrar breves descripciones de estas funciones. Se accederá a una demostración con la instrucción 'demo("facexp")'. Ejemplo: (%i1) expr:(x+1)^2*(y+1)^3; 2 3 (%o1) (x + 1) (y + 1) (%i2) expand(expr); 2 3 3 3 2 2 2 2 2 (%o2) x y + 2 x y + y + 3 x y + 6 x y + 3 y + 3 x y 2 + 6 x y + 3 y + x + 2 x + 1 (%i3) expand(expr,2); 2 3 3 3 (%o3) x (y + 1) + 2 x (y + 1) + (y + 1) (%i4) expr:(x+1)^-2*(y+1)^3; 3 (y + 1) (%o4) -------- 2 (x + 1) (%i5) expand(expr); 3 2 y 3 y 3 y 1 (%o5) ------------ + ------------ + ------------ + ------------ 2 2 2 2 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1 (%i6) expand(expr,2,2); 3 (y + 1) (%o6) ------------ 2 x + 2 x + 1 Vuelve a simplificar una expresión pero sin expansión: (%i7) expr:(1+x)^2*sin(x); 2 (%o7) (x + 1) sin(x) (%i8) exponentialize:true; (%o8) true (%i9) expand(expr,0,0); 2 %i x - %i x %i (x + 1) (%e - %e ) (%o9) - ------------------------------- 2 -- Función: expandwrt (, , ..., ) Expande la expresión 'expr' con respecto a las variables , ..., . Todos los productos que contengan a las variables aparecen explícitamente. El resultado que se obtenga no tendr'a productos de sumas de expresiones que contengan a las variables. Los argumentos , ..., pueden ser variables, operadores o expresiones. Por defecto, no se expanden los denominadores, pero esto puede cambiarse mediante el uso de la variable 'expandwrt_denom'. Esta función se carga automáticamente de 'simplification/stopex.mac'. -- Variable opcional: expandwrt_denom Valor por defecto: 'false' La variable 'expandwrt_denom' controla el tratamiento de las expresiones racinales por parte de 'expandwrt'. Si vale 'true', se expandirán tanto el numerador como el denominador de la expresión respecto de los argumentos de 'expandwrt', pero si 'expandwrt_denom' vale 'false', sólo se expandirá el numerador. -- Función: expandwrt_factored (, , ..., ) Es similar a 'expandwrt', pero trata a las expresiones que son productos de una forma algo diferente. La función 'expandwrt_factored' expande sólo aquellos factores de 'expr' que contienen a las variables , ..., . Esta función se carga automáticamente de 'simplification/stopex.mac'. -- Variable opcional: expon Valor por defecto: 0 La variable 'expon' guarda el mayor exponente negativo que será expandido automáticamente, independientemente de 'expand'. Por ejemplo, si 'expon' vale 4 entonces '(x+1)^(-5)' no se expandirá automáticamente. -- Función: exponentialize () -- Variable opcional: exponentialize La función 'exponentialize (expr)' convierte las funciones trigonométricas e hiperbólicas de a exponenciales, sin alterar la variable global 'exponentialize'. Cuando la variable 'exponentialize' vale 'true', todas las funciones trigonométricas e hiperbólicas se convierten a forma exponencial. El valor por defecto es 'false'. La función 'demoivre' convierte funciones trigonométricas e hiperbólicas a la forma exponencial, por lo que 'demoivre' y 'exponentialize' no pueden valer 'true' al mismo tiempo. -- Variable opcional: expop Valor por defecto: 0 La variable 'expop' guarda el mayor exponente positivo que será expandido automáticamente. Así, '(x+1)^3' se expandirá automáticamente sólo si 'expop' es mayor o igual que 3. Si se quiere expandir '(x+1)^n', siendo 'n' mayor que 'expop', entonces 'expand ((x+1)^n)' se desarrollará sólo si 'maxposex' no es menor que 'n'. -- Propiedad: lassociative La instrucción 'declare (g, lassociative)' le indica al simplificador de Maxima que 'g' es asociativo por la izquierda. Por ejemplo, 'g (g (a, b), g (c, d))'se reduce a 'g (g (g (a, b), c), d)'. -- Propiedad: linear Es una de las propiedades de operadores de Maxima. Si la función univariante 'f' se declara lineal, la expansión de 'f(x + y)' produce 'f(x) + f(y)', 'f(a*x)' produce 'a*f(x)' si 'a' es una constante. Si la función tiene dos o más argumentos, la linealidad se interpreta como la de 'sum' o 'integrate', esto es, 'f (a*x + b, x)' produce 'a*f(x,x) + b*f(1,x)' si 'a' y 'b' no contienen a 'x'. 'linear' equivale a 'additive' y 'outative'. Véase también 'opproperties'. Ejemplo: (%i1) 'sum (F(k) + G(k), k, 1, inf); inf ==== \ (%o1) > (G(k) + F(k)) / ==== k = 1 (%i2) declare (nounify (sum), linear); (%o2) done (%i3) 'sum (F(k) + G(k), k, 1, inf); inf inf ==== ==== \ \ (%o3) > G(k) + > F(k) / / ==== ==== k = 1 k = 1 -- Variable opcional: maxnegex Valor por defecto: 1000 La variable 'maxnegex' es el mayor exponente negativo que expandirá la función 'expand'. Véase también 'maxposex'. -- Variable opcional: maxposex Valor por defecto: 1000 La variable 'maxposex' es el mayor exponenteque expandirá la función 'expand'. Véase también 'maxnegex'. -- Propiedad: multiplicative La instrucción 'declare (f, multiplicative)' indica al simplificador de Maxima que 'f' is multiplicativa. 1. Si 'f' es univariante, cada vez que el simplificador encuentre a 'f' aplicad a un producto, 'f' se distribuirá sobre ese producto. Por ejemplo, 'f(x*y)' se reduciría a 'f(x)*f(y)'. 2. Si 'f' es una función de 2 o más argumentos, la multiplicabilidad se define como multiplicabilidad para el primer argumento de 'f', de modo que 'f (g(x) * h(x), x)' se reduciría a 'f (g(x) ,x) * f (h(x), x)'. Esta transformación no se realiza cuando 'f' se aplica a expresiones de la forma 'product (x[i], i, m, n)'. Ejemplo: (%i1) F2 (a * b * c); (%o1) F2(a b c) (%i2) declare (F2, multiplicative); (%o2) done (%i3) F2 (a * b * c); (%o3) F2(a) F2(b) F2(c) -- Función: multthru () -- Función: multthru (, ) Multiplica un factor (que debería ser una suma) de por los otros factores de . Esto es, es ' ... ', donde al menos un factor, por ejemplo , es una suma de términos. Cada término en esta suma se multiplica por los otros factores del producto, excepto el propio . La función 'multthru' no expande sumas elevadas a exponentes, siendo el método más rápido para distribuir productos (sean o no conmutativos) sobre sumas. Puesto que los cocientes se representan como productos, puede utilizarse'multthru' para dividir sumas entre productos. La llamada 'multthru (, )' multiplica cada término de (que debería ser una suma o una ecuación) por . Si no es ella misma una suma, entonces la llamada es equivalente a 'multthru (*)'. (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3; 1 x f(x) (%o1) - ----- + -------- - -------- x - y 2 3 (x - y) (x - y) (%i2) multthru ((x-y)^3, %); 2 (%o2) - (x - y) + x (x - y) - f(x) (%i3) ratexpand (%); 2 (%o3) - y + x y - f(x) (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2); 10 2 2 2 (b + a) s + 2 a b s + a b (%o4) ------------------------------ 2 a b s (%i5) multthru (%); /* note that this does not expand (b+a)^10 */ 10 2 a b (b + a) (%o5) - + --- + --------- s 2 a b s (%i6) multthru (a.(b+c.(d+e)+f)); (%o6) a . f + a . c . (e + d) + a . b (%i7) expand (a.(b+c.(d+e)+f)); (%o7) a . f + a . c . e + a . c . d + a . b -- Propiedad: nary 'declare(f, nary)' le indica a Maxima que reconozca la función 'f' como n-aria. La declaración 'nary' no equivale a invocar la función 'function_nary, nary'. El único efecto de 'declare(f, nary)' es indicar al simplificador de Maxima que aplane expresiones anidadas, como simplificar 'foo(x, foo(y, z))' a 'foo(x, y, z)'. Véase también 'declare'. Ejemplo: (%i1) H (H (a, b), H (c, H (d, e))); (%o1) H(H(a, b), H(c, H(d, e))) (%i2) declare (H, nary); (%o2) done (%i3) H (H (a, b), H (c, H (d, e))); (%o3) H(a, b, c, d, e) -- Variable opcional: negdistrib Valor por defecto: 'true' Si 'negdistrib' vale 'true', -1 se distribuye sobre una expresión. Por ejemplo, '-(x + y)' se transforma en '- y - x'. Dándole el valor 'false' se mostrará '- (x + y)' tal cual. Esto puede ser útil, pero también peligroso; al igual que el indicador 'simp', no conviene asignarle el valor 'false'. -- Variable del sistema: opproperties La variable 'opproperties' es la lista con las propiedades especiales de los operadores reconocidas por el simplificador de Maxima: 'linear', 'additive', 'multiplicative', 'outative', 'evenfun', 'oddfun', 'commutative', 'symmetric', 'antisymmetric', 'nary', 'lassociative', 'rassociative'. -- Propiedad: outative La instrucción 'declare (f, outative)' le indica al simplificador de Maxima que los factores constantes del argumento de la función 'f' pueden ser extraídos. 1. Si 'f' es univariante, cada vez que el simplificador se encuentra con 'f' aplicada a un producto, éste será particionado en factores que son constantes y factores que no lo son, siendo entonces los constantes extraídos de la función. Por ejemplo, 'f(a*x)' se reducirá a 'a*f(x)' siendo 'a' una constante. Las constantes no atómicas no serán extraídas. 2. Si 'f' es una función de 2 o más argumentos, esta propiedad se define como en 'sum' o 'integrate', esto es, 'f (a*g(x), x)' se reducirá a 'a * f(g(x), x)' si 'a' no contiene a 'x'. Las funciones 'sum', 'integrate' y 'limit' han sido todas declaradas con la propiedad 'outative'. Ejemplo: (%i1) F1 (100 * x); (%o1) F1(100 x) (%i2) declare (F1, outative); (%o2) done (%i3) F1 (100 * x); (%o3) 100 F1(x) (%i4) declare (zz, constant); (%o4) done (%i5) F1 (zz * y); (%o5) zz F1(y) -- Función: radcan () Simplifica la expresión , que puede contener logaritmos, exponenciales y radicales, convirtiéndola a una forma canónica, lo que significa que todas las expresiones funcionalmente equivalentes se reducen a una forma única. Ciertas expresiones, sin embargo, son reducidas por 'radcan' a una forma regular, lo que significa que dos expresiones equivalentes no tienen necesariamente el mismo aspecto, pero su diferencia puede ser reducida por 'radcan' a cero. Con algunas expresiones 'radcan' puede consunir mucho tiempo. Este es el coste por explorar ciertas relaciones entre las componentes de la expresión para simplificaciones basadas en factorizaciones y expansiones parciales de fracciones de exponentes. Ejemplos: (%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2)); a/2 (%o1) log(x + 1) (%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x))); (%o2) 2 (%i3) radcan((%e^x-1)/(1+%e^(x/2))); x/2 (%o3) %e - 1 -- Variable opcional: radexpand Valor por defecto: 'true' La variable 'radexpand' controla algunas simplificaciones de radicales. Si 'radexpand' vale 'all', las raíces -ésimas de los factores de un producto que sean potencias de se extraen del símbolo radical. Por ejemplo, si 'radexpand' vale 'all', 'sqrt (16*x^2)' se reduce a '4*x'. Más concretamente, considérese 'sqrt (x^2)'. * Si 'radexpand' vale 'all' o se ha ejecutado 'assume (x > 0)', 'sqrt(x^2)' se reduce a 'x'. * Si 'radexpand' vale 'true' y 'domain' es 'real' (su valor por defecto), 'sqrt(x^2)' se reduce a 'abs(x)'. * Si 'radexpand' vale 'false' o 'radexpand' vale 'true' y 'domain' es 'complex', 'sqrt(x^2)' no se simplifica. Nótese que 'domain' sólo se tiene en cuenta si 'radexpand' vale 'true'. -- Propiedad: rassociative La instrucción 'declare (g, rassociative)' le indica al simplificador de Maxima que 'g' es asociativa por la derecha. Por ejemplo, 'g(g(a, b), g(c, d))' se reduce a 'g(a, g(b, g(c, d)))'. -- Función: scsimp (, , ..., ) Es el "Sequential Comparative Simplification" (método debido a Stoute). La función 'scsimp' intenta simplificar de acuerdo con las reglas , ..., . Si se obtiene una expresión más pequeña, el proceso se repite. En caso contrario, después de que se hayan intentado todas las simplificaciones, devuelve la respuesta original. La instrucción 'example (scsimp)' muestra algunos ejemplos. -- Variable opcional: simp Valor por defecto: 'true' La variable 'simp' activa y desactiva la simplificación. La simplificación está activada por defecto. La variable 'simp' también es reconocida por la función 'ev' como variable de entorno. Véase también 'ev'. Cuando 'simp' se utiliza en un entorno 'ev' con el valor 'false', la simplificación se evita sólo durante la fase de evaluación de una expresión. La variable no evita la simplificación que sigue a la fase de evaluación. Ejemplos: La simplificación se suspende globalmente. La expresión 'sin(1.0)' no se simplifica a su valor numérico. La variable de entorno 'simp' conmuta el estado de la simplificación. (%i1) simp:false; (%o1) false (%i2) sin(1.0); (%o2) sin(1.0) (%i3) sin(1.0),simp; (%o3) .8414709848078965 La simplificación se vuelve a activar. La variable de entorno 'simp' no puede suprimir totalmente la simplificación. El resultado muestra una expresión simplificada, pero la variable 'x' guarda como valor una expresión sin simplificar, porque la asignación se realizó durante la fase de evaluación de la expresión. (%i4) simp:true; (%o4) true (%i5) x:sin(1.0),simp:false; (%o5) .8414709848078965 (%i6) :lisp $X ((%SIN) 1.0) -- Propiedad: symmetric La instrucción 'declare (h, symmetric)' le indica al simplificador de Maxima que 'h' es una función simétrica. Por ejemplo, 'h (x, z, y)' se reduce a 'h (x, y, z)'. El nombre 'commutative' es sinónimo de 'symmetric'. -- Función: xthru () Combina todos los términos de (la cual debe ser una suma) sobre un común denominador sin expandir productos ni sumas elevadas a exponentes al modo que lo hace 'ratsimp'. La función 'xthru' cancela factores comunes en el numerador y denominador de expresiones racionales, pero sólo si los factores son explícitos. En ocasiones puede ser útil el uso de 'xthru' antes de la llamada a 'ratsimp' a fin de cancelar factores explícitos del máximo común divisor del numerador y denominador y así simplificar la expresión a la que se va a aplicar 'ratsimp'. (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20; xthru (%); 20 1 (x + 2) - 2 y x (%o1) --------- + --------------- - --------- 19 20 20 (y + x) (y + x) (y + x)  File: maxima.info, Node: Funciones matemáticas, Next: Base de datos de Maxima, Prev: Simplificación, Up: Top 10 Funciones matemáticas ************************ * Menu: * Funciones para los números:: * Funciones para los números complejos:: * Funciones combinatorias:: * Funciones radicales exponenciales y logarítmicas:: * Funciones trigonométricas:: * Números aleatorios::  File: maxima.info, Node: Funciones para los números, Next: Funciones para los números complejos, Prev: Funciones matemáticas, Up: Funciones matemáticas 10.1 Funciones para los números =============================== -- Función: abs () La función 'abs' representa el valor absoluto y se puede aplicar tanto a argumentos numéricos como simbólicos. Si el argumento es un número real o complejo, 'abs' devuelve el valor absoluto de . Si es posible, las expresiones simbólicas que utilizan la función del valor absoluto también se simplifican. Maxima puede derivar, integrar y calcular límites de expresiones que contengan a 'abs'. El paquete 'abs_integrate' extiende las capacidades de Maxima para calcular integrales que contengan llamadas a 'abs'. Véase '(%i12)' en el ejemplo de más abajo. Cuando se aplica a una lista o matriz, 'abs' se distribuye automáticamente sobre sus elementos. De forma similar, también se distribuye sobre los dos miembros de una igualdad. Para cambiar este comportamiento por defecto, véase la variable 'distribute_over'. Ejemplos: Cálculo del valor absoluto de números reales y complejos, incluyendo constantes numéricas e infinitos. El primer ejemplo muestra cómo 'abs' se distribuye sobre los elementos de una lista. (%i1) abs([-4, 0, 1, 1+%i]); (%o1) [4, 0, 1, sqrt(2)] (%i2) abs((1+%i)*(1-%i)); (%o2) 2 (%i3) abs(%e+%i); 2 (%o3) sqrt(%e + 1) (%i4) abs([inf, infinity, minf]); (%o4) [inf, inf, inf] Simplificación de expresiones que contienen 'abs': (%i5) abs(x^2); 2 (%o5) x (%i6) abs(x^3); 2 (%o6) x abs(x) (%i7) abs(abs(x)); (%o7) abs(x) (%i8) abs(conjugate(x)); (%o8) abs(x) Integrando y derivando con la función 'abs'. Nótese que se pueden calcular más integrales que involucren la función 'abs' si se carga el paquete 'abs_integrate'. El último ejemplo muestra la transformada de Laplace de 'abs'. Véase 'laplace'. (%i9) diff(x*abs(x),x),expand; (%o9) 2 abs(x) (%i10) integrate(abs(x),x); x abs(x) (%o10) -------- 2 (%i11) integrate(x*abs(x),x); / [ (%o11) I x abs(x) dx ] / (%i12) load(abs_integrate)$ (%i13) integrate(x*abs(x),x); 2 3 x abs(x) x signum(x) (%o13) --------- - ------------ 2 6 (%i14) integrate(abs(x),x,-2,%pi); 2 %pi (%o14) ---- + 2 2 (%i15) laplace(abs(x),x,s); 1 (%o15) -- 2 s -- Función: ceiling () Si es un número real, devuelve el menor entero mayor o igual que . Si es una expresión constante (por ejemplo, '10 * %pi'), 'ceiling' evalúa haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación 'ceiling' al número decimal obtenido. Puesto que 'ceiling' hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para 'fpprec'. Para argumentos no constantes, 'ceiling' intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que 'ceiling' es capaz de hacer: (%i1) ceiling (ceiling (x)); (%o1) ceiling(x) (%i2) ceiling (floor (x)); (%o2) floor(x) (%i3) declare (n, integer)$ (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))]; (%o4) [n, abs(n), max(n, 6)] (%i5) assume (x > 0, x < 1)$ (%i6) ceiling (x); (%o6) 1 (%i7) tex (ceiling (a)); $$\left \lceil a \right \rceil$$ (%o7) false La función 'ceiling' no se extiende automáticamente a los elementos de listas y matrices. Por último, para todos los argumentos que tengan una forma compleja, 'ceiling' devuelve una forma nominal. Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como 'integervalued'. Tanto 'ceiling' como 'floor' son funciones que hacen uso de esta información; por ejemplo: (%i1) declare (f, integervalued)$ (%i2) floor (f(x)); (%o2) f(x) (%i3) ceiling (f(x) - 1); (%o3) f(x) - 1 Ejemplo de uso: (%i1) unitfrac(r) := block([uf : [], q], if not(ratnump(r)) then error("unitfrac: argument must be a rational number"), while r # 0 do ( uf : cons(q : 1/ceiling(1/r), uf), r : r - q), reverse(uf))$ (%i2) unitfrac (9/10); 1 1 1 (%o2) [-, -, --] 2 3 15 (%i3) apply ("+", %); 9 (%o3) -- 10 (%i4) unitfrac (-9/10); 1 (%o4) [- 1, --] 10 (%i5) apply ("+", %); 9 (%o5) - -- 10 (%i6) unitfrac (36/37); 1 1 1 1 1 (%o6) [-, -, -, --, ----] 2 3 8 69 6808 (%i7) apply ("+", %); 36 (%o7) -- 37 -- Función: entier () Devuelve el mayor entero menor o igual a , siendo numérico. La función 'fix' (como en 'fixnum') es un sinónimo, de modo que 'fix()' hace justamente lo mismo. -- Función: floor () Si es un número real, devuelve el mayor entero menor o igual que . Si es una expresión constante (por ejemplo, '10 * %pi'), 'floor' evalúa haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación 'floor' al número decimal obtenido. Puesto que 'floor' hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para 'fpprec'. Para argumentos no constantes, 'floor' intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que 'floor' es capaz de hacer: (%i1) floor (ceiling (x)); (%o1) ceiling(x) (%i2) floor (floor (x)); (%o2) floor(x) (%i3) declare (n, integer)$ (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))]; (%o4) [n, abs(n), min(n, 6)] (%i5) assume (x > 0, x < 1)$ (%i6) floor (x); (%o6) 0 (%i7) tex (floor (a)); $$\left \lfloor a \right \rfloor$$ (%o7) false La función 'floor' no se extiende automáticamente a los elementos de listas y matrices. Por último, para todos los argumentos que tengan una forma compleja, 'floor' devuelve una forma nominal. Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como 'integervalued'. Tanto 'ceiling' como 'floor' son funciones que hacen uso de esta información; por ejemplo: (%i1) declare (f, integervalued)$ (%i2) floor (f(x)); (%o2) f(x) (%i3) ceiling (f(x) - 1); (%o3) f(x) - 1 -- Función: fix () Es un sinónimo de 'entier ()'. -- Función: lmax () Si es una lista o conjunto, devuelve 'apply ('max, args ())'. Si no es una lista o conjunto, envía un mensaje de error. -- Función: lmin () Si es una lista o conjunto, devuelve 'apply ('min, args ())'. Si no es una lista o conjunto, envía un mensaje de error. -- Función: max (, ..., ) Devuelve un valor simplificado de la mayor de las expresiones desde hasta . Si 'get (trylevel, maxmin)' es 2 o más, 'max' aplica la simplificación 'max (e, -e) --> |e|'. Si 'get (trylevel, maxmin)' es 3 o más, intenta eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo, 'max (x, 2*x, 3*x) --> max (x, 3*x)'. Para asignar el valor 2 a 'trylevel' se puede hacer 'put (trylevel, 2, maxmin)'. -- Función: min (, ..., ) Devuelve un valor simplificado de la menor de las expresiones desde hasta . Si 'get (trylevel, maxmin)' es 2 o más, 'min' aplica la simplificación 'min (e, -e) --> |e|'. Si 'get (trylevel, maxmin)' es 3 o más, intenta eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo, 'min (x, 2*x, 3*x) --> min (x, 3*x)'. Para asignar el valor 2 a 'trylevel' se puede hacer 'put (trylevel, 2, maxmin)'. -- Función: round () Si es un número real, la función devuelve el entero más próximo a . Los múltiplos de 1/2 se redondean al entero par más próximo. La evaluación de es similar a 'floor' y 'ceiling'. -- Función: signum () Tanto sea real o complejo, la función 'signum' devuelve 0 si es cero. Para un valor no nulo de , la función devuelve 'x/abs(x)'. Para valores no numéricos de , Maxima intenta determinar el signo del argumento. Cuando es negativo, cero o positivo, 'signum' devuelve -1, 0 o 1, respectivamente. En caso de no poder determinarse, 'signum' devuelve una forma simplificada equivalente. Estas simplificaciones incluyen la transformación de 'signum(-x)' en '-signum(x)' y la de 'signum(x*y)' en 'signum(x) * signum(y)'. La función 'signum' es distributiva respecto de listas, matrices o ecuaciones. Véase 'distribute_over'.  File: maxima.info, Node: Funciones para los números complejos, Next: Funciones combinatorias, Prev: Funciones para los números, Up: Funciones matemáticas 10.2 Funciones para los números complejos ========================================= -- Función: cabs () Calcula el valor absoluto de una expresión que representa a un número complejo. Al contrario que 'abs', la función 'cabs' siempre descompone su argumento en sus partes real e imaginaria. Si 'x' e 'y' representan variables o expresiones reales, la función 'cabs' calcula el valor absoluto de 'x + %i*y' como 2 2 sqrt(y + x ) La función 'cabs' puede utilizar propiedades como la simetría de funciones complejas para calcular el valor absoluto de una expresión. 'cabs' no es una función apropiada para cálculos simbólicos; en tales casos, que incluyen la integración, diferenciación y límites que contienen valores absolutos, es mejor utilizar 'abs'. El resultado devuelto por 'cabs' puede incluir la función de valor absoluto, 'abs', y el arco tangente, 'atan2'. Cuando se aplica a una lista o matriz, 'cabs' automáticamente se distribuye sobre sus elementos. También se distribuye sobre los dos miembros de una igualdad. Para otras formas de operar con números complejos, véanse las funciones 'rectform', 'realpart', 'imagpart', 'carg', 'conjugate' y 'polarform'. Ejemplos: Ejemplos con 'sqrt' and 'sin': (%i1) cabs(sqrt(1+%i*x)); 2 1/4 (%o1) (x + 1) (%i2) cabs(sin(x+%i*y)); 2 2 2 2 (%o2) sqrt(cos (x) sinh (y) + sin (x) cosh (y)) La simetría especular de la función de error 'erf' se utiliza para calcular el valor absoluto del argumento complejo: (%i3) cabs(erf(x+%i*y)); 2 (erf(%i y + x) - erf(%i y - x)) (%o3) sqrt(-------------------------------- 4 2 (erf(%i y + x) + erf(%i y - x)) - --------------------------------) 4 Dado que Maxima reconoce algunas identidades complejas de las funciones de Bessel, le permite calcular su valor absoluto cuando tiene argumentos complejos. Un ejemplo para 'bessel_j': (%i4) cabs(bessel_j(1,%i)); (%o4) abs(bessel_j(1, %i)) -- Función: carg () Devuelve el argumento complejo de . El argumento complejo es un ángulo 'theta' en '(-%pi, %pi]' tal que 'r exp (theta %i) = ' donde 'r' es la magnitud de . La función 'carg' es computacional, no simplificativa. Véanse también 'abs' (módulo complejo), 'polarform', 'rectform', 'realpart' y 'imagpart'. Ejemplos: (%i1) carg (1); (%o1) 0 (%i2) carg (1 + %i); %pi (%o2) --- 4 (%i3) carg (exp (%i)); (%o3) 1 (%i4) carg (exp (%pi * %i)); (%o4) %pi (%i5) carg (exp (3/2 * %pi * %i)); %pi (%o5) - --- 2 (%i6) carg (17 * exp (2 * %i)); (%o6) 2 -- Función: conjugate () Devuelve el conjugado complejo de . (%i1) declare ([aa, bb], real, cc, complex, ii, imaginary); (%o1) done (%i2) conjugate (aa + bb*%i); (%o2) aa - %i bb (%i3) conjugate (cc); (%o3) conjugate(cc) (%i4) conjugate (ii); (%o4) - ii (%i5) conjugate (xx + yy); (%o5) conjugate(yy) + conjugate(xx) -- Función: imagpart () Devuelve la parte imaginaria de la expresión . La función 'imagpart' es computacional, no simplificativa. Véanse también 'abs', 'carg', 'polarform', 'rectform' y 'realpart'. -- Función: polarform () Devuelve una expresión de la forma 'r %e^(%i theta)' equivalente a , con 'r' y 'theta' son reales. -- Función: realpart () Devuelve la parte real de . La funciones 'realpart' y 'imagpart' operan también con expresiones que contengan funciones trigonométricas e hiperbólicas, raíces cuadradas, logaritmos y exponentes. -- Función: rectform () Devuelve una expresión de la forma 'a + b %i' equivalente a , con y reales.  File: maxima.info, Node: Funciones combinatorias, Next: Funciones radicales exponenciales y logarítmicas, Prev: Funciones para los números complejos, Up: Funciones matemáticas 10.3 Funciones combinatorias ============================ -- Operador: !! El operador doble factorial. Para un número entero, de punto flotante o racional 'n', 'n!!' se evaluará como el producto de 'n (n-2) (n-4) (n-6) ... (n - 2 (k-1))' donde 'k' es igual a 'entier(n/2)', que es, el mayor entero menor o igual a 'n/2'. Note que esta definición no coincide con otras definciones publicadas para argumentos, los cuales no son enteros. Para un entero par (o impar) 'n', 'n!' se evalua el producto de todos los enteros pares (o impares) consecutivos desde 2 (o 1) por 'n' inclusive. Para un argumento 'n' el cual no es un número entero, punto flotante o racional, 'n!!' produce una forma de nombre 'genfact (n, n/2, 2)'. -- Función: binomial (, ) Es el coeficiente binomial '!/(! ( - )!)'. Si y son enteros, entonces se calcula el valor numérico del coeficiente binomial. Si o son enteros, el coeficiente binomial se expresa como un polinomio. Ejemplos: (%i1) binomial (11, 7); (%o1) 330 (%i2) 11! / 7! / (11 - 7)!; (%o2) 330 (%i3) binomial (x, 7); (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x (%o3) ------------------------------------------------- 5040 (%i4) binomial (x + 7, x); (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7) (%o4) ------------------------------------------------------- 5040 (%i5) binomial (11, y); (%o5) binomial(11, y) -- Función: factcomb () Trata de combinar los coeficientes de los factoriales de con los mismos factoriales, convirtiendo, por ejemplo, '(n + 1)*n!' en '(n + 1)!'. Si la variable 'sumsplitfact' vale 'false' hará que 'minfactorial' se aplique después de 'factcomb'. -- Función: factorial () -- Operador: ! Representa la función factorial. Maxima considera 'factorial ()' y '!' como sinónimos. Para cualquier número complejo 'x', excepto para enteros negativos, 'x!' se define como 'gamma(x+1)'. Para un entero 'x', 'x!' se reduce al producto de los enteros desde 1 hasta 'x' inclusive. '0!' se reduce a 1. Para un número real o complejo en formato de coma flotante 'x', 'x!' se reduce al valor de 'gamma(x+1)'. Cuando 'x' es igual a 'n/2', siendo 'n' un entero impar, entonces 'x!' se reduce a un factor racional multiplicado por 'sqrt(%pi)' (pues 'gamma(1/2)') es igual a 'sqrt(%pi)'). Las variables opcionales 'factlim' y 'gammalim' controlan la evaluación numérica de factoriales de argumentos enteros y racionales. Las funciones 'minfactorial' y 'factcomb' simplifican expresiones que contiene factoriales. Véanse también 'factlim', 'gammalim', 'minfactorial' y 'factcomb'. Las funciones 'gamma', 'bffac' y 'cbffac' son variaciones de la función matemática gamma. Las funciones 'bffac' y 'cbffac' son llamadas internamente desde 'gamma' para evaluar la función gamma de números reales y complejos decimales con precisión de reales grandes (bigfloats). Las funciones 'makegamma' substituye a 'gamma' para factoriales y funciones relacionadas. Maxima reconoce la derivada de la función factorial y los límites para ciertos valores específicos, tales como los enteros negativos. La variable opcional 'factorial_expand' controla la simplificación de expresiones como '(n+x)!', para 'n' entero. Véase también 'binomial'. Ejemplos: El factorial de un entero se reduce a un número exacto, a menos que el argumento sea mayor que 'factlim'. Los factoriales de números reales o complejos se evalúan como decimales de coma flotante. (%i1) factlim:10; (%o1) 10 (%i2) [0!, (7/2)!, 8!, 20!]; 105 sqrt(%pi) (%o2) [1, -------------, 40320, 20!] 16 (%i3) [4.77!, (1.0+%i)!]; (%o3) [81.44668037931197, .3430658398165454 %i + .6529654964201665] (%i4) [2.86b0!, (1.0b0+%i)!]; (%o4) [5.046635586910012b0, 3.430658398165454b-1 %i + 6.529654964201667b-1] El factorial de una constante conocida o de una expresión general no se calcula. Pero puede ser posible reducir el factorial después de evaluado el argumento. (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!]; (%o1) [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!] (%i2) ev (%, numer, %enumer); (%o2) [.3430658398165454 %i + .6529654964201665, 7.188082728976031, 4.260820476357003, 1.227580202486819] Los factoriales son simplificados o reducidos, no evaluados. Así 'x!' puede ser reemplazado en una expresión nominal. (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]); 105 sqrt(%pi) (%o1) [1, -------------, 81.44668037931199, 40320, 16 2432902008176640000] Maxima reconoce la derivada de la función factorial. (%i1) diff(x!,x); (%o1) x! psi (x + 1) 0 La variable opcional 'factorial_expand' controla la simplificación de expresiones con la función factorial. (%i1) (n+1)!/n!,factorial_expand:true; (%o1) n + 1 -- Variable opcional: factlim Valor por defecto: -1 La variable 'factlim' especifica el mayor factorial que será expandido automáticamente. Si su valor es -1, entonces se expandirán todos los enteros. -- Variable opcional: factorial_expand Valor por defecto: false La variable 'factorial_expand' controla la simplificación de expresiones tales como '(n+1)!', siendo 'n' un entero. Véase '!' para un ejemplo. -- Función: genfact (, , ) Devuelve el factorial generalizado, definido como 'x (x-z) (x - 2 z) ... (x - (y - 1) z)'. Así, para el entero , 'genfact (x, x, 1) = x!' y 'genfact (x, x/2, 2) = x!!'. -- Función: minfactorial () Busca en la presencia de dos factoriales que solo se diferencien en una unidad; en tal caso, 'minfactorial' devuelve una expresión simplificada. (%i1) n!/(n+2)!; n! (%o1) -------- (n + 2)! (%i2) minfactorial (%); 1 (%o2) --------------- (n + 1) (n + 2) -- Variable opcional: sumsplitfact Valor por defecto: 'true' Si 'sumsplitfact' vale 'false', 'minfactorial' se aplica después de 'factcomb'.  File: maxima.info, Node: Funciones radicales exponenciales y logarítmicas, Next: Funciones trigonométricas, Prev: Funciones combinatorias, Up: Funciones matemáticas 10.4 Funciones radicales, exponenciales y logarítmicas ====================================================== -- Variable opcional: %e_to_numlog Valor por defecto: 'false' Si '%e_to_numlog' vale 'true', 'r' es un número racional y 'x' una expresión, '%e^(r*log(x))' se reduce a 'x^r' . Téngase en cuenta que la instrucción 'radcan' también hace este tipo de transformaciones, así como otras más complicadas. La instrucción 'logcontract' "contrae" expresiones que contienen algún 'log'. -- Variable opcional: %emode Valor por defecto: 'true' Si '%emode' vale 'true', '%e^(%pi %i x)' se simplifica como sigue. '%e^(%pi %i x)' se simplifica a 'cos (%pi x) + %i sin (%pi x)' si 'x' es un número decimal de coma flotante, un entero o un múltiplo de 1/2, 1/3, 1/4 o 1/6, y luego se sigue simplificando. Para otros valores numéricos de 'x', '%e^(%pi %i x)' se simplifica a '%e^(%pi %i y)' donde 'y' es 'x - 2 k' para algún entero 'k' tal que 'abs(y) < 1'. Si '%emode' vale 'false', no se realizan simplificaciones especiales a '%e^(%pi %i x)'. -- Variable opcional: %enumer Valor por defecto: 'false' Si la variable '%enumer' vale 'true' hace que '%e' se reemplace por 2.718... siempre que 'numer' valga 'true'. Si '%enumer' vale 'false', esta sustitución se realiza sólo si el exponente en '%e^x' tiene un valor numérico. Véanse también 'ev' y 'numer'. -- Función: exp () Representa la función exponencial. La expresión 'exp ()' en la entrada se simplifica en '%e^'; 'exp' no aparece en expresiones simplificadas. Si la variable 'demoivre' vale 'true' hace que '%e^(a + b %i)' se simplifique a '%e^(a (cos(b) + %i sin(b)))' si 'b' no contiene a '%i'. Véase 'demoivre'. Si la variable '%emode' vale 'true', hace que '%e^(%pi %i x)' se simplifique. Véase '%emode'. Si la variable '%enumer' vale 'true' hace que '%e' se reemplace por 2.718... siempre que 'numer' valga 'true'. Véase '%enumer'. -- Función: li [] () Representa la función polilogarítmica de orden y argumento , definida por la serie infinita inf ==== k \ z Li (z) = > -- s / s ==== k k = 1 'li [1]' es '- log (1 - z)'. 'li [2]' y 'li [3]' son las funciones di- y trilogaritmo, respectivamente. Cuando el orden es 1, el polilogaritmo se simplifica a '- log (1 - z)', el cual a su vez se reduce a un valor numérico si es un número real o complejo en coma flotante o si está presente el término 'numer'. Cuando el orden es 2 ó 3, el polilogaritmo se reduce a un valor numérico si es un número real en coma flotante o si está presente el término 'numer'. Ejemplos: (%i1) assume (x > 0); (%o1) [x > 0] (%i2) integrate ((log (1 - t)) / t, t, 0, x); (%o2) - li (x) 2 (%i3) li [2] (7); (%o3) li (7) 2 (%i4) li [2] (7), numer; (%o4) 1.24827317833392 - 6.113257021832577 %i (%i5) li [3] (7); (%o5) li (7) 3 (%i6) li [2] (7), numer; (%o6) 1.24827317833392 - 6.113257021832577 %i (%i7) L : makelist (i / 4.0, i, 0, 8); (%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0] (%i8) map (lambda ([x], li [2] (x)), L); (%o8) [0, .2676526384986274, .5822405249432515, .9784693966661848, 1.64493407, 2.190177004178597 - .7010261407036192 %i, 2.374395264042415 - 1.273806203464065 %i, 2.448686757245154 - 1.758084846201883 %i, 2.467401098097648 - 2.177586087815347 %i] (%i9) map (lambda ([x], li [3] (x)), L); (%o9) [0, .2584613953442624, 0.537213192678042, .8444258046482203, 1.2020569, 1.642866878950322 - .07821473130035025 %i, 2.060877505514697 - .2582419849982037 %i, 2.433418896388322 - .4919260182322965 %i, 2.762071904015935 - .7546938285978846 %i] -- Función: log () Representa el logaritmo natural (en base e) de . Maxima no tiene definida una función para el logaritmo de base 10 u otras bases. El usuario puede hacer uso de la definición 'log10(x) := log(x) / log(10)'. La simplificación y evaluación de logaritmos se controla con ciertas variables globales: 'logexpand' hace que 'log(a^b)' se convierta en 'b*log(a)'. Si toma el valor 'all', 'log(a*b)' también se reducirá a 'log(a)+log(b)'. Si toma el valor 'super', entonces 'log(a/b)' también se reducirá a 'log(a)-log(b)', siendo 'a/b' racional con 'a#1', (la expresión 'log(1/b)', para 'b' entero, se simplifica siempre). Si toma el valor 'false', se desactivarán todas estas simplificaciones. 'logsimp' si vale 'false', entonces no se transforma '%e' a potencias que contengan logaritmos. 'lognegint' si vale 'true' se aplica la regla 'log(-n)' -> 'log(n)+%i*%pi', siendo 'n' un entero positivo. '%e_to_numlog' si vale 'true', 'r' es un número racional y 'x' una expresión, '%e^(r*log(x))' se reduce a 'x^r'. Téngase en cuenta que la instrucción 'radcan' también hace este tipo de transformaciones, así como otras más complicadas. La instrucción 'logcontract' "contrae" expresiones que contengan algún 'log'. -- Variable opcional: logabs Valor por defecto: 'false' Cuando se calculan integrales indefinidas en las que se generan logaritmos, como en 'integrate(1/x,x)', el resultado se devuelve de la forma 'log(abs(...))' si 'logabs' vale 'true', o de la forma 'log(...)' si 'logabs' vale 'false'. En la integración definida se hace la asignación 'logabs:true', ya que aquí es normalmente necesario evaluar la integral indefinida en los extremos del intervalo de integración. -- Variable opcional: logarc -- Función: logarc () Si la variable global 'logarc' toma el valor 'true', las funciones circulares e hiperbólicas inversas se reemplazan por funciones logarítmicas equivalentes. El valor por defecto de 'logarc' es 'false'. La función 'logarc()' realiza la anterior transformación en la expresión sin necesidad de alterar el valor de la variable global 'logarc'. -- Variable opcional: logconcoeffp Valor por defecto: 'false' Controla qué coeficientes se contraen cuando se utiliza 'logcontract'. Se le puede asignar el nombre de una función de predicado de un argumento; por ejemplo, si se quiere introducir raíces cuadradas, se puede hacer 'logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$' . Entonces 'logcontract(1/2*log(x));' devolverá 'log(sqrt(x))'. -- Función: logcontract () Analiza la expresión recursivamente, transformando subexpresiones de la forma 'a1*log(b1) + a2*log(b2) + c' en 'log(ratsimp(b1^a1 * b2^a2)) + c' (%i1) 2*(a*log(x) + 2*a*log(y))$ (%i2) logcontract(%); 2 4 (%o2) a log(x y ) Si se hace 'declare(n,integer);' entonces 'logcontract(2*a*n*log(x));' da 'a*log(x^(2*n))'. Los coeficientes que se contraen de esta manera son aquellos que como el 2 y el 'n' satisfacen 'featurep(coeff,integer)'. El usuario puede controlar qué coeficientes se contraen asignándole a la variable global 'logconcoeffp' el nombre de una función de predicado de un argumento; por ejemplo, si se quiere introducir raíces cuadradas, se puede hacer 'logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$' . Entonces 'logcontract(1/2*log(x));' devolverá 'log(sqrt(x))'. -- Variable opcional: logexpand Valor por defecto: 'true' Si 'logexpand' vale 'true' hace que 'log(a^b)' se convierta en 'b*log(a)'. Si toma el valor 'all', 'log(a*b)' también se reducirá a 'log(a)+log(b)'. Si toma el valor 'super', entonces 'log(a/b)' también se reducirá a 'log(a)-log(b)', siendo 'a/b' racional con 'a#1', (la expresión 'log(1/b)', para 'b' entero, se simplifica siempre). Si toma el valor 'false', se desactivarán todas estas simplificaciones. -- Variable opcional: lognegint Valor por defecto: 'false' Si 'lognegint' vale 'true' se aplica la regla 'log(-n)' -> 'log(n)+%i*%pi' siendo 'n' un entero positivo. -- Variable opcional: logsimp Valor por defecto: 'true' Si 'logsimp' vale 'false', entonces no se transforma '%e' a potencias que contengan logaritmos. -- Función: plog () Representa la rama principal del logaritmo natural complejo con '-%pi' < 'carg()' <= '+%pi' . -- Función: sqrt () Raíz cuadrada de . Se representa internamente por '^(1/2)'. Véase también 'rootscontract'. Si la variable 'radexpand' vale 'true' hará que las raíces 'n'-ésimas de los factores de un producto que sean potencias de 'n' sean extraídas del radical; por ejemplo, 'sqrt(16*x^2)' se convertirá en '4*x' sólo si 'radexpand' vale 'true'.  File: maxima.info, Node: Funciones trigonométricas, Next: Números aleatorios, Prev: Funciones radicales exponenciales y logarítmicas, Up: Funciones matemáticas 10.5 Funciones trigonométricas ============================== * Menu: * Introducción a la trigonometría:: * Funciones y variables para trigonometría::  File: maxima.info, Node: Introducción a la trigonometría, Next: Funciones y variables para trigonometría, Prev: Funciones trigonométricas, Up: Funciones trigonométricas 10.5.1 Introducción a la trigonometría -------------------------------------- Maxima reconoce muchas funciones trigonométricas. No están programadas todas las identidades trigonométricas, pero el usuario puede añadir muchas de ellas haciendo uso de las técnicas basadas en patrones. Las funciones trigonométricas definidas en Maxima son: 'acos', 'acosh', 'acot', 'acoth', 'acsc', 'acsch', 'asec', 'asech', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'cot', 'coth', 'csc', 'csch', 'sec', 'sech', 'sin', 'sinh', 'tan' y 'tanh'. Hay también un determinado número de instrucciones especiales para manipular funciones trigonométricas; véanse a este respecto 'trigexpand', 'trigreduce' y la variable 'trigsign'. Dos paquetes adicionales amplían las reglas de simplificación de Maxima, 'ntrig' y 'atrig1'. Ejecútese 'describe()' para más detalles.  File: maxima.info, Node: Funciones y variables para trigonometría, Prev: Introducción a la trigonometría, Up: Funciones trigonométricas 10.5.2 Funciones y variables para trigonometría ----------------------------------------------- -- Variable opcional: %piargs Valor por defecto: 'true' Cuando '%piargs' vale 'true', las funciones trigonométricas se simplifican a constantes algebraicas cuando el argumento es múltiplo entero de %pi, %pi/2, %pi/3, %pi/4 o %pi/6. Maxima conoce algunas identidades aplicables cuando %pi, etc., se multiplican por una variable entera (esto es, un símbolo declarado como entero). Ejemplo: (%i1) %piargs : false$ (%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)]; %pi %pi (%o2) [sin(%pi), sin(---), sin(---)] 2 3 (%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)]; %pi %pi %pi (%o3) [sin(---), sin(---), sin(---)] 4 5 6 (%i4) %piargs : true$ (%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)]; sqrt(3) (%o5) [0, 1, -------] 2 (%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)]; 1 %pi 1 (%o6) [-------, sin(---), -] sqrt(2) 5 2 (%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3), cos (sqrt(2)*%pi/3)]; 1 1 sqrt(2) %pi (%o7) [-, - -, sqrt(3), cos(-----------)] 2 2 3 Se aplican ciertas identidades cuando %pi o %pi/2 se multiplican por una variable entera. (%i1) declare (n, integer, m, even)$ (%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m), cos (%pi/2 * m)]; m/2 (%o2) [0, 1, 0, (- 1) ] -- Variable opcional: %iargs Valor por defecto: 'true' Cuando '%iargs' vale 'true', las funciones trigonométricas se simplifican a funciones hiperbólicas si el argumento es aparentemente un múltiplo de la unidad imaginaria %i. La simplificación se lleva a cabo incluso cuando el argumento es manifiestamente real; Maxima sólo se fija en si el argumento es un múltiplo literal de %i. Ejemplos: (%i1) %iargs : false$ (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o2) [sin(%i x), cos(%i x), tan(%i x)] (%i3) %iargs : true$ (%i4) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o4) [%i sinh(x), cosh(x), %i tanh(x)] La simplificación se aplica incluso en el caso de que el argumento se reduzca a un número real. (%i1) declare (x, imaginary)$ (%i2) [featurep (x, imaginary), featurep (x, real)]; (%o2) [true, false] (%i3) sin (%i * x); (%o3) %i sinh(x) -- Function: acos () Arco coseno. -- Función: acosh () Arco coseno hiperbólico. -- Función: acot () Arco cotangente. -- Función: acoth () Arco cotangente hiperbólica. -- Función: acsc () Arco cosecante. -- Función: acsch () Arco cosecante hiperbólica. -- Función: asec () Arco secante. -- Función: asech () Arco secante hiperbólica. -- Función: asin () Arco seno. -- Función: asinh () Arco seno hiperbólico. -- Función: atan () Arco tangente. -- Función: atan2 (, ) Calcula el valor de 'atan(/)' en el intervalo de '-%pi' a '%pi'. -- Función: atanh () Arco tangente hiperbólica. -- Paquete: atrig1 El paquete 'atrig1' contiene ciertas reglas de simplificación adicionales para las funciones trigonométricas inversas. Junto con las reglas que ya conoce Maxima, los siguientes ángulos están completamente implementados: '0', '%pi/6', '%pi/4', '%pi/3' y '%pi/2'. Los ángulos correspondientes en los otros tres cuadrantes también están disponibles. Para hacer uso de estas reglas, ejecútese 'load(atrig1);'. -- Función: cos () Coseno. -- Función: cosh () Coseno hiperbólico. -- Función: cot () Cotangente. -- Función: coth () Cotangente hiperbólica. -- Función: csc () Cosecante. -- Función: csch () Cosecante hiperbólica. -- Variable opcional: halfangles Valor por defecto: 'false' Si 'halfangles' vale 'true', las funciones trigonométricas con argumentos del tipo '/2' se simplifican a funciones con argumentos . Para un argumento real en el intervalo '0 < x < 2*%pi' el seno del semiángulo se simplifica como sqrt(1 - cos(x)) ---------------- sqrt(2) Se necesita un factor relativamente complicado para que esta fórmula sea también válida para cualquier argumento complejo : realpart(z) floor(-----------) 2 %pi (- 1) (1 - unit_step(- imagpart(z)) realpart(z) realpart(z) floor(-----------) - ceiling(-----------) 2 %pi 2 %pi ((- 1) + 1)) Maxima reconoce este factor y otros similares para las funciones 'sin', 'cos', 'sinh' y 'cosh'. Para valores especiales del argumento z, estos factores se simplifican de forma apropiada. Ejemplos: (%i1) halfangles:false; (%o1) false (%i2) sin(x/2); x (%o2) sin(-) 2 (%i3) halfangles:true; (%o3) true (%i4) sin(x/2); x floor(-----) 2 %pi sqrt(1 - cos(x)) (- 1) (%o4) ---------------------------------- sqrt(2) (%i5) assume(x>0, x<2*%pi)$ (%i6) sin(x/2); sqrt(1 - cos(x)) (%o6) ---------------- sqrt(2) -- Paquete: ntrig El paquete 'ntrig' contiene un conjunto de reglas de simplificación que se pueden usar para simplificar funciones trigonométricas cuyos argumentos son de la forma '( %pi/10)' donde es cualquiera de las funciones 'sin', 'cos', 'tan', 'csc', 'sec' o 'cot'. -- Función: sec () Secante. -- Función: sech () Secante hiperbólica. -- Función: sin () Seno. -- Función: sinh () Seno hiperbólico. -- Función: tan () Tangente. -- Función: tanh () Tangente hiperbólica. -- Función: trigexpand () Expande funciones trigonométricas e hiperbólicas de sumas de ángulos y de múltiplos de ángulos presentes en . Para mejorar los resultados, debería expandirse. Para facilitar el control por parte del usuario de las simplificaciones, esta función tan solo expande un nivel de cada vez, expandiendo sumas de ángulos o de múltiplos de ángulos. A fin de obtener una expansión completa en senos y coseno, se le dará a la variable 'trigexpand' el valor 'true'. La función 'trigexpand' está controlada por las siguientes variables: 'trigexpand' Si vale 'true', provoca la expansión de todas las expresiones que contengan senos y cosenos. 'trigexpandplus' Controla la regla de la suma para 'trigexpand', la expansión de una suma como 'sin(x + y)' se llevará a cabo sólo si 'trigexpandplus' vale 'true'. 'trigexpandtimes' Controla la regla del producto para 'trigexpand', la expansión de un producto como 'sin(2 x)' se llevará a cabo sólo si 'trigexpandtimes' vale 'true'. Ejemplos: (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand; 2 2 (%o1) - sin (x) + 3 cos (x) + x (%i2) trigexpand(sin(10*x+y)); (%o2) cos(10 x) sin(y) + sin(10 x) cos(y) -- Variable optativa: trigexpandplus Valor por defecto: 'true' La variable 'trigexpandplus' controla la regla de la suma para 'trigexpand'. Así, si la instrucción 'trigexpand' se utiliza o si la variable 'trigexpand' vale 'true', se realizará la expansión de sumas como 'sin(x+y)' sólo si 'trigexpandplus' vale 'true'. -- Variable optativa: trigexpandtimes Valor por defecto: 'true' La variable 'trigexpandtimes' controla la regla del producto para 'trigexpand'. Así, si la instrucción 'trigexpand' se utiliza o si la variable 'trigexpand' vale 'true', se realizará la expansión de productos como 'sin(2*x)' sólo si 'trigexpandtimes' vale 'true'. -- Variable optativa: triginverses Valor por defecto: 'true' La variable 'triginverses' controla la simplificación de la composición de funciones trigonométricas e hiperbólicas con sus funciones inversas. Si vale 'all', tanto 'atan(tan())' como 'tan(atan())' se reducen a . Si vale 'true', se desactiva la simplificación de '(())'. Si vale 'false', se desactivan las simplificaciones de '(())' y '(())'. -- Función: trigreduce (, ) -- Función: trigreduce () Combina productos y potencias de senos y cosenos trigonométricos e hiperbólicos de , transformándolos en otros que son múltiplos de . También intenta eliminar estas funciones cuando aparecen en los denominadores. Si no se introduce el argumento , entonces se utilizan todas las variables de . Véase también 'poissimp'. (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x); cos(2 x) cos(2 x) 1 1 (%o1) -------- + 3 (-------- + -) + x - - 2 2 2 2 Las rutinas de simplificación trigonométrica utilizan información declarada en algunos casos sencillos. Las declaraciones sobre variables se utilizan como se indica a continuación: (%i1) declare(j, integer, e, even, o, odd)$ (%i2) sin(x + (e + 1/2)*%pi); (%o2) cos(x) (%i3) sin(x + (o + 1/2)*%pi); (%o3) - cos(x) -- Variable optativa: trigsign Valor por defecto: 'true' Si 'trigsign' vale 'true', se permite la simplificación de argumentos negativos en funciones trigonométricas, como en 'sin(-x)', que se transformará en '-sin(x)' sólo si 'trigsign' vale 'true'. -- Función: trigsimp () Utiliza las identidades sin(x)^2 + cos(x)^2 = 1 y cosh(x)^2 - sinh(x)^2 = 1 para simplificar expresiones que contienen 'tan', 'sec', etc., en expresiones con 'sin', 'cos', 'sinh', 'cosh'. Las funciones 'trigreduce', 'ratsimp' y 'radcan' puden seguir siendo útiles para continuar el proceso de simplificación. La instrucción 'demo ("trgsmp.dem")' muestra algunos ejemplos de 'trigsimp'. -- Función: trigrat () Devuelve una forma canónica simplificada cuasi-lineal de una expresión trigonométrica; es una fracción racional que contiene 'sin', 'cos' o 'tan', cuyos argumentos son formas lineales respecto de ciertas variables (o kernels) y '%pi/' ( entero) con coeficientes enteros. El resultado es una fracción simplificada con el numerador y denominador lineales respecto de 'sin' y 'cos'. Así, 'trigrat' devuelve una expresión lineal siempre que sea posible. (%i1) trigrat(sin(3*a)/sin(a+%pi/3)); (%o1) sqrt(3) sin(2 a) + cos(2 a) - 1 El siguiente ejemplo se ha tomado de Davenport, Siret y Tournier, Calcul Formel, Masson (o en inglés, Addison-Wesley), sección 1.5.5, teorema de Morley. (%i1) c : %pi/3 - a - b$ (%i2) bc : sin(a)*sin(3*c)/sin(a+b); %pi sin(a) sin(3 (- b - a + ---)) 3 (%o2) ----------------------------- sin(b + a) (%i3) ba : bc, c=a, a=c; %pi sin(3 a) sin(b + a - ---) 3 (%o3) ------------------------- %pi sin(a - ---) 3 (%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b); 2 2 %pi sin (3 a) sin (b + a - ---) 3 (%o4) --------------------------- 2 %pi sin (a - ---) 3 %pi - (2 sin(a) sin(3 a) sin(3 (- b - a + ---)) cos(b) 3 %pi %pi sin(b + a - ---))/(sin(a - ---) sin(b + a)) 3 3 2 2 %pi sin (a) sin (3 (- b - a + ---)) 3 + ------------------------------- 2 sin (b + a) (%i5) trigrat (ac2); (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a) - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a) - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a) + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a) + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b) + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a) - 9)/4  File: maxima.info, Node: Números aleatorios, Prev: Funciones trigonométricas, Up: Funciones matemáticas 10.6 Números aleatorios ======================= -- Función: make_random_state () -- Función: make_random_state () -- Función: make_random_state (true) -- Función: make_random_state (false) Un objeto de estado aleatorio representa el estado del generador de números aleatorios. El estado consiste en 627 cadenas binarias de 32 bits. La llamada 'make_random_state ()' devuelve un nuevo objeto de estado aleatorio creado a partir de una semilla entera igual a módulo 2^32. El argumento puede ser negativo. La llamada 'make_random_state ()' devuelve una copia del estado aleatorio . La llamada 'make_random_state (true)' devuelve un nuevo objeto de estado aleatorio, cuya semilla se genera a partir de la hora actual del reloj del sistema como semilla. La llamada 'make_random_state (false)' devuelve una copia del estado actual del generador de números aleatorios. -- Función: set_random_state () Establece como estado del generador de números aleatorios. La función 'set_random_state' devuelve 'done' en todo caso. -- Función: random () Devuelve un número seudoaleatorio. Si es un entero, 'random ()' devuelve un entero entre 0 y ' - 1', ambos inclusive. Si es un decimal en punto flotante, 'random ()' devuelve un decimal no negativo en punto flotante menor que . La función 'random' emite un mensaje de error si no es ni entero ni de punto flotante, o si no es positivo. Las funciones 'make_random_state' y 'set_random_state' permiten controlar el estado del generador de números aleatorios. El generador de números aleatorios de Maxima implementa el algoritmo de Mersenne twister MT 19937. Ejemplos: (%i1) s1: make_random_state (654321)$ (%i2) set_random_state (s1); (%o2) done (%i3) random (1000); (%o3) 768 (%i4) random (9573684); (%o4) 7657880 (%i5) random (2^75); (%o5) 11804491615036831636390 (%i6) s2: make_random_state (false)$ (%i7) random (1.0); (%o7) .2310127244107132 (%i8) random (10.0); (%o8) 4.394553645870825 (%i9) random (100.0); (%o9) 32.28666704056853 (%i10) set_random_state (s2); (%o10) done (%i11) random (1.0); (%o11) .2310127244107132 (%i12) random (10.0); (%o12) 4.394553645870825 (%i13) random (100.0); (%o13) 32.28666704056853  File: maxima.info, Node: Base de datos de Maxima, Next: Gráficos, Prev: Funciones matemáticas, Up: Top 11 Base de datos de Maxima ************************** * Menu: * Introducción a la base de datos de Maxima:: * Funciones y variables para las propiedades:: * Funciones y variables para los hechos:: * Funciones y variables para los predicados::  File: maxima.info, Node: Introducción a la base de datos de Maxima, Next: Funciones y variables para las propiedades, Prev: Base de datos de Maxima, Up: Base de datos de Maxima 11.1 Introducción a la base de datos de Maxima ============================================== Propiedades ----------- A las variables y funciones se les puede asignar propiedades con la función 'declare'. Estas propiedades son almacenadas en un banco de datos o registradas en una lista de propiedades que proporciona Lisp. Con la función 'featurep' se puede comprobar si un símbolo tiene una determinada propiedad y con la función 'properties' se pueden obtener todas las propiedades asociadas a él. A su vez, la función 'remove' elimina una propiedad de la base de datos o de la lista de propiedades. En caso de utilizar 'kill' para borrar el valor asignado a una variable, también serán borradas todas las propiedades asociadas a la misma. El usuario tiene la facultad de añadirle propiedades a un símbolo con las funciones 'put' y 'qput'. Con la función 'get' podrá leer sus propiedades y borrarlas con 'rem'. Las variables pueden tener las siguientes propiedades a almacenar en el banco de datos: constant integer noninteger even odd rational irrational real imaginary complex Las funciones pueden tener las siguientes propiedades a almacenar en el banco de datos: increasing decreasing posfun integervalued Las siguientes propiedades se pueden aplicar a funciones y se utilizan para su correcta simplificación. Estas propiedades se describen en el capítulo dedicado a la simplificación: linear additive multiplicative outative commutative symmetric antisymmetric nary lassociativ rassociative evenfun oddfun Otras propiedades aplicables a variables y funciones, y que se almacenan en la lista de propiedades de Lisp, son: bindtest feature alphabetic scalar nonscalar nonarray Contextos --------- Maxima administra contextos en los que se almacenan tanto las propiedades de las variables y funciones como hechos o hipótesis sobre las mismas. Los hechos se establecen con la función 'assume' y se almacenan en el contexto actual. Por ejemplo, con 'assume(a>10)' guarda Maxima la información sobre el hecho de que la variable 'a' es mayor que '10'. Con la función 'forget' se borran los hechos de la base de datos. Cuando Maxima pregunta al usuario sobre las propiedades de una variable, éstas son almacenadas en un contexto. Cada contexto se identifica por un nombre. Al iniciarse Maxima, el contexto actual recibe el nombre de 'initial' y se puede definir un número arbitrario de contextos adicionales que pueden organizarse de forma jerárquica. Así, el contexto 'initial' está incluido en el contexto 'global'. Los hechos definidos en un contexto dado están siempre activos en los contextos de nivel inferior. Por ejemplo, el contexto 'global' contiene hechos que se inicializan por el propio Maxima y estarán activos, por tanto, en el contexto 'initial'. Los contextos pueden almacenar un número arbitrario de hechos y pueden desactivarse con la función 'deactivate'. Desactivar un contexto no implica la pérdida de los hechos almacenados, pudiendo ser posteriormente reactivado con la función 'activate', estando los hechos siempre a disposición del usuario.  File: maxima.info, Node: Funciones y variables para las propiedades, Next: Funciones y variables para los hechos, Prev: Introducción a la base de datos de Maxima, Up: Base de datos de Maxima 11.2 Funciones y variables para las propiedades =============================================== -- Propiedad: alphabetic 'alphabetic' es un tipo de propiedad reconocida por 'declare'. La expresión 'declare(, alphabetic)' le indica a Maxima que reconozca como alfabéticos todos los caracteres que haya en , que debe ser una cadena de texto. Véase también 'Identifiers'. Ejemplo: (%i1) xx\~yy\`\@ : 1729; (%o1) 1729 (%i2) declare ("~`@", alphabetic); (%o2) done (%i3) xx~yy`@ + @yy`xx + `xx@@yy~; (%o3) `xx@@yy~ + @yy`xx + 1729 (%i4) listofvars (%); (%o4) [@yy`xx, `xx@@yy~] -- Propiedad: bindtest La sentencia 'declare(, bindtest' le indica a Maxima que devuelva un mensaje de error cuando el símbolo no tenga asociado valor alguno. Ejemplo: (%i1) aa + bb; (%o1) bb + aa (%i2) declare (aa, bindtest); (%o2) done (%i3) aa + bb; aa unbound variable -- an error. Quitting. To debug this try debugmode(true); (%i4) aa : 1234; (%o4) 1234 (%i5) aa + bb; (%o5) bb + 1234 -- Propiedad: constant 'declare(, constant)' declara como constante. La declaración de un símbolo como constante no impide que se le asigne un valor no constante al símbolo. Véanse 'constantp' y 'declare' Ejemplo: (%i1) declare(c, constant); (%o1) done (%i2) constantp(c); (%o2) true (%i3) c : x; (%o3) x (%i4) constantp(c); (%o4) false -- Función: constantp () Devuelve 'true' si es una expresión constante y 'false' en caso contrario. Una expresión se considera constante si sus argumentos son números (incluidos los números racionales que se muestran con '/R/'), constantes simbólicas como '%pi', '%e' o '%i', variables con valor constante o declarada como constante por 'declare', o funciones cuyos argumentos son constantes. La función 'constantp' evalúa sus argumentos. Ejemplos: (%i1) constantp (7 * sin(2)); (%o1) true (%i2) constantp (rat (17/29)); (%o2) true (%i3) constantp (%pi * sin(%e)); (%o3) true (%i4) constantp (exp (x)); (%o4) false (%i5) declare (x, constant); (%o5) done (%i6) constantp (exp (x)); (%o6) true (%i7) constantp (foo (x) + bar (%e) + baz (2)); (%o7) false (%i8) -- Función: declare (, , , , ...) Asigna al átomo o lista de átomos la propiedad o lista de propiedades. Si y/o son listas, cada uno de los átomos adquiere todas las propiedades. La función 'declare' no evalúa sus argumentos y siempre devuelve la expresión 'done'. La llamada 'featurep (, )' devuelve 'true' si ha sido previamente declarado como poseedor de la propiedad . Véase también 'features'. La función 'declare' reconoce las siguientes propiedades: 'additive' Hace que Maxima simplifique las expresiones haciendo uso de la sustitución '(x + y + z + ...)' '-->' '(x) + (y) + (z) + ...'. Tal sustitución se aplica únicamente al primer argumento. 'alphabetic' Indica a Maxima que reconozca todos los caracteres de la cadena alfanumérica como caracteres alfabéticos. 'antisymmetric, commutative, symmetric' Hace que Maxima reconozca a como una función simétrica o antisimétrica. La propiedad 'commutative' equivale a 'symmetric'. 'bindtest' Hace que Maxima envíe un error si es evaluado sin habérsele asignado un valor. 'constant' Hace que Maxima considere a como una constante simbólica. 'even, odd' Hace que Maxima reconozca a como una variable entera par o impar. 'evenfun, oddfun' Hace que Maxima reconozca a como una función par o impar. 'evflag' Hace que sea reconocida por 'ev', de manera que a se le asigne el valor 'true' durante la ejecución de 'ev' cuando aparezca como argumento de control de 'ev'. Véase también 'evflag'. 'evfun' Hace que sea reconocida por 'ev', de manera que la función nombrada por se aplique cuando aparezca como argumento de control de 'ev'. Véase también 'evfun'. 'feature' Hace que Maxima considere a como el nombre de una propiedad. Otros átomos podrán ser declarados entonces como poseedores de la propiedad . 'increasing, decreasing' Hace que Maxima reconozca a como una función creciente o decreciente. 'integer, noninteger' Hace que Maxima reconozca a como una variable entera o no entera. 'integervalued' Hace que Maxima reconozca a como una función de valor entero. 'lassociative, rassociative' Hace que Maxima reconozca a como una función asociativa por la derecha o por la izquierda. 'linear' Equivale a declarar conjuntamente como 'outative' y 'additive'. 'mainvar' Hace que Maxima considere a como una "variable principal", dándole prioridad frente a cualesquiera otras constantes o variables en la ordenación canónica de expresiones de Maxima, tal como determina 'ordergreatp'. 'multiplicative' Hace que Maxima simplifique las expresiones haciendo uso de la sustitución '(x * y * z * ...)' '-->' '(x) * (y) * (z) * ...'. Tal sustitución se aplica únicamente al primer argumento. 'nary' Hace que Maxima reconozca a como una función n-aria. La declaración 'nary' no es equivalente a la función 'nary'. El único efecto de 'declare(foo, nary)' consiste en hacer que el simplificador de Maxima reduzca expresiones anidadas; por ejemplo, para transformar 'foo(x, foo(y, z))' a 'foo(x, y, z)'. 'nonarray' Indica que Maxima no debe considerar como un array. Esta declaración evita la evaluación múltiple de variables subindicadas. 'nonscalar' Hace que Maxima considere a como una variable no escalar. Se aplica comúnmente para declarar una variable como un vector simbólico o una matriz simbólica. 'noun' Hace que Maxima considere a como un nombre. El efecto que se obtiene es que se reemplazan todas las expresiones por ''' o 'nounify ()', dependiendo del contexto. 'outative' Hace que Maxima simplifique las expresiones extrayendo los factores constantes del primer argumento. Cuando tenga un único argumento, un factor se considerará constante si es una constante literal o declarada. Cuando tenga dos o más argumentos, un factor se considerará constante si el segundo argumento es un símbolo y el factor no contiene al segundo argumento. 'posfun' Hace que Maxima reconozca a como una función positiva. 'rational, irrational' Hace que Maxima reconozca a como una variable real racional o irracional. 'real, imaginary, complex' Hace que Maxima reconozca a como una variable real, imaginaria o compleja. 'scalar' Hace que Maxima considere a como una variable escalar. Ejemplos sobre el uso de estas propiedades están disponibles en la documentación correspondiente a cada propiedad por separado. -- Propiedad: decreasing -- Propiedad: increasing Las instrucciones 'declare(, decreasing)' y 'declare(, increasing' le indican a Maxima que reconozca la función como una función decreciente o creciente. Véase también 'declare' para más propiedades. Ejemplo: (%i1) assume(a > b); (%o1) [a > b] (%i2) is(f(a) > f(b)); (%o2) unknown (%i3) declare(f, increasing); (%o3) done (%i4) is(f(a) > f(b)); (%o4) true -- Propiedad: even -- Propiedad: odd 'declare(, even)' y 'declare(, odd)' le indican a Maxima que reconozca el símbolo como entero par o impar. Las propiedades 'even' y 'odd' no son reconocidas por las funciones 'evenp', 'oddp' y 'integerp'. Véanse también 'declare' y 'askinteger'. Ejemplo: (%i1) declare(n, even); (%o1) done (%i2) askinteger(n, even); (%o2) yes (%i3) askinteger(n); (%o3) yes (%i4) evenp(n); (%o4) false -- Propiedad: feature Maxima interpreta dos tipos diferentes de propiedades, del sistema y las que se aplican a expresiones matemáticas. Véase 'status' para obtener información sobre propiedades del sistema, así como 'features' y 'featurep' para propiedades de las expresiones matemáticas. 'feature' no es el nombre de ninguna función o variable. -- Función: featurep (, ) Intenta determinar si el objeto tiene la propiedad en base a los hechos almacenados en la base de datos. En caso afirmativo, devuelve 'true', o 'false' en caso contrario. Nótese que 'featurep' devuelve 'false' cuando no se puedan verificar ni ni su negación. 'featurep' evalúa su argumento. Véanse también 'declare' y 'features'. Ejemplos: (%i1) declare (j, even)$ (%i2) featurep (j, integer); (%o2) true -- Declaración: features Maxima reconoce ciertas propiedades matemáticas sobre funciones y variables. La llamada 'declare (, )' asocia la propiedad a la función o variable . La llamada 'declare (, feature)' declara una nueva propiedad . Por ejemplo, 'declare ([rojo, verde, azul], feature)' declara tres nuevas propiedades, 'rojo', 'verde' y 'azul'. El predicado 'featurep (, )' devuelve 'true' si goza de la propiedad , y 'false' en caso contrario. La lista 'features' contiene las propiedades que reconoce Maxima; a saber, integer noninteger even odd rational irrational real imaginary complex analytic increasing decreasing oddfun evenfun posfun commutative lassociative rassociative symmetric antisymmetric junto con las definidas por el usuario. La lista 'features' sólo contiene propiedades matemáticas. Hay otra lista con propiedades no matemáticas; Véase 'status'. Ejemplo: (%i1) declare (FOO, feature); (%o1) done (%i2) declare (x, FOO); (%o2) done (%i3) featurep (x, FOO); (%o3) true -- Función: get (, ) Recupera la propiedad de usuario indicada por asociada al átomo o devuelve 'false' si no tiene la propiedad . La función 'get' evalúa sus argumentos. Véanse también 'put' y 'qput'. (%i1) put (%e, 'transcendental, 'type); (%o1) transcendental (%i2) put (%pi, 'transcendental, 'type)$ (%i3) put (%i, 'algebraic, 'type)$ (%i4) typeof (expr) := block ([q], if numberp (expr) then return ('algebraic), if not atom (expr) then return (maplist ('typeof, expr)), q: get (expr, 'type), if q=false then errcatch (error(expr,"is not numeric.")) else q)$ (%i5) typeof (2*%e + x*%pi); x is not numeric. (%o5) [[transcendental, []], [algebraic, transcendental]] (%i6) typeof (2*%e + %pi); (%o6) [transcendental, [algebraic, transcendental]] -- Propiedad: integer -- Propiedad: noninteger 'declare(, integer)' o 'declare(, noninteger)' indica a Maxima que reconozca como una variable entera o no entera. Véase también 'declare'. Ejemplo: (%i1) declare(n, integer, x, noninteger); (%o1) done (%i2) askinteger(n); (%o2) yes (%i3) askinteger(x); (%o3) no -- Propiedad: integervalued 'declare(, integervalued)' indica a MAxima que reconozca como una función que toma valores enteros. Véase también 'declare'. Ejemplo: (%i1) exp(%i)^f(x); %i f(x) (%o1) (%e ) (%i2) declare(f, integervalued); (%o2) done (%i3) exp(%i)^f(x); %i f(x) (%o3) %e -- Propiedad: nonarray La instrucción 'declare(a, nonarray)' le indica a Maxima que no considere como un array. Esta declaración evita la evaluación múltiple de , si ésta es una variable subindicada. Véase también 'declare'. Ejemplo: (%i1) a:'b$ b:'c$ c:'d$ (%i4) a[x]; (%o4) d x (%i5) declare(a, nonarray); (%o5) done (%i6) a[x]; (%o6) a x -- Propiedad: nonscalar Hace que los átomos se comporten como hace una lista o matriz con respecto del operador '.' del la multiplicación no conmutativa. Véase también 'declare'. -- Función: nonscalarp () Devuelve 'true' si no es escalar, es decir, si contiene átomos declarados como no escalares, listas o matrices. -- Declaración: posfun La instrucción 'declare (f, posfun)' declara a 'f' como función positiva, de forma que 'is (f(x) > 0)' devolverá 'true'. Véase también 'declare'. -- Función: printprops (, ) -- Función: printprops ([, ..., ], ) -- Función: printprops (all, ) Muestra la propiedad con el indicador asociado con el átomo . puede ser también una lista de átomos o el átomo 'all' en cuyo caso todos los átomos a los cuales se les haya dado esa propiedad serán usados. Por ejemplo, 'printprops ([f, g], atvalue)'. 'printprops' es para propiedades que no pueden ser mostradas de otra manera, i.e. para 'atvalue', 'atomgrad', 'gradef', y 'matchdeclare'. -- Función: properties () Devuelve una lista con los nombres de todas las propiedades asociadas al t'omo . -- Variable del sistema: props Valor por defecto: '[]' 'props' son t'omos que tienen asociadas otras propiedades además de las explícitamente mencionadas en 'infolists', tales como las especificadas por 'atvalue', 'matchdeclare' y la función 'declare'. -- Función: propvars () Devuelve la lista con los átomos de la lista 'props' que tienen la propiedad indicada por . Así, 'propvars (atvalue)' devuelve la lista con los átomos a los que se les ha asociado valores con 'atvalue'. -- Función: put (<átomo>, , ) Asigna el a la propiedad (especificada por ) de <átomo>; puede ser el nombre de cualquier propiedad y no solamente de aquellas definidas por el sistema. 'rem' deshace la asignación realizada por 'put'. La función 'put' evalúa sus argumentos y devuelve . Ejemplos: (%i1) put (foo, (a+b)^5, expr); 5 (%o1) (b + a) (%i2) put (foo, "Hello", str); (%o2) Hello (%i3) properties (foo); (%o3) [[user properties, str, expr]] (%i4) get (foo, expr); 5 (%o4) (b + a) (%i5) get (foo, str); (%o5) Hello -- Función: qput (<átomo>, , ) Asigna a la propiedad de <átomo> que especifique . Actúa del mismo modeo que 'put', excepto que sus argumentos no son evaluados. Véase también 'get'. Ejemplo: (%i1) foo: aa$ (%i2) bar: bb$ (%i3) baz: cc$ (%i4) put (foo, bar, baz); (%o4) bb (%i5) properties (aa); (%o5) [[user properties, cc]] (%i6) get (aa, cc); (%o6) bb (%i7) qput (foo, bar, baz); (%o7) bar (%i8) properties (foo); (%o8) [value, [user properties, baz]] (%i9) get ('foo, 'baz); (%o9) bar -- Propiedad: rational -- Propiedad: irrational 'declare(, rational)' o 'declare(, irrational)' indica a Maxima que reconozca como una variable real racional o irracional. Véase también 'declare'. -- Propiedad: real -- Propiedad: imaginary -- Propiedad: complex 'declare(, real)', 'declare(, imaginary)' o 'declare(, complex)' indican a Maxima que reconozca como variable real, imaginaria puro o compleja, respectivamente. Véase también 'declare'. -- Función: rem (<átomo>, ) Elimina del <átomo> la propiedad indicada por . 'rem' deshace la asignación realizada por 'put'. 'rem' devuelve 'done' si <átomo> tenía la propiedad cuando 'rem' fue invocado, devolviendo 'false' si carecía tal propiedad. -- Función: remove (, , ..., , ) -- Función: remove ([, ..., ], [, ..., ], ...) -- Función: remove ("", operator) -- Función: remove (, transfun) -- Función: remove (all,

) Elimina propiedades asociadas con átomos. La llamada 'remove (, , ..., , )' elimina la propiedad 'p_k' del átomo 'a_k'. La llamada 'remove ([, ..., ], [, ..., ], ...)' elimina las propiedades ', ..., ' de los átomos , ..., . Puede tener más de un par de listas. La llamada 'remove (all,

)' elimina la propiedad

de todos los átomos que la tengan. Las propiedades eliminadas pueden ser de las que define el sistema, como 'function', 'macro' o 'mode_declare'; 'remove' no elimina las propiedades definidas por 'put'. La llamada 'remove ("", operator)' o su equivalente 'remove ("", op)' elimina de las propiedades de operador declaradas por 'prefix', 'infix', 'nary', 'postfix', 'matchfix' o 'nofix'. Nótese que el nombre del operador debe escribirse como cadena precedida de apóstrofo. La función 'remove' devuelve siempre 'done' independientemente que haya algún átomo con la propiedad especificada. La función 'remove' no evalúa sus argumentos. -- Propiedad: scalar 'declare(, scalar)' indica a Maxima que considere a como una variable escalar. Véase también 'declare'. -- Función: scalarp () Devuelve 'true' si es un número, constante o variable declarada como 'scalar' con 'declare', o compuesta completamente de tales números, constantes o variables, pero que no contengan matrices ni listas.  File: maxima.info, Node: Funciones y variables para los hechos, Next: Funciones y variables para los predicados, Prev: Funciones y variables para las propiedades, Up: Base de datos de Maxima 11.3 Funciones y variables para los hechos ========================================== -- Función: activate (, ..., ) Activa los contextos , ..., . Los hechos en estos contextos están disponibles para hacer deducciones y extraer información. Los hechos en estos contextos no se listan al invocar 'facts ()'. La variable 'activecontexts' es la lista de contextos que se han activado por medio de la función 'activate'. -- Variable del sistema: activecontexts Valor por defecto: '[]' La variable 'activecontexts' es la lista de contextos que se han activado por medio de la función 'activate', pero que no se han activado por ser subcontextos del contexto actual. -- Función: askinteger (, integer) -- Función: askinteger () -- Función: askinteger (, even) -- Función: askinteger (, odd) La llamada 'askinteger (, integer)' intenta determinar a partir de la base de datos de 'assume' si es un entero. La función 'askinteger' pide más información al usuario si no encuentra la respuesta, tratando de almacenar la nueva información en la base de datos si es posible. La llamada 'askinteger ()' equivale a 'askinteger (, integer)'. La llamadas 'askinteger (, even)' ay 'askinteger (, odd)' intentan determinar si es un entero par o impar, respectivamente. -- Función: asksign () Primero intenta determinar si la expresión especificada es positiva, negativa o cero. Si no lo consigue, planteará al usuario preguntas que le ayuden a conpletar la deducción. Las respuestas del usuario son almacenadas en la base de datos durante el tiempo que dure este cálculo. El valor que al final devuelva 'asksign' será 'pos', 'neg' o 'zero'. -- Función: assume (, ..., ) Añade los predicados , ..., al contexto actual. Si un predicado es inconsistente o redundante con los otros predicados del contexto actual, entonces no es añadido al contexto. El contexto va acumulando predicados con cada llamada a 'assume'. La función 'assume' devuelve una lista cuyos miembros son los predicados que han sido añadidos al contexto, o los átomos 'redundant' o 'inconsistent' si fuere necesario. Los predicados , ..., tan solo pueden ser expresiones formadas con los operadores relacionales '< <= equal notequal >=' y '>'. Los predicados no pueden estar formados por expresiones que sean del tipo igualdad '=' ni del tipo desigualdad '#', ni tampoco pueden ser funciones de predicado como 'integerp'. En cambio, sí se reconocen predicados compuestos de la forma ' and ... and ', pero no ' or ... or '. También se reconoce 'not ' si es un predicado relacional. Expresiones de la forma 'not ( and )' y 'not ( or )' no son reconocidas. El mecanismo deductivo de Maxima no es muy potente; existen muchas consecuencias que, siendo obvias, no pueden ser obtenidas por 'is'. Se trata de una debilidad reconocida. 'assume' no gestiona predicados con números complejos. Si un predicado contiene un número complejo, 'assume' devuelve 'inconsistent' o 'redunant'. La función 'assume' evalúa sus argumentos. Véanse también 'is', 'facts', 'forget', 'context' y 'declare'. Ejemplos: (%i1) assume (xx > 0, yy < -1, zz >= 0); (%o1) [xx > 0, yy < - 1, zz >= 0] (%i2) assume (aa < bb and bb < cc); (%o2) [bb > aa, cc > bb] (%i3) facts (); (%o3) [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb] (%i4) is (xx > yy); (%o4) true (%i5) is (yy < -yy); (%o5) true (%i6) is (sinh (bb - aa) > 0); (%o6) true (%i7) forget (bb > aa); (%o7) [bb > aa] (%i8) prederror : false; (%o8) false (%i9) is (sinh (bb - aa) > 0); (%o9) unknown (%i10) is (bb^2 < cc^2); (%o10) unknown -- Variable opcional: assumescalar Valor por defecto: 'true' La variable 'assumescalar' ayuda a controlar si una expresión 'expr' para la cual 'nonscalarp (expr)' es 'false' va a tener un comportamiento similar a un escalar bajo ciertas transformaciones. Sea 'expr' cualquier expresión distinta de una lista o matriz, y sea también '[1, 2, 3]' una lista o una matriz. Entonces, 'expr . [1, 2, 3]' dará como resultado '[expr, 2 expr, 3 expr]' si 'assumescalar' es 'true', o si 'scalarp (expr)' es 'true', o si 'constantp (expr)' es 'true'. Si 'assumescalar' vale 'true', la expresión se comportará como un escalar sólo en operaciones conmutativas, pero no en el caso de la multiplicación no conmutativa o producto matricial '.'. Si 'assumescalar' vale 'false', la expresión se comportará como un no escalar. Si 'assumescalar' vale 'all', la expresión se comportará como un escalar para todas las operaciones. -- Variable opcional: assume_pos Valor por defecto: 'false' Si 'assume_pos' vale 'true' y el signo de un parámetro no puede ser determinado a partir del contexto actual o de otras consideraciones, 'sign' y 'asksign ()' devolverán 'true'. Con esto se pueden evitar algunas preguntas al usuario que se generan automáticamente, como las que hacen 'integrate' y otras funciones. By default, a parameter is such that 'symbolp ()' or 'subvarp ()'. Por defecto, un parámetro es aquel para el que 'symbolp ()' o 'subvarp ()' devuelven 'true'. La clase de expresiones que se consideran parámetros se puede extender mediante la utilización de la variable 'assume_pos_pred'. Las funciones 'sign' y 'asksign' intentan deducir el signo de una expresión a partir de los signos de los operandos que contiene. Por ejemplo, si 'a' y 'b' son ambos positivos, entonces 'a + b' también es positivo. Sin embargo, no es posible obviar todas las preguntas que hace 'asksign'. En particular, cuando el argumento de 'asksign' es una diferencia ' - ' o un logaritmo 'log()', 'asksign' siempre solicita una respuesta por parte del usuario, incluso cuando 'assume_pos' vale 'true' y 'assume_pos_pred' es una función que devuelve 'true' para todos los argumentos. -- Variable opcional: assume_pos_pred Valor por defecto: 'false' Cuando a 'assume_pos_pred' se le asigna el nombre de una función o una expresión lambda de un único argumento , ésta será invocada para determinar si se considera un parámetro por 'assume_pos'. La variable 'assume_pos_pred' se ignora cuando 'assume_pos' vale 'false'. La función 'assume_pos_pred' es invocada por 'sign' y por 'asksign' con un argumento , el cual puede ser un átomo, una variable subindicada o una expresión de llamada a una función. Si la función 'assume_pos_pred' devuelve 'true', será considerada como un parámetro por 'assume_pos'. Por defecto, un parámetro es aquel para el que 'symbolp ()' o 'subvarp ()' devuelven 'true'. Véanse también 'assume' y 'assume_pos'. Ejemplos: (%i1) assume_pos: true$ (%i2) assume_pos_pred: symbolp$ (%i3) sign (a); (%o3) pos (%i4) sign (a[1]); (%o4) pnz (%i5) assume_pos_pred: lambda ([x], display (x), true)$ (%i6) asksign (a); x = a (%o6) pos (%i7) asksign (a[1]); x = a 1 (%o7) pos (%i8) asksign (foo (a)); x = foo(a) (%o8) pos (%i9) asksign (foo (a) + bar (b)); x = foo(a) x = bar(b) (%o9) pos (%i10) asksign (log (a)); x = a Is a - 1 positive, negative, or zero? p; (%o10) pos (%i11) asksign (a - b); x = a x = b x = a x = b Is b - a positive, negative, or zero? p; (%o11) neg -- Variable opcional: context Valor por defecto: 'initial' La variable 'context' da nombre al conjunto de hechos establecidos desde 'assume' y 'forget'. La función 'assume' añade nuevos hechos al conjunto nombrado por 'context', mientras que 'forget' los va eliminando. Asignando a 'context' un nuevo nombre cambia el contexto actual a . Si el contexto no existe todavía, se crea automáticamente mediante una llamada a 'newcontext'. Véase 'contexts' para una descripción general del mecanismo que siguen los contextos. -- Variable opcional: contexts Valor por defecto: '[initial, global]' La variable 'contexts' es una lista que contiene los contextos existentes, incluyendo el actualmente activo. El mecanismo que siguen los contextos permiten al usuario agrupar y nombrar un conjunto de hechos, que recibe el nombre de contexto. Una vez hecho esto, el usuario puede hacer que Maxima tenga en cuenta o que olvide cualquier número de hechos sin más que activar o desactivar su contexto. Cualquier átomo simbólico puede ser el nombre de un contexto, y los hechos contenidos en tal contexto pueden ser almacenados hasta que se destruyan uno a uno mediante llamadas a la función 'forget', o que se destruyan conjuntamente invocando a 'kill' para eliminar el contexto al que pertenecen. Los contextos tienen estructura jerárquica, siendo su raíz el contexto 'global', el cual contiene información sobre Maxima que necesitan algunas funciones. Cuando en un contexto todos los hechos están activos (lo que significa que están siendo utilizados en deducciones) lo estarán también en cualquier subcontexto del contexto actual. Cuando se comienza una sesión de Maxima, el usuario estará trabajando en un contexto llamado 'initial', el cual tiene un subcontexto de nombre 'global'. Véanse también 'facts', 'newcontext', 'supcontext', 'killcontext', 'activate', 'deactivate', 'assume' y 'forget'. -- Función: deactivate (, ..., ) Desactiva los contextos especificados , ..., . -- Función: facts () -- Función: facts () Si es el nombre de un contexto, 'facts ()' devuelve una lista con los hechos asociados al contexto especificado. Si no es el nombre de un contexto, 'facts ()' devuelve una lista con los hechos conocidos acerca de en el contexto actual. Los hechos que estén activos en contextos diferentes no aparecen en la lista. La llamada 'facts ()', sin argumentos, muestra el contexto actual. -- Función: forget (, ..., ) -- Función: forget () Borra los predicados establecidos por 'assume'. Los predicados pueden ser expresiones equivalentes, pero no necesariamente idénticas, a las establecidas por 'assume'. La llamada 'forget ()', siendo una lista de predicados, borra todos los predicados contenidos en ella. -- Función: is () Intenta determinar si el predicado se puede deducir de los hechos almacenados en la base de datos gestionada por 'assume'. Si el predicado se reduce a 'true' o 'false', 'is' devuelve 'true' o 'false', respectivamente. En otro caso, el valor devuelto está controlado por la variable global 'prederror'. Si 'prederror' vale 'true', 'is' emite un mensaje de error; en caso contrario, 'is' devuelve 'unknown'. La instrucción 'ev(, pred)' (que puede escribirse como ', pred' en el modo interactivo) equivale a 'is()'. Véanse también 'assume', 'facts' y 'maybe'. Ejemplos: 'is' evalúa los predicados, (%i1) %pi > %e; (%o1) %pi > %e (%i2) is (%pi > %e); (%o2) true 'is' intenta evaluar predicados a partir del conocimiento almacenado en la base de datos de 'assume'. (%i1) assume (a > b); (%o1) [a > b] (%i2) assume (b > c); (%o2) [b > c] (%i3) is (a < b); (%o3) false (%i4) is (a > c); (%o4) true (%i5) is (equal (a, c)); (%o5) false Si 'is' no puede evaluar el valor lógico del predicado a partir de la base de datos gestionada por 'assume', la variable global 'prederror' controla el comportamiento de 'is'. (%i1) assume (a > b); (%o1) [a > b] (%i2) prederror: true$ (%i3) is (a > 0); Maxima was unable to evaluate the predicate: a > 0 -- an error. Quitting. To debug this try debugmode(true); (%i4) prederror: false$ (%i5) is (a > 0); (%o5) unknown -- Función: killcontext (, ..., ) Elimina los contextos , ..., . Si alguno de estos contextos es el actual, el nuevo contexto activo será el primer subcontexto disponible del actual que no haya sido eliminado. Si el primer contexto no eliminado disponible es 'global' entonces 'initial' será usado en su lugar. Si el contexto 'initial' es eliminado, se creará un nuevo contexto 'initial' completamente vacío. La función 'killcontext' no elimina un contexto actualmente activo si es un subcontexto del contexto actual, o si se hace uso de la función 'activate'. La función 'killcontext' evalúa sus argumentos y devuelve 'done'. -- Función: maybe () Intenta determinar si el predicado se puede deducir de los hechos almacenados en la base de datos gestionada por 'assume'. Si el predicado se reduce a 'true' o 'false', 'maybe' devuelve 'true' o 'false', respectivamente. En otro caso, 'maybe' devuelve 'unknown'. La función 'maybe' es funcionalmente equivalente a 'is' con 'prederror: false', pero el resultado se calcula sin asignar valor alguno a 'prederror'. Véanse también 'assume', 'facts' y 'is'. Ejemplos: (%i1) maybe (x > 0); (%o1) unknown (%i2) assume (x > 1); (%o2) [x > 1] (%i3) maybe (x > 0); (%o3) true -- Función: newcontext () Crea un nuevo contexto vacío , el cual tiene a 'global' como su único subcontexto. El recién creado contexto pasa a ser el contexto actualmente activo. La función 'newcontext' evalúa sus argumentos y devuelve . -- Función: sign () Intenta determinar el signo de en base a los hechos almacenados en la base de datos. Devuelve una de las siguientes respuestas: 'pos' (positivo), 'neg' (negativo), 'zero' (cero), 'pz' (positivo o cero), 'nz' (negativo o cero), 'pn' (positivo o negativo), o 'pnz' (positivo, negativo o cero, lo que significa que el signo es desconocido). -- Función: supcontext (, ) -- Función: supcontext () Crea un nuevo contexto , que tiene a como subcontexto. El argumento debe existir ya. Si no se especifica , se tomará como tal el actual.  File: maxima.info, Node: Funciones y variables para los predicados, Prev: Funciones y variables para los hechos, Up: Base de datos de Maxima 11.4 Funciones y variables para los predicados ============================================== -- Función: charfun (

) Devuelve 0 cuando el predicado

toma el valor 'false', y devuelve 1 cuando vale 'true'. Si el predicado toma un valor diferente de 'true' y 'false' (desconocido), entonces devuelve una forma nominal. Ejemplos: (%i1) charfun(x<1); (%o1) charfun(x<1) (%i2) subst(x=-1,%); (%o2) 1 (%i3) e : charfun('"and"(-1 < x, x < 1))$ (%i4) [subst(x=-1,e), subst(x=0,e), subst(x=1,e)]; (%o4) [0,1,0] -- Función: compare (, ) Devuelve un operador de comparación ('<', '<=', '>', '>=', '=' o '#') de manera que 'is ( )' tome el valor 'true'; cuando tanto como dependan de '%i' y ' # ', devuelve 'notcomparable'; cuando no exista tal operador o Maxima sea incapaz de determinarlo, devolverá 'unknown'. Ejemplos: (%i1) compare(1,2); (%o1) < (%i2) compare(1,x); (%o2) unknown (%i3) compare(%i,%i); (%o3) = (%i4) compare(%i,%i+1); (%o4) notcomparable (%i5) compare(1/x,0); (%o5) # (%i6) compare(x,abs(x)); (%o6) <= La función 'compare' no intenta determinar si los dominios reales de sus argumentos son conjuntos no vacíos; así, (%i1) compare(acos(x^2+1), acos(x^2+1) + 1); (%o1) < Aquí, el dominio real de 'acos (x^2 + 1)' es el conjunto vacío. -- Función: equal (, ) Representa la equivalencia, esto es, la igualdad de los valores. Por sí misma, 'equal' no evalúa ni simplifica. La función 'is' intenta evaluar 'equal' a un resultado booleano. La instrucción 'is(equal(, ))' devuelve 'true' (o 'false') si y sólo si y son iguales (o no iguales) para todos los posibles valores de sus variables, tal como lo determina 'ratsimp( - )'; si 'ratsimp' devuelve 0, las dos expresiones se consideran equivalentes. Dos expresiones pueden ser equivalentes sin ser sintácticamente iguales (es decir, idénticas). Si 'is' no consigue reducir 'equal' a 'true' o 'false', el resultado está controlado por la variable global 'prederror'. Si 'prederror' vale 'true', 'is' emite un mensaje de error; en caso contrario, 'is' devuelve 'unknown'. Además de 'is', otros operadores evalúan 'equal' y 'notequal' a 'true' o 'false'; a saber, 'if', 'and', 'or' y 'not'. La negación de 'equal' es 'notequal'. Ejemplos: Por sí misma, 'equal' no evalúa ni simplifica. (%i1) equal (x^2 - 1, (x + 1) * (x - 1)); 2 (%o1) equal(x - 1, (x - 1) (x + 1)) (%i2) equal (x, x + 1); (%o2) equal(x, x + 1) (%i3) equal (x, y); (%o3) equal(x, y) La función 'is' intenta evaluar 'equal' a un resultado booleano. La instrucción 'is(equal(, ))' devuelve 'true' si 'ratsimp( - )' devuelve 0. Dos expresiones pueden ser equivalentes sin ser sintácticamente iguales (es decir, idénticas). (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1)); (%o1) 0 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1))); (%o2) true (%i3) is (x^2 - 1 = (x + 1) * (x - 1)); (%o3) false (%i4) ratsimp (x - (x + 1)); (%o4) - 1 (%i5) is (equal (x, x + 1)); (%o5) false (%i6) is (x = x + 1); (%o6) false (%i7) ratsimp (x - y); (%o7) x - y (%i8) is (equal (x, y)); (%o8) unknown (%i9) is (x = y); (%o9) false Si 'is' no consigue reducir 'equal' a 'true' o 'false', el resultado está controlado por la variable global 'prederror'. (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1]; 2 2 (%o1) [x + 2 x + 1, x - 2 x - 1] (%i2) ratsimp (aa - bb); (%o2) 4 x + 2 (%i3) prederror : true; (%o3) true (%i4) is (equal (aa, bb)); Maxima was unable to evaluate the predicate: 2 2 equal(x + 2 x + 1, x - 2 x - 1) -- an error. Quitting. To debug this try debugmode(true); (%i5) prederror : false; (%o5) false (%i6) is (equal (aa, bb)); (%o6) unknown Otros operadores evalúan 'equal' y 'notequal' a 'true' o 'false'. (%i1) if equal (y, y - 1) then FOO else BAR; (%o1) BAR (%i2) eq_1 : equal (x, x + 1); (%o2) equal(x, x + 1) (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2); 2 2 (%o3) equal(y + 2 y + 1, (y + 1) ) (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1]; (%o4) [false, true, true] Debido a que 'not ' obliga a la evaluación previa de , 'not equal(, )' equivale a 'is(notequal(, ))'. (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)]; (%o1) [notequal(2 z, 2 z - 1), true] (%i2) is (notequal (2*z, 2*z - 1)); (%o2) true -- Función: notequal (, ) Representa la negación de 'equal (, )'. Ejemplos: (%i1) equal (a, b); (%o1) equal(a, b) (%i2) maybe (equal (a, b)); (%o2) unknown (%i3) notequal (a, b); (%o3) notequal(a, b) (%i4) not equal (a, b); (%o4) notequal(a, b) (%i5) maybe (notequal (a, b)); (%o5) unknown (%i6) assume (a > b); (%o6) [a > b] (%i7) equal (a, b); (%o7) equal(a, b) (%i8) maybe (equal (a, b)); (%o8) false (%i9) notequal (a, b); (%o9) notequal(a, b) (%i10) maybe (notequal (a, b)); (%o10) true -- Función: unknown () Devuelve 'true' si y sólo si contiene un operador o función no reconocido por el simplificador de Maxima. -- Función: zeroequiv (, ) Analiza si la expresión de variable equivale a cero, devolviendo 'true', 'false' o 'dontknow'. La función 'zeroequiv' tiene estas restricciones: 1. No utilizar funciones que Maxima no sepa derivar y evaluar. 2. Si la expresión tiene polos en la recta real, pueden aparecer errores en el resultado, aunque es poco probable. 3. Si la expresión contiene funciones que no son soluciones de ecuaciones diferenciales ordinarias de primer orden (como las funciones de Bessel) pueden presentarse resultados incorrectos. 4. El algoritmo utiliza evaluaciones en puntos aleatoriamente seleccionados. Esto conlleva un riesgo,aunque el algoritmo intenta minimizar el error. Por ejemplo, 'zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)' devuelve 'true' y 'zeroequiv (%e^x + x, x)' devuelve 'false'. Por otro lado 'zeroequiv (log(a*b) - log(a) - log(b), a)' devuelve 'dontknow' debido a la presencia del parámetro 'b'.  File: maxima.info, Node: Gráficos, Next: Lectura y escritura, Prev: Base de datos de Maxima, Up: Top 12 Gráficos *********** * Menu: * Introducción a los gráficos:: * Formatos gráficos:: * Funciones y variables para gráficos:: * Opciones gráficas:: * Opciones para Gnuplot:: * Funciones para el formato Gnuplot_pipes::  File: maxima.info, Node: Introducción a los gráficos, Next: Formatos gráficos, Prev: Gráficos, Up: Gráficos 12.1 Introducción a los gráficos ================================ Maxima utiliza un programa gráfico externo para hacer figuras (véase la sección 'Formatos gráficos'). Las funciones gráficas calculan un conjunto de puntos y se los pasa al programa gráfico, junto con una serie de instrucciones. Estas instrucciones pueden pasarse al programa gráfico, bien a través de una tubería (pipe, en inglés), bien llamando al programa, junto con el nombre del fichero en el que se almacenan los datos. Al fichero de datos se le da el nombre 'maxout.interface', donde 'interface' es el nombre del intefaz a ser utilizado ('gnuplot', 'xmaxima', 'mgnuplot' o 'gnuplot_pipes'). El fichero 'maxout.interface', si se utiliza, se almacena en la carpeta especificada por la variable , cuyo valor se puede cambiar por una cadena de texto que represente la ruta a una carpeta válida, en la que Maxima pueda guardar nuevos ficheros. Una vez creado el gráfico, el fichero 'maxout.interface' puede ejecutarse nuevamente con el programa externo adecuado. Si una instrucción gráfica de Maxima falla, este fichero puede ser inspeccionado a fin de encontrar el origen del problema. Junto con las funciones gráficas descritas en esta sección, el paquete 'draw' añade otras funcionalidades. Nótese que algunas opciones gráficas se llaman igual en ambos contextos gráficos, pero con diferente sintaxis; para acceder a la información de estas opciones en el ámbito de 'draw', es necesario teclear '?? opc', donde 'opc' es el nombre de la opción.  File: maxima.info, Node: Formatos gráficos, Next: Funciones y variables para gráficos, Prev: Introducción a los gráficos, Up: Gráficos 12.2 Formatos gráficos ====================== Actualmente, Maxima utiliza dos programas gráficos externos: Gnuplot y Xmaxima. Existen varios formatos diferentes para estos programas, que pueden seleccionarse con la opción 'plot_format' (véase la sección Opciones gráficas). Los formatos gráficos se listan a continuación: * *gnuplot* (formato por defecto para Windows) Se utiliza para ejecutar el programa externo Gnuplot, el cual debe estar instalado en el sistema. Las instrucciones gráficas y los datos se almacenan en el fichero 'maxout.gnuplot'. * *gnuplot_pipes* (formato por defecto para plataformas distintas de Windows) Este formato no está disponible en plataformas Windows. Es similar al formato 'gnuplot', excepto por el hecho de que las instrucciones son enviadas a Gnuplot por una tubería, mientras que los datos se almacenan en el fichero 'maxout.gnuplot_pipes'. Mediante esta técnica, un único proceso de Gnuplot se mantiene activo y sucesivos gráficos son enviados al mismo proceso, a menos que la tubería a Gnuplot se cierre con la función 'gnuplot_close()'. Cuando se utiliza este formato, se puede utilizar la función 'gnuplot_replot' para modificar un gráfico que ya había sido representado previamente en la pantalla (véase 'gnuplot_replot'). Este formato debería ser utilizado únicamente cuando se representen los gráficos por pantalla; para gráficos almacenados en ficheros, mejor utilizar el formato 'gnuplot'. * *mgnuplot* Mgnuplot es una interfaz para Gnuplot basada en Tk. Se incluye en la distribución de Maxima. Mgnuplot ofrece una interface gráfica de usuario rudimentaria para gnuplot, pero tiene algunas mejoras respecto de la interface propia de gnuplot. Mgnuplot requiere de una instalación externa de Gnuplot y de Tcl/Tk. * *xmaxima* Xmaxima es un interfaz gráfico Tcl/Tk de Maxima, que también se puede utilizar para representar gráficos cuando Maxima se ejecuta desde la consola o desde otros interfaces. Para utilizar este formato, debe estar instalado junto con Maxima. Si Maxima se ejecuta desde el propio Xmaxima, las instrucciones gráficas y los datos se envían por el mismo canal de comunicación que se establece entre Maxima y Xmaxima (un socket). Cuando Maxima se ejecuta desde una consola o desde otro interfaz, las instrucciones gráficas y los datos se almacenan en un fichero de nombre 'maxout.xmaxima', que le es pasado a Xmaxima como argumento En versiones anteriores, este formato se llamaba 'openmath', cuyo nombre se sigue aceptando como sinónimo de 'xmaxima'.  File: maxima.info, Node: Funciones y variables para gráficos, Next: Opciones gráficas, Prev: Formatos gráficos, Up: Gráficos 12.3 Funciones y variables para gráficos ======================================== -- Función: contour_plot (, , , , ...) Dibuja las curvas de nivel de en el rectángulo por . Cualesquiera otros argumentos adicionales se tratan como en 'plot3d'. 'contour_plot' sólo trabaja con los métodos 'gnuplot' o 'gnuplot_pipes'. Véase también 'implicit_plot'. Ejemplos: (%i1) contour_plot (x^2 + y^2, [x, -4, 4], [y, -4, 4])$ Se pueden añadir cualesquiera opciones que acepte 'plot3d'; por ejemplo, la opción 'legend' con un valor 'false', para eliminar la leyenda. Gnuplot muestra por defecto tres líneas de contorno, pero para aumentar el número de niveles es necesario añadir algún código nativo de Gnuplot: (%i1) contour_plot (u^3 + v^2, [u, -4, 4], [v, -4, 4], [legend,false], [gnuplot_preamble, "set cntrparam levels 12"])$ -- Función: get_plot_option (, ) Devuelve el valor actual de la opción almacenada en la variable global 'plot_options'. Si toma el valor 1, devuelve el propio valor de ; si vale 2 le añade el primer parámetro, y así sucesivamente. Véanse también 'plot_options', 'set_plot_option' y la sección Opciones gráficas. -- Función: make_transform ([, , ], , , ) Devuelve una función que se puede utilizar con la opción 'transform_xy' de 'plot3d'. Las tres variables ficticias , y representan las tres variables de la función 'plot3d', las dos primeras independientes y la tercera dependiente. Las tres funciones , y deben depender solo de las tres variables anteriores y retornar las correspondientes x, y, z que se deben dibujar. Hay dos transformaciones predefinidas: 'polar_to_xy' y 'spherical_to_xyz'. Véanse 'polar_to_xy' y 'spherical_to_xyz'. -- Símbolo del sistema: polar_to_xy Cuando a la opción 'transform_xy' de 'plot3d' se le pasa el valor 'polar_to_xy', se interpretarán las dos primeras variables independientes como polares, transformándolas luego a coordenadas cartesianas. -- Función: plot2d (, , ..., , ...) -- Función: plot2d ([, ..., ], ..., , ...) -- Función: plot2d ([, ..., ], , ..., , ...) Donde , , ..., pueden ser expresiones, nombres de funciones o una lista de cualquiera de las siguientes formas: '[discrete, [, ..., ], [, ..., ]]', '[discrete, [[, ], ..., [, ..., ]]' o '[parametric, , , ]'. Muestra un gráfico de una o más expresiones como función de una variable. La función 'plot2d' representa uno o más gráficos en dos dimensiones. Las expresiones o nombres de funciones que se utilicen para definir curvas deben depender todas ellas de una única variable , siendo obligatorio utilizar para nombrar la variable y darle sus valores mínimo y máximo usando la siguiente sintaxis: '[, , ]'. Un gráfico también se puede definir de forma discreta o paramétrica. La forma discreta se utiliza para dibujar un conjunto de puntos de coordenadas dadas. Un gráfico discreto se define como una lista que empiezan con la palabra clave seguida de una o dos listas de valores numéricos. Cuando haya dos listas, ambas deben ser de igual longitud, la primera se interpreta como la de abscisas y la segunda de ordenadas. Cuando haya una lista siguiendo la clave , cada uno de sus elementos debe ser a su vez una lista de solo dos valores, correspondientes a las coordenadas x e y. Un gráfico paramétrico se define como una lista que empieza con la palabra clave , seguida de dos expresiones o nombres de funciones y un rango paramétrico. El rango paramétrico debe ser una lista formada con el nombre del parámetro seguido de sus valores mínimo y máximo: '[, , ]'. El gráfico se formará con los puntos cuyas coordenadas devuelvan las dos expresiones o funciones, según aumente desde hasta . La especificación del rango para el eje vertical es opcional y toma la forma '[y, , ]' ( se utiliza siempre para el eje vertical). En caso de utilizar esta opción, el gráfico mostrará exactamente ese rango vertical, independientemente de los valores alcanzados por los elementos gráficos. Si no se especifica el rango vertical, se ajustará a los valores extremos alcanzados por las ordenadas de los puntos que aparezcan en el gráfico. Cualesquiera otras opciones deben ser listas, comenzando con el nombre de la opción seguido de uno o más valores. Véase 'plot_options'. Si hay varias expresiones para ser dibujadas, se mostrará una leyenda que identifique a cada una de ellas. Las etiquetas a utilizar pueden especificarse con la opción . Si no se utiliza esta opción, Maxima creará etiquetas a partir de las expresiones o nombres de funciones. Ejemplos: Dibujando la función sinusoidal: (%i1) plot2d (sin(x), [x, -%pi, %pi])$ Si la función crece rápidamente puede ser necesario limitar los valores del eje vertical: (%i1) plot2d (sec(x), [x, -2, 2], [y, -20, 20])$ plot2d: some values were clipped. El aspecto del gráfico puede ser diferente dependiendo del programa gráfico utilizado. Por ejemplo, cuando se desactiva el marco, Xmaxima dibuja los ejes como flechas: (%i1) plot2d ( x^2-1, [x, -3, 3], [y, -2, 10], [box, false], [plot_format, xmaxima])$ Gráfico con escala logarítmica: (%i1) plot2d (exp(3*s), [s, -2, 2], [logy])$ Dibujando funciones especificadas por su nombre: (%i1) F(x) := x^2 $ (%i2) :lisp (defun |$g| (x) (m* x x x)) $g (%i2) H(x) := if x < 0 then x^4 - 1 else 1 - x^5 $ (%i3) plot2d ([F, G, H], [u, -1, 1], [y, -1.5, 1.5])$ Ejemplo de función paramétrica. Curva de la mariposa: (%i1) r: (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)$ (%i2) plot2d([parametric, r*sin(t), r*cos(t), [t, -8*%pi, 8*%pi], [nticks, 2000]])$ Una circunferencia de dos vueltas y solo siete puntos: (%i1) plot2d ([parametric, cos(t), sin(t), [t, -2*%pi, 2*%pi], [nticks, 8]])$ Dibujo de una función junto con la representación paramétrica de una circunferencia. El tamaño del gráfico se ha ajustado con las opciones x e y para que la circunferencia no se vea como una elipse. Estos valores son aceptables para el terminal Postscript utilizado para producir este gráfico, y puede seer necesario adaptar los valores para otros terminales: (%i1) plot2d([[parametric, cos(t), sin(t), [t,0,2*%pi], [nticks, 80]], abs(x)], [x,-2,2], [y, -1.5, 1.5])$ plot2d: some values were clipped. Puntos discretos definiendo separadamente las coordenadas x e y: (%i1) plot2d ([discrete, [10, 20, 30, 40, 50], [.6, .9, 1.1, 1.3, 1.4]])$ Los mismos puntos del ejemplo anterior, pero definiendo una a una las coordenadas y sin segmentos que unan los puntos: (%i1) plot2d([discrete, [[10, .6], [20, .9], [30, 1.1], [40, 1.3], [50, 1.4]]], [style, points])$ En este ejemplo, se guarda una tabla de tres columnas en el archivo 'data.txt', que luego será leído para representar las dos últimas columnas: (%i1) with_stdout ("data.txt", for x:0 thru 10 do print (x, x^2, x^3))$ (%i2) data: read_matrix ("data.txt")$ (%i3) plot2d ([discrete, transpose(data)[2], transpose(data)[3]], [style,points], [point_type,diamond], [color,red])$ Un gráfico de datos empíricos junto con su modelo teórico: (%i1) xy: [[10, .6], [20, .9], [30, 1.1], [40, 1.3], [50, 1.4]]$ (%i2) plot2d([[discrete, xy], 2*%pi*sqrt(l/980)], [l,0,50], [style, points, lines], [color, red, blue], [point_type, asterisk], [legend, "experiment", "theory"], [xlabel, "pendulum's length (cm)"], [ylabel, "period (s)"])$ -- Función: plot3d (, , , ..., , ...) -- Función: plot3d ([, ..., ], , , ..., , ...) Dibuja una o más superficies definidas como funciones de dos variables o en forma paramétrica Las funciones a dibujar se pueden especificar como expresiones o nombres de funciones. Puede utilizarse el ratón para hacer girar el gráfico y observarlo desde distintos ángulos. Ejemplos: Representación de una función: (%i1) plot3d (2^(-u^2 + v^2), [u, -3, 3], [v, -2, 2])$ Uso de la opción z para acotar una función que tiende a infinito (en este caso, la función tiende a menos infinito en los ejes x e y): (%i1) plot3d ( log ( x^2*y^2 ), [x, -2, 2], [y, -2, 2], [z, -8, 4], [palette, false], [color, magenta, blue])$ Los valores infinitos de z se pueden obviar eligiendo una retícula que no coincida con las asíntotas; este ejemplo también muestra cómo seleccionar las paletas predefinidas, en este caso la número 4: (%i1) plot3d (log (x^2*y^2), [x, -2, 2], [y, -2, 2], [grid, 29, 29], [palette, get_plot_option(palette,5)])$ Dos superficies en el mismo gráfico, compartiendo el mismo dominio; en Gnuplot, ambas superfifies comparten la misma paleta: (%i1) plot3d ([2^(-x^2 + y^2), 4*sin(3*(x^2+y^2))/(x^2+y^2), [x, -3, 3], [y, -2, 2]])$ Las mismas superficies, pero con diferentes dominios; en Xmaxima cada superficies usa una paleta diferente, elegida de la lista definida por la opción 'palette': (%i1) plot3d ([[2^(-x^2 + y^2),[x,-2,2],[y,-2,2]], 4*sin(3*(x^2+y^2))/(x^2+y^2), [x, -3, 3], [y, -2, 2]], [plot_format,xmaxima])$ La botella de Klein, definida paramétricamente: (%i1) expr_1:5*cos(x)*(cos(x/2)*cos(y)+sin(x/2)*sin(2*y)+3.0)-10.0$ (%i2) expr_2:-5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y) + 3.0)$ (%i3) expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))$ (%i4) plot3d ([expr_1, expr_2, expr_3], [x, -%pi, %pi], [y, -%pi, %pi], [grid, 40, 40])$ Gráfico de un armónico esférico, utilizando las transformaciones predefinidas 'spherical_to_xyz': (%i1) plot3d (sin(2*theta)*cos(phi), [theta, 0, %pi], [phi, 0, 2*%pi], [transform_xy, spherical_to_xyz], [grid,30,60])$ Uso de la transformación predefinida 'polar_to_xy'. Este ejemplo también muestra cómo eliminar el marco y la leyenda: (%i1) plot3d (r^.33*cos(th/3), [r, 0, 1], [th, 0, 6*%pi], [grid, 12, 80], [transform_xy, polar_to_xy], [box, false], [legend,false])$ Dibujo de una esfera utilizando la transformación esférica. En Xmaxima, los tres ejes utilizan escalas proporcionales, manteniendo la forma simétrica de la esfera. Se utiliza una paleta con color degradado: (%i1) plot3d ( 5, [theta, 0, %pi], [phi, 0, 2*%pi], [plot_format,xmaxima], [transform_xy, spherical_to_xyz], [palette,[value,0.65,0.7,0.1,0.9]])$ Definición de una función con dos variables utilizando una matriz. Nótese la comilla simple en la definición de la función para prevenir que 'plot3d' falle al detectar que la matriz necesita índices enteros: (%i1) M: matrix([1, 2, 3, 4], [1, 2, 3, 2], [1, 2, 3, 4], [1, 2, 3, 3])$ (%i2) f(x, y) := float('M [round(x), round(y)])$ (%i3) plot3d (f(x,y), [x, 1, 4], [y, 1, 4], [grid, 4, 4])$ apply: subscript must be an integer; found: round(x) Asignando a la opción 'elevation' el valor cero, una superficie puede verse como una aplicación en la que cada color representa un nivel diferente. La opción 'colorbox' se utiliza para mostrar la correspondencia entre colores y niveles; las líneas de la retícula se desactivan para facilitar la visualización de los colores: (%i1) plot3d (cos (-x^2 + y^3/4), [x, -4, 4], [y, -4, 4], [mesh_lines_color, false], [elevation, 0], [azimuth, 0], [colorbox, true], [grid, 150, 150])$ Véase también la sección Opciones gráficas. -- Variable global: plot_options Los elementos de esta lista establecen las opciones por defecto para los gráficos. Si una opción está presente en una llamada a 'plot2d' o a 'plot3d', este valor adquiere prevalencia sobre las opciones por defecto. En otro caso se utilizará el valor que tenga en 'plot_options'. Las opciones por defecto se asignan mediante la función 'set_plot_option'. Cada elemento de 'plot_options' es una lista de dos o más elementos, el primero de los cuales es el nombre de la opción, siendo los siguientes los valores que toma. En algunos casos el valor asignado es a su vez una lista, que puede contener varios elementos. Véanse también 'set_plot_option', 'get_option' y la sección Opciones gráficas. -- Función: set_plot_option (, ) -- Función: texput (, ) -- Función: texput (, , ) -- Función: texput (, [, ], matchfix) -- Función: texput (, [, , ], matchfix) Establece el formato en TeX del átomo , el cual puede ser un símbolo o el nombre de un operador. La instrucción 'texput (, )' hace que la función 'tex' introduzca en la salida TeX en el lugar de . La instrucción 'texput (, )' hace que 'tex' llame a la función para que genere código TeX. La función debe aceptar un único argumento, el cual es una expresión que tenga como operador y que devuelva una cadena con el código TeX. Esta función puede llamar a 'tex1' para generar el código TeX para los argumentos de la expresión de entrada. La instrucción 'texput (, , )', en la que es 'prefix', 'infix' o 'postfix', 'nary' o 'nofix',hace que la función 'tex' introduzca en la salida TeX en el lugar de , colocándolo en el lugar correcto. La instrucción 'texput (, [, ], matchfix)' hace que la función 'tex' introduzca y en la salida TeX a los lados de los argumentos de . Si son más de uno, los argumentos se separan por comas. La instrucción 'texput (, [, , ], matchfix)' hace que la función 'tex' introduzca y en la salida TeX a los lados de los argumentos de , con separando los argumentos. Ejemplos: Asigna código TeX para una variable. Llama a una función que genera código TeX. (%i1) texfoo (e) := block ([a, b], [a, b] : args (e), concat ("\\left[\\stackrel{", tex1 (b), "}{", tex1 (a), "}\\right]"))$ (%i2) texput (foo, texfoo); (%o2) texfoo (%i3) tex (foo (2^x, %pi)); $$\left[\stackrel{\pi}{2^{x}}\right]$$ (%o3) false (%i1) texput (me,"\\mu_e"); (%o1) \mu_e (%i2) tex (me); $$\mu_e$$ (%o2) false Asigna código TeX para una función ordinaria (no para un operador). (%i1) texput (lcm, "\\mathrm{lcm}"); (%o1) \mathrm{lcm} (%i2) tex (lcm (a, b)); $$\mathrm{lcm}\left(a , b\right)$$ (%o2) false Asigna código TeX para un operador prefijo. (%i1) prefix ("grad"); (%o1) grad (%i2) texput ("grad", " \\nabla ", prefix); (%o2) \nabla (%i3) tex (grad f); $$ \nabla f$$ (%o3) false Asigna código TeX para un operador infijo. (%i1) infix ("~"); (%o1) ~ (%i2) texput ("~", " \\times ", infix); (%o2) \times (%i3) tex (a ~ b); $$a \times b$$ (%o3) false Asigna código TeX para un operador postfijo.. (%i1) postfix ("##"); (%o1) ## (%i2) texput ("##", "!!", postfix); (%o2) !! (%i3) tex (x ##); $$x!!$$ (%o3) false Asigna código TeX para un operador n-ario. (%i1) nary ("@@"); (%o1) @@ (%i2) texput ("@@", " \\circ ", nary); (%o2) \circ (%i3) tex (a @@ b @@ c @@ d); $$a \circ b \circ c \circ d$$ (%o3) false Asigna código TeX para un operador "no-fijo". (%i1) nofix ("foo"); (%o1) foo (%i2) texput ("foo", "\\mathsc{foo}", nofix); (%o2) \mathsc{foo} (%i3) tex (foo); $$\mathsc{foo}$$ (%o3) false Asigna código TeX para un operador "bi-fijo" (matchfix). (%i1) matchfix ("<<", ">>"); (%o1) << (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix); (%o2) [ \langle , \rangle ] (%i3) tex (<>); $$ \langle a \rangle $$ (%o3) false (%i4) tex (<>); $$ \langle a , b \rangle $$ (%o4) false (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"], matchfix); (%o5) [ \langle , \rangle , \, | \,] (%i6) tex (<>); $$ \langle a \rangle $$ (%o6) false (%i7) tex (<>); $$ \langle a \, | \,b \rangle $$ (%o7) false -- Función: get_tex_environment () -- Función: set_tex_environment (, , ) Gestiona el entorno de las salidas TeX que se obtienen de la función 'tex'. El entorno TeX está formado por dos cadenas: una que se escribe antes que cualquier salida en TeX, y otra que se escribe después. 'get_tex_environment' devuelve el entorno TeX que se aplica al operador . Si no se ha asignado ningún entorno, devolverá el que tenga por defecto. 'set_tex_environment' asigna el entorno TeX al operador . Ejemplos: (%i1) get_tex_environment (":="); (%o1) [ \begin{verbatim} , ; \end{verbatim} ] (%i2) tex (f (x) := 1 - x); \begin{verbatim} f(x):=1-x; \end{verbatim} (%o2) false (%i3) set_tex_environment (":=", "$$", "$$"); (%o3) [$$, $$] (%i4) tex (f (x) := 1 - x); $$f(x):=1-x$$ (%o4) false -- Función: get_tex_environment_default () -- Función: set_tex_environment_default (, ) Gestiona el entorno de las salidas TeX que se obtienen de la función 'tex'. El entorno TeX está formado por dos cadenas: una que se escribe antes que cualquier salida en TeX, y otra que se escribe después. 'get_tex_environment_default' devuelve el entorno TeX que se aplica a expresiones para las cuales el operador de mayor rango no tiene entorno TeX asignado (mediante 'set_tex_environment'). 'set_tex_environment_default' asigna el entorno TeX por defecto. Ejemplos: (%i1) get_tex_environment_default (); (%o1) [$$, $$] (%i2) tex (f(x) + g(x)); $$g\left(x\right)+f\left(x\right)$$ (%o2) false (%i3) set_tex_environment_default ("\\begin{equation} ", " \\end{equation}"); (%o3) [\begin{equation} , \end{equation}] (%i4) tex (f(x) + g(x)); \begin{equation} g\left(x\right)+f\left(x\right) \end{equation} (%o4) false  File: maxima.info, Node: Funciones y variables para salida Fortran, Prev: Funciones y variables para salida TeX, Up: Lectura y escritura 13.5 Funciones y variables para salida Fortran ============================================== -- Variable opcional: fortindent Valor por defecto: 0 La variable 'fortindent' controla el margen izquierdo de las expresiones que escribe la instrucción 'fortran'. El valor 0 escribe con un margen normal de 6 espacios; valores positivos harán que las expresiones se escriban más a la derecha. -- Función: fortran () Escribe en código Fortran. La salida se escribe con márgenes, y si ésta es demasiado larga 'fortran' sigue escribiendo en líneas sucesivas. La función 'fortran' escribe el operador de exponenciación '^' como '**', e imprime un número complejo 'a + b %i' como '(a,b)'. El argumento puede ser una ecuación. En tal caso, 'fortran' escribe una sentencia de asignación, dándole el valor del miembro derecho de la expresión al miembro izquierdo. En particular, si el miembro derecho de es el nombre de una matriz, entonces 'fortran' escribe una sentencia de asignación para cada elemento de la matriz. Si no es reconozida por 'fortran', la expresión se escribe en formato 'grind' sin avisos. La función 'fortran' no reconoce listas, arreglos ni funciones. La variable 'fortindent' controla el margen izquierdo de las expresiones que escribe la instrucción 'fortran'. El valor 0 escribe con un margen normal de 6 espacios; valores positivos harán que las expresiones se escriban más a la derecha. Si 'fortspaces' vale 'true', 'fortran' rellena las líneas con espacios de 80 columnas. La función 'fortran' evalúa sus argumentos; un argumento precedido de apóstrofo previene de la evaluación. La función 'fortran' siempre devuelve 'done'. Ejemplos: (%i1) expr: (a + b)^12$ (%i2) fortran (expr); (b+a)**12 (%o2) done (%i3) fortran ('x=expr); x = (b+a)**12 (%o3) done (%i4) fortran ('x=expand (expr)); x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792 1 *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b 2 **3+66*a**10*b**2+12*a**11*b+a**12 (%o4) done (%i5) fortran ('x=7+5*%i); x = (7,5) (%o5) done (%i6) fortran ('x=[1,2,3,4]); x = [1,2,3,4] (%o6) done (%i7) f(x) := x^2$ (%i8) fortran (f); f (%o8) done -- Variable opcional: fortspaces Valor por defecto: 'false' Si 'fortspaces' vale 'true', 'fortran' rellena las líneas con espacios de 80 columnas.  File: maxima.info, Node: Polinomios, Next: Funciones Especiales, Prev: Lectura y escritura, Up: Top 14 Polinomios ************* * Menu: * Introducción a los polinomios:: * Funciones y variables para polinomios::  File: maxima.info, Node: Introducción a los polinomios, Next: Funciones y variables para polinomios, Prev: Polinomios, Up: Polinomios 14.1 Introducción a los polinomios ================================== Los polinomios se almacenan en Maxima, bien en un formato general, bien en una forma conocida como canónica (Cannonical Rational Expressions, CRE). La última corresponde al formato estándar y se utiliza internamente para realizar operaciones como 'factor', 'ratsimp' y demás. Las Expresiones Racionales Canónicas (CRE) constituyen un tipo de representación que es especialmente apropiado para expandir polinomios y funciones racionales (así como para polinomios parcialmente factorizados y funciones racionales cuando a la variable 'ratfac' se le asigna el valor 'true'). En esta forma CRE las variables se ordenan de mayor a menor. Los polinomios se representan recursivamente como una lista compuesta por la variable principal seguida por una serie de pares de expresiones, una por cada término del polinomio. El primer miembro de cada par es el exponente de la variable principal en ese término y el segundo miembro es el coeficiente de ese término, el cual puede ser un número o un polinomio en otra variable representado también de esta forma. Así, la parte principal de la forma CRE de 3*X^2-1 es (X 2 3 0 -1) y la de 2*X*Y+X-3 es (Y 1 (X 1 2) 0 (X 1 1 0 -3)) asumiendo que Y es la variable principal, y será (X 1 (Y 1 2 0 1) 0 -3) si se asume que la variable principal es X. Qué variable se considera "principal" se determinada en orden alfabético inverso. Las "variables" de la expresión CRE no son necesariamente atómicas. De hecho cualquier subexpresión cuyo operador principal no es + - * / ni ^ con potencia entera puede ser considerada como una "variable" de la expresión (en forma CRE) en el cual aparezca. Por ejemplo las variables CRE de la expresión X+SIN(X+1)+2*SQRT(X)+1 son X, SQRT(X) y SIN(X+1). Si el usuario no especifica una ordenación de las variables mediante la función 'ratvars' Maxima escogerá una alfabéticamente. En general, laa CRE representan expresiones racionales, esto es, fracciones de polinomios, donde el numerador y el denominador no tienen factores comunes, siendo el denominador es positivo. La forma interna es esencialmente un par de polinomios (el numerador y el denominador) precedida por la lista de variables ordenadas. Si una expresión a ser mostrada está en la forma CRE o contiene alguna subexpresión en forma de CRE, el simbolo /R/ será seguido por la etiqueta de la línea de comando. Véase la función 'rat' para convertir una expresión a la forma CRE. Una extensión de la forma CRE se utiliza para la representación de las series de Taylor. La noción de una expresión racional se extiende de manera que los exponentes de las variables pueden ser números racionales positivos o negativos y no sólo enteros positivos y los coeficientes pueden ser también expresiones racionales y no sólo polinomios. Estas expresiones se representan internamente por una forma polinomial recursiva que es similar a la forma CRE, pero que la generaliza, aportando información adicional como el grado de truncamiento. Como con la forma CRE, el símbolo /T/ sigue la etiqueta de línea de comando en la que se encuentra dicha expresión.  File: maxima.info, Node: Funciones y variables para polinomios, Prev: Introducción a los polinomios, Up: Polinomios 14.2 Funciones y variables para polinomios ========================================== -- Variable opcional: algebraic Valor por defecto: 'false' La variable 'algebraic' debe valer 'true' para que se pueda hacer la simplificación de enteros algebraicos. -- Variable opcional: berlefact Valor por defecto: 'true' Si 'berlefact' vale 'false' entonces se utiliza el algoritmo de factorización de Kronecker, en caso contrario se utilizará el algoritmo de Berlekamp, que es el que se aplica por defecto. -- Función: bezout (, , ) Es una alternativa a la función 'resultant'. Devuelve una matriz. (%i1) bezout(a*x+b, c*x^2+d, x); [ b c - a d ] (%o1) [ ] [ a b ] (%i2) determinant(%); 2 2 (%o2) a d + b c (%i3) resultant(a*x+b, c*x^2+d, x); 2 2 (%o3) a d + b c -- Función: bothcoef (, ) Devuelve una lista cuyo primer miembro es el coeficiente de en (que coincide con el que devuelve 'ratcoef' si está en formato CRE, o el que devuelve 'coeff' si no está en este formato) y cuyo segundo miembro es la parte restante de . Esto es, '[A, B]' donde ' = A* + B'. Ejemplo: (%i1) islinear (expr, x) := block ([c], c: bothcoef (rat (expr, x), x), is (freeof (x, c) and c[1] # 0))$ (%i2) islinear ((r^2 - (x - r)^2)/x, x); (%o2) true -- Función: coeff (, , ) -- Función: coeff (, ) Devuelve el coeficiente de '^' en , donde es un polinomio o monomio en . 'coeff(, ^)' es equivalente a 'coeff(, , )'. 'coeff(, , 0)' devuelve el resto de , el cual no contiene a . En caso de omisión, se entiende que es igual a 1. puede ser tanto el nombre de una variable simple como el de una variable con subíndice, o también una subexpresión de que contenga un operador junto con todos sus argumentos. En ocasiones, es posible calcular los coeficientes de expresiones equivalentes a aplicando 'expand' o 'factor'. 'coeff' no aplica ni 'expand', ni 'factor', ni ninguna otra función. 'coeff' se distribuye sobre listas, matrices y ecuaciones. Ejemplos: 'coeff' devuelve el coeficiente de '^' en . (%i1) coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3); 3 (%o1) b 'coeff(, ^)' es equivalente a 'coeff(, , )'. (%i1) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3); (%o1) - c 3 (%i2) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3); (%o2) - c 3 'coeff(, , 0)' devuelve el resto de , el cual no contiene a . (%i1) coeff (a*u + b^2*u^2 + c^3*u^3, b, 0); 3 3 (%o1) c u + a u puede ser tanto el nombre de una variable simple como el de una variable con subíndice, o también una subexpresión de que contenga un operador junto con todos sus argumentos. (%i1) coeff (h^4 - 2*%pi*h^2 + 1, h, 2); (%o1) - 2 %pi (%i2) coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2); (%o2) - 2 %pi (%i3) coeff (sin(1 + x)*sin(x) + sin(1 + x)^3*sin(x)^3, sin(1 + x)^3); 3 (%o3) sin (x) (%i4) coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4); (%o4) c - d 'coeff' no aplica ni 'expand', ni 'factor', ni ninguna otra función. (%i1) coeff (c*(a + b)^3, a); (%o1) 0 (%i2) expand (c*(a + b)^3); 3 2 2 3 (%o2) b c + 3 a b c + 3 a b c + a c (%i3) coeff (%, a); 2 (%o3) 3 b c (%i4) coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3); (%o4) 0 (%i5) factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c); 3 (%o5) (b + a) c (%i6) coeff (%, (a + b)^3); (%o6) c 'coeff' se distribuye sobre listas, matrices y ecuaciones. (%i1) coeff ([4*a, -3*a, 2*a], a); (%o1) [4, - 3, 2] (%i2) coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x); [ a b ] (%o2) [ ] [ - c - d ] (%i3) coeff (a*u - b*v = 7*u + 3*v, u); (%o3) a = 7 -- Función: content (, , ..., ) Devuelve una lista cuyo primer miembro es el máximo común divisor de los coeficientes de los términos del polinomio de variable (este es el contenido) y cuyo segundo miembro es el polinomio dividido por el contenido. Ejemplos: (%i1) content (2*x*y + 4*x^2*y^2, y); 2 (%o1) [2 x, 2 x y + y] -- Función: denom () Devuelve el denominador de la expresión racional . -- Función: divide (, , , ..., ) Calcula el cociente y el resto del polinomio dividido por el polinomio , siendo la variable principal . Las otras funciones son como en la función 'ratvars'. El resultado es una lista cuyo primer miembro es el cociente y el segundo miembro el resto. Ejemplos: (%i1) divide (x + y, x - y, x); (%o1) [1, 2 y] (%i2) divide (x + y, x - y); (%o2) [- 1, 2 x] Nótese que 'y' es la variable principal en el segundo ejemplo. -- Función: eliminate ([, ..., ], [, ..., ]) Elimina variables de ecuaciones (o de expresiones que se supone valen cero) tomando resultantes sucesivas. Devuelve una lista con ' - ' expresiones y variables , ..., eliminadas. Primero se elimina dando ' - 1' expresiones, después se elimina 'x_2', etc. Si ' = ' entonces se devuelve una lista con una única expresión, libre de las variables , ..., . En este caso se llama a 'solve' para resolver la última resultante para la última variable. Ejemplo: (%i1) expr1: 2*x^2 + y*x + z; 2 (%o1) z + x y + 2 x (%i2) expr2: 3*x + 5*y - z - 1; (%o2) - z + 5 y + 3 x - 1 (%i3) expr3: z^2 + x - y^2 + 5; 2 2 (%o3) z - y + x + 5 (%i4) eliminate ([expr3, expr2, expr1], [y, z]); 8 7 6 5 4 (%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x 3 2 - 5154 x - 1291 x + 7688 x + 15376] -- Función: ezgcd (, , , ...) Devuelve una lista cuyo primer elemento es el máximo común divisor (mcd) de los polinomios , , , ..., siendo los miembros restantes los mismos polinomios divididos por el mcd. Se utiliza siempre el algoritmo 'ezgcd'. Véanse también 'gcd', 'gcdex', 'gcdivide' y 'poly_gcd'. Ejemplos: Los tres polinomios tiene como máximo común divisor '2*x-3', el cual se calcula primero con la función 'gcd' y luego con 'ezgcd'. (%i1) p1 : 6*x^3-17*x^2+14*x-3; 3 2 (%o1) 6 x - 17 x + 14 x - 3 (%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3; 4 3 2 (%o2) 4 x - 14 x + 12 x + 2 x - 3 (%i3) p3 : -8*x^3+14*x^2-x-3; 3 2 (%o3) - 8 x + 14 x - x - 3 (%i4) gcd(p1, gcd(p2, p3)); (%o4) 2 x - 3 (%i5) ezgcd(p1, p2, p3); 2 3 2 2 (%o5) [2 x - 3, 3 x - 4 x + 1, 2 x - 4 x + 1, - 4 x + x + 1] -- Variable opcional: facexpand Valor por defecto: 'true' La variable 'facexpand' controla si los factores irreducibles devueltos por 'factor' están en formato expandido (por defecto) o recursivo (CRE normal). -- Función: factor () -- Función: factor (,

) Factoriza la expresión , que puede contener cualquier número de variables o funciones, en factores irreducibles respecto de los enteros. La llamada 'factor (,

)' factoriza en el campo de los racionales con un elemento añadido cuyo polinomio mínimo es

. La función 'factor' utiliza a 'ifactors' para factorizar enteros. Si la variable 'factorflag' vale 'false' suprime la factorización de los factores enteros en las expresiones racionales. La variable 'dontfactor' puede contener una lista de variables con respecto a las cuales no se factorizará (inicialmente está vacía). Tampoco se factorizará respecto de cualesquiera otra variables que sean menos importantes (según la ordenación que se sigue en el formato CRE) que aquellas que se encuentran en la lista 'dontfactor'. Si la variable 'savefactors' vale 'true', los factores de una expresión en forma de producto se guardarán por ciertas funciones a fin de acelerar posteriores factorizaciones de expresiones que contengan algunos de estos mismos factores. Si 'berlefact' vale 'false' entonces se utiliza el algoritmo de factorización de Kronecker, en caso contrario se utilizará el algoritmo de Berlekamp, que es el que se aplica por defecto. Si la variable 'intfaclim' vale 'true', Maxima desistirá de factorizar enteros si no encuentra ningún factor después de las divisiones tentativas y de aplicar el método rho de Pollard. Si vale 'false' (este es el caso cuando el usuario invoca explícitamente a 'factor'), se intentará la factorización completa del entero. El valor asignado a 'intfaclim' se utiliza en llamadas internas a 'factor'. Así, se puede cambiar el valor de 'intfaclim' para evitar que Maxima dedique un tiempo prohibitivo a factorizar números enteros grandes. Ejemplos: (%i1) factor (2^63 - 1); 2 (%o1) 7 73 127 337 92737 649657 (%i2) factor (-8*y - 4*x + z^2*(2*y + x)); (%o2) (2 y + x) (z - 2) (z + 2) (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2; 2 2 2 2 2 (%o3) x y + 2 x y + y - x - 2 x - 1 (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2))); 2 (x + 2 x + 1) (y - 1) (%o4) ---------------------- 36 (y + 1) (%i5) factor (1 + %e^(3*x)); x 2 x x (%o5) (%e + 1) (%e - %e + 1) (%i6) factor (1 + x^4, a^2 - 2); 2 2 (%o6) (x - a x + 1) (x + a x + 1) (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3); 2 (%o7) - (y + x) (z - x) (z + x) (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2; x + 2 (%o8) ------------------------ 2 (x + 3) (x + b) (x + c) (%i9) ratsimp (%); 4 3 (%o9) (x + 2)/(x + (2 c + b + 3) x 2 2 2 2 + (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c ) (%i10) partfrac (%, x); 2 4 3 (%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c 2 2 2 2 + (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c)) c - 2 - --------------------------------- 2 2 (c + (- b - 3) c + 3 b) (x + c) b - 2 + ------------------------------------------------- 2 2 3 2 ((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b) 1 - ---------------------------------------------- 2 ((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3) (%i11) map ('factor, %); 2 c - 4 c - b + 6 c - 2 (%o11) - ------------------------- - ------------------------ 2 2 2 (c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c) b - 2 1 + ------------------------ - ------------------------ 2 2 (b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3) (%i12) ratsimp ((x^5 - 1)/(x - 1)); 4 3 2 (%o12) x + x + x + x + 1 (%i13) subst (a, x, %); 4 3 2 (%o13) a + a + a + a + 1 (%i14) factor (%th(2), %); 2 3 3 2 (%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1) (%i15) factor (1 + x^12); 4 8 4 (%o15) (x + 1) (x - x + 1) (%i16) factor (1 + x^99); 2 6 3 (%o16) (x + 1) (x - x + 1) (x - x + 1) 10 9 8 7 6 5 4 3 2 (x - x + x - x + x - x + x - x + x - x + 1) 20 19 17 16 14 13 11 10 9 7 6 (x + x - x - x + x + x - x - x - x + x + x 4 3 60 57 51 48 42 39 33 - x - x + x + 1) (x + x - x - x + x + x - x 30 27 21 18 12 9 3 - x - x + x + x - x - x + x + 1) -- Variable opcional: factorflag Valor por defecto: 'false' Si 'factorflag' vale 'false' se evita la factorización de factores enteros de expresiones racionales. -- Función: factorout (, , , ...) Reorganiza la suma como una suma de términos de la forma 'f (, , ...)*g', donde 'g' es un producto de expresiones que no contienen ningún y 'f' se factoriza. Nótese que 'factorout' ignora la variable opcional 'keepfloat'. Ejemplo: (%i1) expand (a*(x+1)*(x-1)*(u+1)^2); 2 2 2 2 2 (%o1) a u x + 2 a u x + a x - a u - 2 a u - a (%i2) factorout(%,x); 2 (%o2) a u (x - 1) (x + 1) + 2 a u (x - 1) (x + 1) + a (x - 1) (x + 1) -- Función: factorsum () Intenta agrupar términos en los factores de que son sumas en grupos de términos tales que su suma sea factorizable. La función 'factorsum' puede restablecer el recuperar de 'expand ((x + y)^2 + (z + w)^2)' pero no puede recuperar 'expand ((x + 1)^2 + (x + y)^2)' porque los términos tienen variables comunes. Ejemplo: (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2)); 2 2 2 2 (%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x 2 2 2 2 + 2 u v x + u x + a w + v + 2 u v + u (%i2) factorsum (%); 2 2 (%o2) (x + 1) (a (z + w) + (v + u) ) -- Función: fasttimes (, ) Calcula el producto de los polinomios y utilizando un algoritmo especial. Los polinomios 'p_1' y 'p_2' deben ser multivariantes, densos y aproximadamente del mismo tamaño. La multiplicación clásica es de orden 'n_1 n_2' donde 'n_1' es el grado de 'p_1' y 'n_2' el grado de 'p_2'. La función 'fasttimes' es de orden 'max (n_1, n_2)^1.585'. -- Función: fullratsimp () Aplica repetidamente 'ratsimp' a una expresión, seguida de simplificaciones no racionales, hasta que no se obtienen más transformaciones; entonces devuelve el resultado. En presencia de expresiones no racionales, una llamada a 'ratsimp' seguida de una simplificación no racional ("general") puede no ser suficiente para conseguir un resultado simplificado. En ocasiones serán necesarias más de una llamada a 'ratsimp', que es lo que hace precisamente 'fullratsimp'. Ejemplo: (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1); a/2 2 a/2 2 (x - 1) (x + 1) (%o1) ----------------------- a x - 1 (%i2) ratsimp (expr); 2 a a x - 2 x + 1 (%o2) --------------- a x - 1 (%i3) fullratsimp (expr); a (%o3) x - 1 (%i4) rat (expr); a/2 4 a/2 2 (x ) - 2 (x ) + 1 (%o4)/R/ ----------------------- a x - 1 -- Función: fullratsubst (, , ) Similar a 'ratsubst' excepto por el hecho de que se llama a í misma recursivamente hasta que el resultado deja de cambiar. Esta función es útil cuando la expresión a sustituir y la que la sustituye tienen variables comunes. La función 'fullratsubst' también acepta sus argumentos en el formato de 'lratsubst'. Es necesario ejecutar 'load ("lrats")' para cargar 'fullratsubst' y 'lratsubst'. Ejemplos: (%i1) load ("lrats")$ * 'subst' puede hacer sustituciones múltiples; 'lratsubst' es análoga a 'subst'. (%i2) subst ([a = b, c = d], a + c); (%o2) d + b (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); (%o3) (d + a c) e + a d + b c * Si sólo se quiere una sustitución, entonces se puede dar una única ecuación como primer argumento. (%i4) lratsubst (a^2 = b, a^3); (%o4) a b * 'fullratsubst' equivale a 'ratsubst', excepto por el hecho de que se llama a í misma recursivamente hasta que el resultado deja de cambiar. (%i5) ratsubst (b*a, a^2, a^3); 2 (%o5) a b (%i6) fullratsubst (b*a, a^2, a^3); 2 (%o6) a b * 'fullratsubst' también acepta una lista de ecuaciones o una sóla ecuación como primer argumento. (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c); (%o7) b (%i8) fullratsubst (a^2 = b*a, a^3); 2 (%o8) a b * 'fullratsubst' puede caer en una recursión infinita. (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3)); *** - Lisp stack overflow. RESET -- Función: gcd (, , , ...) Devuelve el máximo común divisor de y . La variable 'gcd' determiona qué algoritmo se va a utilizar. Asignándole a 'gcd' los valores 'ez', 'subres', 'red' o 'spmod', se seleccionan los algoritmos 'ezgcd', subresultante 'prs', reducido o modular, respectivamente. Si 'gcd' vale 'false' entonces 'gcd(, , )' devolverá siempre 1 para cualquier . Muchas funciones (por ejemplo, 'ratsimp', 'factor', etc.) hacen uso de 'gcd' implícitamente. En caso de polinomios homogéneos se recomienda darle a 'gcd' el valor 'subres'. Para calcular un máximo común divisor en presencia de raíces, como en 'gcd (^2 - 2*sqrt(2)* + 2, - sqrt(2))', la variable 'algebraic' debe igualarse a 'true' y 'gcd' no puede ser 'ez'. Se recomienda utilizar el algoritmo 'subres' en lugar de 'red', por ser aquél más moderno. Si la variable 'gcd', cuyo valor por defecto es 'spmod', vale 'false', no se calculará el máximo común divisor cuando las expresiones se conviertan a su forma canónica (CRE), lo que redundará en ocasiones en mayor rapidez de cálculo. -- Función: gcdex (, ) -- Función: gcdex (, , ) Devuelve una lista '[, , ]' en la que es el máximo común divisor (mcd) de y , e igual a ' + '. Los argumentos y deben ser polinomios univariantes, o indicarles la variable principal en caso de ser multivariantes. La función 'gcdex' implementa el algoritmo de Euclides, en el que tenemos una secuencia de 'L[i]: [a[i], b[i], r[i]]' todos ellos ortogonales a '[f, g, -1]' siendo el siguiente calculado a partir de 'q = quotient(r[i]/r[i+1])' y 'L[i+2]: L[i] - q L[i+1]'; el proceso termina en 'L[i+1]' cuando el resto 'r[i+2]' se anula. (%i1) gcdex (x^2 + 1, x^3 + 4); 2 x + 4 x - 1 x + 4 (%o1)/R/ [- ------------, -----, 1] 17 17 (%i2) % . [x^2 + 1, x^3 + 4, -1]; (%o2)/R/ 0 -- Función: gcfactor () Factoriza el entero gaussiano como producto, a su vez, de enteros gaussianos, (un entero gaussiano es de la forma' + %i' donde y son números enteros). Los factores se normalizan de manera que tanto la parte real como imaginaria sean no negativas. -- Función: gfactor () Factoriza el polinomio sobre los enteros gaussianos (un entero gaussiano es de la forma' + %i' donde y son números enteros). Es como 'factor (, ^2+1)' donde vale '%i'. Ejemplo: (%i1) gfactor (x^4 - 1); (%o1) (x - 1) (x + 1) (x - %i) (x + %i) -- Función: gfactorsum () Esta función es similar a 'factorsum' pero aplica 'gfactor' en lugar de 'factor'. -- Función: hipow (, ) Devuelve el mayor exponente explícito de en . El argumento puede ser una variable o una expresión general. Si no aparece en , 'hipow' devuelve '0'. La función 'hipow' no tiene en cuenta expresiones equivalentes a 'expr'. En particular, 'hipow' no expande 'expr', de manera que 'hipow (, )' y 'hipow (expand (, ))' pueden dar resultados diferentes. Ejemplos: (%i1) hipow (y^3 * x^2 + x * y^4, x); (%o1) 2 (%i2) hipow ((x + y)^5, x); (%o2) 1 (%i3) hipow (expand ((x + y)^5), x); (%o3) 5 (%i4) hipow ((x + y)^5, x + y); (%o4) 5 (%i5) hipow (expand ((x + y)^5), x + y); (%o5) 0 -- Variable opcional: intfaclim Valor por defecto: 'true' Si vale 'true', Maxima desistirá de factorizar enteros si no encuentra ningún factor después de las divisiones tentativas y de aplicar el método rho de Pollard, por lo que la factorización puede quedar incompleta. Si vale 'false' (este es el caso cuando el usuario invoca explícitamente a 'factor'), se intentará la factorización completa del entero. El valor asignado a 'intfaclim' se utiliza en llamadas internas a 'factor'. A la variable 'intfaclim' se le asigna el valor 'false' cuando se calculan factores desde las funciones 'divisors', 'divsum' y 'totient'. Las llamadas internas a 'factor' respetan el valor dado por el usuario a 'intfaclim'. Asignando a 'intfaclim' el valor 'true' se puede reducir el tiempo que Maxima dedica a factorizar enteros grandes. -- Variable opcional: keepfloat Valor por defecto: 'false' Si 'keepfloat' vale 'true', los números decimales en coma flotante no se racionalizan cuando las expresiones que los contienen se convierten al formato canónico racional (CRE). Nótese que la función 'solve' y todas aquellas otras que la invocan (por ejemplo, 'eigenvalues') ignoran esta variable, por lo que hacen la conversión de los números decimales. Ejemplos: (%i1) rat(x/2.0); `rat' replaced 0.5 by 1/2 = 0.5 x (%o1)/R/ - 2 (%i2) rat(x/2.0), keepfloat; (%o2)/R/ 0.5 x 'solve' ignora 'keepfloat': (%i3) solve(1.0-x,x), keepfloat; `rat' replaced 1.0 by 1/1 = 1.0 (%o3) [x = 1] -- Función: lopow (, ) Devuelve el menor exponente de que aparece explícitamente en . (%i1) lopow ((x+y)^2 + (x+y)^a, x+y); (%o1) min(a, 2) -- Función: lratsubst (, ) Esta función es similar a 'subst (, )', excepto por el hecho de que utiliza 'ratsubst' en lugar de 'subst'. El primer argumento de 'lratsubst' es una ecuación o lista de ecuaciones idénticas en formato a las aceptadas por 'subst'. Las sustituciones se hacen en el orden dado por la lista de ecuaciones, esto es, de izquierda a derecha. La instrucción 'load ("lrats")' carga 'fullratsubst' y 'lratsubst'. Ejemplos: (%i1) load ("lrats")$ * 'subst' can carry out multiple substitutions. 'lratsubst' is analogous to 'subst'. (%i2) subst ([a = b, c = d], a + c); (%o2) d + b (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); (%o3) (d + a c) e + a d + b c * If only one substitution is desired, then a single equation may be given as first argument. (%i4) lratsubst (a^2 = b, a^3); (%o4) a b -- Variable opcional: modulus Valor por defecto: 'false' Si 'modulus' es un número positivo

, las operaciones con números racionales (como los devueltos por 'rat' y funciones relacionadas) se realizan módulo

, utilizando el llamado sistema de módulo balanceado, en el que ' módulo

' se define como un entero de '[-(

-1)/2, ..., 0, ..., (

-1)/2]' si

es impar, o de '[-(

/2 - 1), ..., 0, ....,

/2]' si

es par, de tal manera que '

+ ' es igual a para algún entero . Normalmente a 'modulus' se le asigna un número primo. Se acepta que a 'modulus' se le asigne un entero positivo no primo, pero se obtendrá un mensaje de aviso. Maxima responderá con un mensaje de error cuando se le asigne a 'modulus' cero o un número negativo. Ejemplos: (%i1) modulus:7; (%o1) 7 (%i2) polymod([0,1,2,3,4,5,6,7]); (%o2) [0, 1, 2, 3, - 3, - 2, - 1, 0] (%i3) modulus:false; (%o3) false (%i4) poly:x^6+x^2+1; 6 2 (%o4) x + x + 1 (%i5) factor(poly); 6 2 (%o5) x + x + 1 (%i6) modulus:13; (%o6) 13 (%i7) factor(poly); 2 4 2 (%o7) (x + 6) (x - 6 x - 2) (%i8) polymod(%); 6 2 (%o8) x + x + 1 -- Función: num () Devuelve el numerador de si se trata de una fracción. Si no es una fracción, se devuelve . La función 'num' evalúa su argumento. -- Función: polydecomp (

, ) Descompone el polinomio

de variable en una composición funcional de polinomios en . La función 'polydecomp' devuelve una lista '[, ..., ]' tal que lambda([x],p_1)(lambda ([x],p_2)(...(lambda([x],p_n)(x))...)) es igual a

. El grado de es mayor que 1 para menor que . Esta descomposición no es única. Ejemplos: (%i1) polydecomp (x^210, x); 7 5 3 2 (%o1) [x , x , x , x ] (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a)); 6 4 3 2 (%o2) x - 2 x - 2 x + x + 2 x - a + 1 (%i3) polydecomp (p, x); 2 3 (%o3) [x - a, x - x - 1] La siguiente función compone 'L = [e_1, ..., e_n]' como funciones de 'x'; se trata de la inversa de 'polydecomp': compose (L, x) := block ([r : x], for e in L do r : subst (e, x, r), r) $ Se vuelve a obtener el resultado del ejemplo de más arriba haciendo uso de 'compose': (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x); 2 3 (%o3) [x - a, x - x - 1] Nótese que aunque 'compose (polydecomp (

, ), )' devuelve siempre

(sin expandir), 'polydecomp (compose ([, ..., ], ), )' no devuelve necesariamente '[, ..., ]': (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x); 2 2 (%o4) [x + 2, x + 1] (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x); 2 2 x + 3 x + 5 (%o5) [------, ------, 2 x + 1] 4 2 -- Función: polymod (

) -- Función: polymod (

, ) Convierte el polinomio

a una representación modular respecto del módulo actual, que es el valor almacenado en la variable 'modulus'. La llamada 'polymod (

, )' especifica un módulo para ser utilizado en lugar de valor almacenado en 'modulus'. Véase 'modulus'. -- Función: powers (, ) Devuelve las potencias de dentro de . La instrucción 'load (powers)' carga esta función. -- Función: quotient (, ) -- Función: quotient (, , , ..., ) Devuelve el polinomio dividido por el polinomio . Los argumentos , ..., se interpretan como en la función 'ratvars'. La función 'quotient' devuelve el primer elemento de la lista devuelta por 'divide'. -- Función: rat () -- Función: rat (, , ..., ) Convierte al formato canónico racional (canonical rational expression o CRE) expandiendo y combinando todos los términos sobre un denominador común y cancelando el máximo común divisor del numerador y denominador, así como convirtiendo números decimales en coma flotante a números racionales dentro de la tolerancia indicada por 'ratepsilon'. Las variables se ordenan de acuerdo a , ..., si se han especificado, como en la función 'ratvars'. En general, 'rat' no simplifica otras funciones que no sean la suma '+', resta '-', multiplicación '*', división '/' y exponenciación de exponente entero, mientras que 'ratsimp' sí lo hace. Nótese que los átomos (números y variables) en expresiones en formato CRE no son los mismos que en el formato general. Por ejemplo, 'rat(x)- x' devuelve 'rat(0)', que tiene una representación interna diferente de 0. Si 'ratprint' vale 'false' no aparecerán mensajes informando al usuario sobre la conversión de números decimales en coma flotante a números racionales. Si 'keepfloat' vale 'true' no se convertirán números decimales en coma flotante a números racionales. Véanse también 'ratexpand' y 'ratsimp'. Ejemplos: (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) / (4*y^2 + x^2); 4 (x - 2 y) (y + a) (2 y + x) (------------ + 1) 2 2 2 (x - 4 y ) (%o1) ------------------------------------ 2 2 4 y + x (%i2) rat (%, y, a, x); 2 a + 2 y (%o2)/R/ --------- x + 2 y -- Variable opcional: ratalgdenom Valor por defecto: 'true' Si 'ratalgdenom' vale 'true', se permite la racionalización de denominadores eliminando radicales. La variable 'ratalgdenom' sólo tiene efecto cuando expresiones en formato canónico (CRE) están siendo utilizadas en modo algebraico. -- Función: ratcoef (, , ) -- Función: ratcoef (, ) Devuelve el coeficiente de la expresión '^' dentro de la expresión . Si se omite, se considera igual a 1. El valor devuelto está libre de las variables en , excepto quizás en un sentido no racional. Si no existe un coeficiente de este tipo se devuelve 0. La función 'ratcoef' expande y simplifica racionalmente su primer argumento, por lo que puede dar una respuesta diferente a la dada por la función 'coeff', la cual tiene un carácter puramente sintáctico. Así, 'ratcoef ((x + 1)/y + x, x)' devuelve '(y + 1)/y', mientras que 'coeff' devuelve 1. La llamada 'ratcoef (, , 0)', siendo una suma, devuelve una suma formada por los términos que no contienen . Puesto que se simplifica racionalmente antes de ser examinada, algunos coeficientes puede que no aparezcan como en la expresión original. Ejemplo: (%i1) s: a*x + b*x + 5$ (%i2) ratcoef (s, a + b); (%o2) x -- Función: ratdenom () Devuelve el denominador de , después de transformar al formato canónico (CRE). El valor retornado está también en formato CRE. El argumento se transforma al formato CRE por la función 'rat', a menos que ya esté en este formato. Esta conversión puede cambiar la forma de colocando todos sus términos sobre un denominador común. La función 'denom' es parecida, pero devuelve una expresión general en lugar de una CRE. Tampoco 'denom' intenta colocar todos sus términos sobre un denominador común, de manera que algunas expresiones que son consideradas como divisiones por 'ratdenom', no son tales para 'denom'. -- Variable opcional: ratdenomdivide Valor por defecto: 'true' Si 'ratdenomdivide' vale 'true', la función 'ratexpand' expande una fracción en la que el numerador es una suma en una suma de divisiones. En otro caso, 'ratexpand' reduce una suma de divisiones a una única fracción, cuyo numerador es la suma de los denominadores de cada fracción. Ejemplos: (%i1) expr: (x^2 + x + 1)/(y^2 + 7); 2 x + x + 1 (%o1) ---------- 2 y + 7 (%i2) ratdenomdivide: true$ (%i3) ratexpand (expr); 2 x x 1 (%o3) ------ + ------ + ------ 2 2 2 y + 7 y + 7 y + 7 (%i4) ratdenomdivide: false$ (%i5) ratexpand (expr); 2 x + x + 1 (%o5) ---------- 2 y + 7 (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3); 2 b a (%o6) ------ + ------ 2 2 b + 3 b + 3 (%i7) ratexpand (expr2); 2 b + a (%o7) ------ 2 b + 3 -- Función: ratdiff (, ) Deriva la expresión racional con respecto a . El argumento debe ser una fracción algebraica o un polinomio en . El argumento puede ser una variable o una subexpresión de . El resultado equivale al devuelto por 'diff', aunque es posible que se obtenga en una forma diferente. La función 'ratdiff' puede ser más rápida que 'diff' en expresiones racionales. La función 'ratdiff' devuelve una expresión en formato canónico o CRE si 'expr' es también una expresión CRE. En otro caso, 'ratdiff' devuelve una expresión general. La función 'ratdiff' considera únicamente la dependencia de respecto de , ignorando cualquier dependencia establecida por 'depends'. Ejemplo: (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5); 3 4 x + 10 x - 11 (%o1) ---------------- 5 x + 5 (%i2) ratdiff (expr, x); 7 5 4 2 8 x + 40 x - 55 x - 60 x - 50 (%o2) - --------------------------------- 10 5 x + 10 x + 25 (%i3) expr: f(x)^3 - f(x)^2 + 7; 3 2 (%o3) f (x) - f (x) + 7 (%i4) ratdiff (expr, f(x)); 2 (%o4) 3 f (x) - 2 f(x) (%i5) expr: (a + b)^3 + (a + b)^2; 3 2 (%o5) (b + a) + (b + a) (%i6) ratdiff (expr, a + b); 2 2 (%o6) 3 b + (6 a + 2) b + 3 a + 2 a -- Función: ratdisrep () Devuelve su argumento como una expresión general. Si es una expresión general, se devuelve sin cambios. Normalmente se invoca a 'ratdisrep' a fin de convertir una expresión en formato canónico (CRE) al formato general, lo que puede ser utilizado si se quiere parar el contagio que produce el formato CRE, o para utilizar funciones racionales en contextos no racionales. Véase también 'totaldisrep'. -- Función: ratexpand () -- Variable opcional: ratexpand Expande multiplicando productos de sumas y sumas con exponentes, combinando fracciones con común denominador, cancelando el máximo común divisor del numerador y del denominador y luego dividiendo los sumandos del numerador por el denominador. El valor que devuelve 'ratexpand' es una expresión general, incluso cuando está en formato canónico o CRE. Si la variable 'ratexpand' vale 'true' hará que las expresiones CRE se expandan completamente cuando se conviertan al formato general o se muestren en el terminal, mientras que si vale 'false' se mostrarán de forma recursiva. Véase también 'ratsimp'. Si 'ratdenomdivide' vale 'true', 'ratexpand' expande una fracción en la que el numerador es una suma en una suma de fracciones, todas ellas con denominador común. En otro caso, 'ratexpand' reduce una suma de fracciones en una única fracción, cuyo numerador es la suma de los numeradores de cada fracción. Si 'keepfloat' vale 'true', los números decimales en coma flotante no se racionalizan cuando las expresiones que los contienen se convierten al formato canónico racional (CRE). Ejemplos: (%i1) ratexpand ((2*x - 3*y)^3); 3 2 2 3 (%o1) - 27 y + 54 x y - 36 x y + 8 x (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1); x - 1 1 (%o2) -------- + ----- 2 x - 1 (x + 1) (%i3) expand (expr); x 1 1 (%o3) ------------ - ------------ + ----- 2 2 x - 1 x + 2 x + 1 x + 2 x + 1 (%i4) ratexpand (expr); 2 2 x 2 (%o4) --------------- + --------------- 3 2 3 2 x + x - x - 1 x + x - x - 1 -- Variable opcional: ratfac Valor por defecto: 'false' Si 'ratfac' vale 'true', las expresiones canónicas (CRE) se manipulan en una forma parcialmente factorizada. Durante las operaciones racionales, las expresiones se mantienen completamente factorizadas tanto como sea posible sin llamar a 'factor'. Esto debería ahorrar espacio y tiempo en algunos cálculos. El numerador y denominador se hacen primos relativos, por ejemplo 'rat ((x^2 - 1)^4/(x + 1)^2)' devuelve '(x - 1)^4 (x + 1)^2)', pero los factores dentro de cada parte pueden no ser primos relativos. En el paquete 'ctensr' sobre manipulación de tensores por componentes, los tensores de Ricci, Einstein, Riemann y Weyl y la curvatura escalar se factorizan automáticamente si 'ratfac' vale 'true'; 'ratfac' debe activarse únicamente en aquellos casos en los que se sabe que el número de términos de las componentes tensoriales es pequño. Nota: Los esquemas de comportamiento basados en 'ratfac' y 'ratweight' son incompatibles y no se debe pretender usarlos al mismo tiempo. -- Función: ratnumer () Devuelve el numerador de , después de reducir a su forma canónica (CRE). El valor retornado está también en formato CRE. El argumento se transforma al formato CRE por la función 'rat', a menos que ya esté en este formato. Esta conversión puede cambiar la forma de colocando todos sus términos sobre un denominador común. Es parecida a la función 'num', pero devuelve una expresión general en lugar de una CRE. Además, 'num' no intenta colocar todos los términos sobre un denominador común, de manera que algunas expresiones que son consideradas fracciones por 'ratnumer' no se consideran como tales por 'num'. -- Función: ratp () Devuelve 'true' si es una expresión canónica racional (canonical rational expression o CRE) o una CRE extendida, en caso contrario devuelve 'false'. Las expresiones CRE son creadas por 'rat' y funciones asociadas. Las CRE extendidas son creadas por 'taylor' y funciones asociadas. -- Variable opcional: ratprint Valor por defecto: 'true' Si 'ratprint' vale 'true', se muestra al usuario un mensaje dando cuenta de la conversión de números decimales en coma flotante a formato racional. -- Función: ratsimp () -- Función: ratsimp (, , ..., ) Simplifica la expresión y todas sus subexpresiones, incluyendo los argumentos de funciones no racionales. El resultado es un cociente de dos polinomios en una forma recursiva, esto es, los coeficientes de la variable principal son polinomios respecto de las otras variables. Las variables pueden incluir funciones no racionales, como 'sin (x^2 + 1)', y los argumentos de tales funciones son también racionalmente simplificados. La llamada 'ratsimp (, , ..., )' permite la simplificación racional con la especificación del orden de las variables, como en 'ratvars'. Si 'ratsimpexpons' vale 'true', 'ratsimp' se aplica a los exponentes de las expresiones durante la simplificación. Véase también 'ratexpand'. Nótese que 'ratsimp' se ve afectada por algunas de las variables globales que controlan a 'ratexpand'. Ejemplos: (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2); 2 2 x (log(x) + 1) - log (x) (%o1) sin(------) = %e 2 x + x (%i2) ratsimp (%); 1 2 (%o2) sin(-----) = %e x x + 1 (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1)); 3/2 (x - 1) - sqrt(x - 1) (x + 1) (%o3) -------------------------------- sqrt((x - 1) (x + 1)) (%i4) ratsimp (%); 2 sqrt(x - 1) (%o4) - ------------- 2 sqrt(x - 1) (%i5) x^(a + 1/a), ratsimpexpons: true; 2 a + 1 ------ a (%o5) x -- Variable opcional: ratsimpexpons Valor por defecto: 'false' Si 'ratsimpexpons' vale 'true', 'ratsimp' se aplica a los exponentes de las expresiones durante la simplificación. -- Variable opcional: radsubstflag Valor por defecto: 'false' Si 'radsubstflag' vale 'true' se permite a 'ratsubst' hacer la sustitución 'u' por 'sqrt (x)' in 'x'. -- Función: ratsubst (, , ) Sustituye por en y devuelve la expresión resultante. El argumento puede ser una suma, un producto, una potencia, etc. La función 'ratsubst' reconoce el significado de las expresiones, mientras que 'subst' tan solo realiza sustituciones sintácticas. Así por ejemplo, 'subst (a, x + y, x + y + z)' devuelve 'x + y + z' cuando 'ratsubst' devuelve 'z + a'. Si 'radsubstflag' vale 'true', 'ratsubst' sustituye radicales en expresiones que no los contienen explícitamente. 'ratsubst' ignora el valor 'true' de la variable opcional 'keepfloat'. Ejemplos: (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8); 3 4 (%o1) a x y + a (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1; 4 3 2 (%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1 (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %); 4 2 2 (%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3 (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4); 4 2 (%o4) cos (x) - 2 cos (x) + 1 (%i5) radsubstflag: false$ (%i6) ratsubst (u, sqrt(x), x); (%o6) x (%i7) radsubstflag: true$ (%i8) ratsubst (u, sqrt(x), x); 2 (%o8) u -- Función: ratvars (, ..., ) -- Función: ratvars () -- Variable del sistema: ratvars Declara como variables principales , ..., en expresiones racionales. Si está presente en una expresión racional, se considerará como variable principal. Si no está presente, entonces se considerará principal a la variable si aparece en la expresión, se continúa así hasta , que se considerará como variable principal sólo si ninguna de las variables que le siguen está presente en la expresión. Si una variable de la expresión racional no está presente en la lista 'ratvars', se le dará una prioridad inferior a la de . Los argumentos de 'ratvars' pueden ser tanto variables como funciones no racionales como 'sin(x)'. La variable 'ratvars' es una lista que contiene los argumentos pasados a la función 'ratvars' la última vez que fue invocada. Cada llamada a la función 'ratvars' reinicializa la lista. La llamada 'ratvars ()' vacía la lista. -- Variable opcional: ratvarswitch Valor por defecto: 'true' Maxima almacena una lista interna en la variable Lisp 'VARLIST' cuyo contenido son las variables principales de las expresiones racionales. Cuando 'ratvarswitch' vale 'true', su valor por defecto, cada evaluación comienza con la lista 'VARLIST' vacía. En caso contrario, las variables principales de las expresiones anteriores se mantienen en la lista 'VARLIST'. Las variables principales declaradas con la función 'ratvars' no se ven afectadas por la opción 'ratvarswitch'. Ejemplos: Cuando 'ratvarswitch' vale 'true', su valor por defecto, cada evaluación comienza con la lista 'VARLIST' vacía. (%i1) ratvarswitch:true$ (%i2) rat(2*x+y^2); 2 (%o2)/R/ y + 2 x (%i3) :lisp varlist ($X $Y) (%i3) rat(2*a+b^2); 2 (%o3)/R/ b + 2 a (%i4) :lisp varlist ($A $B) Cuando 'ratvarswitch' vale 'false', las variables principales de las expresiones anteriores se mantienen en lista 'VARLIST'. (%i4) ratvarswitch:false$ (%i5) rat(2*x+y^2); 2 (%o5)/R/ y + 2 x (%i6) :lisp varlist ($X $Y) (%i6) rat(2*a+b^2); 2 (%o6)/R/ b + 2 a (%i7) :lisp varlist ($A $B $X $Y) -- Función: ratweight (, , ..., , ) -- Función: ratweight () Asigna un peso a la variable . Un término será reemplazado por 0 si su peso excede el valor de la variable 'ratwtlvl' (por defecto no se realiza el truncamiento). El peso de un término es la suma de los productos de los pesos de las variables que lo forman multiplicados por sus exponentes. Por ejemplo, el peso de '3 x_1^2 x_2' es '2 w_1 + w_2'. El truncamiento basado en 'ratwtlvl' solamente se lleva a cabo cuando se multiplican o se elevan a potencias expresiones canónicas (CRE). La llamada 'ratweight ()' devuelve la lista acumulada de asignaciones de pesos. Nota: Los esquemas de comportamiento basados en 'ratfac' y 'ratweight' son incompatibles y no se debe pretender usarlos al mismo tiempo. Ejemplos: (%i1) ratweight (a, 1, b, 1); (%o1) [a, 1, b, 1] (%i2) expr1: rat(a + b + 1)$ (%i3) expr1^2; 2 2 (%o3)/R/ b + (2 a + 2) b + a + 2 a + 1 (%i4) ratwtlvl: 1$ (%i5) expr1^2; (%o5)/R/ 2 b + 2 a + 1 -- Variable del sistema: ratweights Valor por defecto: '[]' La variable 'ratweights' es una lista que contiene los pesos asignados por 'ratweight'. Las lista es acumulativa, en el sentido de que cada llamada a 'ratweight' añade nuevos elementos a la lista. -- Variable opcional: ratwtlvl Valor por defecto: 'false' La variable 'ratwtlvl' se utiliza en combinación con la función 'ratweight' para controlar el truncamiento de expresiones racionales canónicas (CRE). Con el valor por defecto, 'false', no se produce truncamiento alguno. -- Función: remainder (, ) -- Función: remainder (, , , ..., ) Devuelve el resto de la división del polinomio entre . Los argumentos , ..., se interpretan como en 'ratvars'. La función 'remainder' devuelve el segundo elemento de la lista retornada por 'divide'. -- Función: resultant (, , ) Calcula la resultante de los dos polinomios y , eliminando la variable . La resultante es un determinante de los coeficientes de en y , que es igual a cero si sólo si y tienen un factor común no constante. Si o pueden ser factorizados, puede ser necesario llamar a 'factor' antes que invocar a 'resultant'. La variable opcional 'resultant' controla qué algoritmo será utilizado para calcular la resultante. Véanse 'option_resultant' y 'resultant'. La función 'bezout' toma los mismos argumentos que 'resultant' y devuelve una matriz. El determinante del valor retornado es la resultante buscada. Ejemplos: (%i1) resultant(2*x^2+3*x+1, 2*x^2+x+1, x); (%o1) 8 (%i2) resultant(x+1, x+1, x); (%o2) 0 (%i3) resultant((x+1)*x, (x+1), x); (%o3) 0 (%i4) resultant(a*x^2+b*x+1, c*x + 2, x); 2 (%o4) c - 2 b c + 4 a (%i5) bezout(a*x^2+b*x+1, c*x+2, x); [ 2 a 2 b - c ] (%o5) [ ] [ c 2 ] (%i6) determinant(%); (%o6) 4 a - (2 b - c) c -- Variable opcional: resultant Valor por defecto: 'subres' La variable opcional 'resultant' controla qué algoritmo será utilizado para calcular la resultante con la función 'resultant'. Los valores posibles son: 'subres' para el algoritmo PRS (polynomial remainder sequence) subresultante, 'mod' para el algoritmo resultante modular y 'red' para el algoritmo PRS (polynomial remainder sequence) reducido. En la mayor parte de problemas, el valor por defecto, 'subres', es el más apropiado. Pero en el caso de problemas bivariantes o univariantes de grado alto, puede ser mejor utilizar 'mod'. -- Variable opcional: savefactors Valor por defecto: 'false' Si 'savefactors' vale 'true', los factores de una expresión producto se almacenan por ciertas funciones a fin de acelerar posteriores factorizaciones de expresiones que contengan algunos de estos factores. -- Función: showratvars () Devuelve una lista de las variables de expresiones canónicas racionales (CRE) en la expresión 'expr'. Véase también 'ratvars'. -- Función: tellrat (, ..., ) -- Función: tellrat () Añade al anillo de enteros algebraicos conocidos por Maxima los elementos que son soluciones de los polinomios , ..., . Cada argumento es un polinomio de coeficientes enteros. La llamada 'tellrat ()' hace que se sustituya 0 por en las funciones racionales. La llamada 'tellrat ()' devuelve una lista con las sustituciones actuales. A la variable 'algebraic' se le debe asignar el valor 'true' a fin de poder realizar la simplificación de enteros algebraicos. Maxima reconoce la unidad imaginaria '%i' y todas las raíces de los enteros. La instrucción 'untellrat' borra todas las propiedades de 'tellrat'. Es ambiguo aplicar 'tellrat' a un polinomio multivariante tal como 'tellrat (x^2 - y^2)', pues no se sabe si sustituir '^2' por '^2' o al revés. Maxima sigue un cierto orden, pero si el usuario quiere especificar uno en concreto, puede hacerlo mediante la sintaxis 'tellrat (y^2 = x^2)', que indica que se ponga '^2' en lugar de '^2'. Ejemplos: (%i1) 10*(%i + 1)/(%i + 3^(1/3)); 10 (%i + 1) (%o1) ----------- 1/3 %i + 3 (%i2) ev (ratdisrep (rat(%)), algebraic); 2/3 1/3 2/3 1/3 (%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2 (%i3) tellrat (1 + a + a^2); 2 (%o3) [a + a + 1] (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2)); 1 a (%o4) ------------- + ----------------- sqrt(2) a - 1 sqrt(3) + sqrt(2) (%i5) ev (ratdisrep (rat(%)), algebraic); (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1 (%o5) ---------------------------------------------- 7 (%i6) tellrat (y^2 = x^2); 2 2 2 (%o6) [y - x , a + a + 1] -- Función: totaldisrep () Convierte cada subexpresión de del formato canónico (CRE) al general y devuelve el resultado. Si está en formato CRE entonces 'totaldisrep' es idéntico a 'ratdisrep'. La función 'totaldisrep' puede ser útil para modificar expresiones como las ecuaciones, listas, matrices, etc., que tienen algunas subexpresiones en formato CRE. -- Función: untellrat (, ..., ) Elimina de , ..., las propiedades relacionadas con 'tellrat'.  File: maxima.info, Node: Funciones Especiales, Next: Funciones elípticas, Prev: Polinomios, Up: Top 15 Funciones Especiales *********************** * Menu: * Introducción a las funciones especiales:: * Funciones de Bessel:: * Funciones de Airy:: * Funciones Gamma y factorial:: * Integral exponencial:: * Función de error:: * Funciones de Struve:: * Funciones hipergeométricas:: * Funciones de cilindro parabólico:: * Funciones y variables para las funciones especiales::  File: maxima.info, Node: Introducción a las funciones especiales, Next: Funciones de Bessel, Prev: Funciones Especiales, Up: Funciones Especiales 15.1 Introducción a las funciones especiales ============================================ A continuación se especifican las notaciones correspondientes a las funciones especiales: bessel_j (index, expr) Función de Bessel de primera especie bessel_y (index, expr) Función de Bessel de segunda especie bessel_i (index, expr) Función de Bessel modificada de primera especie bessel_k (index, expr) Función de Bessel modificada de segunda especie hankel_1 (v,z) Función de Hankel de primera especie hankel_2 (v,z) Función de Hankel de segunda especie struve_h (v,z) Función H de Struve struve_l (v,z) Función L de Struve %p[u,v] (z) Función de Legendre de primera especie %q[u,v] (z) Función de Legendre de segunda especie %f[p,q] ([], [], expr) Función hipergeométrica generalizada gamma(z) Función Gamma gamma_incomplete_lower(a,z) Función Gamma incompleta inferior gamma_incomplete (a,z) Extremo de la función Gamma incompleta hypergeometric(l1, l2, z) Función hipergeométrica slommel %m[u,k] (z) Función de Whittaker de primera especie %w[u,k] (z) Función de Whittaker de segunda especie erfc (z) Complemento de la función de error, erf expintegral_e (v,z) Integral exponencial E expintegral_e1 (z) Integral exponencial E1 expintegral_ei (z) Integral exponencial Ei expintegral_li (z) Integral logarítmica Li expintegral_si (z) Integral exponencial Si expintegral_ci (z) Integral exponencial Ci expintegral_shi (z) Integral exponencial Shi expintegral_chi (z) Integral exponencial Chi kelliptic (z) Integral elíptica completa de primera especie (K) parabolic_cylinder_d(v,z) Función D de cilindro parabólico  File: maxima.info, Node: Funciones de Bessel, Next: Funciones de Airy, Prev: Introducción a las funciones especiales, Up: Funciones Especiales 15.2 Funciones de Bessel ======================== -- Función: bessel_j (, ) Función de Bessel de primera especie de orden v y argumento z. La función 'bessel_j' se define como inf ==== k - v - 2 k v + 2 k \ (- 1) 2 z > -------------------------- / k! gamma(v + k + 1) ==== k = 0 aunque la serie infinita no se utiliza en los cálculos. -- Función: bessel_y (, ) Función de Bessel de segunda especie de orden v y argumento z. La función 'bessel_y' se define como cos(%pi v) bessel_j(v, z) - bessel_j(-v, z) ------------------------------------------- sin(%pi v) si v no es un entero. En caso de que v sea un entero n, se calcula el límite cuando v se aproxima a n. -- Función: bessel_i (, ) Función modificada de Bessel de primera especie de orden v y argumento z. La función 'bessel_i' se define como inf ==== - v - 2 k v + 2 k \ 2 z > ------------------- / k! gamma(v + k + 1) ==== k = 0 aunque la serie infinita no se utiliza en los cálculos. -- Función: bessel_k (, ) Función modificada de Bessel de segunda especie de orden v y argumento z. La función 'bessel_k' se define como %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z)) ------------------------------------------------- 2 si v no es un entero. Si v es igual al entero n, entonces se calcula el límite cuando v tiende a n. -- Función: hankel_1 (, ) Función de Hankel de primera especie de orden v y argumento z (A&S 9.1.3). La función 'hankel_1' se define como bessel_j(v,z) + %i * bessel_y(v,z) Maxima evalúa 'hankel_1' numéricamente para el orden real v y el argumento complejo z en doble precisión (float). La evaluación numérica en gran precisión (bigfloat) y para órdenes complejos no está implementada. Si 'besselexpand' vale 'true', 'hankel_1' se expande en términos de funciones elementales cuando el orden v es la mitad de un entero impar. Véase al respecto 'besselexpand'. Maxima reconoce la derivada de 'hankel_1' con respecto del argumento z. Ejemplos: Evaluación numérica: (%i1) hankel_1(1,0.5); (%o1) .2422684576748738 - 1.471472392670243 %i (%i2) hankel_1(1,0.5+%i); (%o2) - .2558287994862166 %i - 0.239575601883016 No se soportan órdenes complejos. Maxima devuelve una forma nominal: (%i3) hankel_1(%i,0.5+%i); (%o3) hankel_1(%i, %i + 0.5) Expansión de 'hankel_1' cuando 'besselexpand' vale 'true': (%i4) hankel_1(1/2,z),besselexpand:true; sqrt(2) sin(z) - sqrt(2) %i cos(z) (%o4) ---------------------------------- sqrt(%pi) sqrt(z) Derivada de 'hankel_1' respecto del argumento z. No está soportada la derivada respecto del orden v. Maxima devuelve una forma nominal: (%i5) diff(hankel_1(v,z),z); hankel_1(v - 1, z) - hankel_1(v + 1, z) (%o5) --------------------------------------- 2 (%i6) diff(hankel_1(v,z),v); d (%o6) -- (hankel_1(v, z)) dv -- Función: hankel_2 (, ) Función de Hankel de segunda especie de orden v y argumento z (A&S 9.1.4). La función 'hankel_2' se define como bessel_j(v,z) - %i * bessel_y(v,z) Maxima evalúa 'hankel_2' numéricamente para el orden real v y el argumento complejo z en doble precisión (float). La evaluación numérica en gran precisión (bigfloat) y para órdenes complejos no está implementada. Si 'besselexpand' vale 'true', 'hankel_2' se expande en términos de funciones elementales cuando el orden v es la mitad de un entero impar. Véase al respecto 'besselexpand'. Maxima reconoce la derivada de 'hankel_2' con respecto del argumento z. Véanse ejemplos en 'hankel_1'. -- Variable optativa: besselexpand Valor por defecto: 'false' Controla la expansión de las funciones de Bessel cuando el orden es la mitad de un entero impar. En tal caso, las funciones de Bessel se pueden expandir en términos de otras funciones elementales. Si 'besselexpand' vale 'true', se expande la función de Bessel. (%i1) besselexpand: false$ (%i2) bessel_j (3/2, z); 3 (%o2) bessel_j(-, z) 2 (%i3) besselexpand: true$ (%i4) bessel_j (3/2, z); sin(z) cos(z) sqrt(2) sqrt(z) (------ - ------) 2 z z (%o4) --------------------------------- sqrt(%pi) -- Función: scaled_bessel_i (, ) Es la función de Bessel modificada de primera especie de orden v y argumento z, es decir scaled_bessel_i(v,z) = exp(-abs(z))*bessel_i(v, z). Esta función es especialmente útil para calcular bessel_i cuando z es grande. Sin embargo, Maxima no sabe mucho más sobre esta función. En cálculos simbólicos, quizás sea preferible trabajar directamente con la expresión 'exp(-abs(z))*bessel_i(v, z)'. -- Función: scaled_bessel_i0 () Idéntica a 'scaled_bessel_i(0,z)'. -- Función: scaled_bessel_i1 () Idéntica a 'scaled_bessel_i(1,z)'. -- Función: %s [,] () Función s[u,v](z) de Lommel. Gradshteyn & Ryzhik 8.570.1.