जूलिया: कस्टम प्रकार

इस लेख में, हम जूलिया कार्यक्रम में एक कस्टम डेटा प्रकार जोड़ने और नए प्रकार के साथ सुविधाजनक काम के लिए मानक कार्यों को ओवरलोड करने पर विचार करेंगे।

एक कस्टम प्रकार क्या है

एक भयानक रहस्य - जूलिया में "उपयोगकर्ता" और "अंतर्निहित" डेटा प्रकारों के बीच की सीमा व्यावहारिक रूप से अनुपस्थित है। किसी भी जूलिया कार्यक्रम में, आप अपने स्वयं के डेटा प्रकारों को परिभाषित कर सकते हैं, और उनके साथ काम करना बिल्ट-इन डेटा के साथ काम करने से या तो कोड लिखने के संदर्भ में या इस कोड के निष्पादन की गति के संदर्भ में (हेलो, पायथन) से अलग नहीं है। इनपुट डेटा प्रकार या तो आदिम या समग्र हो सकते हैं। उत्तरार्द्ध को भी सार और ठोस प्रकारों में विभाजित किया गया है।

इसके अलावा, हम मिश्रित ठोस प्रकारों के उदाहरण पर विचार करेंगे स्मृति में विशिष्ट वस्तुएँ विशिष्ट प्रकार की होती हैं, और सार वस्तुओं का निर्माण केवल एक पदानुक्रम बनाने के लिए किया जाता है।

कंपोजिट प्रकार को कीवर्ड struct और mutable struct द्वारा परिभाषित किया जाता है। पहले मामले में, एक अपरिवर्तनीय प्रकार बनाया जाता है:

 #    x  y struct Point x y end 

टाइप Point की वस्तुएं अपरिवर्तनीय हैं, अर्थात एक बार बनाई गई वस्तु में फ़ील्ड मान नहीं बदला जा सकता है।

 julia> p = Point(2, 3) Point(2, 3) julia> px 2 julia> py 3 julia> px = 4 ERROR: setfield! immutable struct of type Point cannot be changed 

लेकिन आप एक परिवर्तनशील प्रकार बना सकते हैं:

 mutable struct MutablePoint x y end julia> mp = MutablePoint(3, 4) MutablePoint(3, 4) julia> mp.y = 2 2 julia> mp MutablePoint(3, 2) 

दक्षता के लिए, टाइप एनोटेशन को संरचना क्षेत्रों और संरचना में जोड़ा जा सकता है। उदाहरण के लिए:

 struct ParametricPoint{T<:Real} x::T y::T end 

इसका मतलब यह है कि टाइप ParametricPoint T द्वारा टाइप की गई है और फ़ील्ड x और y को अब उसी प्रकार के मानों के समान होना चाहिए T व्यवहार इस प्रकार होगा:

 julia> ParametricPoint(1, 1) ParametricPoint{Int64}(1, 1) julia> ParametricPoint{Float64}(1, 1) ParametricPoint{Float64}(1.0, 1.0) julia> ParametricPoint{Rational}(1, 1) ParametricPoint{Rational}(1//1, 1//1) # :        T julia> ParametricPoint{Int}(1, 3.4) ERROR: InexactError: Int64(3.4) # :    julia> ParametricPoint(1, 1.0) ERROR: MethodError: no method matching Point(::Int64, ::Float64) # :  T      julia> ParametricPoint{Any}(1,1) ERROR: TypeError: in Point, in T, expected T<:Real, got Type{Any} 

इसके बाद, कंटेनर प्रकार के कुछ अधिक जटिल उदाहरणों को देखें कि इस प्रकार के साथ काम करने के लिए मानक पुस्तकालय में क्या तरीके हैं।

दो तरफा कतार

हम DequeNode प्रकार के नोड्स से दो तरफ़ा कतार DequeNode , जिसमें कतार के पिछले और अगले तत्वों का डेटा रिकॉर्ड और लिंक शामिल होंगे। DequeNode का प्रकार परिवर्तनशील होना चाहिए, क्योंकि लिंक को फिर से लिखना होगा।

 mutable struct DequeNode{T} data::T prev::DequeNode{T} next::DequeNode{T} #   -       function DequeNode{T}() where T node = new{T}() node.prev = node.next = node return node end #     function DequeNode{T}(x) where T node = new{T}() node.data = x node.prev = node.next = node return node end end 

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

कतार को एक काल्पनिक "इनपुट" नोड के रूप में दर्शाया जा सकता है जिसमें कोई डेटा नहीं होता है। इसकी next कड़ी कतार के पहले तत्व की ओर इशारा करेगी, और prev तक रहेगी। खाली कतार के लिए, दोनों लिंक इनपुट नोड को इंगित करते हैं। ऐसा संगठन नोड्स को जोड़ने और हटाने के लिए प्रक्रियाओं को सरल करता है।

 struct Deque{T} entry::DequeNode{T} end Deque{T}() where T = Deque{T}(DequeNode{T}()) Deque() = Deque{Any}() 

एक आंतरिक निर्माणकर्ता को अब कतार की संरचना के लिए आवश्यक नहीं है।

आइटम जोड़ना

एक कतार के लिए मानक प्रक्रियाएं शुरुआत और अंत में एक तत्व जोड़ रही हैं, और शुरुआत और अंत से तत्वों को निकाल रही हैं। इन प्रक्रियाओं के लिए, मानक पुस्तकालय में पहले से ही ऐसे कार्य हैं जिनके लिए आपको केवल दूसरे प्रकार के साथ काम करने के तरीकों को जोड़ना होगा:

• push!(collection, element) - push!(collection, element) लिए एक तत्व जोड़ें (एक आदेशित संग्रह के लिए - अंत में)
• pushfirst!(collection, element) - एक ऑर्डर किए गए संग्रह की शुरुआत में एक तत्व जोड़ें
• pop!(collection) - pop!(collection) से किसी आइटम को हटाएं (ऑर्डर किए गए संग्रह के लिए - अंत से)
• popfirst!(collection) - पहले आइटम को एक ऑर्डर किए गए संग्रह से हटा दें

ये सभी कार्य Base मॉड्यूल में हैं, और आपको इसमें नए तरीके जोड़ने होंगे। इसके अतिरिक्त, हम यह जाँचने के लिए एक फ़ंक्शन लिखेंगे कि क्या संग्रह खाली है - Base.isempty(collection) ।

 Base.isempty(deq::Deque) = deq.entry.prev ≡ deq.entry function Base.push!(deq::Deque{T}, elt) where T tail = deq.entry.prev new_item = DequeNode{T}(elt) new_item.prev, new_item.next = tail, deq.entry tail.next = deq.entry.prev = new_item return deq end function Base.pushfirst!(deq::Deque{T}, elt) where T head = deq.entry.next new_item = DequeNode{T}(elt) new_item.prev, new_item.next = deq.entry, head head.prev = deq.entry.next = new_item return deq end function Base.pop!(deq::Deque) !isempty(deq) || throw(ArgumentError("deque must be non-empty")) last = deq.entry.prev last.prev.next = deq.entry deq.entry.prev = last.prev return last.data end function Base.popfirst!(deq::Deque) !isempty(deq) || throw(ArgumentError("deque must be non-empty")) first = deq.entry.next first.next.prev = deq.entry deq.entry.next = first.next return first.data end 

एक अनियंत्रित संग्रह के आधार पर एक कतार निर्माणकर्ता को लिखने के लिए push!() फ़ंक्शन इसे लगभग तुच्छ बनाता है:

 function Deque(itr) d = Deque{eltype(itr)}() for elt in itr push!(d, elt) end return d end #        Deque(args...) = Deque(args) 

अब नए प्रकार को लगभग एक कतार के रूप में इस्तेमाल किया जा सकता है यदि हमें केवल संचालन जोड़ने और हटाने की आवश्यकता है और हमें एक फ़ंक्शन की आवश्यकता नहीं है जैसे कि peek() और कतार के सिर या पूंछ में तत्व को देखें (इसे हटाए बिना)। तत्वों के लिए गैर-विनाशकारी पहुंच के लिए, कंटेनर पर पुनरावृत्ति फ़ंक्शन को परिभाषित करना सुविधाजनक है।

यात्रा

जूलिया कंटेनर तत्वों को ट्रैवर्स करने के लिए पुनरावृत्तियों की अवधारणा का समर्थन करता है। पुनरावृत्ति के लिए, आपको एकल फ़ंक्शन - iterate(container, state) को परिभाषित करने की आवश्यकता है, जहां state iterate(container, state) की वर्तमान स्थिति को निर्धारित करता है। विशेष रूप से, for x in collection निर्माण for x in collection लिए कुछ इस तरह के लिए वाक्यविन्यास चीनी है:

 let nextstate = iterate(collection) while nextstate ≢ nothing (x, state) = nextstate <- > nextstate = iterate(collection, state) end end 

iterate() फ़ंक्शन एक कंटेनर और एक " iterate() स्थिति" को एक तर्क के रूप में लेता है, और कंटेनर तत्व और अगले iterate() राज्य से या तो एक टपल लौटाता है, या nothing अगर कंटेनर समाप्त हो गया है।
एक कतार के लिए, कतार नोड को लेना तर्कसंगत है, जो पुनरावृत्ति "राज्य" के रूप में पहुंच गया है:

 function Base.iterate(deq::Deque{T}, state::DequeNode{T}=deq.entry) where T nextstate = state.next nextstate ≡ deq.entry ? nothing : (nextstate.data, nextstate) end 

अब कतार के तत्वों को एक लूप के साथ जोड़ा जा सकता है:

 julia> for x in Deque(1:10) println(x); end 1 2 3 4 5 6 7 8 9 10 

एक बड़ा प्लस यह है कि मानक जूलिया लाइब्रेरी के कई कार्यों को सामान्यीकृत इंटरफेस का उपयोग करके लिखा जाता है, विशेष रूप से, पुनरावृत्ति। इस प्रकार, स्वचालित रूप से यह जांचना कि क्या एक तत्व कंटेनर से संबंधित है, स्वचालित रूप से निर्धारित होता है:

 julia> 5 ∈ Deque(3:10) true julia> 100 ∈ Deque(-5:5) false 

हम यह भी पाते हैं कि first() विधि, जो संग्रह का पहला तत्व लौटाती है, काम करने लगी। तस्वीर को पूरा करने के लिए, हम पिछले तत्व को प्राप्त करने के लिए last() विधि को पूरक करते हैं और रिवर्स ऑर्डर में पुनरावृति करते हैं:

 function Base.iterate(r::Base.Iterators.Reverse{Deque{T}}, state::DequeNode{T}=r.itr.entry) where T nextstate = state.prev nextstate ≡ r.itr.entry ? nothing : (nextstate.data, nextstate) end function Base.last(deq::Deque) isempty(deq) && throw(ArgumentError("deque must be non-empty")) deq.entry.prev.data end julia> for x in Iterators.reverse(Deque(1:10)) println(x); end 10 9 8 7 6 5 4 3 2 1 

तो, डेटा संरचना के रूप में कतार इंटरफ़ेस अब पूरी तरह से परिभाषित है

प्रिंटआउट संरचना

यद्यपि कतार पूरी तरह से डेटा संरचना के रूप में कार्य करती है, प्रिंट पर यह अभी भी एक निराकार गंदगी का प्रतिनिधित्व करता है:

 julia> Deque() Deque{Any}(DequeNode{Any}(#undef, DequeNode{Any}(#= circular reference @-1 =#), DequeNode{Any}(#= circular reference @-1 =#))) 

अधिक मानवीय रूप में कतार को मुद्रित करने के लिए एक विधि जोड़ें। टर्मिनल को संरचना का आउटपुट Base.show() फ़ंक्शन द्वारा नियंत्रित किया जाता है, जिसे हम अधिभार देंगे:

 function Base.show(io::IO, deq::Deque{T}) where T print(io, "Deque{", T, "}(") next = iterate(deq) if next ≢ nothing item, state = next show(io, item) next = iterate(deq, state) while next ≢ nothing item, state = next print(io, ", ") show(io, item) next = iterate(deq, state) end end print(io, ")") end #        julia> Deque(1:5) Deque{Int64}(1, 2, 3, 4, 5) #       julia> Deque(Deque(), Deque(), Deque()) Deque{Deque{Any}}(Deque{Any}(), Deque{Any}(), Deque{Any}()) 

अनुक्रमणिका द्वारा पहुँच और परिवर्तन

सिद्धांत रूप में, एक कतार को सूचकांक द्वारा पहुंच के साथ एक कंटेनर के रूप में भी इस्तेमाल किया जा सकता है। इंडेक्स द्वारा मान प्राप्त करना और बदलना getindex() और setindex!() द्वारा नियंत्रित किया जाता है। हम कतार के लिए आवश्यक तरीके लागू करते हैं।

 function Base.getindex(deq::Deque, i::Integer) i > 0 || throw(BoundsError(deq, i)) next = iterate(deq) for idx in 1:i-1 next ≡ nothing && throw(BoundsError(deq, i)) _, state = next next = iterate(deq, state) end if next ≡ nothing throw(BoundsError(deq, i)) else return next[1] end end function Base.setindex!(deq::Deque, val, i::Integer) i > 0 || throw(BoundsError(deq, i)) next = iterate(deq) for idx in 1:i-1 next ≡ nothing && throw(BoundsError(deq, i)) _, state = next next = iterate(deq, state) end if next ≡ nothing throw(BoundsError(deq, i)) else record = next[2] record.data = val return val end end 

किसी तत्व को मनमाने स्थान पर insert!() के कार्य को जोड़ना भी उपयोगी है insert!() और एक तत्व को मनमाने ढंग से हटाने के लिए:

 function Base.insert!(deq::Deque{T}, i::Integer, val) where T i > 0 || throw(BoundsError(deq, i)) next = iterate(deq) for idx in 1:i-1 next ≡ nothing && throw(BoundsError(deq, i)) _, state = next next = iterate(deq, state) end if next ≡ nothing push!(deq, val) else record = next[2] new_node = DequeNode{T}(val) new_node.prev, new_node.next = record.prev, record record.prev = record.prev.next = new_node deq end end function Base.deleteat!(deq::Deque, i::Integer) i > 0 || throw(BoundsError(deq, i)) next = iterate(deq) for idx in 1:i-1 next ≡ nothing && throw(BoundsError(deq, i)) _, state = next next = iterate(deq, state) end if next ≡ nothing throw(BoundsError(deq, i)) else record = next[2] record.prev.next, record.next.prev = record.next, record.prev end end 

अन्य

जैसा कि पहले ही उल्लेख किया गया है, मानक पुस्तकालय के कई कार्यों को iterate() का उपयोग करके लिखा गया है, जो उन्हें स्वचालित रूप से किसी भी प्रकार के साथ काम करने की अनुमति देता है जिसके लिए iterate() फ़ंक्शन परिभाषित है। विशेष रूप से, map() , collect() और कमी के तरीके जैसे sum() या minimum() ।
उदाहरण के लिए, एक कतार की लंबाई खोजने के लिए एक फ़ंक्शन इस तरह लिखा जा सकता है:

 Base.length(deq::Deque) = sum(x->1, deq) julia> length(Deque(1, 1, 2, 3, 5, 8, 13)) 7 

निष्कर्ष

जैसा कि आप देख सकते हैं, जूलिया में अपना स्वयं का डेटा प्रकार बनाना और इसके साथ सुविधाजनक काम का आयोजन करना बहुत सरल है। मानक पुस्तकालय में सामान्यीकृत प्रोग्रामिंग के उपयोग के कारण, यह आमतौर पर कई बुनियादी कार्यों को परिभाषित करने के लिए पर्याप्त होता है, और कई आश्रित अपने आप काम करेंगे। तो, push!(container, element) को परिभाषित करके push!(container, element) एक तत्व को जोड़ने के लिए, आप पा सकते हैं कि push!(container, elements...) एक मनमानी संख्या को जोड़ने के लिए काम करेगा। एक इटरेटर को परिभाषित करने के बाद, सामान्य तौर पर हम अमूर्त कंटेनर के साथ काम करने के लिए मानक पुस्तकालय के सभी कार्यों को स्वचालित रूप से प्राप्त करते हैं।

हैप्पी हैकिंग!