ios - redondear - redondeo de numeros decimales

Cómo redondear CGFloat

Question

Hice este método

+ (CGFloat) round: (CGFloat)f {
    int a = f;
    CGFloat b = a;
    return b;
}

Funciona como se espera pero solo se redondea. Y si es un número negativo todavía se redondea.

Este fue solo un método rápido que hice, no es muy importante que se redondee correctamente, solo lo hice para redondear los valores x e y de la cámara para mi juego.

¿Está bien este método? Es rapido ¿O hay una solución mejor?

Answer 1

2018 Respuesta

Las otras respuestas aquí están fechadas o no dan buenos ejemplos. Es fácil redondear un CGFloat utilizando la función rounded incorporada de Swift.

let x: CGFloat = 3.5
let y = x.rounded() // 4.0

Si desea redondear el valor en su lugar, puede utilizar la round :

var x: CGFloat = 3.5
x.round() // 4.0

Reglas de redondeo

Si desea un control más preciso sobre la forma en que se redondean los números, puede usar una FloatingPointRoundingRule .

Lejos de cero

x.rounded(.awayFromZero)

Los números por encima de cero se redondean hacia arriba y los números por debajo de cero se redondean hacia abajo.

3.000  ->  3.0
3.001  ->  4.0
3.499  ->  4.0
3.500  ->  4.0
3.999  ->  4.0

-3.000  ->  -3.0
-3.001  ->  -4.0
-3.499  ->  -4.0
-3.500  ->  -4.0
-3.999  ->  -4.0

Down

x.rounded(.down)

Redondea cualquier número con un valor decimal hasta el siguiente número entero más pequeño. Esto es lo mismo que floor(x) .

3.000  ->  3.0
3.001  ->  3.0
3.499  ->  3.0
3.500  ->  3.0
3.999  ->  3.0

-3.000  ->  -3.0
-3.001  ->  -4.0
-3.499  ->  -4.0
-3.500  ->  -4.0
-3.999  ->  -4.0

A la más cercana o alejada de cero.

x.rounded(.toNearestOrAwayFromZero)   // same as x.rounded()

Los números decimales se redondean al valor entero más cercano. Sin embargo, cuando el valor está exactamente en el medio (como 3.5 o -3.5 ), los números positivos se redondean hacia arriba y los números negativos se redondean hacia abajo.

Puede tener un nombre largo y complicado, pero normalmente es así como uno aprende a redondear en la escuela. También es la regla utilizada si solo haces x.rounded() .

3.000  ->  3.0
3.001  ->  3.0
3.499  ->  3.0
3.500  ->  4.0  ***
3.999  ->  4.0

-3.000  ->  -3.0
-3.001  ->  -3.0
-3.499  ->  -3.0
-3.500  ->  -4.0  ***
-3.999  ->  -4.0

A la más cercana o incluso

x.rounded(.toNearestOrEven)

Esto es similar a toNearestOrAwayFromZero , excepto que ahora los valores .5 se redondean al número entero par.

3.000  ->  3.0
3.001  ->  3.0
3.499  ->  3.0
3.500  ->  4.0   ***
3.999  ->  4.0
4.500  ->  4.0   ***

-3.000  ->  -3.0
-3.001  ->  -3.0
-3.499  ->  -3.0
-3.500  ->  -4.0   ***
-3.999  ->  -4.0
-4.500  ->  -4.0   ***

Hacia cero

x.rounded(.towardZero)

Esto solo tiene el efecto de cortar cualquier valor decimal. Si necesita un Int , puede hacer lo mismo con Int(x) .

3.000  ->  3.0
3.001  ->  3.0
3.499  ->  3.0
3.500  ->  3.0
3.999  ->  3.0

-3.000  ->  -3.0
-3.001  ->  -3.0
-3.499  ->  -3.0
-3.500  ->  -3.0
-3.999  ->  -3.0

Up

x.rounded(.up)

Esto es lo contrario de .down . Todos los números decimales se redondean hacia arriba. Esto es lo mismo que ceil(x) .

3.000  ->  3.0
3.001  ->  4.0
3.499  ->  4.0
3.500  ->  4.0
3.999  ->  4.0

-3.000  ->  -3.0
-3.001  ->  -3.0
-3.499  ->  -3.0
-3.500  ->  -3.0
-3.999  ->  -3.0

Notas

• No olvides tener en cuenta los valores negativos.
• Los resultados de round y rounded siguen siendo CGFloat . Si necesita un Int , debe convertirlo como Int(myCGFloat) .
• No es necesario utilizar las funciones matemáticas de C round(x) , ceil(x) y floor(x) nunca más. Sin embargo, si los usa, manejan las arquitecturas de 64 y 32 bits, por lo que cualquier respuesta que pueda haber visto con roundf , ceilf y floorf ahora están obsoletas.

Answer 2

Está reinventando la rueda, y esta es una pregunta en C, no el Objetivo C. Solo use la función C (round () estándar).

Answer 3

Para trabajar con 32 y 64 bits puedes crear tus propios macro como

#ifndef CGFLOAT_CEIL
    #ifdef CGFLOAT_IS_DOUBLE
        #define CGFLOAT_CEIL(value) ceil(value)
    #else
        #define CGFLOAT_CEIL(value) ceilf(value)
    #endif
#endif

PD: esta no es una respuesta para la pregunta, sino una adición para la pregunta sobre cómo trabajar con valores de 32/64 bits.

Defina esto en un archivo como MyMacros.h y agregue una importación en myapp-Prefix.pch

También recuerde que elegir CGFloat como prefijo para su función puede ser un riesgo, ya que Apple podría agregar una macro como esta por sí mismo, por lo que la #ifndef CGFLOAT_CEIL es

Answer 4

Pruebe #import "tgmath.h" .

El <tgmath.h> incluirá los encabezados <math.h> y <complex.h> <math.h> y definirá varias macros de tipo genérico.

Answer 5

Un CGFloat está tipificado como double o float , por lo que puede redondearlos como cualquier otro tipo real:

CGFloat round(CGFloat aFloat)
{
    return (int)(aFloat + 0.5);
}

Tenga en cuenta que si bien esto funciona con flotadores lo suficientemente pequeños como para llevar una fracción, puede actuar extraño en valores grandes.

Answer 6

Ya hay funciones estándar con comportamientos que puede necesitar en <math.h> como: floorf , ceilf , roundf , rintf y nearbyintf (lasf ''f'' significa versión "flotante", las versiones sin ella son versiones "dobles").

Es mejor usar métodos estándar no solo porque son estándar, sino porque funcionan mejor en casos extremos.

Actualización 2013 (jessedc)

iOS ya no es solo de 32 bits. Hay otras respuestas a esta pregunta que ahora son más relevantes.

La mayoría de las respuestas mencionan la importación de tgmath.h

• https://.com/a/5352779/184130
• https://.com/a/7695011/184130