Matemáticas con Maxima: 2011

domingo, 4 de diciembre de 2011

Ecuaciones

En general, para resolver ecuaciones en Maxima es necesario utilizar la función solve.

Una sencilla ecuación algebraica de primer grado.

(%i1) solve(3*(x-6)/4 - (3-5*x)/9 - 6 = x/7 + 3);
                                       3486
(%o1)                             [x = ----]
                                       293

Una ecuación de segundo grado, con dos soluciones reales.

(%i2) solve(-x^2 + 15*x = 54);
(%o2)                           [x = 6, x = 9]

Ahora un sistema de dos incógnitas. Fíjate que tienes que introducir la lista de ecuaciones y luego la lista de variables.

(%i3) solve([u-5*v=-26, u-v=-46], [u,v]);
(%o3)                       [[u = - 51, v = - 5]]

Cuando hay una sola incógnita, no necesitas indicarle a Maxima cuál es, a menos que haya un parámetro literal; en tal caso es imperativo decirle cuál es la incógnita a despejar.

(%i4) solve(2*x+(x-9)/8 = a/7, x);
                                     8 a + 63
(%o4)                           [x = --------]
                                       119

Podemos utilizar solve para despejar magnitudes en fórmulas físicas, como aquí, que nos planteamos despejar la resistencia R1. Respecto de este ejemplo, recuerda que el símbolo de procentaje % se utiliza para hacer referencia al último resultado devuelto por Maxima.

(%i5) 1/Rt = 1/R1 + 1/R2;
                                 1    1    1
(%o5)                            -- = -- + --
                                 Rt   R2   R1
(%i6) solve(%, R1);
                                       Rt R2
(%o6)                           [R1 = -------]
                                      R2 - Rt

Otra aplicación de solve es calcular la función inversa de otra dada.

La función psubst que se utiliza al final hace sustituciones de variables en paralelo.

(%i7) y = (x+5)/(3*x+1);
                                       x + 5
(%o7)                             y = -------
                                      3 x + 1
(%i8) solve(%, x);
                                        y - 5
(%o8)                          [x = - (-------)]
                                       3 y - 1
(%i9)  /* extraigo el resultado de la lista de soluciones  */
       first(%);
                                        y - 5
(%o9)                           x = - (-------)
                                       3 y - 1
(%i10) /* cambio de nombre las variables  */
       psubst([x=y, y=x], %);
                                        x - 5
(%o10)                          y = - (-------)
                                       3 x - 1

sábado, 19 de noviembre de 2011

Integración simbólica

La integración simbólica se realiza en Maxima con la función integrate.

Para el cálculo de una primitiva, sólo es necesario pasarle a integrate dos argumentos, la función a integrar y la variable respecto de la cual se integra.

(%i1) integrate(log(x^2), x);
(%o1)                          2 (x log(x) - x)

Nótese que se obvia la escritura de la constante de integración.

El segundo argumento es importante, porque si la función contiene parámetros literales, es necesario indicarle qué letra hace las funciones de variable.

(%i2) integrate(k*a^(-u), u);
                                        k
(%o2)                            - (---------)
                                     u
                                    a  log(a)

Para calcular la integral definida hay que añadirle a integrate dos nuevos argumentos, correspondientes a los límites de integración.

(%i3) integrate(log(x), x, 1, 2);
(%o3)                           2 log(2) - 1

Un ejemplo de Geometría. ¿Cuál es el área encerrada entre la parábola y=-x² + 1 y el eje de abscisas?

Es fácil ver que los puntos de corte con el eje están en x=-1 y x=1. Lo podemos comprobar:

(%i4) solve(-x^2+1, x);
(%o4)                         [x = - 1, x = 1]

Ahora procedemos con el cálculo del área:

(%i5) integrate(-x^2+1, x, -1, 1);
                                      4
(%o5)                                 -
                                      3

Un ejemplo de Física. La velocidad de un móvil viene dada por la expresión v = 2 t² + t. ¿Cuál es el espacio recorrido entre los instantes t=0 y t=1?

(%i6) integrate(2*t^2+t, t, 0, 1);
                                      7
(%o6)                                 -
                                      6

Un problema de integración con condición. Se trata de calcular la primitiva F(x) de la función f(x)=2*e^x -x³ que verifique la condición F(1)=1/2.

(%i1) integrate(2*%e^x-x^3, x) + k;
                                         4
                                    x   x
(%o1)                           2 %e  - -- + k
                                        4
(%i2) subst([x=1], %);
                                            1
