Julia 1.0 - Sparse Arrays

विरल Arrays




julia

विरल Arrays

जूलिया को SparseArrays stdlib मॉड्यूल में विरल वैक्टर और विरल SparseArrays समर्थन है। विरल सरणियाँ वे सरणियाँ हैं जिनमें पर्याप्त शून्य होते हैं जो उन्हें एक विशेष डेटा संरचना में संग्रहीत करते हैं, घने सरणियों की तुलना में अंतरिक्ष और निष्पादन समय में बचत करते हैं।

संपीड़ित विरल स्तंभ (CSC) विरल मैट्रिक्स संग्रहण

जूलिया में, स्पार्स मैट्रिसेस को कंप्रेस्ड स्पार्स कॉलम (सीएससी) प्रारूप में संग्रहीत किया जाता है। जूलिया विरल SparseMatrixCSC{Tv,Ti} टाइप होता है, जहां Tv संग्रहित मानों का प्रकार होता है, और Ti स्तंभ बिंदुओं और पंक्ति सूचकांकों को संग्रहीत करने के लिए पूर्णांक प्रकार होता है। SparseMatrixCSC का आंतरिक प्रतिनिधित्व इस प्रकार है:

struct SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}
    m::Int                  # Number of rows
    n::Int                  # Number of columns
    colptr::Vector{Ti}      # Column i is in colptr[i]:(colptr[i+1]-1)
    rowval::Vector{Ti}      # Row indices of stored values
    nzval::Vector{Tv}       # Stored values, typically nonzeros
end

संपीड़ित विरल कॉलम का भंडारण विरल मैट्रिक्स के कॉलम में तत्वों तक पहुंचने के लिए आसान और त्वरित बनाता है, जबकि पंक्तियों द्वारा विरल मैट्रिक्स तक पहुंच काफी धीमी होती है। सीएससी संरचना में एक समय में पहले से अस्थिर प्रविष्टियों के सम्मिलन जैसे संचालन धीमी गति से होते हैं। ऐसा इसलिए है क्योंकि विरल मैट्रिक्स के सभी तत्व जो सम्मिलन के बिंदु से परे हैं, उन्हें एक स्थान पर ले जाना होगा।

प्रदर्शन के लिए सीएससी डेटा संरचना का फायदा उठाने और महंगे संचालन से बचने के लिए विरल मैट्रिस पर सभी परिचालन सावधानीपूर्वक लागू होते हैं।

यदि आपके पास किसी भिन्न एप्लिकेशन या लाइब्रेरी से CSC प्रारूप में डेटा है, और इसे जूलिया में आयात करना चाहते हैं, तो सुनिश्चित करें कि आप 1-आधारित इंडेक्सिंग का उपयोग करते हैं। हर कॉलम में पंक्ति सूचकांकों को क्रमबद्ध करने की आवश्यकता होती है। यदि आपकी SparseMatrixCSC ऑब्जेक्ट में पंक्तिबद्ध इंडेक्स हैं, तो उन्हें सॉर्ट करने का एक त्वरित तरीका एक डबल ट्रांज़ोज़ करना है।

कुछ अनुप्रयोगों में, SparseMatrixCSC में स्पष्ट शून्य मान संग्रहीत करना सुविधाजनक है। Base में कार्यों द्वारा इन्हें स्वीकार किया जाता है (लेकिन इस बात की कोई गारंटी नहीं है कि इन्हें परिवर्तन संचालन में संरक्षित किया जाएगा)। इस तरह के स्पष्ट रूप से संग्रहीत शून्य को कई रूटीनों द्वारा संरचनात्मक गैर-अक्षरा के रूप में माना जाता है। nnz फ़ंक्शन संरचनात्मक गैर-अक्ष सहित स्पार्स डेटा संरचना में स्पष्ट रूप से संग्रहीत तत्वों की संख्या लौटाता है। संख्यात्मक नॉनज़रोज़ की सटीक संख्या की गणना करने के लिए, count(!iszero, x) , जो एक विरल मैट्रिक्स के प्रत्येक संग्रहीत तत्व का निरीक्षण करता है। dropzeros , और इन-प्लेस dropzeros! , विरल मैट्रिक्स से संग्रहीत शून्य को हटाने के लिए उपयोग किया जा सकता है।

julia> A = sparse([1, 2, 3], [1, 2, 3], [0, 2, 0])
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  0
  [2, 2]  =  2
  [3, 3]  =  0

