Mathematics

-(x)

Opérateur unaire moins.

Voir aussi : abs, flipsign.

Exemples

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
 -1  -2
 -3  -4

julia> -(true)  # promeut en Int
-1

julia> -(0x003)
0xfffd

dt::Date + t::Time -> DateTime

L'addition d'une Date avec un Time produit un DateTime. Les parties heure, minute, seconde et milliseconde du Time sont utilisées avec l'année, le mois et le jour de la Date pour créer le nouveau DateTime. Des microsecondes ou des nanosecondes non nulles dans le type Time entraîneront le lancement d'une InexactError.

+(x, y...)

Opérateur d'addition.

L'infixe x+y+z+... appelle cette fonction avec tous les arguments, c'est-à-dire +(x, y, z, ...), qui par défaut appelle alors (x+y) + z + ... en commençant par la gauche.

Notez que le débordement est possible pour la plupart des types entiers, y compris le Int par défaut, lors de l'addition de grands nombres.

Exemples

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

julia> [1,2] + [3,4]
2-element Vector{Int64}:
 4
 6

julia> typemax(Int) + 1 < 0
true

-(x, y)

Opérateur de soustraction.

Exemples

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

Opérateur de multiplication.

L'infixe x*y*z*... appelle cette fonction avec tous les arguments, c'est-à-dire *(x, y, z, ...), qui par défaut appelle alors (x*y) * z * ... en commençant par la gauche.

La juxtaposition comme 2pi appelle également *(2, pi). Notez que cette opération a une priorité plus élevée qu'un * littéral. Notez également que la juxtaposition "0x..." (zéro entier multiplié par une variable dont le nom commence par x) est interdite car elle entre en conflit avec les littéraux d'entiers non signés : 0x01 isa UInt8.

Notez que le débordement est possible pour la plupart des types d'entiers, y compris le Int par défaut, lors de la multiplication de grands nombres.

Exemples

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # matrice * vecteur
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # la juxtaposition a une priorité plus élevée
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # vecteur adjoint * vecteur
5

/(x, y)

Opérateur de division à droite : multiplication de x par l'inverse de y à droite.

Donne des résultats en virgule flottante pour les arguments entiers. Voir ÷ pour la division entière, ou // pour les résultats Rational.

Exemples

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

La division à droite des matrices : A / B est équivalente à (B' \ A')' où \ est l'opérateur de division à gauche. Pour les matrices carrées, le résultat X est tel que A == X*B.

Voir aussi : rdiv!.

Exemples

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

\(x, y)

Opérateur de division à gauche : multiplication de y par l'inverse de x à gauche. Donne des résultats en virgule flottante pour des arguments entiers.

Exemples

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [4 3; 2 1]; x = [5, 6];

julia> A \ x
2-element Vector{Float64}:
  6.5
 -7.0

julia> inv(A) * x
2-element Vector{Float64}:
  6.5
 -7.0

^(x, y)

Opérateur d'exponentiation.

Si x et y sont des entiers, le résultat peut débordement. Pour entrer des nombres en notation scientifique, utilisez des littéraux Float64 tels que 1.2e3 plutôt que 1.2 * 10^3.

Si y est un littéral Int (par exemple 2 dans x^2 ou -3 dans x^-3), le code Julia x^y est transformé par le compilateur en Base.literal_pow(^, x, Val(y)), pour permettre une spécialisation à la compilation sur la valeur de l'exposant. (En tant que solution de secours par défaut, nous avons Base.literal_pow(^, x, Val(y)) = ^(x,y), où généralement ^ == Base.^ à moins que ^ n'ait été défini dans l'espace de noms appelant.) Si y est un littéral entier négatif, alors Base.literal_pow transforme l'opération en inv(x)^-y par défaut, où -y est positif.

Voir aussi exp2, <<.

Exemples

julia> 3^5
243

julia> 3^-1  # utilise Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERREUR : DomainError avec -1 :
Impossible d'élever un entier x à une puissance négative -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # débordement entier
false

julia> big(10)^19 == 1e19
true

fma(x, y, z)

Calcule x*y+z sans arrondir le résultat intermédiaire x*y. Sur certains systèmes, cela coûte significativement plus cher que x*y+z. fma est utilisé pour améliorer la précision dans certains algorithmes. Voir muladd.

muladd(x, y, z)

Multiplication-addition combinée : calcule x*y+z, mais permet de fusionner l'addition et la multiplication entre elles ou avec des opérations environnantes pour des performances optimales. Par exemple, cela peut être implémenté comme un fma si le matériel le prend en charge de manière efficace. Le résultat peut être différent sur différentes machines et peut également varier sur la même machine en raison de la propagation des constantes ou d'autres optimisations. Voir fma.

Exemples

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

Multiplication-addition combinée, A*y .+ z, pour la multiplication matrice-matrice ou matrice-vecteur. Le résultat est toujours de la même taille que A*y, mais z peut être plus petit, ou un scalaire.

Exemples

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

julia> muladd(A, B, z)
2×2 Matrix{Float64}:
   3.0    3.0
 107.0  107.0

inv(x)

Retourne l'inverse multiplicatif de x, tel que x*inv(x) ou inv(x)*x donne one(x) (l'identité multiplicative) jusqu'aux erreurs d'arrondi.

Si x est un nombre, c'est essentiellement la même chose que one(x)/x, mais pour certains types, inv(x) peut être légèrement plus efficace.

Exemples

julia> inv(2)
0.5

julia> inv(1 + 2im)
0.2 - 0.4im

julia> inv(1 + 2im) * (1 + 2im)
1.0 + 0.0im

julia> inv(2//3)
3//2

div(x, y)
÷(x, y)

Le quotient de la division euclidienne (entière). Généralement équivalent à une opération mathématique x/y sans partie fractionnaire.

Voir aussi : cld, fld, rem, divrem.

Exemples

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) avec eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

div(x, y, r::RoundingMode=RoundToZero)

Le quotient de la division euclidienne (entière). Calcule x / y, arrondi à un entier selon le mode d'arrondi r. En d'autres termes, la quantité

round(x / y, r)

sans aucun arrondi intermédiaire.

Voir aussi fld et cld, qui sont des cas particuliers de cette fonction.

Exemples :

julia> div(4, 3, RoundToZero) # Correspond à div(4, 3)
1
julia> div(4, 3, RoundDown) # Correspond à fld(4, 3)
1
julia> div(4, 3, RoundUp) # Correspond à cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

fld(x, y)

Plus grand entier inférieur ou égal à x / y. Équivalent à div(x, y, RoundDown).

Voir aussi div, cld, fld1.

Exemples

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) avec eltype Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

Parce que fld(x, y) implémente un arrondi à l'entier inférieur strictement correct basé sur la valeur réelle des nombres à virgule flottante, des situations non intuitives peuvent survenir. Par exemple :

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

Ce qui se passe ici, c'est que la valeur réelle du nombre à virgule flottante écrit comme 0.1 est légèrement supérieure à la valeur numérique 1/10 tandis que 6.0 représente le nombre 6 avec précision. Par conséquent, la valeur réelle de 6.0 / 0.1 est légèrement inférieure à 60. Lors de la division, cela est arrondi à précisément 60.0, mais fld(6.0, 0.1) prend toujours le plancher de la valeur réelle, donc le résultat est 59.0.

cld(x, y)

Plus petit entier supérieur ou égal à x / y. Équivalent à div(x, y, RoundUp).

Voir aussi div, fld.

Exemples

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) avec eltype Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

mod(x::Integer, r::AbstractUnitRange)

Trouvez y dans l'intervalle r tel que $x ≡ y (mod n)$, où n = length(r), c'est-à-dire y = mod(x - first(r), n) + first(r).

Voir aussi mod1.

Exemples

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

mod(x, y)
rem(x, y, RoundDown)

La réduction de x modulo y, ou équivalemment, le reste de x après division entière par y, c'est-à-dire x - y*fld(x,y) si calculé sans arrondi intermédiaire.

Le résultat aura le même signe que y, et une magnitude inférieure à abs(y) (avec quelques exceptions, voir la note ci-dessous).

Voir aussi : rem, div, fld, mod1, invmod.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

Trouvez y::T tel que x ≡ y (mod n), où n est le nombre d'entiers représentables dans T, et y est un entier dans [typemin(T),typemax(T)]. Si T peut représenter n'importe quel entier (par exemple, T == BigInt), alors cette opération correspond à une conversion en T.

Exemples

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

rem(x, y)
%(x, y)

Reste de la division euclidienne, retournant une valeur du même signe que x, et de magnitude inférieure à y. Cette valeur est toujours exacte.

Voir aussi : div, mod, mod1, divrem.

Exemples

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) avec eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

rem(x, y, r::RoundingMode=RoundToZero)

Calcule le reste de x après la division entière par y, avec le quotient arrondi selon le mode d'arrondi r. En d'autres termes, la quantité

x - y * round(x / y, r)

sans aucun arrondi intermédiaire.

• si r == RoundNearest, alors le résultat est exact, et dans l'intervalle $[-|y| / 2, |y| / 2]$. Voir aussi RoundNearest.
• si r == RoundToZero (par défaut), alors le résultat est exact, et dans l'intervalle $[0, |y|)$ si x est positif, ou $(-|y|, 0]$ sinon. Voir aussi RoundToZero.
• si r == RoundDown, alors le résultat est dans l'intervalle $[0, y)$ si y est positif, ou $(y, 0]$ sinon. Le résultat peut ne pas être exact si x et y ont des signes différents, et abs(x) < abs(y). Voir aussi RoundDown.
• si r == RoundUp, alors le résultat est dans l'intervalle $(-y, 0]$ si y est positif, ou $[0, -y)$ sinon. Le résultat peut ne pas être exact si x et y ont le même signe, et abs(x) < abs(y). Voir aussi RoundUp.
• si r == RoundFromZero, alors le résultat est dans l'intervalle $(-y, 0]$ si y est positif, ou $[0, -y)$ sinon. Le résultat peut ne pas être exact si x et y ont le même signe, et abs(x) < abs(y). Voir aussi RoundFromZero.

Exemples :

julia> x = 9; y = 4;

julia> x % y  # même que rem(x, y)
1

julia> x ÷ y  # même que div(x, y)
2

julia> x == div(x, y) * y + rem(x, y)
true

rem2pi(x, r::RoundingMode)

Calcule le reste de x après la division entière par 2π, avec le quotient arrondi selon le mode d'arrondi r. En d'autres termes, la quantité

x - 2π*round(x/(2π),r)

sans aucun arrondi intermédiaire. Cela utilise en interne une approximation de haute précision de 2π, et donnera donc un résultat plus précis que rem(x,2π,r)

• si r == RoundNearest, alors le résultat est dans l'intervalle $[-π, π]$. Cela sera généralement le résultat le plus précis. Voir aussi RoundNearest.
• si r == RoundToZero, alors le résultat est dans l'intervalle $[0, 2π]$ si x est positif, ou $[-2π, 0]$ sinon. Voir aussi RoundToZero.
• si r == RoundDown, alors le résultat est dans l'intervalle $[0, 2π]$. Voir aussi RoundDown.
• si r == RoundUp, alors le résultat est dans l'intervalle $[-2π, 0]$. Voir aussi RoundUp.

Exemples

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

mod2pi(x)

Modulus après division par 2π, retournant dans l'intervalle $[0,2π)$.

Cette fonction calcule une représentation en virgule flottante du modulus après division par 2π numériquement exact, et n'est donc pas exactement la même que mod(x,2π), qui calculerait le modulus de x par rapport à la division par le nombre en virgule flottante 2π.

Exemples

julia> mod2pi(9*pi/4)
0.7853981633974481

divrem(x, y, r::RoundingMode=RoundToZero)

Le quotient et le reste de la division euclidienne. Équivalent à (div(x, y, r), rem(x, y, r)). Équivalemment, avec la valeur par défaut de r, cet appel est équivalent à (x ÷ y, x % y).

Voir aussi : fldmod, cld.

Exemples

julia> divrem(3, 7)
(0, 3)

julia> divrem(7, 3)
(2, 1)

fldmod(x, y)

Le quotient arrondi et le module après la division. Un wrapper pratique pour divrem(x, y, RoundDown). Équivalent à (fld(x, y), mod(x, y)).

Voir aussi : fld, cld, fldmod1.

fld1(x, y)

Division entière, retournant une valeur cohérente avec mod1(x,y)

Voir aussi mod1, fldmod1.

Exemples

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

mod1(x, y)

Modulus après division par plancher, retournant une valeur r telle que mod(r, y) == mod(x, y) dans l'intervalle $(0, y]$ pour y positif et dans l'intervalle $[y,0)$ pour y négatif.

Avec des arguments entiers et un y positif, cela est égal à mod(x, 1:y), et donc naturel pour l'indexation à partir de 1. En comparaison, mod(x, y) == mod(x, 0:y-1) est naturel pour les calculs avec des décalages ou des pas.

Voir aussi mod, fld1, fldmod1.

Exemples

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) avec eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

fldmod1(x, y)

Retourne (fld1(x,y), mod1(x,y)).

Voir aussi fld1, mod1.

//(num, den)

Diviser deux entiers ou nombres rationnels, donnant un résultat de type Rational. Plus généralement, // peut être utilisé pour la division rationnelle exacte d'autres types numériques avec des composants entiers ou rationnels, tels que des nombres complexes avec des composants entiers.

Notez que les arguments à virgule flottante (AbstractFloat) ne sont pas autorisés par // (même si les valeurs sont rationnelles). Les arguments doivent être des sous-types de Integer, Rational, ou des composites de ceux-ci.

Exemples

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

julia> (1+2im) // (3+4im)
11//25 + 2//25*im

julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

Approxime le nombre à virgule flottante x en tant que nombre Rational avec des composants du type entier donné. Le résultat diffèrera de x de pas plus que tol.

Exemples

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

numerateur(x)

Numérateur de la représentation rationnelle de x.

Exemples

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

Dénominateur de la représentation rationnelle de x.

Exemples

julia> denominator(2//3)
3

julia> denominator(4)
1

<<(x, n)

Opérateur de décalage binaire à gauche, x << n. Pour n >= 0, le résultat est x décalé à gauche de n bits, rempli de 0s. Cela équivaut à x * 2^n. Pour n < 0, cela équivaut à x >> -n.

Exemples

julia> Int8(3) << 2
12

julia> bitstring(Int8(3))
"00000011"

julia> bitstring(Int8(12))
"00001100"

Voir aussi >>, >>>, exp2, ldexp.

<<(B::BitVector, n) -> BitVector

Opérateur de décalage de bits à gauche, B << n. Pour n >= 0, le résultat est B avec des éléments décalés de n positions vers l'arrière, remplis de valeurs false. Si n < 0, les éléments sont décalés vers l'avant. Équivalent à B >> -n.

Exemples

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

>>(x, n)

Opérateur de décalage à droite, x >> n. Pour n >= 0, le résultat est x décalé à droite de n bits, remplissant avec des 0 si x >= 0, des 1 si x < 0, préservant le signe de x. Cela équivaut à fld(x, 2^n). Pour n < 0, cela équivaut à x << -n.

Exemples

julia> Int8(13) >> 2
3

julia> bitstring(Int8(13))
"00001101"

julia> bitstring(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(-4))
"11111100"

Voir aussi >>>, <<.

>>(B::BitVector, n) -> BitVector

Opérateur de décalage à droite, B >> n. Pour n >= 0, le résultat est B avec des éléments décalés de n positions vers l'avant, remplis de valeurs false. Si n < 0, les éléments sont décalés vers l'arrière. Équivalent à B << -n.

Exemples

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitVector:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0

>>>(x, n)

Opérateur de décalage de bits à droite non signé, x >>> n. Pour n >= 0, le résultat est x décalé à droite de n bits, en remplissant avec des 0. Pour n < 0, cela équivaut à x << -n.

Pour les types d'entiers Unsigned, cela équivaut à >>. Pour les types d'entiers Signed, cela équivaut à signed(unsigned(x) >> n).

Exemples

julia> Int8(-14) >>> 2
60

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(60))
"00111100"

Les BigInt sont traités comme s'ils avaient une taille infinie, donc aucun remplissage n'est requis et cela équivaut à >>.

Voir aussi >>, <<.

>>>(B::BitVector, n) -> BitVector

Opérateur de décalage à droite non signé, B >>> n. Équivalent à B >> n. Voir >> pour des détails et des exemples.

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) implémente la rotation binaire. Il renvoie la valeur de x avec ses bits tournés à gauche k fois. Une valeur négative de k tournera à droite à la place.

Voir aussi : <<, circshift, BitArray.

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

:expr

Citez une expression expr, retournant l'arbre de syntaxe abstraite (AST) de expr. L'AST peut être de type Expr, Symbol, ou une valeur littérale. La syntaxe :identifier évalue à un Symbol.

Voir aussi : Expr, Symbol, Meta.parse

Exemples

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)

Construisez un tableau spécialisé avec des éléments espacés uniformément et un stockage optimisé (un AbstractRange) à partir des arguments. Mathématiquement, une plage est déterminée de manière unique par n'importe quelle combinaison de trois des start, step, stop et length. Les invocations valides de range sont :

• Appelez range avec n'importe quelle combinaison de trois des start, step, stop, length.
• Appelez range avec deux des start, stop, length. Dans ce cas, step sera supposé être un. Si les deux arguments sont des entiers, un UnitRange sera retourné.
• Appelez range avec un des stop ou length. start et step seront supposés être un.

Voir Aide Étendue pour des détails supplémentaires sur le type retourné. Voir aussi logrange pour des points espacés logarithmiquement.

Exemples

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

julia> range(; length = 10)
Base.OneTo(10)

julia> range(; stop = 6)
Base.OneTo(6)

julia> range(; stop = 6.5)
1.0:1.0:6.0

Si length n'est pas spécifié et que stop - start n'est pas un multiple entier de step, une plage qui se termine avant stop sera produite.

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

Une attention particulière est accordée pour s'assurer que les valeurs intermédiaires sont calculées de manière rationnelle. Pour éviter cette surcharge induite, voir le constructeur LinRange.

Aide Étendue

range produira un Base.OneTo lorsque les arguments sont des entiers et

• Seul length est fourni
• Seul stop est fourni

range produira un UnitRange lorsque les arguments sont des entiers et

• Seuls start et stop sont fournis
• Seuls length et stop sont fournis

Un UnitRange n'est pas produit si step est fourni même s'il est spécifié comme un.

Base.OneTo(n)

Définir un AbstractUnitRange qui se comporte comme 1:n, avec la distinction supplémentaire que la limite inférieure est garantie (par le système de types) d'être 1.

StepRangeLen(         ref::R, step::S, len, [offset=1]) where {  R,S}
StepRangeLen{T,R,S}(  ref::R, step::S, len, [offset=1]) where {T,R,S}
StepRangeLen{T,R,S,L}(ref::R, step::S, len, [offset=1]) where {T,R,S,L}

Une plage r où r[i] produit des valeurs de type T (dans la première forme, T est déduit automatiquement), paramétrée par une valeur de reférence, un step, et la length. Par défaut, ref est la valeur de départ r[1], mais vous pouvez alternativement la fournir comme la valeur de r[offset] pour un autre index 1 <= offset <= len. La syntaxe a:b ou a:b:c, où l'un des a, b ou c est un nombre à virgule flottante, crée un StepRangeLen.

logrange(début, fin, longueur)
logrange(début, fin; longueur)

Construit un tableau spécialisé dont les éléments sont espacés logarithmiquement entre les points de départ et d'arrivée donnés. C'est-à-dire que le rapport des éléments successifs est constant, calculé à partir de la longueur.

C'est similaire à geomspace en Python. Contrairement à PowerRange dans Mathematica, vous spécifiez le nombre d'éléments et non le rapport. Contrairement à logspace en Python et Matlab, les arguments début et fin sont toujours les premier et dernier éléments du résultat, et non des puissances appliquées à une certaine base.

Exemples

julia> logrange(10, 4000, longueur=3)
3-élément Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # l'élément du milieu est la moyenne géométrique
true

julia> range(10, 40, longueur=3)[2] ≈ (10 + 40)/2  # moyenne arithmétique
true

julia> logrange(1f0, 32f0, 11)
11-élément Base.LogRange{Float32, Float64}:
 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

julia> logrange(1, 1000, longueur=4) ≈ 10 .^ (0:3)
true

Voir le type LogRange pour plus de détails.

Voir aussi range pour des points espacés linéairement.

LogRange{T}(start, stop, len) <: AbstractVector{T}

Une plage dont les éléments sont espacés logarithmiquement entre start et stop, avec un espacement contrôlé par len. Renvoie par logrange.

Comme LinRange, les premier et dernier éléments seront exactement ceux fournis, mais les valeurs intermédiaires peuvent avoir de petites erreurs de flottement. Celles-ci sont calculées en utilisant les logarithmes des points d'extrémité, qui sont stockés lors de la construction, souvent avec une précision supérieure à T.

Exemples

julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 1.41421, 2.0, 2.82843, 4.0

julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
 1.0, 1.414, 2.0, 2.828, 4.0

julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
 1.0e-310
 9.999999999999974e-309
 9.999999999999981e-307
 9.999999999999988e-305
 9.999999999999994e-303
 1.0e-300

julia> prevfloat(1e-308, 5) == ans[2]
true

Notez que le type d'élément entier T n'est pas autorisé. Utilisez par exemple round.(Int, xs), ou des puissances explicites d'une certaine base entière :

julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 8.0, 64.0, 512.0

julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]

==(x, y)

Opérateur d'égalité générique. Se rabat sur ===. Doit être implémenté pour tous les types ayant une notion d'égalité, basée sur la valeur abstraite qu'une instance représente. Par exemple, tous les types numériques sont comparés par valeur numérique, en ignorant le type. Les chaînes de caractères sont comparées comme des séquences de caractères, en ignorant l'encodage. Les collections du même type comparent généralement leurs ensembles de clés, et si celles-ci sont ==, alors elles comparent les valeurs pour chacune de ces clés, retournant vrai si toutes ces paires sont ==. D'autres propriétés ne sont généralement pas prises en compte (comme le type exact).

Cet opérateur suit la sémantique IEEE pour les nombres à virgule flottante : 0.0 == -0.0 et NaN != NaN.

Le résultat est de type Bool, sauf lorsque l'un des opérandes est missing, auquel cas missing est retourné (logique à trois valeurs). Les collections implémentent généralement une logique à trois valeurs semblable à all, retournant missing si des opérandes contiennent des valeurs manquantes et que toutes les autres paires sont égales. Utilisez isequal ou === pour obtenir toujours un résultat de type Bool.

Implémentation

Les nouveaux types numériques doivent implémenter cette fonction pour deux arguments du nouveau type, et gérer la comparaison avec d'autres types via des règles de promotion lorsque cela est possible.

isequal se rabat sur ==, donc les nouvelles méthodes de == seront utilisées par le type Dict pour comparer les clés. Si votre type sera utilisé comme clé de dictionnaire, il doit donc également implémenter hash.

Si un type définit ==, isequal et isless, alors il doit également implémenter < pour garantir la cohérence des comparaisons.

!=(x, y)
≠(x,y)

Opérateur de comparaison non égal. Donne toujours la réponse opposée à ==.

Implémentation

Les nouveaux types ne devraient généralement pas implémenter cela, et s'appuyer sur la définition par défaut !=(x,y) = !(x==y) à la place.

Exemples

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

Créez une fonction qui compare son argument à x en utilisant !=, c'est-à-dire une fonction équivalente à y -> y != x. La fonction retournée est de type Base.Fix2{typeof(!=)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

!==(x, y)
≢(x,y)

Donne toujours la réponse opposée à ===.

Exemples

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

Opérateur de comparaison inférieur. Fait appel à isless. En raison du comportement des valeurs NaN en virgule flottante, cet opérateur implémente un ordre partiel.

Implémentation

Les nouveaux types avec un ordre partiel canonique devraient implémenter cette fonction pour deux arguments du nouveau type. Les types avec un ordre total canonique devraient implémenter isless à la place.

Voir aussi isunordered.

Exemples

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

Créez une fonction qui compare son argument à x en utilisant <, c'est-à-dire une fonction équivalente à y -> y < x. La fonction retournée est de type Base.Fix2{typeof(<)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

<=(x, y)
≤(x,y)

Opérateur de comparaison inférieur ou égal. Se rabat sur (x < y) | (x == y).

Exemples

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

Créez une fonction qui compare son argument à x en utilisant <=, c'est-à-dire une fonction équivalente à y -> y <= x. La fonction retournée est de type Base.Fix2{typeof(<=)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

>(x, y)

Opérateur de comparaison supérieur à. Se rabat sur y < x.

Implémentation

En général, les nouveaux types devraient implémenter < au lieu de cette fonction, et s'appuyer sur la définition de repli >(x, y) = y < x.

Exemples

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

Créez une fonction qui compare son argument à x en utilisant >, c'est-à-dire une fonction équivalente à y -> y > x. La fonction retournée est de type Base.Fix2{typeof(>)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

>=(x, y)
≥(x,y)

Opérateur de comparaison supérieur ou égal. Se rabat sur y <= x.

Exemples

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

Créez une fonction qui compare son argument à x en utilisant >=, c'est-à-dire une fonction équivalente à y -> y >= x. La fonction retournée est de type Base.Fix2{typeof(>=)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

cmp(x,y)

Retourne -1, 0 ou 1 selon que x est inférieur, égal ou supérieur à y, respectivement. Utilise l'ordre total implémenté par isless.

Exemples

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

cmp(<, x, y)

Retourne -1, 0 ou 1 selon que x est inférieur, égal ou supérieur à y, respectivement. Le premier argument spécifie une fonction de comparaison inférieure à utiliser.

cmp(a::AbstractString, b::AbstractString) -> Int

Comparer deux chaînes. Retourner 0 si les deux chaînes ont la même longueur et que le caractère à chaque index est le même dans les deux chaînes. Retourner -1 si a est un préfixe de b, ou si a vient avant b dans l'ordre alphabétique. Retourner 1 si b est un préfixe de a, ou si b vient avant a dans l'ordre alphabétique (techniquement, l'ordre lexicographique par points de code Unicode).

Exemples

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

~(x)

Non binaire.

Voir aussi : !, &, |.

Exemples

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

Et logique. Implémente la logique à trois valeurs, retournant missing si un opérande est missing et l'autre est true. Ajoutez des parenthèses pour la forme d'application de fonction : (&)(x, y).

Voir aussi : |, xor, &&.

Exemples

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

Opérateur binaire ou. Implémente la logique à trois valeurs, retournant missing si un opérande est missing et l'autre est false.

Voir aussi : &, xor, ||.

Exemples

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

xor(x, y)
⊻(x, y)

Opération exclusive ou bit à bit de x et y. Implémente la logique à trois valeurs, retournant missing si l'un des arguments est missing.

L'opération infixe a ⊻ b est un synonyme de xor(a,b), et ⊻ peut être tapé en complétant par tabulation \xor ou \veebar dans le REPL Julia.

Exemples

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitVector:
 0
 1
 0

nand(x, y)
⊼(x, y)

Nand bitwise (non et) de x et y. Implémente la logique à trois valeurs, retournant missing si l'un des arguments est missing.

L'opération infixe a ⊼ b est un synonyme de nand(a,b), et ⊼ peut être tapé en complétant par tabulation \nand ou \barwedge dans le REPL Julia.

Exemples

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

julia> [true; true; false] .⊼ [true; false; false]
3-element BitVector:
 0
 1
 1

nor(x, y)
⊽(x, y)

Nor bit à bit (non ou) de x et y. Implémente la logique à trois valeurs, retournant missing si l'un des arguments est missing et l'autre n'est pas true.

L'opération infixe a ⊽ b est un synonyme de nor(a,b), et ⊽ peut être tapé en complétant par tabulation \nor ou \barvee dans le REPL Julia.

Exemples

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

julia> [true; true; false] .⊽ [true; false; false]
3-element BitVector:
 0
 0
 1

!(x)

Non booléen. Implémente la logique à trois valeurs, retournant missing si x est missing.

Voir aussi ~ pour non bit à bit.

Exemples

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

!f::Function

Négation de fonction prédicat : lorsque l'argument de ! est une fonction, cela renvoie une fonction composée qui calcule la négation booléenne de f.

Voir aussi ∘.

Exemples

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isletter, str)
"εδxyδfxfyε"

julia> filter(!isletter, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

x && y

Évaluation booléenne avec court-circuit.

Voir aussi &, l'opérateur ternaire ? :, et la section du manuel sur le flux de contrôle.

Exemples

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("expected positive x")
false

x || y

Opérateur booléen OU avec court-circuit.

Voir aussi : |, xor, &&.

Exemples

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("aucun n'est vrai !")
true

isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

Comparaison d'égalité inexacte. Deux nombres sont considérés égaux si leur distance relative ou leur distance absolue est dans les limites de tolérance : isapprox renvoie true si norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). La valeur par défaut de atol (tolérance absolue) est zéro et la valeur par défaut de rtol (tolérance relative) dépend des types de x et y. L'argument clé nans détermine si les valeurs NaN sont considérées comme égales (par défaut, faux).

Pour les valeurs flottantes réelles ou complexes, si un atol > 0 n'est pas spécifié, rtol par défaut est la racine carrée de eps du type de x ou y, selon celui qui est le plus grand (le moins précis). Cela correspond à exiger l'égalité d'environ la moitié des chiffres significatifs. Sinon, par exemple pour des arguments entiers ou si un atol > 0 est fourni, rtol par défaut est zéro.

L'argument clé norm par défaut est abs pour les numériques (x,y) et LinearAlgebra.norm pour les tableaux (où un choix alternatif de norm est parfois utile). Lorsque x et y sont des tableaux, si norm(x-y) n'est pas fini (c'est-à-dire ±Inf ou NaN), la comparaison revient à vérifier si tous les éléments de x et y sont approximativement égaux composant par composant.

L'opérateur binaire ≈ est équivalent à isapprox avec les arguments par défaut, et x ≉ y est équivalent à !isapprox(x,y).

Notez que x ≈ 0 (c'est-à-dire, comparer à zéro avec les tolérances par défaut) est équivalent à x == 0 puisque la valeur par défaut de atol est 0. Dans de tels cas, vous devriez soit fournir un atol approprié (ou utiliser norm(x) ≤ atol) soit réorganiser votre code (par exemple, utiliser x ≈ y plutôt que x - y ≈ 0). Il n'est pas possible de choisir automatiquement un atol non nul car cela dépend de l'échelle globale (les "unités") de votre problème : par exemple, dans x - y ≈ 0, atol=1e-9 est une tolérance ridiculement petite si x est le rayon de la Terre en mètres, mais une tolérance ridiculement grande si x est le rayon d'un atome d'hydrogène en mètres.

Exemples

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # utilisant `norm`
true

isapprox(x; kwargs...) / ≈(x; kwargs...)

Créez une fonction qui compare son argument à x en utilisant ≈, c'est-à-dire une fonction équivalente à y -> y ≈ x.

Les arguments de mot-clé pris en charge ici sont les mêmes que ceux de la fonction isapprox à 2 arguments.

sin(x)

Calculez le sinus de x, où x est en radians.

Voir aussi sind, sinpi, sincos, cis, asin.

Exemples

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

cos(x)

Calculez le cosinus de x, où x est en radians.

Voir aussi cosd, cospi, sincos, cis.

sincos(x)

Calcule simultanément le sinus et le cosinus de x, où x est en radians, renvoyant un tuple (sinus, cosinus).

Voir aussi cis, sincospi, sincosd.

tan(x)

Calculez la tangente de x, où x est en radians.

sind(x)

Calcule le sinus de x, où x est en degrés. Si x est une matrice, x doit être une matrice carrée.

cosd(x)

Calcule le cosinus de x, où x est en degrés. Si x est une matrice, x doit être une matrice carrée.

tand(x)

Calcule la tangente de x, où x est en degrés. Si x est une matrice, x doit être une matrice carrée.

sincosd(x)

Calcule simultanément le sinus et le cosinus de x, où x est en degrés.

sinpi(x)

Calculez $\sin(\pi x)$ plus précisément que sin(pi*x), en particulier pour de grandes valeurs de x.

Voir aussi sind, cospi, sincospi.

cospi(x)

Calculez $\cos(\pi x)$ plus précisément que cos(pi*x), en particulier pour de grandes valeurs de x.

tanpi(x)

Calculez $\tan(\pi x)$ plus précisément que tan(pi*x), en particulier pour de grandes valeurs de x.

Voir aussi tand, sinpi, cospi, sincospi.

sincospi(x)

Calcule simultanément sinpi(x) et cospi(x) (le sinus et le cosinus de π*x, où x est en radians), retournant un tuple (sine, cosine).

Voir aussi : cispi, sincosd, sinpi.

sinh(x)

Calculez le sinus hyperbolique de x.

cosh(x)

Calculez le cosinus hyperbolique de x.

tanh(x)

Calculez la tangente hyperbolique de x.

Voir aussi tan, atanh.

Exemples

julia> tanh.(-3:3f0)  # Ici 3f0 est un Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

asin(x)

Calcule l'arc sinus de x, où la sortie est en radians.

Voir aussi asind pour une sortie en degrés.

Exemples

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

acos(x)

Calculez le cosinus inverse de x, où la sortie est en radians

atan(y)
atan(y, x)

Calcule l'arc tangente de y ou de y/x, respectivement.

Pour un argument réel, c'est l'angle en radians entre l'axe x positif et le point (1, y), retournant une valeur dans l'intervalle $[-\pi/2, \pi/2]$.

Pour deux arguments, c'est l'angle en radians entre l'axe x positif et le point (x, y), retournant une valeur dans l'intervalle $[-\pi, \pi]$. Cela correspond à une fonction atan2 standard. Notez qu'en convention atan(0.0,x) est défini comme $\pi$ et atan(-0.0,x) est défini comme $-\pi$ lorsque x < 0.

Voir aussi atand pour les degrés.

Exemples

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

asind(x)

Calcule l'inverse du sinus de x, où la sortie est en degrés. Si x est une matrice, x doit être une matrice carrée.

acosd(x)

Calcule le cosinus inverse de x, où la sortie est en degrés. Si x est une matrice, x doit être une matrice carrée.

atand(y)
atand(y,x)

Calculez la tangente inverse de y ou de y/x, respectivement, où la sortie est en degrés.

sec(x)

Calculez la sécante de x, où x est en radians.

csc(x)

Calculez la cosecante de x, où x est en radians.

cot(x)

Calculez la cotangente de x, où x est en radians.

secd(x)

Calculez la sécante de x, où x est en degrés.

cscd(x)

Calculez la cosecante de x, où x est en degrés.

cotd(x)

Calculez la cotangente de x, où x est en degrés.

asec(x)

Calcule l'inverse sécante de x, où la sortie est en radians.

acsc(x)

Calculez l'inverse de la cosecante de x, où la sortie est en radians.

acot(x)

Calculez l'inverse de la cotangente de x, où la sortie est en radians.

asecd(x)

Calcule l'inverse sécante de x, où la sortie est en degrés. Si x est une matrice, x doit être une matrice carrée.

acscd(x)

Calcule l'inverse de la cosecante de x, où la sortie est en degrés. Si x est une matrice, x doit être une matrice carrée.

acotd(x)

Calcule l'arc cotangente de x, où la sortie est en degrés. Si x est une matrice, x doit être une matrice carrée.

sech(x)

Calculez la sécante hyperbolique de x.

csch(x)

Calculez le cosécante hyperbolique de x.

coth(x)

Calculez le cotangente hyperbolique de x.

asinh(x)

Calculez le sinus hyperbolique inverse de x.

acosh(x)

Calculez le cosinus hyperbolique inverse de x.

atanh(x)

Calcule l'inverse de la tangente hyperbolique de x.

asech(x)

Calculez la sécante hyperbolique inverse de x.

acsch(x)

Calcule l'inverse du cosécant hyperbolique de x.

acoth(x)

Calculez le cotangente hyperbolique inverse de x.

sinc(x)

Calculez la fonction sinc normalisée $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ si $x \neq 0$, et $1$ si $x = 0$.

Voir aussi cosc, sa dérivée.

cosc(x)

Calculez $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ si $x \neq 0$, et $0$ si $x = 0$. C'est la dérivée de sinc(x).

Voir aussi sinc.

deg2rad(x)

Convertir x des degrés en radians.

Voir aussi rad2deg, sind, pi.

Exemples

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

Convertir x de radians en degrés.

Voir aussi deg2rad.

Exemples

julia> rad2deg(pi)
180.0

hypot(x, y)

Calculez l'hypoténuse $\sqrt{|x|^2+|y|^2}$ en évitant le débordement et le sous-dépassement.

Ce code est une implémentation de l'algorithme décrit dans : Un algorithme amélioré pour hypot(a,b) par Carlos F. Borges. L'article est disponible en ligne sur arXiv à l'adresse https://arxiv.org/abs/1904.09481

hypot(x...)

Calculez l'hypoténuse $\sqrt{\sum |x_i|^2}$ en évitant le débordement et le sous-dépassement.

Voir aussi norm dans la bibliothèque standard LinearAlgebra.

Exemples

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 déborde
ERROR: DomainError with -2.914184810805068e18:
sqrt a été appelé avec un argument réel négatif mais ne renverra qu'un résultat complexe s'il est appelé avec un argument complexe. Essayez sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

log(x)

Calcule le logarithme naturel de x.

Lève une DomainError pour les arguments Real négatifs. Utilisez des arguments complexes pour obtenir des résultats complexes. A une coupure de branche le long de l'axe réel négatif, pour lequel -0.0im est considéré comme étant en dessous de l'axe.

Voir aussi ℯ, log1p, log2, log10.

Exemples

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log a été appelé avec un argument réel négatif mais ne renverra un résultat complexe que s'il est appelé avec un argument complexe. Essayez log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

julia> log.(exp.(-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log(b,x)

Calcule le logarithme de x à la base b. Lance une DomainError pour les arguments Real négatifs.

Exemples

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log a été appelé avec un argument réel négatif mais ne renverra qu'un résultat complexe s'il est appelé avec un argument complexe. Essayez log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log a été appelé avec un argument réel négatif mais ne renverra qu'un résultat complexe s'il est appelé avec un argument complexe. Essayez log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

Calcule le logarithme de x en base 2. Lance une DomainError pour les arguments Real négatifs.

Voir aussi : exp2, ldexp, ispow2.

Exemples

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 a été appelé avec un argument réel négatif mais ne renverra qu'un résultat complexe s'il est appelé avec un argument complexe. Essayez log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log10(x)

Calcule le logarithme de x en base 10. Lance une DomainError pour les arguments Real négatifs.

Exemples

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10 a été appelé avec un argument réel négatif mais ne renverra un résultat complexe que s'il est appelé avec un argument complexe. Essayez log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

Logarithme naturel précis de 1+x. Lance une DomainError pour les arguments Real inférieurs à -1.

Exemples

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p a été appelé avec un argument réel < -1 mais ne renverra un résultat complexe que s'il est appelé avec un argument complexe. Essayez log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

Retourne (x,exp) tel que x a une magnitude dans l'intervalle $[1/2, 1)$ ou 0, et val est égal à $x \times 2^{exp}$.

Voir aussi significand, exponent, ldexp.

Exemples

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # intervalle [1, 2) à la place
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # l'exposant donnerait une erreur
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

Calculez l'exponentielle à base naturelle de x, en d'autres termes $ℯ^x$.

Voir aussi exp2, exp10 et cis.

Exemples

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

exp2(x)

Calcule l'exponentielle de base 2 de x, en d'autres termes $2^x$.

Voir aussi ldexp, <<.

Exemples

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

exp10(x)

Calcule l'exponentielle de base 10 de x, en d'autres termes $10^x$.

Exemples

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

Calcule $x \times 2^n$.

Voir aussi frexp, exponent.

Exemples

julia> ldexp(5.0, 2)
20.0

modf(x)

Renvoie un tuple (fpart, ipart) des parties fractionnaire et entière d'un nombre. Les deux parties ont le même signe que l'argument.

Exemples

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

expm1(x)

Calcule précisément $e^x-1$. Cela évite la perte de précision impliquée dans l'évaluation directe de exp(x)-1 pour de petites valeurs de x.

Exemples

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

Arrondit le nombre x.

Sans arguments de mot-clé, x est arrondi à une valeur entière, retournant une valeur de type T, ou du même type que x si aucun T n'est fourni. Une InexactError sera levée si la valeur n'est pas représentable par T, similaire à convert.

Si l'argument de mot-clé digits est fourni, il arrondit au nombre spécifié de chiffres après la virgule décimale (ou avant si négatif), en base base.

Si l'argument de mot-clé sigdigits est fourni, il arrondit au nombre spécifié de chiffres significatifs, en base base.

Le RoundingMode r contrôle la direction de l'arrondi ; la valeur par défaut est RoundNearest, qui arrondit à l'entier le plus proche, avec des égalités (valeurs fractionnaires de 0.5) arrondies à l'entier pair le plus proche. Notez que round peut donner des résultats incorrects si le mode d'arrondi global est changé (voir rounding).

Lors de l'arrondi à un type à virgule flottante, il arrondira aux entiers représentables par ce type (et Inf) plutôt qu'aux véritables entiers. Inf est traité comme un ulp supérieur à floatmax(T) aux fins de déterminer "le plus proche", similaire à convert.

Exemples

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

Extensions

Pour étendre round à de nouveaux types numériques, il est généralement suffisant de définir Base.round(x::NewType, r::RoundingMode). ```

RoundingMode

Un type utilisé pour contrôler le mode d'arrondi des opérations en virgule flottante (via les fonctions rounding/setrounding), ou comme arguments optionnels pour arrondir à l'entier le plus proche (via la fonction round).

Les modes d'arrondi actuellement pris en charge sont :

• RoundNearest (par défaut)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

Le mode d'arrondi par défaut. Arrondit à l'entier le plus proche, avec des égalités (valeurs fractionnaires de 0,5) arrondies à l'entier pair le plus proche.

RoundNearestTiesAway

Arrondit à l'entier le plus proche, avec des égalités arrondies loin de zéro (comportement de C/C++ round).

RoundNearestTiesUp

Arrondit à l'entier le plus proche, avec des égalités arrondies vers l'infini positif (comportement de round en Java/JavaScript).

RoundToZero

round utilisant ce mode d'arrondi est un alias pour trunc.

RoundFromZero

Arrondit loin de zéro.

Exemples

julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06

RoundUp

round utilisant ce mode d'arrondi est un alias pour ceil.

ArrondiVersLeBas

round utilisant ce mode d'arrondi est un alias pour floor.

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

Retourne la valeur intégrale la plus proche du même type que le z à valeurs complexes, en cas d'égalité, en utilisant les RoundingMode spécifiés. Le premier RoundingMode est utilisé pour arrondir les composants réels tandis que le second est utilisé pour arrondir les composants imaginaires.

RoundingModeReal et RoundingModeImaginary par défaut à RoundNearest, qui arrondit à l'entier le plus proche, avec des égalités (valeurs fractionnelles de 0.5) arrondies à l'entier pair le plus proche.

Exemples

julia> round(3.14 + 4.5im)
3.0 + 4.0im

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])

ceil(x) renvoie la valeur entière la plus proche du même type que x qui est supérieure ou égale à x.

ceil(T, x) convertit le résultat en type T, en lançant une InexactError si la valeur arrondie n'est pas représentable en tant que T.

Les mots-clés digits, sigdigits et base fonctionnent comme pour round.

Pour prendre en charge ceil pour un nouveau type, définissez Base.round(x::NewType, ::RoundingMode{:Up}).

floor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])

floor(x) renvoie la valeur entière la plus proche du même type que x qui est inférieure ou égale à x.

floor(T, x) convertit le résultat en type T, en lançant une InexactError si la valeur arrondie n'est pas représentable en tant que T.

Les mots-clés digits, sigdigits et base fonctionnent comme pour round.

Pour prendre en charge floor pour un nouveau type, définissez Base.round(x::NewType, ::RoundingMode{:Down}).

trunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])

trunc(x) renvoie la valeur entière la plus proche du même type que x dont la valeur absolue est inférieure ou égale à la valeur absolue de x.

trunc(T, x) convertit le résultat en type T, en lançant une InexactError si la valeur tronquée n'est pas représentable en tant que T.

Les mots-clés digits, sigdigits et base fonctionnent comme pour round.

Pour prendre en charge trunc pour un nouveau type, définissez Base.round(x::NewType, ::RoundingMode{:ToZero}).

Voir aussi : %, floor, unsigned, unsafe_trunc.

Exemples

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

Renvoie la valeur entière la plus proche de type T dont la valeur absolue est inférieure ou égale à la valeur absolue de x. Si la valeur n'est pas représentable par T, une valeur arbitraire sera renvoyée. Voir aussi trunc.

Exemples

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

Retourne le minimum des arguments, par rapport à isless. Si l'un des arguments est missing, retourne missing. Voir aussi la fonction minimum pour prendre l'élément minimum d'une collection.

Exemples

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

Retourne le maximum des arguments, par rapport à isless. Si l'un des arguments est missing, retourne missing. Voir aussi la fonction maximum pour prendre l'élément maximum d'une collection.

Exemples

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

Retourne (min(x,y), max(x,y)).

Voir aussi extrema qui retourne (minimum(x), maximum(x)).

Exemples

julia> minmax('c','b')
('b', 'c')

clamp(x, lo, hi)

Retourne x si lo <= x <= hi. Si x > hi, retourne hi. Si x < lo, retourne lo. Les arguments sont promus à un type commun.

Voir aussi clamp!, min, max.

Exemples

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11, 8, 5], 10, 6)  # un exemple où lo > hi
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

Clampe x entre typemin(T) et typemax(T) et convertit le résultat en type T.

Voir aussi trunc.

Exemples

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

clamp(x::Integer, r::AbstractUnitRange)

Clamp x pour qu'il se situe dans la plage r.

clamp!(array::AbstractArray, lo, hi)

Restreindre les valeurs dans array à la plage spécifiée, sur place. Voir aussi clamp.

Exemples

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) avec eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

abs(x)

La valeur absolue de x.

Lorsque abs est appliqué à des entiers signés, un dépassement peut se produire, entraînant le retour d'une valeur négative. Ce dépassement se produit uniquement lorsque abs est appliqué à la valeur minimale représentable d'un entier signé. C'est-à-dire que lorsque x == typemin(typeof(x)), abs(x) == x < 0, et non -x comme on pourrait s'y attendre.

Voir aussi : abs2, unsigned, sign.

Exemples

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # dépassement à typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

Vérifié

Le module Vérifié fournit des fonctions arithmétiques pour les types d'entiers signés et non signés intégrés qui déclenchent une erreur lorsqu'un dépassement se produit. Ils sont nommés comme checked_sub, checked_div, etc. De plus, add_with_overflow, sub_with_overflow, mul_with_overflow renvoient à la fois les résultats non vérifiés et une valeur booléenne indiquant la présence d'un dépassement.

Base.checked_abs(x)

Calcule abs(x), en vérifiant les erreurs de dépassement lorsque cela est applicable. Par exemple, les entiers signés en complément à deux standard (par exemple, Int) ne peuvent pas représenter abs(typemin(Int)), ce qui entraîne un dépassement.

La protection contre le dépassement peut imposer une pénalité de performance perceptible.

Base.checked_neg(x)

Calcule -x, en vérifiant les erreurs de débordement lorsque cela est applicable. Par exemple, les entiers signés en complément à deux standard (par exemple, Int) ne peuvent pas représenter -typemin(Int), ce qui entraîne un débordement.

La protection contre le débordement peut imposer une pénalité de performance perceptible.

Base.checked_add(x, y)

Calcule x+y, en vérifiant les erreurs de dépassement lorsque cela est applicable.

La protection contre le dépassement peut imposer une pénalité de performance perceptible.

Base.checked_sub(x, y)

Calcule x-y, en vérifiant les erreurs de dépassement lorsque cela est applicable.

La protection contre le dépassement peut imposer une pénalité de performance perceptible.

Base.checked_mul(x, y)

Calcule x*y, en vérifiant les erreurs de débordement lorsque cela est applicable.

La protection contre le débordement peut imposer une pénalité de performance perceptible.

Base.checked_div(x, y)

Calcule div(x,y), en vérifiant les erreurs de dépassement lorsque cela est applicable.

La protection contre le dépassement peut imposer une pénalité de performance perceptible.

Base.checked_rem(x, y)

Calcule x%y, en vérifiant les erreurs de débordement lorsque cela est applicable.

La protection contre le débordement peut imposer une pénalité de performance perceptible.

Base.checked_fld(x, y)

Calcule fld(x,y), en vérifiant les erreurs de dépassement lorsque cela est applicable.

La protection contre les dépassements peut imposer une pénalité de performance perceptible.

Base.checked_mod(x, y)

Calcule mod(x,y), en vérifiant les erreurs de dépassement lorsque cela est applicable.

La protection contre le dépassement peut imposer une pénalité de performance perceptible.

Base.checked_cld(x, y)

Calcule cld(x,y), en vérifiant les erreurs de débordement lorsque cela est applicable.

La protection contre le débordement peut imposer une pénalité de performance perceptible.

Base.checked_pow(x, y)

Calcule ^(x,y), en vérifiant les erreurs de débordement lorsque cela est applicable.

La protection contre le débordement peut imposer une pénalité de performance perceptible.

Base.add_with_overflow(x, y) -> (r, f)

Calcule r = x+y, avec le drapeau f indiquant si un dépassement s'est produit.

Base.sub_with_overflow(x, y) -> (r, f)

Calcule r = x-y, avec le drapeau f indiquant si un dépassement s'est produit.

Base.mul_with_overflow(x, y) -> (r, f)

Calcule r = x*y, avec le drapeau f indiquant si un dépassement s'est produit.

abs2(x)

Valeur absolue au carré de x.

Cela peut être plus rapide que abs(x)^2, en particulier pour les nombres complexes où abs(x) nécessite une racine carrée via hypot.

Voir aussi abs, conj, real.

Exemples

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
30

copysign(x, y) -> z

Retourne z qui a la magnitude de x et le même signe que y.

Exemples

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

Retourne zéro si x==0 et $x/|x|$ sinon (c'est-à-dire, ±1 pour x réel).

Voir aussi signbit, zero, copysign, flipsign.

Exemples

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

julia> sign(0 + im)
0.0 + 1.0im

signbit(x)

Retourne true si la valeur du signe de x est négative, sinon false.

Voir aussi sign et copysign.

Exemples

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

Retourne x avec son signe inversé si y est négatif. Par exemple abs(x) = flipsign(x,x).

Exemples

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

Retourne $\sqrt{x}$.

Lève une DomainError pour les arguments Real négatifs. Utilisez plutôt des arguments complexes négatifs. Notez que sqrt a une coupure de branche le long de l'axe réel négatif.

L'opérateur préfixe √ est équivalent à sqrt.

Voir aussi : hypot.

Exemples

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im est en dessous de la coupure de branche
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

isqrt(n::Integer)

Racine carrée entière : le plus grand entier m tel que m*m <= n.

julia> isqrt(5)
2

cbrt(x::Real)

Retourne la racine cubique de x, c'est-à-dire $x^{1/3}$. Les valeurs négatives sont acceptées (retournant la racine réelle négative lorsque $x < 0$).

L'opérateur préfixe ∛ est équivalent à cbrt.

Exemples

julia> cbrt(big(27))
3.0

julia> cbrt(big(-27))
-3.0

real(z)

Renvoie la partie réelle du nombre complexe z.

Voir aussi : imag, reim, complex, isreal, Real.

Exemples

julia> real(1 + 3im)
1

real(T::Type)

Renvoie le type qui représente la partie réelle d'une valeur de type T. Par exemple : pour T == Complex{R}, renvoie R. Équivalent à typeof(real(zero(T))).

Exemples

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

Renvoie un tableau contenant la partie réelle de chaque entrée dans le tableau A.

Équivalent à real.(A), sauf que lorsque eltype(A) <: Real, A est renvoyé sans copie, et que lorsque A a zéro dimensions, un tableau à 0 dimensions est renvoyé (plutôt qu'un scalaire).

Exemples

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

julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2

imag(z)

Renvoie la partie imaginaire du nombre complexe z.

Voir aussi : conj, reim, adjoint, angle.

Exemples

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

Renvoie un tableau contenant la partie imaginaire de chaque entrée dans le tableau A.

Équivalent à imag.(A), sauf que lorsque A a zéro dimension, un tableau à 0 dimension est renvoyé (plutôt qu'un scalaire).

Exemples

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

julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1

reim(z)

Renvoie un tuple des parties réelle et imaginaire du nombre complexe z.

Exemples

julia> reim(1 + 3im)
(1, 3)

reim(A::AbstractArray)

Renvoie un tuple de deux tableaux contenant respectivement la partie réelle et la partie imaginaire de chaque entrée dans A.

Équivalent à (real.(A), imag.(A)), sauf que lorsque eltype(A) <: Real, A est renvoyé sans copie pour représenter la partie réelle, et que lorsque A a zéro dimensions, un tableau à 0 dimensions est renvoyé (plutôt qu'un scalaire).

Exemples

julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])

julia> reim(fill(2 - im))
(fill(2), fill(-1))

conj(z)

Calcule le conjugué complexe d'un nombre complexe z.

Voir aussi : angle, adjoint.

Exemples

julia> conj(1 + 3im)
1 - 3im

conj(A::AbstractArray)

Renvoie un tableau contenant le conjugué complexe de chaque entrée dans le tableau A.

Équivalent à conj.(A), sauf que lorsque eltype(A) <: Real, A est renvoyé sans copie, et que lorsque A a zéro dimensions, un tableau à 0 dimensions est renvoyé (plutôt qu'un scalaire).

Exemples

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

julia> conj(fill(2 - im))
0-dimensional Array{Complex{Int64}, 0}:
2 + 1im

angle(z)

Calcule l'angle de phase en radians d'un nombre complexe z.

Renvoie un nombre -pi ≤ angle(z) ≤ pi, et est donc discontinu le long de l'axe réel négatif.

Voir aussi : atan, cis, rad2deg.

Exemples

julia> rad2deg(angle(1 + im))
45.0

julia> rad2deg(angle(1 - im))
-45.0

julia> rad2deg(angle(-1 + 1e-20im))
180.0

julia> rad2deg(angle(-1 - 1e-20im))
-180.0

cis(x)

Méthode plus efficace pour exp(im*x) en utilisant la formule d'Euler : $\cos(x) + i \sin(x) = \exp(i x)$.

Voir aussi cispi, sincos, exp, angle.

Exemples

julia> cis(π) ≈ -1
true

cispi(x)

Méthode plus précise pour cis(pi*x) (surtout pour de grandes valeurs de x).

Voir aussi cis, sincospi, exp, angle.

Exemples

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.03055685464595456im

binomial(n::Integer, k::Integer)

Le coefficient binomial $\binom{n}{k}$, étant le coefficient du $k$ème terme dans l'expansion polynomiale de $(1+x)^n$.

Si $n$ est non négatif, alors c'est le nombre de façons de choisir k parmi n éléments :

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

où $n!$ est la fonction factorial.

Si $n$ est négatif, alors il est défini en termes de l'identité

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

Voir aussi factorial.

Exemples

julia> binomial(5, 3)
10

julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10

julia> binomial(-5, 3)
-35

Liens externes

• Coefficient binomial sur Wikipedia.

binomial(x::Number, k::Integer)

Le coefficient binomial généralisé, défini pour k ≥ 0 par le polynôme

\[\frac{1}{k!} \prod_{j=0}^{k-1} (x - j)\]

Lorsque k < 0, il renvoie zéro.

Pour le cas de x entier, cela équivaut au coefficient binomial entier ordinaire

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

D'autres généralisations à des k non entiers sont mathématiquement possibles, mais impliquent la fonction Gamma et/ou la fonction bêta, qui ne sont pas fournies par la bibliothèque standard de Julia mais sont disponibles dans des packages externes tels que SpecialFunctions.jl.

Liens externes

• Coefficient binomial sur Wikipedia.

factorial(n::Integer)

Factorielle de n. Si n est un Integer, la factorielle est calculée comme un entier (promu à au moins 64 bits). Notez que cela peut provoquer un dépassement si n n'est pas petit, mais vous pouvez utiliser factorial(big(n)) pour calculer le résultat exactement en précision arbitraire.

Voir aussi binomial.

Exemples

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 est trop grand pour être recherché dans la table ; envisagez d'utiliser `factorial(big(21))` à la place
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

Liens externes

• Factorielle sur Wikipedia.

```

gcd(x, y...)

Plus grand commun diviseur (ou zéro si tous les arguments sont zéro). Les arguments peuvent être des nombres entiers et rationnels.

Exemples

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

julia> gcd(1//3, 2//3)
1//3

julia> gcd(1//3, -2//3)
1//3

julia> gcd(1//3, 2)
1//3

julia> gcd(0, 0, 10, 15)
5

lcm(x, y...)

Plus petit multiple commun (positif) (ou zéro si un argument est zéro). Les arguments peuvent être des nombres entiers et rationnels.

Exemples

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

julia> lcm(1//3, 2//3)
2//3

julia> lcm(1//3, -2//3)
2//3

julia> lcm(1//3, 2)
2//1

julia> lcm(1, 3, 5, 7)
105

gcdx(a, b)

Calcule le plus grand commun diviseur (positif) de a et b ainsi que leurs coefficients de Bézout, c'est-à-dire les coefficients entiers u et v qui satisfont $ua+vb = d = gcd(a, b)$. gcdx(a, b) retourne $(d, u, v)$.

Les arguments peuvent être des nombres entiers et rationnels.

Exemples

julia> gcdx(12, 42)
(6, -3, 1)

julia> gcdx(240, 46)
(2, -9, 47)

ispow2(n::Number) -> Bool

Testez si n est une puissance entière de deux.

Voir aussi count_ones, prevpow, nextpow.

Exemples

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

Le plus petit a^n qui n'est pas inférieur à x, où n est un entier non négatif. a doit être supérieur à 1, et x doit être supérieur à 0.

Voir aussi prevpow.

Exemples

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

Le plus grand a^n qui n'est pas supérieur à x, où n est un entier non négatif. a doit être supérieur à 1, et x ne doit pas être inférieur à 1.

Voir aussi nextpow, isqrt.

Exemples

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextprod(factors::Union{Tuple,AbstractVector}, n)

Entier suivant supérieur ou égal à n qui peut être écrit sous la forme $\prod k_i^{p_i}$ pour des entiers $p_1$, $p_2$, etc., pour les facteurs $k_i$ dans factors.

Exemples

julia> nextprod((2, 3), 105)
108

julia> 2^2 * 3^3
108

invmod(n::Integer, m::Integer)

Prenez l'inverse de n modulo m : y tel que $n y = 1 \pmod m$, et $div(y,m) = 0$. Cela générera une erreur si $m = 0$, ou si $gcd(n,m) \neq 1$.

Exemples

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}

Calcule l'inverse modulaire de n dans l'anneau des entiers de type T, c'est-à-dire modulo 2^N où N = 8*sizeof(T) (par exemple N = 32 pour Int32). En d'autres termes, ces méthodes satisfont les identités suivantes :

n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1

Notez que * ici est la multiplication modulaire dans l'anneau des entiers, T.

Spécifier le module impliqué par un type entier comme une valeur explicite est souvent peu pratique puisque le module est par définition trop grand pour être représenté par le type.

L'inverse modulaire est calculé de manière beaucoup plus efficace que le cas général en utilisant l'algorithme décrit dans https://arxiv.org/pdf/2204.04342.pdf.

powermod(x::Integer, p::Integer, m)

Calcule $x^p \pmod m$.

Exemples

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

ndigits(n::Integer; base::Integer=10, pad::Integer=1)

Calcule le nombre de chiffres dans l'entier n écrit en base base (la base ne doit pas être dans [-1, 0, 1]), éventuellement complété par des zéros jusqu'à une taille spécifiée (le résultat ne sera jamais inférieur à pad).

Voir aussi digits, count_ones.

Exemples

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

julia> string(1022, base=16)
"3fe"

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

L'opérateur de réduction utilisé dans sum. La principale différence par rapport à + est que les petits entiers sont promus en Int/UInt.

widemul(x, y)

Multipliez x et y, en donnant le résultat sous un type plus grand.

Voir aussi promote, Base.add_sum.

Exemples

julia> widemul(Float32(3.0), 4.0) isa BigFloat
true

julia> typemax(Int8) * typemax(Int8)
1

julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
16129

evalpoly(x, p)

Évalue le polynôme $\sum_k x^{k-1} p[k]$ pour les coefficients p[1], p[2], ...; c'est-à-dire que les coefficients sont donnés dans l'ordre croissant par puissance de x. Les boucles sont déroulées au moment de la compilation si le nombre de coefficients est statiquement connu, c'est-à-dire lorsque p est un Tuple. Cette fonction génère du code efficace en utilisant la méthode de Horner si x est réel, ou en utilisant un algorithme de type Goertzel <sup>[DK62]</sup> si x est complexe.

Exemples

julia> evalpoly(2, (1, 2, 3))
17

@evalpoly(z, c...)

Évalue le polynôme $\sum_k z^{k-1} c[k]$ pour les coefficients c[1], c[2], ...; c'est-à-dire que les coefficients sont donnés dans l'ordre croissant par puissance de z. Cette macro se développe en un code en ligne efficace qui utilise soit la méthode de Horner, soit, pour des z complexes, un algorithme plus efficace de type Goertzel.

Voir aussi evalpoly.

Exemples

julia> @evalpoly(3, 1, 0, 1)
10

julia> @evalpoly(2, 1, 0, 1)
5

julia> @evalpoly(2, 1, 1, 1)
7

@fastmath expr

Exécutez une version transformée de l'expression, qui appelle des fonctions pouvant violer les sémantiques IEEE strictes. Cela permet l'opération la plus rapide possible, mais les résultats sont indéfinis – soyez prudent lorsque vous faites cela, car cela peut changer les résultats numériques.

Cela définit les drapeaux Fast-Math LLVM, et correspond à l'option -ffast-math dans clang. Voir les notes sur les annotations de performance pour plus de détails.

Exemples

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672