JSP2014-Tutorial

1215 days ago by jlbravo

Introducción a Sage

Usando la interfaz

Para introducir la operación que se desea evaluar, hay que mover el cursor hasta que aparezca una línea azul. Pulsando el botón izquierdo nos aparecerá un cuadro (celda) como el siguiente:

 
       

Dentro de las celdas se escribe la operación que se desea evaluar y se pulsa el enlace evaluate o <shift>+<Intro>. (Para evaluar una celda tienes que estar dentro de ella, si no no verás el botón de evaluar).

1+1 
       

Si lo que queremos es un cuadro de texto, para escribir explicaciones, responder preguntas, etc, debemos pulsar <shift> a la vez que el botón izquierdo del ratón. Los cuadros de texto como éste permiten incluir comentarios en una hoja de trabajo. Si haces doble clic sobre el cuadro de texto puedes editar el contenido. Al entrar en modo de edición, aparecen botones y desplegables para cambiar algunos aspectos del estilo del texto.Para guardar lo que hemos escrito, hay que pulsar "Save changes".

Dentro de las celdas de texto podemos usar código latex escribiéndolo directamente.

Podemos guardar el documento con el que estamos trabajando pulsando "Save" en el menú superior. También podemos hacer una copia en el disco duro usando el menú:

file->Save workshet to a file

Esto nos creará un archivo que podemos recuperar más tarde (por ejemplo si hemos borrado algo por equivocación y luego lo hemos salvado).

Además, podemos compartir el archivo con otro usuario. Para ello pulsamos el botón "share" en la parte superior de la página e introducimos el nombre del usuario con el que queremos compartir el worksheet.

Para buscar ayuda sobre como se utiliza una función, podemos usar la función "help". Por ejemplo, si queremos conocer cómo funciona la orden "plot", obtendríamos información así:

help(plot) 
       

Sage como una calculadora

Podemos utilizar Sage como cualquier (potente) calculadora científica

5-5*3^3 
       
32.23/234.1 
       

Además de las operaciones aritméticas, podemos usar las muchas funciones disponibles. La forma de usarlas es escribir el nombre de la función, seguido del argumento, o argumentos, entre paréntesis, y separados por comas.

exp(4.5) 
       
sqrt(2.4) 
       

Sage reconoce a qué anillo o cuerpo pertenecen los números con los que se trabaja y opera dentro de esa estructura. Así, por ejemplo, si usamos fracciones, no las escribirá como número real.

(2/4)^23 
       
sin(pi/3) 
       

Para convertir una expresión en un número real en coma flotante, utilizamos la función n()

n(pi) 
       
n(pi,1000) 
       

Variables

Para utilizar posteriormente el resultado de un cálculo, podemos guardarlo en una variable:

b=2.0^4+1.0/5+exp(3.0) 
       

Para ver el contenido de la variable, basta escribir su nombre y ejecutar la celda:

       

Podemos usar una variable en cualquier contexto que en el que podamos usar su contenido:

sin(b)+exp(-b^2) 
       

Funciones (matemáticas)

Podemos definir una función como lo haríamos en clase:

f(x)=x^3+x^2+3 
       

Sage nos indicará que f guarda una función que asigna a cada x el polinomio anterior:

       

Para evaluar la función en un punto, basta sustituir el valor.

f(0); f(3); f(3.2); f(pi) 
       

Tambien podemos calcular derivadas y primitivas de la función, que a su vez son funciones:

f.diff(x) 
       
f.diff(x)(1) 
       

Para ver todas las operaciones que podemos hacer con una función, podemos escribir f. y pulsar el tabulador.

f. 
       

Si queremos que una función dependa de un parámetro, debemos declarar el parámetro con el comando "var".

var('a') g(x)=a*x^3+4*a g(3) 
       
g.diff(x) 
       

Además podemos simplificar y factorizar las funciones y resolver ecuaciones.

f(x)=(sin(2*x)-cos(x))^4+(sin(2*x)-cos(x))^5;f(x) 
       
f.factor() 
       
f.expand() 
       

Listas

Un tipo de datos muy importante en Sage son las listas. Vamos a ver cómo crear, modificar y seleccionar elementos de ellas.

Una lista no es más que una colección ordenada de elementos. Cada elemento de la lista puede ser cualquier tipo de objeto. Para crear una lista se pone entre corchetes la lista de los elementos, separados por comas.

L = [2,3,5,7,11,13,17,2] 
       

Para acceder a un elemento se pone el nombre de la lista, seguido de corchetes y entre corchetes el número de elemento al que queremos acceder. El primer elemento se numera con 0.

L[0] 
       
L[0]=3;L 
       

También podemos comenzar contando desde el último elmento usando índices negativos. Así el último elemento está numerado con -1, el penúltimo con -2, etc

L[-2] 
       

Podemos seleccionar un segmento de la lista con el operador :, siguiendo la convención nombreDeLista[primerElemento:ultimoElemento].

L[2:5] 
       

Si queremos saber cuantos elementos tiene la lista, utilizamos la orden len

len(L) 
       

Podemos unir varias listas con la operación +.

[1,3,5]+[2,4,6]+[100] 
       

Creación de listas de elementos equiespaciados

Python permite crear de modo sencillo una lista de elementos equiespaciados.

[1..7] 
       
[2,4..10] 
       

Operando con listas

Sage soporta muchas operaciones directamente sobre listas. Como ejemplo, vamos a sumar los elementos de una lista, vamos a agrupar dos listas en una uniendo el elemento k de la primera con el k de la segunda, y por último map que aplica una función a cada elemento de una lista.

sum([1..100]) 
       
zip([1,2,3,4],['a','b','c','d'] ) 
       
map( cos, [0, pi/4, pi/2, 3*pi/4, pi] ) 
       

Listas por comprensión

Python permite definir listas por comprensión. Es una manera rápida de crear una lista a partir de otra. La sintasis es [ expresión for indice in lista]. Devuelve una lista resultado de evaluar la expresión (que dependerá de la variable denominada índice) aplicada a cada uno de los elementos de la lista.

[ 2*k for k in [0..10] ] 
       
[ cos(x) for x in [pi/4, pi/2..2*pi]] 
       

Además se puede filtrar el resultado de la salida:

U = [ k for k in [1..19] if gcd(k,20) == 1]; U 
       

Aún más

Para profundizar algo más en lo anterior, se puede mirar:

http://sage-cum.unex.es:8000/home/pub/26/

y hacer los ejercicios que hay allí.

Gráficos en Sage


Elementos básicos

 

Puntos

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

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 
       

Líneas

Para dibujar líneas se utiliza el comando line

line([(0,0),(1,1)]) 
       

Podemos unir dos gráficas utilizando la operación +

line([(0,0),(1,1)],color='black',legend_label=u"Línea")+points([(0,0),(1,1)],color='red',faceted=True, pointsize=40,legend_label="Puntos") 
       
datosx=[random() for k in range(10)] datosy=[random() for k in range(10)] puntos=zip(datosx,datosy); sum([line([(0,0),puntoj],color='black') for puntoj in puntos])+points([(0,0)]+puntos,color='red',faceted=True, pointsize=40,legend_label="Puntos") 
       

Polígonos

Finalmente, para pintar regiones, podemos usar la orden polygon

polygon([(cos(x),sin(x)) for x in [0,(2*pi/7)..2*pi]],axes=false) 
       

Representación de curvas en dos dimensiones

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="--") 
       


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),color='black', fill = dict([(i, [i+1]) for i in [0..5]])) Grafica+plot(1/(1-x),(x,0,1),ymax=4,color='black',thickness=3) 
       

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)) 
       

 

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) 
       

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)) 
       

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) 
       

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() 
       

Gráficas en 3 dimensiones

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 
       

 Aún más

Para profundizar en la creación de gráficos con Sage, puedes seguir el tutorial:

http://sage-cum.unex.es:8000/home/pub/32/

Profundizando en Sage

Programación en Sage

El lenguaje de programación de Sage por defecto es Python. Según Wikipedia:

"Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis muy limpia y que favorezca un código legible.

Se trata de un lenguaje de programación multiparadigma, ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado, usa tipado dinámico y es multiplataforma.

Es administrado por la Python Software Foundation. Posee una licencia de código abierto, denominada Python Software Foundation License,1 que es compatible con la Licencia pública general de GNU a partir de la versión 2.1.1, e incompatible en ciertas versiones anteriores."

Funciones

Para definir una función (programación) en Sage/Python, usamos la palabra clave def, seguida del nombre de la función, las variables de entrada entre paréntesis y dos puntos. En las siguientes líneas se escriben los comandos que queremos que evalúe la función.La identación es muy importante en Python: todo lo que esté con la misma identación será el cuerpo de la función, para terminar la función basta escribir sin identación. Por último, el valor que devuelve la función se determina por la palabra clave return.

def g(x,y): return x*y 
       

Podemos usar la función igual que usamos cualquier función matemática.

g(1,3) 
       

Las funciones pueden recibir listas como parámetros y devolver listas en el return.

def sumaCuadrados(v): return sum([k^2 for k in v]) 
       
sumaCuadrados([1,3..9]) 
       
def primos(n): return [k for k in [1..n] if is_prime(k)] 
       
primos(1000) 
       

Como parámetro de entrada y salida vale cualquier tipo de objeto de Sage:

def graficaDerivada(f,x): return plot(f(x),(x,-1,1))+plot(f.diff(x)(x),(x,-1,1),color="green") 
       
f(x)=exp(x)-x graficaDerivada(f,x) 
       

Estructuras de control

Las estructuras de control seleccionan cuál es la siguiente sentencia a ejecutar (selección -- if) o hacen que una sentencia se ejecute repetidamente (iteración -- while o for).

Selección -  If

La estructura de selección condicional if nos permite elegir ejecutar o no un bloque de instrucciones. La sintaxis es:

if condición:

   instrucciones a ejecutar (1 o varias)

También se puede elegir ejecutar otras instrucciones en el caso en el que no se cumpla la condición:

if condición:

   instrucciones a ejecutar (1 o varias)

else:

   instrucciones a ejecutar (1 o varias)

Por ejemplo, vamos a calcular el valor absoluto de un número.

a=-5 if a<0: a=-a; a 
       

Usando else ejecutamos una instrucción cuando no se comple la condición.

a=pi/2 if a>3: show( latex(a)+ latex(' es mayor que 3')) else: show( latex(a)+ latex(' es menor que 3')) 
       

Podemos combinar varias condiciones con los operadores and y or.

a=pi/2 if a>1 and a<3: show( latex(a)+ latex(' está entre 1 y 5')) else: show( latex(a)+ latex(' no está entre 1 y 5')) 
       

Repetición - While

Para repetir una sentencia un número indeterminado de veces, podemos usar un bucle while, con sintaxis:

while condición:

  instrucciones a ejecutar

Por ejemplo, para encontrar un número en una lista:

lista=[1,2,3,5,3,4,7] i=0; # Este bucle busca en la lista hasta que encuentra el 7 (es decir, mientras i está en la lista y lista[i] no es 7) while i<len(lista) and lista[i] != 7: i=i+1; # Hacemos que la salida sea explicativa if i<len(lista): print "El número ",lista[i]," está en la posición",i+1 else: print "No he encontrado el número" 
       

Repetición - For

Si queremos repetir una instrucción para cada elemento de un vector, podemos usar un bucle for. La sintaxis es:

for variable in lista:

  instrucciones a ejecutar

Vamos a mostrar por pantalla todos los cuadrados del 0 al 4.

for i in [0..4]: print i^2 
       

Y vamos a poner en mayúscula la primera letra de cada cadena de texto de una lista.

for str in ["juan","mario","eva","laura"]: print str.capitalize() 
       

En el siguiente ejemplo, se recibe una lista de cotas equiespaciadas (por ejemplo, la altura en metros de una carretera, medida cada kilómetro) y se calcula la pendiente.

cotas=[323,301,298,302,312,333,340,352,367] distanciaHorizontal=1000 pendiente=[] # comienzo en una lista vacía for k in range(len(cotas)-1): pendiente.append((cotas[k+1]-cotas[k])/distanciaHorizontal) pendiente 
       

