Numbers

Nombre

Supertype abstrait pour tous les types de nombres.

Real <: Number

Supertype abstrait pour tous les nombres réels.

AbstractFloat <: Real

Supertype abstrait pour tous les nombres à virgule flottante.

Integer <: Real

Supertype abstrait pour tous les entiers (par exemple Signed, Unsigned, et Bool).

Voir aussi isinteger, trunc, div.

Exemples

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

Supertype abstrait pour tous les entiers signés.

Unsigned <: Integer

Supertype abstrait pour tous les entiers non signés.

Les entiers non signés intégrés sont imprimés en hexadécimal, avec le préfixe 0x, et peuvent être saisis de la même manière.

Exemples

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

Type numérique représentant une valeur irrationnelle exacte, qui est automatiquement arrondie à la précision correcte dans les opérations arithmétiques avec d'autres quantités numériques.

Les sous-types MyIrrational <: AbstractIrrational doivent implémenter au moins ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), et convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}.

Si un sous-type est utilisé pour représenter des valeurs qui peuvent occasionnellement être rationnelles (par exemple, un type de racine carrée qui représente √n pour des entiers n donnera un résultat rationnel lorsque n est un carré parfait), il doit également implémenter isinteger, iszero, isone, et == avec des valeurs Real (puisque tous ces derniers par défaut renvoient false pour les types AbstractIrrational), ainsi que définir hash pour être égal à celui du Rational correspondant.

Float16 <: AbstractFloat <: Real

Type de nombre à virgule flottante 16 bits (norme IEEE 754). Le format binaire est 1 bit de signe, 5 bits d'exposant, 10 bits de fraction.

Float32 <: AbstractFloat <: Real

Type de nombre à virgule flottante 32 bits (norme IEEE 754). Le format binaire est 1 signe, 8 exposants, 23 bits de fraction.

L'exposant pour la notation scientifique doit être saisi en minuscules f, donc 2f3 === 2.0f0 * 10^3 === Float32(2_000). Pour les littéraux de tableau et les compréhensions, le type d'élément peut être spécifié avant les crochets : Float32[1,4,9] == Float32[i^2 for i in 1:3].

Voir aussi Inf32, NaN32, Float16, exponent, frexp.

Float64 <: AbstractFloat <: Real

Type de nombre à virgule flottante 64 bits (norme IEEE 754). Le format binaire est 1 bit de signe, 11 bits d'exposant, 52 bits de fraction. Voir bitstring, signbit, exponent, frexp, et significand pour accéder à divers bits.

C'est le type par défaut pour les littéraux à virgule flottante, 1.0 isa Float64, et pour de nombreuses opérations telles que 1/2, 2pi, log(2), range(0,90,length=4). Contrairement aux entiers, ce type par défaut ne change pas avec Sys.WORD_SIZE.

L'exposant pour la notation scientifique peut être saisi sous la forme e ou E, donc 2e3 === 2.0E3 === 2.0 * 10^3. Il est fortement recommandé de le faire plutôt que d'utiliser 10^n car les entiers peuvent déborder, donc 2.0 * 10^19 < 0 mais 2e19 > 0.

Voir aussi Inf, NaN, floatmax, Float32, Complex.

BigFloat <: AbstractFloat

Type de nombre à virgule flottante à précision arbitraire.

Bool <: Integer

Type booléen, contenant les valeurs true et false.

Bool est une sorte de nombre : false est numériquement égal à 0 et true est numériquement égal à 1. De plus, false agit comme un "zéro fort" multiplicatif contre NaN et Inf :

julia> [true, false] == [1, 0]
true

julia> 42.0 + true
43.0

julia> 0 .* (NaN, Inf, -Inf)
(NaN, NaN, NaN)

julia> false .* (NaN, Inf, -Inf)
(0.0, 0.0, -0.0)

Les branches via if et d'autres conditionnels n'acceptent que Bool. Il n'y a pas de valeurs "véridiques" en Julia.

Les comparaisons retournent généralement Bool, et les comparaisons diffusées peuvent retourner BitArray au lieu d'un Array{Bool}.

julia> [1 2 3 4 5] .< pi
1×5 BitMatrix:
 1  1  1  0  0

