This is maxima.info, produced by makeinfo version 4.7 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: Funciones y variables para lectura y escritura, Prev: Archivos, Up: Lectura y escritura 9.3 Funciones y variables para lectura y escritura ================================================== -- Variable del sistema: __ `__' es la expresión de entrada que está siendo actualmente evaluada. Esto es, mientras se está evaluando una expresión de entrada, `__' es igual a . A `__' se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de `__' es simplificado, pero no evaluado, cuando su valor es mostrado en el terminal. La variable `__' es reconocida por `batch' y por `load'. Cuando un fichero es procesado por `batch', la variable `__' tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load', a la variable `__' se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `__' una expresión de entrada del fichero que está siendo procesado. En particular, si `load ()' es ejecutado desde el modo interactivo, entonces `__' almacena la expresión `load ()' mientras el fichero está siendo procesado. Véanse también `_' y `%'. Ejemplos: (%i1) print ("I was called as", __); I was called as print(I was called as, __) (%o1) print(I was called as, __) (%i2) foo (__); (%o2) foo(foo(__)) (%i3) g (x) := (print ("Current input expression =", __), 0); (%o3) g(x) := (print("Current input expression =", __), 0) (%i4) [aa : 1, bb : 2, cc : 3]; (%o4) [1, 2, 3] (%i5) (aa + bb + cc)/(dd + ee + g(x)); cc + bb + aa Current input expression = -------------- g(x) + ee + dd 6 (%o5) ------- ee + dd -- Variable del sistema: _ El símbolo `_' representa la última expresión de entrada (esto es, `%i1', `%i2', `%i3', ...). Al símbolo `_' se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de `_' se simplifica (pero no se evalúa) cuando se muestra en el terminal. La variable `_' es reconocida por `batch' y por `load'. Cuando un fichero es procesado por `batch', la variable `_' tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load', a la variable `_' se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `_' una expresión de entrada del fichero que está siendo procesado. Véanse también `__' y `%'. Ejemplos: (%i1) 13 + 29; (%o1) 42 (%i2) :lisp $_ ((MPLUS) 13 29) (%i2) _; (%o2) 42 (%i3) sin (%pi/2); (%o3) 1 (%i4) :lisp $_ ((%SIN) ((MQUOTIENT) $%PI 2)) (%i4) _; (%o4) 1 (%i5) a: 13$ (%i6) b: 29$ (%i7) a + b; (%o7) 42 (%i8) :lisp $_ ((MPLUS) $A $B) (%i8) _; (%o8) b + a (%i9) a + b; (%o9) 42 (%i10) ev (_); (%o10) 42 -- Variable del sistema: % El símbolo `%' representa la expresión de salida (esto es, `%o1', `%o2', `%o3', ...) más reciente calculada por Maxima, independientemente de que la haya mostrado o no. La variable `%' es reconocida por `batch' y por `load'. Cuando un fichero es procesado por `batch', la variable `%' tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load', a la variable `%' se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `%' una expresión de entrada del fichero que está siendo procesado. Véanse también `_', `%%' y `%th'. -- Variable del sistema: %% En una sentencia compuesta, como `block', `lambda' o `(, ..., )', `%%' es el valor de la sentencia previa. Por ejemplo, block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1)); block ([prev], prev: integrate (x^5, x), ev (prev, x=2) - ev (prev, x=1)); devuelven el mismo resultado `21/2'. Una sentencia compuesta puede contener otras sentencias compuestas. Independientemente de que una sentencia sea simple o compuesta, `%%' es el valor de la sentencia previa. Por ejemplo, block (block (a^n, %%*42), %%/6) devuelve `7*a^n'. Dentro de una sentencia compuesta, el valor de `%%' puede inspeccionarse en un punto de interrupción que se abra ejecutando la función `break'. Por ejemplo, en el punto de interrupción abierto por block (a: 42, break ())$ introduciendo `%%;' se obtiene `42'. En la primera sentencia de una sentencia compuesta, o fuera de una sentencia compuesta, `%%' no está definido. La variable `%%' es reconocida por `batch' y por `load'. Cuando un fichero es procesado por `batch', la variable `%%' tiene el mismo significado que en el modo interactivo. Véase también `%'. -- Variable opcional: %edispflag Valor por defecto: `false' Si `%edispflag' vale `true', Maxima muestra `%e' elevado a un exponente negativo como un cociente. Por ejemplo, `%e^-x' se muestra como `1/%e^x'. -- Función: %th () Es el valor de la expresión de la -ésima salida anterior. Esto es, si la siguiente expresión a calcular es la salida -ésima, `%th ()' es la salida ( - )-ésima. La función `%th' es útil en archivos tipo `batch' o para hacer referencia a un grupo de expresiones de salida. Por ejemplo, block (s: 0, for i:1 thru 10 do s: s + %th (i))$ asigna a `s' la suma de las diez últimas expresiones de salida. La variable `%th' es reconocida por `batch' y por `load'. Cuando un fichero es procesado por `batch', la variable `%th' tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load', a la variable `%th' se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `%th' una expresión de entrada del fichero que está siendo procesado. Véase también `%'. -- Símbolo especial: ? Como prefijo de una función o nombre de variable, `?' significa que el nombre es de Lisp, no de Maxima. Por ejemplo, `?round' representa la función de Lisp `ROUND'. Véase `Lisp y Maxima' para más información. La notación `? word' (un símbolo de interrogación seguido de una palabra y separados por un espacio) equivale a `describe ("word")'. El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación. -- Símbolo especial: ?? La notación `?? palabra' (`??' seguido de un espacio y una palabra) equivale a `describe("palabra", inexact)'. El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación. -- Variable opcional: absboxchar Valor por defecto: `!' La variable `absboxchar' es el carácter utilizado para representar el valor absoluto de una expresión que ocupa más de una línea de altura. -- Variable opcional: file_output_append Valor por defecto: `false' La variable `file_output_append' controla si las funciones de escritura de ficheros añaden información o sustituyen el fichero de salida. Cuando `file_output_append' toma el valor `true', estas funciones amplían el contenido de sus ficheros de salida; en otro caso, sustituyen el fichero anterior de igual nombre por otro con el nuevo contenido. Las funciones `save', `stringout' y `with_stdout' se ven afectadas por el valor que tome la variable `file_output_append'. Otras funciones que también escriben en ficheros de salida no tienen en cuenta este valor; en concreto, las funciones para la representación de gráficos y las de traducción siempre sustituyen el fichero anterior por uno nuevo de igual nombre, mientras que las funciones `tex' y `appendfile' siempre añaden información al fichero de salida sin eliminar la información anterior. -- Función: appendfile () Añade información de la consola a , de igual manera que lo hace `writefile', pero con la salvedad de que si el archivo ya existe la información queda añadida al final de su contenido. La función `closefile' cierra los archivos abiertos por `appendfile' o `writefile'. -- Función: batch () Lee expresiones de Maxima desde y las evalúa. La función `batch' busca en la lista `file_search_maxima'. Véase `file_search'. El contenido de debe ser una secuencia de expresiones de Maxima, cada una de las cuales termina en `;' o `$'. La variable especial `%' y la función `%th' se refieren a resultados previos dentro del archivo. El archivo puede incluir construcciones del tipo `:lisp'. Espacios, tabulaciones y saltos de línea en el archivo se ignoran. Un archivo de entrada válido puede crearse con un editor de texto o con la función `stringout'. La función `batch' lee las expresiones del archivo , muestra las entradas en la consola, realiza los cálculos solicitados y muestra las expresiones de los resultados. A las expresiones de entrada se les asignan etiquetas, así como a las de salida. La función `batch' evalúa todas las expresiones de entrada del archivo a menos que se produzca un error. Si se le solicita información al usuario (con `asksign' o `askinteger', por ejemplo) `batch' se detiene para leer la nueva información para luego continuar. Es posible detener `batch' tecleando `control-C' desde la consola. El efecto de `control-C' depende del entorno Lisp instalado. La función `batch' tiene diversas aplicaciones, tales como servir de almacén de líneas de instrucciones, suministrar demostraciones libres de errores o ayudar a organizar el trabajo del usuario en la resolución de problemas complejos. La función `batch' evalúa su argumento. Véanse también `load', `batchload' y `demo'. -- Función: batchload () Lee expresiones de Maxima desde y las evalúa sin mostrar las entradas ni las salidas y sin asignarles etiquetas. Sin embargo, las salidas producidas por `print' o `describe' sí se muestran. La variable especial `%' y la función `%th' se refieren a resultados previos del intérprete interactivo, no a los del propio archivo. El archivo no puede incluir construcciones del tipo `:lisp'. La función `batchload' devuelve la ruta de en formato de cadena. La función `batchload' evalúa sus argumentos. Véanse también `batch' y `load'. -- Función: closefile () La función `closefile' cierra los archivos abiertos por `appendfile' o `writefile'. -- Función: concat (, , ...) Concatena sus argumentos, que deben ser todos átomos. El valor devuelto es un símbolo si el primer argumento es a su vez un símbolo, o una cadena de Maxima en caso contrario. La función `concat' evalúa sus argumentos. El apátrofo `'' evita la evaluación. (%i1) y: 7$ (%i2) z: 88$ (%i3) concat (y, z/2); (%o3) 744 (%i4) concat ('y, z/2); (%o4) y44 A un símbolo construido por `concat' se le puede asignar un valor y ser utilizado posteriormente en expresiones. La asignación con el operador `::' evalúa su expresión izquierda. (%i5) a: concat ('y, z/2); (%o5) y44 (%i6) a:: 123; (%o6) 123 (%i7) y44; (%o7) 123 (%i8) b^a; y44 (%o8) b (%i9) %, numer; 123 (%o9) b Nótese que aunque `concat (1, 2)' parezca un número, se trata de una cadena de Maxima. (%i10) concat (1, 2) + 3; (%o10) 12 + 3 -- Función: sconcat (, , ...) Concatena sus argumentos para producir una cadena. Al contrario que `concat', sus argumentos no necesitan ser átomos. El resultado es una cadena de Lisp. (%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3)); (%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3 -- Función: disp (, , ...) Es como `display' pero sólo se muestran los valores de los argumentos, no las ecuaciones. Es útil para argumentos complicados que no tienen nombre o en situaciones en las que solamente es de interés el valor del argumento pero no su nombre. -- Función: dispcon (, , ...) -- Función: dispcon (all) Muestra las propiedades contractivas de sus argumentos tal como fueron asignadas por `defcon'. La llamada `dispcon (all)' muestra todas propiedades contractivas que fueron definidas. -- Función: display (, , ...) Muestra las ecuaciones cuyos miembros izquierdos son sin evaluar y cuyos miembros derechos son los valores de las expresiones. Esta función es útil en los bloques y en las sentencias `for' para mostrar resultados intermedios. Los argumentos de `display' suelen ser átomos, variables subindicadas o llamadas a funciones. Véase también `disp'. (%i1) display(B[1,2]); 2 B = X - X 1, 2 (%o1) done -- Variable opcional: display2d Valor por defecto: `true' Si `display2d' vale `false', la salida por consola es una cadena unidimensional, en lugar de una expresión bidimensional. -- Variable opcional: display_format_internal Valor por defecto: `false' Si `display_format_internal' vale `true', las expresiones se muestran sin ser transformadas de manera que oculten su representación matemática interna. Se representa lo que la función `inpart' devolvería, en oposición a `part'. Ejemplos: User part inpart a-b; A - B A + (- 1) B A - 1 a/b; - A B B 1/2 sqrt(x); sqrt(X) X 4 X 4 X*4/3; --- - X 3 3 -- Función: dispterms () Muestra en partes, una debajo de la otra. Esto es, primero se muestra el operador de , luego cada término si se trata de una suma, o cada factor si es un producto, o si no se muestra separadamente la parte de una expresión más general. Es útil si es demasiado grande para representarla de otra forma. Por ejemplo, si `P1', `P2', ... son expresiones muy grandes, entonces el programa de representación puede superar el espacio de almacenamiento tratando de mostrar `P1 + P2 + ...' todo junto. Sin embargo, `dispterms (P1 + P2 + ...)' muestra `P1', debajo `P2', etc. Cuando una expresión exponencial es demasiado ancha para ser representada como `A^B', si no se utiliza `dispterms', entonces aparecerá como `expt (A, B)' (o como `ncexpt (A, B)', en lugar de `A^^B'). -- Variable opcional: error_size Valor por defecto: 10 La variable `error_size' modifica los mensajes de error de acuerdo con el tamaño de las expresiones que aparecen en él. Si el tamaño de una expresión (tal como lo determina la función Lisp `ERROR-SIZE') es mayor que `error_size', la expresión se reemplaza en el mensaje por un símbolo, asignándole a éste una expresión. Los símbolos se toman de la lista `error_syms'. En caso contrario, si la expresión es menor que `error_size', la expresión se muestra en el propio mensaje. Véanse también `error' y `error_syms'. Ejemplo: El tamaño de `U', tal como lo determina `ERROR-SIZE', es 24. (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$ (%i2) error_size: 20$ (%i3) error ("Example expression is", U); Example expression is errexp1 -- an error. Quitting. To debug this try debugmode(true); (%i4) errexp1; E D C + B + A (%o4) -------------- cos(X - 1) + 1 (%i5) error_size: 30$ (%i6) error ("Example expression is", U); E D C + B + A Example expression is -------------- cos(X - 1) + 1 -- an error. Quitting. To debug this try debugmode(true); -- Variable opcional: error_syms Valor por defecto: `[errexp1, errexp2, errexp3]' En los mensajes de error, las expresiones mayores que `error_size' son reemplazadas por símbolos a los cuales se les asignas estas expresiones. Los símbolos se toman de la lista `error_syms'. La primera expresión que resulte ser demasiado larga se reemplaza por `error_syms[1]', la segunda por `error_syms[2]' y así sucesivamente. Si hay más expresiones largas que elementos en `error_syms', los símbolos se construyen automáticamente, siendo el -ésimo símbolo equivalente a `concat ('errexp, )'. Véanse también `error' y `error_size'. -- Función: expt (, ) Si una expresión exponencial es demasiado ancha para ser mostrada como `^' aparecerá como `expt (, )' (o como `ncexpt (, )' en lugar de `^^'). Las funciones `expt' y `ncexpt' no se reconocen en una entrada. -- Variable opcional: exptdispflag Valor por defecto: `true' Si `exptdispflag' vale `true', Maxima muestra las expresiones con exponentes negativos como cocientes; por ejemplo, `X^(-1)' se muestra como `1/X'. -- Función: filename_merge (, ) Construye una ruta modificada a partir de y . Si la componente final de es de la forma `###.', la componente se reemplaza con `.'. En otro caso, la componente final se reemplaza simplemente por . -- Función: file_search () -- Función: file_search (, ) La función `file_search' busca el archivo y devuelve su ruta como una cadena; si no lo encuentra, `file_search' devuelve `false'. La llamada `file_search ()' busca en los directorios de búsqueda por defecto, que son los especificados por las variables `file_search_maxima', `file_search_lisp' y `file_search_demo'. La función `file_search' analiza primero si el nombre del argumento existe antes de hacerlo coincidir con los comodines de los patrones de búsqueda de archivos. Véase `file_search_maxima' para más información sobre patrones de búsqueda de archivos. El argumento puede ser una ruta con nombre de archivo, o simplemente el nombre del archivo, o, si el directorio de búsqueda de archivo incluye un patrón de búsqueda, es suficiente con el nombre de archivo sin extensión. Por ejemplo, file_search ("/home/wfs/special/zeta.mac"); file_search ("zeta.mac"); file_search ("zeta"); todos buscan el mismo archivo, dando por hecho que el archivo existe y que `/home/wfs/special/###.mac' está en `file_search_maxima'. La llamada `file_search (, )' busca solamente en los directorios especificados por , que es una lista de cadenas. El argumento ignora los directorios de búsqueda por defecto, de manera que si se da la lista de rutas, `file_search' busca solamente en ellas y no en los directorios por defecto. Incluso si hay un único directorio en , debe ser suministrado como una lista de un único elemento. El usuario puede modificar los directorios de búsqueda por defecto; véase para ello See `file_search_maxima'. La función `file_search' es llamada por `load' con los directorios de búsqueda `file_search_maxima' y `file_search_lisp'. -- Variable opcional: file_search_maxima -- Variable opcional: file_search_lisp -- Variable opcional: file_search_demo Estas variables especifican listas de directorios en los que deben buscar la funciones `load', `demo' y algunas otras. Los valores por defecto de estas variables nombran directorios de la instalación de Maxima. El usuario puede modificar estas variables, bien reemplazando los valores por defecto, bien añadiendo nuevos directorios. Por ejemplo, file_search_maxima: ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"]$ reemplaza el valor por defecto de `file_search_maxima', mintras que file_search_maxima: append (file_search_maxima, ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$ añade dos directorios más. Puede ser conveniente colocar una expresión como esta en el archivo `maxima-init.mac', de manera que la ruta de búsqueda de ficheros se asigne automáticamente cada vez que arranca Maxima. Se pueden especificar varias extensiones de archivos y rutas con comodines especiales. La cadena `###' representa el nombre del archivo buscado y una lista separada de comas y encerrada entre llaves, `{foo,bar,baz}' representa múltiples cadenas. Por ejemplo, suponiendo que se busca el nombre `neumann', "/home/{wfs,gcj}/###.{lisp,mac}" se interpreta como `/home/wfs/neumann.lisp', `/home/gcj/neumann.lisp', `/home/wfs/neumann.mac' y `/home/gcj/neumann.mac'. -- Función: file_type () Devuelve una descripción del contenido de basada en la extensión, sin intentar abrir el archivo para inspeccionar su contenido. El valor que la función retorna puede ser cualquiera de los siguientes: `object', `lisp' o `maxima'. Si la extensión comienza por `m' o `d', `file_type' devuelve `maxima'. Si la extensión comienza por `l', `file_type' devuelve `lisp'. En cualquier otro caso, `file_type' devuelve `object'. -- Función: grind () -- Variable opcional: grind La función `grind' imprime en la consola en un formato admisible como entrada para Maxima. La función `grind' devuelve siempre `done'. Cuando es el nombre de una función o macro, `grind' muestra la definición de la función o de la macro en lugar de sólo su nombre. Véase también `string', que devuelve una cadena en lugar de imprimir la salida. La función `grind' intenta imprimir la expresión de forma que sea lago más sencilla de leer que la salida de `string'. Cuando la variable `grind' vale `true', la salida de `string' y `stringout' tienen el mismo formato que la de `grind'; en caso contrario no se formatea la salida de esas funciones. El valor por defecto de la variable `grind' es `false'. La variable `grind' también se puede utilizar como argumento en `playback'. Si `grind' está presente, `playback' imprime las expresiones de entrada en el mismo formato que lo hace la función `grind'; en caso contrario no se formatean la expresiones de entrada. La función `grind' evalúa sus argumentos. Ejemplos: (%i1) aa + 1729; (%o1) aa + 1729 (%i2) grind (%); aa+1729$ (%o2) done (%i3) [aa, 1729, aa + 1729]; (%o3) [aa, 1729, aa + 1729] (%i4) grind (%); [aa,1729,aa+1729]$ (%o4) done (%i5) matrix ([aa, 17], [29, bb]); [ aa 17 ] (%o5) [ ] [ 29 bb ] (%i6) grind (%); matrix([aa,17],[29,bb])$ (%o6) done (%i7) set (aa, 17, 29, bb); (%o7) {17, 29, aa, bb} (%i8) grind (%); {17,29,aa,bb}$ (%o8) done (%i9) exp (aa / (bb + 17)^29); aa ----------- 29 (bb + 17) (%o9) %e (%i10) grind (%); %e^(aa/(bb+17)^29)$ (%o10) done (%i11) expr: expand ((aa + bb)^10); 10 9 2 8 3 7 4 6 (%o11) bb + 10 aa bb + 45 aa bb + 120 aa bb + 210 aa bb 5 5 6 4 7 3 8 2 + 252 aa bb + 210 aa bb + 120 aa bb + 45 aa bb 9 10 + 10 aa bb + aa (%i12) grind (expr); bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6 +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2 +10*aa^9*bb+aa^10$ (%o12) done (%i13) string (expr); (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\ +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\ bb+aa^10 (%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A), p : makelist (0, i, 1, length (A))], for i thru n do for j : i thru n do (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1), if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]), for i thru n do L[i, i] : 1 / p[i], for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$ (%i15) grind (cholesky); cholesky(A):=block( [n:length(A),L:copymatrix(A), p:makelist(0,i,1,length(A))], for i thru n do (for j from i thru n do (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1), if i = j then p[i]:1/sqrt(x) else L[j,i]:x*p[i])), for i thru n do L[i,i]:1/p[i], for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$ (%o15) done (%i16) string (fundef (cholesky)); (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\ t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\ [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\ ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \ n do (for j from i+1 thru n do L[i,j]:0),L) -- Variable opcional: ibase Valor por defecto: 10 Los enteros que se escriban en Maxima se interpretan como dados en base `ibase'. A la variable `ibase' se le puede asignar cualquier entero entre 2 y 35 (decimal), ambos inclusive. Si `ibase' es mayor que 10, las cifras serán los números decimales entre 0 y 9, más las letras mayúsculas A, B, C, ..., sgún sea necesario. Las cifras en base 35, la mayor base que acepta Maxima, son los dígitos de 0 a 9 y las letras de A a Y. Véase también `obase'. -- Variable opcional: inchar Valor por defecto: `%i' La variable `inchar' es el prefijo de las etiquetas de las expresiones introducidas por el usuario. Maxima crea automáticamente una etiqueta para cada expresión de entrada concatenando `inchar' y `linenum'; a `inchar' se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. (%i1) inchar: "input"; (%o1) input (input1) expand ((a+b)^3); 3 2 2 3 (%o1) b + 3 a b + 3 a b + a (input2) Véase también `labels'. -- Función: ldisp (, ..., ) Muestra las expresiones , ..., en la consola con el formato de salida; `ldisp' asigna una etiqueta a cada argumento y devuelve la lista de etiquetas. Véase también `disp'. (%i1) e: (a+b)^3; 3 (%o1) (b + a) (%i2) f: expand (e); 3 2 2 3 (%o2) b + 3 a b + 3 a b + a (%i3) ldisp (e, f); 3 (%t3) (b + a) 3 2 2 3 (%t4) b + 3 a b + 3 a b + a (%o4) [%t3, %t4] (%i4) %t3; 3 (%o4) (b + a) (%i5) %t4; 3 2 2 3 (%o5) b + 3 a b + 3 a b + a -- Función: ldisplay (, ..., ) Muestra las expresiones , ..., en la consola con el formato de salida. Cad expresión se muestra como una ecuación de la forma `lhs = rhs' en la que `lhs' es uno de los argumentos de `ldisplay' y `rhs' su valor. Normalmente, cada argumento será el nombre de una variable. La función `ldisp' asigna una etiqueta a cada ecuación y devuelve la lista de etiquetas. Véase también `display'. (%i1) e: (a+b)^3; 3 (%o1) (b + a) (%i2) f: expand (e); 3 2 2 3 (%o2) b + 3 a b + 3 a b + a (%i3) ldisplay (e, f); 3 (%t3) e = (b + a) 3 2 2 3 (%t4) f = b + 3 a b + 3 a b + a (%o4) [%t3, %t4] (%i4) %t3; 3 (%o4) e = (b + a) (%i5) %t4; 3 2 2 3 (%o5) f = b + 3 a b + 3 a b + a -- Variable opcional: linechar Valor por defecto: `%t' La variable `linechar' es el prefijo de las etiquetas que genera Maxima para expresiones intermedias. Cuando sea necesario, Maxima creará una etiqueta para cada expresión intermedia concatenando `linechar' y `linenum'. A `linechar' se le puede asignar cualquier cadena o símbolo, no necesariamente un carácter simple. Las expresiones intermedias pueden ser mostradas o no. Véanse también `programmode' y `labels'. -- Variable opcional: linel Valor por defecto: 79 La variable `linel' es la anchura (medida en número de caracteres) de la consola que se le da a Maxima para que muestre las expresiones. A `linel' se le puede asignar cualquier valor, pero si éste es muy pequeño o grande resultará de poca utilidad. El texto que impriman las funciones internas de Maxima, como los mensajes de error y las salidas de la función `describe', no se ve afectado por el valor de `linel'. -- Variable opcional: lispdisp Valor por defecto: `false' Si `lispdisp' vale `true', los símbolos de Lisp se muestran precedidos del carácter de interrogación `?'. En caso contrario, los símbolos de Lisp se muestran sin esta marca. Ejemplos: (%i1) lispdisp: false$ (%i2) ?foo + ?bar; (%o2) foo + bar (%i3) lispdisp: true$ (%i4) ?foo + ?bar; (%o4) ?foo + ?bar -- Función: load () Evalúa las expresiones del archivo , trayendo variables, funciones y otros objetos a Maxima. Una asignación hecha previamente a una variable en Maxima será destruida por otra asignación que se le haga en . Para encontrar el fichero, `load' llama a `file_search' con `file_search_maxima' y `file_search_lisp' como directorios de búsqueda. Si la llamada a `load' funciona correctamente, devuelve el nombre del fichero; en caso contrario, `load' muestra un mensaje de error. La función `load' trabaja indistintamente con código Lisp y Maxima. Los ficheros creados con `save', `translate_file' y `compile_file', que crea código Lisp, y `stringout', que crea código Maxima, todos ellos pueden ser procesados por `load'. La función `load' llama a `loadfile' para cargar archivos en Lisp y a `batchload' para cargar archivos en Maxima. La función `load' no reconoce las construcciones de tipo `:lisp' en ficheros de Maxima. Además, mientras se está procesando , las variables globales `_', `__', `%' y `%th' mantienen los valores que tenían cuando se realizó la llamada a `load'. Véanse también `loadfile', `batch', `batchload' y `demo'; `loadfile' procesa archivos en Lisp; `batch', `batchload' y `demo' procesan archivos en Maxima. Véase `file_search' para más detalles sobre el mecanismo de búsqueda de archivos. La función `load' evalúa sus argumentos. -- Función: loadfile () Evalúa las expresiones Lisp del archivo . La función `loadfile' no llama a `file_search', de manera que `filename' debe incluir la extensión del archivo y su ruta completa. La función `loadfile' puede procesar ficheros creados por `save', `translate_file' y `compile_file'. Puede ser más conveniente utilizar `load' en lugar de `loadfile'. -- Variable opcional: loadprint Valor por defecto: `true' La variable `loadprint' indica si mostrar un mensaje cuando se carga un archivo. * Si `loadprint' vale `true', se muestra siempre un mensaje. * Si `loadprint' vale `'loadfile', muestra un mensaje sólo si el archivo es cargado con la función `loadfile'. * Si `loadprint' vale `'autoload', muestra un mensaje sólo cuandi un archivo se carga automáticamente. Véase `setup_autoload'. * Si `loadprint' vale `false', nunca mostrará mensajes. -- Variable opcional: obase Valor por defecto: 10 La variable `obase' es la base de los enteros mostrados por Maxima; se le puede asignar cualquier entero entre 2 y 35 (decimal), ambos inclusive. Si `obase' es mayor que 10, las cifras serán los números decimales entre 0 y 9, más las letras mayúsculas A, B, C, ..., sgún sea necesario. Las cifras en base 35, la mayor base que acepta Maxima, son los dígitos de 0 a 9 y las letras de A a Y. Véase también `ibase'. -- Variable opcional: outchar Valor por defecto: `%o' La variable `outchar' es el prefijo de las etiquetas de las expresiones calculadas por Maxima. Maxima crea automáticamente una etiqueta para cada expresión calculada concatenando `outchar' y `linenum'; a `outchar' se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. (%i1) outchar: "output"; (output1) output (%i2) expand ((a+b)^3); 3 2 2 3 (output2) b + 3 a b + 3 a b + a (%i3) Véase también `labels'. -- Variable opcional: packagefile Valor por defecto: `false' Los desarrolladores de paquetes que utilizan `save' o `translate' para crear paquetes (ficheros) que van a ser utilizados por terceros pueden hacer `packagefile: true' para evitar que se añada información a la listas de información de Maxima (por ejemplo, `values', `functions') excepto allí donde sea necesario cuando el archivo sea cargado en memoria. -- Variable opcional: pfeformat Valor por defecto: `false' Si `pfeformat' vale `true', una fracción de enteros será mostrada con el carácter de barra inclinada `/' entre ellos. (%i1) pfeformat: false$ (%i2) 2^16/7^3; 65536 (%o2) ----- 343 (%i3) (a+b)/8; b + a (%o3) ----- 8 (%i4) pfeformat: true$ (%i5) 2^16/7^3; (%o5) 65536/343 (%i6) (a+b)/8; (%o6) 1/8 (b + a) -- Función: print (, ..., ) Evalúa y muestra las expresiones , ..., secuencialmente de izquierda a derecha, comenzando la impresión por el borde izquierdo de la consola. El valor devuelto por `print' es el valor de su último argumento. La función `print' no genera etiquetas para las expresiones intermedias. Véanse también `display', `disp', `ldisplay' y `ldisp', que muestran una expresión por línea, mientras que `print' trata de mostrar dos o más expresiones por línea. Para mostrar el contenido de un archivo véase `printfile'. (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$ 3 2 2 3 (a+b)^3 is b + 3 a b + 3 a b + a log (a^10/b) is 10 log(a) - log(b) (%i2) r; (%o2) 10 log(a) - log(b) (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$ (a+b)^3 is 3 2 2 3 b + 3 a b + 3 a b + a log (a^10/b) is 10 log(a) - log(b) -- Función: read (, ..., ) Imprime , ..., y a continuación lee una expresión desde la consola y devuelve la expresión evaluada. La expresión termina con un punto y coma `;' o con el símbolo de dólar `$'. Véase también `readonly'. (%i1) foo: 42$ (%i2) foo: read ("foo vale", foo, " -- nuevo valor.")$ foo vale 42 -- nuevo valor. (a+b)^3; (%i3) foo; 3 (%o3) (b + a) -- Función: readonly (, ..., ) Imprime , ..., y a continuación lee una expresión desde la consola y devuelve la expresión sin evaluar. La expresión termina con un punto y coma `;' o con el símbolo de dólar `$'. (%i1) aa: 7$ (%i2) foo: readonly ("Introducir expresion:"); Introducir expresion: 2^aa; aa (%o2) 2 (%i3) foo: read ("Introducir expresion:"); Introducir expresion: 2^aa; (%o3) 128 Véase también `read'. -- Función: reveal (, ) Reemplaza partes de al especificado y las sutituye por descripciones cortas. * Las sumas y restas se reemplazan por `sum()', siendo el número de términos de la suma. * Los productos se reemplazan por `product()', siendo el número de factores del producto. * Las potencias se reemplazan por `expt'. * Los cocientes se reemplazan por `quotient'. * El símbolo negativo se reemplaza por `negterm'. Si el entero es mayor o igual que la profundidad máxima de , `reveal (, )' devuelve sin modificar. La función `reveal' evalúa sus argumentos y devuelve la expresión con las modificaciones solicitadas. Ejemplo: (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2); 2 2 b - 2 a b + a (%o1) ------------------------- b + a 2 b 2 a 2 %e + %e + %e (%i2) reveal (e, 1); (%o2) quotient (%i3) reveal (e, 2); sum(3) (%o3) ------ sum(3) (%i4) reveal (e, 3); expt + negterm + expt (%o4) ------------------------ product(2) + expt + expt (%i5) reveal (e, 4); 2 2 b - product(3) + a (%o5) ------------------------------------ product(2) product(2) 2 expt + %e + %e (%i6) reveal (e, 5); 2 2 b - 2 a b + a (%o6) -------------------------- sum(2) 2 b 2 a 2 %e + %e + %e (%i7) reveal (e, 6); 2 2 b - 2 a b + a (%o7) ------------------------- b + a 2 b 2 a 2 %e + %e + %e -- Variable opcional: rmxchar Valor por defecto: `]' La variable `rmxchar' es el carácter que se dibuja al lado derecho de una matriz. Véase también `lmxchar'. -- Función: save (, , , , ...) -- Función: save (, values, functions, labels, ...) -- Función: save (, [, ]) -- Función: save (, =, ...) -- Función: save (, all) -- Función: save (, =, =, ...) Alamacena los valores actuales de , , , ..., en el archivo . Los argumentos son nombres de variables, funciones u otros objetos. Si un nombre no tiene un valor o una función asociado a él, entonces se ignora. La función `save' devuelve . La función `save' almacena datos en forma de expresiones Lisp. Los datos almacenados por `save' pueden recuperarse con `load ()'. El resultado de ejecutar `save' cuando ya existe depende del soporte Lisp implementado; el archivo puede ser sobreescrito o que `save' envíe un mesaje de error. La llamada `save (, values, functions, labels, ...)' almacena los elementos cuyos nombres son `values', `functions', `labels', etc. Los nombres pueden ser cualesquiera de los especificados por la variable `infolists'; `values' incluye todas las variables definidas por el usuario. La llamada `save (, [, ])' almacena los valores de las etiquetas de entrada y salida desde hasta . Nótese que y deben ser números. Las etiquetas de entrada y salida también se pueden almacenar una a una, por ejemplo, `save ("foo.1", %i42, %o42)'. La llamada `save (, labels)' almacena todas las etiquetas de entrada y salida. Cuando las etiquetas almacenadas en el archivo sean posteriormente recuperadas, se sobreescribirán las activas en ese momento. La llamada `save (, =, =, ...)' almacena los valores de , , ..., con los nombres , , .... Es útil hacer este tipo de llamada para con etiquetas de entrada y salida, por ejemplo, `save ("foo.1", aa=%o88)'. El miembro derecho de la igualdad puede ser cualquier expresión, que será evaluada. Esta llamada a la función `save' no incorpora nuevos nombres a la sesión actual de Maxima, simplemente los almacena en el archivo . Todas estas formas de llamar a la función `save' se pueden combinar a voluntad. Por ejemplo, `save (, aa, bb, cc=42, functions, [11, 17])'. La llamada `save (, all)' almacena el estado actual de Maxima, lo que incluye todas las variables definidas por el usuario, funciones, arreglos, etc., así como algunos objetos definidos automáticamente. Los elementos almacenados incluyen variables del sistema, como `file_search_maxima' o `showtime', si han sido modificadas por el usuario. Véase `myoptions'. `save' evalúa pero no el resto de argumentos. -- Variable opcional: savedef Valor por defecto: `true' Si `savedef' vale `true', se mantiene la versión Maxima de una función definida por el usuario cuando ésta se traduce, lo que permite mostrar su código con `dispfun' y que la función pueda ser editada. Si `savedef' vale `false', los nombres de las funciones traducidas se eliminan de la lista `functions'. -- Función: show () Muestra `expr' con sus objetos indexados que tengan índices covariantes como subíndices y los contravariantes como superíndices. Los índices derivados se muestran como subíndices, separados por una coma de los covariantes. -- 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'. -- Variable opcional: stardisp Valor por defecto: `false' Si `stardisp' vale `true', la multiplicación se muestra con un asterisco `*' entre los operandos. -- Función: string () Convierte `expr' a la notación lineal de Maxima, tal como si fuese tecleada. El valor que retorna la función `string' es una cadena, por lo que no puede ser utilizada en los cálculos. -- Variable opcional: stringdisp Valor por defecto: `false' Si `stringdisp' vale `true', las cadenas alfanuméricas se muestran encerradas entre comillas dobles. En caso contrario, no se nuestran las comillas. La variable `stringdisp' vale siempre `true' cuando se muestra la definición de una función. Ejemplos: (%i1) stringdisp: false$ (%i2) "This is an example string."; (%o2) This is an example string. (%i3) foo () := print ("This is a string in a function definition."); (%o3) foo() := print("This is a string in a function definition.") (%i4) stringdisp: true$ (%i5) "This is an example string."; (%o5) "This is an example string." -- Función: stringout (, , , , ...) -- Función: stringout (, [, ]) -- Función: stringout (, input) -- Función: stringout (, functions) -- Función: stringout (, values) La función `stringout' escribe expresiones en un archivo de la misma forma en que se escribirían como expresiones de entrada. El archivo puede ser utilizado entonces como entrada a las funciones `batch' o `demo', y puede ser editado para cualquier otro propósito. La forma general de `stringout' escribe los valores de una o más expresiones en el archivo de salida. Nótese que si una expresión es una variable, solamente se escribirá el valor de la variable y no el nombre de ésta. Como caso especial, y muy útil en algunas ocasiones, las expresiones pueden ser etiquetas de entrada (`%i1', `%i2', `%i3', ...) o de salida (`%o1', `%o2', `%o3', ...). Si `grind' vale `true', `stringout' formatea la salida utilizando `grind'. En caso contrario, se utilizará el formato `string'. Véanse `grind' y `string'. La forma especial `stringout (, [, ])' escribe los valores de las etiquetas de entrada desde la m hasta la n, ambas inclusive. La forma especial `stringout (, input)' escribe todas las etiquetas de entrada en el archivo. La forma especial `stringout (, functions)' escribe todas las funciones definidas por el usuario, contenidas en la lista global `functions', en el archivo. La forma especial `stringout (, values)' escribe todas las variables asignadas por el usuario, contenidas en la lista global `values', en el archivo. Cada variable se escribe como una sentencia de asignación, con el nombre de la variable seguida de dos puntos y a continuación su valor. Nótese que la forma general de `stringout' no escribe las variables como sentencias de asignación. -- Función: tex () -- Función: tex (, ) -- 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 (, , )', 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. (%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: system () Ejecuta la instrucción como un proceso independiente de Maxima. La instrucción se le pasa a la consola del sistema para su ejecución. La función `system' no está soportada por todos los sistemas operativos, pero suele estarlo en todos los entornos Unix y similares. Suponiendo que `_hist.out' es una lista de frecuencias que se quieren representar en un diagrama de barras utilizando el programa `xgraph', (%i1) (with_stdout("_hist.out", for i:1 thru length(hist) do ( print(i,hist[i]))), system("xgraph -bar -brw .7 -nl < _hist.out")); A fin de hacer el diagrama y eliminar el archivo temporal posteriormente, hágase: system("(xgraph -bar -brw .7 -nl < _hist.out; rm -f _hist.out)&") -- Variable opcional: ttyoff Valor por defecto: `false' Si `ttyoff' vale `true', no se muestran las expresiones resultantes, pero éstas se calculan de todos modos y se les asignan etiquetas. Véase `labels'. El texto que escriban las funciones internas de Maxima, tales como los mensajes de error y las salidas de `describe', no se ven afectadas por `ttyoff'. -- Macro: with_stdout (, , , , ...) Abre el archivo y a continuación evalúa , , , .... Los valores de los argumentos no se almacenan , pero cualquier resultado a imprimir por `print', `display', `disp' o `grind', va a parar al archivo en lugar de a la consola. La macro `with_stdout' devuelve el valor de su último argumento. Véase también `writefile'. (%i1) with_stdout ("tmp.out", for i:5 thru 10 do print (i, "! yields", i!))$ (%i2) printfile ("tmp.out")$ 5 ! yields 120 6 ! yields 720 7 ! yields 5040 8 ! yields 40320 9 ! yields 362880 10 ! yields 3628800 -- Función: writefile () Comienza escribiendo una transcripción de la sesión de Maxima en el archivo . Cualquier interacción entre Maxima y el usuario se almacena también en este archivo, tal como aparece en la consola. Puesto que la transcripción se escribe en el formato de salida a la consola, su contenido no es interpretable por Maxima. Para hacer un archivo que contenga expresiones que puedan ser nuevamente cargadas en Maxima, véanse `save' y `stringout'; la función `save' almacena expresiones en formato Lisp, mientras que `stringout' lo hace en formato Maxima. El resultado de ejecutar `writefile' cuando el archivo ya existe depende del entorno Lisp operativo; el contenido anterior puede ser sobreescrito o ampliado con la sesión actual. La función `appendfile' siempre añade la sesión al contenido actual. Puede ser útil ejecutar `playback' después de `writefile' para guardar las interacciones previas de la sesión. Puesto que `playback' muestra solamente las variables de entrada y salida (`%i1', `%o1', etc.), cualquier salida generada por una sentencia de impresión desde dentro de una función no es mostrada por `playback'. La función `closefile' cierra los archivos abiertos por `writefile' o `appendfile'.  File: maxima.info, Node: Aritmética de punto flotante, Next: Contextos, Prev: Lectura y escritura, Up: Top 10 Aritmética de punto flotante ******************************* * Menu: * Funciones y variables para la aritmética de punto flotante::  File: maxima.info, Node: Funciones y variables para la aritmética de punto flotante, Prev: Aritmética de punto flotante, Up: Aritmética de punto flotante 10.1 Funciones y variables para la aritmética de punto flotante =============================================================== -- Función: bffac (, ) Versión para "bigfloat" de la función factorial (Gamma desplazada). El segundo argumento indica cuántos dígitos se conservan y devuelven, pudiendo utilizarse para obtener algunas cifras extra. La instrucción `load ("bffac")' carga esta función. -- Variable optativa: algepsilon Valor por defecto: 10^8 El valor de `algepsilon' es usado por `algsys'. -- Función: bfloat () Convierte todos los números y funciones numéricas a números decimales de punto flotante grandes ("bigfloats"). El número de dígitos significativos de los "bigfloats" resultantes se especifica mediante la variable global `fpprec'. Si `float2bf' vale `false' se mostrará un mensaje de aviso cuando un número en punto flotante se convierte a decimal de tipo "bigfloats", puesto que tal transformación puede conllevar pérdida de precisión. -- Función: bfloatp () Devuelve `true' si es un número decimal en punto flotante grande ("bigfloats"), en caso contrario devuelve `false'. -- Función: bfpsi (, , ) -- Función: bfpsi0 (, ) La función `bfpsi' es la poligamma de argumento real y de orden el entero . La función `bfpsi0' es la digamma. La llamada `bfpsi0 (, )' equivale a `bfpsi (0, , )'. Estas funciones devuelven valores "bigfloat". La variable es la precisión "bigfloat" del valor de retorno. La instrucción `load ("bffac")' carga estas funciones. -- Variable optativa: bftorat Valor por defecto: `false' La variable `bftorat' controla la conversión de números decimales de punto flotante grandes ("bigfloats") a números racionales. Si `bftorat' vale `false', se utilizará `ratepsilon' para controlar la conversión (lo cual resulta en números racionales relativamente pequeños). Si `bftorat' vale `true', el número racional generado representará exactamente al número decimal de punto flotante grande ("bigfloat"). -- Variable optativa: bftrunc Valor por defecto: `true' La variable `bftrunc' provoca la eliminación de ceros en números decimales grandes no nulos para que no se muestren. Así, si `bftrunc' vale `false', `bfloat (1)' se muestra como `1.000000000000000B0'. En otro caso, se mostrará como `1.0B0'. -- Función: cbffac (, ) Calcula el factorial de números complejos de punto flotante grandes. La instrucción `load ("bffac")' carga esta función. -- Función: float () Convierte los enteros, números racionales y los decimales de punto flotante grandes ("bigfloats") que están presentes en a números de punto flotante. También actúa como símbolo `evflag'. -- Variable optativa: float2bf Valor por defecto: `false' Si `float2bf' vale `false' se mostrará un mensaje de aviso cuando un número en punto flotante se convierte a decimal de tipo "bigfloats", puesto que tal transformación puede conllevar pérdida de precisión. -- Función: floatnump () Devuelve `true' si es un número de punto flotante, en caso contario retorna `false'. -- Variable optativa: fpprec Valor por defecto: 16 La variable `fpprec' guarda el número de dígitos significativos en la aritmética con números decimales de punto flotante grandes ("bigfloats"). La variable `fpprec' no afecta a los cálculos con números decimales de punto flotante ordinarios. Véanse también `bfloat' y `fpprintprec'. -- Variable optativa: fpprintprec Valor por defecto: 0 La variable `fpprintprec' guarda el número de dígitos a imprimir de los números decimales en coma flotante, tanto los ordinarios como los de precisión ilimitada (bigfloats). En el caso de los decimales ordinarios, si `fpprintprec' toma un valor entre 2 y 16 (inclusive), el número de dígitos que se imprimen es igual a `fpprintprec'. En caso contrario, `fpprintprec' es 0 o mayor que 16, siendo el número de dígitos a imprimir en todos loa casos igual a 16. En el caso de los decimales de precisión ilimitada (bigfloats), si `fpprintprec' toma un valor entre 2 y 16 (inclusive), el número de dígitos que se imprimen es igual a `fpprintprec'. En caso contrario, `fpprintprec' es 0 o mayor que `fpprec', siendo el número de dígitos a imprimir igual a `fpprec'. La variable `fpprintprec' no admite el valor 1.  File: maxima.info, Node: Contextos, Next: Polinomios, Prev: Aritmética de punto flotante, Up: Top 11 Contextos ************ * Menu: * Funciones y variables para Contextos::  File: maxima.info, Node: Funciones y variables para Contextos, Prev: Contextos, Up: Contextos 11.1 Funciones y variables para Contextos ========================================= -- 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: 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. 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 lamada `facts ()', sin argumentos, muestra el contexto actual. -- 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', and `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'. -- 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'. The predicates may be expressions equivalent to (but not necessarily identical to) those previously assumed. La llamada `forget ()', siendo una lista de predicados, borra todos los predicados contenidos en ella. -- 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: 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: 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: Polinomios, Next: Constantes, Prev: Contextos, Up: Top 12 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 12.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 12.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. -- 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 (, , ) Devuelve el coeficiente de `^' en . El argumento puede omitirse si es igual a la unidad. El argumento puede ser un átomo o una subexpresión completa de , por ejemplo `sin(x)', `a[i+1]', `x + y', etc. (En este último caso, la expresión `(x + y)' debe aparecer en ). En ocasiones puede ser necesario expandir o factorizar para hacer `^' explícito, lo cual no hace `coeff' automáticamente. Ejemplos: (%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x)); (%o1) 2 a + 1 = 5 (%i2) coeff (y + x*%e^x + 1, x, 0); (%o2) y + 1 -- Función: combine () Simplifica la suma combinando términos de con igual denominador reduciéndolos a un único término. -- 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'. -- 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: 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: 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 (, p)' factoriza en el campo de los enteros con un elemento añadido cuyo polinomio mínimo es p. 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. -- 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 previamente a `true' y `gcd' no puede ser `ez'. Se recomienda utilizar el algoritmo `subres' en lugar de `red', por ser aquél más nuevo. Cuando la variable `gcd', cuyo valor por defecto es `subres', 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). -- 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 asociadas) 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 permitirá que a `modulus' se le asigne cero o un entero negativo, aunque no esté clara su utilidad. -- 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: 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. Examples: (%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'. -- Variable opcional: ratepsilon Valor por defecto: 2.0e-8 La variable `ratepsilon' guarda la tolerancia utilizada en la conversión de números decimales en coma flotante a números racionales. -- 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: ratnump () Devuelve `true' si es un entero literal o una fracción de enteros literales, en caso contrario devuelve `false'. -- 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. -- 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. 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. -- 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 (, , ) -- Variable: 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 `resultant' controla qué algoritmo será utilizado para calcular la resultante. La función `bezout' toma los mismos argumentos que `resultant' y devuelve una matriz. El determinante del valor retornado es la resultante buscada. -- 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: 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: Constantes, Next: Logaritmos, Prev: Polinomios, Up: Top 13 Constantes ************* * Menu: * Funciones y variables para Constantes::  File: maxima.info, Node: Funciones y variables para Constantes, Prev: Constantes, Up: Constantes 13.1 Funciones y variables para Constantes ========================================== -- Constante: %e El símbolo `%e' representa a la base de los logaritmos naturales, también conocido como número de Euler. El valor numérico de `%e' es el número decimal en coma flotante 2.718281828459045d0. -- Constante: %i El símbolo `%i' representa la unidad imaginaria, sqrt(- 1). -- Constante: false El símbolo `false' representa al valor lógico "falso". Maxima implementa `false' con el valor `NIL' de Lisp. -- Constante: inf El símbolo `inf' representa al infinito real positivo. -- Constante: infinity El símbolo `infinity' representa al infinito complejo. -- Constante: minf El símbolo `minf' representa al infinito real negativo. -- Constante: %phi El símbolo `%phi' representa a la llamada razón áurea, (1 + sqrt(5))/2. El valor numérico de `%phi' es el número decimal en coma flotante 1.618033988749895d0. La función `fibtophi' expresa los números de Fibonacci `fib(n)' en términos de `%phi'. Por defecto, Maxima desconoce las propiedades algebraicas de `%phi'. Tras evaluar `tellrat(%phi^2 - %phi - 1)' y `algebraic: true', `ratsimp' puede simplificar algunas expresiones que contengan `%phi'. Ejemplos: `fibtophi' expresa el número de Fibonacci `fib(n)' en términos de `%phi'. (%i1) fibtophi (fib (n)); n n %phi - (1 - %phi) (%o1) ------------------- 2 %phi - 1 (%i2) fib (n-1) + fib (n) - fib (n+1); (%o2) - fib(n + 1) + fib(n) + fib(n - 1) (%i3) fibtophi (%); n + 1 n + 1 n n %phi - (1 - %phi) %phi - (1 - %phi) (%o3) - --------------------------- + ------------------- 2 %phi - 1 2 %phi - 1 n - 1 n - 1 %phi - (1 - %phi) + --------------------------- 2 %phi - 1 (%i4) ratsimp (%); (%o4) 0 Por defecto, Maxima desconoce las propiedades algebraicas de `%phi'. Después de evaluar `tellrat (%phi^2 - %phi - 1)' y `algebraic: true', `ratsimp' puede simplificar algunas expresiones que contengan `%phi'. (%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1)); 2 2 (%o1) %phi A - %phi A - A + %phi - %phi - 1 (%i2) ratsimp (e); 2 2 (%o2) (%phi - %phi - 1) A + %phi - %phi - 1 (%i3) tellrat (%phi^2 - %phi - 1); 2 (%o3) [%phi - %phi - 1] (%i4) algebraic : true; (%o4) true (%i5) ratsimp (e); (%o5) 0 -- Constante: %pi El símbolo `%pi' representa la razón entre la longitud de una circunferencia y su radio. El valor numérico de `%pi' es el número decimal en coma flotante 3.141592653589793d0. -- Constante: true El símbolo `true' representa al valor lógico "verdadero". Maxima implementa `true' con el valor `T' de Lisp.  File: maxima.info, Node: Logaritmos, Next: Trigonometría, Prev: Constantes, Up: Top 14 Logaritmos ************* * Menu: * Funciones y variables para logaritmos::  File: maxima.info, Node: Funciones y variables para logaritmos, Prev: Logaritmos, Up: Logaritmos 14.1 Funciones y variables para logaritmos ========================================== -- 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'. -- 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 cciertas 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 y `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. `lognumer' - si vale `true', entonces los argumentos de `log' que sean números decimales negativos en coma flotante se convertirán siempre a su valor absoluto antes de aplicar `log'. Si `numer' vale también `true', entonces los argumentos enteros negativos de `log' también se convertirán en su valor absoluto. `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 contienen 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 y `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: lognumer Valor por defecto: `false' Si `lognumer' vale `true', entonces los argumentos de `log' que sean números decimales negativos en coma flotante se convertirán siempre a su valor absoluto antes de aplicar `log'. Si `numer' vale también `true', entonces los argumentos enteros negativos de `log' también se convertirán en su valor absoluto. -- 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' .  File: maxima.info, Node: Trigonometría, Next: Funciones Especiales, Prev: Logaritmos, Up: Top 15 Trigonometría **************** * 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: Trigonometría, Up: Trigonometría 15.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: Trigonometría 15.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; (%o1) 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; (%o4) 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); (%o1) done (%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'. Maxima aplica esta simplificación cuando el argumento es un múltiplo literal de `%i', aunque el resultado sea reducible a real. Ejemplos: (%i1) %iargs : false; (%o1) false (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o2) [sin(%i x), cos(%i x), tan(%i x)] (%i3) %iargs : true; (%o3) 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); (%o1) done (%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. -- 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: `all' 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'. (%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; %pi (%o1) - b - a + --- 3 (%i2) bc: sin(a)*sin(3*c)/sin(a+b); sin(a) sin(3 b + 3 a) (%o2) --------------------- sin(b + a) (%i3) ba: bc, c=a, a=c$ (%i4) ac2: ba^2 + bc^2 - 2*bc*ba*cos(b); 2 2 sin (a) sin (3 b + 3 a) (%o4) ----------------------- 2 sin (b + a) %pi 2 sin(a) sin(3 a) cos(b) sin(b + a - ---) sin(3 b + 3 a) 3 - -------------------------------------------------------- %pi sin(a - ---) sin(b + a) 3 2 2 %pi sin (3 a) sin (b + a - ---) 3 + --------------------------- 2 %pi sin (a - ---) 3 (%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: Funciones Especiales, Next: Funciones elípticas, Prev: Trigonometría, Up: Top 16 Funciones Especiales *********************** * Menu: * Introducción a las funciones especiales:: * Funciones y variables para las funciones especiales::  File: maxima.info, Node: Introducción a las funciones especiales, Next: Funciones y variables para las funciones especiales, Prev: Funciones Especiales, Up: Funciones Especiales 16.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 %he[n] (z) Polinomio de Hermite (Ojo: `he', no `h'. Ver A&S 22.5.18) %p[u,v] (z) Función de Legendre de primera especie %q[u,v] (z) Función de Legendre de segunda especie hstruve[n] (z) Función H de Struve lstruve[n] (z) Función L de Struve %f[p,q] ([], [], expr) Función hipergeométrica generalizada gamma() Función Gamma gammagreek(a,z) Función Gamma incompleta gammaincomplete(a,z) Extremo de la función Gamma incompleta 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 ei (z) Integral exponencial (?) kelliptic (z) Integral elíptica completa de primera especie (K) %d [n] (z) Función cilíndrica parabólica  File: maxima.info, Node: Funciones y variables para las funciones especiales, Prev: Introducción a las funciones especiales, Up: Funciones Especiales 16.2 Funciones y variables para las funciones especiales ======================================================== -- Función: airy_ai () Función Ai de Airy, tal como la definen Abramowitz y Stegun, Handbook of Mathematical Functions, Sección 10.4. La ecuación de Airy `diff (y(x), x, 2) - x y(x) = 0' tiene dos soluciones linealmente independientes, `y = Ai(x)' y `y = Bi(x)'. La derivada `diff (airy_ai(x), x)' es `airy_dai(x)'. Si el argumento `x' es un número decimal real o complejo, se devolverá el valor numérico de `airy_ai' siempre que sea posible. Véanse `airy_bi', `airy_dai' y `airy_dbi'. -- Función: airy_dai () Es la derivada de la función Ai de Airy, `airy_ai(x)'. Véase `airy_ai'. -- Función: airy_bi () Es la función Bi de Airy, tal como la definen Abramowitz y Stegun, Handbook of Mathematical Functions, Sección 10.4. Se trata de la segunda solución de la ecuación de Airy `diff (y(x), x, 2) - x y(x) = 0'. Si el argumento `x' es un número decimal real o complejo, se devolverá el valor numérico de `airy_bi' siempre que sea posible. En los otros casos, se devuelve la expresión sin evaluar. La derivada `diff (airy_bi(x), x)' es `airy_dbi(x)'. Véanse `airy_ai' y `airy_dbi'. -- Función: airy_dbi () Es la derivada de la función Bi de Airy, `airy_bi(x)'. Véanse `airy_ai' y `airy_bi'. -- Función: asympa El paquete `asympa' contiene funciones de simplificación para realizar análisis asintótico, incluyendo las funciones "big O" y "little o", de uso frecuente en el análisis complejo y numérico. La instrucción `load ("asympa")' carga este paquete. -- Función: bessel (, ) Función de Bessel de primera especie. Ya no se recomienda su uso. Utilícese `bessel_j (, )' en su lugar. -- Función: bessel_j (, ) Función de Bessel de primera especie de orden v y argumento z. La función `bessel_j' calcula el arreglo `besselarray' tal que `besselarray [i] = bessel_j [i + v - int(v)] (z)' para `i' desde cero hasta `int(v)'. 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' calcula el arreglo `besselarray' tal que `besselarray [i] = bessel_y [i + v - int(v)] (z)' para `i' desde cero hasta `int(v)'. 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' calcula el arreglo `besselarray' tal que `besselarray [i] = bessel_i [i + v - int(v)] (z)' para `i' desde cero hasta `int(v)'. 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' calcula el arreglo `besselarray' tal que `besselarray [i] = bessel_k [i + v - int(v)] (z)' para `i' desde cero hasta `int(v)'. 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. -- 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); 2 z sin(z) cos(z) (%o4) sqrt(---) (------ - ------) %pi 2 z z -- 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: beta (, ) Función beta, definida como `gamma(x) gamma(y)/gamma(x + y)'. -- Función: gamma () Función gamma. Véase también `makegamma'. La variable `gammalim' controla la simplificación de la función gamma. La constante de Euler-Mascheroni es `%gamma'. -- Variable optativa: gammalim Valor por defecto: 1000000 La variable `gammalim' controla la simplificación de la función gamma con argumentos enteros o racionales. Si el valor absoluto del argumento no es mayor que `gammalim', entonces se realizará la simplificación. Nótese que la variable `factlim' también controla la simplificación del resultado de `gamma' con argumento entero. -- Función: intopois () Convierte en un codificado Poisson. -- Función: makefact () Transforma las funciones `binomial', `gamma' y `beta' que aparecen en en su notación factorial. Véase también `makegamma'. -- Función: makegamma () Transforma las funciones `binomial', `factorial' y `beta' que aparecen en en funciones `gamma'. Véase también `makefact'. -- Función: numfactor () Devuelve el factor numérico que multiplica a la expresión , la cual debe tener un único término. (%i1) gamma (7/2); 15 sqrt(%pi) (%o1) ------------ 8 (%i2) numfactor (%); 15 (%o2) -- 8 -- Función: outofpois () Convierte desde codificado de Poisson a una representación general. Si no está en forma de Poisson, `outofpois' hace la conversión, siendo entonces el valor retornado `outofpois (intopois ())'. Esta función es un simplificador canónico para sumas de potencias de senos y cosenos. -- Función: poisdiff (, ) Deriva con respecto a . El argumento debe aparecer sólo en los argumentos trigonométricos o sólo en los coeficientes. -- Función: poisexpt (, ) Idéntico a `intopois (^)'. El argumento debe ser un entero positivo. -- Variable optativa: poislim Valor por defecto: 5 La variable `poislim' determina el dominio de los coeficientes en los argumentos de las funciones trigonométricas. El valor por defecto 5 corresponde al intervalo [-2^(5-1)+1,2^(5-1)], o [-15,16], pero puede reasignarse para [-2^(n-1)+1, 2^(n-1)]. -- Función: poisplus (, ) Idéntico a `intopois (a + b)'. -- Función: poissimp () Convierte en una serie de Poisson para en su representación general. -- Símbolo especial: poisson El símbolo `/P/' sigue a la etiqueta de las líneas que contienen expresiones que son series de Poisson. -- Función: poissubst (, , ) Sustituye por en , donde es una serie de Poisson. (1) Si es una de las variables , , , , o , entonces debe ser una expresión lineal en esas variables (por ejemplo, `6*u + 4*v'). (2) Si no es ninguna de esas variables, entonces no puede contener tampoco a ninguna de ellas, ni senos, ni cosenos. -- Función: poistimes (, ) Idéntico a `intopois (*)'. -- Función: printpois () Presenta una serie de Poisson en un formato legible. Conjuntamente con `outofpois', si es necesario convertirá primero en una codificación de Poisson. -- Función: psi []() Es la derivada de `log (gamma ())' de orden `+1', de tal manera que `psi[0]()' es la primera derivada, `psi[1]()' la segunda derivada y así sucesivamente. En general, Maxima no sabe cómo calcular valores numéricos de `psi', pero sí conoce el valor exacto para algunos argumentos racionales. Existen algunas variables globales para controlar en qué rangos racionales debe devolver `psi' resultados exactos, si ello es posible. Véanse las descripciones de `maxpsiposint', `maxpsinegint', `maxpsifracnum' y `maxpsifracnum'. En resumen, debe alcanzar un valor entre `maxpsinegint' y `maxpsiposint'. Si el valor absoluto de la parte fraccional de es racional y tiene un numerador menor que `maxpsifracnum' y un denominador menor que `maxpsifracdenom', la función `psi' devolverá un valor exacto. La función `bfpsi' del paquete `bffac' puede calcular valores numéricos. -- Variable opcional: maxpsiposint Valor por defecto: 20 La variable `maxpsiposint' guarda el mayor valor positivo para el que `psi[n](x)' intentará calcular un valor exacto. -- Variable opcional: maxpsinegint Valor por defecto: -10 La variable `maxpsinegint' guarda el menor valor negativo para el que `psi[n](x)' intentará calcular un valor exacto. Si es menor que `maxnegint', `psi[n]()' no devolverá una respuesta simplificada, aunque supiese cómo hacerlo. -- Variable opcional: maxpsifracnum Valor por defecto: 6 Sea un número racional menor que la unidad de la forma `p/q'. Si `p' es mayor que `maxpsifracnum', entonces `psi[]()' no devolverá una respuesta simplificada. -- Variable opcional: maxpsifracdenom Valor por defecto: 6 Sea un número racional menor que la unidad de la forma `p/q'. Si `q' es mayor que `maxpsifracnum', entonces `psi[]()' no devolverá una respuesta simplificada. -- Función: specint (exp(- s*) * , ) Calcula la transformada de Laplace de respecto de la variable . El integrando puede contener funciones especiales. Si `specint' no puede calcular la integral, le valor devuelto puede contener símbolos de Lisp, incluyendo `other-defint-to-follow-negtest', `other-lt-exponential-to-follow', `product-of-y-with-nofract-indices', etc.; se trata de un fallo pendiente de corrección. La ejecución de `demo(hypgeo)' muestra algunso ejemplos de transformadas de Laplace calculadas con `specint'. Examples: (%i1) assume (p > 0, a > 0); (%o1) [p > 0, a > 0] (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t); sqrt(%pi) (%o2) ------------ a 3/2 2 (p + -) 4 (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) * exp(-p*t), t); - a/p sqrt(a) %e (%o3) --------------- 2 p  File: maxima.info, Node: Funciones elípticas, Next: Límites, Prev: Funciones Especiales, Up: Top 17 Funciones elípticas ********************** * Menu: * Introducción a las funciones e integrales elípticas:: * Funciones y variables para funciones elípticas:: * Funciones y variables para integrales elípticas::  File: maxima.info, Node: Introducción a las funciones e integrales elípticas, Next: Funciones y variables para funciones elípticas, Prev: Funciones elípticas, Up: Funciones elípticas 17.1 Introducción a las funciones e integrales elípticas ======================================================== Maxima da soporte para las funciones elípticas jacobianas y para las integrales elípticas completas e incompletas. Esto incluye la manipulación simbólica de estas funciones y su evaluación numérica. Las definiciones de estas funciones y de muchas de sus propiedades se pueden encontrar en Abramowitz y Stegun, capítulos 16-17, que es la fuente principal utilizada para su programación en Maxima, aunque existen algunas diferencias. En particular, todas las funciones e integrales elípticas utilizan el parámero m en lugar del módulo k o del ángulo alfa. Esta es una de las diferencias con Abramowitz y Stegun, que utilizan el ángulo para las funciones elípticas. Las siguientes relaciones son válidas: m = k^2 y k = sin(alfa). Las funciones e integrales elípticas en Maxima tienen como objetivo primordial dar soporte al cálculo simbólico, de ahí que también estén incluidas la mayoría de las derivadas e integrales asociadas a estas funciones. No obstante lo anterior, si los argumentos dados a las funciones son decimales en coma flotante, los resultados también serán decimales. Sin embargo, la mayoría de las propiedades no realacionadas con las derivadas de las funciones e integrales elípticas todavía no han sido programadas en Maxima. Algunos ejemplos de funciones elípticas: (%i1) jacobi_sn (u, m); (%o1) jacobi_sn(u, m) (%i2) jacobi_sn (u, 1); (%o2) tanh(u) (%i3) jacobi_sn (u, 0); (%o3) sin(u) (%i4) diff (jacobi_sn (u, m), u); (%o4) jacobi_cn(u, m) jacobi_dn(u, m) (%i5) diff (jacobi_sn (u, m), m); (%o5) jacobi_cn(u, m) jacobi_dn(u, m) elliptic_e(asin(jacobi_sn(u, m)), m) (u - ------------------------------------)/(2 m) 1 - m 2 jacobi_cn (u, m) jacobi_sn(u, m) + -------------------------------- 2 (1 - m) Algunos ejemplos de integrales elípticas: (%i1) elliptic_f (phi, m); (%o1) elliptic_f(phi, m) (%i2) elliptic_f (phi, 0); (%o2) phi (%i3) elliptic_f (phi, 1); phi %pi (%o3) log(tan(--- + ---)) 2 4 (%i4) elliptic_e (phi, 1); (%o4) sin(phi) (%i5) elliptic_e (phi, 0); (%o5) phi (%i6) elliptic_kc (1/2); 1 (%o6) elliptic_kc(-) 2 (%i7) makegamma (%); 2 1 gamma (-) 4 (%o7) ----------- 4 sqrt(%pi) (%i8) diff (elliptic_f (phi, m), phi); 1 (%o8) --------------------- 2 sqrt(1 - m sin (phi)) (%i9) diff (elliptic_f (phi, m), m); elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m) (%o9) (----------------------------------------------- m cos(phi) sin(phi) - ---------------------)/(2 (1 - m)) 2 sqrt(1 - m sin (phi)) El paquete para funciones e integrales elípticas fue programado por Raymond Toy. Se distribuye, igual que Maxima, bajo la General Public License (GPL).  File: maxima.info, Node: Funciones y variables para funciones elípticas, Next: Funciones y variables para integrales elípticas, Prev: Introducción a las funciones e integrales elípticas, Up: Funciones elípticas 17.2 Funciones y variables para funciones elípticas =================================================== -- Función: jacobi_sn (, ) Función elíptica jacobiana sn(u,m). -- Función: jacobi_cn (, ) Función elíptica jacobiana cn(u,m). -- Función: jacobi_dn (, ) Función elíptica jacobiana dn(u,m). -- Función: jacobi_ns (, ) Función elíptica jacobiana ns(u,m) = 1/sn(u,m). -- Función: jacobi_sc (, ) Función elíptica jacobiana sc(u,m) = sn(u,m)/cn(u,m). -- Función: jacobi_sd (, ) Función elíptica jacobiana sd(u,m) = sn(u,m)/dn(u,m). -- Función: jacobi_nc (, ) Función elíptica jacobiana nc(u,m) = 1/cn(u,m). -- Función: jacobi_cs (, ) Función elíptica jacobiana cs(u,m) = cn(u,m)/sn(u,m). -- Función: jacobi_cd (, ) Función elíptica jacobiana cd(u,m) = cn(u,m)/dn(u,m). -- Función: jacobi_nd (, ) Función elíptica jacobiana nc(u,m) = 1/cn(u,m). -- Función: jacobi_ds (, ) Función elíptica jacobiana ds(u,m) = dn(u,m)/sn(u,m). -- Función: jacobi_dc (, ) Función elíptica jacobiana dc(u,m) = dn(u,m)/cn(u,m). -- Función: inverse_jacobi_sn (, ) Inversa de la función elíptica jacobiana sn(u,m). -- Función: inverse_jacobi_cn (, ) Inversa de la función elíptica jacobiana cn(u,m). -- Función: inverse_jacobi_dn (, ) Inversa de la función elíptica jacobiana dn(u,m). -- Función: inverse_jacobi_ns (, ) Inversa de la función elíptica jacobiana ns(u,m). -- Función: inverse_jacobi_sc (, ) Inversa de la función elíptica jacobiana sc(u,m). -- Función: inverse_jacobi_sd (, ) Inversa de la función elíptica jacobiana sd(u,m). -- Función: inverse_jacobi_nc (, ) Inversa de la función elíptica jacobiana nc(u,m). -- Función: inverse_jacobi_cs (, ) Inversa de la función elíptica jacobiana cs(u,m). -- Función: inverse_jacobi_cd (, ) Inversa de la función elíptica jacobiana cd(u,m). -- Función: inverse_jacobi_nd (, ) Inversa de la función elíptica jacobiana nc(u,m). -- Función: inverse_jacobi_ds (, ) Inversa de la función elíptica jacobiana ds(u,m). -- Función: inverse_jacobi_dc (, ) Inversa de la función elíptica jacobiana dc(u,m).  File: maxima.info, Node: Funciones y variables para integrales elípticas, Prev: Funciones y variables para funciones elípticas, Up: Funciones elípticas 17.3 Funciones y variables para integrales elípticas ==================================================== -- Función: elliptic_f (, ) Integral elíptica incompleta de primera especie, definida como integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi) Véanse también `elliptic_e' y `elliptic_kc'. -- Función: elliptic_e (, ) Integral elíptica incompleta de segunda especie, definida como elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi) Véanse también `elliptic_e' y `elliptic_ec'. -- Función: elliptic_eu (, ) Integral elíptica incompleta de segunda especie, definida como integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t, 0, tau) donde tau = sn(u,m) Esto se relaciona con `elliptic_e' mediante elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m) Véase también `elliptic_e'. -- Función: elliptic_pi (, , ) Integral elíptica incompleta de tercera especie, definida como integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi) Maxima sólo conoce la derivada respecto de phi. -- Función: elliptic_kc () Integral elíptica completa de primera especie, definida como integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2) Para algunos valores de m, se conoce el valor de la integral en términos de la función Gamma. Hágase uso de `makegamma' para realizar su cálculo. -- Función: elliptic_ec () Integral elíptica completa de segunda especie, definida como integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2) Para algunos valores de m, se conoce el valor de la integral en términos de la función Gamma. Hágase uso de `makegamma' para realizar su cálculo.  File: maxima.info, Node: Límites, Next: Diferenciación, Prev: Funciones elípticas, Up: Top 18 Límites ********** * Menu: * Funciones y variables para límites::  File: maxima.info, Node: Funciones y variables para límites, Prev: Límites, Up: Límites 18.1 Funciones y variables para límites ======================================= -- Variable optativa: lhospitallim Valor por defecto: 4 Es el número máximo de veces que la regla de L'Hopital es aplicada en la función `limit', evitando bucles infinitos al iterar la regla en casos como `limit (cot(x)/csc(x), x, 0)'. -- Función: limit (, , ,

) -- Función: limit (, , ) -- Función: limit () Calcula el ímite de cuando la variable real se aproxima al valor desde la dirección . El argumento puede ser el valor `plus' para un límite por la derecha, `minus' para un límite por la izquierda o simplemente se omite para indicar un límite en ambos sentidos. La función `limit' utiliza los símbolos especiales siguientes: `inf' (más infinito) y `minf' (menos infinito). En el resultado también puede hacer uso de `und' (indefinido), `ind' (indefinido pero acotado) y `infinity' (infinito complejo). La variable `lhospitallim' guarda el número máximo de veces que la regla de L'Hopital es aplicada en la función `limit', evitando bucles infinitos al iterar la regla en casos como `limit (cot(x)/csc(x), x, 0)'. Si la variable `tlimswitch' vale `true' hará que el paquete sobre límites utilice desarrollos de Taylor siempre que sea posible. La variable `limsubst' evita que la función `limit' realice sustituciones sobre formas desconocidas, a fin de evitar fallos tales como que `limit (f(n)/f(n+1), n, inf)' devuelva 1. Dándole a `limsubst' el valor `true' se permitirán tales sustituciones. La función `limit' con un solo argumento se utiliza frecuentemente para simplificar expresiones constantes, como por ejemplo `limit (inf-1)'. La instrucción `example (limit)' muestra algunos ejemplos. Para información sobre el método utilizado véase Wang, P., "Evaluation of Definite Integrals by Symbolic Manipulation", Ph.D. thesis, MAC TR-92, October 1971. -- Variable optativa: limsubst Valor por defecto: `false' La variable `limsubst' evita que la función `limit' realice sustituciones sobre formas desconocidas, a fin de evitar fallos tales como que `limit (f(n)/f(n+1), n, inf)' devuelva 1. Dándole a `limsubst' el valor `true' se permitirán tales sustituciones. -- Función: tlimit (, , , ) -- Función: tlimit (, , ) -- Función: tlimit () Devuelve el límite solicitado dándole a `tlimswitch' el valor `true'. -- Variable optativa: tlimswitch Valor por defecto: `false' Si la variable `tlimswitch' vale `true' hará que el paquete sobre límites utilice desarrollos de Taylor siempre que sea posible.  File: maxima.info, Node: Diferenciación, Next: Integración, Prev: Límites, Up: Top 19 Diferenciación ***************** * Menu: * Funciones y variables para la diferenciación::  File: maxima.info, Node: Funciones y variables para la diferenciación, Prev: Diferenciación, Up: Diferenciación 19.1 Funciones y variables para la diferenciación ================================================= -- Función: antid (, , ) Devuelve una lista con dos elementos, de manera que se pueda calcular la antiderivada de respecto de a partir de la lista. La expresión puede contener una función no especificada y sus derivadas. Sea la lista con dos elementos que devuelve la función `antid'. Entonces, `[1] + 'integrate ([2], )' es una antiderivada de con respecto a . Si la ejecución de `antid' resulta exitosa, el segundo elemento de la lista retornada es cero. En caso contrario, el segundo elemento es distinto de cero y el primero puede ser nulo o no. Si `antid' no es capaz de hacer ningún progreso, el primer elemento es nulo y el segundo no nulo. Es necesario ejecutar `load ("antid")' para cargar esta función. El paquete `antid' define también las funciones `nonzeroandfreeof' y `linear'. La función `antid' está relacionada con `antidiff' como se indica a continuación. Sea la lista devuelta por la función `antid'. Entonces, el resultado de `antidiff' es igual a `[1] + 'integrate ([2], )', donde es la variable de integración. Ejemplos: (%i1) load ("antid")$ (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); z(x) d (%o2) y(x) %e (-- (z(x))) dx (%i3) a1: antid (expr, x, z(x)); z(x) z(x) d (%o3) [y(x) %e , - %e (-- (y(x)))] dx (%i4) a2: antidiff (expr, x, z(x)); / z(x) [ z(x) d (%o4) y(x) %e - I %e (-- (y(x))) dx ] dx / (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); (%o5) 0 (%i6) antid (expr, x, y(x)); z(x) d (%o6) [0, y(x) %e (-- (z(x)))] dx (%i7) antidiff (expr, x, y(x)); / [ z(x) d (%o7) I y(x) %e (-- (z(x))) dx ] dx / -- Función: antidiff (, , ()) Devuelve la antiderivada de respecto de . La expresión puede contener una función no especificada y sus derivadas. Cuando `antidiff' se ejecuta con éxito, la expresión resultante no tiene símbolos integrales (esto es, no tiene referencias a la función `integrate'). En otro caso, `antidiff' devuelve una expresión que se encuentra total o parcialmente bajo el signo de integración. Si `antidiff' no puede ralizar ningún progreso, el valor devuelto se encuentra completamente bajo la integral. Es necesario ejecutar `load ("antid")' para cargar esta función. El paquete `antid' define también las funciones `nonzeroandfreeof' y `linear'. La función `antidiff' está relacionada con `antid' como se indica a continuación. Sea la lista de dos elementos que devuelve `antid'. Entonces, el valor retornado por `antidiff' es igual a `[1] + 'integrate ([2], )', donde es la variable de integración. Ejemplos: (%i1) load ("antid")$ (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); z(x) d (%o2) y(x) %e (-- (z(x))) dx (%i3) a1: antid (expr, x, z(x)); z(x) z(x) d (%o3) [y(x) %e , - %e (-- (y(x)))] dx (%i4) a2: antidiff (expr, x, z(x)); / z(x) [ z(x) d (%o4) y(x) %e - I %e (-- (y(x))) dx ] dx / (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); (%o5) 0 (%i6) antid (expr, x, y(x)); z(x) d (%o6) [0, y(x) %e (-- (z(x)))] dx (%i7) antidiff (expr, x, y(x)); / [ z(x) d (%o7) I y(x) %e (-- (z(x))) dx ] dx / -- Propiedad: atomgrad La propiedad `atomgrad' es asignada por `gradef'. -- Función: atvalue (, [ = , ..., = ], ) -- Función: atvalue (, = , ) Asigna el valor a en el punto ` = '. La expresión es una función del tipo `(, ..., )', o una derivada, `diff ((, ..., ), , , ..., , )' en la que aparecen los argumentos de la función de forma explícita. Los símbolos se refieren al orden de diferenciación respecto de . El punto en el que `atvalue' establece el valor se especifica mediante la lista de ecuaciones `[ = , ..., = ]'. Si hay una única variable , la ecuación puede escribirse sin formar parte de una lista. La llamada `printprops ([, , ...], atvalue)' muestra los valores asignados por `atvalue' a las funciones `, , ...'. La llamada `printprops (, atvalue)' muestra los valores asignados por `atvalue' a la función . La llamada `printprops (all, atvalue)' muestra los valores asignados por `atvalue' a todas las funciones. Los símbolos `@1', `@2', ... representan las variables , , ... cuando se muestran los valores asignados por `atvalue'. La función `atvalue' evalúa sus argumentos y devuelve , el valor asignado. Ejemplos: (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2); 2 (%o1) a (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y); (%o2) @2 + 1 (%i3) printprops (all, atvalue); ! d ! --- (f(@1, @2))! = @2 + 1 d@1 ! !@1 = 0 2 f(0, 1) = a (%o3) done (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x); d d (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y))) dx dx (%i5) at (%, [x = 0, y = 1]); ! 2 d ! (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! ) dx ! !x = 0, y = 1 -- Función: cartan - El cálculo exterior de formas diferenciales es una herramienta básica de la geometría diferencial desarrollada por Elie Cartan, teniendo importantes aplicaciones en la teoría de ecuaciones diferenciales en derivadas parciales. El paquete `cartan' dispone de las funciones `ext_diff' y `lie_diff', así como de los operadores `~' (producto exterior) y `|' (contracción de una forma con un vector). La orden `demo (tensor)' permite ver una breve descripción de estas instrucciones, junto con ejemplos. El paquete `cartan' fue escrito por F.B. Estabrook y H.D. Wahlquist. -- Función: del () La expresión `del ()' representa el diferencial de la variable x. La función `diff' devuelve una expresión que contiene a `del' si no se ha especificado una variable independiente. En este caso, el valor retornado es el llamado "diferencial total". Ejemplos: (%i1) diff (log (x)); del(x) (%o1) ------ x (%i2) diff (exp (x*y)); x y x y (%o2) x %e del(y) + y %e del(x) (%i3) diff (x*y*z); (%o3) x y del(z) + x z del(y) + y z del(x) -- Función: delta () Es la función delta de Dirac. En el estado actual de desarrollo de Maxima, sólo `laplace' reconoce la función `delta'. Ejemplo: (%i1) laplace (delta (t - a) * sin(b*t), t, s); Is a positive, negative, or zero? p; - a s (%o1) sin(a b) %e -- Variable del sistema: dependencies Valor por defecto: `[]' La variable `dependencies' es la lista de átomos que tienen algún tipo de dependencia funcional, asignada por `depends' o `gradef'. La lista `dependencies' es acumulativa: cada llamada a `depends' o `gradef' añade elementos adicionales. Véanse `depends' y `gradef'. -- Función: depends (, , ..., , ) Declara dependencias funcionales entre variables con el propósito de calcular derivadas. En ausencia de una dependencia declarada, `diff (f, x)' devuelve cero. Si se declara `depends (f, x)', `diff (f, x)' devuelve una derivada simbólica (esto es, una expresión con `diff'). Cada argumento , , etc., puede ser el nombre de una variable, de un arreglo o una lista de nombres. Cada elemento de (quizás un único elemento) se declara como dependiente de cada elemento de (quizás también un único elemento). Si alguno de los es el nombre de un arreglo o contiene el nombre de un arreglo, todos los elemento del arregl dependen de . La función `diff' reconoce dependencias indirectas establecidas por `depends' y aplica la regla de la cadena en tales casos. La instrucción `remove (, dependency)' borra todas las dependencias declaradas para . La función `depends' devuelve una lista con las dependencias que han sido establecidas. Las dependencias se añaden a la variable global `dependencies'. La función `depends' evalúa sus argumentos. La función `diff' es la única instrucción de Maxima que reconoce las dependencias establecidas por `depends'. Otras funciones (`integrate', `laplace', etc.) solamente reconocen dependencias explícitamente representadas por sus argumentos. Por ejemplo, `integrate' no reconoce la dependencia de `f' respecto de `x' a menos que se represente explícitamente como `integrate (f(x), x)'. (%i1) depends ([f, g], x); (%o1) [f(x), g(x)] (%i2) depends ([r, s], [u, v, w]); (%o2) [r(u, v, w), s(u, v, w)] (%i3) depends (u, t); (%o3) [u(t)] (%i4) dependencies; (%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)] (%i5) diff (r.s, u); dr ds (%o5) -- . s + r . -- du du (%i6) diff (r.s, t); dr du ds du (%o6) -- -- . s + r . -- -- du dt du dt (%i7) remove (r, dependency); (%o7) done (%i8) diff (r.s, t); ds du (%o8) r . -- -- du dt -- Variable optativa: derivabbrev Valor por defecto: `false' Si `derivabbrev' vale `true', las derivadas simbólicas (esto es, expresiones con `diff') se muestran como subíndices. En otro caso, las derivadas se muestran en la notación de Leibniz, `dy/dx'. -- Función: derivdegree (, , ) Devuelve el mayor grado de la derivada de la variable dependiente respecto de la variable independiente que aparece en . Ejemplo: (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2; 3 2 d y d y 2 dy (%o1) --- + --- + x -- 3 2 dx dz dx (%i2) derivdegree (%, y, x); (%o2) 2 -- Función: derivlist (, ..., ) Hace que las derivadas calculadas por la instrucción `ev' se calculen respecto de las variables indicadas. -- Variable optativa: derivsubst Valor por defecto: `false' Si `derivsubst' vale `true', una sustitución no sintáctica del estilo `subst (x, 'diff (y, t), 'diff (y, t, 2))' devuelve `'diff (x, t)'. -- Función: diff (, , , ..., , ) -- Función: diff (, , ) -- Función: diff (, ) -- Función: diff () Devuelve la derivada o diferencial de respecto de alguna o de todas las variables presentes en . La llamada `diff (, , )' devuelve la -esima derivada de respecto de . La llamada `diff (, , , ..., , )' devuelve la derivada parcial de con respecto de , ..., . Equivale a `diff (... (diff (, , ) ...), , )'. La llamada `diff (, )' devuelve la primera derivada de respecto de la variable . La llamada `diff ()' devuelve el diferencial total de , esto es, la suma de las derivadas de respecto de cada una de sus variables, multiplicadas por el diferencial `del' de cada una de ellas. La forma nominal de `diff' es necesaria en algunos contextos, como para definir ecuaciones diferenciales. En tales casos, `diff' puede ir precedida de un apóstrofo (como `'diff') para evitar el cálculo de la derivada. Si `derivabbrev' vale `true', las derivadas se muestran como subíndices. En otro caso, se muestran en la notación de Leibniz, `dy/dx'. Ejemplos: (%i1) diff (exp (f(x)), x, 2); 2 f(x) d f(x) d 2 (%o1) %e (--- (f(x))) + %e (-- (f(x))) 2 dx dx (%i2) derivabbrev: true$ (%i3) 'integrate (f(x, y), y, g(x), h(x)); h(x) / [ (%o3) I f(x, y) dy ] / g(x) (%i4) diff (%, x); h(x) / [ (%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x) ] x x x / g(x) Para el paquete sobre tensores se han introducido las siguientes modificaciones: (1) Las derivadas de los objetos indexados en tendrán las variables añadidas como argumentos adicionales. Entonces se ordenarán todos los índices de derivadas. (2) Las pueden ser enteros entre 1 hasta el valor de la variable `dimension' [valor por defecto: 4]. Esto hará que la diferenciación sea llevada a cabo con respecto al -ésimo número de la lista `coordinates', la cual debería contener una lista con los nombres de las coordenadas, por ejemplo, `[x, y, z, t]'. Si `coordinates' es una variableis atómica, entonces esa variable será utilizada como variable de diferenciación. Se permite la utilización de arreglos con los nombres de las coordenadas o nombres con subíndices, como `X[1]', `X[2]', ... to be used. Si a `coordinates' no se le ha asignado ningún valor, entonces las variables serán tratadas como se ha indicado en (1). -- Símbolo especial: diff Si el nombre `diff' está presente en una llamada a la función `ev' en modo `evflag', entonces se calculan todas las derivadas presentes en `expr'. -- Función: express () Transforma los nombres de los operadores diferenciales en expresiones que contienen derivadas parciales. Los operadores reconocidos por la función `express' son: `grad' (gradiente), `div' (divergencia), `curl' (rotacional), `laplacian' (laplaciano) y `~' (producto vectorial). Las derivadas simbólicas (es decir, las que incluyen la forma nominal `diff') que aparecen en la expresión devuelta por `express', se pueden calcular pasándole a `ev' el argumento `diff', o escribiéndolo directamente en la línea de comandos. En este contexto, `diff' actúa como `evfun'. Es necesario ejecutar `load ("vect")' para cargar esta función. Ejemplos: (%i1) load ("vect")$ (%i2) grad (x^2 + y^2 + z^2); 2 2 2 (%o2) grad (z + y + x ) (%i3) express (%); d 2 2 2 d 2 2 2 d 2 2 2 (%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )] dx dy dz (%i4) ev (%, diff); (%o4) [2 x, 2 y, 2 z] (%i5) div ([x^2, y^2, z^2]); 2 2 2 (%o5) div [x , y , z ] (%i6) express (%); d 2 d 2 d 2 (%o6) -- (z ) + -- (y ) + -- (x ) dz dy dx (%i7) ev (%, diff); (%o7) 2 z + 2 y + 2 x (%i8) curl ([x^2, y^2, z^2]); 2 2 2 (%o8) curl [x , y , z ] (%i9) express (%); d 2 d 2 d 2 d 2 d 2 d 2 (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )] dy dz dz dx dx dy (%i10) ev (%, diff); (%o10) [0, 0, 0] (%i11) laplacian (x^2 * y^2 * z^2); 2 2 2 (%o11) laplacian (x y z ) (%i12) express (%); 2 2 2 d 2 2 2 d 2 2 2 d 2 2 2 (%o12) --- (x y z ) + --- (x y z ) + --- (x y z ) 2 2 2 dz dy dx (%i13) ev (%, diff); 2 2 2 2 2 2 (%o13) 2 y z + 2 x z + 2 x y (%i14) [a, b, c] ~ [x, y, z]; (%o14) [a, b, c] ~ [x, y, z] (%i15) express (%); (%o15) [b z - c y, c x - a z, a y - b x] -- Función: gradef ((, ..., ), , ..., ) -- Función: gradef (, , ) Define las derivadas parciales, o componentes del gradiente, de la función o variable . La llamada `gradef ((, ..., ), , ..., )' define `d/d' como , donde es una expresión; puede ser una llamada a función, pero no el nombre de una función. El número de derivadas parciales puede ser menor que el número de argumentos , en cuyo caso las derivadas se definen solamente con respecto a , ...., . La llamada `gradef (, , )' define la derivada de la variable respecto de en . Con esto se establece la dependencia de respecto de a través de `depends (, )'. El primer argumento `(, ..., )' o no se evalúa, pero sí lo hacen el resto de argumentos , ..., . La llamada a `gradef' devuelve la función o variable para la que se define la derivada parcial. La instrucción `gradef' puede redefinir las derivadas de las funciones propias de Maxima. Por ejemplo, `gradef (sin(x), sqrt (1 - sin(x)^2))' redefine la derivada de `sin'. La instrucción `gradef' no puede definir derivadas parciales de funciones subindicadas. La llamada `printprops ([, ..., ], gradef)' muestra las derivadas parciales de las funciones , ..., , tal como las definió `gradef'. La llamada `printprops ([, ..., ], atomgrad)' muestra las derivadas parciales de las variables , ..., , tal como las definió `gradef'. La variable `gradefs' contiene la lista de las funciones para las que se han definido derivadas parciales con la instrucción `gradef', pero no incluye las variables para las que se han definido las derivadas parciales. Los gradientes son necesarios cuando una función no se conoce explícitamente pero sí sus primeras derivadas y es necesario calcular las derivadas de orden mayor. -- Variable del sistema: gradefs Valor por defecto: `[]' La variable `gradefs' contiene la lista de las funciones para las que se han definido derivadas parciales con la instrucción `gradef', pero no incluye las variables para las que se han definido las derivadas parciales. -- Función: laplace (, , ) Calcula la transformada de Laplace de con respecto de la variable y parámetro de transformación . Si `laplace' no puede encontrar la solución, se devuelve la forma nominal `'laplace'. La función `laplace' reconoce en las funciones `delta', `exp', `log', `sin', `cos', `sinh', `cosh' y `erf', así como `derivative', `integrate', `sum' y `ilt'. Bajo la presencia de otras funciones, `laplace' puede que no sea capaz de calcular la transformada. La función `laplace' reconoce integrales de convolución de la forma `integrate (f(x) * g(t - x), x, 0, t)', no pudiendo reconocer otros tipos de convoluciones. Las relaciones funcionales se deben representar explícitamente en ; las relaciones implícitas establecidas por `depends' no son reconocidas. Así, si depende de y , `f (x, y)' debe aparecer en . Véase también `ilt', la transformada inversa de Laplace. Ejemplos: (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s); a %e (2 s - 4) (%o1) --------------- 2 2 (s - 4 s + 5) (%i2) laplace ('diff (f (x), x), x, s); (%o2) s laplace(f(x), x, s) - f(0) (%i3) diff (diff (delta (t), t), t); 2 d (%o3) --- (delta(t)) 2 dt (%i4) laplace (%, t, s); ! d ! 2 (%o4) - -- (delta(t))! + s - delta(0) s dt ! !t = 0  File: maxima.info, Node: Integración, Next: Ecuaciones, Prev: Diferenciación, Up: Top 20 Integración ************** * Menu: * Introducción a la integración:: * Funciones y variables para integración:: * Introducción a QUADPACK:: * Funciones y variables para QUADPACK::  File: maxima.info, Node: Introducción a la integración, Next: Funciones y variables para integración, Prev: Integración, Up: Integración 20.1 Introducción a la integración ================================== Maxima tiene varias rutinas para calcular integrales. La función `integrate' hace uso de la mayor parte de ellas. También está el paquete `antid', que opera con funciones no especificadas y sus derivadas. Para usos numéricos se dispone de la batería de integradores adaptativos de `QUADPACK', como `quad_qag', `quad_qags', etc., que se describen en la sección `QUADPACK'. También se trabajan funciones hipergeométricas, véase `specint' para más detalles. En términos generales, Maxima sólo opera con funciones que son integrables en términos de funciones elementales, como las racionales, trigonométricas, logarítmicas, exponenciales, radicales, etc., y unas pocas extensiones de éstas, como la función de error o los dilogaritmos. No opera con integrales en términos de funciones desconocidas, como `g(x)' o `h(x)'.  File: maxima.info, Node: Funciones y variables para integración, Next: Introducción a QUADPACK, Prev: Introducción a la integración, Up: Integración 20.2 Funciones y variables para integración =========================================== -- Función: changevar (, , , ) Hace el cambio de variable dado por ` = 0' en todas las integrales que aparecen en con la integración respecto de . La nueva variable será . (%i1) assume(a > 0)$ (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4); 4 / [ sqrt(a) sqrt(y) (%o2) I %e dy ] / 0 (%i3) changevar (%, y-z^2/a, z, y); 0 / [ abs(z) 2 I z %e dz ] / - 2 sqrt(a) (%o3) - ---------------------------- a Si una expresión contiene formas nominales, como aquélla en la que aparece `'integrate' en el ejemplo, podrá ser evaluada por `ev' si se utiliza el término `nouns'. Por ejemplo, la expresión devuelta por `changevar' se puede evaluar haciendo `ev (%o3, nouns)'. La función `changevar' también se puede utilizar para cambiar los índices de una suma o producto. Sin embargo, debe tenerse en cuenta que cuando se realiza un cambio en una suma o producto, el mismo debe expresarse en términos de sumas, como `i = j+ ...', no como una función de mayor grado. Ejemplo: (%i4) sum (a[i]*x^(i-2), i, 0, inf); inf ==== \ i - 2 (%o4) > a x / i ==== i = 0 (%i5) changevar (%, i-2-n, n, i); inf ==== \ n (%o5) > a x / n + 2 ==== n = - 2 -- Función: dblint (, , , , ) Es una rutina para integrales dobles escrita en lenguaje Maxima y posteriormente traducida y compilada a código máquina. La instrucción `load (dblint)' carga esta función. Utiliza el método de Simpson en las dos direcciones `x' e `y' para calcular /b /s(x) | | | | f(x,y) dy dx | | /a /r(x) La función debe ser una función traducida o compilada de dos variables, a la vez que y deben ser cada una de ellas una función traducida o compilada de una variable, mientras que y deben ser números en coma flotante. La rutina tiene dos variables globales que determinan el número de divisiones de los intervalos `x' e `y': `dblint_x' y `dblint_y', ambos con un valor por defecto de 10, pero que pueden cambiarse de forma independiente a otros valores enteros (hay `2*dblint_x+1' puntos a calcular en la dirección `x' y `2*dblint_y+1' en la dirección `y'). La rutina subdivide el eje X y luego para cada valor de X calcula primero `(x)' y `(x)'; entonces se subdivide el eje Y entre `(x)' y `(x)', evaluándose la integral a lo largo del eje Y aplicando la regla de Simpson; a continuación, se evalúa la integral a lo largo del eje X utilizando también la regla de Simpson tomando como valores de función las integrales sobre Y. Este procedimiento puede ser numéricamente inestable por múltiples motivos, pero es razonablemente rápido: evítese su uso con funciones con grandes oscilaciones o que tengan singularidades. Las integrales del eje Y dependen de la proximidad de los límites `(x)' y `(x)', de manera que si la distancia `(x) - (x)' varía rápidamente con X, puede dar lugar errores importantes debido a truncamientos de diferente amplitud en las integrales de Y. Se puede aumentar `dblint_x' y `dblint_y' al objeto de mejorar el recubrimiento de la región de integración, pero a costa del tiempo de cómputo. Es necesario que las funciones , y estén traducidas o compiladas antes de utilizar `dblint', lo cual redundará en una mejora del tiempo de ejecución de varios órdenes de magnitud respecto de la ejecución de código interpretado. -- Función: defint (, , , ) Intenta calcular una integral definida. La función `defint' es invocada por `integrate' cuando se especifican los límites de integración, por ejemplo `integrate (, , , )'. Así, desde el punto de vista del usuario, es suficiente con utilizar `integrate'. La función `defint' devuelve una expresión simbólica, bien sea el resultado calculado o la forma nominal. Véase `quad_qag' y sus funciones relacionadas para aproximaciones numéricas de integrales definidas. -- Función: erf () Es la función de error, cuya derivada es `2*exp(-x^2)/sqrt(%pi)'. -- Variable optativa: erfflag Valor por defecto: `true' Si `erfflag' vale `false', la función `risch' no introduce la función `erf' en el resultado si no había ninguna en el integrando. -- Función: ilt (, , ) Calcula la transformada inversa de Laplace de con respecto de y parámetro . El argumento debe ser una fracción de polinomios cuyo denominador tenga sólo factores lineales y cuadráticos. Utilizando las funciones `laplace' y `ilt', junto con las funciones `solve' o `linsolve', el usuario podrá resolver ciertas ecuaciones integrales. (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2; t / [ 2 (%o1) I f(t - x) sinh(a x) dx + b f(t) = t ] / 0 (%i2) laplace (%, t, s); a laplace(f(t), t, s) 2 (%o2) b laplace(f(t), t, s) + --------------------- = -- 2 2 3 s - a s (%i3) linsolve ([%], ['laplace(f(t), t, s)]); 2 2 2 s - 2 a (%o3) [laplace(f(t), t, s) = --------------------] 5 2 3 b s + (a - a b) s (%i4) ilt (rhs (first (%)), s, t); Is a b (a b - 1) positive, negative, or zero? pos; sqrt(a b (a b - 1)) t 2 cosh(---------------------) 2 b a t (%o4) - ----------------------------- + ------- 3 2 2 a b - 1 a b - 2 a b + a 2 + ------------------ 3 2 2 a b - 2 a b + a -- Función: integrate (, ) -- Función: integrate (, , , ) Calcula simbólicamente la integral de respecto de . La llamada `integrate (, )' resuelve una integral indefinida, mientras que `integrate (, , , )' resuelve una integral definida con límites de integración y . Los límites no pueden contener a . El argumento no necesita ser menor que . Si es igual a , `integrate' devuelve cero. Véase `quad_qag' y funciones relacionadas para la aproximación numérica de integrales definidas. Véase `residue' para el cálculo de residuos (integración compleja). Véase `antid' para un método alternativo de resolución de integrales indefinidas. Se obtendrá una integral (es decir, una expresión sin `integrate') si `integrate' tiene éxito en el cálculo. En otro caso, la respuesta es la forma nominal de la integral (esto es, el operador `'integrate' precedido de apóstrofo) o una expresión que contiene una o más formas nominales. La forma nominal de `integrate' se muestra con un símbolo integral. En ciertos casos es útil proporcionar una forma nominal 'a mano', haciendo preceder `integrate' con una comilla simple o apóstrofo, como en `'integrate (, )'. Por ejemplo, la integral puede depender de algunos parámetros que todavía no han sido calculados. La forma nominal puede aplicarse después a sus argumentos haciendo `ev (, nouns)' donde es la forma nominal de interés. La función `integrate' trata de manera diferente las integrales definidas de las indefinidas, empleando una batería de heurísticas especial para cada caso. Casos especiales de integrales definidas incluyen las que tienen límites de integración iguales a cero o a infinito (`inf' o `minf'), funciones trigonométricas con límites de integración igual a cero y `%pi' o `2 %pi', funciones racionales, integrales relacionadas con las funciones `beta' y `psi' y algunas integrales logarítmicas y trigonométricas. El tratamiento de funciones racionales puede incluir el cálculo de residuos. Si no se reconoce ninguno de los casos especiales, se intenta resolver la integral idefinida y evaluarla en los límites de integración. Esto incluye tomar límites cuando alguno de los extremos del intervalo de integración se acerca a más infinito o a menos infinito; véase también `ldefint'. Casos especiales de integrales indefinidas incluyen a las funciones trigonométricas, exponenciales, logarítmicas y racionales. La función `integrate' también hace uso de una pequeña tabla de integrales elementales. La función `integrate' puede llevar a cabo cambios de variable si el integrando es de la forma `f(g(x)) * diff(g(x), x)', entonces `integrate' trata de encontrar una subexpresión de `g(x)' tal que la derivada de `g(x)' divida el integrando. Esta búsqueda puede hacer uso de las derivadas establecidas con la función `gradef'. Véanse también `changevar' y `antid'. Si ninguna de las heurísticas descritas resuelve la integral indefinida, se ejecuta el algoritmo de Risch. La variable `risch' puede utilizarse como una `evflag', en una llamada a `ev' o en la línea de comandos por ejemplo, `ev (integrate (, ), risch)' o `integrate (, ), risch'. Si `risch' está presenta, `integrate' llama a la función `risch' sin intentar primero las heurísticas. Véase también `risch'. La función `integrate' opera únicamente con relaciones funcionales que se representen explícitamente con la notación `f(x)', sin considerar las dependencias implícitas establecidas mediante la función `depends'. Es posible que `integrate' necesite conocer alguna propiedad de alguno de los parámetros presentes en el integrando, en cuyo caso `integrate' consultará en primer lugar la base de datos creada con `assume', y si la variable de interés no se encuentra ahí, `integrate' le preguntará al usuario. Dependiendo de la pregunta, posibles respuestas son: `yes;', `no;', `pos;', `zero;' o `neg;'. Por defecto, `integrate' no se considera lineal. Véanse `declare' y `linear'. La función `integrate' intentará la integración por partes sólo en casos especiales. Ejemplos: * Integrales elementales indefinidas y definidas. (%i1) integrate (sin(x)^3, x); 3 cos (x) (%o1) ------- - cos(x) 3 (%i2) integrate (x/ sqrt (b^2 - x^2), x); 2 2 (%o2) - sqrt(b - x ) (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi); %pi 3 %e 3 (%o3) ------- - - 5 5 (%i4) integrate (x^2 * exp(-x^2), x, minf, inf); sqrt(%pi) (%o4) --------- 2 * Utilización de `assume' e interacción. (%i1) assume (a > 1)$ (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf); 2 a + 2 Is ------- an integer? 5 no; Is 2 a - 3 positive, negative, or zero? neg; 3 (%o2) beta(a + 1, - - a) 2 * Cambio de variable. En este ejemplo hay dos cambios de variable: uno utilizando una derivada establecida con `gradef' y otra utilizando la derivada `diff(r(x))' de una función no especificada `r(x)'. (%i3) gradef (q(x), sin(x**2)); (%o3) q(x) (%i4) diff (log (q (r (x))), x); d 2 (-- (r(x))) sin(r (x)) dx (%o4) ---------------------- q(r(x)) (%i5) integrate (%, x); (%o5) log(q(r(x))) * El valor devuelto contiene la forma nominal `'integrate'. En este ejemplo, Maxima puede extraer un factor del denominador de una función racional, pero no puede factorizar el resto. La función `grind' muestra la forma nominal `'integrate' del resultado. Véase también `integrate_use_rootsof' para más información sobre integrales de funciones racionales. (%i1) expand ((x-4) * (x^3+2*x+1)); 4 3 2 (%o1) x - 4 x + 2 x - 7 x - 4 (%i2) integrate (1/%, x); / 2 [ x + 4 x + 18 I ------------- dx ] 3 log(x - 4) / x + 2 x + 1 (%o2) ---------- - ------------------ 73 73 (%i3) grind (%); log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$ * Definición de una función mediante una integral. El cuerpo de una función no se evalúa cuando ésta se define, de manera que el cuerpo de `f_1' en este ejemplo contiene la forma nominal de `integrate'. El operador comilla-comilla `''' hace que se evalúe la integral y su resultado será el que defina a la función `f_2'. (%i1) f_1 (a) := integrate (x^3, x, 1, a); 3 (%o1) f_1(a) := integrate(x , x, 1, a) (%i2) ev (f_1 (7), nouns); (%o2) 600 (%i3) /* Note parentheses around integrate(...) here */ f_2 (a) := ''(integrate (x^3, x, 1, a)); 4 a 1 (%o3) f_2(a) := -- - - 4 4 (%i4) f_2 (7); (%o4) 600 -- Variable del sistema: integration_constant_counter Valor por defecto: 0 La variable `integration_constant_counter' es un contador que se actualiza cada vez que se introduce una constante de integración en una expresión como resultado de una integración indefinida. -- Variable optativa: integrate_use_rootsof Valor por defecto: `false' Si `integrate_use_rootsof' vale `true' y el denominador de una función racional no se puede factorizar, `integrate' devuelve la integral como una suma respecto de las raíces desconocidas del denominador. Por ejemplo, dándole a `integrate_use_rootsof' el valor `false', `integrate' devuelve la integral no resuelta de la función racional en forma nominal: (%i1) integrate_use_rootsof: false$ (%i2) integrate (1/(1+x+x^5), x); / 2 [ x - 4 x + 5 I ------------ dx 2 x + 1 ] 3 2 2 5 atan(-------) / x - x + 1 log(x + x + 1) sqrt(3) (%o2) ----------------- - --------------- + --------------- 7 14 7 sqrt(3) Si ahora se le da a la variable el valor `true', la parte no resuelta de la integral se expresa como una suma cuyos sumandos dependen de las raíces del denominador de la función racional: (%i3) integrate_use_rootsof: true$ (%i4) integrate (1/(1+x+x^5), x); ==== 2 \ (%r4 - 4 %r4 + 5) log(x - %r4) > ------------------------------- / 2 ==== 3 %r4 - 2 %r4 3 2 %r4 in rootsof(x - x + 1) (%o4) ---------------------------------------------------------- 7 2 x + 1 2 5 atan(-------) log(x + x + 1) sqrt(3) - --------------- + --------------- 14 7 sqrt(3) Alternativamente, el usuario puede calcular las raíces del denominador separadamente y luego representar el integrando en función de dichas raíces, como por ejemplo `1/((x - a)*(x - b)*(x - c))' o `1/((x^2 - (a+b)*x + a*b)*(x - c))' si el denominador es un polinomio de tercer grado. En algunos casos, esto ayudará a Maxima mejorar sus resultados. -- Función: ldefint (, , , ) Calcula la integral definida de utilizando `limit' tras el cálculo de la integral indefinida de respecto a en los extremos de integración y . Si no consigue calcular la integral definida, `ldefint' devuelve una expresión con los límites en forma nominal. La función `integrate' no llama a `ldefint', de modo que la ejecución de `ldefint (, , , )' puede dar un resultado diferente que `integrate (, , , )'. La función `ldefint' siempre utiliza el mismo método para calcular la integral definida, mientras que `integrate' puede hacer uso de varias heurísticas y reconocer así casos especiales. -- Función: residue (, , ) Calcula el residuo en el plano complejo de la expresión cuando la variable toma el valor . El residuo es el coeficiente de `( - )^(-1)' en el desarrollo de Laurent de . (%i1) residue (s/(s**2+a**2), s, a*%i); 1 (%o1) - 2 (%i2) residue (sin(a*x)/x**4, x, 0); 3 a (%o2) - -- 6 -- Función: risch (, ) Integra respecto de utilizando el caso trascendental del algoritmo de Risch. El caso algebraico del algoritmo de Risch no se ha implementado. Este método trata los casos de exponenciales y logaritmos anidados que no resuelve el procedimiento principal de `integrate'. La función `integrate' llamará automáticamente a `risch' si se presentan estos casos. Si la variable `erfflag' vale `false', evita que `risch' introduzca la función `erf' en la respuesta si ésta no estaba presente previamente en el integrando. (%i1) risch (x^2*erf(x), x); 2 3 2 - x %pi x erf(x) + (sqrt(%pi) x + sqrt(%pi)) %e (%o1) ------------------------------------------------- 3 %pi (%i2) diff(%, x), ratsimp; 2 (%o2) x erf(x) -- Función: tldefint (, , , ) Equivale a `ldefint' cuando `tlimswitch' vale `true'.  File: maxima.info, Node: Introducción a QUADPACK, Next: Funciones y variables para QUADPACK, Prev: Funciones y variables para integración, Up: Integración 20.3 Introducción a QUADPACK ============================ QUADPACK es un conjunto de funciones para el cálculo numérico de integrales definidas de una variable. Se creó a partir de un trabajo conjunto de R. Piessens (1), E. de Doncker (2), C. Ueberhuber (3), and D. Kahaner (4). La librería QUADPACK incluida en Maxima es una traducción automática (mediante el programa `f2cl') del código fuente Fortran de QUADPACK tal como se encuentra en la SLATEC Common Mathematical Library,Versión 4.1 (5). La librería SLATEC está fechada en julio de 1993, pero las funciones QUADPACK fueron escritas algunos años antes. Hay otra versión de QUADPACK en Netlib (6), pero no está claro hasta qué punto difiere de la que forma parte de la librería SLATEC. Las funciones QUADPACK incluidas en Maxima son todas automáticas, en el sentido de que estas funciones intentan calcular sus resultados con una exactitud especificada, requiriendo un número indeterminado de evaluaciones de funciones. La traducción a Lisp que Maxima hace de QUADPACK incluye también algunas funciones que no son automáticas, pero que no son accesibles desde el nivel de Maxima. Se puede encontrar más información sobre QUADPACK en el libro (7). 20.3.1 Perspectiva general -------------------------- `quad_qag' Integración de una función general en un intervalo finito. La función `quad_qag' implementa un integrador global adaptativo simple utilizando una estrategia de Aind (Piessens, 1973). Se puede escoger entre seis pares de fórmulas de cuadratura de Gauss-Kronrod para la regla de evaluación. Las reglas de rango superior son útiles en los casos en los que los integrandos tienen un alto grado de oscilación. `quad_qags' Integración de una función general en un intervalo finito. La función `quad_qags' implementa la subdivisión de intervalos global adaptativa con extrapolación (de Doncker, 1978) mediante el algoritmo Epsilon (Wynn, 1956). `quad_qagi' Integración de una función general en un intervalo infinito o semi-infinito. El intervalo se proyecta sobre un intervalo finito y luego se aplica la misma estrategia que en `quad_qags'. `quad_qawo' Integración de cos(omega x) f(x) o sin(omega x) f(x) en un intervalo finito, siendo omega una constante. La regla de evaluación se basa en la técnica modificada de Clenshaw-Curtis. La función `quad_qawo' aplica la subdivisión adaptativa con extrapolación, de forma similar a `quad_qags'. `quad_qawf' Calcula la transformada seno o coseno de Fourier en un intervalo semi-infinito. Se aplica el mismo método que en `quad_qawo' a sucesivos intervalos finitos, acelerando la convergencia mediante el algoritmo Epsilon (Wynn, 1956). `quad_qaws' Integración de w(x) f(x) en un intervalo finito [a, b], siendo w una función de la forma (x - a)^alpha (b - x)^beta v(x), con v(x) igual a 1, a log(x - a), a log(b - x) o a log(x - a) log(b - x) y con alpha > -1, y beta > -1. Se aplica una estrategia de subdivisión adaptativa global, con integración de Clenshaw-Curtis modificada en los subintervalos que contienen a a y a b. `quad_qawc' Calcula el valor principal de Cauchy de f(x)/(x - c) en un intervalo finito (a, b) para una c dada. La estrategia es global adaptativa, utilizando la integración de Clenshaw-Curtis modificada en los subintervalos que contienen a x = c. ---------- Footnotes ---------- (1) Applied Mathematics and Programming Division, K.U. Leuven (2) Applied Mathematics and Programming Division, K.U. Leuven (3) Institut für Mathematik, T.U. Wien (4) National Bureau of Standards, Washington, D.C., U.S.A (5) `http://www.netlib.org/slatec' (6) `http://www.netlib.org/quadpack' (7) R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, and D.K. Kahaner. QUADPACK: A Subroutine Package for Automatic Integration. Berlin: Springer-Verlag, 1983, ISBN 0387125531.  File: maxima.info, Node: Funciones y variables para QUADPACK, Prev: Introducción a QUADPACK, Up: Integración 20.4 Funciones y variables para QUADPACK ======================================== -- Función: quad_qag (, , , , , , ) -- Función: quad_qag (, , , , , , ) Integración de una función general en un intervalo finito. La función `quad_qag' implementa un integrador global adaptativo simple utilizando una estrategia de Aind (Piessens, 1973). Se puede escoger entre seis pares de fórmulas de cuadratura de Gauss-Kronrod para la regla de evaluación. Las reglas de rango superior son útiles en los casos en los que los integrandos tienen un alto grado de oscilación. La función `quad_qag' calcula numéricamente la integral integrate (f(x), x, a, b) utilizando un integrador adaptativo simple. La función a integrar es , con variable independiente , siendo el intervalo de integración el comprendido entre y . El argumento indica el integrador a utilizar y debe ser un número entero entre 1 y 6, ambos inclusive. El valor de selecciona el orden de la regla de integración de Gauss-Kronrod. Las reglas de rango superior son útiles en los casos en los que los integrandos tienen un alto grado de oscilación. El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima. La integración numérica se hace de forma adaptativa particionando la región de integración en subintervalos hasta conseguir la precisión requerida. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. La función `quad_qag' devuelve una lista de cuatro elementos: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3); (%o1) [.4444444444492108, 3.1700968502883E-9, 961, 0] (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1); 4 (%o2) - 9 -- Función: quad_qags (, , , , , ) -- Función: quad_qags (, , , , , ) Integración de una función general en un intervalo finito. La función `quad_qags' implementa la subdivisión de intervalos global adaptativa con extrapolación (de Doncker, 1978) mediante el algoritmo Epsilon (Wynn, 1956). La función `quad_qags' calcula la integral integrate (f(x), x, a, b) La función a integrar es , de variable independiente , siendo el intervalo de integración el comprendido entre y . El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. La función `quad_qags' devuelve una lista de cuatro elementos: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `4' fallo de convergencia; `5' la integral es probablemente divergente o de convergencia lenta; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qags (x^(1/2)*log(1/x), x, 0 ,1); (%o1) [.4444444444444448, 1.11022302462516E-15, 315, 0] Nótese que `quad_qags' es más precisa y eficiente que `quad_qag' para este integrando. -- Función: quad_qagi (, , , , , ) -- Función: quad_qagi (, , , , , ) Integración de una función general en un intervalo infinito o semi-infinito. El intervalo se proyecta sobre un intervalo finito y luego se aplica la misma estrategia que en `quad_qags'. La función `quad_qagi' calcula cualquiera las siguientes integrales: integrate (f(x), x, a, inf) integrate (f(x), x, minf, a) integrate (f(x), x, minf, inf) utilizando la rutina QAGI de Quadpack QAGI. La función a integrar es , con variable independiente , siendo el intervalo de integración de rango infinito. El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima. El argumento determina el intervalo de integración como sigue: `inf' El intervalo es desde hasta más infinito. `minf' El intervalo es desde menos infinito hasta . `both' El intervalo es toda la recta real. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. La función `quad_qagi' devuelve una lista de cuatro elementos: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `4' fallo de convergencia; `5' la integral es probablemente divergente o de convergencia lenta; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf); (%o1) [0.03125, 2.95916102995002E-11, 105, 0] (%i2) integrate (x^2*exp(-4*x), x, 0, inf); 1 (%o2) -- 32 -- Función: quad_qawc (, , , , , , ) -- Función: quad_qawc (, , , , , , ) Calcula el valor principal de Cauchy de f(x)/(x - c) en un intervalo finito (a, b) para una c dada. La estrategia es global adaptativa, utilizando la integración de Clenshaw-Curtis modificada en los subintervalos que contienen a x = c. La función `quad_qawc' calcula el valor principal de Cauchy de integrate (f(x)/(x - c), x, a, b) utilizando la rutina QAWC de Quadpack. La función a integrar es `/( - )', con variable independiente , siendo el intervalo de integración el comprendido entre y . El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. `quad_qawc' returns a list of four elements: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5); (%o1) [- 3.130120337415925, 1.306830140249558E-8, 495, 0] (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), x, 0, 5); Principal Value alpha alpha 9 4 9 4 log(------------- + -------------) alpha alpha 64 4 + 4 64 4 + 4 (%o2) (----------------------------------------- alpha 2 4 + 2 3 alpha 3 alpha ------- ------- 2 alpha/2 2 alpha/2 2 4 atan(4 4 ) 2 4 atan(4 ) alpha - --------------------------- - -------------------------)/2 alpha alpha 2 4 + 2 2 4 + 2 (%i3) ev (%, alpha=5, numer); (%o3) - 3.130120337415917 -- Función: quad_qawf (, , , , , , , , ) -- Función: quad_qawf (, , , , , , , , ) Calcula la transformada seno o coseno de Fourier en un intervalo semi-infinito. Se aplica el mismo método que en `quad_qawo' a sucesivos intervalos finitos, acelerando la convergencia mediante el algoritmo Epsilon (Wynn, 1956). La función `quad_qawf' calcula la integral integrate (f(x)*w(x), x, a, inf) La función peso w se selecciona mediante : `cos' w(x) = cos (omega x) `sin' w(x) = sin (omega x) El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima Los argumentos opcionales son: El error absoluto deseado para la aproximación. El valor por defecto es 1d-10. Tamaño del arreglo interno de trabajo. ( - )/2 es el número máximo de subintervalos para la partición. El valor por defecto es 200. Número máximo de momentos de Chebyshev. Debe ser mayor que 0. El valor por defecto es 100. Cota superior del número de ciclos. Debe ser mayor o igual que 3. El valor por defecto es 10. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. `quad_qawf' returns a list of four elements: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos); (%o1) [.6901942235215714, 2.84846300257552E-11, 215, 0] (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf); - 1/4 %e sqrt(%pi) (%o2) ----------------- 2 (%i3) ev (%, numer); (%o3) .6901942235215714 -- Función: quad_qawo (, , , , , , , , , ) -- Función: quad_qawo (, , , , , , , , , ) Integración de cos(omega x) f(x) o sin(omega x) f(x) en un intervalo finito, siendo omega una constante. La regla de evaluación se basa en la técnica modificada de Clenshaw-Curtis. La función `quad_qawo' aplica la subdivisión adaptativa con extrapolación, de forma similar a `quad_qags'. La función `quad_qawo' realiza la integración utilizando la rutina QAWO de Quadpack: integrate (f(x)*w(x), x, a, b) La función peso w se selecciona mediante : `cos' w(x) = cos (omega x) `sin' w(x) = sin (omega x) El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima Los argumentos opcionales son: El error absoluto deseado para la aproximación. El valor por defecto es 1d-10. Tamaño del arreglo interno de trabajo. ( - )/2 es el número máximo de subintervalos para la partición. El valor por defecto es 200. Número máximo de momentos de Chebyshev. Debe ser mayor que 0. El valor por defecto es 100. Cota superior del número de ciclos. Debe ser mayor o igual que 3. El valor por defecto es 10. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. `quad_qawo' returns a list of four elements: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos); (%o1) [1.376043389877692, 4.72710759424899E-11, 765, 0] (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), x, 0, inf)); alpha/2 - 1/2 2 alpha sqrt(%pi) 2 sqrt(sqrt(2 + 1) + 1) (%o2) ----------------------------------------------------- 2 alpha sqrt(2 + 1) (%i3) ev (%, alpha=2, numer); (%o3) 1.376043390090716 -- Función: quad_qaws (, , , , , , , , ) -- Función: quad_qaws (, , , , , , , , ) Integración de w(x) f(x) en un intervalo finito [a, b], siendo w una función de la forma (x - a)^alpha (b - x)^beta v(x), con v(x) igual a 1, a log(x - a), a log(b - x) o a log(x - a) log(b - x) y con alpha > -1, y beta > -1. Se aplica una estrategia de subdivisión adaptativa global, con integración de Clenshaw-Curtis modificada en los subintervalos que contienen a a y a b. La función `quad_qaws' realiza la integración utizando la rutina QAWS de Quadpack: integrate (f(x)*w(x), x, a, b) La función peso w se selecciona mediante : `1' w(x) = (x - a)^alfa (b - x)^beta `2' w(x) = (x - a)^alfa (b - x)^beta log(x - a) `3' w(x) = (x - a)^alfa (b - x)^beta log(b - x) `4' w(x) = (x - a)^alfa (b - x)^beta log(x - a) log(b - x) El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima Los argumentos opcionales son: El error absoluto deseado para la aproximación. El valor por defecto es 1d-10. Tamaño del arreglo interno de trabajo. ( - )/2 es el número máximo de subintervalos para la partición. El valor por defecto es 200. Los argumentos opcionales y son el error relativo y el número máximo de subintervalos, respectivamente. La variable tiene por defecto el valor 1e-8 y el de 200. `quad_qaws' returns a list of four elements: * la aproximación a la integral, * el error absoluto estimado de la aproximación, * el número de evaluaciones del integrando, * un código de error. El código de error (el cuarto elemento del resultado) puede tener los siguientes valores: `0' si no ha habido problemas; `1' si se utilizaron demasiados intervalos; `2' si se encontró un número excesivo de errores de redondeo; `3' si el integrando ha tenido un comportamiento extraño frente a la integración; `6' si los argumentos de entrada no son válidos. Ejemplos: (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1); (%o1) [8.750097361672832, 1.24321522715422E-10, 170, 0] (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1); alpha Is 4 2 - 1 positive, negative, or zero? pos; alpha alpha 2 %pi 2 sqrt(2 2 + 1) (%o2) ------------------------------- alpha 4 2 + 2 (%i3) ev (%, alpha=4, numer); (%o3) 8.750097361672829  File: maxima.info, Node: Ecuaciones, Next: Ecuaciones Diferenciales, Prev: Integración, Up: Top 21 Ecuaciones ************* * Menu: * Funciones y variable para las ecuaciones::  Local Variables: coding: iso-8859-1 End: