Mathematics

-(x)

عامل السالب الأحادي.

انظر أيضًا: abs, flipsign.

أمثلة

julia> -1
-1

julia> -(2)
-2

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

julia> -(true)  # يترقى إلى Int
-1

julia> -(0x003)
0xfffd

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

إن إضافة Date مع Time ينتج DateTime. يتم استخدام أجزاء الساعة والدقيقة والثانية والمللي ثانية من Time مع السنة والشهر واليوم من Date لإنشاء DateTime الجديد. ستؤدي الميكروثانية أو النانوثانية غير الصفرية في نوع Time إلى حدوث InexactError.

+(x, y...)

عامل الجمع.

العبارة x+y+z+... تستدعي هذه الدالة مع جميع المعطيات، أي +(x, y, z, ...)، والتي تستدعي بشكل افتراضي بعد ذلك (x+y) + z + ... بدءًا من اليسار.

لاحظ أن حدوث تجاوز ممكن لمعظم أنواع الأعداد الصحيحة، بما في ذلك Int الافتراضي، عند إضافة أعداد كبيرة.

أمثلة

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

-(س, ص)

عامل الطرح.

أمثلة

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

عامل الضرب.

العبارة x*y*z*... تستدعي هذه الدالة مع جميع المعطيات، أي *(x, y, z, ...)، والتي تستدعي افتراضيًا بعد ذلك (x*y) * z * ... بدءًا من اليسار.

الترتيب مثل 2pi يستدعي أيضًا *(2, pi). لاحظ أن هذه العملية لها أولوية أعلى من الرمز * الحرفي. لاحظ أيضًا أن الترتيب "0x..." (الصفر الصحيح مضروبًا في متغير يبدأ بـ x) محظور لأنه يتعارض مع الثوابت الصحيحة غير الموقعة: 0x01 isa UInt8.

لاحظ أن حدوث تجاوز ممكن لمعظم أنواع الأعداد الصحيحة، بما في ذلك Int الافتراضي، عند ضرب أعداد كبيرة.

أمثلة

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # مصفوفة * متجه
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # الترتيب له أولوية أعلى
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # متجه مرفوع * متجه
5

/(x, y)

عامل القسمة اليمنى: ضرب x في معكوس y من اليمين.

يعطي نتائج عائمة للنقاط للأعداد الصحيحة. انظر ÷ للقسمة الصحيحة، أو // لنتائج Rational.

أمثلة

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

تقسيم المصفوفات من اليمين: A / B يعادل (B' \ A')' حيث \ هو عامل القسمة من اليسار. بالنسبة للمصفوفات المربعة، النتيجة X هي بحيث A == X*B.

انظر أيضًا: rdiv!.

أمثلة

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)

عامل القسمة اليسارية: ضرب y في معكوس x من اليسار. يعطي نتائج عائمة للنقاط للوسائط الصحيحة.

أمثلة

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)

عامل الأس.

إذا كانت x و y أعدادًا صحيحة، فقد يحدث تجاوز. لإدخال الأعداد بالتدوين العلمي، استخدم أدبيات Float64 مثل 1.2e3 بدلاً من 1.2 * 10^3.

إذا كانت y أدبًا صحيحًا (مثل 2 في x^2 أو -3 في x^-3)، يتم تحويل كود جوليا x^y بواسطة المترجم إلى Base.literal_pow(^, x, Val(y))، لتمكين التخصص في وقت الترجمة على قيمة الأس. (كخيار افتراضي لدينا Base.literal_pow(^, x, Val(y)) = ^(x,y)، حيث عادةً ما يكون ^ == Base.^ ما لم يتم تعريف ^ في مساحة الأسماء المستدعاة.) إذا كانت y أدبًا صحيحًا سالبًا، فإن Base.literal_pow تحول العملية إلى inv(x)^-y بشكل افتراضي، حيث -y موجب.

انظر أيضًا exp2، <<.

أمثلة

julia> 3^5
243

julia> 3^-1  # يستخدم Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # تجاوز صحيح
false

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

fma(x, y, z)

يحسب x*y+z دون تقريب النتيجة الوسيطة x*y. في بعض الأنظمة، يكون هذا أكثر تكلفة بشكل ملحوظ من x*y+z. يتم استخدام fma لتحسين الدقة في بعض الخوارزميات. انظر muladd.

muladd(x, y, z)

الضرب والإضافة المدمجة: تحسب x*y+z، ولكن تسمح بدمج الإضافة والضرب مع بعضهما البعض أو مع العمليات المحيطة من أجل الأداء. على سبيل المثال، قد يتم تنفيذ ذلك كـ fma إذا كانت الأجهزة تدعمه بكفاءة. يمكن أن تكون النتيجة مختلفة على آلات مختلفة ويمكن أن تكون أيضًا مختلفة على نفس الآلة بسبب انتشار الثوابت أو تحسينات أخرى. انظر fma.

أمثلة

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

جمع الضرب والإضافة، A*y .+ z، لعملية ضرب المصفوفات أو ضرب المصفوفة بالمتجه. النتيجة دائمًا بنفس حجم A*y، لكن z قد تكون أصغر، أو عددًا حقيقيًا.

أمثلة

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، بحيث x*inv(x) أو inv(x)*x ينتج one(x) (الهوية الضربية) حتى أخطاء التقريب.

إذا كان x عددًا، فإن هذا في الأساس هو نفسه one(x)/x، ولكن لبعض الأنواع قد يكون inv(x) أكثر كفاءة قليلاً.

أمثلة

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)

ناتج القسمة من القسمة الإقليدية (الصحيحة). يعادل عمومًا عملية رياضية x/y بدون جزء كسري.

انظر أيضًا: cld, fld, rem, divrem.

أمثلة

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)

ناتج قسمة من القسمة الإقليدية (الصحيحة). يحسب x / y، مقربًا إلى عدد صحيح وفقًا لوضع التقريب r. بعبارة أخرى، الكمية

round(x / y, r)

دون أي تقريب وسيط.

انظر أيضًا fld و cld، اللذان هما حالات خاصة من هذه الدالة.

أمثلة:

julia> div(4, 3, RoundToZero) # يتطابق مع div(4, 3)
1
julia> div(4, 3, RoundDown) # يتطابق مع fld(4, 3)
1
julia> div(4, 3, RoundUp) # يتطابق مع cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

fld(x, y)

أكبر عدد صحيح أقل من أو يساوي x / y. يعادل div(x, y, RoundDown).

انظر أيضًا div، cld، fld1.

أمثلة

julia> fld(7.3, 5.5)
1.0

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

لأن fld(x, y) تنفذ تقريبًا صحيحًا قائمًا على القيمة الحقيقية للأعداد العشرية، يمكن أن تنشأ حالات غير بديهية. على سبيل المثال:

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

ما يحدث هنا هو أن القيمة الحقيقية للعدد العشري المكتوب كـ 0.1 أكبر قليلاً من القيمة العددية 1/10 بينما يمثل 6.0 الرقم 6 بدقة. لذلك، فإن القيمة الحقيقية لـ 6.0 / 0.1 أقل قليلاً من 60. عند القيام بالقسمة، يتم تقريبها بدقة إلى 60.0، لكن fld(6.0, 0.1) تأخذ دائمًا الأرضية للقيمة الحقيقية، لذا فإن النتيجة هي 59.0.

cld(x, y)

أصغر عدد صحيح أكبر من أو يساوي x / y. يعادل div(x, y, RoundUp).

انظر أيضًا div، fld.

أمثلة

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)

ابحث عن y في النطاق r بحيث $x ≡ y (mod n)$، حيث n = length(r)، أي y = mod(x - first(r), n) + first(r).

انظر أيضًا mod1.

أمثلة

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 بالنسبة إلى y، أو بشكل مكافئ، باقي x بعد القسمة المفلترة بواسطة y، أي x - y*fld(x,y) إذا تم حسابه بدون تقريب وسيط.

ستكون النتيجة بنفس إشارة y، وذات مقدار أقل من abs(y) (مع بعض الاستثناءات، انظر الملاحظة أدناه).

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

انظر أيضًا: 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

ابحث عن y::T بحيث x ≡ y (mod n)، حيث n هو عدد الأعداد الصحيحة القابلة للتمثيل في T، و y هو عدد صحيح في [typemin(T),typemax(T)]. إذا كان بإمكان T تمثيل أي عدد صحيح (على سبيل المثال، T == BigInt)، فإن هذه العملية تتوافق مع تحويل إلى T.

أمثلة

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

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

باقي القسمة الإقليدية، يعيد قيمة بنفس إشارة x، وأصغر في المقدار من y. هذه القيمة دائمًا دقيقة.

انظر أيضًا: div, mod, mod1, divrem.

أمثلة

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 بعد القسمة الصحيحة على y، مع تقريب الناتج وفقًا لوضع التقريب r. بعبارة أخرى، الكمية

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

دون أي تقريب وسيط.

• إذا كان r == RoundNearest، فإن النتيجة دقيقة، وفي الفترة $[-|y| / 2, |y| / 2]$. انظر أيضًا RoundNearest.
• إذا كان r == RoundToZero (افتراضي)، فإن النتيجة دقيقة، وفي الفترة $[0, |y|)$ إذا كانت x موجبة، أو $(-|y|, 0]$ بخلاف ذلك. انظر أيضًا RoundToZero.
• إذا كان r == RoundDown، فإن النتيجة في الفترة $[0, y)$ إذا كانت y موجبة، أو $(y, 0]$ بخلاف ذلك. قد لا تكون النتيجة دقيقة إذا كانت x و y لهما إشارات مختلفة، و abs(x) < abs(y). انظر أيضًا RoundDown.
• إذا كان r == RoundUp، فإن النتيجة في الفترة $(-y, 0]$ إذا كانت y موجبة، أو $[0, -y)$ بخلاف ذلك. قد لا تكون النتيجة دقيقة إذا كانت x و y لهما نفس الإشارة، و abs(x) < abs(y). انظر أيضًا RoundUp.
• إذا كان r == RoundFromZero، فإن النتيجة في الفترة $(-y, 0]$ إذا كانت y موجبة، أو $[0, -y)$ بخلاف ذلك. قد لا تكون النتيجة دقيقة إذا كانت x و y لهما نفس الإشارة، و abs(x) < abs(y). انظر أيضًا RoundFromZero.

أمثلة:

julia> x = 9; y = 4;

julia> x % y  # نفس الشيء مثل rem(x, y)
1

julia> x ÷ y  # نفس الشيء مثل div(x, y)
2

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

rem2pi(x, r::RoundingMode)

احسب باقي x بعد القسمة الصحيحة على 2π، مع تقريب الناتج وفقًا لوضع التقريب r. بعبارة أخرى، الكمية

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

دون أي تقريب وسيط. يستخدم هذا داخليًا تقريبًا عالي الدقة لـ 2π، وبالتالي سيعطي نتيجة أكثر دقة من rem(x,2π,r)

• إذا كان r == RoundNearest، فإن النتيجة تكون في الفترة $[-π, π]$. ستكون هذه عمومًا النتيجة الأكثر دقة. انظر أيضًا RoundNearest.
• إذا كان r == RoundToZero، فإن النتيجة تكون في الفترة $[0, 2π]$ إذا كانت x موجبة، أو $[-2π, 0]$ بخلاف ذلك. انظر أيضًا RoundToZero.
• إذا كان r == RoundDown، فإن النتيجة تكون في الفترة $[0, 2π]$. انظر أيضًا RoundDown.
• إذا كان r == RoundUp، فإن النتيجة تكون في الفترة $[-2π, 0]$. انظر أيضًا RoundUp.

أمثلة

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

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

mod2pi(x)

المودول بعد القسمة على 2π، مع إرجاع القيمة في النطاق $[0,2π)$.

تقوم هذه الدالة بحساب تمثيل النقطة العائمة للمودول بعد القسمة على 2π بدقة عددية، وبالتالي فهي ليست بالضبط نفس mod(x,2π)، الذي سيحسب المودول لـ x بالنسبة للقسمة على الرقم العائم 2π.

!!! ملاحظة اعتمادًا على تنسيق قيمة الإدخال، قد تكون أقرب قيمة قابلة للتمثيل لـ 2π أقل من 2π. على سبيل المثال، التعبير mod2pi(2π) لن يُرجع 0، لأن القيمة الوسيطة لـ 2*π هي Float64 و 2*Float64(π) < 2*big(π). انظر rem2pi لمزيد من التحكم الدقيق في هذا السلوك.

أمثلة

julia> mod2pi(9*pi/4)
0.7853981633974481

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

حاصل القسمة والباقي من القسمة الإقليدية. يعادل (div(x, y, r), rem(x, y, r)). وبالمثل، مع القيمة الافتراضية لـ r، فإن هذه المكالمة تعادل (x ÷ y, x % y).

انظر أيضًا: fldmod, cld.

أمثلة

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

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

fldmod(x, y)

ناتج القسمة المفلتر والمودول بعد القسمة. غلاف مريح لـ divrem(x, y, RoundDown). يعادل (fld(x, y), mod(x, y)).

انظر أيضًا: fld, cld, fldmod1.

fld1(x, y)

قسمة الأرض، تعيد قيمة متوافقة مع mod1(x,y)

انظر أيضًا mod1، fldmod1.

أمثلة

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)

الناتج بعد قسمة الطابق، مع إرجاع قيمة r بحيث mod(r, y) == mod(x, y) في النطاق $(0, y]$ لـ y الموجبة وفي النطاق $[y,0)$ لـ y السالبة.

مع المعاملات الصحيحة و y الموجبة، هذا يساوي mod(x, 1:y)، وبالتالي فهو طبيعي للفهرسة التي تبدأ من 1. بالمقارنة، mod(x, y) == mod(x, 0:y-1) هو طبيعي للحسابات مع الإزاحات أو الخطوات.

انظر أيضًا mod، fld1، fldmod1.

أمثلة

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

See also fld1, mod1.

//(num, den)

قسّم عددين صحيحين أو أعداد كسرية، مع إعطاء نتيجة Rational. بشكل عام، يمكن استخدام // للقسمة الكسرية الدقيقة لأنواع عددية أخرى تحتوي على مكونات صحيحة أو كسرية، مثل الأعداد المركبة ذات المكونات الصحيحة.

لاحظ أن الوسائط من نوع النقطة العائمة (AbstractFloat) غير مسموح بها بواسطة // (حتى لو كانت القيم كسرية). يجب أن تكون الوسائط من الأنواع الفرعية لـ Integer، Rational، أو مركبات منها.

أمثلة

julia> 3 // 5
3//5

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

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

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

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

قم بتقريب الرقم العائم x كعدد Rational مع مكونات من نوع العدد الصحيح المعطى. ستختلف النتيجة عن x بأكثر من tol.

أمثلة

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt

المقام(x)

المقام من التمثيل الكسرى لـ x.

أمثلة

julia> numerator(2//3)
2

julia> numerator(4)
4

مقام(x)

مقام التمثيل الكسري لـ x.

أمثلة

julia> مقام(2//3)
3

julia> مقام(4)
1

<<(x, n)

عامل إزاحة البت لليسار، x << n. بالنسبة لـ n >= 0، تكون النتيجة هي x مزاحة لليسار بمقدار n بت، مع ملء بـ 0s. هذا يعادل x * 2^n. بالنسبة لـ n < 0، هذا يعادل x >> -n.

أمثلة

julia> Int8(3) << 2
12

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

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

انظر أيضًا >>، >>>، exp2، ldexp.

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

عامل إزاحة البت لليسار، B << n. بالنسبة لـ n >= 0، تكون النتيجة هي B مع العناصر المزالة n موضعًا للخلف، مع ملء القيم بـ false. إذا كان n < 0، يتم إزاحة العناصر للأمام. يعادل B >> -n.

أمثلة

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)

عامل إزاحة البت إلى اليمين، x >> n. بالنسبة لـ n >= 0، تكون النتيجة هي x مزاحة إلى اليمين بمقدار n بت، مع ملء بـ 0s إذا كان x >= 0، و 1s إذا كان x < 0، مع الحفاظ على إشارة x. هذا يعادل fld(x, 2^n). بالنسبة لـ n < 0، هذا يعادل x << -n.

أمثلة

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"

انظر أيضًا >>>، <<.

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

عامل الإزاحة إلى اليمين، B >> n. بالنسبة لـ n >= 0، تكون النتيجة B مع العناصر المزيحة n موضعًا للأمام، مع ملء القيم بـ false. إذا كان n < 0، يتم إزاحة العناصر للخلف. يعادل B << -n.

أمثلة

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)

عامل إزاحة البت غير الموقعة إلى اليمين، x >>> n. بالنسبة لـ n >= 0، تكون النتيجة هي x مزاحة إلى اليمين بمقدار n بت، مع ملء بـ 0s. بالنسبة لـ n < 0، فإن هذا يعادل x << -n.

بالنسبة لأنواع الأعداد الصحيحة Unsigned، فإن هذا يعادل >>. بالنسبة لأنواع الأعداد الصحيحة Signed، فإن هذا يعادل signed(unsigned(x) >> n).

أمثلة

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

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

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

تُعتبر BigInts كما لو كانت بحجم غير محدود، لذا لا يلزم الملء وهذا يعادل >>.

انظر أيضًا >>، <<.

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

عامل إزاحة البت غير الموقعة إلى اليمين، B >>> n. يعادل B >> n. انظر >> لمزيد من التفاصيل والأمثلة.

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

bitrotate(x, k) ينفذ التدوير البتّي. يُرجع قيمة x مع تدوير بتاته إلى اليسار k مرات. القيمة السلبية لـ k ستقوم بالتدوير إلى اليمين بدلاً من ذلك.

انظر أيضًا: <<, 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

اقتبس تعبير expr، معيدًا شجرة التركيب المجردة (AST) لـ expr. قد تكون شجرة التركيب من النوع Expr أو Symbol أو قيمة حرفية. التعبير :identifier يقيم إلى Symbol.

انظر أيضًا: Expr، Symbol، Meta.parse

أمثلة

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)

قم بإنشاء مصفوفة متخصصة تحتوي على عناصر متباعدة بالتساوي وتخزين محسن (وهو AbstractRange) من المعطيات. رياضيًا، يتم تحديد النطاق بشكل فريد بواسطة أي ثلاثة من start و step و stop و length. الاستدعاءات الصحيحة لـ range هي:

• استدعاء range مع أي ثلاثة من start و step و stop و length.
• استدعاء range مع اثنين من start و stop و length. في هذه الحالة، سيتم افتراض أن step يساوي واحد. إذا كانت كلا المعطيات من الأعداد الصحيحة، سيتم إرجاع UnitRange.
• استدعاء range مع واحد من stop أو length. سيتم افتراض أن start و step يساويان واحد.

انظر المساعدة الموسعة لمزيد من التفاصيل حول النوع المعاد. انظر أيضًا logrange للنقاط المتباعدة لوغاريتميًا.

أمثلة

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

إذا لم يتم تحديد length و stop - start ليس مضاعفًا صحيحًا لـ step، سيتم إنتاج نطاق ينتهي قبل stop.

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

تم اتخاذ احتياطات خاصة لضمان حساب القيم الوسيطة بشكل عقلاني. لتجنب هذا الحمل الزائد الناتج، انظر إلى منشئ LinRange.

المساعدة الموسعة

سيقوم range بإنتاج Base.OneTo عندما تكون المعطيات أعداد صحيحة و

• تم توفير length فقط
• تم توفير stop فقط

سيقوم range بإنتاج UnitRange عندما تكون المعطيات أعداد صحيحة و

• تم توفير start و stop فقط
• تم توفير length و stop فقط

لا يتم إنتاج UnitRange إذا تم توفير step حتى لو تم تحديده كواحد.

Base.OneTo(n)

قم بتعريف AbstractUnitRange يتصرف مثل 1:n، مع التمييز الإضافي بأن الحد الأدنى مضمون (من خلال نظام النوع) أن يكون 1.

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

نطاق r حيث r[i] ينتج قيمًا من النوع T (في الشكل الأول، يتم استنتاج T تلقائيًا)، مُعَلم بمعامل ref، وstep، وlength. بشكل افتراضي، ref هو القيمة الابتدائية r[1]، ولكن بدلاً من ذلك يمكنك تقديمه كقيمة لـ r[offset] لمؤشر آخر 1 <= offset <= len. بناء الجملة a:b أو a:b:c، حيث أي من a، b، أو c هي أرقام عائمة، ينشئ StepRangeLen.

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

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

هذا مشابه لـ geomspace في بايثون. على عكس PowerRange في Mathematica، تحدد عدد العناصر وليس النسبة. على عكس logspace في بايثون و Matlab، فإن وسائط start و stop هي دائماً العناصر الأولى والأخيرة من النتيجة، وليس قوى مطبقة على بعض الأساس.

أمثلة

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)  # العنصر الأوسط هو المتوسط الهندسي
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # المتوسط الحسابي
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

انظر إلى LogRange للحصول على مزيد من التفاصيل.

انظر أيضًا range لنقاط متباعدة خطياً.

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

نطاق تكون عناصره متباعدة لوغاريتمياً بين start و stop، مع التحكم في التباعد بواسطة len. يتم إرجاعه بواسطة logrange.

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

أمثلة

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

لاحظ أن نوع العنصر الصحيح T غير مسموح به. استخدم على سبيل المثال round.(Int, xs)، أو قوى صريحة لبعض الأسس الصحيحة:

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)

عامل المساواة العام. يعتمد على ===. يجب أن يتم تنفيذه لجميع الأنواع التي لديها مفهوم المساواة، بناءً على القيمة المجردة التي يمثلها الكائن. على سبيل المثال، تتم مقارنة جميع الأنواع الرقمية بالقيمة الرقمية، متجاهلة النوع. تتم مقارنة السلاسل كترتيب من الأحرف، متجاهلة الترميز. عادةً ما تقارن المجموعات من نفس النوع مجموعات المفاتيح الخاصة بها، وإذا كانت تلك ==، فإنها تقارن القيم لكل من تلك المفاتيح، وتعيد true إذا كانت جميع تلك الأزواج ==. عادةً ما لا تؤخذ الخصائص الأخرى في الاعتبار (مثل النوع الدقيق).

يتبع هذا العامل دلالات IEEE للأرقام العائمة: 0.0 == -0.0 و NaN != NaN.

النتيجة من نوع Bool، باستثناء عندما يكون أحد المعاملات هو missing، وفي هذه الحالة يتم إرجاع missing (المنطق ثلاثي القيم). عادةً ما تنفذ المجموعات منطقًا ثلاثي القيم مشابهًا لـ all، حيث تعيد missing إذا كانت أي من المعاملات تحتوي على قيم مفقودة وكانت جميع الأزواج الأخرى متساوية. استخدم isequal أو === للحصول دائمًا على نتيجة Bool.

التنفيذ

يجب على الأنواع الرقمية الجديدة تنفيذ هذه الوظيفة لوسيطين من النوع الجديد، والتعامل مع المقارنة مع الأنواع الأخرى عبر قواعد الترويج حيثما كان ذلك ممكنًا.

isequal يعتمد على ==، لذا ستستخدم الطرق الجديدة لـ == من قبل نوع Dict لمقارنة المفاتيح. إذا كان سيتم استخدام نوعك كمفتاح في القاموس، فيجب عليه أيضًا تنفيذ hash.

إذا كان بعض الأنواع يعرف == و isequal و isless فيجب عليه أيضًا تنفيذ < لضمان اتساق المقارنات.

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

عامل المقارنة غير المتساوي. يعطي دائمًا الإجابة المعاكسة لـ ==.

التنفيذ

يجب عمومًا ألا تقوم الأنواع الجديدة بتنفيذ هذا، والاعتماد على التعريف الافتراضي !=(x,y) = !(x==y) بدلاً من ذلك.

أمثلة

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