julia> map(>(pi), [1 2 3 4 5])
1×5 Matrix{Bool}:
 0  0  0  1  1

Voir aussi trues, falses, ifelse.

Int8 <: Signed <: Integer

Type d'entier signé de 8 bits.

Représente des nombres n ∈ -128:127. Notez que de tels entiers débordent sans avertissement, donc typemax(Int8) + Int8(1) < 0.

Voir aussi Int, widen, BigInt.

UInt8 <: Unsigned <: Integer

Type d'entier non signé de 8 bits.

Imprimé en hexadécimal, donc 0x07 == 7.

Int16 <: Signed <: Integer

Type d'entier signé de 16 bits.

Représente des nombres n ∈ -32768:32767. Notez que de tels entiers débordent sans avertissement, donc typemax(Int16) + Int16(1) < 0.

Voir aussi Int, widen, BigInt.

UInt16 <: Unsigned <: Integer

Type d'entier non signé de 16 bits.

Imprimé en hexadécimal, donc 0x000f == 15.

Int32 <: Signed <: Integer

Type d'entier signé 32 bits.

Notez que de tels entiers débordent sans avertissement, donc typemax(Int32) + Int32(1) < 0.

Voir aussi Int, widen, BigInt.

UInt32 <: Unsigned <: Integer

Type d'entier non signé de 32 bits.

Imprimé en hexadécimal, donc 0x0000001f == 31.

Int64 <: Signed <: Integer

Type d'entier signé 64 bits.

Notez que de tels entiers débordent sans avertissement, donc typemax(Int64) + Int64(1) < 0.

Voir aussi Int, widen, BigInt.

UInt64 <: Unsigned <: Integer

Type d'entier non signé de 64 bits.

Imprimé en hexadécimal, donc 0x000000000000003f == 63.

Int128 <: Signed <: Integer

Type d'entier signé de 128 bits.

Notez que de tels entiers débordent sans avertissement, donc typemax(Int128) + Int128(1) < 0.

Voir aussi Int, widen, BigInt.

UInt128 <: Unsigned <: Integer

Type d'entier non signé de 128 bits.

Imprimé en hexadécimal, donc 0x0000000000000000000000000000007f == 127.

Int

Type entier signé de Sys.WORD_SIZE bits, Int <: Signed <: Integer <: Real.

C'est le type par défaut de la plupart des littéraux entiers et c'est un alias pour Int32 ou Int64, selon Sys.WORD_SIZE. C'est le type retourné par des fonctions telles que length, et le type standard pour l'indexation des tableaux.

Notez que les entiers débordent sans avertissement, donc typemax(Int) + 1 < 0 et 10^19 < 0. Le débordement peut être évité en utilisant BigInt. Des littéraux entiers très grands utiliseront un type plus large, par exemple 10_000_000_000_000_000_000 isa Int128.

La division entière est div alias ÷, tandis que / agissant sur des entiers retourne Float64.

Voir aussi Int64, widen, typemax, bitstring.

UInt

Type entier non signé de taille Sys.WORD_SIZE bits, UInt <: Unsigned <: Integer.

Comme Int, l'alias UInt peut pointer soit vers UInt32 soit vers UInt64, selon la valeur de Sys.WORD_SIZE sur un ordinateur donné.

Imprimé et analysé en hexadécimal : UInt(15) === 0x000000000000000f.

BigInt <: Signed

Type d'entier à précision arbitraire.

Complex{T<:Réel} <: Nombre

Type de nombre complexe avec une partie réelle et une partie imaginaire de type T.

ComplexF16, ComplexF32 et ComplexF64 sont des alias pour Complex{Float16}, Complex{Float32} et Complex{Float64} respectivement.

Voir aussi : Réel, complex, real.

Rational{T<:Integer} <: Réel

Type de nombre rationnel, avec un numérateur et un dénominateur de type T. Les rationnels sont vérifiés pour les débordements.

Irrational{sym} <: AbstractIrrational

Type de nombre représentant une valeur irrationnelle exacte désignée par le symbole sym, tel que π, ℯ et γ.

Voir aussi AbstractIrrational.

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

Renvoie un tableau avec un type d'élément T (par défaut Int) des chiffres de n dans la base donnée, éventuellement complété par des zéros à une taille spécifiée. Les chiffres les plus significatifs se trouvent à des indices plus élevés, de sorte que n == sum(digits[k]*base^(k-1) for k in eachindex(digits)).

Voir aussi ndigits, digits!, et pour la base 2 également bitstring, count_ones.

Exemples

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

Remplit un tableau des chiffres de n dans la base donnée. Les chiffres les plus significatifs se trouvent à des indices plus élevés. Si la longueur du tableau est insuffisante, les chiffres les moins significatifs sont remplis jusqu'à la longueur du tableau. Si la longueur du tableau est excessive, la portion excédentaire est remplie de zéros.

Exemples

julia> digits!([2, 2, 2, 2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

Une chaîne donnant la représentation binaire littérale d'un type primitif.

Voir aussi count_ones, count_zeros, digits.

Exemples

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(::Type{SimpleColor}, rgb::String)

Un analogue de tryparse(SimpleColor, rgb::String) (voir ci-dessus), qui lève une erreur au lieu de retourner nothing.

parse(::Type{Platform}, triplet::AbstractString)

Analyse une chaîne de caractères triplet de plateforme et la convertit en un objet Platform.

parse(type, str; base)

Analyse une chaîne de caractères comme un nombre. Pour les types Integer, une base peut être spécifiée (la valeur par défaut est 10). Pour les types à virgule flottante, la chaîne est analysée comme un nombre à virgule flottante décimal. Les types Complex sont analysés à partir de chaînes décimales de la forme "R±Iim" comme un Complex(R,I) du type demandé ; "i" ou "j" peuvent également être utilisés à la place de "im", et "R" ou "Iim" sont également autorisés. Si la chaîne ne contient pas un nombre valide, une erreur est levée.

Exemples

julia> parse(Int, "1234")
1234

julia> parse(Int, "1234", base = 5)
194

julia> parse(Int, "afc", base = 16)
2812

julia> parse(Float64, "1.2e-3")
0.0012

julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
0.32 + 4.5im

tryparse(::Type{SimpleColor}, rgb::String)

Tente de parser rgb en tant que SimpleColor. Si rgb commence par # et a une longueur de 7, il est converti en un SimpleColor soutenu par un RGBTuple. Si rgb commence par a-z, rgb est interprété comme un nom de couleur et converti en un SimpleColor soutenu par un Symbol.

Sinon, nothing est retourné.

Exemples

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

Comme parse, mais renvoie soit une valeur du type demandé, soit nothing si la chaîne ne contient pas un nombre valide.

big(x)

Convertir un nombre en une représentation de précision maximale (typiquement BigInt ou BigFloat). Voir BigFloat pour des informations sur certains pièges avec les nombres à virgule flottante.

signed(T::Integer)

Convertir un type de bit entier en type signé de la même taille.

Exemples

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

Convertit un nombre en un entier signé. Si l'argument est non signé, il est réinterprété comme signé sans vérifier le débordement.

Voir aussi : unsigned, sign, signbit.

unsigned(T::Integer)

Convertir un type entier en un type non signé de la même taille.

Exemples

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

Convertir un nombre ou un tableau en un type de données à virgule flottante.

Voir aussi : complex, oftype, convert.

Exemples

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

Extraire le significand (a.k.a. mantisse) d'un nombre à virgule flottante. Si x est un nombre fini non nul, alors le résultat sera un nombre du même type et signe que x, et dont la valeur absolue est dans l'intervalle $[1,2)$. Sinon, x est retourné.

Voir aussi frexp, exponent.

Exemples

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

julia> significand(-15.2) * 2^3
-15.2

julia> significand(-Inf), significand(Inf), significand(NaN)
(-Inf, Inf, NaN)

exponent(x::Real) -> Int

Renvoie le plus grand entier y tel que 2^y ≤ abs(x).

Lève une DomainError lorsque x est zéro, infini, ou NaN. Pour tout autre nombre à virgule flottante non subnormal x, cela correspond aux bits d'exposant de x.

Voir aussi signbit, significand, frexp, issubnormal, log2, ldexp.

Exemples

julia> exponent(8)
3

julia> exponent(6.5)
2

julia> exponent(-1//4)
-2

julia> exponent(3.142e-4)
-12

julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
(-126, -149)

julia> exponent(0.0)
ERROR: DomainError with 0.0:
Cannot be ±0.0.
[...]

complex(r, [i])

Convertir des nombres réels ou des tableaux en complexes. i est par défaut égal à zéro.

Exemples

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Vector{Complex{Int64}}:
 1 + 0im
 2 + 0im
 3 + 0im

bswap(n)

Inverse l'ordre des octets de n.

(Voir aussi ntoh et hton pour convertir entre l'ordre des octets natif actuel et l'ordre big-endian.)

Exemples

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

hex2bytes(itr)

Étant donné un itérable itr de codes ASCII pour une séquence de chiffres hexadécimaux, renvoie un Vector{UInt8} d'octets correspondant à la représentation binaire : chaque paire successive de chiffres hexadécimaux dans itr donne la valeur d'un octet dans le vecteur de retour.

La longueur de itr doit être paire, et le tableau retourné a la moitié de la longueur de itr. Voir aussi hex2bytes! pour une version en place, et bytes2hex pour l'inverse.

Exemples

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

Convertir un itérable itr d'octets représentant une chaîne hexadécimale en sa représentation binaire, similaire à hex2bytes sauf que la sortie est écrite en place dans dest. La longueur de dest doit être la moitié de la longueur de itr.

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

Convertit un itérateur itr d'octets en sa représentation sous forme de chaîne hexadécimale, soit en retournant une String via bytes2hex(itr), soit en écrivant la chaîne dans un flux io via bytes2hex(io, itr). Les caractères hexadécimaux sont tous en minuscules.

Exemples

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

Retourne une identité multiplicative pour x : une valeur telle que one(x)*x == x*one(x) == x. Alternativement, one(T) peut prendre un type T, auquel cas one retourne une identité multiplicative pour tout x de type T.

Si possible, one(x) retourne une valeur du même type que x, et one(T) retourne une valeur de type T. Cependant, cela peut ne pas être le cas pour les types représentant des quantités dimensionnelles (par exemple, le temps en jours), puisque l'identité multiplicative doit être sans dimension. Dans ce cas, one(x) devrait retourner une valeur d'identité de la même précision (et forme, pour les matrices) que x.

Si vous voulez une quantité qui est du même type que x, ou de type T, même si x est dimensionnelle, utilisez oneunit à la place.

Voir aussi la fonction identity, et I dans LinearAlgebra pour la matrice identité.

Exemples

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

oneunit(x::T)
oneunit(T::Type)

Retourne T(one(x)), où T est soit le type de l'argument soit (si un type est passé) l'argument. Cela diffère de one pour les quantités dimensionnelles : one est sans dimension (une identité multiplicative) tandis que oneunit est dimensionnelle (du même type que x, ou de type T).

Exemples

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 jour

zero(x)
zero(::Type)

Obtenez l'élément d'identité additive pour le type de x (x peut également spécifier le type lui-même).

Voir aussi iszero, one, oneunit, oftype.

Exemples

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

L'unité imaginaire.

Voir aussi : imag, angle, complex.

Exemples

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

La constante pi.

Unicode π peut être tapé en écrivant \pi puis en appuyant sur tab dans le REPL Julia, et dans de nombreux éditeurs.

Voir aussi : sinpi, sincospi, deg2rad.

Exemples

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

La constante ℯ.

Unicode ℯ peut être tapé en écrivant \euler et en appuyant sur tab dans le REPL Julia, et dans de nombreux éditeurs.

Voir aussi : exp, cis, cispi.

Exemples

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

constante de Catalan.

# Exemples

jldoctest julia> Base.MathConstants.catalan catalan = 0.9159655941772...

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01 0.9159466120554123 ```

γ
eulergamma

La constante d'Euler.

Exemples

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133

φ
golden

Le nombre d'or.

Exemples

julia> Base.MathConstants.golden
φ = 1.6180339887498...

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

L'infini positif de type Float64.

Voir aussi : isfinite, typemax, NaN, Inf32.

Exemples

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf, Inf64

L'infini positif de type Float64.

Voir aussi : isfinite, typemax, NaN, Inf32.

Exemples

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

Infini positif de type Float32.

Inf16

L'infini positif de type Float16.

NaN, NaN64

Une valeur not-a-number de type Float64.

Voir aussi : isnan, missing, NaN32, Inf.

Exemples

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN, NaN64

Une valeur not-a-number de type Float64.

Voir aussi : isnan, missing, NaN32, Inf.

Exemples

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN32

Une valeur not-a-number de type Float32.

Voir aussi : NaN.

NaN16

Une valeur not-a-number de type Float16.

Voir aussi : NaN.

issubnormal(f) -> Bool

Testez si un nombre à virgule flottante est subnormal.

Un nombre à virgule flottante IEEE est subnormal lorsque ses bits d'exposant sont zéro et que son significand n'est pas zéro.

Exemples

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

Teste si un nombre est fini.

Exemples

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

Testez si un nombre est infini.

Voir aussi : Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

Testez si une valeur numérique est un NaN, une valeur indéterminée qui n'est ni une infinité ni un nombre fini ("pas un nombre").

Voir aussi : iszero, isone, isinf, ismissing.

iszero(x)

Renvoie true si x == zero(x) ; si x est un tableau, cela vérifie si tous les éléments de x sont zéro.

Voir aussi : isone, isinteger, isfinite, isnan.

Exemples

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

isone(x)

Retourne true si x == one(x); si x est un tableau, cela vérifie si x est une matrice identité.

Exemples

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

nextfloat(x::AbstractFloat, n::Integer)

Le résultat de n applications itératives de nextfloat à x si n >= 0, ou -n applications de prevfloat si n < 0.

nextfloat(x::AbstractFloat)

Retourne le plus petit nombre à virgule flottante y du même type que x tel que x < y. Si aucun y de ce type n'existe (par exemple si x est Inf ou NaN), alors retourne x.

Voir aussi : prevfloat, eps, issubnormal.

prevfloat(x::AbstractFloat, n::Integer)

Le résultat de n applications itératives de prevfloat à x si n >= 0, ou -n applications de nextfloat si n < 0.

prevfloat(x::AbstractFloat)

Retourne le plus grand nombre à virgule flottante y du même type que x tel que y < x. Si aucun y de ce type n'existe (par exemple, si x est -Inf ou NaN), alors retourne x.

isinteger(x) -> Bool

Testez si x est numériquement égal à un entier.

Exemples

julia> isinteger(4.0)
true

isreal(x) -> Bool

Teste si x ou tous ses éléments sont numériquement égaux à un nombre réel, y compris les infinis et les NaNs. isreal(x) est vrai si isequal(x, real(x)) est vrai.

Exemples

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Float32(x [, mode::RoundingMode])

Crée un Float32 à partir de x. Si x n'est pas exactement représentable, alors mode détermine comment x est arrondi.

Exemples

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

Voir RoundingMode pour les modes d'arrondi disponibles. ```

Float64(x [, mode::RoundingMode])

Crée un Float64 à partir de x. Si x n'est pas exactement représentable, alors mode détermine comment x est arrondi.

Exemples

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

Voir RoundingMode pour les modes d'arrondi disponibles.

rounding(T)

Obtenez le mode d'arrondi flottant actuel pour le type T, contrôlant l'arrondi des fonctions arithmétiques de base (+, -, *, / et sqrt) et la conversion de type.

Voir RoundingMode pour les modes disponibles.

setrounding(T, mode)

Définir le mode d'arrondi du type de point flottant T, contrôlant l'arrondi des fonctions arithmétiques de base (+, -, *, / et sqrt) et la conversion de type. D'autres fonctions numériques peuvent donner des valeurs incorrectes ou invalides lors de l'utilisation de modes d'arrondi autres que le mode par défaut RoundNearest.

Notez que cela n'est actuellement pris en charge que pour T == BigFloat.

setrounding(f::Function, T, mode)

Changez le mode d'arrondi du type de point flottant T pour la durée de f. Cela équivaut logiquement à :

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

Voir RoundingMode pour les modes d'arrondi disponibles.

get_zero_subnormals() -> Bool

Retourne false si les opérations sur les valeurs flottantes subnormales ("denormals") respectent les règles de l'arithmétique IEEE, et true si elles pourraient être converties en zéros.

set_zero_subnormals(yes::Bool) -> Bool

Si yes est false, les opérations en virgule flottante suivantes suivent les règles de l'arithmétique IEEE sur les valeurs subnormales ("denormals"). Sinon, les opérations en virgule flottante sont autorisées (mais pas obligatoires) à convertir les entrées ou sorties subnormales en zéro. Renvoie true sauf si yes==true mais le matériel ne prend pas en charge la mise à zéro des nombres subnormaux.

set_zero_subnormals(true) peut accélérer certains calculs sur certains matériels. Cependant, cela peut rompre des identités telles que (x-y==0) == (x==y).

count_ones(x::Integer) -> Integer

Nombre de uns dans la représentation binaire de x.

Exemples

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

Nombre de zéros dans la représentation binaire de x.

Exemples

julia> count_zeros(Int32(2 ^ 16 - 1))
16

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

Nombre de zéros précédant la représentation binaire de x.

Exemples

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

Nombre de uns menant la représentation binaire de x.

Exemples

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

trailing_zeros(x::Integer) -> Integer

Nombre de zéros à la fin de la représentation binaire de x.

Exemples

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

Nombre de uns à la fin de la représentation binaire de x.

Exemples

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

Retourne true si x est un entier impair (c'est-à-dire un entier non divisible par 2), et false sinon.

Exemples

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

Retourne true si x est un entier pair (c'est-à-dire un entier divisible par 2), et false sinon.

Exemples

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

Analyse str comme un Int128. Lancez une ArgumentError si la chaîne n'est pas un entier valide.

Exemples

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]

@uint128_str str

Analyse str comme un UInt128. Lancez une ArgumentError si la chaîne n'est pas un entier valide.

Exemples

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
[...]

BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

Créez un nombre à virgule flottante de précision arbitraire à partir de x, avec une précision precision. L'argument rounding spécifie la direction dans laquelle le résultat doit être arrondi si la conversion ne peut pas être effectuée exactement. S'il n'est pas fourni, ceux-ci sont définis par les valeurs globales actuelles.

BigFloat(x::Real) est identique à convert(BigFloat,x), sauf si x est déjà un BigFloat, auquel cas il renverra une valeur avec la précision définie par la précision globale actuelle ; convert renverra toujours x.

BigFloat(x::AbstractString) est identique à parse. Cela est fourni pour la commodité puisque les littéraux décimaux sont convertis en Float64 lors de l'analyse, donc BigFloat(2.1) peut ne pas donner ce que vous attendez.

Voir aussi :

• @big_str
• rounding et setrounding
• precision et setprecision

Exemples

julia> BigFloat(2.1) # 2.1 ici est un Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # le BigFloat le plus proche de 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

Obtenez la précision d'un nombre à virgule flottante, telle que définie par le nombre effectif de bits dans le significand, ou la précision d'un type à virgule flottante T (sa valeur par défaut actuelle, si T est un type à précision variable comme BigFloat).

Si base est spécifié, alors il renvoie le nombre maximum correspondant de chiffres de significand dans cette base.

setprecision([T=BigFloat,] precision::Int; base=2)

Définissez la précision (en bits, par défaut) à utiliser pour l'arithmétique de T. Si base est spécifié, alors la précision est le minimum requis pour donner au moins precision chiffres dans la base donnée.

setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

Changez la précision arithmétique de T (dans la base donnée) pour la durée de f. C'est logiquement équivalent à :

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

Souvent utilisé sous la forme setprecision(T, precision) do ... end

Note : nextfloat(), prevfloat() n'utilisent pas la précision mentionnée par setprecision.

BigInt(x)

Créez un entier à précision arbitraire. x peut être un Int (ou tout ce qui peut être converti en Int). Les opérateurs mathématiques habituels sont définis pour ce type, et les résultats sont promus à un BigInt.

Des instances peuvent être construites à partir de chaînes via parse, ou en utilisant le littéral de chaîne big.

Exemples

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

Analyse une chaîne de caractères en un BigInt ou un BigFloat, et lance une ArgumentError si la chaîne n'est pas un nombre valide. Pour les entiers, _ est autorisé dans la chaîne comme séparateur.

Exemples

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: format de nombre invalide _ pour BigInt ou BigFloat
[...]