Utilizando otros programas dentro de Sage

Dentro de Sage podemos utilizar varios programas de software matemático. Vamos a ilustrar cómo trabajar con R.

El primer método es ir a la cabecera del documento, y en el desplegable que pone sage, elegir el programa R. Hazlo y después ejecuta el siguiente código.

x<- runif(1000) mean(x) 
       

Vuelva a poner sage en el desplegable. Un segundo modo de ejecutar comandos en otro lenguage, es escribir %nombredellenguaje al principio de la celda. Por ejemplo, %r hará que Sage entienda que todos los comandos en esa celda usan la sintaxis de R.

%r x<- runif(1000) mean(x) 
       

También podemos generar gráficas de R. Para ello hay que escribir png() antes de comenzar a generar las gráficas y .silent.me. <- dev.off() al final para que las muestre.

%r x <- rnorm(100) y <- rnorm(100, mean=5)*x+rnorm(100, mean=0.1) png() plot(y ~ x) abline(lm(y ~ x), lwd=2) .silent.me. <- dev.off() 
       

Los métodos anteriores son válidos si queremos utilizar puntualmente R para analizar datos o dibujar una gráfica, pero no son útiles cuando lo que queremos es utilizar los resultados para combinarlos con las funciones que nos ofrece Sage. Si lo que queremos es precisamente eso, es mejor utilizar los comandos de R llamándolos como r.nombrecomando. Veamos algunos ejemplos.

r.png() x = r.rnorm(100) r.hist(x) r.library("lattice") r("print(histogram(~wt | cyl, data=mtcars))") r.histogram(x = "~ wt | cyl", data="mtcars") r.dev_off() 
       

Cuando usamos R, los datos que nos devuelve están en "formato R", por lo que algunas operaciones no estarán disponibles. Para pasarlos a formato Sage, escribiremos al final ._sage_().

x=[1,4,3,2,4,1,2,1,2] r.mean(x)._sage_() 
       

Manejo de datos

En este apartado, veremos cómo importar archivos de datos y realizar algunas operaciones básicas. En general, podemos tener los archivos de datos en múltiples formatos y usualmente en Bases de Datos. Como el lenguaje de Sage es python, podemos acceder a multitud de formatos de archivo, pero por simplicidad, vamos a asumir que tenemos los datos en un archivo en formato csv.

El primer paso para leer un archivo es añadirlo al directorio "DATA" de la hoja de Sage en la que estamos trabajando. Vamos a cargar un archivo como ejemplo.

En el desplegable "DATA" de la parte superior de la página, elige la opción "upload or create a file".

Aparecerá una nueva página con varias opciones para crear un archivo. Introduce en "Or enter the URL of a file on the web:" la dirección:

http://samplecsvs.s3.amazonaws.com/Sacramentorealestatetransactions.csv

En "What do you want to call it? (if different than the original name)" escribe "datos.csv" y pulsa "Upload or create a file". Después, vuelve a la página pulsando en "Worksheet".

import csv data =list( csv.reader(open(DATA+'datos.csv','rU')) ) 
       

Podemos visualizar los datos escribiendo "data" en una celda. Sin embargo el tamaño es tan grande que sólo nos mostrará parte. Para evitar eso, podemos mostrar las dos primeras filas.

data[0];data[1] 
       

Vamos a representar las coordenadas de las ventas.

posiciones=[(data[k][11],data[k][10]) for k in range(1,len(data))]; posiciones[0],posiciones[1] 
       
points(posiciones) 
       

Vamos a representar tambien el precio.

precio=[int(data[k][9]) for k in range(1,len(data))] min(precio),max(precio),mean(precio).n() 
       

Vamos a asignar un color, de modo que las casas más baratas sean azules y las más caras rojas.

def rangoColores(k): porcentaje=float(precio[k]-min(precio))/float(max(precio)-min(precio)) r=porcentaje g=porcentaje*(1-porcentaje) b=(1-porcentaje) return (r,g,b) 
       
sum([points(posiciones[k], color=rangoColores(k)) for k in range(len(posiciones))])