أنشئ دالة تقارن وسيطها بـ x باستخدام !=، أي دالة تعادل y -> y != x. الدالة المعادة هي من النوع Base.Fix2{typeof(!=)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

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

يعطي دائمًا الإجابة المعاكسة لـ ===.

أمثلة

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

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

عامل المقارنة أقل من. يعتمد على isless. بسبب سلوك قيم NaN العائمة، يقوم هذا العامل بتنفيذ ترتيب جزئي.

التنفيذ

يجب على الأنواع الجديدة التي تحتوي على ترتيب جزئي قياسي تنفيذ هذه الدالة لوسيطين من النوع الجديد. يجب على الأنواع التي تحتوي على ترتيب كلي قياسي تنفيذ isless بدلاً من ذلك.

انظر أيضًا isunordered.

أمثلة

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

أنشئ دالة تقارن وسيطها بـ x باستخدام <، أي دالة تعادل y -> y < x. الدالة المعادة هي من النوع Base.Fix2{typeof(<)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

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

عامل مقارنة أقل من أو يساوي. يعتمد على (x < y) | (x == y).

أمثلة

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

أنشئ دالة تقارن وسيطها بـ x باستخدام <=، أي دالة تعادل y -> y <= x. الدالة المعادة هي من النوع Base.Fix2{typeof(<=)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

>(x, y)

عامل المقارنة أكبر من. يعتمد على y < x.

التنفيذ

بشكل عام، يجب على الأنواع الجديدة تنفيذ < بدلاً من هذه الدالة، والاعتماد على التعريف الاحتياطي >(x, y) = y < x.

أمثلة

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

أنشئ دالة تقارن وسيطها بـ x باستخدام >، أي دالة تعادل y -> y > x. الدالة المعادة هي من النوع Base.Fix2{typeof(>)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

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

عامل مقارنة أكبر من أو يساوي. يعود إلى y <= x.

أمثلة

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

أنشئ دالة تقارن وسيطها بـ x باستخدام >=، أي دالة تعادل y -> y >= x. الدالة المعادة هي من النوع Base.Fix2{typeof(>=)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

cmp(x,y)

يرجع -1 أو 0 أو 1 اعتمادًا على ما إذا كان x أقل من أو يساوي أو أكبر من y، على التوالي. يستخدم الترتيب الكلي المنفذ بواسطة isless.

أمثلة

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

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

cmp(<, x, y)

إرجاع -1 أو 0 أو 1 اعتمادًا على ما إذا كان x أقل من أو يساوي أو أكبر من y، على التوالي. تحدد الحجة الأولى دالة مقارنة أقل من لاستخدامها.

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

قارن بين سلسلتين. أعد 0 إذا كانت السلسلتان لهما نفس الطول وكان الحرف في كل فهرس هو نفسه في كلا السلسلتين. أعد -1 إذا كانت a بادئة لـ b، أو إذا كانت a تأتي قبل b في الترتيب الأبجدي. أعد 1 إذا كانت b بادئة لـ a، أو إذا كانت b تأتي قبل a في الترتيب الأبجدي (تقنيًا، الترتيب المعجمي حسب نقاط الشيفرة Unicode).

أمثلة

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

~(س)

ليس.

انظر أيضًا: !, &, |.

أمثلة

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

العملية المنطقية البتية "و". تنفذ المنطق الثلاثي القيم، وتعيد missing إذا كان أحد المعاملين هو missing والآخر هو true. أضف أقواسًا لشكل تطبيق الدالة: (&)(x, y).

انظر أيضًا: |, xor, &&.

أمثلة

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

أو بت bitwise. ينفذ المنطق الثلاثي القيم، ويعيد missing إذا كان أحد المعاملين هو missing والآخر هو false.

انظر أيضًا: &، xor، ||.

أمثلة

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

العملية الحصرية البتية لـ x و y. تنفذ المنطق الثلاثي القيم، وتعيد missing إذا كان أحد المعطيات هو missing.

العملية البينية a ⊻ b هي مرادف لـ xor(a,b)، ويمكن كتابة ⊻ عن طريق إكمال التبويب \xor أو \veebar في REPL جوليا.

أمثلة

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

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

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

عملية nand بتقنية البت (ليس و) لـ x و y. تنفذ المنطق الثلاثي القيم، وتعيد missing إذا كان أحد المعطيات هو missing.

العملية الجانبية a ⊼ b هي مرادف لـ nand(a,b)، ويمكن كتابة ⊼ عن طريق إكمال التبويب \nand أو \barwedge في REPL جولي.

أمثلة

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)

العملية النقطية النفي (not or) لـ x و y. تنفذ المنطق الثلاثي القيم، وتعيد missing إذا كان أحد المعطيات هو missing والآخر ليس true.

العملية البينية a ⊽ b هي مرادف لـ nor(a,b)، ويمكن كتابة ⊽ عن طريق إكمال التبويب \nor أو \barvee في REPL جوليا.

أمثلة

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)

النفي البولياني. ينفذ المنطق ثلاثي القيم، ويعيد missing إذا كانت x هي missing.

انظر أيضًا ~ للنفي بتقنية البت.

أمثلة

julia> !true
false

julia> !false
true

julia> !missing
missing

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

!f::Function

نفي دالة الشرط: عندما يكون وسيط ! دالة، فإنه يُرجع دالة مركبة تحسب نفي f البولياني.

انظر أيضًا ∘.

أمثلة

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

اختصار عملية AND المنطقية.

انظر أيضًا &، وعامل الشرط ? :، وقسم الدليل حول تدفق التحكم.

أمثلة

julia> x = 3;

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

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

x || y

اختصار المنطق البولياني OR.

انظر أيضًا: |, xor, &&.

أمثلة

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("neither is true!")
true

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

مقارنة المساواة غير الدقيقة. يتم اعتبار رقمين متساويين إذا كانت المسافة النسبية أو المسافة المطلقة بينهما ضمن حدود التسامح: isapprox ترجع true إذا كان norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). القيمة الافتراضية لـ atol (التسامح المطلق) هي صفر والقيمة الافتراضية لـ rtol (التسامح النسبي) تعتمد على أنواع x و y. تحدد الوسيطة الرئيسية nans ما إذا كانت قيم NaN تعتبر متساوية أم لا (القيمة الافتراضية هي false).

بالنسبة للقيم العائمة الحقيقية أو المعقدة، إذا لم يتم تحديد atol > 0، فإن rtol تكون افتراضيًا جذر eps من نوع x أو y، أيهما أكبر (الأقل دقة). وهذا يتوافق مع متطلبات المساواة لنحو نصف الأرقام المهمة. خلاف ذلك، على سبيل المثال، بالنسبة للوسائط الصحيحة أو إذا تم تقديم atol > 0، فإن rtol تكون افتراضيًا صفر.

تكون الوسيطة الرئيسية norm افتراضيًا abs للأرقام (x,y) و LinearAlgebra.norm للمصفوفات (حيث يكون اختيار norm البديل مفيدًا أحيانًا). عندما تكون x و y مصفوفات، إذا لم تكن norm(x-y) نهائية (أي ±Inf أو NaN)، فإن المقارنة تعود إلى التحقق مما إذا كانت جميع عناصر x و y متساوية تقريبًا من حيث المكونات.

المشغل الثنائي ≈ يعادل isapprox مع الوسائط الافتراضية، و x ≉ y يعادل !isapprox(x,y).

لاحظ أن x ≈ 0 (أي، المقارنة بالصفر مع التسامحات الافتراضية) تعادل x == 0 حيث أن القيمة الافتراضية لـ atol هي 0. في مثل هذه الحالات، يجب عليك إما تقديم atol مناسب (أو استخدام norm(x) ≤ atol) أو إعادة ترتيب الكود الخاص بك (على سبيل المثال، استخدام x ≈ y بدلاً من x - y ≈ 0). لا يمكن اختيار atol غير الصفري تلقائيًا لأنه يعتمد على المقياس العام (الـ "وحدات") لمشكلتك: على سبيل المثال، في x - y ≈ 0، فإن atol=1e-9 هو تسامح صغير بشكل غير معقول إذا كان x هو نصف قطر الأرض بالمتر، ولكنه تسامح كبير بشكل غير معقول إذا كان x هو نصف قطر ذرة الهيدروجين بالمتر.

أمثلة

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 باستخدام ≈، أي دالة تعادل y -> y ≈ x.

تكون وسائط الكلمات الرئيسية المدعومة هنا هي نفسها الموجودة في isapprox ذات الوسيطين.

sin(x)

احسب جيب الزاوية لـ x، حيث x بال radians.

انظر أيضًا sind، sinpi، sincos، cis، asin.

أمثلة

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، حيث x بال radians.

انظر أيضًا cosd، cospi، sincos، cis.

sincos(x)

احسب جيب الزاوية وجيب التمام لـ x في نفس الوقت، حيث x بالراديان، مع إرجاع زوج مرتب (sine, cosine).

انظر أيضًا cis، sincospi، sincosd.

tan(x)

احسب ظل x، حيث x بال radians.

sind(x)

احسب جيب الزاوية لـ x، حيث أن x بالدرجات. إذا كانت x مصفوفة، يجب أن تكون x مصفوفة مربعة.

cosd(x)

احسب جيب التمام لـ x، حيث x بالدرجات. إذا كانت x مصفوفة، يجب أن تكون x مصفوفة مربعة.

tand(x)

احسب ظل x، حيث x بالدرجات. إذا كانت x مصفوفة، يجب أن تكون x مصفوفة مربعة.

sincosd(x)

احسب جيب الزاوية وجيب التمام لـ x في نفس الوقت، حيث x بالدرجات.

sinpi(x)

احسب $\sin(\pi x)$ بدقة أكبر من sin(pi*x)، خاصة للقيم الكبيرة لـ x.

انظر أيضًا sind، cospi، sincospi.

cospi(x)

احسب $\cos(\pi x)$ بدقة أكبر من cos(pi*x)، خاصة للقيم الكبيرة لـ x.

tanpi(x)

احسب $\tan(\pi x)$ بدقة أكبر من tan(pi*x)، خاصة للقيم الكبيرة لـ x.

انظر أيضًا tand, sinpi, cospi, sincospi.

sincospi(x)

احسب في الوقت نفسه sinpi(x) و cospi(x) (جيب الزاوية وجيب التمام لـ π*x، حيث x بالراديان)، مع إرجاع زوج مرتب (sine, cosine).

انظر أيضًا: cispi, sincosd, sinpi.

sinh(x)

احسب الجيب الزائد لـ x.

cosh(x)

احسب جيب التمام الزائدي لـ x.

tanh(x)

احسب الظل الزائدي لـ x.

انظر أيضًا tan، atanh.

أمثلة

julia> tanh.(-3:3f0)  # هنا 3f0 isa Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

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

asin(x)

احسب الجيب العكسي لـ x، حيث تكون النتيجة بالراديان.

انظر أيضًا asind للحصول على النتيجة بالدرجات.

أمثلة

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، حيث تكون النتيجة بالراديان

atan(y)
atan(y, x)

احسب الزاوية العكسية لـ y أو y/x، على التوالي.

بالنسبة لوسيط حقيقي واحد، هذه هي الزاوية بالراديان بين المحور x الموجب والنقطة (1، y)، مع إرجاع قيمة في الفترة $[-\pi/2, \pi/2]$.

بالنسبة لوسيطين، هذه هي الزاوية بالراديان بين المحور x الموجب والنقطة (x، y)، مع إرجاع قيمة في الفترة $[-\pi, \pi]$. وهذا يتوافق مع دالة atan2 القياسية. لاحظ أنه وفقًا للتقليد، يتم تعريف atan(0.0,x) كـ $\pi$ و atan(-0.0,x) كـ $-\pi$ عندما يكون x < 0.

انظر أيضًا atand للدرجات.

أمثلة

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

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

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

asind(x)

احسب الجيب العكسي لـ x، حيث تكون النتيجة بالدرجات. إذا كانت x مصفوفة، يجب أن تكون x مصفوفة مربعة.

acosd(x)

احسب جيب التمام العكسي لـ x، حيث تكون النتيجة بالدرجات. إذا كان x مصفوفة، يجب أن تكون x مصفوفة مربعة.

atand(y)
atand(y,x)

احسب الزاوية العكسية لـ y أو y/x، على التوالي، حيث تكون النتيجة بالدرجات.

sec(x)

احسب القاطع لـ x، حيث أن x بال radians.

csc(x)

احسب القاطع العكسي لـ x، حيث أن x بال radians.

cot(x)

احسب قاطع الزاوية لـ x، حيث أن x بال radians.

secd(x)

احسب القاطع لـ x، حيث أن x بالدرجات.

cscd(x)

احسب القاطع العكسي لـ x، حيث أن x بالدرجات.

cotd(x)

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

asec(x)

احسب القاطع العكسي لـ x، حيث تكون النتيجة بال radians.

acsc(x)

احسب القيم العكسية للكسينوس المقلوب لـ x، حيث تكون النتيجة بالراديان.

acot(x)

احسب القاطع العكسي لـ x، حيث تكون النتيجة بالراديان.

asecd(x)

احسب القاطع العكسي لـ x، حيث تكون النتيجة بالدرجات. إذا كان x مصفوفة، يجب أن تكون x مصفوفة مربعة.

acscd(x)

احسب القوس العكسي للكسين من x، حيث تكون النتيجة بالدرجات. إذا كان x مصفوفة، يجب أن تكون x مصفوفة مربعة.

acotd(x)

احسب القاطع العكسي لـ x، حيث تكون النتيجة بالدرجات. إذا كانت x مصفوفة، يجب أن تكون x مصفوفة مربعة.

sech(x)

احسب القاطع الزائد لـ x.

csch(x)

احسب الكوساين الزائد العكسي لـ x.

coth(x)

احسب القاطع الزائد لـ x.

asinh(x)

احسب الجيب الزائد العكسي لـ x.

acosh(x)

احسب جيب التمام العكسي الزائد لـ x.

atanh(x)

احسب الظل المعكوس الزائد لـ x.

asech(x)

احسب القاطع الزائد العكسي لـ x.

acsch(x)

احسب القيم العكسية للكسور الزائدية لـ x.

acoth(x)

احسب القاطع الزائف العكسي لـ x.

sinc(x)

احسب دالة سينك العادية $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ إذا كان $x \neq 0$، و$1$ إذا كان $x = 0$.

انظر أيضًا cosc، مشتقتها.

cosc(x)

احسب $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ إذا كان $x \neq 0$، و$0$ إذا كان $x = 0$. هذه هي المشتقة لـ sinc(x).

انظر أيضًا sinc.

deg2rad(x)

تحويل x من الدرجات إلى الراديان.

انظر أيضًا rad2deg, sind, pi.

أمثلة

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

تحويل x من الراديان إلى الدرجات.

انظر أيضًا deg2rad.

أمثلة

julia> rad2deg(pi)
180.0

hypot(x, y)

احسب الوتر $\sqrt{|x|^2+|y|^2}$ مع تجنب overflow و underflow.

هذا الكود هو تنفيذ للخوارزمية الموصوفة في: خوارزمية محسّنة لـ hypot(a,b) بواسطة كارلوس ف. بورغيس. المقال متاح على الإنترنت في arXiv على الرابط https://arxiv.org/abs/1904.09481

hypot(x...)

احسب الوتر $\sqrt{\sum |x_i|^2}$ مع تجنب overflow و underflow.

انظر أيضًا norm في مكتبة LinearAlgebra القياسية.

أمثلة

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 يسبب overflow
ERROR: DomainError with -2.914184810805068e18:
sqrt تم استدعاؤه مع حجة حقيقية سالبة ولكن سيعيد فقط نتيجة معقدة إذا تم استدعاؤه مع حجة معقدة. حاول sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

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

julia> using LinearAlgebra

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

log(x)

احسب اللوغاريتم الطبيعي لـ x.

يرمي DomainError للوسائط السلبية من نوع Real. استخدم الوسائط المعقدة للحصول على نتائج معقدة. يحتوي على قطع فرعي على المحور الحقيقي السالب، حيث يُعتبر -0.0im تحت المحور.

انظر أيضًا ℯ، log1p، log2، log10.

أمثلة

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log تم استدعاؤه مع وسيط حقيقي سالب ولكنه سيعيد نتيجة معقدة فقط إذا تم استدعاؤه مع وسيط معقد. حاول log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

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

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

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

log(b,x)

احسب لوغاريتم الأساس b لـ x. يثير DomainError للوسائط السلبية من نوع Real.

أمثلة

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

!!! ملاحظة إذا كان b قوة من 2 أو 10، يجب استخدام log2 أو log10، حيث ستكون هذه عادةً أسرع وأكثر دقة. على سبيل المثال،

```jldoctest
julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0
```

log2(x)

احسب لوغاريتم x بالأساس 2. يثير DomainError للوسائط السلبية من نوع Real.

انظر أيضًا: exp2, ldexp, ispow2.

أمثلة

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 تم استدعاؤه مع وسيط حقيقي سالب ولكنه سيعيد نتيجة معقدة فقط إذا تم استدعاؤه مع وسيط معقد. حاول log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

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

log10(x)

احسب لوغاريتم x بالأساس 10. يثير DomainError للوسائط السلبية من نوع Real.

أمثلة

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10 تم استدعاؤه مع وسيط حقيقي سالب ولكنه سيعيد نتيجة معقدة فقط إذا تم استدعاؤه مع وسيط معقد. حاول log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

لوغاريتم طبيعي دقيق لـ 1+x. يرمي DomainError للوسائط Real التي تقل عن -1.

أمثلة

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p was called with a real argument < -1 but will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

إرجاع (x,exp) بحيث يكون x له مقدار في الفترة $[1/2, 1)$ أو 0، و val يساوي $x \times 2^{exp}$.

انظر أيضًا significand، exponent، ldexp.

أمثلة

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # الفترة [1, 2) بدلاً من ذلك
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # الأس سيكون خطأ
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

احسب الأس الأساس الطبيعي لـ x، بعبارة أخرى $ℯ^x$.

انظر أيضًا exp2، exp10 و cis.

أمثلة

julia> exp(1.0)
2.718281828459045

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

exp2(x)

احسب الأس الأساس 2 لـ x، بعبارة أخرى $2^x$.

انظر أيضًا ldexp، <<.

أمثلة

julia> exp2(5)
32.0

julia> 2^5
32

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

exp10(x)

احسب الأس exponential للقاعدة 10 لـ x، بعبارة أخرى $10^x$.

أمثلة

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

احسب $x \times 2^n$.

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

أمثلة

julia> ldexp(5.0, 2)
20.0

modf(x)

إرجاع زوج مرتب (fpart, ipart) من الأجزاء الكسرية والعددية لرقم. كلا الجزئين لهما نفس إشارة المعطى.

أمثلة

julia> modf(3.5)
(0.5, 3.0)

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

expm1(x)

احسب بدقة $e^x-1$. يتجنب فقدان الدقة المرتبط بالتقييم المباشر لـ exp(x)-1 للقيم الصغيرة من x.

أمثلة

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.

بدون وسائط الكلمات الرئيسية، يتم تقريب x إلى قيمة صحيحة، مما يعيد قيمة من النوع T، أو من نفس نوع x إذا لم يتم توفير T. سيتم رمي InexactError إذا كانت القيمة غير قابلة للتعبير عنها بواسطة T، مشابه لـ convert.

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

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

تتحكم RoundingMode r في اتجاه التقريب؛ الافتراضي هو RoundNearest، الذي يقرب إلى أقرب عدد صحيح، مع وجود روابط (قيم كسرية تبلغ 0.5) يتم تقريبها إلى أقرب عدد صحيح زوجي. لاحظ أن round قد يعطي نتائج غير صحيحة إذا تم تغيير وضع التقريب العالمي (انظر rounding).

عند التقريب إلى نوع نقطة عائمة، سيتم التقريب إلى الأعداد الصحيحة القابلة للتعبير عنها بواسطة هذا النوع (و Inf) بدلاً من الأعداد الصحيحة الحقيقية. يتم التعامل مع Inf كواحد ulp أكبر من floatmax(T) لأغراض تحديد "الأقرب"، مشابه لـ convert.

أمثلة

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)

!!! ملاحظة قد يكون التقريب إلى أرقام محددة في قواعد غير 2 غير دقيق عند العمل على أرقام النقاط العائمة الثنائية. على سبيل المثال، القيمة Float64 الممثلة بـ 1.15 هي في الواقع أقل من 1.15، ومع ذلك سيتم تقريبها إلى 1.2. على سبيل المثال:

```jldoctest
julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2
```

التمديدات

لتمديد round إلى أنواع رقمية جديدة، يكفي عادةً تعريف Base.round(x::NewType, r::RoundingMode).

RoundingMode

نوع يُستخدم للتحكم في وضع التقريب لعمليات النقطة العائمة (عبر rounding/setrounding الوظائف)، أو كوسائط اختيارية للتقريب إلى أقرب عدد صحيح (عبر وظيفة round).

أوضاع التقريب المدعومة حاليًا هي:

• RoundNearest (افتراضي)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

وضعية التقريب الافتراضية. تقرب إلى أقرب عدد صحيح، مع كون الروابط (القيم الكسرية 0.5) تقرب إلى أقرب عدد صحيح زوجي.

RoundNearestTiesAway

يقوم بالتقريب إلى أقرب عدد صحيح، مع تقريب الروابط بعيدًا عن الصفر (سلوك round في C/C++).

RoundNearestTiesUp

يقرب إلى أقرب عدد صحيح، مع تقريب الروابط نحو اللانهاية الموجبة (سلوك round في Java/JavaScript).

RoundToZero

round باستخدام وضع التقريب هذا هو اسم مستعار لـ trunc.

RoundFromZero

يقرّب بعيدًا عن الصفر.

أمثلة

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

RoundUp

round باستخدام وضع التقريب هذا هو اسم مستعار لـ ceil.

RoundDown

round باستخدام وضع التقريب هذا هو اسم مستعار لـ floor.

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

ارجع أقرب قيمة صحيحة من نفس نوع z المعقد إلى z، مع كسر الروابط باستخدام RoundingModes المحددة. يتم استخدام RoundingMode الأول لتقريب المكونات الحقيقية بينما يتم استخدام الثاني لتقريب المكونات التخيلية.

تكون RoundingModeReal و RoundingModeImaginary افتراضيًا RoundNearest، والذي يقرب إلى أقرب عدد صحيح، مع الروابط (القيم الكسرية 0.5) التي يتم تقريبها إلى أقرب عدد صحيح زوجي.

أمثلة

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 التي هي أكبر من أو تساوي x.

ceil(T, x) يُحوّل النتيجة إلى نوع T، مما يؤدي إلى إلقاء InexactError إذا كانت القيمة المقربة غير قابلة للتعبير عنها كـ T.

تعمل الكلمات الرئيسية digits و sigdigits و base كما في round.

لدعم ceil لنوع جديد، عرّف Base.round(x::NewType, ::RoundingMode{:Up}).

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

floor(x) يُرجع أقرب قيمة عددية صحيحة من نفس نوع x التي هي أقل من أو تساوي x.

floor(T, x) يُحوّل النتيجة إلى نوع T، مما يؤدي إلى حدوث InexactError إذا كانت القيمة المقربة غير قابلة للتعبير عنها كـ T.

تعمل الكلمات الرئيسية digits و sigdigits و base كما في round.

لدعم floor لنوع جديد، عرّف Base.round(x::NewType, ::RoundingMode{:Down}).

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

trunc(x) يُرجع أقرب قيمة صحيحة من نفس نوع x التي تكون قيمتها المطلقة أقل من أو تساوي القيمة المطلقة لـ x.

trunc(T, x) يُحوّل النتيجة إلى نوع T، مما يؤدي إلى إلقاء InexactError إذا كانت القيمة المقطوعة غير قابلة للتعبير عنها كـ T.

تعمل الكلمات الرئيسية digits و sigdigits و base كما في round.

لدعم trunc لنوع جديد، عرّف Base.round(x::NewType, ::RoundingMode{:ToZero}).

انظر أيضًا: %, floor, unsigned, unsafe_trunc.

أمثلة

julia> trunc(2.22)
2.0

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

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

إرجاع أقرب قيمة عددية صحيحة من النوع T التي تكون قيمتها المطلقة أقل من أو تساوي القيمة المطلقة لـ x. إذا كانت القيمة غير قابلة للتمثيل بواسطة T، سيتم إرجاع قيمة عشوائية. انظر أيضًا trunc.

أمثلة

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

إرجاع الحد الأدنى من المعطيات، مع مراعاة isless. إذا كان أي من المعطيات هو missing، إرجع missing. انظر أيضًا إلى دالة minimum لأخذ العنصر الأدنى من مجموعة.

أمثلة

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

إرجاع القيمة القصوى من المعطيات، مع مراعاة isless. إذا كان أي من المعطيات هو missing، إرجع missing. انظر أيضًا إلى دالة maximum لأخذ العنصر الأقصى من مجموعة.

أمثلة

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

إرجاع (min(x,y), max(x,y)).

انظر أيضًا extrema التي ترجع (minimum(x), maximum(x)).

أمثلة

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

clamp(x, lo, hi)

إرجاع x إذا كان lo <= x <= hi. إذا كان x > hi، إرجع hi. إذا كان x < lo، إرجع lo. يتم ترقية المعاملات إلى نوع مشترك.

انظر أيضًا clamp!، min، max.

أمثلة

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
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

قم بتقييد x بين typemin(T) و typemax(T) وتحويل النتيجة إلى النوع T.

انظر أيضًا trunc.

أمثلة

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

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

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

قم بتقييد x ليكون ضمن النطاق r.

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

قيّد القيم في array إلى النطاق المحدد، في المكان. انظر أيضًا clamp.

أمثلة

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

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

عندما يتم تطبيق abs على الأعداد الصحيحة الموقعة، قد يحدث تجاوز، مما يؤدي إلى إرجاع قيمة سالبة. يحدث هذا التجاوز فقط عندما يتم تطبيق abs على الحد الأدنى القابل للتمثيل لقيمة عدد صحيح موقعة. أي، عندما x == typemin(typeof(x))، فإن abs(x) == x < 0، وليس -x كما قد يتوقع.

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

أمثلة

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # تجاوز عند typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

تم التحقق

يوفر نموذج Checked دوال حسابية لأنواع الأعداد الصحيحة الموقعة وغير الموقعة المدمجة والتي ترمي خطأً عند حدوث تجاوز. وهي مسماة مثل checked_sub و checked_div، إلخ. بالإضافة إلى ذلك، فإن add_with_overflow و sub_with_overflow و mul_with_overflow تعيد كل من النتائج غير المراقبة وقيمة منطقية تشير إلى وجود تجاوز.

Base.checked_abs(x)

يحسب abs(x)، مع التحقق من أخطاء تجاوز السعة حيثما كان ذلك مناسبًا. على سبيل المثال، لا يمكن للأعداد الصحيحة الموقعة بتكملة اثنين القياسية (مثل Int) تمثيل abs(typemin(Int))، مما يؤدي إلى تجاوز السعة.

قد يفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

Base.checked_neg(x)

يحسب -x، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك. على سبيل المثال، لا يمكن للأعداد الصحيحة الموقعة بتكملة اثنين القياسية (مثل Int) تمثيل -typemin(Int)، مما يؤدي إلى تجاوز السعة.

قد تفرض حماية التجاوز عقوبة أداء ملحوظة.

Base.checked_add(x, y)

يحسب x+y، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية التجاوز عقوبة أداء ملحوظة.

Base.checked_sub(x, y)

يحسب x-y، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية التجاوز عقوبة أداء ملحوظة.

Base.checked_mul(x, y)

يحسب x*y، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

Base.checked_div(x, y)

يحسب div(x,y)، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

Base.checked_rem(x, y)

يحسب x%y، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية التجاوز عقوبة أداء ملحوظة.

Base.checked_fld(x, y)

يحسب fld(x,y)، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

Base.checked_mod(x, y)

يحسب mod(x,y)، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

Base.checked_cld(x, y)

يحسب cld(x,y)، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

Base.checked_pow(x, y)

يحسب ^(x,y)، مع التحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك.

قد تفرض حماية تجاوز السعة عقوبة أداء ملحوظة.

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

يحسب r = x+y، مع العلم أن العلم f يشير إلى ما إذا كان قد حدث تجاوز.

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

يحسب r = x-y، مع العلم أن العلم f يشير إلى ما إذا كان قد حدث تجاوز.

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

يحسب r = x*y، مع العلم أن العلم f يشير إلى ما إذا كان قد حدث تجاوز.

abs2(x)

القيمة المطلقة المربعة لـ x.

يمكن أن تكون هذه الطريقة أسرع من abs(x)^2، خاصة للأعداد المركبة حيث تتطلب abs(x) جذرًا تربيعيًا عبر hypot.

انظر أيضًا abs، conj، real.

أمثلة

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 الذي له مقدار x ونفس إشارة y.

أمثلة

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

ارجع صفر إذا كان x==0 و $x/|x|$ خلاف ذلك (أي ±1 لـ x الحقيقي).

انظر أيضًا signbit، zero، copysign، flipsign.

أمثلة

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)

ارجع true إذا كانت قيمة إشارة x سالبة، وإلا false.

انظر أيضًا sign و copysign.

أمثلة

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

إرجاع x مع عكس إشارته إذا كان y سالبًا. على سبيل المثال abs(x) = flipsign(x,x).

أمثلة

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

√(x)

ارجع $\sqrt{x}$.

يرمي DomainError للوسائط السلبية من نوع Real. استخدم الوسائط السلبية المعقدة بدلاً من ذلك. لاحظ أن sqrt لديه قطع فرعي على المحور الحقيقي السالب.

المشغل البادئ √ يعادل sqrt.

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

أمثلة

julia> sqrt(big(81))
9.0

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

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

julia> sqrt(-81 - 0.0im)  # -0.0im هو أدنى من القطع الفرعي
0.0 - 9.0im

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

isqrt(n::Integer)

جذر مربع صحيح: أكبر عدد صحيح m بحيث m*m <= n.

julia> isqrt(5)
2

cbrt(x::Real)

إرجاع الجذر التكعيبي لـ x، أي $x^{1/3}$. القيم السلبية مقبولة (مع إرجاع الجذر الحقيقي السالب عندما يكون $x < 0$).

المشغل البادئ ∛ يعادل cbrt.

أمثلة

julia> cbrt(big(27))
3.0

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

