Collections and Data Structures

iterate(iter [, state]) -> Union{Nothing, Tuple{Any, Any}}

قم بتقديم المؤشر للحصول على العنصر التالي. إذا لم يتبق أي عناصر، يجب إرجاع nothing. خلاف ذلك، يجب إرجاع زوج مكون من عنصرين: العنصر التالي وحالة التكرار الجديدة.

IteratorSize(itertype::Type) -> IteratorSize

بالنظر إلى نوع المكرر، أعد واحدة من القيم التالية:

• SizeUnknown() إذا كان لا يمكن تحديد الطول (عدد العناصر) مسبقًا.
• HasLength() إذا كان هناك طول ثابت ومحدود.
• HasShape{N}() إذا كان هناك طول معروف بالإضافة إلى مفهوم الشكل متعدد الأبعاد (كما هو الحال في المصفوفة). في هذه الحالة، يجب أن تعطي N عدد الأبعاد، وتكون دالة axes صالحة للمكرر.
• IsInfinite() إذا كان المكرر ينتج القيم إلى الأبد.

القيمة الافتراضية (للمكررات التي لا تعرف هذه الدالة) هي HasLength(). وهذا يعني أن معظم المكررات يُفترض أنها تنفذ دالة length.

تُستخدم هذه السمة عمومًا لاختيار بين الخوارزميات التي تقوم بتهيئة المساحة لنتائجها مسبقًا، والخوارزميات التي تعيد حجم نتائجها بشكل تدريجي.

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()

julia> Base.IteratorSize((2,3))
Base.HasLength()

IteratorEltype(itertype::Type) -> IteratorEltype

بالنظر إلى نوع المكرر، أعد واحدة من القيم التالية:

• EltypeUnknown() إذا كان نوع العناصر التي ينتجها المكرر غير معروف مسبقًا.
• HasEltype() إذا كان نوع العنصر معروفًا، و eltype سيعيد قيمة ذات معنى.

HasEltype() هو الافتراضي، حيث يُفترض أن المكررات تنفذ eltype.

تُستخدم هذه السمة عمومًا للاختيار بين الخوارزميات التي تقوم بتهيئة نوع محدد من النتائج، والخوارزميات التي تختار نوع النتيجة بناءً على أنواع القيم الناتجة.

julia> Base.IteratorEltype(1:5)
Base.HasEltype()

AbstractRange{T} <: AbstractVector{T}

نوع أعلى للنطاقات الخطية مع عناصر من النوع T. UnitRange، LinRange وأنواع أخرى هي أنواع فرعية من هذا.

يجب على جميع الأنواع الفرعية تعريف step. وبالتالي، فإن LogRange ليست نوعًا فرعيًا من AbstractRange.

OrdinalRange{T, S} <: AbstractRange{T}

نوع أعلى لنطاقات الترتيب مع عناصر من النوع T مع فواصل من النوع S. يجب أن تكون الخطوات دائمًا مضاعفات دقيقة لـ oneunit، ويجب أن يكون T نوعًا "منفصلًا"، لا يمكن أن تكون له قيم أصغر من oneunit. على سبيل المثال، ستؤهل الأنواع Integer أو Date، في حين أن Float64 لن تؤهل (لأن هذا النوع يمكن أن يمثل قيمًا أصغر من oneunit(Float64)). UnitRange، StepRange، وأنواع أخرى هي أنواع فرعية من هذا.

AbstractUnitRange{T} <: OrdinalRange{T, T}

نوع السوبر لنطاقات ذات حجم خطوة oneunit(T) مع عناصر من النوع T. UnitRange وأنواع أخرى هي أنواع فرعية من هذا.

StepRange{T, S} <: OrdinalRange{T, S}

نطاقات تحتوي على عناصر من النوع T مع تباعد من النوع S. الخطوة بين كل عنصر ثابتة، ويتم تعريف النطاق من حيث start و stop من النوع T و step من النوع S. لا ينبغي أن يكون كل من T أو S من الأنواع العائمة. التركيب a:b:c مع b != 0 و a و b و c كلها أعداد صحيحة ينشئ StepRange.

أمثلة