julia> dropzeros(A)
3×3 SparseMatrixCSC{Int64,Int64} with 1 stored entry:
  [2, 2]  =  2

विरल वेक्टर भंडारण

विरल वैक्टरों को स्पार्स मैट्रीस के लिए विरल स्तंभ प्रारूप को संपीड़ित करने के लिए एक करीबी एनालॉग में संग्रहीत किया जाता है। जूलिया में, विरल वैक्टर में SparseVector{Tv,Ti} का प्रकार होता है, जहां Tv संग्रहीत मानों का प्रकार होता है और सूचकांकों के लिए पूर्णांक प्रकार Ti होता है। आंतरिक प्रतिनिधित्व इस प्रकार है:

struct SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}
    n::Int              # Length of the sparse vector
    nzind::Vector{Ti}   # Indices of stored values
    nzval::Vector{Tv}   # Stored values, typically nonzeros
end

SparseMatrixCSC{Tv,Ti} रूप में, SparseVector प्रकार में स्पष्ट रूप से संग्रहीत शून्य भी हो सकते हैं। ( स्पार्स मैट्रिक्स स्टोरेज देखें।)

विरल वेक्टर और मैट्रिक्स कंस्ट्रक्टर्स

एक विरल सरणी बनाने का सबसे सरल तरीका zeros फ़ंक्शन के बराबर फ़ंक्शन का उपयोग करना है जो जूलिया घने सरणियों के साथ काम करने के लिए प्रदान करता है। इसके बजाय एक विरल सरणी का उत्पादन करने के लिए, आप उसी नाम का उपयोग कर सकते हैं जिसमें sp उपसर्ग हो

julia> spzeros(3)
3-element SparseVector{Float64,Int64} with 0 stored entries

sparse फ़ंक्शन अक्सर स्पार्स सरणियों के निर्माण का एक आसान तरीका है। उदाहरण के लिए, एक विरल मैट्रिक्स के निर्माण के लिए हम पंक्ति सूचकांकों का एक वेक्टर I , स्तंभ सूचकांकों का एक वेक्टर J और संग्रहीत मानों का एक वेक्टर V इनपुट कर सकते हैं (इसे COO (निर्देशांक) प्रारूप के रूप में भी जाना जाता है)। sparse(I,J,V) तब एक विरल मैट्रिक्स का निर्माण करता है जैसे कि S[I[k], J[k]] = V[k] । समतुल्य विरल वेक्टर कंस्ट्रक्टर विरल है, जो संग्रहीत मानों के साथ पंक्ति (पंक्ति) सूचकांक वेक्टर I और वेक्टर V लेता है और विरल वेक्टर R निर्माण करता है, जैसे R[I[k]] = V[k]

julia> I = [1, 4, 3, 5]; J = [4, 7, 18, 9]; V = [1, 2, -5, 3];

julia> S = sparse(I,J,V)
5×18 SparseMatrixCSC{Int64,Int64} with 4 stored entries:
  [1 ,  4]  =  1
  [4 ,  7]  =  2
  [5 ,  9]  =  3
  [3 , 18]  =  -5

julia> R = sparsevec(I,V)
5-element SparseVector{Int64,Int64} with 4 stored entries:
  [1]  =  1
  [3]  =  -5
  [4]  =  2
  [5]  =  3

sparse और sparse फ़ंक्शंस का findnz , जो स्पार्स सरणी बनाने के लिए उपयोग किए गए इनपुट को पुनः प्राप्त करता है। findall(!iszero, x) में शून्य-शून्य प्रविष्टियों के कार्टेशियन सूचकांकों को लौटाता है (जिसमें संग्रहीत प्रविष्टियाँ शून्य के बराबर होती हैं)।

julia> findnz(S)
([1, 4, 5, 3], [4, 7, 9, 18], [1, 2, 3, -5])

julia> findall(!iszero, S)
4-element Array{CartesianIndex{2},1}:
 CartesianIndex(1, 4)
 CartesianIndex(4, 7)
 CartesianIndex(5, 9)
 CartesianIndex(3, 18)

julia> findnz(R)
([1, 3, 4, 5], [1, -5, 2, 3])

julia> findall(!iszero, R)
4-element Array{Int64,1}:
 1
 3
 4
 5

विरल सरणी बनाने का दूसरा तरीका यह है कि विरल सरणी को sparse फ़ंक्शन का उपयोग करके एक विरल सरणी में परिवर्तित किया जाए:

julia> sparse(Matrix(1.0I, 5, 5))
5×5 SparseMatrixCSC{Float64,Int64} with 5 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0
  [4, 4]  =  1.0
  [5, 5]  =  1.0

julia> sparse([1.0, 0.0, 1.0])
3-element SparseVector{Float64,Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0

आप Array कंस्ट्रक्टर का उपयोग करके दूसरी दिशा में जा सकते हैं। मैट्रिक्स के विरल होने पर क्वेरी फ़ंक्शन का उपयोग क्वेरी के लिए किया जा सकता है।

julia> issparse(spzeros(5))
true

विरल मैट्रिक्स ऑपरेशन

विरल मैट्रिस पर अंकगणित संचालन भी काम करते हैं क्योंकि वे घने मैट्रीस पर करते हैं। में, असाइनमेंट का अनुक्रमण, और विरल मैट्रिसेस का संघनन उसी तरह काम करता है जैसे घने मैट्रिस। अनुक्रमण संचालन, विशेष रूप से असाइनमेंट, महंगे होते हैं, जब एक समय में एक तत्व किया जाता है। कई मामलों में विरल मैट्रिक्स (I,J,V) फॉर्मेट को findnz का उपयोग करके परिवर्तित करना बेहतर हो सकता है, घने वैक्टर (I,J,V) में मानों या संरचना को findnz , और फिर विरल मैट्रिक्स को फिर से संगठित करते हैं।

घने और विरल तरीकों का पत्राचार

निम्न तालिका विरल मैट्रिक्स पर निर्मित विधियों और घने मैट्रिक्स प्रकारों पर उनके संबंधित तरीकों के बीच एक पत्राचार देती है। सामान्य तौर पर, विरल मैट्रिक्स उत्पन्न करने वाली विधियां उनके घने समकक्षों से भिन्न होती हैं, जिसके परिणामस्वरूप मैट्रिक्स एक दिए गए विरल मैट्रिक्स S रूप में समान स्पार्सिटी पैटर्न का अनुसरण करता है, या जिसके परिणामस्वरूप स्पार्स मैट्रिक्स में घनत्व d , अर्थात प्रत्येक मैट्रिक्स तत्व की संभावना d । गैर शून्य।

विवरण मानक पुस्तकालय संदर्भ के विरल क्षेत्र और मैट्रिक्स खंड में पाया जा सकता है।

विरल सघन विवरण
spzeros(m,n) zeros शून्य का एक mby- n मैट्रिक्स बनाता है। ( spzeros(m,n) खाली है।)
sparse Matrix(I,n,n) एक n -by- n पहचान मैट्रिक्स बनाता है।
Array sparse घने और विरल स्वरूपों के बीच परस्पर संबंध।
sprand(m,n,d) rand(m,n) आधे-खुले अंतराल $ [0, 1) $ पर समान रूप से वितरित iid गैर-शून्य तत्वों के साथ एक mby- n यादृच्छिक मैट्रिक्स (घनत्व डी का ) बनाता है।
sprandn(m,n,d) randn(m,n) मानक सामान्य (गाऊसी) वितरण के अनुसार वितरित ईद गैर-शून्य तत्वों के साथ एक mby- n यादृच्छिक मैट्रिक्स (घनत्व डी का ) बनाता है।
sprandn(m,n,d) randn(m,n) X वितरण के अनुसार वितरित iid गैर-शून्य तत्वों के साथ एक mby- n यादृच्छिक मैट्रिक्स (घनत्व डी का ) बनाता है। ( Distributions पैकेज की आवश्यकता है।)

विरल Arrays

SparseArrays.SparseVector प्रकार

SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}

वेक्टर विरल भंडारण के लिए वेक्टर प्रकार।

source

SparseArrays.SparseMatrixCSC प्रकार

SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}

संपीड़ित विरल कॉलम फॉर्मेट में विरल मैट्रिस के भंडारण के लिए मैट्रिक्स प्रकार।

source

SparseArrays.sparse फ़ंक्शन

sparse(A)

एक AbstractMatrix A एक विरल मैट्रिक्स में परिवर्तित करें।

उदाहरण

julia> A = Matrix(1.0I, 3, 3)
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> sparse(A)
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0
source
sparse(I, J, V,[ m, n, combine])

