Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

round

Redondear al decimal o entero más próximo

Descripción

ejemplo

Y = round(X) redondea cada elemento de X al entero más próximo. En caso de un empate en el que un elemento tenga una parte fraccionaria de 0.5 (dentro del error de redondeo) en decimales, la función round redondea alejándose de cero hacia el entero más próximo de mayor magnitud.

ejemplo

Y = round(X,N) redondea a N dígitos:

  • N > 0: redondea N dígitos a la derecha del separador decimal.

  • N = 0: redondea al entero más próximo.

  • N < 0: redondea N dígitos a la izquierda del separador decimal.

ejemplo

Y = round(X,N,type) especifica el tipo de redondeo. Especifique "significant" para que redondee a N dígitos significativos (contados a partir del dígito de la izquierda del todo). En este caso, N debe ser un entero positivo.

ejemplo

Y = round(___,TieBreaker=direction) redondea los empates como especifica direction. Utilice este argumento después de cualquiera de las combinaciones de argumentos de entrada de las sintaxis anteriores.

ejemplo

Y = round(t) redondea cada elemento del arreglo duration t al número más próximo de segundos.

ejemplo

Y = round(t,unit) redondea cada elemento de t al número más próximo de la unidad de tiempo especificado.

Ejemplos

contraer todo

Redondee los elementos de una matriz de 2 por 2 al entero más próximo.

X = [2.11 3.5; -3.5 0.78];
Y = round(X)
Y = 2×2

     2     4
    -4     1

Redondee pi a los 3 dígitos decimales más próximos.

Y = round(pi,3)
Y = 3.1420

Redondee el número 863178137 al múltiplo más próximo de 100.

round(863178137,-2)
ans = 863178100

Redondee los elementos de un vector para que mantengan 2 dígitos significativos.

X = [1253 1.345 120.44]
X = 1×3
103 ×

    1.2530    0.0013    0.1204

Y = round(X,2,"significant")
Y = 1×3
103 ×

    1.3000    0.0013    0.1200

El comando format controla el modo en que MATLAB® muestra los números en la línea de comandos. Si un número tiene dígitos adicionales que no se pueden visualizar en el formato actual, MATLAB redondea automáticamente el número con fines de visualización. Esta visualización puede provocar resultados imprevistos al combinarse con la función round.

Considere el resultado de esta operación de resta, que muestra 5 dígitos.

format short
x = 112.05 - 110
x = 2.0500

El resultado que se muestra es 2.0500, que parece un empate. No obstante, debido al error aritmético de punto flotante, el empate en una parte fraccionaria de 0.5 no se encuentra dentro del error de redondeo.

Según el valor visualizado de x, al redondear x a 1 decimal se debe devolver 2.1.

y = round(x,1)
y = 2

De hecho, el problema en este caso es que MATLAB redondea x a 5 dígitos con fines de visualización. La función round devuelve la respuesta correcta. Confirme la respuesta visualizando x con format long, lo que muestra x redondeado a 15 dígitos.

format long
x
x = 
   2.049999999999997

Para comparar, muestre los resultados de redondeo para un empate que está dentro del error de redondeo y para un empate que no lo está.

x1 = 2.05
x1 = 
   2.050000000000000

y1 = round(x1,1)
y1 = 
   2.100000000000000

x2 = 2.05 - eps(2.05)
x2 = 
   2.049999999999999

y2 = round(x2,1)
y2 = 
     2

Cree un vector de decimales que tenga empates, es decir, decimales con una parte fraccionaria de 0.5 (dentro del error de redondeo).

X = -2.5:1:2.5
X = 1×6

   -2.5000   -1.5000   -0.5000    0.5000    1.5000    2.5000

Redondee los empates a los enteros par e impar más próximos.

Yeven = round(X,TieBreaker="even")
Yeven = 1×6

    -2    -2     0     0     2     2

Yodd = round(X,TieBreaker="odd")
Yodd = 1×6

    -3    -1    -1     1     1     3

Redondee los empates hacia infinito positivo y negativo.

Yplusinf = round(X,TieBreaker="plusinf")
Yplusinf = 1×6

    -2    -1     0     1     2     3

Yminusinf = round(X,TieBreaker="minusinf")
Yminusinf = 1×6

    -3    -2    -1     0     1     2

Redondee los empates alejándose de cero y hacia cero.

Yfromzero = round(X,TieBreaker="fromzero")
Yfromzero = 1×6

    -3    -2    -1     1     2     3

Ytozero = round(X,TieBreaker="tozero")
Ytozero = 1×6

    -2    -1     0     0     1     2

Redondee cada valor de un arreglo de duración al número más próximo de segundos.

t = hours(8) + minutes(29:31) + seconds(1.3:0.5:2.3);
t.Format = "hh:mm:ss.SS"
t = 1x3 duration
   08:29:01.30   08:30:01.80   08:31:02.30

Y1 = round(t)
Y1 = 1x3 duration
   08:29:01.00   08:30:02.00   08:31:02.00

Redondee cada valor de t al número más próximo de horas.

Y2 = round(t,"hours")
Y2 = 1x3 duration
   08:00:00.00   09:00:00.00   09:00:00.00

Argumentos de entrada

contraer todo

Arreglo de entrada, especificado como escalar, vector, matriz o arreglo multidimensional. En el caso de X complejo, round trata las partes reales y las imaginarias de distinta forma.

X debe ser single o double cuando utilice round con más de una entrada.

round convierte elementos lógicos y char de X a valores double.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | char | logical
Soporte de números complejos:

Número de dígitos, especificado como entero escalar. Cuando especifica N, la función round(X,N) redondea X al múltiplo más próximo de 10—N.

Si especifica el tipo de redondeo "significant", N debe ser un entero positivo.

Tipo de redondeo, especificado como "decimals" o "significant". El tipo de redondeo determina si round considera los dígitos en relación con el separador decimal o el número global de dígitos significativos. N debe ser un entero positivo cuando especifica "significant". En ese caso, la función round redondea al número más próximo con N dígitos significativos.

El valor predeterminado es "decimals", de forma que round(X,N,"decimals") equivalga a round(X,N).

Ejemplo: round(3132,2,"significant") devuelve 3100, que es el número más próximo a 3132 con 2 dígitos significativos.

Tipos de datos: char | string

Dirección para resolver empates, especificada como uno de estos valores:

  • "fromzero": redondea los empates alejándose de cero al entero más próximo de mayor magnitud.

  • "tozero": redondea los empates hacia cero al entero más próximo de menor magnitud.

  • "even": redondea los empates al entero par más próximo.

  • "odd": redondea los empates al entero impar más próximo.

  • "plusinf": redondea los empates hacia infinito positivo al entero más próximo de mayor valor.

  • "minusinf": redondea los empates hacia infinito negativo al entero más próximo de menor valor.

Los empates son infrecuentes. Al utilizar round(X,N,TieBreaker=direction), se produce un empate solo cuando X * 10N está dentro del error de redondeo de un punto a medio camino entre dos enteros consecutivos, es decir, X * 10N tiene una parte fraccionaria de 0.5 (dentro del error de redondeo) en decimales.

Ejemplo: round(2.015,2,TieBreaker="even")

Duración de entrada, especificada como arreglo de duration.

Unidad de tiempo, especificada como "seconds", "minutes", "hours", "days" o "years". Una duración de 1 año equivale exactamente a 365,2425 días de 24 horas.

Tipos de datos: char | string

Sugerencias

  • Tanto format short como format long muestran números redondeados. Esta visualización puede provocar resultados imprevistos al combinarse con la función round.

  • Con fines de visualización, utilice sprintf para controlar la visualización exacta de un número como cadena. Por ejemplo, para visualizar exactamente 2 dígitos decimales de pi (sin ceros posteriores), utilice sprintf("%.2f",pi).

Capacidades ampliadas

Historial de versiones

Introducido antes de R2006a

expandir todo