float
Un type intégré pour les nombres à virgule flottante.
Description
Le type intégré float est un nombre à virgule flottante en double précision de 64 bits, équivalent à double en C++. Ce type a 14 chiffres décimaux fiables de précision. La valeur maximale de float est d'environ 1.79769e308, et le minimum est d'environ -1.79769e308.
Beaucoup de méthodes et de propriétés dans le moteur utilisent des nombre à virgule flottante de 32 bits, équivalents à float en C++, qui a 6 chiffres décimaux fiables de précision. Pour les structures de données telles que Vector2 et Vector3, Godot utilise par défaut des nombres flottants de 32 bits, mais il peut être modifié pour utiliser des doubles de 64 bits si Godot est compilé avec l'option precision=double.
Les mathématiques effectuées en utilisant le type float ne sont pas garanties d'être exactes et entraîneront souvent de petites erreurs. Vous devriez généralement utiliser les méthodes @GlobalScope.is_equal_approx() et @GlobalScope.is_zero_approx() au lieu de == pour comparer les valeurs float pour l'égalité.
Tutoriels
Constructeurs
float() |
|
Opérateurs
operator !=(right: float) |
|
operator !=(right: int) |
|
operator *(right: Color) |
|
operator *(right: Quaternion) |
|
operator *(right: Vector2) |
|
operator *(right: Vector2i) |
|
operator *(right: Vector3) |
|
operator *(right: Vector3i) |
|
operator *(right: Vector4) |
|
operator *(right: Vector4i) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator **(right: float) |
|
operator **(right: int) |
|
operator +(right: float) |
|
operator +(right: int) |
|
operator -(right: float) |
|
operator -(right: int) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: float) |
|
operator <(right: int) |
|
operator <=(right: float) |
|
operator <=(right: int) |
|
operator ==(right: float) |
|
operator ==(right: int) |
|
operator >(right: float) |
|
operator >(right: int) |
|
operator >=(right: float) |
|
operator >=(right: int) |
|
Descriptions des constructeurs
Construit un float initialisé par défaut, à 0.0.
Construit un float en tant que copie du float donné.
Convertit un String en un float, en suivant les mêmes règles que String.to_float().
Transforme un bool en flottant, float(true) sera égal à 1.0 et float(false) à 0.0.
Cast une valeur int en un flottant, float(1) sera égale à 1.0.
Descriptions des opérateurs
bool operator !=(right: float) 🔗
Renvoie true si deux flottant sont différents l'un de l'autre
Note : @GDScript.NAN ne se comporte pas comme les autres nombres. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator !=(right: int) 🔗
Renvoie true si l'entier a une valeur différente de celle du flottant.
Color operator *(right: Color) 🔗
Multiplie chaque composante de la couleur Color, y compris l'alpha, par le flottant float donné.
print(1.5 * Color(0.5, 0.5, 0.5)) # Affiche (0.75, 0.75, 0.75, 1.5)
Quaternion operator *(right: Quaternion) 🔗
Multiplie chaque composante du Quaternion par le flottant float donné. Cette opération ne veut rien dire seule, mais peut-être utilisée comme partie d'une plus grande expression.
Vector2 operator *(right: Vector2) 🔗
Multiplie chaque composante du Vector2 par le flottant float donné.
print(2.5 * Vector2(1, 3)) # Affiche (2.5, 7.5)
Vector2 operator *(right: Vector2i) 🔗
Multiplie chaque composante du Vector2i par le flottant float donné. Renvoie un Vector2.
print(0.9 * Vector2i(10, 15)) # Affiche (9.0, 13.5)
Vector3 operator *(right: Vector3) 🔗
Multiplie chaque composante du Vector3 par le flottant float donné.
Vector3 operator *(right: Vector3i) 🔗
Multiplie chaque composante du Vector3i par le flottant float donné. Renvoie un Vector3.
print(0.9 * Vector3i(10, 15, 20)) # Affiche (9.0, 13.5, 18.0)
Vector4 operator *(right: Vector4) 🔗
Multiplie chaque composante du Vector4 par le flottant float donné.
Vector4 operator *(right: Vector4i) 🔗
Multiplie chaque composante du Vector4i par le flottant float donné. Renvoie un Vector4.
print(0.9 * Vector4i(10, 15, 20, -10)) # Affiche (9.0, 13.5, 18.0, -9.0)
float operator *(right: float) 🔗
Multiplie deux float.
float operator *(right: int) 🔗
Multiplie un float et un int. Le résultat est un float.
float operator **(right: float) 🔗
Élève un float à la puissance d'un float.
print(39.0625**0.25) # 2.5
float operator **(right: int) 🔗
Élève un float à la puissance d'un int. Le résultat est un float.
print(0,9**3) # 0,729
float operator +(right: float) 🔗
Additionne deux flottants.
float operator +(right: int) 🔗
Additionne un float et un int. Le résultat est un float.
float operator -(right: float) 🔗
Soustrait un flottant d'un autre flottant.
float operator -(right: int) 🔗
Soustrait un int d'un float. Le résultat est un float.
float operator /(right: float) 🔗
Divise deux flottants.
float operator /(right: int) 🔗
Divise un float par un int. Le résultat est un float.
bool operator <(right: float) 🔗
Renvoie true si le flottant de gauche est inférieur à celui de droite.
Note : @GDScript.NAN ne se comporte pas comme les autres nombres. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
Renvoie true si ce float est inférieur au int donné.
bool operator <=(right: float) 🔗
Renvoie true si le flottant de gauche est inférieur ou égal à celui de droite.
Note : @GDScript.NAN ne se comporte pas comme les autres nombres. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator <=(right: int) 🔗
Renvoie true si ce float est inférieur ou égal au int donné.
bool operator ==(right: float) 🔗
Renvoie true si les deux flottants sont exactement égaux.
Note : À cause des erreurs de précision des flottants, envisagez d'utiliser @GlobalScope.is_equal_approx() ou @GlobalScope.is_zero_approx() à la place, qui sont plus fiables.
Note : @GDScript.NAN ne se comporte pas comme les autres nombres. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator ==(right: int) 🔗
Renvoie true si le float et le int donné sont égaux.
bool operator >(right: float) 🔗
Renvoie true si le flottant de gauche est supérieur à celui de droite.
Note : @GDScript.NAN ne se comporte pas comme les autres nombres. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
Renvoie true si ce float est supérieur au int donné.
bool operator >=(right: float) 🔗
Renvoie true si le flottant gauche est supérieur ou égal à celui de droite.
Note : @GDScript.NAN ne se comporte pas comme les autres nombres. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator >=(right: int) 🔗
Renvoie true si ce float est supérieur ou égal au int donné.
Renvoie la même valeur comme si + n'était pas là. Le + unaire ne fait rien, mais peut parfois rendre votre code plus lisible.
Renvoie la valeur négative du float. Si positif, rend le nombre négatif. Si négatif, rend le nombre positif. Avec des flottants, le nombre zéro peut être positif ou négatif.