round

Redondear al decimal o entero más próximo

Sintaxis

Y = round(X)

Y = round(X,N)

Y = round(X,N,type)

Y = round(___,TieBreaker=direction)

Y = round(t)

Y = round(t,unit)

Descripción

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.

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.

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.

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.

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

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

Ejemplos

Redondear elementos de matriz

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

Redondear a un número especificado de dígitos decimales

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

Y = round(pi,3)

Y = 3.1420

Redondear al múltiplo más próximo de 100

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

round(863178137,-2)

ans = 863178100

Redondear elementos al número especificado de dígitos significativos

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

Controlar la visualización de números al redondear

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 mostrar 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

Especificar dirección de redondeo para empates

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

Redondear los valores de duración

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

X — Arreglo de entrada

escalar | vector | matriz | arreglo multidimensional | tabla | horario

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

X debe ser single, double, table o timetable 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 | table | timetable
Soporte de números complejos: Sí

N — Número de dígitos

entero escalar

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.

type — Tipo de redondeo

"decimals" (predeterminado) | "significant"

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

direction — Dirección para resolver empates

"fromzero" (predeterminado) | "tozero" | "even" | "odd" | "plusinf" | "minusinf"

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 * 10^N está dentro del error de redondeo de un punto a medio camino entre dos enteros consecutivos, es decir, X * 10^N tiene una parte fraccionaria de 0.5 (dentro del error de redondeo) en decimales.

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

t — Duración de entrada

arreglo de duration

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

unit — Unidad de tiempo

"seconds" (predeterminado) | "minutes" | "hours" | "days" | "years"

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 mostrar exactamente 2 dígitos decimales de pi (sin ceros posteriores), utilice sprintf("%.2f",pi).

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

Esta función es totalmente compatible con los arreglos altos. Para obtener más información, consulte Arreglos altos.

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• La generación de código solo es compatible con la sintaxis Y = round(X).

Generación de código de GPU

Genere código CUDA® para GPU NVIDIA® mediante GPU Coder™.

Notas y limitaciones de uso:

• La generación de código solo es compatible con la sintaxis Y = round(X).

Entorno basado en subprocesos

Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Esta función es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Ejecutar funciones de MATLAB en un entorno basado en subprocesos.

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

Notas y limitaciones de uso:

• Estas sintaxis no son compatibles:

  Y = round(X,N)

  Y = round(X,N,type)

  Y = round(___,TieBreaker=direction)

Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

Esta función es totalmente compatible con los arreglos distribuidos. Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido antes de R2006a

R2023a: Realizar cálculos directamente en tablas y horarios

La función round puede realizar cálculos sobre todas las variables de una tabla u horario sin indexar para acceder a dichas variables. Todas las variables deben tener tipos de datos que admitan el cálculo. Para obtener más información, consulte Direct Calculations on Tables and Timetables.

R2022a: Controlar el comportamiento de la resolución de empates

Especifique cómo resolver empates utilizando el argumento nombre-valor TieBreaker. Por ejemplo, round(X,TieBreaker="tozero") redondea los empates hacia cero.

R2022a: round devuelve resultados consistentes para empates

A partir de la versión R2022a, la función round siempre redondea los empates alejándose de cero al múltiplo más próximo de 10^—N con mayor magnitud de forma predeterminada. Por ejemplo:

X = 1.015:5.015;
N = 2;
Y = round(1.015:5.015,2)

Y =
    1.0200    2.0200    3.0200    4.0200    5.0200

En versiones anteriores, la función round devolvía en ocasiones resultados inconsistentes para empates de forma predeterminada. En el caso anterior, por ejemplo, el segundo y tercer elemento se redondeaban hacia cero a 2.01 y 3.01 respectivamente.

R2014b: Redondear a un número especificado de dígitos

En la versión R2014b, se añadieron estas sintaxis para redondear a cualquier número decimal o de dígitos significativos y para redondear valores de duración:

Y = round(X,N)
Y = round(X,N,type)
Y = round(t)  
Y = round(t,unit)   

Las versiones más antiguas de MATLAB^® solo son compatibles con esta sintaxis, que redondea al entero más próximo:

Y = round(X) 

Consulte también

ceil | fix | floor

Temas

• Valores enteros
• Números de punto flotante