En esta asignatura usaremos el programa Sage para resolver distintos problemas de matemáticas con el ordenador. El programa es libre, lo que nos permite copiarlo, modificarlo y redistribuirlo libremente. Sage consta de un buen número de librerías para ejecutar cálculos matemáticos y para generar gráficas. Para llamar a estas librerías se usa el lenguaje de programación python, para el que existen un buen número de recursos didácticos disponibles. Os listamos unos pocos
SAGE es un entorno de cálculos matemáticos (MCE, siglas de Mathematics computing environment) que realiza cálculos algebraicos, simbólicos y numéricos. La comunicación con el intérprete de comandos se efectúa por medio de cuadros de código, que contienen, en el lenguaje apropiado, líneas que serán evaluadas y producirán un resultado, visible o no. Pero también podemos acompañar estos cálculos de texto, imágenes o cualquier otro material ilustrativo, que nos permiten recrear un cuaderno de apuntes. Para ello, lanzamos SAGE con la compañía de un navegador, y editamos cuadros de texto y cuadros de código.
Antes de abrir el cuaderno por alguna hoja concreta, tenemos, en la portada${}^*$, una lista de hojas ya utilizadas y podemos acceder a abrir otras que se nos hayan facilitado (descargadas, guardadas por otro usuario, accesibles desde algún servidor, ...)
${}^*$ se accede a la portada pinchando sobre Home en la parte superior de la hoja.
{{{id=1| /// }}}Los cuadros de texto como este permiten incluir comentarios en una hoja de trabajo. Si haces doble click sobre el cuadro de texto puedes editar el contenido. Al cambiar a modo de edición, aparecen botones y desplegables para cambiar algunos aspectos del estilo del texto. Lo más importante para mantener un orden en la hoja de trabajo es el primer desplegable, que permite elegir si se trata de un párrafo, un encabezado.
{{{id=2| /// }}}Los cuadros de código son rectagulares y su borde cambia de color al seleccionarlos. Dentro de los cuadros de código podemos escribir órdenes que serán ejecutadas al pulsar el botón evaluate o pulsar mayúsculas+Enter.
Puedes crear un nuevo cuadro de código pulsando sobre la línea azul que aparece al poner el cursor ligeramente por encima de un cuadro de código existente, o pulsando control+Enter dentro de un cuadro de código. Puedes crear un nuevo cuadro de texto pulsando sobre la misma línea azul, pero manteniendo pulsada la tecla de mayúsculas.
{{{id=3| /// }}}Si ponemos varias líneas de código, se ejecutan una tras otra de arriba a abajo. El intérprete de instrucciones lee las instrucciones, las interpreta y ejecuta lo que se le pide. Algunas instrucciones producen una salida, que se muestra debajo del cuadro de código.
Ejecuta el código siguiente, para ello sitúa el cursor dentro del mismo y pulsa evaluate o teclea May.+Enter. ¿Encuentras algo a faltar en la respuesta?
{{{id=14| print 'Hola, mundo' 2+2 print 3<4 4^5-6 /// }}}Dentro de un cuadro de código, cualquier línea que comience con el carácter # no será evaluada por el intérprete.
Ejecuta el código siguiente.
{{{id=5| print 2+2 #Ahora sí me lo muestra print 'Mi primera gráfica' #El comando plot esboza y nos muestra diversos objetos, #en este caso la gráfica de una función de una variable. plot(x*(x^2-3),-2,2) /// }}}Podemos usar los bloques de código como una simple calculadora, escribiendo operaciones aritméticas y observando el resultado debajo del cuadro. Podemos introducir números con decimales usando el punto decimal. Los paréntesis marcan qué operación se ejecuta antes, naturalmente. Podemos anidar paréntesis si es necesario, pero no se pueden usar corchetes ni llaves, caracteres estos reservados a otros propósitos.
{{{id=6| (1*2)+(3*4)+5 /// }}} {{{id=7| 1*(2+3)*(4+5) /// }}} {{{id=8| (1*(2+3)*4)+5 /// }}}Aparte de las operaciones de la artimética elemental, se puede operar con valores booleanos: True y False. Las operaciones son:
| and | True | False | or | True | False | not | |||||
| True | True | False | True | True | True | True | False | ||||
| False | False | False | False | True | False | False | True |
Se ha de tener en cuenta que, en ausencia de paréntesis, SAGE decide qué operaciones se ejecutan antes y cuáles se ejecutan después. Se siguen una reglas fijas conocidas como reglas de precedencia de operadores.
La regla más importante: en caso de duda, usa paréntesis.
Además de las operaciones aritméticas, podemos usar las muchas funciones disponibles. Por ejemplo, seno (sin), coseno (cos), exponencial (exp). La forma de usarlas es escribir el nombre de la función, seguido del argumento entre paréntesis.
{{{id=68| sin(pi/3) /// }}} {{{id=64| (1+sin(pi/3))/2 /// }}} {{{id=38| cos(0.032)*exp(-0.5) /// }}} {{{id=128| pi.n() /// }}}Incluso esbozar sus gráficas:
{{{id=136| plot(sin(x),-pi,pi) /// }}}Las variables permiten almacenar el valor de un cómputo en la memoria, y utilizar ese valor posteriormente. Para guardar el valor de una expresión dentro de una variable, usamos la sintaxis:
variable = expresion
Por ejemplo,
numero = 1+2+3+4+5+6
largo = 2.56*20
angulo = pi/3
Para poder ver el valor de una variable podemos usar el comando print:
print numero
print largo, angulo
print largo * sin(angulo)
Una vez hemos guardado un valor en una variable, podemos hacer cálculos con el valor de la variable:
masa = 3
aceleracion = 10
fuerza = masa*aceleracion
print fuerza
{{{id=134|
///
}}}
{{{id=79|
numero = 1+2+3+4+5+6
largo = 2.56*20
angulo = pi/3
///
}}}
{{{id=78|
print numero
print largo, angulo
print largo * sin(angulo)
///
}}}
{{{id=65|
distancia = 2.56*20
print distancia
///
}}}
Nota: los nombres de las variables deben empezar por una letra o un guión bajo (_), pueden contener números, y son distintos si se usan mayúsculas o minúsculas. Las variables distancia y Distancia son distintas.
{{{id=59| print Distancia /// }}}Guardamos en una variable el valor del radio, luego calculamos y guardamos en dos variables el área y el perímetro, y escribimos el resultado:
{{{id=43| radio = 5 /// }}} {{{id=45| area = pi * radio^2 perimetro = 2*pi*radio print 'Area:', area print 'Perimetro:', perimetro /// }}}Salida numérica: para obtener valores aproximados de números irracionales, podemos usar el método .n()
{{{id=61| print 'Area: ', area.n() print 'Perimetro: ', perimetro.n() /// }}}Con bastante frecuencia se realiza un cálculo que depende del valor de una variable, y se asigna el resultado a esa misma variable. Aunque conceptualmente no suponga ningún problema, la sintaxis suele confundir cuando se ve por primera vez. Por ejemplo:
k=k+1
realiza el cálculo consistente en sumar 1 al valor de la variable k, y después guarda dentro de la variable k el resultado de la operación.
Atención: Se ha de tener en cuenta que, en la sintaxis habitual de los lenguajes de programación, un símbolo igual '=' se utiliza para asignar valores a variables, y no para escribir una ecuación.
{{{id=69| k = 5 print k k = k + 1 print k /// }}}Usando el comando del, podemos liberar una variable, y a partir de ese punto el nombre de la variable deja de estar definido.
del variable{{{id=122| numero = 12 print 2*numero /// }}} {{{id=121| del numero print 3*numero /// }}} {{{id=130| factorial (1000)/factorial (1001) /// }}}
En las variables podemos almacenar cualquier tipo de datos que resulte de evaluar una expresión. La función type() nos informa del tipo de datos que estamos manejando.
Más adelante en el curso, guardaremos en las variables vectores, matrices e incluso gráficas. Por ahora hemos usado los siguientes tipos de datos:
Al usar el ordenador para hacer matemáticas es importante saber si los datos del ordenador representan los objetos matemáticos de forma exacta.
Es imposible almacenar en un ordenador, con una cantidad finita de memoria, todas las cifras decimales del número pi. Una alternativa es almacenar sólo unas cuantas cifras, y cometer por tanto un pequeño error. Para la mayoría de las aplicaciones es más que suficiente usar 10 o 20 cifras decimales significativas. Con esto queremos decir que al escribir el número en notación exponencial, descartamos todas las cifras a partir de la número 10. Por ejemplo, el número $1/\pi$ con diez dígitos significativos:
$$
3.183098861 \cdot 10^{-1}
$$
y la constante de Planck con seis dígitos significativos:
$$
6.62606 \cdot 10^{-34}
$$
Al hacer operaciones con números que contienen errores, los errores se suman y multiplican, y pueden acabar estropeando un cálculo. Otra alternativa es usar una variable simbólica, y no hacer los cálculos, exactamente igual que os contaban en el instituto:
$$
\frac{\sqrt[3]{2}\cdot 3^2}{\frac{3 \cdot 4}{\sqrt[3]{4}}}= 2^{1/3-2+2/3}3^{2-1}=2^{-1}3=3/2
$$
Al estar orientado preferentemente al público matemático, Sage prefiere usar expresiones simbólicas exactas antes que resultados numéricos. Como vimos antes, para obtener una representación decimal de una expresión simbólica, podemos usar el método .n() (n de numérico).
{{{id=76| 1/pi /// }}} {{{id=46| (1/pi).n() /// }}} {{{id=119| a = sqrt(2) /// }}} {{{id=120| a.n() /// }}} {{{id=118| /// }}}Cada tipo de datos tiene sus propios métodos: funciones que se aplican sólo a datos de este tipo y que se llaman escribiendo primero la variable que contiene el dato, después un punto (.) y, por último, el método:
variable.metodo()
Por ejemplo, podemos calcular la factorización de un número entero, pero no de un número real, o podríamos intentar simplificar una expresión simbólica, pero no podemos simplificar un número entero.
{{{id=110| a = 12 print a.factor() #Factorizacion del entero 'a' /// }}} {{{id=111| b = 4.7 print b.integer_part() #Parte entera del numero real 'b' /// }}} {{{id=117| c = (3*sqrt(6)+sqrt(2))/sqrt(8) print c.full_simplify() #Intenta simplificar la expresion 'c' /// }}} {{{id=115| print b.factor() /// }}} {{{id=116| print a.full_simplify() /// }}} {{{id=113| /// }}}Aunque Sage utiliza el lenguaje python, los tipos numéricos en Sage no corresponden exactamente a los tipos numéricos de python, ya que los números en Sage tienen más funcionalidad. Por ejemplo, los enteros de Sage permiten calcular su lista de divisores, su expresión binaria, etcétera. Por defecto, los tipos numéricos son enteros, racionales y numeros reales de Sage, no de python.
{{{id=96| a = 12 #Entero de Sage #a = Integer(12) #Otra forma equivalente de definir un entero de Sage b = int(12) #Entero de 32 bits de python /// }}} {{{id=99| print a.divisors(), a.digits(base = 2) /// }}} {{{id=98| print b.divisors() /// }}} {{{id=104| c = 1.2 #Real de Sage (de precision limitada) c = RealNumber(1.2) #Otra forma equivalente de definir un real de Sage d = float(1.2) #Real de 64 bits de python /// }}} {{{id=105| d.exact_rational() /// }}} {{{id=106| c.exact_rational() /// }}} {{{id=74| /// }}}Para poder ver en pantalla los valores de las variables, hemos usado el comando print.
print var1
print var1, var2, ...
De esta forma podemos mostrar los valores de las variables. También podemos escribir texto que contenga los valores de estas variables usando el operador % y los códigos de formato. Para usarlo, escribimos una cadena que contiene códigos de formato seguida del operador % y a continuación las variables que queremos sustituir dentro de la cadena. Si hay más de una variable, los escribimos dentro de parentésis, y separados por comas. Ejemplos:
lados = 8
print 'El número de lados es %d'%lados
area = 17.5
print 'El área es %f'%area
print 'El área del polígono de %d lados es %f'%(lados, area)
nombre = 'Juan'
print '%s vino ayer a cenar'%nombre
Los códigos más usuales son: