Esta página es para la versión anterior. La página correspondiente en inglés ha sido eliminada en la versión actual.

Matemáticas de precisión simple

Este ejemplo muestra cómo realizar el álgebra aritmética y lineal con datos de precisión única. También muestra cómo los resultados se calculan apropiadamente en precisión simple o doble precisión, dependiendo de la entrada.

Crear datos de doble precisión

Vamos a crear primero algunos datos, que es de doble precisión de forma predeterminada.

Ad = [1 2 0; 2 5 -1; 4 10 -1]
Ad = 3×3

     1     2     0
     2     5    -1
     4    10    -1

Convertir a precisión única

Podemos convertir los datos a una precisión única con la función.single

A = single(Ad); % or A = cast(Ad,'single');

Crear ceros y unos únicos de precisión

También podemos crear ceros de precisión única y unos con sus respectivas funciones.

n = 1000; Z = zeros(n,1,'single'); O = ones(n,1,'single');

Echemos un vistazo a las variables en el área de trabajo.

whos A Ad O Z n
  Name         Size            Bytes  Class     Attributes    A            3x3                36  single                 Ad           3x3                72  double                 O         1000x1              4000  single                 Z         1000x1              4000  single                 n            1x1                 8  double               

Podemos ver que algunas de las variables son de tipo y que la variable (la versión de precisión única de) toma la mitad del número de bytes de memoria para almacenar porque los solteros requieren solo cuatro bytes (32 bits), mientras que los dobles requieren 8 bytes (64 bits).singleAAd

El álgebra aritmética y lineal

Podemos realizar aritmética estándar y álgebra lineal en singles.

B = A'    % Matrix Transpose
B = 3x3 single matrix

     1     2     4
     2     5    10
     0    -1    -1

whos B
  Name      Size            Bytes  Class     Attributes    B         3x3                36  single               

Vemos el resultado de esta operación, es una sola.B

C = A * B % Matrix multiplication
C = 3x3 single matrix

     5    12    24
    12    30    59
    24    59   117

C = A .* B % Elementwise arithmetic
C = 3x3 single matrix

     1     4     0
     4    25   -10
     0   -10     1

X = inv(A) % Matrix inverse
X = 3x3 single matrix

     5     2    -2
    -2    -1     1
     0    -2     1

I = inv(A) * A % Confirm result is identity matrix
I = 3x3 single matrix

     1     0     0
     0     1     0
     0     0     1

I = A \ A  % Better way to do matrix division than inv
I = 3x3 single matrix

     1     0     0
     0     1     0
     0     0     1

E = eig(A) % Eigenvalues
E = 3x1 single column vector

    3.7321
    0.2679
    1.0000

F = fft(A(:,1)) % FFT
F = 3x1 single column vector

   7.0000 + 0.0000i
  -2.0000 + 1.7321i
  -2.0000 - 1.7321i

S = svd(A) % Singular value decomposition
S = 3x1 single column vector

   12.3171
    0.5149
    0.1577

P = round(poly(A)) % The characteristic polynomial of a matrix
P = 1x4 single row vector

     1    -5     5    -1

R = roots(P) % Roots of a polynomial
R = 3x1 single column vector

    3.7321
    1.0000
    0.2679

Q = conv(P,P) % Convolve two vectors
Q = 1x7 single row vector

     1   -10    35   -52    35   -10     1

R = conv(P,Q)
R = 1x10 single row vector

     1   -15    90  -278   480  -480   278   -90    15    -1

stem(R); % Plot the result

Un programa que funciona para la precisión simple o doble

Ahora echemos un vistazo a una función para calcular suficientes términos en la secuencia de Fibonacci por lo que la relación es menor que la máquina correcta Epsilon () para el tipo de datos simple o doble.eps

% How many terms needed to get single precision results? fibodemo('single')
ans = 19 
 % How many terms needed to get double precision results? fibodemo('double')
ans = 41 
 % Now let's look at the working code. type fibodemo
function nterms = fibodemo(dtype) %FIBODEMO Used by SINGLEMATH demo. % Calculate number of terms in Fibonacci sequence.  % Copyright 1984-2014 The MathWorks, Inc.  fcurrent = ones(dtype); fnext = fcurrent; goldenMean = (ones(dtype)+sqrt(5))/2; tol = eps(goldenMean); nterms = 2; while abs(fnext/fcurrent - goldenMean) >= tol    nterms = nterms + 1;    temp  = fnext;    fnext = fnext + fcurrent;    fcurrent = temp; end 
 % Notice that we initialize several of our variables, |fcurrent|, % |fnext|, and |goldenMean|, with values that are dependent on the % input datatype, and the tolerance |tol| depends on that type as % well.  Single precision requires that we calculate fewer terms than % the equivalent double precision calculation.