real(z)

إرجاع الجزء الحقيقي من العدد المركب z.

انظر أيضًا: imag, reim, complex, isreal, Real.

أمثلة

julia> real(1 + 3im)
1

real(T::Type)

إرجاع النوع الذي يمثل الجزء الحقيقي من قيمة من النوع T. على سبيل المثال: لـ T == Complex{R}، إرجاع R. يعادل typeof(real(zero(T))).

أمثلة

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

إرجاع مصفوفة تحتوي على الجزء الحقيقي من كل عنصر في المصفوفة A.

يعادل real.(A)، باستثناء أنه عندما يكون eltype(A) <: Real يتم إرجاع A دون نسخ، وعندما تكون A ذات أبعاد صفرية، يتم إرجاع مصفوفة ذات أبعاد صفرية (بدلاً من عدد حقيقي).

أمثلة

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

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

imag(z)

إرجاع الجزء التخيلي من العدد المركب z.

انظر أيضًا: conj, reim, adjoint, angle.

أمثلة

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

إرجاع مصفوفة تحتوي على الجزء التخيلي من كل عنصر في المصفوفة A.

يعادل imag.(A)، باستثناء أنه عندما تكون A ذات أبعاد صفرية، يتم إرجاع مصفوفة ذات أبعاد صفرية (بدلاً من عدد حقيقي).

أمثلة

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

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

reim(z)

إرجاع مجموعة من الأجزاء الحقيقية والتخييلية للعدد المركب z.

أمثلة

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

reim(A::AbstractArray)

إرجاع مجموعة من مصفوفتين تحتويان على الجزء الحقيقي والجزء التخيلي لكل عنصر في A.

معادل لـ (real.(A), imag.(A))، باستثناء أنه عندما يكون eltype(A) <: Real يتم إرجاع A دون نسخ لتمثيل الجزء الحقيقي، وأنه عندما يكون لـ A أبعاد صفرية، يتم إرجاع مصفوفة ذات أبعاد صفرية (بدلاً من عدد).

أمثلة

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

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

conj(z)

احسب المرافق العقدي لعدد مركب z.

انظر أيضًا: angle، adjoint.

أمثلة

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

conj(A::AbstractArray)

إرجاع مصفوفة تحتوي على المرافق العقدي لكل عنصر في المصفوفة A.

يعادل conj.(A)، باستثناء أنه عندما يكون eltype(A) <: Real يتم إرجاع A دون نسخ، وعندما تكون A ذات أبعاد صفرية، يتم إرجاع مصفوفة ذات أبعاد صفرية (بدلاً من عدد حقيقي).

أمثلة

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

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

angle(z)

احسب زاوية الطور بالراديان لعدد مركب z.

ترجع عددًا بحيث -pi ≤ angle(z) ≤ pi، وبالتالي فهي غير مستمرة على طول المحور الحقيقي السالب.

انظر أيضًا: atan، cis، rad2deg.

أمثلة

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)

طريقة أكثر كفاءة لـ exp(im*x) باستخدام صيغة أويلر: $\cos(x) + i \sin(x) = \exp(i x)$.

انظر أيضًا cispi, sincos, exp, angle.

أمثلة

julia> cis(π) ≈ -1
true

cispi(x)

طريقة أكثر دقة لـ cis(pi*x) (خصوصًا للقيم الكبيرة لـ x).

انظر أيضًا cis, sincospi, exp, angle.

أمثلة

julia> cispi(10000)
1.0 + 0.0im

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

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

معامل ثنائي $\binom{n}{k}$، وهو معامل الحد $k$ في توسيع كثيرات الحدود لـ $(1+x)^n$.

إذا كان $n$ غير سالب، فإنه يمثل عدد الطرق لاختيار k من n عنصر:

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

حيث $n!$ هو دالة factorial.

إذا كان $n$ سالبًا، فإنه يُعرف من خلال الهوية

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

انظر أيضًا factorial.

أمثلة

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

روابط خارجية

• معامل ثنائي على ويكيبيديا.

```

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

معامل ثنائي عام، معرف لـ k ≥ 0 بواسطة كثير الحدود

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

عندما يكون k < 0، فإنه يُرجع صفر.

في حالة x الصحيحة، فإن هذا يعادل معامل ثنائي صحيح عادي

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

التعميمات الإضافية لـ k غير الصحيح ممكنة رياضيًا، ولكنها تتضمن دالة غاما و/أو دالة بيتا، والتي ليست متوفرة في مكتبة جوليا القياسية ولكنها متاحة في حزم خارجية مثل SpecialFunctions.jl.

روابط خارجية

• معامل ثنائي على ويكيبيديا.

factorial(n::Integer)

عامل n. إذا كان n هو Integer، يتم حساب العامل كعدد صحيح (يرتفع إلى 64 بت على الأقل). لاحظ أن هذا قد يتجاوز الحد إذا لم يكن n صغيرًا، ولكن يمكنك استخدام factorial(big(n)) لحساب النتيجة بدقة في دقة تعسفية.

انظر أيضًا binomial.

أمثلة

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

روابط خارجية

• عامل على ويكيبيديا.

```

gcd(x, y...)

أكبر قاسم مشترك (موجب) (أو صفر إذا كانت جميع المعطيات صفر). يمكن أن تكون المعطيات أعداد صحيحة وأعداد كسرية.

أمثلة

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

أقل مضاعف مشترك (موجب) (أو صفر إذا كان أي من المعطيات صفر). يمكن أن تكون المعطيات أعداد صحيحة وأعداد كسرية.

أمثلة

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 و b ومعاملات بيزوت الخاصة بهم، أي المعاملات الصحيحة u و v التي تحقق $ua+vb = d = gcd(a, b)$. ترجع gcdx(a, b) القيمة $(d, u, v)$.

يمكن أن تكون المعطيات أعدادًا صحيحة أو أعدادًا كسرية.

أمثلة

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

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

ispow2(n::Number) -> Bool

اختبر ما إذا كان n هو قوة صحيحة من اثنين.

انظر أيضًا count_ones، prevpow، nextpow.

أمثلة

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)

أصغر a^n ليس أقل من x، حيث n هو عدد صحيح غير سالب. يجب أن يكون a أكبر من 1، و x يجب أن يكون أكبر من 0.

انظر أيضًا prevpow.

أمثلة

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

أكبر a^n ليس أكبر من x، حيث n هو عدد صحيح غير سالب. يجب أن يكون a أكبر من 1، ويجب ألا يكون x أقل من 1.

انظر أيضًا nextpow، isqrt.

أمثلة

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 الذي يمكن كتابته كـ $\prod k_i^{p_i}$ لأعداد صحيحة $p_1$، $p_2$، وما إلى ذلك، لعوامل $k_i$ في factors.

أمثلة

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

julia> 2^2 * 3^3
108

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

خذ المعكوس لـ n بالنسبة لـ m: y بحيث $n y = 1 \pmod m$، و $div(y,m) = 0$. سيؤدي هذا إلى حدوث خطأ إذا كان $m = 0$، أو إذا كان $gcd(n,m) \neq 1$.

أمثلة

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 في حلقة الأعداد الصحيحة من النوع T، أي المودولوس 2^N حيث N = 8*sizeof(T) (على سبيل المثال، N = 32 لـ Int32). بعبارة أخرى، هذه الطرق تلبي الهويات التالية:

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

لاحظ أن * هنا هو ضرب مودولي في حلقة الأعداد الصحيحة، T.

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

يتم حساب المعكوس المودولي بكفاءة أكبر بكثير من الحالة العامة باستخدام الخوارزمية الموضحة في https://arxiv.org/pdf/2204.04342.pdf.

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

احسب $x^p \pmod m$.

أمثلة

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)

احسب عدد الأرقام في العدد الصحيح n المكتوب في الأساس base (يجب ألا يكون base في [-1, 0, 1])، مع إمكانية إضافة أصفار إلى حجم محدد (لن يكون الناتج أقل من pad).

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

أمثلة

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. الفرق الرئيسي عن + هو أن الأعداد الصحيحة الصغيرة يتم ترقيتها إلى Int/UInt.

widemul(x, y)

اضرب x و y، مع إعطاء النتيجة كنوع أكبر.

انظر أيضًا promote، Base.add_sum.

أمثلة

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)

قيم كثير الحدود $\sum_k x^{k-1} p[k]$ للمعاملات p[1], p[2], ...؛ أي أن المعاملات تُعطى بترتيب تصاعدي حسب قوة x. يتم فك الحلقات في وقت الترجمة إذا كان عدد المعاملات معروفًا ثابتًا، أي عندما تكون p عبارة عن Tuple. هذه الدالة تولد كودًا فعالًا باستخدام طريقة هورنر إذا كان x حقيقيًا، أو باستخدام خوارزمية مشابهة لـ Goertzel إذا كان x مركبًا.

أمثلة

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

@evalpoly(z, c...)

قيم كثير الحدود $\sum_k z^{k-1} c[k]$ للمعاملات c[1], c[2], ...؛ أي أن المعاملات تُعطى بترتيب تصاعدي حسب قوة z. هذا الماكرو يتوسع إلى كود مدمج فعال يستخدم إما طريقة هورنر أو، بالنسبة لـ z المعقد، خوارزمية أكثر كفاءة تشبه خوارزمية غورتزل.

انظر أيضًا evalpoly.

أمثلة

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

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

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

@fastmath expr

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

هذا يضبط علامات سرعة LLVM، ويتوافق مع خيار -ffast-math في clang. انظر ملاحظات حول تعليقات الأداء لمزيد من التفاصيل.

أمثلة

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672