Cómo redondear CGFloat

Question

I hizo que este método

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

Funciona como se esperaba pero sólo redondea hacia abajo. Y si se trata de un número negativo que todavía se redondea hacia abajo.

Esto fue sólo un método rápido que hice, no es muy importante que se redondea correctamente, acabo de hacer que para redondear x de la cámara y los valores de y para mi juego.

¿Es este método de acuerdo? ¿Es rápido? ¿O hay una solución mejor?

Answer 1

Ya son funciones estándar con comportamientos que pueda necesitar en <math.h> tales como: floorf, ceilf, roundf, rintf y nearbyintf (medios LASF 'f' "flotar" versión, las versiones sin ella son versiones "doble").

Es mejor utilizar métodos estándar no sólo porque son estándar, pero debido a que trabajan mejor en casos extremos.

2013 Update (jessedc)

IOS es ya sólo el 32 bits no. Hay una serie de otras respuestas a esta pregunta, que ahora son más relevantes.

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

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

Answer 2

2018 respuesta

Las otras respuestas aquí están bien definida o no dan buenos ejemplos. Es fácil para redondear un CGFloat de Swift usando construido en función de rounded.

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

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

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

normas de redondeo

Si desea un control más preciso sobre cómo se redondean los números, se puede utilizar un FloatingPointRoundingRule .

lejos de cero

x.rounded(.awayFromZero)

Los números encima de cero están redondeados y números debajo de cero están abajo redondeado.

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

abajo

x.rounded(.down)

Rondas cualquier número con un valor decimal hasta el siguiente número entero más pequeño. Este es el 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

Para más cerca o lejos de cero

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

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

Puede tener un nombre largo y complicado, pero esto es normalmente uno aprende cómo redondeo en la escuela. También es la norma que se utiliza si sólo hacemos 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

Para más próximo o incluso

x.rounded(.toNearestOrEven)

Esto es similar a toNearestOrAwayFromZero, excepto que ahora los valores se redondean a .5 incluso todo el número.

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 sólo tiene el efecto de cortar cualquier valores decimales. Si usted necesita un Int que podría 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

Hasta

x.rounded(.up)

Esto es lo contrario de .down. Todos los números decimales se redondean. Este es el 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 se olvide de tomar valores negativos en cuenta.
• Los resultados de round y rounded siguen siendo CGFloat. Si necesita un Int tienes que convertirlo como Int(myCGFloat).
• No hay necesidad de utilizar las funciones matemáticas round(x) C, ceil(x) y floor(x) más. Sin embargo, si usted hace uso de ellos, que manejan tanto la arquitectura de 64 bits y 32 por lo que cualquier respuesta que puede haber visto con roundf, ceilf y floorf se han quedado obsoletas.

Answer 3

A CGFloat es typedef'd ya sea a un double o una float, por lo que puede redondear ellos como cualquier otro tipo de bienes:

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

Tenga en cuenta que mientras que esto funciona con los flotadores lo suficientemente pequeño como para llevar a una fracción, podrá actuar raro en los valores grandes.

Answer 4

Trate #import "tgmath.h".

La cabecera <tgmath.h> incluirá la <math.h> cabeceras y <complex.h> y definirá varias macros de tipo genérico.

Answer 5

Se le reinventar la rueda - y esto es una pregunta C, no Objective C. Sólo tiene que utilizar la función de ronda patrón C ()

.

Answer 6

Para trabajar con 32 y 64 bits puede crear sus propias del macro como

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

Sal esto no es una respuesta para la pregunta, pero una adición a la pregunta acerca de cómo trabajar con valores de 32/64 bits.

Definir esto en un archivo como MyMacros.h y de añadir una importación en el miaplicacion-Prefix.pch

Asimismo, recuerda que la elección de CGFloat como prefijo para su función puede ser un riesgo, ya que Apple podría añadir una macro como esto ellos mismo modo que es la razón por la #ifndef CGFLOAT_CEIL es