एंड्रियास ने #19344 में Aᵀ (और शायद Aᴴ ) की कोशिश की, लेकिन यह बहुत अच्छी तरह से प्राप्त नहीं हुआ था। हम इसी तरह ^ पर विशेष घातांक प्रकार T (और शायद H ) के साथ पन कर सकते हैं जैसे कि A^T स्थानांतरित हो, लेकिन यह भी छायादार है। सुनिश्चित नहीं है कि कई अन्य अच्छे विकल्प हैं जो अभी भी गणित संकेतन की तरह दिखते हैं।

मुझे लगता है कि t(A) सबसे अच्छा हो सकता है, लेकिन एक और एक अक्षर का नाम "चोरी" करना दुर्भाग्यपूर्ण है।

मेरी टिप्पणी को दूसरे मुद्दे से आगे बढ़ाना (ऐसा नहीं है कि यह कुछ भी हल करता है, लेकिन ...):

+1 .' के अलावा किसी और चीज़ का उपयोग करने के लिए।

मुझे ट्रांसपोज़िशन के लिए एक विशेष सिंटैक्स वाली भाषाएँ नहीं मिलीं, सिवाय एपीएल को छोड़कर जो स्पष्ट नहीं है ⍉ , और पायथन जो *X (जो जूलिया के लिए भ्रमित करने वाला होगा) का उपयोग करता है। कई भाषाएं transpose(X) का उपयोग करती हैं; आर t(X) का उपयोग करता है। यह सुंदर नहीं है, लेकिन यह .' से भी बदतर नहीं है। कम से कम आप ' को .' के साथ भ्रमित करके उपयोग करने के लिए कम लुभाते हैं: यह स्पष्ट होगा कि ये बहुत अलग ऑपरेशन हैं।

रोसेटा कोड देखें। (बीटीडब्लू, जूलिया उदाहरण वास्तव में संयुग्मित स्थानांतरण दिखाता है ...)

क्या अन्य टिकों में से एक का उपयोग किया जा सकता है? ` या "

-100 को बदलने के लिए, क्योंकि यह उन भयानक चीजों में से एक है जो जूलिया कोड को गणित लिखने के रूप में स्पष्ट बनाता है, साथ ही conjugate transpose आमतौर पर आप वैसे भी चाहते हैं, इसलिए इसके लिए एक संक्षिप्त वाक्यविन्यास होना समझ में आता है।

जब तक हमारे पास संयुग्मित स्थानांतरण के लिए अच्छा वाक्यविन्यास है, नियमित रूप से स्थानांतरण के लिए एक पोस्टफिक्स ऑपरेटर अधिकतर अनावश्यक लगता है, इसलिए इसे नियमित फ़ंक्शन कॉल होने पर मुझे ठीक लगता है। transpose पहले से ही काम कर रहा है; क्या हम इसका इस्तेमाल नहीं कर सकते? मुझे t(x) R-ism दुर्भाग्यपूर्ण लगता है, क्योंकि यह नाम से स्पष्ट नहीं है कि इसे वास्तव में क्या करना चाहिए।

एक अलग टिक का उपयोग करना अजीब होगा, उदाहरण के लिए A` फ़ॉन्ट के आधार पर $# A' 3$#$ जैसा दिख सकता है, और A" A'' $ जैसा दिखता है .

यदि हम #20978 में परिवर्तन करते हैं, तो एक पोस्टफिक्स ट्रांसपोज़ वास्तव में अब की तुलना में अधिक उपयोगी हो जाता है। उदाहरण के लिए यदि आपके पास दो वैक्टर x और y हैं और आप उन पर f युग्म के अनुसार लागू करना चाहते हैं, तो आप ऐसा कर सकते हैं जैसे f.(x, y.') ... #20978 के साथ , यह मनमाना प्रकार के सरणियों पर लागू होगा।

ईमानदारी से, मुझे लगता है कि हमारा सबसे अच्छा विकल्प अभी भी इसे वैसे ही छोड़ना है। कोई भी सुझाव मुझे स्पष्ट सुधार जैसा नहीं लगता। .' को मैटलैब से परिचित होने का लाभ है। . वास्तव में f.(x, y.') जैसे उदाहरणों में डॉट-कॉल सिंटैक्स के साथ कुछ हद तक अनुरूप है, और सुझाव देता है (कुछ हद तक सही) कि ट्रांसपोज़ "फ़्यूज़" (यह RowVector के लिए अस्थायी प्रतिलिपि नहीं बनाता है धन्यवाद

वास्तव में, हम इसे और आगे ले जा सकते हैं, और f.(x, g.(y).') एक फ्यूज़िंग ऑपरेशन बना सकते हैं। यानी हम .' को गैर-पुनरावर्ती ala #20978 में बदलते हैं और हम अन्य नेस्टेड डॉट कॉल के साथ फ्यूजन को शामिल करने के लिए इसके शब्दार्थ का विस्तार करते हैं। (यदि आप गैर-फ़्यूज़िंग संस्करण चाहते हैं, तो आप transpose पर कॉल करेंगे।)

मुझे वह योजना बहुत पसंद है, @stevengj।

एक शिकन: संभवतः @. मैक्रो y' को y.' में नहीं बदलता है (क्योंकि यह गलत होगा)। हालाँकि, यह y' को किसी प्रकार के फ़्यूज्ड एडजॉइंट ऑपरेशन में बदल सकता है।

मुख्य समस्या f.(x, g.(y).') को फ़्यूज़िंग सेमेन्टिक्स बनाने का एक साफ तरीका ढूंढ रही है। एक संभावना यह होगी कि इसे f.(x, g.(y.')) में बदल दिया जाए और इसलिए broadcast(x,y -> f(x, g(y)), x, y.') ?

ध्यान दें, इसके लिए ठीक से काम करने के लिए, हमें फ़ॉलबैक transpose(x) = x पद्धति को पुनर्स्थापित करने की आवश्यकता हो सकती है, इस स्थिति में हम स्थानांतरण को पुनरावर्ती रहने दे सकते हैं।

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

@StefanKarpinski , यदि फॉलबैक transpose(x) = x को पुनर्स्थापित करता है, तो इसे गैर-पुनरावर्ती होने के लिए बदलने की अधिकांश प्रेरणा दूर हो जाती है।

यदि फ़ॉलबैक को पुनर्स्थापित किया जाता है तो समस्या क्या है लेकिन हमारे पास अभी भी स्थानांतरण गैर-पुनरावर्ती है?

@jebej , रिकर्सिव ट्रांसपोज़ अधिक सही होता है जब इसे रैखिक ऑपरेटरों पर गणितीय ऑपरेशन के रूप में उपयोग किया जाता है। अगर मुझे ठीक से याद है, तो इसे गैर-पुनरावर्ती बनाने का मुख्य कारण यह था कि हमें MethodError को फेंकने के बजाय transpose(x) = x फ़ॉलबैक को परिभाषित करने की आवश्यकता नहीं है।

लेकिन फॉलबैक होना भयानक नहीं होगा लेकिन फिर भी गैर-पुनरावर्ती होगा।

मुझे दो टिप्पणियां जोड़ने दें (मैंने पिछली चर्चा को देखा है और उन पर ध्यान नहीं दिया है - क्षमा करें अगर मैंने कुछ छोड़ा है):

• permutedims के लिए प्रलेखन कहता है कि यह बहु-आयामी सरणियों के लिए स्थानांतरण का एक सामान्यीकरण है। transpose फ़ंक्शन के सामान्यीकरण को पढ़ने का सुझाव देता है, जो यह नहीं है।
• किसी को सदिश x=["a", "b"] का स्थानान्तरण कैसे करना चाहिए? वास्तव y=x.' काम करता है और एक नया चर बनाता है लेकिन getindex उस पर विफल रहता है। AFAIK आपको इसे प्राप्त करने के लिए reshape(x, 1, :) या बहुत धीमी hcat(x...) का उपयोग करना होगा लेकिन Vector ( permutedims के लिए एक अलग वाक्यविन्यास होना अप्राकृतिक है यहां काम नहीं करता है )

तारों के वेक्टर को स्थानांतरित करने के लिए आपका उपयोग केस क्या है?

उदाहरण के लिए निम्नलिखित परिदृश्य पर विचार करें:

x = ["$(j+i)" for j in 1:3, i in 1:5]
y = ["$i" for i in 5:9]

और मैं y की अंतिम पंक्ति के बाद x जोड़ना चाहता हूं। और सबसे आसान तरीका है vcat का स्थानांतरण y ।

अभ्यास में आता है जब पाठ डेटा को Matrix{String} (मैं Vector{Vector{String}} का उपयोग कर सकता हूं) में वृद्धिशील रूप से लॉगिंग करता हूं, लेकिन अक्सर मैट्रिक्स अधिक उपयोगी होता है (या फिर एक प्रश्न है कि Vector{Vector{String}} को कैसे परिवर्तित किया जाए Matrix{String} लगातार तत्वों को लंबवत रूप से जोड़कर)।

एक अन्य उपयोग-मामला: कार्टेशियन उत्पाद ( f.(v, w.') ) पर एक फ़ंक्शन प्रसारित करने के लिए ट्रांसपोज़िंग दो वैक्टर को एक दूसरे के लिए ऑर्थोगोनल बनाने का सबसे आसान तरीका है।

डेटा बिंदु: कल मुझे पोस्टफ़िक्स "ब्रॉडकास्ट-एडजॉइंट" ऑपरेटर द्वारा भ्रमित एक पार्टी का सामना करना पड़ा और यह ट्रांसपोज़ की तरह क्यों व्यवहार करता है। श्रेष्ठ!

एफडब्ल्यूआईडब्ल्यू, मुझे दृढ़ता से लगता है कि हमें .' सिंटैक्स से छुटकारा पाना चाहिए। जैसा कि कोई मैटलैब की तुलना में जूलिया से अधिक परिचित है, मुझे उम्मीद है कि इसका मतलब वेक्टरकृत आसन्न होगा और जब ऐसा नहीं हुआ तो मैं वास्तव में फिसल गया। जूलिया मतलाब नहीं है और मैटलैब के सम्मेलनों से बाध्य नहीं होना चाहिए - यदि जूलिया में, एक बिंदु का अर्थ आसन्न फ़ंक्शन का वेक्टरकरण है, तो यह भाषा भर में सुसंगत होना चाहिए और यादृच्छिक रूप से एक भयानक अपवाद नहीं होना चाहिए कि .' औपचारिक रूप से ' से असंबंधित है।

मुझे लगता है कि बिना किसी विशेष "टिक" नोटेशन के केवल transpose होना ठीक है, क्योंकि अधिकांश समय, इसे वास्तविक संख्याओं के मैट्रिक्स पर बुलाया जाता है, इसलिए ' बराबर होगा यदि आप वास्तव में टाइपिंग को सहेजना चाहते हैं। अगर हम ट्रांसपोज़ का फ़्यूज़िंग संस्करण बनाना चाहते हैं, तो मुझे नहीं लगता कि .' सही सिंटैक्स है।

ये एक अच्छा बिंदु है। तर्कसंगत रूप से केवल आसन्न को सुपर-कॉम्पैक्ट सिंटैक्स की आवश्यकता होती है।

आइए बस इसे transpose कहते हैं और .' को हटा दें। भविष्य में, हम विचार कर सकते हैं कि क्या हम .' को बिंदुवार सहायक के रूप में चाहते हैं या यदि हम मैटलैब उपयोगकर्ताओं को फँसाने से बचने के लिए इसे केवल स्थायी-पदावनत छोड़ना चाहते हैं।

ध्यान दें कि मैंने अभी पंजीकृत पैकेजों को पकड़ लिया है और .' के 600+ उपयोग पाए हैं, इसलिए यह बहुत दुर्लभ नहीं है। और डॉट कॉल / broadcast (जो केवल 0.6 में गैर-संख्यात्मक डेटा को पूरी तरह से संभालना शुरू कर दिया) के साथ, गैर-संख्यात्मक सरणी (जहां आसन्न कम समझ में आता है) को आलसी रूप से स्थानांतरित करने की इच्छा शायद अधिक सामान्य हो जाएगी, इसलिए एक कॉम्पैक्ट सिंटैक्स के लिए तर्क कुछ हद तक मजबूत होता है।

फिर हम बेहतर तरीके से .' को जल्द से जल्द हटा देंगे, इससे पहले कि अधिक कोड खराब उपयोग पैटर्न में फंस जाए।

यह बुरा क्यों है?

समस्या यह है कि .' अब इसका मतलब यह नहीं है कि डॉटेड ऑपरेटर के रूप में इसका क्या अर्थ है।

जैसा कि मैंने ऊपर कहा, क्योंकि यह सामान्य पैटर्न का उल्लंघन करता है कि . का अर्थ वैश्वीकरण है, और ऐसा लगता है कि इसका अर्थ वेक्टरकृत आसन्न है (विशेषकर किसी ऐसे व्यक्ति के लिए जो मैटलैब से परिचित नहीं है)।

मुझे लगता है कि @stevengj एक अच्छा मुद्दा बनाता है - यह एक साधारण गैर-पुनरावर्ती स्थानान्तरण की इच्छा से जुड़ा हुआ है।

मुझे पता है कि यह अलोकप्रिय था, लेकिन मैं ᵀ के लिए एंड्रियास के #19344 का पक्ष लेना शुरू कर रहा हूं। इस बिंदु पर, मैं पहचानकर्ता के रूप में _all_ सुपरस्क्रिप्ट के उपयोग को हटाने का पक्ष लेता हूं, और _any_ अनुगामी सुपरस्क्रिप्ट को पोस्टफिक्स ऑपरेटर के रूप में व्याख्या करता हूं। यह सुपरस्क्रिप्ट संख्याओं का उपयोग करके literal_pow के आसपास की कुछ गड़बड़ियों को हल करने की दिशा में भी एक मार्ग प्रदान करता है। हां, χ² और जैसे चर नामों को खोना दुखद होगा, लेकिन मुझे लगता है कि लाभ डाउनसाइड्स से अधिक होगा।

इस बिंदु पर, मैं पहचानकर्ता के रूप में _all_ सुपरस्क्रिप्ट के उपयोग को हटाने का पक्ष लेता हूं, और _any_ अनुगामी सुपरस्क्रिप्ट को पोस्टफिक्स ऑपरेटर के रूप में व्याख्या करता हूं।

मेरा कोड रिप करें

इस बिंदु पर, मैं पहचानकर्ता के रूप में सभी सुपरस्क्रिप्ट के उपयोग को बंद करने का पक्ष लेता हूं

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

एक मूर्खतापूर्ण संगति ...

हां, स्थानांतरण के लिए .' का उपयोग करना थोड़ा असंगत है, लेकिन अब तक प्रस्तावित सभी विकल्प बदतर प्रतीत होते हैं। यह कहना दुनिया में सबसे बुरी बात नहीं है " .' ट्रांसपोज़ है, डॉट ऑपरेटरों के बारे में सामान्य नियम का अपवाद।" आप इसे सीखें और आगे बढ़ें।

एक बात ध्यान देने योग्य है कि .' पर डॉट ब्रॉडकास्ट नहीं होने पर किसी भी संभावित भ्रम में मदद मिल सकती है, यह एक पोस्टफिक्स ऑपरेटर है, जबकि प्रीफिक्स ब्रॉडकास्टिंग op. है और इंफिक्स .op है। तो हम कह सकते हैं कि . का मतलब प्रसारण नहीं है जब यह पोस्टफिक्स हो। पोस्टफ़िक्स . का अन्य उपयोग फ़ील्ड लुकअप है, और getfield(x, ') का कोई मतलब नहीं है, इसलिए यह अन्य अर्थों से अलग है।

(उस ने कहा, मैं $# .' transpose(x) पक्ष लेता हूं।)

@stevengj मैं शर्त लगाता हूं कि आपके द्वारा ऊपर उल्लिखित पंजीकृत पैकेजों में .' के 600+ उपयोगों में से कई (शायद अधिकांश) पठनीयता के लिए बिना किसी कीमत के ' द्वारा प्रतिस्थापित किए जा सकते हैं, और कोड काम करना जारी रखेंगे।

संभवत: लोकप्रिय नहीं है, लेकिन अभी भी पोस्टफिक्स " और ` हो सकता है?

का उपयोग करता है।' आपके द्वारा ऊपर उल्लिखित पंजीकृत पैकेजों में 'बिना किसी कीमत के पठनीयता' से प्रतिस्थापित किया जा सकता है, और कोड काम करना जारी रखेगा।

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

वहाँ अभी भी पोस्टफ़िक्स हो सकता है "और `?

transpose() के लिए नया सिंटैक्स समय से पहले जैसा लगता है। आईएमएचओ केवल .' को प्रतिस्थापित करने के लिए बेहतर होगा जैसा कि आप आवश्यकतानुसार conj(x') और transpose के साथ सुझाव देते हैं।

मुझे लगता है कि .' मैटलैब में मुख्य रूप से मैटलैब आग्रह के कारण इतना उपयोगी है कि सुसंगत स्लाइसिंग नियमों की कमी के साथ "सब कुछ एक मैट्रिक्स है" जैसे कि आपको अक्सर विभिन्न स्थानों में यादृच्छिक ट्रांसपोज़ डालने की आवश्यकता होती है काम करने के लिए चीजें प्राप्त करें।

यहाँ तर्कों को संक्षेप में प्रस्तुत करने के लिए:

1. .' अब एक डॉटेड ऑपरेटर के रूप में अकेला स्टैंडआउट है जिसका मतलब यह नहीं है कि "अनडॉटेड ऑपरेटर एलिमेंटवाइज लागू करें"; मैटलैब से नहीं आने वाले नए उपयोगकर्ताओं को यह एक आश्चर्यजनक जाल लगता है।

2. .' अब प्रभावी रूप से अस्पष्ट है: क्या आपका मतलब transpose था या आपका मतलब conj(x') था? सिद्धांत रूप में, .' के प्रत्येक विरासत उपयोग को यह निर्धारित करने के लिए पुनरीक्षित किया जाना चाहिए कि क्या यह 2-आयामी सरणी के सूचकांकों को अनुमति दे रहा है या क्या यह "असंयुग्मित सहायक" कर रहा है।

पहला मुद्दा समस्याग्रस्त है लेकिन अपने आप में घातक नहीं है; दूसरा मुद्दा वास्तव में खराब है - यह अब एक एकल सुसंगत संचालन नहीं है, बल्कि इसे दो अलग-अलग अर्थों में विभाजित किया जाएगा।

मैंने अभी देखा है कि अगर हमने कभी भी .' को "एलिमेंटवाइज एडजॉइंट" में बदल दिया है, तो conj(x') मोटे तौर पर x'.' के बराबर होगा और conj(x)' मोटे तौर पर x.'' होगा x.' के बहुत करीब है।

संभवत: लोकप्रिय नहीं है, लेकिन फिर भी पोस्टफिक्स "और `?

पेस्टिंग कोड को स्लैक में कॉपी करें और देखें कि सिंटैक्स हाइलाइटिंग को नष्ट करना होगा ...

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

मैं यहां दो बहुत ही संबंधित चीजें देखता हूं:

1) x' गैर-संख्या प्रकारों के लिए काम नहीं करता है, इसलिए हम अन्य डेटा के लिए इसे आसानी से करने का एक तरीका चाहते हैं
2) transpose(x) x.' जितना आसान नहीं है। यह ज्यादातर (1) के मामलों के लिए है, क्योंकि जटिल मैट्रिसेस को स्थानांतरित करने के लिए उपयोग के मामले बहुत अधिक दुर्लभ हैं।

लेकिन नीचे जाने के बजाय (2), क्यों न कोशिश करें और (1) के लिए उचित सुधार करें?

हो सकता है कि एक उचित फिक्स सिर्फ एक मैक्रो है जो ' को आसन्न के बजाय स्थानांतरित करता है?

लेकिन नीचे जाने के बजाय (2), क्यों न कोशिश करें और (1) के लिए उचित सुधार करें?

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

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

अंत में, जबकि मैं दृढ़ता से महसूस करता हूं कि permutedims(x, (2, 1)) निश्चित रूप से 2d सरणी के आयामों को स्वैप करने के लिए बहुत असुविधाजनक है, मुझे यह तर्क मिलता है कि transpose(x) बहुत असुविधाजनक है। क्या यह ऑपरेशन इतना सामान्य है कि इसके लिए एक सरल, स्पष्ट फ़ंक्शन नाम होना बहुत अधिक है? सच में? क्या किसी सरणी के आयामों की अदला-बदली करना भाषा में अन्य सभी चीजों की तुलना में बहुत अधिक सामान्य या महत्वपूर्ण है जिसके लिए हम फ़ंक्शन नाम और फ़ंक्शन कॉल सिंटैक्स का उपयोग करते हैं? हाउसहोल्डर नोटेशन adjoint काफी खास बनाता है क्योंकि हम v'v , v*v' और v'A*v जैसी चीजें लिखना चाहते हैं। इसलिए adjoint को वास्तव में अच्छा सिंटैक्स मिलता है। लेकिन एक सरणी के आयामों की अदला-बदली? यह मेरी राय में एक ऑपरेटर को वारंट नहीं करता है।

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

मैंने https://github.com/JuliaLang/julia/pull/19344#issuecomment -261621763 पर कुछ सिंटैक्स विचारों पर टिप्पणी की थी, मूल रूप से यह था:

julia> const ᵀ, ᴴ = transpose, ctranspose;

julia> for op in (ᵀ, ᴴ)
           <strong i="7">@eval</strong> Base.:*(x::AbstractArray{T}, f::typeof($op)) where {T<:Number} = f(x)
       end

julia> A = rand(2, 2)
2×2 Array{Float64,2}:
 0.919332  0.651938
 0.387085  0.16784

julia>  Aᵀ = (A)ᵀ    # variable definition and function application are both available!
2×2 Array{Float64,2}:
 0.919332  0.387085
 0.651938  0.16784

julia> Aᴴ = (A)ᴴ
2×2 Array{Float64,2}:
 0.919332  0.387085
 0.651938  0.16784

लेकिन निश्चित रूप से हैक के बिना, केवल यह विचार कि "पोस्टफिक्स फ़ंक्शन एप्लिकेशन" हो सकता है और यह (x)f कोष्ठक की मांग करता है, बिंदीदार संस्करण इस तरह हो सकते हैं (x).f ( xf एक पहचानकर्ता होगा, यहां तक ​​​​कि f एक सुपरस्क्रिप्ट प्रतीक होने के बावजूद)।

यह उदाहरण हैक 0.6 पर काम करता था लेकिन अब:

julia> Aᵀ = (A)ᵀ               
ERROR: syntax: invalid operator

julia> Aᵀ = (A)transpose       
2×2 Array{Float64,2}:          
 0.995848  0.549117            
 0.69401   0.908227            

julia> Aᴴ = (A)ᴴ               
ERROR: syntax: invalid operator

julia> Aᴴ = (A)ctranspose      # or adjoint or whatever
2×2 Array{Float64,2}:          
 0.995848  0.549117            
 0.69401   0.908227            

जो दुख की बात है, मैं मूल रूप से शक्तियों के लिए ऐसा करना चाहता था:

julia> square(n) = n^2; cube(n) = n^3;

julia> Base.:*(n, f::typeof(square)) = f(n)

julia> Base.:*(n, f::typeof(cube)) = f(n)

julia> const ² = square    # why?
syntax: invalid character "²"

julia> const ³ = cube    # why?
syntax: invalid character "³"

जो मैंने भोलेपन से सोचा था कि सिंटैक्स को सक्षम करेगा जैसे: n² = (n)² और n³ = (n)³ लेकिन किसी भी तरह के संख्यात्मक पहचानकर्ता को पहले स्थान पर होने से प्रतिबंधित कर दिया गया है, हालांकि (A)⁻¹ ने भी काम किया, जहां ⁻¹ const ⁻¹ = inv था।

मैंने InfixFunctions.jl के लिए एक समान हैक लागू किया है।

एक उपयोगकर्ता के रूप में मैं सिर्फ PostfixFunctions.jl पैकेज कर सकता था, और जो कुछ भी आपको यहां सबसे अच्छा लगता है उससे खुश रहें। लेकिन वर्तमान में यह वाक्यविन्यास प्रतिबंध:

• किसी पहचानकर्ता की शुरुआत में संख्यात्मक सुपरइंडिस का उपयोग करने की अनुमति नहीं है
• सुपरइंडेक्स x * ᶠ पोस्टफिक्स में (हैक में निहित गुणन) (x)ᶠ की अनुमति नहीं है

मुझे आईएमएचओ के लिए थोड़ा सा लगता है, मैं कम से कम पहचानकर्ताओं को परिभाषित करने में सक्षम होना चाहता हूं जो संख्यात्मक सुपरस्क्रिप्ट के साथ शुरू हो सकते हैं, या अधिक आम तौर पर, केवल वास्तविक संख्यात्मक वर्णों को 0-9 संख्या अर्थशास्त्र के साथ अस्वीकार कर सकते हैं, एक की शुरुआत में पहचानकर्ता, यह बहुत अच्छा होगा। मैं

चीयर्स!

पहचानकर्ता के रूप में अन्य संख्या वर्णों की कुछ चर्चा के लिए #10762 देखें।

दूसरा मुद्दा #22089, ऑपरेटर प्रत्यय से संबंधित है। +ᵀ अब एक वैध ऑपरेटर है, जिसने (शायद गलती से) पहचानकर्ताओं को अस्वीकार कर दिया है जिसमें केवल उन संदर्भों में वर्णों का संयोजन होता है जहां एक ऑपरेटर की उम्मीद की जा सकती है। यह मेरे लिए एक बग की तरह लगता है। यह भी थोड़ा अजीब है कि ᵀ एक वैध पहचानकर्ता है लेकिन -ᵀ ऐसा नहीं करता है -(ᵀ) । हालांकि यह दुनिया का अंत नहीं है, और आईएमओ इसे ठीक करना ᵀ के अन्य संभावित उपयोगों को खोने के लायक नहीं होगा।

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

@ इस्माइल-वीसी, मैं सुपरस्क्रिप्ट के लिए पोस्टफिक्स फ़ंक्शन सिंटैक्स के रूप में (x)ᵀ की अनुमति देख सकता हूं - क्योंकि इसका और क्या अर्थ होगा? मुझे लगता है कि आपका प्रस्ताव लोगों को गलत तरीके से रगड़ना शुरू कर देता है जिससे किसी भी पहचानकर्ता को पोस्टफिक्स सिंटैक्स में फ़ंक्शन के रूप में लागू करने की इजाजत मिलती है। मैं इसे सुपरस्क्रिप्ट तक सीमित रखूंगा।

@StefanKarpinski , मैंने सोचा था कि सर्वसम्मति .' मतलब गैर-पुनरावर्ती, गैर-संयुग्मित सरणी ट्रांसपोज़िशन (यदि हमारे पास यह ऑपरेटर है) की अनुमति देने के लिए सटीक था, जबकि ' पुनरावर्ती, संयुग्म है संयुक्त संचालन।

मैं वास्तव में, पोस्टफिक्स ट्रांसपोज़ ऑपरेटर के लिए ᵀ का उपयोग करने के विचार से वास्तव में नफरत करता हूं। चर नामों में सुपरस्क्रिप्ट के रूप में होना बहुत उपयोगी है , जैसे aᵀa या LᵀDL = ltdlfact(A) । (इस तथ्य के अलावा कि एक ऑपरेटर के लिए केवल ᵀ का उपयोग करना जबकि अन्य सुपरस्क्रिप्ट पहचान में मान्य हैं, अजीब होगा।)

यह मेरी समझ में बिल्कुल नहीं था - मैंने सोचा था कि लिनालग लोग a.' को यथावत रखने के पक्ष में थे, अर्थात conj(a)' । .' रखना लेकिन इसका अर्थ सरणी स्थानान्तरण में बदलना काफी अलग है - मुझे यकीन नहीं है कि मैं इसके बारे में कैसा महसूस करता हूं। मैं सहमत हूं कि पोस्टफिक्स ऑपरेटर के रूप में केवल ᵀ का होना कष्टप्रद और असंगत होगा। हालांकि, मुझे @ इस्माइल-वीसी का (a)ᵀ प्रस्ताव पसंद है, जो एक नाम के रूप में aᵀ का उपयोग करने से नहीं रोकेगा।

उन चर्चाओं की मेरी याददाश्त स्टीवन की है। पुनरावर्ती, गैर-संयुग्मित स्थानान्तरण दुर्लभ और आम तौर पर बहुत अजीब है। यहाँ अच्छा सारांश: https://github.com/JuliaLang/julia/issues/20978#issuecomment -316141984।

मुझे लगता है कि हम सभी सहमत हैं कि पोस्टफिक्स ' आसन्न है और रहना चाहिए।
मुझे लगता है कि हम सभी सहमत हैं कि पोस्टफ़िक्स .' सबऑप्टिमल सिंटैक्स है।
मुझे लगता है कि अधिकांश सहमत हैं कि गैर-पुनरावर्ती (संरचनात्मक) स्थानांतरण एक पुनरावर्ती स्थानान्तरण से अधिक उपयोगी है।

ठीक है, इसलिए जिन बिंदुओं पर सभी सहमत हैं:

1. a' के लिए adjoint(a) उपयोग करें
2. conj(a)' या conj(a') का उपयोग (गैर-) संयुग्मित जोड़ के लिए करें।

तो विवाद का एकमात्र बिंदु यह है कि सरणी स्थानान्तरण कैसे लिखा जाए:

• a.' या . के रूप में
• transpose(a) या . के रूप में
• (a)ᵀ के रूप में।

क्या यह आकलन सही है?

हां, मुझे ऐसा लगता है (जहां "सरणी स्थानांतरण" गैर-पुनरावर्ती है)।

साथ ही, जैसा कि मैं इसे समझता हूं, हर कोई सहमत है कि transpose(a) निश्चित रूप से वैध वाक्यविन्यास (और गैर-पुनरावर्ती) होना चाहिए, और असहमति का एकमात्र बिंदु यह है कि .' और/या (a)ᵀ वैकल्पिक (पूरी तरह से समकक्ष) वैध वाक्यविन्यास होना चाहिए।

दृष्टिकोण (1) https://github.com/JuliaLang/julia/issues/20978#issuecomment -315902532 से, जिसे अच्छा समर्थन मिला (जैसे https://github.com/JuliaLang/julia/issues/20978# निर्गमन-316080448), एक संभावना बनी हुई है। मेरे पास उस दृष्टिकोण को समझने वाली एक शाखा है ( flip(A) पेश करना) जिसे मैं पोस्ट कर सकता हूं।

इसके लायक क्या है, मैं .' बहिष्कृत करने का समर्थन करता हूं। इस सूत्र में भ्रम और अस्पष्टता अपने आप में ऐसा करने का एक मजबूत तर्क है। श्रेष्ठ!

मेरा मानना ​​है कि जब तक हमारे पास पोस्टफिक्स ' है, तब तक लोग इसका उपयोग f को f.(v, w') के साथ वैक्टर के कार्टेशियन उत्पाद पर प्रसारित करने के लिए करना चाहते हैं। और लोग टेबल-जैसी संरचना के लिए हेडर के पंक्ति-वेक्टर में स्ट्रिंग्स के वेक्टर को दोबारा बदलने के लिए इसका उपयोग करना चाहते हैं। तो यह मेरे लिए एक सरल और उपयोग में आसान प्रतिस्थापन के लिए मजबूर कर रहा है जिसे हम उन्हें निर्देशित कर सकते हैं।

यहां एक विकल्प है जिस पर हमने विचार नहीं किया है: A*' — एक नया जीवनवृत्त। विशिष्ट गणित संकेतन इसकी व्याख्या conj(A)' के रूप में कर सकता है, जो वास्तव में हम जो चाहते हैं उसके बहुत करीब है। यह 0.6 पर उपलब्ध था, लेकिन 0.7 पर हम वर्णों को जोड़ने के लिए * का उपयोग करने की अनुमति देते हैं ...

मुझे विश्वास नहीं है कि पोस्टफिक्स " और ` एक पंक्ति के अंत से परे कस्टम स्ट्रिंग अक्षर पार्सिंग के कारण उपलब्ध हैं। पोस्टफिक्स * अपने आप में भी इसी कारण से अनुपलब्ध है। पोस्टफिक्स प्राइम A′ शायद सबसे अधिक इस्तेमाल किए जाने वाले यूनिकोड पहचानकर्ताओं में से एक है, इसलिए यह Aᵀ से भी अधिक है।

ईमानदारी से, मेरे कोड को देखने के बाद, मैं .' का उपयोग बिल्कुल नहीं करता, इसलिए transpose(a) शायद ठीक है।

ध्यान दें कि मैंने अभी पंजीकृत पैकेजों को पकड़ लिया है और .' के 600+ उपयोग पाए हैं, इसलिए यह बहुत दुर्लभ नहीं है।

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

<strong i="17">@transpose</strong> A = A'*A*B'*B*C'*C

उस दुर्लभ मामले के लिए मेरे साथ ठीक रहेगा।

लोग f.(v, w') के साथ वैक्टर के कार्टेशियन उत्पाद पर f प्रसारित करने के लिए इसका उपयोग करना चाहते हैं। और लोग टेबल-जैसी संरचना के लिए हेडर के पंक्ति-वेक्टर में स्ट्रिंग्स के वेक्टर को दोबारा बदलने के लिए इसका उपयोग करना चाहते हैं। तो यह मेरे लिए एक सरल और उपयोग में आसान प्रतिस्थापन के लिए मजबूर कर रहा है जिसे हम उन्हें निर्देशित कर सकते हैं।

यदि यह कथन में केवल एक बार दिखाई देता है, तो क्या केवल transpose का उपयोग करना ठीक नहीं है?

conjugate-adjoint के लिए a*' सिंटैक्स बहुत अच्छा है, हालांकि यह वास्तव में ऐसा नहीं लगता है कि ऑपरेशन के लिए हमें एक बेहतर सिंटैक्स की आवश्यकता है। &a जल्द ही उपलब्ध होगा और चीजों की अदला-बदली का सुझाव देता है, हालांकि यह इसके लिए पारंपरिक नोटेशन से काफी अलग है।

शायद यह एक स्ट्रॉ पोल का समय है?

हमें संरचनात्मक स्थानान्तरण कैसे करना चाहिए?

(मोटे तौर पर प्रस्ताव के क्रम में; यहां इमोजी नामों पर कोई निर्णय नहीं है)

• : A.' — बस अर्थ बदलें, वाक्य रचना वही रखें
• : transpose(A) — कोई विशेष सिंटैक्स नहीं
• : t(A) या tr(A) — कोई विशेष सिंटैक्स नहीं है, लेकिन एक छोटा नाम निर्यात करें
• : Aᵀ — केवल ᵀ के साथ और शायद एक या दो सुपरस्क्रिप्ट पहचानकर्ताओं से विशेष-आवरण
• : (A)ᵀ - सभी सुपरस्क्रिप्ट के साथ पहचानकर्ताओं से अलग पोस्टफिक्स ऑपरेटरों की तरह व्यवहार कर रहे हैं
• ❤️: A*' - उस अलौकिक घाटी के ठीक ऊपर चमक, इसका अर्थ है एक संरचनात्मक स्थानान्तरण
• यदि आप &A पसंद करते हैं, तो तुरंत ऊपर स्टीफन की पोस्ट पर एक फेंक दें (हम इमोजी से बाहर हैं)

LinAlg चर्चाओं ने वास्तव में .’ को गैर-पुनरावर्ती हस्तांतरण उपयोग के लिए उपहार देने के बारे में बात की, क्योंकि conj(x’) अपेक्षाकृत असामान्य है। हालांकि ᵀ गणितीय वाक्यविन्यास है और वास्तव में गणितीय अर्थ लेना चाहिए (यदि कुछ भी)।

tr(A) माध्य मैट्रिक्स ट्रांसपोज़ करने का बहुत पुरजोर विरोध - हर कोई यह सोचने वाला है कि इसका अर्थ मैट्रिक्स ट्रेस है: https://en.wikipedia.org/wiki/Trace_ (linear_algebra)

यदि सुपरस्क्रिप्ट को पहचानकर्ता के रूप में पदावनत नहीं किया जाता है (जिस पर संभवतः 1.0 से पहले गंभीरता से विचार किया जाना है) तो ᵀ(A) भी संभावना है।

सुझाव के संबंध में (A)ᵀ , निम्नलिखित टिप्पणी के साथ इस चर्चा को थोड़ा पटरी से उतारने के लिए मेरी क्षमायाचना:

मैंने कभी भी √ को यूनरी ऑपरेटर के रूप में उपलब्ध कराने के लिए बहुत अधिक परवाह नहीं की है, खासकर जब से आप किसी भी तरह से √(...) टाइप करना समाप्त कर देंगे जैसे ही आप इसे एक से अधिक चर पर लागू करना चाहते हैं एक या कुछ वर्ण। इसके अलावा, मैंने हमेशा a² और √a के बीच काम करने में बहुत ही कृत्रिम अंतर पाया है। यह शायद समझ में आता है यदि आप यूनिकोड कक्षाओं आदि के बारे में जानते हैं, लेकिन किसी और को यह बेतुका लगता है। निश्चित रूप से एक वैध चर नाम के रूप में a² $ होना उपयोगी है, लेकिन इसी तरह √a a के वर्गमूल को संग्रहीत करने के लिए एक उपयोगी चर नाम हो सकता है यदि आपको इसे कई उपयोग करने की आवश्यकता है बार। या अधिक जटिल अभिव्यक्तियां जैसे a²b और इसका वर्गमूल a√b , जहां पूर्व एक मान्य पहचानकर्ता है और बाद वाला नहीं है। सबसे बढ़कर, मुझे निरंतरता पसंद है।

तो निरंतरता के लिए, मुझे यूनिकोड यूनरी ऑपरेटर √ (और उसके रिश्तेदारों) को हटाने के साथ संयोजन में (A)ᵀ , (a)² कोष्ठक का उपयोग करते समय पोस्टफिक्स ऑपरेटर रखने का प्रस्ताव पसंद है ताकि इसका उपयोग पहचानकर्ताओं में भी किया जा सकता है (जबकि सामान्य फ़ंक्शन कॉल के रूप में अभी भी सुलभ है √(a) )।

@Jutho ने जो कहा उससे मैं 100% सहमत हूं और कई मौकों पर इस पर विचार किया है। क्या आप @Jutho कोई मुद्दा खोलना चाहेंगे? प्रस्ताव: पहचानकर्ता नामों में √ की अनुमति दें, op के रूप में कॉल करने के लिए √(x) की आवश्यकता है।

अगला प्रश्न -> 2 |> √ के बारे में क्या?

आइए एक अन्य सूत्र में √ की चर्चा करें, लेकिन संक्षेप में 2 |> √ का अर्थ है √(2) ।

एक अन्य विकल्प, जिसके लिए पार्सर परिवर्तन की आवश्यकता नहीं होगी और टाइप करना आसान होगा, A^T ट्रांसपोज़ के लिए होगा ( T को ^ विधि के साथ सिंगलटन प्रकार के रूप में परिभाषित करके)। … ओह, मैं देख रहा हूं कि @mbauman के पास भी यह विचार था। यह थोड़ा बदसूरत है, लेकिन A.' से अधिक नहीं है।

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

transpose(A) # with no special syntax ऊपर वोट जीत रहा है, लेकिन मेरी आंखों और उंगलियों के लिए दर्दनाक है।

पायथन में आम उपयोग शायद numpy और बहुत सी चीजें हैं जो निम्न की तरह दिखती हैं और बहुत खराब नहीं हैं:

import numpy as np
# define matrix X of n columns, with m rows of observations
error = X.dot(Theta.T) - Y
gradient = (1 / m) * (X.dot(Theta.T) - Y).T.dot(X)

मैं नहीं करना चाहता:

grad = 1/m * transpose(X * transpose(Theta) - Y)) * X

यह उस सम्मेलन से स्थानांतरण की मानसिक अवधारणा को पूरी तरह से बदल देता है जिस पर गणित संकेतन बस गया है, जो एक पोस्टफिक्स संकेतक है, आमतौर पर Aᵀ या Aᵗ ।

व्यक्तिगत रूप से मैं A' से बहुत खुश हूं जो जूलिया v.0.6 में काम करता है, इससे पहले कि इसे एडजॉइंट द्वारा लिया जाए। क्या एडजॉइंट का इस्तेमाल अक्सर किया जाता है?

यहाँ एक तालिका में मेरी टिप्पणियाँ हैं:

Aᵀ or Aᵗ    if the world won't accept unicode operators, let them use transpose(A)
A'          close to math notation, easy to type and *especially* easy to read
A^'         this could signal `^` not to be parsed as Exponentiation.
A.'         conflicts with dotted operator syntax, but at face value OK
A^T or A^t  these are pretty good, but what if variable `T` is meant to be an exponent? 
A.T         same as numpy, same dotted operator collision
t(A)        nesting reverses semantics, 3 keystrokes and two of them with shift key.
transpose(A) with no special syntax     # please don't do this.

व्यक्तिगत रूप से मैं A' से बहुत खुश हूं जो जूलिया v.0.6 में काम करता है, इससे पहले कि इसे जोड़ा गया। क्या एडजॉइंट का इस्तेमाल अक्सर किया जाता है?

मुझे समझ नहीं आया, A' हमेशा से A का जोड़ रहा है। हम कंजुगेट ट्रांसपोज़ के लिए अंतर्निहित फ़ंक्शन ctranspose को कॉल करते थे, लेकिन हमने कार्यक्षमता में कोई बदलाव किए बिना इसका नाम बदलकर समकक्ष शब्द adjoint कर दिया।

यदि आप रैखिक बीजगणित कर रहे हैं तो आप वैसे भी एक संयुग्मित स्थानांतरण चाहते हैं, इसलिए आप $#$ transpose(A) $#$ के बजाय A' टाइप करेंगे। गैर-संयुग्म हस्तांतरण के लिए एक विशेष वाक्यविन्यास को परिभाषित नहीं करने की लोकप्रियता (संभवतः) इस तथ्य के कारण है कि गैर-संयुग्मित स्थानांतरण के लिए अधिकांश रैखिक बीजगणितीय उपयोगों के लिए यह वास्तव में सामान्य नहीं है।

यदि आप रैखिक बीजगणित कर रहे हैं तो ...

अगर आपका टूल हैमर है तो... :)

... आपको इस संभावना के बारे में सोचना होगा कि जूलिया सामान्य प्रोग्रामिंग भाषा में विकसित हो सकती है।

शायद नहीं, शायद यह रैखिक बीजगणित तर्क के रूप में रहेगा - जो संभावना है कि मुझे मेरे जैसे प्रोग्रामर के बारे में सोचना होगा। :)

@mahiki , आप NumPy उदाहरण हैं:

import numpy as np
# define matrix X of n columns, with m rows of observations
error = X.dot(Theta.T) - Y
gradient = (1 / m) * (X.dot(Theta.T) - Y).T.dot(X)

जूलिया में शाब्दिक रूप से लिखा जाएगा:

