Arrays

AbstractArray{T,N}

نوع أعلى لمصفوفات N-الأبعاد (أو أنواع مشابهة للمصفوفات) مع عناصر من النوع T. Array وأنواع أخرى هي أنواع فرعية من هذا. انظر قسم الدليل حول واجهة AbstractArray.

انظر أيضًا: AbstractVector، AbstractMatrix، eltype، ndims.

AbstractVector{T}

نوع أعلى للمصفوفات أحادية البعد (أو الأنواع الشبيهة بالمصفوفات) مع عناصر من النوع T. اسم مستعار لـ AbstractArray{T,1}.

AbstractMatrix{T}

نوع أعلى للمصفوفات ثنائية الأبعاد (أو الأنواع الشبيهة بالمصفوفات) مع عناصر من النوع T. اسم مستعار لـ AbstractArray{T,2}.

AbstractVecOrMat{T}

نوع الاتحاد لـ AbstractVector{T} و AbstractMatrix{T}.

Array{T,N} <: AbstractArray{T,N}

مصفوفة كثيفة ذات أبعاد N مع عناصر من نوع T.

Array{T}(undef, dims)
Array{T,N}(undef, dims)

قم بإنشاء مصفوفة غير مهيأة من الأبعاد N تحتوي على عناصر من النوع T. يمكن تزويد N بشكل صريح، كما في Array{T,N}(undef, dims)، أو يمكن تحديده بواسطة طول أو عدد dims. قد تكون dims عبارة عن مجموعة أو سلسلة من المعاملات الصحيحة التي تتوافق مع الأطوال في كل بعد. إذا تم تزويد الرتبة N بشكل صريح، فيجب أن تتطابق مع طول أو عدد dims. هنا undef هو UndefInitializer.

أمثلة

julia> A = Array{Float64, 2}(undef, 2, 3) # N معطاة بشكل صريح
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N محددة بواسطة الإدخال
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # استخدم typeof(B)، والحجم المعطى
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0

Array{T}(nothing, dims)
Array{T,N}(nothing, dims)

قم بإنشاء Array بُعد N يحتوي على عناصر من النوع T، مُهيأً بإدخالات nothing. يجب أن يكون نوع العنصر T قادرًا على احتواء هذه القيم، أي Nothing <: T.

أمثلة

julia> Array{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing

julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, Int64}}:
 nothing  nothing  nothing
 nothing  nothing  nothing

Array{T}(missing, dims)
Array{T,N}(missing, dims)

قم بإنشاء Array بُعد N يحتوي على عناصر من النوع T، مُهيأً بإدخالات missing. يجب أن يكون نوع العنصر T قادرًا على احتواء هذه القيم، أي Missing <: T.

أمثلة

julia> Array{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Matrix{Union{Missing, Int64}}:
 missing  missing  missing
 missing  missing  missing

UndefInitializer

نوع مفرد يُستخدم في تهيئة المصفوفات، مما يشير إلى أن مُنشئ المصفوفة يرغب في مصفوفة غير مهيأة. انظر أيضًا undef، وهو مرادف لـ UndefInitializer().

أمثلة

julia> Array{Float64, 1}(UndefInitializer(), 3)
3-element Array{Float64, 1}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314

undef

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

انظر أيضًا: missing، similar.

أمثلة

julia> Array{Float64, 1}(undef, 3)
3-element Vector{Float64}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314

Vector{T} <: AbstractVector{T}

مصفوفة كثيفة أحادية البعد تحتوي على عناصر من النوع T، وغالبًا ما تستخدم لتمثيل متجه رياضي. مرادف لـ Array{T,1}.

انظر أيضًا إلى empty و similar و zero لإنشاء المتجهات.

Vector{T}(undef, n)

قم بإنشاء Vector{T} غير مُهيأ بطول n.

أمثلة

julia> Vector{Float64}(undef, 3)
3-element Array{Float64, 1}:
 6.90966e-310
 6.90966e-310
 6.90966e-310

Vector{T}(nothing, m)

قم بإنشاء Vector{T} بطول m، مُهيأً بإدخالات nothing. يجب أن يكون نوع العنصر T قادرًا على احتواء هذه القيم، أي Nothing <: T.

أمثلة

julia> Vector{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing

Vector{T}(missing, m)

قم بإنشاء Vector{T} بطول m، مُهيأً بإدخالات missing. يجب أن يكون نوع العنصر T قادرًا على احتواء هذه القيم، أي Missing <: T.

أمثلة

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing

Matrix{T} <: AbstractMatrix{T}

مصفوفة ثنائية الأبعاد كثيفة تحتوي على عناصر من النوع T، وغالبًا ما تستخدم لتمثيل مصفوفة رياضية. اسم مستعار لـ Array{T,2}.

انظر أيضًا إلى fill، zeros، undef و similar لإنشاء المصفوفات.

Matrix{T}(undef, m, n)

إنشاء مصفوفة غير مهيأة Matrix{T} بحجم m×n.

أمثلة

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64, 2}:
 2.36365e-314  2.28473e-314    5.0e-324
 2.26704e-314  2.26711e-314  NaN

julia> similar(ans, Int32, 2, 2)
2×2 Matrix{Int32}:
 490537216  1277177453
         1  1936748399

Matrix{T}(nothing, m, n)

قم بإنشاء Matrix{T} بحجم m×n، مُهيأً بقيم nothing. يجب أن يكون نوع العنصر T قادرًا على احتواء هذه القيم، أي Nothing <: T.

أمثلة

julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, String}}:
 nothing  nothing  nothing
 nothing  nothing  nothing

Matrix{T}(missing, m, n)

قم بإنشاء Matrix{T} بحجم m×n، مُهيأً بقيم missing. يجب أن يكون نوع العنصر T قادرًا على احتواء هذه القيم، أي Missing <: T.

أمثلة

julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2×3 Matrix{Union{Missing, String}}:
 missing  missing  missing
 missing  missing  missing

VecOrMat{T}

نوع اتحاد بين Vector{T} و Matrix{T} الذي يسمح للدوال بقبول إما مصفوفة أو متجه.

أمثلة

julia> Vector{Float64} <: VecOrMat{Float64}
true

julia> Matrix{Float64} <: VecOrMat{Float64}
true

julia> Array{Float64, 3} <: VecOrMat{Float64}
false

DenseArray{T, N} <: AbstractArray{T,N}

مصفوفة كثيفة ذات N أبعاد مع عناصر من النوع T. يتم تخزين عناصر المصفوفة الكثيفة بشكل متجاور في الذاكرة.

DenseVector{T}

مصفوفة كثيفة أحادية البعد DenseArray مع عناصر من النوع T. اسم مستعار لـ DenseArray{T,1}.

DenseMatrix{T}

مصفوفة ثنائية الأبعاد DenseArray مع عناصر من النوع T. اسم مستعار لـ DenseArray{T,2}.

DenseVecOrMat{T}

نوع اتحاد لـ DenseVector{T} و DenseMatrix{T}.

StridedArray{T, N}

مجموعة ثابتة من Union لأنواع المصفوفات الشائعة التي تتبع واجهة المصفوفات المتدرجة، مع عناصر من النوع T وأبعاد N.

إذا كانت A عبارة عن StridedArray، فإن عناصرها تُخزن في الذاكرة مع إزاحات، قد تختلف بين الأبعاد ولكنها ثابتة ضمن بعد واحد. على سبيل المثال، يمكن أن تحتوي A على إزاحة 2 في البعد 1، وإزاحة 3 في البعد 2. زيادة A على طول البعد d تقفز في الذاكرة بمقدار [stride(A, d)] من الفتحات. تعتبر المصفوفات المتدرجة مهمة ومفيدة بشكل خاص لأنها يمكن أحيانًا تمريرها مباشرة كأصابع إلى مكتبات اللغات الأجنبية مثل BLAS.

StridedVector{T}

مصفوفة أحادية البعد StridedArray مع عناصر من النوع T.

StridedMatrix{T}

مصفوفة ثنائية الأبعاد StridedArray مع عناصر من النوع T.

StridedVecOrMat{T}

نوع اتحاد لـ StridedVector و StridedMatrix مع عناصر من النوع T.

GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: DenseVector{T}

حجم ثابت DenseVector{T}.

يمكن أن يكون kind حاليًا إما :not_atomic أو :atomic. لمزيد من التفاصيل حول ما يعنيه :atomic، انظر AtomicMemory

يمكن تعيين addrspace حاليًا فقط إلى Core.CPU. تم تصميمه للسماح بالتمديد بواسطة أنظمة أخرى مثل وحدات معالجة الرسوميات (GPUs)، التي قد تعرف قيمًا مثل:

module CUDA
const Generic = bitcast(Core.AddrSpace{CUDA}, 0)
const Global = bitcast(Core.AddrSpace{CUDA}, 1)
end

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

Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}

حجم ثابت DenseVector{T}.

`memoryref(::GenericMemory)`

قم بإنشاء GenericMemoryRef من كائن الذاكرة. هذا لا يفشل، ولكن الذاكرة الناتجة ستشير إلى خارج الحدود إذا وفقط إذا كانت الذاكرة فارغة.

memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)

قم بإنشاء GenericMemoryRef من كائن ذاكرة ومؤشر إزاحة (1-based) يمكن أن يكون سالبًا أيضًا. هذا دائمًا ما يُرجع كائنًا ضمن الحدود، وسيرمي خطأ إذا لم يكن ذلك ممكنًا (لأن المؤشر سيؤدي إلى إزاحة خارج حدود الذاكرة الأساسية).

Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}

مصفوفة AbstractArray من الشرائح في مصفوفة الوالد عبر الأبعاد المحددة، مع إرجاع وجهات نظر تحدد جميع البيانات من الأبعاد الأخرى.

يجب عادةً إنشاء هذه باستخدام eachslice، eachcol أو eachrow.

parent(s::Slices) ستعيد مصفوفة الوالد.

RowSlices{M,AX,S}

حالة خاصة من Slices التي هي متجه من شرائح الصفوف لمصفوفة، كما تم إنشاؤه بواسطة eachrow.

يمكن استخدام parent للحصول على المصفوفة الأساسية.

ColumnSlices{M,AX,S}

حالة خاصة من Slices التي هي متجه من شرائح الأعمدة لمصفوفة، كما تم إنشاؤه بواسطة eachcol.

يمكن استخدام parent للحصول على المصفوفة الأساسية.

getindex(type[, elements...])

قم بإنشاء مصفوفة أحادية البعد من النوع المحدد. عادةً ما يتم استدعاؤها باستخدام بناء الجملة Type[]. يمكن تحديد قيم العناصر باستخدام Type[a,b,c,...].

أمثلة

julia> Int8[1, 2, 3]
3-element Vector{Int8}:
 1
 2
 3

julia> getindex(Int8, 1, 2, 3)
3-element Vector{Int8}:
 1
 2
 3

zeros([T=Float64,] dims::Tuple)
zeros([T=Float64,] dims...)

أنشئ Array، مع نوع العنصر T، من جميع الأصفار بالحجم المحدد بواسطة dims. انظر أيضًا fill، ones، zero.

أمثلة

julia> zeros(1)
1-element Vector{Float64}:
 0.0

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
 0  0  0
 0  0  0

ones([T=Float64,] dims::Tuple)
ones([T=Float64,] dims...)

قم بإنشاء Array، مع نوع العنصر T، من جميع الواحدات بالحجم المحدد بواسطة dims. انظر أيضًا fill، zeros.

أمثلة

julia> ones(1,2)
1×2 Matrix{Float64}:
 1.0  1.0

julia> ones(ComplexF64, 2, 3)
2×3 Matrix{ComplexF64}:
 1.0+0.0im  1.0+0.0im  1.0+0.0im
 1.0+0.0im  1.0+0.0im  1.0+0.0im

BitArray{N} <: AbstractArray{Bool, N}

مصفوفة بوليانية ذات أبعاد N بكفاءة مساحة، تستخدم بت واحد فقط لكل قيمة بوليانية.

تجمع BitArrays حتى 64 قيمة في كل 8 بايت، مما يؤدي إلى كفاءة مساحة تبلغ 8 مرات مقارنة بـ Array{Bool, N} ويسمح لبعض العمليات بالعمل على 64 قيمة في وقت واحد.

بشكل افتراضي، تعيد جوليا BitArrays من عمليات البث التي تولد عناصر بوليانية (بما في ذلك المقارنات المنقطة مثل .==) وكذلك من الدوال trues و falses.

!!! ملاحظة بسبب تنسيق التخزين المضغوط، فإن الوصول المتزامن إلى عناصر BitArray حيث يكون على الأقل واحد منها كتابة ليس آمناً من حيث الخيوط.

BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})

قم بإنشاء BitArray غير محدد بالأبعاد المعطاة. يتصرف بشكل مماثل لمُنشئ Array. انظر undef.

أمثلة

julia> BitArray(undef, 2, 2)
2×2 BitMatrix:
 0  0
 0  0

julia> BitArray(undef, (3, 1))
3×1 BitMatrix:
 0
 0
 0

BitArray(itr)

قم بإنشاء BitArray تم إنشاؤه بواسطة كائن قابل للتكرار المعطى. يتم استنتاج الشكل من كائن itr.

أمثلة

julia> BitArray([1 0; 0 1])
2×2 BitMatrix:
 1  0
 0  1

julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
2×3 BitMatrix:
 0  1  0
 1  0  0

julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
6-element BitVector:
 0
 1
 0
 1
 0
 0

trues(dims)

أنشئ BitArray مع تعيين جميع القيم إلى true.

أمثلة

julia> trues(2,3)
2×3 BitMatrix:
 1  1  1
 1  1  1

falses(dims)

إنشاء BitArray مع تعيين جميع القيم إلى false.

أمثلة

julia> falses(2,3)
2×3 BitMatrix:
 0  0  0
 0  0  0

fill(value, dims::Tuple)
fill(value, dims...)

أنشئ مصفوفة بحجم dims مع تعيين كل موقع إلى value.

على سبيل المثال، fill(1.0, (5,5)) تُرجع مصفوفة 5×5 من الأعداد العشرية، مع 1.0 في كل موقع من المصفوفة.

يمكن تحديد أطوال الأبعاد dims كإما مجموعة أو تسلسل من المعاملات. تُحدد مجموعة بطول N أو N معاملات تلي value مصفوفة بأبعاد N. وبالتالي، فإن تعبير شائع لإنشاء مصفوفة بعدد أبعاد صفرية مع تعيين موقعها الوحيد إلى x هو fill(x).

يتم تعيين كل موقع من المصفوفة المُرجعة إلى (وبالتالي هو ===) value الذي تم تمريره؛ وهذا يعني أنه إذا تم تعديل value نفسه، فإن جميع عناصر المصفوفة المُملوءة ستعكس هذا التعديل لأنها لا تزال تلك value بالذات. هذا ليس مصدر قلق مع fill(1.0, (5,5)) حيث أن value 1.0 غير قابلة للتعديل ولا يمكن تعديلها، ولكن يمكن أن يكون غير متوقع مع القيم القابلة للتعديل مثل - الأكثر شيوعًا - المصفوفات. على سبيل المثال، fill([], 3) يضع نفس المصفوفة الفارغة في جميع المواقع الثلاثة من المتجه المُرجع:

julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v[1] === v[2] === v[3]
true

julia> value = v[1]
Any[]

julia> push!(value, 867_5309)
1-element Vector{Any}:
 8675309

julia> v
3-element Vector{Vector{Any}}:
 [8675309]
 [8675309]
 [8675309]

لإنشاء مصفوفة من العديد من المصفوفات الداخلية المستقلة، استخدم comprehension بدلاً من ذلك. هذا ينشئ مصفوفة جديدة ومتميزة في كل تكرار من الحلقة:

julia> v2 = [[] for _ in 1:3]
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v2[1] === v2[2] === v2[3]
false

julia> push!(v2[1], 8675309)
1-element Vector{Any}:
 8675309

julia> v2
3-element Vector{Vector{Any}}:
 [8675309]
 []
 []

انظر أيضًا: fill!, zeros, ones, similar.

أمثلة

julia> fill(1.0, (2,3))
2×3 Matrix{Float64}:
 1.0  1.0  1.0
 1.0  1.0  1.0

julia> fill(42)
0-dimensional Array{Int64, 0}:
42

julia> A = fill(zeros(2), 2) # يعيّن كلا العنصرين إلى نفس المتجه [0.0, 0.0]
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # يعدل القيمة المملوءة لتكون [42.0, 0.0]

julia> A # كلا من A[1] و A[2] هما نفس المتجه بالضبط
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

املأ المصفوفة `A` بالقيمة `x`. إذا كانت `x` مرجع كائن، فستشير جميع العناصر إلى نفس الكائن. `fill!(A, Foo())` ستعيد `A` مملوءة بنتيجة تقييم `Foo()` مرة واحدة.

# أمثلة

jldoctest julia> A = zeros(2,3) 2×3 Matrix{Float64}: 0.0 0.0 0.0 0.0 0.0 0.0

julia> fill!(A, 2.) 2×3 Matrix{Float64}: 2.0 2.0 2.0 2.0 2.0 2.0

julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A 3-element Vector{Vector{Int64}}: [2, 1, 1] [2, 1, 1] [2, 1, 1]

julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f()) 3-element Vector{Int64}: 1 1 1 ```

empty(x::Tuple)

إرجاع مجموعة فارغة، ().

empty(v::AbstractVector, [eltype])

إنشاء متجه فارغ مشابه لـ v، مع إمكانية تغيير eltype.

انظر أيضًا: empty!، isempty، isassigned.

أمثلة

julia> empty([1.0, 2.0, 3.0])
Float64[]

julia> empty([1.0, 2.0, 3.0], String)
String[]

empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])

إنشاء حاوية AbstractDict فارغة يمكنها قبول الفهارس من نوع index_type والقيم من نوع value_type. الحجة الثانية والثالثة اختيارية وتفترض القيم الافتراضية لنوع keytype و valtype للإدخال، على التوالي. (إذا تم تحديد نوع واحد فقط من النوعين، يُفترض أنه value_type، ونعود إلى index_type كـ keytype(a)).

يمكن أن تختار الأنواع الفرعية المخصصة لـ AbstractDict أي نوع قاموس محدد هو الأنسب للإرجاع لأنواع الفهارس والقيم المعطاة، من خلال التخصص في توقيع الثلاثة معطيات. الافتراضي هو إرجاع Dict فارغ.

similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

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

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

similar(array, [element_type=eltype(array)], [dims=size(array)])

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

يمكن أن تختار الأنواع الفرعية المخصصة لـ AbstractArray أي نوع مصفوفة محدد هو الأنسب للإرجاع لنوع العنصر والأبعاد المعطاة. إذا لم تخصص هذه الطريقة، فإن الافتراضي هو Array{element_type}(undef, dims...).

على سبيل المثال، similar(1:10, 1, 4) تُرجع مصفوفة غير مهيأة من نوع Array{Int,2} حيث أن النطاقات ليست قابلة للتعديل ولا تدعم الأبعاد الثنائية:

julia> similar(1:10, 1, 4)
1×4 Matrix{Int64}:
 4419743872  4374413872  4419743888  0

على العكس، similar(trues(10,10), 2) تُرجع مصفوفة غير مهيأة من نوع BitVector مع عنصرين حيث أن BitArrays قابلة للتعديل ويمكن أن تدعم المصفوفات أحادية البعد:

julia> similar(trues(10,10), 2)
2-element BitVector:
 0
 0

ومع ذلك، حيث أن BitArrays يمكنها تخزين عناصر من نوع Bool فقط، إذا طلبت نوع عنصر مختلف، فسيتم إنشاء Array عادية بدلاً من ذلك:

julia> similar(falses(10), Float64, 2, 4)
2×4 Matrix{Float64}:
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314

انظر أيضًا: undef، isassigned.

similar(storagetype, axes)

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

أمثلة:

similar(Array{Int}, axes(A))

تنشئ مصفوفة "تتصرف مثل" Array{Int} (وقد تكون مدعومة بالفعل بواحدة)، ولكن يتم فهرستها بشكل مطابق لـ A. إذا كانت A تحتوي على فهرسة تقليدية، فسيكون هذا مطابقًا لـ Array{Int}(undef, size(A))، ولكن إذا كانت A تحتوي على فهرسة غير تقليدية، فستتطابق مؤشرات النتيجة مع A.

similar(BitArray, (axes(A, 2),))

ستنشئ مصفوفة منطقية أحادية البعد تتطابق مؤشراتُها مع مؤشرات أعمدة A.

ndims(A::AbstractArray) -> Integer

إرجاع عدد أبعاد A.

انظر أيضًا: size, axes.

أمثلة

julia> A = fill(1, (3,4,5));

julia> ndims(A)
3

size(A::AbstractArray, [dim])

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

لاحظ أن size قد لا يتم تعريفه للمصفوفات ذات الفهارس غير القياسية، وفي هذه الحالة قد تكون axes مفيدة. انظر الفصل في الدليل حول المصفوفات ذات الفهارس المخصصة.

انظر أيضاً: length, ndims, eachindex, sizeof.

أمثلة

julia> A = fill(1, (2,3,4));

julia> size(A)
(2, 3, 4)

julia> size(A, 2)
3

axes(A)

ارجع إلى مجموعة من الفهارس الصالحة للمصفوفة A.

انظر أيضًا: size, keys, eachindex.

أمثلة

julia> A = fill(1, (5,6,7));

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))

axes(A, d)

إرجاع النطاق الصالح من الفهارس للمصفوفة A على طول البعد d.

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

أمثلة

julia> A = fill(1, (5,6,7));

julia> axes(A, 2)
Base.OneTo(6)

julia> axes(A, 4) == 1:1  # جميع الأبعاد d > ndims(A) لها حجم 1
true

ملاحظة استخدام

يجب أن يكون كل من الفهارس AbstractUnitRange{<:Integer}، ولكن في نفس الوقت يمكن أن يكون نوعًا يستخدم فهارس مخصصة. لذا، على سبيل المثال، إذا كنت بحاجة إلى مجموعة فرعية، استخدم تراكيب الفهرسة العامة مثل begin/end أو firstindex/lastindex:

ix = axes(v, 1)
ix[2:end]          # سيعمل على سبيل المثال مع Vector، ولكن قد يفشل بشكل عام
ix[(begin+1):end]  # يعمل مع الفهارس العامة

length(A::AbstractArray)

إرجاع عدد العناصر في المصفوفة، الافتراضي هو prod(size(A)).

أمثلة

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

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

keys(a::AbstractArray)

إرجاع مصفوفة فعالة تصف جميع الفهارس الصالحة لـ a مرتبة في شكل a نفسه.

مفاتيح المصفوفات أحادية البعد (المتجهات) هي أعداد صحيحة، بينما تستخدم جميع المصفوفات N-dimensional الأخرى CartesianIndex لوصف مواقعها. غالبًا ما تُستخدم أنواع المصفوفات الخاصة LinearIndices و CartesianIndices لتمثيل هذه المصفوفات من الأعداد الصحيحة و CartesianIndex بشكل فعال، على التوالي.

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

أمثلة

julia> keys([4, 5, 6])
3-element LinearIndices{1, Tuple{Base.OneTo{Int64}}}:
 1
 2
 3

julia> keys([4 5; 6 7])
CartesianIndices((2, 2))

eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)

أنشئ كائنًا قابلًا للتكرار لزيارة كل فهرس من AbstractArray A بطريقة فعالة. بالنسبة لأنواع المصفوفات التي اختارت استخدام الفهرسة الخطية السريعة (مثل Array)، فإن هذا ببساطة هو النطاق 1:length(A) إذا كانت تستخدم الفهرسة القائمة على 1. بالنسبة لأنواع المصفوفات التي لم تختار استخدام الفهرسة الخطية السريعة، يتم عادةً إرجاع نطاق كارتيسي متخصص لتسهيل الفهرسة في المصفوفة باستخدام الفهارس المحددة لكل بعد.

بشكل عام، يقبل eachindex أي تكرارات، بما في ذلك السلاسل والقواميس، ويعيد كائنًا تكراريًا يدعم أنواع الفهارس العشوائية (مثل الفهارس غير المتساوية أو غير الصحيحة).

إذا كانت A هي AbstractArray، فمن الممكن تحديد نمط الفهارس التي يجب إرجاعها بواسطة eachindex بشكل صريح عن طريق تمرير قيمة من نوع IndexStyle كأول وسيط (عادةً IndexLinear() إذا كانت الفهارس الخطية مطلوبة أو IndexCartesian() إذا كان النطاق الكارتيسي مطلوبًا).

إذا قمت بتزويد أكثر من وسيط AbstractArray، سيقوم eachindex بإنشاء كائن قابل للتكرار يكون سريعًا لجميع الوسائط (عادةً UnitRange إذا كانت جميع المدخلات تحتوي على فهرسة خطية سريعة، و CartesianIndices خلاف ذلك). إذا كانت المصفوفات ذات أحجام و/أو أبعاد مختلفة، سيتم طرح استثناء DimensionMismatch.

انظر أيضًا pairs(A) للتكرار على الفهارس والقيم معًا، و axes(A, 2) للحصول على فهارس صالحة على طول بعد واحد.

أمثلة

julia> A = [10 20; 30 40];

julia> for i in eachindex(A) # الفهرسة الخطية
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

julia> for i in eachindex(view(A, 1:2, 1:1)) # الفهرسة الكارتيسية
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle يحدد "نمط الفهرسة الأصلي" للمصفوفة A. عند تعريف نوع جديد من AbstractArray، يمكنك اختيار تنفيذ إما الفهرسة الخطية (مع IndexLinear) أو الفهرسة الكارتيزية. إذا قررت تنفيذ الفهرسة الخطية فقط، فيجب عليك تعيين هذه السمة لنوع المصفوفة الخاص بك:

Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()

الإعداد الافتراضي هو IndexCartesian().

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

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

IndexLinear()

نوع من IndexStyle يُستخدم لوصف المصفوفات التي يتم فهرستها بشكل مثالي بواسطة فهرس خطي واحد.

تستخدم أسلوب الفهرسة الخطية فهرسًا صحيحًا واحدًا لوصف الموضع في المصفوفة (حتى لو كانت مصفوفة متعددة الأبعاد) ويتم استخدام ترتيب الأعمدة للوصول بكفاءة إلى العناصر. هذا يعني أنه عند طلب eachindex من مصفوفة هي IndexLinear، ستعيد نطاقًا بسيطًا أحادي الأبعاد، حتى لو كانت متعددة الأبعاد.

تحتاج مصفوفة مخصصة تُبلغ عن IndexStyle الخاص بها كـ IndexLinear فقط إلى تنفيذ الفهرسة (وتعيين الفهرس) باستخدام فهرس Int واحد؛ سيتم إعادة حساب جميع تعبيرات الفهرسة الأخرى - بما في ذلك الوصولات متعددة الأبعاد - إلى الفهرس الخطي. على سبيل المثال، إذا كانت A مصفوفة مخصصة بحجم 2×3 مع فهرسة خطية، وعند الإشارة إلى A[1, 3]، سيتم إعادة حساب ذلك إلى الفهرس الخطي المعادل واستدعاء A[5] حيث أن 1 + 2*(3 - 1) = 5.

انظر أيضًا IndexCartesian.

IndexCartesian()

نوع فرعي من IndexStyle يُستخدم لوصف المصفوفات التي يتم فهرستها بشكل مثالي بواسطة فهرس كارتيسي. هذا هو الافتراضي لأنواع AbstractArray الفرعية المخصصة الجديدة.

تستخدم أسلوب الفهرسة الكارتيسية مؤشرات صحيحة متعددة لوصف الموقع في مصفوفة متعددة الأبعاد، مع وجود مؤشر واحد بالضبط لكل بعد. هذا يعني أن طلب eachindex من مصفوفة تكون IndexCartesian سيعيد نطاقًا من CartesianIndices.

تحتاج مصفوفة مخصصة بُعدها N والتي تُبلغ عن IndexStyle الخاص بها كـ IndexCartesian إلى تنفيذ الفهرسة (وتعيين الفهرس) باستخدام بالضبط N مؤشرات Int؛ سيتم إعادة حساب جميع تعبيرات الفهرسة الأخرى - بما في ذلك الفهرسة الخطية - إلى الموقع الكارتيسي المعادل. على سبيل المثال، إذا كانت A مصفوفة مخصصة بحجم 2×3 مع فهرسة كارتيسية، وعندما نشير إلى A[5]، سيتم إعادة حساب ذلك إلى الفهرس الكارتيسي المعادل واستدعاء A[1, 3] حيث أن 5 = 1 + 2*(3 - 1).

إن حساب المؤشرات الكارتيسية من فهرس خطي أكثر تكلفة بكثير من الذهاب في الاتجاه الآخر. تتطلب العملية الأولى القسمة - وهي عملية مكلفة جدًا - بينما تستخدم الأخيرة فقط الضرب والجمع وتكون مجانية بشكل أساسي. تعني هذه اللامتناظرة أنه من الأكثر تكلفة بكثير استخدام الفهرسة الخطية مع مصفوفة IndexCartesian مقارنة باستخدام الفهرسة الكارتيسية مع مصفوفة IndexLinear.

انظر أيضًا IndexLinear.

conj!(A)

تحويل مصفوفة إلى نظيرها المركب في المكان.

انظر أيضًا conj.

أمثلة

julia> A = [1+im 2-im; 2+2im 3+im]
2×2 Matrix{Complex{Int64}}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Matrix{Complex{Int64}}:
 1-1im  2+1im
 2-2im  3-1im

stride(A, k::Integer)

إرجاع المسافة في الذاكرة (بعدد العناصر) بين العناصر المتجاورة في البعد k.

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

أمثلة

julia> A = fill(1, (3,4,5));

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

إرجاع مجموعة من خطوات الذاكرة في كل بعد.

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

أمثلة

julia> A = fill(1, (3,4,5));

julia> strides(A)
(1, 3, 12)

broadcast(f, As...)

بث الدالة f على المصفوفات، والصفوف، والمجموعات، وRefs و/أو القيم العددية As.

يتم تطبيق البث على الدالة f على عناصر وسائط الحاوية والقيم العددية نفسها في As. يتم توسيع الأبعاد الفردية والمفقودة لتتناسب مع امتدادات الوسائط الأخرى من خلال تكرار القيمة بشكل افتراضي. بشكل افتراضي، يتم اعتبار عدد محدود فقط من الأنواع كقيم عددية، بما في ذلك Numbers، Strings، Symbols، Types، Functions وبعض العناصر الفردية الشائعة مثل missing وnothing. يتم تكرار جميع الوسائط الأخرى أو فهرستها بشكل عنصر بعنصر.

يتم تحديد نوع الحاوية الناتجة وفقًا للقواعد التالية:

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

يوجد بناء جملة خاص للبث: f.(args...) يعادل broadcast(f, args...)، ويتم دمج استدعاءات f.(g.(args...)) المتداخلة في حلقة بث واحدة.

أمثلة

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

julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
5×2 Matrix{Int64}:
 1   2
 3   4
 5   6
 7   8
 9  10

julia> broadcast(+, A, B)
5×2 Matrix{Int64}:
  2   3
  5   6
  8   9
 11  12
 14  15

julia> parse.(Int, ["1", "2"])
2-element Vector{Int64}:
 1
 2

julia> abs.((1, -2))
(1, 2)

julia> broadcast(+, 1.0, (0, -2.0))
(1.0, -1.0)

julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
2-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Vector{String}:
 "one: 1"
 "two: 2"
 "three: 3"
 "four: 4"

broadcast!(f, dest, As...)

مثل broadcast، ولكن قم بتخزين نتيجة broadcast(f, As...) في مصفوفة dest. لاحظ أن dest تُستخدم فقط لتخزين النتيجة، ولا تزود f بالمعاملات ما لم تكن مدرجة أيضًا في As، كما في broadcast!(f, A, A, B) لتنفيذ A[:] = broadcast(f, A, B).

أمثلة

julia> A = [1.0; 0.0]; B = [0.0; 0.0];

julia> broadcast!(+, B, A, (0, -2.0));

julia> B
2-element Vector{Float64}:
  1.0
 -2.0

julia> A
2-element Vector{Float64}:
 1.0
 0.0

julia> broadcast!(+, A, A, (0, -2.0));

julia> A
2-element Vector{Float64}:
  1.0
 -2.0

@. expr

قم بتحويل كل استدعاء دالة أو عامل في expr إلى "استدعاء نقطة" (على سبيل المثال، تحويل f(x) إلى f.(x))، وتحويل كل تعيين في expr إلى "تعيين نقطة" (على سبيل المثال، تحويل += إلى .+=).

إذا كنت تريد تجنب إضافة النقاط لاستدعاءات دالة محددة في expr، قم بإدخال تلك الاستدعاءات مع $. على سبيل المثال، @. sqrt(abs($sort(x))) تعادل sqrt.(abs.(sort(x))) (لا نقطة لـ sort).

(@. تعادل استدعاء لـ @__dot__.)

أمثلة

julia> x = 1.0:3.0; y = similar(x);

julia> @. y = x + 3 * sin(x)
3-element Vector{Float64}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

BroadcastStyle هو نوع مجرد ودالة سمة تُستخدم لتحديد سلوك الكائنات تحت البث. BroadcastStyle(typeof(x)) يُرجع النمط المرتبط بـ x. لتخصيص سلوك البث لنوع ما، يمكن للمرء إعلان نمط عن طريق تعريف زوج نوع/طريقة

struct MyContainerStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

ثم يكتب المرء طريقة (طرق) (على الأقل similar) تعمل على Broadcasted{MyContainerStyle}. هناك أيضًا عدة أنواع فرعية معرفة مسبقًا من BroadcastStyle التي قد تتمكن من الاستفادة منها؛ انظر فصل الواجهات لمزيد من المعلومات.

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle هو السوبرتايب المجرد لأي نمط مرتبط بنوع AbstractArray. معلمة N هي الأبعاد، والتي يمكن أن تكون مفيدة لأنواع AbstractArray التي تدعم فقط أبعادًا محددة:

struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()

بالنسبة لأنواع AbstractArray التي تدعم الأبعاد التعسفية، يمكن تعيين N إلى Any:

struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

في الحالات التي تريد فيها أن تكون قادرًا على مزج أنماط AbstractArrayStyle متعددة وتتبع الأبعاد، يحتاج نمطك إلى دعم مُنشئ Val:

struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end
(::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()

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

انظر أيضًا Broadcast.DefaultArrayStyle.

Broadcast.ArrayStyle{MyArrayType}() هو BroadcastStyle يشير إلى أن الكائن يتصرف كصفيف للبث. إنه يقدم طريقة بسيطة لبناء Broadcast.AbstractArrayStyles لأنواع حاويات AbstractArray محددة. أنماط البث التي تم إنشاؤها بهذه الطريقة تفقد تتبع الأبعاد؛ إذا كان تتبع الأبعاد مهمًا لنوعك، يجب عليك إنشاء Broadcast.AbstractArrayStyle مخصص خاص بك.

Broadcast.DefaultArrayStyle{N}() هو BroadcastStyle يشير إلى أن كائنًا ما يتصرف كصفيف N-الأبعاد للبث. بشكل محدد، يتم استخدام DefaultArrayStyle لأي نوع من AbstractArray لم يتم تعريف نمط متخصص له، وفي غياب أي تجاوزات من حجج broadcast الأخرى، يكون نوع المخرجات الناتج هو Array. عندما تكون هناك مدخلات متعددة لـ broadcast، فإن DefaultArrayStyle "تخسر" أمام أي Broadcast.ArrayStyle آخر.

Broadcast.broadcastable(x)

إرجاع إما x أو كائن مثل x بحيث يدعم axes والفهرسة، ونوعه يدعم ndims.

إذا كان x يدعم التكرار، يجب أن يكون للقيمة المعادة نفس سلوكيات axes والفهرسة مثل collect(x).

إذا لم يكن x من نوع AbstractArray ولكنه يدعم axes والفهرسة، ونوعه يدعم ndims، فقد يتم تنفيذ broadcastable(::typeof(x)) لإرجاع نفسه فقط. علاوة على ذلك، إذا كان x يعرف أسلوب BroadcastStyle الخاص به، فيجب عليه تعريف طريقة broadcastable الخاصة به لإرجاع نفسه حتى يكون للأسلوب المخصص أي تأثير.

أمثلة

julia> Broadcast.broadcastable([1,2,3]) # مثل `identity` لأن المصفوفات تدعم بالفعل المحاور والفهرسة
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # الأنواع لا تدعم المحاور أو الفهرسة أو التكرار ولكنها تستخدم عادة كقيم عددية
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # السلاسل تكسر قاعدة مطابقة التكرار وتتصرف كقيمة عددية بدلاً من ذلك
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

حدد محاور النتيجة للبث عبر جميع القيم في As.

julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))

julia> Broadcast.combine_axes(1, 1, 1)
()

combine_styles(cs...) -> BroadcastStyle

يحدد أي BroadcastStyle يجب استخدامه لأي عدد من وسائط القيمة. يستخدم BroadcastStyle للحصول على النمط لكل وسيط، ويستخدم result_style لدمج الأنماط.

أمثلة

julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()

result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle

يأخذ واحدًا أو اثنين من BroadcastStyles ويجمعهما باستخدام BroadcastStyle لتحديد BroadcastStyle مشترك.

أمثلة

julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()

julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()

getindex(A, inds...)

إرجاع مجموعة فرعية من المصفوفة A كما تم اختيارها بواسطة المؤشرات inds.

يمكن أن يكون كل مؤشر من أي نوع مؤشر مدعوم، مثل Integer، CartesianIndex، نطاق، أو مصفوفة من المؤشرات المدعومة. يمكن استخدام : لاختيار جميع العناصر على طول بعد معين، ويمكن استخدام مصفوفة بوليانية (مثل Array{Bool} أو BitArray) لتصفية العناصر حيث يكون المؤشر المقابل true.

عندما تختار inds عناصر متعددة، ترجع هذه الدالة مصفوفة جديدة مخصصة. لاستخدام مؤشرات متعددة دون إنشاء نسخة، استخدم view بدلاً من ذلك.

انظر قسم الدليل حول فهرسة المصفوفات للحصول على التفاصيل.

أمثلة

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

julia> getindex(A, 1)
1

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

julia> getindex(A, 2:4)
3-element Vector{Int64}:
 3
 2
 4

julia> getindex(A, 2, 1)
3

julia> getindex(A, CartesianIndex(2, 1))
3

julia> getindex(A, :, 2)
2-element Vector{Int64}:
 2
 4

julia> getindex(A, 2, :)
2-element Vector{Int64}:
 3
 4

julia> getindex(A, A .> 2)
2-element Vector{Int64}:
 3
 4

setindex!(A, X, inds...)
A[inds...] = X

قم بتخزين القيم من المصفوفة X داخل بعض العناصر الفرعية من A كما هو محدد بواسطة inds. الصيغة A[inds...] = X تعادل (setindex!(A, X, inds...); X).

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

أمثلة

julia> A = zeros(2,2);

julia> setindex!(A, [10, 20], [1, 2]);

julia> A[[3, 4]] = [30, 40];

julia> A
2×2 Matrix{Float64}:
 10.0  30.0
 20.0  40.0

nextind(A, i)

إرجاع الفهرس بعد i في A. الفهرس المعاد غالبًا ما يكون مكافئًا لـ i + 1 لعدد صحيح i. يمكن أن تكون هذه الدالة مفيدة للشفرة العامة.

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

أمثلة

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

julia> nextind(x, 1) # نتيجة صالحة
2

julia> nextind(x, 4) # نتيجة غير صالحة
5

julia> nextind(x, CartesianIndex(1, 1)) # نتيجة صالحة
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # نتيجة غير صالحة
CartesianIndex(1, 3)

prevind(A, i)

إرجاع الفهرس قبل i في A. الفهرس المعاد غالبًا ما يكون مكافئًا لـ i - 1 لعدد صحيح i. يمكن أن تكون هذه الدالة مفيدة للشفرة العامة.

!!! تحذير قد يكون الفهرس المعاد خارج الحدود. ضع في اعتبارك استخدام checkbounds.

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

أمثلة

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

julia> prevind(x, 4) # نتيجة صالحة
3

julia> prevind(x, 1) # نتيجة غير صالحة
0

julia> prevind(x, CartesianIndex(2, 2)) # نتيجة صالحة
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # نتيجة غير صالحة
CartesianIndex(2, 0)

copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

انسخ الكتلة من src في نطاق Rsrc إلى الكتلة من dest في نطاق Rdest. يجب أن تتطابق أحجام المنطقتين.

أمثلة

julia> A = zeros(5, 5);

julia> B = [1 2; 3 4];

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0

copy!(dst, src) -> dst

نسخ في المكان copy من src إلى dst، مع تجاهل أي عناصر موجودة مسبقًا في dst. إذا كانت dst و src من نفس النوع، يجب أن تكون dst == src صحيحة بعد الاستدعاء. إذا كانت dst و src مصفوفات متعددة الأبعاد، يجب أن تكون لها axes متساوية.

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

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

!!! توافق "جوليا 1.1" تتطلب هذه الطريقة على الأقل جوليا 1.1. في جوليا 1.0، تتوفر هذه الطريقة من مكتبة Future القياسية كـ Future.copy!.

isassigned(array, i) -> Bool

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

أمثلة

julia> isassigned(rand(3, 3), 5)
true

julia> isassigned(rand(3, 3), 3 * 3 + 1)
false

julia> mutable struct Foo end

julia> v = similar(rand(3), Foo)
3-element Vector{Foo}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false

Colon()

تُستخدم النقطتان (:) للدلالة على فهرسة الكائنات أو الأبعاد بالكامل دفعة واحدة.

قليل من العمليات مُعرفة على النقطتين مباشرةً؛ بدلاً من ذلك، يتم تحويلها بواسطة to_indices إلى نوع متجه داخلي (Base.Slice) لتمثيل مجموعة الفهارس التي تغطيها قبل استخدامها.

تُستخدم النسخة الفردية من Colon أيضًا كدالة لإنشاء النطاقات؛ انظر :.

CartesianIndex(i, j, k...)   -> I
CartesianIndex((i, j, k...)) -> I

قم بإنشاء فهرس متعدد الأبعاد I، والذي يمكن استخدامه لفهرسة مصفوفة متعددة الأبعاد A. على وجه الخصوص، A[I] يعادل A[i,j,k...]. يمكن للمرء أن يخلط بحرية بين الفهارس الصحيحة وCartesianIndex؛ على سبيل المثال، A[Ipre, i, Ipost] (حيث Ipre و Ipost هما فهارس CartesianIndex و i هو Int) يمكن أن تكون تعبيرًا مفيدًا عند كتابة الخوارزميات التي تعمل على بعد واحد من مصفوفة ذات أبعاد عشوائية.

يتم إنتاج CartesianIndex أحيانًا بواسطة eachindex، ودائمًا عند التكرار باستخدام CartesianIndices بشكل صريح.

يتم التعامل مع I::CartesianIndex كـ "عدد" (ليس حاوية) لـ broadcast. من أجل التكرار على مكونات CartesianIndex، قم بتحويله إلى مجموعة باستخدام Tuple(I).

أمثلة

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

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> A[CartesianIndex((1, 1, 1, 1))]
1

julia> A[CartesianIndex((1, 1, 1, 2))]
9

julia> A[CartesianIndex((1, 1, 2, 1))]
5

CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R

حدد منطقة R تمتد عبر نطاق مستطيل متعدد الأبعاد من مؤشرات الأعداد الصحيحة. وغالبًا ما يتم مواجهتها في سياق التكرار، حيث for I in R ... end ستعيد مؤشرات CartesianIndex I المعادلة للحلقات المتداخلة

for j = jstart:jstep:jstop
    for i = istart:istep:istop
        ...
    end
end

وبالتالي، يمكن أن تكون هذه مفيدة لكتابة الخوارزميات التي تعمل في أبعاد عشوائية.

CartesianIndices(A::AbstractArray) -> R

كوسيلة راحة، فإن إنشاء CartesianIndices من مصفوفة يجعل نطاقًا من مؤشرات تلك المصفوفة.

أمثلة

julia> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

julia> CartesianIndices(fill(1, (2,3)))
CartesianIndices((2, 3))

التحويل بين المؤشرات الخطية والكارتيزية

يستغل تحويل المؤشر الخطي إلى المؤشر الكارتيزي حقيقة أن CartesianIndices هو AbstractArray ويمكن فهرسته خطيًا:

julia> cartesian = CartesianIndices((1:3, 1:2))
CartesianIndices((1:3, 1:2))

julia> cartesian[4]
CartesianIndex(1, 2)

julia> cartesian = CartesianIndices((1:2:5, 1:2))
CartesianIndices((1:2:5, 1:2))

julia> cartesian[2, 2]
CartesianIndex(3, 2)

البث

تدعم CartesianIndices العمليات الحسابية للبث (+ و -) مع CartesianIndex.

julia> CIs = CartesianIndices((2:3, 5:6))
CartesianIndices((2:3, 5:6))

julia> CI = CartesianIndex(3, 4)
CartesianIndex(3, 4)

julia> CIs .+ CI
CartesianIndices((5:6, 9:10))

لتحويل الكارتيزي إلى المؤشر الخطي، انظر LinearIndices. ```

Dims{N}

NTuple من N Ints تُستخدم لتمثيل أبعاد AbstractArray.

LinearIndices(A::AbstractArray)

إرجاع مصفوفة LinearIndices بنفس الشكل و axes مثل A، تحمل الفهرس الخطي لكل إدخال في A. يسمح فهرسة هذه المصفوفة باستخدام الفهارس الكارتيسية بربطها بالفهارس الخطية.

بالنسبة للمصفوفات ذات الفهرسة التقليدية (تبدأ الفهارس من 1)، أو أي مصفوفة متعددة الأبعاد، تتراوح الفهارس الخطية من 1 إلى length(A). ومع ذلك، بالنسبة لـ AbstractVectors، تكون الفهارس الخطية هي axes(A, 1)، وبالتالي لا تبدأ من 1 بالنسبة للمتجهات ذات الفهرسة غير التقليدية.

استدعاء هذه الدالة هو الطريقة "الآمنة" لكتابة الخوارزميات التي تستغل الفهرسة الخطية.

أمثلة

julia> A = fill(1, (5,6,7));

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

LinearIndices(inds::CartesianIndices) -> R
LinearIndices(sz::Dims) -> R
LinearIndices((istart:istop, jstart:jstop, ...)) -> R

إرجاع مصفوفة LinearIndices بالشكل المحدد أو axes.

أمثلة

الغرض الرئيسي من هذا المُنشئ هو التحويل البديهي من الفهرسة الكارتيسية إلى الفهرسة الخطية:

julia> linear = LinearIndices((1:3, 1:2))
3×2 LinearIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 1  4
 2  5
 3  6

julia> linear[1,2]
4

to_indices(A, I::Tuple)

قم بتحويل التوابل I إلى مجموعة من المؤشرات لاستخدامها في الفهرسة داخل المصفوفة A.

يجب أن تحتوي المجموعة المعادة فقط على إما Ints أو AbstractArrays من المؤشرات السلمية المدعومة من قبل المصفوفة A. ستظهر خطأ عند مواجهة نوع مؤشر جديد لا تعرف كيفية معالجته.

بالنسبة لأنواع المؤشرات البسيطة، تعتمد على الدالة غير المصدرة Base.to_index(A, i) لمعالجة كل مؤشر i. على الرغم من أن هذه الدالة الداخلية ليست مخصصة للاستدعاء المباشر، يمكن توسيع Base.to_index بواسطة أنواع المصفوفات أو المؤشرات المخصصة لتوفير سلوكيات فهرسة مخصصة.

قد تتطلب أنواع المؤشرات الأكثر تعقيدًا مزيدًا من السياق حول البعد الذي تشير إليه. لدعم تلك الحالات، تستدعي to_indices(A, I) to_indices(A, axes(A), I)، والتي تتنقل بعد ذلك بشكل متكرر عبر كل من مجموعة المؤشرات المعطاة ومؤشرات الأبعاد لـ A بالتزامن. وبالتالي، لا تضمن جميع أنواع المؤشرات أن تنتقل إلى Base.to_index.

أمثلة

julia> A = zeros(1,2,3,4);

julia> to_indices(A, (1,1,2,2))
(1, 1, 2, 2)

julia> to_indices(A, (1,1,2,20)) # لا يوجد فحص للحدود
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # مؤشر غريب
(1, 2, 3, 4)

julia> to_indices(A, ([1,1], 1:2, 3, 4))
([1, 1], 1:2, 3, 4)

julia> to_indices(A, (1,2)) # لا يوجد فحص للشكل
(1, 2)

checkbounds(Bool, A, I...)

ارجع true إذا كانت الفهارس المحددة I ضمن الحدود للمصفوفة المعطاة A. يجب على الأنواع الفرعية من AbstractArray تخصيص هذه الطريقة إذا كانت بحاجة إلى توفير سلوكيات فحص حدود مخصصة؛ ومع ذلك، في العديد من الحالات يمكن الاعتماد على فهارس A و checkindex.

انظر أيضًا checkindex.

أمثلة

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

julia> checkbounds(Bool, A, 3, 4)
false

julia> checkbounds(Bool, A, 1:3)
true

julia> checkbounds(Bool, A, 1:3, 2:4)
false

checkbounds(A, I...)

ارمي خطأ إذا كانت الفهارس المحددة I ليست ضمن الحدود للمصفوفة المعطاة A.

checkindex(Bool, inds::AbstractUnitRange, index)

ارجع true إذا كان index المعطى ضمن حدود inds. يمكن لأنواع البيانات المخصصة التي ترغب في التصرف كمؤشرات لجميع المصفوفات توسيع هذه الطريقة لتوفير تنفيذ مخصص للتحقق من الحدود.

انظر أيضًا checkbounds.

أمثلة

julia> checkindex(Bool, 1:20, 8)
true

julia> checkindex(Bool, 1:20, 21)
false

elsize(type)

