Introducción a draw
===================

draw es un interfaz para comunicar Maxima con Gnuplot.

Tres son las funciones principales a utilizar a nivel de Maxima: draw2d, draw3d y draw.

Sígase este enlace para ver ejemplos más elaborados de este paquete:

http://www.telefonica.net/web2/biomates/maxima/gpdraw

Se necesita tener instalado Gnuplot 4.2 para ejecutar este paquete.

Funciones y variables para draw
===============================

 -- Opción gráfica: xrange
     Valor por defecto: false

     Cuando xrange vale false, el rango de la coordenada X se calcula de forma automática.

     Si el usuario quiere especificar un intervalo para X, é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 Y se calcula de forma automática.

     Si el usuario quiere especificar un intervalo para Y, é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 Z se calcula de forma automática.

     Si el usuario quiere especificar un intervalo para Z, é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 X 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 Y 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 Z 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 XY.

     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 X. 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 Y. 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 Z. 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 X.

     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 Y.

     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 Z.

     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 X) 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 Z) 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 X, Y y Z 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 X, 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 (OPCIÓN GRÁFICA, ..., GRAPHIC_OBJECT, ...)

     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 (OPCIÓN GRÁFICA, ..., GRAPHIC_OBJECT, ...)

     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 ([[X1,Y1], [X2,Y2],...])
 -- Objeto gráfico: points ([X1,X2,...], [Y1,Y2,...])
 -- Objeto gráfico: points ([Y1,Y2,...])
 -- Objeto gráfico: points ([[X1,Y1,Z1], [X2,Y2,Z2],...])
 -- Objeto gráfico: points ([X1,X2,...], [Y1,Y2,...], [Z1,Z2,...])
     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 ([[X1,Y1], [X2,Y2],...]) o points ([X1,X2,...], [Y1,Y2,...]) dibuja los puntos [X1,Y1], [X2,Y2], etc. Si no se dan las abscisas, éstas se asignan automáticamente a enteros positivos consecutivos, de forma que points([Y1,Y2,...]) dibuja los puntos [1,Y1], [2,Y2], 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 ([[X1,Y1,Z1], [X2,Y2,Z2],...]) o points ([X1,X2,...], [Y1,Y2,...], [Z1,Z2,...]) dibuja los puntos [X1,Y1,Z1], [X2,Y2,Z2], 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 ([[X1,Y1], [X2,Y2],...])
 -- Objeto gráfico: polygon ([X1,X2,...], [Y1,Y2,...])
     Dibuja polígonos en 2D.

     2D

     polygon ([[X1,Y1], [X2,Y2],...]) o polygon ([X1,X2,...], [Y1,Y2,...]): dibuja en el plano un polígono de vértices [X1,Y1], [X2,Y2], 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 ([X1,Y1], [X2,Y2])
     Dibuja rectángulos en 2D.

     2D

     rectangle ([X1,Y1], [X2,Y2]) dibuja un rectángulo de vértices opuestos [X1,Y1] y [X2,Y2].

     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 (XC, YC, A, B, ANG1, ANG2)
     Dibuja elipses y círculos en 2D.

     2D

     ellipse (XC, YC, A, B, ANG1, ANG2) dibuja una elipse de centro [XC, YC] con semiejes horizontal y vertical A y B, respectivamente, desde el ángulo ANG1 hasta el ángulo ANG2.

     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 ([STRING,X,Y],...)
 -- Objeto gráfico: label ([STRING,X,Y,Z],...)
     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([STRING,X,Y]) escribe la cadena de caracteres STRING en el punto [X,Y].

     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([STRING,X,Y,Z]) escribe la cadena de caracteres STRING en el punto [X,Y,Z].

     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 ([X,Y], [DX,DY])
 -- Objeto gráfico: vector ([X,Y,Z], [DX,DY,DZ])
     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 ([X,Y], [DX,DY]) dibuja el vector [DX,DY] con origen en [X,Y].

     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([X,Y,Z], [DX,DY,DZ]) dibuja el vector [DX,DY,DZ] con origen en [X,Y,Z].

     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 (FCN,VAR,MINVAL,MAXVAL)
 -- Objeto gráfico: explicit (FCN,VAR1,MINVAL1,MAXVAL1,VAR2,MINVAL2,MAXVAL2)
     Dibuja funciones explícitas en 2D y 3D.

     2D

     explicit (FCN,VAR,MINVAL,MAXVAL) dibuja la función explícita FCN, con la variable VAR tomando valores desde MINVAL hasta MAXVAL.

     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 (FCN,VAR1,MINVAL1,MAXVAL1,VAR2,MINVAL2,MAXVAL2) dibuja la función explícita FCN, con la variable var1 tomando valores desde MINVAL1 hasta MAXVAL1 y la variable VAR2 tomando valores desde MINVAL2 hasta MAXVAL2.

     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 (FCN,XVAR,XMINVAL,XMAXVAL,YVAR,YMINVAL,YMAXVAL)
     Dibuja funciones implícitas en 2D.

     2D

     implicit (FCN,XVAR,XMINVAL,XMAXVAL,YVAR,YMINVAL,YMAXVAL) dibuja la función implícita FCN, con la variable xvar tomando valores desde XMINVAL hasta XMAXVAL, y la variable YVAR tomando valores desde YMINVAL hasta YMAXVAL.

     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 (RADIUS,ANG,MINANG,MAXANG)
     dibuja funciones 2D definidas en coordenadas polares.

     2D

     polar (RADIUS,ANG,MINANG,MAXANG) dibuja la función RADIUS(ANG) definida en coordenadas polares, con la variable ANG tomando valores desde MINANG hasta MAXANG.

     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 (XFUN,YFUN,PAR,PARMIN,PARMAX)
 -- Objeto gráfico: parametric (XFUN,YFUN,ZFUN,PAR,PARMIN,PARMAX)
     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 (XFUN,YFUN,PAR,PARMIN,PARMAX) dibuja la función paramétrica [XFUN,YFUN], con el parámetro PAR tomando valores desde PARMIN hasta PARMAX.

     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 (XFUN,YFUN,ZFUN,PAR,PARMIN,PARMAX) dibuja la curva paramétrica [XFUN,YFUN,ZFUN], con el parámetro PAR tomando valores desde PARMIN hasta PARMAX.

     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 (IM,X0,Y0,WIDTH,HEIGHT)
     Reproduce una imagen en 2D.

     2D

     image (IM,X0,Y0,WIDTH,HEIGHT): dibuja la imagen IM en la región rectangular desde el vértice (X0,Y0) hasta el (x0+WIDTH,y0+HEIGHT) del plano real. El argumento IM debe ser una matriz de números reales, una matriz de vectores de longitud tres o un objeto de tipo picture.

     Si IM 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 IM es una matriz de vectores de longitud tres, éstos se interpretarán como las componentes cromáticas rojo, verde y azul.

     Ejemplos:

     Si IM 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 IM 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 (N1,N2,...)
     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 (N1,N2,...) 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 (XFUN,YFUN,ZFUN,PAR1,PAR1MIN,PAR1MAX,PAR2,PAR2MIN,PAR2MAX)
     Dibuja superficies paramétricas en 3D.

     3D

     parametric_surface (XFUN,YFUN,ZFUN,PAR1,PAR1MIN,PAR1MAX,PAR2,PAR2MIN,PAR2MAX) dibuja la superficie paramétrica [XFUN,YFUN,ZFUN], con el parámetro PAR1 tomando valores desde PAR1MIN hasta PAR1MAX y el parámetro PAR2 tomando valores desde PAR2MIN hasta PAR2MAX.

     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 (GR2D, ..., GR3D, ..., OPTIONS, ...)

     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 (OPTION, GRAPHIC_OBJECT, ...)

     Esta función es un atajo para draw2d(gr2d(OPTIONS, ..., GRAPHIC_OBJECT, ...)).

     Puede utilizarse para representar una única escena en 2d.

     Para utilizar esta función, ejecútese primero load(draw).

 -- Función: draw3d (OPTION, GRAPHIC_OBJECT, ...)

     Esta función es un atajo para draw3d(gr3d(OPTIONS, ..., GRAPHIC_OBJECT, ...)).

     Puede utilizarse para representar una única escena en 3d.

     Para utilizar esta función, ejecútese primero load(draw).

