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 draw, Next: Funciones y variables para picture, Prev: Introducción a draw, Up: draw 48.2 Funciones y variables para draw ==================================== -- Opción gráfica: xrange Valor por defecto: `false' Cuando `xrange' vale `false', el rango de la coordenada se calcula de forma automática. Si el usuario quiere especificar un intervalo para , éste debe expresarse como una lista de Maxima, como en `xrange=[-2, 3]'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [-3,5], explicit(x^2,x,-1,1))$ Véanse también `yrange' y `zrange'. -- Opción gráfica: yrange Valor por defecto: `false' Cuando `yrange' vale `false', el rango de la coordenada se calcula de forma automática. Si el usuario quiere especificar un intervalo para , éste debe expresarse como una lista de Maxima, como en `yrange=[-2, 3]'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(yrange = [-2,3], explicit(x^2,x,-1,1), xrange = [-3,3])$ Véanse también `xrange' y `zrange'. -- Opción gráfica: zrange Valor por defecto: `false' Cuando `zrange' vale `false', el rango de la coordenada se calcula de forma automática. Si el usuario quiere especificar un intervalo para , éste debe expresarse como una lista de Maxima, como en `zrange=[-2, 3]'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(yrange = [-3,3], zrange = [-2,5], explicit(x^2+y^2,x,-1,1,y,-1,1), xrange = [-3,3])$ Véanse también `yrange' y `zrange'. -- Opción gráfica: logx Valor por defecto: `false' Cuando `logx' vale `true', el eje se dibujará en la escala logarítmica. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(explicit(log(x),x,0.01,5), logx = true)$ Véanse también `logy' y `logz'. -- Opción gráfica: logy Valor por defecto: `false' Cuando `logy' vale `true', el eje se dibujará en la escala logarítmica. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(logy = true, explicit(exp(x),x,0,5))$ Véanse también `logx' y `logz'. -- Opción gráfica: logz Valor por defecto: `false' Cuando `logz' vale `true', el eje se dibujará en la escala logarítmica. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(logz = true, explicit(exp(u^2+v^2),u,-2,2,v,-2,2))$ Véanse también `logx' y `logy'. -- Opción gráfica: terminal Valor por defecto: `screen' Selecciona el terminal a utilizar por Gnuplot; valores posibles son: `screen' (por defecto), `png', `jpg', `eps' y `eps_color'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Examples: (%i1) load(draw)$ (%i2) /* screen terminal (default) */ draw2d(explicit(x^2,x,-1,1))$ (%i3) /* png file */ draw2d(terminal = 'png, pic_width = 300, explicit(x^2,x,-1,1))$ (%i4) /* jpg file */ draw2d(terminal = 'jpg, pic_width = 300, pic_height = 300, explicit(x^2,x,-1,1))$ (%i5) /* eps file */ draw2d(file_name = "myfile", explicit(x^2,x,-1,1), terminal = 'eps)$ Véanse también `file_name', `pic_width' y `pic_height'. -- Opción gráfica: grid Valor por defecto: `false' Cuando `grid' vale `true', se dibujará una rejilla sobre el plano . Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(grid = true, explicit(exp(u),u,-2,2))$ -- Opción gráfica: title Valor por defecto: `""' (cadena vacía) La opción `title' almacena una cadena de Maxima con el título de la escena. Por defecto, no se escribe título alguno. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(explicit(exp(u),u,-2,2), title = "Exponential function")$ -- Opción gráfica: xlabel Valor por defecto: `""' (cadena vacía) La opción `xlabel' almacena una cadena de Maxima con la etiqueta del eje . Por defecto, el eje no tiene etiqueta. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xlabel = "Time", explicit(exp(u),u,-2,2), ylabel = "Population")$ Véanse también `ylabel' y `zlabel'. -- Opción gráfica: ylabel Valor por defecto: `""' (cadena vacía) La opción `ylabel' almacena una cadena de Maxima con la etiqueta del eje . Por defecto, el eje no tiene etiqueta. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xlabel = "Time", ylabel = "Population", explicit(exp(u),u,-2,2) )$ Véanse también `xlabel' y `zlabel'. -- Opción gráfica: zlabel Valor por defecto: `""' (cadena vacía) La opción `zlabel' almacena una cadena de Maxima con la etiqueta del eje . Por defecto, el eje no tiene etiqueta. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(zlabel = "Z variable", ylabel = "Y variable", explicit(sin(x^2+y^2),x,-2,2,y,-2,2), xlabel = "X variable" )$ Véanse también `xlabel' y `ylabel'. -- Opción gráfica: xtics Valor por defecto: `true' Cuando `xtics' vale `true', se dibujarán las marcas del eje . Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) /* No tics in the x-axis */ draw2d(xtics = false, explicit(exp(u),u,-2,2))$ Véanse también `ytics' y `ztics'. -- Opción gráfica: ytics Valor por defecto: `true' Cuando `ytics' vale `true', se dibujarán las marcas del eje . Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(ytics = false, explicit(exp(u),u,-2,2), xtics = false)$ Véanse también `xtics' y `ztics'. -- Opción gráfica: ztics Valor por defecto: `true' Cuando `ztics' vale `true', se dibujarán las marcas del eje . Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) /* No tics in the z-axis */ draw3d(ztics = false, explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$ Véanse también `xtics' y `ytics'. -- Opción gráfica: rot_vertical Valor por defecto: 60 `rot_vertical' es el ángulo (en grados) de la rotación vertical (alrededor del eje ) para situar el punto del observador en las escenas 3d. El ángulo debe pertenecer al intervalo [0, 180]. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(rot_vertical = 170, explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$ Véase también `rot_horizontal'. -- Opción gráfica: rot_horizontal Valor por defecto: 30 `rot_horizontal' es el ángulo (en grados) de la rotación horizontal (alrededor del eje ) para situar el punto del observador en las escenas 3d. El ángulo debe pertenecer al intervalo [0, 360]. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(rot_vertical = 170, rot_horizontal = 360, explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$ Véase también `rot_vertical'. -- Opción gráfica: xy_file Valor por defecto: `""' (cadena vacía) `xy_file' es el nombre del fichero donde se almacenarán las coordenadas después de hacer clic con el botón del ratón en un punto de la imagen y pulsado la tecla 'x'. Por defecto, las coordenadas no se almacenan. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. -- Opción gráfica: user_preamble Valor por defecto: `""' (cadena vacía) Usuarios expertos en Gnuplot pueden hacer uso de esta opción para afinar el comportamiento de Gnuplot escribiendo código que será enviado justo antes de la instrucción `plot' o `splot'. El valor dado a esta opción debe ser una cadena alfanumérica o una lista de cadenas (una por línea). Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: El terminal dumb no está soportado por el paquete `draw', pero es posible activarlo haciendo uso de la opción `user_preamble', (%i1) load(draw)$ (%i2) draw2d(explicit(exp(x)-1,x,-1,1), parametric(cos(u),sin(u),u,0,2*%pi), user_preamble="set terminal dumb")$ -- Opción gráfica: file_name Valor por defecto: `"maxima_out"' `file_name' es el nombre del fichero en el que los terminales `png', `jpg', `eps' y `eps_color' guardarán el gráfico. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(file_name = "myfile", explicit(x^2,x,-1,1), terminal = 'png)$ Véanse también `terminal', `pic_width' y `pic_height'. -- Opción gráfica: pic_width Valor por defecto: 640 `pic_width' es la anchura del fichero de imagen de bits generado por los terminales `png' y `jpg'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(terminal = 'png, pic_width = 300, pic_height = 300, explicit(x^2,x,-1,1))$ Véanse también `terminal', `file_name' y `pic_height'. -- Opción gráfica: pic_height Valor por defecto: 640 `pic_height' es la altura del fichero de imagen de bits generado por los terminales `png' y `jpg'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(terminal = 'png, pic_width = 300, pic_height = 300, explicit(x^2,x,-1,1))$ Véanse también `terminal', `file_name' y `pic_width'. -- Opción gráfica: eps_width Valor por defecto: 12 `eps_width' es el ancho (medido en cm) del archivo Postscipt generado por los terminales `eps' y `eps_color'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(terminal = 'eps, eps_width = 3, eps_height = 3, explicit(x^2,x,-1,1))$ Véanse también `terminal', `file_name' y `eps_height'. -- Opción gráfica: eps_height Valor por defecto: 8 `eps_height' es la altura (medida en cm) del archivo Postscipt generado por los terminales `eps' y `eps_color'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(terminal = 'eps, eps_width = 3, eps_height = 3, explicit(x^2,x,-1,1))$ Véanse también `terminal', `file_name' y `eps_width'. -- Opción gráfica: axis_bottom Valor por defecto: `true' Cuando `axis_bottom' vale `true', el eje inferior permanece visible en las escenas 2d. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(axis_bottom = false, explicit(x^3,x,-1,1))$ Véanse también `axis_left', `axis_top', `axis_right' y `axis_3d'. -- Opción gráfica: axis_left Valor por defecto: `true' Cuando `axis_left' vale `true', el eje izquierdo permanece visible en las escenas 2d. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(axis_left = false, explicit(x^3,x,-1,1))$ Véanse también `axis_bottom', `axis_top', `axis_right' y `axis_3d'. -- Opción gráfica: axis_top Valor por defecto: `true' Cuando `axis_top' vale `true', el eje superior permanece visible en las escenas 2d. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(axis_top = false, explicit(x^3,x,-1,1))$ Véanse también `axis_bottom', `axis_left', `axis_right' y `axis_3d'. -- Opción gráfica: axis_right Valor por defecto: `true' Cuando `axis_right' vale `true', el eje derecho permanece visible en las escenas 2d. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(axis_right = false, explicit(x^3,x,-1,1))$ Véanse también `axis_bottom', `axis_left', `axis_top' y `axis_3d'. -- Opción gráfica: axis_3d Valor por defecto: `true' Cuando `axis_3d' vale `true', los ejes , y permanecen visibles en las escenas 3d. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(axis_3d = false, explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$ Véanse también `axis_bottom', `axis_left', `axis_top' y `axis_right' for axis in 2d. -- Opción gráfica: palette Valor por defecto: `color' `palette' indica cómo transformar los valores reales de una matriz pasada al objeto `image' en componentes cromáticas. `palette' es un vector de longitud tres con sus componentes tomando valores enteros en el rango desde -36 a +36; cada valor es un índice para seleccionar una fórmula que transforma los niveles numéricos en las componentes cromáticas rojo, verde y azul: 0: 0 1: 0.5 2: 1 3: x 4: x^2 5: x^3 6: x^4 7: sqrt(x) 8: sqrt(sqrt(x)) 9: sin(90x) 10: cos(90x) 11: |x-0.5| 12: (2x-1)^2 13: sin(180x) 14: |cos(180x)| 15: sin(360x) 16: cos(360x) 17: |sin(360x)| 18: |cos(360x)| 19: |sin(720x)| 20: |cos(720x)| 21: 3x 22: 3x-1 23: 3x-2 24: |3x-1| 25: |3x-2| 26: (3x-1)/2 27: (3x-2)/2 28: |(3x-1)/2| 29: |(3x-2)/2| 30: x/0.32-0.78125 31: 2*x-0.84 32: 4x;1;-2x+1.84;x/0.08-11.5 33: |2*x - 0.5| 34: 2*x 35: 2*x - 0.5 36: 2*x - 1 los números negativos se interpretan como colores invertidos de las componentes cromáticas. `palette = gray' y `palette = color' son atajos para `palette = [3,3,3]' y `palette = [7,5,15]', respectivamente. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplos: (%i1) load(draw)$ (%i2) im: apply( 'matrix, makelist(makelist(random(200),i,1,30),i,1,30))$ (%i3) /* palette = color, default */ draw2d(image(im,0,0,30,30))$ (%i4) draw2d(palette = gray, image(im,0,0,30,30))$ (%i5) draw2d(palette = [15,20,-4], colorbox=false, image(im,0,0,30,30))$ Véase también `colorbox'. -- Opción gráfica: colorbox Valor por defecto: `true' Cuando `colorbox' vale `true', se dibuja una escala de color al lado de los objetos `image'. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) im: apply('matrix, makelist(makelist(random(200),i,1,30),i,1,30))$ (%i3) draw2d(image(im,0,0,30,30))$ (%i4) draw2d(colorbox=false, image(im,0,0,30,30))$ Véase también `palette'. -- Opción gráfica: enhanced3d Valor por defecto: `false' Si `enhanced3d' vale `true', se coloreaerán las superficies de los gráficos tridimensionales; en otras palabras, se activa el modo pm3d de Gnuplot. Véase la opción `palette' para informarse sobre cómo se especifican las paletas de colores. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(surface_hide = true, enhanced3d = true, palette = gray, explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$ -- Opción gráfica: point_size Valor por defecto: 1 `point_size' establece el tamaño de los puntos dibujados. Debe ser un número no negativo. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `points'. * `gr3d': `points'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d( points(makelist([random(20),random(50)],k,1,10)), point_size = 5, points(makelist(k,k,1,20),makelist(random(30),k,1,20)))$ -- Opción gráfica: point_type Valor por defecto: 1 `point_type' indica cómo se van a dibujar los puntos aislados. Los valores para esta opción pueden ser índices enteros mayores o iguales que -1, o también nombres de estilos: `$none' (-1), `dot' (0), `plus' (1), `multiply' (2), `asterisk' (3), `square' (4), `filled_square' (5), `circle' (6), `filled_circle' (7), `up_triangle' (8), `filled_up_triangle' (9), `down_triangle' (10), `filled_down_triangle' (11), `diamant' (12) y `filled_diamant' (13). Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `points'. * `gr3d': `points'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,10], yrange = [0,10], point_size = 3, point_type = diamant, points([[1,1],[5,1],[9,1]]), point_type = filled_down_triangle, points([[1,2],[5,2],[9,2]]), point_type = asterisk, points([[1,3],[5,3],[9,3]]), point_type = filled_diamant, points([[1,4],[5,4],[9,4]]), point_type = 5, points([[1,5],[5,5],[9,5]]), point_type = 6, points([[1,6],[5,6],[9,6]]), point_type = filled_circle, points([[1,7],[5,7],[9,7]]), point_type = 8, points([[1,8],[5,8],[9,8]]), point_type = filled_diamant, points([[1,9],[5,9],[9,9]]) )$ -- Opción gráfica: points_joined Valor por defecto: `false' Cuando `points_joined' vale `true', los puntos se unen con segmentos. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `points'. * `gr3d': `points'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,10], yrange = [0,4], point_size = 3, point_type = up_triangle, color = blue, points([[1,1],[5,1],[9,1]]), points_joined = true, point_type = square, line_type = dots, points([[1,2],[5,2],[9,2]]), point_type = circle, color = red, line_width = 7, points([[1,3],[5,3],[9,3]]) )$ -- Opción gráfica: filled_func Valor por defecto: `false' `filled_func' indica si la función se debe rellenar (`true') o no (`false'). Esta opción sólo afecta al objeto gráfico bidimensional `explicit'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(fill_color = red, filled_func = true, explicit(sin(x),x,0,10) )$ Véase también `fill_color'. -- Opción gráfica: transparent Valor por defecto: `false' Cuando `transparent' vale `true', las regiones internas de los polígonos se rellenan de acuerdo con `fill_color'. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `polygon', `rectangle' y `ellipse'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(polygon([[3,2],[7,2],[5,5]]), transparent = true, color = blue, polygon([[5,2],[9,2],[7,5]]) )$ -- Opción gráfica: border Valor por defecto: `true' Cuando `border' vale `true', los bordes de los polígonos se dibujan de acuerdo con `line_type' y `line_width'. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `polygon', `rectangle' y `ellipse'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(color = brown, line_width = 8, polygon([[3,2],[7,2],[5,5]]), border = false, fill_color = blue, polygon([[5,2],[9,2],[7,5]]) )$ -- Opción gráfica: head_both Valor por defecto: `false' Cuando `head_both' vale `true', los vectores se dibujan bidireccionales. Si vale `false', se dibujan unidireccionales. Esta opción sólo es relevante para objetos de tipo `vector'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,8], yrange = [0,8], head_length = 0.7, vector([1,1],[6,0]), head_both = true, vector([1,7],[6,0]) )$ Véanse también `head_length', `head_angle' y `head_type'. -- Opción gráfica: head_length Valor por defecto: 2 `head_length' indica, en las unidades del eje , la longitud de las flechas de los vectores. Esta opción sólo es relevante para objetos de tipo `vector'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,12], yrange = [0,8], vector([0,1],[5,5]), head_length = 1, vector([2,1],[5,5]), head_length = 0.5, vector([4,1],[5,5]), head_length = 0.25, vector([6,1],[5,5]))$ Véanse también `head_both', `head_angle' y `head_type'. -- Opción gráfica: head_angle Valor por defecto: 45 `head_angle' indica el ángulo, en grados, entre la flecha y el segmento del vector. Esta opción sólo es relevante para objetos de tipo `vector'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,10], yrange = [0,9], head_length = 0.7, head_angle = 10, vector([1,1],[0,6]), head_angle = 20, vector([2,1],[0,6]), head_angle = 30, vector([3,1],[0,6]), head_angle = 40, vector([4,1],[0,6]), head_angle = 60, vector([5,1],[0,6]), head_angle = 90, vector([6,1],[0,6]), head_angle = 120, vector([7,1],[0,6]), head_angle = 160, vector([8,1],[0,6]), head_angle = 180, vector([9,1],[0,6]) )$ Véanse también `head_both', `head_length' y `head_type'. -- Opción gráfica: head_type Valor por defecto: `filled' `head_type' se utiliza para especificar cómo se habrán de dibujar las flechas de los vectores. Los valores posibles para esta opción son: `filled' (flechas cerradas y rellenas), `empty' (flechas cerradas pero no rellenas) y `nofilled' (flechas abiertas). Esta opción sólo es relevante para objetos de tipo `vector'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,12], yrange = [0,10], head_length = 1, vector([0,1],[5,5]), /* default type */ head_type = 'empty, vector([3,1],[5,5]), head_type = 'nofilled, vector([6,1],[5,5]))$ Véanse también `head_both', `head_angle' y `head_length'. -- Opción gráfica: label_alignment Valor por defecto: `center' `label_alignment' se utiliza para especificar dónde se escribirán las etiquetas con respecto a las coordenadas de referencia. Los valores posibles para esta opción son: `center', `left' y `right'. Esta opción sólo es relevante para objetos de tipo `label'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,10], yrange = [0,10], points_joined = true, points([[5,0],[5,10]]), color = blue, label(["Centered alignment (default)",5,2]), label_alignment = 'left, label(["Left alignment",5,5]), label_alignment = 'right, label(["Right alignment",5,8]))$ Véanse también `label_orientation' y `color'. -- Opción gráfica: label_orientation Valor por defecto: `horizontal' `label_orientation' se utiliza para especificar la orientación de las etiquetas. Los valores posibles para esta opción son: `horizontal' y `vertical'. Esta opción sólo es relevante para objetos de tipo `label'. Ejemplo: En este ejemplo, el punto ficticio que se añade sirve para obtener la imagen, ya que el paquete `draw' necesita siempre de datos para construir la escena. (%i1) load(draw)$ (%i2) draw2d(xrange = [0,10], yrange = [0,10], point_size = 0, points([[5,5]]), color = navy, label(["Horizontal orientation (default)",5,2]), label_orientation = 'vertical, color = "#654321", label(["Vertical orientation",1,5]))$ Véanse también `label_alignment' y `color'. -- Opción gráfica: color Valor por defecto: `"black"' `color' especifica el color para dibujar líneas, puntos, bordes de polígonos y etiquetas. Los colores se pueden dar a partir de sus nombres o en código hexadecimal rgb. Los nombres de colores disponibles son: `"white"', `"black"', `"gray0"', `"grey0"', `"gray10"', `"grey10"', `"gray20"', `"grey20"', `"gray30"', `"grey30"', `"gray40"', `"grey40"', `"gray50"', `"grey50"', `"gray60"', `"grey60"', `"gray70"', `"grey70"', `"gray80"', `"grey80"', `"gray90"', `"grey90"', `"gray100"', `"grey100"', `"gray"', `"grey"', `"light-gray"', `"light-grey"', `"dark-gray"', `"dark-grey"', `"red"', `"light-red"', `"dark-red"', `"yellow"', `"light-yellow"', `"dark-yellow"', `"green"', `"light-green"', `"dark-green"', `"spring-green"', `"forest-green"', `"sea-green"', `"blue"', `"light-blue"', `"dark-blue"', `"midnight-blue"', `"navy"', `"medium-blue"', `"royalblue"', `"skyblue"', `"cyan"', `"light-cyan"', `"dark-cyan"', `"magenta"', `"light-magenta"', `"dark-magenta"', `"turquoise"', `"light-turquoise"', `"dark-turquoise"', `"pink"', `"light-pink"', `"dark-pink"', `"coral"', `"light-coral"', `"orange-red"', `"salmon"', `"light-salmon"', `"dark-salmon"', `"aquamarine"', `"khaki"', `"dark-khaki"', `"goldenrod"', `"light-goldenrod"', `"dark-goldenrod"', `"gold"', `"beige"', `"brown"', `"orange"', `"dark-orange"', `"violet"', `"dark-violet"', `"plum"' y `"purple"'. Las componentes cromáticas en código hexadecimal se introducen en el formato `"#rrggbb"'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(explicit(x^2,x,-1,1), /* default is black */ color = "red", explicit(0.5 + x^2,x,-1,1), color = blue, explicit(1 + x^2,x,-1,1), color = "light-blue", /* double quotes if - is used */ explicit(1.5 + x^2,x,-1,1), color = "#23ab0f", label(["This is a label",0,1.2]) )$ Véase también `fill_color'. -- Opción gráfica: fill_color Valor por defecto: `"red"' `fill_color' especifica el color para rellenar polígonos y funciones explícitas bidimensionales. Véase `color' para más información sobre cómo definir colores. -- Opción gráfica: line_width Valor por defecto: 1 `line_width' es el ancho de las líneas a dibujar. Su valor debe ser un número positivo. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `points', `polygon', `rectangle', `ellipse', `vector', `explicit', `implicit', `parametric' y `polar'. * `gr3d': `points' y `parametric'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(explicit(x^2,x,-1,1), /* default width */ line_width = 5.5, explicit(1 + x^2,x,-1,1), line_width = 10, explicit(2 + x^2,x,-1,1))$ Véase también `line_type'. -- Opción gráfica: line_type Valor por defecto: 1 `line_type' indica cómo se van a dibujar las líneas; valores posibles son `solid' y `dots'. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `points', `polygon', `rectangle', `ellipse', `vector', `explicit', `implicit', `parametric' y `polar'. * `gr3d': `points', `explicit', `parametric' y `parametric_surface'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(line_type = dots, explicit(1 + x^2,x,-1,1), line_type = solid, /* default */ explicit(2 + x^2,x,-1,1))$ Véase también `line_width'. -- Opción gráfica: nticks Valor por defecto: 30 `nticks' es el número de puntos muestreados por la rutina gráfica. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `ellipse', `explicit', `parametric' y `polar'. * `gr3d': `parametric'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(transparent = true, ellipse(0,0,4,2,0,180), nticks = 5, ellipse(0,0,4,2,180,180) )$ -- Opción gráfica: adapt_depth Valor por defecto: 10 `adapt_depth' es el número máximo de particiones utilizadas por la rutina gráfica adaptativa. Esta opción sólo es relevante para funciones de tipo `explicit' en 2d. -- Opción gráfica: key Valor por defecto: `""' (cadena vacía) `key' es la clave de una función en la leyenda. Si `key' es una cadena vacía, las funciones no tendrán clave asociada en la leyenda. Esta opción afecta a los siguientes objetos gráficos: * `gr2d': `points', `polygon', `rectangle', `ellipse', `vector', `explicit', `implicit', `parametric' y `polar'. * `gr3d': `points', `explicit', `parametric', y `parametric_surface'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(key = "Sinus", explicit(sin(x),x,0,10), key = "Cosinus", color = red, explicit(cos(x),x,0,10) )$ -- Opción gráfica: xu_grid Valor por defecto: 30 `xu_grid' es el número de coordenadas de la primera variable (`x' en superficies explcítas y `u' en las paramétricas) para formar la rejilla de puntos muestrales. Esta opción afecta a los siguientes objetos gráficos: * `gr3d': `explicit' y `parametric_surface'. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(xu_grid = 10, yv_grid = 50, explicit(x^2+y^2,x,-3,3,y,-3,3) )$ Véase también `yv_grid'. -- Opción gráfica: yv_grid Valor por defecto: 30 `yv_grid' es el número de coordenadas de la segunda variable (`y' en superficies explcítas y `v' en las paramétricas) para formar la rejilla de puntos muestrales. Esta opción afecta a los siguientes objetos gráficos: * `gr3d': `explicit' y `parametric_surface'. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(xu_grid = 10, yv_grid = 50, explicit(x^2+y^2,x,-3,3,y,-3,3) )$ Véase también `xu_grid'. -- Opción gráfica: surface_hide Valor por defecto: `false' Cuando `surface_hide' vale `true', las partes ocultas no se muestran en las superficies de las escenas 3d. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw(columns=2, gr3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)), gr3d(surface_hide = true, explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)) )$ -- Opción gráfica: contour Valor por defecto: `none' La opción `contour' permite al usuario decidir dónde colocar las líneas de nivel. Valores posibles son: * `none': no se dibujan líneas de nivel. * `base': las líneas de nivel se proyectan sobre el plano xy. * `surface': las líneas de nivel se dibujan sobre la propia superficie. * `both': se dibujan dos conjuntos de líneas de nivel: sobre la superficie y las que se proyectan sobre el plano xy. * `map': las líneas de nivel se proyectan sobre el plano xy y el punto de vista del observador se coloca perpendicularmente a él. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3), contour_levels = 15, contour = both, surface_hide = true) $ Véase también `contour_levels'. -- Opción gráfica: contour_levels Valor por defecto: 5 `contour_levels' is the number of levels in contour plots. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3), contour_levels = 15, contour = both, surface_hide = true) $ Véase también `contour'. -- Opción gráfica: columns Valor por defecto: 1 `columns' es el número de columnas en gráficos múltiples. Puesto que ésta es una opción global, su posición dentro de la descripción de la escena no reviste importancia. También puede usarse como argumento de la función `draw'. Ejemplo: (%i1) load(draw)$ (%i2) scene1: gr2d(title="Ellipse", nticks=30, parametric(2*cos(t),5*sin(t),t,0,2*%pi))$ (%i3) scene2: gr2d(title="Triangle", polygon([4,5,7],[6,4,2]))$ (%i4) draw(scene1, scene2, columns = 2)$ -- Opción gráfica: ip_grid Valor por defecto: `[50, 50]' `ip_grid' establece la rejilla del primer muestreo para los gráficos de funciones implícitas. Esta opción sólo es relevante para funciones de tipo `implicit'. -- Opción gráfica: ip_grid_in Valor por defecto: `[5, 5]' `ip_grid_in' establece la rejilla del segundo muestreo para los gráficos de funciones implícitas. Esta opción sólo es relevante para funciones de tipo `implicit'. -- Constructor de escena: gr2d (, ..., , ...) La función `gr2d' construye un objeto que describe una escena 2d. Los argumentos son opciones gráficas y objetos gráficos. Esta escena se interpreta secuencialmente: las opciones gráficas afectan a aquellos objetos gráficos colocados a su derecha. Algunas opciones gráficas afectan al aspecto global de la escena. La lista de objetos gráficos disponibles para escenas en dos dimensiones: `points', `polygon', `rectangle', `ellipse', `label', `vector', `explicit', `implicit', `polar', `parametric', `image' y `geomap'. Para utilizar esta función, ejecútese primero `load(draw)'. Véanse también las siguientes opciones gráficas: `xrange', `yrange', `logx', `logy', `terminal', `grid', `title', `xlabel', `ylabel', `xtics', `ytics', `xy_file', `file_name', `pic_width', `pic_height', `eps_width', `eps_height', `user_preamble', `axis_bottom', `axis_left', `axis_top' y `axis_right'. -- Constructor de escena: gr3d (, ..., , ...) La función `gr3d' construye un objeto que describe una escena 3d. Los argumentos son opciones gráficas y objetos gráficos. Esta escena se interpreta secuencialmente: las opciones gráficas afectan a aquellos objetos gráficos colocados a su derecha. Algunas opciones gráficas afectan al aspecto global de la escena. La lista de objetos gráficos disponibles para escenas en tres dimensiones: `points', `label', `vector', `explicit', `parametric' y `parametric_surface'. Véanse también las siguientes opciones gráficas: `xrange', `yrange', `zrange', `logx', `logy', `logz', `terminal', `grid', `title', `xlabel', `ylabel', `zlabel', `xtics', `ytics', `ztics', `xy_file', `user_preamble', `axis_bottom', `axis_left', `axis_top', `file_name', `pic_width', `pic_height', `eps_width', `eps_height', `axis_right', `rot_vertical', `rot_horizontal', `axis_3d', `xu_grid', `yv_grid', `surface_hide', `contour', `contour_levels', `palette', `colorbox' y `enhanced3d'. Para utilizar esta función, ejecútese primero `load(draw)'. -- Objeto gráfico: points ([[,], [,],...]) -- Objeto gráfico: points ([,,...], [,,...]) -- Objeto gráfico: points ([,,...]) -- Objeto gráfico: points ([[,,], [,,],...]) -- Objeto gráfico: points ([,,...], [,,...], [,,...]) Dibuja puntos en 2D y 3D. Este objeto se ve afectado por las siguientes opciones gráficas: `point_size', `point_type', `points_joined', `line_width', `key', `line_type' y `color'. 2D `points ([[,], [,],...])' o `points ([,,...], [,,...])' dibuja los puntos `[,]', `[,]', etc. Si no se dan las abscisas, éstas se asignan automáticamente a enteros positivos consecutivos, de forma que `points([,,...])' dibuja los puntos `[1,]', `[2,]', etc. Ejemplo: (%i1) load(draw)$ (%i2) draw2d( key = "Small points", points(makelist([random(20),random(50)],k,1,10)), point_type = circle, point_size = 3, points_joined = true, key = "Great points", points(makelist(k,k,1,20),makelist(random(30),k,1,20)), point_type = filled_down_triangle, key = "Automatic abscissas", color = red, points([2,12,8]))$ 3D `points ([[,,], [,,],...])' o `points ([,,...], [,,...], [,,...])' dibuja los puntos `[,,]', `[,,]', etc. Ejemplo: Una muestra tridimensional, (%i1) load(draw)$ (%i2) load (numericalio)$ (%i3) s2 : read_matrix (file_search ("wind.data"))$ (%i4) draw3d(title = "Daily average wind speeds", point_size = 2, points(args(submatrix (s2, 4, 5))) )$ Dos muestras tridimensionales, (%i1) load(draw)$ (%i2) load (numericalio)$ (%i3) s2 : read_matrix (file_search ("wind.data"))$ (%i4) draw3d( title = "Daily average wind speeds. Two data sets", point_size = 2, key = "Sample from stations 1, 2 and 3", points(args(submatrix (s2, 4, 5))), point_type = 4, key = "Sample from stations 1, 4 and 5", points(args(submatrix (s2, 2, 3))) )$ -- Objeto gráfico: polygon ([[,], [,],...]) -- Objeto gráfico: polygon ([,,...], [,,...]) Dibuja polígonos en 2D. 2D `polygon ([[,], [,],...])' o `polygon ([,,...], [,,...])': dibuja en el plano un polígono de vértices `[,]', `[,]', etc.. Este objeto se ve afectado por las siguientes opciones gráficas: `transparent', `fill_color', `border', `line_width', `key', `line_type' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(color = "#e245f0", line_width = 8, polygon([[3,2],[7,2],[5,5]]), border = false, fill_color = yellow, polygon([[5,2],[9,2],[7,5]]) )$ -- Objeto gráfico: rectangle ([,], [,]) Dibuja rectángulos en 2D. 2D `rectangle ([,], [,])' dibuja un rectángulo de vértices opuestos `[,]' y `[,]'. Este objeto se ve afectado por las siguientes opciones gráficas: `transparent', `fill_color', `border', `line_width', `key', `line_type' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(fill_color = red, line_width = 6, line_type = dots, transparent = false, fill_color = blue, rectangle([-2,-2],[8,-1]), /* opposite vertices */ transparent = true, line_type = solid, line_width = 1, rectangle([9,4],[2,-1.5]), xrange = [-3,10], yrange = [-3,4.5] )$ -- Objeto gráfico: ellipse (, , , , , ) Dibuja elipses y círculos en 2D. 2D `ellipse (, , , , , )' dibuja una elipse de centro `[, ]' con semiejes horizontal y vertical y , respectivamente, desde el ángulo hasta el ángulo . Este objeto se ve afectado por las siguientes opciones gráficas: `nticks', `transparent', `fill_color', `border', `line_width', `line_type', `key' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(transparent = false, fill_color = red, color = gray30, transparent = false, line_width = 5, ellipse(0,6,3,2,270,-270), /* center (x,y), a, b, start & end in degrees */ transparent = true, color = blue, line_width = 3, ellipse(2.5,6,2,3,30,-90), xrange = [-3,6], yrange = [2,9] )$ -- Objeto gráfico: label ([,,],...) -- Objeto gráfico: label ([,,,],...) Escribe etiquetas en 2D y 3D. Este objeto se ve afectado por las siguientes opciones gráficas: `label_alignment', `label_orientation' y `color'. 2D `label([,,])' escribe la cadena de caracteres en el punto `[,]'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(yrange = [0.1,1.4], color = "red", label(["Label in red",0,0.3]), color = "#0000ff", label(["Label in blue",0,0.6]), color = "light-blue", label(["Label in light-blue",0,0.9], ["Another ligght-blue",0,1.2]) )$ 3D `label([,,,])' escribe la cadena de caracteres en el punto `[,,]'. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3), color = red, label(["UP 1",-2,0,3], ["UP 2",1.5,0,4]), color = blue, label(["DOWN 1",2,0,-3]) )$ -- Objeto gráfico: vector ([,], [,]) -- Objeto gráfico: vector ([,,], [,,]) Dibuja vectores en 2D y 3D. Este objeto se ve afectado por las siguientes opciones gráficas: `head_both', `head_length', `head_angle', `head_type', `line_width', `line_type', `key' y `color'. 2D `vector ([,], [,])' dibuja el vector `[,]' con origen en `[,]'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(xrange = [0,12], yrange = [0,10], head_length = 1, vector([0,1],[5,5]), /* default type */ head_type = 'empty, vector([3,1],[5,5]), head_both = true, head_type = 'nofilled, line_type = dots, vector([6,1],[5,5]))$ 3D `vector([,,], [,,])' dibuja el vector `[,,]' con origen en `[,,]'. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(color = cyan, vector([0,0,0],[1,1,1]/sqrt(3)), vector([0,0,0],[1,-1,0]/sqrt(2)), vector([0,0,0],[1,1,-2]/sqrt(6)) )$ -- Objeto gráfico: explicit (,,,) -- Objeto gráfico: explicit (,,,,,,) Dibuja funciones explícitas en 2D y 3D. 2D `explicit (,,,)' dibuja la función explícita , con la variable tomando valores desde hasta . Este objeto se ve afectado por las siguientes opciones gráficas: `nticks', `adapt_depth', `line_width', `line_type', `key', `filled_func', `fill_color' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(line_width = 3, color = blue, explicit(x^2,x,-3,3) )$ (%i3) draw2d(fill_color = brown, filled_func = true, explicit(x^2,x,-3,3) )$ 3D `explicit (,,,,,,)' dibuja la función explícita , con la variable `var1' tomando valores desde hasta y la variable tomando valores desde hasta . Este objeto se ve afectado por las siguientes opciones gráficas: `xu_grid', `yv_grid', `line_type', `key' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(key = "Gauss", color = "#a02c00", explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3), yv_grid = 10, color = blue, key = "Plane", explicit(x+y,x,-5,5,y,-5,5), surface_hide = true)$ -- Objeto gráfico: implicit (,,,,,,) Dibuja funciones implícitas en 2D. 2D `implicit (,,,,,,)' dibuja la función implícita , con la variable `xvar' tomando valores desde hasta , y la variable tomando valores desde hasta . Este objeto se ve afectado por las siguientes opciones gráficas: `ip_grid', `ip_grid_in', `line_width', `line_type', `key' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(terminal = eps, grid = true, line_type = solid, key = "y^2=x^3-2*x+1", implicit(y^2=x^3-2*x+1, x, -4,4, y, -4,4), line_type = dots, key = "x^3+y^3 = 3*x*y^2-x-1", implicit(x^3+y^3 = 3*x*y^2-x-1, x,-4,4, y,-4,4), title = "Two implicit functions" )$ -- Objeto gráfico: polar (,,,) dibuja funciones 2D definidas en coordenadas polares. 2D `polar (,,,)' dibuja la función `()' definida en coordenadas polares, con la variable tomando valores desde hasta . Este objeto se ve afectado por las siguientes opciones gráficas: `nticks', `line_width', `line_type', `key' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw2d(user_preamble = "set grid polar", nticks = 200, xrange = [-5,5], yrange = [-5,5], color = blue, line_width = 3, title = "Hyperbolic Spiral", polar(10/theta,theta,1,10*%pi) )$ -- Objeto gráfico: parametric (,,,,) -- Objeto gráfico: parametric (,,,,,) Dibuja funciones paramétricas en 2D y 3D. Este objeto se ve afectado por las siguientes opciones gráficas: `nticks', `line_width', `line_type', `key' y `color'. 2D `parametric (,,,,)' dibuja la función paramétrica `[,]', con el parámetro tomando valores desde hasta . Ejemplo: (%i1) load(draw)$ (%i2) draw2d(explicit(exp(x),x,-1,3), color = red, key = "This is the parametric one!!", parametric(2*cos(rrr),rrr^2,rrr,0,2*%pi))$ 3D `parametric (,,,,,)' dibuja la curva paramétrica `[,,]', con el parámetro tomando valores desde hasta . Ejemplo: (%i1) load(draw)$ (%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3), color = royalblue, parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2), color = turquoise, line_width = 2, parametric(t^2,sin(t),2+t,t,0,2), surface_hide = true, title = "Surface & curves" )$ -- Objeto gráfico: image (,,,,) Reproduce una imagen en 2D. 2D `image (,,,,)': dibuja la imagen en la región rectangular desde el vértice <(X0,Y0)> hasta el `(x0+,y0+)' del plano real. El argumento debe ser una matriz de números reales, una matriz de vectores de longitud tres o un objeto de tipo `picture'. Si es una matriz de números reales, los valores de los píxeles se interpretan según indique la opción gráfica `palette', que es un vector de longitud tres con sus componentes tomando valores enteros en el rango desde -36 a +36; cada valor es un índice para seleccionar una fórmula que transforma los niveles numéricos en las componentes cromáticas rojo, verde y azul: 0: 0 1: 0.5 2: 1 3: x 4: x^2 5: x^3 6: x^4 7: sqrt(x) 8: sqrt(sqrt(x)) 9: sin(90x) 10: cos(90x) 11: |x-0.5| 12: (2x-1)^2 13: sin(180x) 14: |cos(180x)| 15: sin(360x) 16: cos(360x) 17: |sin(360x)| 18: |cos(360x)| 19: |sin(720x)| 20: |cos(720x)| 21: 3x 22: 3x-1 23: 3x-2 24: |3x-1| 25: |3x-2| 26: (3x-1)/2 27: (3x-2)/2 28: |(3x-1)/2| 29: |(3x-2)/2| 30: x/0.32-0.78125 31: 2*x-0.84 32: 4x;1;-2x+1.84;x/0.08-11.5 33: |2*x - 0.5| 34: 2*x 35: 2*x - 0.5 36: 2*x - 1 los números negativos se interpretan como colores invertidos de las componentes cromáticas. `palette = gray' y `palette = color' son atajos para `palette = [3,3,3]' y `palette = [7,5,15]', respectivamente. Si es una matriz de vectores de longitud tres, éstos se interpretarán como las componentes cromáticas rojo, verde y azul. Ejemplos: Si es una matriz de números reales, los valores de los píxeles se interpretan según indique la opción gráfica `palette'. (%i1) load(draw)$ (%i2) im: apply( 'matrix, makelist(makelist(random(200),i,1,30),i,1,30))$ (%i3) /* palette = color, default */ draw2d(image(im,0,0,30,30))$ (%i4) draw2d(palette = gray, image(im,0,0,30,30))$ (%i5) draw2d(palette = [15,20,-4], colorbox=false, image(im,0,0,30,30))$ Véase también `colorbox'. Si es una matriz de vectores de longitud tres, éstos se interpretarán como las componentes cromáticas rojo, verde y azul. (%i1) load(draw)$ (%i2) im: apply( 'matrix, makelist( makelist([random(300), random(300), random(300)],i,1,30),i,1,30))$ (%i3) draw2d(image(im,0,0,30,30))$ El paquete `draw' carga automáticamente el paquete `picture'. En este ejemplo, una imagen de niveles se define a mano, reproduciéndola a continuación. (%i1) load(draw)$ (%i2) im: make_level_picture([45,87,2,134,204,16],3,2); (%o2) picture(level, 3, 2, {Array: #(45 87 2 134 204 16)}) (%i3) /* default color palette */ draw2d(image(im,0,0,30,30))$ (%i4) /* gray palette */ draw2d(palette = gray, image(im,0,0,30,30))$ Se lee un fichero xpm y se reproduce. (%i1) load(draw)$ (%i2) im: read_xpm("myfile.xpm")$ (%i3) draw2d(image(im,0,0,10,7))$ Véanse también `make_level_picture', `make_rgb_picture' y `read_xpm'. En `http://www.telefonica.net/web2/biomates/maxima/gpdraw/image' se encuentran ejemplos más elaborados. -- Global variable: boundaries_array Valor por defecto: `false' `boundaries_array' es donde el objeto gráfico `geomap' lee las coordenadas de las líneas fronterizas. Cada componente de `boundaries_array' es un array de números decimales en coma flotante representando las coordenadas que definen un segmento poligonal o línea fronteriza. Véase también `geomap'. -- Objeto gráfico: geomap (,,...) Dibuja mapas cartográficos en 2D. 2D Esta función trabaja junto con la variable global `boundaries_array'. Los argumentos son números o listas, las cuales a su vez pueden contener números o listas. Todos estos números deben ser enteros mayores o iguales que cero, representando las componentes del array global `boundaries_array'. Cada componente de `boundaries_array' es un array de decimales en coma flotante, las coordenadas de un segmento poligonal o línea fronteriza. `geomap (,,...)' toma los enteros de sus argumentos y dibuja los segmentos poligonales asociados de `boundaries_array'. Este objeto se ve afectado por las siguientes opciones gráficas: `line_width', `line_type' y `color'. Ejemplos: Un sencillo mapa hecho a mano: (%i1) load(draw)$ (%i2) /* Vertices of boundary #0: {(1,1),(2,5),(4,3)} */ ( bnd0: make_array(flonum,6), bnd0[0]:1.0, bnd0[1]:1.0, bnd0[2]:2.0, bnd0[3]:5.0, bnd0[4]:4.0, bnd0[5]:3.0 )$ (%i3) /* Vertices of boundary #1: {(4,3),(5,4),(6,4),(5,1)} */ ( bnd1: make_array(flonum,8), bnd1[0]:4.0, bnd1[1]:3.0, bnd1[2]:5.0, bnd1[3]:4.0, bnd1[4]:6.0, bnd1[5]:4.0, bnd1[6]:5.0, bnd1[7]:1.0)$ (%i4) /* Vertices of boundary #2: {(5,1), (3,0), (1,1)} */ ( bnd2: make_array(flonum,6), bnd2[0]:5.0, bnd2[1]:1.0, bnd2[2]:3.0, bnd2[3]:0.0, bnd2[4]:1.0, bnd2[5]:1.0 )$ (%i5) /* Vertices of boundary #3: {(1,1), (4,3)} */ ( bnd3: make_array(flonum,4), bnd3[0]:1.0, bnd3[1]:1.0, bnd3[2]:4.0, bnd3[3]:3.0)$ (%i6) /* Vertices of boundary #4: {(4,3), (5,1)} */ ( bnd4: make_array(flonum,4), bnd4[0]:4.0, bnd4[1]:3.0, bnd4[2]:5.0, bnd4[3]:1.0)$ (%i7) /* Pack all together in boundaries_array */ ( boundaries_array: make_array(any,5), boundaries_array[0]: bnd0, boundaries_array[1]: bnd1, boundaries_array[2]: bnd2, boundaries_array[3]: bnd3, boundaries_array[4]: bnd4 )$ (%i8) draw2d(geomap([0,1,2,3,4]))$ El paquete auxiliar `worldmap' asigna al array global `boundaries_array' líneas fronterizas reales en coordenadas (longitud, latitud). Estos datos son de dominio público y proceden de `http://www-cger.nies.go.jp/grid-e/gridtxt/grid19.html'. El paquete `worldmap' también define fronteras de países y continentes a partir de las componentes de `boundaries_array' (véase el fichero `share/draw/worldmap.mac' para más información). El paquete `draw' no carga automáticamente `worldmap'. (%i1) load(draw)$ (%i2) load(worldmap)$ (%i3) c1: gr2d(geomap(Canada,United_States, Mexico,Cuba))$ (%i4) c2: gr2d(geomap(Africa))$ (%i5) c3: gr2d(geomap(Oceania,China,Japan))$ (%i6) c4: gr2d(geomap(France,Portugal,Spain, Morocco,Western_Sahara))$ (%i7) draw(columns = 2, c1,c2,c3,c4)$ `worldmap' se puede utilizar para dibujar países como polígonos. En este caso, ya no será necesario hacer uso del objeto gráfico `geomap', pero sí de `polygon'. Puesto que en este caso se utilizan listas en lugar de arrays, los mapas se reproducirán de forma más lenta. Véanse también `make_poly_country' y `make_poly_continent' para comprender el siguiente código. (%i1) load(draw)$ (%i2) load(worldmap)$ (%i3) mymap: append( [color = white], /* borders are white */ [fill_color = red], make_poly_country(Bolivia), [fill_color = cyan], make_poly_country(Paraguay), [fill_color = green], make_poly_country(Colombia), [fill_color = blue], make_poly_country(Chile), [fill_color = "#23ab0f"], make_poly_country(Brazil), [fill_color = goldenrod], make_poly_country(Argentina), [fill_color = "midnight-blue"], make_poly_country(Uruguay))$ (%i4) apply(draw2d, mymap)$ En `http://www.telefonica.net/web2/biomates/maxima/gpdraw/geomap' hay ejemplos más elaborados. -- Objeto gráfico: parametric_surface (,,,,,,,,) Dibuja superficies paramétricas en 3D. 3D `parametric_surface (,,,,,,,,)' dibuja la superficie paramétrica `[,,]', con el parámetro tomando valores desde hasta y el parámetro tomando valores desde hasta . Este objeto se ve afectado por las siguientes opciones gráficas: `xu_grid', `yv_grid', `line_type', `key' y `color'. Ejemplo: (%i1) load(draw)$ (%i2) draw3d(title = "Sea shell", xu_grid = 100, yv_grid = 25, rot_vertical = 100, rot_horizontal = 20, surface_hide = true, parametric_surface(0.5*u*cos(u)*(cos(v)+1), 0.5*u*sin(u)*(cos(v)+1), u*sin(v) - ((u+3)/8*%pi)^2 - 20, u, 0, 13*%pi, v, -%pi, %pi) )$ -- Función: draw (, ..., , ..., , ...) Representa gráficamente una serie de escenas; sus argumentos son objetos `gr2d' y/o `gr3d', junto con algunas opciones. Por defecto, las escenas se representan en una columna. La función `draw' acepta dos opciones posibles: `terminal' y `columns'. Las funciones `draw2d' y `draw3d' son atajos a utilizar cuando se quiere representar una única escena en dos o tres dimensiones, respectivamente. Para utilizar esta función, ejecútese primero `load(draw)'. Ejemplo: (%i1) load(draw)$ (%i2) scene1: gr2d(title="Ellipse", nticks=30, parametric(2*cos(t),5*sin(t),t,0,2*%pi))$ (%i3) scene2: gr2d(title="Triangle", polygon([4,5,7],[6,4,2]))$ (%i4) draw(scene1, scene2, columns = 2)$ -- Función: draw2d (, ) Devuelve `true' si el número pertenece al intervalo [a, b), y `false' en caso contrario. -- Función: linearinterpol () -- Función: linearinterpol (, ) -- Función: eigens_by_jacobi (, ) Calcula los valores y vectores propios de por el método de las rotaciones de Jacobi. debe ser una matriz simétrica (aunque no necesariamente definida o semidefinida positiva). El argumento indica el tipo numérico sobre el que se realizan los cálculos, que puede ser tanto `floatfield' como `bigfloatfield'. En caso de que no se especifique , su valor por defecto será `floatfield'. Los elementos de deben ser números o expresiones reducibles a números mediante la ejecución de `float' o `bfloat', según sea el valor de . Ejemplos: (%i1) S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]); [ 1 1 ] [ ------- ------- ] [ sqrt(2) sqrt(2) ] (%o1) [ ] [ 1 1 ] [ - ------- ------- ] [ sqrt(2) sqrt(2) ] (%i2) L : matrix ([sqrt(3), 0], [0, sqrt(5)]); [ sqrt(3) 0 ] (%o2) [ ] [ 0 sqrt(5) ] (%i3) M : S . L . transpose (S); [ sqrt(5) sqrt(3) sqrt(5) sqrt(3) ] [ ------- + ------- ------- - ------- ] [ 2 2 2 2 ] (%o3) [ ] [ sqrt(5) sqrt(3) sqrt(5) sqrt(3) ] [ ------- - ------- ------- + ------- ] [ 2 2 2 2 ] (%i4) eigens_by_jacobi (M); The largest percent change was 0.1454972243679 The largest percent change was 0.0 number of sweeps: 2 number of rotations: 1 (%o4) [[1.732050807568877, 2.23606797749979], [ 0.70710678118655 0.70710678118655 ] [ ]] [ - 0.70710678118655 0.70710678118655 ] (%i5) float ([[sqrt(3), sqrt(5)], S]); (%o5) [[1.732050807568877, 2.23606797749979], [ 0.70710678118655 0.70710678118655 ] [ ]] [ - 0.70710678118655 0.70710678118655 ] (%i6) eigens_by_jacobi (M, bigfloatfield); The largest percent change was 1.454972243679028b-1 The largest percent change was 0.0b0 number of sweeps: 2 number of rotations: 1 (%o6) [[1.732050807568877b0, 2.23606797749979b0], [ 7.071067811865475b-1 7.071067811865475b-1 ] [ ]] [ - 7.071067811865475b-1 7.071067811865475b-1 ] -- Función: get_lu_factors () Cuando ` = lu_factor ()', entonces `get_lu_factors' devuelve una lista de la forma `[P, L, U]', donde

es una matriz permutación, es triangular inferior con unos en la diagonal y es triangular superior, verificándose que ` =

'. -- Función: hankel () -- Función: hankel (, ) Devuelve la matriz de Hankel . La primera columna de coincide con , excepto en el primer elemento, la última fila de es . El valor por defecto para es el vector nulo con igual número de elementos que . -- Función: hessian (,) Devuelve la matriz hessiana de con respecto de las variables de la lista . El elemento ,-ésimo de la matriz hessiana es . -- Función: hilbert_matrix () Devuelve la matriz de Hilbert por . Si no es un entero positivo, emite un mensaje de error. -- Función: identfor () -- Función: identfor (, ) Devuelve una matriz identidad con la misma forma que la matriz . Los elementos de la diagonal de la matriz identidad son la identidad multiplicativa del campo ; el valor por defecto para es . El primer argumento debe ser una matriz cuadrada o no ser matriz en absoluto. Si es una matriz, sus elementos pueden ser matrices cuadradas. La matriz puede tener bloques a cualquier nivel finito de profundidad. Véase también `zerofor' -- Función: invert_by_lu (, <(rng generalring)>) Invierte la matriz mediante la factorización LU, la cual se hace utilizando el anillo . -- Función: kronecker_product (, ) Devuelve el producto de Kroneckerde las matrices y . -- Función: listp (,

) -- Función: listp () Dado el argumento opcional

, devuelve `true' si es una lista de Maxima y

toma el valor `true' al aplicarlo a cada elemento de la lista. Si a `listp' no se le suministra el argumento opcional, devuelve `true' si es una lista de Maxima. En cualquier otro caso, el resultado es `false'. -- Función: locate_matrix_entry (, , , , , , ) El primer argumento debe ser una matriz, mientras que los argumentos desde hasta determinan la submatriz de tomando las filas desde hasta y las columnas desde hasta . La función `locate_matrix_entry' busca en la submatriz de un elemento que satisfaga cierta propiedad. hay tres posibilidades: (1) ` = 'bool' y es un predicado: Rastrea la submatriz de izquierda a derecha y de arriba hacia abajo, devolviendo el índice del primer elemento que satisface el predicado ; si ningún elemento lo satisface, el resultado es `false'. (2) ` = 'max' y una función real: Rastrea la submatriz buscando el elemento que maximice , devolviendo el índice correspondiente. (3) ` = 'min' y una función real: Rastrea la submatriz buscando el elemento que minimice , devolviendo el índice correspondiente. -- Función: lu_backsub (, ) Si ` = lu_factor (, )', entonces `lu_backsub (, )' resuelve el sistema de ecuaciones lineales ` = '. -- Función: lu_factor (, ) Devuelve una lista de la forma `[, , ]', o `[, , , ]', donde * La matriz contiene la factorización de de forma empaquetada, lo que significa tres cosas. En primer lugar, que las filas de están permutadas de acuerdo con la lista ; por ejemplo, si es la lista `[3,2,1]', la primera fila de la factorización es la tercera fila de la matriz . En segundo lugar, el factor triangular inferior de es la parte triangular inferior de con los elementos de la diagonal sustituidos por unos. Por último, el factor triangular superior de es la parte triangular superior de . * Si el campo es `floatfield' o `complexfield', los números y son las cotas inferior y superior del número de condición de la norma infinita de . El número de condición no se puede estimar para todos los campos, en cuyo caso `lu_factor' devuelve una lista de dos elementos. Tanto la cota inferior como la superior pueden diferir de sus valores verdaderos. Véase también `mat_cond'. El argumento debe ser una matriz cuadrada. El argumento opcional debe ser un símbolo que determine un anillo o un campo. Los anillos y campos predefinidos son: a. `generalring' - el anillo de las expresiones de Maxima b. `floatfield' - el campo de los números decimales en coma flotante de doble precisión c. `complexfield' - el campo de los números complejos decimales en coma flotante de doble precisión d. `crering' - el anillo de las expresiones canónicas racionales (Canonical Rational Expression o CRE) de Maxima e. `rationalfield' - el campo de los números racionales f. `runningerror' - controla los errores de redondeo de las operaciones en coma flotante g. `noncommutingring' - el anillo de las expresiones de Maxima en las que el producto es el operador no conmutativo "." Si el campo es `floatfield', `complexfield' o `runningerror', el algoritmo utiliza pivoteo parcial; para los demás campos, las filas se cambian cuando se necesita evitar pivotes nulos. La suma aritmética en coma flotante no es asociativa, por lo que el significado de 'campo' no coincide exactamente con su definición matemática. Un elemento del campo `runningerror' consiste en una lista de Maxima de la forma `[x,n]', donde es un número decimal en coma flotante y `n' un enetro. La diferencia relativa entre el valor real de `x' y `x' está aproximadamente acotado por el valor epsilon de la máquina multiplicado por `n'. No es posible la definición de un nuevo campo por parte del usuario, a menos que éste tenga conocimientos de Common Lisp. Para hacerlo, el usuario debe definir funciones para las operaciones aritméticas y para convertir de la representación del campo a Maxima y al revés. Además, en los campos ordenados, donde se hace uso del pivoteo parcial, el usuario debe definir funciones para el módulo y para comparar números del campo. Después de lo anterior, tan solo queda definir una estructura Common Lisp `mring'. El fichero `mring' tiene muchos ejemplos. Para calcular la factorización, la primera tarea consiste en convertir cada elemento de la matriz a un elemento del campo especificado. Si la conversión no es posible, la factorización se detiene con un mensaje de error. Los elementos del campo no necesitan ser expresiones de Maxima; por ejemplo, los elementos de `complexfield' son números complejos de Common Lisp. Tras la factorización, los elementos de la matriz deben convertirse nuevamente a expresiones de Maxima. Véase también `get_lu_factors'. Ejemplos: (%i1) w[i,j] := random (1.0) + %i * random (1.0); (%o1) w := random(1.) + %i random(1.) i, j (%i2) showtime : true$ Evaluation took 0.00 seconds (0.00 elapsed) (%i3) M : genmatrix (w, 100, 100)$ Evaluation took 7.40 seconds (8.23 elapsed) (%i4) lu_factor (M, complexfield)$ Evaluation took 28.71 seconds (35.00 elapsed) (%i5) lu_factor (M, generalring)$ Evaluation took 109.24 seconds (152.10 elapsed) (%i6) showtime : false$ (%i7) M : matrix ([1 - z, 3], [3, 8 - z]); [ 1 - z 3 ] (%o7) [ ] [ 3 8 - z ] (%i8) lu_factor (M, generalring); [ 1 - z 3 ] [ ] (%o8) [[ 3 9 ], [1, 2], generalring] [ ----- - z - ----- + 8 ] [ 1 - z 1 - z ] (%i9) get_lu_factors (%); [ 1 0 ] [ 1 - z 3 ] [ 1 0 ] [ ] [ ] (%o9) [[ ], [ 3 ], [ 9 ]] [ 0 1 ] [ ----- 1 ] [ 0 - z - ----- + 8 ] [ 1 - z ] [ 1 - z ] (%i10) %[1] . %[2] . %[3]; [ 1 - z 3 ] (%o10) [ ] [ 3 8 - z ] -- Función: mat_cond (, 1) -- Función: mat_cond (, inf) Devuelve el número de condición de la

-norma de la matriz . Los valores admisibles para

son 1 y . Esta función utiliza la factorización LU para invertir la matriz , por lo que el tiempo de ejecución de `mat_cond' es proporcional al cubo del tamaño de la matriz; `lu_factor' determina las cotas inferior y superior para el número de condición de la norma infinita en un tiempo proporcional al cuadrado del tamaño de la matriz. -- Función: mat_norm (, 1) -- Función: mat_norm (, inf) -- Función: mat_norm (, frobenius) Devuelve la

-norma de la matriz . Los valores admisibles para

son 1, `inf' y `frobenius' (la norma matricial de Frobenius). La matriz no debe contener bloques. -- Función: matrixp (,

) -- Función: matrixp () Dado el argumento opcional

