पिछले अंक के तार्किक उत्तराधिकारी ... a

सरणियों पर संचालक ऑपरेटिंग तत्व का व्यवहार मतलाब से दुर्भाग्यपूर्ण होल्डओवर की तरह है और वास्तव में गणितीय रूप से उचित संचालन नहीं है

यह बिल्कुल सच नहीं है, और exp अनुरूप नहीं है। जटिल वेक्टर रिक्त स्थान, और संयुग्मन, एक पूरी तरह से स्थापित गणितीय अवधारणा है। यह भी देखें https://github.com/JuliaLang/julia/pull/19996#issuecomment -272312876

जटिल वेक्टर रिक्त स्थान, और संयुग्मन, एक पूरी तरह से स्थापित गणितीय अवधारणा है।

जब तक मैं गलत नहीं हूँ, उस संदर्भ में सही गणितीय संयुग्मन ऑपरेशन ctranspose बजाय conj (जो ठीक मेरी बात थी):

julia> v = rand(3) + rand(3)*im
3-element Array{Complex{Float64},1}:
 0.0647959+0.289528im
  0.420534+0.338313im
  0.690841+0.150667im

julia> v'v
0.879291582684847 + 0.0im

julia> conj(v)*v
ERROR: DimensionMismatch("Cannot multiply two vectors")
Stacktrace:
 [1] *(::Array{Complex{Float64},1}, ::Array{Complex{Float64},1}) at ./linalg/rowvector.jl:180

recur लिए एक कीवर्ड का उपयोग करने के साथ समस्या यह है कि, पिछली बार मैंने जाँच की थी, कीवर्ड का उपयोग करने के लिए एक बड़ा प्रदर्शन जुर्माना था, जो एक समस्या है अगर आप इन कार्यों को बेस केस के साथ पुनरावर्ती रूप से कॉल करते हैं जो समाप्त हो जाते हैं scalars।

हमें वैसे भी 1.0 में कीवर्ड प्रदर्शन की समस्या को ठीक करने की आवश्यकता है।

@StefanKarpinski , आप गलत हैं। आप एक वेक्टर अंतरिक्ष में जटिल संयोजन हो सकते हैं बिना adjoints - adjoints एक अवधारणा है जिसमें एक हिल्बर्ट स्थान आदि की आवश्यकता होती है, न कि केवल एक जटिल वेक्टर अंतरिक्ष।

इसके अलावा, यहां तक ​​कि जब आपके पास हिल्बर्ट स्थान होता है, तो जटिल संयुग्म समीप से अलग होता है। जैसे conj complex में एक जटिल स्तंभ वेक्टर का संयुग्मन एक और जटिल वेक्टर है, लेकिन सहायक एक रैखिक ऑपरेटर (एक "पंक्ति वेक्टर") है।

(जटिल संयुग्मन का मतलब यह नहीं है कि आप conj(v)*v गुणा कर सकते हैं!)

डिप्रेक्टेटिंग वेक्टरकृत conj शेष प्रस्ताव से स्वतंत्र है। क्या आप वेक्टर स्थान में जटिल संयुग्मन की परिभाषा के लिए कुछ संदर्भ प्रदान कर सकते हैं?

https://en.wikipedia.org/wiki/Complexification#Complex_conjugation

(यह उपचार बल्कि औपचारिक है; लेकिन यदि आप "जटिल संयुग्म मैट्रिक्स" या "जटिल संयुग्मी वेक्टर" पर आधारित हैं, तो आपको उपयोग के लाखों मिलेंगे।)

यदि संयुग्म वेक्टर के लिए एक जटिल वेक्टर मानचित्रण (क्या conj अब करता है) एक महत्वपूर्ण ऑपरेशन है जो इसे मैप करने से अलग है संयुग्म covector (क्या ' करता है), तो हम निश्चित रूप से conj रख सकते हैं conj और adjoint बीच एक अंतर प्रदान करता है।

उस मामले में, चाहिए conj(A) फोन conj प्रत्येक तत्व पर या कॉल adjoint ? 2x2 मैट्रिक्स उदाहरण के रूप में जटिल संख्याओं का प्रतिनिधित्व सुझाव देगा कि conj(A) को वास्तव में adjoint प्रत्येक तत्व पर कॉल करने के बजाय conj कॉल करना चाहिए। यह adjoint , conj और conj. सभी अलग-अलग ऑपरेशन करेगा:

1. adjoint : स्वैप i और j सूचक और पुनरावर्ती रूप से adjoint तत्वों पर मैप करें।
2. conj : मानचित्र adjoint तत्वों पर।
3. conj. : तत्वों पर conj नक्शा।

conj(A) को प्रत्येक तत्व पर conj कॉल करना चाहिए। यदि आप 2x2 मैट्रिक्स द्वारा जटिल संख्याओं का प्रतिनिधित्व कर रहे हैं, तो आपके पास एक अलग जटिल वेक्टर स्थान है।

उदाहरण के लिए, वैक्टरों के संयुग्मन का एक सामान्य उपयोग वास्तविक मैट्रिसेस के आइगेनवेल्यूज के विश्लेषण में है : ईजेनवल और ईजेनवेक्टर जटिल-संयुग्म जोड़े में आते हैं। अब, मान लीजिए कि आपके पास 2d सरणी A का असली 2x2 मैट्रिसेस द्वारा प्रतिनिधित्व किया गया ब्लॉक मैट्रिक्स है, जो अवरुद्ध वैक्टर v 2-घटक वैक्टर के 1d सरणियों द्वारा दर्शाया गया है। किसी भी eigenvalue λ A eigenvector v , हम एक दूसरे eigenvalue conj(λ) eigenvector conj(v) अपेक्षा करते हैं। अगर conj कॉल adjoint फिर से न हो तो यह काम नहीं करेगा।

(ध्यान दें कि मैट्रिक्स के लिए भी समीपवर्ती, संयुग्म-पारगमन से भिन्न हो सकता है, क्योंकि सबसे सामान्य तरीके से परिभाषित रैखिक ऑपरेटर का आसन्न आंतरिक उत्पाद की पसंद पर भी निर्भर करता है। बहुत सारे वास्तविक अनुप्रयोग हैं जहां एक प्रकार का भारित आंतरिक उत्पाद उपयुक्त होता है, जिस स्थिति में मैट्रिक्स के परिवर्तन को स्थगित करने का उपयुक्त तरीका होता है! लेकिन मैं इस बात से सहमत हूं कि, Matrix , हमें दिए गए मानक आंतरिक उत्पाद के अनुरूप विज्ञापन लेना चाहिए dot(::Vector,::Vector) । हालांकि, यह पूरी तरह से संभव है कि कुछ अलग करने के लिए AbstractMatrix (या अन्य रैखिक-ऑपरेटर) प्रकार adjoint को ओवरराइड करना चाहेंगे।)

इसके विपरीत, 3 डी सरणियों के लिए बीजगणितीय रूप से उचित adjoint(A) को परिभाषित करने में भी कुछ कठिनाई है, क्योंकि हमने 3 डी सरणियों को रैखिक संचालक के रूप में परिभाषित नहीं किया है (उदाहरण के लिए कोई अंतर्निहित array3d * array2d ऑपरेशन नहीं है) । शायद adjoint को केवल स्केलर, 1d और 2d सरणियों के लिए डिफ़ॉल्ट रूप से परिभाषित किया जाना चाहिए?

अद्यतन करें: ओह, अच्छा: हम ctranspose डी सरणियों के लिए

(ओटी: मैं पहले से ही "7-टेनर्स को गंभीरता से लेते हुए" आगे देख रहा हूं, "6-मिनिसरीज की बेहद सफलतम अगली किश्त ...)

यदि आप 2x2 मैट्रिक्स द्वारा जटिल संख्याओं का प्रतिनिधित्व कर रहे हैं, तो आपके पास एक अलग जटिल वेक्टर स्थान है।

मैं इसका पालन नहीं कर रहा हूं - जटिल संख्याओं के 2x2 मैट्रिक्स प्रतिनिधित्व को तत्वों के रूप में जटिल स्केलर के समान व्यवहार करना चाहिए। मुझे लगता है, जैसे कि अगर हम परिभाषित करते हैं

m(z::Complex) = [z.re -z.im; z.im z.re]

और हमारे पास एक मनमाना जटिल वेक्टर v फिर हम इस पहचान को रखना चाहेंगे:

conj(m.(v)) == m.(conj(v))

मैं उदाहरण को और अधिक स्पष्ट करूँगा और ' साथ तुलना करूँगा, जो पहले से ही m साथ आने वाला है, लेकिन मैं https://github.com/JuliaLang/julia/ के कारण नहीं कर सकता m.(v)' == m.(v') पकड़ लेंगे, लेकिन अगर मैं आपको सही ढंग से समझ रहा हूं, तो @stevengj , तो conj(m.(v)) == m.(conj(v)) नहीं होना चाहिए?

conj(m(z)) == m(z) होना चाहिए।

आपका m(z) इसके अलावा और गुणन के तहत जटिल संख्याओं के लिए एक समरूपता है, लेकिन यह रैखिक बीजगणित के लिए अन्य तरीकों से समान वस्तु नहीं है, और हमें यह नहीं दिखाना चाहिए कि यह conj । उदाहरण के लिए, यदि z एक जटिल स्केलर है, तो eigvals(z) == [z] , लेकिन eigvals(m(z)) == [z, conj(z)] । जब m(z) ट्रिक को जटिल मैट्रीस तक बढ़ाया जाता है, तो स्पेक्ट्रम के इस दोहरीकरण के उदाहरण के तरीकों के लिए मुश्किल परिणाम होते हैं (उदाहरण के लिए यह पेपर देखें)।

इसे लगाने का एक और तरीका यह है कि z पहले से ही एक जटिल वेक्टर स्पेस (जटिल संख्याओं पर एक वेक्टर स्थान) है, लेकिन 2x2 असली मैट्रिक्स m(z) वास्तविक संख्याओं पर एक वेक्टर स्थान है (आप गुणा कर सकते हैं m(z) कोई वास्तविक संख्या से) ... आप "complexify" अगर m(z) एक जटिल संख्या जैसे द्वारा यह गुणा करके m(z) * (2+3im) (नहीं m(z) * m(2+3im) ) तो आप मूल कॉम्प्लेक्स वेक्टर स्पेस z लिए अब एक अलग जटिल वेक्टर स्थान आइसोमॉर्फ़िक नहीं प्राप्त करें।

यह प्रस्ताव ऐसा लगता है कि यह एक वास्तविक सुधार उत्पन्न करेगा: +1: मैं गणितीय पक्ष के बारे में सोच रहा हूं:

• जैसा कि मैं समझता हूं, संयुग्मन रिंग पर एक क्रिया है (पढ़ें: संख्याएं) जो हमारे वेक्टर अंतरिक्ष / वैक्टर के लिए गुणांक प्रदान करती हैं। यह क्रिया वेक्टर स्पेस (और इसके मैपिंग, रीड: मैट्रिसेस) पर एक और कार्रवाई को प्रेरित करती है, जिसे रिंग के ऊपर वेक्टर स्पेस के निर्माण की रैखिकता द्वारा संयुग्मन भी कहा जाता है। इसलिए संयुग्मन जरूरी गुणांक के लिए तत्ववाचक अनुप्रयोग द्वारा काम करता है। जूलिया के लिए, इसका मतलब है कि दिल के लिए एक वेक्टर v , conj(v) = conj.(v) , और यह एक डिज़ाइन पसंद है कि क्या conj में सरणियों के लिए या केवल स्केलर के लिए विधियां हैं, जिनमें से दोनों ठीक लगता है? (कॉम्प्लेक्स-संख्याओं के रूप में 2x2-matrices उदाहरण के बारे में स्टीवन का कहना है कि यह एक वेक्टर स्थान है जिसके गुणांक औपचारिक रूप से / वास्तव में वास्तविक हैं, इसलिए संयुग्मन का यहां कोई प्रभाव नहीं है।)
• adjoint का एक बीजगणितीय अर्थ है जो कि कई महत्वपूर्ण डोमेन में मौलिक रूप से रैखिक बीजगणित को शामिल करता है (देखें 1 और 2 और 3 , सभी भौतिकी में बड़े अनुप्रयोगों के साथ भी)। यदि adjoint जोड़ा जाता है, तो उसे विचाराधीन कार्रवाई के लिए कीवर्ड तर्क की अनुमति देनी चाहिए - एक वेक्टर रिक्त स्थान / कार्यात्मक विश्लेषण में, यह क्रिया आम तौर पर आंतरिक उत्पाद से प्रेरित होती है, इसलिए इसके बजाय कीवर्ड तर्क हो सकता है। जो भी जूलिया के प्रस्तावों के लिए डिज़ाइन किया गया है, उन्हें इन अनुप्रयोगों के साथ संघर्ष करने से बचना चाहिए, इसलिए मुझे लगता है कि adjoint थोड़ा उच्च-चार्ज है?

@felixrehren , मुझे नहीं लगता कि आप उस आंतरिक तर्क को निर्दिष्ट करने के लिए कीवर्ड तर्क का उपयोग करेंगे जो dot का अर्थ बदलना चाहते थे।

मेरी प्राथमिकता थोड़ी सरल होगी:

• conj as-is (एलिमेंट वाइज) रखें।
• बनाओ a' के अनुरूप adjoint(a) , और यह हमेशा पुनरावर्ती (और इसलिए तार आदि के एरे जहां के लिए असफल बनाने के adjoint तत्वों के लिए निर्धारित नहीं है)।
• बनाओ a.' के अनुरूप transpose(a) , और यह कभी पुनरावर्ती बनाना (सिर्फ एक permutedims ), और इसलिए तत्वों के प्रकार पर ध्यान न दें।

मैं वास्तव में गैर-पुनरावर्ती adjoint लिए उपयोग का मामला नहीं देखता। एक खिंचाव के रूप में, मैं एक पुनरावर्ती transpose लिए उपयोग-मामलों की कल्पना कर सकता हूं, लेकिन किसी भी एप्लिकेशन में जहां आपको a.' से transpose(a, recur=true) बदलना होगा, यह उतना ही आसान लगता है किसी अन्य फ़ंक्शन को transposerecursive(a) कॉल करें। हम बेस में transposerecursive को परिभाषित कर सकते हैं, लेकिन मुझे लगता है कि इसके लिए आवश्यकता इतनी दुर्लभ होगी कि हमें यह देखने के लिए इंतजार करना चाहिए कि क्या यह वास्तव में आता है।

मुझे व्यक्तिगत रूप से लगता है कि यह सरल रखना उपयोगकर्ताओं (और कार्यान्वयन के लिए) के लिए सबसे सरल होगा, और अभी भी रैखिक बीजगणित के मोर्चे पर काफी रक्षात्मक हो सकता है।

हमारे रैखिक बीजगणित दिनचर्या के अब तक (अधिकांश) मानक सरणी संरचनाओं और मानक आंतरिक उत्पाद के लिए बहुत दृढ़ता से निहित हैं। अपने मैट्रिक्स या वेक्टर के प्रत्येक स्लॉट में, आप अपने "फ़ील्ड" का एक तत्व डालते हैं। मैं बहस करेंगे कि खेतों के तत्वों के लिए, हम के बारे में परवाह + , * , आदि, और conj , लेकिन नहीं transpose । यदि आपके क्षेत्र में एक विशेष जटिल प्रतिनिधित्व जो एक 2x2 असली मैट्रिक्स की तरह एक सा दिखता है, लेकिन के तहत बदल जाता था conj इसके बारे में एक संपत्ति है - है, तो उस के ठीक conj । अगर यह सिर्फ एक 2x2 असली AbstractMatrix जो conj तहत नहीं बदलता है, तो यकीनन मैट्रिक्स के ऐसे तत्व आसन्न के तहत नहीं बदलना @stevengj ने कहा कि मैं जितना बेहतर वर्णन कर सकता हूं: जटिल संख्याओं के लिए एक समरूपता हो सकती है लेकिन इसका मतलब यह नहीं है कि यह सभी तरीकों से समान व्यवहार करती है)।

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

तो मेरा "सरलीकृत" सुझाव होगा:

• conj को अपने पास रखें (या AbstractArray s के लिए इसे देखें)
• a' एक गैर-पुनरावर्ती दृश्य जैसे कि (a')[i,j] == conj(a[j,i])
• a.' एक गैर-पुनरावर्ती दृश्य जैसे कि (a.')[i,j] == a[j,i]
• ब्लॉक-मेट्रिक्स और इतने पर ( Base , या संभवतः एक अच्छी तरह से समर्थित पैकेज में) से निपटने के लिए BlockArray प्रकार का परिचय दें। यकीनन, यह इस उद्देश्य के लिए Matrix{Matrix} से कहीं अधिक शक्तिशाली और लचीला होगा, लेकिन उतना ही कुशल भी।

मुझे लगता है कि ये नियम उपयोगकर्ताओं को गले लगाने और बनाने के लिए काफी सरल होंगे।

PS - @StefanKarpinski व्यावहारिक कारणों से, पुनरावृत्ति के लिए बूलियन कीवर्ड तर्क ट्रांसपोज़ के लिए दृश्य के साथ काम नहीं करेगा। दृश्य का प्रकार बूलियन मूल्य पर निर्भर हो सकता है।

इसके अलावा, मैंने कहीं और उल्लेख किया है, लेकिन मैं इसे पूर्णता के लिए यहां जोड़ूंगा: पुनरावर्ती पारगमन के विचारों में कष्टप्रद संपत्ति है कि तत्व प्रकार उस सरणी की तुलना में बदल सकता है जो इसे लपेट रहा है। जैसे transpose(Vector{Vector}) -> RowVector{RowVector} । मैंने रन-टाइम जुर्माना के बिना RowVector लिए इस तत्व प्रकार को प्राप्त करने के तरीके के बारे में नहीं सोचा है या आउटपुट प्रकार की गणना करने के लिए आक्रमण का आह्वान किया है। मैं अनुमान लगा रहा हूं कि वर्तमान व्यवहार (आक्रमण को रोकना) भाषा के दृष्टिकोण से अवांछनीय है।

NB: उपयोगकर्ताओं को conj को एक अलग प्रकार से लौटाने से रोकने के लिए कुछ भी नहीं है - इसलिए ConjArray दृश्य भी इस समस्या से ग्रस्त हैं, चाहे ट्रांसपोज़र पुनरावर्ती हो या न हो।

@stevengj - आप "कॉम्प्लेक्स" 2x2 मैट्रिसेस के बारे में इंगित करते हैं जो एक जटिल सदिश स्थान के बजाय औपचारिक रूप से वास्तविक सदिश स्थान है, मेरे लिए समझ में आता है, लेकिन फिर वह बिंदु मेरे लिए पुनरावर्ती निकटता के लिए मूल प्रेरणा का प्रश्न है, जो मुझे आश्चर्यचकित करता है। @andyferris का प्रस्ताव बेहतर नहीं होगा (गैर-पुनरावर्ती प्रस्ताव और

यदि adjoint पुनरावर्ती नहीं है, तो यह adjoint नहीं है। यह सिर्फ गलत है।

जब आपको एक पल मिल गया है तो क्या आप इसके लिए थोड़ा सा औचित्य दे सकते हैं?

एक वेक्टर के आस-पास एक रैखिक ऑपरेटर होना चाहिए जो इसे स्केलर पर मैप कर रहा है। अगर a एक वेक्टर है, तो a'*a स्केलर होना चाहिए। और यह मेट्रिसेस पर एक समान निकटता को प्रेरित करता है, क्योंकि परिभाषित संपत्ति a'*A*a == (A'*a)'*a ।

यदि a वैक्टर का एक वेक्टर है, तो इसका अर्थ है कि a' == adjoint(a) का पुनरावर्ती होना आवश्यक है।

ठीक है, मुझे लगता है कि मैं इसका पालन करता हूं।

हमारे पास पुनरावर्ती आंतरिक उत्पाद भी हैं:

julia> norm([[3,4]])
5.0

julia> dot([[3,4]], [[3,4]])
25

स्पष्ट रूप से, "सहायक" या "दोहरी" या जो कुछ भी समान रूप से पुनरावर्ती होना चाहिए।

मुझे लगता है कि मुख्य प्रश्न तो है, हम की आवश्यकता होती है कि a' * b == dot(a,b) सभी वैक्टर के लिए a , b ?

विकल्प यह है कि ' आवश्यक रूप से सहायक को वापस नहीं करता है - यह सिर्फ एक सरणी ऑपरेशन है जो तत्वों को स्थानांतरित करता है और उन्हें conj से गुजरता है। यह सिर्फ वास्तविक या जटिल तत्वों के लिए सहायक होता है।

वहाँ एक और केवल एक कारण है कि हम रैखिक बीजगणित में adjoints के लिए एक विशेष नाम और विशेष प्रतीक है, और यह आंतरिक उत्पादों के लिए संबंध है। यही कारण है कि "conjugate transpose" एक महत्वपूर्ण ऑपरेशन है और "conjugate matrices का 90 डिग्री तक" नहीं है। अगर यह डॉट उत्पादों से जुड़ा नहीं है, तो ऐसा कुछ होने का कोई मतलब नहीं है, "यह केवल एक सरणी ऑपरेशन है जो पंक्तियों और स्तंभों और संयुग्मों को स्वैप करता है"।

एक transpose और एक असंबद्ध "डॉट उत्पाद" के बीच एक समान संबंध को परिभाषित कर सकता है, जो एक पुनरावर्ती हस्तांतरण के लिए तर्क देगा। हालांकि, जटिल डेटा के लिए अपुष्ट "डॉट उत्पाद", जो वास्तव में आंतरिक उत्पाद बिल्कुल भी नहीं हैं, लगभग वास्तविक आंतरिक उत्पादों के रूप में लगभग नहीं दिखाते हैं - वे द्वि-ऑर्थोगोनलिटी संबंधों से उत्पन्न होते हैं जब एक ऑपरेटर जटिल में लिखा जाता है- सममित (हर्मिटियन नहीं) रूप - और यहां तक ​​कि एक अंतर्निहित जूलिया फ़ंक्शन या रैखिक बीजगणित में एक सामान्य शब्दावली नहीं है, जबकि मनमाने ढंग से गैर-संख्यात्मक सरणियों की पंक्तियों और स्तंभों को स्वैप करना चाहते हैं, विशेष रूप से प्रसारण के साथ कहीं अधिक सामान्य लगता है। यही कारण है कि मैं adjoint पुनरावर्ती छोड़ने के दौरान transpose गैर-पुनरावर्ती बनाने का समर्थन कर सकता हूं।

समझा। इसलिए ' adjoint का नाम बदलना परिवर्तन का हिस्सा होगा, यह स्पष्ट करने के लिए कि यह conj ∘ transpose ?

जो चीज मुझे हमेशा पुनरावर्ती सरणियों के साथ भ्रमित करती है वह है: इस संदर्भ में एक अदिश राशि क्या है? सभी मामलों मैं से परिचित हूँ में, यह के कहा एक वेक्टर के तत्वों scalars हैं। उस मामले में भी जहां एक गणितज्ञ थोड़ा सा कागज पर एक ब्लॉक-वेक्टर / मैट्रिक्स संरचना लिखता है, हम अभी भी जानते हैं कि यह एक बड़े वेक्टर / मैट्रिक्स के लिए सिर्फ शॉर्टहैंड है जहां तत्व संभवतः वास्तविक या जटिल संख्याएं हैं (यानी BlockArray )। आपको उम्मीद है कि स्केलर * तहत गुणा करने में सक्षम होंगे, और स्केलर का प्रकार आमतौर पर वेक्टर के बीच भिन्न नहीं होता है और यह दोहरी होता है।

@ कैंडीफेरिस , एक सामान्य वेक्टर स्पेस के लिए, स्केलर्स एक रिंग (संख्या) होते हैं जिन्हें आप वैक्टर से गुणा कर सकते हैं। मैं 3 * [[1,2], [3,4]] कर सकता हूं, लेकिन मैं [3,3] * [[1,2], [3,4]] नहीं कर सकता। तो, Array{Array{Number}} , सही स्केलर प्रकार Number ।

सहमत - लेकिन तत्वों को आमतौर पर (समान) स्केलर कहा जाता है, नहीं?

उपचार, मैंने वैसे भी देखा है, एक अंगूठी से शुरू करते हैं, और उनमें से एक वेक्टर स्थान का निर्माण करते हैं। यह अंगूठी + , * , लेकिन मैंने ऐसा कोई उपचार नहीं देखा है जिसके लिए इसे adjoint , dot का समर्थन करने की आवश्यकता हो, या जो भी हो।

(क्षमा करें, मैं केवल उस अंतर्निहित गणितीय वस्तु को समझने की कोशिश कर रहा हूं जिसे हम मॉडलिंग कर रहे हैं)।

यह इस बात पर निर्भर करता है कि आपको "आशुलिपि" से क्या मतलब है और "तत्वों" से आपका क्या मतलब है।

उदाहरण के लिए, फ़ंक्शंस के परिमित आकार वाले वैक्टर, और अनंत आयामी ऑपरेटरों के "मैट्रिसेस" होना काफी आम है। उदाहरण के लिए मैक्रोस्कोपिक मैक्सवेल समीकरणों के निम्नलिखित रूप पर विचार करें:

इस मामले में, हमारे पास 2-घटक वैक्टर पर अभिनय करने वाले रैखिक ऑपरेटरों (जैसे कर्ल) का 2x2 मैट्रिक्स है, जिनके "तत्व" 3-घटक वेक्टर फ़ील्ड हैं। ये जटिल संख्याओं के अदिश क्षेत्र पर वैक्टर हैं। कुछ अर्थों में, यदि आप पर्याप्त दूर तक ड्रिल करते हैं तो वैक्टर के "तत्व" जटिल संख्याएँ हैं - अंतरिक्ष में अलग-अलग बिंदुओं पर खेतों के अलग-अलग घटक - लेकिन यह उतना ही अस्पष्ट है।

या शायद अधिक सटीक रूप से, हम हमेशा किसी न किसी आधार में वेक्टर के गुणांक का वर्णन करने के लिए अंगूठी का उपयोग नहीं कर सकते हैं (जूलिया में चीजों की सरणी प्रकृति को देखते हुए, हम आधार मुक्त नहीं हो रहे हैं)?

किसी भी मामले में, परिणाम अभी भी है कि adjoints को पुनरावर्ती होना है, नहीं? मुझे समझ में नहीं आ रहा है कि आप किस बिंदु पर हो रहे हैं।

(हम पूरी तरह से आधार-मुक्त जा सकते हैं, मुझे लगता है, क्योंकि ऑब्जेक्ट्स या सरणियों के तत्व प्रतीकात्मक अभिव्यक्तियाँ हो सकते हैं ala SymPy या कुछ अन्य डेटा संरचना जो एक अमूर्त गणितीय वस्तु का प्रतिनिधित्व करती है, और निकटता किसी अन्य ऑब्जेक्ट को वापस कर सकती है जब बहुगुणित कंप्यूटर्स a अभिन्न, उदाहरण के लिए।)

मैं सिर्फ बेहतर समझने की कोशिश कर रहा हूं, कोई खास बात नहीं कर रहा हूं :)

निश्चित रूप से, उपरोक्त में, निकटवर्ती पुनरावर्ती है। मैं सोच रहा था कि यदि उपरोक्त में उदाहरण के लिए [E, H] को BlockVector रूप में सोचना सबसे अच्छा है, तो (असीम रूप से?) कई तत्व जटिल हैं, या 2-वेक्टर के रूप में जिनके तत्व सदिश क्षेत्र हैं। मुझे लगता है कि इस मामले में, BlockVector दृष्टिकोण अप्राप्य होगा।

कोई बात नहीं धन्यवाद।

इसलिए, शायद मैं इस रूप में अपने विचारों को विचलित कर सकता हूं:

एक वेक्टर v , मुझे उम्मीद है कि length(v) वेक्टर अंतरिक्ष के आयाम का वर्णन करता है, यानी स्केलर गुणांक की आवश्यकता है जो (पूरी तरह से) वेक्टर अंतरिक्ष के एक तत्व का वर्णन करता है, और यह भी कि v[i] i th स्केलर गुणांक देता है। आज तक, मैंने "अमूर्त वेक्टर" के रूप में AbstractVector बारे में नहीं सोचा है, बल्कि एक ऐसी वस्तु है जो कुछ वेक्टर अंतरिक्ष के एक तत्व के गुणांक रखती है जिसे कुछ आधार दिया जाता है जिसके बारे में प्रोग्रामर को पता है।

यह एक सरल और उपयोगी मानसिक मॉडल की तरह लग रहा था, लेकिन शायद यह बहुत अधिक प्रतिबंधात्मक / अव्यवहारिक है।

(EDIT: यह प्रतिबंधात्मक है क्योंकि Vector{T} , T को कार्य करने के लिए रैखिक बीजगणित संचालन के लिए एक स्केलर की तरह व्यवहार करना चाहिए।)

लेकिन मैं [3,3] * [[1,2], [3,4]] नहीं कर सकता

हम इसे ठीक कर सकते हैं। मुझे यकीन नहीं है कि यह एक अच्छा विचार है या नहीं, लेकिन यह निश्चित रूप से काम करने के लिए बनाया जा सकता है।

मुझे यकीन नहीं है कि यह वांछनीय है ... इस मामले में [3,3] वास्तव में एक अदिश राशि नहीं है। (हमारे पास पहले से ही [3,3]' * [[1,2], [3,4]] करने की क्षमता है - जो मुझे वास्तव में एक रैखिक बीजगणित में व्याख्या करने का तरीका नहीं पता है)।

यह एक दिलचस्प कोने-मामले को दर्शाता है: हम यह कहते प्रतीत होते हैं कि v1' * v2 आंतरिक उत्पाद है (और इस प्रकार "स्केलर" लौटाता है), लेकिन [3,3]' * [[1,2], [3,4]] == [12, 18] । एक आकस्मिक उदाहरण, मुझे लगता है।

उस मामले में [3,3] एक अदिश है: scalars अंतर्निहित रिंग में तत्व हैं, और वहाँ प्रपत्र के तत्वों बनाने के लिए अच्छा तरीके के बहुत सारे हैं [a,b] एक रिंग में (और इस प्रकार परिभाषित करने वैक्टर / मैट्रिक्स इसके ऊपर)। तथ्य यह है कि वे वैक्टर के रूप में लिखे गए हैं, या तथ्य यह है कि यह अंगूठी खुद एक और अंतर्निहित रिंग के ऊपर एक वेक्टर स्थान बनाती है, वह नहीं बदलती है। (आप किसी भी अन्य संकेतन को ले सकते हैं जो वैक्टर को छिपा सकता है! या इसे पूरी तरह से अलग कर सकता है।) जैसा कि @ कैंडीफेरिस हो रहा था, एक स्केलर क्या है संदर्भ पर निर्भर करता है।

औपचारिक रूप से, पुनरावृत्ति निकटवर्ती का हिस्सा नहीं है। इसके बजाय, स्केलर तत्वों का संयुग्मन कार्य के उस हिस्से को करता है - और अक्सर, अगर एक स्केलर s को मैट्रिक्स के रूप में दर्शाया जाता है, तो s संयुग्मन करना मैट्रिक्स का उपयोग करना होगा जिसे हम निरूपित करने के लिए उपयोग करते हैं। यह। लेकिन यह हमेशा ऐसा नहीं होता है, यह उपयोगकर्ता-दिए गए संरचना पर निर्भर करता है, जो रिंगर ऑफ रिंगर है।

मुझे लगता है कि निकटवर्ती पुनरावृत्ति के लिए मजबूर करना ठीक हो सकता है व्यावहारिक समझौता, मटलब-प्रकार के अनुप्रयोगों के लिए विशिष्ट। लेकिन मेरे लिए, इसे सुपर को गंभीरता से लेने का मतलब गैर-पुनरावर्ती निकटता और टाइप किए गए स्केलर्स + डिस्पैच का उपयोग करना होगा, जो कि अंतर्निहित रिंग की संरचना के होने पर conj आवश्यक जादू का काम करते हैं।

उस स्थिति में [3,3] एक अदिश राशि है: अदिश वलय में अदिश तत्व होते हैं

ऐसे स्केलर को छोड़कर + , * द्वारा परिभाषित रिंग का कोई तत्व नहीं है। यह * समर्थन नहीं करता है; मैं [3,3] * [3,3] नहीं कर सकता।

मुझे लगता है कि निकटवर्ती पुनरावृत्ति के लिए मजबूर करना ठीक हो सकता है व्यावहारिक समझौता, मटलब-प्रकार के अनुप्रयोगों के लिए विशिष्ट। लेकिन मेरे लिए, इसे सुपर को गंभीरता से लेने का मतलब गैर-पुनरावर्ती निकटता और टाइप किए गए स्केलर्स + डिस्पैच का उपयोग करना होगा, जो कि अंतर्निहित रिंग की संरचना के होने पर conj आवश्यक जादू का काम करते हैं।

मैं सहमत हूं, अगर हम एक व्यावहारिक समावेश करना चाहते हैं तो यह पूरी तरह से ठीक है और यह हमने अब तक किया है, लेकिन मुझे ऐसा लगता है कि अंतर्निहित स्केलर पूरी तरह से चपटे सरणी के हैं और यही रैखिक बीजगणित पर परिभाषित किया गया है । हमारे पास BlockVector और BlockMatrix (और BlockDiagonal , आदि) बनाने की तकनीक है, जो पूरी तरह से विस्तारित सरणी का एक कुशल, चपटा दृश्य प्रस्तुत करता है, इसलिए "सुपर गंभीर" "दृष्टिकोण, कम से कम, योग्य होना चाहिए। मैं यह भी सोचता हूं कि यह उपयोगकर्ता के अनुकूल होगा जैसा कि पुनरावर्ती दृष्टिकोण (कुछ अतिरिक्त वर्ण टाइप करने के लिए BlockMatrix([A B; C D]) के बदले में जो एक अच्छे शब्दार्थ और संभवतः अधिक पठनीय कोड हो सकता है - मुझे यकीन है कि ये हैं अंक बहस के लिए ऊपर हैं)। हालाँकि, यह सभी को लागू करने के लिए अधिक काम होगा।

@ कैंडीफ़ायर आप सही कह रहे हैं, वे एक अंगूठी नहीं हैं क्योंकि * को परिभाषित नहीं किया गया है - लेकिन मुझे लगता है कि हम एक ही पृष्ठ पर हैं कि * आसानी से इसके लिए परिभाषित किया जा सकता है। और यह करने के लिए कई अलग-अलग तरीके हैं जो एक रिंग संरचना देंगे। इसलिए मुझे लगता है कि हम एक ही पृष्ठ पर हैं: टाइप करना इसको हल करने का अधिक विस्तृत तरीका है।

(स्केलर्स के बारे में: स्केलर्स आवश्यक रूप से पूरी तरह से चपटी संरचना के तत्व नहीं हैं! इसका कारण यह है। 1-आयामी जटिल वेक्टर अंतरिक्ष जटिल संख्याओं पर 1-आयामी है और वास्तविक संख्याओं पर 2-आयामी; न ही प्रतिनिधित्व; विशेष। चतुर्भुज जटिल संख्याओं पर 2-आयामी होते हैं। ऑक्टोनियन 2-आयामी होते हैं क्वैर्टनियन, 4-आयामी जटिल संख्याओं पर, और 8-आयामी वास्तविकताओं पर। लेकिन इस बात पर ज़ोर देने का कोई कारण नहीं है कि ऑक्टोनियन "8-आयामी" हैं। इस बात पर जोर देने के लिए कि उनके स्केलर वास्तविक संख्याएं हैं जो जटिल नहीं हैं; वे विकल्प हैं जिन्हें तर्क द्वारा मजबूर नहीं किया जाता है। यह पूरी तरह से प्रतिनिधित्व का सवाल है, उपयोगकर्ता को इस स्वतंत्रता की अनुमति दी जानी चाहिए क्योंकि रैखिक बीजगणित प्रत्येक मामले में समान है। और आपको मिलता है। ऐसे रिक्त स्थान की बहुत लंबी श्रृंखलाओं [छंटनी वाली] बहुपद के छल्ले, या संख्या क्षेत्रों के बीजीय विस्तार, जिनमें से दोनों में मेट्रिसेस के साथ जीवंत अनुप्रयोग हैं। जूलिया को खरगोश के छेद से बहुत दूर नहीं जाना पड़ता है - हम। याद रखना चाहिए कि यह मौजूद है, इसलिए इसे बंद करने के लिए नहीं। शायद एक प्रवचन विषय? :))

@felixrehren , एक रिंग R के ऊपर वैक्टर के एक वेक्टर को एक डायरेक्ट-सम स्पेस के रूप में सबसे अच्छी तरह से समझा जाता है, जो R के ऊपर एक वेक्टर स्पेस भी है। वैक्टर को खुद को "अंतर्निहित रिंग" कहना निरर्थक है, क्योंकि सामान्य तौर पर वे नहीं होते हैं। अंगूठी। यह तर्क पूरी तरह से [[1,2], [3,4]] पर लागू होता है।

संयुग्मन और विशेषण अलग-अलग अवधारणाएँ हैं; यह कहते हुए कि "स्केलर तत्वों के संयुग्मन" को यहाँ कार्य करना चाहिए जो मुझे पूरी तरह से गलत लगता है - "गंभीर" के विपरीत - विशेष रूप से नीचे उल्लेखित मामले को छोड़कर।

दो तत्वों के "2-घटक कॉलम वैक्टर" (| u |; | v of) के मामले पर विचार करें। कुछ रिंग में कुछ हिल्बर्ट स्पेस H में u⟩ और | vbert (जटिल संख्या को, कहें), Dirac संकेतन में: "वैक्टर के वैक्टर।" यह प्राकृतिक आंतरिक उत्पाद | (| u direct; | v⟩), - (| w,,। Z⟩)⟩ = ⟨u | w⟩ + ⟨v | z⟩ के साथ एक प्रत्यक्ष योग हिल्बर्ट स्पेस H⊕H है। (| ⟨V | ⟨u) adjoint इसलिए रैखिक ऑपरेटर "पंक्ति वेक्टर" से मिलकर प्रस्तुत करना चाहिए, जिसका तत्व खुद को ऑपरेटरों रैखिक हैं: adjoint है"पुनरावर्ती" । यह जटिल संयुग्म से पूरी तरह से अलग है, जो एक ही हिल्बर्ट अंतरिक्ष H differentH के एक तत्व का उत्पादन करता है, जो अंडरलिंग रिंग के संयुग्मन से प्रेरित होता है।

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

एक और तरीका है, वस्तु के प्रकार को सूचना के दो अलग-अलग टुकड़ों को इंगित करने की आवश्यकता है:

• अदिश वलय (इसलिए संयुग्म, जो एक ही स्थान का एक तत्व उत्पन्न करता है)।
• आंतरिक उत्पाद (इसलिए सहायक, जो दोहरे स्थान का एक तत्व पैदा करता है)।

Vector{T<:Number} , हमें यह इंगित करते हुए पढ़ना चाहिए कि स्केलर की अंगूठी T (या complex(T) जटिल वेक्टर स्थान के लिए) है, और यह कि आंतरिक उत्पाद सामान्य यूक्लोनियन एक है ।

यदि आपके पास वैक्टर के वेक्टर हैं, तो यह एक प्रत्यक्ष-योग हिल्बर्ट स्पेस है और रिंग व्यक्तिगत वैक्टर के स्केलर रिंग का प्रचार है, और डॉट उत्पाद तत्वों के डॉट उत्पादों का योग है। (यदि स्कैलर्स को बढ़ावा नहीं दिया जा सकता है या डॉट उत्पादों को अभिव्यक्त नहीं किया जा सकता है, तो यह एक वेक्टर / हिल्बर्ट स्पेस नहीं है।)

यदि आपके पास एक स्केलर T<:Number , तो conj(x::T) == adjoint(x::T) ।

तो, यदि आप 2x2 मैट्रिसेस m(z)::Array{T,2} जटिल संख्या z::Complex{T} प्रतिनिधित्व करने का प्रयास करते हैं, तो आपका प्रकार z की तुलना में दोनों भिन्न T और एक अलग आंतरिक उत्पाद को इंगित करता है। z , और इसलिए आपको समकक्ष परिणाम देने के लिए conj या adjoint उम्मीद नहीं करनी चाहिए।

मैं आपको @felixrehren के बारे में जो कुछ भी कह रहा हूं उसे देख कर यदि स्केलर वास्तविक है, तो एक ऑक्टेरियन को 8 आयामी वेक्टर अंतरिक्ष के रूप में सोचा जा सकता है। लेकिन अगर स्केलर गुणांक एक ऑक्टेरियन था, तो तुच्छ आयाम -1 आधार है जो सभी ऑक्टेरियन का प्रतिनिधित्व करता है। मुझे यकीन नहीं है कि अगर मैंने जो कहा है, वह अलग है (या मेरा क्या मतलब है: मुस्कान :), अगर हमारे पास AbstractVector{T1} यह एक अलग आयामीता के AbstractVector{T2} के लिए आइसोमोर्फिक हो सकता है ( length )। लेकिन T1 और T2 दोनों को जूलिया ऑपरेटरों के तहत + और * (और समरूपता + के व्यवहार को संरक्षित कर सकती है] लेकिन * , या आंतरिक उत्पाद या निकटता नहीं)।

@stevengj मैं हमेशा बिल्कुल मेरी तरह प्रत्यक्ष योग के बारे में सोचा गया है BlockVector । आपके पास दो (अव्यवस्थित) अधूरे आधार हैं। प्रत्येक आधार पर आप पहले c₁⟩ | X₂ + c₂⟩ | X₂⟩ जैसे सुपरपोज़िशन बनाने में सक्षम हो सकते हैं या दूसरे में c₁⟩ | Y₃ + c₄ | Y₂⟩ दूसरे में। "प्रत्यक्ष योग" उन राज्यों के स्थान का प्रतिनिधित्व करता है जो देखने में (c₁⟩ | X₂ + c₂⟩ | X₂⟩) + (c₁⟩ | Y₃ + c₄ | Y₂⟩) की तरह लगते हैं। मुझे ऐसा लगता है कि केवल एक ही विशेष चीज जो जटिल संख्याओं पर आयाम चार के आधार पर इसे अलग करती है (जैसे कि c₁⟩ | X₂ + c₁⟩ | X₂⟩ + c₃ | Y₁⟩ + c₄ | Y₂⟩) कोष्ठक है - मेरे लिए, यह उल्लेखनीय लगता है; सीधा योग कागज पर या कंप्यूटर पर सरणियों के साथ लिखने के लिए सिर्फ एक सुविधाजनक तरीका है (और उदाहरण के लिए उपयोगी हो सकता है कि हमें कैटलॉग करने के लिए और समरूपता का लाभ लेने के लिए, या समस्या को विभाजित करने के लिए (शायद इसे समानांतर करने के लिए), आदि। )। इस उदाहरण में X spaceY अभी भी एक चार-आयामी वेक्टर स्थान है जहां स्केलर जटिल हैं।

यह वही है जो मुझे eltype(v) == Complex{...} और length(v) == 4 बजाय eltype(v) == Vector{Complex{...}} और length(v) == 2 । यह मुझे अंतर्निहित रिंग और वेक्टर स्पेस के बारे में देखने और उसका कारण बनाने में मदद करता है। क्या यह भी "चपटा" स्थान नहीं है जहाँ आप "वैश्विक" ट्रांसपोज़िशन और तत्ववाचक conj हैं ताकि आसन्न की गणना की जा सके?

(आप दो पोस्टों में मिले जब मैं सिर्फ एक लिख रहा था, @stevengj : smile :)

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

स्पष्ट होने के लिए, मैं दोनों दृष्टिकोणों से खुश हूं और मैंने इस चर्चा से बहुत कुछ सीखा है। धन्यवाद।

@ कैंडीफेरिस , सिर्फ इसलिए कि दो रिक्त स्थान हैं

फिर, मुझे यकीन नहीं है कि आपकी बात क्या है। क्या आप गंभीरता से प्रस्ताव कर रहे हैं कि जूलिया में eltype(::Vector{Vector{Complex}}) Complex होना चाहिए, या कि length को लंबाई का योग वापस करना चाहिए? जूलिया में हर किसी को अपने "चपटा" समरूपता को प्रत्यक्ष-योग स्थानों के लिए अपनाने के लिए मजबूर किया जाना चाहिए? यदि नहीं, तो निकटवर्ती को पुनरावर्ती होना चाहिए।

और यदि आप "केवल बेहतर समझने की कोशिश कर रहे हैं, एक विशेष बिंदु नहीं बना रहे हैं", तो क्या आप इसे एक अलग मंच पर ले जा सकते हैं? यह समस्या प्रत्यक्ष-योग स्थानों के अर्थ के बारे में आध्यात्मिक तर्क के बिना पर्याप्त भ्रमित है।

सिर्फ इसलिए कि दो स्थान हैं आइसोमॉर्फिक का मतलब यह नहीं है कि वे "समान" स्थान हैं

मैं निश्चित रूप से सुझाव नहीं दे रहा था कि, बिल्कुल।

फिर, मुझे यकीन नहीं है कि आपकी बात क्या है

मैं गंभीरता से सुझाव दे रहा हूं कि यदि आप AbstractArray साथ रैखिक बीजगणित करना चाहते हैं, तो eltype बेहतर एक रिंग हो ( + , * और conj ) जो बाहर नियम रखता है उदाहरण के लिए Vector क्योंकि [1,2] * [3,4] काम नहीं करता है। और एक वेक्टर के length वास्तव में आपके रैखिक बीजगणित की गतिशीलता का प्रतिनिधित्व करेंगे। हां, यह असीम रूप से आयामी वेक्टर रिक्त स्थान से बाहर है, लेकिन आम तौर पर जूलिया AbstractVector असीम आकार नहीं हो सकता है। मुझे लगता है कि इसे लागू करने और जूलिया पर रैखिक बीजगणित की कार्यक्षमता का उपयोग करने के बारे में तर्क करना आसान होगा। हालांकि, उपयोगकर्ताओं को स्पष्ट रूप से नेस्टेड सरणी संरचनाओं के बजाय BlockArray या समान के माध्यम से एक प्रत्यक्ष राशि को निरूपित करना होगा।

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

यह सब सीधे ओपी के लिए प्रासंगिक लगता है। लागू किए गए चपटा दृष्टिकोण के साथ, हम पुनरावर्ती पारगमन / adjoints को खोदेंगे, और यदि हमने पुनरावर्ती पारगमन / adjoints को खोदा है, तो केवल चपटा संरचनाएं रैखिक बीजगणित के लिए व्यवहार्य हो सकती हैं। यदि हम एक चपटा दृष्टिकोण लागू नहीं करते हैं, तो हमें एक पुनरावर्ती आसन्न रखना चाहिए । मेरे लिए, यह एक जुड़ा हुआ निर्णय लग रहा था।

क्या आप गंभीरता से प्रस्ताव कर रहे हैं कि जूलिया में eltype(::Vector{Vector{Complex}}) Complex होना चाहिए, या कि length को लंबाई का योग वापस करना चाहिए?

नहीं, क्षमा करें, शायद मैंने जो लिखा था वह स्पष्ट नहीं था - मैं केवल सुझाव दे रहा था कि इस उद्देश्य के लिए दो नए सुविधा कार्य कुछ परिस्थितियों में काम आ सकते हैं। उदाहरण के लिए, कभी-कभी आप उस रिंग के zero या one चाहें, हो सकता है।

क्या आप कह रहे हैं कि जूलिया में हर किसी को आपके "चपटा" समरूपता को प्रत्यक्ष-योग के लिए अपनाने के लिए मजबूर होना चाहिए?

मैं सुझाव दे रहा था कि एक संभावना के रूप में, हाँ। मैं 100% आश्वस्त नहीं हूं कि यह सबसे अच्छा विचार है, लेकिन मुझे लगता है कि कुछ फायदे (और कुछ नुकसान) हैं।

यहाँ क्रियात्मक परिवर्तनों के दायरे में लौटते हुए, ऐसा लगता है कि मेरे प्रस्ताव का @stevengj सरलीकृत संस्करण यहाँ जाने का मार्ग है, अर्थात:

• conj as-is (एलिमेंट वाइज) रखें।
• बनाओ a' के अनुरूप adjoint(a) , और यह हमेशा पुनरावर्ती (और इसलिए तार आदि के एरे जहां adjoint तत्वों के लिए निर्धारित नहीं है के लिए असफल) बनाते हैं।
• बनाओ a.' के अनुरूप transpose(a) , और यह कभी पुनरावर्ती बनाना (सिर्फ एक permutedims ), और इसलिए तत्वों के प्रकार पर ध्यान न दें।

मुख्य वास्तविक "टॉडोस" जिसे इस से निकाला जा सकता है:

1. [] ctranspose नाम बदलें adjoint ।
2. [] transpose को गैर-पुनरावर्ती होने के लिए बदलें।
3. [] चित्रा बाहर यह कैसे पंक्ति वैक्टर के साथ फिट बैठता है।

मुझे संदेह है कि पुनरावर्ती हस्तांतरण पर भरोसा करना पर्याप्त रूप से दुर्लभ है कि हम इसे 1.0 में बदल सकते हैं और इसे NEWS में तोड़ सकते हैं। ctranspose से adjoint बदलना एक सामान्य अवमूल्यन के माध्यम से जा सकता है (हालांकि हम 1.0 के लिए ऐसा करते हैं)। क्या कुछ और है जो करने की आवश्यकता है?

@StefanKarpinski , हमें RowVector लिए इसी परिवर्तन करने की आवश्यकता होगी। एक संभावना RowVector Transpose और Adjoint आलसी गैर-पुनरावर्ती transpose और आलसी पुनरावृत्ति के लिए adjoint क्रमशः विभाजित करने की होगी। और Conj (आलसी conj ) से छुटकारा पाने के लिए।

कम से कम स्पर्श संबंधी कुछ बदलाव

• कुछ दृश्य transpose और adjoint AbstractMatrix
• adjoint(::Diagonal) पुनरावर्ती (यकीनन हमें इस "बग" को Diagonal transpose और ctranspose जुलिया v0.6.0 से पहले ठीक करना चाहिए)
• चीजों में उचित "स्केलर" प्रकार का उपयोग करें: v = Vector{Vector{Float64}}(); dot(v,v) (वर्तमान में एक त्रुटि - यह zero(Vector{Float64}) लौटने की कोशिश करता है)

ठीक है, मैं पुनरावर्ती ब्लॉक मैट्रिक्स को गंभीरता से लेना है, और मैं भी के व्यवहार में सुधार करने के कोशिश कर रहा हूँ इस का बैकअप लेने की कोशिश कर रहा है Diagonal यहाँ (वहाँ पहले से ही कुछ तरीकों की आशा कर रहे हैं एक ब्लॉक विकर्ण संरचना, जैसे getindex , इसलिए इस मामले में पारगमन को पुनरावर्ती बनाना स्वाभाविक लगता है)।

जहां मैं फंस गया हूं, और ऊपर दिए गए मेरे सभी चर्चा बिंदुओं को सीधे प्रेरित किया है, ऐसी संरचना पर रैखिक बीजगणित संचालन कैसे करना है, जिसमें inv , det , expm । eig , और इसी तरह। उदाहरण के लिए, det(::Diagonal{T}) where T लिए एक विधि है जो सिर्फ सभी विकर्ण तत्वों के उत्पाद को लेती है। T <: Number लिए शानदार ढंग से काम करता है, और यह भी काम करता है अगर सभी तत्व समान आकार के वर्ग मैट्रिसेस हैं। (बेशक, अगर वे एक ही आकार के वर्ग मैट्रिक्स कर रहे हैं, तो तत्व एक अंगूठी के रूप में, और यह सब काफी समझदार है - भी पुनरावर्ती पक्षांतरित (संपादित करें: adjoint) सही बात है)।

हालांकि, अगर हम एक सामान्य ब्लॉक-विकर्ण मैट्रिक्स Diagonal{Matrix{T}} , या किसी भी ब्लॉक-मैट्रिक्स Matrix{Matrix{T}} बारे में सोचते हैं, तो हम आम तौर पर स्केलर T रूप में इसके निर्धारक की बात कर सकते हैं। Ie यदि आकार (3 ⊕ 4) × (3 ⊕ 4) (विकर्ण तत्वों के साथ एक 2 × 2 मैट्रिक्स जो आयाम 3 × 3, 4 × 4 और मिलान-विकर्ण तत्वों से मेल खाते हैं), तो det वापसी होनी चाहिए। "चपटा" 7 × 7 संरचना के निर्धारक, या इसे बस कोशिश करनी चाहिए और 2 × 2 के तत्वों को गुणा करना चाहिए जैसे वे हैं (और त्रुटि-आउट, इस मामले में)?

(संपादित करें: मैंने उपरोक्त आयामों को अलग-अलग किया है, जो अस्पष्ट भाषा से बचना चाहिए)

मुझे a' पुनरावर्ती होने में कोई समस्या नहीं है, लेकिन मैं व्यक्तिगत रूप से नए a.' नोटेशन को बहुत भ्रमित करूंगा। यदि आपने मुझे जूलिया के मेरे मानसिक मॉडल के आधार पर मुझे सिंटैक्स a.' दिखाया, तो यह होगा कि यह transpose.(a) अर्थात a का मूल रूप से हस्तांतरण करता है, और मैं पूरी तरह से होऊंगा गलत। वैकल्पिक रूप से, यदि आपने मुझे दिखाया कि a' और a.' दोनों एक प्रस्ताव के लिए विकल्प थे, और उनमें से एक ने भी तत्ववापसी की, तो मैं आपको बताऊंगा कि a.' होना आवश्यक है। एलिमेंट वाइज पुनरावृत्ति, और मैं फिर से गलत होगा।

बेशक, इस मामले में . का मेरा मानसिक मॉडल गलत है। लेकिन मुझे संदेह है कि मैं एकमात्र ऐसा व्यक्ति नहीं हूं जो उस वाक्य रचना को बिल्कुल गलत तरीके से व्याख्यायित करेगा। उस अंत तक, मैं गैर-पुनरावर्ती हस्तांतरण के लिए .' अलावा कुछ का उपयोग करने का सुझाव दूंगा।

@ मुझे लगता है कि मुझे डर है कि यह वाक्य रचना MATLAB से निकली है। एक बार (काफी अद्भुत) डॉट-कॉल प्रसारण सिंटैक्स v0.5 के लिए पेश किया गया था, यह थोड़ा दुर्भाग्यपूर्ण हो गया।

हम MATLAB से अलग अपना रास्ता बना सकते हैं और इसे बदल सकते हैं - लेकिन मेरा मानना ​​है कि इसके बारे में कहीं अलग चर्चा हुई थी (किसी को याद है कि कहां है?)।

आह, यह दुर्भाग्यपूर्ण है। धन्यवाद!

एक और कार्य:

• [] issymmetric और ishermitian का मिलान करने के लिए transpose और adjoint - प्रत्येक जोड़ी का पूर्ववर्ती गैर-पुनरावर्ती है, प्रत्येक जोड़ी का उत्तरवर्ती पुनरावर्ती है।

Matlab .' सिंटैक्स निश्चित रूप से हमारे नए . सिंटैक्स के संदर्भ में काफी दुर्भाग्यपूर्ण है। मैं इसे बदलने के खिलाफ नहीं होऊंगा, लेकिन तब हमें संक्रमण के लिए एक नए वाक्यविन्यास की आवश्यकता होती है, और मुझे यकीन नहीं है कि हमारे पास एक उपलब्ध है। किसी के पास भी कोई सुझाव है?

चलिए यहां पर ट्रांसजेंड सिंटैक्स चर्चा को आगे बढ़ाते हैं: https://github.com/JuliaLang/julia/issues/21037।

मेरे पास transpose / ctranspose / adjoint बारे में कोई ठोस राय नहीं है, लेकिन मैं इसके बजाय A::Matrix{Matrix{T}} को ब्लॉक मैट्रिक्स की तरह नहीं मानूंगा एक आलसी hvcat भावना, जो @andyferris कम से कम भाग में लगती है। यही है, अगर A के तत्व सभी एक ही आकार के वर्ग मैट्रिसेस थे (यानी एक रिंग बनाते हैं), तो मुझे उस आकार के एक वर्ग को फिर से वापस करने के लिए det(A) उम्मीद होगी। यदि वे आयताकार या विभिन्न आकारों के हैं, तो मैं एक त्रुटि की उम्मीद करूंगा।

उस ने कहा, एक ब्लॉक मैट्रिक्स / आलसी बिल्ली प्रकार उपयोगी हो सकता है, लेकिन यह सभी तरह से जाना चाहिए और चपटा डेटा पर काम करने के लिए उदा getindex को भी परिभाषित करना चाहिए। लेकिन मैं निश्चित रूप से Matrix या मौजूदा मैट्रिक्स प्रकारों जैसे Diagonal द्वारा अवशोषित इस अवधारणा को नहीं देखना चाहूंगा।

यह राहत है, @martinholters। इस धागे में पहले जो मैं घबरा रहा था, वह यह विचार था कि हमें किसी तरह जूलिया के पूरे रैखिक बीजगणित की रूपरेखा को मनमाने ढंग से ब्लॉक मेट्रिसेस के लिए Matrix{Matrix} लागू करने में सक्षम होना चाहिए (जहां उपमात्रा में भिन्न आकार होते हैं)।

मैं क्या "चपटे" के साथ बहस कर रहा था कि तत्व क्या हैं, का कोई फैंसी आत्मनिरीक्षण नहीं कर रहा है, और बस तत्वों को अपने गुण के आधार पर एक अंगूठी के तत्वों के रूप में मानें। हालाँकि, पुनरावर्ती ctranspose / adjoint तत्वों की अनुमति देता है जो रैखिक ऑपरेटरों की तरह कार्य करते हैं, जो सही और उपयोगी लगता है। (दूसरा मामला एक वेक्टर के तत्वों का है जो एक वेक्टर की तरह काम करता है, जहां एक पुनरावर्ती निकटता भी सही है)।

थोड़ा और पीछे जाने के लिए - transpose(x) = x और ctranpsose(x) = conj(x) लिए डिफ़ॉल्ट नो-ऑप व्यवहार को हटाने की मूल प्रेरणा क्या थी? ये हमेशा मेरे लिए काफी उपयोगी लगते थे।

थोड़ा आगे जाने के लिए - संक्रमण (x) = x और ctranpsose (x) = conj (x) के लिए डिफ़ॉल्ट नो-ऑप व्यवहार को हटाने के लिए मूल प्रेरणा क्या थी? ये हमेशा मेरे लिए काफी उपयोगी लगते थे।

यह कस्टम रैखिक-संचालक प्रकारों (जो कि AbstractArray के उपप्रकार नहीं हो सकते) से प्रेरित था, जो ctranspose विशेषज्ञ करने में विफल रहा। इसका मतलब यह था कि उन्हें एक गलत कदम से https://github.com/JuliaLang/julia/issues/13171

https://discourse.julialang.org/t/proposal-rename-rowvector-to-transposevector-add-rowvector-that-doesnt-transposes-entries/4681

हमें दो विकल्प प्रतीत होते हैं - दोनों में, transpose गैर-पुनरावर्ती हो जाते हैं, अन्यथा:

1. गैर-पुनरावर्ती ctranspose ।
2. पुनरावर्ती ctranspose ।

@stevengj , @jiahao , @andreasnoack - आपकी प्राथमिकताएँ यहाँ क्या हैं? अन्य?

मैं के बाद से @jiahao के JuliaCon 2017 बात इस बारे में बहुत कुछ सोच रहा हूँ।

मेरे लिए, मुझे अभी भी लगता है कि रैखिक बीजगणित को "स्केलर" फ़ील्ड के संबंध में एक तत्व प्रकार T रूप में परिभाषित किया जाना चाहिए। यदि T एक फ़ील्ड है ( + , * और conj ( - भी / , .. का समर्थन करता है) ।)) तब मैं यह नहीं देखता कि Base.LinAlg विफल क्यों हों।

उदाहरण के लिए, OTOH यह ब्लॉक मैट्रिक्स के पारगमन लेने के बारे में बात करने के लिए काफी सामान्य (और मान्य) है। मुझे लगता है कि हम यहां "गणितीय" प्रकार के सिद्धांत से सीख सकते हैं, जो उदाहरण के लिए स्केल के सेट के "पहले के आदेश" सेट, "दूसरे क्रम" के सेट ऑफ स्केलर के सेट, "तीसरे" के सेटों पर चर्चा करने से उत्पन्न अजीब बयानों से निपटने की कोशिश करता है। आदेश "स्केलर के सेट के सेट, और इतने पर। मुझे लगता है कि हमारे पास एक ही समस्या (और अवसर) है जब सरणियों के सरणियों से निपटते हैं - हम संभावित रूप से जूलिया के टाइप सिस्टम का उपयोग कर सकते हैं ताकि "सच्चे" स्केलर के "प्रथम क्रम" सरणियों का वर्णन किया जा सके, स्केलरों के सरणियों के "दूसरे क्रम" सरणियों आदि। मुझे लगता है कि @stevengj , खुद और अन्य लोगों के बीच लंबी चर्चा इस तथ्य के परिणामस्वरूप हुई है कि, हाँ, आप मनमाने ढंग से "आदेश" के सरणियों पर संचालन के एक आत्मनिर्भर सेट के साथ आ सकते हैं, और इस ढांचे में (ग) संक्रमण स्पष्ट रूप से और सही ढंग से पुनरावर्ती है, लेकिन फिर भी, आपको ऐसा करने की आवश्यकता नहीं है। जैसा कि जियाओ की बात स्पष्ट रूप से बताई गई है, प्रोग्रामिंग लैंग्वेज / फ्रेमवर्क एरर्स को सरणियों (या नहीं) से अलग करने के बारे में शब्दार्थ विकल्प बनाते हैं, मैट्रिस (या नहीं) और इतने पर से वैक्टर को अलग करते हैं, और मुझे लगता है कि यह एक संबंधित पसंद है जिसे हम बना सकते हैं।

मेरे लिए, यहाँ महत्वपूर्ण बिंदु यह है कि "मनमाना क्रम" सरणी का काम करने के लिए आपको अपने "स्केलर्स" को कुछ ऑपरेशनों को सिखाना होगा जो आमतौर पर केवल वैक्टर और मैट्रिस पर परिभाषित होते हैं। वर्तमान जूलिया विधि जो ऐसा करती है वह transpose(x::Number) = x । हालांकि, मैं वास्तव में पसंद करूंगा यदि हम इस पद्धति को हटाकर सरणियों और स्केलरों के बीच हमारे शब्दार्थ भेद को बढ़ाते हैं - और मुझे लगता है कि यह काफी संभव हो सकता है।

अगला कदम Base.LinAlg को पहले-ऑर्डर मैट्रिक्स और दूसरे-ऑर्डर मैट्रिक्स और इतने पर के बीच का अंतर सिखाना होगा। मैंने दो व्यवहार्य विकल्पों के बारे में सोचा है, और भी बहुत कुछ हो सकता है, मैं वास्तव में नहीं जानता:

• "सरणी" के लिए कुछ प्रकार के ऑप्ट-इन विशेषता रखें, ताकि transpose(::AbstractMatrix{T}) पुनरावृत्ति हो जब T AbstractMatOrVec न हो, और न कि जब T Number , और इसे किसी भी तरह से विन्यास योग्य बनाएं (ऑप्ट-इन, ऑप्ट-आउट, जो भी हो) अन्यथा। (कुछ मायनों में यह तत्वों के लिए transpose पद्धति के व्यवहार को नियंत्रित करके किया गया था, लेकिन मुझे लगता है कि transpose पद्धति के व्यवहार को नियंत्रित करने के लिए यह बाहरी (बाहरी) है ) सरणी)।
• वैकल्पिक रूप से, यह है कि ज्यादातर ज़ोर AbstractArray एस सहित Array रों पहले के आदेश (उनके तत्वों अदिश क्षेत्र हैं), और एक अलग का उपयोग AbstractArray प्रकार (कहना NestedArray ) सरणियों को लपेटने और "निशान" करने के लिए कि उनके तत्वों को सरणियों के रूप में माना जाना चाहिए न कि स्केलर। मैंने इसके साथ थोड़ा खेलने की कोशिश की, लेकिन ऐसा लगता था कि उपरोक्त विकल्प शायद उपयोगकर्ताओं के लिए बोझ से कम है।

मुझे लगता है कि जूलिया एरे और स्केलर्स के बीच एक मजबूत सिमेंटिक पृथक्करण बनाता है, और यह कि वर्तमान स्थिति मुझे (के साथ) थोड़ी असंगत लगती है, क्योंकि स्केल संपत्ति transpose बारे में "सिखाया" जाना था। एक उपयोगकर्ता स्पष्ट रूप से बता सकता है कि Matrix{Float64} स्केलर्स (प्रथम-क्रम सरणी) का एक मैट्रिक्स है और Matrix{Matrix{Float64}} एक ब्लॉक मैट्रिक्स (द्वितीय-क्रम सरणी) है। यह हमारे लिए और अधिक सुसंगत हो सकता है कि प्रकार या प्रणाली का उपयोग करके यह निर्धारित किया जाए कि कोई सरणी "प्रथम क्रम" है या जो भी हो। मुझे यह भी लगता है कि पहला विकल्प जो मैंने सूचीबद्ध किया है वह जूलिया को अधिक उपयोगकर्ता के अनुकूल बना देगा (इसलिए मैं ["abc", "def"].' कर सकता हूं) फिर भी ब्लॉक मैट्रिसेस के साथ कुछ समझदार / उपयोगी डिफ़ॉल्ट काम करने के लिए लचीलापन बनाए रखें।

इतने लंबे समय तक वीणा के लिए खेद है, लेकिन जूलियाकॉन में @ @StefanKarpinski द्वारा उल्लिखित अन्य विकल्पों को "काम" से ऊपर कर सकते हैं, लेकिन मेरे लिए यह "वर्किंग" होगा जैसे मैट्रिक्स / वेक्टर बीजगणित RowVector "

TLDR था - मत बनाओ ( c ) transpose या तो पुनरावर्ती हो या न हो - इसे दोनों (यानी विन्यास योग्य) होने दो।

वे अच्छे बिंदु हैं, लेकिन केवल यह इंगित करना चाहते हैं कि (c)transpose बारे में शिकायतों के लगभग सभी (यदि सभी नहीं) पुनरावृत्ति ' और .' गैर-माथि उपयोग से संबंधित हैं Vector{String} और Vector{PyObject} 1xn मैट्रिसेस में। टाइप करके इसे ठीक करना आसान है लेकिन मैं देख सकता हूं कि यह कष्टप्रद है। हालांकि, सोच यह थी कि पुनरावर्ती परिभाषा गणितीय रूप से सही थी और "कई मामलों में सही लेकिन कष्टप्रद" "दुर्लभ मामलों में सुविधाजनक लेकिन गलत" से बेहतर थी।

एक संभावित समाधान पहली गोली में आपका सुझाव हो सकता है, अर्थात केवल सरणी-जैसे तत्वों के लिए पुनरावर्ती प्रस्ताव होना चाहिए। मेरा मानना ​​है कि T<:AbstractVecOrMat ज्यादातर मामलों को "सुविधाजनक लेकिन बहुत दुर्लभ मामलों में गलत" की स्थिति में बदल देंगे। यह अभी भी गलत हो सकता है इसका कारण यह है कि कुछ ऑपरेटर जैसे प्रकार AbstractMatrix में फिट नहीं होंगे क्योंकि AbstractArray इंटरफ़ेस मुख्य रूप से सरणी ( getindex ) शब्दार्थ के बारे में है , रैखिक बीजगणित नहीं।

@ कैंडीफरिस , एक स्केलर के सहायक और दोहरे पूरी तरह से अच्छी तरह से परिभाषित हैं, और ctranspose(x::Number) = conj(x) सही है।

मेरी भावना यह है कि transpose अधिकांश उपयोग "नॉन-मैथी" हैं, और ctranspose (यानी जहां संयुग्मन व्यवहार वांछित है) के अधिकांश उपयोग मैथी हैं (क्योंकि वहाँ कोई अन्य कारण नहीं है) )। इसलिए, मैं गैर-पुनरावर्ती transpose और पुनरावर्ती ctranspose पक्ष में होना चाहूंगा।

निजी तौर पर, मुझे लगता है कि ब्लॉक एरे को देखने की कोशिश करना Arrays n https://github.com/KristofferC/BlockArrays.jl यह।

अच्छा लग रहा है, @KristofferC।

एक बहुत ही मान्य बिंदु है जो @stevengj ऊपर बनाता है, और वह यह है कि कभी-कभी आपके तत्व जैसे गणितीय अर्थों में वैक्टर या रैखिक ऑपरेटर हो सकते हैं, लेकिन AbstractArray s नहीं। हमें निश्चित रूप से इन के लिए पुनरावर्ती (सी) हस्तांतरण करने का एक तरीका चाहिए - यकीन नहीं कि आपने इस बारे में सोचा है या नहीं, लेकिन मुझे लगा कि मैं इसका उल्लेख करूंगा।

इस विषय पर एक सुस्त / # linalg बातचीत की मुख्य विशेषताएं। उपरोक्त धागे में से कुछ को फिर से बनाता है। शब्दार्थ पर ध्यान केंद्रित करता है, वर्तनी से बचा जाता है। (उस बातचीत में भाग लेने वाले सभी को धन्यवाद! :))

तीन अलग-अलग ऑपरेशन मौजूद हैं:
1) "गणितीय सहायक" (पुनरावर्ती और आलसी)
2) "गणितीय संक्रमण" (आदर्श रूप से पुनरावर्ती और आलसी)
3) "संरचनात्मक परिवर्तन" (आदर्श रूप से गैर-पुनरावर्ती और? उत्सुक?)

वर्तमान स्थिति: ctranspose लिए "गणितीय आसन्न" मानचित्र, "गणितीय स्थानान्तरण" से transpose , और "संरचनात्मक रूपांतर" से permutedims(C, (2, 1)) दो-आयामी C और reshape(C, 1, length(C)) एक-विषयक C । मुद्दा: "संरचनात्मक हस्तांतरण" एक सामान्य ऑपरेशन है, और permutedims / reshape कहानी कुछ भ्रामक / अप्राकृतिक / कष्टप्रद है।

यह कैसे उत्पन्न हुआ: पहले "संरचनात्मक संक्रमण" को " transpose(x::Any) = x , ctranspose(x::Any) = conj(x) , और conj(x::Any) = x जैसे सामान्य नो-ऑप कमियों के माध्यम से" गणितीय आसन्न "/" गणितीय पारगमन "के साथ जब्त किया गया था। इन कमियों ने ज्यादातर मामलों में "संरचनात्मक हस्तांतरण" के लिए [c]transpose और संबंधित पोस्टफ़िक्स ऑपरेटरों ' / .' सेवा की। महान। लेकिन उन्होंने कुछ उपयोगकर्ता-परिभाषित संख्यात्मक प्रकारों पर [c]transpose संचालन को भी गलत तरीके से विफल कर दिया (गलत परिणाम लौटाएं) उन प्रकारों के लिए [c]transpose विशेषज्ञता की अनुपस्थित परिभाषा। आउच। इसलिए उन सामान्य नो-ऑप कमियों को हटा दिया गया था, जो वर्तमान स्थिति की उपज थी।

सवाल यह है कि अब क्या किया जाए।

आदर्श परिणाम: "संरचनात्मक संक्रमण" के लिए एक एकीकृत, प्राकृतिक और कॉम्पैक्ट झुकाव प्रदान करें। इसके साथ ही गणितीय रूप से स्थगन और संक्रमण को सही करने के लिए समर्थन करें। उपयोग या कार्यान्वयन में मुश्किल कोने के मामलों को पेश करने से बचें।

दो व्यापक प्रस्ताव मौजूद हैं:

(१) गणितीय संश्लिष्ट, गणितीय पारगमन, और संरचनात्मक रूपांतर तीन वाक्यविन्यास और शब्दार्थ रूप से अलग-अलग संक्रियाएँ प्रदान करते हैं। अपसाइड्स: सब कुछ काम करता है, सफाई से अवधारणाओं को अलग करता है, और मुश्किल कोने के मामलों से बचा जाता है। डाउनसाइड्स: समझाने और लागू करने के लिए तीन ऑपरेशन।

(2) जूता-सींग तीन ऑपरेशन को दो में। इस प्रस्ताव के तीन रूप मौजूद हैं:

(2a) transpose शब्दार्थिक रूप से "संरचनात्मक स्थानान्तरण" करें, जो आम मामलों में "गणितीय स्थानान्तरण" भी है। अपसाइड्स: दो ऑपरेशन। असंदिग्ध रूप से अदिश तत्वों वाले कंटेनरों के लिए अपेक्षित के रूप में काम करता है। डाउनसाइड्स: किसी को "गणितीय संक्रमण" की उम्मीद है, शब्दार्थ चुपचाप वस्तुओं पर गलत परिणाम प्राप्त करेंगे, जो कि असंदिग्ध रूप से अदिश तत्वों वाले कंटेनरों की तुलना में अधिक जटिल हैं। यदि उपयोगकर्ता उस समस्या को पकड़ता है, तो "गणितीय संक्रमण" शब्दार्थ को प्राप्त करने के लिए नए प्रकार और / या विधियों को परिभाषित करने की आवश्यकता होती है।

(२ बी) एक प्रकार की "गणित" का संकेत देने वाला गुण प्रस्तुत करता है। जब किसी वस्तु पर स्थगन / स्थानांतरण लागू होता है, यदि कंटेनर / तत्व प्रकार "मैथी" हैं, तो पुनरावृत्ति करें; यदि नहीं, तो पुनरावृत्ति न करें। अपसाइड्स: दो ऑपरेशन। कई सामान्य मामलों को कवर कर सकता है। डाउनसाइड्स: जेनेरिक न-ऑप [c]transpose कमियां के रूप में एक ही मुद्दे से ग्रस्त हैं, यानी उपयोगकर्ता द्वारा परिभाषित संख्यात्मक प्रकारों के लिए आवश्यक गुण परिभाषाओं की कमी के कारण चुपचाप गलत परिणाम दे सकते हैं। एक "मैथी" प्रकार के संरचनात्मक हस्तांतरण के आवेदन को सक्षम नहीं करता है या एक "गैर-मैथी" प्रकार को गणितीय संक्रमण करता है। स्पष्ट नहीं है कि कैसे तय किया जाए कि कोई वस्तु सभी मामलों में "मैथी" है या नहीं। (जैसे, यदि तत्व प्रकार सार है? क्या पुनरावर्ती / गैर-पुनरावर्ती निर्णय है तो रनटाइम और एलीमेंटीव, या रनटाइम और कंटेनर में सभी तत्वों पर अपने सामूहिक प्रकार की जांच करने के लिए पहले स्वीप की आवश्यकता है?)

(2c) adjoint ( ctranspose ) "गणितीय निकटता" और transpose "गणितीय स्थानान्तरण" रखें, और adjoint लिए विशेष (जेनरिक फ़ॉलबैक) तरीकों को पेश न करें। गैर-संख्यात्मक स्केलर प्रकारों के लिए / transpose (जैसे adjoint(s::AbstractString) = s )। अपसाइड्स: दो ऑपरेशन। सही गणितीय शब्दार्थ। डाउनसाइड्स: गैर-संख्यात्मक प्रकारों के लिए adjoint / transpose टुकड़ा-टुकड़ा परिभाषा की आवश्यकता होती है, जेनेरिक प्रोग्रामिंग को बाधित करता है। "मैथी" प्रकार के संरचनात्मक संक्रमण के आवेदन को सक्षम नहीं करता है।

प्रस्तावों (1) और (2 ए) (2 बी) और (2 सी) की तुलना में व्यापक रूप से व्यापक समर्थन मिला।

कृपया # 19344, # 21037, # 13171, और स्लैक / # लिनालग में अधिक चर्चा पाएं। श्रेष्ठ!

अच्छा लिखने के लिए धन्यवाद!

मैं तालिका पर एक और संभावना रखना चाहता हूं जो विकल्प 1 के साथ अच्छी तरह से जाएगी: गणितीय मैट्रिसेस और सारणीबद्ध डेटा के लिए अलग-अलग कंटेनर प्रकार हैं। तब के अर्थ A' के प्रकार के द्वारा निर्णय लिया जा सकता है A (ध्यान दें: नहीं अपने तत्व प्रकार के रूप में ऊपर चर्चा की)। विपक्ष यहाँ हैं कि इसके लिए दोनों के बीच बहुत सारे convert s की आवश्यकता हो सकती है (क्या यह?) और निश्चित रूप से, अत्यधिक विघटनकारी होगा। बेशक, मैं संदेह से अधिक हूं कि क्या लाभ इस व्यवधान को सही ठहराएंगे, लेकिन फिर भी इसका उल्लेख करना चाहते थे।

धन्यवाद, उत्कृष्ट राइटअप। मैं वोट देता हूं (1)।

शानदार लेखन। ध्यान दें कि (1) वर्तनी हो सकती है:

• सहायक: a' (पुनरावर्ती, आलसी)
• गणितीय संक्रमण: conj(a') (पुनरावर्ती, आलसी)
• संरचनात्मक परिवर्तन: a.' (गैर-पुनरावर्ती, उत्सुक)

इसलिए जरूरी नहीं कि किसी भी नए ऑपरेटर को पेश किया जाए - समवर्ती और संयुग्मन के लिए गणितीय पारगमन सिर्फ एक (आलसी और इसलिए कुशल) रचना होगी। सबसे बड़ा मुद्दा यह है कि यह दो समान प्रतीत होता है ऑपरेटर, अर्थात् ' और .' , काफी अलग शब्द। हालाँकि, मैं सबसे सही जेनेरिक कोड में बताऊंगा कि क्या किसी ने ' या .' है या नहीं, इसका 99% सटीक संकेत है कि क्या उनका मतलब "मुझे इस चीज़ का सन्दर्भ देना" है या "स्वैप"? इस चीज के आयाम ”। इसके अलावा, ऐसे मामलों में जहां किसी ने ' का उपयोग किया है और वास्तव में "इस चीज के आयामों को स्वैप" किया है, उनका कोड उन तत्वों के साथ किसी भी मैट्रिक्स के लिए पहले से ही गलत होगा जिनके स्केलर के आस-पास गैर-तुच्छ है, जैसे कि जटिल संख्याएं। कुछ शेष मामलों में जहां किसी का वास्तव में मतलब था "मुझे इस के निकटवर्ती का संयुग्मन दें", मैं तर्क दूंगा कि conj(a') लिखने का अर्थ है कि बहुत अधिक स्पष्ट है क्योंकि व्यवहार में लोग वास्तव में a.' का उपयोग करते हैं। मतलब " a के आयाम स्वैप"।

सभी अंतर्निहित सामान्य प्रकारों के लिए काम करना, जिनके लिए हमें इसकी आवश्यकता होगी, यह निर्धारित किया जाना है, लेकिन @andreasnoack इस मामले पर पहले से ही कुछ विचार रखते हैं और यह संभव लगता है।

मुझे लगा कि मुझे भी अपडेट करना चाहिए, क्योंकि यह चर्चा कहीं और चली गई थी। मैं स्वीकार करता हूं कि इस प्रस्ताव के बारे में एक (स्पष्ट?) बात थी जो मुझे पूरी तरह याद आ गई थी, जो मुझे लगता था कि हम रैखिक बीजगणित के लिए .' का उपयोग करना जारी रखेंगे, लेकिन मुझे महसूस करना चाहिए कि यह मामला नहीं है !

उदाहरण के लिए, vector.' को अब RowVector होने की आवश्यकता नहीं होगी (चूँकि RowVector एक रेखीय बीजगणित अवधारणा है, "दोहरे" वेक्टर पर हमारा पहला प्रयास) - यह बस हो सकता है एक Matrix । जब मैं रैखिक बीजगणित में "गैर-संयुग्मन पारगमन" चाहता हूं, तो जो मैं वास्तव में कर रहा हूं, वह conj(adjoint(a)) ले रहा है, और यही हम सभी रैखिक बीजगणित उपयोगकर्ताओं का उपयोग करने की सलाह देंगे (अब तक मेरे पास है) MATLAB के बाद से एक लंबे समय से "बुरा" आदत सिर्फ इस्तेमाल किया था a.' बजाय a' किसी भी मैट्रिक्स (या सदिश) जो मुझे पता था कि वास्तविक था transposing के लिए, जब क्या मैं वास्तव में चाहता था adjoint (या दोहरी) - नाम में परिवर्तन यहां एक बड़ी मदद होगी)।

मैं संक्षेप में यह भी बताता हूं कि यह एक दिलचस्प स्थान खोलता है। पहले vector' और vector.' को "डेटा ट्रांज़ोज़" करने और दोहरी वेक्टर जैसी चीज़ लेने की दोहरी ज़रूरतों को पूरा करना पड़ता था। अब कि .' सरणी आकार में हेरफेर करने के लिए है और ' एक रेखीय बीजगणित अवधारणा है, हम RowVector को 1D DualVector या कुछ और में बदलने में सक्षम हो सकते हैं। पूरी तरह से। (शायद हमें यहां इस पर चर्चा नहीं करनी चाहिए - अगर किसी को इसके लिए भूख है, तो आइए एक अलग मुद्दा बनाते हैं।)

अंत में, मैं सुस्त से एक प्रस्तावित कार्य योजना की प्रतिलिपि बनाऊंगा:

1) transpose LinAlg Base आगे बढ़ें और depwarns (0.7 केवल) जोड़ें इसके बारे में अब RowVector रहा है या पुनरावर्ती (यदि यह संभव है)
2) हर जगह ctranspose से adjoint नाम बदलें
3) Vector , ConjVector और RowVector ' और conj संयोजन के साथ काम करना सुनिश्चित करें, संभवतः * , संभवतः RowVector नाम बदलें। (यहाँ हम conj(vector) आलसी भी बनाते हैं)।
4) एक आलसी मैट्रिक्स को जोड़ो जो conj और ConjMatrix साथ अच्छी तरह से बातचीत करता है
5) A_mul_Bc हटा दें। A_mul_B! से mul! (या *! ) का नाम बदलें।
6) लाभ

@stevengj ने लिखा:

@ कैंडीफरिस , एक स्केलर के सहायक और दोहरे पूरी तरह से अच्छी तरह से परिभाषित हैं, और ctranspose(x::Number) = conj(x) सही है।

रिकॉर्ड के लिए, मैं निश्चित रूप से इससे सहमत हूं।

मेरी भावना यह है कि संक्रमण के अधिकांश उपयोग "नॉन-मैथी" हैं, और ctranspose (...) के अधिकांश उपयोग मैथी हैं

इसलिए यह विचार औपचारिक होगा: transpose का सभी उपयोग "नॉन-मैथी" हो जाएगा और adjoint का एकमात्र उपयोग "मैथी" हो जाएगा।

उदाहरण के लिए, vector.' को अब RowVector होने की आवश्यकता नहीं होगी (क्योंकि RowVector एक रेखीय बीजगणित अवधारणा है, "दोहरे" वेक्टर पर हमारा पहला प्रयास है) - यह बस हो सकता है एक Matrix ।

हम अभी भी .' हालांकि आलसी होना चाहते हैं। उदाहरण के लिए X .= f.(x, y.') अभी भी गैर-आवंटित होना चाहिए।

यहाँ एक प्रश्न है: हमें issymmetric(::AbstractMatrix{<:AbstractMatrix}) कैसे लागू करना चाहिए? क्या यह transpose से मिलान करने के लिए एक गैर-पुनरावर्ती चेक होगा? मैं कार्यान्वयन को देख रहा हूं; यह मानता है कि तत्व transpose । OTOH यह जाँचने के लिए काफी मान्य है कि issymmetric(::Matrix{String}) ...

Symmetric btw में लिपटे रहने पर यह वर्तमान में पुनरावर्ती नहीं है

julia> A = [rand(2, 2) for i in 1:2, j in 1:2]; A[1, 2] = A[2, 1]; As = Symmetric(A);

julia> issymmetric(A)
false

julia> issymmetric(As)
true

julia> A == As
true

हां, मैं इसके लिए एक पीआर बनाने पर काम कर रहा हूं और इस प्रकार की विसंगतियां बहुत हैं। (सरणी कोड में transpose , adjoint और conj के हर उदाहरण की खोज करते हुए मैं बहुत समय पहले आया था)।

जब तक अन्यथा निर्देशित नहीं किया जाता है तब तक मैं ऐसे व्यवहार को लागू करूंगा जो issymmetric(a) == (a == a.') और ishermitian(a) == (a == a') । ये अपने आप में बहुत सहज लगते हैं और AFAICT issymmetric का मौजूदा उपयोग Number तत्व प्रकारों के लिए है (या अक्सर अन्य गलतियाँ / धारणाएँ होती हैं जो नेस्टेड सरणियों के लिए पूरी तरह से समझ में नहीं आएंगी) ।

(वैकल्पिक कार्यान्वयन issymmetric(a) == (a == conj(adjoint(a))) ... न तो "सुंदर" के रूप में और न ही यह "डेटा" सरणियों ( String , आदि) के लिए काम करेगा, लेकिन यह Number सरणियों पर मेल खाता है

जब तक अन्यथा निर्देशित नहीं किया जाता है तब तक मैं ऐसे व्यवहार को लागू करूंगा जो issymmetric(a) == (a == a.') और ishermitian(a) == (a == a')

मेरे लिए सही समाधान की तरह लगता है।

अद्यतन: मेरे मन को बदल दिया। सममित शायद मुख्य रूप से रैखिक बीजगणित के लिए है

बस एक छोटा सा सुझाव: दो वैक्टर ( dotu ) के उत्पाद पर एक योग करने के लिए अक्सर उपयोगी होता है, और x.’y एक स्केलर लौटाना ऐसा करने का एक सुविधाजनक तरीका है। इसलिए मैं Matrix से transpose(::Vector) वापस नहीं करने के पक्ष में रहूंगा

हां, यह एक RowVector इसलिए आपको एक स्केलर मिलना चाहिए। (ध्यान दें कि पारगमन पुनरावर्ती नहीं होगा)।

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

चूंकि हम पूर्णांक सरणियों का समर्थन करते हैं, इसलिए हम प्रभावी रूप से मॉड्यूल का समर्थन करते हैं, न कि केवल वेक्टर रिक्त स्थान का। बेशक, हम पूर्णांक सरणियों को भी फ़्लोटिंग-पॉइंट सरणियों में एम्बेडेड रूप से व्यवहारिक रूप से देख सकते हैं, इसलिए वे एक वेक्टर स्थान का आंशिक प्रतिनिधित्व करते हैं। लेकिन हम मॉड्यूलर पूर्णांक (उदाहरण के लिए) के एरे भी बना सकते हैं, और एक गैर-प्राइम मापांक के साथ हम एक रिंग के साथ काम करेंगे जो स्वाभाविक रूप से किसी भी क्षेत्र में एम्बेडेड नहीं है। संक्षेप में, हम वास्तव में केवल वेक्टर स्थानों के बजाय सामान्य रूप से मॉड्यूल पर विचार करना चाहते हैं, लेकिन मुझे नहीं लगता कि हमारे उद्देश्यों के लिए कोई महत्वपूर्ण अंतर है (हम आम तौर पर केवल + और * बारे में बात कर रहे हैं।

हां, जूलिया सामान्य मॉड्यूल पर और साथ ही सच्चे वेक्टर रिक्त स्थान पर बीजीय संचालन का समर्थन करता है (और चाहिए)। लेकिन जैसा कि मैं इसे समझता हूं, समुदाय का सामान्य दर्शन यह है कि Base में कार्यों को "सामान्य 'सामान्य रेखीय बीजगणित रूटीन को ध्यान में रखकर तैयार किया जाना चाहिए - इसलिए, उदाहरण के लिए, पूर्णांक-मेट्रिसेस डॉन के लिए

क्रॉसपोस्टिंग https://github.com/JuliaLang/julia/pull/23424#issuecomment -346678279

मैं # 5332 और # 20978 को आगे बढ़ाने के प्रयास की सराहना करता हूं जो इस पुल अनुरोध का प्रतिनिधित्व करता है, और अधिकांश संबद्ध योजना के साथ बोर्ड पर हूं। मैं शब्दावली विकल्पों और डाउनस्ट्रीम प्रभाव के साथ बोर्ड पर भी होना चाहूंगा जो इस पुल अनुरोध को आगे बढ़ाता है, और इसलिए नियमित रूप से खुद को यह समझाने की कोशिश करता है कि उन विकल्पों में उपलब्ध सर्वोत्तम सेट का उत्पादन होता है।

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

समझाने के लिए, mul(A, B) जहां A और B नंगे हों, आस-पास लिपटे, ट्रांसपोज़-रैप या अरेंज-फ्लिप लिपटे Matrix s हों। ट्रांज़ोज़ और एरे-फ्लिप को भ्रमित किए बिना, A Matrix , एक सहायक लिपटे Matrix , या एक ट्रांसपोज़-लिपटे Matrix (और इसी तरह B )। इसलिए mul(A, B) नौ प्रकार के संयोजनों का समर्थन करने की आवश्यकता है। लेकिन पारगमन और सरणी-फ्लिप, A Matrix , एक सहायक-लिपटे Matrix , एक ट्रांज़ोज़-लिपटे Matrix , या एक सरणी- हो सकता है फ्लिप-लिपटे Matrix (और इसी तरह B )। तो अब mul(A, B) सोलह प्रकार के संयोजनों का समर्थन चाहिए।

यह समस्या तर्कों की संख्या के साथ तेजी से बिगड़ती है। उदाहरण के लिए, बिना पुष्टि के mul!(C, A, B) सत्ताईस प्रकार के संयोजनों का समर्थन करने की आवश्यकता है, जबकि भ्रम के साथ mul!(C, A, B) चौंसठ प्रकार के समर्थन की जरूरत है। और निश्चित रूप से मिश्रण को और जटिल बनाने के लिए Vector s और गैर- Matrix मैट्रिक्स / ऑपरेटर प्रकार मिलाते हैं।

इस परिवर्तन के साथ आगे बढ़ने से पहले यह साइड इफेक्ट विचार करने लायक है। श्रेष्ठ!

यह पोस्ट जीथब, स्लैक और ट्राइएज पर हालिया चर्चा को समेकित / समीक्षा करता है, और आगे के संभावित रास्तों का विश्लेषण करता है। (आध्यात्मिक उत्तराधिकारी https://github.com/JuliaLang/julia/issues/20978#issuecomment-315902532 के बारे में सोचकर पैदा हुआ कि 1.0 को कैसे प्राप्त करें।)

तीन अलग-अलग अलग ऑपरेशन जारी हैं:

• सहायक (रैखिक बीजगणितीय, पुनरावर्ती, आदर्श रूप से डिफ़ॉल्ट रूप से आलसी)
• स्थानान्तरण (रैखिक बीजगणितीय, पुनरावर्ती, आदर्श रूप से डिफ़ॉल्ट रूप से आलसी)
• सरणी-फ्लिप (सार-सरणी-आईसी, गैर-पुनरावर्ती, आदर्श रूप से? आलसी? डिफ़ॉल्ट रूप से)

मास्टर पर इन कार्यों की स्थिति

• Adjoint को adjoint / ' (लेकिन ' थलग करने वाले भावों को विशेष रूप से A[c|t]_(mul|rdiv|ldiv)_B[c|t][!] कॉल्स के लिए उतारा जाता है, जो मध्यवर्ती उत्सुक प्रेजेंस / ट्रांज़ोज़ से बचते हैं) ।

• पक्षांतरित कहा जाता है transpose / .' (के रूप में ही चेतावनी के साथ adjoint )।

• सरणी-फ्लिप कहा जाता है permutedims(C, (2, 1)) के लिए दो आयामी C और reshape(C, 1, length(C)) एक आयामी के लिए C ।

प्रासंगिक मुद्दों

1. 5332: A[c|t]_(mul|rdiv|ldiv)_B[c|t] कम करने और विधि नामों के संबद्ध कॉम्बीनेटरियल संग्रह को 1.0 से गायब कर देना चाहिए। उस विशेष कमिंग / संबंधित विधियों को हटाते हुए नामों के लिए आलसी सहायक और स्थानांतरण की आवश्यकता होती है।

2. 13171: Adjoint (née ctranspose ) और पूर्व में सामान्य transpose(x::Any) = x , ctranspose(x::Any) = conj(x) , और conj(x::Any) = x जैसे सामान्य नो-ऑप फ़ॉलबैक के माध्यम से सरणी-फ्लिप के साथ पूर्वसंबंधित थे। इन कमियों ने कुछ उपयोगकर्ता-परिभाषित संख्यात्मक प्रकारों पर [c]transpose ऑपरेशन किए, जो चुपचाप विफल हो जाते हैं (गलत परिणाम लौटाते हैं) उन प्रकारों के लिए [c]transpose विशेषज्ञताओं को अनुपस्थित करते हैं। चुपचाप गलत परिणाम लौटाना बुरी खबर है, इसलिए उन कमियों को हटा दिया गया (# 17075)। अधिक मौन विफलताओं का परिचय नहीं देना महान होगा।

3. 17075, # 17374, # 19205: पूर्ववर्ती कमियों को दूर करके सरणी-फ्लिप को कम सुविधाजनक बनाया गया। और (माफी, मेरी गलती) के साथ मिलकर कम-से-महान महान पदावनत चेतावनियाँ, उस निष्कासन (क्षणिक रूप से) ने शिकायतों का कारण बना दिया। सरणी-फ्लिप के लिए एक अधिक सुविधाजनक झुकाव अच्छा होगा।

4. 21037: 1.0 के लिए अब-भ्रामक .' सिंटैक्स को हटाना प्यारा होगा। इस परिवर्तन को सक्षम करने के लिए उपर्युक्त विशेष लोअरिंग को हटाया जाना चाहिए।

इन मुद्दों को हल करने के लिए डिजाइन उद्देश्य

विशेष निचली और संबद्ध विधि नामों को निकालें, मौन विफलताओं को शुरू करने से बचें, संक्रमण और सरणी फ्लिप के लिए सहज और सुविधाजनक झुकाव प्रदान करें, और .' निकालें। न्यूनतम अतिरिक्त जटिलता और टूटने के साथ पूर्ववर्ती प्राप्त करें।

डिजाइन के प्रस्ताव

इस क्षेत्र को दो डिजाइन प्रस्तावों के लिए तैयार किया गया है:

1. कॉल adjoint adjoint , conjadjoint ("conjugate adjoint"), और सरणी transpose स्थानांतरित करें। adjoint और conjadjoint LinAlg , और transpose Base में जीते हैं।

2. कॉल adjoint adjoint , transpose , और सरणी-फ्लिप flip । adjoint और transpose LinAlg , और flip Base में जीते हैं।

पहले ब्लश पर ये प्रस्ताव केवल सतही रूप से भिन्न प्रतीत होते हैं। लेकिन आगे की परीक्षा से गहरे व्यावहारिक अंतर का पता चलता है। इन नामकरण योजनाओं के सापेक्ष सतही गुणों की चर्चा करते हुए, आइए उन गहन व्यावहारिक अंतरों पर एक नजर डालते हैं।

अंतर, उच्च-स्तरीय दृश्य

1. जटिलता:

   सरणी-फ्लिप transpose कॉल करके एक प्रस्ताव, LinAlg को स्थानांतरित करने और स्थगित करने के अलावा सरणी-फ्लिप को संभालने के लिए मजबूर करता है। नतीजतन, LinAlg को आम संचालन द्वारा समर्थित प्रकार संयोजनों के सेट का पर्याप्त रूप से विस्तार करना चाहिए; https://github.com/JuliaLang/julia/pull/23424#issuecomment -346678279 उदाहरण के माध्यम से इस अतिरिक्त जटिलता का चित्रण करता है, और निम्नलिखित चर्चा स्पष्ट रूप से इस जटिलता के अस्तित्व की पुष्टि करती है।

   प्रस्ताव दो के लिए LinAlg समर्थन केवल स्थानान्तरण और निकटता की आवश्यकता है, जो LinAlg अब करता है।

2. टूटना:

   प्रस्ताव एक मौजूदा परिचालनों के मूल शब्दार्थों में परिवर्तन करता है: transpose -परिवर्तन के बजाय सरणी-फ्लिप हो जाता है, और सभी transpose -संबंधित कार्यक्षमता को तदनुसार बदलना होगा। (उदाहरण के लिए, सभी गुणन और बाईं / सही-डिवीजन में परिचालन LinAlg नाम के साथ संबद्ध transpose अर्थ संशोधन की आवश्यकता होगी।) यह परिवर्तन महसूस किया है के आधार पर, इस परिवर्तन चुप टूटना का कारण बनता है जहाँ भी वर्तमान शब्दार्थ पर (उद्देश्यपूर्ण या अनजाने में) भरोसा किया जाता है।

   प्रस्ताव दो सभी मौजूदा परिचालनों के मूल शब्दार्थ को बनाए रखता है।

3. युग्मन:

   प्रस्ताव एक एक रेखीय बीजीय अवधारणा (पक्षांतरित) में लाता है Base में, और एक सार-सरणी अवधारणा (सरणी-फ्लिप) LinAlg , दृढ़ता से युग्मन Base और LinAlg ।

   प्रस्ताव दो स्पष्ट रूप से सार सार और रैखिक बीजगणित चीजों को अलग करता है, जिससे पूर्व को केवल आधार में और बाद में केवल LinAlg में रहने की अनुमति मिलती है, जिसमें कोई नया युग्मन नहीं है।

4. मौन बनाम जोर से विफलता:

   एक प्रस्ताव चुपचाप गलत परिणाम की ओर जाता है जब कोई transpose उम्मीद करता है, ट्रांसपोटेंट शब्दार्थ (लेकिन इसके बजाय सरणी-फ्लिप शब्दार्थ प्राप्त करता है)।

   प्रस्ताव दो के तहत एनालॉग एक गैर-संख्यात्मक सरणी पर transpose कॉल कर रहा है, जो सरणी-फ्लिप शब्दार्थों की अपेक्षा कर रहा है। इस मामले में, transpose उपयोगकर्ता को flip ओर इंगित करने में मदद करने वाली त्रुटि फेंक सकते हैं।

5. .' : .' न निकालने का प्राथमिक तर्क transpose की लंबाई है। प्रस्ताव एक ने .' को transpose और conjadjoint , जो उस स्थिति में सुधार नहीं करता है। इसके विपरीत, प्रस्ताव दो उस स्थिति में सुधार करते हुए नाम flip और transpose करता है।

1.0 के रास्तों में अंतर

प्रत्येक प्रस्ताव के तहत 1.0 प्राप्त करने के लिए क्या मिलता है? 1.0 का रास्ता प्रस्ताव दो के तहत सरल है, तो चलो वहाँ शुरू करते हैं।

प्रस्ताव दो के तहत 1.0 पथ

1. LinAlg में आलसी निकटता और आवरण प्रकारों को प्रस्तुत करें, Adjoint और Transpose कहें। उन रैपर प्रकारों पर प्रेषण और संबंधित A[c|t]_{mul|ldiv|rdiv}_B[c|t][!] विधियों के कोड वाले mul[!] / ldiv[!] / rdiv[!] परिचय करें। पूर्व विधियों के छोटे बच्चों के रूप में बाद के तरीकों को फिर से लागू करें।

   यह कदम कुछ भी नहीं तोड़ता है, और तुरंत .' के विशेष लोअरिंग और डेप्रिसिएशन को हटाने में सक्षम बनाता है:

2. A[c|t]_{mul|ldiv|rdiv}_B[c|t] पैदावार करने वाली विशेष कमियों को निकालें, इसके बजाय केवल ' / .' Adjoint / Transpose ; पूर्व में विशेष रूप से नीची अभिव्यक्तियाँ A[c|t]_{mul|ldiv|rdiv}_B[c|t] कॉल उत्पन्न करती हैं, इसके बजाय mul / ldiv / rdiv कॉल्स बनें। A[c|t]_{mul|ldiv|rdiv}_B[c|t][!] से mul[!] / ldiv[!] / rdiv[!] विधियाँ। .' घटाएँ।

   ये कदम 0.7 में किया जा सकता है। (1) कोड विशेष हिट करने के लिए कम करने पर भरोसा: वे दो बातें केवल टूट जाता है A[c|t]_{mul|ldiv|rdiv}_B[c|t] गैर के लिए तरीके Base / LinAlg प्रकार टूट जाएगा। इस तरह के कोड से स्पष्ट रूप से MethodError s का संकेत होगा कि नई कम पैदावार क्या है / टूटे हुए कोड की क्या आवश्यकता है। (2) अलग-थलग ' s / .' s पर निर्भर कोड सख्ती से बर्ताव करने से टूट जाएगा। सामान्य विफलता मोड स्पष्ट MethodError s होना चाहिए। चारों ओर, टूटना सीमित है और जोर से।

   और यह 1.0 के लिए कड़ाई से आवश्यक परिवर्तनों के लिए है।

   इस बिंदु पर, Adjoint(A) / Transpose(A) आलसी अधिनिर्णय और हस्तांतरण होगा, और adjoint(A) / transpose(A) उत्सुक आसन्न और पारगमन होगा। बाद के नाम अनिश्चित काल तक रह सकते हैं या, यदि वांछित हो, तो 0.7 में कुछ अन्य वर्तनी के लिए पदावनत किया जा सकता है, उदाहरण के लिए eagereval(Adjoint(A)) / eagereval(Transpose(A)) eagereval eageradjoint(A) / eagertranspose(A) । वंचन मामले में, adjoint / transpose फिर 1.0 में पुनर्खरीद किया जा सकता है (हालांकि Adjoint(A) / Transpose(A) आसपास, मुझे यकीन नहीं है कि ऐसा होगा) ज़रूरी)।

   आखिरकार...

3. flip और / या Flip Base परिचय दें। एक सुविधा जोड़ होने के नाते, यदि आवश्यक हो तो यह परिवर्तन 1.x में हो सकता है।

एक प्रस्ताव के तहत 1.0 पथ

प्रस्ताव एक के बारे में क्या? नीचे दो संभावित रास्तों की रूपरेखा दी गई है। पहला पथ 0.7 में परिवर्तनों को समेकित करता है लेकिन इसमें मौन विच्छेद शामिल है। दूसरा रास्ता मूक टूटने से बचा जाता है, लेकिन इसमें अधिक परिवर्तन शामिल है 0.7-> 1.0। दोनों रूपरेखाएँ लगातार कोडबेस को विकसित करती हैं; कम निरंतर समकक्ष कुछ कार्य / मंथन को समेकित / टाल सकते हैं, लेकिन संभावना अधिक चुनौतीपूर्ण और त्रुटि प्रवण होगी। पहले से चल रहे काम पहले मार्ग का अनुसरण करते हैं।

प्रस्ताव एक के तहत पहला रास्ता (मूक टूटने के साथ)

1. transpose के शब्दार्थ को सरणी-फ़्लिप से स्थानांतरित करें, और आवश्यक रूप से सभी transpose -संबंधित कार्यक्षमता के शब्दार्थ भी। उदाहरण के लिए, सभी A[c|t]_{mul|ldiv|rdiv}_B[c|t][!] विधियों की शुरुआत At_... या ..._Bt[!] ख़त्म होने से संभावित संशोधन की आवश्यकता है। Symmetric / issymmetric की परिभाषाएँ और व्यवहार भी बदलना चाहिए। transpose को Base ।

   ये बदलाव चुपचाप और मोटे तौर पर टूटेंगे।

2. conjadjoint LinAlg परिचय दें। इस चरण को पूर्ववर्ती चरण में छुआ सभी तरीकों को पुनर्स्थापित करने की आवश्यकता है, लेकिन उनके मूल शब्दार्थ रूप में, और अब conjadjoint ( Aca_... और ..._Bca[!] नाम के साथ जुड़े विभिन्न नामों के साथ) । अतिरिक्त प्रकार के संयोजनों के लिए तरीकों को जोड़ने की आवश्यकता है जो एक साथ सरणी-फ्लिप (अब transpose ) का समर्थन करते हैं, स्थानांतरित करते हैं (अब conjadjoint ), और LinAlg में आसन्न हैं (उदाहरण के लिए) ca A[c|t|ca]_{mul|ldiv|rdiv}_B[c|t|ca][!] के बीच

3. आलसी adjoint और पक्षांतरित (बुलाया परिचय conjadjoint में) LinAlg , का कहना है कि Adjoint और ConjAdjoint । एक आलसी सरणी-फ्लिप (बुलाया परिचय transpose में) प्रकार आवरण Base , का कहना है कि Transpose । उन रैपर प्रकारों पर प्रेषण और इसी A[c|t|ca]_{mul|ldiv|rdiv}_B[c|t|ca][!] विधियों के कोड वाले mul[!] / ldiv[!] / rdiv[!] तरीकों का परिचय दें। पूर्व विधियों के छोटे बच्चों के रूप में बाद के तरीकों को फिर से लागू करें।

4. A[c|t]_{mul|ldiv|rdiv}_B[c|t] पैदावार करने वाली विशेष कमियों को निकालें, इसके बजाय केवल ' / .' Adjoint / Transpose ; पूर्व-विशेष-विशेष रूप से कम किए गए भाव A[c|t]_{mul|ldiv|rdiv}_B[c|t] कॉल उत्पन्न करते हैं, इसके बजाय mul / ldiv / rdiv कॉल हो जाते हैं (हालांकि याद रखें कि शब्दार्थ चुपचाप बदल जाएगा)। A[c|t]_{mul|ldiv|rdiv}_B[c|t][!] लेकर mul[!] / ldiv[!] / rdiv[!] तरीके। इसी तरह हाल ही में शुरू किए गए Aca_... / ...Bca[!] तरीकों को mul[!] / ldiv[!] / rdiv[!] समकक्षों के पक्ष में हटा दें। .' डिप्रेक्ट करें।

इन परिवर्तनों को 0.7 में जाने की आवश्यकता होगी। मौजूदा परिचालनों के शब्दार्थ परिवर्तन से व्यापक, मूक टूटन होगी। विशेष कम हटाने से ऊपर वर्णित एक ही सीमित, ज़ोर से टूटना होगा।

इस बिंदु पर Adjoint(A) / Transpose(A) / ConjAdjoint(A) क्रमशः आलसी adjoint, सरणी-फ्लिप, और हस्तांतरण, और adjoint(A) / transpose(A) मिलेगा। / conjadjoint(A) क्रमशः उत्सुकता, सरणी-फ्लिप और संक्रमण का उत्पादन करेंगे। उत्तरार्द्ध नाम अनिश्चित काल तक रह सकते हैं या, यदि वांछित हो, तो कुछ अन्य वर्तनी को भी 0.7 (रेफरी। ऊपर) में पदावनत किया जा सकता है।

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

प्रस्ताव एक के तहत दूसरा रास्ता (मौन टूटने से बचना)

1. उत्सुक परिचय conjadjoint में LinAlg । वर्तमान में transpose (उदाहरण के लिए A[c|t]_{mul|ldiv|rdiv}_B[c|t][!] t ) conjadjoint और व्युत्पन्न नामों से युक्त विधियों के साथ सभी कार्यक्षमता और विधियों को माइग्रेट करें। नए conjadjoint समकक्षों के सभी transpose -संबंधित नाम छोटे बच्चों को बनाओ। transpose conjadjoint समकक्षों के लिए सभी transpose -नियंत्रित नाम लिखें।

2. आलसी adjoint और पक्षांतरित (बुलाया परिचय conjadjoint में प्रकार आवरण) LinAlg , का कहना है कि Adjoint और ConjAdjoint । उन रैपर प्रकारों पर प्रेषण और इसी A[c|ca]_{mul|ldiv|rdiv}_B[c|ca][!] विधियों के कोड वाले mul[!] / ldiv[!] / rdiv[!] तरीकों का परिचय दें। पूर्व विधियों के छोटे बच्चों के रूप में बाद के तरीकों को फिर से लागू करें।

3. Base में एक आलसी सरणी-फ्लिप आवरण प्रकार का परिचय दें, जिसे Transpose (कुछ भ्रमित करने वाला कहा जाता है, साथ ही transpose को conjadjoint ट्रांसजेंड शब्दार्थ के साथ घटाया जाता है)। सरणी-फ्लिप ( Transpose ) के लिए आवश्यक सभी सामान्य तरीकों को Base कार्य करने के लिए जोड़ें। फिर सभी अतिरिक्त प्रकार के संयोजनों के लिए LinAlg विधियाँ जोड़ें जो एक साथ सरणी-फ्लिप (अब Transpose , लेकिन transpose ) को हस्तांतरित नहीं करते हैं (अब conjadjoint और ConjAdjoint ), और में adjoint LinAlg की आवश्यकता है (उदाहरण के लिए mul[!] / rdiv[!] / ldiv[!] समकक्षों की A[c|t|ca]_{mul|ldiv|rdiv}_B[c|t|ca][!] वह वर्तमान में मौजूद नहीं है)।

4. A[c|t]_{mul|ldiv|rdiv}_B[c|t] पैदावार करने वाली विशेष कमियों को निकालें, इसके बजाय केवल ' / .' Adjoint / Transpose ; पूर्व में विशेष रूप से नीची अभिव्यक्तियाँ A[c|t]_{mul|ldiv|rdiv}_B[c|t] कॉल उपजती हैं, इसके बजाय mul / ldiv / rdiv कॉल्स बनें। A[c|t]_{mul|ldiv|rdiv}_B[c|t][!] लेकर mul[!] / ldiv[!] / rdiv[!] विधियाँ हैं। .' डिप्रेक्ट करें।

पूर्ववर्ती परिवर्तनों को 0.7 में जाने की आवश्यकता होगी। कोई मूक टूटना नहीं, केवल ऊपर वर्णित के रूप में विशेष कम हटाने से जोर से टूटना।

इस बिंदु पर Adjoint(A) / Transpose(A) / ConjAdjoint(A) क्रमशः आलसी सहायक, सरणी-फ्लिप, और स्थानांतरित करेंगे। adjoint(A) / conjadjoint(A) क्रमशः उत्सुकता और संक्रमण का उत्पादन करेंगे। transpose(A) conjadjoint घटाया जाएगा; transpose 1.0 में पुनर्खरीद किया जा सकता है अगर वांछित। adjoint अनिश्चित काल तक बने रह सकते हैं या 0.7 में एक और वर्तनी के पक्ष में पदावनत हो सकते हैं। conjadjoint एक और तरीका सीधे 0.7 में जा सकता है।

कुछ कार्य / मंथन से बचते हुए, 1 और 2 को कुछ हद तक समेकित किया जा सकता है, हालांकि संभावना है कि दृष्टिकोण अधिक चुनौतीपूर्ण और त्रुटि प्रवण होगा।

#

पढ़ने के लिए धन्यवाद!

महान समीक्षा के लिए धन्यवाद। मैं आम तौर पर प्रस्ताव 2 से भी सहमत हूं, अतिरिक्त कारण के साथ कि संयुग्मन समीपवर्ती सभी मानक शब्दावली में नहीं है और मुझे व्यक्तिगत रूप से यह बहुत भ्रामक लगता है (क्योंकि आसन्न का उपयोग कभी-कभी गणित की कुछ शाखाओं में सादे पारगमन के लिए शब्दावली के रूप में किया जाता है, और अतिरिक्त विशेषण संयुग्म है लगता है कि संयुग्मन होता है)।

मैंने ऊपर विस्तृत चर्चाओं को पढ़ने की कोशिश की, लेकिन यह देखने में विफल रहा कि यह किस बिंदु पर तय किया गया था / प्रेरित था कि गणितीय transpose पुनरावर्ती होना चाहिए। यह कुछ निजी चर्चा (कहीं 14 से 18 जुलाई के बीच) का पालन करने के लिए लग रहा था, जिसके बाद अचानक एक गणितीय और संरचनात्मक बदलाव पेश किया गया था।
@ Sacha0 इसका वर्णन करता है

यह कैसे पैदा हुआ: पहले "संरचनात्मक संक्रमण" को "गणितीय समायोजन" / "गणितीय संक्रमण" के साथ कबूल किया गया था

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

उस के संबंध में, मुझे लगता है कि कोई भी वास्तव में सार गणितीय अर्थों में transpose का उपयोग नहीं कर रहा है, रैखिक नक्शे पर एक RowVector s पर, अर्थात यह RowVector से RowVector मैप करेगा। पुनरावर्ती हस्तांतरण के लिए कमी के तर्क को देखते हुए, मुझे वास्तव में सादे मैट्रिक्स के बीच कोई अंतर नहीं दिखता है जो आमतौर पर एक (आधार पर निर्भर) अवधारणा के रूप में परिभाषित किया गया है, और नए प्रस्तावित flip संचालन।

धन्यवाद @ Sacha0 महान लिखने के लिए। मैं प्रस्ताव 2 का पक्ष लेता हूं (कॉल adjoint , transpose , और सरणी-फ्लिप flip । adjoint और transpose लाइव का समर्थन करता LinAlg , और flip Base ।)। मेरे लिए यह सबसे अच्छा अंतिम परिणाम (जो प्राथमिक चिंता का विषय होना चाहिए) देने के लिए लगता है, और v1.0 के लिए वहां एक क्लीनर तरीके की अनुमति भी देता है। मैं आपकी बातों से ऊपर सहमत हूं इसलिए मैं उन बातों को नहीं दोहराऊंगा, लेकिन यहां कुछ अतिरिक्त टिप्पणियां हैं।

गैर-पुनरावर्ती transpose पक्ष में एक तर्क यह है कि .' -syntax बहुत सुविधाजनक है, और इस प्रकार उदा Matrix{String} लिए उपयोग किया जा सकता है। कि वाक्य रचना मानते हुए (# 21037) दूर जा रहा है और एक का उपयोग करने के लिए है transpose(A) के बजाय A.' , तो मुझे लगता है कि एक flip समारोह एक स्वागत योग्य इसके अलावा हो सकता है (कम और transpose(A) तुलना में स्पष्ट है, और निश्चित रूप से permutedims(A, (2,1)) तुलना में अच्छा है)।

LinAlg और Base बीच का डिकूपिंग जो प्रस्ताव 2 देता है वह भी बहुत अच्छा है। न केवल LinAlg केवल Transpose और Adjoint को संभालने के तरीके के बारे में देखभाल करने की आवश्यकता है, बल्कि यह भी कि यह स्पष्ट करता है कि हम transpose और adjoint LinAlg ऑपरेशन, और flip एक सामान्य AbstractMatrix चीज जो सिर्फ एक मैट्रिक्स के आयामों को झटकती है।

अंत में, मैंने transpose(::Matrix{String}) आदि के बारे में बहुत सारी शिकायतें नहीं देखी हैं जो काम नहीं कर रही हैं। क्या यह वास्तव में एक सामान्य उपयोग का मामला है? ज्यादातर मामलों में वैसे भी शुरू से फ़्लिप किए गए मैट्रिक्स का निर्माण करना बेहतर होना चाहिए।

यह नामकरण योजना (प्रस्ताव 2) वास्तव में बेहतर हो सकती है। अनुगामी और पारगमन रैखिक बीजगणित में बहुत मानक शब्द हैं, और यह कम टूट रहा है ...

लेकिन यह देखने में असफल रहा कि किस बिंदु पर यह तय किया गया था / प्रेरित किया गया था कि एक गणितीय परिवर्तन पुनरावर्ती होना चाहिए

@ जूथो यह एक ही तर्क है कि सन्निकट है, यह संयुग्मित है (क्योंकि जटिल संख्याएँ वैध रैंक-एक वेक्टर रिक्त स्थान और रैखिक परिचालक हैं, आंतरिक उत्पाद और निकटवर्ती अवधारणाएँ लागू होती हैं), और एक ब्लॉक मैट्रिक्स का सन्निकटन पुनरावर्ती है ...)। लोग उदाहरण के लिए, नेस्टेड, वास्तविक मैट्रिस के साथ रैखिक बीजगणित करना चाह सकते हैं। मुझे अभी भी "वास्तविक मैट्रिक्स या सदिश के निकट" के लिए .' का उपयोग करते हुए बहुत सारे कोड दिखाई देते हैं, और मैं भी ऐसा करता था। यहां, ' न केवल मान्य होगा, बल्कि अधिक सामान्य भी होगा (सरणियों के लिए काम करना जो जटिल मूल्यवान और / या नेस्टेड हो सकता है)। नेस्टेड कॉम्प्लेक्स मैट्रिस पर पुनरावर्ती संक्रमण का अधिक वास्तविक उपयोग तब होता है जब आपके समीकरण आपको conj(adjoint(a)) , जो अपेक्षाकृत दुर्लभ होता है, लेकिन फिर भी ऐसा होता है (यह दुर्लभ है कि मैं खुश हूँ अगर इसके साथ कोई फ़ंक्शन जुड़ा नहीं है - ऊपर और अन्य जगहों पर चर्चा करते हुए विभिन्न लोगों ने इसे "गणितीय स्थानान्तरण" जैसे विभिन्न चीजों के रूप में कॉल करना शुरू कर दिया, मैंने conjadoint चुना, लेकिन इसमें से कोई भी महान शब्दावली IMO नहीं है, सिवाय शायद transpose स्वयं)। रेखीय बीजगणित में गैर-पुनरावर्ती ऑपरेशन जो एक ब्लॉक मैट्रिक्स के ब्लॉकों को फिर से व्यवस्थित करता है लेकिन उन ब्लॉकों के लिए कुछ भी नहीं करता है जो आमतौर पर स्वयं दिखाई देते हैं।

अंत में, मैंने transpose(::Matrix{String}) आदि के बारे में बहुत सारी शिकायतें नहीं देखी हैं। क्या यह वास्तव में एक सामान्य उपयोग का मामला है? ज्यादातर मामलों में वैसे भी शुरू से फ़्लिप किए गए मैट्रिक्स का निर्माण करना बेहतर होना चाहिए।

मुझे लगता है कि जूलिया के प्रसारण कार्यों के साथ इस तरह की बात काफी वांछनीय है। उदाहरण के लिए, कुछ डेटा के बाहरी (कार्टेशियन) उत्पाद लेना चाहते हैं और शायद इसे एक फ़ंक्शन के माध्यम से मैप करना बहुत आम है। इसलिए map(f, product(a, b)) जैसी किसी चीज़ के बजाय हम broadcast(f, a, transpose(b)) या केवल f.(a, b.') उपयोग कर सकते हैं। यह कुछ पात्रों में बहुत शक्ति है।

मेरे विचार: इस स्थान पर और भी अधिक फ़ंक्शन नाम जोड़ने से बचने के लिए (अर्थात flip ), मैं सोच रहा हूं कि क्या हम permutedims(a) = permutedims(a, (2,1)) में क्रमचय के लिए डिफ़ॉल्ट मान रख सकते हैं। दुर्भाग्य से यह flip जितना कम नहीं है, लेकिन पूर्ण permutedims(a, (2,1)) फॉर्म की तुलना में काफी कम अप्रिय है (और अधिक सामान्य फ़ंक्शन के बारे में उपयोगकर्ताओं को सिखाने का दुष्प्रभाव है)।

( @ Sacha0 यहाँ आपके Adjoint और Transpose रैपर, या RowVector + MappedArray जो भी फ़्लिप करें) के बीच चुनाव में। पहले की योजना के अनुसार मैट्रिस (शायद सिर्फ PermutedDimsArray ), मैं अभी भी बाद का पक्ष लेता हूं ...)

नेस्टेड जटिल मैट्रिस पर पुनरावर्ती संक्रमण का अधिक वास्तविक उपयोग तब होता है जब आपके समीकरण आपको conj(adjoint(a))

एक बार जब आप अपने समीकरणों में conj(adjoint(a)) प्राप्त करते हैं, तो आप कैसे जानते हैं कि इसका वास्तव में conj जो आप अपनी मैट्रिक्स प्रविष्टियों पर लागू करना चाहते थे और शायद adjoint , यानी शायद आप वास्तव में चाहते हैं adjoint.(adjoint(a)) ।

यह शायद मुझे प्रतिबंधित / निष्कासित कर देगा, लेकिन मैं पूरे पुनरावर्ती विचार का बड़ा प्रशंसक नहीं हूं। मैं आवश्यक रूप से इसका विरोध नहीं कर रहा हूँ, मुझे नहीं लगता कि इसके लिए एक गणितीय रूप से कठोर कारण है, क्योंकि वैक्टर और ऑपरेटर / मैट्रिसेस को पुनरावृत्ति रूप से परिभाषित नहीं किया जाता है, वे स्केलर के क्षेत्रों में परिभाषित किए जाते हैं (और यदि आप चाहते हैं कि विस्तार के छल्ले द्वारा) वेक्टर वेक्टर के बजाय मॉड्यूल के साथ काम करने के लिए)। और इसलिए Base.LinAlg को केवल उस मामले में काम करना चाहिए। मुख्य तर्क

एक वेक्टर के आस-पास एक रैखिक ऑपरेटर होना चाहिए जो इसे स्केलर पर मैप कर रहा है। यदि एक वेक्टर है तो 'a' * अदिश होना चाहिए।

कैसे जूलिया बेस काम करता है के साथ असंगत है: सुनिश्चित a=[rand(2,2),rand(2,2)] और निरीक्षण a'*a । यह अदिश राशि नहीं है। तो क्या अब a एक मैट्रिक्स है, क्योंकि यह वेक्टर से भरा वेक्टर है? उपरोक्त केवल एक स्केलर है यदि वास्तव में आप 2x2 मैट्रीस की रिंग को स्केलर के रूप में उपयोग करना चाहते हैं जिस पर आपने एक मॉड्यूल परिभाषित किया है। लेकिन उन संदर्भों में, मेरे लिए यह स्पष्ट नहीं है कि उपरोक्त परिणाम अभीष्ट है। यूक्लिडियन इनर उत्पाद वैसे भी शायद ही कभी मॉड्यूल आदि के संदर्भ में उपयोग किया जाता है, इसलिए मुझे नहीं लगता कि बेस को इसके लिए सही व्यवहार को परिभाषित करने के लिए भी परेशान होना चाहिए।

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

तो क्यों, जूलिया में इस तरह के एक शक्तिशाली प्रकार की प्रणाली के साथ, न केवल ब्लॉक मैट्रिसेस के लिए एक समर्पित प्रकार है। और इस प्रकार, शैतान के वकील की भूमिका:

• कितने लोग वास्तव में किसी भी व्यावहारिक कार्य के लिए निकटवर्ती के वर्तमान पुनरावर्ती व्यवहार का उपयोग / भरोसा कर रहे हैं?
• क्या इस तरह के पुनरावर्ती दृष्टिकोण का उपयोग करने वाली अन्य भाषाएं हैं? (Matlab, matrices की कोशिकाओं का उपयोग करते हुए, नहीं करता है)

जैसा कि कहा गया है, मैं जरूरी विरोध नहीं कर रहा हूं, बस वैधता पर सवाल उठा रहा हूं (उपरोक्त सभी चर्चाओं को पढ़ने के बाद भी), विशेष रूप से transpose मामले के लिए।

यह शायद मुझे प्रतिबंधित / निष्कासित कर देगा

मुझे लगता है कि यह एक मजाक है, लेकिन एक अलोकप्रिय राय होने से किसी को भी प्रतिबंधित नहीं किया जाएगा। केवल बुरा व्यवहार जो लंबे समय तक चलता है, वह प्रतिबंध का कारण बन सकता है। उसके बाद भी प्रतिबंध स्थायी नहीं है ।

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

इस कथन से मुझे कोई मतलब नहीं है। वैक्टर का एक वेक्टर, या फ़ंक्शंस का एक वेक्टर, या मेट्रिक्स का एक वेक्टर, फिर भी + और * scalar साथ एक सदिश स्थान बनाता है (पुनर्संरचित रूप से परिभाषित), और इसी तरह के रूप आंतरिक उत्पाद के साथ एक आंतरिक उत्पाद स्थान पुनरावर्ती रूप से परिभाषित किया गया है। यह विचार कि वैक्टर केवल "स्केलर के कॉलम" हो सकते हैं, गणित, भौतिकी और इंजीनियरिंग में परिभाषाओं और सामान्य उपयोग दोनों को परिभाषित करते हैं।

बनाओ a=[rand(2,2),rand(2,2)] और निरीक्षण a'*a । यह अदिश राशि नहीं है।

इस मामले में a की "स्केलर रिंग" 2x2 मैट्रीस की अंगूठी है। तो यह एक भाषाई समस्या है, न कि जिस तरह से काम करता है उसके साथ एक समस्या है।

कैसे के बारे में बहस a'*a यह वर्तमान में कैसे काम करता है (या काम नहीं करता है) जूलिया में से काम करना चाहिए बल्कि परिपत्र लगता है।

यदि आप एक नया स्केलर फ़ील्ड अपने आप को परिभाषित करते हैं, तो यह सिर्फ एक अजीब बोझ है जिसे आपको adjoint और transpose conj अतिरिक्त परिभाषित करने की आवश्यकता है, इससे पहले कि आप इसका उपयोग कर सकें एक मैट्रिक्स में

मुझे लगता है कि यह बोझ व्यावहारिक से अधिक सौंदर्यवादी है। यदि आप इसे Number का उपप्रकार बनाने के साथ ठीक हैं, तो आपको कुछ भी परिभाषित करने की आवश्यकता नहीं है और भले ही आप मानते हों कि Number आपके लिए सही बात नहीं है, परिभाषाएँ इतनी तुच्छ हैं कि उन्हें जोड़ना शायद ही बोझ हो।

तो क्यों, जूलिया में इस तरह के एक शक्तिशाली प्रकार की प्रणाली के साथ, न केवल ब्लॉक मैट्रिसेस के लिए एक समर्पित प्रकार है।

https://github.com/KristofferC/BlockArrays.jl/ योगदानकर्ताओं का स्वागत :)

"प्रतिबंध" मजाक के लिए मेरी माफी। यह मेरी अंतिम प्रतिक्रिया होगी ताकि इस चर्चा को आगे न बढ़ाया जा सके। यह स्पष्ट है कि पुनरावर्ती निकटता (लेकिन शायद स्थानांतरण नहीं) बस गया है, और मैं उस निर्णय को पूर्ववत करने की कोशिश नहीं कर रहा हूं। मैं सिर्फ कुछ विसंगतियों को इंगित करने का प्रयास कर रहा हूं।

@StefanKarpinski : स्केलर रिंग का उदाहरण पुनरावृत्ति के साथ विरोधाभास में है: क्या 2x2 स्वयं स्केलर हैं, या परिभाषा पुनरावर्ती है और अंतर्निहित Number स्केलर है?

पूर्व मामले में, आपके पास वास्तव में एक वेक्टर स्थान के बजाय एक मॉड्यूल है और यह संभवतः उपयोग के मामले पर निर्भर करता है कि क्या आप उन 'स्केलर' पर conj या adjoint चाहते हैं, यदि आप भी होंगे आंतरिक उत्पादों और विशेषणों का उपयोग करना।

मैं बाद की परिभाषा को स्वीकार करने के साथ ठीक हूं। मैं अपनी नौकरी में सुपर वेक्टर रिक्त स्थान के श्रेणीबद्ध टैंसर उत्पादों के समूह-अपरिवर्तनीय उप-स्थानों में मनमाने तत्वों का उपयोग कर रहा हूं, इसलिए मैं वास्तव में वैक्टर की मेरी संख्या के कॉलम तक ही सीमित नहीं हूं। लेकिन मैट्रिस के वैक्टर, क्या वे सिर्फ शुद्ध वैक्टर हैं या क्या उन्हें कुछ मैट्रिक्स व्यवहार भी विरासत में मिला है। पूर्व मामले में, dot(v,w) को अपने तत्वों पर संभवतः vecdot कॉल करके, एक स्केलर का उत्पादन करना चाहिए। बाद के मामले में, कम से कम vecdot(v,w) को पुनरावर्ती अभिनय करके एक स्केलर का उत्पादन करना चाहिए। ताकि पुनरावर्ती सहायक के अनुरूप होना एक न्यूनतम तय हो।

लेकिन यह आसान नहीं लगता है कि एक पुनरावर्ती transpose और बस इसे गैर-गणित अनुप्रयोगों के लिए भी उपयोग करने की अनुमति है, क्योंकि मुझे लगता है कि यहां तक ​​कि विशिष्ट मैट्रिक्स समीकरणों में भी वास्तविक गणितीय संक्रमण के साथ ऐसा करने के लिए बहुत कम है। एक रेखीय मानचित्र के।

मुझे लगता है कि dot को dot फिर से कॉल करना चाहिए, न कि vecdot , इसलिए मैट्रिस के वेक्टर के लिए यह त्रुटि होगी क्योंकि हम मैट्रिस के लिए एक कैनोनिकल इनर उत्पाद को परिभाषित नहीं करते हैं।

मुझे हमेशा आश्चर्य होता है कि संक्रमण पुनरावर्ती है .. और मैं सोच भी नहीं सकता कि कोई भी नहीं है। (मैं अनुमान लगा रहा हूं कि विकिपीडिया लेख के "एक रेखीय नक्शे के हस्तांतरण" पर विचार इस चर्चा के कारण कम से कम तीन गुना है।)

मैंने भी अक्सर पुनरावर्ती परिभाषाओं को अनिश्चित पाया है, और आम तौर पर

मुझे लगता है कि मैंने उस असंगति का पता लगा लिया है जो मुझे यहां परेशान कर रही है - हम रिंग और फ़ील्ड का उपयोग करते रहते हैं जैसे कि 2x2 मैट्रिक्स जटिल संख्या के एक उदाहरण के रूप में एम्बेड करना यहाँ है, लेकिन यह वास्तव में बाहर काम नहीं करता है और न ही पुनरावर्ती संक्रमण (और निकटता) को प्रेरित करता है )।

मुझे समझाने दो। जिन चीजों से मैं मोटे तौर पर सहमत हूं

1. स्केलर वैध रैंक -1 रैखिक ऑपरेटर हैं। जूलिया के शक्तिशाली टाइप सिस्टम को देखते हुए LinAlg अवधारणाओं जैसे adjoint लागू नहीं होने का कोई कारण नहीं है, उदाहरण के लिए हमें adjoint(z::Complex) = conj(z) को परिभाषित करना चाहिए। (वैक्टर के परे और स्केटर के मैट्रीस , LinAlg अवधारणाओं को भी अन्य वस्तुओं तक बढ़ाया जा सकता है (उपयोगकर्ताओं द्वारा, मुझे लगता है) अन्य वस्तुओं के लिए - @stevengj जैसे कि अनंत आकार के वेक्टर रिक्त स्थान (हिल्बर्ट स्थान) का उल्लेख किया गया है।
2. हमें अलग-अलग अभ्यावेदन के साथ किसी न किसी तरह से निपटने में सक्षम होना चाहिए। यहां प्रोटोटाइपिक उदाहरण एक जटिल संख्या z = x + y*im Z = x*[1 0; 0 1] + y*[0 1; -1 0] और संचालन + , - , * , / और \ इस समरूपता में संरक्षित हैं। (ध्यान दें कि conj(z) adjoint(Z) / transpose(Z) / flip(Z) - अधिक है कि बाद में)।
3. ब्लॉक मैट्रिसेस किसी भी तरह से संभव होना चाहिए (वर्तमान दृष्टिकोण पुनरावर्ती adjoint डिफ़ॉल्ट रूप से निर्भर करता है, आदि)।

यह उचित लगता है कि Base.LinAlg 1 और 2 के साथ संगत हो, लेकिन IMO 3 केवल Base में किया जाना चाहिए, अगर यह स्वाभाविक रूप से फिट बैठता है (अन्यथा मैं https: / जैसे बाहरी पैकेजों को टाल सकता हूं) /github.com/KristofferC/BlockArrays.jl)।

मुझे अब एहसास हुआ कि हम 2 और 3 का सामना कर रहे हैं और यह कुछ विसंगतियों की ओर जाता है ( @ जूथो ने इसे भी इंगित किया)। नीचे, मैं यह दिखाना चाहता हूं कि 3. ब्लॉक मैट्रीक के अनुसार पुनरावर्ती adjoint और अन्य संचालन का उपयोग हमें नहीं देता है। सबसे आसान तरीका उदाहरण के द्वारा है। आइए जटिल संख्याओं के 2x2 मैट्रिक्स को m = [z1 z2; z3 z4] रूप में परिभाषित करें, आइसोमोर्फिक प्रतिनिधित्व M = [Z1 Z2; Z3 Z4] , और एक मानक 2x2 ब्लॉक मैट्रिक्स b = [m1 m2; m3 m4] जहां m1 आदि समान रूप से आकार वर्ग है। Number मैट्रिसेस। आम कार्यों के लिए शब्दार्थिक उत्तर नीचे सूचीबद्ध हैं:

| ऑपरेशन | z | Z | m | M | b |
| - | - | - | - | - | - |
| + , - , * | पुनरावर्ती | पुनरावर्ती | पुनरावर्ती | पुनरावर्ती | पुनरावर्ती |
| conj | conj(z) | Z' या Z.' या flip(Z) | conj.(m) | adjoint.(M) (या transpose.(M) ) | conj.(b) |
| adjoint | conj(z) | Z' या Z.' या flip(Z) | flip(conj.(m)) या पुनरावर्ती | flip(transpose.(m)) या पुनरावर्ती | पुनरावर्ती |
| trace | z | Z | z1 + z4 | Z1 + Z4 | trace(m1) + trace(m4) |
| det | z | Z | z1*z4 - z2*z3 | Z1*Z3 - Z2*Z3 | det(m1) * det(m4 - m2*inv(m1)*m3) (यदि m1 उल्टा, उदाहरण के लिए देखें विकिपीडिया ) |

trace और det जो वापसी के स्केलर की तरह संचालन को ध्यान में रखते हुए, मुझे लगता है कि यह बहुत स्पष्ट है कि LinAlg लिए हमारी जूलिया प्रकार प्रणाली संभवतः Complex हमारे 2x2 मैट्रिक्स एम्बेडिंग को संभाल नहीं सकती है। trace(Z) जहां Z = [1 0; 0 1] 2 , जबकि यह हमारे 1 का प्रतिनिधित्व है। इसी तरह rank(Z) ।

स्थिरता को पुनर्प्राप्त करने का एक तरीका यह है कि हम अपने 2x2 प्रतिनिधित्व को स्केलर के रूप में परिभाषित करें, उदाहरण के लिए Number नीचे जैसे घटाकर:

struct CNumber{T <: Real} <: Number
    m::Matrix{T}
end
CNumber(x::Real, y::Real) = CNumber([x y; -y x])

+(c1::CNumber, c2::CNumber) = CNumber(c1.m + c2.m)
-(c1::CNumber, c2::CNumber) = CNumber(c1.m - c2.m)
*(c1::CNumber, c2::CNumber) = CNumber(c1.m * c2.m)
/(c1::CNumber, c2::CNumber) = CNumber(c1.m / c2.m)
\(c1::CNumber, c2::CNumber) = CNumber(c1.m \ c2.m)
conj(c::CNumber) = CNumber(transpose(c.m))
zero(c::CNumber{T}) where {T} = CNumber(zero(T), zero(T))
one(c::CNumber{T}) where {T} = CNumber(one(T), one(T))

इन परिभाषा के साथ, सामान्य LinAlg विधियां शायद ठीक काम करेंगी।

निष्कर्ष मैं इससे आकर्षित करता हूं: पुनरावर्ती adjoint ब्लॉक मैट्रिसेस और वैक्टर के वैक्टर के लिए एक सुविधा है। इसे "स्केलर" 2x2 मैट्रिसेस के प्रकारों के लिए गणितीय शुद्धता से प्रेरित नहीं होना चाहिए, जिन्हें मैंने Z ऊपर लेबल किया था। हम इसे अपनी पसंद के रूप में देखते हैं कि क्या हम निम्नलिखित नियमों और विपक्षों के साथ डिफ़ॉल्ट रूप से ब्लॉक मैट्रिस का समर्थन करते हैं या नहीं।

पेशेवरों

• ब्लॉक सरणी उपयोगकर्ताओं के लिए सुविधा
• वैक्टर के वैक्टर वैध वेक्टर रिक्त स्थान होते हैं, और ब्लॉक मेट्रिसेस, + , * , conj , आदि के तहत मान्य लीनियर ऑपरेटर्स होते हैं। (ऊपर Z उदाहरण के विपरीत, जिसके लिए CNumber आवश्यकता होती है), तो क्यों नहीं?

विपक्ष

• LinAlg हमारे कार्यान्वयन के लिए महत्वपूर्ण अतिरिक्त जटिलता (जो संभवतः दूसरे पैकेज में रह सकती है)।
• eig(block_matrix) जैसी चीजों का समर्थन करना थोड़ा मुश्किल (लेकिन असंभव नहीं) है। अगर हम कहते हैं कि LinAlg eig और LinAlg का समर्थन ब्लॉक मैट्रिस करता है, तो मैं इसे बग तब तक मानता हूं जब तक यह तय नहीं हो जाता। LinAlg द्वारा प्रदान की गई कार्यक्षमता की बड़ी मात्रा को देखते हुए यह देखना मुश्किल है कि हम कभी भी "समाप्त" हो जाएंगे।
• गैर-पुनरावर्ती तरीके से transpose जैसे ऑपरेशन का उपयोग करने के इच्छुक डेटा उपयोगकर्ताओं की असुविधा,

मेरे लिए सवाल यह है - क्या हम यह कहना चाहते हैं कि डिफ़ॉल्ट रूप से LinAlg AbstractArray s के तत्व "स्केलर" ( Number सबटिप या डक-टाइपिंग) की अपेक्षा रखते हैं। और बाहरी पैकेजों के लिए ब्लॉक सरणियों की जटिलता को दूर करें? या हम Base और LinAlg में जटिलता को गले लगाते हैं?

एक दिन पहले तक की योजना बाद की थी।

@ Sacha0 मैं यहां परिवर्तनों का समर्थन करने के लिए आवश्यक RowVector काम करने की कोशिश कर रहा हूं (पहले वाले: गैर-पुनरावर्ती transpose , RowVector सहायक तार और अन्य डेटा) और अब मैं सोच रहा हूं कि डिजाइन के मामले में आपके मन में क्या था।

हालिया चर्चाओं से, मैं इन मामलों को इस अनुमान से देखता हूं कि क्या वांछित हो सकता है

| | वेक्टर | मैट्रिक्स |
| - | - | - |
| adjoint | RowVector पुनरावर्ती adjoint | AdjointMatrix या TransposedMatrix पुनरावर्ती adjoint |
| transpose | RowVector पुनरावर्ती transpose | TransposeMatrix पुनरावर्ती transpose |
| flip | एक प्रति या PermutedDimsArray ? | एक प्रति या PermutedDimsArray ? |
| conj AbstractArray | आलसी या उत्सुक? | आलसी या उत्सुक? |
| conj RowVector या TransposedMatrix | आलसी | आलसी |

(डेटा के सरणियों के अनुमत आयामों से रैखिक बीजगणितीय चिंताओं को अलग करने के लिए उपरोक्त प्रयास।)

तो कुछ बुनियादी सवाल मुझे अस्थिर करने के लिए:

• क्या हम पुनरावर्ती transpose या नहीं कर रहे हैं? adjoint बारे में क्या?
• यदि हां, तो क्या हम conj(transpose(array)) == adjoint(array) मान लेते रहेंगे?
• ऐसा लगता है कि कम से कम कुछ जटिल संयुग्मन आलसी होंगे, उदाहरण के लिए बिना किसी अतिरिक्त प्रतियां के सभी वर्तमान BLAS संचालन। क्या हम सभी सरणियों के लिए conj आलसी बनाते हैं?
• अगर हम flip परिचय देते हैं, तो क्या यह आलसी या उत्सुक है?

FYI करें मैंने # 24839 पर मैट्रिक्स के आयामों को "फ़्लिपिंग" करने के लिए कम-घर्षण दृष्टिकोण की कोशिश की, permutedims लिए छोटे रूप का उपयोग करते हुए।

मैं दृढ़ता से @ सखा 0 के प्रस्ताव के पक्ष में आधारों को पूरी तरह से हल नहीं किया है, लेकिन स्वतंत्र रूप से इससे: यह अब कैसे उपयोगी हो गया है, कम से कम मेरे लिए , और उस से दूर एक अंतिम मिनट परिवर्तन शायद बीमार की सलाह दी है। ट्रांसजेंड को इस संबंध में आसन्न (= conj∘adjoint ) का पालन करना चाहिए, यदि यह सभी आवश्यक है।

FWIW, Mathematica Transpose और न ही ConjugateTranspose पुनरावृत्ति नहीं करता है:

मैंने ऊपर विस्तृत चर्चाओं को पढ़ने की कोशिश की, लेकिन यह देखने में असफल रहा कि किस बिंदु पर यह तय किया गया था / प्रेरित किया गया था कि एक गणितीय परिवर्तन को सरसरी तौर पर किया जाना चाहिए। [...] पूर्णता / आत्म-समता के लिए, क्या यह अवधारणा और क्यों इसे पुनरावर्ती होना चाहिए संक्षेप में दोहराया / संक्षिप्त किया जाना चाहिए?

मैं इस भावना को समझता हूं और इसकी सराहना करता हूं, और इसे समय की अनुमति के रूप में इसे संबोधित करना चाहूंगा। सुलभ और स्पष्ट रूप से यह समझाते हुए कि परिभाषा के द्वारा आसन्न और पारगमन को पुनरावर्ती क्यों होना चाहिए दुर्भाग्य से सबसे अच्छे रूप में चुनौतीपूर्ण है और संक्षेप में संभव नहीं है। सुसंगत, व्यापक लेखन जैसे कि ऊपर निर्माण के लिए भारी मात्रा में समय लेते हैं। समय कम हो रहा है, दिन के दौरान मैं इसके बजाय कुछ विशेष पदों / सवालों के जवाब देकर पूर्ववर्ती कुछ पोस्टों में भ्रम को दूर करने की कोशिश करूंगा; कृपया मेरे साथ सहन करें जब मैं ऐसा टुकड़ा करता हूं :)। श्रेष्ठ!

यह बताते हुए कि क्यों ... परिभाषा द्वारा पुनरावर्ती होना चाहिए ...

मैं बहुत सुंदर हूं, जिन्होंने इस चर्चा में योगदान दिया है, सहमत हैं कि adjoint(A) को पुनरावर्ती होना चाहिए। विवाद का एकमात्र बिंदु यह है कि क्या transpose(A) को भी पुनरावर्ती होना चाहिए (और क्या कोई नया कार्य flip(A) गैर-पुनरावर्ती हस्तांतरण के लिए पेश किया जाना चाहिए)।

मैं बहुत सुंदर हूं, जिसने इस चर्चा में योगदान दिया है, इस बात से सहमत हैं कि निकटवर्ती (ए) को पुनरावर्ती होना चाहिए।

देखें, उदाहरण के लिए, https://github.com/JuliaLang/julia/issues/20978#issuecomment-347777577 और पिछली टिप्पणियाँ :)। श्रेष्ठ!

पुनरावर्ती विज्ञापन के लिए तर्क परिभाषा के लिए बहुत बुनियादी है। dot(x,y) एक आंतरिक उत्पाद होना चाहिए, अर्थात एक अदिश पदार्थ का उत्पादन करना चाहिए, और आसन्न की परिभाषा यह है कि dot(A'*x, y) == dot(x, A*y) । पुनर्मिलन (दोनों dot और adjoint ) इन दोनों गुणों से निम्नानुसार है।

(डॉट उत्पादों का संबंध पूरे कारण है कि लंबन और बीजगणित रैखिक बीजगणित में महत्वपूर्ण संचालन हैं। यही कारण है कि हमारे पास उनके लिए एक नाम है, और अन्य कार्यों के लिए नहीं है जैसे कि मेट्रिक्स को 90 डिग्री से घुमाकर ( rot90 मटलब में)। )।)

ध्यान दें कि गैर-पुनरावर्ती हस्तांतरण के लिए flip का उपयोग करने के साथ एक समस्या यह है कि मतलब और नेम्पी दोनों ही flip करते हैं जिसे हम flipdim ।

मुझे लगता है कि कोई भी वास्तव में रेखीय नक्शे पर एक ऑपरेशन के रूप में अमूर्त गणितीय अर्थों में पारगमन का उपयोग नहीं कर रहा है, इस सरल कारण के लिए कि मैट्रिक्स का संक्रमण एक ऐसी वस्तु होगी जो वैक्टर पर नहीं बल्कि रोवेक्टरों पर कार्य करता है, अर्थात यह रोवेक्टर का मानचित्रण करेगा रोवेक्टर को।

लेकिन यह सरल प्रतीत नहीं होता है कि एक पुनरावर्ती हस्तांतरण नहीं है और बस इसे गैर-गणित अनुप्रयोगों के लिए भी उपयोग करने की अनुमति है, क्योंकि मुझे लगता है कि विशिष्ट मैट्रिक्स समीकरणों में भी रैखिक मानचित्र के वास्तविक गणितीय हस्तांतरण के साथ ऐसा करने के लिए बहुत कम है।

संक्रमण (जिसका उपयोग गणितीय अर्थ में कभी नहीं किया जाता है लेकिन हमेशा फ्लिप मैट्रिक्स सूचकांकों में होता है)

यह थोड़ा गोल-मटोल प्रतीत होगा, इसलिए मेरे साथ सहन करें :)।

जूलिया के adjoint अर्थ विशेष रूप से हर्मिटियन निकटता से है । सामान्य तौर पर, यू और वी के लिए संबंधित दोहरे रिक्त स्थान यू * और वी के साथ पूर्ण मानक वेक्टर रिक्त स्थान (Banach रिक्त स्थान) , और रैखिक मानचित्र A: U -> V के लिए, फिर A के निकटवर्ती, आमतौर पर निरूपित A , एक रेखीय मानचित्र A है *: वी * -> यू * । यही है, सामान्य तौर पर निकटस्थ स्थान दोहरे स्थानों के बीच एक रेखीय मानचित्र होता है, जैसा कि सामान्य रूप से ट्रांसएन्स ए ^ टी दोहरे रिक्त स्थान के बीच एक रेखीय मानचित्र है जैसा कि ऊपर बताया गया है। तो कोई व्यक्ति इन परिभाषाओं को हर्मिटियन सन्निकट की परिचित धारणा के साथ कैसे सामंजस्य स्थापित करता है? :)

उत्तर उन अतिरिक्त संरचनाओं में निहित होता है, जिनके रिक्त स्थान में आमतौर पर पूर्ण आंतरिक उत्पाद स्थान (हिल्बर्ट स्थान) काम करता है। एक आंतरिक उत्पाद एक मानदंड को प्रेरित करता है, इसलिए एक पूर्ण आंतरिक उत्पाद स्थान (हिल्बर्ट) एक पूर्ण आदर्श स्थान (Banach) है, और इस तरह (हर्मीशियन) की अवधारणा का समर्थन करता है। यहाँ कुंजी है: केवल एक मानक के बजाय एक आंतरिक उत्पाद होने से, रैखिक बीजगणित में सबसे सुंदर प्रमेयों में से एक, रिज्ज़ प्रतिनिधित्व प्रमेय अर्थात् लागू होता है। संक्षेप में, रिस्ज़ प्रतिनिधित्व प्रमेय बताता है कि एक हिल्बर्ट स्थान अपने दोहरे स्थान के लिए स्वाभाविक रूप से आइसोमॉर्फिक है। नतीजतन, हिल्बर्ट रिक्त स्थान के साथ काम करते समय, हम आम तौर पर रिक्त स्थान और उनके दोहरे की पहचान करते हैं और भेद को छोड़ देते हैं। यह पहचान बनाना कि आप A *: V -> U की बजाय A *: V * -> U * के रूप में हरमिटियन की परिचित धारणा पर कैसे पहुंचे ।

और एक ही पहचान आम तौर पर हिल्बर्ट रिक्त स्थान पर विचार करने के लिए पारगमन के लिए बनाई जाती है, जैसे कि ए ^ टी: वी -> यू, पारगमन की परिचित धारणा की उपज। तो स्पष्ट करने के लिए, हाँ, संक्रमण की आम धारणा सबसे परिचित (हिल्बर्ट) सेटिंग के लिए लागू की जाने वाली सामान्य धारणा है, जैसे कि हर्मिटियन आसन्न की आम धारणा उस सेटिंग पर लागू होने वाली सामान्य धारणा है। श्रेष्ठ!

एक मृत घोड़े की पिटाई के लिए माफी, लेकिन मुझे लगा कि मैं गणितीय उलझन के मुद्दों को संक्षेप में एक अलग तरीके से संक्षेप में बताऊंगा। असहमति का मुख्य बिंदु यह है कि किसी वस्तु को Vector{T} गणितीय रूप से व्याख्या कैसे की जाए जब T Number उप-प्रकार न हो, जिसमें कोई सरणी-जैसी उप-संरचना न हो।

विचार का एक स्कूल @stevengj का दावा है कि स्वीकार करता है

एक रिंग आर के ऊपर वैक्टर के एक वेक्टर को एक प्रत्यक्ष-योग स्थान के रूप में सबसे अच्छा समझा जाता है, जो आर के ऊपर एक वेक्टर स्थान भी है।

अनंत-आयामी वेक्टर रिक्त स्थान, आदि के बारे में मोडुलो कुछ सूक्ष्मताएं, यह मूल रूप से इसका मतलब है कि हमें वैक्टर के वैक्टर को ब्लॉक वैक्टर के रूप में सोचना चाहिए। तो एक Vector{Vector{T<:Number}} को मानसिक रूप से "चपटा" होना चाहिए एक सरल Vector{T} । इस प्रतिमान के भीतर, रेखीय संचालक जिन्हें मेट्रिसेस के मैट्रीस के रूप में दर्शाया जाता है, उन्हें ब्लॉक मैट्रिस के समान माना जाना चाहिए, और adjoint निश्चित रूप से पुनरावर्ती होना चाहिए, जैसा कि हम शब्द का उपयोग कर रहे हैं, transpose होना चाहिए। गणितीय अर्थ । कृपया मुझे सही करें अगर मैं गलत हूं, लेकिन मेरा मानना ​​है कि जो लोग इस दृष्टिकोण को लेते हैं, वे सोचते हैं कि Vector{Matrix{T}} जैसी कोई प्राकृतिक-पर्याप्त व्याख्या नहीं है जिसे हमें इसके लिए डिज़ाइन करना चाहिए। (विशेष रूप से, हमें केवल यह नहीं मान लेना चाहिए कि आंतरिक Matrix एक जटिल संख्या का एक मैट्रिक्स प्रतिनिधित्व है, क्योंकि @stevengj ने कहा है,

यदि आप 2x2 मैट्रिक्स द्वारा जटिल संख्याओं का प्रतिनिधित्व कर रहे हैं, तो आपके पास एक अलग जटिल वेक्टर स्थान है।

)

विचार का दूसरा स्कूल यह है कि Vector{T} हमेशा स्केल के ऊपर एक सार सदिश स्थान में एक वेक्टर के प्रतिनिधित्व के बारे में सोचा जाना चाहिए (शब्द के रैखिक बीजगणित अर्थ में) T , T प्रकार की परवाह किए बिना। इस प्रतिमान में, एक Vector{Vector{T'}} को एक प्रत्यक्ष योग स्थान के तत्व के रूप में नहीं सोचा जाना चाहिए, बल्कि इसके बजाय स्केलर पर एक वेक्टर के रूप में Vector{T'} । इस मामले में, transpose(Matrix{T}) को पुनरावर्ती नहीं होना चाहिए, लेकिन बस बाहरी मैट्रिक्स को फ्लिप करना चाहिए। इस व्याख्या के साथ एक मुद्दा यह है कि स्केलर की वैध अंगूठी बनाने के लिए T के तत्वों के लिए, इसके अलावा (कम्यूटेटिव) जोड़ और गुणन की एक अच्छी तरह से परिभाषित धारणा होनी चाहिए। Vector{Vector{T'}} जैसे वेक्टर के लिए, हमें दो "स्केल" Vector{T'} को एक और Vector{T'} गुणा करने के लिए एक नियम की आवश्यकता होगी। जबकि कोई निश्चित रूप से इस तरह के एक नियम के साथ आ सकता है (जैसे एलिमेंटवाइज़ मल्टीप्लिकेशन, जो इस मुद्दे को सजा देता है कि T' को कैसे बढ़ाया जाए), ऐसा करने के लिए कोई सार्वभौमिक प्राकृतिक तरीका नहीं है। एक अन्य मुद्दा यह है कि इस व्याख्या के तहत adjoint कैसे काम करेंगे। हर्मिटियन निकटता केवल एक हिल्बर्ट स्थान पर रेखीय परिचालकों पर परिभाषित की गई है, जिसकी परिभाषा के आधार पर स्केलर फ़ील्ड या तो वास्तविक या जटिल संख्या होनी चाहिए। इसलिए अगर हम adjoint को मैट्रिक्स Matrix{T} लागू करना चाहते हैं, तो हमें यह मान लेना चाहिए कि T जटिल संख्याओं (या वास्तविक संख्याओं) का कुछ प्रतिनिधित्व है, लेकिन मैं सिर्फ छड़ी करूँगा जटिल होने के कारण वह मामला अधिक सूक्ष्म है)। इस व्याख्या में, adjoint को पुनरावर्ती नहीं होना चाहिए लेकिन बाहरी मैट्रिक्स को फ्लिप करना चाहिए और फिर conjugate लागू करना चाहिए। लेकिन यहां अधिक समस्याएं हैं, क्योंकि conjugate(T) की सही कार्रवाई प्रतिनिधित्व की प्रकृति पर निर्भर करती है। अगर यह विकिपीडिया पर वर्णित 2x2 प्रतिनिधित्व है, तो conjugate मैट्रिक्स को फ्लिप करना चाहिए। लेकिन ऊपर वर्णित कारणों के लिए, conjugate निश्चित रूप से हमेशा मैट फ्लिप नहीं करना चाहिए। इसलिए इस दृष्टिकोण को लागू करने में थोड़ी गड़बड़ होगी।

यहां मेरे अपने विचार हैं: कोई "उद्देश्यपूर्ण रूप से सही" उत्तर नहीं है कि क्या transpose को उन सरणियों पर लागू किया जाना चाहिए, जिनके तत्वों में आगे जटिल उप-निर्माण है। यह इस बात पर निर्भर करता है कि उपयोगकर्ता जूलिया में उनके अमूर्त बीजीय संरचना का प्रतिनिधित्व करने के लिए वास्तव में कैसे चुन रहा है। फिर भी, पूरी तरह से मनमाने ढंग से छल्ले का समर्थन करना ऐसा लगता है कि यह बहुत मुश्किल होगा, इसलिए मुझे लगता है कि व्यावहारिकता के लिए हमें उस महत्वाकांक्षी होने की कोशिश नहीं करनी चाहिए और गैर-मानक रिंगों पर मॉड्यूल के गूढ़ गणित के बारे में भूलना चाहिए। हमें निश्चित रूप से Base में कार्य करना चाहिए ( permutedims(A, (2,1)) तुलना में सरल सिंटैक्स के साथ) जिसका ट्रांसपोज़िशन के रैखिक बीजगणितीय अवधारणा से कोई लेना-देना नहीं है और बस मैट्रिस को फ़्लिप करता है और पुनरावर्ती कुछ भी नहीं करता है, चाहे वह कुछ भी हो। transpose या flip या क्या कहा जाता है। यह अच्छा होगा यदि adjoint और एक अलग ट्रांज़ोज़ फ़ंक्शन (संभवतः एक अलग नाम के साथ) LinAlg में पुनरावर्ती थे, क्योंकि तब वे ब्लॉक वैक्टर / मैट्रिस और प्रत्यक्ष योग के सरल कार्यान्वयन को संभाल सकते थे। वैक्टर के वैक्टर के रूप में, लेकिन इसके लिए "उद्देश्य गणितीय शुद्धता" की आवश्यकता नहीं है, और यह उस निर्णय को पूरी तरह से कार्यान्वयन में आसानी के आधार पर करना ठीक होगा।

मेरे पिछले वादे के बावजूद कोई टिप्पणी नहीं करने के लिए, मुझे दुर्भाग्य से इस पर प्रतिक्रिया करनी है।

जूलिया के सहायक विशेष रूप से हर्मिटियन निकटता को संदर्भित करता है। सामान्य तौर पर, यू और वी के लिए संबंधित दोहरे रिक्त स्थान यू * और वी के साथ पूर्ण मानक वेक्टर रिक्त स्थान (Banach रिक्त स्थान) , और रैखिक मानचित्र A: U -> V के लिए, फिर A के हरमिटियन निकटता, आमतौर पर A को चिह्नित किया जाता है , एक रैखिक नक्शा है ए *: वी * -> यू *। यही है, सामान्य तौर पर हर्मिटियन समीपता दोहरे स्थानों के बीच एक रेखीय मानचित्र है, जैसा कि सामान्य तौर पर पारगमन A ^ t दोहरे रिक्त स्थान के बीच एक रेखीय मानचित्र है जैसा कि ऊपर बताया गया है। तो आप इन परिभाषाओं को हर्मिटियन सन्निकट की परिचित धारणा के साथ कैसे सामंजस्य स्थापित करते हैं? :)

वास्तव में यह सच नहीं है। आप यहाँ जो वर्णन कर रहे हैं वह वास्तव में परिवर्तन है, लेकिन (जैसा कि मैंने पहले ही उल्लेख किया है), कुछ क्षेत्रों में इसे निकटवर्ती (हर्मिटियन के बिना) के रूप में संदर्भित किया जाता है और इसे ए ^ टी या ए ^ * (कभी ए ^ डैगर) के रूप में दर्शाया जाता है। वास्तव में, यह वेक्टर स्थानों से परे अच्छी तरह से फैली हुई है, और श्रेणी सिद्धांत में इस तरह की अवधारणा किसी भी monoidal श्रेणी में मौजूद है (उदाहरण के लिए n- आयामी उन्मुख cateogory कोबर्डिज्म के साथ रेखीय नक्शे के रूप में प्रकट होता है), जहां इसे निकटवर्ती दोस्त के रूप में जाना जाता है तथ्य यह है कि दो अलग-अलग ए और ए हो सकते हैं , चूंकि बाएं और दाएं दोहरे स्थान आवश्यक रूप से समान नहीं हैं)। लेकिन ध्यान दें, इसमें जटिल संयुग्मन शामिल नहीं है। V * के तत्व वास्तव में रैखिक नक्शे f: V-> स्केलर हैं, और रैखिक नक्शे A: U-> V और U से एक वेक्टर v के लिए, हमारे पास f (Av) = (A ^ tf) (v) है । चूंकि f की कार्रवाई में जटिल संयुग्मन शामिल नहीं है, न ही A ^ t की परिभाषा है।

उत्तर उन अतिरिक्त संरचनाओं में निहित है, जिनके स्थान पर आप आमतौर पर काम करते हैं, अर्थात् पूर्ण आंतरिक उत्पाद स्थान (हिल्बर्ट स्थान)। एक आंतरिक उत्पाद एक मानदंड को प्रेरित करता है, इसलिए एक पूर्ण आंतरिक उत्पाद स्थान (हिल्बर्ट) एक पूर्ण आदर्श स्थान (Banach) है, और जिससे हर्मिटियन सहायक की अवधारणा का समर्थन करता है। यहाँ कुंजी है: केवल एक मानक के बजाय एक आंतरिक उत्पाद होने से, रैखिक बीजगणित में सबसे सुंदर प्रमेयों में से एक, रिज्ज़ प्रतिनिधित्व प्रमेय अर्थात् लागू होता है। संक्षेप में, रिस्ज़ प्रतिनिधित्व प्रमेय बताता है कि एक हिल्बर्ट स्थान अपने दोहरे स्थान के लिए स्वाभाविक रूप से आइसोमॉर्फिक है। नतीजतन, हिल्बर्ट रिक्त स्थान के साथ काम करते समय, हम आम तौर पर रिक्त स्थान और उनके दोहरे की पहचान करते हैं और भेद को छोड़ देते हैं। यह पहचान बनाना कि आप A *: V -> U की बजाय A *: V * -> U * के रूप में हरमिटियन की परिचित धारणा पर कैसे पहुंचे।

फिर, मुझे नहीं लगता कि यह पूरी तरह से सही है। आंतरिक उत्पाद रिक्त स्थान में, आंतरिक उत्पाद sesquilinear form dot conj (V) x V -> स्केलर (संयुग्मित सदिश स्थान के साथ conj (V)) है। यह वास्तव में V से V * (या तकनीकी रूप से conj (V) से V *) तक का नक्शा स्थापित करने की अनुमति देता है, जो वास्तव में रिज्ज़ प्रतिनिधित्व प्रमेय है। हालाँकि, हमें जरूरत नहीं है कि हर्मिटियन समीपता का परिचय दें। वास्तव में, आंतरिक उत्पाद dot अपने आप में पर्याप्त है, और एक रेखीय मानचित्र A के हरमिजियन ऐसा है
dot(w, Av) = dot(A' w, v) । इसमें जटिल संयुग्मन शामिल है।

वास्तव में यह सच नहीं है। आप यहाँ जो वर्णन कर रहे हैं वह वास्तव में परिवर्तन है, लेकिन (जैसा कि मैंने पहले ही उल्लेख किया है), कुछ क्षेत्रों में इसे निकटवर्ती (हर्मिटियन के बिना) के रूप में संदर्भित किया जाता है और इसे ए ^ टी या ए ^ * (कभी ए ^ डैगर) के रूप में दर्शाया जाता है। [...]

@ जुथो , कृपया देखें, उदाहरण के लिए, विकिपीडिया पृष्ठ ।

हो सकता है कि गणित के विभिन्न क्षेत्रों के बीच असंगतता हो, लेकिन:
https://en.wikipedia.org/wiki/Transpose_of_a_linear_map
खास तरीके से
https://en.wikipedia.org/wiki/Transpose_of_a_linear_map#Relation_to_the_Hermitian_adjoint
और श्रेणी सिद्धांत में बेशुमार संदर्भ, उदाहरण के लिए
https://arxiv.org/pdf/0908.3347v1.pdf

https://en.wikipedia.org/wiki/Transpose_of_a_linear_map
खास तरीके से
https://en.wikipedia.org/wiki/Transpose_of_a_linear_map#Relation_to_the_Hermitian_adjoint

@ जूथो , मुझे उस पेज सेक्शन के बारे में कोई असंगतता नहीं दिखती । श्रेष्ठ!

मैं @ Sacha0 के प्रस्ताव पर भी हस्ताक्षर permutedims के साथ अब के लिए भी ठीक हूं; मुझे लगता है कि यह flip से बेहतर है।

@ Sacha0 , तो हमारे पास उस की व्याख्या करने का एक अलग तरीका है। मैंने इसे पढ़ा
दिए गए A के लिए: U-> V,
पारगमन (ए) = दोहरी (ए) = (कभी-कभी) भी स्थगित (ए): वी * -> यू *
hermitian adjoint (A) = डैगर (A) = (आमतौर पर सिर्फ) adjoint (A): V-> यू
और दोनों के बीच का संबंध वास्तव में अंतरिक्ष से दोहरे स्थान (यानी रिज्ज़ ...) के नक्शे का उपयोग करके प्राप्त किया गया है, जिसमें जटिल संयुग्मन शामिल है। इसलिए, हेर्मिटियन आसन्न में संयुग्मन शामिल है, संक्रमण नहीं करता है।

यदि आप पहले एक हेर्मैटिनियन निकटता को कॉल करना चाहते हैं, तो आप ट्रांसजेंड को क्या कहते हैं? आपने वास्तव में यह परिभाषित नहीं किया कि आपके विवरण में क्या था, आपने अभी उल्लेख किया है

आम तौर पर ए से निरूपित हर्मिटियन ए , एक रैखिक नक्शा A : V * -> U * है। यही है, सामान्य तौर पर हर्मिटियन समीपता दोहरे स्थानों के बीच एक रेखीय मानचित्र है, जैसे कि सामान्य रूप से पारगमन A ^ t दोहरे स्थानों के बीच एक रेखीय मानचित्र है।

तो पारगमन और हर्मिटियन आसन्न हैं तो A: U-> V को V -> U से नक्शे में बदलने के दो अलग-अलग तरीके हैं? मैं वास्तव में इस बारे में आगे चर्चा करने में प्रसन्न हूं, लेकिन मुझे लगता है कि हम इसे कहीं और करते हैं। लेकिन वास्तव में, मुझसे संपर्क करें क्योंकि मैं वास्तव में इस बारे में अधिक जानने के लिए इच्छुक हूं।

इसके अलावा http://staff.um.edu.mt/jmus1/banach.pdf एक संदर्भ के लिए देखें जो Banach रिक्त स्थान के संदर्भ में उपयोग किया जाता है, वास्तव में ट्रांसपोज़ होता है, न कि हरमिटियन adjoint (विशेष रूप से इसके रैखिक और प्रतिविष नहीं। परिवर्तन)। विकिपीडिया (और अन्य संदर्भ) वास्तव में इन दो अवधारणाओं का सामना कर रहे हैं, हिल्बर्ट रिक्त स्थान में बानच रिक्त स्थान में सहायक की एक सामान्य परिभाषा के लिए प्रेरणा के रूप में हर्मिटियन आसन्न की धारणा का उपयोग करते हुए। हालांकि, उत्तरार्द्ध वास्तव में संक्रमण है (और इसके लिए एक आंतरिक उत्पाद की आवश्यकता नहीं है, न ही एक मानक)। लेकिन यह वह बदलाव है जिसके बारे में मैं बात कर रहा था, कि कोई भी वास्तव में कंप्यूटर कोड का उपयोग नहीं कर रहा है।

जूलिया बेस के लिए: मैं हर्मिसियन संयुग्मन के पुनरावर्ती होने का विरोध नहीं कर रहा हूं; मैं मानता हूं कि यह अक्सर सही बात होगी। मुझे यकीन नहीं है कि आधार को चतुर चीजों को करने की कोशिश करनी चाहिए जब तत्व प्रकार Number । यहां तक ​​कि T संख्या के साथ, गैर-यूक्लिडियन आंतरिक उत्पादों (और निकटता की संबद्ध संशोधित परिभाषाओं) के अधिक सामान्य उपयोग के लिए बेस में कोई समर्थन नहीं है, और न ही मुझे लगता है कि होना चाहिए। इसलिए मुझे लगता है कि मुख्य प्रेरणा ब्लॉक मैट्रिस थी, लेकिन वहां मुझे लगता है कि एक विशेष उद्देश्य प्रकार (बेस या पैकेज में) जूलियन अधिक है, और जैसा कि @andyferris ने भी उल्लेख किया है, यह बाकी सभी LinAlg का समर्थन करता है कि ब्लॉक मेट्रिसेस की धारणा, यहां तक ​​कि inv (अकेले मैट्रिक्स फैक्टरशिप्स आदि) जैसी सरल चीजें भी।

लेकिन अगर पुनरावर्ती हर्मिटियन संयुग्मन यहाँ रहना है (मेरे द्वारा ठीक है), तो मुझे लगता है कि निरंतरता के लिए dot और vecdot तत्वों पर पुनरावृत्ति कार्य करना चाहिए। वर्तमान में, यह मामला नहीं है: तत्वों पर dot x'y (जो तत्वों के परिपक्व होने पर समान नहीं है) और vecdot dot कॉल करते हैं तत्वों पर। तो मैट्रिक के वेक्टर के लिए, वास्तव में स्केलर परिणाम प्राप्त करने का कोई तरीका नहीं है। मुझे एक पीआर तैयार करने में खुशी होगी यदि लोग सहमत हैं कि वर्तमान कार्यान्वयन वास्तव में पुनरावृत्ति adjoint साथ असंगत नहीं है।

के रूप में transpose , यह सिर्फ गैर-पुनरावर्ती बनाने के लिए सरल लगता है और यह भी उन लोगों द्वारा उपयोग किया जाता है जो संख्यात्मक डेटा के साथ काम नहीं करते हैं। मुझे लगता है कि मैट्रिस के साथ काम करने वाले अधिकांश लोग transpose का शब्द जानते हैं और इसके लिए देखेंगे। अभी भी conj(adjoint()) उन लोगों के लिए है जिन्हें एक पुनरावर्ती transpose ।

ट्राइएज सोचता है @ सखा 0 को प्रस्ताव 2 के साथ आगे बढ़ना चाहिए ताकि हम इसे आज़मा सकें।

मैं @ttparker के साथ दृढ़ता से सहमत

1 - के लिए LinAlg , एक AbstractVector v एक है length(v) (अदिश) के आधार पर वजन के साथ आयामी वेक्टर v[1] , v[2] , ..., v[length(v)] ।

(और इसी तरह AbstractMatrix )।

यह शायद यह धारणा होगी कि कई लोग अन्य पुस्तकालयों से आएंगे, और आधार वैक्टर, रैंक, आदि की ऐसी सरल परिभाषा होने से कार्यान्वयन को सरल रखने में मदद मिलती है। (कई लोग शायद कहेंगे कि संख्यात्मक रैखिक बीजगणित कंप्यूटर पर ठीक से लागू करने के लिए संभव है क्योंकि हमारे पास काम करने के लिए एक अच्छा आधार है।)

हमारा वर्तमान तरीका अधिक पसंद है:

2 - LinAlg , एक AbstractVector v length(v) अमूर्त वैक्टर का एक सीधा योग है। हम स्केलर प्रकारों पर पर्याप्त परिभाषाएँ भी शामिल करते हैं जैसे Number ताकि LinAlg वे मान्य एक आयामी रैखिक ऑपरेटर / वैक्टर हों।

और इसी तरह (ब्लॉक) मैट्रिस के लिए। यह MATLAB, रैखिक, eigen, आदि में रैखिक बीजगणित कार्यान्वयन की तुलना में बेतहाशा अधिक सामान्यीकृत है, और यह जूलिया के शक्तिशाली प्रकार / प्रेषण प्रणाली का प्रतिबिंब है कि यह भी संभव है।

मैं जिस कारण से विकल्प 2 को देख सकता हूं, उसे फिर से देखने का कारण यह है कि जूलिया के प्रकार / प्रेषण प्रणाली से हमें अधिक व्यापक लक्ष्य प्राप्त करने की अनुमति मिलती है, जो निम्नानुसार है:

3 - LinAlg , हम एक सामान्य रेखीय बीजगणित इंटरफ़ेस बनाने का प्रयास कर रहे हैं जो उन वस्तुओं के लिए काम करता है जो + , * , conj तहत रैखिकता (आदि) को संतुष्ट करते हैं।

जो वास्तव में अच्छा लक्ष्य है (निश्चित रूप से किसी भी अन्य प्रोग्रामिंग भाषा / पुस्तकालय से परे है जो मुझे पता है), पूरी तरह से पुनरावर्ती adjoint और 2 को प्रेरित करता है (क्योंकि + , * और conj स्वयं पुनरावर्ती हैं) और यही कारण है कि @ सखा 0 का प्रस्ताव 2 और ट्राइएज निर्णय एक अच्छा विकल्प है :)