Funciones y variables para picture
==================================

 -- Función: make_level_picture (DATA)
 -- Función: make_level_picture (DATA,WIDTH,HEIGHT)
     Devuelve un objeto picture consistente en una imagen de niveles. make_level_picture (DATA) construye el objeto picture a partir de la matriz DATA. make_level_picture (DATA,WIDTH,HEIGHT) construye el objeto a partir de una lista de números, en cuyo caso deben indicarse el ancho WIDTH y la altura HEIGHT en píxeles.

     El objeto  picture devuelto contiene los siguientes cuatro elemento:

      1. el símbolo level

      2. anchura de la imagen

      3. altura de la imagen

      4. un array de enteros con los valores de los píxeles entre 0 y 255. El argumento DATA debe contener sólo números entre 0 y 255; los cantidades negativas se transforman en ceros y las que son mayores de 255 se igualan a este número.

     Ejemplo:

     Imagen de niveles a partir de una matriz.

          (%i1) load(draw)$
          (%i2) make_level_picture(matrix([3,2,5],[7,-9,3000]));
          (%o2)         picture(level, 3, 2, {Array:  #(3 2 5 7 0 255)})

     Imagen de niveles a partir de una lista numérica.

          (%i1) load(draw)$
          (%i2) make_level_picture([-2,0,54,%pi],2,2);
          (%o2)            picture(level, 2, 2, {Array:  #(0 0 54 3)})

 -- Función: picturep (X)
     Devuelve true si el argumento es una imagen bien formada, o false en caso contrario.

 -- Función: picture_equalp (X,Y)
     Devuelve true si los dos argumentos son imágenes idénticas, o false en caso contrario.

 -- Función: make_rgb_picture (REDLEVEL,GREENLEVEL,BLUELEVEL)
     Devuelve un objeto picture conteniendo una imagen en color (RGB). Los tres argumentos deben ser imágenes de niveles, para el rojo (R), verde (G) y azul (B).

     El objeto  picture devuelto contiene los siguientes cuatro elemento:

      1. el símbolo rgb

      2. anchura de la imagen

      3. altura de la imagen

      4. un array de enteros de 3*ancho*alto con los valores de los píxeles entre 0 y 255. Cada valor de pixel se representa en el array con tres números consecutivos (rojo, verde, azul).

     Ejemplo:

          (%i1) load(draw)$
          (%i2) red: make_level_picture(matrix([3,2],[7,260]));
          (%o2)           picture(level, 2, 2, {Array:  #(3 2 7 255)})
          (%i3) green: make_level_picture(matrix([54,23],[73,-9]));
          (%o3)           picture(level, 2, 2, {Array:  #(54 23 73 0)})
          (%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
          (%o4)          picture(level, 2, 2, {Array:  #(123 82 45 33)})
          (%i5) make_rgb_picture(red,green,blue);
          (%o5) picture(rgb, 2, 2,
                        {Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)})

 -- Función: take_channel (IM,COLOR)
     Si el argumento COLOR es RED, GREEN o BLUE, la función take_channel devuelve el canal de color correspondiente de la imagen IM.

     Ejemplo:

          (%i1) load(draw)$
          (%i2) red: make_level_picture(matrix([3,2],[7,260]));
          (%o2)           picture(level, 2, 2, {Array:  #(3 2 7 255)})
          (%i3) green: make_level_picture(matrix([54,23],[73,-9]));
          (%o3)           picture(level, 2, 2, {Array:  #(54 23 73 0)})
          (%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
          (%o4)          picture(level, 2, 2, {Array:  #(123 82 45 33)})
          (%i5) make_rgb_picture(red,green,blue);
          (%o5) picture(rgb, 2, 2,
                        {Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)})
          (%i6) take_channel(%,'green);  /* simple quote!!! */
          (%o6)           picture(level, 2, 2, {Array:  #(54 23 73 0)})

 -- Función: negative_picture (PIC)
     Devuelve el negativo de la imagen, sea ésta de tipo nivel (level) o color (rgb).

 -- Función: rgb2level (PIC)
     Transforma una imagen en color rgb a otra de niveles level promediando los niveles.

 -- Función: get_pixel (PIC,X,Y)
     Devuelve el pixel de la imagen PIC. Las coordenadas X e Y van desde 0 hasta ancho-1 y alto-1, respectivamente.

 -- Función: read_xpm (XPM_FILE)
     Lee el fichero gráfico en formato xpm y devuelve un objeto picture.

Funciones y variables para worldmap
===================================

 -- Función: region_boundaries (X1,Y1,X2,Y2)
     Detecta los segmentos poligonales almacenados en la variable global boundaries_array contenidos en el rectángulo de vértices (X1,Y1) -superior izquierdo- y (X2,Y2) -inferior derecho-.

     Ejemplo:

     Devuelve los números de los segmentos necesarios para dibujar el sur de Italia.

          (%i1) load(draw)$
          (%i2) load(worldmap)$
          (%i3) region_boundaries(10.4,41.5,20.7,35.4);
          (%o3)                [1846, 1863, 1864, 1881, 1888, 1894]
          (%i4) draw2d(geomap(%))$

 -- Función: numbered_boundaries (NLIST)
     Dibuja una lista de segmentos poligonales (líneas fronterizas), etiquetadas con sus números correspondientes (coordenadas de boundaries_array). Esta función es de mucha ayuda a la hora de definir nuevas entidades geográficas.

     Ejemplo:

     Mapa de Europa con las fronteras y costas etiquetadas con su componente numérica de boundaries_array.

          (%i1) load(draw)$
          (%i2) load(worldmap)$
          (%i3) european_borders:
                   region_boundaries(-31.81,74.92,49.84,32.06)$
          (%i4) numbered_boundaries(european_borders)$

 -- Función: make_polygon (NLIST)
     Devuelve un objeto polygon a partie de una lista de líneas fronterizas y de costas. El argumento NLIST debe ser una lista de componentes de boundaries_array.

     Ejemplo:

     La variable Bhutan (Bután) está definida con los números fronterizos 171, 173 y 1143, de manera que make_polygon([171,173,1143]) concatena los arrays boundaries_array[171], boundaries_array[173] y boundaries_array[1143] y devuelve un objeto polygon apto para ser dibujado por draw. A fin de evitar mensajes de errores, los arrays deben ser compatibles en el sentido de que dos de ellos consecutivos deben tener dos coordenadas comunes en los extremos. En este ejemplo, las dos primeras componentes de boundaries_array[171] son iguales a las dos últimas de boundaries_array[173], y las dos primeras de boundaries_array[173] coinciden con las dos primeras de boundaries_array[1143]; en conclusión, los números de segmentos poligonales171, 173 y 1143 (en este orden) son compatibles y el polígono coloreado se podrá dibujar.

          (%i1) load(draw)$
          (%i2) load(worldmap)$
          (%i3) Bhutan;
          (%o3)                        [[171, 173, 1143]]
          (%i4) boundaries_array[171];
          (%o4) {Array:
                 #(88.750549 27.14727 88.806351 27.25305 88.901367 27.282221
                   88.917877 27.321039)}
          (%i5) boundaries_array[173];
          (%o5) {Array:
                 #(91.659554 27.76511 91.6008 27.66666 91.598022 27.62499
                   91.631348 27.536381 91.765533 27.45694 91.775253 27.4161
                   92.007751 27.471939 92.11441 27.28583 92.015259 27.168051
                   92.015533 27.08083 92.083313 27.02277 92.112183 26.920271
                   92.069977 26.86194 91.997192 26.85194 91.915253 26.893881
                   91.916924 26.85416 91.8358 26.863331 91.712479 26.799999
                   91.542191 26.80444 91.492188 26.87472 91.418854 26.873329
                   91.371353 26.800831 91.307457 26.778049 90.682457 26.77417
                   90.392197 26.903601 90.344131 26.894159 90.143044 26.75333
                   89.98996 26.73583 89.841919 26.70138 89.618301 26.72694
                   89.636093 26.771111 89.360786 26.859989 89.22081 26.81472
                   89.110237 26.829161 88.921631 26.98777 88.873016 26.95499
                   88.867737 27.080549 88.843307 27.108601 88.750549
                   27.14727)}
          (%i6) boundaries_array[1143];
          (%o6) {Array:
                 #(91.659554 27.76511 91.666924 27.88888 91.65831 27.94805
                   91.338028 28.05249 91.314972 28.096661 91.108856 27.971109
                   91.015808 27.97777 90.896927 28.05055 90.382462 28.07972
                   90.396088 28.23555 90.366074 28.257771 89.996353 28.32333
                   89.83165 28.24888 89.58609 28.139999 89.35997 27.87166
                   89.225517 27.795 89.125793 27.56749 88.971077 27.47361
                   88.917877 27.321039)}
          (%i7) Bhutan_polygon: make_polygon([171,173,1143])$
          (%i8) draw2d(Bhutan_polygon)$

 -- Función: make_poly_country (COUNTRY_NAME)
     Construye los polígonos necesarios para dibujar un país coloreado. En caso de contener islas, un país tendrá asociados varios polígonos.

     Ejemplo:

          (%i1) load(draw)$
          (%i2) load(worldmap)$
          (%i3) make_poly_country(India)$
          (%i4) apply(draw2d, %)$

 -- Función: make_poly_continent (CONTINENT_NAME)
 -- Función: make_poly_continent (COUNTRY_LIST)
     Construye los polígonos necesarios para dibujar un continente o lista de países coloreados.

     Ejemplo:

          (%i1) load(draw)$
          (%i2) load(worldmap)$
          (%i3) /* A continent */
                make_poly_continent(Africa)$
          (%i4) apply(draw2d, %)$
          (%i5) /* A list of countries */
                make_poly_continent([Germany,Denmark,Poland])$
          (%i6) apply(draw2d, %)$