MATLAB dispone de tres funciones útiles relacionadas con las operaciones de coma flotante.

Estas funciones, que no tienen argumentos, son las siguientes:

eps devuelve la diferencia entre 1.0 y el número de coma flotante inmediatamente
superior. Da una idea de la precisión o número de cifras almacenadas. En un
PC, eps vale 2.2204e-016.
realmin devuelve el número más pequeño con que se puede trabajar (2.2251e-308)
realmax devuelve el número más grande con que se puede trabajar (1.7977e+308)

Detalles de Matlab

Formatos de Salida

Respecto a los formatos numéricos con que MATLAB muestra los resultados (recuérdese que
siempre calcula y almacena con doble precisión, es decir con unas 16 cifras decimales
equivalentes), las posibilidades existentes se muestran en la lista desplegable de la Figura 21 y
son las siguientes:

short coma fija con 4 decimales (defecto)

long coma fija con 15 decimales
hex cifras hexadecimales
bank números con dos cifras decimales
short e notación científica con 4 decimales
short g notación científica o decimal, dependiendo del valor
long e notación científica con 15 decimales
long g notación científica o decimal, dependiendo del valor
rat expresa los números racionales como cocientes de enteros

Estos formatos se pueden cambiar también desde la línea de comandos anteponiendo la

palabra format. Por ejemplo, para ver las matrices en formato long habrá que ejecutar el
comando:

>> format long

MATLAB mantiene una forma especial para los números muy grandes (más grandes que los que
es capaz de representar), que son considerados como infinito. Por ejemplo, obsérvese cómo
responde el programa al ejecutar el siguiente comando:

>> 1.0/0.0
Warning: Divide by zero
ans =
Inf
Así pues, para MATLAB el infinito se representa como inf ó Inf. MATLAB tiene también
una representación especial para los resultados que no están definidos como números. Por
ejemplo, ejecútense los siguientes comandos y obsérvense las respuestas obtenidas:

>> 0/0
Warning: Divide by zero
ans =
 NaN
>> inf/inf
ans =
NaN
En ambos casos la respuesta es NaN, que es la abreviatura de Not a Number. Este tipo de
respuesta, así como la de Inf, son enormemente importantes en MATLAB, pues permiten
controlar la fiabilidad de los resultados de los cálculos matriciales. Los NaN se propagan al
realizar con ellos cualquier operación aritmética, en el sentido de que, por ejemplo, cualquier
número sumado a un NaN da otro NaN. MATLAB tiene esto en cuenta. Algo parecido sucede
con los Inf.

MATLAB dispone de tres funciones útiles relacionadas con las operaciones de coma flotante.
Estas funciones, que no tienen argumentos, son las siguientes:
eps devuelve la diferencia entre 1.0 y el número de coma flotante inmediatamente
superior. Da una idea de la precisión o número de cifras almacenadas. En un
PC, eps vale 2.2204e-016.
realmin devuelve el número más pequeño con que se puede trabajar (2.2251e-308)
realmax devuelve el número más grande con que se puede trabajar (1.7977e+308)

En muchos cálculos matriciales los datos y/o los resultados no son reales sino complejos, con
parte real y parte imaginaria. MATLAB trabaja sin ninguna dificultad con números complejos.
Para ver como se representan por defecto los números complejos, ejecútense los siguientes
comandos:

>> a=sqrt(-4)
a =
0 + 2.0000i
>> 3 + 4j
ans =
3.0000 + 4.0000i

En la entrada de datos de MATLAB se pueden utilizar indistintamente la i y la j para

representar el número imaginario unidad (en la salida, sin embargo, puede verse que siempre
aparece la i). Si la i o la j no están definidas como variables, puede intercalarse el signo (*). Esto
no es posible en el caso de que sí estén definidas, porque entonces se utiliza el valor de la
variable. En general, cuando se está trabajando con números complejos, conviene no utilizar la i
como variable ordinaria, pues puede dar lugar a errores y confusiones. Por ejemplo, obsérvense
los siguientes resultados:

>> i=2
i =
2
>> 2+3i
ans =
2.0000 + 3.0000i
>> 2+3*i
ans =
8
>> 2+3*j
ans =
2.0000 + 3.0000i
Cuando i y j son variables utilizadas para otras finalidades, como unidad imaginaria puede
utilizarse también la función sqrt(-1), o una variable a la que se haya asignado el resultado de
esta función.

MATLAB puede definir variables que contengan cadenas de caracteres. En MATLAB las
cadenas de texto van entre apóstrofos o comillas simples (Nótese que en lenguaje C van entre
comillas dobles: "cadena"). Por ejemplo, en MATLAB:

s = 'cadena de caracteres'

Las cadenas de texto tienen su más clara utilidad en temas que se verán más adelante y por
eso se difiere hasta entonces una explicación más detallada.
<p class=MsoNormal style='mso-layout-grid-align:none;text-autospac

Introducción al Matlab
    El propósito de estas notas es hacer una rápida introducción al matlab. Son sólo unas pequeñas

muestras para dar idea de como funciona este programa. Para un estudio más serio deben
consultarse otras referencias. En particular las que damos al final de esta página.

    El nombre de Matlab viene de Matrix Laboratory y como el nombre indica matlab es
especialmente fuerte
en el tratamiento de matrices. Estos fueron sus orígenes, a los que se han ido incorporando
sucesivamente
más capacidades, sobretodo gráficas.

    Matlab es una potente calculadora, por ejemplo calcula la suma de dos números
 

>> 2+2
ans =
       4

    Aunque el ejemplo es sencillo ya vemos como actua matlab, se escriben las instrucciones en
la línea de comandos >>  y  después de pulsar la tecla Intro aparece el resultado más abajo como
variable ans.
El resultado no aparece visible en la pantalla si ponemos punto y coma ; al final de las
instrucciones, como en
 
>> A=rand(6); B=inv(A); B*A;

    Si quitamos los puntos y comas de esta última expresión veremos el resultado. Para
escribirla de nuevo podemos usar la flecha hacia arriba del teclado, que nos recupera
los comandos escritos anteriormente en la sesión.
 

>> A=rand(6), B=inv(A), B*A

A =
    0.1338    0.4514    0.6831    0.0164    0.7176   
0.1536
    0.2071    0.0439    0.0928    0.1901    0.6927   
0.6756
    0.6072    0.0272    0.0353    0.5869    0.0841   
0.6992
    0.6299    0.3127    0.6124    0.0576    0.4544   
0.7275
    0.3705    0.0129    0.6085    0.3676    0.4418   
0.4784
    0.5751    0.3840    0.0158    0.6315    0.3533   
0.5548
B =
  -18.9422   -0.1768  -27.4583    8.2189   14.1721  
17.0665
   10.6427   -0.8112   14.3231   -3.3853   -9.0470  
-7.7695
    5.3157   -0.9261    7.4863   -1.8170   -2.6566  
-5.1051
    4.6141   -0.4972    6.8101   -3.2198   -2.1772  
-3.1550
   -9.7318    1.3315  -15.5596    3.3890    7.9718   
9.3641
   13.0642    0.4891   20.4944   -4.6187  -10.9522 
-12.7382
ans =
    1.0000    0.0000    0.0000    0.0000    0.0000   
0.0000
    0.0000    1.0000    0.0000         0   
0.0000         0
   -0.0000   -0.0000    1.0000    0.0000   -0.0000  
-0.0000
   -0.0000   -0.0000    0.0000    1.0000   -0.0000   
0.0000
    0.0000    0.0000   -0.0000    0.0000    1.0000   
0.0000
    0.0000   -0.0000    0.0000         0    0.0000   
1.0000

    Obsérvese la rapidez con que se han calculado estas matrices A=rand(6) encuentra una matriz
6x6 de
números aleatorios (cada uno entre 0 y 1), inv(A) calcula su inversa y luego comprobamos que
B*A
es la matriz identidad. Los números negativos que aparecen son debido al redondeo (en este caso
serían números muy pequeños, pero negativos).

    Veamos como maneja matab los números:

 

>> pi
ans =
    3.1416
>> format long
>> pi
ans =
   3.14159265358979

    Aunque nos da el valor de pi con distinto número de decimales en realidad matlab trabaja
internamente
con doble presición, pero nos muestra distintos formatos. Para ver los distintos formatos basta
con usar el help:
 

>>  help format  (aparece el cuadro de la derecha -->)

  Ejemplo:          10*pi                  10*exp(1)
format short      27.1828 FORMAT SHORT Scaled
31.4159 27.1828182845904 fixed point format
format long       5 with 5 digits.
31.41592653589793 2.7183e+001 FORMAT LONG    Scaled
format short e    2.71828182845904 fixed point format
3.1416e+001 5e+001 with 15 digits.
format long e     27.183 FORMAT SHORT E
3.141592653589793e+00 27.1828182845905 Floating point format
1 403b2ecd2dd96d44 with 5 digits.
format short g    27.18 FORMAT LONG E 
31.416 2528/93 Floating point format
format long g     with 15 digits.
31.4159265358979  FORMAT SHORT G Best of
format hex        fixed or floating
403f6a7a2955385e point format with 5
format bank       digits.
31.42 FORMAT LONG G  Best of
format rat        fixed or floating
3550/113 point format with 15
digits.
FORMAT HEX    
Hexadecimal format.
FORMAT +       The
symbols +, - and blank
are printed
                    
for positive, negative
and zero elements.
                    
Imaginary parts are
ignored.
 FORMAT BANK    Fixed
format for dollars and
cents.
FORMAT RAT    
Approximation by ratio
of small integers.
    All computations in MATLAB are done in double precision.

    Cada número se guarda en memoria como un vector de 8 bytes, lo que da una mantisa de unos
15 ó 16
dígitos decimales. Al ser 8 bytes = 64 bits de memoria, cada bit es como si fuera una cajita donde
se almacenan
los ceros o unos corrspondientes al número en binario. De estas cajitas o bits, una de ellas
corresponde al
signo (+ ó -), 11 bits al exponente y el resto, esto es 52 bits a la mantisa. Un número x será por
tanto

      x= signo x mantisa x 10E

    Los 211=2048 posibles exponentes E se distribuyen entre -1023  E   1024, siendo el número
más
grande posible del orden de (2-eps)*21023 x 10308 y el número más pequeño del orden de

2-1022 x10-308 . La mantisa de 52 bits nos da un epsilon máquina del orden de eps=2-
52
x10-16.
    Recordenmos que el epsilon máquina eps se define como el número más grande eps tal que la
máquina no
distingue entre 1 y 1+eps.

    El número real más grande, más pequeño y epsilon máquina respectivamente, se obtienen con
 

>>realmin
>>realmax
>>eps

    Con matlab podemos ir escribiendo los comandos uno tras otro, pero cuando tenemos que
hacer un pequeño
programa o escribir muchos comandos suele resultar más útil escribir un fichero con las
instrucciones
y luego hacer que matlab los ejecute. Estos son los ficheros .m que no son más que ficheros de
texto
a los que luego ponemos la extensión .m . Matlab lleva incorporado un editor que podemos usar
para
este propósito. Buscamos en File -> New -> M-file y escribimos en el editor que aparece
 

format long
primero=2.1;
segundo=2.1
for n=1:40
   tercero=4*primero-3*segundo
   primero=segundo;
   segundo=tercero;
end

que luego guardamos en matlab con el nombre diferencias.m , ya que lo que hace este programita
es
calcular los sucesivos términos de la sucesión  an+2=4 an3 an+1 empezando con a1=2.1 y  a2=2.1
En este caso, como no hemos puesto punto y coma después de la línea de tercero, los resultados
se irán escribiendo en la pantalla, unos debajo de otros a medida que se van calculando.
 

2.10000000000000   El resultado es sorprendente !! 

2.10000000000000
2.10000000000000
2.09999999999999   Esperaríamos ver que  an=2.1, para todo n.
2.10000000000002 ¿Por qué aparece este extraño
2.09999999999991 comportamiento?
2.10000000000036   En realidad la ecuación en diferencias  an+2=4
2.09999999999854
2.10000000000582 an3 an+1  tiene por solución
2.09999999997672
2.10000000009313  
2.09999999962747
2.10000000149012 donde 
2.09999999403954 siendo C1 y C2 dos constantes cualesquiera.
2.10000002384186 Las condiciones iniciales a1=a2=2.1
2.09999990463257
2.10000038146973 determinan la solución con constantes C1=1,
2.09999847412109 C2=0. Pero debido a que 2.1 en
2.10000610351563 base dos tiene una fracción periódica que se
2.09997558593750 repite indefinidamente, ya que 
2.10009765625000
2.09960937500000
2.10156250000000
2.09375000000000
2.12500000000000
2
2.50000000000000   al calcular 
0.50000000000000
8.50000000000000
-      tercero=tercero=4*primero-3*segundo,
23.5000000000000
0 resulta que si eps es un número muy pequeño
1.04500000000000
0e+002
comparable al epsilon máquina
-
4.07500000000000
0e+002      a3=tercero=2.1+eps
1.64050000000000
0e+003
- al iterar ahora de nuevo con 
6.55150000000000
0e+003      a2=2.1,   a3=2.1+eps, 
2.62165000000000
0e+004
como nuevas condiciones iniciales, resulta que
- la constante C2 ya no es 0. 
1.04855500000000 Lo que hace que la solución errónea aumente
0e+005 exponencialmente y enmascare 
4.19432500000000 completamente la solución  prevista. Es un
0e+005
- claro ejemplo de inestabilidad 
1.67771950000000 numérica. 
0e+006
6.71088850000000     !No te fíes de los 
0e+006
     ordenadores!
-
2.68435435000000  
0e+007
1.07374184500000  
0e+008

Comentarios al programa:
 

 1) Si añadimos la instrucción   fprintf(' %16.7f\n ',segundo);

    aparecerá una pantalla más ordenada con los resultados en columna.

 2)

 
format long  Este programa abre un fichero de texto
primero=2.1;
segundo=2.1;  llamado resultados.txt donde se escribirán
fi=fopen('resultados.txt','w');  los cálculos en columna.
for n=1:40
   tercero=4*primero-3*segundo;  Buscar en
   primero=segundo;
   segundo=tercero;
 >> help fprintf
   fprintf(fi,'%16.7f\n',segundo);
end  para más información sobre este y otros 
fclose(fi)  comandos parecidos.

 3)

a(1)=2.1; Este otro programa tiene una estructura más apropiada

a(2)=2.1;
para 
 Matlab ya que va incrementando las componentes de un 
vector a.
Que luego se puede usar , por ejemplo,  para representar 
  for n=1:18
gráficamente como 
>>plot(a)
  a(n+2)=4*a(n+1)-3*a(n);
  end Ver 
>>whos 
para observar
las variables que están en memoria y como van
cambiando.
    En matlab hay unos añadidos llamados Toolboxes que incorporan más funciones y
posibilidades.
Una de ellas, que se incorpora en todas las versiones de Matlab para estudiantes, se llama
Symbolic Toolbox. Con ella podemos trabajar con el número de dígitos de mantisa que
deseemos, esta función es
vpa. Buscar en help vpa. El ejemplo siguiente nos da los 800 primeros dígitos de pi:
 
>> vpa(pi,800)
ans =
3.1415926535897932384626433832795028841971693993751058209749445923
078164062862089986280348253
42117067982148086513282306647093844609550582231725359408128481117
4502841027019385211055596446
22948954930381964428810975665933446128475648233786783165271201909
1456485669234603486104543266
48213393607260249141273724587006606315588174881520920962829254091
7153643678925903600113305305
48820466521384146951941511609433057270365759591953092186117381932
6117931051185480744623799627
49567351885752724891227938183011949129833673362440656643086021394
9463952247371907021798609437
02770539217176293176752384674818467669405132000568127145263560827
7857713427577896091736371787
21468440901224953430146549585371050792279689258923542019956112129
0219608640344181598136297747
713099605187072113499999983729780499510597317328160963186

    Como otro ejemplo, calculemos con mantisa 3  la suma de los primeros 20 términos
de la serie armónica, esto es

 clear all
 suma=1
 for n=2:20
 suma=vpa(vpa(suma,3)+vpa(1/n,3),3)
 end
El resultado que obtenemos es suma =3.60. De no haber calculado con esta
mantisa obtendríamos
>> suma =3.59773965714368
 suma=0;
 tic
 for m=1:20
 for n=1:1000*m
     
suma=suma+1/n;
   end
   t(m)=toc;
 end
 plot(t)

    El programita de aquí arriba  utiliza una gráfica para representar el tiempo que ha tardado
Matlab en sumar distintas sumas
parciales de esta serie armónica. ¿Cuál es la suma de la serie armónica infinita? Todos sabemos
que diverge, esto es, que si vamos sumando más y más términos las sumas parciales se hacen tan
grandes como queramos. Hay una manera divertida de pensar en la
suma de los términos de una serie.  Se puede pensar que tenemos una pulguita que va dando
saltitos, cada vez, en este caso, primero
de un metro, luego de medio, luego de una tercera parte, y así sucesivamente. Esto es que en el
salto n avanzaría una distancia 1/n.
Que esta serie diverge significa que si el número de saltos es suficientemente grande nuestra
amiga llegaría de la Autónoma
a Madrid, a la Luna, ... llegaría tan lejos como queramos. !!Pero si la calculamos con el
ordenador esta suma sería finita !!

¿Has pensado en cuál sería la suma?

    Tal como hemos dicho Matlab está muy adaptado al cálculo con vectores y matrices, por
ejemplo en las
siguientes instrucciones

>> x=[0 : 0.1 : 1]

significa que x es un vector cuyas componentes empiezan en 0, se van incrementando de 0.1 en
0.1
y terminan en 1. Luego
>>y=sin(x)
es un vector cuyas componentes son los senos de las anteriores,
>>disp([x' y' z'])
muestra los traspuestos de estos vectores. El resultado se puede ver como sigue:
 
>>    x=[0:0.1:1];  y=sin(x);  z=cos(x);
>>
'-----------------------------------------------------
--  '
>>    '        x                seno(x)            
cos(x)       ', disp([x' y' z'])
ans =
        x                seno(x)            cos(x)
 -----------------------------------------------------
-----
   0                  0                 
1.00000000000000
   0.10000000000000   0.09983341664683  
0.99500416527803
   0.20000000000000   0.19866933079506  
0.98006657784124
   0.30000000000000   0.29552020666134  
0.95533648912561
   0.40000000000000   0.38941834230865  
0.92106099400289
   0.50000000000000   0.47942553860420  
0.87758256189037
   0.60000000000000   0.56464247339504  
0.82533561490968
   0.70000000000000   0.64421768723769  
0.76484218728449
   0.80000000000000   0.71735609089952  
0.69670670934717
   0.90000000000000   0.78332690962748  
0.62160996827066
   1.00000000000000   0.84147098480790  
0.54030230586814

    En Matlab podemos escribir un conjunto de instrucciones que forman un fichero.m,  pero
también podemos
utilizar una function. Hay una diferencia entre ambos ya que en un fichero.m los datos y las
variables son como
si las hubiérmos escrito desde la consola. En una función las variables son internas, no cambian
ni afectan las
externas. Por cierto que conviene muchas veces limpiar las variables externas con  la instrucción

>>clear all
si no queremos tener cálculos confusos. Para limpiar la pantalla usaremos
>>clc
    Un ejemplo de función sería el programita siguiente, que calcula los 20 primeros términos de
la serie exponencial

 function [s]=serie(x)
 term=1; suma=1;
 for n=1:20
   term=term*x/n;
   suma=suma+term;
 end
 s=suma

    La función se llama desde la consola como

>>serie(x),
    Por ejemplo:
 
 >>serie(1)
 suma=2.71828182845905

    Resultado que ya da todas las cifras decimales correctas del numero e hasta la precisión de
Matlat, como se puede
comprobar fácilmente. Con esta función podemos comprobar por ejemplo que al sumar una suma
alternada afecta
en mucho el error de redondeo, ya que
 

 >> exp(-8)-serie(-8)
 ans = -0.13229825662640

    Mientras que

 

 >>  1/serie(8)-exp(-8)
 ans =3.152568231321777e-008

Gráficos con Matlab

Pueden verse en los siguientes ejemplos:

    Un comando útil en matlab es ginput. Ver >>help gineput (también gtext). Abajo el pequeño
programita dibuja y=x(x-1)sin x, luego sobre la figura, permite tomar 6 puntos con el ratón, que
al final muestra en la consola.
 

 >> f='x*(x-1)*sin(x)'; ezplot(f);[x,y]=ginput(6);

[x,y]
 >> help plot
Various line types, plot symbols and colors may be obtained with
    PLOT(X,Y,S) where S is a character string made from one
element
    from any or all the following 3 colunms:

           y     yellow        .     point              -     solid

           m     magenta       o     circle             :     dotted
           c     cyan          x     x-mark             -.    dashdot 
           r     red           +     plus               --    dashed 
           g     green         *     star
           b     blue          s     square
           w     white         d     diamond
           k     black         v     triangle (down)
                               ^     triangle (up)
                               <     triangle (left)
                               >     triangle (right)
                               p     pentagram
                               h     hexagram
    Otros ejemplos:
 
 
 

Ventana de comandos de matlab

 close all
 u=-8:0.5:8; v=u;
 [U,V]=meshgrid(u,v);
 R=sqrt(U.*U+V.*V)
+eps;
 W=sin(R)./R;
 mesh(W)

 
 x=[-3:0.4:3];
y=x;
close
subplot(2,2,1)
figure(gcf), fi=[-
6*pi:pi/20:6*pi];
plot3(fi.*cos(fi),fi.*sin(fi),
fi,'r')
[X,Y]=meshgrid(x,y);
Z=superficie(X,Y);
subplot(2,2,2)
mesh(Z)
subplot(2,2,3)
surf(Z)
subplot(2,2,4)
contour3(Z,16)

 
 >>[x y z]=peaks;
 >>contour(x,y,z,'k')
 >>pcolor(x,y,z)
 >>shading interp
 >>Z=peaks;
 >> figure (2); [C,h]=contour(Z,10);
 >> clabel(C,h)

produce las siguientes figuras:

 

>> help elfun
Trigonometric.
    sin         - Sine.
    sinh        - Hyperbolic sine.
    asin        - Inverse sine.
    asinh       - Inverse hyperbolic
sine.
    cos         - Cosine.
    cosh        - Hyperbolic cosine.
    acos        - Inverse cosine.
    acosh       - Inverse hyperbolic
cosine.
    tan         - Tangent.
    tanh        - Hyperbolic tangent.
    atan        - Inverse tangent.
    atan2       - Four quadrant inverse
tangent.
    atanh       - Inverse hyperbolic
tangent.
    sec         - Secant.
    sech        - Hyperbolic secant.
    asec        - Inverse secant.
    asech       - Inverse hyperbolic
secant.
    csc         - Cosecant.
Exponential.
    exp         - Exponential.
    log         - Natural logarithm.
    log10       - Common (base 10) logarithm.
    log2        - Base 2 logarithm and dissect floating
point number.
    pow2        - Base 2 power and scale floating point
number.
    sqrt        - Square root.
    nextpow2    - Next higher power of 2.
  Complex.
    abs         - Absolute value.
    angle       - Phase angle.
    complex     - Construct complex data from real and
imaginary parts.
    conj        - Complex conjugate.
    imag        - Complex imaginary part.
    real        - Complex real part.
    unwrap      - Unwrap phase angle.
    isreal      - True for real array.
    cplxpair    - Sort numbers into complex conjugate
pairs.
    csch        - Hyperbolic cosecant.
    acsc        - Inverse cosecant.
    acsch       - Inverse hyperbolic
cosecant.
    cot         - Cotangent.
    coth        - Hyperbolic cotangent.
    acot        - Inverse cotangent.
    acoth       - Inverse hyperbolic
cotangent.
  Rounding and remainder.
    fix         - Round towards zero.
    floor       - Round towards minus infinity.
    ceil        - Round towards plus infinity.
    round       - Round towards nearest integer.
    mod         - Modulus (signed remainder after
division).
    rem         - Remainder after division.
    sign        - Signum.

Ver también

>>help specfun  (Bessel , gamma, Airy).

>>help mfun
>>mfunlist  (Zeta de Riemann, Polinomios ortogonales)

cardioide:
>>ezpolar('1+co
s(t)')

Otros comandos útiles de matlab:

 

>> date
>> calendar
>> clear x, clear all   limpia la variable x, limpia todas las variables
>> close , close all  cierra la figura actual, cierra todas las figuras
>> axis([minx maxx miny maxy])   encuadra figura en este marco
>> break sale de dentro de un  “if” o de un “while” 
>> clc limpia la pantalla
 Control C (ó Control Z) acaba con la ejecución de 
 un cálculo de matlab (en caso necesario).
Un juego: Vamos a mandar mensajes secretos

    Julio César se comunicaba con sus gobernadoresy generales con mensajes codificados. Hacía
corresponder a cada
letra del abecedario la tercera siguiente. El mensaje parecía una sopa de letras ininteligible. Para
decodificar no había
más que proceder al revés. Aquí tenemos en cuenta que las letras y símbolos del teclado tienen
asignados números
enteros del 0 al 127, código ASCII. El comando char asigna este número a las letras mientras
que rem (p,q) es el
resto de dividir p entre q (clase de restos). El resultado es el siguiente:
 

» texto='Me encanta este curso'

texto =
   Me encanta este curso
» secreto=char(rem(texto+3,128))
  secreto =
  Ph#hqfdqwd#hvwh#fxuvr
» decodifica=char(rem(secreto-3,128))
  decodifica =
  Me encanta este curso

Un programita de regalo:  tetris.m

Refencias: http://www.glue.umd.edu/~nsw/ench250/primer.htm

http://mate.uprh.edu/~pnm/notas4061/cap2/repre.html

http://www.ticalc.org/pub/v200/basic/science/ programas para la voyage