julia> collect(StepRange(1, Int8(2), 10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

julia> typeof(StepRange(1, Int8(2), 10))
StepRange{Int64, Int8}

julia> typeof(1:3:6)
StepRange{Int64, Int64}

UnitRange{T<:Real}

نطاق مُعَلم بواسطة start و stop من النوع T، مليء بالعناصر المتباعدة بمقدار 1 من start حتى يتم تجاوز stop. تُنشئ الصيغة a:b حيث أن a و b كلاهما من نوع Integer نطاق UnitRange.

أمثلة

julia> collect(UnitRange(2.3, 5.2))
3-element Vector{Float64}:
 2.3
 3.3
 4.3

julia> typeof(1:10)
UnitRange{Int64}

LinRange{T,L}

نطاق يحتوي على len عناصر موزعة خطيًا بين start و stop. يتم التحكم في حجم التباعد بواسطة len، والذي يجب أن يكون Integer.

أمثلة

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64, Int64}:
 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5

بالمقارنة مع استخدام range، فإن إنشاء LinRange مباشرة يجب أن يكون له تكلفة أقل ولكن لن يحاول تصحيح أخطاء النقطة العائمة:

julia> collect(range(-0.1, 0.3, length=5))
5-element Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

julia> collect(LinRange(-0.1, 0.3, 5))
5-element Vector{Float64}:
 -0.1
 -1.3877787807814457e-17
  0.09999999999999999
  0.19999999999999998
  0.3

انظر أيضًا Logrange للنقاط الموزعة لوغاريتميًا.

isempty(collection) -> Bool

حدد ما إذا كانت المجموعة فارغة (لا تحتوي على عناصر).

أمثلة

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

ارجع true إذا لم تكن هناك مهام تنتظر الشرط، و false خلاف ذلك.

isdone(itr, [state]) -> Union{Bool, Missing}

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

يجب على المكررات ذات الحالة التي ترغب في الاستفادة من هذه الميزة تعريف طريقة isdone التي تعيد true/false اعتمادًا على ما إذا كان المكرر قد اكتمل أم لا. لا تحتاج المكررات غير الحالة إلى تنفيذ هذه الدالة.

إذا كانت النتيجة missing، يمكن للمتصلين المتابعة وحساب iterate(x, state) === nothing للحصول على إجابة محددة.

انظر أيضًا iterate، isempty

empty!(collection) -> collection

قم بإزالة جميع العناصر من collection.

أمثلة

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

إفراغ قناة c عن طريق استدعاء empty! على المخزن الداخلي. إرجاع القناة الفارغة.

length(collection) -> Integer

إرجاع عدد العناصر في المجموعة.

استخدم lastindex للحصول على آخر فهرس صالح لمجموعة قابلة للفهرسة.

انظر أيضًا: size، ndims، eachindex.

أمثلة

julia> length(1:5)
5

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4

Base.checked_length(r)

يحسب length(r)، ولكنه قد يتحقق من أخطاء تجاوز السعة حيثما ينطبق ذلك عندما لا يتناسب الناتج مع Union{Integer(eltype(r)),Int}.

in(item, collection) -> Bool
∈(item, collection) -> Bool

حدد ما إذا كان العنصر موجودًا في المجموعة المعطاة، بمعنى أنه == لأحد القيم الناتجة عن التكرار عبر المجموعة. أعد قيمة Bool، باستثناء إذا كان item هو missing أو كانت collection تحتوي على missing ولكن ليس item، وفي هذه الحالة يتم إرجاع missing (منطق ثلاثي القيم، متطابقًا مع سلوك any و==).

تتبع بعض المجموعات تعريفًا مختلفًا قليلاً. على سبيل المثال، تتحقق Sets مما إذا كان العنصر isequal لأحد العناصر؛ بينما تبحث Dicts عن أزواج key=>value، ويتم مقارنة key باستخدام isequal.

لاختبار وجود مفتاح في القاموس، استخدم haskey أو k in keys(dict). بالنسبة للمجموعات المذكورة أعلاه، تكون النتيجة دائمًا Bool.

عند البث باستخدام in.(items, collection) أو items .∈ collection، يتم بث كل من item و collection، وهو ما لا يكون غالبًا ما هو مقصود. على سبيل المثال، إذا كانت كلا الحجتين متجهتين (وكانت الأبعاد متطابقة)، فإن النتيجة هي متجه يشير إلى ما إذا كانت كل قيمة في مجموعة items موجودة في القيمة في الموضع المقابل في collection. للحصول على متجه يشير إلى ما إذا كانت كل قيمة في items موجودة في collection، قم بتغليف collection في مجموعة أو Ref مثل هذا: in.(items, Ref(collection)) أو items .∈ Ref(collection).

انظر أيضًا: ∉، insorted، contains، occursin، issubset.

أمثلة

julia> a = 1:3:20
1:3:19

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

julia> missing in Set([1, 2])
false

julia> (1=>missing) in Dict(1=>10, 2=>20)
missing

julia> [1, 2] .∈ [2, 3]
2-element BitVector:
 0
 0

julia> [1, 2] .∈ ([2, 3],)
2-element BitVector:
 0
 1

∉(item, collection) -> Bool
∌(collection, item) -> Bool

نفي ∈ و ∋، أي يتحقق مما إذا كان item غير موجود في collection.

عند البث باستخدام items .∉ collection، يتم بث كل من item و collection، وهو ما لا يكون غالبًا ما هو مقصود. على سبيل المثال، إذا كانت كلا الحجتين متجهتين (وكانت الأبعاد متطابقة)، فإن النتيجة هي متجه يشير إلى ما إذا كانت كل قيمة في items غير موجودة في القيمة الموجودة في الموضع المقابل في collection. للحصول على متجه يشير إلى ما إذا كانت كل قيمة في items غير موجودة في collection، قم بتغليف collection في مجموعة أو Ref مثل هذا: items .∉ Ref(collection).

أمثلة

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitVector:
 1
 1

julia> [1, 2] .∉ ([2, 3],)
2-element BitVector:
 1
 0

Base.hasfastin(T)

حدد ما إذا كانت العملية x ∈ collection حيث collection::T يمكن اعتبارها عملية "سريعة" (عادةً ما تكون ذات تعقيد ثابت أو لوغاريتمي). يتم توفير التعريف hasfastin(x) = hasfastin(typeof(x)) للراحة بحيث يمكن تمرير الحالات بدلاً من الأنواع. ومع ذلك، يجب تعريف الشكل الذي يقبل وسيط النوع للأنواع الجديدة.

الإعداد الافتراضي لـ hasfastin(T) هو true لأنواع فرعية من AbstractSet، AbstractDict و AbstractRange و false بخلاف ذلك.

eltype(type)

حدد نوع العناصر التي يتم إنشاؤها عن طريق تكرار مجموعة من type المعطاة. بالنسبة لأنواع القواميس، سيكون هذا Pair{KeyType,ValType}. يتم توفير التعريف eltype(x) = eltype(typeof(x)) للراحة بحيث يمكن تمرير الحالات بدلاً من الأنواع. ومع ذلك، يجب تعريف الشكل الذي يقبل وسيط نوعي لأنواع جديدة.

انظر أيضًا: keytype، typeof.

أمثلة

julia> eltype(fill(1f0, (2,2)))
Float32

julia> eltype(fill(0x1, (2,2)))
UInt8

indexin(a, b)

إرجاع مصفوفة تحتوي على الفهرس الأول في b لكل قيمة في a التي هي عضو في b. تحتوي مصفوفة الإخراج على nothing في أي مكان لا تكون فيه a عضوًا في b.

انظر أيضًا: sortperm، findfirst.

أمثلة

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a', 'b', 'c'];

julia> indexin(a, b)
6-element Vector{Union{Nothing, Int64}}:
 1
 2
 3
 2
  nothing
 1

julia> indexin(b, a)
3-element Vector{Union{Nothing, Int64}}:
 1
 2
 3

unique(itr)

إرجاع مصفوفة تحتوي فقط على العناصر الفريدة من المجموعة itr، كما تحددها isequal و hash، بالترتيب الذي تظهر به أول مجموعة من العناصر المتكافئة في الأصل. يتم الحفاظ على نوع العنصر المدخل.

انظر أيضًا: unique!، allunique، allequal.

أمثلة

julia> unique([1, 2, 6, 2])
3-element Vector{Int64}:
 1
 2
 6

julia> unique(Real[1, 1.0, 2])
2-element Vector{Real}:
 1
 2

unique(f, itr)

إرجاع مصفوفة تحتوي على قيمة واحدة من itr لكل قيمة فريدة تنتجها f المطبقة على عناصر itr.

أمثلة

julia> unique(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

يمكن أيضًا استخدام هذه الوظيفة لاستخراج المؤشرات لأولى حدوث العناصر الفريدة في مصفوفة:

julia> a = [3.1, 4.2, 5.3, 3.1, 3.1, 3.1, 4.2, 1.7];

julia> i = unique(i -> a[i], eachindex(a))
4-element Vector{Int64}:
 1
 2
 3
 8

julia> a[i]
4-element Vector{Float64}:
 3.1
 4.2
 5.3
 1.7

julia> a[i] == unique(a)
true

unique(A::AbstractArray; dims::Int)

إرجاع المناطق الفريدة من A على طول البعد dims.

أمثلة

julia> A = map(isodd, reshape(Vector(1:8), (2,2,2)))
2×2×2 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

[:, :, 2] =
 1  1
 0  0

julia> unique(A)
2-element Vector{Bool}:
 1
 0

julia> unique(A, dims=2)
2×1×2 Array{Bool, 3}:
[:, :, 1] =
 1
 0

[:, :, 2] =
 1
 0

julia> unique(A, dims=3)
2×2×1 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

unique!(f, A::AbstractVector)

يختار قيمة واحدة من A لكل قيمة فريدة تنتج عن f المطبقة على عناصر A، ثم يُرجع A المعدلة.

أمثلة

julia> unique!(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

julia> unique!(n -> n%3, [5, 1, 8, 9, 3, 4, 10, 7, 2, 6])
3-element Vector{Int64}:
 5
 1
 9

julia> unique!(iseven, [2, 3, 5, 7, 9])
2-element Vector{Int64}:
 2
 3

unique!(A::AbstractVector)

قم بإزالة العناصر المكررة كما تحددها isequal وhash، ثم أعد A المعدلة. ستعيد unique! عناصر A بالترتيب الذي تحدث فيه. إذا لم تكن مهتمًا بترتيب البيانات المعادة، فإن استدعاء (sort!(A); unique!(A)) سيكون أكثر كفاءة طالما يمكن فرز عناصر A.

أمثلة

julia> unique!([1, 1, 1])
1-element Vector{Int64}:
 1

julia> A = [7, 3, 2, 3, 7, 5];

julia> unique!(A)
4-element Vector{Int64}:
 7
 3
 2
 5

julia> B = [7, 6, 42, 6, 7, 42];

julia> sort!(B);  # unique! قادرة على معالجة البيانات المرتبة بكفاءة أكبر.

julia> unique!(B)
3-element Vector{Int64}:
  6
  7
 42

allunique(itr) -> Bool
allunique(f, itr) -> Bool

ارجع true إذا كانت جميع القيم من itr مميزة عند مقارنتها بـ isequal. أو إذا كانت جميع [f(x) for x in itr] مميزة، للطريقة الثانية.

لاحظ أن allunique(f, itr) قد تستدعي f أقل من length(itr) مرات. العدد الدقيق للاستدعاءات يعتبر تفصيلًا تنفيذيًا.

قد تستخدم allunique تنفيذًا متخصصًا عندما تكون المدخلات مرتبة.

انظر أيضًا: unique, issorted, allequal.

أمثلة

julia> allunique([1, 2, 3])
true

julia> allunique([1, 2, 1, 2])
false

julia> allunique(Real[1, 1.0, 2])
false

julia> allunique([NaN, 2.0, NaN, 4.0])
false

julia> allunique(abs, [1, -1, 2])
false

allequal(itr) -> Bool
allequal(f, itr) -> Bool

ارجع true إذا كانت جميع القيم من itr متساوية عند المقارنة باستخدام isequal. أو إذا كانت جميع قيم [f(x) for x in itr] متساوية، للطريقة الثانية.

لاحظ أن allequal(f, itr) قد تستدعي f أقل من length(itr) مرات. العدد الدقيق للاستدعاءات يعتبر كجزء من تفاصيل التنفيذ.

انظر أيضًا: unique, allunique.

أمثلة

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

julia> allequal(Dict(:a => 1, :b => 1))
false

julia> allequal(abs2, [1, -1])
true

reduce(op, itr; [init])

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

بالنسبة للمجموعات الفارغة، سيكون من الضروري توفير init، باستثناء بعض الحالات الخاصة (مثل عندما يكون op أحد +، *، max، min، &، |) عندما يمكن لجوليا تحديد العنصر المحايد لـ op.

قد تحتوي التخفيضات لبعض العوامل الشائعة الاستخدام على تنفيذات خاصة، ويجب استخدامها بدلاً من ذلك: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). هناك طرق فعالة لدمج بعض المصفوفات من المصفوفات عن طريق استدعاء reduce(vcat, arr) أو reduce(hcat, arr).

تعتمد تجميعية التخفيض على التنفيذ. هذا يعني أنه لا يمكنك استخدام العمليات غير التجميعية مثل - لأنه غير محدد ما إذا كان يجب تقييم reduce(-,[1,2,3]) كـ (1-2)-3 أو 1-(2-3). استخدم foldl أو foldr بدلاً من ذلك لضمان التجميعية اليسارية أو اليمنى.

بعض العمليات تجمع الخطأ. سيكون من الأسهل تنفيذ التوازي إذا كان يمكن تنفيذ التخفيض في مجموعات. قد تغير الإصدارات المستقبلية من جوليا الخوارزمية. لاحظ أن العناصر لا تعاد ترتيبها إذا كنت تستخدم مجموعة مرتبة.

أمثلة

julia> reduce(*, [2; 3; 4])
24

julia> reduce(*, [2; 3; 4]; init=-1)
-24

reduce(f, A::AbstractArray; dims=:, [init])

قم بتقليل دالة ذات وسيطين f على طول أبعاد A. dims هو متجه يحدد الأبعاد التي سيتم تقليلها، وحجة الكلمة الرئيسية init هي القيمة الأولية التي سيتم استخدامها في التخفيضات. بالنسبة لـ + و * و max و min، فإن حجة init اختيارية.

تعتمد التجميعية للتقليل على التنفيذ؛ إذا كنت بحاجة إلى تجميعية معينة، مثل من اليسار إلى اليمين، يجب عليك كتابة حلقتك الخاصة أو النظر في استخدام foldl أو foldr. راجع الوثائق الخاصة بـ reduce.

أمثلة

julia> a = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reduce(max, a, dims=2)
4×1 Matrix{Int64}:
 13
 14
 15
 16

julia> reduce(max, a, dims=1)
1×4 Matrix{Int64}:
 4  8  12  16

foldl(op, itr; [init])

مثل reduce، ولكن مع ضمان التوافق الأيسر. إذا تم توفيره، سيتم استخدام الوسيطة الرئيسية init مرة واحدة فقط. بشكل عام، سيكون من الضروري توفير init للعمل مع المجموعات الفارغة.

انظر أيضًا mapfoldl، foldr، accumulate.

أمثلة

julia> foldl(=>, 1:4)
((1 => 2) => 3) => 4

julia> foldl(=>, 1:4; init=0)
(((0 => 1) => 2) => 3) => 4

julia> accumulate(=>, (1,2,3,4))
(1, 1 => 2, (1 => 2) => 3, ((1 => 2) => 3) => 4)

foldr(op, itr; [init])

مثل reduce، ولكن مع ضمان التوافق الأيمن. إذا تم توفيره، سيتم استخدام الوسيطة الرئيسية init مرة واحدة فقط. بشكل عام، سيكون من الضروري توفير init للعمل مع المجموعات الفارغة.

أمثلة

julia> foldr(=>, 1:4)
1 => (2 => (3 => 4))

julia> foldr(=>, 1:4; init=0)
1 => (2 => (3 => (4 => 0)))

maximum(f, itr; [init])

إرجاع أكبر نتيجة لاستدعاء الدالة f على كل عنصر من itr.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون عنصرًا محايدًا لـ max (أي أقل من أو يساوي أي عنصر آخر) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

أمثلة

julia> maximum(length, ["Julion", "Julia", "Jule"])
6

julia> maximum(length, []; init=-1)
-1

julia> maximum(sin, Real[]; init=-1.0)  # جيد، حيث أن ناتج sin >= -1
-1.0

maximum(itr; [init])

إرجاع أكبر عنصر في مجموعة.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن يكون عنصرًا محايدًا لـ max (أي أقل من أو يساوي أي عنصر آخر) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

أمثلة

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3

julia> maximum(())
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

julia> maximum((); init=-Inf)
-Inf

maximum(A::AbstractArray; dims)

احسب القيمة القصوى لمصفوفة عبر الأبعاد المعطاة. انظر أيضًا إلى max(a,b) الدالة لأخذ الحد الأقصى من اثنين أو أكثر من المعطيات، والتي يمكن تطبيقها عنصرًا عنصرًا على المصفوفات عبر max.(a,b).

انظر أيضًا: maximum!، extrema، findmax، argmax.

أمثلة

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

julia> maximum(A, dims=1)
1×2 Matrix{Int64}:
 3  4

julia> maximum(A, dims=2)
2×1 Matrix{Int64}:
 2
 4

maximum(f, A::AbstractArray; dims)

احسب القيمة القصوى عن طريق استدعاء الدالة f على كل عنصر من عناصر المصفوفة عبر الأبعاد المعطاة.

أمثلة

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

julia> maximum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  16

julia> maximum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  4
 16

maximum!(r, A)

احسب القيمة القصوى لـ A عبر الأبعاد الفردية لـ r، واكتب النتائج في r.

!!! تحذير قد يكون السلوك غير متوقع عندما تشترك أي حجة معدلة في الذاكرة مع أي حجة أخرى.

أمثلة

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

julia> maximum!([1; 1], A)
2-element Vector{Int64}:
 2
 4

julia> maximum!([1 1], A)
1×2 Matrix{Int64}:
 3  4

minimum(f, itr; [init])

إرجاع أصغر نتيجة لاستدعاء الدالة f على كل عنصر من itr.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون عنصرًا محايدًا لـ min (أي أكبر من أو يساوي أي عنصر آخر) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

أمثلة

julia> minimum(length, ["Julion", "Julia", "Jule"])
4

julia> minimum(length, []; init=typemax(Int64))
9223372036854775807

julia> minimum(sin, Real[]; init=1.0)  # جيد، حيث أن ناتج sin <= 1
1.0

minimum(itr; [init])

إرجاع أصغر عنصر في مجموعة.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون عنصرًا محايدًا لـ min (أي أكبر من أو يساوي أي عنصر آخر) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

أمثلة

julia> minimum(-20.5:10)
-20.5

julia> minimum([1,2,3])
1

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

julia> minimum([]; init=Inf)
Inf

minimum(A::AbstractArray; dims)

احسب القيمة الدنيا لمصفوفة عبر الأبعاد المعطاة. انظر أيضًا إلى min(a,b) الدالة لأخذ الحد الأدنى من اثنين أو أكثر من المعطيات، والتي يمكن تطبيقها عنصرًا عنصرًا على المصفوفات عبر min.(a,b).

انظر أيضًا: minimum!، extrema، findmin، argmin.

أمثلة

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

julia> minimum(A, dims=1)
1×2 Matrix{Int64}:
 1  2

julia> minimum(A, dims=2)
2×1 Matrix{Int64}:
 1
 3

minimum(f, A::AbstractArray; dims)

احسب القيمة الدنيا عن طريق استدعاء الدالة f على كل عنصر من عناصر المصفوفة عبر الأبعاد المعطاة.

أمثلة

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

julia> minimum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 1  4

julia> minimum(abs2, A, dims=2)
2×1 Matrix{Int64}:
 1
 9

minimum!(r, A)

احسب القيمة الدنيا لـ A عبر الأبعاد الفردية لـ r، واكتب النتائج في r.

!!! تحذير قد يكون السلوك غير متوقع عندما تشترك أي حجة معدلة في الذاكرة مع أي حجة أخرى.

أمثلة

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

julia> minimum!([1; 1], A)
2-element Vector{Int64}:
 1
 3

julia> minimum!([1 1], A)
1×2 Matrix{Int64}:
 1  2

extrema(itr; [init]) -> (mn, mx)

احسب كل من العنصر الأدنى mn والأعلى mx في تمريرة واحدة، وأعدهما كزوج مكون من 2.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون عبارة عن زوج مكون من 2 حيث تكون العناصر الأولى والثانية عناصر محايدة لـ min و max على التوالي (أي التي تكون أكبر/أقل من أو تساوي أي عنصر آخر). ونتيجة لذلك، عندما يكون itr فارغًا، فإن الزوج المعاد (mn, mx) سيلبي mn ≥ mx. عند تحديد init، يمكن استخدامه حتى لـ itr غير الفارغ.

أمثلة

julia> extrema(2:10)
(2, 10)

julia> extrema([9,pi,4.5])
(3.141592653589793, 9.0)

julia> extrema([]; init = (Inf, -Inf))
(Inf, -Inf)

extrema(f, itr; [init]) -> (mn, mx)

احسب كل من الحد الأدنى mn والحد الأقصى mx لـ f المطبقة على كل عنصر في itr وأعدهما كزوج ثنائي. يتم إجراء تمريرة واحدة فقط على itr.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون عبارة عن زوج ثنائي تكون عناصره الأولى والثانية عناصر محايدة لـ min و max على التوالي (أي التي تكون أكبر/أقل من أو تساوي أي عنصر آخر). يتم استخدامها للمجموعات غير الفارغة. ملاحظة: هذا يعني أنه بالنسبة لـ itr الفارغ، فإن القيمة المعادة (mn, mx) تلبي mn ≥ mx على الرغم من أنه بالنسبة لـ itr غير الفارغ تلبي mn ≤ mx. هذه نتيجة "بارادوكسية" ولكنها متوقعة.

أمثلة

julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # جيد، حيث -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

extrema(A::AbstractArray; dims) -> Array{Tuple}

احسب العناصر الدنيا والقصوى لمصفوفة عبر الأبعاد المعطاة.

انظر أيضًا: [`minimum`](@ref), [`maximum`](@ref), [`extrema!`](@ref).

# أمثلة

jldoctest julia> A = reshape(Vector(1:2:16), (2,2,2)) 2×2×2 Array{Int64, 3}: [:, :, 1] = 1 5 3 7

[:, :, 2] = 9 13 11 15

julia> extrema(A, dims = (1,2)) 1×1×2 Array{Tuple{Int64, Int64}, 3}: [:, :, 1] = (1, 7)

[:, :, 2] = (9, 15) ```

extrema(f, A::AbstractArray; dims) -> Array{Tuple}

احسب الحد الأدنى والحد الأقصى لـ f المطبق على كل عنصر في الأبعاد المعطاة من A.

extrema!(r, A)

احسب القيمة الدنيا والقصوى لـ A عبر الأبعاد الفردية لـ r، واكتب النتائج في r.

أمثلة

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

julia> extrema!([(1, 1); (1, 1)], A)
2-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (3, 4)

julia> extrema!([(1, 1);; (1, 1)], A)
1×2 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (2, 4)

argmax(r::AbstractRange)

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

argmax(f, domain)

إرجاع قيمة x من domain حيث يتم تعظيم f(x). إذا كانت هناك قيم قصوى متعددة لـ f(x)، فسيتم العثور على الأولى.

يجب أن يكون domain قابل للتكرار وغير فارغ.

تتم مقارنة القيم باستخدام isless.

انظر أيضًا argmin، findmax.

أمثلة

julia> argmax(abs, -10:5)
-10

julia> argmax(cos, 0:π/2:2π)
0.0

argmax(itr)

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

يجب ألا تكون المجموعة فارغة.

الفهارس من نفس نوع تلك التي يتم إرجاعها بواسطة keys(itr) و pairs(itr).

تتم مقارنة القيم باستخدام isless.

انظر أيضًا: argmin، findmax.

أمثلة

julia> argmax([8, 0.1, -9, pi])
1

julia> argmax([1, 7, 7, 6])
2

julia> argmax([1, 7, 7, NaN])
4

argmax(A; dims) -> indices

لإدخال مصفوفة، ارجع مؤشرات العناصر القصوى عبر الأبعاد المعطاة. يتم اعتبار NaN أكبر من جميع القيم الأخرى باستثناء missing.

أمثلة

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> argmax(A, dims=1)
1×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)

julia> argmax(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

argmin(r::AbstractRange)

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

argmin(f, domain)

إرجاع قيمة x من domain حيث يتم تقليل f(x). إذا كانت هناك قيم دنيا متعددة لـ f(x)، فسيتم العثور على الأولى.

يجب أن يكون domain قابل للتكرار وغير فارغ.

يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

انظر أيضًا argmax، findmin.

أمثلة

julia> argmin(sign, -10:5)
-10

julia> argmin(x -> -x^3 + x^2 - 10, -5:5)
5

julia> argmin(acos, 0:0.1:1)
1.0

argmin(itr)

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

يجب ألا تكون المجموعة فارغة.

الفهارس من نفس نوع تلك التي يتم إرجاعها بواسطة keys(itr) و pairs(itr).

يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

انظر أيضًا: argmax، findmin.

أمثلة

julia> argmin([8, 0.1, -9, pi])
3

julia> argmin([7, 1, 1, 6])
2

julia> argmin([7, 1, 1, NaN])
4

argmin(A; dims) -> indices

لإدخال مصفوفة، ارجع مؤشرات العناصر الدنيا عبر الأبعاد المعطاة. يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

أمثلة

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> argmin(A, dims=1)
1×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)

julia> argmin(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

findmax(f, domain) -> (f(x), index)

إرجاع زوج من قيمة في المجال (مخرجات f) ومؤشر أو مفتاح القيمة المقابلة في domain (مدخلات f) بحيث يتم تعظيم f(x). إذا كانت هناك نقاط قصوى متعددة، فسيتم إرجاع الأولى.

يجب أن يكون domain قابل للتكرار غير فارغ يدعم keys. المؤشرات من نفس نوع تلك التي يتم إرجاعها بواسطة keys(domain).

تتم مقارنة القيم باستخدام isless.

أمثلة

julia> findmax(identity, 5:9)
(9, 5)

julia> findmax(-, 1:10)
(-1, 1)

julia> findmax(first, [(1, :a), (3, :b), (3, :c)])
(3, 2)

julia> findmax(cos, 0:π/2:2π)
(1.0, 1)

findmax(itr) -> (x, index)

إرجاع العنصر الأقصى من المجموعة itr ومؤشره أو مفتاحه. إذا كان هناك عناصر قصوى متعددة، فسيتم إرجاع الأول. يتم مقارنة القيم باستخدام isless.

المؤشرات من نفس نوع تلك التي يتم إرجاعها بواسطة keys(itr) و pairs(itr).

انظر أيضًا: findmin، argmax، maximum.

أمثلة

julia> findmax([8, 0.1, -9, pi])
(8.0, 1)

julia> findmax([1, 7, 7, 6])
(7, 2)

julia> findmax([1, 7, 7, NaN])
(NaN, 4)

findmax(A; dims) -> (maxval, index)

لإدخال مصفوفة، تُرجع القيمة والفهرس للحد الأقصى عبر الأبعاد المعطاة. يتم اعتبار NaN أكبر من جميع القيم الأخرى باستثناء missing.

أمثلة

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> findmax(A, dims=1)
([3.0 4.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(2, 2)])

julia> findmax(A, dims=2)
([2.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 2); CartesianIndex(2, 2);;])

findmax(f, A; dims) -> (f(x), index)

لإدخال مصفوفة، يُرجع القيمة في المجال المقابل ومؤشر القيمة المقابلة التي تعظم f عبر الأبعاد المعطاة.

أمثلة

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

julia> findmax(abs2, A, dims=1)
([1.0 4.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(2, 2)])

julia> findmax(abs2, A, dims=2)
([1.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 2);;])

findmin(f, domain) -> (f(x), index)

إرجاع زوج من قيمة في المجال (مخرجات f) ومؤشر أو مفتاح القيمة المقابلة في domain (مدخلات f) بحيث يتم تقليل f(x). إذا كانت هناك نقاط دنيا متعددة، فسيتم إرجاع الأولى.

يجب أن يكون domain قابل للتكرار وغير فارغ.

المؤشرات من نفس نوع تلك التي يتم إرجاعها بواسطة keys(domain) و pairs(domain).

يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

أمثلة

julia> findmin(identity, 5:9)
(5, 1)

julia> findmin(-, 1:10)
(-10, 10)

julia> findmin(first, [(2, :a), (2, :b), (3, :c)])
(2, 1)

julia> findmin(cos, 0:π/2:2π)
(-1.0, 3)

findmin(itr) -> (x, index)

إرجاع العنصر الأدنى من المجموعة itr ومؤشره أو مفتاحه. إذا كان هناك عناصر دنيا متعددة، فسيتم إرجاع الأول منها. يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

المؤشرات من نفس نوع تلك التي يتم إرجاعها بواسطة keys(itr) و pairs(itr).

انظر أيضًا: findmax، argmin، minimum.

أمثلة

julia> findmin([8, 0.1, -9, pi])
(-9.0, 3)

julia> findmin([1, 7, 7, 6])
(1, 1)

julia> findmin([1, 7, 7, NaN])
(NaN, 4)

findmin(A; dims) -> (minval, index)

لإدخال مصفوفة، تُرجع القيمة والفهرس للحد الأدنى عبر الأبعاد المعطاة. يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

أمثلة

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> findmin(A, dims=1)
([1.0 2.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(1, 2)])

julia> findmin(A, dims=2)
([1.0; 3.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])

findmin(f, A; dims) -> (f(x), index)

لإدخال مصفوفة، يُرجع القيمة في المجال المقابل ومؤشر القيمة المقابلة التي تقلل f عبر الأبعاد المعطاة.

أمثلة

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

julia> findmin(abs2, A, dims=1)
([0.25 1.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(1, 2)])

julia> findmin(abs2, A, dims=2)
([1.0; 0.25;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])

findmax!(rval, rind, A) -> (maxval, index)

ابحث عن الحد الأقصى لـ A والفهرس الخطي المقابل على الأبعاد الفردية لـ rval و rind، واحتفظ بالنتائج في rval و rind. يتم اعتبار NaN أكبر من جميع القيم الأخرى باستثناء missing.

!!! تحذير قد يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

findmin!(rval, rind, A) -> (minval, index)

ابحث عن الحد الأدنى لـ A والفهرس الخطي المقابل على الأبعاد الفردية لـ rval و rind، واحتفظ بالنتائج في rval و rind. يتم اعتبار NaN أقل من جميع القيم الأخرى باستثناء missing.

!!! تحذير قد يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

sum(f, itr; [init])

اجمع نتائج استدعاء الدالة f على كل عنصر من itr.

نوع الإرجاع هو Int للأعداد الصحيحة الموقعة التي تقل عن حجم كلمة النظام، و UInt للأعداد الصحيحة غير الموقعة التي تقل عن حجم كلمة النظام. بالنسبة لجميع المعاملات الأخرى، يتم العثور على نوع إرجاع مشترك يتم ترقية جميع المعاملات إليه.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون هوية الجمع (أي صفر) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

أمثلة

julia> sum(abs2, [2; 3; 4])
29

لاحظ الفرق المهم بين sum(A) و reduce(+, A) للمصفوفات ذات نوع عنصر صحيح صغير:

julia> sum(Int8[100, 28])
128

julia> reduce(+, Int8[100, 28])
-128

في الحالة الأولى، يتم توسيع الأعداد الصحيحة إلى حجم كلمة النظام وبالتالي تكون النتيجة 128. في الحالة الأخيرة، لا يحدث أي توسيع من هذا القبيل وتؤدي زيادة الأعداد الصحيحة إلى -128.

sum(itr; [init])

إرجاع مجموع جميع العناصر في مجموعة.

نوع الإرجاع هو Int للأعداد الصحيحة الموقعة التي تقل عن حجم كلمة النظام، و UInt للأعداد الصحيحة غير الموقعة التي تقل عن حجم كلمة النظام. بالنسبة لجميع الحجج الأخرى، يتم العثور على نوع إرجاع مشترك يتم ترقية جميع الحجج إليه.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون هوية الجمع (أي صفر) حيث أنه غير محدد ما إذا كان يتم استخدام init للمجموعات غير الفارغة.

انظر أيضًا: reduce, mapreduce, count, union.

أمثلة

julia> sum(1:20)
210

julia> sum(1:20; init = 0.0)
210.0

sum(A::AbstractArray; dims)

اجمع عناصر المصفوفة عبر الأبعاد المعطاة.

أمثلة

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

julia> sum(A, dims=1)
1×2 Matrix{Int64}:
 4  6

julia> sum(A, dims=2)
2×1 Matrix{Int64}:
 3
 7

sum(f, A::AbstractArray; dims)

اجمع نتائج استدعاء الدالة f على كل عنصر من عناصر المصفوفة عبر الأبعاد المعطاة.

أمثلة

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

julia> sum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 10  20

julia> sum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  5
 25

sum!(r, A)

اجمع عناصر A عبر الأبعاد الفردية لـ r، واكتب النتائج في r.

!!! تحذير يمكن أن يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

أمثلة

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

julia> sum!([1; 1], A)
2-element Vector{Int64}:
 3
 7

julia> sum!([1 1], A)
1×2 Matrix{Int64}:
 4  6

prod(f, itr; [init])

إرجاع حاصل ضرب f المطبق على كل عنصر من itr.

نوع الإرجاع هو Int للأعداد الصحيحة الموقعة التي تقل عن حجم كلمة النظام، و UInt للأعداد الصحيحة غير الموقعة التي تقل عن حجم كلمة النظام. بالنسبة لجميع المعاملات الأخرى، يتم العثور على نوع إرجاع مشترك يتم ترقية جميع المعاملات إليه.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون هوية الضرب (أي واحد) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

أمثلة

julia> prod(abs2, [2; 3; 4])
576

prod(itr; [init])

إرجاع حاصل ضرب جميع عناصر مجموعة.

نوع الإرجاع هو Int للأعداد الصحيحة الموقعة التي تقل عن حجم كلمة النظام، و UInt للأعداد الصحيحة غير الموقعة التي تقل عن حجم كلمة النظام. بالنسبة لجميع الحجج الأخرى، يتم العثور على نوع إرجاع مشترك يتم ترقية جميع الحجج إليه.

يمكن تحديد القيمة المعادة لـ itr الفارغ بواسطة init. يجب أن تكون هوية الضرب (أي واحد) حيث أنه غير محدد ما إذا كان سيتم استخدام init للمجموعات غير الفارغة.

انظر أيضًا: reduce, cumprod, any.

أمثلة

julia> prod(1:5)
120

julia> prod(1:5; init = 1.0)
120.0

prod(A::AbstractArray; dims)

اضرب عناصر مصفوفة عبر الأبعاد المعطاة.

أمثلة

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

julia> prod(A, dims=1)
1×2 Matrix{Int64}:
 3  8

julia> prod(A, dims=2)
2×1 Matrix{Int64}:
  2
 12

prod(f, A::AbstractArray; dims)

اضرب نتائج استدعاء الدالة f على كل عنصر من عناصر مصفوفة عبر الأبعاد المعطاة.

أمثلة

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

julia> prod(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  64

julia> prod(abs2, A, dims=2)
2×1 Matrix{Int64}:
   4
 144

prod!(r, A)

اضرب عناصر A عبر الأبعاد الفردية لـ r، واكتب النتائج في r.

!!! تحذير يمكن أن يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

أمثلة

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

julia> prod!([1; 1], A)
2-element Vector{Int64}:
  2
 12

julia> prod!([1 1], A)
1×2 Matrix{Int64}:
 3  8

any(itr) -> Bool

اختبر ما إذا كانت أي عناصر من مجموعة بوليانية هي true، مع إرجاع true بمجرد العثور على أول قيمة true في itr (التوقف المبكر). للتوقف المبكر عند false، استخدم all.

إذا كانت المدخلات تحتوي على قيم missing، فقم بإرجاع missing إذا كانت جميع القيم غير المفقودة false (أو بمعنى آخر، إذا كانت المدخلات لا تحتوي على أي قيمة true)، متبعًا المنطق الثلاثي القيم.

انظر أيضًا: all، count، sum، |، ||.

أمثلة

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

any(p, itr) -> Bool

حدد ما إذا كانت الدالة p تعيد true لأي من عناصر itr، مع إرجاع true بمجرد العثور على العنصر الأول في itr الذي تعيد له p true (التوقف المبكر). للتوقف المبكر عند false، استخدم all.

إذا كانت المدخلات تحتوي على قيم missing، فقم بإرجاع missing إذا كانت جميع القيم غير المفقودة false (أو بشكل مكافئ، إذا كانت المدخلات لا تحتوي على قيمة true)، وفقًا لـ المنطق الثلاثي القيم.

أمثلة

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

any!(r, A)

اختبر ما إذا كانت أي قيم في A على الأبعاد الفردية لـ r هي true، واكتب النتائج في r.

أمثلة

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> any!([1; 1], A)
2-element Vector{Int64}:
 1
 1

julia> any!([1 1], A)
1×2 Matrix{Int64}:
 1  0

all(itr) -> Bool

اختبر ما إذا كانت جميع عناصر مجموعة البوليان true، مع إرجاع false بمجرد العثور على أول قيمة false في itr (التوقف المبكر). لاستخدام التوقف المبكر عند true، استخدم any.

إذا كانت المدخلات تحتوي على قيم missing، فقم بإرجاع missing إذا كانت جميع القيم غير المفقودة true (أو بمعنى آخر، إذا كانت المدخلات لا تحتوي على قيمة false)، متبعًا المنطق الثلاثي القيم.

انظر أيضًا: all!، any، count، &، &&، allunique.

أمثلة

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

all(p, itr) -> Bool

حدد ما إذا كانت الدالة الشرطية p تُرجع true لجميع عناصر itr، مع إرجاع false بمجرد العثور على العنصر الأول في itr الذي تُرجع له p قيمة false (التوقف المبكر). لاستخدام التوقف المبكر عند true، استخدم any.

إذا كانت المدخلات تحتوي على قيم missing، فقم بإرجاع missing إذا كانت جميع القيم غير المفقودة true (أو بمعنى آخر، إذا كانت المدخلات لا تحتوي على قيمة false)، متبعًا المنطق الثلاثي القيم.

أمثلة

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

all!(r, A)

اختبر ما إذا كانت جميع القيم في A على الأبعاد الفردية لـ r هي true، واكتب النتائج في r.

!!! تحذير قد يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

أمثلة

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> all!([1; 1], A)
2-element Vector{Int64}:
 0
 0

julia> all!([1 1], A)
1×2 Matrix{Int64}:
 1  0

count([f=identity,] itr; init=0) -> Integer

احسب عدد العناصر في itr التي تعيد فيها الدالة f القيمة true. إذا تم حذف f، احسب عدد العناصر true في itr (التي يجب أن تكون مجموعة من القيم البوليانية). يحدد init اختياريًا القيمة التي يبدأ العد منها وبالتالي يحدد أيضًا نوع الإخراج.

انظر أيضًا: any, sum.

أمثلة

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3

julia> count(>(3), 1:7, init=0x03)
0x07

count(
    pattern::Union{AbstractChar,AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

إرجاع عدد المطابقات لـ pattern في string. هذا يعادل استدعاء length(findall(pattern, string)) ولكنه أكثر كفاءة.

إذا كان overlap=true، يُسمح بتداخل التسلسلات المطابقة في الفهارس الأصلية للسلسلة، وإلا يجب أن تكون من نطاقات أحرف غير متداخلة.

أمثلة

julia> count('a', "JuliaLang")
2

julia> count(r"a(.)a", "cabacabac", overlap=true)
3

julia> count(r"a(.)a", "cabacabac")
2

count([f=identity,] A::AbstractArray; dims=:)

احسب عدد العناصر في A التي تعيد true عند تطبيق f عليها عبر الأبعاد المعطاة.

أمثلة

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

julia> count(<=(2), A, dims=1)
1×2 Matrix{Int64}:
 1  1

julia> count(<=(2), A, dims=2)
2×1 Matrix{Int64}:
 2
 0

foreach(f, c...) -> Nothing

استدعاء الدالة f على كل عنصر من العناصر القابلة للتكرار c. بالنسبة لعدة معطيات قابلة للتكرار، يتم استدعاء f بشكل عنصر بعنصر، ويتوقف التكرار عندما ينتهي أي مكرر.

يجب استخدام foreach بدلاً من map عندما لا تكون نتائج f مطلوبة، على سبيل المثال في foreach(println, array).

أمثلة

julia> tri = 1:3:7; res = Int[];

julia> foreach(x -> push!(res, x^2), tri)

julia> res
3-element Vector{Int64}:
  1
 16
 49

julia> foreach((x, y) -> println(x, " with ", y), tri, 'a':'z')
1 with a
4 with b
7 with c

map(f, c...) -> collection

حوّل المجموعة c عن طريق تطبيق f على كل عنصر. بالنسبة لعدة معطيات من المجموعات، قم بتطبيق f عنصرًا بعنصر، وتوقف عندما يتم استنفاد أي منها.

انظر أيضًا map!، foreach، mapreduce، mapslices، zip، Iterators.map.

أمثلة

julia> map(x -> x * 2, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30, 400, 5000])
3-element Vector{Int64}:
 11
 22
 33

map(f, A::AbstractArray...) -> N-array

عند العمل على مصفوفات متعددة الأبعاد بنفس ndims، يجب أن تحتوي جميعها على نفس axes، وستكون الإجابة كذلك.

انظر أيضًا إلى broadcast، الذي يسمح بأحجام غير متطابقة.

أمثلة

julia> map(//, [1 2; 3 4], [4 3; 2 1])
2×2 Matrix{Rational{Int64}}:
 1//4  2//3
 3//2  4//1

julia> map(+, [1 2; 3 4], zeros(2,1))
ERROR: DimensionMismatch

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # يتكرر حتى تنفد الثالثة
3-element Vector{Float64}:
   2.0
  13.0
 102.0

map!(function, destination, collection...)

مثل map، ولكن يخزن النتيجة في destination بدلاً من مجموعة جديدة. يجب أن تكون destination على الأقل بحجم أصغر مجموعة.

انظر أيضًا: map، foreach، zip، copyto!.

أمثلة

julia> a = zeros(3);

julia> map!(x -> x * 2, a, [1, 2, 3]);

julia> a
3-element Vector{Float64}:
 2.0
 4.0
 6.0

julia> map!(+, zeros(Int, 5), 100:999, 1:3)
5-element Vector{Int64}:
 101
 103
 105
   0
   0

map!(f, values(dict::AbstractDict))

يعدل dict عن طريق تحويل كل قيمة من val إلى f(val). لاحظ أن نوع dict لا يمكن تغييره: إذا كانت f(val) ليست من نوع قيمة dict، فسيتم تحويلها إلى نوع القيمة إذا كان ذلك ممكنًا، وإلا ستظهر خطأ.

أمثلة

julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol, Int64} with 2 entries:
  :a => 1
  :b => 2

julia> map!(v -> v-1, values(d))
ValueIterator for a Dict{Symbol, Int64} with 2 entries. Values:
  0
  1

mapreduce(f, op, itrs...; [init])

تطبق الدالة f على كل عنصر (أو عناصر) في itrs، ثم يتم تقليل النتيجة باستخدام الدالة الثنائية op. إذا تم توفيرها، يجب أن تكون init عنصرًا محايدًا لـ op سيتم إرجاعه للمجموعات الفارغة. لا يُحدد ما إذا كانت init تُستخدم للمجموعات غير الفارغة. بشكل عام، سيكون من الضروري توفير init للعمل مع المجموعات الفارغة.

mapreduce تعادل وظيفيًا استدعاء reduce(op, map(f, itr); init=init)، لكنها ستنفذ بشكل أسرع بشكل عام نظرًا لعدم الحاجة إلى إنشاء مجموعة وسيطة. راجع الوثائق لـ reduce و map.

أمثلة

julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

تعتمد تجميعية التقليل على التنفيذ. بالإضافة إلى ذلك، قد تعيد بعض التنفيذات استخدام قيمة الإرجاع لـ f للعناصر التي تظهر عدة مرات في itr. استخدم mapfoldl أو mapfoldr بدلاً من ذلك لضمان التجميعية اليسارية أو اليمنى واستدعاء f لكل قيمة.

mapfoldl(f, op, itr; [init])

مثل mapreduce، ولكن مع ضمان التوافق الأيسر، كما في foldl. إذا تم توفيره، سيتم استخدام الوسيطة الرئيسية init مرة واحدة فقط. بشكل عام، سيكون من الضروري توفير init للعمل مع المجموعات الفارغة.

mapfoldr(f, op, itr; [init])

مثل mapreduce، ولكن مع ضمان التوافق الأيمن، كما في foldr. إذا تم توفيرها، سيتم استخدام الوسيطة الرئيسية init مرة واحدة فقط. بشكل عام، سيكون من الضروري توفير init للعمل مع المجموعات الفارغة.

first(coll)

احصل على العنصر الأول من مجموعة قابلة للتكرار. ارجع نقطة البداية من AbstractRange حتى لو كانت فارغة.

انظر أيضًا: only، firstindex، last.

أمثلة

julia> first(2:2:10)
2

julia> first([1; 2; 3; 4])
1

first(itr, n::Integer)

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

انظر أيضًا: startswith, Iterators.take.

أمثلة

julia> first(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "foo"
 "bar"

julia> first(1:6, 10)
1:6

julia> first(Bool[], 1)
Bool[]

first(s::AbstractString, n::Integer)

احصل على سلسلة تتكون من أول n حرف من s.

أمثلة

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(coll)

احصل على العنصر الأخير من مجموعة مرتبة، إذا كان يمكن حسابه في وقت O(1). يتم ذلك عن طريق استدعاء lastindex للحصول على الفهرس الأخير. ارجع نقطة النهاية من AbstractRange حتى لو كانت فارغة.

انظر أيضًا first، endswith.

أمثلة

julia> last(1:2:10)
9

julia> last([1; 2; 3; 4])
4

last(itr, n::Integer)

احصل على آخر n عناصر من مجموعة itr القابلة للتكرار، أو عدد أقل من العناصر إذا لم تكن itr طويلة بما يكفي.

أمثلة

julia> last(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "bar"
 "qux"

julia> last(1:6, 10)
1:6

julia> last(Float64[], 1)
Float64[]

last(s::AbstractString, n::Integer)

احصل على سلسلة تتكون من آخر n حرف من s.

أمثلة

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

front(x::Tuple)::Tuple

إرجاع Tuple يتكون من جميع مكونات x ما عدا المكون الأخير.

انظر أيضًا: first, tail.

أمثلة

julia> Base.front((1,2,3))
(1, 2)

julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.

tail(x::Tuple)::Tuple

إرجاع Tuple يتكون من جميع المكونات ما عدا المكون الأول من x.

انظر أيضًا: front, rest, first, Iterators.peel.

أمثلة

julia> Base.tail((1,2,3))
(2, 3)

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.

step(r)

احصل على حجم الخطوة لكائن AbstractRange.

أمثلة

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(range(2.5, stop=10.9, length=85))
0.1

جمع(collection)

إرجاع Array من جميع العناصر في مجموعة أو مكرر. بالنسبة للقواميس، يتم إرجاع Vector من key=>value Pairs. إذا كانت الحجة تشبه المصفوفة أو كانت مكرراً مع سمة HasShape، فسيكون للنتيجة نفس الشكل وعدد الأبعاد مثل الحجة.

تستخدم بواسطة التراكيب لتحويل تعبير مولد إلى Array. وبالتالي، على المولدات، يمكن استخدام صيغة الأقواس المربعة بدلاً من استدعاء جمع، انظر المثال الثاني.

أمثلة

جمع العناصر من مجموعة UnitRange{Int64}:

julia> جمع(1:3)
3-element Vector{Int64}:
 1
 2
 3

جمع العناصر من مولد (نفس الناتج مثل [x^2 for x in 1:3]):

julia> جمع(x^2 for x in 1:3)
3-element Vector{Int64}:
 1
 4
 9

جمع(element_type, collection)

إرجاع Array مع نوع العنصر المعطى لجميع العناصر في مجموعة أو قابل للتكرار. النتيجة لها نفس الشكل وعدد الأبعاد مثل collection.

أمثلة

julia> جمع(Float64, 1:2:5)
3-element Vector{Float64}:
 1.0
 3.0
 5.0

filter(f, a)

إرجاع نسخة من المجموعة a، مع إزالة العناصر التي تكون فيها f false. يتم تمرير دالة f حجة واحدة.

انظر أيضًا: filter!, Iterators.filter.

أمثلة

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter(f)

أنشئ دالة تقوم بتصفية وسائطها باستخدام الدالة f باستخدام filter، أي دالة تعادل x -> filter(f, x).

الدالة المعادة هي من النوع Base.Fix1{typeof(filter)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

أمثلة

julia> (1, 2, Inf, 4, NaN, 6) |> filter(isfinite)
(1, 2, 4, 6)

julia> map(filter(iseven), [1:3, 2:4, 3:5])
3-element Vector{Vector{Int64}}:
 [2]
 [2, 4]
 [4]

filter(f, d::AbstractDict)

إرجاع نسخة من d، مع إزالة العناصر التي تكون فيها f false. يتم تمرير الدالة f أزواج key=>value.

أمثلة

julia> d = Dict(1=>"a", 2=>"b")
Dict{Int64, String} with 2 entries:
  2 => "b"
  1 => "a"

julia> filter(p->isodd(p.first), d)
Dict{Int64, String} with 1 entry:
  1 => "a"

filter(f, itr::SkipMissing{<:AbstractArray})

إرجاع متجه مشابه للمصفوفة المغلفة بواسطة المكرر SkipMissing المعطى ولكن مع إزالة جميع العناصر المفقودة وتلك التي تعيد f لها القيمة false.

أمثلة

julia> x = [1 2; missing 4]
2×2 Matrix{Union{Missing, Int64}}:
 1         2
  missing  4

julia> filter(isodd, skipmissing(x))
1-element Vector{Int64}:
 1

filter!(f, a)

قم بتحديث المجموعة a، بإزالة العناصر التي تكون فيها f هي false. يتم تمرير دالة f حجة واحدة.

أمثلة

julia> filter!(isodd, Vector(1:10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter!(f, d::AbstractDict)

قم بتحديث d، مع إزالة العناصر التي تكون فيها f هي false. يتم تمرير الدالة f أزواج key=>value.

أمثلة

julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
Dict{Int64, String} with 3 entries:
  2 => "b"
  3 => "c"
  1 => "a"

julia> filter!(p->isodd(p.first), d)
Dict{Int64, String} with 2 entries:
  3 => "c"
  1 => "a"

استبدل(A, old_new::Pair...; [count::Integer])

إرجاع نسخة من المجموعة A حيث، لكل زوج old=>new في old_new، يتم استبدال جميع حالات old بـ new. يتم تحديد المساواة باستخدام isequal. إذا تم تحديد count، فسيتم الاستبدال في أقصى حد لـ count حالات إجمالاً.

يتم اختيار نوع العنصر في النتيجة باستخدام الترويج (انظر promote_type) بناءً على نوع العنصر في A وأنواع القيم new في الأزواج. إذا تم حذف count وكان نوع العنصر في A هو Union، فلن يتضمن نوع العنصر في النتيجة الأنواع الفردية التي تم استبدالها بقيم من نوع مختلف: على سبيل المثال، Union{T,Missing} ستصبح T إذا تم استبدال missing.

انظر أيضًا replace!، splice!، delete!، insert!.

أمثلة

julia> replace([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Vector{Int64}:
 0
 4
 1
 3

julia> replace([1, missing], missing=>0)
2-element Vector{Int64}:
 1
 0

replace(new::Union{Function, Type}, A; [count::Integer])

ارجع نسخة من A حيث يتم استبدال كل قيمة x في A بـ new(x). إذا تم تحديد count، فاستبدل عند الحد الأقصى count من القيم في المجموع (يتم تعريف الاستبدالات على أنها new(x) !== x).

أمثلة

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} with 2 entries:
  3 => 4
  1 => 3

replace!(A, old_new::Pair...; [count::Integer])

لكل زوج old=>new في old_new، استبدل جميع occurrences لـ old في المجموعة A بـ new. يتم تحديد المساواة باستخدام isequal. إذا تم تحديد count، فاستبدل في أقصى حد count occurrences إجمالاً. انظر أيضًا replace.

أمثلة

julia> replace!([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Vector{Int64}:
 0
 4
 1
 3

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} with 3 elements:
  0
  2
  3

replace!(new::Union{Function, Type}, A; [count::Integer])

استبدل كل عنصر x في المجموعة A بـ new(x). إذا تم تحديد count، فاستبدل عند الحد الأقصى count من القيم في المجموع (حيث يتم تعريف الاستبدالات على أنها new(x) !== x).

أمثلة

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace!(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} with 2 entries:
  3 => 4
  1 => 3

julia> replace!(x->2x, Set([3, 6]))
Set{Int64} with 2 elements:
  6
  12

Base.rest(collection[, itr_state])

دالة عامة لأخذ ذيل collection، بدءًا من حالة تكرار محددة itr_state. تُرجع Tuple، إذا كانت collection نفسها Tuple، أو نوع فرعي من AbstractVector، إذا كانت collection مصفوفة AbstractArray، أو نوع فرعي من AbstractString إذا كانت collection AbstractString، ومكرر عشوائي، مع الرجوع إلى Iterators.rest(collection[, itr_state])، خلاف ذلك.

يمكن تحميلها بشكل زائد لأنواع المجموعات المعرفة من قبل المستخدم لتخصيص سلوك القراءة في التعيينات في الموضع النهائي، مثل a, b... = collection.

انظر أيضًا: first، Iterators.rest، Base.split_rest.

أمثلة

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

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.rest(a, state)
(1, [3, 2, 4])

Base.split_rest(collection, n::Int[, itr_state]) -> (rest_but_n, last_n)

دالة عامة لتقسيم ذيل collection، بدءًا من حالة تكرار محددة itr_state. تُرجع مجموعة من مجموعتين جديدتين. تحتوي المجموعة الأولى على جميع عناصر الذيل باستثناء آخر n منها، والتي تشكل المجموعة الثانية.

عادةً ما يتبع نوع المجموعة الأولى نوع Base.rest، باستثناء أن حالة التراجع ليست كسولة، بل يتم جمعها بشغف في متجه.

يمكن تحميلها بشكل زائد لأنواع المجموعات المعرفة من قبل المستخدم لتخصيص سلوك الابتلاع في التعيينات في الموضع غير النهائي، مثل a, b..., c = collection.

انظر أيضًا: Base.rest.

أمثلة

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

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.split_rest(a, 1, state)
(1, ([3, 2], [4]))

getindex(collection, key...)

استرجع القيمة (القيم) المخزنة عند المفتاح أو الفهرس المعطى داخل مجموعة. يتم تحويل الصيغة a[i,j,...] بواسطة المترجم إلى getindex(a, i, j, ...).

انظر أيضًا get، keys، eachindex.

أمثلة

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> getindex(A, "a")
1

setindex!(collection, value, key...)

قم بتخزين القيمة المعطاة في المفتاح أو الفهرس المعطى داخل مجموعة. يتم تحويل الصيغة a[i,j,...] = x بواسطة المترجم إلى (setindex!(a, x, i, j, ...); x).

أمثلة

julia> a = Dict("a"=>1)
Dict{String, Int64} with 1 entry:
  "a" => 1

julia> setindex!(a, 2, "b")
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

firstindex(collection) -> Integer
firstindex(collection, d) -> Integer

ارجع الفهرس الأول لـ collection. إذا تم إعطاء d، ارجع الفهرس الأول لـ collection على طول البعد d.

تتحول الصيغ A[begin] و A[1, begin] إلى A[firstindex(A)] و A[1, firstindex(A, 2)]، على التوالي.

انظر أيضًا: first, axes, lastindex, nextind.

أمثلة

julia> firstindex([1,2,4])
1

julia> firstindex(rand(3,4,5), 2)
1

lastindex(collection) -> Integer
lastindex(collection, d) -> Integer

إرجاع الفهرس الأخير لـ collection. إذا تم إعطاء d، إرجع الفهرس الأخير لـ collection على طول البعد d.

تتحول الصيغ A[end] و A[end, end] إلى A[lastindex(A)] و A[lastindex(A, 1), lastindex(A, 2)]، على التوالي.

انظر أيضًا: axes, firstindex, eachindex, prevind.

أمثلة

julia> lastindex([1,2,4])
3

julia> lastindex(rand(3,4,5), 2)
4

AbstractDict{K, V}

نوع أعلى لأنواع تشبه القاموس مع مفاتيح من النوع K وقيم من النوع V. Dict و IdDict وأنواع أخرى هي أنواع فرعية من هذا. يجب أن يكون AbstractDict{K, V} مكررًا لـ Pair{K, V}.

Dict([itr])

Dict{K,V}() ينشئ جدول تجزئة بمفاتيح من النوع K وقيم من النوع V. يتم مقارنة المفاتيح باستخدام isequal ويتم تجزئتها باستخدام hash.

عند إعطاء وسيط قابل للتكرار، يتم إنشاء Dict حيث يتم أخذ أزواج المفتاح-القيمة من الأزواج الثنائية (key,value) التي تم إنشاؤها بواسطة الوسيط.

أمثلة

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

بدلاً من ذلك، يمكن تمرير سلسلة من الوسائط الزوجية.

julia> Dict("A"=>1, "B"=>2)
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

!!! تحذير يُسمح للمفاتيح أن تكون قابلة للتغيير، ولكن إذا قمت بتغيير المفاتيح المخزنة، فقد يصبح جدول التجزئة غير متسق داخليًا، وفي هذه الحالة لن يعمل Dict بشكل صحيح. يمكن أن يكون IdDict بديلاً إذا كنت بحاجة إلى تغيير المفاتيح.

IdDict([itr])

IdDict{K,V}() ينشئ جدول تجزئة باستخدام objectid كدالة تجزئة و === كمعيار للمساواة مع مفاتيح من النوع K وقيم من النوع V. انظر إلى Dict لمزيد من المساعدة و IdSet للإصدار الخاص بالمجموعة من هذا.

في المثال أدناه، جميع مفاتيح Dict هي isequal وبالتالي يتم تجزئتها بنفس الطريقة، لذا يتم الكتابة فوقها. يقوم IdDict بالتجزئة حسب معرف الكائن، وبالتالي يحتفظ بالمفاتيح الثلاثة المختلفة.

أمثلة

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

WeakKeyDict() ينشئ جدول تجزئة حيث تكون المفاتيح مراجع ضعيفة للكائنات التي قد يتم جمعها بواسطة جامع القمامة حتى عند الإشارة إليها في جدول التجزئة.

انظر إلى Dict لمزيد من المساعدة. لاحظ، على عكس Dict، أن WeakKeyDict لا يقوم بتحويل المفاتيح عند الإدخال، حيث إن ذلك قد يعني أن كائن المفتاح لم يكن له أي إشارة في أي مكان قبل الإدخال.

انظر أيضًا إلى WeakRef.

ImmutableDict

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

ImmutableDict(KV::Pair)

إنشاء إدخال جديد في ImmutableDict لزوج key => value

• استخدم (key => value) in dict لمعرفة ما إذا كانت هذه التركيبة الخاصة موجودة في مجموعة الخصائص
• استخدم get(dict, key, default) لاسترجاع أحدث قيمة لمفتاح معين

PersistentDict

PersistentDict هو قاموس يتم تنفيذه كـ trie مخصص لمصفوفة هاش، وهو مثالي للحالات التي تحتاج فيها إلى الاستمرارية، حيث تعيد كل عملية قاموسًا جديدًا منفصلًا عن السابق، لكن التنفيذ الأساسي فعال من حيث المساحة وقد يشارك التخزين عبر عدة قواميس منفصلة.

!!! ملاحظة إنه يتصرف مثل IdDict.

PersistentDict(KV::Pair)

أمثلة

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} مع 1 إدخال:
  :a => 1

julia> dict2 = Base.delete(dict, :a)
Base.PersistentDict{Symbol, Int64}()

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} مع 1 إدخال:
  :a => 2

haskey(collection, key) -> Bool

حدد ما إذا كانت المجموعة تحتوي على تعيين لمفتاح معين key.

أمثلة

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

إرجاع القيمة المخزنة للمفتاح المعطى، أو القيمة الافتراضية المعطاة إذا لم يكن هناك تعيين للمفتاح.

أمثلة

julia> d = Dict("a"=>1, "b"=>2);

julia> get(d, "a", 3)
1

julia> get(d, "c", 3)
3

get(f::Union{Function, Type}, collection, key)

إرجاع القيمة المخزنة للمفتاح المعطى، أو إذا لم يكن هناك تعيين للمفتاح، إرجاع f(). استخدم get! لتخزين القيمة الافتراضية أيضًا في القاموس.

هذا من المقرر أن يتم استدعاؤه باستخدام بناء جملة كتلة do

get(dict, key) do
    # القيمة الافتراضية محسوبة هنا
    time()
end

get!(collection, key, default)

إرجاع القيمة المخزنة للمفتاح المعطى، أو إذا لم يكن هناك تعيين للمفتاح، قم بتخزين key => default، وأرجع default.

أمثلة

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

julia> d
Dict{String, Int64} with 4 entries:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

get!(f::Union{Function, Type}, collection, key)

إرجاع القيمة المخزنة للمفتاح المعطى، أو إذا لم يكن هناك تعيين للمفتاح، قم بتخزين key => f()، وأرجع f().

هذا مخصص ليتم استدعاؤه باستخدام بناء جملة كتلة do.

أمثلة

julia> squares = Dict{Int, Int}();

julia> function get_square!(d, i)
           get!(d, i) do
               i^2
           end
       end
get_square! (generic function with 1 method)

julia> get_square!(squares, 2)
4

julia> squares
Dict{Int64, Int64} with 1 entry:
  2 => 4

getkey(collection, key, default)

إرجاع المفتاح الذي يطابق الوسيطة key إذا كان موجودًا في collection، وإلا إرجاع default.

أمثلة

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> getkey(D, 'a', 1)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

delete!(collection, key)

احذف التعيين للمفتاح المعطى في مجموعة، إن وُجد، وأعد المجموعة.

أمثلة

julia> d = Dict("a"=>1, "b"=>2)
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> delete!(d, "b")
Dict{String, Int64} with 1 entry:
  "a" => 1

julia> delete!(d, "b") # d يبقى دون تغيير
Dict{String, Int64} with 1 entry:
  "a" => 1

pop!(collection, key[, default])

احذف وأعد القيمة المرتبطة بـ key إذا كانت موجودة في collection، وإلا أعد default، أو أطلق خطأ إذا لم يتم تحديد default.

أمثلة

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

keys(iterator)

للمكرر أو المجموعة التي تحتوي على مفاتيح وقيم (مثل المصفوفات والقواميس)، ارجع مكررًا على المفاتيح.

values(iterator)

لإرجاع قيم لمؤشر أو مجموعة تحتوي على مفاتيح وقيم، قم بإرجاع مؤشر على القيم. هذه الدالة ببساطة تعيد وسيطها بشكل افتراضي، حيث تعتبر عناصر المؤشر العام عادةً "قيمه".

أمثلة

julia> d = Dict("a"=>1, "b"=>2);

julia> values(d)
ValueIterator for a Dict{String, Int64} with 2 entries. Values:
  2
  1

julia> values([2])
1-element Vector{Int64}:
 2

values(a::AbstractDict)

إرجاع مُكرّر لجميع القيم في مجموعة. collect(values(a)) يُرجع مصفوفة من القيم. عندما يتم تخزين القيم داخليًا في جدول تجزئة، كما هو الحال في Dict، قد يختلف الترتيب الذي يتم إرجاعها به. لكن keys(a) و values(a) و pairs(a) جميعها تتكرر على a وتُرجع العناصر بنفس الترتيب.

أمثلة

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> collect(values(D))
2-element Vector{Int64}:
 2
 3

pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

مكرر يقوم بالوصول إلى كل عنصر من مصفوفة A، عائدًا i => x، حيث i هو الفهرس للعنصر و x = A[i]. مماثل لـ pairs(A)، باستثناء أن نمط الفهرس يمكن اختياره. مشابه أيضًا لـ enumerate(A)، باستثناء أن i سيكون فهرسًا صالحًا لـ A، بينما enumerate دائمًا يعد من 1 بغض النظر عن فهارس A.

تحديد IndexLinear() يضمن أن i سيكون عددًا صحيحًا؛ تحديد IndexCartesian() يضمن أن i سيكون Base.CartesianIndex؛ تحديد IndexStyle(A) يختار أيًا كان قد تم تعريفه كنمط الفهرسة الأصلي للمصفوفة A.

تغيير حدود المصفوفة الأساسية سيؤدي إلى إبطال هذا المكرر.

أمثلة

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in pairs(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in pairs(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex(1, 1) a
CartesianIndex(2, 1) b
CartesianIndex(1, 2) d
CartesianIndex(2, 2) e

انظر أيضًا IndexStyle، axes.

pairs(collection)

إرجاع مُكرّر على أزواج key => value لأي مجموعة تربط مجموعة من المفاتيح بمجموعة من القيم. يشمل ذلك المصفوفات، حيث تكون المفاتيح هي مؤشرات المصفوفة. عندما يتم تخزين الإدخالات داخليًا في جدول تجزئة، كما هو الحال في Dict، قد يختلف الترتيب الذي يتم إرجاعه. لكن keys(a) و values(a) و pairs(a) جميعها تتكرر على a وتعيد العناصر بنفس الترتيب.

أمثلة

julia> a = Dict(zip(["a", "b", "c"], [1, 2, 3]))
Dict{String, Int64} with 3 entries:
  "c" => 3
  "b" => 2
  "a" => 1

julia> pairs(a)
Dict{String, Int64} with 3 entries:
  "c" => 3
  "b" => 2
  "a" => 1

julia> foreach(println, pairs(["a", "b", "c"]))
1 => "a"
2 => "b"
3 => "c"

julia> (;a=1, b=2, c=3) |> pairs |> collect
3-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2
 :c => 3

julia> (;a=1, b=2, c=3) |> collect
3-element Vector{Int64}:
 1
 2
 3

merge(initial::Face, others::Face...)

دمج خصائص وجه initial و others، مع إعطاء الأولوية للوجوه اللاحقة.

دمج(d::AbstractDict، الآخرين::AbstractDict...)

قم بإنشاء مجموعة مدمجة من المجموعات المعطاة. إذا لزم الأمر، سيتم ترقية أنواع المجموعة الناتجة لاستيعاب أنواع المجموعات المدمجة. إذا كان نفس المفتاح موجودًا في مجموعة أخرى، ستكون القيمة لذلك المفتاح هي القيمة التي يحملها في آخر مجموعة مدرجة. انظر أيضًا mergewith لمعالجة مخصصة للقيم ذات المفتاح نفسه.

أمثلة

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String, Float64} with 3 entries:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String, Float64} with 3 entries:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

دمج(a::NamedTuple, bs::NamedTuple...)

قم بإنشاء مجموعة جديدة مسماة عن طريق دمج اثنين أو أكثر من المجموعات الموجودة، بطريقة تزاوجية من اليسار إلى اليمين. يتم الدمج من اليسار إلى اليمين، بين أزواج من المجموعات المسماة، وبالتالي فإن ترتيب الحقول الموجودة في كل من المجموعات المسماة الأكثر يسارًا والأكثر يمينًا تأخذ نفس الموضع كما هو موجود في المجموعة المسماة الأكثر يسارًا. ومع ذلك، يتم أخذ القيم من الحقول المتطابقة في المجموعة المسماة الأكثر يمينًا التي تحتوي على ذلك الحقل. يتم إضافة الحقول الموجودة فقط في المجموعة المسماة الأكثر يمينًا من زوج إلى النهاية. تم تنفيذ احتياطي عندما يتم تزويد مجموعة مسماة واحدة فقط، مع توقيع دمج(a::NamedTuple).

أمثلة

julia> دمج((a=1, b=2, c=3), (b=4, d=5))
(a = 1, b = 4, c = 3, d = 5)

julia> دمج((a=1, b=2), (b=3, c=(d=1,)), (c=(d=2,),))
(a = 1, b = 3, c = (d = 2,))

merge(a::NamedTuple, iterable)

تفسير iterable من أزواج المفتاح-القيمة كـ named tuple، وأداء دمج.

julia> merge((a=1, b=2, c=3), [:b=>4, :d=>5])
(a = 1, b = 4, c = 3, d = 5)

mergewith(combine, d::AbstractDict, others::AbstractDict...)
mergewith(combine)
merge(combine, d::AbstractDict, others::AbstractDict...)

قم بإنشاء مجموعة مدمجة من المجموعات المعطاة. إذا لزم الأمر، سيتم ترقية أنواع المجموعة الناتجة لاستيعاب أنواع المجموعات المدمجة. سيتم دمج القيم ذات المفتاح نفسه باستخدام دالة الدمج. الشكل المخصص mergewith(combine) يعيد الدالة (args...) -> mergewith(combine, args...).

الطريقة merge(combine::Union{Function,Type}, args...) كاسم مستعار لـ mergewith(combine, args...) لا تزال متاحة للتوافق مع الإصدارات السابقة.

أمثلة

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> mergewith(+, a, b)
Dict{String, Float64} with 3 entries:
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

julia> ans == mergewith(+)(a, b)
true

merge!(d::AbstractDict, others::AbstractDict...)

تحديث المجموعة مع الأزواج من المجموعات الأخرى. انظر أيضًا merge.

أمثلة

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> merge!(d1, d2);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 4

mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d

قم بتحديث المجموعة باستخدام الأزواج من المجموعات الأخرى. سيتم دمج القيم ذات المفتاح نفسه باستخدام دالة الدمج. الشكل المخصص mergewith!(combine) يعيد الدالة (args...) -> mergewith!(combine, args...).

طريقة merge!(combine::Union{Function,Type}, args...) كاسم مستعار لـ mergewith!(combine, args...) لا تزال متاحة للتوافق مع الإصدارات السابقة.

أمثلة

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> mergewith!(+, d1, d2);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 6

julia> mergewith!(-, d1, d1);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 0
  3 => 0
  1 => 0

julia> foldl(mergewith!(+), [d1, d2]; init=Dict{Int64, Int64}())
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 0
  1 => 4

sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s

يقترح أن يحتفظ التجميع s بسعة لا تقل عن n عنصر. أي أنه إذا كنت تتوقع أنك ستحتاج إلى دفع الكثير من القيم إلى s، يمكنك تجنب تكلفة إعادة التخصيص التدريجي من خلال القيام بذلك مرة واحدة في البداية؛ يمكن أن يحسن ذلك الأداء.

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

إذا كان shrink=true (الافتراضي)، فقد يتم تقليل سعة التجميع إذا كانت ساعته الحالية أكبر من n.

انظر أيضًا resize!.

ملاحظات حول نموذج الأداء

بالنسبة للأنواع التي تدعم sizehint!،

1. قد تقوم طرق push! و append! عمومًا (لكن ليس من الضروري) بحجز تخزين إضافي مسبقًا. بالنسبة للأنواع المنفذة في Base، فإنها عادةً ما تفعل ذلك، باستخدام خوارزمية محسّنة لحالة استخدام عامة.
2. قد تتحكم sizehint! في هذا الحجز المسبق. مرة أخرى، عادةً ما تفعل ذلك للأنواع في Base.
3. empty! يكاد يكون بلا تكلفة (و O(1)) للأنواع التي تدعم هذا النوع من الحجز المسبق.

keytype(T::Type{<:AbstractArray})
keytype(A::AbstractArray)

ارجع نوع المفتاح لمصفوفة. هذا يساوي eltype لنتيجة keys(...)، ويُقدم بشكل أساسي من أجل التوافق مع واجهة القاموس.

أمثلة

julia> keytype([1, 2, 3]) == Int
true

julia> keytype([1 2; 3 4])
CartesianIndex{2}

keytype(type)

احصل على نوع المفتاح لنوع القاموس. يتصرف بشكل مشابه لـ eltype.

أمثلة

julia> keytype(Dict(Int32(1) => "foo"))
Int32

valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)

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

أمثلة

julia> valtype(["one", "two", "three"])
String

valtype(type)

احصل على نوع القيمة لنوع القاموس. يتصرف بشكل مشابه لـ eltype.

أمثلة

julia> valtype(Dict(Int32(1) => "foo"))
String

AbstractSet{T}

نوع السوبر لمجموعات تشبه المجموعات التي عناصرها من النوع T. Set، BitSet وأنواع أخرى هي أنواع فرعية من هذا.

Set{T} <: AbstractSet{T}

Set هي حاويات قابلة للتغيير توفر اختبار عضوية سريع.

تحتوي Set على تنفيذات فعالة لعمليات المجموعات مثل in و union و intersect. العناصر في Set فريدة، كما تحددها تعريفات العناصر لـ isequal. ترتيب العناصر في Set هو تفصيل تنفيذي ولا يمكن الاعتماد عليه.

انظر أيضًا: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

أمثلة

julia> s = Set("aaBca")
Set{Char} with 3 elements:
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} with 4 elements:
  'a'
  'b'
  'B'
  'c'

julia> s = Set([NaN, 0.0, 1.0, 2.0]);

julia> -0.0 in s # isequal(0.0, -0.0) is false
false

julia> NaN in s # isequal(NaN, NaN) is true
true

BitSet([itr])

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

IdSet{T}([itr])
IdSet()

تقوم IdSet{T}() بإنشاء مجموعة (انظر Set) باستخدام === كمعيار للمساواة مع القيم من النوع T.

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

أمثلة

julia> Set(Any[true, 1, 1.0])
Set{Any} with 1 element:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} with 3 elements:
  1.0
  1
  true

union(s, itrs...)
∪(s, itrs...)

قم بإنشاء كائن يحتوي على جميع العناصر المميزة من جميع المعطيات.

المعطى الأول يتحكم في نوع الحاوية التي يتم إرجاعها. إذا كانت هذه مصفوفة، فإنها تحافظ على الترتيب الذي تظهر به العناصر لأول مرة.

يمكن كتابة الرمز Unicode ∪ عن طريق كتابة \cup ثم الضغط على زر التبويب في REPL الخاص بـ Julia، وفي العديد من المحررات. هذا هو عامل ثنائي، مما يسمح بـ s ∪ itr.

انظر أيضًا unique، intersect، isdisjoint، vcat، Iterators.flatten.

أمثلة

julia> union([1, 2], [3])
3-element Vector{Int64}:
 1
 2
 3

julia> union([4 2 3 4 4], 1:3, 3.0)
4-element Vector{Float64}:
 4.0
 2.0
 3.0
 1.0

julia> (0, 0.0) ∪ (-0.0, NaN)
3-element Vector{Real}:
   0
  -0.0
 NaN

julia> union(Set([1, 2]), 2:3)
Set{Int64} with 3 elements:
  2
  3
  1

union!(s::Union{AbstractSet,AbstractVector}, itrs...)

قم بإنشاء union من المجموعات الممررة واستبدل s بالنتيجة. حافظ على الترتيب مع المصفوفات.

!!! تحذير قد يكون السلوك غير متوقع عندما تشترك أي حجة معدلة في الذاكرة مع أي حجة أخرى.

أمثلة

julia> a = Set([3, 4, 5]);

julia> union!(a, 1:2:7);

julia> a
Set{Int64} with 5 elements:
  5
  4
  7
  3
  1

intersect(s, itrs...)
∩(s, itrs...)

قم بإنشاء المجموعة التي تحتوي على العناصر التي تظهر في جميع الوسائط.

الوسيط الأول يتحكم في نوع الحاوية التي يتم إرجاعها. إذا كانت مصفوفة، فإنها تحافظ على الترتيب الذي تظهر به العناصر لأول مرة.

يمكن كتابة الرمز Unicode ∩ عن طريق كتابة \cap ثم الضغط على زر التبويب في REPL الخاص بـ Julia، وفي العديد من المحررات. هذا هو عامل ثنائي، مما يسمح بـ s ∩ itr.

انظر أيضًا setdiff، isdisjoint، issubset، issetequal.

أمثلة

julia> intersect([1, 2, 3], [3, 4, 5])
1-element Vector{Int64}:
 3

julia> intersect([1, 4, 4, 5, 6], [6, 4, 6, 7, 8])
2-element Vector{Int64}:
 4
 6

julia> intersect(1:16, 7:99)
7:16

julia> (0, 0.0) ∩ (-0.0, 0)
1-element Vector{Real}:
 0

julia> intersect(Set([1, 2]), BitSet([2, 3]), 1.0:10.0)
Set{Float64} with 1 element:
  2.0

setdiff(s, itrs...)

قم بإنشاء مجموعة من العناصر في s ولكن ليست في أي من القوائم القابلة للتكرار في itrs. حافظ على الترتيب مع المصفوفات.

انظر أيضًا setdiff!، union و intersect.

أمثلة

julia> setdiff([1,2,3], [3,4,5])
2-element Vector{Int64}:
 1
 2

setdiff!(s, itrs...)

قم بإزالة من المجموعة s (في المكان) كل عنصر من كل iterable من itrs. حافظ على الترتيب مع المصفوفات.

!!! تحذير يمكن أن يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

أمثلة

julia> a = Set([1, 3, 4, 5]);

julia> setdiff!(a, 1:2:6);

julia> a
Set{Int64} with 1 element:
  4

symdiff(s, itrs...)

قم بإنشاء الفرق المتناظر للعناصر في المجموعات الممررة. عندما لا تكون s مجموعة AbstractSet، يتم الحفاظ على الترتيب.

انظر أيضًا symdiff!، setdiff، union و intersect.

أمثلة

julia> symdiff([1,2,3], [3,4,5], [4,5,6])
3-element Vector{Int64}:
 1
 2
 6

julia> symdiff([1,2,1], [2, 1, 2])
Int64[]

symdiff!(s::Union{AbstractSet,AbstractVector}, itrs...)

قم بإنشاء الفرق المتناظر بين المجموعات الممررة، واستبدل s بالنتيجة. عندما تكون s مصفوفة، يتم الحفاظ على الترتيب. لاحظ أنه في هذه الحالة، تعتبر كثافة العناصر مهمة.

!!! تحذير قد يكون السلوك غير متوقع عندما تشترك أي حجة معدلة في الذاكرة مع أي حجة أخرى.

intersect!(s::Union{AbstractSet,AbstractVector}, itrs...)

قم بتقاطع جميع المجموعات الممررة وكتابة النتيجة في s. حافظ على الترتيب مع المصفوفات.

!!! تحذير قد يكون السلوك غير متوقع عندما تشترك أي حجة معدلة في الذاكرة مع أي حجة أخرى.

issubset(a, b) -> Bool
⊆(a, b) -> Bool
⊇(b, a) -> Bool

حدد ما إذا كان كل عنصر من a موجودًا أيضًا في b، باستخدام in.

انظر أيضًا ⊊، ⊈، ∩، ∪، contains.

أمثلة

julia> issubset([1, 2], [1, 2, 3])
true

julia> [1, 2, 3] ⊆ [1, 2]
false

julia> [1, 2, 3] ⊇ [1, 2]
true

in!(x, s::AbstractSet) -> Bool

إذا كان x في s، ارجع true. إذا لم يكن، أضف x إلى s وارجع false. هذا يعادل in(x, s) ? true : (push!(s, x); false)، ولكن قد يكون له تنفيذ أكثر كفاءة.

انظر أيضًا: in، push!، Set

أمثلة

julia> s = Set{Any}([1, 2, 3]); in!(4, s)
false

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} with 4 elements:
  4
  2
  3
  1

⊈(a, b) -> Bool
⊉(b, a) -> Bool

نفي ⊆ و ⊇، أي يتحقق من أن a ليست مجموعة فرعية من b.

انظر أيضًا issubset (⊆)، ⊊.

أمثلة

julia> (1, 2) ⊈ (2, 3)
true

julia> (1, 2) ⊈ (1, 2, 3)
false

⊊(a, b) -> Bool
⊋(b, a) -> Bool

يحدد ما إذا كان a مجموعة فرعية من b، ولكن ليست متساوية.

انظر أيضًا issubset (⊆)، ⊈.

أمثلة

julia> (1, 2) ⊊ (1, 2, 3)
true

julia> (1, 2) ⊊ (1, 2)
false

issetequal(a, b) -> Bool

حدد ما إذا كانت a و b تحتويان على نفس العناصر. يعادل a ⊆ b && b ⊆ a ولكنه أكثر كفاءة عند الإمكان.

انظر أيضًا: isdisjoint, union.

أمثلة

julia> issetequal([1, 2], [1, 2, 3])
false

julia> issetequal([1, 2], [2, 1])
true

issetequal(x)

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

isdisjoint(a, b) -> Bool

حدد ما إذا كانت المجموعات a و b غير متقاطعة. يعادل isempty(a ∩ b) ولكنه أكثر كفاءة عند الإمكان.

انظر أيضًا: intersect, isempty, issetequal.

أمثلة

julia> isdisjoint([1, 2], [2, 3, 4])
false

julia> isdisjoint([3, 1], [2, 4])
true

isdisjoint(x)

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

push!(collection, items...) -> collection

أدخل عنصرًا أو أكثر من items في collection. إذا كانت collection حاوية مرتبة، يتم إدخال العناصر في النهاية (بالترتيب المعطى).

أمثلة

julia> push!([1, 2, 3], 4, 5, 6)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

إذا كانت collection مرتبة، استخدم append! لإضافة جميع عناصر مجموعة أخرى إليها. نتيجة المثال السابق تعادل append!([1, 2, 3], [4, 5, 6]). بالنسبة لكائنات AbstractSet، يمكن استخدام union! بدلاً من ذلك.

انظر إلى sizehint! لملاحظات حول نموذج الأداء.

انظر أيضًا pushfirst!.

pop!(collection) -> item

قم بإزالة عنصر من collection وأعده. إذا كانت collection حاوية مرتبة، يتم إرجاع العنصر الأخير؛ بالنسبة للحاويات غير المرتبة، يتم إرجاع عنصر عشوائي.

انظر أيضًا: popfirst!، popat!، delete!، deleteat!، splice!، و push!.

أمثلة

julia> A=[1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 1
 2

julia> S = Set([1, 2])
Set{Int64} with 2 elements:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} with 1 element:
  1

julia> pop!(Dict(1=>2))
1 => 2

pop!(collection, key[, default])

احذف وأعد القيمة المرتبطة بـ key إذا كانت موجودة في collection، وإلا أعد default، أو أطلق خطأ إذا لم يتم تحديد default.

أمثلة

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

popat!(a::Vector, i::Integer, [default])

قم بإزالة العنصر عند i المعطاة وأعده. يتم نقل العناصر اللاحقة لملء الفجوة الناتجة. عندما لا يكون i فهرسًا صالحًا لـ a، أعد default، أو ألقِ خطأ إذا لم يتم تحديد default.

انظر أيضًا: pop!, popfirst!, deleteat!, splice!.

أمثلة

julia> a = [4, 3, 2, 1]; popat!(a, 2)
3

julia> a
3-element Vector{Int64}:
 4
 2
 1

julia> popat!(a, 4, missing)
missing

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Vector{Int64} at index [4]
[...]

pushfirst!(collection, items...) -> collection

أدخل عنصرًا أو أكثر items في بداية collection.

تسمى هذه الدالة unshift في العديد من لغات البرمجة الأخرى.

أمثلة

julia> pushfirst!([1, 2, 3, 4], 5, 6)
6-element Vector{Int64}:
 5
 6
 1
 2
 3
 4

popfirst!(collection) -> item

قم بإزالة أول item من collection.

تسمى هذه الدالة shift في العديد من لغات البرمجة الأخرى.

انظر أيضًا: pop!, popat!, delete!.

أمثلة

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

julia> popfirst!(A)
1

julia> A
5-element Vector{Int64}:
 2
 3
 4
 5
 6

insert!(a::Vector, index::Integer, item)

أدخل item في a عند index المعطى. index هو فهرس item في a الناتجة.

انظر أيضًا: push!, replace, popat!, splice!.

أمثلة

julia> insert!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6

deleteat!(a::Vector, i::Integer)

قم بإزالة العنصر في الموضع i المعطى وأعد المصفوفة المعدلة a. يتم نقل العناصر التالية لملء الفجوة الناتجة.

انظر أيضًا: keepat!, delete!, popat!, splice!.

أمثلة

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Vector{Int64}:
 6
 4
 3
 2
 1

deleteat!(a::Vector, inds)

قم بإزالة العناصر عند الفهارس المعطاة بواسطة inds، وأعد a المعدلة. يتم نقل العناصر التالية لملء الفجوة الناتجة.

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

أمثلة

julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

قم بإزالة العناصر في جميع الفهارس التي لم يتم إعطاؤها بواسطة inds، وأعد a المعدلة. العناصر التي تم الاحتفاظ بها يتم نقلها لملء الفجوات الناتجة.

!!! تحذير قد يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل في الذاكرة مع أي وسيط آخر.

يجب أن يكون inds مكررًا من فهارس صحيحة مرتبة وفريدة. انظر أيضًا deleteat!.

!!! توافق "جوليا 1.7" هذه الدالة متاحة اعتبارًا من جوليا 1.7.

أمثلة

julia> keepat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 6
 4
 2

keepat!(a::Vector, m::AbstractVector{Bool})
keepat!(a::BitVector, m::AbstractVector{Bool})

الإصدار في المكان من الفهرسة المنطقية a = a[m]. أي أن keepat!(a, m) على المتجهات ذات الطول المتساوي a و m ستقوم بإزالة جميع العناصر من a التي يكون فيها m عند الفهرس المقابل false.

أمثلة

julia> a = [:a, :b, :c];

julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
 :a
 :c

julia> a
2-element Vector{Symbol}:
 :a
 :c

splice!(a::Vector, index::Integer, [replacement]) -> item

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

انظر أيضًا: replace, delete!, deleteat!, pop!, popat!.

أمثلة

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Vector{Int64}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Vector{Int64}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Vector{Int64}:
 -1
 -2
 -3
  5
  4
  3
 -1

لإدراج replacement قبل فهرس n دون إزالة أي عناصر، استخدم splice!(collection, n:n-1, replacement).

splice!(a::Vector, indices, [replacement]) -> items

قم بإزالة العناصر في الفهارس المحددة، وأعد مجموعة تحتوي على العناصر التي تمت إزالتها. يتم نقل العناصر التالية إلى اليسار لملء الفجوات الناتجة. إذا تم تحديدها، سيتم إدخال قيم الاستبدال من مجموعة مرتبة في مكان العناصر المزالة؛ في هذه الحالة، يجب أن تكون indices عبارة عن AbstractUnitRange.

لإدراج replacement قبل فهرس n دون إزالة أي عناصر، استخدم splice!(collection, n:n-1, replacement).

!!! تحذير قد يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

!!! توافق "جوليا 1.5" قبل جوليا 1.5، يجب أن تكون indices دائمًا عبارة عن UnitRange.

!!! توافق "جوليا 1.8" قبل جوليا 1.8، يجب أن تكون indices عبارة عن UnitRange إذا تم إدخال قيم الاستبدال.

أمثلة

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Vector{Int64}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

resize!(a::Vector, n::Integer) -> Vector

قم بتغيير حجم a ليحتوي على n عنصر. إذا كان n أصغر من طول المجموعة الحالي، سيتم الاحتفاظ بالعناصر الأولى n. إذا كان n أكبر، فإن العناصر الجديدة غير مضمونة أن تكون مهيأة.

أمثلة

julia> resize!([6, 5, 4, 3, 2, 1], 3)
3-element Vector{Int64}:
 6
 5
 4

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

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

append!(collection, collections...) -> collection.

لإضافة عناصر كل collections إلى نهاية حاوية مرتبة collection.

أمثلة

julia> append!([1], [2, 3])
3-element Vector{Int64}:
 1
 2
 3

julia> append!([1, 2, 3], [4, 5], [6])
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

استخدم push! لإضافة عناصر فردية إلى collection التي ليست موجودة بالفعل في مجموعة أخرى. نتيجة المثال السابق تعادل push!([1, 2, 3], 4, 5, 6).

انظر sizehint! لملاحظات حول نموذج الأداء.

انظر أيضًا vcat للمصفوفات، وunion! للمجموعات، وprepend! وpushfirst! للترتيب المعاكس.

prepend!(a::Vector, collections...) -> collection

أدخل عناصر كل collections في بداية a.

عندما تحدد collections مجموعات متعددة، يتم الحفاظ على الترتيب: ستظهر عناصر collections[1] في أقصى اليسار في a، وهكذا.

أمثلة

julia> prepend!([3], [1, 2])
3-element Vector{Int64}:
 1
 2
 3

julia> prepend!([6], [1, 2], [3, 4, 5])
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

Pair(x, y)
x => y

قم بإنشاء كائن Pair من النوع Pair{typeof(x), typeof(y)}. يتم تخزين العناصر في الحقول first و second. يمكن أيضًا الوصول إليها عبر التكرار (لكن يتم التعامل مع Pair كـ "مقياس" واحد لعمليات البث).

انظر أيضًا Dict.

أمثلة

julia> p = "foo" => 7
"foo" => 7

julia> typeof(p)
Pair{String, Int64}

julia> p.first
"foo"

julia> for x in p
           println(x)
       end
foo
7

julia> replace.(["xops", "oxps"], "x" => "o")
2-element Vector{String}:
 "oops"
 "oops"

Base.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}

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