Mathematics

-(x)

Tekil eksi operatörü.

Ayrıca bakınız: abs, flipsign.

Örnekler

julia> -1
-1

julia> -(2)
-2

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

julia> -(true)  # Int'e yükseltilir
-1

julia> -(0x003)
0xfffd

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

Bir Date ile bir Time'ın toplanması bir DateTime üretir. Time'ın saat, dakika, saniye ve milisaniye kısımları, yeni DateTime'ı oluşturmak için Date'in yıl, ay ve günü ile birlikte kullanılır. Time türündeki sıfırdan farklı mikro saniyeler veya nano saniyeler bir InexactError hatasının fırlatılmasına neden olacaktır.

+(x, y...)

Toplama operatörü.

İnfix x+y+z+... bu fonksiyonu tüm argümanlarla çağırır, yani +(x, y, z, ...), bu varsayılan olarak soldan başlayarak (x+y) + z + ... çağırır.

Büyük sayılar toplandığında, varsayılan Int dahil olmak üzere çoğu tam sayı türü için taşma olasılığının olduğunu unutmayın.

Örnekler

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)

Çıkarma operatörü.

Örnekler

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

Çarpma operatörü.

İnfix x*y*z*... bu fonksiyonu tüm argümanlarla çağırır, yani *(x, y, z, ...), bu da varsayılan olarak (x*y) * z * ... şeklinde soldan başlayarak çağrılır.

Yan yana yazım 2pi gibi ifadeler de *(2, pi) çağrısını yapar. Bu işlemin, bir literal *'dan daha yüksek önceliğe sahip olduğunu unutmayın. Ayrıca, yan yana yazım "0x..." (x ile başlayan bir değişkenin sıfır katı) yasaktır çünkü bu, işaretsiz tam sayı literal'leriyle çakışır: 0x01 isa UInt8.

Büyük sayıları çarparken, varsayılan Int dahil olmak üzere çoğu tam sayı türü için taşma olasılığının olduğunu unutmayın.

Örnekler

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # matris * vektör
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # yan yana yazım daha yüksek önceliğe sahiptir
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # adjoint vektör * vektör
5

/(x, y)

Sağ bölme operatörü: x'in sağdaki y'nin tersine çarpımı.

Tam sayı argümanları için kayan nokta sonuçları verir. Tam sayı bölümü için ÷ veya Rational sonuçları için // bakın.

Örnekler

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

Matris sağ-bölümü: A / B, (B' \ A')' ile eşdeğerdir; burada \ sol-bölüm operatörüdür. Kare matrisler için, sonuç X öyle ki A == X*B olur.

Ayrıca bakınız: rdiv!.

Örnekler

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)

Sol bölme operatörü: y'nin sol tarafında x'in tersinin çarpımı. Tam sayı argümanları için kayan nokta sonuçları verir.

Örnekler

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)

Üst alma operatörü.

Eğer x ve y tam sayılar ise, sonuç taşabilir. Bilimsel notasyonda sayılar girmek için 1.2 * 10^3 yerine Float64 literalleri olan 1.2e3 kullanın.

Eğer y bir Int literali ise (örneğin x^2'deki 2 veya x^-3'deki -3), Julia kodu x^y, derleyici tarafından Base.literal_pow(^, x, Val(y))'ye dönüştürülür; bu, üssün değerine göre derleme zamanı uzmanlaşmasını sağlar. (Varsayılan bir geri dönüş olarak Base.literal_pow(^, x, Val(y)) = ^(x,y) vardır; burada genellikle ^ == Base.^'dir, aksi takdirde ^ çağrılan ad alanında tanımlanmışsa farklı olabilir.) Eğer y negatif bir tam sayı literali ise, o zaman Base.literal_pow işlemi varsayılan olarak inv(x)^-y'ye dönüştürülür; burada -y pozitif bir değerdir.

Ayrıca exp2, << ile de bakabilirsiniz.

Örnekler

julia> 3^5
243

julia> 3^-1  # Base.literal_pow kullanır
0.3333333333333333

julia> p = -1;

julia> 3^p
HATA: -1 ile DomainError:
Bir tam sayıyı negatif bir üste -1 yükseltmek mümkün değil.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # tam sayı taşması
false

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

fma(x, y, z)

x*y+z hesaplar, ara sonucu x*y yuvarlamadan. Bazı sistemlerde bu, x*y+z'dan önemli ölçüde daha pahalıdır. fma, belirli algoritmalarda doğruluğu artırmak için kullanılır. muladd bakın.

muladd(x, y, z)

Birleşik çarpma-toplama: x*y+z hesaplar, ancak toplama ve çarpmanın birbirleriyle veya çevresindeki işlemlerle birleştirilmesine izin verir. Örneğin, bu, donanımın bunu verimli bir şekilde desteklemesi durumunda bir fma olarak uygulanabilir. Sonuç, farklı makinelerde farklı olabilir ve aynı makinede de sabit yayılımı veya diğer optimizasyonlar nedeniyle farklı olabilir. fma için bakın.

Örnekler

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

Birleşik çarpma-toplama, A*y .+ z, matris-matris veya matris-vektör çarpımı için. Sonuç her zaman A*y ile aynı boyuttadır, ancak z daha küçük olabilir veya bir skalar olabilir.

Örnekler

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)

x'in çarpan tersini döndürür, böylece x*inv(x) veya inv(x)*x one(x) (çarpan kimliği) ile yuvarlama hataları göz önüne alındığında eşit olur.

Eğer x bir sayı ise, bu esasen one(x)/x ile aynıdır, ancak bazı türler için inv(x) biraz daha verimli olabilir.

Örnekler

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)

Euclidean (tam sayı) bölme işleminin sonucu. Genel olarak, kesirli bir parça olmadan matematiksel bir işlem olan x/y ile eşdeğerdir.

Ayrıca bakınız: cld, fld, rem, divrem.

Örnekler

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

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

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

Euclidean (tam sayı) bölmeden elde edilen bölüm. x / y hesaplar, r yuvarlama moduna göre bir tam sayıya yuvarlanır. Diğer bir deyişle, miktar

round(x / y, r)

herhangi bir ara yuvarlama olmadan.

Ayrıca fld ve cld ile ilgili, bu fonksiyonun özel durumlarıdır.

Örnekler:

julia> div(4, 3, RoundToZero) # div(4, 3) ile eşleşir
1
julia> div(4, 3, RoundDown) # fld(4, 3) ile eşleşir
1
julia> div(4, 3, RoundUp) # cld(4, 3) ile eşleşir
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)

x / y'den küçük veya eşit en büyük tam sayı. div(x, y, RoundDown) ile eşdeğerdir.

Ayrıca bkz. div, cld, fld1.

Örnekler

julia> fld(7.3, 5.5)
1.0

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

fld(x, y)'nin, kayan nokta sayıların gerçek değerine dayalı olarak kesin doğru tabanlı yuvarlama uygulaması nedeniyle, sezgisel olmayan durumlar ortaya çıkabilir. Örneğin:

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

Burada olan, 0.1 olarak yazılan kayan nokta sayısının gerçek değerinin, sayısal değer 1/10'dan biraz daha büyük olmasıdır; oysa 6.0 sayısı tam olarak 6'yı temsil eder. Bu nedenle 6.0 / 0.1'in gerçek değeri 60'tan biraz daha azdır. Bölme işlemi yapıldığında, bu tam olarak 60.0'a yuvarlanır, ancak fld(6.0, 0.1) her zaman gerçek değerin tabanını alır, bu nedenle sonuç 59.0'dır.

cld(x, y)

x / y'ye eşit veya ondan büyük en küçük tam sayı. div(x, y, RoundUp) ile eşdeğerdir.

Ayrıca bkz. div, fld.

Örnekler

julia> cld(5.5, 2.2)
3.0

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

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

r aralığında y'yi bul, böylece $x ≡ y (mod n)$, burada n = length(r), yani y = mod(x - first(r), n) + first(r).

Ayrıca mod1 bakın.

Örnekler

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)

x'in y'ye göre modülasyonu veya eşdeğer olarak, y'ye göre tabanlı bölme sonrası x'in kalanı, yani x - y*fld(x,y) ifadesi, ara yuvarlama olmadan hesaplandığında.

Sonuç, y ile aynı işarete sahip olacak ve büyüklüğü abs(y)'den küçük olacaktır (bazı istisnalarla, aşağıdaki notu inceleyin).

Ayrıca bakınız: 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

x ≡ y (mod n) bul, burada n T içinde temsil edilebilen tam sayıların sayısıdır ve y [typemin(T),typemax(T)] aralığında bir tam sayıdır. Eğer T herhangi bir tam sayıyı temsil edebiliyorsa (örneğin T == BigInt), o zaman bu işlem T'ye bir dönüşüm ile eşdeğerdir.

Örnekler

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

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

Euclidean bölme kalanı, x ile aynı işareti taşıyan ve y'den daha küçük bir değer döndürür. Bu değer her zaman tamdır.

Ayrıca bakınız: div, mod, mod1, divrem.

Örnekler

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}) with eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

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

x'in y ile tam bölümü sonrası kalanını, bölümün r yuvarlama moduna göre yuvarlanarak hesaplar. Başka bir deyişle, miktar

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

herhangi bir ara yuvarlama olmadan.

• eğer r == RoundNearest ise, sonuç tamdır ve $[-|y| / 2, |y| / 2]$ aralığındadır. Ayrıca bkz. RoundNearest.
• eğer r == RoundToZero (varsayılan), o zaman sonuç tamdır ve $[0, |y|)$ aralığındadır eğer x pozitifse, aksi takdirde $(-|y|, 0]$ aralığındadır. Ayrıca bkz. RoundToZero.
• eğer r == RoundDown ise, sonuç $[0, y)$ aralığındadır eğer y pozitifse, aksi takdirde $(y, 0]$ aralığındadır. Sonuç, x ve y farklı işaretlere sahipse ve abs(x) < abs(y) ise tam olmayabilir. Ayrıca bkz. RoundDown.
• eğer r == RoundUp ise, sonuç $(-y, 0]$ aralığındadır eğer y pozitifse, aksi takdirde $[0, -y)$ aralığındadır. Sonuç, x ve y aynı işarete sahipse ve abs(x) < abs(y) ise tam olmayabilir. Ayrıca bkz. RoundUp.
• eğer r == RoundFromZero ise, sonuç $(-y, 0]$ aralığındadır eğer y pozitifse, aksi takdirde $[0, -y)$ aralığındadır. Sonuç, x ve y aynı işarete sahipse ve abs(x) < abs(y) ise tam olmayabilir. Ayrıca bkz. RoundFromZero.

Örnekler:

julia> x = 9; y = 4;

julia> x % y  # rem(x, y) ile aynı
1

julia> x ÷ y  # div(x, y) ile aynı
2

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

rem2pi(x, r::RoundingMode)

x'in tam sayısal bölümü sonrası kalanını 2π ile hesaplar, bölüm r yuvarlama moduna göre yuvarlanır. Diğer bir deyişle, miktar

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

herhangi bir ara yuvarlama olmadan. Bu, dahili olarak 2π'nin yüksek hassasiyetli bir yaklaşımını kullanır ve bu nedenle rem(x,2π,r)'den daha doğru bir sonuç verir.

• eğer r == RoundNearest ise, sonuç $[-π, π]$ aralığındadır. Bu genellikle en doğru sonuç olacaktır. Ayrıca bkz. RoundNearest.
• eğer r == RoundToZero ise, sonuç pozitifse $[0, 2π]$ aralığındadır, aksi takdirde $[-2π, 0]$ aralığındadır. Ayrıca bkz. RoundToZero.
• eğer r == RoundDown ise, sonuç $[0, 2π]$ aralığındadır. Ayrıca bkz. RoundDown.
• eğer r == RoundUp ise, sonuç $[-2π, 0]$ aralığındadır. Ayrıca bkz. RoundUp.

Örnekler

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

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

mod2pi(x)

2π ile bölme sonrası modül, $[0,2π)$ aralığında döner.

Bu fonksiyon, sayısal olarak tam 2π ile bölme sonrası modülün bir kayan nokta temsilini hesaplar ve bu nedenle mod(x,2π) ile tam olarak aynı değildir; çünkü mod(x,2π) x'in kayan nokta sayısı 2π ile bölünmesine göre modülünü hesaplar.

Örnekler

julia> mod2pi(9*pi/4)
0.7853981633974481

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

Euclidean bölme işlemi ile elde edilen bölüm ve kalanı döndürür. (div(x, y, r), rem(x, y, r)) ile eşdeğerdir. Eşit olarak, r'nin varsayılan değeri ile bu çağrı (x ÷ y, x % y) ile eşdeğerdir.

Ayrıca bakınız: fldmod, cld.

Örnekler

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

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

fldmod(x, y)

Bölme işleminden sonra tabanlı bölüm ve modül. divrem(x, y, RoundDown) için bir kolaylık sarmalayıcı. (fld(x, y), mod(x, y)) ile eşdeğerdir.

Ayrıca bakınız: fld, cld, fldmod1.

fld1(x, y)

Kattığı bölme, mod1(x,y) ile tutarlı bir değer döndürür.

Ayrıca bkz. mod1, fldmod1.

Örnekler

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)

Zemin bölme sonrası modül, mod(r, y) == mod(x, y) olacak şekilde bir değer r döndürür; pozitif y için $(0, y]$ aralığında ve negatif y için $[y,0)$ aralığında.

Tam sayı argümanları ve pozitif y ile bu, mod(x, 1:y) ile eşdeğerdir ve bu nedenle 1 tabanlı indeksleme için doğaldır. Karşılaştırıldığında, mod(x, y) == mod(x, 0:y-1) ofsetler veya adımlar ile hesaplamalar için doğaldır.

Ayrıca bkz. mod, fld1, fldmod1.

Örnekler

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with 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)

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

Ayrıca fld1, mod1 bakınız.

//(num, den)

İki tam sayıyı veya rasyonel sayıyı bölerek Rational sonucu verir. Daha genel olarak, // tam sayı veya rasyonel bileşenlere sahip diğer sayısal türlerin tam rasyonel bölümü için kullanılabilir; örneğin, tam sayı bileşenlerine sahip karmaşık sayılar.

// ile kayan nokta (AbstractFloat) argümanlarına izin verilmediğini unutmayın (değerler rasyonel olsa bile). Argümanlar Integer, Rational veya bunların bileşenleri olan alt türler olmalıdır.

Örnekler

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
HATA: MethodError: no method matching //(::Float64, ::Int64)
[...]

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

Verilen tam sayı türünün bileşenleri ile x sayısını Rational sayısı olarak yaklaşık bir şekilde ifade edin. Sonuç, x'ten tol kadar bir farkla farklı olacaktır.

Örnekler

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt

numerator(x)

x'in rasyonel temsilinin payı.

Örnekler

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

x'in rasyonel temsilinin paydası.

Örnekler

julia> denominator(2//3)
3

julia> denominator(4)
1

<<(x, n)

Sol taraftan bit kaydırma operatörü, x << n. n >= 0 için, sonuç x'in n bit sola kaydırılmasıdır, 0 ile doldurulur. Bu, x * 2^n ile eşdeğerdir. n < 0 için, bu x >> -n ile eşdeğerdir.

Örnekler

julia> Int8(3) << 2
12

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

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

Ayrıca bkz. >>, >>>, exp2, ldexp.

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

Sol bit kaydırma operatörü, B << n. n >= 0 için, sonuç B'nin elemanları n pozisyon geri kaydırılarak, false değerleri ile doldurulmasıdır. Eğer n < 0 ise, elemanlar ileri kaydırılır. B >> -n ile eşdeğerdir.

Örnekler

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)

Sağ bit kaydırma operatörü, x >> n. n >= 0 için, sonuç x'in n bit sağa kaydırılmasıdır; x >= 0 ise 0 ile, x < 0 ise 1 ile doldurularak x'in işareti korunur. Bu, fld(x, 2^n) ile eşdeğerdir. n < 0 için, bu x << -n ile eşdeğerdir.

Örnekler

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"

Ayrıca >>>, << bakınız.

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

Sağ bit kaydırma operatörü, B >> n. n >= 0 için, sonuç B'nin elemanlarının n pozisyon ileri kaydırılmasıyla elde edilir ve false değerleriyle doldurulur. Eğer n < 0 ise, elemanlar geriye kaydırılır. B << -n ile eşdeğerdir.

Örnekler

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)

Unsigned sağ bit kaydırma operatörü, x >>> n. n >= 0 için, sonuç x'in n bit sağa kaydırılmasıdır ve 0 ile doldurulur. n < 0 için, bu x << -n ile eşdeğerdir.

Unsigned tam sayı türleri için, bu >> ile eşdeğerdir. Signed tam sayı türleri için, bu signed(unsigned(x) >> n) ile eşdeğerdir.

Örnekler

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

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

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

BigIntler sonsuz boyutta gibi kabul edilir, bu nedenle doldurmaya gerek yoktur ve bu >> ile eşdeğerdir.

Ayrıca bkz. >>, <<.

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

İşaretsiz sağ bit kaydırma operatörü, B >>> n. B >> n ile eşdeğerdir. Ayrıntılar ve örnekler için >> kısmına bakın.

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

bitrotate(x, k) bit düzeyinde döndürme işlemi gerçekleştirir. x'in bitlerini k kez sola döndürerek değerini döndürür. k'nın negatif bir değeri sağa döndürme işlemi yapar.

Ayrıca bakınız: <<, 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

Bir ifadeyi expr alıntılayın ve expr'nin soyut sözdizim ağacını (AST) döndürün. AST, Expr, Symbol veya bir literal değer türünde olabilir. :identifier sözdizimi bir Symbol'a değerlenecektir.

Ayrıca bakınız: Expr, Symbol, Meta.parse

Örnekler

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)

Argümanlardan eşit aralıklı elemanlarla ve optimize edilmiş depolama ile özel bir dizi (bir AbstractRange) oluşturun. Matematiksel olarak bir aralık, start, step, stop ve length'in herhangi üçü ile benzersiz bir şekilde belirlenir. Geçerli range çağrıları şunlardır:

• start, step, stop, length'in herhangi üçü ile range çağrısı yapın.
• start, stop, length'in iki tanesi ile range çağrısı yapın. Bu durumda step bir olarak varsayılacaktır. Her iki argüman da Tam Sayı ise, bir UnitRange döndürülecektir.
• stop veya length'in bir tanesi ile range çağrısı yapın. start ve step bir olarak varsayılacaktır.

Dönülen tür hakkında ek bilgiler için Genişletilmiş Yardım'a bakın. Ayrıca logaritmik olarak aralıklı noktalar için logrange ile de bakabilirsiniz.

Örnekler

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

Eğer length belirtilmemişse ve stop - start bir tam sayı katı değilse, stop'dan önce biten bir aralık üretilecektir.

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

Ara değerlerin rasyonel olarak hesaplanmasını sağlamak için özel önlemler alınmıştır. Bu neden olduğu aşırı yükten kaçınmak için LinRange yapıcısına bakın.

Genişletilmiş Yardım

range, argümanlar Tam Sayı olduğunda bir Base.OneTo üretecektir ve

• Sadece length sağlandığında
• Sadece stop sağlandığında

range, argümanlar Tam Sayı olduğunda bir UnitRange üretecektir ve

• Sadece start ve stop sağlandığında
• Sadece length ve stop sağlandığında

Bir UnitRange, step sağlandığında, bir olarak belirtilse bile üretilmez.

Base.OneTo(n)

1:n gibi davranan bir AbstractUnitRange tanımlayın, ek olarak alt sınırın (tip sistemi tarafından) 1 olarak garanti edildiği bir ayrım ile.

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}

Bir aralık r burada r[i] değerleri T türünde üretir (ilk formda, T otomatik olarak çıkarılır), bir referans değeri, bir step ve length ile parametrelenmiştir. Varsayılan olarak ref, başlangıç değeri r[1]dir, ancak alternatif olarak bunu r[offset] değerinin değeri olarak sağlayabilirsiniz, burada başka bir indeks için 1 <= offset <= len. a:b veya a:b:c sözdizimi, a, b veya c'nin herhangi birinin ondalık sayılar olduğu durumlarda bir StepRangeLen oluşturur.

logrange(start, stop, length)
logrange(start, stop; length)

Verilen uç noktalar arasında logaritmik olarak aralıklı elemanlara sahip özel bir dizi oluşturur. Yani, ardışık elemanların oranı, uzunluktan hesaplanan sabit bir değerdir.

Bu, Python'daki geomspace'e benzer. Mathematica'daki PowerRange'in aksine, eleman sayısını belirtirsiniz, oranı değil. Python ve Matlab'daki logspace'in aksine, start ve stop argümanları her zaman sonucun ilk ve son elemanlarıdır, bazı birimlere uygulanmış güçler değil.

Örnekler

julia> logrange(10, 4000, length=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # orta eleman geometrik ortadır
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # aritmetik ortadır
true

julia> logrange(1f0, 32f0, 11)
11-element 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, length=4) ≈ 10 .^ (0:3)
true

Daha fazla ayrıntı için LogRange türüne bakın.

Ayrıca, lineer olarak aralıklı noktalar için range ile de bakabilirsiniz.

LogRange{T}(başlangıç, durdur, uzunluk) <: AbstractVector{T}

başlangıç ve durdur arasında logaritmik olarak aralıklı elemanlara sahip bir aralık, aralık uzunluk ile kontrol edilir. logrange tarafından döndürülür.

LinRange gibi, ilk ve son elemanlar tam olarak sağlananlar olacaktır, ancak ara değerlerde küçük kayan nokta hataları olabilir. Bu değerler, inşaat sırasında saklanan uç noktaların logaritmaları kullanılarak hesaplanır ve genellikle T'den daha yüksek bir hassasiyetle saklanır.

Örnekler

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

Tam sayı eltipi T'ye izin verilmez. Örneğin round.(Int, xs) veya bazı tam sayı tabanlarının açık kuvvetlerini kullanın:

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)

Genel eşitlik operatörü. === ile geri dönmektedir. Eşitlik kavramına sahip tüm türler için, bir örneğin temsil ettiği soyut değere dayalı olarak uygulanmalıdır. Örneğin, tüm sayısal türler sayısal değerlerine göre karşılaştırılır, tür göz ardı edilir. Dizeler, kodlamayı göz ardı ederek karakter dizileri olarak karşılaştırılır. Aynı türdeki koleksiyonlar genellikle anahtar kümelerini karşılaştırır ve eğer bunlar == ise, o anahtarlar için değerleri karşılaştırır ve tüm bu çiftler == ise true döner. Diğer özellikler genellikle dikkate alınmaz (örneğin, tam tür).

Bu operatör, kayan noktalı sayılar için IEEE semantiğini takip eder: 0.0 == -0.0 ve NaN != NaN.

Sonuç Bool türündedir, bir operand missing olduğunda, bu durumda missing döner (üç değerli mantık). Koleksiyonlar genellikle all benzeri üç değerli mantığı uygular, herhangi bir operand missing değer içeriyorsa ve diğer tüm çiftler eşitse missing döner. Her zaman Bool sonucu almak için isequal veya === kullanın.

Uygulama

Yeni sayısal türler, yeni türün iki argümanı için bu işlevi uygulamalı ve mümkün olduğunda diğer türlerle karşılaştırmayı terfi kuralları aracılığıyla ele almalıdır.

isequal == ile geri döner, bu nedenle == için yeni yöntemler Dict türü tarafından anahtarları karşılaştırmak için kullanılacaktır. Eğer türünüz bir sözlük anahtarı olarak kullanılacaksa, bu nedenle hash işlevini de uygulamalıdır.

Eğer bir tür ==, isequal ve isless tanımlıyorsa, karşılaştırmaların tutarlılığını sağlamak için < işlevini de uygulamalıdır.

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

Eşit olmama karşılaştırma operatörü. Her zaman == ile ters cevap verir.

Uygulama

Yeni türler genellikle bunu uygulamamalı ve bunun yerine !=(x,y) = !(x==y) yedek tanımına güvenmelidir.

Örnekler

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

x ile argümanını != kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> y != x ile eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(!=)} türündedir ve özel yöntemleri uygulamak için kullanılabilir.

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

Her zaman === ile ters cevap verir.

Örnekler

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

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

Küçükten büyüğe karşılaştırma operatörü. isless fonksiyonuna geri döner. Kayar nokta NaN değerlerinin davranışı nedeniyle, bu operatör kısmi bir sıralama uygular.

Uygulama

Kanonik bir kısmi sıralamaya sahip yeni türler, bu fonksiyonu yeni türün iki argümanı için uygulamalıdır. Kanonik bir tam sıralamaya sahip türler ise isless fonksiyonunu uygulamalıdır.

Ayrıca bkz. isunordered.

Örnekler

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

x ile argümanını < kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> y < x ile eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(<)} türündedir ve özel yöntemler uygulamak için kullanılabilir.

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

Küçük veya eşit karşılaştırma operatörü. (x < y) | (x == y) ifadesine geri döner.

Örnekler

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

x ile argümanını <= kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> y <= x ile eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(<=)} türündedir ve özel yöntemleri uygulamak için kullanılabilir.

>(x, y)

Büyüktür karşılaştırma operatörü. y < x ifadesine geri döner.

Uygulama

Genel olarak, yeni türler bu fonksiyonu yerine < uygulamalıdır ve geri dönüş tanımına >(x, y) = y < x dayanmalıdır.

Örnekler

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

x ile > kullanarak argümanını karşılaştıran bir fonksiyon oluşturun, yani y -> y > x ile eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(>)} türündedir ve özel yöntemleri uygulamak için kullanılabilir.

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

Büyüktür veya eşittir karşılaştırma operatörü. y <= x ifadesine geri döner.

Örnekler

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

x ile argümanını >= kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> y >= x fonksiyonuna eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(>=)} türündedir ve özel yöntemleri uygulamak için kullanılabilir.

cmp(x,y)

x'in y'den küçük, eşit veya büyük olup olmadığına bağlı olarak sırasıyla -1, 0 veya 1 döner. isless tarafından uygulanan toplam sıralamayı kullanır.

Örnekler

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

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

cmp(<, x, y)

x'in y'den küçük, eşit veya büyük olup olmadığına bağlı olarak sırasıyla -1, 0 veya 1 döner. İlk argüman, kullanılacak bir küçükten küçüğe karşılaştırma fonksiyonunu belirtir.

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

İki dizeyi karşılaştır. Her iki dize de aynı uzunluktaysa ve her bir indeksteki karakterler her iki dizede de aynıysa 0 döndür. a, b'nin ön eki ise veya a, b'den alfabetik sırada önce geliyorsa -1 döndür. b, a'nın ön eki ise veya b, a'dan alfabetik sırada önce geliyorsa (teknik olarak, Unicode kod noktalarına göre leksikografik sırada) 1 döndür.

Örnekler

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)

Bitwise değil.

Ayrıca bakınız: !, &, |.

Örnekler

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

Bitwise ve. Üç değerli mantık uygular, bir operand missing ve diğeri true ise missing döner. Fonksiyon uygulama biçimi için parantez ekleyin: (&)(x, y).

Ayrıca bkz: |, xor, &&.

Örnekler

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

Bitwise veya. Üç değerli mantık uygular, bir operand missing ve diğeri false ise missing döner.

Ayrıca bakınız: &, xor, ||.

Örnekler

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

x ve y'nin bit düzeyinde özel veya işlemi. Eğer argümanlardan biri missing ise missing döner.

İnfix işlem a ⊻ b, xor(a,b) için bir eşanlamlıdır ve ⊻ Julia REPL'de \xor veya \veebar yazarak tamamlanabilir.

Örnekler

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)

x ve y'nin bit düzeyinde nand (ve değil) işlemi. missing olan bir argüman varsa, üç değerli mantık uygular.

İnfix işlemi a ⊼ b, nand(a,b) için bir eşanlamlıdır ve ⊼ Julia REPL'de \nand veya \barwedge yazarak tamamlanabilir.

Örnekler

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)

x ve y'nin bit düzeyinde nor (değil veya) işlemi. Eğer argümanlardan biri missing ise ve diğeri true değilse missing döner.

İnfix işlemi a ⊽ b, nor(a,b) için bir eşanlamlıdır ve ⊽ Julia REPL'de \nor veya \barvee yazarak otomatik tamamlama ile yazılabilir.

Örnekler

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)

Boolean değil. missing döndürerek üç değerli mantık uygular, eğer x missing ise.

Ayrıca ~ bit düzeyinde değil için bakınız.

Örnekler

julia> !true
false

julia> !false
true

julia> !missing
missing

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

!f::Function

Predikat fonksiyonun olumsuzlanması: !'nin argümanı bir fonksiyon olduğunda, f'nin boolean olumsuzlamasını hesaplayan bir bileşik fonksiyon döndürür.

Ayrıca bkz. ∘.

Örnekler

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

Kısa devre boolean VE.

Ayrıca bkz. &, üçlü operatör ? :, ve kontrol akışı ile ilgili kılavuz bölümü.

Örnekler

julia> x = 3;

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

julia> x < 0 && error("beklenen pozitif x")
false

x || y

Kısa devre boolean VEYA.

Ayrıca bakınız: |, xor, &&.

Örnekler

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("hiçbiri doğru değil!")
true

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

Kesin olmayan eşitlik karşılaştırması. İki sayı, göreceli mesafeleri veya mutlak mesafeleri tolerans sınırları içinde ise eşit kabul edilir: isapprox, norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))) koşulu sağlandığında true döner. Varsayılan atol (mutlak tolerans) sıfırdır ve varsayılan rtol (göreceli tolerans) x ve y'nin türlerine bağlıdır. nans anahtar argümanı, NaN değerlerinin eşit kabul edilip edilmediğini belirler (varsayılan olarak false).

Gerçek veya karmaşık kayan nokta değerleri için, atol > 0 belirtilmemişse, rtol, x veya y türlerinin en büyüğünün eps kareköküne varsayılan olarak ayarlanır (en az hassas). Bu, yaklaşık olarak yarım anlamlı basamağın eşitliğini gerektirir. Aksi takdirde, örneğin tam sayı argümanları için veya atol > 0 sağlanmışsa, rtol varsayılan olarak sıfırdır.

norm anahtar kelimesi, sayısal (x,y) için abs ve diziler için LinearAlgebra.norm olarak varsayılan ayarlanmıştır (alternatif bir norm seçeneği bazen faydalı olabilir). x ve y diziler olduğunda, norm(x-y) sonlu değilse (yani ±Inf veya NaN), karşılaştırma, x ve y'nin tüm elemanlarının bileşen bazında yaklaşık eşit olup olmadığını kontrol etmeye geri döner.

İkili operatör ≈, varsayılan argümanlarla isapprox ile eşdeğerdir ve x ≉ y, !isapprox(x,y) ile eşdeğerdir.

x ≈ 0 (yani, varsayılan toleranslarla sıfıra karşılaştırma) x == 0 ile eşdeğerdir çünkü varsayılan atol sıfırdır. Bu tür durumlarda, uygun bir atol sağlamalı (veya norm(x) ≤ atol kullanmalısınız) veya kodunuzu yeniden düzenlemelisiniz (örneğin, x ≈ y kullanmak yerine x - y ≈ 0 kullanın). Sıfırdan farklı bir atol otomatik olarak seçmek mümkün değildir çünkü bu, probleminizin genel ölçeklenmesine (birimlerine) bağlıdır: örneğin, x - y ≈ 0 durumunda, atol=1e-9, x Dünya'nın yarıçapı metre cinsinden ise son derece küçük bir tolerans, ancak x Hidrojen atomunun yarıçapı metre cinsinden ise son derece büyük bir tolerans olur.

Örnekler

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]) # using `norm`
true

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

x ile argümanını ≈ kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> y ≈ x ile eşdeğer bir fonksiyon.

Burada desteklenen anahtar kelime argümanları, 2-argümanlı isapprox ile aynı olanlardır.

sin(x)

x radyan cinsinden x'in sinüsünü hesaplayın.

Ayrıca bkz. sind, sinpi, sincos, cis, asin.

Örnekler

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)

x radyan cinsinden olduğunda x'in kosinüsünü hesaplayın.