(%o2)                            k + 2 %e - -
                                            4
(%i3) solve(% = 1/2);
                                      8 %e - 3
(%o3)                         [k = - (--------)]
                                         4

miércoles, 16 de noviembre de 2011

Representación de funciones explícitas

La representación de funciones explícitas la vamos a hacer con el paquete draw. Como siempre que vayamos a utilizar esta librería, necesitamos cargarla previamente en memoria.

(%i1) load(draw) $

Construimos una escena paso a paso.

(%i2) draw2d(explicit(sin(x^2-x+1), x, -3,3)) $

Para facilitar la lectura del gráfico, podemos dibujar un retículo,

(%i3) draw2d(
        grid = true,
        explicit(sin(x^2-x+1), x, -3,3)) $

Ahora añadimos unas etiquetas a los ejes coordenadas y un título, además de redimensionar la ventana,

(%i4) draw2d(
        title = "Composicion seno y polinomio",
        xlabel = "x",
        ylabel = "y",
        dimensions = [600,300],
        grid = true,
        explicit(sin(x^2-x+1), x, -3,3)) $

Podemos incluir más de una función en la misma escena. Por ejemplo, vamos a añadirle a la gráfica su función derivada en color rojo; vemos también que podemos añadirle comentarios al código en cualquier sitio,

(%i5) draw2d(
        title = "Composicion seno y polinomio",
        xlabel = "x",
        ylabel = "y",
        dimensions = [600,300],
        grid = true,
        explicit(sin(x^2-x+1), x, -3,3),

        /* ahora va la derivada en rojo */
        color = red,
        explicit(diff(sin(x^2-x+1),x), x, -3,3)) $

La curva azul se ha reescalado automáticamente para acomodar la derivada dentro de la escena.

Representación gráfica de una función definida a trozos. Nos planteamos representar gráficamente la función

Damos por sentado que ya hemos cargado en memoria el paquete draw.

El asunto consiste en dibujar los tres trozos como funciones explícitas independientes,

(%i6) draw2d(
        grid = true,
        explicit(-1, x, -6,-4),
        explicit(x+2, x, -4,2),
        explicit(8/x, x, 2,6)) $

Vamos a mejorar la presentación añadiendo los ejes coordenados como líneas sólidas, al paso que hacemos el trazo algo más ancho y fijamos el rango del eje vertical,

(%i7) draw2d(
        grid = true,
        xaxis = true, xaxis_type = solid,
        yaxis = true, yaxis_type = solid,
        line_width = 3,
        yrange = [-4,5],

        /* ahora pintamos los tres trozos */
        explicit(-1, x, -10,-4),
        explicit(x+2, x, -4,2),
        explicit(8/x, x, 2,20)) $

Vemos que hay una discontinuidad de salto finito en x = -4. Ahí la función toma el valor y = -2. Podemos hacer destacar este hecho si pintamos un círculo justo en ese lugar,

(%i8) draw2d(
        grid = true,
        xaxis = true, xaxis_type = solid,
        yaxis = true, yaxis_type = solid,
        line_width = 3,
        yrange = [-4,5],

        /* ahora pintamos los tres trozos */
        explicit(-1, x, -10,-4),
        explicit(x+2, x, -4,2),
        explicit(8/x, x, 2,20),

        /* añadimos el punto grueso en (-4,-2) */
        point_type = filled_circle,
        point_size = 4,
        points ([[-4,-2]]) ) $

sábado, 12 de noviembre de 2011

Asíntotas

De entre toda la información que hay que extraer de una función antes de proceder a su representación gráfica, la detección de posibles asíntotas facilita la visualización del comportamiento general de la función.

En esta entrada veremos cómo calcular, si existen, y con la ayuda de Maxima, las asíntotas verticales, horizontales y oblicuas.

Para la detección de posibles asíntotas verticales nos fijaremos en aquellos puntos en los que la función pueda presentar una discontinuidad de salto infinito, como valores en los que se anulen los denominadores o los argumentos de los logaritmos.

Por ejemplo, la función y = (x^2+1)/(x-2) presenta una discontinuidad de salto infinito en x=2, ya que

(%i1) y: (x^2+1)/(x^2-2);
                                     2
                                    x  + 1
(%o1)                               ------
                                     2
                                    x  - 2
(%i2) limit(y, x, sqrt(2));
(%o2)                             infinity

Como se ve, hemos guardado en la variable y la expresión de la función.

