Réponses:
Utiliser Math.round()
, éventuellement en conjonction avecMidpointRounding.AwayFromZero
par exemple:
Math.Round(1.2) ==> 1
Math.Round(1.5) ==> 2
Math.Round(2.5) ==> 2
Math.Round(2.5, MidpointRounding.AwayFromZero) ==> 3
double d = 1.234;
int i = Convert.ToInt32(d);
Gère les arrondis comme ceci:
arrondi à l'entier signé 32 bits le plus proche. Si la valeur est à mi-chemin entre deux nombres entiers, le nombre pair est renvoyé; autrement dit, 4,5 est converti en 4 et 5,5 est converti en 6.
Math.Round
car il renvoie un int comme requis.
[0,.5)
- vers le bas et exactement la moitié des nombres - [.5,1)
- vers le haut. Arrondir à même légèrement biaiser les nombres pairs, car il arrondit (.5,1.5)
à 1 mais [1.5,2.5]
à 2.
Vous pouvez également utiliser la fonction:
//Works with negative numbers now
static int MyRound(double d) {
if (d < 0) {
return (int)(d - 0.5);
}
return (int)(d + 0.5);
}
Selon l'architecture, c'est plusieurs fois plus rapide.
double d;
int rounded = (int)Math.Round(d);
Je sais que cette question est ancienne, mais je l'ai rencontrée en cherchant la réponse à ma question similaire. J'ai pensé partager le conseil très utile qui m'a été donné.
Lors de la conversion en int, ajoutez simplement .5
à votre valeur avant le downcasting. Comme le downcasting int
tombe toujours au nombre inférieur (par exemple (int)1.7 == 1
), si votre nombre est .5
ou supérieur, l'ajout .5
le ramènera au nombre suivant et votre downcast int
devrait renvoyer la valeur correcte. (par exemple (int)(1.8 + .5) == 2
)
+ 0.5 * Math.Abs(d)
Les méthodes d'autres réponses lancent OverflowException
si la valeur flottante est en dehors de la plage Int. https://docs.microsoft.com/en-us/dotnet/api/system.convert.toint32?view=netframework-4.8#System_Convert_ToInt32_System_Single_
int result = 0;
try {
result = Convert.ToInt32(value);
}
catch (OverflowException) {
if (value > 0) result = int.MaxValue;
else result = int.Minvalue;
}
Pour Unity, utilisez Mathf.RoundToInt .
using UnityEngine;
public class ExampleScript : MonoBehaviour
{
void Start()
{
// Prints 10
Debug.Log(Mathf.RoundToInt(10.0f));
// Prints 10
Debug.Log(Mathf.RoundToInt(10.2f));
// Prints 11
Debug.Log(Mathf.RoundToInt(10.7f));
// Prints 10
Debug.Log(Mathf.RoundToInt(10.5f));
// Prints 12
Debug.Log(Mathf.RoundToInt(11.5f));
// Prints -10
Debug.Log(Mathf.RoundToInt(-10.0f));
// Prints -10
Debug.Log(Mathf.RoundToInt(-10.2f));
// Prints -11
Debug.Log(Mathf.RoundToInt(-10.7f));
// Prints -10
Debug.Log(Mathf.RoundToInt(-10.5f));
// Prints -12
Debug.Log(Mathf.RoundToInt(-11.5f));
}
}
public static int RoundToInt(float f) { return (int)Math.Round(f); }
Je développe une calculatrice scientifique qui arbore un bouton Int. J'ai trouvé ce qui suit est une solution simple et fiable:
double dblInteger;
if( dblNumber < 0 )
dblInteger = Math.Ceiling(dblNumber);
else
dblInteger = Math.Floor(dblNumber);
Math.Round produit parfois des résultats inattendus ou indésirables, et la conversion explicite en entier (via cast ou Convert.ToInt ...) produit souvent des valeurs erronées pour les nombres de plus haute précision. La méthode ci-dessus semble toujours fonctionner.
Convert.ToInt32()
fera- t-il pas la même chose ou supprimera-t-il simplement tout après la virgule?