, devuelve `true' si es una matriz y

toma el valor `true' al aplicarlo a cada elemento de la matriz. Si a `matrixp' no se le suministra el argumento opcional, devuelve `true' si es una matriz. En cualquier otro caso, el resultado es `false'. Véase también `blockmatrixp' -- Función: matrix_size () Devuelve una lista con el número de filas y columnas de la matriz . -- Función: mat_fullunblocker () Si es una matriz de bloques, transforma la matriz llevando todos los elementos de los bloques al primer nivel. Si es una matriz, devuelve ; en cualquier otro caso, envía un mensaje de error. -- Función: mat_trace () Calcula la traza de la matriz . Si no es una matriz, devuelve una forma nominal. Si es una matriz de bloques, `mat_trace(M)' calcula el mismo valor que `mat_trace(mat_unblocker(m))'. -- Función: mat_unblocker () Si es una matriz de bloques, deshace los bloques de un nivel. Si es una matriz, `mat_unblocker (M)' devuelve ; en cualquier otro caso, envía un mensaje de error. Si todos los elementos de son matrices, `mat_unblocker (M)' devuelve una matriz sin bloques, pero si los elementos de son a su vez matrices de bloques, `mat_unblocker (M)' devuelve una matriz con el nivel de bloques disminuido en uno. En caso de trabajar con matrices de bloques, quizás sea conveniente darle a `matrix_element_mult' el valor `"."' y a `matrix_element_transpose' el valor `'transpose'. Véase también `mat_fullunblocker'. Ejemplo: (%i1) A : matrix ([1, 2], [3, 4]); [ 1 2 ] (%o1) [ ] [ 3 4 ] (%i2) B : matrix ([7, 8], [9, 10]); [ 7 8 ] (%o2) [ ] [ 9 10 ] (%i3) matrix ([A, B]); [ [ 1 2 ] [ 7 8 ] ] (%o3) [ [ ] [ ] ] [ [ 3 4 ] [ 9 10 ] ] (%i4) mat_unblocker (%); [ 1 2 7 8 ] (%o4) [ ] [ 3 4 9 10 ] -- Función: nonnegintegerp () Devuelve `true' si y solo si ` >= 0', siendo un entero. -- Función: nullspace () Si es una matriz, devuelve `span (v_1, ..., v_n)', siendo `{v_1, ..., v_n}' la base del espacio nulo de . Si el espacio nulo contiene un único elemento, devuelve `span ()'. -- Función: nullity () Si es una matriz, devuelve la dimensión del espacio nulo de . -- Función: orthogonal_complement (, ..., ) Devuelve `span (u_1, ..., u_m)', siendo `{u_1, ..., u_m}' la base del complemento ortogonal del conjunto `(v_1, ..., v_n)', cuyos elementos deben ser vectores columna. -- Función: polynomialp (