احسب المسافة في الذاكرة بالبايت بين العناصر المتتالية من eltype المخزنة داخل type المعطى، إذا كانت عناصر المصفوفة مخزنة بكثافة مع مسافة خطية موحدة.

أمثلة

julia> Base.elsize(rand(Float32, 10))
4

view(A, inds...)

مثل getindex، ولكن يُرجع مصفوفة خفيفة الوزن تشير بشكل كسول (أو هي فعليًا عرض في) المصفوفة الأصلية A عند الفهرس أو الفهارس المعطاة inds بدلاً من استخراج العناصر بشكل متعجل أو إنشاء مجموعة فرعية منسوخة. استدعاء getindex أو setindex! على القيمة المعادة (غالبًا ما تكون SubArray) يحسب الفهارس للوصول إلى المصفوفة الأصلية أو تعديلها في الوقت الفعلي. السلوك غير محدد إذا تم تغيير شكل المصفوفة الأصلية بعد استدعاء view لأنه لا يوجد فحص حدود للمصفوفة الأصلية؛ على سبيل المثال، قد يتسبب ذلك في حدوث خطأ في تقسيم الذاكرة.

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

أمثلة

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

julia> b = view(A, :, 1)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A # لاحظ أن A قد تغير على الرغم من أننا عدلنا b
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # يُرجع نطاقًا حيث أن النوع غير قابل للتغيير
3:4

@view A[inds...]

حوّل تعبير الفهرسة A[inds...] إلى مكالمة view المعادلة.

يمكن تطبيق ذلك مباشرةً على تعبير فهرسة واحد فقط، وهو مفيد بشكل خاص للتعبيرات التي تتضمن بناء الفهرسة الخاص begin أو end مثل A[begin, 2:end-1] (حيث أن هذه غير مدعومة من قبل دالة view العادية).

لاحظ أن @view لا يمكن استخدامها كهدف لتعيين عادي (مثل @view(A[1, 2:end]) = ...)، ولا يمكن أن تجعل تعيين الفهرسة غير المزخرف (A[1, 2:end] = ...) أو تعيين الفهرسة الموزعة (A[1, 2:end] .= ...) نسخة. ومع ذلك، يمكن أن تكون مفيدة لـ تحديث التعيينات الموزعة مثل @view(A[1, 2:end]) .+= 1 لأن هذه صيغة بسيطة لـ @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1، والتعبير الفهرسي على الجانب الأيمن سيجعل نسخة بدون @view.

انظر أيضًا @views لتحويل كتلة كاملة من الكود لاستخدام العروض للفهرسة غير الاسكالية.

أمثلة

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

julia> b = @view A[:, 1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A
2×2 Matrix{Int64}:
 0  2
 0  4

@views التعبير

قم بتحويل كل عملية تقطيع مصفوفة في التعبير المعطى (الذي قد يكون كتلة begin/end، حلقة، دالة، إلخ) لتعيد عرضًا. المؤشرات السلمية، الأنواع غير المصفوفية، واستدعاءات getindex الصريحة (على عكس array[...]) غير متأثرة.

وبالمثل، يقوم @views بتحويل شرائح السلاسل إلى عروض SubString.

!!! ملاحظة يؤثر ماكرو @views فقط على تعبيرات array[...] التي تظهر صراحة في التعبير المعطى، وليس تقطيع المصفوفات الذي يحدث في الدوال التي تستدعى بواسطة هذا الكود.

!!! توافق "جوليا 1.5" تم تنفيذ استخدام begin في تعبير الفهرسة للإشارة إلى الفهرس الأول في جوليا 1.4، ولكن تم دعمه فقط بواسطة @views بدءًا من جوليا 1.5.

أمثلة

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b هو عرض، وليس نسخة
           b .= row      # تعيين كل عنصر إلى فهرس الصف
       end

julia> A
3×3 Matrix{Float64}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

parent(A)

ارجع الكائن الأب الأساسي للعرض. هذا الأب للكائنات من الأنواع SubArray، SubString، ReshapedArray أو LinearAlgebra.Transpose هو ما تم تمريره كوسيط إلى view، reshape، transpose، إلخ. أثناء إنشاء الكائن. إذا لم يكن الإدخال كائنًا مغلفًا، ارجع الإدخال نفسه. إذا كان الإدخال مغلفًا عدة مرات، فسيتم إزالة الغلاف الخارجي فقط.

أمثلة

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

julia> V = view(A, 1:2, :)
2×2 view(::Matrix{Int64}, 1:2, :) with eltype Int64:
 1  2
 3  4

julia> parent(V)
2×2 Matrix{Int64}:
 1  2
 3  4

parentindices(A)

إرجاع الفهارس في parent التي تتوافق مع العرض A.

أمثلة

julia> A = [1 2; 3 4];

julia> V = view(A, 1, :)
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))

selectdim(A, d::Integer, i)

إرجاع عرض لجميع بيانات A حيث يكون الفهرس بعدد الأبعاد d يساوي i.

يعادل view(A,:,:,...,i,:,:,...) حيث يكون i في الموضع d.

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

أمثلة

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

julia> selectdim(A, 2, 3)
2-element view(::Matrix{Int64}, :, 3) with eltype Int64:
 3
 7

julia> selectdim(A, 2, 3:4)
2×2 view(::Matrix{Int64}, :, 3:4) with eltype Int64:
 3  4
 7  8

reinterpret(::Type{Out}, x::In)

قم بتغيير تفسير النوع للبيانات الثنائية في قيمة isbits x إلى نوع isbits Out. يجب أن يكون حجم Out (مع تجاهل الحشو) هو نفسه حجم نوع x. على سبيل المثال، reinterpret(Float32, UInt32(7)) يفسر الـ 4 بايت المرتبطة بـ UInt32(7) كـ Float32. لاحظ أن reinterpret(In, reinterpret(Out, x)) === x

julia> reinterpret(Float32, UInt32(7))
1.0f-44

julia> reinterpret(NTuple{2, UInt8}, 0x1234)
(0x34, 0x12)

julia> reinterpret(UInt16, (0x34, 0x12))
0x1234

julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
(0x0301, 0x02)

reinterpret(T::DataType, A::AbstractArray)

قم بإنشاء عرض للمصفوفة بنفس البيانات الثنائية مثل المصفوفة المعطاة، ولكن مع T كنوع عنصر.

تعمل هذه الدالة أيضًا على المصفوفات "الكسولة" التي لا يتم حساب عناصرها حتى يتم استرجاعها بشكل صريح. على سبيل المثال، يعمل reinterpret على النطاق 1:6 بشكل مشابه للمصفوفة الكثيفة collect(1:6):

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Matrix{UInt32}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45

julia> reinterpret(Complex{Int}, 1:6)
3-element reinterpret(Complex{Int64}, ::UnitRange{Int64}):
 1 + 2im
 3 + 4im
 5 + 6im

إذا لم يتماشى موقع بتات الحشو بين T و eltype(A)، ستكون المصفوفة الناتجة للقراءة فقط أو الكتابة فقط، لمنع كتابة بتات غير صالحة أو قراءتها، على التوالي.

julia> a = reinterpret(Tuple{UInt8, UInt32}, UInt32[1, 2])
1-element reinterpret(Tuple{UInt8, UInt32}, ::Vector{UInt32}):
 (0x01, 0x00000002)

julia> a[1] = 3
ERROR: Padding of type Tuple{UInt8, UInt32} is not compatible with type UInt32.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # showing will error

julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.

reinterpret(reshape, T, A::AbstractArray{S}) -> B

غير نوع التفسير لـ A أثناء استهلاك أو إضافة "بعد القناة".

إذا كان sizeof(T) = n*sizeof(S) لـ n>1، يجب أن يكون البعد الأول لـ A بحجم n و B تفتقر إلى البعد الأول لـ A. على العكس، إذا كان sizeof(S) = n*sizeof(T) لـ n>1، يحصل B على بعد أول جديد بحجم n. تبقى الأبعاد دون تغيير إذا كان sizeof(T) == sizeof(S).

أمثلة

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

julia> reinterpret(reshape, Complex{Int}, A)    # النتيجة هي متجه
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

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

julia> reinterpret(reshape, Int, a)             # النتيجة هي مصفوفة
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6

reshape(A, dims...) -> AbstractArray
reshape(A, dims) -> AbstractArray

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

يمكن تحديد الأبعاد الجديدة إما كقائمة من المعاملات أو كزوج شكل. يمكن تحديد بعد واحد فقط باستخدام :, وفي هذه الحالة يتم حساب طوله بحيث يكون حاصل ضربه مع جميع الأبعاد المحددة مساوياً لطول المصفوفة الأصلية A. يجب ألا يتغير العدد الإجمالي للعناصر.

أمثلة

julia> A = Vector(1:16)
16-element Vector{Int64}:
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16

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

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

julia> reshape(1:6, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6

dropdims(A; dims)

إرجاع مصفوفة بنفس بيانات A، ولكن مع إزالة الأبعاد المحددة بواسطة dims. يجب أن يكون size(A,d) مساوياً لـ 1 لكل d في dims، والأبعاد المتكررة أو الأرقام خارج 1:ndims(A) محظورة.

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

انظر أيضًا: reshape، vec.

أمثلة

julia> a = reshape(Vector(1:4),(2,2,1,1))
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 1  3
 2  4

julia> b = dropdims(a; dims=3)
2×2×1 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

julia> b[1,1,1] = 5; a
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 5  3
 2  4

vec(a::AbstractArray) -> AbstractVector

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

أمثلة

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

julia> vec(a)
6-element Vector{Int64}:
 1
 4
 2
 5
 3
 6

julia> vec(1:3)
1:3

انظر أيضًا reshape، dropdims.

SubArray{T,N,P,I,L} <: AbstractArray{T,N}

عرض N-الأبعاد في مصفوفة الأب (من النوع P) مع نوع عنصر T، مقيد بواسطة مجموعة من الفهارس (من النوع I). L صحيح للأنواع التي تدعم الفهرسة الخطية السريعة، وخاطئ بخلاف ذلك.

قم بإنشاء SubArrays باستخدام دالة view.

cat(A...; dims)

قم بدمج مصفوفات الإدخال على طول الأبعاد المحددة في dims.

على طول بعد d in dims، يكون حجم مصفوفة الإخراج هو sum(size(a,d) for a in A). على الأبعاد الأخرى، يجب أن تكون جميع مصفوفات الإدخال بنفس الحجم، والذي سيكون أيضًا حجم مصفوفة الإخراج على تلك الأبعاد.

إذا كان dims رقمًا واحدًا، فإن المصفوفات المختلفة تكون متراصة بإحكام على طول ذلك البعد. إذا كان dims عبارة عن مجموعة تحتوي على عدة أبعاد، فإن المواضع على طول هذه الأبعاد تزداد في الوقت نفسه لكل مصفوفة إدخال، مع ملء الأصفار في أماكن أخرى. وهذا يسمح بإنشاء مصفوفات قطرية كتلة مثل cat(matrices...; dims=(1,2))، ونظائرها ذات الأبعاد الأعلى.

الحالة الخاصة dims=1 هي vcat، و dims=2 هي hcat. انظر أيضًا hvcat، hvncat، stack، repeat.

تقبل الكلمة الرئيسية أيضًا Val(dims).

أمثلة

دمج مصفوفتين في أبعاد مختلفة:

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

julia> b = [4 5 6]
1×3 Matrix{Int64}:
 4  5  6

julia> cat(a, b; dims=1)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> cat(a, b; dims=2)
1×6 Matrix{Int64}:
 1  2  3  4  5  6

julia> cat(a, b; dims=(1, 2))
2×6 Matrix{Int64}:
 1  2  3  0  0  0
 0  0  0  4  5  6

مساعدة موسعة

دمج مصفوفات ثلاثية الأبعاد:

julia> a = ones(2, 2, 3);

julia> b = ones(2, 2, 4);

julia> c = cat(a, b; dims=3);

julia> size(c) == (2, 2, 7)
true

دمج مصفوفات بأحجام مختلفة:

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # نفس الشيء مثل hcat
2×6×1 Array{Float64, 3}:
[:, :, 1] =
 1.0  2.0  3.14159  10.0  10.0  10.0
 3.0  4.0  3.14159  10.0  10.0  10.0

إنشاء مصفوفة قطرية كتلة:

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # قطرية كتلة
4×7 Matrix{Bool}:
 1  0  0  0  0  0  0
 0  1  1  0  0  0  0
 0  1  1  0  0  0  0
 0  0  0  1  1  1  1

julia> cat(1, [2], [3;;]; dims=Val(2))
1×3 Matrix{Int64}:
 1  2  3

julia> a = "aaa";

julia> b = "bbb";

julia> cat(a, b; dims=1)
2-element Vector{String}:
 "aaa"
 "bbb"

julia> cat(a, b; dims=2)
1×2 Matrix{String}:
 "aaa"  "bbb"

julia> a * b
"aaabbb"

vcat(A...)

دمج المصفوفات أو الأرقام عموديًا. يعادل cat(A...; dims=1)، وإلى الصيغة [a; b; c].

لدمج متجه كبير من المصفوفات، فإن reduce(vcat, A) يستدعي طريقة فعالة عندما يكون A isa AbstractVector{<:AbstractVecOrMat}، بدلاً من العمل بشكل ثنائي.

انظر أيضًا hcat، Iterators.flatten، stack.

أمثلة

julia> v = vcat([1,2], [3,4])
4-element Vector{Int64}:
 1
 2
 3
 4

julia> v == vcat(1, 2, [3,4])  # يقبل الأرقام
true

julia> v == [1; 2; [3,4]]  # صيغة لنفس العملية
true

julia> summary(ComplexF64[1; 2; [3,4]])  # صيغة لتحديد نوع العنصر
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # يجمع النطاقات الكسولة
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # متجه صف ومصفوفة
([10 20 30], [4.0 5.0 6.0; 7.0 8.0 9.0])

julia> vcat(two...)
3×3 Matrix{Float64}:
 10.0  20.0  30.0
  4.0   5.0   6.0
  7.0   8.0   9.0

julia> vs = [[1, 2], [3, 4], [5, 6]];

julia> reduce(vcat, vs)  # أكثر كفاءة من vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> ans == collect(Iterators.flatten(vs))
true

hcat(A...)

قم بدمج المصفوفات أو الأرقام أفقيًا. يعادل cat(A...; dims=2)، و إلى الصيغة [a b c] أو [a;; b;; c].

بالنسبة لمتجه كبير من المصفوفات، فإن reduce(hcat, A) يستدعي طريقة فعالة عندما يكون A isa AbstractVector{<:AbstractVecOrMat}. بالنسبة لمتجه من المتجهات، يمكن أيضًا كتابة ذلك كـ stack(A).

انظر أيضًا vcat، hvcat.

أمثلة

julia> hcat([1,2], [3,4], [5,6])
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # يقبل الأرقام
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # صيغة لنفس العملية
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # صيغة لتحديد نوع العنصر
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

julia> ms = [zeros(2,2), [1 2; 3 4], [50 60; 70 80]];

julia> reduce(hcat, ms)  # أكثر كفاءة من hcat(ms...)
2×6 Matrix{Float64}:
 0.0  0.0  1.0  2.0  50.0  60.0
 0.0  0.0  3.0  4.0  70.0  80.0

julia> stack(ms) |> summary  # لا يتفق على متجه من المصفوفات
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # متجهات فارغة، كل منها بحجم (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat مع مصفوفة فارغة 2×0
2×1 Matrix{Any}:
 1.1
 9.9

hvcat(blocks_per_row::Union{Tuple{Vararg{Int}}, Int}, values...)

الدمج الأفقي والعمودي في استدعاء واحد. يتم استدعاء هذه الدالة لكتلة مصفوفة. يحدد الوسيط الأول عدد الوسائط التي سيتم دمجها في كل صف كتلة. إذا كان الوسيط الأول عددًا صحيحًا واحدًا n، فيُفترض أن جميع صفوف الكتل تحتوي على n عمود كتلة.

أمثلة

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c; d e f]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> hvcat((3,3), a,b,c,d,e,f)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> [a b; c d; e f]
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6

julia> hvcat((2,2,2), a,b,c,d,e,f)
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6
julia> hvcat((2,2,2), a,b,c,d,e,f) == hvcat(2, a,b,c,d,e,f)
true

hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

التجميع الأفقي والعمودي وذو الأبعاد المتعددة للعديد من values في استدعاء واحد.

تُستدعى هذه الدالة لكتابة مصفوفة الكتل. الحجة الأولى إما تحدد شكل التجميع، مشابهة لـ hvcat، كزوج من الأزواج، أو الأبعاد التي تحدد العدد الرئيسي من العناصر على طول كل محور، وتستخدم لتحديد أبعاد المخرجات. شكل dims أكثر كفاءة، ويستخدم بشكل افتراضي عندما يكون لعملية التجميع نفس عدد العناصر على طول كل محور (على سبيل المثال، [a b; c d;;; e f ; g h]). يُستخدم شكل shape عندما يكون عدد العناصر على طول كل محور غير متوازن (على سبيل المثال، [a b ; c]). تحتاج الصيغة غير المتوازنة إلى عبء تحقق إضافي. شكل dim هو تحسين للتجميع على طول بعد واحد فقط. يشير row_first إلى كيفية ترتيب values. كما يتم تبديل معنى العنصرين الأول والثاني من shape بناءً على row_first.

أمثلة

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c;;; d e f]
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

julia> hvncat((2,1,3), false, a,b,c,d,e,f)
2×1×3 Array{Int64, 3}:
[:, :, 1] =
 1
 2

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

julia> [a b;;; c d;;; e f]
1×2×3 Array{Int64, 3}:
[:, :, 1] =
 1  2

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

julia> hvncat(((3, 3), (3, 3), (6,)), true, a, b, c, d, e, f)
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

أمثلة لبناء المعطيات

[a b c ; d e f ;;;
 g h i ; j k l ;;;
 m n o ; p q r ;;;
 s t u ; v w x]
⇒ dims = (2, 3, 4)

[a b ; c ;;; d ;;;;]
 ___   _     _
 2     1     1 = العناصر في كل صف (2, 1, 1)
 _______     _
 3           1 = العناصر في كل عمود (3, 1)
 _____________
 4             = العناصر في كل شريحة ثلاثية الأبعاد (4,)
 _____________
 4             = العناصر في كل شريحة رباعية الأبعاد (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) مع `row_first` = true

stack(iter; [dims])

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

بشكل افتراضي، يتم وضع محاور العناصر أولاً، مما يعطي size(result) = (size(first(iter))..., size(iter)...). هذا له نفس ترتيب العناصر مثل Iterators.flatten(iter).

مع الكلمة الرئيسية dims::Integer، بدلاً من ذلك يصبح العنصر i من iter هو الشريحة selectdim(result, dims, i)، بحيث size(result, dims) == length(iter). في هذه الحالة، تعكس stack عمل eachslice بنفس dims.

تجمع الوظائف المختلفة cat أيضًا المصفوفات. ومع ذلك، فإن هذه جميعها تمدد الأبعاد الحالية للمصفوفات (التي قد تكون تافهة)، بدلاً من وضع المصفوفات على طول أبعاد جديدة. كما أنها تقبل المصفوفات كوسائط منفصلة، بدلاً من مجموعة واحدة.

أمثلة

julia> vecs = (1:2, [30, 40], Float32[500, 600]);

julia> mat = stack(vecs)
2×3 Matrix{Float32}:
 1.0  30.0  500.0
 2.0  40.0  600.0

julia> mat == hcat(vecs...) == reduce(hcat, collect(vecs))
true

julia> vec(mat) == vcat(vecs...) == reduce(vcat, collect(vecs))
true

julia> stack(zip(1:4, 10:99))  # يقبل أي متكررات من المتكررات
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

julia> vec(ans) == collect(Iterators.flatten(zip(1:4, 10:99)))
true

julia> stack(vecs; dims=1)  # على عكس أي وظيفة cat، المحور الأول من vecs[1] هو المحور الثاني من النتيجة
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # عكس eachslice
true

أمثلة ذات أبعاد أعلى:

julia> A = rand(5, 7, 11);

julia> E = eachslice(A, dims=2);  # متجه من المصفوفات

julia> (element = size(first(E)), container = size(E))
(element = (5, 11), container = (7,))

julia> stack(E) |> size
(5, 11, 7)

julia> stack(E) == stack(E; dims=3) == cat(E...; dims=3)
true

julia> A == stack(E; dims=2)
true

julia> M = (fill(10i+j, 2, 3) for i in 1:5, j in 1:7);

julia> (element = size(first(M)), container = size(M))
(element = (2, 3), container = (5, 7))

julia> stack(M) |> size  # يحتفظ بجميع الأبعاد
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # vec(container) على طول dims=1
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat يضع المصفوفات بجانب بعضها البعض
(14, 15)

stack(f, args...; [dims])

تطبيق دالة على كل عنصر من مجموعة، وstack النتيجة. أو على عدة مجموعات، تم zipها معًا.

يجب أن تُرجع الدالة مصفوفات (أو مجموعات، أو مكررات أخرى) جميعها بنفس الحجم. تصبح هذه شرائح من النتيجة، كل منها مفصول على طول dims (إذا تم إعطاؤها) أو بشكل افتراضي على طول الأبعاد الأخيرة.

انظر أيضًا mapslices، eachcol.

أمثلة

julia> stack(c -> (c, c-32), "julia")
2×5 Matrix{Char}:
 'j'  'u'  'l'  'i'  'a'
 'J'  'U'  'L'  'I'  'A'

julia> stack(eachrow([1 2 3; 4 5 6]), (10, 100); dims=1) do row, n
         vcat(row, row .* n, row ./ n)
       end
2×9 Matrix{Float64}:
 1.0  2.0  3.0   10.0   20.0   30.0  0.1   0.2   0.3
 4.0  5.0  6.0  400.0  500.0  600.0  0.04  0.05  0.06

vect(X...)

إنشاء Vector مع نوع العنصر المحسوب من promote_typeof للوسيط، يحتوي على قائمة الوسائط.

أمثلة

julia> a = Base.vect(UInt8(1), 2.5, 1//2)
3-element Vector{Float64}:
 1.0
 2.5
 0.5

circshift(A, shifts)

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

انظر أيضًا: circshift!, circcopy!, bitrotate, <<.

أمثلة

julia> b = 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> circshift(b, (0,2))
4×4 Matrix{Int64}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Matrix{Int64}:
 2  6  10  14
 3  7  11  15
 4  8  12  16
 1  5   9  13

julia> a = BitArray([true, true, false, false, true])
5-element BitVector:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitVector:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitVector:
 1
 0
 0
 1
 1

circshift!(a::AbstractVector, shift::Integer)

قم بتحويل البيانات في المتجه a دائريًا، أو تدويرها، بواسطة shift موضع.

أمثلة

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

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

circshift!(dest, src, shifts)

قم بإزاحة البيانات في src بشكل دائري، أي تدويرها، وتخزين النتيجة في dest. يحدد shifts مقدار الإزاحة في كل بعد.

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

انظر أيضًا circshift.

circcopy!(dest, src)

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

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

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

أمثلة

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

julia> dest = OffsetArray{Int}(undef, (0:3,2:5))

julia> circcopy!(dest, src)
OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} with indices 0:3×2:5:
 8  12  16  4
 5   9  13  1
 6  10  14  2
 7  11  15  3

julia> dest[1:3,2:4] == src[1:3,2:4]
true

findall(A)

إرجاع متجه I من الفهارس أو المفاتيح true لـ A. إذا لم يكن هناك عناصر من هذا النوع في A، إرجع مصفوفة فارغة. للبحث عن أنواع أخرى من القيم، مرر دالة شرطية كأول وسيط.

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

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

أمثلة

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

julia> findall(A)
2-element Vector{Int64}:
 1
 4

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

julia> findall(A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 2)

julia> findall(falses(3))
Int64[]

findall(f::Function, A)

إرجاع متجه I من الفهارس أو المفاتيح لـ A حيث تعيد f(A[I]) القيمة true. إذا لم يكن هناك عناصر من A، إرجع مصفوفة فارغة.

الفهارس أو المفاتيح من نفس النوع الذي يتم إرجاعه بواسطة keys(A) و pairs(A).

أمثلة

julia> x = [1, 3, 4]
3-element Vector{Int64}:
 1
 3
 4

julia> findall(isodd, x)
2-element Vector{Int64}:
 1
 2

julia> A = [1 2 0; 3 4 0]
2×3 Matrix{Int64}:
 1  2  0
 3  4  0
julia> findall(isodd, A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

julia> findall(!iszero, A)
4-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

julia> d = Dict(:A => 10, :B => -1, :C => 0)
Dict{Symbol, Int64} with 3 entries:
  :A => 10
  :B => -1
  :C => 0

julia> findall(x -> x >= 0, d)
2-element Vector{Symbol}:
 :A
 :C

findfirst(A)

ارجع الفهرس أو المفتاح لأول قيمة true في A. ارجع nothing إذا لم يتم العثور على مثل هذه القيمة. للبحث عن أنواع أخرى من القيم، مرر دالة شرطية كأول وسيط.

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

انظر أيضًا: findall، findnext، findlast، searchsortedfirst.

أمثلة

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # returns nothing, but not printed in the REPL

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

julia> findfirst(A)
CartesianIndex(2, 1)

findfirst(predicate::Function, A)

ارجع الفهرس أو المفتاح لأول عنصر من A الذي تعيد فيه predicate القيمة true. ارجع nothing إذا لم يكن هناك مثل هذا العنصر.

الفهارس أو المفاتيح هي من نفس النوع الذي يتم إرجاعه بواسطة keys(A) و pairs(A).

أمثلة

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

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # يرجع nothing، لكن لا يتم طباعته في REPL

julia> findfirst(isequal(4), A)
2

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

julia> findfirst(iseven, A)
CartesianIndex(2, 1)

findlast(A)

ارجع الفهرس أو المفتاح لآخر قيمة true في A. ارجع nothing إذا لم يكن هناك قيمة true في A.

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

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

أمثلة

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

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # يرجع nothing، لكن لا يتم طباعته في REPL

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

julia> findlast(A)
CartesianIndex(2, 1)

findlast(predicate::Function, A)

إرجاع الفهرس أو المفتاح لآخر عنصر من A الذي تُرجع له predicate القيمة true. إرجاع nothing إذا لم يكن هناك مثل هذا العنصر.

الفهارس أو المفاتيح من نفس نوع تلك التي تُرجع بواسطة keys(A) و pairs(A).

أمثلة

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # returns nothing, but not printed in the REPL

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

julia> findlast(isodd, A)
CartesianIndex(2, 1)

findnext(A, i)

ابحث عن الفهرس التالي بعد أو بما في ذلك i لعنصر true في A، أو nothing إذا لم يتم العثور عليه.

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

أمثلة

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

julia> findnext(A, 1)
3

julia> findnext(A, 4) # يرجع nothing، ولكن لا يتم طباعته في REPL

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

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)

findnext(predicate::Function, A, i)

ابحث عن الفهرس التالي بعد أو بما في ذلك i لعنصر من A حيث تُرجع predicate القيمة true، أو nothing إذا لم يتم العثور عليه. يعمل هذا مع المصفوفات، والسلاسل، ومعظم المجموعات الأخرى التي تدعم getindex، وkeys(A)، وnextind.

الفهارس من نفس نوع تلك التي تُرجعها keys(A) وpairs(A).

أمثلة

julia> A = [1, 4, 2, 2];

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # يُرجع nothing، ولكن لا يُطبع في REPL

julia> A = [1 4; 2 2];

julia> findnext(isodd, A, CartesianIndex(1, 1))
CartesianIndex(1, 1)

julia> findnext(isspace, "a b c", 3)
4

findprev(A, i)

ابحث عن الفهرس السابق قبل أو بما في ذلك i لعنصر true في A، أو nothing إذا لم يتم العثور عليه.

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

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

أمثلة

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

julia> findprev(A, 3)
3

julia> findprev(A, 1) # يرجع nothing، ولكن لا يتم طباعته في REPL

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

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)

findprev(predicate::Function, A, i)

ابحث عن الفهرس السابق قبل أو بما في ذلك i لعنصر من A حيث تُرجع predicate القيمة true، أو nothing إذا لم يتم العثور عليه. يعمل هذا مع المصفوفات، والسلاسل، ومعظم المجموعات الأخرى التي تدعم getindex، وkeys(A)، وnextind.

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

أمثلة

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

julia> findprev(isodd, A, 1) # لا يُرجع شيئًا، ولكن لا يُطبع في REPL

julia> findprev(isodd, A, 3)
3

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

julia> findprev(isodd, A, CartesianIndex(1, 2))
CartesianIndex(2, 1)

julia> findprev(isspace, "a b c", 3)
2

permutedims(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)

قم بتبديل أبعاد (محاور) المصفوفة A. perm هو مجموعة أو متجه من ndims(A) أعداد صحيحة تحدد التبديل.

إذا كانت A مصفوفة ثنائية الأبعاد (AbstractMatrix)، فإن perm يكون افتراضيًا (2,1)، مما يبدل المحورين لـ A (الصفوف والأعمدة للمصفوفة). هذا يختلف عن transpose حيث أن العملية ليست تكرارية، وهو ما يكون مفيدًا بشكل خاص للمصفوفات التي تحتوي على قيم غير عددية (حيث أن transpose التكرارية ستؤدي إلى خطأ) و/أو المصفوفات الثنائية الأبعاد التي لا تمثل مشغلين خطيين.

للمصفوفات أحادية البعد، انظر إلى permutedims(v::AbstractVector)، والتي تعيد "مصفوفة" ذات صف واحد.

انظر أيضًا permutedims!، PermutedDimsArray، transpose، invperm.

أمثلة

مصفوفات ثنائية الأبعاد:

على عكس transpose، يمكن استخدام permutedims لتبديل الصفوف والأعمدة لمصفوفات ثنائية الأبعاد من عناصر غير عددية عشوائية، مثل السلاسل النصية:

julia> A = ["a" "b" "c"
            "d" "e" "f"]
2×3 Matrix{String}:
 "a"  "b"  "c"
 "d"  "e"  "f"

julia> permutedims(A)
3×2 Matrix{String}:
 "a"  "d"
 "b"  "e"
 "c"  "f"

و permutedims ينتج نتائج تختلف عن transpose للمصفوفات التي تكون عناصرها مصفوفات عددية بنفسها:

julia> a = [1 2; 3 4];

julia> b = [5 6; 7 8];

julia> c = [9 10; 11 12];

julia> d = [13 14; 15 16];

julia> X = [[a] [b]; [c] [d]]
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

julia> permutedims(X)
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [9 10; 11 12]
 [5 6; 7 8]  [13 14; 15 16]

julia> transpose(X)
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [9 11; 10 12]
 [5 7; 6 8]  [13 15; 14 16]

مصفوفات متعددة الأبعاد

julia> A = reshape(Vector(1:8), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

julia> perm = (3, 1, 2); # ضع البعد الأخير أولاً

julia> B = permutedims(A, perm)
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 5  6

[:, :, 2] =
 3  4
 7  8

julia> A == permutedims(B, invperm(perm)) # التبديل العكسي
true

بالنسبة لكل بعد i من B = permutedims(A, perm)، سيكون البعد المقابل له من A هو perm[i]. هذا يعني أن المساواة size(B, i) == size(A, perm[i]) صحيحة.

julia> A = randn(5, 7, 11, 13);

julia> perm = [4, 1, 3, 2];

julia> B = permutedims(A, perm);

julia> size(B)
(13, 5, 11, 7)

julia> size(A)[perm] == ans
true

permutedims(v::AbstractVector)

إعادة تشكيل المتجه v إلى مصفوفة صفية بحجم 1 × length(v). يختلف عن transpose في أن العملية ليست تكرارية، وهو ما يكون مفيدًا بشكل خاص للمصفوفات التي تحتوي على قيم غير عددية (حيث قد يؤدي transpose التكراري إلى حدوث خطأ).

أمثلة

على عكس transpose، يمكن استخدام permutedims على المتجهات التي تحتوي على عناصر غير عددية بشكل تعسفي، مثل السلاسل النصية:

julia> permutedims(["a", "b", "c"])
1×3 Matrix{String}:
 "a"  "b"  "c"

بالنسبة للمتجهات التي تحتوي على أرقام، يعمل permutedims(v) بشكل مشابه لـ transpose(v) باستثناء أن نوع الإرجاع يختلف (يستخدم reshape بدلاً من عرض LinearAlgebra.Transpose، على الرغم من أن كلاهما يشترك في الذاكرة مع المصفوفة الأصلية v):

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

julia> p = permutedims(v)
1×4 Matrix{Int64}:
 1  2  3  4

julia> r = transpose(v)
1×4 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3  4

julia> p == r
true

julia> typeof(r)
Transpose{Int64, Vector{Int64}}

julia> p[1] = 5; r[2] = 6; # تغيير p أو r يغير أيضًا v

julia> v # يشترك في الذاكرة مع كل من p و r
4-element Vector{Int64}:
 5
 6
 3
 4

ومع ذلك، تنتج permutedims نتائج تختلف عن transpose بالنسبة للمتجهات التي تكون عناصرها مصفوفات عددية بنفسها:

julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
2-element Vector{Matrix{Int64}}:
 [1 2; 3 4]
 [5 6; 7 8]

julia> permutedims(V)
1×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [5 6; 7 8]

julia> transpose(V)
1×2 transpose(::Vector{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [5 7; 6 8]

permutedims!(dest, src, perm)

قم بتبديل أبعاد المصفوفة src وتخزين النتيجة في المصفوفة dest. perm هو متجه يحدد تبديلًا بطول ndims(src). يجب أن تحتوي المصفوفة المخصصة مسبقًا dest على size(dest) == size(src)[perm] ويتم الكتابة عليها بالكامل. لا يتم دعم التبديل في المكان، وستحدث نتائج غير متوقعة إذا كانت src و dest لهما مناطق ذاكرة متداخلة.

انظر أيضًا permutedims.

PermutedDimsArray(A, perm) -> B

بالنظر إلى AbstractArray A، قم بإنشاء عرض B بحيث تبدو الأبعاد وكأنها تم تبديلها. مشابه لـ permutedims، باستثناء أنه لا يحدث نسخ (B تشارك التخزين مع A).

انظر أيضًا permutedims، invperm.

أمثلة

julia> A = rand(3,5,4);

julia> B = PermutedDimsArray(A, (3,1,2));

julia> size(B)
(4, 3, 5)

julia> B[3,1,2] == A[1,2,3]
true

promote_shape(s1, s2)

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

أمثلة

julia> a = fill(1, (3,4,1,1,1));

julia> b = fill(1, (3,4));

julia> promote_shape(a,b)
(Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))

julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
(2, 3, 1, 4, 1)

accumulate(op, A; dims::Integer, [init])

عملية تراكمية op على طول البعد dims من A (مع توفير dims كخيار إضافي للمتجهات). يمكن تقديم قيمة أولية init كخيار إضافي بواسطة وسيط كلمة. انظر أيضًا accumulate! لاستخدام مصفوفة مخرجات مُعدة مسبقًا، من أجل الأداء وللتحكم في دقة المخرجات (على سبيل المثال، لتجنب الفائض).

لعمليات شائعة هناك متغيرات متخصصة من accumulate، انظر cumsum، cumprod. للحصول على نسخة كسولة، انظر Iterators.accumulate.

أمثلة

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

julia> accumulate(min, (1, -2, 3, -4, 5), init=0)
(0, -2, -2, -4, -4)

julia> accumulate(/, (2, 4, Inf), init=100)
(50.0, 12.5, 0.0)

julia> accumulate(=>, i^2 for i in 1:3)
3-element Vector{Any}:
          1
        1 => 4
 (1 => 4) => 9

julia> accumulate(+, fill(1, 3, 4))
3×4 Matrix{Int64}:
 1  4  7  10
 2  5  8  11
 3  6  9  12

julia> accumulate(+, fill(1, 2, 5), dims=2, init=100.0)
2×5 Matrix{Float64}:
 101.0  102.0  103.0  104.0  105.0
 101.0  102.0  103.0  104.0  105.0

accumulate!(op, B, A; [dims], [init])

عملية تراكمية op على A على طول البعد dims، مع تخزين النتيجة في B. توفير dims اختياري بالنسبة للمتجهات. إذا تم إعطاء الوسيطة الرئيسية init، يتم استخدام قيمتها لتهيئة التراكم.

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

انظر أيضًا accumulate، cumsum!، cumprod!.

أمثلة

julia> x = [1, 0, 2, 0, 3];

julia> y = rand(5);

julia> accumulate!(+, y, x);

julia> y
5-element Vector{Float64}:
 1.0
 1.0
 3.0
 3.0
 6.0

julia> A = [1 2 3; 4 5 6];

julia> B = similar(A);

julia> accumulate!(-, B, A, dims=1)
2×3 Matrix{Int64}:
  1   2   3
 -3  -3  -3

julia> accumulate!(*, B, A, dims=2, init=10)
2×3 Matrix{Int64}:
 10   20    60
 40  200  1200

cumprod(A; dims::Integer)

المنتج التراكمي على طول البعد dim. انظر أيضًا cumprod! لاستخدام مصفوفة مخرجات مسبقة التخصيص، سواء من أجل الأداء أو للتحكم في دقة المخرجات (على سبيل المثال، لتجنب overflow).

أمثلة

julia> a = Int8[1 2 3; 4 5 6];

julia> cumprod(a, dims=1)
2×3 Matrix{Int64}:
 1   2   3
 4  10  18

julia> cumprod(a, dims=2)
2×3 Matrix{Int64}:
 1   2    6
 4  20  120

cumprod(itr)

حاصل الضرب التراكمي لمكرر.

انظر أيضًا cumprod!، accumulate، cumsum.

أمثلة

julia> cumprod(fill(1//2, 3))
3-element Vector{Rational{Int64}}:
 1//2
 1//4
 1//8

julia> cumprod((1, 2, 1, 3, 1))
(1, 2, 2, 6, 6)

julia> cumprod("julia")
5-element Vector{String}:
 "j"
 "ju"
 "jul"
 "juli"
 "julia"

cumprod!(B, A; dims::Integer)

المنتج التراكمي لـ A على طول البعد dims، مع تخزين النتيجة في B. انظر أيضًا cumprod.

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

cumprod!(y::AbstractVector, x::AbstractVector)

المنتج التراكمي لمتجه x، مع تخزين النتيجة في y. انظر أيضًا cumprod.

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

cumsum(A; dims::Integer)

مجموع تراكمي على البعد dims. انظر أيضًا cumsum! لاستخدام مصفوفة مخرجات مسبقة التخصيص، سواء من أجل الأداء أو للتحكم في دقة المخرجات (على سبيل المثال، لتجنب تجاوز السعة).

أمثلة

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

julia> cumsum(a, dims=1)
2×3 Matrix{Int64}:
 1  2  3
 5  7  9

julia> cumsum(a, dims=2)
2×3 Matrix{Int64}:
 1  3   6
 4  9  15

!!! ملاحظة نوع eltype لمصفوفة الإرجاع هو Int للأعداد الصحيحة الموقعة التي تقل عن حجم كلمة النظام و UInt للأعداد الصحيحة غير الموقعة التي تقل عن حجم كلمة النظام. للحفاظ على eltype للمصفوفات ذات الأعداد الصحيحة الصغيرة الموقعة أو غير الموقعة يجب استخدام accumulate(+, A).

```jldoctest
julia> cumsum(Int8[100, 28])
2-element Vector{Int64}:
 100
 128

julia> accumulate(+,Int8[100, 28])
2-element Vector{Int8}:
  100
 -128
```

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

cumsum(itr)

مجموع تراكمي لمكرر.

انظر أيضًا accumulate لتطبيق وظائف غير +.

أمثلة

julia> cumsum(1:3)
3-element Vector{Int64}:
 1
 3
 6

julia> cumsum((true, false, true, false, true))
(1, 1, 2, 2, 3)

julia> cumsum(fill(1, 2) for i in 1:3)
3-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]
 [3, 3]

cumsum!(B, A; dims::Integer)

مجموع تراكمي لـ A على طول البعد dims، مع تخزين النتيجة في B. انظر أيضًا cumsum.

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

diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)

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

أمثلة

julia> a = [2 4; 6 16]
2×2 Matrix{Int64}:
 2   4
 6  16

julia> diff(a, dims=2)
2×1 Matrix{Int64}:
  2
 10

julia> diff(vec(a))
3-element Vector{Int64}:
  4
 -2
 12

repeat(A::AbstractArray, counts::Integer...)

قم بإنشاء مصفوفة عن طريق تكرار المصفوفة A عددًا معينًا من المرات في كل بُعد، كما هو محدد بواسطة counts.

انظر أيضًا: fill, Iterators.repeated, Iterators.cycle.

أمثلة

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

julia> repeat([1, 2, 3], 2, 3)
6×3 Matrix{Int64}:
 1  1  1
 2  2  2
 3  3  3
 1  1  1
 2  2  2
 3  3  3

كرر(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))

قم بإنشاء مصفوفة عن طريق تكرار عناصر A. يحدد العنصر i من inner عدد المرات التي يجب تكرار العناصر الفردية من البعد i من A. يحدد العنصر i من outer عدد المرات التي يجب تكرار شريحة على البعد i من A. إذا تم حذف inner أو outer، فلن يتم إجراء أي تكرار.

أمثلة

julia> repeat(1:2, inner=2)
4-element Vector{Int64}:
 1
 1
 2
 2

julia> repeat(1:2, outer=2)
4-element Vector{Int64}:
 1
 2
 1
 2

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Matrix{Int64}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4

repeat(s::AbstractString, r::Integer)

كرر سلسلة r مرات. يمكن كتابة ذلك كـ s^r.

انظر أيضًا ^.

أمثلة

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

كرر حرفًا r مرات. يمكن تحقيق ذلك بشكل مكافئ عن طريق استدعاء c^r.

أمثلة

julia> repeat('A', 3)
"AAA"

rot180(A)

قم بتدوير المصفوفة A بزاوية 180 درجة.

أمثلة

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

julia> rot180(a)
2×2 Matrix{Int64}:
 4  3
 2  1

rot180(A, k)

قم بتدوير المصفوفة A بزاوية 180 درجة عدد صحيح k مرات. إذا كان k زوجيًا، فإن هذا يعادل copy.

أمثلة

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

julia> rot180(a,1)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rot180(a,2)
2×2 Matrix{Int64}:
 1  2
 3  4

rotl90(A)

قم بتدوير المصفوفة A لليسار بزاوية 90 درجة.

أمثلة

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

julia> rotl90(a)
2×2 Matrix{Int64}:
 2  4
 1  3

rotl90(A, k)

قم بتدوير المصفوفة A بزاوية 90 درجة عكس اتجاه عقارب الساعة عدد صحيح k من المرات. إذا كان k مضاعفًا لأربعة (بما في ذلك الصفر)، فإن هذا يعادل copy.

أمثلة

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

julia> rotl90(a,1)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotl90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotl90(a,3)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotl90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4

rotr90(A)

قم بتدوير المصفوفة A إلى اليمين بزاوية 90 درجة.

أمثلة

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

julia> rotr90(a)
2×2 Matrix{Int64}:
 3  1
 4  2

rotr90(A, k)

قم بتدوير المصفوفة A بزاوية 90 درجة في اتجاه عقارب الساعة عدد صحيح k من المرات. إذا كان k مضاعفًا لأربعة (بما في ذلك الصفر)، فإن هذا يعادل copy.

أمثلة

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

julia> rotr90(a,1)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotr90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotr90(a,3)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotr90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4

mapslices(f, A; dims)

حوّل الأبعاد المعطاة للمصفوفة A عن طريق تطبيق دالة f على كل شريحة من الشكل A[..., :, ..., :, ...]، مع وجود نقطتين في كل d في dims. يتم دمج النتائج على طول الأبعاد المتبقية.

على سبيل المثال، إذا كانت dims = [1,2] و A ذات 4 أبعاد، فإن f يتم استدعاؤها على x = A[:,:,i,j] لجميع i و j، و f(x) تصبح R[:,:,i,j] في النتيجة R.

انظر أيضًا eachcol أو eachslice، المستخدمة مع map أو stack.

أمثلة

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) with eltype Int64:
[:, :, 1] =
 1  3  5  7   9
 2  4  6  8  10