आयामों का एक विरल मैट्रिक्स S बनाएँ, जैसे कि S[I[k], J[k]] = V[k] । डुप्लिकेट को संयोजित करने के लिए combine फ़ंक्शन का उपयोग किया जाता है। यदि m और n निर्दिष्ट नहीं हैं, तो वे क्रमशः maximum(I) और maximum(J) हैं। यदि combine फंक्शन की आपूर्ति नहीं की जाती है, तो डिफ़ॉल्ट को + तब तक मिलाएं जब तक V के तत्व बूलियन नहीं होते हैं, जिस स्थिति में डिफॉल्ट का combine होता है |I सभी तत्वों को 1 <= I[k] <= m , और J सभी तत्वों को 1 <= J[k] <= n संतुष्ट करना होगा। संख्यात्मक शून्य में ( I , J , V ) संरचनात्मक गैर-अक्ष के रूप में बनाए रखा जाता है; संख्यात्मक शून्य को छोड़ने के लिए, dropzeros! उपयोग dropzeros!

अतिरिक्त प्रलेखन और एक विशेषज्ञ ड्राइवर के लिए, Base.SparseArrays.sparse! देखें Base.SparseArrays.sparse!

उदाहरण

julia> Is = [1; 2; 3];

julia> Js = [1; 2; 3];

julia> Vs = [1; 2; 3];

julia> sparse(Is, Js, Vs)
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  1
  [2, 2]  =  2
  [3, 3]  =  3
source

SparseArrays.sparsevec फ़ंक्शन

sparsevec(I, V, [m, combine])

लंबाई m का एक विरल सदिश बनाएँ जैसे कि S[I[k]] = V[k] । डुप्लिकेट को combine फ़ंक्शन का उपयोग करके combine है, जो कि + को डिफॉल्ट करता है यदि कोई combine तर्क प्रदान नहीं किया जाता है, जब तक कि V के तत्व बूलियन नहीं होते हैं तो किस मामले में डिफॉल्ट को combine |

उदाहरण

julia> II = [1, 3, 3, 5]; V = [0.1, 0.2, 0.3, 0.2];

julia> sparsevec(II, V)
5-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  0.5
  [5]  =  0.2

julia> sparsevec(II, V, 8, -)
8-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  -0.1
  [5]  =  0.2

julia> sparsevec([1, 3, 1, 2, 2], [true, true, false, false, false])
3-element SparseVector{Bool,Int64} with 3 stored entries:
  [1]  =  true
  [2]  =  false
  [3]  =  true
source
sparsevec(d::Dict, [m])

लंबाई m का एक विरल वेक्टर बनाएं जहां नॉनज़रो इंडेक्स डिक्शनरी से चाबियाँ हैं, और नॉनज़रो वैल्यू शब्दकोश से मान हैं।

उदाहरण

julia> sparsevec(Dict(1 => 3, 2 => 2))
2-element SparseVector{Int64,Int64} with 2 stored entries:
  [1]  =  3
  [2]  =  2
source
sparsevec(A)

वेक्टर A को लंबाई m विरल वेक्टर में परिवर्तित करें।

उदाहरण

julia> sparsevec([1.0, 2.0, 0.0, 0.0, 3.0, 0.0])
6-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  2.0
  [5]  =  3.0
source

SparseArrays.issparse फ़ंक्शन

issparse(S)

true अगर S विरल है, और अन्यथा false

उदाहरण

julia> sv = sparsevec([1, 4], [2.3, 2.2], 10)
10-element SparseVector{Float64,Int64} with 2 stored entries:
  [1 ]  =  2.3
  [4 ]  =  2.2

julia> issparse(sv)
true

julia> issparse(Array(sv))
false
source

SparseArrays.nnz फ़ंक्शन

nnz(A)

एक विरल सरणी में संग्रहीत (भरे हुए) तत्वों की संख्या लौटाता है।

उदाहरण

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2

julia> nnz(A)
3
source

SparseArrays.findnz फ़ंक्शन

findnz(A)

एक टपल लौटाएं (I, J, V) जहां I और J , स्पार्स मैट्रिक्स A में संग्रहीत ("संरचनात्मक रूप से गैर-शून्य") मानों की पंक्ति और स्तंभ सूचक हैं, और V मानों का एक वेक्टर है।

उदाहरण