, , , ) -- Función: polynomialp (

, , ) -- Función: polynomialp (

, ) Devuelve `true' si

es un polinomio cuyas variables son las de la lista , el predicado toma el valor `true' al aplicarlo a cada coeficiente y el predicado también alcanza el valor `true' al ser aplicado a los exponentes de las variables listadas en . En caso de necesitar que no sea un predicado por defecto, se deberá especificar también el predicado , aunque aquí se desee su comportamiento por defecto. `polynomialp (

, , )' equivale a `polynomialp (

, , , 'nonnegintegerp)'. `polynomialp (

, )' equivale a `polynomialp (

, L<,> 'constantp, 'nonnegintegerp)'. No es necesario expandir el polinomio: (%i1) polynomialp ((x + 1)*(x + 2), [x]); (%o1) true (%i2) polynomialp ((x + 1)*(x + 2)^a, [x]); (%o2) false Un ejemplo utilizando valores distintos a los utilizados por defecto en y en : (%i1) polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp); (%o1) true (%i2) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp); (%o2) true Polinomios con dos variables: (%i1) polynomialp (x^2 + 5*x*y + y^2, [x]); (%o1) false (%i2) polynomialp (x^2 + 5*x*y + y^2, [x, y]); (%o2) true -- Función: polytocompanion (

, ) Si