Ayrıca bkz. cosd, cospi, sincos, cis.

sincos(x)

x radyan cinsinden olduğunda x'in sinüs ve kosinüsünü aynı anda hesaplayarak (sinüs, kosinüs) şeklinde bir demet döndürür.

Ayrıca bkz. cis, sincospi, sincosd.

tan(x)

x radyan cinsinden olduğunda x'in tanjantını hesaplayın.

sind(x)

x dereces cinsinden sine değerini hesaplar. Eğer x bir matris ise, x kare bir matris olmalıdır.

cosd(x)

x derecesinde kosinüsünü hesaplar. Eğer x bir matris ise, x kare bir matris olmalıdır.

tand(x)

x derecesinde x'in tanjantını hesaplayın. Eğer x bir matris ise, x kare bir matris olmalıdır.

sincosd(x)

x dereces cinsinden olduğunda, x'in sinüs ve kosinüsünü aynı anda hesaplar.

sinpi(x)

\[\sin(\pi x)\]

'i sin(pi*x)'ten daha hassas bir şekilde hesaplayın, özellikle büyük x için.

Ayrıca sind, cospi, sincospi bakın.

cospi(x)

\[\cos(\pi x)\]

'ı, özellikle büyük x için cos(pi*x)'ten daha doğru bir şekilde hesaplayın.

tanpi(x)

\[\tan(\pi x)\]

'i tan(pi*x)'ten daha doğru bir şekilde hesaplar, özellikle büyük x için.

Ayrıca tand, sinpi, cospi, sincospi bakınız.

sincospi(x)

Aynı anda sinpi(x) ve cospi(x) (sırasıyla π*x'in sinüsü ve kosinüsü, burada x radyan cinsindendir) hesaplayarak (sinüs, kosinüs) şeklinde bir demet döner.

Ayrıca bakınız: cispi, sincosd, sinpi.

sinh(x)

x'in hiperbolik sinüsünü hesaplar.

cosh(x)

x'in hiperbolik kosinüsünü hesaplayın.

tanh(x)

x'in hiperbolik tanjantını hesaplayın.

Ayrıca bkz. tan, atanh.

Örnekler

julia> tanh.(-3:3f0)  # Burada 3f0 Float32'dir
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)

x'in tersine sinüsünü hesaplar, çıktı radyan cinsindendir.

Ayrıca asind ile derece cinsinden çıktı için bakınız.

Örnekler

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)

x'in tersine kosinüsünü hesaplar, çıktı radyan cinsindendir.

atan(y)
atan(y, x)

y veya y/x'nin ters tanjantını hesaplayın.

Bir gerçek argüman için, bu, pozitif x-ekseni ile (1, y) noktası arasındaki açıdır ve $[-\pi/2, \pi/2]$ aralığında bir değer döndürür.

İki argüman için, bu, pozitif x-ekseni ile (x, y) noktası arasındaki açıdır ve $[-\pi, \pi]$ aralığında bir değer döndürür. Bu, standart atan2 fonksiyonuna karşılık gelir. Not edin ki, geleneksel olarak atan(0.0,x) değeri $\pi$ olarak tanımlanır ve atan(-0.0,x) değeri x < 0 olduğunda $-\pi$ olarak tanımlanır.

Ayrıca atand için dereceleri kontrol edin.

Örnekler

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

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

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

asind(x)

x'in tersine sinüsünü hesaplar; çıktı derece cinsindendir. Eğer x bir matris ise, x kare bir matris olmalıdır.

acosd(x)

x'in ters açısını hesaplar, çıktı derece cinsindendir. Eğer x bir matris ise, x kare bir matris olmalıdır.

atand(y)
atand(y,x)

y veya y/x'nin ters tanjantını hesaplayın; çıktı dereceler cinsindendir.

sec(x)

x radyan cinsinden olduğunda x'in sekantını hesaplayın.

csc(x)

x radyan cinsinden olduğunda x'in koskecantını hesaplayın.

cot(x)

x radyan cinsinden cotanjantını hesaplayın.

secd(x)

x dereces cinsinden secantını hesaplar.

cscd(x)

x dereces cosecant'ını hesaplar.

cotd(x)

x dereces cinsinden cotanjantını hesaplar.

asec(x)

x'in tersine sekantını hesaplayın, çıktı radyan cinsindendir.

acsc(x)

x'in tersine kosekantını hesaplar, çıktı radyan cinsindendir.

acot(x)

x'in tersine kotanjantını hesaplar, çıktı radyan cinsindendir.

asecd(x)

x'in ters açısını hesaplar, çıktı derece cinsindendir. Eğer x bir matris ise, x kare bir matris olmalıdır.

acscd(x)

x'in tersine kosekantını hesaplayın, burada çıktı dereceler cinsindendir. Eğer x bir matris ise, x kare bir matris olmalıdır.

acotd(x)

x'in tersine kotanjantını hesaplar, çıktı derece cinsindendir. Eğer x bir matris ise, x kare bir matris olmalıdır.

sech(x)

x'in hiperbolik sekantını hesaplayın.

csch(x)

x'in hiperbolik kosinüs karşıtını hesaplar.

coth(x)

x'in hiperbolik kotanjantını hesaplayın.

asinh(x)

x'in ters hiperbolik sinüsünü hesaplar.

acosh(x)

x'in ters hiperbolik kosinüsünü hesaplar.

atanh(x)

x'in ters hiperbolik tanjantını hesaplayın.

asech(x)

x'in ters hiperbolik sekantını hesaplar.

acsch(x)

x'in ters hiperbolik kosinüsünü hesaplar.

acoth(x)

x'in ters hiperbolik kotanjantını hesaplar.

sinc(x)

Normalize edilmiş sinc fonksiyonunu $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ olarak hesaplayın, eğer $x \neq 0$ ise, ve $1$ eğer $x = 0$ ise.

Ayrıca cosc ve onun türevine de bakın.

cosc(x)

\[\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)\]

hesaplayın eğer $x \neq 0$, ve $0$ eğer $x = 0$. Bu sinc(x)'in türevidir.

Ayrıca bkz. sinc.

deg2rad(x)

x değerini derece cinsinden radyana dönüştürür.

Ayrıca bkz. rad2deg, sind, pi.

Örnekler

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

x değerini radyandan dereceye dönüştürür.

Ayrıca bkz. deg2rad.

Örnekler

julia> rad2deg(pi)
180.0

hypot(x, y)

Hipotenüsü hesaplar $\sqrt{|x|^2+|y|^2}$ taşma ve alt taşmayı önleyerek.

Bu kod, Carlos F. Borges tarafından tanımlanan hypot(a,b) algoritmasının bir uygulamasıdır. Makale çevrimiçi olarak arXiv'de şu bağlantıda mevcuttur: https://arxiv.org/abs/1904.09481

hypot(x...)

Hipotenüsü hesaplar $\sqrt{\sum |x_i|^2}$ taşma ve alt taşmayı önleyerek.

Ayrıca norm'u LinearAlgebra standart kütüphanesinde görebilirsiniz.

Örnekler

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 taşar
HATA: DomainError with -2.914184810805068e18:
sqrt negatif bir reel argüman ile çağrıldı, ancak yalnızca karmaşık bir argüman ile çağrıldığında karmaşık bir sonuç döndürecektir. sqrt(Complex(x)) ile denemeyi deneyin.
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)

x'in doğal logaritmasını hesaplar.

Negatif Real argümanlar için DomainError fırlatır. Karmaşık sonuçlar elde etmek için karmaşık argümanlar kullanın. Negatif reel eksen boyunca bir dal kesimi vardır; bu eksenin altında -0.0im alınır.

Ayrıca bkz. ℯ, log1p, log2, log10.

Örnekler

julia> log(2)
0.6931471805599453

julia> log(-3)
HATA: DomainError with -3.0:
log negatif reel bir argüman ile çağrıldı ancak yalnızca karmaşık bir argüman ile çağrıldığında karmaşık bir sonuç döndürecektir. log(Complex(x))'i deneyin.
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)

x'in taban b logaritmasını hesaplar. Negatif Real argümanlar için DomainError fırlatır.

Örnekler

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
HATA: -2.0 ile DomainError:
log negatif bir gerçek argüman ile çağrıldı, ancak karmaşık bir argüman ile çağrıldığında yalnızca karmaşık bir sonuç döndürecektir. log(Complex(x))'i deneyin.
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
HATA: -3.0 ile DomainError:
log negatif bir gerçek argüman ile çağrıldı, ancak karmaşık bir argüman ile çağrıldığında yalnızca karmaşık bir sonuç döndürecektir. log(Complex(x))'i deneyin.
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)

x için 2 tabanında logaritmayı hesaplar. Negatif Real argümanlar için DomainError fırlatır.

Ayrıca bakınız: exp2, ldexp, ispow2.

Örnekler

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
HATA: DomainError ile -2.0:
log2 negatif bir gerçek argüman ile çağrıldı ancak yalnızca karmaşık bir argüman ile çağrıldığında karmaşık bir sonuç döndürecektir. log2(Complex(x))'i deneyin.
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)

x için 10 tabanında logaritmayı hesaplar. Negatif Real argümanlar için DomainError fırlatır.

Örnekler

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
HATA: -2.0 ile DomainError:
log10 negatif bir gerçek argüman ile çağrıldı, ancak yalnızca karmaşık bir argüman ile çağrıldığında karmaşık bir sonuç döndürecektir. log10(Complex(x)) deneyin.
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

1+x'in doğal logaritmasını doğru bir şekilde hesaplar. Real argümanları -1'den küçük olduğunda DomainError fırlatır.

Örnekler

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
HATA: -2.0 ile DomainError:
log1p, -1'den küçük bir gerçek argüman ile çağrıldı ancak yalnızca karmaşık bir argüman ile çağrıldığında karmaşık bir sonuç döndürecektir. log1p(Complex(x))'i deneyin.
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

x'in $[1/2, 1)$ veya 0 büyüklüğünde olduğu ve val'ın $x \times 2^{exp}$'e eşit olduğu (x,exp) çiftini döndürür.

Ayrıca significand, exponent, ldexp bakınız.

Örnekler

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # [1, 2) aralığı yerine
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # üstel bir hata verecektir
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

x'in doğal taban üstelini hesaplayın, diğer bir deyişle $ℯ^x$.

Ayrıca bkz. exp2, exp10 ve cis.

Örnekler

julia> exp(1.0)
2.718281828459045

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

exp2(x)

x'in taban 2 üstelini hesaplar, diğer bir deyişle $2^x$.

Ayrıca bkz. ldexp, <<.

Örnekler

julia> exp2(5)
32.0

julia> 2^5
32

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

exp10(x)

x'in taban 10 üssünü hesaplar, diğer bir deyişle $10^x$.

Örnekler

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

\[x \times 2^n\]

hesaplar.

Ayrıca bkz. frexp, exponent.

Örnekler

julia> ldexp(5.0, 2)
20.0

modf(x)

Bir sayının kesirli ve tam kısımlarını içeren (fpart, ipart) demetini döndürür. Her iki kısım da argümanın aynı işaretine sahiptir.

Örnekler

julia> modf(3.5)
(0.5, 3.0)

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

expm1(x)

Doğru bir şekilde $e^x-1$ hesaplar. Küçük x değerleri için exp(x)-1'in doğrudan değerlendirilmesinde meydana gelen hassasiyet kaybını önler.

Örnekler

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)

x sayısını yuvarlar.

Anahtar kelime argümanları olmadan, x bir tam sayı değerine yuvarlanır ve bir T türünde veya T sağlanmadıysa x ile aynı türde bir değer döner. Eğer değer T tarafından temsil edilemeyecekse, InexactError hatası fırlatılacaktır, bu da convert ile benzerdir.

digits anahtar kelime argümanı sağlanırsa, belirtilen ondalık basamağı (veya negatifse öncesini) yuvarlar, base tabanında.

sigdigits anahtar kelime argümanı sağlanırsa, belirtilen anlamlı basamak sayısına yuvarlar, base tabanında.

RoundingMode r, yuvarlama yönünü kontrol eder; varsayılan RoundNearest olup, en yakın tam sayıya yuvarlar, 0.5 olan bağlama değerleri en yakın çift tam sayıya yuvarlanır. round'un küresel yuvarlama modu değişirse yanlış sonuçlar verebileceğini unutmayın (bkz. rounding).

Bir kayan nokta türüne yuvarlarken, o tür tarafından temsil edilebilen (ve Inf) tam sayılara yuvarlanır, gerçek tam sayılara değil. Inf, "en yakın" belirlemek için floatmax(T)'den bir ulp daha büyük olarak kabul edilir, bu da convert ile benzerdir.

Örnekler

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

Uzantılar

round'u yeni sayısal türlere genişletmek için, genellikle Base.round(x::NewType, r::RoundingMode) tanımlamak yeterlidir.

RoundingMode

Bir tür, kayan nokta işlemlerinin yuvarlama modunu kontrol etmek için (rounding/setrounding fonksiyonları aracılığıyla) veya en yakın tam sayıya yuvarlama için isteğe bağlı argümanlar olarak (round fonksiyonu aracılığıyla) kullanılır.

Şu anda desteklenen yuvarlama modları şunlardır:

• RoundNearest (varsayılan)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

Varsayılan yuvarlama modu. En yakın tam sayıya yuvarlar; bağlar (0.5 kesirli değerler) en yakın çift tam sayıya yuvarlanır.

RoundNearestTiesAway

En yakın tam sayıya yuvarlar, sıfırdan uzaklaşarak bağlanan durumlar (C/C++ round davranışı).

RoundNearestTiesUp

En yakın tam sayıya yuvarlar, bağlanma durumlarında pozitif sonsuzluğa doğru yuvarlanır (Java/JavaScript round davranışı).

SıfıraYuvarla

round bu yuvarlama modu kullanılarak trunc için bir takma adıdır.

Sıfırdan Yuvarlama

Sıfırdan uzaklaştırır.

Örnekler

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

RoundUp

round bu yuvarlama modu için ceil için bir takma addır.

AşağıYuvarla

round bu yuvarlama modu kullanılarak floor için bir takma adıdır.

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

Kompleks değerli z için aynı türdeki en yakın tam sayıyı döndürün, belirtilen RoundingMode kullanarak bağları kırın. İlk RoundingMode gerçek bileşenleri yuvarlamak için, ikincisi ise hayali bileşenleri yuvarlamak için kullanılır.

RoundingModeReal ve RoundingModeImaginary varsayılan olarak RoundNearest değerini alır; bu, en yakın tam sayıya yuvarlar ve bağlar (0.5'lik kesirli değerler) en yakın çift tam sayıya yuvarlanır.

Örnekler

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) x'in kendisinden büyük veya eşit olan en yakın tam sayı değerini döndürür.

ceil(T, x) sonucu T türüne dönüştürür, eğer yuvarlanmış değer T olarak temsil edilemiyorsa bir InexactError fırlatır.

digits, sigdigits ve base anahtar kelimeleri round için olduğu gibi çalışır.

Yeni bir tür için ceil desteği sağlamak için Base.round(x::NewType, ::RoundingMode{:Up}) tanımlayın.

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

floor(x) ifadesi, x'e eşit veya daha küçük olan x ile aynı türdeki en yakın tam sayıyı döndürür.

floor(T, x) sonucu T türüne dönüştürür, eğer yuvarlanmış değer T olarak temsil edilemiyorsa bir InexactError fırlatır.

digits, sigdigits ve base anahtar kelimeleri round için olduğu gibi çalışır.

Yeni bir tür için floor desteği sağlamak için, Base.round(x::NewType, ::RoundingMode{:Down}) tanımlayın.

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

trunc(x) x'in mutlak değeri x'in mutlak değerine eşit veya daha küçük olan aynı türdeki en yakın tam sayıyı döndürür.

trunc(T, x) sonucu T türüne dönüştürür, eğer kesilmiş değer T olarak temsil edilemiyorsa bir InexactError fırlatır.

digits, sigdigits ve base anahtar kelimeleri round için olduğu gibi çalışır.

Yeni bir tür için trunc'u desteklemek için Base.round(x::NewType, ::RoundingMode{:ToZero}) tanımlayın.

Ayrıca bkz: %, floor, unsigned, unsafe_trunc.

Örnekler

julia> trunc(2.22)
2.0

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

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

x'in mutlak değeri x'in mutlak değerine eşit veya daha küçük olan T türünde en yakın tam sayı değerini döndürür. Eğer değer T tarafından temsil edilemiyorsa, rastgele bir değer döndürülecektir. Ayrıca bkz. trunc.

Örnekler

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

Argümanların en küçüğünü isless ile karşılaştırarak döndürür. Argümanlardan herhangi biri missing ise, missing döner. Bir koleksiyondan en küçük öğeyi almak için minimum fonksiyonuna da bakın.

Örnekler

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

Argümanların maksimumunu isless ile karşılaştırarak döndürür. Argümanlardan herhangi biri missing ise, missing döner. Bir koleksiyondan maksimum elemanı almak için maximum fonksiyonuna da bakın.

Örnekler

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

Döndürür (min(x,y), max(x,y)).

Ayrıca (minimum(x), maximum(x)) döndüren extrema ile de bakabilirsiniz.

Örnekler

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

clamp(x, lo, hi)

lo <= x <= hi ise x döner. Eğer x > hi ise hi döner. Eğer x < lo ise lo döner. Argümanlar ortak bir türe yükseltilir.

Ayrıca bkz. clamp!, min, max.

Örnekler

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)  # lo > hi olan bir örnek
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

x değerini typemin(T) ve typemax(T) arasında sınırlayın ve sonucu T türüne dönüştürün.

Ayrıca bkz. trunc.

Örnekler

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

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

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

x değerini r aralığında sınırlayın.

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

array içindeki değerleri belirtilen aralıkla sınırlayın, yerinde. Ayrıca bkz. clamp.

Örnekler

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

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) ile 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)

x'in mutlak değeri.

abs işlevi işaretli tam sayılara uygulandığında, taşma meydana gelebilir ve bu da negatif bir değerin döndürülmesine neden olabilir. Bu taşma, yalnızca abs işlevi işaretli bir tam sayının temsil edilebilen en küçük değerine uygulandığında gerçekleşir. Yani, x == typemin(typeof(x)) olduğunda, abs(x) == x < 0 olur, beklenildiği gibi -x değil.

Ayrıca bakınız: abs2, unsigned, sign.

Örnekler

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # typemin(Int8) üzerinde taşma
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

Kontrol Edildi

Kontrol Edildi modülü, taşma meydana geldiğinde hata fırlatan yerleşik işaretli ve işaretsiz Tam sayı türleri için aritmetik fonksiyonlar sağlar. checked_sub, checked_div gibi adlandırılmışlardır. Ayrıca, add_with_overflow, sub_with_overflow, mul_with_overflow hem kontrolsüz sonuçları hem de bir taşmanın varlığını belirten bir boolean değeri döndürür.

Base.checked_abs(x)

abs(x) değerini hesaplar, uygun yerlerde taşma hatalarını kontrol eder. Örneğin, standart iki'nin tamamlayanı işaretli tam sayılar (örneğin Int), abs(typemin(Int)) değerini temsil edemez, bu da bir taşmaya yol açar.

Taşma koruması, algılanabilir bir performans cezası getirebilir.

Base.checked_neg(x)

-x hesaplar, uygun yerlerde taşma hatalarını kontrol eder. Örneğin, standart iki'nin tamamlayanı işaretli tam sayılar (örneğin Int) -typemin(Int) değerini temsil edemez, bu da bir taşmaya yol açar.

Taşma koruması, algılanabilir bir performans cezası getirebilir.

Base.checked_add(x, y)

x+y hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_sub(x, y)

x-y hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_mul(x, y)

x*y hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_div(x, y)

div(x,y) hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_rem(x, y)

x%y hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_fld(x, y)

fld(x,y) hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_mod(x, y)

mod(x,y) hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_cld(x, y)

cld(x,y) hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

Base.checked_pow(x, y)

^(x,y) hesaplar, uygun yerlerde taşma hatalarını kontrol eder.

Taşma koruması, algılanabilir bir performans cezası uygulayabilir.

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

r = x+y hesaplar, f ise taşmanın olup olmadığını gösterir.

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

r = x-y hesaplar, f ise taşmanın olup olmadığını gösterir.

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

r = x*y hesaplanır, f ise taşmanın olup olmadığını gösterir.

abs2(x)

x'in kare mutlak değeri.

Bu, özellikle abs(x)'in bir karekök gerektirdiği karmaşık sayılar için abs(x)^2'den daha hızlı olabilir, hypot aracılığıyla.

Ayrıca bkz. abs, conj, real.

Örnekler

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

z'yi x'in büyüklüğüne ve y'nin aynı işaretine sahip olacak şekilde döndürün.

Örnekler

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

x==0 ise sıfır döndür ve aksi takdirde $x/|x|$ (yani, reel x için ±1) döndür.

Ayrıca bkz. signbit, zero, copysign, flipsign.

Örnekler

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)

x değerinin işaretinin negatif olup olmadığını kontrol eder, eğer negatifse true, aksi takdirde false döner.

Ayrıca bkz. sign ve copysign.

Örnekler

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

y negatifse x'in işaretini tersine çevirir. Örneğin abs(x) = flipsign(x,x).

Örnekler

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

√(x)

Sonuç $\sqrt{x}$.

Negatif Real argümanlar için DomainError fırlatır. Bunun yerine karmaşık negatif argümanlar kullanın. sqrt'ın negatif reel eksen boyunca bir dal kesimi olduğunu unutmayın.

Önek operatör √, sqrt ile eşdeğerdir.

Ayrıca bkz: hypot.

Örnekler

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
HATA: -81.0 ile DomainError:
NaN girişi için NaN olmayan sonuç.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

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

julia> sqrt(-81 - 0.0im)  # -0.0im dal kesiminin altında
0.0 - 9.0im

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

isqrt(n::Integer)

Tam sayı karekökü: m*m <= n koşulunu sağlayan en büyük tam sayı m.

julia> isqrt(5)
2

cbrt(x::Gerçek)

x'in küp kökünü döndürür, yani $x^{1/3}$. Negatif değerler kabul edilir (eğer $x < 0$ ise negatif gerçek kökü döndürür).

Önek operatör ∛, cbrt ile eşdeğerdir.

Örnekler

julia> cbrt(big(27))
3.0

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

real(z)

Karmaşık sayı z'nin reel kısmını döndürür.

Ayrıca bakınız: imag, reim, complex, isreal, Real.

Örnekler

julia> real(1 + 3im)
1

real(T::Type)

Bir T türündeki bir değerin reel kısmını temsil eden türü döndürür. Örneğin: T == Complex{R} için R döner. typeof(real(zero(T))) ile eşdeğerdir.

Örnekler

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

Dizi A'deki her bir elemanın reel kısmını içeren bir dizi döndürür.

real.(A) ile eşdeğerdir, ancak eltype(A) <: Real olduğunda A kopyalanmadan döndürülür ve A sıfır boyutlu olduğunda bir skalar yerine 0-boyutlu bir dizi döndürülür.

Örnekler

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

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

imag(z)

Karmaşık sayı z'nin hayali kısmını döndürür.

Ayrıca bakınız: conj, reim, adjoint, angle.

Örnekler

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

Dizi A'deki her bir elemanın hayali kısmını içeren bir dizi döndürür.

imag.(A) ile eşdeğerdir, ancak A sıfır boyutlu olduğunda, bir skalar yerine 0-boyutlu bir dizi döndürülür.

Örnekler

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

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

reim(z)

Karmaşık sayı z'nin reel ve sanal kısımlarını içeren bir demet döndürür.

Örnekler

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

reim(A::AbstractArray)

Her bir girişin gerçek ve hayali kısmını içeren iki diziden oluşan bir demet döndürür A.

(real.(A), imag.(A)) ile eşdeğerdir, ancak eltype(A) <: Real olduğunda A gerçek kısmı temsil etmek için kopyalanmadan döndürülür ve A sıfır boyutlu olduğunda, bir skalar yerine 0-boyutlu bir dizi döndürülür.

Örnekler

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

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

conj(z)

Bir karmaşık sayı z'nin karmaşık eşleniğini hesaplar.

