# Curso del Profesor David López Medina con el que puedes 
aprender los comandos básicos estructurados por temas. 

## Álgebra lineal

### Vectores

Definición: v=(2,-3), w=(1,2)

v:[2,-3];
w:[1,2];

Componentes: v_2

v[2];

Suma: v+w

v+w;

Producto por escalares: -3·v

-3*v;

Producto escalar: v·w

v.w;

Norma: ||v||

sqrt(v.v);

### Matrices

Definición: A=(1 2), B=(0  1), C=(1 2 3)
              (3 4)    (-2 1)    (4 5 6)
                                 (7 8 9)

A:matrix([1,2],[3,4]);
B:matrix([1,1],[-1,1]);
C:matrix([1,2,3],[4,5,6],[7,8,9]);

Coeficientes: c_{2,3}

C[2][3];

Suma: A+B

A+B;

Producto por escalares: 3·A

3*A;

Producto: A·B (OJO: no es A*B)

A.B;
A*B;

Matriz por vector: A·v

A.v;

Traspuesta: A^t

transpose(A);

Inversa: A^-1 (OJO: no es A^-1)

invert(A);
A^-1;

Determinante: |A|

determinant(A);

Rango: rg(C)

rank(C);

Núcleo: Ker(C)

nullspace(C);

args(%);

Imagen: Im(C)

columnspace(C);
args(%);

### Sistemas lineales

SCD: x+y=2,2x+3y=2

linsolve([x+y=2,2*x+3*y=2],[x,y]);

SI: x+y=2,2x+2y=2

linsolve([x+y=2,2*x+2*y=2],[x,y]);

SCI (solución paramétrica): x+y=2,2x+2y=4

linsolve([x+y=2,2*x+2*y=4],[x,y]);

SCI (solución implícita): x+y=2,2x+2y=4

linsolve_params:false$
linsolve([x+y=2,2*x+2*y=4],[x,y]);

### Diagonalización

Polinomio característico: p_A(x)

charpoly(A,x);

expand(%);

Autovalores: lambda_i

eigenvalues(A);

solve(charpoly(A,x),x);

Autovectores: v_i

eigenvectors(A);

## Cálculo

### Cálculo diferencial

Límites finitos: lim(x->0) sen x/x

limit(sin(x)/x,x,0);

Límites infinitos: lim(x->-inf) (2x-1)^3/(x^2+1)

limit((2*x-1)^3/(x^2+1),x,-inf);

Series numéricas: sum 1/n^2

simpsum;
sum(1/n^2, n, 1, inf);
simpsum:true;
sum(1/n^2, n, 1, inf);
reset(simpsum)$

Derivadas: d^3 sin 2xy/dx^3

diff(sin(2*x*y),x,3);

Jacobiana: J(x+y^2,sin(x·y),x^y)

jacobian([x+y^2,sin(x*y),x^y],[x,y]);

Hessiana: H(sin(x+2y))

hessian(sin(x+2*y),[x,y]);

Taylor: sin x/x, n=10, x0=0

taylor(sin(x)/x,x,0,10);

ratdisrep(%);

powerdisp;
powerdisp:true$
ratdisrep(taylor(sin(x)/x,x,0,10));
powerdisp:false$
ratdisrep(taylor(sin(x)/x,x,0,10));

### Cálculo integral

Primitiva: int x/(x^3-2x^2+1)

integrate(x/(x^3-2*x^2+1),x);

Definida: int[0,pi] cos^2 x

integrate(cos(x)^2,x,0,%pi);

Impropia: int[-inf,inf] e^(-x^2/2)

integrate(exp(-x^2/2),x,-inf,inf);

rootscontract(%);

### Cálculo vectorial

Gradiente: grad x·y^2·sin(z)

load(vect)$
express(grad(x*y^2*sin(z)));

ev(%,diff);

Divergencia: div (x,z·y^2,sin(x+z))

express(div([x,z*y^2,sin(x+z)]));
ev(%,diff);

Rotacional: rot (x^2,y^3,z)

express(curl([x^2,y^3,z]));
ev(%,diff);

Laplaciano: lap x·y^2

express(laplacian(x*y^2));
ev(%,diff);

## Variable compleja

### Operaciones

Definición: z=1+i, omega=2·e^(pi·i/6) (OJO: Im z antes de Re z)

z:1+%i;
%omega:2*exp(%pi*%i/8);

powerdisp:true$
z;

Operaciones: z+omega, z*omega

z+%omega;
z*%omega;

Parte real: Re(omega)

realpart(%omega);

Parte imaginaria: Im(omega)

imagpart(%omega);

Forma binómica: Re(omega)+i·Im(omega)

rectform(%omega);

Módulo: |z|

abs(z);

Argumento: arg(z)

carg(z);

Forma exponencial: |z|·e^(i·arg(z))

polarform(z);

Conjugado: z^*,omega^*

conjugate(z);
conjugate(%omega);

### Series

Definición: f(z)=(z+1)/(z^3+4z^2-3z-18) (OJO: z definido)

f(z):=(z+1)/(z^3+4*z^2-3*z-18)$
f(z);

kill(z)$
f(z):=(z+1)/(z^3+4*z^2-3*z-18)$
f(z);

Numerador: p(z)

num(f(z));

Denominador: q(z)

denom(f(z));

Singularidades: q(z)=0

solve(denom(f(z)),z);

factor(denom(f(z)));

Serie de potencias: f(z), z0=0

powerseries(f(z),z,0);

niceindices(%);

Serie de Laurent: f(z), z0=-3

niceindicespref;
niceindicespref:[n,m]$
niceindices(powerseries(f(z),z,-3));

Residuo: Res(f,2)

residue(f(z),z,2);

## Ecuaciones diferenciales

### EDO de primer orden

Separadas: y'=sen x/sqrt(y)

ode2('diff(y,x)=sin(x)/sqrt(y),y,x);

Lineales: y'=y/x+1, y(1)=3

ode2('diff(y,x)=y/x+1,y,x);

ic1(%,x=1,y=3);

Homogéneas: y'=(x+y)/(2x+y)

ode2('diff(y,x)=(x+y)/(2*x+y),y,x);

Factor integrante: y'=(4x^3-y)/(2x-x^4/y)

ode2('diff(y,x)=(4*x^3-y)/(2*x-x^4/y),y,x);

### EDO de segundo orden

Coeficientes constantes: y''+2y'+2y=sen x

ode2('diff(y,x,2)+2*'diff(y,x)+2*y=sin(x),y,x);

Condiciones iniciales: y''+2y'+2y=sen x, y(pi/2)=3, y'(pi/2)=5

ic2(%,x=%pi/2,y=3,'diff(y,x)=5);

Condiciones frontera: y''+2y'+2y=sen x, y(0)=-2/5, y(pi)=2/5

bc2(ode2('diff(y,x,2)+2*'diff(y,x)+2*y=sin(x),y,x),x=0,y=-2/5,x=%pi,y=2/5);

Euler: x^2·y''+x·y'+y=1, y(1)=3, y'(1)=-2

ode2(x^2*'diff(y,x,2)+x*'diff(y,x)+y=1,y,x);
ic2(%,x=1,y=3,'diff(y,x)=-2);

### Transformada de Laplace

Transformada: L(log(x))

laplace(log(x),x,z);

Heaviside: L(H_2)

laplace(unit_step(x-2),x,z);

Transformada inversa: L^-1((z-1)/(z^3+z))

ilt((z-1)/(z^3+z),z,x);

Ecuaciones lineales: y1'=y1+y2, y2'=y1-y2, y1(0)=2, y2(0)=3

desolve(['diff(y1(x),x)=y1(x)+y2(x),'diff(y2(x),x)=y1(x)-y2(x)],[y1(x),y2(x)]);

atvalue(y1(x),x=0,2)$
atvalue(y2(x),x=0,3)$
desolve(['diff(y1(x),x)=y1(x)+y2(x),'diff(y2(x),x)=y1(x)-y2(x)],[y1(x),y2(x)]);

## Cálculo numérico

### Aritmética

Coma flotante: sqrt(2)

sqrt(2);
sqrt(2.0);

float(sqrt(2));

Calculadora: sqrt(2)+pi/3+e^2

sqrt(2)+%pi/3+%e^2;
numer:true$
sqrt(2)+%pi/3+%e^2;

Precisión baja: sqrt(2), N=6 (OJO: doble precisión interna)

fpprintprec:6$
sqrt(2);
sqrt(2)^2-2;

Precisión alta: 1/3, N=50 (OJO: numer lo anula)

reset(fpprintprec)$
fpprec:50$
bfloat(1/3);
numer:false$
bfloat(1/3);

Tiempo de CPU: sum(n=1,25000) 1/n^2

showtime:true$
sum(1/n^2,n,1,25000);
showtime:false$

### Factorizaciones

LU: (0  1 2)
    (1  1 3)
    (-1 0 5)

lu_factor(matrix([0,1,2],[1,1,3],[-1,0,5]));
get_lu_factors(%);

Cholesky: (4   2 -2)
          (2   3 -3)
          (-2 -3 14)

cholesky(matrix([4,2,-2],[2,2,-3],[-2,-3,14]));

### Ecuaciones no lineales

Bisección: cos(x)=x, [a,b]=[0,1]

find_root(cos(x)=x,x,0,1);

Newton: cos(x)=x, x0=0

load(mnewton)$
mnewton(x-cos(x),x,0);

Newton: x+cos(y)=2,y+sin(x)=3, (x0,y0)=(0,0) (OJO: y depende de x)

mnewton([x+cos(y)-2,y+sin(x)-3],[x,y],[0,0]);

diff(y,x);
kill(y)$
diff(y,x);
mnewton([x+cos(y)-2,y+sin(x)-3],[x,y],[0,0]);

### Interpolación

Lagrange: p(0)=1, p(2)=-1, p(3)=0

load(interpol)$
lagrange([[0,1],[2,-1],[3,0]]);
expand(%);

### Cuadratura

Cuadratura: int[0,1] exp(-x^2/2)/sqrt(2·pi)

quad_qags(exp(-x^2/2)/sqrt(2*%pi),x,0,1);

### Ecuaciones diferenciales

Runge-Kutta: y1''=-y1/(y1^2+y2^2)^(3/2), y2''=-y2/(y1^2+y2^2)^(3/2), y1(0)=1, y2(0)=0, y1'(0)=0, y2'(0)=1, T=2*pi

rk([y3,y4,-y1/(y1^2+y2^2)^(3/2),-y2/(y1^2+y2^2)^(3/2)],
  [y1,y2,y3,y4],
  [1,0,0,1],
  [t,0,2*%pi,0.1]
);

last(%);

## Gráficas

### Funciones en 2-D

Una: y=sen x en [0,2·pi]

plot2d(sin(x),[x,0,2*%pi])$

Varias: y=sen x, y=cos x, y=tg x en [-2·pi,2·pi] (OJO: asíntotas)

plot2d([sin(x),cos(x),tan(x)],[x,-2*%pi,2*%pi])$

plot2d([sin(x),cos(x),tan(x)],[x,-2*%pi,2*%pi],[y,-2,2])$

Poligonal: y=sen x en [0,2·pi]

l:makelist(2*%pi*n/10,n,0,10);
plot2d([discrete,l,sin(l)])$

Puntos: y=sen x en [0,2·pi]

plot2d([discrete,l,sin(l)],
  [style,points]
)$

Paramétricas: Círculo (OJO: escalas distintas, picos)

plot2d([parametric,cos(t),sin(t)],[t,0,2*%pi])$

plot2d([parametric,cos(t),sin(t)],[t,0,2*%pi],
  [gnuplot_preamble, "set size ratio 1;"]
)$

plot2d([parametric,cos(t),sin(t)],[t,0,2*%pi],
  [nticks,100],
  [gnuplot_preamble, "set size ratio 1;"]
)$

### Superficies en 3-D

Superficie: z=2^(-x^2+y^2) en [-3,3]x[-2,2]

plot3d(2^(-x^2+y^2),[x,-3,3],[y,-2,2])$

Perspectiva: z=2^(-x^2+y^2) en [-3,3]x[-2,2]

plot3d(2^(-x^2+y^2),[x,-3,3],[y,-2,2],
  [azimuth,0],
  [elevation,90]
)$

Malla: z=2^(-x^2+y^2) en [-3,3]x[-2,2]

plot3d(2^(-x^2+y^2),[x,-3,3],[y,-2,2],
  [palette,false]
)$

Cilíndicas: Cono

plot3d(r,[r,0,1],[theta,0,2*%pi],
  [transform_xy,polar_to_xy]
)$

Esféricas: Casquete esférico

plot3d(1,[theta,0,2*%pi/3],[phi,0,2*%pi],
  [transform_xy,spherical_to_xyz]
)$

### Campos de direcciones

Ecuación: y'=(y^2-1) (OJO: ejes excesivos)

load(plotdf)$
plotdf(y^2-1)$

plotdf(y^2-1,
  [xradius,3],
  [yradius,3]
)$

Sistema: y1'=y2, y2'=-y1

plotdf([y,-x])$

Trayectoria: y''-(1-y^2)·y'+y=0

plotdf([y,(1-x^2)*y-x],
  [xradius,5],
  [yradius,5],
  [trajectory_at,2,0],
  [direction,forward]
)$

### Animaciones

EDO: y''+y=sen omega·x, y(0)=y'(0)=0 (OJO: omega definido)

ic2(ode2('diff(y,x,2)+y=sin(%omega*x),y,x),x=0,y=0,'diff(y,x)=0);

kill(%omega)$
ic2(ode2('diff(y,x,2)+y=sin(%omega*x),y,x),x=0,y=0,'diff(y,x)=0);

l:makelist(1+i/20,i,20,1,-1);
with_slider(
  %omega,
  l,
  (%omega*sin(x))/(%omega^2-1)-sin(%omega*x)/(%omega^2-1),
  [x,-10*%pi,10*%pi],
  [y,-15,15]
)$

Direcciones: y1'=y2, y2'=-a·y1

plotdf(
  [y,-2^b*x],
  [sliders,"b=-2:2"]
)$

### Gráficos avanzados

Implícitas: x^2+4y^2=4

load(draw)$
draw2d(implicit(x^2+4*y^2=4,x,-2.5,2.5,y,-1.5,1.5))$

Paramétricas: banda Moëbius (OJO: plano visible)

draw3d(
  xu_grid=50,
  yv_grid=25,
  parametric_surface(cos(a)*(3+b*cos(a/2)),sin(a)*(3+b*cos(a/2)),b*sin(a/2),
    a,-%pi,%pi,b,-1,1)
)$

draw3d(
  xu_grid=50,
  yv_grid=25,
  parametric_surface(cos(a)*(3+b*cos(a/2)),sin(a)*(3+b*cos(a/2)),b*sin(a/2),
    a,-%pi,%pi,b,-1,1),
  surface_hide=true
)$

Regiones: Circunferencia inscrita

draw2d(
  x_voxel=200,
  y_voxel=200,
  region(abs(x)+abs(y)<1 and x^2+y^2>0.49,x,-1.5,1.5,y,-1.5,1.5)
)$

Rellenos: f(x)=2-3·x^2, g(x)=sqrt(1-x^2/4)

draw2d(fill_color=grey,
  filled_func=2-3*x^2,
  explicit(sqrt(1-x^2/4),x,-0.59,0.59),
  filled_func=false,
  line_width=2,
  color=red,
  explicit(2-3*x^2,x,-sqrt(2/3),sqrt(2/3)),
  color=blue,
  explicit(sqrt(1-x^2/4),x,-1,1)
)$

Vectores: f(x)=x^2, x=1

draw2d(explicit(x^2,x,-2,2),
  line_width=2,
  color=red,
  explicit(1+2*(x-1),x,-2,2),
  color=black,
  point_size=3,
  point_type=filled_circle,
  points([[1,1]]),
  line_width=1,
  head_length=0.1,
  vector([1.5,0.5],[-0.4,0.4]),
  label(["punto de tangencia",1.5,0.3]),
  xtics={["x",1]},
  ytics_rotate=true,
  ytics={["f(x)",1]},
  grid=true,
  title="recta tangente"
)$

Contornos: e^(-x^2-y^3/100)

draw3d(color=gray,
  explicit(exp(-x^2-y^3/100),x,-1,1,y,-4,4),
  yv_grid=10,
  contour_levels=10,
  contour=both,
  surface_hide=true
)$

Múltiples: f(x)=1,x,x^2,x^3

multiplot_mode(screen)$
draw2d(
  title="Constante",
  allocation=[[0,1/2],[1/2,1/2]],
  xtics=none,
  ytics=none,
  explicit(1,x,-1,1)
)$
draw2d(
  title="Recta",
  allocation=[[1/2,1/2],[1/2,1/2]],
  xtics=none,
  ytics=none,
  explicit(x,x,-1,1)
)$
draw2d(
  title="Parabola",
  allocation=[[0,0],[1/2,1/2]],
  xtics=none,
  ytics=none,
  explicit(x^2,x,-1,1)
)$
draw2d(
  title="Cubica",
  allocation=[[1/2,0],[1/2,1/2]],
  xtics=none,
  ytics=none,
  explicit(x^3,x,-1,1)
)$
multiplot_mode(none)$

## Programación

### Bucles

For: 10! (OJO: bucle no sale por pantalla)

x:1;
for n:1 thru 10 do x:x*n;

x:1;
for n:1 thru 10 do (
  x:x*n,
  disp(x)
)$

While: 10!

x:1$
n:0$
while (n<10) do (
  n:n+1,
  x:x*n,
  disp(x)
)$

### Condicionales

If: Fibonnacci

f(n):=if (n=1 or n=2) then (1) else (f(n-2)+f(n-1))$
for n:1 thru 10 do disp(f(n))$

### Salida por pantalla

Evaluada: x

x;

disp(x)$

No evaluada: x

'x;
disp('x)$

Nominal: x

display(x)$

Compuesta: x

print("La variable ",'x," vale 10!=",x)$

### Funciones

Sencillas: f(x,y)=(x,sin(y),H(sin(x+y)) (OJO: (x,y) definido)

kill(x,y)$
f(x,y):=[x,sin(y),hessian(sin(x+2*y),[x,y])]$
f(x,y);

Procedimientos: sum(i=1...n) i, n! (OJO: variable globales)

f(n):=block(
  a:0,
  x:1,
  for i:1 thru n do print('sum(j,j,1,i),"=",a:a+i,", ",i,"!=",x:x*i)
)$

f(5)$

a;
x;
kill(a,x)$
a;
x;

f(n):=block([a,x],
  a:0,
  x:1,
  for i:1 thru n do print('sum(j,j,1,i),"=",a:a+i,", ",i,"!=",x:x*i)
)$

f(5)$

x;
a;

### Ejemplos prácticos

LU(A,[no_output]): Factorización LU de una matriz cuadrada A (con output paso a paso opcional)

LU(A,[no_output]):=block([n,L,U,l,u,e], /*Variables bloqueadas*/
local(l,u,e), /*Vectores locales*/
globalsolve:true, /*Parámetro de la función linsolve para asignar la solución*/
n:matrix_size(A)[1], /*Dimensión de la matriz A*/
for i:1 thru n do 
  (
  for j:1 thru n do (
    if i>j then u[i,j]:0 else if i=j then l[i,j]:1 else l[i,j]:0 /*Coeficientes de L y U conocidos*/
    )
  ),
L:genmatrix(l,n,n),U:genmatrix(u,n,n), /*L y U antes de empezar*/
if emptyp(no_output)=true then print("Sistema original: ",L,".",U,"=",A), /*Salida por pantalla (condicional)*/ 
for i:1 thru n do 
  (
  for j:1 thru n do
    (
    e[i,j]:sum(l[i,k]*u[k,j],k,1,min(i,j))=A[i][j], /*Cada ecuación*/
    linsolve(e[i,j],if i>j then l[i,j] else u[i,j]), /*Solución de cada ecuación*/
    if emptyp(no_output)=true then ( /*Salida por pantalla (condicional)*/ 
      print(""), /*Una línea en blanco*/
      print("Ecuación fila ",i," columna ",j,":",e[i,j],
", Solución:",if i>j then 'l[i,j]=l[i,j] else 'u[i,j]=u[i,j]), /*Ecuaciones por orden*/
      print("Sistema actualizado: ",L:genmatrix(l,n,n),".",U:genmatrix(u,n,n),"=",A) /* Sistema actualizado*/
      )
 )
  ),
globalsolve:false, /*Parámetro de la función linsolve para no asignar la solución*/
L:genmatrix(l,n,n),U:genmatrix(u,n,n), /*L y U definitivas*/
[L,U] /*Salida de la función*/
)$

LU(matrix([4,2,-2], [2,2,-3],[-2,-3,14]))$

construye_regla(c,[no_output]): Coeficientes y error de una regla de cuadratura (con output paso a paso opcional)

construye_regla(c,[no_output]):=block([A,X,E,B,b,C,p,n], /*Variables bloqueadas*/
local(b), /*Vectores locales*/
globalsolve:true, /*Parámetro de la función linsolve para asignar la solución*/
powerdisp:true, /*Parámetro para ordenar los subíndices de menor a mayor*/
n:length(c), /*Dimensión del sistema*/
A:transpose(vandermonde_matrix(c)), /*Matriz del sistema*/
X:makelist(b[i],i,1,n), /*Vector de coeficientes */
for i:1 thru n do e[i]:A[i].X=1/i, /*Cada ecuación del sistema*/
E:makelist(e[i],i,1,n), /*Vector de ecuaciones*/
B:linsolve(E,X), /*Solución del sistema*/
C:0,
for i:n while(is(equal(C,0))) do (
  p:i, /*Orden*/
  C:expand((1/(p+1)-sum(b[i]*c[i]^p,i,1,n))/p!) /*Constante de error*/
  ),
if emptyp(no_output)=true then ( /*Salida por pantalla (condicional)*/ 
  print("El sistema es ",transpose(E)),
  powerdisp:false, /*Parámetro para escribir (b-a) y no (-a+b)*/
  print("Los coeficientes son ",B," y ",makelist(a[i]=('b-'a)*b[i],i,n)),
  print("La regla es ",integrate('f('x),'x,'a,'b),"~",('b-'a)*sum(b[i]*'f('a+c[i]*('b-'a)),i,1,n)),
  print("El orden es p=",p," y la constante es ",'C[p],"=",C),
  print("El error es ",integrate('f('x),'x,'a,'b)-('b-'a)*sum(b[i]*'f('a+c[i]*('b-'a)),i,1,n),"~",C*('b-'a)^(p+1),at('diff('f('x),'x,p),'x='theta))
),
[makelist(b[i],i,1,n),p,C]
)$

construye_regla([0,1/2,1])$

Forma_Lagrange(x,f,t,[no_output]): Función que calcula en la forma de Lagrange el polinomio interpolador de la función f(t) basado en los nodos x (con output paso a paso opcional)

Lagrange(x,f,t,[no_output]):=block([l,L,n], /*Variables bloqueadas*/
n:length(x)-1, /*Grado del polinomio*/
for i:0 thru n do l[i]:product((t-x[j+1])/(x[i+1]-x[j+1]),j,0,i-1)*product((t-x[j+1])/(x[i+1]-x[j+1]),j,i+1,n), /*Base de Lagrange*/
L:sum(subst(t=x[i+1],f)*l[i],i,0,n), /*Polinomio interpolador*/
if emptyp(no_output)=true then ( /*Salida por pantalla (condicional)*/ 
  plot2d([f,L,[discrete,makelist([x[i],subst(t=x[i],f)],i,1,n+1)]],[t,lmin(x),lmax(x)],
    [style,lines,lines,points],[point_type, bullet],[legend,f,sconcat("L(",t,")"),""],
    [xlabel,""],[color,red,blue,magenta]),
  print("Los nodos son ",makelist('x[i]=x[i+1],i,0,n))
),
L
)$

n:4$
Lagrange(makelist(-5+10*i/n,i,0,n),1/(1+x^2),x)$

n:8$
Lagrange(makelist(-5+10*i/n,i,0,n),1/(1+x^2),x)$

n:16$
Lagrange(makelist(-5+10*i/n,i,0,n),1/(1+x^2),x)$

Chevyshev(n,I,f,t,[no_output]): Función que calcula los nodos de Chevyshev para grado n en el intervalo I y dibuja el polinomio interpolador de f(t) basado en ellos (con output paso a paso opcional)

Chevyshev(n,I,f,t,[no_output]):=block([a,b,x,L], /*Variables bloqueadas*/
[a,b]:I, /*Intervalo*/
x:float(makelist(a+(b-a)/2*(1+cos(%pi*(2*n-2*i+1)/(2*n+2))),i,0,n)), /*Nodos de Chevyshev (en coma flotante)*/
L:Lagrange(x,f,t,vacio),
if emptyp(no_output)=true then ( /*Salida por pantalla (condicional)*/ 
plot2d([f,L,[discrete,makelist([x[i+1],subst(t=x[i+1],f)],i,0,n)]],[t,lmin(x),lmax(x)],
    [style,lines,lines,points],[point_type, bullet],[legend,f,sconcat("L(",t,")"),""],
    [xlabel,""],[color,red,blue,magenta]), 
  print("Los nodos son ",makelist('x[i]=x[i+1],i,0,n))
),
L
)$

Chevyshev(4,[-5,5],1/(1+x^2),x)$

Chevyshev(8,[-5,5],1/(1+x^2),x)$

Chevyshev(16,[-5,5],1/(1+x^2),x)$

## LaTeX

### Salida

Expresiones: e^(sqrt(pi)) (OJO: entorno matemático)

tex(exp(%pi^(1/2)))$

tex1(exp(%pi^(1/2)));

Formales: int[0,pi]sen xdx

f(x):=sin(x)$
'integrate(f(x),x,0,%pi);
tex1(%);

Igualdades: int[0,pi]sen x·dx

'integrate(f(x),x,0,%pi)=integrate(f(x),x,0,%pi);
tex1(%);

Definición: epsilon_0

tex1(e0);
texput(e0,"\\varepsilon_{0}")$
tex1(e0);

Modificación: conjugado(z)

declare(z,complex)$
tex1(conjugate(z));

texconjugado(e):=block([a:first(e)],
  concat("\\overline\{",tex1(a),"\}")
)$
texput(conjugate,texconjugado)$
tex1(conjugate(z));

### Gráficas

Terminal (plot): sen x en eps

plot2d(sin(x),[x,0,2*%pi],
  [gnuplot_term,ps],
  [gnuplot_out_file,"plot.eps"]
)$

Terminal (draw): sen x en eps

draw2d(
  terminal='eps,
  file_name="draw",
  explicit(sin(x),x,0,2*%pi)
)$

Tipografía (plot): sen x en eps-LaTeX (OJO: incompleto, color, puntos)

plot2d(sin(x),[x,0,2*%pi],
  [gnuplot_term,"epslatex"],
  [gnuplot_out_file,"plotlatex.tex"]
)$

plot2d(sin(x),[x,0,2*%pi],
  [gnuplot_term,"epslatex standalone color solid"],
  [gnuplot_out_file,"plotlatex.tex"]
)$

Tipografía (draw): sen x en eps-LaTeX (OJO: 5.29.0, gplbacktext)

load(draw)$
draw2d(
  dimensions=[1600,900],
  terminal='epslatex_standalone,
  file_name="drawlatex",
  explicit(sin(x),x,0,2*%pi)
)$

### Interacción

Ejecución: latex-maxima.tex (OJO: requiere max-tex-tools.lisp, max-tex-init.mac y maxiplot.sty)

Reptición: latex-personalizado.tex