es un polinomio en , devuelve la matriz compañera de

. Para un polinomio mónico

de grado se tiene `

= (-1)^ charpoly (polytocompanion (

, ))'. Si

no es un polinomio en , se devuelve un mensaje de error. -- Función: ptriangularize (, ) Si es una matriz en la que sus elementos son polinomios en , devuelve una matriz tal que 1. es triangular superior, 2. ` = ... ', donde , ..., son matrices elementales cuyos elementos son polinomios en , 3. `|det ()| = |det ()|', Nota: esta función no comprueba si los elementos de la matriz son polinomios en . -- Función: rowop (, , , ) Si es una matriz, devuelve la matriz que resulta de relizar la transformación `R_i <- R_i - theta * R_j' con las filas `R_i' y `R_j'. Si no tiene estas filas, devuelve un mensaje de error. -- Función: rank () Calcula el rango de la matriz . El rango es la dimensión del espacio columna. Ejemplo: (%i1) rank(matrix([1,2],[2,4])); (%o1) 1 (%i2) rank(matrix([1,b],[c,d])); Proviso: {d - b c # 0} (%o2) 2 -- Función: rowswap (, , ) Si es una matriz, intercambia las filas y . Si carece de estas filas, devuelve un mensaje de error. -- Función: toeplitz () -- Función: toeplitz (, ) Devuelve una matriz de Toeplitz . La primera columna de es , excepto su primer elemento. La primera fila de es . El valor por defecto para es el complejo conjugado de . Ejemplo: (%i1) toeplitz([1,2,3],[x,y,z]); [ 1 y z ] [ ] (%o1) [ 2 1 y ] [ ] [ 3 2 1 ] (%i2) toeplitz([1,1+%i]); [ 1 1 - %I ] (%o2) [ ] [ %I + 1 1 ] -- Función: vandermonde_matrix ([, ..., ]) Devuelve una matriz por , cuya -ésima fila es `[1, , ^2, ... ^(-1)]'. -- Función: zerofor () -- Función: zerofor (, ) Devuelve la matriz nula con la misma estructura que la matriz . Cada elemento de la matriz nula es la identidad aditiva del campo ; el valor por defecto de es . El primer argumento de debe ser una matriz cuadrada o no ser matriz en absoluto. Si es una matriz, cada uno de sus elementos puede ser una matriz cuadrada, por lo que puede ser una matriz de Maxima definida por bloques. Véase también `identfor'. -- Función: zeromatrixp () Si no es una matriz definida por bloques, devuelve `true' si `is (equal (, 0))' es verdadero para todo elemento de . Si es una matriz por bloques, devuelve `true' si `zeromatrixp' devuelve a su vez `true' para cada elemento de .  File: maxima.info, Node: lsquares, Next: makeOrders, Prev: linearalgebra, Up: Top 59 lsquares *********** * Menu: * Funciones y variables para lsquares::  File: maxima.info, Node: Funciones y variables para lsquares, Prev: lsquares, Up: lsquares 59.1 Funciones y variables para lsquares ======================================== -- Variable global: DETCOEF Esta variable es utilizada por las funciones `lsquares' y `plsquares' para almacenar el coeficiente de determinación que mide la bondad del ajuste, el cual varía entre 0 (ausencia de correlación) y 1 (dependencia exacta). Cuando se llama a `plsquares' con una lista de variables dependientes, almacena una lista de coeficientes de determinación. Véase `plsquares' para más detalles. Véase también `lsquares'. -- Función: lsquares (,,,) -- Función: lsquares (,,,,) Ajuste de una función multivariante a una tabla de datos por el método de los mínimos cuadrados. es la matriz con los datos empíricos, es la lista con los nombres de las variables (una por cada columna de ), es la función a ajustar, la cual debe estar expresada en cualquiera de las formas `depvar=f(indepvari,..., paramj,...)', `g(depvar)=f(indepvari,..., paramj,...)' o `g(depvar, paramk,...)=f(indepvari,..., paramj,...)'), es la lista de los parámetros a estimar y es una lista opcional de aproximaciones iniciales de los parámetros; cuando este último argumento está presente, se utiliza `mnewton' en lugar de `solve' a fin de obtener los parámetros. La función puede ser no lineal con respecto a las variables, tanto independientes como dependiente. Al objeto de utilizar `solve()' las funciones deben ser lineales o polinómicas respecto de los parámetros. Funciones como `y=a*b^x+c' pueden ajustarse para `[a,b,c]' con `solve' si los valores `x' son enteros positivos pequeños y hay pocos datos (véase el ejemplo en `lsquares.dem'). La función `mnewton' permite ajustar una función no lineal respecto de los parámetros, pero deberá suministrársele un conjunto de buenas aproximaciones iniciales. Si es posible se retornará la función ajustada. En caso de existir más de una solución, se devolverá una lista de funciones. El coeficiente de determinación se mostrará también a fin de aportar información sobre la bondad del ajuste, el cual varía entre 0 (ausencia de correlación) y 1 (ajuste exacto); este valor se almacena también en la variable global . Ejemplos utilizando `solve': (%i1) load("lsquares")$ (%i2) lsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]), [x,y,z], z=a*x*y+b*x+c*y+d, [a,b,c,d]); Determination Coefficient = 1.0 x y + 23 y - 29 x - 19 (%o2) z = ---------------------- 6 (%i3) lsquares(matrix([0,0],[1,0],[2,0],[3,8],[4,44]), [n,p], p=a4*n^4+a3*n^3+a2*n^2+a1*n+a0, [a0,a1,a2,a3,a4]); Determination Coefficient = 1.0 4 3 2 3 n - 10 n + 9 n - 2 n (%o3) p = ------------------------- 6 (%i4) lsquares(matrix([1,7],[2,13],[3,25]), [x,y], (y+c)^2=a*x+b, [a,b,c]); Determination Coefficient = 1.0 (%o4) [y = 28 - sqrt(657 - 216 x), y = sqrt(657 - 216 x) + 28] (%i5) lsquares(matrix([1,7],[2,13],[3,25],[4,49]), [x,y], y=a*b^x+c, [a,b,c]); Determination Coefficient = 1.0 x (%o5) y = 3 2 + 1 Ejemplos utilizando `mnewton': (%i6) load("lsquares")$ (%i7) lsquares(matrix([1.1,7.1],[2.1,13.1],[3.1,25.1],[4.1,49.1]), [x,y], y=a*b^x+c, [a,b,c], [5,5,5]); x (%o7) y = 2.799098974610482 1.999999999999991 + 1.099999999999874 (%i8) lsquares(matrix([1.1,4.1],[4.1,7.1],[9.1,10.1],[16.1,13.1]), [x,y], y=a*x^b+c, [a,b,c], [4,1,2]); .4878659755898127 (%o8) y = 3.177315891123101 x + .7723843491402264 (%i9) lsquares(matrix([0,2,4],[3,3,5],[8,6,6]), [m,n,y], y=(A*m+B*n)^(1/3)+C, [A,B,C], [3,3,3]); 1/3 (%o9) y = (3.999999999999862 n + 4.999999999999359 m) + 2.00000000000012 Antes de hacer uso de esta función ejecútese `load("lsquares")'. Véanse también `DETCOEF' y `mnewton'. -- Función: plsquares (,,) -- Función: plsquares (,,,) -- Función: plsquares (,,,,) Ajuste de una función polinómica multivariante a una tabla de datos por el método de los mínimos cuadrados. es la matriz con los datos empíricos, es la lista con los nombres de las variables (una por cada columna de , pero úsese `-' en lugar de los nombres de variables para ignorar las columnas de ), es el nombre de la variable dependiente o una lista con uno o más nombres de variables dependientes (cuyos nombres deben estar también en ), es un argumento opcional para indicar el máximo exponente para cada una de las variables independientes (1 por defecto) y es otro argumento opcional para el grado del polinomio ( por defecto); nótese que la suma de exponentes de cada término debe ser igual o menor que . Si `maxdgree = 0' entonces no se aplicará ningún límite. Si es el nombre de una variable dependiente (no en una lista), `plsquares' devuelve el polinomio ajustado. Si es una lista de una o más variables dependientes, `plsquares' devuelve una lista con los polinomios ajustados. Los coeficientes de determinación se muestran en su orden correspondiente para informar sobre la bondad del ajuste. Estos valores se almacenan también en la variable global ; en un formato de lista si es a su vez una lista. Un ejemplo sencillo de ajuste lineal multivariante: (%i1) load("plsquares")$ (%i2) plsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]), [x,y,z],z); Determination Coefficient for z = .9897039897039897 11 y - 9 x - 14 (%o2) z = --------------- 3 El mismo ejemplo sin restricciones en el grado: (%i3) plsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]), [x,y,z],z,1,0); Determination Coefficient for z = 1.0 x y + 23 y - 29 x - 19 (%o3) z = ---------------------- 6 Cálculo del número de diagonales de un polígono de N lados (%i4) plsquares(matrix([3,0],[4,2],[5,5],[6,9],[7,14],[8,20]), [N,diagonals],diagonals,5); Determination Coefficient for diagonals = 1.0 2 N - 3 N (%o4) diagonals = -------- 2 (%i5) ev(%, N=9); /* Testing for a 9 sides polygon */ (%o5) diagonals = 27 Cálculo del número de formas de colocar dos reinas en un tablero n x n de manera que no se amenacen. (%i6) plsquares(matrix([0,0],[1,0],[2,0],[3,8],[4,44]), [n,positions],[positions],4); Determination Coefficient for [positions] = [1.0] 4 3 2 3 n - 10 n + 9 n - 2 n (%o6) [positions = -------------------------] 6 (%i7) ev(%[1], n=8); /* Testing for a (8 x 8) chessboard */ (%o7) positions = 1288 Un ejemplo con seis variables dependientes: (%i8) mtrx:matrix([0,0,0,0,0,1,1,1],[0,1,0,1,1,1,0,0], [1,0,0,1,1,1,0,0],[1,1,1,1,0,0,0,1])$ (%i8) plsquares(mtrx,[a,b,_And,_Or,_Xor,_Nand,_Nor,_Nxor], [_And,_Or,_Xor,_Nand,_Nor,_Nxor],1,0); Determination Coefficient for [_And, _Or, _Xor, _Nand, _Nor, _Nxor] = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0] (%o2) [_And = a b, _Or = - a b + b + a, _Xor = - 2 a b + b + a, _Nand = 1 - a b, _Nor = a b - b - a + 1, _Nxor = 2 a b - b - a + 1] Antes de hacer uso de esta función ejecútese `load("plsquares")'.  File: maxima.info, Node: makeOrders, Next: mnewton, Prev: lsquares, Up: Top 60 makeOrders ************* * Menu: * Funciones y variables para makeOrders::  File: maxima.info, Node: Funciones y variables para makeOrders, Prev: makeOrders, Up: makeOrders 60.1 Funciones y variables para makeOrders ========================================== -- Función: makeOrders (,) Devuelve una lista con las potencias de las variables de un polinomio término a término. (%i1) load("makeOrders")$ (%i2) makeOrders([a,b],[2,3]); (%o2) [[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3], [2, 0], [2, 1], [2, 2], [2, 3]] (%i3) expand((1+a+a^2)*(1+b+b^2+b^3)); 2 3 3 3 2 2 2 2 2 (%o3) a b + a b + b + a b + a b + b + a b + a b 2 + b + a + a + 1 donde `[0, 1]' se asocia al término b y `[2, 3]' a a^2 b^3. Antes de hacer uso de esta función ejecútese `load("makeOrders")'.  File: maxima.info, Node: mnewton, Next: numericalio, Prev: makeOrders, Up: Top 61 mnewton ********** * Menu: * Funciones y variables para mnewton::  File: maxima.info, Node: Funciones y variables para mnewton, Prev: mnewton, Up: mnewton 61.1 Funciones y variables para mnewton ======================================= -- Variable opcional: newtonepsilon Valor por defecto: `10.0^(-fpprec/2)' Precisión que determina cuando la función `mnewton' ha conseguido una convergencia aceptable. Véase también `mnewton'. -- Variable opcional: newtonmaxiter Valor por defecto: `50' Número máximo de iteraciones para la función `mnewton' en caso de que no se produzca convergencia, o de que ésta se haga muy lenta. Véase también `mnewton'. -- Función: mnewton (,,) Resolución de sistemas de ecuaciones no lineales por el método de Newton. es la lista de ecuaciones a resolver, es la lista con los nombres de las incógnitas y es la lista de aproximaciones iniciales. La solución se devuelve en el mismo formato que lo hace la función `solve()'. Si no se le encuentra solución al sistema, se obtiene `[]' como respuesta. Esta función se controla con las variables globales `newtonepsilon' y `newtonmaxiter'. (%i1) load("mnewton")$ (%i2) mnewton([x1+3*log(x1)-x2^2, 2*x1^2-x1*x2-5*x1+1], [x1, x2], [5, 5]); (%o2) [[x1 = 3.756834008012769, x2 = 2.779849592817897]] (%i3) mnewton([2*a^a-5],[a],[1]); (%o3) [[a = 1.70927556786144]] (%i4) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]); (%o4) [[u = 1.066618389595407, v = 1.552564766841786]] Antes de hacer uso de esta función ejecútese `load("mnewton")'. Véanse también `newtonepsilon' y `newtonmaxiter'.  File: maxima.info, Node: numericalio, Next: opsubst, Prev: mnewton, Up: Top 62 numericalio ************** * Menu: * Introducción a numericalio:: * Funciones y variables para numericalio::  File: maxima.info, Node: Introducción a numericalio, Next: Funciones y variables para numericalio, Prev: numericalio, Up: numericalio 62.1 Introducción a numericalio =============================== El paquete `numericalio' define funciones para leer y escribir ficheros de datos y flujos. Cada elemento a leer o escribir en un fichero debe ser necesariamente un átomo: un número entero, decimal, decimal grande, una cadena o un símbolo; no se admiten fracciones, números complejos o cualquier otra expresión no atómica. Estas funciones pueden llegar a realizar operaciones válidas con expresiones no atómicas, pero estos resultados no se documentan y están sujetos a cambios ulteriores. Los átomos, tanto en los ficheros de entrada como en los de salida, tienen el mismo formato que en los ficheros por lotes de Maxima o en la consola interactiva. En particular, las cadenas deben encerrarse entre comillas dobles, la barra invertida `\' evita cualquier interpretación especial del carácter siguiente, y el símbolo de interrogación `?' se reconoce como el comienzo de un símbolo de Lisp. No se reconoce ningún carácter de continuación de línea interrumpida. El argumento opcional , común a todas las funciones de lectura y escritura, indica qué carácter será el utilizado para separar elementos. 62.1.1 Separadores válidos para lectura --------------------------------------- Para la lectura de ficheros se reconocen los siguientes valores de la variable : `comma' para los valores separados por comas, `pipe' para los valores separados por el carácter de la barra vertical `|', `semicolon' para los valores separados por punto y coma `;', y `space' para cuando los valores se separan por espacios o tabulaciones. Si el nombre del fichero tiene extensión `.csv' y no se especifica el argumento , se tomará por defecto `comma'. Si el fichero tiene cualquier otra extensión diferente de `.csv' y no se especifica `separator_flag', se usará por defecto `space'. En la lectura, varios espacios y tabulaciones sucesivos cuentan como un único separador. Sin embargo, varias comas, barras verticales o punto y comas sucesivos se interpretan que tienen el símbolo `false' entre ellos; por ejemplo, `1234,,Foo' se interpreta lo mismo que si fuese `1234,false,Foo'. En la salida, los átomos `false' deben escribirse explícitamente, por lo que la lista `[1234, false, Foo]' debe escribirse `1234,false,Foo'. 62.1.2 Separadores válidos para escritura ----------------------------------------- Para la escritura, `tab', para valores separados por tabuladores, se acepta como valor de , así como `comma', `pipe', `semicolon' y `space'. En la escritura, el átomo`false' se escribe tal cual y una lista `[1234, false, Foo]' se escribe `1234,false,Foo'.  File: maxima.info, Node: Funciones y variables para numericalio, Prev: Introducción a numericalio, Up: numericalio 62.2 Funciones y variables para numericalio =========================================== -- Función: read_matrix () -- Función: read_matrix (, ) -- Función: read_matrix () -- Función: read_matrix (, ) Lee el fichero o el flujo y devuelve su contenido completo en forma de matriz. Si no se especifica , se entiende que los valores están separados por espacios. La función `read_matrix' obtiene el tamaño de la matriz a partir de los datos de entrada. Cada línea del fichero forma una fila de la matriz. Si hay filas con diferente número de elementos, `read_matrix' emite un mensaje de error. -- Función: read_lisp_array (, ) -- Función: read_lisp_array (, , ) -- Función: read_lisp_array (, ) -- Función: read_lisp_array (, , ) La función `read_lisp_array' requiere que el arreglo sea declarado por `make_array' antes de solicitar la lectura del fichero, lo cual evita la necesidad de calcular las dimensiones del arreglo, especialmente en el caso de arreglos multidimensionales. La función `read_lisp_array' no comprueba si el fichero de entrada es compatible con las dimensiones del arreglo; la entrada se lee como una lista para a continuación completar el arreglo con `fillarray'. -- Función: read_maxima_array (, ) -- Función: read_maxima_array (, , ) -- Función: read_maxima_array (, ) -- Función: read_maxima_array (, , ) Lee el fichero o el flujo y devuelve su contenido completo en forma de array de Maxima. Si no se especifica , se entiende que los valores están separados por espacios. La función `read_maxima_array' requiere que el arreglo sea declarado por `array' antes de solicitar la lectura del fichero, lo cual evita la necesidad de calcular las dimensiones del arreglo, especialmente en el caso de arreglos multidimensionales. La función `read_maxima_array' no comprueba si el fichero de entrada es compatible con las dimensiones del arreglo; la entrada se lee como una lista para a continuación completar el arreglo con `fillarray'. -- Función: read_hashed_array (, ) -- Función: read_hashed_array (, , ) -- Función: read_hashed_array (, ) -- Función: read_hashed_array (, , ) Lee el fichero o el flujo y devuelve su contenido completo en forma de arreglo hash. Si no se especifica , se entiende que los valores están separados por espacios. La función `read_hashed_array' considera el primer término de la línea como un índice, asociando a éste el resto de la línea. Por ejemplo, una fila con el contenido `567 12 17 32 55' equivale a `A[567]: [12, 17, 32, 55]$'. Las filas no necesitan tener el mismo número de elementos. -- Función: read_nested_list () -- Función: read_nested_list (, ) -- Función: read_nested_list () -- Función: read_nested_list (, ) La función `read_nested_list' devuelve una lista con una sublista por cada fila de entrada. Las filas no necesitan tener el mismo número de elementos. Las filas vacías no se ignoran, dando lugar a sublistas vacías. -- Función: read_list () -- Función: read_list (, ) -- Función: read_list () -- Función: read_list (, ) La función `read_list' o flujo y lee todo el fichero de entrada como una lista simple. Si no se especifica , se entiende que los valores están separados por espacios. -- Función: write_data (, ) -- Función: write_data (, , ) -- Función: write_data (, ) -- Función: write_data (, , ) La función `write_data' escribe el objeto en el fichero o flujo . `write_data' escribe las matrices fila a fila. `write_data' escribe arreglos de Maxima y Lisp fila a fila, con un salto de línea al final de cada tabla. Las tablas multidimensionales se separan con saltos de línea adicionales. `write_data' escribe arreglos codificados con un índice seguido de una lista asociativa en cada línea. `write_data' escribe una lista anidada con una sublista por línea. `write_data' escribe una lista simple en una única línea. Cuando `write_data' escribe a un fichero, la variable global `file_output_append' controla si los datos se añaden a fichero o si éste es borrado antes de la escritura. En el caso de flujos, no se toman acciones especiales relacionadas con la sobreescritura. La función `write_data' no cierra el flujo.  File: maxima.info, Node: opsubst, Next: orthopoly, Prev: numericalio, Up: Top 63 opsubst ********** * Menu: * Funciones y variables para opsubst::  File: maxima.info, Node: Funciones y variables para opsubst, Prev: opsubst, Up: opsubst 63.1 Funciones y variables para opsubst ======================================= -- Función: opsubst (,,) -- Función: opsubst (=,) -- Función: opsubst ([=,=,..., =],) La función `opsubst' es similar a la función `subst', excepto por el hecho de que `opsubst' tan solo hace sustituciones de operadores en las expresiones. En general, si es un operador en la expresión , lo cambia por en la expresión . Para determinar el operador, `opsubst' asigna a `inflag' el valor `true', lo cual significa que `opsubst' sustituye el operador interno de la expresión, no el mostrado en la salida formateada. Ejemplo: (%i1) load (opsubst)$ (%i2) opsubst(f,g,g(g(x))); (%o2) f(f(x)) (%i3) opsubst(f,g,g(g)); (%o3) f(g) (%i4) opsubst(f,g[x],g[x](z)); (%o4) f(z) (%i5) opsubst(g[x],f, f(z)); (%o5) g (z) x (%i6) opsubst(tan, sin, sin(sin)); (%o6) tan(sin) (%i7) opsubst([f=g,g=h],f(x)); (%o7) h(x) Internamente, Maxima no hace uso de los operadores de negación unaria, de división ni de la resta, por lo que: (%i8) opsubst("+","-",a-b); (%o8) a - b (%i9) opsubst("f","-",-a); (%o9) - a (%i10) opsubst("^^","//",a/b); a (%o10) - b La representación interna de -a*b es *(-1,a,b), de modo que (%i11) opsubst("[","*", -a*b); (%o11) [- 1, a, b] Si alguno de los operadores no es un sí de Maxima, se emitirá un mensaje de error: (%i12) opsubst(a+b,f, f(x)); Improper name or value in functional position: b + a -- an error. Quitting. To debug this try debugmode(true); Sin embargo se permiten operadores subindicados: (%i13) opsubst(g[5],f, f(x)); (%o13) g (x) 5 Antes de hacer uso de esta función ejecútese `load("opsubst")'.  File: maxima.info, Node: orthopoly, Next: plotdf, Prev: opsubst, Up: Top 64 orthopoly ************ * Menu: * Introducción a polinomios ortogonales:: * Funciones y variables para polinomios ortogonales::  File: maxima.info, Node: Introducción a polinomios ortogonales, Next: Funciones y variables para polinomios ortogonales, Prev: orthopoly, Up: orthopoly 64.1 Introducción a polinomios ortogonales ========================================== El paquete `orthopoly' contiene funciones para la evaluación simbólica y numérica de diversos tipos de polinomios ortogonales, como los de Chebyshev, Laguerre, Hermite, Jacobi, Legendre y ultraesféricos (Gegenbauer). Además, `orthopoly' soporta las funciones esféricas de Bessel, Hankel y armónicas. Referencias: * Abramowitz y Stegun, Handbook of Mathematical Functions, (1972, décima reimpresión, capítulo 22) * Gradshteyn y Ryzhik, Table of Integrals, Series y Products, (1980, edición corregida y ampliada) * Eugen Merzbacher, Quantum Mechanics, (1970, segunda edición) El paquete `orthopoly', junto con su documentación, fue escrito por Barton Willis de la Universidad de Nebraska en Kearney. El paquete se distribuye con la licencia GNU General Public License (GPL). 64.1.1 Iniciándose con orthopoly -------------------------------- `load (orthopoly)' carga el paquete `orthopoly'. Para obtener el polinomio de Legendre de tercer orden, (%i1) legendre_p (3, x); 3 2 5 (1 - x) 15 (1 - x) (%o1) - ---------- + ----------- - 6 (1 - x) + 1 2 2 Para expresarlo como una suma de potencias de , aplíquese o al resultado. (%i2) [ratsimp (%), rat (%)]; 3 3 5 x - 3 x 5 x - 3 x (%o2)/R/ [----------, ----------] 2 2 De forma alternativa, conviértase el segundo argumento de to `legendre_p' (su variable "principal") a una expresión racional canónica (canonical rational expression, CRE)). (%i1) legendre_p (3, rat (x)); 3 5 x - 3 x (%o1)/R/ ---------- 2 Para la evaluación numérica, `orthopoly' hace uso del análisis de error de ejecución para estimar una cota superior del error. Por ejemplo, (%i1) jacobi_p (150, 2, 3, 0.2); (%o1) interval(- 0.062017037936715, 1.533267919277521E-11) Los intervalos tienen la forma `interval (, )', donde es el centro y el radio del intervalo. Puesto que Maxima no soporta aritmética de intervalos, en algunas situaciones, como en los gráficos, puede ser necesario ignorar el error y utilizar el centro del intervalo. Para conseguirlo conviene asignar a la variable `orthopoly_returns_intervals' el valor `false'. (%i1) orthopoly_returns_intervals : false; (%o1) false (%i2) jacobi_p (150, 2, 3, 0.2); (%o2) - 0.062017037936715 Véase la sección Evaluación numérica para más información. La mayor parte de las funciones de `orthopoly' tienen una propiedad `gradef'; así, (%i1) diff (hermite (n, x), x); (%o1) 2 n H (x) n - 1 (%i2) diff (gen_laguerre (n, a, x), x); (a) (a) n L (x) - (n + a) L (x) unit_step(n) n n - 1 (%o2) ------------------------------------------ x La función `unit_step' del segundo ejemplo evita el error que aparecería al evaluar la expresión con igual a 0. (%i3) ev (%, n = 0); (%o3) 0 La propiedad "gradef" sólo se aplica a la variable principal; derivadas respecto de las otras variables darán lugar normalmente a mensajes de error; por ejemplo, (%i1) diff (hermite (n, x), x); (%o1) 2 n H (x) n - 1 (%i2) diff (hermite (n, x), n); Maxima doesn't know the derivative of hermite with respect the first argument -- an error. Quitting. To debug this try debugmode(true); Generalmente, las funciones de `orthopoly' se distribuyen sobre listas y matrices. Al objeto de que la evaluación se realice completamente, las variables opcionales `doallmxops' y `listarith' deben valer ambas `true', que es el valor por defecto. Para ilustrar la distribución sobre matrices sirve el siguiente ejemplo (%i1) hermite (2, x); 2 (%o1) - 2 (1 - 2 x ) (%i2) m : matrix ([0, x], [y, 0]); [ 0 x ] (%o2) [ ] [ y 0 ] (%i3) hermite (2, m); [ 2 ] [ - 2 - 2 (1 - 2 x ) ] (%o3) [ ] [ 2 ] [ - 2 (1 - 2 y ) - 2 ] En el segundo ejemplo, el elemento `i, j'-ésimo es `hermite (2, m[i,j])', que no es lo mismo que calcular `-2 + 4 m . m', según se ve en el siguiente ejemplo. (%i4) -2 * matrix ([1, 0], [0, 1]) + 4 * m . m; [ 4 x y - 2 0 ] (%o4) [ ] [ 0 4 x y - 2 ] Si se evalúa una función en un punto fuera de su dominio de definición, generalmente `orthopoly' devolverá la función sin evaluar. Por ejemplo, (%i1) legendre_p (2/3, x); (%o1) P (x) 2/3 `orthopoly' da soporte a la traducción de expresiones al formato TeX y la representación bidimensional en el terminal. (%i1) spherical_harmonic (l, m, theta, phi); m (%o1) Y (theta, phi) l (%i2) tex (%); $$Y_{l}^{m}\left(\vartheta,\varphi\right)$$ (%o2) false (%i3) jacobi_p (n, a, a - b, x/2); (a, a - b) x (%o3) P (-) n 2 (%i4) tex (%); $$P_{n}^{\left(a,a-b\right)}\left({{x}\over{2}}\right)$$ (%o4) false 64.1.2 Limitaciones ------------------- Cuando una expresión contenga varios polinomios ortogonales con órdenes simbólicos, es posible que aunque la expresión sea nula, Maxima sea incapaz de simplificarla a cero, por lo que si se divide por esta cantidad, aparecerán problemas. Por ejemplo, la siguiente expressión se anula para enteros mayores que 1, no pudiendo Maxima reducirla a cero. (%i1) (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x) + (1 - n) * legendre_p (n - 2, x); (%o1) (2 n - 1) P (x) x - n P (x) + (1 - n) P (x) n - 1 n n - 2 Para un valor específico de se puede reducir la expresión a cero. (%i2) ev (% ,n = 10, ratsimp); (%o2) 0 Generalmente, la forma polinomial de un polinomio ortogonal no es la más apropiada para su evaluación numérica. Aquí un ejemplo. (%i1) p : jacobi_p (100, 2, 3, x)$ (%i2) subst (0.2, x, p); (%o2) 3.4442767023833592E+35 (%i3) jacobi_p (100, 2, 3, 0.2); (%o3) interval(0.18413609135169, 6.8990300925815987E-12) (%i4) float(jacobi_p (100, 2, 3, 2/10)); (%o4) 0.18413609135169 Este resultado se puede mejorar expandiendo el polinomio y evaluando a continuación, lo que da una aproximación mejor. (%i5) p : expand(p)$ (%i6) subst (0.2, x, p); (%o6) 0.18413609766122982 Sin embargo esto no vale como regla general; la expansión del polinomio no siempre da como resultado una expresión más fácil de evaluar numéricamente. Sin duda, la mejor manera de hacer la evaluación numérica consiste en hacer que uno o más de los argumentos de la función sean decimales en coma flotante; de esta forma se utilizarán algoritmos decimales especializados para hacer la evaluación. La función `float' de Maxima trabaja de forma indiscriminada; si se aplica `float' a una expresión que contenga un polinomio ortogonal con el grado u orden simbólico, éstos se pueden transformar en decimales y la expresión no ser evaluada de forma completa. Considérese (%i1) assoc_legendre_p (n, 1, x); 1 (%o1) P (x) n (%i2) float (%); 1.0 (%o2) P (x) n (%i3) ev (%, n=2, x=0.9); 1.0 (%o3) P (0.9) 2 La expresión en `(%o3)' no da como resultado un decimal en coma flotante; `orthopoly' no reconoce decimales donde espera que haya enteros. De forma semejante, la evaluación numérica de la función `pochhammer' para órdenes que excedan `pochhammer_max_index' puede ser problemática; considérese (%i1) x : pochhammer (1, 10), pochhammer_max_index : 5; (%o1) (1) 10 Aplicando `float' no da para un valor decimal (%i2) float (x); (%o2) (1.0) 10.0 A fin de evaluar como decimal, es necesario asignar a `pochhammer_max_index' en valor 11 o mayor y aplicar `float' a . (%i3) float (x), pochhammer_max_index : 11; (%o3) 3628800.0 El valor por defecto de `pochhammer_max_index' es 100; cámbiese este valor tras cargar el paquete `orthopoly'. Por último, téngase en cuenta que las referencias bibliográficas no coinciden a la hora de definir los polinomios ortogonales; en `orthopoly' se han utilizado normalmente las convenciones seguidas por Abramowitz y Stegun. Cuando se sospeche de un fallo en `orthopoly', compruébense algunos casos especiales a fin de determinar si las definiciones de las que el usuario parte coinciden con las utilizadas por el paquete `orthopoly'. A veces las definiciones difieren por un factor de normalización; algunos autores utilizan versiones que hacen que las familias sean ortogonales en otros intervalos diferentes de (-1, 1). Así por ejemplo, para definir un polinomio de Legendre ortogonal en (0, 1) defínase (%i1) shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$ (%i2) shifted_legendre_p (2, rat (x)); 2 (%o2)/R/ 6 x - 6 x + 1 (%i3) legendre_p (2, rat (x)); 2 3 x - 1 (%o3)/R/ -------- 2 64.1.3 Evaluación numérica -------------------------- La mayor parte de las funciones de `orthopoly' realizan análisis de errores en tiempo de ejecución para estimar el error en la evaluación decimal, a excepción de las funciones esféricas de Bessel y los polinomios asociados de Legendre de segunda especie. Para la evaluación numérica, las funciones esféricas de Bessel hacen uso de funciones SLATEC. No se lleva a cabo ningún método especial de evaluación numérica para los polinomios asociados de Legendre de segunda especie. Es posible, aunque improbable, que el error obtenido en las evaluaciones numéricas exceda al error estimado. Los intervalos tienen la forma `interval (, )', siendo el centro del intervalo y su radio. El centro del intervalo puede ser un número complejo, pero el radio será siempre un número real positivo. He aquí un ejemplo: (%i1) fpprec : 50$ (%i2) y0 : jacobi_p (100, 2, 3, 0.2); (%o2) interval(0.1841360913516871, 6.8990300925815987E-12) (%i3) y1 : bfloat (jacobi_p (100, 2, 3, 1/5)); (%o3) 1.8413609135168563091370224958913493690868904463668b-1 Se comprueba que el error es menor que el estimado (%i4) is (abs (part (y0, 1) - y1) < part (y0, 2)); (%o4) true En este ejemplo el error estimado es una cota superior para el error verdadero. Maxima no da soporte a la aritmética de intervalos. (%i1) legendre_p (7, 0.1) + legendre_p (8, 0.1); (%o1) interval(0.18032072148437508, 3.1477135311021797E-15) + interval(- 0.19949294375000004, 3.3769353084291579E-15) El usuario puede definir operadores aritméticos para los intervalos. Para definir la suma de intervalos se puede hacer (%i1) infix ("@+")$ (%i2) "@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2) + part (y, 2))$ (%i3) legendre_p (7, 0.1) @+ legendre_p (8, 0.1); (%o3) interval(- 0.019172222265624955, 6.5246488395313372E-15) Las rutinas especiales para cálculo numérico son llamadas cuando los argumentos son complejos. Por ejemplo, (%i1) legendre_p (10, 2 + 3.0*%i); (%o1) interval(- 3.876378825E+7 %i - 6.0787748E+7, 1.2089173052721777E-6) Compárese con el valor verdadero. (%i1) float (expand (legendre_p (10, 2 + 3*%i))); (%o1) - 3.876378825E+7 %i - 6.0787748E+7 Además, cuando los argumentos son números decimales grandes (big floats), se realizan llamadas a las rutinas numéricas especiales; sin embargo, los decimales grandes se convierten previamente a doble precisión y de este tipo serán también los resultados. (%i1) ultraspherical (150, 0.5b0, 0.9b0); (%o1) interval(- 0.043009481257265, 3.3750051301228864E-14) 64.1.4 Gráficos y orthopoly --------------------------- Para representar gráficamente expresiones que contengan polinomios ortogonales se deben hacer dos cosas: 1. Asignar a la variable opcional `orthopoly_returns_intervals' el valor `false', 2. Comentar (con apóstrofo) las llamadas a las funciones de `orthopoly'. Si las llamadas a las funciones no se comentan, Maxima las evalúa a polinomios antes de hacer el gráfico, por lo que el código especializado en el cálculo numérico no es llamado. Aquí hay un ejemplo de cómo se debe hacer para representar gráficamente una expresión que contiene un polinomio de Legendre: (%i1) plot2d ('(legendre_p (5, x)), [x, 0, 1]), orthopoly_returns_intervals : false; (%o1) La expresión `legendre_p (5, x)' se comenta completamente, que no es lo mismo que comentar el nombre de la función, como en `'legendre_p (5, )'. 64.1.5 Miscelánea de funciones ------------------------------ El paquete `orthopoly' define el símbolo de Pochhammer y la función de escalón unidad en sentencias gradef. Para convertir los símbolos de Pochhammer en cocientes o funciones gamma, hágase uso de `makegamma'. (%i1) makegamma (pochhammer (x, n)); gamma(x + n) (%o1) ------------ gamma(x) (%i2) makegamma (pochhammer (1/2, 1/2)); 1 (%o2) --------- sqrt(%pi) Las derivadas del símbolo de Pochhammer se dan en términos de la función `psi'. (%i1) diff (pochhammer (x, n), x); (%o1) (x) (psi (x + n) - psi (x)) n 0 0 (%i2) diff (pochhammer (x, n), n); (%o2) (x) psi (x + n) n 0 Es necesario tener cuidado con la expresión en `(%o1)', pues la diferencia de las funciones `psi' tiene polos cuando ` = -1, -2, .., -'. Estos polos se cancelan con factores de `pochhammer (, )' haciendo que la derivada sea un polinomio de grado ` - 1' si es entero positivo. El símbolo de Pochhammer se define para órdenes negativos a través de su representación como cociente de funciones gamma. Considérese (%i1) q : makegamma (pochhammer (x, n)); gamma(x + n) (%o1) ------------ gamma(x) (%i2) sublis ([x=11/3, n= -6], q); 729 (%o2) - ---- 2240 De forma alternativa, es posible llegar a este resultado directamente. (%i1) pochhammer (11/3, -6); 729 (%o1) - ---- 2240 La función de escalón unidad es continua por la izquierda; así, (%i1) [unit_step (-1/10), unit_step (0), unit_step (1/10)]; (%o1) [0, 0, 1] En caso de ser necesaria una función escalón unidad que no sea continua ni por la izquierda ni por la derecha en el origen, se puede definir haciendo uso de `signum'; por ejemplo, (%i1) xunit_step (x) := (1 + signum (x))/2$ (%i2) [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)]; 1 (%o2) [0, -, 1] 2 No se debe redefinir la función `unit_step', ya que parte del código de `orthopoly' requiere que la función escalón sea continua por la izquierda. 64.1.6 Algoritmos ----------------- En general, el paquete `orthopoly' gestiona la evaluación simbólica a través de la representación hipergeométrica de los polinomios ortogonales. Las funciones hipergeométricas se evalúan utilizando las funciones (no documentadas) `hypergeo11' y `hypergeo21'. Excepciones son las funciones de Bessel de índice semi-entero y las funciones asociadas de Legendre de segunda especie; las funciones de Bessel de índice semi-entero se evalúan utilizando una representación explícita, mientras que la función asociada de Legendre de segunda especie se evalúa recursivamente. En cuanto a la evaluación numérica, la mayor parte de las funciones se convierten a su forma hipergeométrica, evaluándolas mediante recursión. Además, las excepciones son las funciones de Bessel de índice semi-entero y las funciones asociadas de Legendre de segunda especie. Las funciones de Bessel de índice semi-entero se evalúan numéricamente con código SLATEC.  File: maxima.info, Node: Funciones y variables para polinomios ortogonales, Prev: Introducción a polinomios ortogonales, Up: orthopoly 64.2 Funciones y variables para polinomios ortogonales ====================================================== -- Función: assoc_legendre_p (, , ) Función asociada de Legendre de primera especie. Referencia: Abramowitz y Stegun, ecuaciones 22.5.37, página 779, 8.6.6 (segunda ecuación), página 334 y 8.2.5, página 333. -- Función: assoc_legendre_q (, , ) Función asociada de Legendre de segunda especie. Referencia: Abramowitz y Stegun, ecuaciones 8.5.3 y 8.1.8. -- Función: chebyshev_t (, ) Función de Chebyshev de primera especie. Referencia: Abramowitz y Stegun, ecuación 22.5.47, página 779. -- Función: chebyshev_u (, ) Función de Chebyshev de segunda especie. Referencia: Abramowitz y Stegun, ecuación 22.5.48, página 779. -- Función: gen_laguerre (, , ) Polinomio de Laguerre generalizado. Referencia: Abramowitz y Stegun, ecuación 22.5.54, página 780. -- Función: hermite (, ) Polinomio de Hermite. Referencia: Abramowitz y Stegun, ecuación 22.5.55, página 780. -- Función: intervalp () Devuelve `true' si la entrada es un intervalo y `false' en caso contrario. -- Función: jacobi_p (, , , ) Polinomio de Jacobi. Los polinomios de Jacobi están definidos para todo y ; sin embargo, el peso `(1 - )^ (1 + )^' no es integrable para ` <= -1' o ` <= -1'. Referencia: Abramowitz y Stegun, ecuación 22.5.42, página 779. -- Función: laguerre (, ) Polinomio de Laguerre. Referencia: Abramowitz y Stegun, ecuaciones 22.5.16 y 22.5.54, página 780. -- Función: legendre_p (, ) Polinomio de Legendre de primera especie. Referencia: Abramowitz y Stegun, ecuaciones 22.5.50 y 22.5.51, página 779. -- Función: legendre_q (, ) Polinomio de Legendre de segunda especie. Referencia: Abramowitz y Stegun, ecuaciones 8.5.3 y 8.1.8. -- Función: orthopoly_recur (, ) Devuelve una relación recursiva para la familia de funciones ortogonales con argumentos . La recursión se hace con respecto al grado del polinomio. (%i1) orthopoly_recur (legendre_p, [n, x]); (2 n - 1) P (x) x + (1 - n) P (x) n - 1 n - 2 (%o1) P (x) = ----------------------------------------- n n El segundo argumento de `orthopoly_recur' debe ser una lista con el número correcto de argumentos para la función ; si no lo es, Maxima emite un mensaje de error. (%i1) orthopoly_recur (jacobi_p, [n, x]); Function jacobi_p needs 4 arguments, instead it received 2 -- an error. Quitting. To debug this try debugmode(true); Además, si no es el nombre de ninguna de las familias de polinomios ortogonales, se emite otro mensaje de error. (%i1) orthopoly_recur (foo, [n, x]); A recursion relation for foo isn't known to Maxima -- an error. Quitting. To debug this try debugmode(true); -- Variable opcional: orthopoly_returns_intervals Valor por defecto: `true' Si `orthopoly_returns_intervals' vale `true', los números decimales en coma flotante se retornan con el formato `interval (, )', donde es el centro del intervalo y su radio. El centro puede ser un número complejo, en cuyo caso el intervalo es un disco en el plano complejo. -- Función: orthopoly_weight (, ) Devuelve una lista con tres elementos; el primer elemento es la fórmula del peso para la familia de polinomios ortogonales con los argumentos dados por la lista ; el segundo y tercer elementos son los extremos inferior y superior del intervalo de ortogonalidad. Por ejemplo, (%i1) w : orthopoly_weight (hermite, [n, x]); 2 - x (%o1) [%e , - inf, inf] (%i2) integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]); (%o2) 0 La variable principal de debe ser un símbolo, en caso contrario Maxima emite un mensaje de error. -- Función: pochhammer (, ) Símbolo de Pochhammer. Para enteros no negativos con ` <= pochhammer_max_index', la expresión `pochhammer (, )' se evalúa como el producto ` ( + 1) ( + 2) ... ( + n - 1)' si ` > 0' y como 1 si ` = 0'. Para negativo, `pochhammer (, )' se define como `(-1)^ / pochhammer (1 - , -)'. Así por ejemplo, (%i1) pochhammer (x, 3); (%o1) x (x + 1) (x + 2) (%i2) pochhammer (x, -3); 1 (%o2) - ----------------------- (1 - x) (2 - x) (3 - x) A fin de convertir el símbolo de Pochhammer en un cociente de funciones gamma (véase Abramowitz y Stegun, ecuación 6.1.22), hágase uso de `makegamma'. Por ejemplo, (%i1) makegamma (pochhammer (x, n)); gamma(x + n) (%o1) ------------ gamma(x) Si es mayor que `pochhammer_max_index' o si es simbólico, `pochhammer' devuelve una forma nominal. (%i1) pochhammer (x, n); (%o1) (x) n -- Variable opcional: pochhammer_max_index Valor por defecto: 100 `pochhammer (, )' se evalúa como un producto si y sólo si ` <= pochhammer_max_index'. Ejemplos: (%i1) pochhammer (x, 3), pochhammer_max_index : 3; (%o1) x (x + 1) (x + 2) (%i2) pochhammer (x, 4), pochhammer_max_index : 3; (%o2) (x) 4 Referencia: Abramowitz y Stegun, ecuación 6.1.16, página 256. -- Función: spherical_bessel_j (, ) Función de Bessel esférica de primera especie. Referencia: Abramowitz y Stegun, ecuaciones 10.1.8, página 437 y 10.1.15, página 439. -- Función: spherical_bessel_y (, ) Función de Bessel esférica de segunda especie. Referencia: Abramowitz y Stegun, ecuaciones 10.1.9, página 437 y 10.1.15, página 439. -- Función: spherical_hankel1 (, ) Función esférica de Hankel de primera especie. Referencia: Abramowitz y Stegun, ecuación 10.1.36, página 439. -- Función: spherical_hankel2 (, ) Función esférica de Hankel de segunda especie. Referencia: Abramowitz y Stegun, ecuación 10.1.17, página 439. -- Función: spherical_harmonic (, , , ) Función armónica esférica. Referencia: Merzbacher 9.64. -- Función: unit_step () Función de escalón unidad continua por la izquierda, definida de tal forma que `unit_step ()' se anula para ` <= 0' y es igual a 1 para ` > 0'. En caso de ser necesaria una función escalón unidad que tome el valor 1/2 en el origen, utilícese `(1 + signum ())/2'. -- Función: ultraspherical (, , ) Polinomio ultraesférico o de Gegenbauer. Referencia: Abramowitz y Stegun, ecuación 22.5.46, página 779.  File: maxima.info, Node: plotdf, Next: romberg, Prev: orthopoly, Up: Top 65 plotdf ********* * Menu: * Introducción a plotdf:: * Funciones y variables para plotdf::  File: maxima.info, Node: Introducción a plotdf, Next: Funciones y variables para plotdf, Prev: plotdf, Up: plotdf 65.1 Introducción a plotdf ========================== La función `plotdf' crea un gráfico del campo de direcciones para una Ecuación Diferencial Ordinaria (EDO) de primer orden, o para un sistema de dos EDO's autónomas, de primer orden. Como se trata de un paquete adicional, para poder usarlo debe cargarlo primero con el comando `load("plotdf")'. También es necesario que Xmaxima esté instalado, a pesar de que ejecute Maxima desde otra interface diferente. Para dibujar el campo de direcciones de una única EDO, esa ecuación deberá escribirse en la forma siguiente: dy -- = F(x,y) dx y la función será dada como argumento para el comando `plotdf'. La variable independiente tiene que ser siempre y la variable dependiente . A esas dos variables no podrá estar asociado ningún valor numérico. Para dibujar el campo de direcciones de un sistema autónomo de dos EDO's, Las dos ecuaciones deben ser escritas en la forma siguiente dx dy -- = G(x,y) -- = F(x,y) dt dt y el argumento para el comando `plotdf' será una lista con dos expresiones para las funciones y . Cuando se trabaja con una única ecuación, `plotdf' asume implícitamente que `x=t' y `G(x,y)=1', transformando la ecuación en un sistema autónomo con dos ecuaciones.  File: maxima.info, Node: Funciones y variables para plotdf, Prev: Introducción a plotdf, Up: plotdf 65.2 Funciones y variables para plotdf ====================================== -- Function: plotdf (,...opciones...) -- Function: plotdf (`[',`]',...opciones...) Dibuja un campo de direcciones en dos dimensiones y . , y son expresiones que dependen de y . Además de esas dos variables, las dos expresiones pueden depender de un conjunto de parámetros, con valores numéricos que son dados por medio de la opción `parameters' (la sintaxis de esa opción se explica mas al frente), o con un rango de posibles valores definidos con la opción . Varias otras opciones se pueden incluir dentro del comando, o seleccionadas en el menú. Haciendo click en un punto del gráfico se puede hacer que sea dibujada la curva integral que pasa por ese punto; lo mismo puede ser hecho dando las coordenadas del punto con la opción `trajectory_at' dentro del comando plotdf. La dirección de integración se puede controlar con la opción `direction', que acepta valores de _forward_, _backward_ ou _both_. El número de pasos realizado en la integración numérica se controla con la opción `nsteps' y el incremento del tiempo en cada paso con la opción `tstep'. Se usa el método de Adams Moulton para hacer la integración numérica; también es posible cambiar para el método de Runge-Kutta de cuarto orden con ajuste de pasos. Menú de la ventana del gráfico: El menú de la ventana gráfica dispone de las siguientes opciones: _Zoom_, que permite cambiar el comportamiento del ratón, de manera que hará posible el hacer zoom en la región del gráfico haciendo clic con el botón izquierdo. Cada clic agranda la imagen manteniendo como centro de la misma el punto sobre el cual se ha hecho clic. Manteniendo pulsada la tecla mientras se hace clic, retrocede al tamaño anterior. Para reanudar el cálculo de las trayectorias cuando se hace clic, seleccine la opción _Integrate_ del menú. La opción _Config_ del menú se puede utilizar para cambiar la(s) EDO(S) y algunos otros ajustes. Después de hacer los cambios, se debe utilizar la opción _Replot_ para activar los nuevos ajustes. Si en el campo _Trajectory at_ del menú de diálogo de _Config_ se introducen un par de coordenadas y luego se pulsa la tecla , se mostrará una nueva curva integral, además de las ya dibujadas. Si se selecciona la opción _Replot_, sólo se mostrará la última curva integral seleccionada. Manteniendo pulsado el botón derecho del ratón mientras se mueve el cursor, se puede arrastrar el gráfico horizontal y verticalmente. Otros parámetros, como pueden ser el número de pasos, el valor inicial de , las coordenadas del centro y el radio, pueden cambiarse en el submenú de la opción _Config_. Con la opción _Save_, se puede obtener una copia del gráfico en una impresora Postscript o guardarlo en un fichero Postscript. Para optar entre la impresión o guardar en fichero, se debe seleccionar _Print Options_ en la ventana de diálogo de _Config_. Una vez cubiertos los campos de la ventana de diálogo de _Save_, será necesario seleccionar la opción _Save_ del primer menú para crear el fichero o imprimir el gráfico. Opciones gráficas: La función `plotdf' admite varias opciones, cada una de las cuales es una lista de dos o más elementos. El primer elemento es el nombre de la opción, y el resto está formado por el valor o valores asignados a dicha opción. La función `plotdf' reconoce las siguientes opciones: * "tstep" establece la amplitud de los incrementos en la variable independiente , utilizados para calcular la curva integral. Si se aporta sólo una expresión , la variable será directamente proporcional a . El valor por defecto es 0.1. * "nsteps" establece el número de pasos de longitud `tstep' que se utilizarán en la variable independiente para calcular la curva integral. El valor por defecto es 100. * "direction" establece la dirección de la variable independiente que será seguida para calcular una curva integral. Valores posibles son: `forward', para hacer que la variable independiente aumente `nsteps' veces, con incrementos `tstep'; `backward', para hacer que la variable independiente disminuya; `both', para extender la curva integral `nsteps' pasos hacia adelante y `nsteps' pasos hacia atrás. Las palabras `right' y `left' se pueden utilizar como sinónimos de `forward' y `backward'. El valor por defecto es `both'. * "tinitial" establece el valor inicial de la variable utilizado para calcular curvas integrales. Puesto que las ecuaciones diferenciales son autónomas, esta opción sólo aparecerá en los gráficos de las curvas como funciones de . El valor por defecto es 0. * "versus_t" se utiliza para crear una segunda ventana gráfica, con el gráfico de una curva integral, como dos funciones , , de variable independiente . Si se le da a `versus_t' cualquier valor diferente de 0, se mostrará la segunda ventana gráfica, la cual incluye otro menú, similar al de la ventana principal. El valor por defecto es 0. * "trajectory_at" establece las coordenadas y para el extremo inicial de la curva integral. No tiene asignado valor por defecto. * "parameters" establece una lista de parámetros, junto con sus valores numéricos, que son utilizados en la definición de la ecuación diferencial. Los nombres de los parámetros y sus valores deben escribirse en formato de cadena de caracteres como una secuencia de pares `nombre=valor' separados por comas. * "sliders" establece una lista de parámetros que se cambiarán interactivamente utilizando barras de deslizamiento, así como los rangos de variación de dichos parámetros. Los nombres de los parámetros y sus rangos deben escribirse en formato de cadena de caracteres como una secuencia de pares `nombre=min:max' separados por comas. * "xfun" establece una cadena de caracteres con funciones de separadas por puntos y comas para ser representadas por encima del campo de direcciones. Estas funciones serán interpretadas por Tcl, no por Maxima. * "xradius" es la mitad de la longitud del rango de valores a representar en la dirección x. El valor por defecto es 10. * "yradius" es la mitad de la longitud del rango de valores a representar en la dirección y. El valor por defecto es 10. * "xcenter" es la coordenada x del punto situado en el centro del gráfico. El valor por defecto es 0. * "ycenter" es la coordenada y del punto situado en el centro del gráfico. El valor por defecto es 0. * "width" establece el ancho de la ventana gráfica en píxeles. El valor por defecto es 500. * "height" establece la altura de la ventana gráfica en píxeles. El valor por defecto es 500. Ejemplos: NOTA: Dependiendo de la interface que se use para Maxima, las funciones que usan `openmath', incluida `plotdf', pueden desencadenar un fallo si terminan en punto y coma, en vez del símbolo de dólar. Para evitar problemas, se usará el símbolo de dólar en todos ejemplos. * Para mostrar el campo de direcciones de la ecuación diferencial y' = exp(-x) + y y la solución que pasa por (2, -0.1): (%i1) load("plotdf")$ (%i2) plotdf(exp(-x)+y,[trajectory_at,2,-0.1]); * Para mostrar el campo de direcciones de la ecuación diff(y,x) = x - y^2 y la solución de condición inicial y(-1) = 3, se puede utilizar la sentencia: (%i3) plotdf(x-y^2,[xfun,"sqrt(x);-sqrt(x)"], [trajectory_at,-1,3], [direction,forward], [yradius,5],[xcenter,6]); El gráfico también muestra la función y = sqrt(x). * El siguiente ejemplo muestra el campo de direcciones de un oscilador armónico, definido por las ecuaciones dx/dt = y y dy/dt = -k*x/m, y la curva integral que pasa por (x,y) = (6,0), con una barra de deslizamiento que permitirá cambiar el valor de m interactivamente (k permanece fijo a 2): (%i4) plotdf([y,-k*x/m],[parameters,"m=2,k=2"], [sliders,"m=1:5"], [trajectory_at,6,0]); * Para representar el campo de direcciones de la ecuación de Duffing, m*x"+c*x'+k*x+b*x^3 = 0, se introduce la variable y=x' y se hace: (%i5) plotdf([y,-(k*x + c*y + b*x^3)/m], [parameters,"k=-1,m=1.0,c=0,b=1"], [sliders,"k=-2:2,m=-1:1"],[tstep,0.1]); * El campo de direcciones de un péndulo amortiguado, incluyendo la solución para condiciones iniciales dadas, con una barra de deslizamiento que se puede utilizar para cambiar el valor de la masa, m, y con el gráfico de las dos variables de estado como funciones del tiempo: (%i6) plotdf([y,-g*sin(x)/l - b*y/m/l], [parameters,"g=9.8,l=0.5,m=0.3,b=0.05"], [trajectory_at,1.05,-9],[tstep,0.01], [xradius,6],[yradius,14], [xcenter,-4],[direction,forward],[nsteps,300], [sliders,"m=0.1:1"], [versus_t,1]);  File: maxima.info, Node: romberg, Next: simplex, Prev: plotdf, Up: Top 66 romberg ********** * Menu: * Funciones y variables para romberg::  File: maxima.info, Node: Funciones y variables para romberg, Prev: Top, Up: Top 66.1 Funciones y variables para romberg ======================================= -- Función: romberg (, , , ) -- Función: romberg (, , ) Integra numéricamente por el método de Romberg. La llamada `romberg(, , , )' devuelve una estimación de la integral `integrate(, , , )'. El argumento debe ser una expresión reducible a un valor decimal en coma flotante cuando es a su vez un número decimal. La llamada `romberg(, , )' devuelve una estimación de la integral `integrate((x), x, , )', siendo `x' el único argumento de . El argumento debe ser una función en Lisp o en Maxima que devuelva un valor decimal en coma flotante cuando es a su vez un número decimal; puede ser el nombre de una función de Maxima traducida o compilada. La exactitud de `romberg' se controla con las variables globales `rombergabs' y `rombergtol'. La función `romberg' termina con éxito su cálculo cuando la diferencia absoluta entre sucesivas aproximaciones es menor que `rombergabs', o cuando la diferencia relativa de sucesivas aproximaciones es menor que `rombergtol'. Así, cuando `rombergabs' vale 0.0 (su valor por defecto) sólo tiene efecto el test del error relativo basado en `romberg'. La función `romberg' reduce a mitades sucesivas la amplitud del paso un máximo de `rombergit' veces antes de abandonar el cómputo; el número máximo de evaluaciones del integrando es, por consiguiente, igual a `2^rombergit'. De no satisfacerse el criterio de error establecido por `rombergabs' y `rombergtol', `romberg' devuelve un mensaje de error. La función `romberg' hace siempre al menos `rombergmin' iteraciones; se trata de una heurística para evitar la finalización prematura cuando el integrando oscila mucho. La función `romberg' evalúa el integrando repetidamente tras asignarle a la variable de integración un valor específico. Este criterio permite anidar llamadas a `romberg' para calcular integrales múltiples. Sin embargo, los errores de cálculo no tienen en cuenta los errores de las integraciones anidadas, por lo que tales errores pueden subestimarse. Por otro lado, métodos especialmente desarrollados para integraciones múltiples pueden dar la misma exactitud con menos evaluaciones del integrando. Para hacer uso de esta función ejecútese primero `load(romberg)'. Véase también `QUADPACK', un conjunto de funciones para integración numérica. Ejemplos: Una integración unidimensional. (%i1) load (romberg); (%o1) /usr/share/maxima/5.11.0/share/numeric/romberg.lisp (%i2) f(x) := 1/((x - 1)^2 + 1/100) + 1/((x - 2)^2 + 1/1000) + 1/((x - 3)^2 + 1/200); 1 1 1 (%o2) f(x) := -------------- + --------------- + -------------- 2 1 2 1 2 1 (x - 1) + --- (x - 2) + ---- (x - 3) + --- 100 1000 200 (%i3) rombergtol : 1e-6; (%o3) 9.9999999999999995E-7 (%i4) rombergit : 15; (%o4) 15 (%i5) estimate : romberg (f(x), x, -5, 5); (%o5) 173.6730736617464 (%i6) exact : integrate (f(x), x, -5, 5); (%o6) 10 sqrt(10) atan(70 sqrt(10)) + 10 sqrt(10) atan(30 sqrt(10)) + 10 sqrt(2) atan(80 sqrt(2)) + 10 sqrt(2) atan(20 sqrt(2)) + 10 atan(60) + 10 atan(40) (%i7) abs (estimate - exact) / exact, numer; (%o7) 7.5527060865060088E-11 Una integración bidimensional, implementada mediante llamadas anidadas a `romberg'. (%i1) load (romberg); (%o1) /usr/share/maxima/5.11.0/share/numeric/romberg.lisp (%i2) g(x, y) := x*y / (x + y); x y (%o2) g(x, y) := ----- x + y (%i3) rombergtol : 1e-6; (%o3) 9.9999999999999995E-7 (%i4) estimate : romberg (romberg (g(x, y), y, 0, x/2), x, 1, 3); (%o4) 0.81930239628356 (%i5) assume (x > 0); (%o5) [x > 0] (%i6) integrate (integrate (g(x, y), y, 0, x/2), x, 1, 3); 3 2 log(-) - 1 9 2 9 (%o6) - 9 log(-) + 9 log(3) + ------------ + - 2 6 2 (%i7) exact : radcan (%); 26 log(3) - 26 log(2) - 13 (%o7) - -------------------------- 3 (%i8) abs (estimate - exact) / exact, numer; (%o8) 1.3711979871851024E-10 -- Variable opcional: rombergabs Valor por defecto: 0.0 La exactitud de `romberg' se controla con las variables globales `rombergabs' y `rombergtol'. La función `romberg' termina con éxito su cálculo cuando la diferencia absoluta entre sucesivas aproximaciones es menor que `rombergabs', o cuando la diferencia relativa de sucesivas aproximaciones es menor que `rombergtol'. Así, cuando `rombergabs' vale 0.0 (su valor por defecto) sólo tiene efecto el test del error relativo basado en `romberg'. Véanse también `rombergit' y `rombergmin'. -- Variable opcional: rombergit Valor por defecto: 11 La función `romberg' reduce a mitades sucesivas la amplitud del paso un máximo de `rombergit' veces antes de abandonar el cómputo; el número máximo de evaluaciones del integrando es, por consiguiente, igual a `2^rombergit'. La función `romberg' hace siempre al menos `rombergmin' iteraciones; se trata de una heurística para evitar la finalización prematura cuando el integrando oscila mucho. Véanse también `rombergabs' y `rombergtol'. -- Variable opcional: rombergmin Valor por defecto: 0 La función `romberg' hace siempre al menos `rombergmin' iteraciones; se trata de una heurística para evitar la finalización prematura cuando el integrando oscila mucho. Véanse también `rombergit', `rombergabs' y `rombergtol'. -- Variable opcional: rombergtol Valor por defecto: 1e-4 La exactitud de `romberg' se controla con las variables globales `rombergabs' y `rombergtol'. La función `romberg' termina con éxito su cálculo cuando la diferencia absoluta entre sucesivas aproximaciones es menor que `rombergabs', o cuando la diferencia relativa de sucesivas aproximaciones es menor que `rombergtol'. Así, cuando `rombergabs' vale 0.0 (su valor por defecto) sólo tiene efecto el test del error relativo basado en `romberg'. Véanse también `rombergit' y `rombergmin'.  File: maxima.info, Node: simplex, Next: simplification, Prev: romberg, Up: Top 67 simplex ********** * Menu: * Introducción a simplex:: * Funciones y variables para simplex::  File: maxima.info, Node: Introducción a simplex, Next: Funciones y variables para simplex, Prev: simplex, Up: simplex 67.1 Introducción a simplex =========================== El paquete `simplex' utiliza el algoritmo simplex para programación lineal. Ejemplo: (%i1) load("simplex")$ (%i2) minimize_lp(x+y, [3*x+2*y>2, x+4*y>3]); 9 7 1 (%o2) [--, [y = --, x = -]] 10 10 5  File: maxima.info, Node: Funciones y variables para simplex, Prev: Introducción a simplex, Up: simplex 67.2 Funciones y variables para simplex ======================================= -- Variable opcional: epsilon_lp Valor por defecto: `10^-8' Error epsilon utilizado en los cálculos numéricos de `linear_program'. Véase también `linear_program'. -- Función: linear_program (, , ) La función `linear_program' es una implementación del algoritmo simplex. La instrucción `linear_program(A, b, c)' calcula un vector tal que minimiza `c.x' bajo las restricciones `A.x = b' y `x >= 0'. El argumento es una matriz y los argumentos y son listas. La función `linear_program' devuelve una lista que contiene el vector solución y el valor mínimo de `c.x'. Si el problema no está acotado, devuelve el mensaje "Problem not bounded!" y si el problema no es factible, devuelve el mensaje "Problem not feasible!". Para usar esta función, cárguese primero el paquete con la instrucción `load(simplex);'. Ejemplo: (%i1) A: matrix([1,1,-1,0], [2,-3,0,-1], [4,-5,0,0])$ (%i2) b: [1,1,6]$ (%i3) c: [1,-2,0,0]$ (%i4) linear_program(A, b, c); [ 1 1 - 1 0 ] [ ] (%o4) linear_program([ 2 - 3 0 - 1 ], [1, 1, 6], [ ] [ 4 - 5 0 0 ] [1, - 2, 0, 0]) Véanse también `minimize_lp', `scale_lp' y `epsilon_lp'. -- Función: maximize_lp (, , []) Maximiza la función objetivo lineal sujeta a ciertas restricciones lineales . Véase `minimize_lp' para una descripción detallada de los argumentos y de la respuesta dada por esta función. -- Función: minimize_lp (, , []) Minimiza la función objetivo lineal sujeta a ciertas restricciones lineales , siendo ésta una lista de ecuaciones o inecuaciones lineales. En las inecuaciones estrictas se reemplaza `>' por `>=' y `<' por `<='. El argumento opcional es una lista de variables de decisión que se suponen positivas. Si el mínimo existe, `minimize_lp' devuelve una lista que contiene el valor mínimo de la función objetivo y una lista de valores para las variables de decisión con los que se alcanza el mínimo. Si el problema no está acotado, devuelve el mensaje "Problem not bounded!" y si el problema no es factible, devuelve el mensaje "Problem not feasible!". Las variables de decisión no se suponen no negativas. Si todas las variables de decisión son no negativas, asígnese el valor `true' a la variable `nonegative_lp'. Si sólo algunas de las variables de decisión son positivas, lístense en el argumento opcional , lo cual es más eficiente que añadir restricciones. La función `minimize_lp' utiliza el algoritmo simplex implementado en la función `linear_program' de Maxima. Para usar esta función, cárguese primero el paquete con la instrucción `load(simplex);'. Ejemplos: (%i1) minimize_lp(x+y, [3*x+y=0, x+2*y>2]); (%o1) minimize_lp(y + x, [y + 3 x = 0, 2 y + x > 2]) (%i2) minimize_lp(x+y, [3*x+y>0, x+2*y>2]), nonegative_lp=true; (%o2) minimize_lp(y + x, [y + 3 x > 0, 2 y + x > 2]) (%i3) minimize_lp(x+y, [3*x+y=0, x+2*y>2]), nonegative_lp=true; (%o3) minimize_lp(y + x, [y + 3 x = 0, 2 y + x > 2]) (%i4) minimize_lp(x+y, [3*x+y>0]); (%o4) minimize_lp(y + x, [y + 3 x > 0]) Véanse también `maximize_lp', `nonegative_lp' y `epsilon_lp'. -- Variable opcional: nonegative_lp Valor por defecto: `false' Si `nonegative_lp' vale `true' todas las variables de decisión pasadas a `minimize_lp' y a `maximize_lp' se suponen positivas. Véase también `minimize_lp'.  File: maxima.info, Node: simplification, Next: solve_rec, Prev: simplex, Up: Top 68 simplification ***************** * Menu: * Introducción a simplification:: * Funciones y variables para simplification::  File: maxima.info, Node: Introducción a simplification, Next: Funciones y variables para simplification, Prev: simplification, Up: simplification 68.1 Introducción a simplification ================================== El directorio `maxima/share/simplification' contiene programas que implementan algunas reglas y funciones para simplificar expresiones, así como ciertas funciones no relacionadas con la simplificación.  File: maxima.info, Node: Funciones y variables para simplification, Prev: Introducción a simplification, Up: simplification 68.2 Funciones y variables para simplification ============================================== 68.2.1 Paquete absimp --------------------- El paquete `absimp' contiene reglas para aplicar patrones que extienden el sistema de reglas nativo de Maxima para las funciones `abs' y `signum', respetando las relaciones establecidas con la función `assume' o con declaraciones tales como `modedeclare (m, even, n, odd)' para enteros pares o impares. En el paquete `absimp' se definen las funciones `unitramp' y `unitstep' en términos de `abs' y `signum'. La instrucción `load (absimp)' carga este paquete y `demo (absimp)' desarrolla una demostración sobre el uso del mismo. Ejemplos: (%i1) load (absimp)$ (%i2) (abs (x))^2; 2 (%o2) x (%i3) diff (abs (x), x); x (%o3) ------ abs(x) (%i4) cosh (abs (x)); (%o4) cosh(x) 68.2.2 Paquete facexp --------------------- El paquete `facexp' contiene varias funciones que le aportan al usuario la posibilidad de estructurar expresiones controlando su expansión. Esta capacidad es especialmente útil cuando la expresión contiene variables con significado físico, ya que se suele dar el caso de que la forma más sencilla para estas expresiones se obtiene cuando se expanden respecto de estas variables y luego se factoriza respecto de sus coeficientes. Si bien es cierto que este procedimiento no es difícil de llevar a cabo con las funciones estándar de Maxima, pueden ser necesarios algunos retoques adicionales que sí pueden ser más difíciles de hacer. La función `facsum' y sus formas relacionadas proporcionan un método para controlar la estructura de expresiones. La función `collectterms' puede usarse para añadir dos o más expresiones que ya hayan sido simplificadas de la forma indicada, sin necesidad de volver a simplificar la expresión completa. Esta función puede ser útil cuando las expresiones sean largas. La instrucción `load (facexp)' carga este paquete y `demo (facexp)' hace una demostración sobre su uso. -- Función: facsum (, , ..., ) Devuelve una expresión equivalente a , la cual depende de los argumentos , ..., , y éstos pueden ser de cualquiera de las formas aceptables para `ratvars', o listas de estas formas. Si los argumentos no son listas, la forma devuelta se expande completamente con respecto de los argumentos, siendo los coeficientes de tales argumentos factorizados. Estos coeficientes no contienen a ninguno de los argumentos, excepto quizás de una forma no racional. En caso de que cualquiera de los argumentos sea una lista, entonces todos ellos se combinan en una única lista, y en lugar de llamar a `factor' para los coeficientes de los argumentos, `facsum' se llama a sí misma utilizando esta nueva lista única como lista de argumentos. Es posible que se quiera utilizar `facsum' con respecto a expresiones más complicadas, tales como `log (x + y)'. Estos argumentos son también admisibles. Si no se especifican variables, como en `facsum ()', el resultado devuelto es el mismo que el conseguido mediante `ratsimp ()'. En ocasiones puede ser necesario obtener cualquiera de las formas anteriores especificadas por sus operadores principales. Por ejemplo, se puede querer aplicar `facsum' con respecto a todos los `log'; en este caso, se puede incluir entre los argumentos bien los `log' específicos que se quieran tratar de esta manera, bien la expresión `operator (log)' o `'operator (log)'. Si se quiere aplicar `facsum' a con respecto a los operadores , ..., , se debe evaluar `facsum (, operator (, ..., ))'. La forma `operator' puede aparecer también dentro de las listas de argumentos. Además, dándole valores a las variables opcionales `facsum_combine' y `nextlayerfactor' se puede controlar el resultado de `facsum'. -- Variable global: nextlayerfactor Valor por defecto: `false' Si `nextlayerfactor' vale `true', las llamadas recursivas de `facsum' se aplican a los factores de la forma factorizada de los coeficientes de los argumentos. Si vale `false', `facsum' se aplica a cada coeficiente como un todo cada vez que se efectúen llamadas recursivas a `facsum'. La inclusión del átomo `nextlayerfactor' en la lista de argumentos de `facsum' tiene el mismo efecto que `nextlayerfactor: true', pero solamente para el siguiente nivel de la expresión. Puesto que `nextlayerfactor' toma siempre uno de los valores `true' o `false', debe aparecer comentado (comilla simple) cada vez que aparezca en la lista de argumentos de `facsum'. -- Variable global: facsum_combine Valor por defecto: `true' La variable `facsum_combine' controla la forma del resultado final devuelto por `facsum' si su argumento es un cociente de polinomios. Si `facsum_combine' vale `false', el resultado será una suma completamente expandida, pero si vale `true', la expresión devuelta es un cociente de polinomios. -- Función: factorfacsum (, , ... ) Devuelve una expresión equivalente a obtenida aplicando `facsum' a los factores de , de argumentos , ... . Si alguno de los factores de se eleva a una potencia, tanto el factor como el exponente se procesarán de esta manera. -- Función: collectterms (, ..., ) Si algunas expresiones fueron ya simplificadas con `facsum', `factorfacsum', `factenexpand', `facexpten' o `factorfacexpten', debiendo ser luego sumadas, puede ser conveniente combinarlas utilizando la función `collecterms', la cual admite como argumentos todos aquéllos que se puedan pasar a las anteriormente citadas funciones, con la excepción de `nextlayerfactor', que no tiene efecto alguno sobre `collectterms'. La ventaja de `collectterms' es que devuelve una forma similar a la de `facsum', pero debido a que suma expresiones que ya han sido previamente procesadas, no necesita repetir esta operación, lo cual resulta ser especialmente útil cuando las expresiones a sumar son muy grandes. 68.2.3 Paquete functs --------------------- -- Función: rempart (, ) Elimina la parte de la expresión . Si es una lista de la forma `[, ]', entonces las partes desde a serán eliminadas. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: wronskian ([, ..., ], ) Devuelve la matriz wronskiana de las funciones , ..., dependeientes de la variable . Los argumentos , ..., pueden ser nombres de funciones definidas por el usuario, o expresiones de variable . El determinante de la matriz wronskiana es el determinante wronskiano del conjunto de funciones. Las funciones serán linealmente dependientes si este determinante es nulo. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: tracematrix () Devuelve la traza (suma de los elementos de la diagonal) de la matriz . Para hacer uso de esta función ejecutar `load(functs)'. -- Función: rational () Multiplica el numerador y denominador de por el complejo conjugado del denominador, racionalizando así el denominador. Devuelve la expresión canónica racional (canonical rational expression, CRE) si el argumento es de esta forma, en caso contrario devuelve una expresión en formato común. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: logand (,) Devuelve el "y" lógico binario de los argumentos e . Para hacer uso de esta función ejecutar `load(functs)'. -- Función: logor (,) Devuelve el "o" lógico binario de los argumentos e . Para hacer uso de esta función ejecutar `load(functs)'. -- Función: logxor (,) Devuelve el "o-excusivo" lógico binario de los argumentos e . Para hacer uso de esta función ejecutar `load(functs)'. -- Función: nonzeroandfreeof (, ) Devuelve `true' si es diferente de cero y `freeof (, )' devuelve `true'. En caso contrario devuelve `false'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: linear (, ) Si es una expresión lineal respecto de la variable , `linear' devuelve `* + ', siendo no nula y, junto con , no incluye a . En otro caso, `linear' devuelve . Para hacer uso de esta función ejecutar `load(functs)'. -- Función: gcdivide (

, ) Si `takegcd' vale `true', `gcdivide' divide los polinomios

