MUI_IIMA_1314_Tutorial_Graficos

1512 days ago by trinidad

Gráficos en Sage


1. Representación de funciones de una variable.

Para representar funciones de una variable utilizamos la la función plot. El primer argumento será la función a representar y el segundo una tupla (x,xmin,xmax), donde x es la variable independiente, xmin el mínimo valor de dicha variable y xmax el máximo.

plot(cos(x),(x,0,2*pi)) 
       

Podemos guardar el gráfico en un fichero pdf (también es posible guardarlo como imagen con formato png pinchando en el gráfico y seleccionando "guardar como..."

plot(cos(x),(x,0,2*pi)).save("dibujo.pdf") 
       

Para ver todas las opciones, podemos usar la ayuda.

help(plot) 
       

Se puede modificar el grosor de la gráfica, el trazo, el número de puntos a representar, los marcadores de los puntos usados, etc.

plot(cos(x),(x,0,2*pi),thickness=3,linestyle="--") 
       

También añadir una leyenda o etiquetas a los ejes. En las etiquetas escribimos u delante del texto para indicar que es unicode (con acentos). También podemos usar Latex.

plot(cos(x),(x,0,2*pi),linestyle="", marker="p",plot_points=50,legend_label=u'Pentágonos',axes_labels=['$x$','$y=\sin(x)$']) 
       

Tambié se puede modificar el color, usando una terna RGB, de números entre 0 y 1, o una cadena de caracteres, por ejemplo 'red' o en HTML '#9acd32'

plot(cos(x),(x,0,2*pi),rgbcolor=(1,0.5,0)) 
       

También podemos limitar el área de nuestra gráfica, dando los valores mínimo  y máximos del eje Y

plot(1/x,(x,-4,4), ymin=-5,ymax=5, color='#600bff') 
       

Se puede rellenar el espacio entre la gráfica y el eje X:

plot(sin(x^3),-3,3, fill='axis') 
       

También es posible representar dos o más funciones simultáneamente:

Vamos a dibujar la función $e^x$ junto con su desarrollo de Taylor de grado 4 en $x=0$

f(x)=taylor(e^x, x, 0, 3) print f(x) plot(e^x,(x,-3,3), color='red')+plot(taylor(f(x),x,0,4),x,-3,3) 
       

Las funciones seno y coseno:

plot(cos(x),(x,0,2*pi))+plot(sin(x),(x,0,2*pi),rgbcolor=(1,0,0)) 
       

Y rellenar el espacio entre las gráficas:

plot(cos(x),(x,0,2*pi))+plot(sin(x),(x,0,2*pi),fill=cos(x),fillcolor='green') #gráfica del área definida por dos funciones 
       

Por otra parte, podemos dibujar varias gráficas en una tabla. Cada una de ellas puede ser a su vez una suma de gráficas, etc.

f(x,n)=sin(n*x) G = [plot(f(n,x)) for n in xrange(1,5*pi,pi)] # una lista de cuatro gráficas graphics_array(G,2,2).show() # las dibujamos en una tabla 2x2 
       

Juntando todo lo anterior:

p1 = plot(sin(x), -pi, pi, fill = 'axis') p2 = plot(sin(x), -pi, pi, fill = 'min') p3 = plot(sin(x), -pi, pi, fill = 'max') p4 = plot(sin(x), -pi, pi, fill = 0.5) graphics_array([[p1, p2], [p3, p4]]).show(frame=True, axes=False) 
       

Un ejemplo más complicado en el que vamos aproximando $1/(1-x)$ por su serie de Taylor, coloreando el espacio entre cada dos gráficas:

f(n,x)=x^n Grafica=plot([1+sum([f(c,x) for c in [1..k]]) for k in [1..7]], (x,0,1), fill = dict([(i, [i+1]) for i in [0..5]])) Grafica+plot(1/(1-x),(x,0,1),ymax=4) 
       

Texto

Podemos añadir texto a cualquier gráfico. Para ello tenemos la función text que dibuja el texto en la posición que queramos.

text(u"Máximo",(pi/2,1.05))+plot(sin(x),(x,0,pi)) 
       

Podemos cambiar el tamaño, color, etc

text(u"Máximo",(pi/2,1.05),fontsize=20,color="black")+plot(sin(x),(x,0,pi)) 
       

Ejercicios:

1. Dibuja la gráfica de la función $\sin x$ para valores de $x$ entre $0$ y $10\pi$.

2. Añade una leyenda que indique que es la función seno. También marca los ejes como $x$ e $y$.

3. Dibuja en una gráfica la función $\sin x$ y $2-\sin x$ para valores de $x$ entre $0$ y $10\pi$. Dibújalas con distintos colores y tipo de trazo. En la segunda función añade una leyenda que indique que es la función $2-\sin x$.

4. Dibuja en una gráfica las funciones $\sin x$, $2-\sin x$, $4+\sin x$, $6-\sin x$. Colorea el espacio entre las dos primeras y entre las dos últimas. Dibújalas sin mostrar los ejes.

5. Dibuja una tabla de gráficas en una cuadrícula de 3x3 con las funciones $f(x)=x^i(1-x)^j$, para $x$ entre 0 y 1 y $0\leq i,j\leq 2$. Rellena el área definida por cada una de esas funciones con el eje horizontal. Añade en cada una de ellas un texto que ponga "área".

 
       

2. Representación de datos

Vamos a ver cómo representar datos con Sage.

Puntos

Si tenemos una tabla de puntos (x,y), podemos representarlos con el comando points.

Supongamos que partimos de un vector de datos.

datos = [ sin(x) for x in range(10)]; puntos 
       
list_plot(datos) 
       

Podemos ver algunas opciones utilizando la ayuda.

help(list_plot) 
       

Podemos cambiar las opciones de dibujado. Por ejemplo, unir los puntos, cambiar el color, etc

list_plot(datos, plotjoined=True, color='purple') 
       

Supongamos que nos dan puntos de un plano.

datosx=[random() for k in range(10)] datosy=[random() for k in range(10)] puntos=zip(datosx,datosy);puntos 
       

Y los representamos mediante la función points.

points(puntos) 
       

Podemos ver todas las opciones usando options.

point2d.options 
       

Por ejemplo, podemos elegir el color, el tamaño, ...

G=points(puntos,color='red',faceted=True, pointsize=40,legend_label="Puntos");G 
       

Podemos modificar el gráfico creado. Vamos a ver por ejemplo, cómo cambiar la posición de la etiqueta.

G.set_legend_options(loc=2); G 
       

Podemos ajustar dichos puntos por ejemplo mediante splines:

interpolation = spline(puntos) G+plot(interpolation, min(datosx),max(datosx), legend_label="Spline") 
       

Gráficos estadísticos

Aunque Sage no es el mejor programa para pintar datos estadísticos, sí que posee librerías para dibujarlos si queremos hacer un gráfico sencillo mientras usamos Sage.

Para dibujar gráficos de barra, utilizamos bar_chart que recibe un vector de datos y los dibuja como gráfico de barras.

bar_chart([1,2,3,4]) 
       

Podemos ajustar el ancho de las barras.

bar_chart([x^2 for x in range(1,20)], width=0.2) 
       

Podemos ajustar el color, los ejes, etc.

bar_chart([2,8,7,3], rgbcolor=(1,0,0), axes=False) 
       

Si queremos más (muchísimos más) gráficos estadísticos y más control en cómo dibujarlos podemos usar la librería pyplot.

import matplotlib.pyplot as plt fig = plt.figure() patterns = [ "/" , "\\" , "|" , "-" , "+" , "x", "o", "O", ".", "*" ] ax1 = fig.add_subplot(111) for i in range(len(patterns)): ax1.bar(i, cos(i), color=(random(),random(),random()), edgecolor='black', hatch=patterns[i]) plt.savefig('') 
       

También podemos dibujar, por ejemplo, gráficos circulares.

# Limpiamos el dibujo import matplotlib.pyplot as plt plt.close() # Hacemos que sea cuadrado plt.figure(1, figsize=(6,6)) ax = plt.axes([0.1, 0.1, 0.8, 0.8]) # Introducimos etiqutas y datos. También destacamos (explode) la segunda porción labels = 'Ranas', 'Lechones', 'Perros', 'Troncos' fracs = [15, 30, 45, 10] explode=(0, 0.05, 0, 0) plt.pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True) plt.title('Perros y lechones', bbox={'facecolor':'0.8', 'pad':5}) plt.savefig('') 
       

Podemos exportar estas figuras en diversos formatos. Por ejemplo, en postscript para después editarlas con nuestro programa favorito.

plt.savefig('perrosylechones.eps') 
       

Ejercicios.

Un biólogo realiza 10 capturas de buitres (adultos y crias) y mide el peso de cada pájaro y la longitud del pico.

peso                     =[5.3, 3.1, 4.3, 7.4, 4.7, 6.1, 1.5, 8.2, 3.1, 9.2]

longitud del pico =[7.4, 2.1, 4.5, 8.3, 4.1, 5.1, 2.1, 7.1, 2.1, 8.1]

1. Representar en una gráfica el peso de cada pájaro.

2. Representar en una gráfica el peso de cada pájaro con puntos de un color y la longitud del pico con otro.

3. Representar en una gráfica el peso en el eje horizontal y la longitud del pico en la vertical. Incluir una leyenda.

4. Representar en un diagrama de barras, sin ejes, en color verde, los distintos pesos.

 
       

3. Representación de curvas en el plano.

Vamos a ver distintos métodos para representar curvas en el plano. Básicamente, una curva plana puede estar en paramétricas (es decir, escrita en la forma x=f(t), y=g(t), donde f,g son funciones de una variable) o en implícitas (escrita como una ecuación F(x,y)=0).

Representación de curvas paramétricas

Es posible representar una curva en paramétricas en dimensión 2. La instrucción es parametric_plot((f(t), g(t)), (t, a, b)) donde [a,b] es el intervalo que recorre el parámetro

¡Atención! Si se usa otra variable distinta de x, hay que definirla como tal en la hoja de trabajo.

var('t') parametric_plot((3*cos(t),sin(t)),(t,0, 2*pi)) 
       

Existen opciones para ocultar los ejes, enmarcar la gráfica, etc.:

parametric_plot((3*cos(t),sin(t)),(t,0, 2*pi)).show(aspect_ratio=2, frame=true, axes=false) 
       

También podemos usar polygon para dibujar una curva paramétrica rellena. Para ello deberemos pasar una lista con pares de elementos, que serán las coordenadas de los puntos a dibujar.

L = [[6*cos(pi*t)+5*cos((6/2)*pi*t),6*sin(pi*t)-5*sin((6/2)*pi*t)] for t in [0,0.02..2]] polygon2d(L, rgbcolor=(1/8,1/4,1/2)) 
       

Representación de curvas implícitas

Es posible representar una curva definida de forma implícita por $x^2+y^2=1$ en dimensión 2:

var('x,y') implicit_plot(x^2+y^2-1,(x,-1,1),(y,-1,1)) 
       

Podemos salvar nuestro dibujo también con la extensión .eps:

implicit_plot(x^2+y^2==1,(x,-2,2),(y,-2,2)).save("dibujo2.eps") 
       

Curvas de nivel

Un modo de representar funciones de dos variables, $f(x,y)$ es mostrar las curvas de nivel, es decir, las curvas implícitas definidas por $f(x,y)=z$, para ciertos valores de $z$.

En Sage, podemos representar curvas de nivel utilizando contour_plot.

var('x,y') contour_plot(y^2 + 1 - x^3 - x, (x,-1,1), (y,-1,1)) 
       

Podemos no rellenar el espacio sino sólo dibujar las curvas de nivel utilizando fill. También podemos cambiar el mapa de color  usando cmap y mostrar las altura con labels.

var('x,y') contour_plot(y^2 + 1 - x^3 - x, (x,-pi,pi), (y,-pi,pi), fill=False, cmap='hsv', labels=True) 
       

Vamos a cambiar un poco el aspecto de las etiquetas, su color y también el número de cifras decimales que se muestran.

P=contour_plot(y^2 + 1 - x^3 - x, (x,-pi,pi), (y,-pi,pi), fill=False, cmap='hsv',labels=True, label_fmt="%1.0f", label_colors='black');P 
       

También podemos mostrar una leyenda.

contour_plot(x^2+y^2, (x,-3,3), (y,-3,3),colorbar=True,colorbar_spacing='uniform') 
       

Y elegir mostrar sólo algunos niveles.

contour_plot(x^2+y^2, (x,-3,3), (y,-3,3), contours=[0,2,3,5,6,9,11],colorbar=True,colorbar_format='%.3f',cmap='jet') 
       

Interacción y animaciones

Podemos interactuar con las curvas, por ejemplo visualizando la variación del parámetro

var('t') r=(2*cos(t), sin(t)) tbounds=(0, 2*pi) tmin,tmax=tbounds @interact def myplot(tt=slider(tmin.n(), tmax.n(),default=((tmin+tmax)/2).n())): p=parametric_plot(r, (t, tmin, tmax),alpha=0.5) background=parametric_plot(r, (t, tmin, tt),thickness=3) show(p+background) 
       

Click to the left again to hide and once more to show the dynamic interactive window

También existe la opción de gráficos animados

a = animate([sin(x + float(k)) for k in srange(0,4*pi,0.3)],xmin=0, xmax=4*pi, figsize=[4,2]) a.show() 
       

Ejercicios.

1.Representa la curva paramétrica $(\cos(\pi t)+t,\sin(\pi t)+t)$, para $t$ entre $0$ y $8$.

2. Representa la curva paramétrica $(-\cos(\pi t)+\cos(10\pit),\sin(\pi t)+\sin(10\pit)$, para $t$ entre $0$ y $2$, sin mostrar los ejes.

3. Dibuja la curva anterior rellena.

4. Dibuja la curva implícita $x^4+y^4-y^2=1$.

5. Dibuja las curvas de nivel de la función $sin(x^2)+cos(x^2)$. Muestra sólo las líneas anotadas con la altura.

 
       

3. Gráficas en dimensión 3

Curvas paramétricas

Se puede representar una curva en paramétricas en dimensión 3:

var('t'); parametric_plot((t*cos(t),t*sin(t),t),(t,0, 4*pi)) 
       

Funciones

Para representar una función de dos variables:

var('y') plot3d(4*x*exp(-x^2-y^2),(x,-2,2),(y,-2,2)) 
       

Superficies implícitas

Para representar una superficie definida de forma implícita en dimensión 3. Por ejemplo, la superficie $x^2+y^2=1$.

var('x,y,z'); implicit_plot3d(x^2+y^2-1,(x,-2,2),(y,-2,2),(z,-2,2)) 
       

Para mostrar dos superficies simultáneamente:

implicit_plot3d(x^2+y^2==1,(x,-2,2),(y,-2,2),(z,-2,2))+implicit_plot3d(x^2+y^2+z^2==2,(x,-2,2),(y,-2,2),(z,-2,2)) 
       

Superficies paramétricas

Para representar superficies en forma paramétrica:

var("u,v") parametric_plot3d([cos(u)*v, sin(u)*v, 3/2-3*v/2], (u, 0, 2*pi), (v, 0, 1.5)) 
       

Para representar dos superficies, una dentro de otra, de modo que se vean ambas, podemos usar la opción "opacity":

var("u,v") p1 = parametric_plot3d([cos(u)*v, sin(u)*v, 3/2-3*v/2], (u, 0, 2*pi), (v, 0, 1.5), opacity = 0.5, plot_points=[20,20]) p2 = parametric_plot3d([cos(u)/2, sin(u)/2, v-3/4], (u, 0, 2*pi), (v, 0, 3/2), plot_points=[20,20]) p1+p2 
       

Gŕaficos 3D con pyplot

Como en los apartados anteriores, podemos importar las librerías de pyton para tener más control.

from mpl_toolkits.mplot3d import axes3d import matplotlib.pyplot as plt from matplotlib import cm fig = plt.figure() ax = fig.gca(projection='3d') X, Y, Z = axes3d.get_test_data(0.05) ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3) cset = ax.contour(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm) cset = ax.contour(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm) cset = ax.contour(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm) ax.set_xlabel('X') ax.set_xlim(-40, 40) ax.set_ylabel('Y') ax.set_ylim(-40, 40) ax.set_zlabel('Z') ax.set_zlim(-100, 100) plt.savefig("") 
       

Ejercicios.

1. Representa la curva paramétrica $(\sin(\pi t),\sin(7\pi t),\sin(9\pi t))$, para $t$ entre $0$ y $2$.

2. Representa la función $f(x,y)=\sin(x y)$, para $x,y$ entre $-3$ y $3$.

3. Representa la superficie implícita $(x^2+2y^2+3z^2-1)((3x^2+2y^2+z^2-1/2)==0$. Haz que sea algo transparente para ver el interior.

4. Representa la superficie paramétrica $(u\cos v,u\sin v,v)$, para $u$ entre 0 y 1 y $v$ entre 0 y $4\pi$.

5. Representa la superficie paramétrica $((3+\sin(v)+\cos(u))cos(2v), (3+\sin(v)+\cos(u))\sin(2v),\sin(u)+2\cos(v)$ para $u,v$ entre 0 y $2\pi$

 
       

4. Imágenes

Veamos de modo básico cómo manejar imágenes. Una imagen no es más que una matriz con un color en cada posición. Si el color consiste en un único valor numérico, podemos representarlo con matrix_plot.

n=7; A=matrix(RDF,n) A[1,1:6]=Matrix([1,1,1,1,1]) A[3,1:6]=Matrix([1,1/2,1/3,1/4,1/5]) A[5,1:6]=Matrix([1,1,1,1,1]) matrix_plot(A) 
       

Podemos crear una imagen más grande y aleatoria.

n=100; A=[[random() for i in [1..n]] for j in [1..n]] matrix_plot(A) 
       

Si en lugar de 1 número en cada posición de la matriz, tenemos una lista con 3 números, lo interpreta como un color rgb.

n=100; A=[[[random(),0,0] for i in [1..n]] for j in [1..n]] matrix_plot(A) 
       

Vamos a hacer un degradado por los tonos del rgb.

n=100; A=[[[i/n,j/n,1-(i+j)/(2*n)] for i in [1..n]] for j in [1..n]] matrix_plot(A) 
       

En la librería pyplot tenemos muchas más utilizades para analizar imágenes.

from scipy import ndimage as nd import matplotlib.pyplot as plt image=nd.imread(DATA+'logo.png') plt.imshow(image) plt.savefig('') 
       

 

Ejercicios

1. Crea una matriz con todos los colores posibles usando sólo ceros y unos.

2. Si tenemos un punto con colores RGB (r,g,b), el formato YUV se define como la terna:

Y = 0.299r+0.587g+0.114b
U = 0.492(b-Y)
V = 0.877(r-Y)

Y es la intensidad de color y $U,V$ recogen el tono. Despeja en la fórmula anterior $r,g,b$. Crea una matriz fijando $Y=1/2$ y variando $U,V$ entre 0 y 1 (con 100 filas y 100 columnas) y que en cada posición tenga el color $(r,g,b)$ correspondiente.