मैं वास्तव में इस बारे में आगे चर्चा करने में प्रसन्न हूं, लेकिन मुझे लगता है कि हम इसे कहीं और करते हैं। लेकिन वास्तव में, मुझसे संपर्क करें क्योंकि मैं वास्तव में इस बारे में अधिक जानने के लिए इच्छुक हूं।

चीयर्स, चलो करते हैं! मैं आगे ऑफ़लाइन चैट करने के लिए तत्पर हूं :)। श्रेष्ठ!

अच्छा सारांश एंडी! :)

पूरी तरह से सहमत एंडी, कम से कम adjoint (जो आपकी टिप्पणी का विषय था) के लिए।

हालांकि, एक गैर-पुनरावर्ती transpose लिए एक अंतिम याचिका, इससे पहले कि मैं हमेशा अपनी शांति (उम्मीद) रखूं।
मुझे निम्नलिखित फायदे होने के लिए एक गैर-पुनरावर्ती संक्रमण दिखाई देता है:

• इसका उपयोग मैट्रिस के साथ काम करने वाले सभी लोग कर सकते हैं, यहां तक ​​कि गैर-संख्यात्मक डेटा भी। यह भी है कि वे इस ऑपरेशन को कैसे जानेंगे और इसके लिए दूसरी भाषाओं से और बुनियादी गणित से लेकर उनके गैर-संख्यात्मक मामले तक की तलाश करेंगे।

• आलसी flip प्रकार या PermutedDimsArray LinAlg साथ सहभागिता करने के लिए अतिरिक्त कोड लिखने की आवश्यकता नहीं है। क्या होगा यदि मेरे पास एक संख्यात्मक मैट्रिक्स है जिसे मैं ट्रांसपोज़्ड के बजाय फ़्लिप किया गया हूं; क्या मैं अभी भी इसे अन्य मेट्रिसेस (अधिमानतः BLAS का उपयोग करके) के साथ गुणा कर पाऊंगा?

• एक गैर-पुनरावर्ती transpose और एक पुनरावर्ती adjoint , हम आसानी से conj(transpose(a)) रूप में एक गैर-पुनरावर्ती आसन्न हो सकते हैं और एक पुनरावर्ती conj(adjoint(a)) । और अभी भी सब कुछ LinAlg साथ अच्छी तरह से बातचीत करेगा।

तो नुकसान क्या हैं। मैं कोई नहीं देखता। मैं अभी भी अपनी बात पर कायम हूं कि वास्तव में कोई भी transpose का उपयोग अपने गणितीय अर्थ में नहीं कर रहा है। लेकिन किसी भी आगे बहस करने की कोशिश करने के बजाय, क्या कोई मुझे एक ठोस उदाहरण दे सकता है जहां एक पुनरावर्ती हस्तांतरण की आवश्यकता है या उपयोगी है, और जहां वास्तव में यह एक गणितीय टैनस्पोज़ है? यह किसी भी उदाहरण को शामिल नहीं करता है जहां आप वास्तव में adjoint का उपयोग करने का इरादा रखते हैं लेकिन केवल वास्तविक संख्याएं हैं। इसलिए एक ऐसा अनुप्रयोग जहां अधिक मैट्रिक्स से भरे वेक्टर या मैट्रिक्स को स्थानांतरित करने के लिए एक गणितीय कारण है जो स्वयं जटिल हैं।

मैं कह सकता हूं कि कम से कम गणितज्ञ (जो किसी से इस बारे में काफी विचार करने की उम्मीद करेगा) पुनरावर्ती पारगमन नहीं करता है:

A = Array[1 &, {2, 3, 4, 5}];
Dimensions[A]  # returns {2, 3, 4, 5}
Dimensions[Transpose[A]] # returns {3, 2, 4, 5}

संपादित करें: ओह, यह भी ऊपर टिप्पणी की गई थी, क्षमा करें

इसलिए मैं उलझन में हूं। ऐसा प्रतीत होता है कि बहुत ठोस सहमति है कि transpose को गैर-पुनरावर्ती बनाया जाना चाहिए - जैसे https://github.com/JuliaLang/julia/issues/20978#issuecomment -285880225, https://github.com/ जूलियालैंग / जूलिया / मुद्दे / 20978 # जारी करने वाला -285942526, https://github.com/JuliaLang/julia/issues/20978#issuecomment -285993057, https://github.com/JuliaLang/julia/issues/20978#issuommentment 348464449, और https://github.com/JuliaLang/julia/pull/23424 तब @ Sacha0 ने दो प्रस्ताव दिए, जिनमें से एक को पुनरावर्ती छोड़ दिया जाएगा, लेकिन एक गैर-पुनरावर्ती flip फ़ंक्शन का परिचय दें, जिसे मजबूत समर्थन मिला (इसके बावजूद जहां तक ​​मैं बता सकता हूं) वास्तव में पहले एक संभावना के रूप में नहीं उठाया गया। । तब @JeffBezanson ने सुझाव दिया कि हमें flip आवश्यकता नहीं है अगर हम permutedims एक डिफ़ॉल्ट दूसरा तर्क देते हैं, जिसे मजबूत समर्थन भी मिला।

तो अब सर्वसम्मति से ऐसा लगता है कि transpose वास्तविक परिवर्तन "पर्दे के पीछे" होना चाहिए: विशेष कमिंग और आलसी बनाम उत्सुक मूल्यांकन के बारे में, जिसे विशिष्ट अंतिम उपयोगकर्ता शायद नहीं जानते होंगे या उसकी परवाह नहीं करेंगे । केवल वास्तव में दिखाई देने वाले परिवर्तन अनिवार्य रूप से केवल वर्तनी में परिवर्तन हैं ( .' और permutedims एक डिफ़ॉल्ट दूसरा तर्क देना)।

ऐसा लगता है कि सामुदायिक सहमति लगभग 180 डिग्री में बहुत कम समय में ( @ Sacha0 की पोस्ट https://github.com/JuliaLang/julia/issues/20978#issuecomment-347360279 पर) बदल गई है। क्या सच्चा का पद इतना लचर था कि इसने सभी के मन को बदल दिया? (यह ठीक है अगर ऐसा है, तो मैं सिर्फ यह समझना चाहता हूं कि क्यों हम एक ऐसे रास्ते पर आगे बढ़ रहे हैं कि कुछ दिन पहले हम सभी सहमत होना चाहते थे कि यह गलत है।)

मैं भूल जाता हूं कि अगर किसी ने यह सुझाव दिया है, लेकिन क्या हम सिर्फ transpose(::AbstractMatrix{AbstractMatrix}) (और संभवतः transpose(::AbstractMatrix{AbstractVector}) भी) पुनरावर्ती और transpose गैर-पुनरावर्ती हो सकते हैं? ऐसा लगता है कि यह सभी ठिकानों को कवर करेगा और मैं किसी अन्य उपयोग के मामले के बारे में नहीं सोच सकता, जहां आप tranpose पुनरावर्ती होना चाहते हैं।

ऐसा लगता है कि सामुदायिक सहमति लगभग 180 डिग्री में बहुत कम समय में बदल गई है ( @ Sacha0 की पोस्ट # 20978 (टिप्पणी) के समय के आसपास)। क्या सच्चा का पद इतना लचर था कि इसने सभी के मन को बदल दिया? (यह ठीक है अगर ऐसा है, तो मैं सिर्फ यह समझना चाहता हूं कि क्यों हम एक ऐसे रास्ते पर आगे बढ़ रहे हैं कि कुछ दिन पहले हम सभी सहमत होना चाहते थे कि यह गलत है।)

यदि केवल मैं ही इतना e होता तो e आप जो देख रहे हैं वह यह है कि आम सहमति वास्तव में नहीं बनी थी। इसके बजाय, (1) प्रतिभागी जो यथास्थिति का पक्ष लेते हैं, लेकिन विस्मय के कारण चर्चा से हट गए, एक राय व्यक्त करने के लिए लौट आए; और (2) अन्य पक्षों ने विचार नहीं किया था कि यथास्थिति से दूर जाने का क्या चलन होगा (और यह कैसे विमोचन के साथ खेल सकता है) ने यथास्थिति के पक्ष में एक मजबूत राय बनाई और उस राय को व्यक्त किया।

कृपया विचार करें कि यह चर्चा 2014 के बाद से जीथब पर एक या रूप में चल रही है, और पहले ऑफ़लाइन होने की संभावना है। लंबे समय तक प्रतिभागियों के लिए, इस तरह की चर्चाएं थकाऊ और चक्रीय हो जाती हैं। इस चर्चा में शामिल होने के अलावा अन्य काम करने के लिए सार्थक काम किया जा रहा है --- जैसे लेखन कोड, जो अधिक सुखद है --- परिणाम उन दीर्घकालिक प्रतिभागियों के बीच आकर्षण है। नतीजतन, वार्तालाप एक अवधि या किसी अन्य के दौरान लोप हो जाता है। व्यक्तिगत रूप से, मैं उस एट्रिशन थ्रेशोल्ड के बारे में हूं, इसलिए मैं इस चर्चा में संलग्न रहने के बजाय अब कोड लिखने पर ध्यान केंद्रित करने जा रहा हूं। सभी को धन्यवाद और शुभकामनाएं! :)

मैं AbstractArrays के लिए गैर-पुनरावर्ती पारगमन और ctranspose के पक्ष में एक छोटा सा वोट डालूँगा, दोनों AbstractArray {T} पर पुनरावर्ती होने के साथ जहां T <: AbstractArray।

मैं मानता हूं कि कुछ मामलों में पुनरावर्ती व्यवहार 'सही' है, और मैं इस सवाल को देखता हूं कि हम पैकेजों का उपयोग और विकास करने वालों के लिए कम से कम आश्चर्य के साथ सही व्यवहार कैसे प्राप्त करते हैं।
इस प्रकार के प्रचार में, कस्टम प्रकारों के लिए पुनरावर्ती व्यवहार का विकल्प ऑप्ट-इन होता है: आप ऑप्ट-इन करके अपने प्रकार को एक AbstractArray बनाते हैं या उपयुक्त विधि को परिभाषित करके चुनते हैं।
Base.transpose(AbstractArray{MyType}) या Base.transpose(AbstractArray{T}) where T<: MyAbstractType ।
मुझे लगता है कि पुनरावर्ती पारगमन के लिए बतख टाइपिंग की रणनीति (बिना पूछे बस पुनरावृत्ति) ऊपर दस्तावेज के रूप में कुछ आश्चर्य पैदा करता है। यदि आप अलग ctranspose और adjoint, या अधिक जटिल प्रस्ताव जैसे conjadjoint और फ्लिप पेश करते हैं, तो उपयोगकर्ता इनका सामना करेंगे और उनका उपयोग करने का प्रयास करेंगे, और पैकेज अनुरक्षक उन सभी का समर्थन करने का प्रयास करेंगे।

एक ऐसे उदाहरण के रूप में जो नए प्रस्तावों के तहत समर्थन करने के लिए कठिन होगा: सामान्य, परिवर्तन, ctranspose और conj सरणियों में सभी को विचार (या आलसी मूल्यांकन) करने में सक्षम होना चाहिए जो कि ReshapedArray और SubAray के विचारों के साथ परस्पर क्रिया करता है। (मैं इस बारे में अज्ञेय हूं कि क्या ये डिफ़ॉल्ट रूप से विचार उत्पन्न करते हैं या केवल @view का उपयोग करते समय।) यह A*_mul_B* कम करने पर काम करता है और निचले स्तर पर BLAS झंडे 'एन' के साथ कॉल करता है। घने सरणियों के लिए 'टी', और 'सी', जैसा कि कहीं और नोट किया गया है। अगर normal , transpose , ctranspose , और conj इलाज किया जाए, तो यह कहना आसान होगा
बराबरी पर। ध्यान दें कि BLAS स्वयं केवल सामान्य के लिए 'N', स्थानान्तरण के लिए 'T', और ctranspose के लिए 'C' का समर्थन करता है और इसके पास संयुग्मन के लिए कोई ध्वज नहीं है, जो मुझे लगता है कि एक गलती है।

अंत में, उच्च आयामी Arrays और reshapes के साथ संगति के लिए, मेरा मानना ​​है कि परिवर्तन और ctranspose के उचित सामान्यीकरण को सभी आयामों को उल्टा करना है, अर्थात
पारगमन (A :: Array {T, 3}) = क्रमबद्धता (A, (3, 2, 1))।

चीयर्स!

मैं वास्तव में काम कर रहे लोगों की बहुत सराहना करता हूं। जिस तरह से बहुत अधिक लंबाई पर चर्चा की गई है वह वेक्टर adjoints / transpose (लेकिन कभी भी इसके पुनरावर्ती पहलू) नहीं है, जब तक @andyferris ने कदम नहीं

कहा जा रहा है कि, मैट्रिक्स ट्रांसजेंड और adjoint / ctranspose को कभी अधिक चर्चा नहीं मिली, विशेष रूप से इसके पुनरावर्ती पहलू को नहीं, जिसे लगभग चुपचाप https://github.com/JuliaLang/julia/pull/7th4 में एकल प्रेरणा ब्लॉक मेट्रिक्स के साथ पेश किया गया था । पुनरावर्ती निकटता के विभिन्न कारण और प्रेरणाएँ (तथ्यों के बाद) दी गई हैं, और अधिकांश लोग इस बात पर सहमत हो सकते हैं कि एक अच्छा (लेकिन केवल) विकल्प नहीं है। हालाँकि ट्रांसपोज़ में एक भी प्रेरणा या वास्तविक उपयोग के मामले में कमी है।

इन चर्चाओं में कुछ अलग चीजें चल रही हैं, और यह अभी होता है कि हमें एक योजना की आवश्यकता है जिसे जल्दी से लागू किया जा सके।

• हमने चर्चा की है कि क्या सपोर्टिंग ब्लॉक मैट्रिस (और अधिक विदेशी संरचनाएं) LinAlg में सार्थक है। कार्यान्वयन विकल्प हैं: कोई भी पुनरावर्ती सामान बिल्कुल नहीं ( + , * और conj क्योंकि वह जूलिया में सामान्य कार्यों की प्रकृति है), पुनरावर्ती सब कुछ (यथास्थिति), या किसी प्रकार के चेक या ट्रेस के लिए कोशिश कर रहा है कि किसी तत्व को पुनरावर्ती रैखिक बीजगणित करना चाहिए या स्केलर के रूप में माना जाना चाहिए।
• हम उपयोगकर्ताओं को डेटा के 2D सरणी के आयामों के लिए एक अच्छा तरीका चाहते हैं। हमें गैर-पुनरावर्ती transpose , flip , permutedims सिंटैक्स मिला है (क्योंकि PR को पहले शुद्ध रूप से प्रस्तुत किया गया था क्योंकि इसे लागू करने के लिए सबसे कम वर्ण हैं, और शायद यह भी समझ में आता है अगर हम कुछ और भी करते हैं), किसी प्रकार का चेक या लक्षण के लिए कि क्या किसी तत्व को पुनरावर्ती पारगमन करना चाहिए (शायद transpose(x::Any) = x ...)।
• जूलिया पार्सर में x' * y -> Ac_mul_B(x, y) जैसा अजीब व्यवहार होता है जो कि एक मस्सा होता है, जो आदर्श रूप से v1.0 में मौजूद नहीं होगा। इसे तब तक संभव नहीं देखा जा सकता है जब तक कि हम इसके बिना तेजी से बीएलएएस (कोई अतिरिक्त प्रतियां) का समर्थन नहीं कर सकते हैं, इस प्रकार आलसी मैट्रिक्स ट्रांसजेंड और सहायक है।
• LinAlg में कोड काफी बड़ा है और कई वर्षों में बनाया गया है। मैट्रिक्स गुणन जैसी कई चीजों को और अधिक विशेषता-अनुकूल होने के लिए फिर से बनाया जा सकता है, शायद नए broadcast जैसे प्रेषण प्रणाली के साथ। मुझे लगता है कि यह वह जगह है जहां हम सही सरणियों को भेजना आसान बना सकते हैं (मैं सोच रहा हूं कि संयुग्मित मैथ्यूज के ajdointed विचारों के साथ संयुग्मित reshaped ajdointed विचारों के बावजूद)। हालाँकि, यह v1.0 नहीं बनाएगा और हम कोड को बहुत खराब किए बिना प्रदर्शन प्रतिगमन से बचने की कोशिश कर रहे हैं। जैसा कि साचा ने बताया (और मुझे पता चल रहा है) तत्वों पर विस्तृत व्यवहार के साथ विचारों को स्थानांतरित करना (पुनरावर्ती निकटता, पुनरावर्ती पारगमन, संयुग्मन, कुछ भी नहीं) अतिरिक्त जटिलता और नए तरीकों का एक गुच्छा बनाता है ताकि वे काम कर सकें। कर रहे हैं।

अगर हम v1.0 के बारे में कुछ हद तक भाषा को स्थिर करने के बारे में सोचते हैं, तो कुछ अर्थों में व्यवहार में बदलाव लाने की सबसे बड़ी प्राथमिकता तीसरी है। मैं कहूंगा: भाषा (पार्सर सहित) सबसे स्थिर होनी चाहिए, इसके बाद Base , इसके बाद stdlib (जिसमें LinAlg शामिल नहीं हो सकता है, लेकिन मुझे लगता है कि लगभग निश्चित रूप से शामिल होगा) BLAS , Sparse , आदि एक दिन)। यह एक ऐसा बदलाव है जो वास्तव में उपयोगकर्ताओं (ज्यादातर पुस्तकालय डेवलपर्स) को प्रभावित नहीं करता है, इसलिए मुझे आश्चर्य नहीं होगा अगर लोगों की राय यहां अलग है।

एंडी पर हाजिर! :)

मुझे लगता है कि यहां केवल एक चीज बची है, वह है adjoint और transpose डिफ़ॉल्ट रूप से आलसी?

क्या अब इसे बंद किया जा सकता है?

अगला ऊपर: "स्केलर को गंभीरता से ले जाना"

लेकिन गंभीरता से, क्या हमारे पास अलग-अलग 3 डी ट्रांज़ोज़ और टेनर गुणन को निर्दिष्ट करने के लिए एक अच्छा इंटरफ़ेस हो सकता है जो पीडीई सॉल्वर में उपयोग किए जाते हैं? गंभीर की तरह, लेकिन मुझे यकीन नहीं है कि मैं इस पागलपन के अगले पुनरावृत्ति के लिए ओपी होने में सक्षम हो सकता हूं।

नहीं

:)

क्या हम अलग-अलग 3D ट्रांज़ोज़ और दसियों गुणन को निर्दिष्ट करने के लिए एक अच्छा इंटरफ़ेस रख सकते हैं, जिनका उपयोग PDE सॉल्वर में किया जाता है

निश्चित रूप से एक पैकेज के लिए एक अच्छा विषय की तरह लगता है।

अलग-अलग 3 डी ट्रांज़ोज़ और टेनसर गुणन को निर्दिष्ट करने के लिए एक अच्छा इंटरफ़ेस

क्या TensorOperations.jl को यहाँ आपकी ज़रूरत नहीं है? (ध्यान दें कि इस स्तर पर "एक अच्छा इंटरफ़ेस" का मतलब एक टेंसर नेटवर्क आरेख की तरह है, जो कि TensorOperations के सिंटैक्स की तुलना में किसी भी अधिक विशिष्ट रूप से कोड में लिखना थोड़ा चुनौतीपूर्ण है)।

हाँ, TensorOperations.jl अच्छा लग रहा है। मैं थोड़ा मजाक कर रहा था, लेकिन मुझे वह मिल गया जिसकी मुझे जरूरत थी,।