y por su máximo común divisor y devuelve el cociente de los resultados. Si `takegcd' vale `false', `gcdivide' devuelve el cociente `

/'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: arithmetic (, , ) Devuelve el -ésimo término de la progresión aritmética `, + , + 2*, ..., + ( - 1)*'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: geometric (, , ) Devuelve el -ésimo término de la progresión geométrica `, *, *^2, ..., *^( - 1)'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: harmonic (, , , ) Devuelve el -ésimo término de la progresión armónica `/, /( + ), /( + 2*), ..., /( + ( - 1)*)'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: arithsum (, , ) Devuelve la suma de la progresión aritmética desde hasta el -ésimo término. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: geosum (, , ) Devuelve la suma de la sucesión geométrica hasta el -ésimo término. Si es infinito (`inf') la suma será finita sólo si el valor absoluto de es menor que 1. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: gaussprob () Devuelve la función de densidad de probabilidad, normal `%e^(-^2/2) / sqrt(2*%pi)'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: gd () Devuelve la función de Gudermann, `2 * atan(%e^ - %pi/2)'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: agd () Devuelve la inversa de la función de Gudermann, `log (tan (%pi/4 + x/2)))'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: vers () Devuelve `1 - cos (x)'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: covers () Devuelve `1 - sin ()'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: exsec () Devuelve `sec () - 1'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: hav () Devuelve `(1 - cos(x))/2'. Para hacer uso de esta función ejecutar `load(functs)'. -- Función: combination (, ) Calcula el número de combinaciones de objetos tomados de en . Para hacer uso de esta función ejecutar `load(functs)'. -- Función: permutation (, ) Calcula el número de permutaciones de , seleccionados de un conjunto de . Para hacer uso de esta función ejecutar `load(functs)'. 68.2.4 Paquete ineq ------------------- El paquete `ineq' contiene reglas de simplificación para desigualdades Una sesión de ejemplo: (%i1) load(ineq)$ Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. Warning: Putting rules on '+' or '*' is inefficient, and may not work. (%i2) a>=4; /* a sample inequality */ (%o2) a >= 4 (%i3) (b>c)+%; /* add a second, strict inequality */ (%o3) b + a > c + 4 (%i4) 7*(x=3*z); /* multiply by a negative number */ (%o5) - 2 x <= - 6 z (%i6) (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */ 2 (%o6) 1 <= a + 1 (%i7) assume(x>0)$ x*(2<3); /* assuming x>0 */ (%o7) 2 x < 3 x (%i8) a>=b; /* another inequality */ (%o8) a >= b (%i9) 3+%; /* add something */ (%o9) a + 3 >= b + 3 (%i10) %-3; /* subtract it out */ (%o10) a >= b (%i11) a>=c-b; /* yet another inequality */ (%o11) a >= c - b (%i12) b+%; /* add b to both sides */ (%o12) b + a >= c (%i13) %-c; /* subtract c from both sides */ (%o13) - c + b + a >= 0 (%i14) -%; /* multiply by -1 */ (%o14) c - b - a <= 0 (%i15) (z-1)^2>-2*z; /* determining truth of assertion */ 2 (%o15) (z - 1) > - 2 z (%i16) expand(%)+2*z; /* expand this and add 2*z to both sides */ 2 (%o16) z + 1 > 0 (%i17) %,pred; (%o17) true Debe tenerse cuidado con el uso de paréntesis que incluyan desigualdades; si se escribe `(A > B) + (C = 5)' el resultado es `A + C > B + 5', pero `A > B + C = 5' es un error sintáctico y `(A > B + C) = 5' es una cosa completamente diferente. Ejecútese `disprule (all)' para ver la lista completa de las reglas definidas. Maxima preguntará al usuario cuando desconozca el signo de una cantidad que multiplica a una desigualdad. Los fallos más comunes son: eq: a > b; 2*eq; % - eq; Otro problema es el producto de una desigualdad por cero. Si se escribe `x*' y Maxima pregunta por el signo de `x' y se responde que vale `zero' (o `z'), el programa devuelve `x*' sin hacer uso de la información de que `x' es 0. En tal caso se debería escribir `ev (%, x: 0)', ya que la base de datos sólo será utilizada para fines comparativos y no para evaluar `x'. El usuario puede apreciar que las respuestas son más lentas al cargarse este paquete, ya que el simplificador deberá examinar más reglas que cuando no se hace uso del paquete, por lo que puede ser conveniente borrar estas reglas cuando ya no se haga uso de ellas. Ejecútese `kill (rules)' para eliminar todas las reglas (incluidas las definidas por el usuario); también es posible eliminar parte de ellas o utilizar `remrule' sobre una reglas específica. Nótese que si se carga este paquete después de haber definido otras reglas de igual nombre,se borrarán las antiguas. Las reglas de este paquete son: `*rule1', ..., `*rule8', `+rule1', ..., `+rule18', debiéndose encerrar entre comillas el nombre de la reglas para referenciarse a ellas, como en `remrule ("+", "+rule1")' para eliminar la primera regla sobre `"+"', o `disprule ("*rule2")' para mostrar la definición de la segunda regla multiplicativa. 68.2.5 Paquete rducon --------------------- -- Función: reduce_consts () Sustituye subexpresiones constantes de por átomos, guardando la definición de todos ellos en la lista de ecuaciones `const_eqns' y devolviendo el expresión ya modificada. Se consideran partes constantes de aquellas que devuelven `true' cuando se les aplica la función `constantp', por lo que antes de llamar a `reduce_consts' se debe ejecutar declare ([], constant)$ para crear la base de datos de las cantidades constantes presentes en la expresión. Si se pretende generar código Fortran después de estos cálculos simbólicos, una de las primeras secciones del código debe ser el cálculo de las constantes. Para generar este segmento de código hacer map ('fortran, const_eqns)$ Junto a `const_eqns', otras variables que afectan a `reduce_consts' son: `const_prefix' (Valor por defecto: `xx') es la cadena de caracteres utilizada como prefijo para todos los símbolos generados por `reduce_consts' para representar subexpresiones constantes. `const_counter' (Valor por defecto: 1) es el índice entero utilizado para generar los símbolos que representen a las subexpresiones constantes encontradas por `reduce_consts'. La instrucción `load (rducon)' carga esta función y `demo (rducon)' hace una demostración sobre su uso. 68.2.6 Paquete scifac --------------------- -- Función: gcfac () Es una función de factorización que intenta aplicar la misma heurística que los humanos cuando tratan de hacer las expresiones más simples, limitándose a la factorización de monomios. En caso de sumas, `gcfac' hace lo siguiente: 1. Factoriza los enteros. 2. Factoriza las potencias mayores de los términos que aparecen como coeficientes, independientemente de su complejidad. 3. Utiliza (1) y (2) en la factorización de pares de términos adyacentes. 4. Aplica estas técnicas repetida y recursivamente hasta que la expresión deje de sufrir cambios. En general, el apartado (3) no hace una factorización óptima debido a la naturaleza combinatoria y compleja de encontrar cuál de todas las ordenaciones posibles de los pares da lugar a la expresión más compacta. La instrucción `load (scifac)' carga esta función y `demo (scifac)' hace una demostración sobre su uso. 68.2.7 Paquete sqdnst --------------------- -- Función: sqrtdenest () Reduce expresiones en las que se encuentren raíces cuadradas anidadas, siempre que sea posible Ejemplo: (%i1) load (sqdnst)$ (%i2) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12); sqrt(3) sqrt(------- + 1) 2 (%o2) --------------------- sqrt(11 sqrt(2) - 12) (%i3) sqrtdenest(%); sqrt(3) 1 ------- + - 2 2 (%o3) ------------- 1/4 3/4 3 2 - 2 A veces conviene aplicar `sqrtdenest' más de una vez, como en el caso `(19601-13860 sqrt(2))^(7/4)'. La sentencia `load (sqdnst)' carga esta función.  File: maxima.info, Node: solve_rec, Next: stats, Prev: simplification, Up: Top 69 solve_rec ************ * Menu: * Introducción a solve_rec:: * Funciones y variables para solve_rec::  File: maxima.info, Node: Introducción a solve_rec, Next: Funciones y variables para solve_rec, Prev: solve_rec, Up: solve_rec 69.1 Introducción a solve_rec ============================= El paquete `solve_rec' resuelve expresiones recurrentes lineales con coeficientes polinomiales. Ejecútese `demo(solve_rec);' para ver una demostración sobre la utilización de este paquete. Ejemplo: (%i1) load("solve_rec")$ (%i2) solve_rec((n+4)*s[n+2] + s[n+1] - (n+1)*s[n], s[n]); n %k (2 n + 3) (- 1) %k 1 2 (%o2) s = -------------------- + --------------- n (n + 1) (n + 2) (n + 1) (n + 2)  File: maxima.info, Node: Funciones y variables para solve_rec, Prev: Introducción a solve_rec, Up: solve_rec 69.2 Funciones y variables para solve_rec ========================================= -- Función: reduce_order (, , ) Reduce el orden de la expresión recurrente lineal cuando se conoce una solución particular . La recurrencia reducida puede utilizarse para obterner más soluciones. Ejemplo: (%i3) rec: x[n+2] = x[n+1] + x[n]/n; x n (%o3) x = x + -- n + 2 n + 1 n (%i4) solve_rec(rec, x[n]); WARNING: found some hypergeometrical solutions! (%o4) x = %k n n 1 (%i5) reduce_order(rec, n, x[n]); (%t5) x = n %z n n n - 1 ==== \ (%t6) %z = > %u n / %j ==== %j = 0 (%o6) (- n - 2) %u - %u n + 1 n (%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]); n %k (- 1) 1 (%o6) %u = ---------- n (n + 1)! So the general solution is n - 1 ==== n \ (- 1) %k n > -------- + %k n 2 / (n + 1)! 1 ==== n = 0 -- Variable opcional: simplify_products Valor por defecto: `true' Si `simplify_products' vale `true', `solve_rec' intentará simplificar los productos del resultado. Véase también `solve_rec'. -- Función: simplify_sum () Intenta reducir todas las sumas que aparecen en a una forma cerrada. La función `simplify_sum' utiliza los algoritmos de Gosper y Zeilberger para reducir las sumas. Para utilizar esta función cárguese previamente el paquete `simplify_sum' ejecutando la instrucción `load(simplify_sum)'. Ejemplo: (%i1) load("simplify_sum")$ (%i2) sum(binom(n+k,k)/2^k, k, 0, n) + sum(binom(2*n, 2*k), k, 0, n); n n ==== ==== \ binomial(n + k, k) \ (%o2) > ------------------ + > binomial(2 n, 2 k) / k / ==== 2 ==== k = 0 k = 0 (%i3) simplify_sum(%); n 4 n (%o3) -- + 2 2 -- Función: solve_rec (, , []) Obtiene las soluciones hipergeométricas de la expresión recurrente con coeficientes lineales en la variable . Los argumentos opcionales son condiciones iniciales. La función `solve_rec' puede resolver expresiones recurrentes con coeficientes constantes, encuentra soluciones hipergeométricas de expresiones recurrentes lineales homogéneas con coeficientes polinomiales, obtiene soluciones racionales de expresiones recurrentes lineales con coeficientes lineales y resuelve también expresiones recurrentes de Ricatti. Nótese que el tiempo de ejecución del algoritmo para encontrar soluciones hipergeométricas es exponencial respecto del grado del coeficiente principal. Para hacer uso de esta función ejecútese previamente `load(solve_rec);'. Ejemplo de recurrencia lineal con coeficientes constantes: (%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]); n n (sqrt(5) - 1) %k (- 1) 1 n (%o2) a = ------------------------- - ---- n n n 2 5 2 n (sqrt(5) + 1) %k 2 2 + ------------------ - ---- n n 2 5 2 Ejemplo de recurrencia lineal con coeficientes polinomiales: (%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2]; 2 (%o7) (x - 1) y - (x + 3 x - 2) y + 2 x (x + 1) y x + 2 x + 1 x (%i8) solve_rec(%, y[x], y[1]=1, y[3]=3); x 3 2 x! (%o9) y = ---- - -- x 4 2 Ejemplo de recurrencia de Ricatti: (%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0; y y x + 1 x (%o2) x y y - ------ + ----- = 0 x x + 1 x + 2 x - 1 (%i3) solve_rec(%, y[x], y[3]=5)$ (%i4) ratsimp(minfactorial(factcomb(%))); 3 30 x - 30 x (%o4) y = - ------------------------------------------------- x 6 5 4 3 2 5 x - 3 x - 25 x + 15 x + 20 x - 12 x - 1584 Véanse también `solve_rec_rat', `simplify_products' y `product_use_gamma'. -- Función: solve_rec_rat (, , []) Calcula las soluciones racionales de las expresiones recurrentes lineales. Véase `solve_rec' para la descripción de sus argumentos. Para hacer uso de esta función ejecútese previamente `load(solve_rec);'. Ejemplo: (%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x]; (%o1) (x + 4) a + (x + 3) a - x a x + 3 x + 2 x + 1 2 + (x - 1) a x (%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]); 1 (%o2) a = --------------- x (x - 1) (x + 1) Véase también `solve_rec'. -- Variable opcional: product_use_gamma Valor por defecto:`true' Si `product_use_gamma' vale `true', `solve_rec' introduce la función gamma en la expresión del resultado cuando se simplifican productos. Véanse también `simplify_products' y `solve_rec'. -- Función: summand_to_rec (, , ) Devuelve la expresión recurrente que satisface la suma inf ==== \ > sumando / ==== k = minf donde el sumando es hipergeométrico en y . Para hacer uso de esta función deben cargarse previamente los paquetes `zeilberger' y `solve_rec' mediante la ejecución de las sentencias `load(solve_rec)' y `load(zeilberger)'. (%i17) load("zeilberger")$ (%i18) summand: binom(3*k+1,k)*binom(3*(n-k),n-k)/(3*k+1)$ (%i19) summand_to_rec(summand, k, n); Dependent equations eliminated: (3 2) (%o19) - 4 (n + 2) (2 n + 3) (2 n + 5) sm n + 2 2 + 12 (2 n + 3) (9 n + 27 n + 22) sm n + 1 - 81 (n + 1) (3 n + 2) (3 n + 4) sm n (%i21) sum(''summand, k, 0, n), n=0; (%o21) 1 (%i22) sum(''summand, k, 0, n), n=1; (%o22) 4 (%i23) product_use_gamma: false$ (%i24) solve_rec(%o19, sm[n], sm[0]=1, sm[1]=4); n - 1 n - 1 /===\ /===\ ! ! ! ! n ( ! ! (3 %j + 2)) ( ! ! (3 %j + 4)) 3 ! ! ! ! %j = 0 %j = 0 (%o24) sm = ------------------------------------------ n n - 1 /===\ ! ! n ( ! ! (2 %j + 3)) 2 n! ! ! %j = 0  File: maxima.info, Node: stats, Next: stirling, Prev: solve_rec, Up: Top 70 stats ******** * Menu: * Introducción a stats:: * Funciones y variables para inference_result:: * Funciones y variables para stats:: * Funciones y variables para distribuciones especiales::  File: maxima.info, Node: Introducción a stats, Next: Funciones y variables para inference_result, Prev: Top, Up: Top 70.1 Introducción a stats ========================= El paquete `stats' contiene procedimientos clásicos sobre inferencia estadística y contraste de hipótesis. Todas estas funciones devuelven un objeto Maxima de tipo `inference_result', el cual contiene los resultados necesarios para hacer inferencias sobre la población y toma de decisiones. La variable global `stats_numer' controla si los resultados deben darse en formato decimal o simbólico y racional; su valor por defecto es `true', por lo que el formato de salida es decimal. El paquete `descriptive' contiene algunas utilidades para manipular estructuras de datos (listas y matrices); por ejemplo para extraer submuestras. También contiene algunos ejemplos sobre cómo utilizar el paquete `numericalio' para leer datos de ficheros en texto plano. Véanse `descriptive' y `numericalio' para más detalles. El paquete `stats' carga en memoria los paquetes `descriptive', `distrib' y `inference_result'. Para comentarios, errores o sugerencias, contáctese con el autor en <'mario ARROBA edu PUNTO xunta PUNTO es'>.  File: maxima.info, Node: Funciones y variables para inference_result, Next: Funciones y variables para stats, Prev: Introducción a stats, Up: Top 70.2 Funciones y variables para inference_result ================================================ -- Función: inference_result (, <values>, <numbers>) Construye un objeto `inference_result' del tipo devuelto por las funciones estadísticas. El argumento <title> es una cadena de Maxima con el nombre del procedimiento; <values> es una lista con elementos de la forma `symbol = value' y <numbers> es una lista con enteros positivos desde uno hasta `length(<values>)', que indican qué valores serán mostrados por defecto. Ejemplo: Este es un ejemplo que muestra los resultados asociados a un rectángulo. El título de este objeto es la cadena `"Rectangle"', el cual almacena cinco resultados, a saber, `'base', `'height', `'diagonal', `'area' y `'perimeter', pero sólo muestra el primero, segundo, quinto y cuarto. El resultado `'diagonal' también se almacena en este objeto, pero no se muestra por defecto; para tener acceso a este valor, hágase uso de la función `take_inference'. (%i1) load(inference_result)$ (%i2) b: 3$ h: 2$ (%i3) inference_result("Rectangle", ['base=b, 'height=h, 'diagonal=sqrt(b^2+h^2), 'area=b*h, 'perimeter=2*(b+h)], [1,2,5,4] ); | Rectangle | | base = 3 | (%o3) | height = 2 | | perimeter = 10 | | area = 6 (%i4) take_inference('diagonal,%); (%o4) sqrt(13) Véase también `take_inference'. -- Función: inferencep (<obj>) Devuelve `true' o `false', dependiendo de que <obj> sea un objeto de tipo `inference_result' o no. -- Función: items_inference (<obj>) Devuelve una lista con los nombres de los elementos almacenados en <obj>, el cual debe ser un objeto de tipo `inference_result'. Ejemplo: El objeto `inference_result' almacena dos valores, cuyos nombres son `'pi' y `'e', pero sólo se muestra el segundo. La función `items_inference' devuelve los nombres de todos los elementos almacenados, independientemente de que sean mostrados o no. (%i1) load(inference_result)$ (%i2) inference_result("Hi", ['pi=%pi,'e=%e],[2]); | Hi (%o2) | | e = %e (%i3) items_inference(%); (%o3) [pi, e] -- Función: take_inference (<n>, <obj>) -- Función: take_inference (<name>, <obj>) -- Función: take_inference (<list>, <obj>) Si <n> es un entero positivo, devuelve el <n>-ésimo valor almacenado en <obj>; si el símbolo <name> es el nombre de uno de los elementos almacenados, también devuelve su valor. Si el primer elemento es una lista de números y/o símbolos, la función `take_inference' devuelve una lista con los resultados correspondientes. Ejemplo: Dado un objeto `inference_result', la función `take_inference' es invocada para extraer cierta información almacenada en él. (%i1) load(inference_result)$ (%i2) b: 3$ h: 2$ (%i3) sol: inference_result("Rectangle", ['base=b, 'height=h, 'diagonal=sqrt(b^2+h^2), 'area=b*h, 'perimeter=2*(b+h)], [1,2,5,4] ); | Rectangle | | base = 3 | (%o3) | height = 2 | | perimeter = 10 | | area = 6 (%i4) take_inference('base,sol); (%o4) 3 (%i5) take_inference(5,sol); (%o5) 10 (%i6) take_inference([1,'diagonal],sol); (%o6) [3, sqrt(13)] (%i7) take_inference(items_inference(sol),sol); (%o7) [3, 2, sqrt(13), 6, 10] Véanse también `inference_result' y `take_inference'.  Local Variables: coding: iso-8859-1 End: