Numbers

رقم

نوع سوبر تجريدي لجميع أنواع الأرقام.

Real <: Number

نوع مجرد أعلى لجميع الأعداد الحقيقية.

AbstractFloat <: Real

نوع السوبر المجرد لجميع أرقام النقطة العائمة.

Integer <: Real

نوع تجريدي أعلى لجميع الأعداد الصحيحة (مثل Signed، Unsigned، وBool).

انظر أيضًا isinteger، trunc، div.

أمثلة

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

نوع تجريدي أعلى لجميع الأعداد الصحيحة الموقعة.

Unsigned <: Integer

نوع تجريدي أعلى لجميع الأعداد الصحيحة غير الموقعة.

تتم طباعة الأعداد الصحيحة غير الموقعة المدمجة بالصيغة السداسية عشر، مع بادئة 0x، ويمكن إدخالها بنفس الطريقة.

أمثلة

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

نوع الرقم الذي يمثل قيمة غير عقلانية دقيقة، والتي يتم تقريبها تلقائيًا إلى الدقة الصحيحة في العمليات الحسابية مع كميات عددية أخرى.

يجب أن تنفذ الأنواع الفرعية MyIrrational <: AbstractIrrational على الأقل ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), و convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}.

إذا تم استخدام نوع فرعي لتمثيل قيم قد تكون عقلانية أحيانًا (على سبيل المثال، نوع الجذر التربيعي الذي يمثل √n للأعداد الصحيحة n سيعطي نتيجة عقلانية عندما تكون n مربعًا كاملًا)، فيجب عليه أيضًا تنفيذ isinteger, iszero, isone, و == مع قيم Real (نظرًا لأن جميع هذه القيم الافتراضية تكون false لأنواع AbstractIrrational)، بالإضافة إلى تعريف hash ليكون مساوياً لذلك الخاص بـ Rational المقابل.

Float16 <: AbstractFloat <: Real

نوع الرقم العائم 16 بت (معيار IEEE 754). التنسيق الثنائي هو 1 إشارة، 5 أس، 10 بت كسر.

Float32 <: AbstractFloat <: Real

نوع الرقم العائم 32 بت (معيار IEEE 754). التنسيق الثنائي هو 1 إشارة، 8 أس، 23 بت كسر.

يجب إدخال الأس للتدوين العلمي بحرف صغير f، وبالتالي 2f3 === 2.0f0 * 10^3 === Float32(2_000). بالنسبة للأدبيات والمفاهيم المصفوفية، يمكن تحديد نوع العنصر قبل الأقواس المربعة: Float32[1,4,9] == Float32[i^2 for i in 1:3].

انظر أيضًا Inf32، NaN32، Float16، exponent، frexp.

Float64 <: AbstractFloat <: Real

نوع الرقم العائم 64 بت (معيار IEEE 754). التنسيق الثنائي هو 1 إشارة، 11 أس، 52 بت كسر. انظر bitstring، signbit، exponent، frexp، و significand للوصول إلى بتات مختلفة.

هذا هو الافتراضي للأدبيات العائمة، 1.0 isa Float64، ولعديد من العمليات مثل 1/2، 2pi، log(2)، range(0,90,length=4). على عكس الأعداد الصحيحة، هذا الافتراضي لا يتغير مع Sys.WORD_SIZE.

يمكن إدخال الأس للتدوين العلمي كـ e أو E، وبالتالي 2e3 === 2.0E3 === 2.0 * 10^3. يُفضل القيام بذلك بشدة على 10^n لأن الأعداد الصحيحة تتجاوز الحد، وبالتالي 2.0 * 10^19 < 0 ولكن 2e19 > 0.

انظر أيضًا Inf، NaN، floatmax، Float32، Complex.

BigFloat <: AbstractFloat

نوع عدد الفاصلة العائمة بدقة تعسفية.

Bool <: Integer

نوع Boolean، يحتوي على القيم true و false.

Bool هو نوع من الأعداد: false يساوي عددياً 0 و true يساوي عددياً 1. علاوة على ذلك، يعمل false كـ "صفر قوي" مضاعف ضد NaN و Inf:

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

julia> 42.0 + true
43.0

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

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

الفروع عبر if وغيرها من الشروط تقبل فقط Bool. لا توجد قيم "حقيقية" في Julia.

عادةً ما تعيد المقارنات Bool، وقد تعيد المقارنات الموزعة BitArray بدلاً من Array{Bool}.

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

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

انظر أيضًا trues، falses، ifelse.

Int8 <: Signed <: Integer

نوع عدد صحيح موقّع بحجم 8 بت.

يمثل الأعداد n ∈ -128:127. لاحظ أن هذه الأعداد الصحيحة تتجاوز الحدود دون تحذير، وبالتالي typemax(Int8) + Int8(1) < 0.

انظر أيضًا Int، widen، BigInt.

UInt8 <: Unsigned <: Integer

نوع عدد صحيح غير موقع بحجم 8 بت.

يتم طباعته بالصيغة السداسية عشر، وبالتالي 0x07 == 7.

Int16 <: Signed <: Integer

نوع عدد صحيح موقّع 16 بت.

يمثل الأعداد n ∈ -32768:32767. لاحظ أن هذه الأعداد الصحيحة تتجاوز الحدود دون تحذير، وبالتالي typemax(Int16) + Int16(1) < 0.

انظر أيضًا Int، widen، BigInt.

UInt16 <: Unsigned <: Integer

نوع عدد صحيح غير موقع 16 بت.

يتم طباعته بالصيغة السداسية عشر، وبالتالي 0x000f == 15.

Int32 <: Signed <: Integer

نوع عدد صحيح موقّع 32 بت.

لاحظ أن هذه الأعداد الصحيحة تتجاوز الحدود دون تحذير، وبالتالي typemax(Int32) + Int32(1) < 0.

انظر أيضًا Int، widen، BigInt.

UInt32 <: Unsigned <: Integer

نوع عدد صحيح غير موقع 32 بت.

مطبوع بالصيغة السداسية عشر، وبالتالي 0x0000001f == 31.

Int64 <: Signed <: Integer

نوع عدد صحيح موقّع 64 بت.

لاحظ أن هذه الأعداد الصحيحة تتجاوز الحدود دون تحذير، وبالتالي typemax(Int64) + Int64(1) < 0.

انظر أيضًا Int، widen، BigInt.

UInt64 <: Unsigned <: Integer

نوع عدد صحيح غير موقع 64 بت.

يتم طباعته بالصيغة السداسية عشر، وبالتالي 0x000000000000003f == 63.

Int128 <: Signed <: Integer

نوع عدد صحيح موقّع بحجم 128 بت.

لاحظ أن هذه الأعداد الصحيحة تتجاوز الحدود دون تحذير، وبالتالي typemax(Int128) + Int128(1) < 0.

انظر أيضًا Int، widen، BigInt.

UInt128 <: Unsigned <: Integer

نوع عدد صحيح غير موقع بحجم 128 بت.

يتم طباعته بالصيغة السداسية عشر، وبالتالي 0x0000000000000000000000000000007f == 127.

Int

نوع عدد صحيح موقّع بحجم Sys.WORD_SIZE بت، Int <: Signed <: Integer <: Real.

هذا هو النوع الافتراضي لمعظم الأدبيات العددية الصحيحة وهو مرادف لـ Int32 أو Int64، اعتمادًا على Sys.WORD_SIZE. إنه النوع الذي تُرجعه دوال مثل length، والنوع القياسي لفهرسة المصفوفات.

لاحظ أن الأعداد الصحيحة تتجاوز الحدود دون تحذير، وبالتالي typemax(Int) + 1 < 0 و 10^19 < 0. يمكن تجنب التجاوز باستخدام BigInt. ستستخدم الأدبيات العددية الكبيرة جدًا نوعًا أوسع، على سبيل المثال 10_000_000_000_000_000_000 isa Int128.

القسمة الصحيحة هي div مرادف ÷، بينما / التي تعمل على الأعداد الصحيحة تُرجع Float64.

انظر أيضًا Int64، widen، typemax، bitstring.

UInt

نوع عدد صحيح غير موقع بحجم Sys.WORD_SIZE بتنسيق UInt <: Unsigned <: Integer.

مثل Int، قد تشير التسمية المستعارة UInt إما إلى UInt32 أو UInt64، وفقًا لقيمة Sys.WORD_SIZE على جهاز معين.

يتم طباعته وتحليله في النظام السداسي عشر: UInt(15) === 0x000000000000000f.

BigInt <: Signed

نوع عدد صحيح بدقة تعسفية.

Complex{T<:Real} <: Number

نوع الرقم المركب مع جزء حقيقي وجزء تخيلي من النوع T.

ComplexF16 و ComplexF32 و ComplexF64 هي أسماء مستعارة لـ Complex{Float16} و Complex{Float32} و Complex{Float64} على التوالي.

انظر أيضًا: Real, complex, real.

Rational{T<:Integer} <: Real

نوع الرقم النسبي، مع البسط والمقام من نوع T. يتم التحقق من الأعداد النسبية للتجاوز.

Irrational{sym} <: AbstractIrrational

نوع الرقم الذي يمثل قيمة غير عقلانية دقيقة يُشار إليها بالرمز sym، مثل π، ℯ و γ.

انظر أيضًا AbstractIrrational.

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

إرجاع مصفوفة بنوع العنصر T (افتراضي Int) من أرقام n في القاعدة المعطاة، مع إمكانية إضافة أصفار لتعبئة الحجم المحدد. الأرقام الأكثر أهمية تكون في مؤشرات أعلى، بحيث n == sum(digits[k]*base^(k-1) for k in eachindex(digits)).

انظر أيضًا ndigits، digits!، وللقاعدة 2 أيضًا bitstring، count_ones.

أمثلة

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

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

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

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

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

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

يملأ مصفوفة بالأرقام المكونة لـ n في القاعدة المعطاة. الأرقام الأكثر أهمية تكون في مؤشرات أعلى. إذا كانت طول المصفوفة غير كافٍ، يتم ملء الأرقام الأقل أهمية حتى طول المصفوفة. إذا كانت طول المصفوفة مفرطة، يتم ملء الجزء الزائد بالأصفار.

أمثلة

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)

سلسلة تعطي التمثيل الثنائي الحرفي لنوع بدائي.

انظر أيضًا count_ones، count_zeros، digits.

أمثلة

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

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

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

نظير لـ tryparse(SimpleColor, rgb::String) (انظر هناك)، الذي يثير خطأ بدلاً من إرجاع nothing.

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

يحلل سلسلة ثلاثية المنصة مرة أخرى إلى كائن Platform.

parse(type, str; base)

تحليل سلسلة كنقطة رقمية. بالنسبة لأنواع Integer، يمكن تحديد قاعدة (الافتراضي هو 10). بالنسبة لأنواع النقاط العائمة، يتم تحليل السلسلة كرقم عشري عائم. يتم تحليل أنواع Complex من سلاسل عشرية بالشكل "R±Iim" كـ Complex(R,I) من النوع المطلوب؛ يمكن أيضًا استخدام "i" أو "j" بدلاً من "im"، و "R" أو "Iim" مسموح بهما أيضًا. إذا كانت السلسلة لا تحتوي على رقم صالح، يتم رفع خطأ.

أمثلة

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 كـ SimpleColor. إذا كان rgb يبدأ بـ # وله طول 7، يتم تحويله إلى SimpleColor مدعوم بـ RGBTuple. إذا كان rgb يبدأ بـ a-z، يتم تفسير rgb كاسم لون ويتم تحويله إلى SimpleColor مدعوم بـ Symbol.

بخلاف ذلك، يتم إرجاع nothing.

أمثلة

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

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

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

مثل parse، ولكن يعيد إما قيمة من النوع المطلوب، أو nothing إذا كانت السلسلة لا تحتوي على رقم صالح.

big(x)

تحويل رقم إلى تمثيل بدقة قصوى (عادةً BigInt أو BigFloat). راجع BigFloat لمعلومات حول بعض المشاكل المتعلقة بأرقام النقطة العائمة.

signed(T::Integer)

تحويل نوع بت صحيح إلى النوع الموقّع بنفس الحجم.

أمثلة

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

signed(x)

تحويل رقم إلى عدد صحيح موقّع. إذا كانت الحجة غير موقعة، يتم إعادة تفسيرها كموقعة دون التحقق من تجاوز السعة.

انظر أيضًا: unsigned، sign، signbit.

unsigned(T::Integer)

قم بتحويل نوع بت صحيح إلى النوع غير الموقع بنفس الحجم.

أمثلة

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

float(x)

تحويل رقم أو مصفوفة إلى نوع بيانات نقطة عائمة.

انظر أيضًا: complex, oftype, convert.

أمثلة

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

julia> float(typemax(Int32))
2.147483647e9

significand(x)

استخراج المقياس (المعروف أيضًا باسم المانتيسا) لعدد عشري. إذا كان x عددًا غير صفري ومحدودًا، فإن النتيجة ستكون عددًا من نفس النوع والإشارة مثل x، وقيمته المطلقة تقع في الفترة $[1,2)$. خلاف ذلك، يتم إرجاع x.

انظر أيضًا frexp، exponent.

أمثلة

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

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

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

exponent(x::Real) -> Int

يُرجع أكبر عدد صحيح y بحيث 2^y ≤ abs(x).

يرمي DomainError عندما يكون x صفرًا أو لانهائيًا أو NaN. بالنسبة لأي عدد عائم غير فرعي آخر x، يتوافق هذا مع بتات الأس للعدد x.

انظر أيضًا signbit، significand، frexp، issubnormal، log2، ldexp.

أمثلة

julia> exponent(8)
3

julia> exponent(6.5)
2

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

julia> exponent(3.142e-4)
-12

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

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

complex(r, [i])

تحويل الأعداد الحقيقية أو المصفوفات إلى أعداد مركبة. i افتراضيًا يساوي صفر.

أمثلة

julia> complex(7)
7 + 0im

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

bswap(n)

عكس ترتيب البايت لـ n.

(انظر أيضًا ntoh و hton للتحويل بين ترتيب البايت الأصلي الحالي وترتيب البايت الكبير.)

أمثلة

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

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

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

hex2bytes(itr)

بالنظر إلى متكرر itr من رموز ASCII لتسلسل من الأرقام السداسية عشر، فإنه يُرجع Vector{UInt8} من البايتات التي تتوافق مع التمثيل الثنائي: كل زوج متتالي من الأرقام السداسية عشر في itr يعطي قيمة بايت واحد في المتجه المُرجع.

يجب أن يكون طول itr زوجيًا، ويكون طول المصفوفة المُرجعة نصف طول itr. انظر أيضًا hex2bytes! للإصدار في المكان، و bytes2hex للعكس.

أمثلة

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)

تحويل iterable itr من البايتات التي تمثل سلسلة سداسية عشرية إلى تمثيلها الثنائي، مشابه لـ hex2bytes باستثناء أن الإخراج يُكتب في المكان إلى dest. يجب أن يكون طول dest نصف طول itr.

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

قم بتحويل مكرر itr من البايتات إلى تمثيل سلسلة سداسية عشرية، إما عن طريق إرجاع String عبر bytes2hex(itr) أو كتابة السلسلة إلى تدفق io عبر bytes2hex(io, itr). جميع الأحرف السداسية عشرية هي أحرف صغيرة.

أمثلة

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: قيمة بحيث one(x)*x == x*one(x) == x. بدلاً من ذلك، يمكن أن تأخذ one(T) نوع T، وفي هذه الحالة ترجع one هوية مضاعفية لأي x من نوع T.

إذا كان ذلك ممكنًا، ترجع one(x) قيمة من نفس نوع x، و one(T) ترجع قيمة من نوع T. ومع ذلك، قد لا يكون هذا هو الحال بالنسبة للأنواع التي تمثل كميات ذات أبعاد (مثل الوقت بالأيام)، حيث يجب أن تكون الهوية المضاعفية بلا أبعاد. في هذه الحالة، يجب أن ترجع one(x) قيمة هوية بنفس الدقة (والشكل، بالنسبة للمصفوفات) مثل x.

إذا كنت تريد كمية من نفس نوع x، أو من نوع T، حتى لو كان x ذو أبعاد، استخدم oneunit بدلاً من ذلك.

انظر أيضًا إلى دالة identity، و I في LinearAlgebra لمصفوفة الهوية.

أمثلة

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))، حيث T هو إما نوع الوسيطة أو (إذا تم تمرير نوع) الوسيطة. هذا يختلف عن one للكميات ذات الأبعاد: one بلا أبعاد (هو هوية ضرب) بينما oneunit له أبعاد (من نفس نوع x، أو من نوع T).

أمثلة

julia> oneunit(3.7)
1.0

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

zero(x)
zero(::Type)

احصل على عنصر الهوية الجمعي لنوع x (x يمكن أن يحدد أيضًا النوع نفسه).

انظر أيضًا iszero, one, oneunit, oftype.

أمثلة

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

الوحدة التخيلية.

انظر أيضًا: imag, angle, complex.

أمثلة

julia> im * im
-1 + 0im

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

π
pi

الثابت باي.

يمكن كتابة Unicode π عن طريق كتابة \pi ثم الضغط على زر التبويب في REPL الخاص بـ Julia، وفي العديد من المحررات.

انظر أيضًا: sinpi, sincospi, deg2rad.

أمثلة

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

الثابت ℯ.

يمكن كتابة Unicode ℯ عن طريق كتابة \euler والضغط على زر التبويب في REPL الخاص بـ Julia، وفي العديد من المحررات.

انظر أيضًا: exp, cis, cispi.

أمثلة

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

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

ثابت كاتالان.

# أمثلة

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

ثابت أويلر.

أمثلة

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

φ
نسبة ذهبية

نسبة ذهبية.

أمثلة

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

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

إنف، إنف64

لانهائية إيجابية من نوع Float64.

انظر أيضًا: isfinite، typemax، NaN، Inf32.

أمثلة

julia> π/0
إنف

julia> +1.0 / -0.0
-إنف

julia> ℯ^-إنف
0.0

إنف، إنف64

لانهائية إيجابية من نوع Float64.

انظر أيضًا: isfinite، typemax، NaN، Inf32.

أمثلة

julia> π/0
إنف

julia> +1.0 / -0.0
-إنف

julia> ℯ^-إنف
0.0

Inf32

لانهائية موجبة من نوع Float32.

Inf16

لانهائية إيجابية من نوع Float16.

NaN, NaN64

قيمة غير رقمية من النوع Float64.

انظر أيضًا: isnan، missing، NaN32، Inf.

أمثلة

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

!!! ملاحظة استخدم دائمًا isnan أو isequal للتحقق من NaN. استخدام x === NaN قد يعطي نتائج غير متوقعة:

```julia-repl
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.

انظر أيضًا: isnan، missing، NaN32، Inf.

أمثلة

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

!!! ملاحظة استخدم دائمًا isnan أو isequal للتحقق من NaN. استخدام x === NaN قد يعطي نتائج غير متوقعة:

```julia-repl
julia> reinterpret(UInt32, NaN32)
0x7fc00000

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

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

NaN32

قيمة غير رقمية من نوع Float32.

انظر أيضًا: NaN.

NaN16

قيمة غير رقمية من نوع Float16.

انظر أيضًا: NaN.

issubnormal(f) -> Bool

اختبر ما إذا كان رقم النقطة العائمة غير طبيعي.

رقم IEEE للنقطة العائمة هو غير طبيعي عندما تكون بتات الأس صفرًا ويمتنع المعنوي عن الصفر.

أمثلة

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

اختبر ما إذا كان الرقم محدودًا.

أمثلة

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

اختبر ما إذا كان الرقم لانهائيًا.

انظر أيضًا: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

اختبر ما إذا كانت قيمة الرقم هي NaN، وهي قيمة غير محددة ليست لانهائية ولا رقمًا نهائيًا ("ليس رقمًا").

انظر أيضًا: iszero, isone, isinf, ismissing.

iszero(x)

ارجع true إذا كان x == zero(x)؛ إذا كان x مصفوفة، فإن هذا يتحقق مما إذا كانت جميع عناصر x تساوي صفر.

انظر أيضًا: isone, isinteger, isfinite, isnan.

أمثلة

julia> iszero(0.0)
true

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

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

isone(x)

ارجع true إذا كان x == one(x)؛ إذا كان x مصفوفة، فإن هذا يتحقق مما إذا كانت x مصفوفة هوية.

أمثلة

julia> isone(1.0)
true

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

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

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

نتيجة n تطبيقات متكررة لـ nextfloat على x إذا كان n >= 0، أو -n تطبيقات لـ prevfloat إذا كان n < 0.

nextfloat(x::AbstractFloat)

إرجاع أصغر عدد عائم y من نفس نوع x بحيث x < y. إذا لم يوجد مثل هذا y (على سبيل المثال إذا كان x هو Inf أو NaN)، فقم بإرجاع x.

انظر أيضًا: prevfloat, eps, issubnormal.

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

نتيجة تطبيق prevfloat على x بشكل تكراري n مرة إذا كان n >= 0، أو تطبيق nextfloat بشكل -n مرة إذا كان n < 0.

prevfloat(x::AbstractFloat)

إرجاع أكبر عدد عائم y من نفس نوع x بحيث y < x. إذا لم يوجد مثل هذا y (على سبيل المثال إذا كان x هو -Inf أو NaN)، فقم بإرجاع x.

isinteger(x) -> Bool

اختبر ما إذا كان x يساوي عددًا صحيحًا.

أمثلة

julia> isinteger(4.0)
true

isreal(x) -> Bool

اختبر ما إذا كان x أو جميع عناصره متساوية عددياً مع بعض الأعداد الحقيقية بما في ذلك اللانهاية وNaNs. تكون isreal(x) صحيحة إذا كانت isequal(x, real(x)) صحيحة.

أمثلة

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

قم بإنشاء Float32 من x. إذا لم يكن x قابلاً للتمثيل بدقة، فإن mode يحدد كيفية تقريب x.

أمثلة

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

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

انظر RoundingMode لوضعيات التقريب المتاحة. ```

Float64(x [, mode::RoundingMode])

إنشاء Float64 من x. إذا لم يكن x قابلاً للتمثيل بدقة، فإن mode يحدد كيفية تقريب x.

أمثلة

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

انظر RoundingMode لوضعيات التقريب المتاحة.

rounding(T)

احصل على وضع التقريب الحالي لنقطة العائمة لنوع T، الذي يتحكم في تقريب الدوال الحسابية الأساسية (+، -، *، / و sqrt) وتحويل النوع.

انظر RoundingMode للوضعيات المتاحة.

setrounding(T, mode)

قم بتعيين وضع التقريب لنوع النقطة العائمة T، مما يتحكم في تقريب الدوال الحسابية الأساسية (+، -، *، / و sqrt) وتحويل النوع. قد تعطي الدوال العددية الأخرى قيمًا غير صحيحة أو غير صالحة عند استخدام أوضاع التقريب بخلاف الوضع الافتراضي RoundNearest.

لاحظ أن هذا مدعوم حاليًا فقط لـ T == BigFloat.

!!! تحذير هذه الدالة ليست آمنة للاستخدام في خيوط متعددة. ستؤثر على الشيفرة التي تعمل على جميع الخيوط، لكن سلوكها غير محدد إذا تم استدعاؤها بالتزامن مع حسابات تستخدم الإعداد.

setrounding(f::Function, T, mode)

قم بتغيير وضع التقريب لنوع النقطة العائمة T خلال مدة f. إنه معادل منطقيًا لـ:

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

انظر RoundingMode لوضعيات التقريب المتاحة.

get_zero_subnormals() -> Bool

ارجع false إذا كانت العمليات على القيم العائمة تحت الطبيعية ("denormals") تتبع قواعد حساب IEEE، و true إذا كان من الممكن تحويلها إلى أصفار.

!!! تحذير هذه الدالة تؤثر فقط على الخيط الحالي.

set_zero_subnormals(yes::Bool) -> Bool

إذا كان yes هو false، فإن العمليات العائمة اللاحقة تتبع قواعد حساب IEEE على القيم تحت الطبيعية ("denormals"). خلاف ذلك، يُسمح (ولكن ليس مطلوبًا) للعمليات العائمة بتحويل المدخلات أو المخرجات تحت الطبيعية إلى صفر. تُرجع true ما لم يكن yes==true ولكن الأجهزة لا تدعم تصفير الأعداد تحت الطبيعية.

يمكن أن تُسرع set_zero_subnormals(true) بعض الحسابات على بعض الأجهزة. ومع ذلك، يمكن أن تكسر الهويات مثل (x-y==0) == (x==y).

!!! تحذير هذه الوظيفة تؤثر فقط على الخيط الحالي.

count_ones(x::Integer) -> Integer

عدد الواحدات في التمثيل الثنائي لـ x.

أمثلة

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

عدد الأصفار في التمثيل الثنائي لـ x.

أمثلة

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

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

عدد الأصفار التي تسبق التمثيل الثنائي لـ x.

أمثلة

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

عدد الواحدات التي تسبق التمثيل الثنائي لـ x.

أمثلة

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

trailing_zeros(x::Integer) -> Integer

عدد الأصفار التي تلي التمثيل الثنائي لـ x.

أمثلة

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

عدد الواحدات التي تتبع التمثيل الثنائي لـ x.

أمثلة

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

ارجع true إذا كان x عددًا صحيحًا فرديًا (أي عدد صحيح غير قابل للقسمة على 2)، وfalse خلاف ذلك.

أمثلة

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

ارجع true إذا كان x عددًا صحيحًا زوجيًا (أي عدد صحيح قابل للقسمة على 2)، وfalse خلاف ذلك.

أمثلة

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

قم بتحليل str كـ Int128. ارمِ ArgumentError إذا كانت السلسلة ليست عددًا صحيحًا صالحًا.

أمثلة

julia> int128"123456789123"
123456789123

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

@uint128_str str

قم بتحليل str كـ UInt128. ارمِ ArgumentError إذا كانت السلسلة ليست عددًا صحيحًا صالحًا.

أمثلة

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

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

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

قم بإنشاء عدد عشري بدقة تعسفية من x، مع الدقة precision. تحدد حجة rounding الاتجاه الذي يجب أن يتم فيه تقريب النتيجة إذا لم يكن من الممكن إجراء التحويل بدقة. إذا لم يتم توفيرها، يتم تعيينها بواسطة القيم العالمية الحالية.

BigFloat(x::Real) هو نفسه convert(BigFloat,x)، باستثناء إذا كان x نفسه بالفعل BigFloat، في هذه الحالة سيعيد قيمة مع الدقة المحددة على الدقة العالمية الحالية؛ ستعيد convert دائمًا x.

BigFloat(x::AbstractString) هو مطابق لـ parse. يتم توفير ذلك للراحة حيث يتم تحويل الأعداد العشرية إلى Float64 عند تحليلها، لذا قد لا يؤدي BigFloat(2.1) إلى ما تتوقعه.

انظر أيضًا:

• @big_str
• rounding و setrounding
• precision و setprecision

أمثلة

julia> BigFloat(2.1) # 2.1 هنا هو Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # أقرب BigFloat إلى 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

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

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

احصل على دقة رقم النقطة العائمة، كما هو محدد بواسطة عدد البتات الفعالة في المعامل، أو دقة نوع النقطة العائمة T (افتراضيه الحالية، إذا كان T نوع دقة متغيرة مثل BigFloat).

إذا تم تحديد base، فإنه يعيد الحد الأقصى لعدد الأرقام المعنوية المقابلة في ذلك الأساس.

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

قم بتعيين الدقة (بالبتات، بشكل افتراضي) التي ستستخدم في حسابات T. إذا تم تحديد base، فإن الدقة هي الحد الأدنى المطلوب للحصول على ما لا يقل عن precision أرقام في base المعطاة.

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

تغيير دقة الحساب لـ T (بالـ base المعطى) لمدة تنفيذ f. هذا يعادل منطقياً:

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

غالبًا ما يُستخدم كـ setprecision(T, precision) do ... end

ملاحظة: nextfloat(), prevfloat() لا تستخدم الدقة المذكورة بواسطة setprecision.

BigInt(x)

إنشاء عدد صحيح بدقة تعسفية. قد يكون x من نوع Int (أو أي شيء يمكن تحويله إلى Int). يتم تعريف العمليات الرياضية المعتادة لهذا النوع، وتُرفع النتائج إلى BigInt.

يمكن إنشاء الحالات من السلاسل النصية عبر parse، أو باستخدام حرف السلسلة big.

أمثلة

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

قم بتحليل سلسلة إلى BigInt أو BigFloat، وارمي ArgumentError إذا كانت السلسلة ليست رقمًا صالحًا. بالنسبة للأعداد الصحيحة، يُسمح باستخدام _ في السلسلة كفاصل.

أمثلة

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
[...]

!!! تحذير استخدام @big_str لبناء قيم BigFloat قد لا يؤدي إلى السلوك الذي قد يُتوقع ببساطة: كميكرو، فإن @big_str يطيع دقة العالمية (setprecision) وإعدادات وضع التقريب (setrounding) كما هي في وقت التحميل. وبالتالي، فإن دالة مثل () -> precision(big"0.3") تعيد ثابتًا تعتمد قيمته على قيمة الدقة في النقطة التي تم فيها تعريف الدالة، ليس على الدقة في الوقت الذي يتم فيه استدعاء الدالة.