# INTRODUCCIÓN A wxMAXIMA

La hoja de trabajo de este programa se compone de celdas. Las hay de 3 tipos:

    → De Texto: Para incluir las explicaciones
    → De Input: Para los comandos, programas y/o funciones que se desean ejecutar
    → De Output: Dónde aparecen los resultados obtenidos 

Para insertar una celda se puede emplear el ratón (clic botón izquierdo) o el menú de la barra de herramientas superior. Para cambiar el formato del texto:

                                        EDITAR → CONFIGURAR (o PREFERENCIAS) → ESTILO

En las celdas Input se pueden incluir comentarios introduciéndolos de la siguiente forma: "texto"
Este primer bloque es un ejemplo de celda de texto

"Esto es un ejemplo de comentario";

## CELDAS DE TÍTULO Y DE SECCIÓN

Son las celdas de texto que usaremos para diseñar y/o organizar nuestra hoja de trabajo. Cada una de ellas tiene una utilidad: 
    → De título: Para empezar la hoja de trabajo. En nuestro caso:  "INTRODUCCIÓN A wxMAXIMA"
    → De secciones: Son los diferentes "capítulos" en los que se divide la hoja de trabajo
    → De subsecciones: Son los subapartados que puede tener cada sección

## CELDAS DE TEXTO

Son las celdas que nos van a permitir incluir las explicaciones de lo que vayamos haciendo. Son, por tanto, fundamentales para que obtener una fácil comprensión de la hoja de trabajo desarrollada. 

En esta hoja de trabajo todas las celdas de texto se han puesto con un fondo de color mediante:

                                        EDITAR → CONFIGURAR (o PREFERENCIAS) → ESTILO

Esto es un ejemplo de celda de texto

## CONSTANTES

Las principales constantes matemáticas que más utilizaremos en secundaria las deberemos escribir de la siguiente forma:
                                        π → %pi             e → %e          i → %i          γ → %gamma          Φ → %phi

Los valores lógicos los escribiremos:

                                        Verdadero → true        Falso → false

Expresaremos los infinitos reales de la siguiente forma:

                                        +∞ →inf         -∞ → minf

Y, por último, en el cálculo de límites:

                                        límite acotado indeterminado → ind
                                        límite indefinido → und
                                        Infinitesimal positivo → zeroa
                                        Infinitesimal negativo → zerob

## FUNCIONES MATEMÁTICAS BÁSICAS Y OPERADORES ARITMÉTICOS

### Operadores aritméticos

Los principales operadores aritméticos se deberán escribir como aparecen en la siguiente figura que se ha insertado a través del menú "celda" de la barra de herramientas

Operadores aritméticos

Como ejemplo de aplicación vamos a utilizar las celdas de Input (%i...) y de Output (%o...):

        Escribimos la operación utilizando los operadores anteriores
        Al final de la operación deberemos poner
            → Punto y coma (;) si querermos que se vea el resultado de la operación
            → Símbolo del dolar ($) si no queremos que se vea el resultado de la operación

        Pulsando MAYÚSCULAS + INTRO (o menú de la barra de herramientas) vemos el resultado

4^3+(3*5)-64/4;
sqrt(458);
25!;
3*(x^4+5)/(2-x);

            → Si el resultado es un número decimal, el resultado aproximado se puede obtener añadiendo "numer"

sqrt(486),numer;
3/4,numer;
4/3,numer;

            → Para expresar el resultado en notación científica deberemos escribir delante de la operacion "bfloat"

bfloat(25^85);
bfloat(sqrt(85000));

            → El resultado debe interpretarse de la siguiente forma: 
                    El número que hay delante de cada "b" está multiplicado por 10 elevado a lo que aparece después. 
                                    - En el primer ejemplo, 10 elevado a 118
                                    - En el segundo ejemplo, 10 elevado a 2.

            → Los operadores "asignación"(:) y "definición de funciones"(:=), los veremos en la sección 5
            → Para evaluar los operadores relacionales se puede utilizar la orden "is( )", de forma que se obtendrá:
                                    - "true", si es verdad
                                    - "false", si es falso

is(3<2);
is(4500>2405);

### Funciones matemáticas básicas

### Con números naturales

Las principales funciones con números naturales son:
        random(n) → Obtiene un número pseudoaleatorio entre 0 y n-1
        factorial(n) ó n! → Calcula el factorial de n
        binomial(n,m) → Obtiene el número combinatorio n sobre m

random(56);
factorial(45);
45!;
binomial(5,3);

### Con números reales

Con números reales
        random(x) → Número pseudoaleatorio no negativo y menor que x (con x decimal positvo)
        exp(x) → Exponencial de base el número e
        log(x) → Logaritmo neperiano de x
        abs(x) → Valor absoluto de x
        entier(x) → Parte entera de x
        signum(x) → Signo de x
        max(x1, x2,..., xn)→ El valor máximo de x1, x2,..., xn
        min(x1, x2,..., xn)→ El valor mínimo de x1, x2,..., xn

random(3.456);
exp(4.5);
log(2.4567);
abs(-47);
entier(3.675);
signum(-47);
max(3,6,2,9);
min(3,6,2,9);

### Con la trigonometría

Para trabajar con la trigonometría:
        sin(x), cos(x), tan(x) → seno, coseno y tangente (en radianes)
        csc(x), sec(x), cot(x) → cosecante, secante y cotangente (en radianes)
        asin(x), acos(x), atan(x) → arco seno, arco coseno y arco tangente

sin(5*%pi/4);
cos(5*%pi/4);
tan(5*%pi/4);
asin(1/2);
acos(1/2);

### Con números complejos

Para introducir el número complejo:
        En forma binómica (a+bi) → a+b*%i
        En forma polar (rexp(iα)) →r*%e^(%i*α)

Los cálculos que se pueden hacer:
        abs(z) → Módulo del complejo z
        carg(z) → Argumento del número complejo z
        conjugate(z) → Conjugado del número complejo z
        imagpart(z) → Parte imaginaria del número complejo z
        realpart(z) → Parte real del número complejo z
        polarform(z) → Forma polar del complejo dado en binómica
        rectform(z) → Forma binómica del complejo dado en polar

"Número complejo en forma binómica";
z1:3+3*%i;
abs(z1);
carg(z1);
conjugate(z1);
imagpart(z1);
realpart(z1);
polarform(z1);

"Número complejo en forma polar";
z2:3*%e^(%i*%pi/3);
abs(z2);
carg(z2);
conjugate(z2);
imagpart(z2);
realpart(z2);
rectform(z2);

### Con expresiones algebraicas

Si trabajamos con polinomios:
        factor(expr) → Obtiene la factorización del polinomio
        expand(expr) → Obtiene el polinomio 
        gcd(expr1, expr2, ..., var1, var2, ...) → Obtiene el mcd de los polinomios
        lcm(expr1, expr2, ..., var1, var2, ...) → Obtiene el mcm de los polinomios

factor(x^3-5*x^2-x+5);
expand((x-2)*(x^2-9)+(x^3+2*x-5));
gcd(x^2+2*x+1,x^2-1,x);
lcm(x^2+2*x+1,x^2-1,x);

Si trabajamos con fracciones algebraicas:
        ratsimp(expr, var) → Obtiene la fracción simplificada
        partfrac(expr, var) → Descompone una fracción en suma de fracciones

ratsimp((x^3+5*x^2-x-5)/(x^4-2*x^3-x^2+2*x));
partfrac((x^4-7*x^3+2*x^2+3*x+50)/(x^4-11*x^3+32*x^2-22*x+60),x);

## DEFINICIÓN DE FUNCIONES POR EL USUARIO

### Primera forma 

Para definir una función se pueden utilizar:
                El operador ":" para asignar un valor numérico a una constante
                El operador ":=" para definir una función particular

"Función con una variable"$
f(x):= a*x^3+b*x^2+c*x+d; 

"Función con dos variables"$
g(x,y):=k*cos((%pi*y)/x)+m*sin((%pi*x)/y);

"Función definida a trozos"$
h(x):= if x<=3 then x^2+4 else 3-x^3;

La función h(x) se compone de dos trozos. El primero es un polinomio de segundo grado para x <= 3, y el segundo es otro polinomio de grado 3, para x > 3

Función h(x)

### Segunda forma 

En este caso, para definir una función se puede utilizar: define(func, expr)

define(f2(x),5*x^3+2*x^2-5);
define(g2(x,y),4*sin((%pi*x)/y)+2*cos((%pi*y)/x));
define(h2(x),if x>2 then x^5+4 else log(x));

## LISTAS

Consisten en conjuntos ordenados de objetos. Para definirlos introducimos entre corchetes los objetos que vamos a usar separados por comas. Los elementos de la lista pueden ser cualquier cosa, incluso otra lista

### Creación de listas

Una forma básica sería crear una lista "a mano". Es decir, introduciendo uno a uno todos los elementos

lista1:[4,2,"barco",5,7,[2,4,5],-5, 9,"casa",0,-1];

Pero también se pueden utilizar los siguientes comandos:
        makelist(expr, var, n, m) → Construye una lista dando valores a la variable desde n hasta m
        create_list(expr, var1, lista1, var2, lista2, ...) → Crea listas usando como variables otras listas

lista2: makelist(x^2-3,x,-2,5);
lista3: makelist(x^3,x,[1,6,-2,p,4]);
    x[1]:2$ x[n]:=(3+(x[n-1])^2)$
lista4: makelist((n,x[n]),n,1,5);
lista5: create_list([n^3-4,m],n,2,3,m,[3,8]);
    x(n):=1/n$ p(x):=x^2$
lista6: create_list((x(n),p(x(n))),n,1,5);

### Manipulación de listas

A partir de una lista, podemos utilizar:
        lista[k] → Se obtiene el término k-ésimo de la lista
        sort(lista, p) → Ordena los elementos de la lista según la condición p
        length(lista) → Indica la longitud de la lista
        unique(lista) → Elimina los elementos repetidos de la lista
        flatten(lista) → unifica las sublistas en una lista

lista1[3];
lista3[4];
sort(lista2,"<");
length(lista5);
unique(lista2);
sort(lista6,">");
flatten(lista5);

Si tenemos varias listas, serán útiles:
        append(lista_A, lista_B, lista_C, ...) → Añade a la lista_A el resto de listas
        join(lista_A,lista_B) → Crea una nueva lista con los elementos alternados de las lista_A y lista_B

lista7: append(lista2,lista3);
lista8: join(lista4,lista5);

## EVALUACIÓN DE FUNCIONES

### Evaluación sobre listas

Para evaluar una función f(x) en x = a hay que ejecutar f(a). Como se vio en el apartado 5.
Sin embargo, las funciones pueden trabajar sobre listas, devolviéndo una lista con la imagen de cada elemento de la lista inicial

f2(x); "ver apartado 5.1"$
f2(1); f2(4);
lista9:[1,4,-3,6,8];
f2(lista9);

### Con funciones específicas

La evaluación se puede realizar con los siguiente funciones:
        ev(expr, arg1, arg2, arg3, ...) → Aplica los argumentos sobre las variables que aparecen en expr
        map(f,expr_1, expr_2, expr_3) → Aplica f sobre cada una de las expresiones 
        subst(a,b,c) → Sustituye la expresión a por la b en la expresión c

ev(3*x^2+5*y^3-4*z,x:a+b,y:5+c,z:3);

En este primer ejemplo se han sustituido las variables x, y z de la función por a+b, 5+c y 3, respectivamente

f(x,y,z):=2*exp(x)+5*log(y)-7*sin(z)$
map(f,[1,2],[a,b],[c,d]);

En este segundo ejemplo, se han sustituido cada variable por dos valores diferentes

subst(x^2+4,x,sin(x)+cos(x));

En este tercer ejempo, se ha sustituido la variable x por otra función polinómica de grado 2

### Con los operadores comillas

El operador "comilla simple" (') inhibe la evaluación de la función, aunque sus argumentos si son evaluados
El operador "doble comilla" ('') permite que las variables de la expresión sean sustituidas por sus valores

x0:2$
x1:8$
A:2$
B:-5$
integrate((A*x^3+B),x,x0,x1)$
'integrate((A*x^3+B),x,x0,x1);
''integrate((A*x^3+B),x,x0,x1);

## VECTORES Y MATRICES

### Vectores

Un vector es una lista en la que sus elementos son sus coordenadas. 

v1:[1,-2,4,0];
v2:[3,5,-2,-1];

Las operaciones que podemos realizar con vectores son:
        Suma y/o resta → Con los operadores + ó -
        Producto escalar → Con el operador . (no con *)
        Producto de un escalar por un vector → Con el operador * (no con .)
        Módulo de un vector → Realizando la operación sqrt(v.v)

v1+v2;
v1.v2;
5*v2;
modulo(v):=sqrt(v.v)$
modulo(v1);

### Matrices

Es una estructura que se obtiene con listas de igual longitud. 
Por tanto, una manera de contruir una matriz sería:
                    matrix([a11, a12, a13, ...],[a21, a22, a23, ...],...,[an1, an2, an3, ...])
Cada una de esas listas se correponde con una fila de la matriz.

Pero también se puede utilizar la barra de herramientas y utilizar "generar matriz"

A:matrix([1,5,4],[0,-1,3],[2,2,0]);

B:matrix([0,1,3],[-2,-5,1],[1,0,1]);

C:matrix([1,1,1],[2,0,1],[0,3,1]);

Entre las funciones que podemos utilizar, podemos destacar:
        rank(matriz) → Calcula el rango de la matriz
        determinant(matriz) → Calcula el determinante de la matriz (si fuera cuadrada)
        invert(matriz) → Obtiene la inversa de la matriz inicial (si ésta es cuadrada)
        transpose(matriz) → Obiene la matriz traspuesta de la inicial
        adjoint(matriz) → Obtiene la matriz de adjuntos asociada a la matriz inicial
        matrix_size(matriz) → Indica las dimensiones de la matriz
        addcol(matriz, lista1, lista2,...) → Añade a la derecha, lista1, lista2, ... como columna a la matriz inicial
        addrow(matriz, lista1, lista2,...) → Añade en la base de la matriz inicial, lista1, lista2, ... como filas 

[rank(A), rank(B), rank(C)];

[determinant(A), determinant(B), determinant(C)];

[invert(A), invert(B),invert(C)];

[transpose(A), transpose(B),transpose(C)];

[adjoint(A), adjoint(B), adjoint(C)];

Para añadir filas y columnas a una matriz dada:

addrow(A,[1,3,4]);

addcol(A,[1,1,2]);

Para operar con matrices:

A+B;

2*A;

A.B; "Se ha utilizado el . en lugar de *";

Cargando el paquete "eigen"

load(eigen);

M:matrix([2,1,1],[2,3,2],[3,3,4]);

Triangularizar una matriz:

triangularize(M);

Obtener el polinomio característico:

C(x):=charpoly(M,x)$
expand(C(x));

Obtener los autovalores asociados, con sus multiplicidades:

eigenvalues(M);

Obtener los autovectores asociados:

eigenvectors(M);

Obtiene la ortogonalización de Gramschmidt:

gramschmidt(M);