error = X*Θ' - Y
gradient = (1/m) * (X*Θ' - Y)' * X

या यह मानते हुए कि वेक्टर उस NumPy उदाहरण में पंक्तियाँ हैं और जूलिया में कॉलम होंगे:

error = X'Θ - Y
gradient = (1/m) * (X'Θ - Y) * X'

जो जितना स्पष्ट और गणितीय लगता है उतना ही लगता है। यदि आपका डेटा वास्तविक है, तो एडजॉइंट और ट्रांसपोज़ एक ही ऑपरेशन हैं, यही वजह है कि आप ऊपर ट्रांसपोज़ का उपयोग कर रहे हैं - लेकिन गणितीय रूप से आसन्न सही ऑपरेशन है। जैसा कि @ararslan ने कहा, X' का मतलब हमेशा जूलिया में adjoint होता है (और मैटलैब में भी)। इसे पहले " conjugate transpose " के लिए ctranspose छोटा कहा जाता था, लेकिन यह नाम एक मिथ्या नाम था क्योंकि ऑपरेटर की परिभाषित संपत्ति यह है कि

dot(A*x, y) == dot(x, A'y)

जो कि हर्मिटियन एडजॉइंट की परिभाषित संपत्ति है, लेकिन जब A एक जटिल मैट्रिक्स है, तो संयुग्मित स्थानान्तरण से संतुष्ट होता है। इसलिए "adjoint" इस ऑपरेटर के लिए सही सामान्य शब्द है।

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

@mahiki अगर किसी कारण से आपको वास्तव में अपने कोड में adjoint $ के बजाय transpose का उपयोग करने की आवश्यकता है, तो आप @t जैसे छोटे मैक्रो को परिभाषित कर सकते हैं जो उपनाम transpose (हालांकि मुझे पता है कि यह समाधान आदर्श नहीं है, खासकर यदि आप अन्य लोगों के साथ अपना कोड लिख रहे हैं)।

आपको इस संभावना के बारे में सोचना होगा कि जूलिया सामान्य प्रोग्रामिंग भाषा में विकसित हो सकती है।

@ लिसो77 यह पहले से ही है। कई उदाहरणों में से एक के रूप में, नैनोसॉल्डियर एक वेब सर्वर चलाता है जो गिटहब घटनाओं को सुनता है और मांग पर प्रदर्शन बेंचमार्क चलाता है, सभी जूलिया में। हालांकि यह एक विषयांतर है, और मैं नहीं चाहता कि यह विषय विषय से हट जाए।

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

यदि आप किसी प्रकार के मैट्रिक्स को गैर-संख्यात्मक डेटा के साथ स्थानांतरित कर रहे हैं - जो एक पूरी तरह से वैध उपयोग का मामला है - गणितीय स्थानान्तरण संकेतन वास्तव में एक खराब वाक्य की तरह लगता है।

चूँकि A.' सामान्य अर्थों में वास्तव में "गणितीय स्थानान्तरण संकेतन" नहीं है, मुझे नहीं लगता कि यह इसके पक्ष या विपक्ष में तर्क है।

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

संदर्भ। https://github.com/JuliaLang/julia/issues/20978#issuecomment -315902532। श्रेष्ठ!

... लेकिन यह ऑपरेशन वास्तव में "स्थानांतरण" नहीं है जैसा कि हम आमतौर पर इसके बारे में सोचते हैं, ...

यदि यह इतना असामान्य है तो अरर्सलान और कई अन्य लोग संरचनात्मक स्थानान्तरण की वर्तनी के लिए transpose(A) के रूप में वोट क्यों करते हैं?

धन्यवाद @StefanKarpinski @ararslan @ttparker। मुझे अपने रैखिक बीजगणित पाठ पर वापस जाना था और आस-पास को फिर से खोजना था, यह सब ठीक है। मैंने इसे कॉम्प्लेक्स एनालिसिस से पहले लिया था, शायद इसलिए मैंने इस पर ध्यान नहीं दिया।

मुझे ऐसा करने में सक्षम होना पसंद है
gradient = (1/m) * (X'Θ - Y) * X'

मेरा भ्रम संदर्भ दस्तावेज़ों, कागजात, पाठ्यपुस्तकों आदि में 'ट्रांसपोज़' (सुपरस्क्रिप्ट टी के रूप में) के व्यापक उपयोग से उत्पन्न होता है, उदाहरण के लिए एंड्रयू एनजी के स्टैनफोर्ड सीएस 229 व्याख्यान नोट्स , जहां संबंधित जूलिया कोड adjoint का उपयोग करेगा ऊपर @StefanKarpinski के साफ-सुथरे उदाहरण में। ऐसा इसलिए है क्योंकि (दाएं?) अद्यतन: हाँ

अब स्थानांतरण के लिए मेरा पसंदीदा अंकन तार्किक रूप से सुसंगत है। स्पष्ट रूप से .' बिंदीदार ऑपरेटर सिंटैक्स के साथ संघर्ष के कारण नहीं है, और मुझे कोई विशेष वाक्यविन्यास के साथ transpose(A) पर कोई आपत्ति नहीं है, क्योंकि यूनिकोड सुपरस्क्रिप्ट को छोड़कर कोई भी विशेष विशेष वाक्यविन्यास उपलब्ध नहीं है।

मुझे @ttparker समाधान पसंद है अगर मैं खुद को बहुत सारे ट्रांसपोज़ लिख रहा हूं, मैक्रो @t जो उपनाम transpose ।

फिर, मुझे यह बताने में गलती हुई:

transpose(A) with no special syntax # please don't do this.

स्नातक स्तर के गणित के साथ मेरी खराब सुविधा के बावजूद मेरी टिप्पणियों को गंभीरता से लेने के लिए धन्यवाद।

( प्रवचन से।)

मैं ' को एक पोस्ट-फिक्स ऑपरेटर बनना चाहता हूं जो $ f' से '(f) तक मैप करता है जहां Base.:'(x::AbstractMatrix) = adjoint(x) और उपयोगकर्ता अन्य विधियों को जोड़ने के लिए स्वतंत्र है जोड़ से कोई लेना-देना नहीं है। (उदाहरण के लिए, कुछ लोग df/dt को संदर्भित करने के लिए f' पसंद कर सकते हैं।)

0.7 में पेश किए गए ऑपरेटर प्रत्यय के साथ, f'ᵃ के लिए 'ᵃ(f) $ पर मैप करना स्वाभाविक होगा, और इसी तरह, उपयोगकर्ता को अपने स्वयं के पोस्टफिक्स ऑपरेटरों को परिभाषित करने की इजाजत देता है। इससे Base.:'ᵀ(x::AbstractMatrix) = transpose(x) और Base.:'⁻¹(x::Union{AbstractMatrix,Number}) = inv(x) आदि होना संभव हो जाएगा।

A'ᵀ लिखना शायद Aᵀ जितना साफ नहीं है, लेकिन इसके लिए ᵀ में समाप्त होने वाले चर नामों को पदावनत करने की आवश्यकता नहीं होगी।

पहली नज़र में ऐसा लगता है कि यह एक नॉन-ब्रेकिंग फीचर हो सकता है। यह एक बहुत ही चतुर समझौता है। मुझें यह पसंद है।

मेरे लिए उचित लगता है। सबसे कठिन हिस्सा ' फ़ंक्शन के लिए एक नाम के साथ आ रहा है - इस मामले में उपसर्ग सिंटैक्स काम नहीं करता है।

सबसे कठिन हिस्सा 'फंक्शन' के नाम के साथ आ रहा है

apostrophe ? बहुत शाब्दिक हो सकता है ...

क्या उपसर्ग वाक्यविन्यास कार्य करना संभव है (उदाहरण के लिए, एक स्पष्ट (')(A) वाक्यविन्यास के साथ?)? यदि नहीं, तो यह एक समस्या है क्योंकि यह https://github.com/JuliaLang द्वारा शुरू किए गए if-you-can-define-the-symbol-name-then-you-can-override-its-syntax नियम को तोड़ देगा।

संपादित करें: उपलब्ध होना प्रतीत होता है:

julia> (')(A)


ERROR: syntax: incomplete: invalid character literal

julia> (')(A) = 2


ERROR: syntax: incomplete: invalid character literal

दुर्भाग्य से ' पहचानकर्ता नाम के रूप में उपयोग करने के लिए सबसे कठिन वर्णों में से एक है, क्योंकि यह एक अलग प्रकार के परमाणु (अक्षर) का परिचय देता है, जिसकी बहुत उच्च प्राथमिकता है (स्वयं पहचानकर्ताओं की प्राथमिकता के बराबर)। उदाहरण के लिए, क्या (')' अपने आप में ' $ का एक आवेदन है, या एक खुले माता-पिता के बाद ')' शाब्दिक है?

एक विकल्प जो अल्पावधि में व्यावहारिक नहीं है, वह है चरित्र शाब्दिकों को ' के लायक नहीं घोषित करना, और इसके बजाय c"_" जैसे स्ट्रिंग मैक्रो का उपयोग करना।

कैसे के बारे में अगर ' डॉट-कोलन से पहले एक पहचानकर्ता के रूप में पार्स करता है, ताकि Base.:' काम करे?

बेशक (@__MODULE__).:'(x) = function_body लिखना थोड़ा बोझिल हो सकता है, लेकिन (x)' = function_body को वही काम करना चाहिए। संपादित करें: नहीं, चूंकि (x)' को ' में Base पर कॉल करने के लिए मैप करना चाहिए। वर्तमान मॉड्यूल में ' फ़ंक्शन को परिभाषित करना बोझिल होगा, लेकिन ऐसा करने का कोई कारण भी नहीं होगा।

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

सब कुछ जो वर्तमान में एक सिंटैक्स त्रुटि नहीं है, वह अभी भी पहले की तरह पार्स होगा (उदाहरण के लिए 2'' पोस्टफ़िक्स ' है जिसे 2 $ पर दो बार लागू किया गया है), लेकिन 2*'' अब होगा पार्स को दो गुना ' के रूप में पार्स करें।

यह भ्रमित करने वाला लगता है कि हमारे पास a'' === a होगा लेकिन ''(a) === a' । इसके बजाय नाम के रूप में Base.apostrophe का उपयोग करना बेहतर लगता है (या ऐसा कुछ)।

क्या इस चर्चा को एक नए Github मुद्दे में विभाजित करना बेहतर हो सकता है, क्योंकि यह लगभग ' सिंटैक्स है जो सीधे मैट्रिक्स ट्रांसपोज़िशन से संबंधित नहीं है?

क्या मुद्दों को विभाजित करने का एक स्वचालित तरीका है, या क्या मुझे बस एक नया खोलना चाहिए और यहां चर्चा से लिंक करना चाहिए?

बाद वाला

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

मुझे लगता है कि मुझे चर्चा के लिए बहुत देर हो चुकी है, लेकिन मैं एक ऐसे उपयोग को इंगित करना चाहता हूं जो मुझे लगता है कि ध्यान देने योग्य है: जटिल-चरण भेदभाव को वास्तविक-मूल्यवान फ़ंक्शन में लागू करना जिसमें transpose अंदर है यह। (मुझे व्यक्तिगत रूप से पता चला है कि इस विशेष कारण से मुझे MATLAB और जूलिया में .' की आवश्यकता है।)

मैं transpose के कई अवसरों के साथ एक उदाहरण दूंगा (शायद मैं इसे इस तरह से करने से बच सकता हूं?)

using LinearAlgebra

# f : Rⁿ → R
#     x  ↦ f(x) = xᵀ * x / 2
f(x) = 0.5 * transpose(x) * x

# Fréchet derivative of f
# Df : Rⁿ → L(Rⁿ, R)
#      x  ↦ Df(x) : Rⁿ → R (linear, so expressed via multiplication)
#                   h  ↦ Df(x)(h) = Df(x) * h
Df(x) = transpose(x) 

# Complex-step method version of Df
function CSDf(x) 
    out = zeros(eltype(x), 1, length(x))
        for i = 1:length(x)
        x2 = copy(x) .+ 0im
        h = x[i] * 1e-50
        x2[i] += im * h
        out[i] = imag(f(x2)) / h
    end
    return out
end

# 2nd Fréchet derivative
# D2f : Rⁿ → L(Rⁿ ⊗ Rⁿ, R)
#       x  ↦ D2f(x) : Rⁿ ⊗ Rⁿ → R (linear, so expressed via multiplication)
#                     h₁ ⊗ h₂ ↦ D2f(x)(h₁ ⊗ h₂) = h₁ᵀ * D2f(x) * h₂
D2f(x) = Matrix{eltype(x)}(I, length(x), length(x))

# Complex-step method version of D2f
function CSD2f(x)
    out = zeros(eltype(x), length(x), length(x))
    for i = 1:length(x)
        x2 = copy(x) .+ 0im
        h = x[i] * 1e-50
        x2[i] += im * h
        out[i, :] .= transpose(imag(Df(x2)) / h)
    end
    return out
end 

# Test on random vector x of size n
n = 5
x = rand(n)
Df(x) ≈ CSDf(x)
D2f(x) ≈ CSD2f(x)

# test that the 1st derivative is correct Fréchet derivative
xϵ = √eps(norm(x))
for i = 1:10
    h = xϵ * randn(n) # random small y
    println(norm(f(x + h) - f(x) - Df(x) * h) / norm(h)) # Fréchet check
end

# test that the 2nd derivative is correct 2nd Fréchet derivative
for i = 1:10
    h₁ = randn(n) # random h₁
    h₂ = xϵ * randn(n) # random small h₂
    println(norm(Df(x + h₂) * h₁ - Df(x) * h₁ - transpose(h₁) * D2f(x) * h₂) / norm(h₂)) # Fréchet check
end
# Because f is quadratic, we can even check that f is equal to its Taylor expansion
h = rand(n)
f(x + h) ≈ f(x) + Df(x) * h + 0.5 * transpose(h) * D2f(x) * h

मुद्दा यह है कि f और Df को transpose का उपयोग करके परिभाषित किया जाना चाहिए और आसन्न का उपयोग नहीं करना चाहिए।

मुझे नहीं लगता कि जूलिया में जटिल कदम विधि सुपर प्रासंगिक है। क्या यह उन मामलों में स्वचालित भेदभाव प्राप्त करने के लिए एक साफ हैक/समाधान नहीं है जहां एक भाषा कुशल बिल्टिन जटिल संख्याओं का समर्थन करती है, लेकिन समान रूप से कुशल Dual संख्या प्रकार को परिभाषित नहीं किया जा सकता है? जूलिया में ऐसा नहीं है, जिसमें वास्तव में अच्छी स्वचालित भेदभाव पुस्तकालय हैं।

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

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

मेरे कोड में हर्मिटियन ट्रांसपोज़ के सापेक्ष ट्रांसपोज़र ऑपरेटर का घनत्व लगभग 1 से 1 है। तो अपराजित स्थानान्तरण मेरे लिए समान रूप से महत्वपूर्ण है। ट्रांसपोज़ का बहुत उपयोग बाहरी उत्पादों को बनाने और अन्य कोड को इंटरफेस करने या मैट्रिक्स गुणन के लिए सही ढंग से आकार देने के लिए है।

मैं अभी ऑपरेशन के लिए एक मैक्रो या एक कैरेक्टर फ़ंक्शन प्रदान करने का इरादा रखता हूं, हालांकि पुरानी कार्यक्षमता के लिए उचित समकक्ष क्या है, ट्रांसपोज़ () या परमिटिम्स ()?

transpose रैखिक बीजगणित के लिए अभिप्रेत है और पुनरावर्ती है, और permutedims किसी भी प्रकार के डेटा की गैर-पुनरावर्ती व्यवस्था के लिए है।

यह दिलचस्प है कि आप कहते हैं कि आप ट्रांसपोज़ का उपयोग उतना ही करते हैं जितना कि आसन्न। मैं वही हुआ करता था, लेकिन ज्यादातर इसलिए कि मैं गलतियाँ करता था जहाँ मेरा डेटा वास्तविक था इसलिए मैं स्थानांतरित करने के लिए प्रवृत्त हुआ लेकिन वास्तव में आसन्न सही ऑपरेशन था (जटिल मामले के लिए सामान्यीकृत - मेरे एल्गोरिथ्म के लिए आसन्न सही ऑपरेशन था)। निश्चित रूप से (कई) वैध अपवाद हैं।

इलेक्ट्रोडायनामिक्स से संबंधित हर चीज में, आप अक्सर अंतरिक्ष जैसे वैक्टर का उपयोग करते हैं और आर ^ n (आमतौर पर n = 3) में वेक्टर संचालन का उपयोग करना चाहते हैं, अर्थात transpose विशेष रूप से, भले ही आपके वैक्टर जटिल-मूल्यवान हों क्योंकि आप एक फूरियर रूपांतरण लिया है। ऐसा लगता है जैसे @mattcbro इस तरह के एप्लिकेशन के बारे में बात कर रहा है।

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

इलेक्ट्रोडायनामिक्स से संबंधित हर चीज में, आप अक्सर अंतरिक्ष जैसे वैक्टर का उपयोग करते हैं और आर ^ एन (आमतौर पर एन = 3) में वेक्टर संचालन का उपयोग करना चाहते हैं, यानी विशेष रूप से स्थानांतरित करना, भले ही आपके वैक्टर जटिल-मूल्यवान हों क्योंकि आपने फूरियर लिया है परिवर्तन।

जरूरी नही। अक्सर आप फूरियर आयामों से समय-औसत मात्रा चाहते हैं, जिस स्थिति में आप जटिल डॉट उत्पाद का उपयोग करते हैं, उदाहरण के लिए ½ℜ[𝐄*×𝐇] जटिल फूरियर घटकों से समय-औसत पॉयंटिंग प्रवाह है और ¼ε₀|𝐄|² एक है समय-औसत वैक्यूम ऊर्जा घनत्व। दूसरी ओर, चूंकि मैक्सवेल ऑपरेटर (आमतौर पर) एक जटिल-सममित ऑपरेटर ("पारस्परिक") है, आप अक्सर 𝐄(𝐱) आदि क्षेत्रों पर (अनंत-आयामी) बीजगणित के लिए एक असंबद्ध "आंतरिक उत्पाद" का उपयोग करते हैं। सभी जगह।

यह सच है, मेरे पास पहले वाक्य में अक्सर शब्द था, लेकिन इसे स्पष्ट रूप से हटा दिया :-)।

ठीक है अगर आप वहां जाना चाहते हैं, तो इलेक्ट्रोमैग्नेटिक मात्राएं क्लिफोर्ड बीजगणितीय सूत्रीकरण में और भी अधिक संक्षिप्त रूप से लिखी जाती हैं, जिसे अक्सर ज्यामितीय बीजगणित कहा जाता है। उन बीजगणित में कई ऑटोमोर्फिज्म और एंटीऑटोमोर्फिज्म होते हैं जो सिद्धांत के निर्माण में महत्वपूर्ण भूमिका निभाते हैं, खासकर जब बिखरने की समस्याओं पर विचार करते हैं।

इन बीजगणितों में आम तौर पर एक संक्षिप्त मैट्रिक्स प्रतिनिधित्व होता है और उन morphisms को अक्सर जटिल ट्रांसपोज़, हर्मिटियन ट्रांसपोज़ और संयुग्मन के माध्यम से आसानी से गणना की जाती है।

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

मैं व्यक्तिगत रूप से xH और xT . के सुपीरियर सिंटैक्स का पक्ष लेता हूं

1.0 में अब लागू करना आसान है, और कुशल होना चाहिए:

function Base.getproperty(x::AbstractMatrix, name::Symbol)
    if name === :T
        return transpose(x) 
    #elseif name === :H # can also do this, though not sure why we'd want to overload with `'`
    #    return adjoint(x)
    else
        return getfield(x, name)
    end
end 

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

गेटप्रॉपर्टी के ऑर्थोगोनल उपयोग रचना नहीं करते हैं

हम्म। मुझे आश्चर्य है कि इसका मतलब है कि xT "चाहिए" को कम करके getproperty(x, Val(:T)) कर दिया गया है। मैं यह सोचकर कांपता हूं कि हालांकि गरीब कंपाइलर का क्या होगा।

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

(आपके प्रकारों में Val प्रेषण परत को आसानी से जोड़ना भी संभव है)।

@ c42f का कोड एक आकर्षण की तरह काम करता है। दुर्भाग्य से मेरे लिए मैं कोड लिखने की कोशिश कर रहा हूं जो 0.64 और ऊपर के संस्करणों पर काम करता है, जो मुझे या तो ट्रांसपोज़ या मेरे अपने परिभाषित फ़ंक्शन टी (ए) = ट्रांसपोज़ (ए) का उपयोग करने के लिए मजबूर करता है। शायद एक मैक्रो थोड़ा साफ और थोड़ा अधिक कुशल होता।

स्पष्ट होने के लिए, मैं यह विशेष रूप से परिभाषित करने का सुझाव नहीं दे रहा हूं getproperty उपयोगकर्ता कोड के लिए एक अच्छा विचार है। यह लंबी अवधि में चीजों को तोड़ने की संभावना है ;-) हालांकि शायद एक दिन हमें उन परिणामों के लिए पर्याप्त अनुभव होगा जो हम x.T में परिभाषित कर सकते हैं Base ।

लेकिन एक सामान्य अर्थ में, मुझे आश्चर्य है कि जेनेरिक इंटरफेस में "गेटर्स" को परिभाषित करने के लिए इस तरह की संपत्ति का उपयोग वास्तव में खराब क्यों है। उदाहरण के लिए, जेनेरिक फ़ील्ड गेट्टर फ़ंक्शंस में वर्तमान में एक बड़ी बड़ी नामस्थान समस्या है जिसे आसानी से getproperty के विवेकपूर्ण उपयोग द्वारा हल किया जाता है। x.A लिखने की तुलना में MyModule.A(x) लिखना कहीं अधिक अच्छा है, get_my_A(x) जैसे कुछ लंबे बदसूरत फ़ंक्शन नाम, या उपयोगकर्ता से बेहद सामान्य नाम A निर्यात करना मापांक। एकमात्र समस्या जैसा कि मैं इसे देखता हूं, सुपर प्रकार पर सामान्य रूप से परिभाषित .A से स्वतंत्र रूप से उपप्रकारों के लिए .B के अर्थ को ओवरराइड करने की अपेक्षित क्षमता है। इसलिए Val के बारे में आधी गंभीर टिप्पणी।

मजेदार विचार:

julia> x'̄
ERROR: syntax: invalid character "̄"

चरित्र एक T जैसा दिखता है, लेकिन यह वास्तव में एक ' है जिसके ऊपर एक पट्टी है। यकीन नहीं होता अगर गंभीर...

हाँ, ऐसा लगता है कि मुझे गिटहब पर भी ऐसा लगता है। लेकिन यह एक ओवरबार है। मेरे टर्मिनल शो में कॉपी और पेस्ट करें:

बहुत चालाक और प्यारा। मैं अभी भी संयोजन पात्रों को पसंद करता हूं, और मुझे लगता है कि 'ᵀ अच्छा है।

-100 को बदलने के लिए, क्योंकि यह उन भयानक चीजों में से एक है जो जूलिया कोड को गणित लिखने के रूप में स्पष्ट बनाता है, साथ ही conjugate transpose आमतौर पर आप वैसे भी चाहते हैं, इसलिए इसके लिए एक संक्षिप्त वाक्यविन्यास होना समझ में आता है।

इस तरह के बयान में एक निश्चित अहंकार है। विचार करें कि डेवलपर्स के कुछ सीमित अनुपात स्पष्ट रूप से _do not_ चाहते हैं adjoint() लेकिन _need_ transpose() ।

डिफ़ॉल्ट ' ऑपरेटर मॉडलिंग के लिए प्रतीकात्मक गणना के साथ काम करने वाले हमारे लिए मामला और बिंदु उदाहरण के लिए छद्म उलटा (A'*A)\(A *b) या एक द्विघात रूप v'*A*v गलत तरीके से लौटने का कारण होगा लंबे और जटिल परिणाम जिन्हें कम नहीं किया जा सकता है।

हो सकता है कि समाधान किसी प्रकार का संकलक निर्देश है जो ' का अर्थ घोषित करता है।