Numbers

Sayı

Tüm sayı türleri için soyut süper tür.

Gerçek <: Sayı

Tüm gerçek sayılar için soyut üsttip.

AbstractFloat <: Real

Tüm kayan nokta sayıları için soyut üst tip.

Tam sayı <: Gerçek

Tüm tam sayılar için soyut üst tür (örneğin, Signed, Unsigned ve Bool).

Ayrıca bkz. isinteger, trunc, div.

Örnekler

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

Tüm işaretli tam sayılar için soyut üst tür.

Unsigned <: Integer

Tüm işaretsiz tam sayılar için soyut üst tür.

Yerleşik işaretsiz tam sayılar onaltılık olarak, 0x öneki ile yazdırılır ve aynı şekilde girilebilir.

Örnekler

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

Tam sayısı, diğer sayısal miktarlarla yapılan aritmetik işlemlerde doğru hassasiyete otomatik olarak yuvarlanan tam bir irrasyonel değeri temsil eder.

MyIrrational <: AbstractIrrational alt türleri en azından ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt) ve convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}} işlevlerini uygulamalıdır.

Bir alt tür, zaman zaman rasyonel değerleri temsil etmek için kullanılıyorsa (örneğin, √n için tam sayılar n olduğunda bir karekök türü, n bir mükemmel kare olduğunda rasyonel bir sonuç verecektir), o zaman isinteger, iszero, isone ve == işlevlerini Real değerleri ile uygulamalıdır (çünkü bunların hepsi AbstractIrrational türleri için varsayılan olarak false döner), ayrıca hash işlevini karşılık gelen Rational ile eşit olacak şekilde tanımlamalıdır.

Float16 <: AbstractFloat <: Real

16 bit kayan nokta türü (IEEE 754 standardı). İkili format 1 işaret, 5 üstel, 10 kesir bitidir.

Float32 <: AbstractFloat <: Real

32-bit kayan nokta türü (IEEE 754 standardı). İkili format 1 işaret, 8 üs, 23 kesir bitidir.

Bilimsel gösterim için üs, küçük harf f olarak girilmelidir, bu nedenle 2f3 === 2.0f0 * 10^3 === Float32(2_000). Dizi literalleri ve kavramları için, eleman türü köşeli parantezlerden önce belirtilebilir: Float32[1,4,9] == Float32[i^2 for i in 1:3].

Ayrıca Inf32, NaN32, Float16, exponent, frexp bakınız.

Float64 <: AbstractFloat <: Real

64-bit kayan nokta sayısı türü (IEEE 754 standardı). İkili format 1 işaret, 11 üs, 52 kesir bitidir. Çeşitli bitlere erişmek için bitstring, signbit, exponent, frexp ve significand bakın.

Bu, kayan nokta literalleri için varsayılan olanıdır, 1.0 isa Float64 ve 1/2, 2pi, log(2), range(0,90,length=4) gibi birçok işlem için. Tam sayılardan farklı olarak, bu varsayılan Sys.WORD_SIZE ile değişmez.

Bilimsel notasyon için üs e veya E olarak girilebilir, böylece 2e3 === 2.0E3 === 2.0 * 10^3. Bunu 10^n yerine kullanmak şiddetle tercih edilir çünkü tam sayılar taşar, bu nedenle 2.0 * 10^19 < 0 ama 2e19 > 0.

Ayrıca Inf, NaN, floatmax, Float32, Complex bakın.

BigFloat <: AbstractFloat

Rastgele hassasiyetli kayan nokta sayı türü.

Bool <: Integer

Boolean türü, true ve false değerlerini içerir.

Bool, bir tür sayı gibidir: false sayısal olarak 0'a, true ise sayısal olarak 1'e eşittir. Dahası, false, NaN ve Inf karşısında çarpan olarak "güçlü sıfır" işlevi görür:

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

julia> 42.0 + true
43.0

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

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

if ve diğer koşullu ifadeler yalnızca Bool kabul eder. Julia'da "doğruluk" değerleri yoktur.

Karşılaştırmalar genellikle Bool döner ve yayılmış karşılaştırmalar BitArray yerine Array{Bool} dönebilir.

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

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

Ayrıca trues, falses, ifelse bakınız.

Int8 <: Signed <: Integer

8 bit işaretli tam sayı türü.

n ∈ -128:127 aralığındaki sayıları temsil eder. Bu tür tam sayılar uyarı vermeden taşar, bu nedenle typemax(Int8) + Int8(1) < 0 ifadesi doğrudur.

Ayrıca bkz. Int, widen, BigInt.

UInt8 <: Unsigned <: Integer

8 bit işaretsız tam sayı türü.

Onaltılık olarak yazdırıldığında, bu nedenle 0x07 == 7.

Int16 <: Signed <: Integer

16-bit işaretli tam sayı türü.

n ∈ -32768:32767 sayılarını temsil eder. Bu tür tam sayılar uyarı olmadan taşar, bu nedenle typemax(Int16) + Int16(1) < 0 ifadesi geçerlidir.

Ayrıca bkz. Int, widen, BigInt.

UInt16 <: Unsigned <: Integer

16-bit işaretsız tam sayı türü.

Onaltılık olarak yazdırıldığında, bu nedenle 0x000f == 15.

Int32 <: Signed <: Integer

32-bit işaretli tam sayı türü.

Bu tür tam sayıların uyarı vermeden taşma yaptığını unutmayın, bu nedenle typemax(Int32) + Int32(1) < 0.

Ayrıca bkz. Int, widen, BigInt.

UInt32 <: Unsigned <: Integer

32-bit işaretsız tam sayı türü.

Onaltılık olarak yazdırıldığında, bu nedenle 0x0000001f == 31.

Int64 <: Signed <: Integer

64-bit işaretli tam sayı türü.

Bu tür tam sayıların uyarı vermeden taşma yaptığını unutmayın, bu nedenle typemax(Int64) + Int64(1) < 0.

Ayrıca bkz. Int, widen, BigInt.

UInt64 <: Unsigned <: Integer

64-bit işaretsiz tam sayı türü.

Onaltılık olarak yazdırıldığında, bu nedenle 0x000000000000003f == 63.

Int128 <: Signed <: Integer

128 bit işaretli tam sayı türü.

Bu tür tam sayıların uyarı vermeden taşma yaptığını unutmayın, bu nedenle typemax(Int128) + Int128(1) < 0.

Ayrıca bkz. Int, widen, BigInt.

UInt128 <: Unsigned <: Integer

128-bit işaretsiz tam sayı türü.

Onaltılık olarak yazdırıldığında, bu nedenle 0x0000000000000000000000000000007f == 127.

Int

Sys.WORD_SIZE-bit işaretli tam sayı türü, Int <: Signed <: Integer <: Real.

Bu, çoğu tam sayı literali için varsayılan türdür ve Sys.WORD_SIZE'a bağlı olarak ya Int32 ya da Int64 için bir takma addır. length gibi fonksiyonlar tarafından döndürülen türdür ve dizileri indekslemek için standart türdür.

Tam sayıların uyarı olmadan taşma yaptığını unutmayın, bu nedenle typemax(Int) + 1 < 0 ve 10^19 < 0 doğrudur. Taşmayı önlemek için BigInt kullanabilirsiniz. Çok büyük tam sayı literalleri daha geniş bir tür kullanır, örneğin 10_000_000_000_000_000_000 isa Int128.

Tam sayı bölmesi div takma adı ÷ iken, tam sayılar üzerinde / kullanmak Float64 döndürür.

Ayrıca Int64, widen, typemax, bitstring ile de bakabilirsiniz.

UInt

Sys.WORD_SIZE bit işaretsiz tam sayı türü, UInt <: Unsigned <: Integer.

Int gibi, UInt takma adı, belirli bir bilgisayardaki Sys.WORD_SIZE değerine göre ya UInt32 ya da UInt64'e işaret edebilir.

Onaltılık olarak yazdırılır ve ayrıştırılır: UInt(15) === 0x000000000000000f.

BigInt <: Signed

Arbitrar hassasiyet tam sayı türü.

Complex{T<:Gerçek} <: Sayı

Gerçek ve hayali kısmı T türünde olan karmaşık sayı türü.

ComplexF16, ComplexF32 ve ComplexF64, sırasıyla Complex{Float16}, Complex{Float32} ve Complex{Float64} için takma adlardır.

Ayrıca bakınız: Real, complex, real.

Rasyonel{T<:Tam Sayı} <: Gerçek

Rasyonel sayı türü, pay ve payda T türündedir. Rasyoneller taşma için kontrol edilir.

Irrasyonel{sym} <: AbstractIrrasyonel

Sembol sym ile gösterilen tam bir irrasyonel değeri temsil eden sayı türü, örneğin π, ℯ ve γ.

Ayrıca bkz. AbstractIrrasyonel.

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

Verilen tabanda n'nin basamaklarını, isteğe bağlı olarak belirtilen boyuta sıfırlarla doldurulmuş T (varsayılan Int) türünde bir dizi döndürür. Daha anlamlı basamaklar daha yüksek indekslerde yer alır, böylece n == sum(digits[k]*base^(k-1) for k in eachindex(digits)) olur.

Ayrıca ndigits, digits! ve taban 2 için bitstring, count_ones ile de bakabilirsiniz.

Örnekler

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

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

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

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

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

digits!(dizi, n::Tam sayı; taban::Tam sayı = 10)

Verilen tabanda n'nin basamaklarını içeren bir dizi doldurur. Daha anlamlı basamaklar daha yüksek indekslerde bulunur. Eğer dizi uzunluğu yetersizse, en az anlamlı basamaklar dizi uzunluğuna kadar doldurulur. Eğer dizi uzunluğu fazla ise, fazlalık kısmı sıfırlarla doldurulur.

Örnekler

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

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

bitstring(n)

Bir ilkel türün literal bit temsilini veren bir dize.

Ayrıca bkz. count_ones, count_zeros, digits.

Örnekler

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

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

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

tryparse(SimpleColor, rgb::String) (buna bakınız) ile benzer bir işlevdir; nothing döndürmek yerine bir hata yükseltir.

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

Bir dize platform triplet'ini tekrar bir Platform nesnesine ayrıştırır.

parse(tip, str; taban)

Bir dizeyi sayı olarak ayrıştırır. Tam Sayı türleri için bir taban belirtilebilir (varsayılan 10'dur). Kesirli sayı türleri için dize ondalık kesirli bir sayı olarak ayrıştırılır. Karmaşık türler, istenen türde Complex(R,I) olarak "R±Iim" biçimindeki ondalık dizelerden ayrıştırılır; "i" veya "j" de "im" yerine kullanılabilir ve "R" veya "Iim" de geçerlidir. Dize geçerli bir sayı içermiyorsa, bir hata oluşur.

Örnekler

julia> parse(Int, "1234")
1234

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

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

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

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

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

rgb'yi bir SimpleColor olarak ayrıştırmayı deneyin. Eğer rgb # ile başlıyorsa ve uzunluğu 7 ise, RGBTuple destekli bir SimpleColor'a dönüştürülür. Eğer rgb a-z ile başlıyorsa, rgb bir renk adı olarak yorumlanır ve Symbol destekli bir SimpleColor'a dönüştürülür.

Aksi takdirde, nothing döndürülür.

Örnekler

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

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

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

parse gibi, ancak istenen türde bir değer döndürür veya dize geçerli bir sayı içermiyorsa nothing döndürür.

big(x)

Bir sayıyı maksimum hassasiyet temsilinde dönüştür (tipik olarak BigInt veya BigFloat). Kayan nokta sayılarıyla ilgili bazı tuzaklar hakkında bilgi için BigFloat'ya bakın.

signed(T::Integer)

Bir tam sayı bit türünü aynı boyuttaki işaretli türe dönüştürür.

Örnekler

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

signed(x)

Bir sayıyı işaretli bir tam sayıya dönüştürür. Eğer argüman işaretsiz ise, taşma kontrolü yapılmadan işaretli olarak yeniden yorumlanır.

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

unsigned(T::Integer)

Bir tam sayı bit türünü aynı boyuttaki işaretsiz türe dönüştürür.

Örnekler

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

float(x)

Bir sayıyı veya diziyi kayan nokta veri türüne dönüştürür.

Ayrıca bakınız: complex, oftype, convert.

Örnekler

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

julia> float(typemax(Int32))
2.147483647e9

significand(x)

Bir kayan noktalı sayının anlamlı kısmını (diğer adıyla mantissa) çıkarır. Eğer x sıfırdan farklı sonlu bir sayı ise, sonuç x ile aynı türde ve işarete sahip bir sayı olacak ve mutlak değeri $[1,2)$ aralığında olacaktır. Aksi takdirde x döndürülür.

Ayrıca bkz. frexp, exponent.

Örnekler

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

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

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

exponent(x::Gerçek) -> Int

2^y ≤ abs(x) koşulunu sağlayan en büyük tam sayı y'yi döndürür.

x sıfır, sonsuz veya NaN olduğunda bir DomainError fırlatır. Diğer herhangi bir normal olmayan kayan nokta sayısı x için bu, x'in üs bitlerine karşılık gelir.

Ayrıca signbit, significand, frexp, issubnormal, log2, ldexp ile de ilgili.

Örnekler

julia> exponent(8)
3

julia> exponent(6.5)
2

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

julia> exponent(3.142e-4)
-12

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

julia> exponent(0.0)
HATA: DomainError ile 0.0:
±0.0 olamaz.
[...]

complex(r, [i])

Gerçek sayıları veya dizileri karmaşık sayılara dönüştürür. i varsayılan olarak sıfırdır.

Örnekler

julia> complex(7)
7 + 0im

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

bswap(n)

n'nin bayt sırasını tersine çevirir.

(Ayrıca, mevcut yerel bayt sırası ile büyük-endian sırası arasında dönüştürmek için ntoh ve hton bakın.)

Örnekler

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

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

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

hex2bytes(itr)

Bir dizi onaltılık basamak için ASCII kodlarının itr adlı bir yineleyicisi verildiğinde, dönen Vector{UInt8} türünde baytların ikili temsilini döndürür: itr içindeki her ardışık onaltılık basamak çifti, dönen vektörde bir baytın değerini verir.

itr'nin uzunluğu çift olmalıdır ve dönen dizi itr'nin uzunluğunun yarısı kadar olacaktır. Ayrıca hex2bytes! yerinde bir sürüm için ve bytes2hex tersine dönüşüm için bakınız.

Örnekler

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

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

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

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

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

Bir hexadecimal dizesini temsil eden byte'ların itr adlı iterable'ını ikili temsiline dönüştürür; hex2bytes ile benzerlik gösterir, ancak çıktı dest'e yerinde yazılır. dest'in uzunluğu itr'nin uzunluğunun yarısı olmalıdır.

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

Bir itr baytları iteratörünü onaltılık dize temsilini dönüştürür; ya bytes2hex(itr) ile bir String döndürür ya da bytes2hex(io, itr) ile dizeyi bir io akışına yazar. Onaltılık karakterler tamamen küçük harflerdir.

Örnekler

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

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

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

x için çarpan kimliği döndürür: one(x)*x == x*one(x) == x eşitliğini sağlayan bir değer. Alternatif olarak, one(T) bir tür T alabilir; bu durumda one, türü T olan herhangi bir x için çarpan kimliği döndürür.

Mümkünse, one(x) x ile aynı türde bir değer döndürür ve one(T) türü T olan bir değer döndürür. Ancak, bu durum boyutlu nicelikleri temsil eden türler (örneğin, gün cinsinden zaman) için geçerli olmayabilir, çünkü çarpan kimliği boyutsuz olmalıdır. Bu durumda, one(x) x ile aynı hassasiyette (ve şekil, matrisler için) bir kimlik değeri döndürmelidir.

x ile aynı türde veya T türünde bir nicelik istiyorsanız, oneunit[@ref] yerine kullanın.

Ayrıca identity fonksiyonuna ve I'ye LinearAlgebra içinde kimlik matrisine bakın.

Örnekler

julia> one(3.7)
1.0

julia> one(Int)
1

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

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

T(one(x)) döndürür, burada T ya argümanın türü ya da (bir tür geçerse) argümandır. Bu, boyutlu nicelikler için one ile farklıdır: one boyutsuzdur (çarpan kimliği) iken oneunit boyutludur (aynı türde x ile ya da T türünde).

Örnekler

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 gün

zero(x)
zero(::Type)

x için toplama kimlik elemanını alır (x aynı zamanda türü de belirtebilir).

Ayrıca bkz. iszero, one, oneunit, oftype.

Örnekler

julia> zero(1)
0

julia> zero(big"2.0")
0.0

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

im

Hayali birim.

Ayrıca bakınız: imag, angle, complex.

Örnekler

julia> im * im
-1 + 0im

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

π
pi

Sabit pi.

Unicode π Julia REPL'de \pi yazıp tab tuşuna basarak ve birçok editörde yazılabilir.

Ayrıca bakınız: sinpi, sincospi, deg2rad.

Örnekler

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

Sabit ℯ.

Unicode ℯ Julia REPL'de \euler yazarak ve tab tuşuna basarak, ve birçok editörde yazılabilir.

Ayrıca bakınız: exp, cis, cispi.

Örnekler

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

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

Katalan sabiti.

# Örnekler

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

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

γ
eulergamma

Euler sabiti.

Örnekler

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

julia> dx = 10^-6;

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

φ
altın

Altın oran.

# Örnekler

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

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

Inf, Inf64

Float64 türünde pozitif sonsuz.

Ayrıca bakınız: isfinite, typemax, NaN, Inf32.

Örnekler

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf, Inf64

Float64 türünde pozitif sonsuz.

Ayrıca bakınız: isfinite, typemax, NaN, Inf32.

Örnekler

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

Float32 türünde pozitif sonsuzluk.

Inf16

Float16 türünde pozitif sonsuzluk.

NaN, NaN64

Float64 türünde bir not-a-number değeri.

Ayrıca bakınız: isnan, missing, NaN32, Inf.

Örnekler

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

julia> reinterpret(UInt32, NaN32)
0x7fc00000

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

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

NaN, NaN64

Float64 türünde bir not-a-number değeri.

Ayrıca bakınız: isnan, missing, NaN32, Inf.

Örnekler

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

julia> reinterpret(UInt32, NaN32)
0x7fc00000

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

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

NaN32

Float32 türünde bir not-a-number değeri.

Ayrıca bakınız: NaN.

NaN16

Float16 türünde bir not-a-number değeri.

Ayrıca bakınız: NaN.

issubnormal(f) -> Bool

Bir kayan nokta sayısının altnormal olup olmadığını test eder.

Bir IEEE kayan nokta sayısı, üstel bitleri sıfır ve anlam değeri sıfır değilse altnormal olarak kabul edilir.

Örnekler

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

Bir sayının sonlu olup olmadığını test eder.

Örnekler

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

Bir sayının sonsuz olup olmadığını test eder.

Ayrıca bakınız: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

Bir sayı değerinin NaN olup olmadığını test eder; bu, ne bir sonsuzluk ne de sonlu bir sayı olan belirsiz bir değerdir ("sayı değil").

Ayrıca bakınız: iszero, isone, isinf, ismissing.

iszero(x)

x == zero(x) ise true döner; eğer x bir dizi ise, bu x'in tüm elemanlarının sıfır olup olmadığını kontrol eder.

Ayrıca bakınız: isone, isinteger, isfinite, isnan.

Örnekler

julia> iszero(0.0)
true

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

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

isone(x)

x == one(x) ise true döner; eğer x bir dizi ise, bu x'in bir kimlik matris olup olmadığını kontrol eder.

Örnekler

julia> isone(1.0)
true

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

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

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

x'e n kez ardışık nextfloat uygulamasının sonucu, eğer n >= 0 ise; n < 0 ise prevfloat uygulamalarının -n kez sonucudur.

nextfloat(x::AbstractFloat)

x ile aynı türdeki en küçük kayan nokta sayısını y döndürür, böylece x < y. Eğer böyle bir y yoksa (örneğin, x Inf veya NaN ise), o zaman x döndürülür.

Ayrıca bakınız: prevfloat, eps, issubnormal.

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

x'e n kez ardışık prevfloat uygulamalarının sonucu, eğer n >= 0 ise; n < 0 ise nextfloat uygulamalarının -n kez sonucudur.

prevfloat(x::AbstractFloat)

x ile aynı türdeki en büyük kayan nokta sayısını y döndürür, böylece y < x. Eğer böyle bir y yoksa (örneğin, x -Inf veya NaN ise), o zaman x'i döndür.

isinteger(x) -> Bool

x'in sayısal olarak bazı bir tam sayıya eşit olup olmadığını test eder.

Örnekler

julia> isinteger(4.0)
true

isreal(x) -> Bool

x veya tüm elemanlarının sonsuzluklar ve NaN'lar dahil olmak üzere bazı reel sayılara sayısal olarak eşit olup olmadığını test eder. isreal(x) eğer isequal(x, real(x)) doğruysa doğrudur.

Örnekler

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

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

Float32(x [, mode::RoundingMode])

x'den bir Float32 oluşturur. Eğer x tam olarak temsil edilemiyorsa, mode x'in nasıl yuvarlandığını belirler.

Örnekler

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

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

Mevcut yuvarlama modları için RoundingMode kısmına bakın. ```

Float64(x [, mode::RoundingMode])

x'den bir Float64 oluşturur. Eğer x tam olarak temsil edilemiyorsa, mode x'in nasıl yuvarlanacağını belirler.

Örnekler

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

Mevcut yuvarlama modları için RoundingMode kısmına bakın. ```

rounding(T)

T tipi için mevcut kayan nokta yuvarlama modunu alır, temel aritmetik fonksiyonların (+, -, *, / ve sqrt) ve tür dönüşümünün yuvarlamasını kontrol eder.

Mevcut modlar için RoundingMode bakın.

setrounding(T, mode)

T türündeki kayan nokta sayısının yuvarlama modunu ayarlar ve temel aritmetik fonksiyonların (+, -, *, / ve sqrt) ve tür dönüşümünün yuvarlamasını kontrol eder. Varsayılan RoundNearest dışındaki yuvarlama modları kullanıldığında diğer sayısal fonksiyonlar yanlış veya geçersiz değerler verebilir.

Bu durumun şu anda yalnızca T == BigFloat için desteklendiğini unutmayın.

setrounding(f::Function, T, mode)

f fonksiyonu süresince T kayan nokta türünün yuvarlama modunu değiştirir. Mantıksal olarak şuna eşdeğerdir:

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

Mevcut yuvarlama modları için RoundingMode kısmına bakın.

get_zero_subnormals() -> Bool

Alt false eğer alt normal kayan nokta değerleri ("denormal" olarak da bilinir) IEEE aritmetiği kurallarına uyuyorsa, ve true eğer bunlar sıfıra dönüştürülebilirlerse.

!!! uyarı Bu fonksiyon yalnızca mevcut iş parçacığını etkiler.

set_zero_subnormals(yes::Bool) -> Bool

Eğer yes false ise, sonraki kayan nokta işlemleri alt normal değerler ("denormals") için IEEE aritmetiği kurallarını takip eder. Aksi takdirde, kayan nokta işlemleri alt normal girişleri veya çıkışları sıfıra dönüştürmek için izin verilir (ancak zorunlu değildir). true döner, eğer yes==true ise ama donanım alt normal sayıları sıfırlamayı desteklemiyorsa.

set_zero_subnormals(true) bazı donanımlarda bazı hesaplamaları hızlandırabilir. Ancak, (x-y==0) == (x==y) gibi kimlikleri bozabilir.

!!! uyarı Bu fonksiyon yalnızca mevcut iş parçacığını etkiler.

count_ones(x::Integer) -> Integer

x'in ikili temsilindeki birlerin sayısı.

Örnekler

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

x'in ikili temsilindeki sıfır sayısı.

Örnekler

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

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

x'in ikili temsilindeki başındaki sıfırların sayısı.

Örnekler

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

x'in ikili temsilindeki baştaki 1'lerin sayısı.

Örnekler

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

trailing_zeros(x::Integer) -> Integer

x'in ikili temsilinin ardındaki sıfır sayısı.

Örnekler

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

x'in ikili temsilinin sonundaki 1'lerin sayısı.

Örnekler

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

x tek bir tek sayı ise true döner (yani, 2'ye tam bölünemeyen bir tam sayı), aksi takdirde false döner.

Örnekler

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

x bir çift tam sayı (yani, 2'ye tam bölünebilen bir tam sayı) ise true, aksi takdirde false döndürün.

Örnekler

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

str'yi Int128 olarak ayrıştırın. Dize geçerli bir tam sayı değilse bir ArgumentError fırlatın.

Örnekler

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
HATA: LoadError: ArgumentError: "123456789123.4" içinde geçersiz taban 10 rakamı '.' 
[...]

@uint128_str str

str'yi UInt128 olarak ayrıştırın. Dize geçerli bir tam sayı değilse bir ArgumentError fırlatın.

Örnekler

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
HATA: LoadError: ArgumentError: "-123456789123" içinde geçersiz taban 10 rakamı '-'
[...]

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

x'den precision ile birlikte, keyfi hassasiyetli bir kayan nokta sayısı oluşturur. rounding argümanı, dönüşüm tam olarak yapılamazsa sonucun hangi yönde yuvarlanması gerektiğini belirtir. Sağlanmadığı takdirde, bunlar mevcut küresel değerler tarafından ayarlanır.

BigFloat(x::Real) convert(BigFloat,x) ile aynıdır, ancak x kendisi zaten BigFloat ise, bu durumda mevcut küresel hassasiyet ayarlarına sahip bir değer döndürür; convert her zaman x'i döndürecektir.

BigFloat(x::AbstractString) parse ile aynıdır. Bu, ondalık literallerin ayrıştırıldığında Float64'e dönüştürüldüğü için sağlanmıştır, bu nedenle BigFloat(2.1) beklediğiniz sonucu vermeyebilir.

Ayrıca bakınız:

• @big_str
• rounding ve setrounding
• precision ve setprecision

Örnekler

julia> BigFloat(2.1) # 2.1 burada bir Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # 2.1'e en yakın BigFloat
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

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

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

Bir kayan nokta sayısının hassasiyetini, anlamlı basamaklardaki etkili bit sayısı olarak tanımlar veya bir kayan nokta türü T için hassasiyeti döner (eğer T, BigFloat gibi değişken hassasiyetli bir türse, mevcut varsayılanı).

Eğer base belirtilmişse, o zaman o tabandaki maksimum karşılık gelen anlamlı basamak sayısını döner.

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

T aritmetiği için kullanılacak hassasiyeti (varsayılan olarak bit cinsinden) ayarlayın. base belirtilirse, o zaman hassasiyet, belirtilen base'de en az precision basamağı vermek için gereken minimum değerdir.

!!! uyarı Bu fonksiyon thread-güvenli değildir. Tüm thread'lerde çalışan kodu etkileyecektir, ancak ayar ile birlikte hesaplamalarla eşzamanlı olarak çağrıldığında davranışı tanımsızdır.

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

Verilen base için f süresince T aritmetik hassasiyetini değiştirir. Mantıken eşdeğerdir:

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

Genellikle setprecision(T, precision) do ... end şeklinde kullanılır.

Not: nextfloat(), prevfloat() setprecision ile belirtilen hassasiyeti kullanmaz.

BigInt(x)

Arbitrary hassasiyetli bir tam sayı oluşturur. x, bir Int (veya bir Int'e dönüştürülebilen herhangi bir şey) olabilir. Bu tür için olağan matematiksel operatörler tanımlıdır ve sonuçlar BigInt olarak yükseltilir.

Örnekler, parse aracılığıyla dizelerden veya big dize literalini kullanarak oluşturulabilir.

Örnekler

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

Bir dizeyi BigInt veya BigFloat olarak ayrıştırın ve dize geçerli bir sayı değilse bir ArgumentError fırlatın. Tam sayılar için _ dizede bir ayırıcı olarak kullanılabilir.

Örnekler

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
HATA: ArgumentError: BigInt veya BigFloat için geçersiz sayı formatı _
[...]

!!! uyarı BigFloat değerleri oluşturmak için @big_str kullanmak, naif olarak beklenebilecek davranışı sağlamayabilir: bir makro olarak @big_str, yükleme zamanı itibarıyla mevcut olan global hassasiyet (setprecision) ve yuvarlama modu (setrounding) ayarlarına uyar. Bu nedenle, () -> precision(big"0.3") gibi bir fonksiyon, fonksiyonun tanımlandığı andaki hassasiyet değerine bağlı olan sabit bir değer döndürür, fonksiyonun çağrıldığı zamandaki hassasiyete değil.