Ayrıca bakınız: angle, adjoint.

Örnekler

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

conj(A::AbstractArray)

Dizi A'deki her bir elemanın karmaşık eşleniğini içeren bir dizi döndürür.

conj.(A) ile eşdeğerdir, ancak eltype(A) <: Real olduğunda A kopyalanmadan döndürülür ve A sıfır boyutlu olduğunda bir skalar yerine 0-boyutlu bir dizi döndürülür.

Örnekler

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

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

angle(z)

Bir karmaşık sayı z'nin radyan cinsinden faz açısını hesaplar.

-pi ≤ angle(z) ≤ pi aralığında bir sayı döndürür ve bu nedenle negatif reel eksen boyunca kesintilidir.

Ayrıca bakınız: atan, cis, rad2deg.

Örnekler

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)

Euler formülünü kullanarak exp(im*x) için daha verimli bir yöntem: $\cos(x) + i \sin(x) = \exp(i x)$.

Ayrıca bkz. cispi, sincos, exp, angle.

Örnekler

julia> cis(π) ≈ -1
true

cispi(x)

cis(pi*x) için daha doğru bir yöntem (özellikle büyük x için).

Ayrıca bkz. cis, sincospi, exp, angle.

Örnekler

julia> cispi(10000)
1.0 + 0.0im

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

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

binom katsayısı $\binom{n}{k}$, $(1+x)^n$ polinom genişlemesindeki $k$'inci terimin katsayısıdır.

Eğer $n$ negatif değilse, o zaman k'yı n öğesinden seçmenin yollarının sayısıdır:

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

burada $n!$ factorial fonksiyonudur.

Eğer $n$ negatifse, o zaman tanım şu kimlik ile yapılır:

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

Ayrıca bkz. factorial.

Örnekler

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

Dış bağlantılar

• Binom katsayısı Wikipedia'da.

```

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

Genelleştirilmiş binom katsayısı, k ≥ 0 için aşağıdaki polinom ile tanımlanır

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

k < 0 olduğunda sıfır döner.

Tam sayı x durumu için bu, sıradan tam sayı binom katsayısına eşdeğerdir

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

Tam olmayan k için daha fazla genelleme matematiksel olarak mümkündür, ancak Gamma fonksiyonu ve/veya beta fonksiyonu içerir; bu fonksiyonlar Julia standart kütüphanesinde sağlanmamaktadır, ancak SpecialFunctions.jl gibi harici paketlerde mevcuttur.

Harici bağlantılar

• Binom katsayısı Vikipedi'de.

factorial(n::Integer)

n'nin faktöriyeli. Eğer n bir Integer ise, faktöriyel en az 64 bit'e yükseltilmiş bir tam sayı olarak hesaplanır. n küçük değilse bu taşma yapabilir, ancak sonucu tam olarak hesaplamak için factorial(big(n)) kullanabilirsiniz.

Ayrıca binomial ile de bakabilirsiniz.

Örnekler

julia> factorial(6)
720

julia> factorial(21)
HATA: OverflowError: 21, tabloda bakmak için çok büyük; bunun yerine `factorial(big(21))` kullanmayı düşünün
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

Dış bağlantılar

• Faktöriyel Wikipedia'da.

```

gcd(x, y...)

En büyük ortak (pozitif) bölen (veya tüm argümanlar sıfırsa sıfır). Argümanlar tam sayılar ve rasyonel sayılar olabilir.

Örnekler

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...)

En küçük (pozitif) çarpan (veya herhangi bir argüman sıfırsa sıfır). Argümanlar tam sayılar ve rasyonel sayılar olabilir.

Örnekler

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)

a ve b'nin en büyük ortak (pozitif) bölenini ve Bézout katsayılarını, yani $ua+vb = d = gcd(a, b)$ eşitliğini sağlayan tam sayı katsayıları u ve v'yi hesaplar. gcdx(a, b) $(d, u, v)$ döner.

Argümanlar tam sayılar ve rasyonel sayılar olabilir.

Örnekler

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

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

ispow2(n::Number) -> Bool

n'nin bir tam sayı iki kuvveti olup olmadığını test eder.

Ayrıca bkz. count_ones, prevpow, nextpow.

Örnekler

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)

x'ten küçük olmayan en küçük a^n, burada n pozitif bir tam sayıdır. a 1'den büyük olmalı ve x 0'dan büyük olmalıdır.

Ayrıca prevpow bakınız.

Örnekler

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

x'den büyük olmayan en büyük a^n, burada n sıfır veya pozitif bir tam sayıdır. a 1'den büyük olmalı ve x 1'den küçük olmamalıdır.

Ayrıca bkz. nextpow, isqrt.

Örnekler

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)

n'ye eşit veya daha büyük olan ve factors içindeki faktörler için $k_i^{p_i}$ şeklinde yazılabilen en küçük tam sayı.

Örnekler

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

julia> 2^2 * 3^3
108

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

m modülünde n'nin tersini alır: $n y = 1 \pmod m$ olacak şekilde y, ve $div(y,m) = 0$. Bu, $m = 0$ olduğunda veya $gcd(n,m) \neq 1$ olduğunda bir hata fırlatır.

Örnekler

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}

n'nin modüler tersini T türündeki tam sayı halkasında hesaplar, yani 2^N modunda, burada N = 8*sizeof(T) (örneğin N = 32 için Int32). Başka bir deyişle, bu yöntemler aşağıdaki kimlikleri sağlar:

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

Burada * modüler çarpma anlamına gelir, T tam sayı halkasında.

Bir tam sayı türü tarafından ima edilen modülü açık bir değer olarak belirtmek genellikle elverişsizdir çünkü modül tanım gereği tür tarafından temsil edilemeyecek kadar büyüktür.

Modüler ters, genel duruma göre çok daha verimli bir şekilde, https://arxiv.org/pdf/2204.04342.pdf adresinde açıklanan algoritma kullanılarak hesaplanır.

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

\[x^p \pmod m\]

hesaplar.

Örnekler

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)

Tam sayısı n'nin base tabanında yazıldığında kaç basamak olduğunu hesaplar (base değeri [-1, 0, 1] içinde olmamalıdır), isteğe bağlı olarak belirtilen boyuta sıfırlarla doldurulabilir (sonuç asla pad'den az olmayacaktır).

Ayrıca digits, count_ones bakınız.

Örnekler

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)

sum içinde kullanılan azaltma operatörü. + ile ana fark, küçük tam sayıların Int/UInt'ye yükseltilmesidir.

widemul(x, y)

x ve y'yi çarpar, sonucu daha büyük bir türde verir.

Ayrıca bkz. promote, Base.add_sum.

Örnekler

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)

Polinomun $\sum_k x^{k-1} p[k]$ değerini hesaplar; yani, katsayılar p[1], p[2], ... şeklinde x'in kuvvetine göre artan sırada verilmiştir. Katsayıların sayısı statik olarak biliniyorsa, yani p bir Tuple ise döngüler derleme zamanında açılır. Bu fonksiyon, x gerçekse Horner yöntemi kullanarak verimli kod üretir veya x karmaşık ise Goertzel benzeri ^[DK62] algoritmasını kullanır.

Örnekler

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

@evalpoly(z, c...)

Polinomun $\sum_k z^{k-1} c[k]$ değerini c[1], c[2], ... için hesaplar; yani, katsayılar z'nin kuvvetine göre artan sırada verilmiştir. Bu makro, ya Horner yöntemi ya da karmaşık z için daha verimli bir Goertzel benzeri algoritma kullanan verimli satır içi koda genişler.

Ayrıca evalpoly bakınız.

Örnekler

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

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

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

@fastmath expr

Dönüştürülmüş bir ifadenin yürütülmesini sağlar; bu, katı IEEE semantiğini ihlal edebilecek işlevleri çağırır. Bu, mümkün olan en hızlı işlemi sağlar, ancak sonuçlar belirsizdir – bunu yaparken dikkatli olun, çünkü sayısal sonuçları değiştirebilir.

Bu, LLVM Fast-Math bayraklarını ayarlar ve clang'daki -ffast-math seçeneğine karşılık gelir. Daha fazla ayrıntı için performans notları bölümüne bakın.

Örnekler

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672