[:, :, 2] =
 11  13  15  17  19
 12  14  16  18  20

[:, :, 3] =
 21  23  25  27  29
 22  24  26  28  30

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # returns a 1×4 matrix

julia> B = mapslices(f, A, dims=(1,2))
1×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1

[:, :, 2] =
 11  11  11  11

[:, :, 3] =
 21  21  21  21

julia> f2(x::AbstractMatrix) = fill(x[1,1], 1,4);

julia> B == stack(f2, eachslice(A, dims=3))
true

julia> g(x) = x[begin] // x[end-1];  # returns a number

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

لاحظ أنه في eachslice(A; dims=2)، البعد المحدد هو الذي بدون نقطتين في الشريحة. هذا هو view(A,:,i,:)، بينما mapslices(f, A; dims=(1,3)) يستخدم A[:,i,:]. قد تقوم الدالة f بتغيير القيم في الشريحة دون التأثير على A.

eachrow(A::AbstractVecOrMat) <: AbstractVector

أنشئ كائن RowSlices الذي هو متجه من صفوف المصفوفة أو المتجه A. يتم إرجاع شرائح الصفوف كعرض AbstractVector لـ A.

للعكس، انظر stack(rows; dims=1).

انظر أيضًا eachcol، eachslice و mapslices.

أمثلة

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

julia> s = eachrow(a)
2-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2]
 [3, 4]

julia> s[1]
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

eachcol(A::AbstractVecOrMat) <: AbstractVector

أنشئ كائن ColumnSlices الذي هو متجه من أعمدة المصفوفة أو المتجه A. يتم إرجاع شرائح الأعمدة كعرض AbstractVector لـ A.

للعكس، انظر إلى stack(cols) أو reduce(hcat, cols).

انظر أيضًا eachrow، eachslice و mapslices.

أمثلة

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

julia> s = eachcol(a)
2-element ColumnSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}}:
 [1, 3]
 [2, 4]

julia> s[1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

eachslice(A::AbstractArray; dims, drop=true)

إنشاء كائن Slices الذي هو مصفوفة من الشرائح على الأبعاد dims من A، مع إرجاع وجهات تختار جميع البيانات من الأبعاد الأخرى في A. يمكن أن تكون dims إما عددًا صحيحًا أو مجموعة من الأعداد الصحيحة.

إذا كانت drop = true (الإعداد الافتراضي)، ستقوم Slices الخارجية بإسقاط الأبعاد الداخلية، وسيطابق ترتيب الأبعاد تلك الموجودة في dims. إذا كانت drop = false، فإن Slices ستحتفظ بنفس الأبعاد مثل المصفوفة الأساسية، مع وجود الأبعاد الداخلية بحجم 1.

انظر stack(slices; dims) لعكس eachslice(A; dims::Integer).

انظر أيضًا eachrow، eachcol، mapslices و selectdim.

أمثلة

julia> m = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> s = eachslice(m, dims=1)
3-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

julia> s[1]
3-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
 3

julia> eachslice(m, dims=1, drop=false)
3×1 Slices{Matrix{Int64}, Tuple{Int64, Colon}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}, 2}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

invperm(v)

إرجاع الترتيب العكسي لـ v. إذا كان B = A[v]، فإن A == B[invperm(v)].

انظر أيضًا sortperm، invpermute!، isperm، permutedims.

أمثلة

julia> p = (2, 3, 1);

julia> invperm(p)
(3, 1, 2)

julia> v = [2; 4; 3; 1];

julia> invperm(v)
4-element Vector{Int64}:
 4
 1
 3
 2

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

julia> B = A[v]
4-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> B[invperm(v)]
4-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

isperm(v) -> Bool

ارجع true إذا كان v ترتيبًا صالحًا.

أمثلة

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

قم بترتيب المتجه v في المكان، وفقًا للترتيب p. لا يتم إجراء أي تحقق للتأكد من أن p هو ترتيب.

لإرجاع ترتيب جديد، استخدم v[p]. هذا عمومًا أسرع من permute!(v, p)؛ من الأسرع حتى الكتابة في مصفوفة مخرجات مُعدة مسبقًا باستخدام u .= @view v[p]. (على الرغم من أن permute! يكتب فوق v في المكان، إلا أنه يتطلب داخليًا بعض التخصيص لتتبع العناصر التي تم نقلها.)

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

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

أمثلة

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> permute!(A, perm);

julia> A
4-element Vector{Int64}:
 1
 4
 3
 1

invpermute!(v, p)

مثل permute!، ولكن يتم تطبيق العكس من الترتيب المعطى.

لاحظ أنه إذا كان لديك مصفوفة مخرجات مُعدة مسبقًا (مثل u = similar(v))، فمن الأسرع استخدام u[p] = v. (invpermute! يقوم داخليًا بتخصيص نسخة من البيانات.)

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

أمثلة

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> invpermute!(A, perm);

julia> A
4-element Vector{Int64}:
 4
 1
 3
 1

reverse(A; dims=:)

عكس A على طول البعد dims، والذي يمكن أن يكون عددًا صحيحًا (بعد واحد)، أو مجموعة من الأعداد الصحيحة (مجموعة من الأبعاد) أو : (عكس على طول جميع الأبعاد، الافتراضي). انظر أيضًا reverse! للعكس في المكان.

أمثلة

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

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

julia> reverse(b)
2×2 Matrix{Int64}:
 4  3
 2  1

reverseind(v, i)

بالنظر إلى فهرس i في reverse(v)، أعد الفهرس المقابل في v بحيث يكون v[reverseind(v,i)] == reverse(v)[i]. (يمكن أن يكون هذا غير تافه في الحالات التي تحتوي فيها v على أحرف غير ASCII.)

أمثلة

julia> s = "Julia🚀"
"Julia🚀"

julia> r = reverse(s)
"🚀ailuJ"

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀

reverse!(v [, start=firstindex(v) [, stop=lastindex(v) ]]) -> v

نسخة في المكان من reverse.

أمثلة

julia> A = Vector(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> reverse!(A);

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

reverse!(A; dims=:)

مثل reverse، ولكنه يعمل في المكان في A.