julia> A = sparse([1 2 0; 0 0 3; 0 4 0])
3×3 SparseMatrixCSC{Int64,Int64} with 4 stored entries:
  [1, 1]  =  1
  [1, 2]  =  2
  [3, 2]  =  4
  [2, 3]  =  3

julia> findnz(A)
([1, 1, 3, 2], [1, 2, 2, 3], [1, 2, 4, 3])
source

SparseArrays.spzeros फ़ंक्शन

spzeros([type,]m[,n])

आकार mxn की लंबाई m या विरल मैट्रिक्स का एक विरल वेक्टर बनाएँ। इस विरल सरणी में कोई भी गैर-मान नहीं होगा। निर्माण के दौरान गैर-भंडारण मूल्यों के लिए कोई भंडारण आवंटित नहीं किया जाएगा। यदि निर्दिष्ट नहीं है, तो प्रकार Float64 लिए डिफॉल्ट करता है।

उदाहरण

julia> spzeros(3, 3)
3×3 SparseMatrixCSC{Float64,Int64} with 0 stored entries

julia> spzeros(Float32, 4)
4-element SparseVector{Float32,Int64} with 0 stored entries
source

SparseArrays.spdiagm फ़ंक्शन

spdiagm(kv::Pair{<:Integer,<:AbstractVector}...)

वैक्टर और विकर्णों की Pair से एक चौकोर विरल विकर्ण मैट्रिक्स का निर्माण करें। वेक्टर kv.second को kv.first विकर्ण पर रखा जाएगा।

उदाहरण

julia> spdiagm(-1 => [1,2,3,4], 1 => [4,3,2,1])
5×5 SparseMatrixCSC{Int64,Int64} with 8 stored entries:
  [2, 1]  =  1
  [1, 2]  =  4
  [3, 2]  =  2
  [2, 3]  =  3
  [4, 3]  =  3
  [3, 4]  =  2
  [5, 4]  =  4
  [4, 5]  =  1
source

SparseArrays.blockdiag फ़ंक्शन

blockdiag(A...)

सम्‍मिलित मैट्रिक्‍स ब्‍लॉक-तिरछे। वर्तमान में केवल विरल मैट्रिस के लिए लागू किया गया है।

उदाहरण

julia> blockdiag(sparse(2I, 3, 3), sparse(4I, 2, 2))
5×5 SparseMatrixCSC{Int64,Int64} with 5 stored entries:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2
  [4, 4]  =  4
  [5, 5]  =  4
source

SparseArrays.sprand फ़ंक्शन

sprand([rng],[type],m,[n],p::AbstractFloat,[rfn])

n विरल मैट्रिक्स द्वारा एक यादृच्छिक लंबाई m विरल वेक्टर या m बनाएं, जिसमें किसी भी तत्व के नॉनजेरो होने की संभावना स्वतंत्र रूप से p द्वारा दी गई है (और इसलिए गैर-अक्ष का घनत्व भी बिल्कुल p )। Nonzero मानों को rfn द्वारा निर्दिष्ट वितरण से rfn और उनका प्रकार type । वर्दी वितरण का उपयोग उस स्थिति में किया जाता है जब rfn निर्दिष्ट नहीं होता है। वैकल्पिक rng तर्क यादृच्छिक संख्या जनरेटर को निर्दिष्ट करता है, यादृच्छिक संख्याएँ देखें।

उदाहरण

julia> sprand(Bool, 2, 2, 0.5)
2×2 SparseMatrixCSC{Bool,Int64} with 2 stored entries:
  [1, 1]  =  true
  [2, 1]  =  true

julia> sprand(Float64, 3, 0.75)
3-element SparseVector{Float64,Int64} with 1 stored entry:
  [3]  =  0.298614
source

SparseArrays.sprandn फ़ंक्शन

sprandn([rng], m[,n],p::AbstractFloat)

किसी भी प्रविष्टि के नॉनज़रो के निर्दिष्ट (स्वतंत्र) होने की संभावना के साथ n द्वारा लंबाई m या आकार m विरल मैट्रिक्स का एक यादृच्छिक विरल वेक्टर बनाएँ, जहाँ नॉनज़रो मानों को सामान्य वितरण से मापा जाता है। वैकल्पिक rng तर्क यादृच्छिक संख्या जनरेटर को निर्दिष्ट करता है, यादृच्छिक संख्याएँ देखें।

उदाहरण

julia> sprandn(2, 2, 0.75)
2×2 SparseMatrixCSC{Float64,Int64} with 2 stored entries:
  [1, 1]  =  0.586617
  [1, 2]  =  0.297336
source

SparseArrays.nonzeros फ़ंक्शन

nonzeros(A)

विरल सरणी A में संरचनात्मक गैर-अक्षीय मानों का एक वेक्टर लौटाएं। इसमें शून्य शामिल हैं जो स्पष्ट रूप से विरल सरणी में संग्रहीत हैं। लौटा हुआ वेक्टर सीधे A के आंतरिक नॉनज़रो स्टोरेज की ओर इशारा करता है, और लौटे वेक्टर में कोई भी संशोधन A को भी बदल देगा। rowvals और nzrange देखें।

उदाहरण

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2

julia> nonzeros(A)
3-element Array{Int64,1}:
 2
 2
 2
source

SparseArrays.rowvals फ़ंक्शन

rowvals(A::SparseMatrixCSC)

A के पंक्ति सूचकांकों का एक वेक्टर लौटाएं। लौटे हुए वेक्टर में कोई भी संशोधन A को भी बदल देगा। पंक्ति सूचकांकों को आंतरिक रूप से कैसे संग्रहीत किया जाता है, इस तक पहुंच प्रदान करना संरचनात्मक नॉनजेरो मूल्यों पर पुनरावृत्ति के साथ उपयोगी हो सकता है। nonzeros और nzrange भी देखें।

उदाहरण

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  2
  [2, 2]  =  2
  [3, 3]  =  2

julia> rowvals(A)
3-element Array{Int64,1}:
 1
 2
 3
source

SparseArrays.nzrange फंक्शन

nzrange(A::SparseMatrixCSC, col::Integer)

एक विरल मैट्रिक्स कॉलम के संरचनात्मक नॉनज़ेरो मूल्यों के लिए सूचकांकों की सीमा लौटाएं। nonzeros - nonzeros और rowvals के साथ संयोजन में, यह एक विरल मैट्रिक्स पर सुविधाजनक पुनरावृत्ति की अनुमति देता है:

A = sparse(I,J,V)
rows = rowvals(A)
vals = nonzeros(A)
m, n = size(A)
for i = 1:n
   for j in nzrange(A, i)
      row = rows[j]
      val = vals[j]
      # perform sparse wizardry...
   end
end
source

SparseArrays.dropzeros! समारोह

dropzeros!(A::SparseMatrixCSC; trim::Bool = true)

A से संग्रहीत संख्यात्मक शून्य हटाता है, वैकल्पिक रूप से ट्रिमिंग के A.rowval होने पर A.rowvalA.rowval और A.nzval से अतिरिक्त स्थान प्राप्त A.rowval true

एक आउट-ऑफ- dropzeros -जगह संस्करण के लिए, dropzeros देखें। एल्गोरिदमिक जानकारी के लिए, fkeep! देखें fkeep!

source
dropzeros!(x::SparseVector; trim::Bool = true)

x से संग्रहीत संख्यात्मक शून्य हटाता है, वैकल्पिक रूप से ट्रिमिंग trim true होने पर x.nzind और x.nzval से अतिरिक्त स्थान प्राप्त x.nzind true

एक आउट-ऑफ- dropzeros -जगह संस्करण के लिए, dropzeros देखें। एल्गोरिदमिक जानकारी के लिए, fkeep! देखें fkeep!

source

SparseArrays.dropzeros फ़ंक्शन

dropzeros(A::SparseMatrixCSC; trim::Bool = true)

A की A प्रति rowval और उस प्रति से संग्रहीत संख्यात्मक शून्य को हटाता है, trim के true होने पर nzval की rowval और nzval सरणियों से वैकल्पिक रूप से अतिरिक्त स्थान को trim है।

इन-प्लेस संस्करण और एल्गोरिदमिक जानकारी के लिए, dropzeros! देखें dropzeros!

उदाहरण

julia> A = sparse([1, 2, 3], [1, 2, 3], [1.0, 0.0, 1.0])
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  0.0
  [3, 3]  =  1.0

julia> dropzeros(A)
3×3 SparseMatrixCSC{Float64,Int64} with 2 stored entries:
  [1, 1]  =  1.0
  [3, 3]  =  1.0
source
dropzeros(x::SparseVector; trim::Bool = true)

x की एक प्रति nzind और उस प्रति से संख्यात्मक शून्य हटाता है, जब trim true होता true , तो परिणाम के nzind और nzval सरणियों से वैकल्पिक रूप से अतिरिक्त स्थान को trim है।

इन-प्लेस संस्करण और एल्गोरिदमिक जानकारी के लिए, dropzeros! देखें dropzeros!

उदाहरण

julia> A = sparsevec([1, 2, 3], [1.0, 0.0, 1.0])
3-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  0.0
  [3]  =  1.0

julia> dropzeros(A)
3-element SparseVector{Float64,Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0
source

SparseArrays.permute फ़ंक्शन

permute(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
        q::AbstractVector{<:Integer}) where {Tv,Ti}

द्विपक्षीय रूप से परमिट A , PAQ ( A[p,q] ) लौटाता है। कॉलम-क्रमपरिवर्तन q की लंबाई A के कॉलम की गिनती ( length(q) == An ) से मेल खाना चाहिए। पंक्ति-क्रमपरिवर्तन p की लंबाई A की पंक्ति गणना ( length(p) == Am ) से मेल खाना चाहिए।

विशेषज्ञ ड्राइवरों और अतिरिक्त जानकारी के लिए, permute! देखें permute!

उदाहरण

julia> A = spdiagm(0 => [1, 2, 3, 4], 1 => [5, 6, 7])
4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
  [1, 1]  =  1
  [1, 2]  =  5
  [2, 2]  =  2
  [2, 3]  =  6
  [3, 3]  =  3
  [3, 4]  =  7
  [4, 4]  =  4

julia> permute(A, [4, 3, 2, 1], [1, 2, 3, 4])
4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
  [4, 1]  =  1
  [3, 2]  =  2
  [4, 2]  =  5
  [2, 3]  =  3
  [3, 3]  =  6
  [1, 4]  =  4
  [2, 4]  =  7

julia> permute(A, [1, 2, 3, 4], [4, 3, 2, 1])
4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
  [3, 1]  =  7
  [4, 1]  =  4
  [2, 2]  =  6
  [3, 2]  =  3
  [1, 3]  =  5
  [2, 3]  =  2
  [1, 4]  =  1
source

Base.permute! तरीका

permute!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
         [C::SparseMatrixCSC{Tv,Ti}]) where {Tv,Ti}

द्विपक्षीय रूप से अनुमति A , एक्स में पीएक्यू ( A[p,q] ) का भंडारण। यदि वैकल्पिक हो तो C इंटरमीडिएट रिजल्ट (AQ)^T ( transpose(A[:,q]) )। यह आवश्यक है कि कोई भी X , A और, यदि मौजूद हो, C एक-दूसरे को उर्फ; PAQ वापस A में स्टोर करने के लिए, निम्नलिखित विधि का उपयोग करें जिसमें X कमी है:

permute!(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
         q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti},
         [workcolptr::Vector{Ti}]]) where {Tv,Ti}

X के आयामों को A ( Xm == Am और Xn == An ) से मेल खाना चाहिए, और X पास A ( length(X.rowval) >= nnz(A) और length(X.nzval) >= nnz(A) length(X.rowval) >= nnz(A) में सभी आवंटित प्रविष्टियों को समायोजित करने के लिए पर्याप्त भंडारण होना चाहिए length(X.nzval) >= nnz(A) )। कॉलम-क्रमपरिवर्तन q की लंबाई A के कॉलम की गिनती ( length(q) == An ) से मेल खाना चाहिए। पंक्ति-क्रमपरिवर्तन p की लंबाई A की पंक्ति गणना ( length(p) == Am ) से मेल खाना चाहिए।

C के आयामों को transpose(A) ( Cm == An और Cn == Am ) से मेल खाना चाहिए, और C पास A ( length(C.rowval) >= nnz(A) में सभी आवंटित प्रविष्टियों को समायोजित करने के लिए पर्याप्त संग्रहण होना चाहिए और length(C.nzval) >= nnz(A) )।

अतिरिक्त (एल्गोरिथम) जानकारी के लिए, और इन विधियों के संस्करणों के लिए जो तर्क की जाँच से गुजरते हैं, देखें (अस्पष्टीकृत) मूल तरीके unchecked_noalias_permute! और unchecked_aliasing_permute!

यह भी देखें: permute

source