Las asíntotas horizontales las obtenemos si calculamos los límites hacia los infinitos; si algunos de ellos es un número real, tenemos asíntota horizontal. Seguimos con la función anterior.

(%i3) limit(y, x, inf);
(%o3)                                  1
(%i4) limit(y, x, minf);
(%o4)                                  1

De modo que esta función tiene asíntota horizontal y=1, tanto hacia la derecha como hacia la izquierda. Un gráfico ayuda a ver las tres asíntotas. Para hacer uso de la función gráfica draw2d necesitamos cargar antes en memoria la librería correspondiente.

(%i5) load(draw)$
(%i6) draw2d(
         explicit(y, x, -15, 15),
         yrange= [-20,20],
         grid=true) $

El cálculo de las asíntotas oblicuas lo hacemos en dos pasos; primero obtenemos las pendientes de las rectas:

(%i7) y: sqrt((x+1)^2-10);
                                          2
(%o7)                         sqrt((x + 1)  - 10)
(%i8) limit(y/x, x, minf);
(%o8)                                 - 1
(%i9) limit(y/x, x, inf);
(%o9)                                  1

Así que tenemos asíntotas oblicuas a ambos lados, pues los límites, es decir las pendientes, son números reales distintos de cero. Calculamos ahora las ordenadas en origen:

(%i10) limit(y - (-1)*x, x, minf);
(%o10)                                - 1
(%i11) limit(y - (+1)*x, x, inf);
(%o11)                                 1

Así tenemos que esta función es asintótica por la derecha a la recta y=x+1 y por la izquierda a la recta y=-x-1.

(%i12) draw2d(
         explicit(y, x, -15, 15),
         grid=true)$

Límites

El cálculo de límites se hace con la función limit. Hay algunos símbolos que nos van a ser de ayuda:

inf: es el más infinito,
minf: es el menos infinito,
plus: cuando nos acercamos por la derecha,
minus: cuando nos acercamos por la izquierda,
infinity: infinito, pero sin determinar el signo.

Venga, unos ejemplos.

Un límite cuando la variable independiente tiende a infinito. Siempre se pondrá como primer argumento la función, luego la variable independiente y, finalmente, el lugar hacia el que tiende la variable.

(%i1) limit(1/x, x, inf);
(%o1)                                 0

Ahora hacemos que x se aproxime a menos infinito. En este caso, el denominador es un parámetro desconocido.

(%i2) limit(a/x, x, minf);
(%o2)                                 0

Límite de un cociente de polinomios.

(%i3) limit((x^7+x^5-3*x+1)/(4*x^7-2*x^4+x-56), x, inf);
                                       1
(%o3)                                  -
                                       4

Límite cuando x tiende a un número real.

(%i4) limit(log(x)/x^2, x, 5);
                                    log(5)
(%o4)                               ------
                                      25

Un límite indeterminado.

(%i4) limit(2/(x-3), x, 3);
(%o4)                             infinity

Pero podemos afinar calculando los límites laterales, primero por la izquierda y luego por la derecha. Los resultados son, respectivamente, menos infinito y más infinito.

(%i5) limit(2/(x-3), x, 3, minus);
(%o5)                               minf
(%i6) limit(2/(x-3), x, 3, plus);
(%o6)                                inf

Vamos a ver un pequeño truco que nos va a permitir ver en una igualdad el límite que queremos calcular junto con su resultado. Existe un operador en Maxima que se llama de comilla simple ('), cuya función es inhibir el cálculo de una expresión.

Se observa que escribimos lo mismo a ambos lados de la igualdad (copiar+pegar), pero a la izquierda utilizamos la comilla simple para que represente, sin calcular, el límite. En el lado derecho, al no poner la comilla simple, se hace efectivo el cálculo. Así queda una expresión más fácil de interpretar.

(%i7) 'limit((x^3+1)/(x^2-3), x, inf) = limit((x^3+1)/(x^2-3), x, inf);
                                       3
                                      x  + 1
(%o7)                        limit    ------ = inf
                             x -> inf  2
                                      x  - 3

(%i8) 'limit(sqrt(x^2+1) - x, x, inf) = limit(sqrt(x^2+1) - x, x, inf);
                                        2
(%o8)                   limit    (sqrt(x  + 1) - x) = 0
                        x -> inf
(%i9) 'limit((x^2+5)/(2-x), x, 2, minus) = limit((x^2+5)/(2-x), x, 2, minus);
                                      2
                                     x  + 5
(%o9)                        limit   ------ = inf
                             x -> 2- 2 - x

Los resultados que se muestran aquí en formato de texto no hacen justicia a los que muestran los interfaces gráficos que habitualmente los usuarios utilizan para hacer sus cálculos. A modo de ejemplo, incluimos una captura desde Wxmaxima.

viernes, 11 de noviembre de 2011

Potencias y raíces

Para calcular raíces cuadradas, disponemos en Maxima de la función sqrt, del inglés square root. Cualquier otra raíz de índice distinto de 2 requiere el uso del operador de potencia ^.

Empezamos en esta sesión con el cálculo de raíces cuadradas, seguimos con las potencias y terminamos con las raíces de índice n.

Raíz cuadrada de un número entero.

(%i1) sqrt(65986820641);
(%o1)                               256879

Raíz cuadrada de un número racional.

(%i2) sqrt(155176849/7495923241);
                                     12457
(%o2)                                -----
                                     86579

Cuando la raíz cuadrada no es racional, Maxima devuelve una expresión simbólica; esto es así porque su obsesión es la exactitud. Si queremos obtener una aproximación a un resultado irracional, debemos utilizar la función float. En este ejemplo, utilizamos el símbolo % para hacer referencia al último resultado devuelto por el programa; así evitamos tener que teclear nuevamente las expresiones.

(%i3) sqrt(60);
(%o3)                             2 sqrt(15)
(%i4) float(%);
(%o4)                          7.745966692414834

Fíjate cómo al calcular la raíz, Maxima simplificó hasta donde pudo. También se podría haber hecho todo el cálculo junto componiendo las dos funciones:

(%i5) float(sqrt(60));
(%o5)                          7.745966692414834

Pasamos ahora al cálculo de potencias con exponentes enteros.

(%i6) 89^12;
(%o6)                      246990403565262140303521
(%i7) 5^-6;
                                       1
(%o7)                                -----
                                     15625

(%i8) (3/8)^14;
                                    4782969
(%o8)                            -------------
                                 4398046511104
(%i9) (3/8)^-14;
                                 4398046511104
(%o9)                            -------------
                                    4782969
(%i10) /* ¿Cuál es la aproximación decimal del resultado %o8?  */
       float(%o8);
(%o10)                       1.0875212410610402E-6

Hemos visto en este ejemplo que además de %, que guarda el último resultado calculado, también podemos hacer en todo momento referencia a las etiquetas asociadas a las expresiones, tanto las que hemos introducido nosotros, como las que nos ha devuelto Maxima.

Otro detalle visto aquí es que podemos colocar comentarios que el programa ignora, siempre entre los símbolos /* y */

Los exponentes fraccionarios tienen una interpretación muy concreta: si elevamos una expresión a 1/n, es como si le extrayésemos la raíz n-ésima. Esta es la equivalencia que utilizamos en Maxima para calcular raíces de índice arbitrario.

Aquí calculamos una raíz quinta. Es muy importante el paréntesis; si no lo ponemos, primero elevaría a 1 y luego dividiría entre 5.

(%i11) 72589938853835776^(1/5);
(%o11)                               2356

Ejemplo de raíz racional. Aquí el índice de la raíz es 15.

(%i12) (14348907/35184372088832)^(1/15);
                                       3
(%o12)                                 -
                                       8

El exponente puede ser una fracción cualquiera.

(%i13) 2^(-2/3);
                                      1
(%o13)                               ----
                                      2/3
                                     2
(%i14) float(%);
(%o14)                         .6299605249474366

Ya por último, indicar que Maxima también trabaja con expresiones literales.

(%i15) sqrt(4*a^32);
                                        16
(%o15)                               2 a
(%i16) (8*a^27)^(1/3);
                                        9
(%o16)                               2 a

Operaciones aritméticas

Las operaciones más básicas que se deben poder hacer con un programa de Matemáticas son:

Suma: +
Resta: -
Multiplicación: *
División: /
Potencia: ^

También podemos hacer uso de tantos paréntesis como queramos con el fin de alterar el orden habitual en el que se deben hacer las operaciones:

las potencias,
las multiplicaciones y divisiones,
las sumas y las restas.

Veamos algunos ejemplos de cálculos hechos con Maxima.

Los resultados se muestran en formato de texto ASCII, que es más fácil de exportar para incorporar en esta página. Los entornos gráficos de usuario permiten obtener los resultados en formatos de mejor calidad.

Algunas operaciones básicas.

(%i1) 1+2*3;
(%o1)                                  7
(%i2) (1+2)*3;
(%o2)                                  9
(%i3) 3*5+7*9;
(%o3)                                 78
(%i4) 3*(-2)*(+3) - (-30)*40/15;
(%o4)                                 62
(%i5) (2+1)^3;
(%o5)                                 27

Operaciones con fracciones.

(%i6) 3/4 + 1/4 - 23/67;
                                      44
(%o6)                                 --
                                      67
(%i7) (-3/7)*(2/6-6/11)^4 + 1;
                                    394964
(%o7)                               ------
                                    395307
(%i8) (1+1/2)^(3*2+6*4-3);
                                 7625597484987
(%o8)                            -------------
                                   134217728

Operaciones con potencias de exponente entero.

(%i9) (23/95)^(-3);
                                    857375
(%o9)                               ------
                                    12167
(%i10) 8^5 - (1+4/5)^(-2);
                                    2654183
(%o10)                              -------
                                      81

Instalación

Maxima está disponible para los sistemas operativos Linux, Mac y Windows.

Linux

Todas las distribuciones tienen Maxima en sus repositorios, siendo suficiente con abrir un terminal y escribir:

sudo apt-get install maxima maxima-doc maxima-share gnuplot wxmaxima

Esperar un poco y listo.

Mac

Se debe descargar e fichero de extenxión dmg desde la zona de descarga de Sourceforge para Mac. A continuación se seguirá e proceso de instalación habitual.

Windows

Se debe descargar e fichero de extenxión exe desde la zona de descarga de Sourceforge para Windows. continuación se seguirá e proceso de instalación habitual.

Si bien Maxima es el motor matemático, a la hora de trabajar con el programa es más fácil hacerlo con el interfaz Wxmaxima, que es el que habitualmente se utiliza, aunqu hay otros.

A continuación se muestra una captura de Wxmaxima:

Aunque también es posible trabajar desde un terminal de texto, el interfaz gráfico hace las cosas más sencillas, presentando los resultados matemáticos de manera que se interpreten mejor.

¿Qué es Maxima?

Maxima es un programa de Matemáticas que tiene una larga historia. Nació como proyecto de investigación en el Instituto Tecnológico de Massachussets en el año 1969.

Con Maxima se puede hacer cualquier tipo de cálculo, desde el más sencillo que se enseña en las escuelas, hasta el más complejo que se pueda necesitar a nivel universitario, industrial o de investigación.

Hoy en día, Maxima es un proxecto de software libre que cualquier persona puede utilizar y distribuir.

La página del proyecto se encuentra en http://maxima.sf.net. Allí se puede encontrar toda la información relevante asociada al programa.

Sólo a modo introductorio, veamos algunas cosas que puede hacer el programa:

Calculamos una operación combinada con fracciones:

(%i1) (2/3 - 5/8) * (5^3/4 + 1/17) + 7 ;
                                     13553
(%o1)                                -----
                                     1632

Resolvemos una ecuación:

(%i2) solve(3*x - 5/8 + (x-8)/9 = (12 - x)/3 );
                                        397
(%o2)                              [x = ---]
                                        248

Factorizamos un polinomio:

(%i3) factor(x^6-10*x^5+x^4+304*x^3-1288*x^2+2080*x-1200);
                                  2        3
(%o3)                      (x - 5)  (x - 2)  (x + 6)

Multiplicamos polinomios:

(%i4) expand( (a+b^2)*(a-b+c) );
                        2            3      2          2
(%o4)                  b  c + a c - b  + a b  - a b + a

Calculamos los 500 primeros decimales del número π:

(%i5) (fpprec:500, bfloat(%pi));
(%o5)  3.141592653589793238462643383279502884197169399375105820974944592307816\
406286208998628034825342117067982148086513282306647093844609550582231725359408\
128481117450284102701938521105559644622948954930381964428810975665933446128475\
648233786783165271201909145648566923460348610454326648213393607260249141273724\
587006606315588174881520920962829254091715364367892590360011330530548820466521\
384146951941511609433057270365759591953092186117381932611793105118548074462379\
9627495673518857527248912279381830119491b0

Derivamos una función:

(%i6) diff(sin(x^2), x);
                                           2
(%o6)                             2 x cos(x )

Calculamos una integral:

(%i7) integrate(2*x*cos(x^2), x);
                                         2
(%o7)                              sin(x )

Ya por último, dibujamos una superficie en el espacio:

draw3d(
  xu_grid = 100,
  yv_grid = 50,
  color = white,
  explicit(exp(-x^2-y^2),x,-2,2,y,-2,0) )$