उदाहरण के लिए, वेक्टर हैक्टर एक वेक्टर की पैदावार (# 2472, # 2936), वेक्टर 'एक मैट्रिक्स उपज, और वेक्टर' एक मैट्रिक्स (# 2686) उपज सभी खराब गणित हैं।

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

v' == v कैसे हो सकता है, लेकिन v'*v != v*v ? क्या हम x' * y लिए अपने स्वयं के ऑपरेटर होने की तुलना में अधिक समझ में आते हैं?

एक परिमित आयामी सदिश स्थान का दोहरा-दोहरापन समरूप है, समान नहीं है।

(अब खुद के रूप में बोलते हुए) यह सिर्फ आइसोमोर्फिक नहीं है, यह स्वाभाविक रूप से आइसोमॉर्फिक है, यानी आइसोमॉर्फिज्म आधार की पसंद से स्वतंत्र है। मैं एक व्यावहारिक अनुप्रयोग के बारे में नहीं सोच सकता जिसके लिए यह इस तरह के समरूपता और एक पहचान के बीच अंतर करने के लायक होगा। आईएमओ झुंझलाहट कारक इस तरह के अंतर को बनाने से आता है।

क्या हम x' * y लिए जितना सोचते हैं, उससे कहीं अधिक समझ में आता है?

यही वह आभास था जो मुझे आज दोपहर @alanedelman के साथ हुई चर्चा से मिला।

मुझे लगता है कि जेफ जो पूछ रहा है वह पैसे पर सही है ... यह x'_y की तरह लग रहा है और x_y 'अधिक बना रहा है
पहले से कहीं ज्यादा।

मैं @stefan के साथ हिंसक समझौते में हूं। खराब गणित का मतलब गलत गणित नहीं था, यह था
मतलब कष्टप्रद गणित। बहुत सारी चीजें ऐसी हैं जो तकनीकी रूप से सही हैं, लेकिन बहुत अच्छी नहीं ...।

यदि हम इस तर्क के साथ चलते हैं, तो हमारे पास दो विकल्प हैं

x_x एक त्रुटि है ..... शायद एक सुझाव के साथ "शायद आप डॉट का उपयोग करना चाहते हैं"
या x_x डॉट उत्पाद है (मुझे यह पसंद नहीं है)

यदि x और x' एक ही बात है, तो यदि आप (x')*y का अर्थ dot(x,y) जिसका अर्थ है कि x*y भी dot(x,y) । वहाँ से बाहर कोई रास्ता नहीं है। हम x'y और x'*y एक अलग ऑपरेशन कर सकते हैं, लेकिन मुझे यकीन नहीं है कि यह एक महान विचार है। लोग स्पष्ट तरीके से इसे संक्षिप्त करना चाहते हैं और यह अभी भी काम कर रहा है।

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

यहां "अप टुपल्स" और "डाउन ट्यूपल्स" में अंतर करने की व्यावहारिक चर्चा है जो मुझे पसंद है:

http://mitpress.mit.edu/sites/default/files/tmarks/content/sicm/book-ZH-79-#.html% _idx_3310

यह ध्यान से "वेक्टर" और "दोहरी" जैसे शब्दों से बचता है, शायद लोगों को परेशान करने से बचने के लिए। मुझे लगता है कि आवेदन आंशिक व्युत्पन्न सम्मोहक के लिए है:

http://mitpress.mit.edu/sites/default/files/tmarks/content/sicm/book-ZH-79-#.html% _sec_Temp_453

M[1,:] और M[:,1] को अलग करने का एक और कारण यह है कि वर्तमान में हमारा प्रसारण व्यवहार इस बहुत सुविधाजनक व्यवहार की अनुमति देता है: M./sum(M,1) कॉलम-स्टोचैस्टिक है और M./sum(M,2) पंक्ति-स्टोचैस्टिक है । यदि हम पंक्तियों और स्तंभों पर आसानी से आवेदन करने की अनुमति देने के लिए norm कार्य करते हैं, तो इसे सामान्य बनाने के लिए किया जा सकता है। बेशक, हम अभी भी ऊपर और नीचे वैक्टर के बजाय sum(M,1) और sum(M,2) वापसी कर सकते हैं, लेकिन यह थोड़ा बंद लगता है।

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

यह सच है कि ऊपर / नीचे एक अलग सिद्धांत हो सकता है। उन्हें सामान्य बनाने का दृष्टिकोण नेस्टेड संरचना है, जो चीजों को एक अलग दिशा में ले जाता है। बहुत संभावना है कि एक कारण है कि वे उन्हें वैक्टर नहीं कहते हैं।

इसके अलावा, x*y = dot(x,y) * गैर-सहयोगी होगा, जैसा कि x*(y*z) बनाम (x*y)*z । मैं वास्तव में आशा करता हूं कि हम इससे बच सकते हैं।

हाँ। मेरे लिए, यह पूरी तरह से अस्वीकार्य है। मेरा मतलब है कि तकनीकी रूप से, फ्लोटिंग-पॉइंट * गैर-सहयोगी है, लेकिन यह लगभग साहचर्य है, जबकि यह सिर्फ गैर-सहयोगी होगा।

हम सभी सहमत हैं कि x*x डॉट उत्पाद नहीं होना चाहिए।

प्रश्न यह है कि क्या हम डॉट उत्पाद के रूप में v'w और v'*w विचार कर सकते हैं?
मैं वास्तव में इस तरह से काम कर रहा हूं।

@JeffBezanson और मैं चैट कर रहे थे

एक प्रस्ताव निम्नलिखित है:

v' वैक्टर के लिए एक त्रुटि है (यह वही है जो गणितज्ञ करता है)
v'w और v'*w एक डॉट उत्पाद (परिणाम = स्केलर) है
v*w एक बाहरी उत्पाद मैट्रिक्स है (परिणाम = मैट्रिक्स)

पंक्तियों और स्तंभ वैक्टर में कोई भेद नहीं है। मुझे वैसे भी यह पसंद था
और गणितज्ञ की मिसाल देखकर खुश था
गणित से: http://reference.wolfram.com/mathematica/tutorial/VectorsAndMatrices.html
जिस तरह से Mathematica वैक्टर और मैट्रिस का प्रतिनिधित्व करने के लिए सूचियों का उपयोग करता है, आपको कभी भी "पंक्ति" और "कॉलम" वैक्टर के बीच अंतर नहीं करना पड़ता है

उपयोगकर्ताओं को यह जानना होगा कि कोई पंक्ति वैक्टर नहीं हैं .... अवधि।

इस प्रकार यदि M एक मैट्रिक्स है

M[1,:]*v एक त्रुटि है ..... (हम M[1,:] साथ चलते हैं एक अदिश राशि है
चेतावनी dot या '* या M[i:i,:] का प्रयास करने का सुझाव दे सकती है

M[[1],:]*v या M[1:1,:]*v लंबाई 1 का वेक्टर है (यह जूलिया का वर्तमान व्यवहार है)

Https://groups.google.com/forum/# .topic/julia -users / L3vPeZ7kews में बारीकी से संबंधित मुद्दे के बारे में

Mathematica स्केलर जैसी सरणी वर्गों को संकुचित करता है:

m = Array[a, {2, 2, 2}] 


Out[49]= {{{a[1, 1, 1], a[1, 1, 2]}, {a[1, 2, 1], 
   a[1, 2, 2]}}, {{a[2, 1, 1], a[2, 1, 2]}, {a[2, 2, 1], a[2, 2, 2]}}}

In[123]:= Dimensions[m]
Dimensions[m[[All, 1, All]]]
Dimensions[m[[2, 1, All]]]
Dimensions[m[[2, 1 ;; 1, All]]]

Out[123]= {2, 2, 2}

Out[124]= {2, 2}

Out[125]= {2}

Out[126]= {1, 2}

[संपादित करें: कोड स्वरूपण - @StefanKarpinski]

@alanedelman

यह मानते हुए कि हम M [1 ,:] के साथ चलते हैं, एक अदिश राशि है

क्या आपका मतलब M [1 ,:] सिर्फ एक सदिश राशि है?

हाँ क्षमा करें। मेरे मन का मतलब था M [1,:] स्केलर को संसाधित कर रहा था 1 :-)

Mathematica तारांकन * बजाय . की अवधि का उपयोग करता है
और फिर पूरे 9 गज की दूरी पर जाता है और एक वेक्टर में (वेक्टर वेक्टर) बनाता है, वास्तव में हम जो बच रहे हैं
तारांकन के साथ।

इस अवधि के साथ कई समस्याएं नहीं हैं, जिनमें से एक यह है कि यह अभी नहीं है
एक डॉट उत्पाद में "डॉट" जैसा दिखता है, और एक अन्य यह है कि इसके साथ टकराव होता है
डॉट के "पॉइंटवाइज़ ऑप" को पढ़ना,

यूनिकोड बहुत अच्छी तरह से एक चरित्र प्रदान करता है जिसका नाम "डॉट ऑपरेटर" है
⋅ (char(8901)) जो हम पेशकश करने की कल्पना कर सकते हैं

इसलिए हम (v ⋅ w) (v'*w) पर्याय बन सकते हैं

संक्षेप में बहस के लिए एक वर्तमान प्रस्ताव विषय है

1. स्केलर इंडेक्सिंग इस प्रकार आयाम को मारता है
   A[i,:] एक वेक्टर है जैसा कि A[:,i,j]
2. वेक्टर इंडेक्सिंग मोटी है
   A[ i:i , : ] या A[ [i], : ] एक पंक्ति के साथ एक मैट्रिक्स लौटाता है
3. v'w या v'*w वैक्टर के लिए डॉट उत्पाद है (इसी तरह v*w' बाहरी उत्पाद के लिए)
4. v' वैक्टर के लिए अपरिभाषित है (उपयोगकर्ता को permutedims(v,1) ?????
5. v*A एक सदिश देता है यदि A एक मैट्रिक्स है
6. v⋅w भी डॉट उत्पाद लौटाता है (लेकिन मैत्रेयता के . को मैट्रिसेस पर काम करके नहीं जाता है
7. v*w वैक्टर के लिए अपरिभाषित है, लेकिन एक चेतावनी उपयोगकर्ता को अच्छे सुझावों सहित सुझाव दे सकती है
   ⋅

परिणाम हैं कि

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

सुझाव 5) मुझे बहुत अजीब लगता है। मैं v'*A पसंद करता हूं ताकि यह स्पष्ट हो कि आप दोहरे वेक्टर का उपयोग कर रहे हैं। यह जटिल वेक्टर रिक्त स्थान में विशेष रूप से महत्वपूर्ण है, जहां दोहरी सिर्फ "आकार" परिवर्तन नहीं है।

मैं @StefanKarpinski को प्रतिध्वनित करना चाहता v और उन मूल्यों द्वारा मैट्रिक्स A के कॉलम को सामान्य करने के लिए संक्षिप्त सिंटैक्स क्या है? वर्तमान में, कोई A ./ v' उपयोग कर सकता है। यह डेटा हेरफेर के लिए बेहद अच्छा है।

अच्छा सवाल है

मेरी योजना v'*A को v और mulitiplying के जटिल संयुग्म को शामिल नहीं करती है
और सभी विभिन्न अन्य मामले जिन्हें मैंने अभी तक स्पष्ट रूप से उल्लेख नहीं किया था, लेकिन आसानी से

हम 5 को खत्म कर सकते हैं
शायद यह वांछनीय है
यह मेरे कॉलम वेक्टर नियम के अनुरूप नहीं है

प्रसारण के लिए यह दृष्टिकोण प्यारा और मज़ेदार है
एक समाधान अब A ./ v[:,[1]]

यह प्रलेखित करने का लाभ है कि किस आयाम पर प्रसारण किया जा रहा है
और उच्च आयामी सरणियों के लिए सामान्यीकृत करता है

ओह और v[:,[1]] समाधान में जटिल संयुग्मन नहीं लेने का गुण है
जो शायद उपयोगकर्ता का इरादा है .....

मैं अपने दो उदाहरणों को पसंद करता हूं क्योंकि पहला एक LINEAR ALGEBRA उदाहरण है
जहां एक जटिल संयुग्म बहुत बार वांछित होता है, लेकिन दूसरा उदाहरण है
एक बहुदलीय डेटा उदाहरण जहां हम सभी आयामों में काम करना चाहते हैं
सिर्फ मैट्रीस के लिए नहीं, और हम बहुत जटिल कॉम्जूगेट नहीं चाहते हैं

⋅ # 552 की आवश्यकता होती है। यह पिछले दो हफ्तों में तीसरी बार दिखाया गया है।

M [1 ,:] और M [:, 1] में अंतर करने का एक और कारण यह है कि वर्तमान में हमारा प्रसारण व्यवहार इस बहुत सुविधाजनक व्यवहार की अनुमति देता है: M./sum(M,1) कॉलम-स्टोचैस्टिक और M./sum(M है। 2) पंक्ति-स्टोचैस्टिक है। यदि हम पंक्तियों और स्तंभों पर आसानी से आवेदन करने की अनुमति देते हैं, तो सामान्य कार्य के लिए इसे सामान्य किया जा सकता है। बेशक, हम अभी भी ऊपर और नीचे वैक्टर के बजाय सम (एम, 1) और सम (एम, 2) रिटर्न मैट्रिस् कर सकते हैं, लेकिन यह थोड़ा बंद लगता है।

मुझे ऐसा लगता है कि प्रसारण के समय का व्यवहार कुछ अच्छा है, आप अंत में उन अतिरिक्त इकाई को निचोड़ने का प्रयास करते हैं जो अक्सर ही समाप्त हो जाती हैं। इस प्रकार, कुछ समय के विपरीत करने के लिए ठीक है यदि बाकी सिस्टम अच्छा है (और मुझे लगता है कि स्केलेर आयाम गिराए जाने से सिस्टम अच्छा हो जाएगा)। इस प्रकार आपको एक फ़ंक्शन की आवश्यकता होगी

julia> widen(A::AbstractArray,dim::Int) = reshape(A,insert!([size(A)...],dim,1)...)
# methods for generic function widen
widen(A::AbstractArray{T,N},dim::Int64) at none:1

जो M ./ widen(sum(M,2),2) या A ./ widen(v,1) जैसे कोड की अनुमति देगा (ऊपर देखें @blakejohnson उदाहरण)

M [:, 0 ,:] और v [:, 0] ?????

मैं कमी के मुद्दे पर @blakejohnson के साथ अधिक हूं; मैं व्यक्तिगत रूप से लगता है कि यह करने के लिए स्पष्ट है squeeze करने के लिए की तुलना में आयाम widen उन्हें। मुझे संदेह है कि मैं डॉक्स को हमेशा यह देखने के लिए देखूंगा कि widen संकेत सूचकांक पर या उसके बाद आयाम सम्मिलित करता है या नहीं, और यदि आप एक साथ कई आयामों को चौड़ा करना चाहते हैं तो नंबरिंग थोड़ी अधिक जटिल हो जाती है। (वेक्टर v widen(v, (1, 2)) लिए squeeze लिए समस्याएँ नहीं हैं।

भले ही हम प्रति डिफ़ॉल्ट को चौड़ा या निचोड़ लें, मुझे लगता है कि जूलिया को सीप से लीड का पालन करना चाहिए जब वह चौड़ी हो जाती है और v[:, newaxis] जैसी किसी चीज़ की अनुमति देती है। लेकिन मुझे विश्वास है कि मैं उन्हें छोड़ने के बजाय आयाम रखना पसंद करता हूं, यह एक बग को पकड़ना मुश्किल है जहां आपने गलती से गलत तरीके से चौड़ा किया जब आपने गलत तरीके से निचोड़ा (जो आमतौर पर एक त्रुटि देगा)।

@Alanedelman की सूची में
मैं महसूस करता हूँ कि

v * A एक वेक्टर है जो A मैट्रिक्स है

अच्छा नहीं है।

v_A एक त्रुटि होनी चाहिए यदि A 1x1 नहीं है (अनुक्रमणिका की श्रेणी का बेमेल)
v'_A इसे करने का उचित तरीका होना चाहिए।

इस समस्या से निपटने का एक तरीका वेक्टर वी को nx1 मैट्रिक्स में बदलना है (जब जरूरत हो)
और हमेशा v 'को 1xn मैट्रिक्स के रूप में मानें (इसे कभी वेक्टर या nx1 मैट्रिक्स में परिवर्तित न करें)
इसके अलावा, हम स्वचालित रूप से 1x1 मैट्रिक्स को स्केलर संख्या (जब आवश्यक हो) में बदलने की अनुमति देते हैं।

मुझे लगता है कि यह रैखिक बीजगणित के बारे में सोचने के लिए एक सुसंगत और एक समान तरीका दर्शाता है। (अच्छा गणित)

उन सभी मुद्दों को संभालने के लिए एक समान तरीका स्वचालित (प्रकार?) रूपांतरण (जब आवश्यक हो) की अनुमति देना है
आकार की सरणी (n), (n, 1), (n, 1,1), (n, 1,1,1) आदि के बीच (लेकिन आकार के सरणियों के बीच नहीं (n, 1) और (1, n) )
(जैसे हम जरूरत पड़ने पर वास्तविक संख्या को स्वचालित रूप से जटिल संख्या में बदल देते हैं)

इस स्थिति में आकार की एक सरणी (1,1) एक संख्या में परिवर्तित की जा सकती है (जब जरूरत हो) (# 4797 देखें)

जिओ-गैंग (एक भौतिक विज्ञानी)

हालांकि यह v'_A छोड़ देता है .... मैं वास्तव में काम करने के लिए v'_A * w चाहता हूं

जूलिया में रैखिक बीजगणित की मेरी धारणा यह है कि यह मैट्रिक्स बीजगणित की तरह बहुत व्यवस्थित है, हालांकि स्केलर और सच्चे वैक्टर मौजूद हैं (जो मुझे लगता है कि अच्छा है!)

आइए विचार करें कि x*y*z*w जैसे उत्पाद को कैसे संभालना है, जहां प्रत्येक कारक एक स्केलर, वेक्टर या मैट्रिक्स हो सकता है, संभवतः उस पर एक संक्रमण के साथ। मैट्रिक्स बीजगणित मैट्रिक्स के उत्पाद को परिभाषित करता है, जहां एक मैट्रिक्स का आकार n x m । एक दृष्टिकोण इस परिभाषा को विस्तारित करने के लिए होगा ताकि n या m absent द्वारा प्रतिस्थापित किया जा सके, जो कि उत्पाद की गणना के रूप में दूर के मूल्य की तरह कार्य करेगा , लेकिन मैटरिस से स्केलर और वैक्टर को अलग करने के लिए उपयोग किया जाता है:

• एक स्केलर absent x absent
• a (स्तंभ) वेक्टर n x absent
• एक पंक्ति वेक्टर absent x n

आदर्श रूप से, हम चीजों को व्यवस्थित करना चाहते हैं ताकि हमें पंक्ति वैक्टर का प्रतिनिधित्व करने की आवश्यकता न हो, लेकिन यह x'*y और x*y' जैसे कार्यों को लागू करने के लिए पर्याप्त होगा। मुझे लगता है कि यह उस योजना का स्वाद है जिसे हम में से कई लोग खोज रहे हैं।

लेकिन मुझे संदेह होने लगा है कि इस तरह की स्कीम में रो वैक्टर पर प्रतिबंध लगाना एक उच्च लागत पर आएगा। उदाहरण: विचार करें कि किसी भी मध्यवर्ती कदम पर एक पंक्ति वेक्टर बनाने से बचने के लिए हमें किसी उत्पाद को छोटा करने की आवश्यकता कैसे होगी: ( a एक अदिश राशि है, u और v वैक्टर हैं)

a*u'*v = a*(u'*v) // a*u' is forbidden
v*u'*a = (v*u')*a // u'*a is forbidden

पंक्ति वैक्टर बनाने से परहेज करते हुए एक उत्पाद x*y'*z मूल्यांकन करने के लिए, हमें गुणन क्रम चुनने से पहले कारकों के प्रकार को जानना होगा! यदि उपयोगकर्ता को इसे स्वयं करना चाहिए, तो यह जेनेरिक प्रोग्रामिंग के लिए एक बाधा की तरह लगता है। और मुझे यकीन नहीं है कि जूलिया यह कैसे कर सकता है एक स्वचालित तरीके से।

गुणन क्रम को अग्रिम रूप से ठीक नहीं करने का एक और कारण: मुझे याद है कि आवश्यक संचालन की संख्या को कम करने के लिए *(x,y,z,w) का इष्टतम मूल्यांकन क्रम चुनने के लिए गतिशील प्रोग्रामिंग का उपयोग करने का विचार था। कुछ भी जो हम पंक्ति वैक्टर बनाने से बचने के लिए करते हैं, संभवतः इसके साथ हस्तक्षेप करेंगे।

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

ट्रांसपोज़ेशन, मोड्स को परमिट करने का एक विशेष तरीका है। यदि आप v.' अनुमति देते हैं, जहाँ v एक सदिश राशि है, तो permutedims(v,[2 1]) को उसी चीज़ को वापस करना चाहिए। या तो दोनों एक विशेष पंक्ति वेक्टर प्रकार लौटाते हैं, या वे एक नया आयाम पेश करते हैं।

पंक्ति वैक्टर के लिए एक विशेष प्रकार होने से मेरे लिए एक अच्छा समाधान नहीं दिखता है, क्योंकि आप अन्य प्रकार के मोड-एन वैक्टर के बारे में क्या करेंगे, जैसे, permutedims([1:4],[3 2 1]) ? मैं आपसे आग्रह करता हूं कि निर्णय लेने से पहले मल्टीलाइनर बीजगणित को भी ध्यान में रखें।

@toivoh ने उल्लेख किया है कि

"एक दृष्टिकोण इस परिभाषा को विस्तारित करने के लिए होगा ताकि एन या एम को अनुपस्थित द्वारा प्रतिस्थापित किया जा सके, जो उत्पाद के कंप्यूटिंग के संबंध में एक के मूल्य की तरह कार्य करेगा, लेकिन इसका उपयोग स्केलर और वैक्टर को मैट्रिसेस से अलग करने के लिए किया जाता है:

1. एक स्केलर अनुपस्थित एक्स अनुपस्थित होगा
2. a (कॉलम) वेक्टर nx अनुपस्थित होगा
3. एक पंक्ति वेक्टर अनुपस्थित होगा xn "

बहु रेखीय बीजगणित में (या उच्च रैंड टेंसरों के लिए) उपरोक्त प्रस्ताव अनुपस्थित का प्रतिनिधित्व करने के लिए अनुरूप है
श्रेणी 1 के कई सूचकांकों, अर्थात आकार (m, n, अनुपस्थित), (m, n), (m, n, 1), (m, n, 1,1), आदि के अनुरूप हो सकते हैं।

यदि हम अनुपस्थित की इस व्याख्या का उपयोग करते हैं, तो 1. और 2. ठीक है और अच्छा है, लेकिन 3. ठीक नहीं हो सकता है।
हम आकार (1, n) और (1,1, n) के सरणियों को नहीं मिलाना चाहते हैं।

मैं टेंसर सिद्धांत का विशेषज्ञ नहीं हूं, लेकिन मैंने ऊपर उल्लिखित सभी प्रणालियों (_without_ किसी भी ऐड-ऑन पैकेज) का उपयोग किया है, जिसमें रैखिक बीजगणित से संबंधित पर्याप्त परियोजनाएं हैं।

[TL; DR: सारांश में छोड़ें]

यहाँ सबसे आम परिदृश्य हैं जिनमें मुझे सामान्य मैट्रिक्स-वेक्टर ऑपरेशन की तुलना में सरणी हैंडलिंग में अधिक व्यापकता की आवश्यकता है:

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

(2) मूल्यांकन नियंत्रण: उदाहरण के लिए, किसी भी उत्पाद की गणना की जा सकती है, किसी को उस उत्पाद की किसी भी उप-इकाई की अलग से गणना करने में सक्षम होना चाहिए, क्योंकि कोई भी अलग-अलग उत्पाद बनाने के लिए कई अलग-अलग उप-संस्थाओं के साथ संयोजन करना चाह सकता है। इस प्रकार के बारे में Toivo की चिंता, उदाहरण के लिए, a*u' मना किया जाना केवल एक संकलन चिंता का विषय नहीं है, बल्कि एक प्रोग्रामिंग चिंता का विषय है; एक और भी सामान्य संस्करण पूर्व-कम्प्यूटिंग x'Q है जो द्विघात रूपों की गणना करने के लिए x'Q*y1 , x'Q*y2 , ... (जहां ये क्रमिक रूप से किया जाना चाहिए)।

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

यहाँ उपरोक्त प्रणालियों के साथ मेरे सामान्य अनुभव हैं:

MATLAB: कोर भाषा आम मैट्रिक्स-वेक्टर ऑप्स से परे सीमित है, इसलिए आमतौर पर इंडेक्सिंग के साथ छोरों को लिखना होता है।

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

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

scmutils: कार्यात्मक विश्लेषण के लिए, यह साफ है, सामान्य है, और उपरोक्त में से किसी के भी गणितीय रूप से सहज संचालन (दोनों लिखने और पढ़ने) प्रदान करता है। अप / डाउन टुपल विचार वास्तव में सिर्फ एक अधिक सुसंगत और अधिक सामान्य विस्तार है जो लोग अक्सर लिखित गणित में ट्रांसजेंड संकेतों, भेदभाव सम्मेलनों और अन्य अर्ध-मानकीकृत धारणाओं का उपयोग करते हैं; लेकिन सब कुछ सिर्फ काम करता है। (अपनी पीएचडी थीसिस लिखने के लिए, मैंने पारंपरिक गणित संकेतन से मिलता-जुलता एक सुसंगत और अस्पष्ट अंकन विकसित किया, लेकिन सूसमैन और विजडम के SICM वाक्य-विन्यास के लिए समसामयिक है।) उन्होंने इसे एक अंतर ज्यामिति कार्यान्वयन [1] के लिए भी उपयोग किया है, जो कि है। एक बंदरगाह को SymPy [2] के लिए प्रेरित किया। मैंने डेटा विश्लेषण के लिए इसका उपयोग नहीं किया है, लेकिन मैं उम्मीद करूंगा कि एक सामान्य सरणी संदर्भ में जहां आप केवल एक प्रकार का टपल चाहते थे (जैसे कि मैथमेटिका की सूची), आप केवल एक ("ऊपर") सम्मेलन द्वारा चुन सकते हैं। फिर से, सामान्यता प्रोग्रामर के प्रदर्शन के विचारों को अस्पष्ट करती है, लेकिन मुझे उम्मीद है कि यह एक ऐसा क्षेत्र है जहां जूलिया उत्कृष्टता प्राप्त कर सकते हैं।

सारांश

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

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

मेरा मानना ​​है कि यह दृष्टिकोण विभिन्न ऑपरेशनों के परिणामों के लिए उपरोक्त सहमति को दर्शाता है, इस अपवाद के साथ कि वे मामले जो पहले के पदों की त्रुटियों को मानते थे ( v' और v*A ) वास्तव में सार्थक (और अक्सर उपयोगी) देंगे ) परिणाम।

[१] http://dspace.mit.edu/handle/1721.1/30520
[२] http://krastanov.wordpress.com/diff-geometry-in-python/

@thomasmcfish ध्वनि की तरह आप सह और contravariant वैक्टर के बीच एक स्पष्ट अंतर के लिए वकालत कर रहे हैं।

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

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

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

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

immutable UpDownTensor{T, N, UPMASK} <: AbstractArray{T, N}
    A::AbstractArray{T, N}
end

जहां UPMASK थोड़ा सा मुखौटा होगा जो यह दर्शाता है कि कौन से आयाम हैं। फिर गैर लिपटे सरणियों पर कार्रवाई एक डिफ़ॉल्ट प्रदान करके लागू किया जा सकता UPMASK के एक समारोह के रूप में N : वैक्टर एक भी अप करने के लिए डिफ़ॉल्ट होता, पहले और दूसरे नीचे करने के लिए मैट्रिक्स; फिर मुझे यकीन नहीं है कि यह यथोचित रूप से कैसे जारी रहेगा।

कुछ यादृच्छिक विचार:

• द्विघाती / द्विभाजित रूपों को दो डाउन आयामों द्वारा बेहतर रूप से दर्शाया जाएगा?
• यदि ट्रांसपोज़ प्रत्येक आयाम के अप-डाउनिंग / फ़्लिपिंग के अनुरूप होगा, तो मुझे लगता है कि हमें ट्रांसपोज़्ड-मैट्रिक्स टाइप भी मिलेगा जिसमें पहला आयाम नीचे और दूसरा ऊपर होगा।
• डिफ़ॉल्ट के अनुरूप होने वाले अप-पैटर्न को इसे लपेटने के बजाय सीधे अंतर्निहित सरणी द्वारा दर्शाया जा सकता है।

खैर, यह निश्चित रूप से Transposed प्रकार का एक सामान्यीकरण है, और इसमें निश्चित रूप से कुछ योग्यता है। यकीन नहीं होता कि क्या यह संभव है।

मुझे लगता है कि टिवो का सुझाव एक उचित अहसास है जो मैं ऊपर बता रहा था। मेरे लिए, सबसे समझदार डिफ़ॉल्ट उच्च आदेशों पर वैकल्पिक दिशाओं को जारी रखना है: उदाहरण के लिए, यदि किसी ने बिजली की श्रृंखला के घटकों को गैर-लिपटे सरणियों के रूप में प्रदान किया है, तो यह सही काम करेगा।

लेकिन आगे के प्रतिबिंब पर, मुझे लगता है कि यह दोनों विचारों को संयोजित करने के लिए बहुत शक्तिशाली हो सकता है: (1) ऊपर और नीचे वैक्टर और (2) एरे और वैक्टर के बीच अंतर। तब आपके पास ऐसी वस्तुएं हो सकती हैं जहां कुछ आयाम ऊपर हैं, कुछ नीचे हैं, और कुछ "तटस्थ" हैं। सरणियों और वैक्टर को अलग करने का कारण यह है कि, शब्दार्थ, सरणियाँ संगठन के लिए हैं (एक ही प्रकार की कई चीजों को इकट्ठा करना), जबकि वैक्टर समन्वय (बहुआयामी स्थानों का प्रतिनिधित्व) के लिए हैं। एक वस्तु में दोनों भेदों को मिलाने की शक्ति यह है कि यह दोनों उद्देश्यों को एक साथ पूरा कर सकता है। प्रसारण आयामों के अनुसार तटस्थ आयामों का इलाज किया जाएगा, जबकि ऊपर / नीचे के आयामों को टेंसर अंकगणितीय नियमों के अनुसार माना जाएगा।

मेरे पहले के उदाहरण पर लौटते हुए, मान लीजिए कि आप अलग-अलग वैक्टर y1, y2, ... लिए x'Q*y1, x'Q*y2, ... संख्या की गणना कर रहे हैं। SICM के बाद, (...) और tuples (पंक्ति वैक्टर) द्वारा [...] tuples (स्तंभ वैक्टर) को दर्शाएँ। यदि आप यह सब एक ही बार में करना चाहते हैं, और आप केवल ऊपर / नीचे के साथ अटके हुए हैं, तो पारंपरिक तरीका होगा yi को एक मैट्रिक्स Y = [y1, y2, ...] कर एक tuple (का उपयोग करके) tuples), और r = x'Q*Y गणना करते हैं, जो आपको परिणाम में tuple r । लेकिन क्या होगा यदि आप इन परिणामों में से प्रत्येक को (कॉलम) वेक्टर v से गुणा करना चाहते हैं? आप सिर्फ r*v नहीं कर सकते, क्योंकि आपको एक संकुचन (डॉट उत्पाद) मिलेगा। आप r को एक अप ट्यूपल में रूपांतरित कर सकते हैं, और फिर गुणा कर सकते हैं, जो आपको एक अप ट्यूपल (अप ट्यूपल) में आपके परिणाम देता है। लेकिन लगता है कि अगले चरण के लिए आपको एक डाउन टपल की आवश्यकता है? शब्दार्थ, आपके पास अपनी गणना से गुजरने वाला एक आयाम है जो सिर्फ चीजों के संग्रह का प्रतिनिधित्व करता है, जिसे आप हमेशा प्रसारित करना चाहते हैं; लेकिन सख्ती से ऊपर / नीचे की दुनिया में इसे प्राप्त करने के लिए, आपको सही व्यवहार को लागू करने के लिए मनमाना संदर्भ-निर्भर रूपांतरण करते रहना होगा।

इसके विपरीत, मान लें कि आपके पास तटस्थ ट्यूपल्स (सरणियां) हैं, जो {...} निरूपित हैं। फिर आप स्वाभाविक रूप से एक सरणी के रूप में ys = {y1, y2, ...} लिखते हैं (टुपल्स का), ताकि r = x'Q*ys एक सरणी हो, और r*v भी एक सरणी (अप ट्यूपल) है। सब कुछ समझ में आता है, और कोई मनमाना रूपांतरण की आवश्यकता नहीं है।

स्टीफन सुझाव देते हैं कि 1 / डी सरणियों को अप / डाउन वैक्टर से अलग करना विनाशकारी है, लेकिन मुझे लगता है कि यह समस्या इस तथ्य से हल हो जाती है कि अधिकांश फ़ंक्शन वैक्टर पर ऑपरेटिंग अर्थों को संचालित करते हैं, लेकिन सरणियों पर _or_ नहीं। (या, matrices _or_ पर वैक्टर के arrays पर _or_, arrays के वैक्टर पर _or_, सरणियों के ऐरे पर, लेकिन नहीं _either_ और इसी तरह।) इसलिए उचित रूपांतरण नियमों के साथ, मैंने एक सामान्य मामले के बारे में नहीं सोचा है जो ऐसा नहीं करेगा। स्वचालित रूप से सही बात। शायद कोई कर सकता है?

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

[१] http://groups.csail.mit.edu/mac/users/gjs/6946/refman.txt --- "संरचित वस्तुएँ" पर शुरू
[२] http://www.sagemath.org/

मैं लंच टेबल पर @ जियाओ से बात कर रहा था और उन्होंने उल्लेख किया कि जूलिया टीम यह जानने की कोशिश कर रही थी कि रैखिक बीजगणित के संचालन को उच्च आयामी सरणियों में कैसे सामान्य किया जाए। दो साल पहले मैंने इस बारे में सोचने में कई महीने बिताए क्योंकि मुझे इसकी जरूरत क्रोनकेरियो के लिए थी। मैं अपना दृष्टिकोण साझा करना चाहता था।

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

मैं आमतौर पर एक भूखंड के x, y और z अक्षों की तरह ऑर्डर किए जाने के बजाय नाम के आयामों के बारे में सोचता हूं। लेकिन यदि आप चाहते हैं कि उपयोगकर्ता वास्तव में आदेशित अनुक्रमणिका (जैसे A[1,2,5] बजाय A[a1=1, a3=5, a2=2] ) द्वारा एक्सेस करने में सक्षम हों, तो आपके पास ऑपरेशन के परिणामों को क्रम में रखने के लिए एक सुसंगत प्रक्रिया होनी चाहिए। मैं पहले सरणी के सभी आयामों को सूचीबद्ध करके परिणाम का आदेश देने का प्रस्ताव करता हूं और इसके बाद दूसरे सरणी के सभी आयामों को सूचीबद्ध करता हूं। आंतरिक उत्पाद में भाग लेने वाले किसी भी आयाम को निचोड़ लिया जाता है, और उन आयामों के लिए, जो तत्व तत्व उत्पाद में भाग लेते हैं, केवल दूसरे सरणी से आयाम निचोड़ा जाता है।

मैं इसके लिए कुछ अंकन करने जा रहा हूं। बेझिझक जूलियाफी इसे। A एक ऐसा सरणी हो जो a1 a2 a3 और B एक ऐसा सरणी हो जो b1 b2 । मान लें कि array_product(A, B, inner=[2, 1], elementwise=[3, 2]) आंतरिक उत्पाद को a2 और b1 बीच ले जाएगा, a3 और b2 बीच का प्राथमिक उत्पाद, और a1 का बाहरी उत्पाद। परिणाम एक सरणी होगा जो a1 a3 ।

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

मतलब का A*B array_product(A, B, inner=[2,1]) ।

मतलाब के A.' permute(A, B, [2,1]) जहां परमिट तीसरे तर्क की गिनती की तुलना में सभी आयामों को अपरिवर्तित रखता है।

आप यह चुन सकते हैं कि एरर्स को फेंकना या न भरना जब सरणियों की आयाम 2 से अधिक है या 2 के बराबर भी नहीं है, जैसे कि मैथमेटिका वेक्टर ट्रांसपोज़ के साथ करता है। यदि आप केवल सामान्य सरणी गणनाओं का उपयोग कर रहे हैं, तो आपको सभी (n, m) सरणियों को (n, m, 1) और (n, m, 1) के रूप में व्याख्या करने के लिए @wenxgwen का सुझाव लेने या नहीं लेने की @wenxgwen का सुझाव पसंद है, क्योंकि डायनेमिक रूप से टाइप की गई भाषा में बहुत कम है।

मैंने अपने सिस्टम का अधिक

परिप्रेक्ष्य के लिए धन्यवाद! मुझे यह समझने में काफी ज्ञान मिला कि एक सामान्य सरणी * सरणी उत्पाद वास्तव में किस प्रकार का जानवर है।

PEP 0465 में मैट्रिक्स गुणन ऑपरेटर के लिए प्रस्तावित शब्दार्थ के साथ बहुआयामी सरणी गुणन के प्रस्तावों को क्रॉस-रेफरेंस करना दिलचस्प हो सकता है। विशेष रूप से:

1d वेक्टर इनपुट्स को आकार में '1' से जोड़कर या जोड़कर 2d को बढ़ावा दिया जाता है, ऑपरेशन किया जाता है, और फिर आउटपुट से अतिरिक्त आयाम हटा दिया जाता है। 1 को हमेशा आकृति के "बाहर" पर जोड़ा जाता है: बाएं तर्कों के लिए तैयार किया जाता है, और सही तर्कों के लिए जोड़ा जाता है। परिणाम यह है कि मैट्रिक्स @ वेक्टर और वेक्टर @ मैट्रिक्स दोनों कानूनी (संगत आकार मान रहे हैं), और दोनों 1 डी वैक्टर लौटाते हैं; वेक्टर @ वेक्टर एक स्केलर लौटाता है ... 1 डी वैक्टर के लिए इस परिभाषा की एक विशिष्टता यह है कि यह कुछ मामलों में (गैर-सहयोगी) (Mat1 @ vec) @ Mat2! = Mat1 @ (vec @ Mat2) बनाता है। लेकिन यह ऐसा मामला प्रतीत होता है जहां व्यावहारिकता शुद्धता को हरा देती है

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

PEP से 0465:

1d वैक्टर के लिए इस परिभाषा की एक विशिष्टता यह है कि यह कुछ मामलों में (@ (Mat1 @ vec) @ Mat2! = Mat1 @ (vec @ Mat2) को @ गैर-सहयोगी बनाता है।

विशेष रूप से, परिभाषा इस तरह, मेथेमेटिका में गलत परिणाम का उत्पादन कर सकते क्योंकि Dot ( . ) साहचर्य (माना जाता है Flat जब प्रतीकात्मक का मूल्यांकन (साथ) f नीचे, लेकिन g ):

In[1]:= f=X.(y.Z);
g:=X.(y.Z)

In[3]:= Block[{
X=Array[a,{2,2}],
y=Array[b,2],
Z=Array[c,{2,2}]
},{f,g}]

Out[3]= {{(a[1,1] b[1]+a[1,2] b[2]) c[1,1]+(a[2,1] b[1]+a[2,2] b[2]) c[2,1],(a[1,1] b[1]+a[1,2] b[2]) c[1,2]+(a[2,1] b[1]+a[2,2] b[2]) c[2,2]},{a[1,1] (b[1] c[1,1]+b[2] c[2,1])+a[1,2] (b[1] c[1,2]+b[2] c[2,2]),a[2,1] (b[1] c[1,1]+b[2] c[2,1])+a[2,2] (b[1] c[1,2]+b[2] c[2,2])}}

In[4]:= SameQ@@Expand[%]
Out[4]= False

@ वृद्धजन से :

जूलिया रनटाइम प्रकार की जाँच के साथ और convert विधियाँ इस अस्पष्टता से ग्रस्त नहीं हैं।

यही कारण है कि मैं जूलिया _should_ के लिए सही समाधान महसूस करता हूं डेटा को सरणी-जैसे शब्दार्थ (सार्वभौमिक प्रसारण के लिए) और टेंसर जैसे शब्दार्थ (संभव संकुचन के लिए) के बीच अंतर करने देता है।

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

रैखिक बीजगणित के गणितीय क्षेत्र में काम करने के लिए, तब तीन और प्रकार होने चाहिए, Matrix , ColumnVector , और RowVector , जिस पर सभी सामान्य रेखीय बीजगणित संचालक और कार्य सामान्य रूप से काम करें।

अब जब प्रकार संरचना अच्छी तरह से परिभाषित है, तो आप Matrix से Array{2} , ColumnVector Array{1} लिए निहित रूपांतरण जोड़कर उपयोगकर्ता पर इसे आसान बना सकते हैं। और RowVector से Array{2} (इस बारे में निश्चित नहीं), Array{2} से Matrix , और Array{1} से ColumnVector ।

ऊपर मेरा प्रस्ताव (https://github.com/JuliaLang/julia/issues/4774#issuecomment-32705055) एक बहुआयामी संरचना के प्रत्येक आयाम को यह भेद करने की अनुमति देता है कि क्या यह तटस्थ है ("संग्रह" / "सरणी"), ऊपर (" स्तंभ "), या नीचे (" पंक्ति ") शब्दार्थ। मुझे लगता है कि आप जो वर्णन कर रहे हैं वह एक विशेष मामला है।

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

@thomasmcfish मुझे आपका प्रस्ताव बहुत पसंद है। मैंने कुछ मार्गदर्शक सिद्धांतों (उर्फ व्यक्तिगत राय) के साथ एक डीएसएल (बहुत पहले, बहुत दूर) में समान रूप से लागू किया:

1. किसी भी समझदारी से आत्म-सुसंगत शब्दार्थ के लिए दोहरे की धारणा महत्वपूर्ण है।
2. पैरामीटर ऑपरेटर (या उस मामले के लिए डेटा के लिए कुछ भी बाहरी) के साथ टेंसर बीजगणित का तदर्थ प्रवर्तन सौंदर्यशास्त्र दृढ़ता से अनपेक्षित है।

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

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

मुझे लगता है कि तुम सही हो डेविड। हम वास्तव में दो उपयोग के मामलों के बारे में बात कर रहे हैं।

रैखिक बीजगणित के सबसेट की सबसे अधिक जरूरत है कि आप के रूप में ज्यादातर लोग
कहते हैं। वहां भी मैं v और v के बीच अंतर बनाए रखने की वकालत करता हूं। '

मैं वास्तव में क्या चाहूंगा (लालच का खुलासा यहां बताएं) Tensors with है
प्रथम श्रेणी (या पास) की स्थिति ... देशी गति के पास (सीमित मामले में)
आसान सिंटैक्स के साथ रैखिक बीजगणित के प्रदर्शन) की तुलना में, कोई ओवरवॉच नहीं है
टाइपिंग मुद्दों, सह / contravariance के साथ डेटा में इनकोड किया गया है, पर नहीं
ऑपरेटरों। एक बार जब मैं डेटा शब्दार्थ को परिभाषित करता हूं, तो संचालन करना चाहिए
सिर्फ काम। टेंसरल डक टाइपिंग।

शायद टेंसर्स और टीडीटी एक पैकेज में हैं और कोर में नहीं, बस
रिश्तेदार लोकप्रियता के आधार। लेकिन जूलिया की घोषणा की तरह
स्वतंत्रता कहती है, जूलिया लालच से पैदा हुई है। और जैसे गॉर्डन गेको कहते हैं,
लालच अच्छा है। :)
21 मार्च, 2014 3:14 AM पर, "डेविड हेगन" सूचनाएं @github.com ने लिखा:

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

इस ईमेल का उत्तर सीधे दें या Gi tHubhttps: //github.com/JuliaLang/julia/issues/4774#issuecomment -38262998 पर देखें
।

मुझे लगता है कि निर्बाध एकीकरण निश्चित रूप से एक समृद्ध पर्याप्त प्रकार का परिवार है। तिववो का https://github.com/JuliaLang/julia/issues/4774#issuecomment -32693110 तक का विस्तार, यह विशेष रूप से इस तरह से शुरू हो सकता है:

immutable AbstractTensorArray{T, N, UPMASK, DOWNMASK} <: AbstractArray{T, N}
    A::AbstractArray{T, N}
end
# where !any(UPMASK & DOWNMASK)

typealias AbstractColumnVector{T} AbstractTensorArray{T, 1, [true], [false]}
typealias AbstractRowVector{T} AbstractTensorArray{T, 1, [false], [true]}
typealias AbstractMatrix{T} AbstractTensorArray{T, 2, [false, true], [true, false]}

(वर्तमान में AbstractMatrix{T} बस उपनाम AbstractArray{T, 2} ; संभावित रूप से, एक और नाम यहाँ इस्तेमाल किया जा सकता है)

यहाँ से निम्नलिखित कार्यान्वयन तर्कसंगत लगते हैं:

1. सामान्यीकृत transpose पद्धति, आयामों और संबंधित UPMASK और DOWNMASK सूचकांकों के बाद, फिर UPMASK और DOWNMASK को इंटरचेंज करता है। तटस्थ आयाम अप्रभावित रहेंगे।
2. किसी भी AbstractArray{T, N} उपप्रकारों को आमतौर पर डिफ़ॉल्ट रूप से परिवर्तित करके AbstractTensorArray{T, N, [..., false, true, false, true], [..., true, false, true, false]} दसियों परिचालनों में बदल दिया जाता है। यह जूलिया के विशेष सरणी वाक्यविन्यास को वैक्टर और मैट्रिस के लिए संरक्षित करता है।
3. एक विधायक विधि ( array लिए AbstractTensorArray का उपयोग तटस्थ आयामों का उत्पादन करने के लिए किया जाता है, और एक संयुक्त AbstractTensorArray बनाने के लिए अन्य AbstractTensorArray s (या प्रकार परिवर्तनीय उपचार) का संयोजन कर सकते हैं। AbstractTensorArray तटस्थ शीर्ष-स्तरीय आयाम के साथ।

@Drhagen के उदाहरणों को ध्यान में रखते हुए:

वेक्टर-मैट्रिक्स गुणन, स्केलर-सरणी गुणन

c = 1               # Int
v = [1, 2]          # Array{Int, 1}
M = [[1, 2] [3, 4]] # Array{Int, 2}

# scalar-array
c * M               # UNCHANGED: *(Int, Array{Int, 2}) => Array{Int, 2}

# matrix-vector
M * v               # *(Array{Int, 2}, Array{Int, 1}) => *(Matrix{Int}, ColumnVector{Int}) => ColumnVector{Int}

# vector-matrix
v' * M              # transpose(Array{Int, 1}) => transpose(ColumnVector{Int}) => RowVector{Int}
                    # *(RowVector{Int}, Array{Int, 2}) => *(RowVector{Int}, Matrix{Int}) => RowVector{Int}

# (1-array)-(2-array)
v .* M              # UNCHANGED: .*(Array{Int, 1}, Array{Int, 2}) => Array{Int, 2}

(का उपयोग कर Matrix एक परिभाषा के लिए इसी के साथ AbstractMatrix उपरोक्त परिभाषा)

सरणी के एक सरणी पर एक सरणी के अतिरिक्त वितरण

मैं इसका मतलब, शब्दार्थ, वैक्टर के एक सरणी पर एक वेक्टर के अलावा, मैट्रिक्स के एक सरणी पर एक मैट्रिक्स के अलावा, और इसी तरह ले रहा हूं:

# vector-(vector-array)
ws = array([1, 2], [3, 4])
                    # TensorArray{Int, 2, [false, true], [false, false]}
v + ws              # +(Array{Int, 1}, TensorArray{Int, 2, [false, true], [false, false]}) => +(ColumnVector{Int}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 2, [false, true], [false, false]}
# => array([2, 4], [4, 6])

# array-(vector-array)
u = array(1, 2)     # TensorArray{Int, 1, [false], [false]}
u + ws              # +(TensorArray{Int, 1, [false], [false]}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 2, [false, true], [false, false]}
# => array([2, 3], [5, 6])
# alternatively:
v .+ ws             # .+(Array{Int, 1}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 2, [false, true], [false, false]}
# => array([2, 3], [5, 6])
# same effect, but meaning less clear:
v .+ M              # UNCHANGED: .+(Array{Int, 1}, Array{Int, 2}) => Array{Int, 2}
# => [[2, 4] [4, 6]]

# matrix-(matrix-array)
Ns = array([[1, 2] [3, 4]], [[5, 6] [7, 8]])
                    # TensorArray{Int, 2, [false, false, true], [false, true, false]}
M + Ns              # +(Array{Int, 2}, TensorArray{Int, 2, [false, false, true], [false, true, false]}) => +(Matrix{Int}, TensorArray{Int, 2, [false, false, true], [false, true, false]}) => TensorArray{Int, 2, [false, false, true], [false, true, false]}
# => array([[2, 4] [6, 8]], [[6, 8] [10, 12]])

एक वेक्टर परिणाम v को कई अलग-अलग द्विघात रूपों से x'M*w1, x'M*w2, ... , अंतिम परिणाम के लिए x'M*w1*v, x'M*w2*v, ... : के मेरे पहले उदाहरण को देखते हुए:

x = v
x' * M * ws * v     # *(RowVector{Int}, Array{Int, 2}) => *(RowVector{Int}, Matrix{Int}) => RowVector{Int}
                    # *(RowVector{Int}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 1, [false], [false]}
                    # *(TensorArray{Int, 1, [false], [false]}, Array{Int, 1}) => *(TensorArray{Int, 1, [false], [false]}, ColumnVector{Int}) => TensorArray{Int, 1, [false, true], [false, false]}
# => array([27, 54], [59, 118])

इस उल्लेखनीय कार्यान्वयन में, मैंने मान लिया है कि AbstractArray अकेला बचा है, और इस प्रकार AbstractTensorArray प्रकार की पदानुक्रम में अपना "स्थान" बनाता है। यदि AbstractArray परिवार को केवल AbstractTensorArray द्वारा प्रतिस्थापित किया गया, तो चीजें सरल हो सकती हैं, लेकिन यह एक और चर्चा है।

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

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

बेशक, सामान्य ट्रांसपोज़ेशन और जटिल संयुग्मन वास्तव में इस सेटिंग में अच्छी तरह से परिभाषित नहीं होते हैं (यानी ये स्वतंत्र अवधारणाओं का आधार नहीं हैं)

न्यूनतम रूप से, यह कुछ इस तरह दिखता है:

immutable Space
    dim::Int
    dual::Bool
end
Space(dim::Int)=Space(dim,false) # assume normal vector space by default
dual(s::Space)=Space(s.dim,!s.dual)

matrix=Tensor((Space(3),dual(Space(5))))
# size is no longer sufficient to characterise the tensor and needs to be replaced by space
space(matrix) # returns (Space(3),dual(Space(5))) 
space(matrix') # returns (Space(5),dual(Space(3)))

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

मैंने हमेशा सोचा है कि इंजीनियरिंग / भौतिकी में दसियों का उपयोग कैसे किया जाता है और गणितीय सॉफ्टवेयर प्रोग्राम में उन्हें कैसे संभाला जाता है, के बीच घनिष्ठ संबंध नहीं है। मुझे इस विषय पर एक दिलचस्प स्टैक एक्सचेंज वार्तालाप मिला ... http://math.stackexchange.com/questions/412423/differences-between-a-matrix-and-a-tensor। यहाँ भी, एक अच्छा संदर्भ पोस्ट था।
http://www.mat.univie.ac.at/~neum/physfaq/topics/tensors

मैं अपने दैनिक वैज्ञानिक कंप्यूटिंग के लिए मतलाब का बहुत उपयोग करता हूं, लेकिन जूलिया पर एक नौसिखिया। यहाँ, मैं ध्यान देता हूँ कि उच्च-आयामी ऐरे गुणा और ट्रांसपोज़िशन या इसी तरह के अन्य ऐरे ऑपरेशंस पर बहुत सारी चर्चाएँ होती हैं। मैं http://www.mathworks.com/matlabcentral/fileexchange/8773-multiple-matrix-multiplications--with-array-expansion-enabled पर एक नज़र डालने का सुझाव देता हूं

यह मूल रूप से सिंटैक्स का अनुसरण करता है, जो @drhagen ने पहले की पोस्ट में उल्लिखित है, जैसे कि array_product (A, B, inner_A_dim = [1, 2], inner_B_dim = [3, 4], सरणियों A और B के बीच के उत्पाद के लिए दिए गए आंतरिक आयाम।

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

आपके संदर्भ के लिए: INV ऑपरेशन के लिए मतलाब में एक और समान कार्यान्वयन यहां है: http://www.mathworks.com/matlabcentral/fileexchange/31222-inversion-every-2d-slice-for-arbiteath-multi-dimension-array

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

@ananedelman के शीर्ष के लिए प्रस्तावित समाधान के लिए यहां एक और वोट। यहाँ एक प्रेरक उदाहरण है।

अभी, एक पंक्ति-स्लाइस 2d सरणी है, जबकि एक कॉलम स्लाइस 1d सरणी है; जो अजीब तरह से असममित और बदसूरत है:

julia> A = randn(4,4)
4x4 Array{Float64,2}:
  2.12422    0.317163   1.32883    0.967186
 -1.0433     1.44236   -0.822905  -0.130768
 -0.382788  -1.16978   -0.19184   -1.15773
 -1.2865     1.21368   -0.747717  -0.66303

julia> x = A[:,1]
4-element Array{Float64,1}:
  2.12422
 -1.0433
 -0.382788
 -1.2865

julia> y = A[1,:]
1x4 Array{Float64,2}:
 2.12422  0.317163  1.32883  0.967186

विशेष रूप से, इसका मतलब है कि मैं एक पंक्ति को एक कॉलम से गुणा नहीं कर सकता और कुछ संख्या को बिना किसी बुरी तरह से छेड़छाड़ किए बिना निकाल सकता हूं

julia> dot(y[:],x)
2.4284575954571106
julia> (y*x)[1]
2.42845759545711

यह एक सुसंगत प्रस्ताव नहीं है जब तक आप '* एक विशेष ऑपरेटर नहीं बनाते हैं, जो बहुत संदिग्ध है, तब से x'*y और (x')*y अर्थ एक ही बात नहीं है। इसके अलावा, यह गुणन को गैर-सहयोगी बना देगा।

मैं x_y 'और y'_x के साथ कठिनाइयों को समझता हूं। इसका इलाज बेहतर हो सकता है
आंतरिक और बाहरी उत्पादों को अलग-अलग ऑपरेशन के रूप में, उदाहरण के लिए डॉट () का उपयोग करके। (शायद
cdot का उपयोग करके भी?)

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

बुध पर, जुलाई 16, 2014 को 8:17 बजे, स्टीफन करपिंस्की सूचनाएं @github.com
लिखा था:

यह एक सुसंगत प्रस्ताव नहीं है जब तक कि आप '* एक विशेष ऑपरेटर नहीं बनाते हैं, जो
बहुत संदिग्ध है, तब से x'_y और (x ') _ y का अर्थ एक ही बात नहीं है।
इसके अलावा, यह गुणन को गैर-सहयोगी बना देगा।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment -49254346

मेडेलीन उडेल
कम्प्यूटेशनल और गणितीय इंजीनियरिंग में पीएचडी उम्मीदवार
स्टैनफोर्ड विश्वविद्यालय
www.stanford.edu/~udell

@ हस्तलिखित , मैं

एक बार जब हम ऐरे व्यू पर स्विच करते हैं, तो उन दिशाओं का पता लगाना आसान हो जाएगा। विशेष रूप से, slice(A, i, :) कहने से आपको वह व्यवहार मिलता है जो आप चाहते हैं। (यह अभी ऐसा करता है, लेकिन एक धीमी प्रकार की शुरुआत करने की कीमत पर, सबर्रे।)

विशुद्ध रूप से गणितीय दृष्टिकोण से, यहाँ प्रस्तुत सभी मुद्दे (और बीच में भ्रम) से आते हैं कि हमें ऐरे से क्या मतलब है और हम वैक्टर / टेनर्स / मैट्रीस से क्या मतलब है। Arrays, वैचारिक रूप से, केवल सूचियाँ हैं (या, n- मंद सरणियों के मामले में, सूचियों की सूची)। जैसे, सरणी गुणन, ट्रांसपोज़िशन इत्यादि के संचालन के लिए कोई प्राकृतिक विनिर्देश नहीं है, जबकि परमिटधारी, तत्व-वार संचालन और अक्ष-विशिष्ट संचालन (मतलब, मंझला, आदि) जैसे कार्य समझ में आते हैं और विशिष्ट रूप से परिभाषित किए जा सकते हैं प्राकृतिक तरीके से, डॉट उत्पाद जैसे ऑपरेशन नहीं हो सकते।

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

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

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

इस परिप्रेक्ष्य का व्यावहारिक निहितार्थ यह प्रतीत होता है कि सरणियों को टेंसरों के सबसेट के साथ पहचाना जाना चाहिए, और 1-डी सरणी को स्थानांतरित करने पर DualVector या शायद एक त्रुटि देनी चाहिए। मेरा विचार है कि यह वास्तविक संख्याओं पर परिचालनों के अनुरूप है जो जटिल संख्याएँ देते हैं।

मेरा दृष्टिकोण यह होगा कि सामान्य AbstractArray परिवार, (एक बहुआयामी) डेटा कंटेनर, किसी भी तकनीकी प्रोग्रामिंग भाषा का एक अनिवार्य हिस्सा होने के लिए पर्याप्त रूप से सामान्य है। सख्त गणितीय नियमों का पालन करने वाला एक टेंसर, भले ही मैं इसकी देखभाल करता हूं, एक समर्पित पैकेज के लिए एक अच्छी वस्तु है। वास्तव में, मैं https://github.com/Jutho/TensorToolbox.jl में @jdbates द्वारा निर्दिष्ट लाइनों के साथ कुछ पर काम कर रहा हूं। यह अब तक अनियंत्रित है और काफी हद तक अप्रयुक्त है। मैंने इसे उन चीजों के लिए लिखा है जिनकी मुझे व्यक्तिगत रूप से कई शरीर भौतिकी में आवश्यकता है, लेकिन मुझे आशा है कि इसका निर्माण इस तरह से किया गया है कि गणितज्ञों और भौतिकविदों के बड़े समुदाय के लिए उपयोगी होने के लिए पर्याप्त रूप से सामान्य और एक्स्टेंसिबल है जो टेनर्स के साथ काम करने की परवाह करते हैं।

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

तो पैकेज का पहला भाग वेक्टर रिक्त स्थान को परिभाषित करने के लिए सार भाग है, जहां मैं जूलिया वस्तुओं के प्रकार पदानुक्रम को वेक्टर रिक्त स्थान के गणितीय पदानुक्रम से मेल खाता हूं। एक सामान्य वेक्टर अंतरिक्ष V चार किस्मों में आता है, जो V पर सामान्य रैखिक समूह के प्रतिनिधित्व सिद्धांत के अनुरूप है, अर्थात V (मौलिक प्रतिनिधित्व), संयोजन (V), दोहरे (V) और दोहरे (conj) (V)। वास्तविक वेक्टर रिक्त स्थान के लिए, कंजर्वेशन (V) = V और केवल V और डुअल (V) है, जो कि कंट्राविरेंट और सहसंयोजक वैक्टर के अनुरूप है। फिर आंतरिक उत्पाद स्थान हैं, और पदानुक्रम के शीर्ष स्तर पर यूक्लिडियन रिक्त स्थान हैं, जो एक मानक यूक्लिडियन आंतरिक उत्पाद (यानी ऑर्थोगोनल आधार) के साथ आंतरिक उत्पाद स्थान हैं। भौतिक विज्ञान में, वेक्टर रिक्त स्थान के बारे में सोचना भी उपयोगी है जो विभिन्न क्षेत्रों में विघटित होते हैं, अर्थात उन्हें समरूपता क्रियाओं के उदाहरणों के अप्रासंगिक प्रतिनिधित्व द्वारा वर्गीकृत किया जाता है।

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

फिर टेनर्स पर परिभाषित कुछ निश्चित ऑपरेशन होने चाहिए, जिनमें से सबसे महत्वपूर्ण टेनर्स को अनुबंधित करना है, लेकिन यह भी, जैसे कि ऑर्थोगोनल फैक्टरिस (एकवचन मूल्य विघटन) आदि। आखिर में रैखिक नक्शे होने चाहिए जो एक के बाद एक टेनॉर को मैप करते हैं। वे एक विशेष प्रकार के लायक हैं कि आम तौर पर उन्हें पूरी तरह से मैट्रिक्स के रूप में सांकेतिक शब्दों में बदलना नहीं चाहते हैं, बल्कि एक तरह से मैट्रिक्स वेक्टर उत्पाद को कुशलता से गणना की जा सकती है, ताकि पुनरावृत्त तरीकों (लैंक्ज़ोस आदि) में उपयोग के लिए। मेरे अब तक के दो मौजूदा पैकेज (TensorOperations.jl और LinearMaps.jl) मानक Arrays के लिए इस कार्यक्षमता को कार्यान्वित करते हैं, निर्माणाधीन टेंसर टूलबॉक्स नए AbstractTensor पदानुक्रम के लिए उन्हें अधिभार / पुनर्परिभाषित करेगा।

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

अंत में, मानक जूलिया के साथ इंटरॉप बुला से आता है tensor पर एक मानक Array है, जो इसे प्रकार का ऑब्जेक्ट में लपेटता Tensor के प्रकार के रिक्त स्थान के लिए जुड़े सूचकांक के साथ CartesianSpace । यह यूक्लिडियन उत्पाद के साथ मानक वास्तविक वेक्टर स्पेस आर ^ एन है, जहां सहसंयोजक और कॉन्ट्रावैरिएंट इंडेक्स के बीच कोई अंतर नहीं है। मुझे लगता है कि यह सबसे अच्छा है जो एक मानक जूलिया ऐरे है।

@ जेफ़ बेज़ेनसन , मैं महत्वाकांक्षी हूं। कोई भी जानकारी उस तरह से नहीं खोई जाती है, लेकिन एक ही समय में सरणियों के लिए कई संभावित व्याख्याएं होती हैं, और टेंसर व्याख्या हमेशा (या आमतौर पर भी) समझ में नहीं आती है। छवियों पर विचार करें: एक छवि को एक (आमतौर पर 2d) कई गुना पर वेक्टर-मूल्यवान क्षेत्र के रूप में सोचा जा सकता है। उस क्षेत्र को एक आयताकार ग्रिड में प्रतिबंधित करने से आपको एक संरचना मिलती है, जो स्वाभाविक रूप से, आप एक 3 डी सरणी का उपयोग करके प्रतिनिधित्व करना चाहेंगे। हालाँकि, वास्तव में, यह ग्रिड बिंदुओं के स्थान से {R, G, B} सदिश स्थान में केवल एक मैपिंग है, इसलिए पहले दो आयामों (ग्रिड के x और y लेबल) का ज्यामितीय अर्थ, से अलग है तीसरे आयाम का ज्यामितीय अर्थ (जो वास्तव में एक वेक्टर है)।

मैं @Jutho के विरोध में अलग पैकेज में

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

मैं आपसे सहमत हूं कि यह वैचारिक रूप से वास्तविक संख्याओं के संचालन के समान है जो जटिल संख्याओं को वापस करते हैं।

छवियों पर विचार करें: एक छवि को एक (आमतौर पर 2d) कई गुना पर वेक्टर-मूल्यवान क्षेत्र के रूप में सोचा जा सकता है। उस क्षेत्र को एक आयताकार ग्रिड में प्रतिबंधित करने से आपको एक संरचना मिलती है, जो स्वाभाविक रूप से, आप एक 3 डी सरणी का उपयोग करके प्रतिनिधित्व करना चाहेंगे। हालाँकि, वास्तव में, यह ग्रिड बिंदुओं के स्थान से {R, G, B} सदिश स्थान में केवल एक मैपिंग है, इसलिए पहले दो आयामों (ग्रिड के x और y लेबल) का ज्यामितीय अर्थ, से अलग है तीसरे आयाम का ज्यामितीय अर्थ (जो वास्तव में एक वेक्टर है)।

हालांकि यह आपके समग्र संदेश को संबोधित या दूर नहीं करता है, https://github.com/timholy/Images.jl/pull/135 छवियों के लिए इस विचार के कार्यान्वयन की दिशा में काम कर रहा है। मुझे उम्मीद है कि यह रंग संरचना टेंसर्स से निपटने में भी आसान बनाता है, जिसे मैं एक परियोजना के लिए उपयोग करना चाहता हूं।

23 अगस्त 2014 को, 20:36 पर, jdbates सूचनाएं @github.com ने लिखा:

@ जेफ़ बेज़ेनसन , मैं महत्वाकांक्षी हूं। कोई भी जानकारी उस तरह से नहीं खोई जाती है, लेकिन एक ही समय में छवियों के लिए कई संभावित व्याख्याएं होती हैं, और दहाई की व्याख्या हमेशा (या आमतौर पर भी) समझ में नहीं आती है। छवियों पर विचार करें: एक छवि को एक (आमतौर पर 2d) कई गुना पर वेक्टर-मूल्यवान क्षेत्र के रूप में सोचा जा सकता है। उस क्षेत्र को एक आयताकार ग्रिड में प्रतिबंधित करने से आपको एक संरचना मिलती है, जो स्वाभाविक रूप से, आप एक 3 डी सरणी का उपयोग करके प्रतिनिधित्व करना चाहेंगे। हालाँकि, वास्तव में, यह ग्रिड बिंदुओं के स्थान से {R, G, B} सदिश स्थान में केवल एक मैपिंग है, इसलिए पहले दो आयामों (ग्रिड के x और y लेबल) का ज्यामितीय अर्थ, से अलग है तीसरे आयाम का ज्यामितीय अर्थ (जो वास्तव में एक वेक्टर है)।

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

मैं @Jutho के विरोध में अलग पैकेज में

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

मैं आपसे सहमत हूं कि यह वैचारिक रूप से वास्तविक संख्याओं के संचालन के समान है जो जटिल संख्याओं को वापस करते हैं।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

सरणियों के लिए कई संभावित व्याख्याएं हैं, और टेंसर व्याख्या हमेशा (या आमतौर पर भी) समझ में नहीं आती है। छवियों पर विचार करें: एक छवि को एक (आमतौर पर 2d) कई गुना पर वेक्टर-मूल्यवान क्षेत्र के रूप में सोचा जा सकता है। उस क्षेत्र को एक आयताकार ग्रिड में प्रतिबंधित करने से आपको एक संरचना मिलती है, जो स्वाभाविक रूप से, आप एक 3 डी सरणी का उपयोग करके प्रतिनिधित्व करना चाहेंगे। हालाँकि, वास्तव में, यह ग्रिड बिंदुओं के स्थान से {R, G, B} सदिश स्थान में केवल एक मैपिंग है, इसलिए पहले दो आयामों (ग्रिड के x और y लेबल) का ज्यामितीय अर्थ, से अलग है तीसरे आयाम का ज्यामितीय अर्थ (जो वास्तव में एक वेक्टर है)।

यह सिर्फ इस तरह का अंतर था जिसे मैं व्यूइंग AbstractTensorArray https://github.com/JuliaLang/julia/issues/4774#issuecomment -382323295 में कैप्चर करने का प्रयास कर रहा था। - समान आयाम। इस योजना के तहत, मैं आपके उदाहरण का प्रतिनिधित्व करने की अपेक्षा करूंगा

AbstractTensorArray{Uint8, 3, [false, true, false], [true, false, false]}

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

मैंने @Jutho का उल्लेख करने वाले संयुग्मन अभ्यावेदन पर विचार नहीं किया था, लेकिन मुझे लगता है कि इस सामान्यीकरण को जटिल स्थानों के लिए, उसी मास्किंग दृष्टिकोण को आगे बढ़ाकर नियंत्रित किया जा सकता है।

जिस प्रश्न को हम वास्तव में यहाँ पूछने की कोशिश कर रहे हैं वह यह है कि "रेखीय बीजगणित किस डोमेन में होना चाहिए?"

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

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

मुझे लगता है कि आप यहां कुछ मिला रहे हैं। ऊपर चर्चा में, यह वास्तव में समझाया गया था कि x और y निर्देशांक वेक्टर अंतरिक्ष की व्याख्या नहीं करते हैं, क्योंकि वे एक मनमाने ढंग से घुमावदार कई गुना पर निर्देशांक के अनुरूप हो सकते हैं, जरूरी नहीं कि एक सपाट स्थान। यह आरजीबी आयाम था जिसे वेक्टर व्याख्या दी गई थी, हालांकि यह वास्तव में सबसे अच्छा विकल्प भी नहीं हो सकता है, जैसा कि मुझे याद है (मुझे छवि प्रसंस्करण में एक सभ्य पृष्ठभूमि नहीं है) कि रंग स्थान भी घुमावदार है। इसके अलावा, यहां तक ​​कि उस मामले के लिए भी जहां डोमेन (x और y) एक वेक्टर स्थान बनाता है, x और y ऊपर और नीचे क्यों होगा, या यह आपके संकेतन के उदाहरण के रूप में था?

वैसे भी, मैंने भी TensorToolbox.jl के साथ कुछ प्रकार के मापदंडों या मुखौटे के रूप में सहसंयोजक और कॉन्ट्रावेरिएंट सूचकांकों को दर्शाते हुए शुरू किया, लेकिन यह जल्द ही एक पूर्ण दुःस्वप्न बन जाता है, यही कारण है कि मैं एक प्रतिनिधित्व में बदल गया हूं, जहां हर टेंसर कुछ वेक्टर अंतरिक्ष का एक तत्व है। , और संचालन करने के लिए, किसी को उस रिक्त स्थान से मेल खाना है, ठीक उसी तरह जैसे कि आपको उस आकार की जांच करने की आवश्यकता होती है जब सरणियों के साथ संचालन करते हैं।

x और y निर्देशांक वेक्टर स्पेस की व्याख्या नहीं करते थे

क्षमा करें, मैंने "आयताकार ग्रिड" को फैलाया है --- मुझे लगता है कि

हर टेंसर कुछ वेक्टर स्पेस का एक तत्व है

एक अच्छा विचार की तरह लगता है --- मुझे उपयोगकर्ता के लिए काम करने के कुछ उदाहरण देखने में दिलचस्पी होगी (मुझे कोड पढ़ने में बहुत दूर नहीं मिला)।

मुझे इस मुद्दे के लिए एक नया प्रस्ताव मिला है।

(1) एपीएल-शैली टुकड़ा करने की क्रिया।

size(A[i_1, ..., i_n]) == tuple(size(i_1)..., ..., size(i_n)...)

विशेष रूप से, इसका मतलब है कि "सिंगलटन स्लाइस" - यानी स्लाइस जहां सूचकांक स्केलर या शून्य-आयामी है - हमेशा गिरा दिया जाता है और M[1,:] और M[:,1] दोनों वैक्टर होते हैं, बजाय एक वेक्टर होने के जबकि दूसरा एक पंक्ति मैट्रिक्स, या कोई अन्य ऐसा अंतर है।

(2) वैक्टर और मैट्रिसेस के लिए Transpose और ConjTranspose रैपर पेश करें। दूसरे शब्दों में, कुछ इस तरह से:

immutable Transpose{T,n,A<:AbstractArray} <: AbstractArray{T,n}
    array::A
end
Transpose{T,n}(a::AbstractArray{T,n}) = Transpose{T,n,typeof(a)}(a)

और ये सभी उपयुक्त तरीके हैं जो इन कामों को बनाने के लिए वैक्टर और मेट्रिसेस के लिए चाहिए। हम इसे केवल वैक्टर और मैट्रिस के लिए काम करने के लिए सीमित करना चाह सकते हैं, क्योंकि यह स्पष्ट नहीं है कि मनमाना आयामों के लिए एक सामान्य संक्रमण का क्या मतलब होना चाहिए (हालांकि सिर्फ उलट आयाम आकर्षक है)। जब आप लिखना a' आपको मिल ConjTranspose(a) और इसी तरह v.' का उत्पादन Transpose(a) ।

(3) ट्रांसफ़ेक्टेड वैक्टर और मैट्रीज़ के लिए विभिन्न विशेष विधियों को परिभाषित करें, जैसे:

*(v::Transpose{T,1}, w::AbstractVector) = dot(v.array,w)
*(v::AbstractVector, w::Transpose{T,1}) = [ v[i]*w[j] for i=1:length(v), j=1:length(w) ]

आदि, सहित सभी भयानक At_mul_B कार्यों और विशेष आलसी (संयुग्मित) के साथ पार्स निर्माण के बाद Transpose और ConjTranspose प्रकारों पर प्रेषण के बाद निर्माण।

(4) उन मामलों में प्रसारण परिचालन को प्रतिबंधित करें जहां तर्कों या सरणियों को समान संख्या में आयामों के साथ रखा गया है। इस प्रकार, निम्नलिखित, जो वर्तमान में दिखाए गए अनुसार काम करता है, विफल हो जाएगा:

julia> M = rand(3,4);

julia> M./M[1,:]
3x4 Array{Float64,2}:
 1.0       1.0       1.0      1.0
 0.516884  0.675712  2.11216  9.0797
 1.00641   0.726229  2.48336  4.38751

julia> M./M[:,1]
3x4 Array{Float64,2}:
 1.0  0.891557  0.561464  0.103968
 1.0  1.16552   2.29433   1.82633
 1.0  0.643353  1.38544   0.453257

इसके बजाय, आपको ऐसा कुछ करना होगा:

julia> M./M[[1],:]
3x4 Array{Float64,2}:
 1.0       1.0       1.0      1.0
 0.516884  0.675712  2.11216  9.0797
 1.00641   0.726229  2.48336  4.38751

julia> M./M[:,[1]]
3x4 Array{Float64,2}:
 1.0  0.891557  0.561464  0.103968
 1.0  1.16552   2.29433   1.82633
 1.0  0.643353  1.38544   0.453257

मेरा मानना ​​है कि यह प्रस्ताव हमारे पास वर्तमान में मौजूद सभी प्रमुख मुद्दों को हल करता है:

1. सममित स्लाइसिंग व्यवहार - अनुगामी आयाम अब विशेष नहीं हैं।
2. v'' === v ।
3. v' == v ।
4. v'w v और w का डॉट उत्पाद है - विशेष रूप से, यह एक स्केलर है, न कि एक-तत्व वेक्टर।
5. v*w' v और w का बाहरी उत्पाद है।
6. M*v एक सदिश राशि है।
7. M*v' एक त्रुटि है।
8. v'*M एक ट्रांसपोज़्ड वेक्टर है।
9. v*M एक त्रुटि है।
10. At_mul_B ऑपरेटरों और विशेष पार्सिंग चले जाते हैं।

: +1: सभी को। मैंने # 6837 में 2 और 3 पर कुछ काम किया, लेकिन इसे कभी खत्म नहीं किया। @simonbyrne ने भी इसमें देखा।

+1 भी। ऐसा लगता है कि यह सभी जगह पर काफी सुसंगत व्यवहार प्रस्तुत करेगा।

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

हाँ कृपया! टेंसर ट्रांसपोज़ को संभवतः किसी भी उपयोगकर्ता-परिभाषित क्रमपरिवर्तन की अनुमति देनी चाहिए, साथ ही डिम को डिफ़ॉल्ट के रूप में उलट देना चाहिए।

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

ऐसा लगता है कि यह प्रकार को थोड़ा और जटिल कर देगा, शायद हमारे पास PermuteDims प्रकार हो सकते हैं जो मनमाने ढंग से आलसी आयाम की अनुमति देता है।

@Stefan : यह सदिश और 2-मंद का काम करने के लिए एक बहुत अच्छा विचार है
बीजगणित। बस कुछ चुनौतियां:

1. कई-आयाम सरणी मामलों के बारे में: आयाम के साथ सरणी A के लिए
   (i_1, i_2, ..., i_n), यदि कोई चाहता है कि वह [i_2, i_3] पर लागू होने वाला स्थानान्तरण करे
   आयाम - या, यहां तक ​​कि हैश पर, [i_2, i_4] आयाम। क्या आप इसमें कर सकते हैं
   संक्रमण की नई परिभाषा?
2. सिंगलटन आयाम के बारे में: यह संभव है कि एक सिंगलटन स्लाइस हो
   जानबूझकर छोड़ दिया। क्या जूलिया को इस सिंगलटन आयाम को रखना चाहिए
   गणना? उदाहरण के लिए, यदि कोई वेक्टर को सरणी V के रूप में परिभाषित करता है
   आयाम (2,1), और एक मैट्रिक्स ए में संक्रमण को गुणा करना चाहता है
   आयाम (2,3,4)। क्या आप आयाम में v '* A का परिणाम प्राप्त कर सकते हैं
   (1,3,4)?

Thu पर, 16 अक्टूबर 2014 को दोपहर 2:31 बजे, स्टीफन करपिंस्की सूचनाएं @github.com
लिखा था:

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

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment -59425385।

पुन: 2 और 3: इस पर एक मोटा छुरा होने के कारण, मैं इस नतीजे पर पहुंचा कि वेक्टर ट्रांज़िशन AbstractVector का उपप्रकार नहीं होना चाहिए, अन्यथा सब कुछ गड़बड़ हो जाता है (# 6837 पर चर्चा देखें)। मुझे लगता है कि सबसे आगे रास्ता Transpose{T,A} <: AbstractMatrix{T} , और एक अलग Covector प्रकार (+ Conjugate वेरिएंट) के साथ है।

दूसरी महत्वपूर्ण समस्या जो मुझे सामने आई, वह यह है कि अक्सर आप एक विशिष्ट मैट्रिक्स प्रकार, इसके ट्रांसजेंड या इसके संयुग्मित ट्रांज़िशन पर प्रेषण करना चाहते हैं। दुर्भाग्य से, मैं इसे मौजूदा प्रकार की मशीनरी ( इस मेलिंग सूची चर्चा देखें ) के माध्यम से व्यक्त करने का एक तरीका नहीं दे सका। इसके बिना, मुझे लगता है कि हम तर्क के 3x3 संभव संयोजनों पर @eval -ing के लिए बहुत कुछ करेंगे।

@simonbyrne , मैं कार्यान्वयन के साथ आपके अनुभव को

मैंने इंगित किया है (कम-सार्वजनिक मंचों में, इसलिए यह शायद यहां एक संक्षिप्त उल्लेख सहन करता है) कि संभावित विकल्प सभी को आकार देने के लिए संभालता है _internally_, अनुक्रमण के प्रकारों का विस्तार करके, जो सबएयर्रे का उपयोग कर सकते हैं। विशेष रूप से, एक "ट्रांसपोज़्ड रेंज" प्रकार हो सकता है, जो सबएरे को एक ट्रांसपोज़्ड आकार प्रदान करेगा, तब भी जब मूल सरणी Vector । (देखें https://github.com/JuliaLang/julia/blob/d4cab1dd127a6e13deae5652872365653a5f4010/base/subarray.jl#L5-L9 यदि आप इस बात से अपरिचित हैं कि सबएयर्रेज़ कैसे लागू हो सकते हैं / हैं)।

मुझे यकीन नहीं है कि यह वैकल्पिक रणनीति जीवन को आसान या कठिन बनाती है। यह बाहरी रूप से सामना करने वाले प्रकारों की संख्या को कम करता है, जिसका अर्थ हो सकता है कि किसी को कम तरीकों की आवश्यकता है। (जैसा कि कोई है जो _still_ Color Images में Color संक्रमण के कारण लापता तरीकों में भर रहा है, यह एक गुड थिंग जैसा लगता है।) दूसरी ओर, सुविधाजनक त्रिकोणीय विवाद की अनुपस्थिति में। चयनात्मक तरीकों को लिखने के लिए कुछ हद तक अजीब है, जो @simonbyrne द्वारा उठाए गए समस्याओं को बढ़ा सकते हैं।

किसी भी अंतर्दृष्टि का सबसे अधिक स्वागत होगा।

इस तरह के विवरण के अलावा, मुझे @StefanKarpinski के प्रस्ताव का आकार पसंद है। मुझे एपीएल-स्टाइल इंडेक्सिंग के लिए तैयार नहीं किया गया है, लेकिन संतुलन पर मुझे संदेह है कि यह अब हमारे पास मौजूद माटलाब-व्युत्पन्न नियमों की तुलना में बेहतर विकल्प है।

दो विचार:

• यदि A[[2], :] जैसे इंडेक्सिंग मुहावरेदार हो जाते हैं, तो एकल इंडेक्स 2 को लपेटने के लिए वेक्टर बनाना थोड़ा व्यर्थ लगता है। क्या हमें समान चीज़ के लिए A[(2,), :] अनुमति देने पर विचार करना चाहिए, या कुछ इसी तरह का? मुझे लगता है कि एक एकल तत्व रेंज ठीक है, लेकिन इसके लिए एक सिंटैक्स होना अच्छा होगा जो [2] रूप में लगभग सुविधाजनक है।
• अगर हमें प्रसारण करने के लिए कई आयामों के मिलान की आवश्यकता है, तो एक सरणी में सिंगलटन आयामों को जोड़ने का एक सरल तरीका होना चाहिए, शायद कुछ खामियों की तरह newaxis इंडेक्सिंग।

मैं यह प्रस्तावित करने के बारे में सोच रहा था कि अर्धविराम के साथ अनुक्रमण, एक ला A[2;:] , एक अलग अनुक्रमण मोड हो सकता है, जहां परिणाम में हमेशा A के समान आयाम होते हैं - अर्थात कोई एकल नहीं छोड़ते हैं और साथ अनुक्रमण करते हैं एक से अधिक रैंक वाली कोई भी त्रुटि है। सरलता के लिए मुख्य प्रस्ताव से बाहर जाने का फैसला किया, लेकिन ऐसा कुछ होना एक अच्छी बात लगती है।

मैं @simonbyrne द्वारा व्यक्त की गई चिंताओं को देख सकता Transpose या Covector प्रकार AbstractArray का उपप्रकार भी कुछ हद तक अनियंत्रित महसूस नहीं करता है। एक संभावित रिज़ॉल्यूशन, जो एक बड़ा ब्रेकिंग परिवर्तन होगा और शायद इस पर विचार नहीं किया जाएगा (लेकिन मैं इसे वैसे भी उल्लेख करना चाहता था) पूरे AbstractArray परिवार को एक अतिरिक्त प्रकार का पैरामीटर trans , जो :N , :T या :C मान हो सकते थे। सभी तरीकों के लिए जो केवल एक वेक्टर को एक-आयामी संख्याओं की सूची मानते हैं, उन्हें इस अंतिम पैरामीटर के विभिन्न मूल्यों के बीच अंतर करने की आवश्यकता नहीं होगी, और इसलिए संबंधित विधि परिभाषाएं अभी भी बनी रह सकती हैं।

एन> 2 के साथ एन-आयामी सरणियों के लिए, विभिन्न विकल्प हैं। या तो transpose एक त्रुटि देता है और वास्तव में AbstractArray{3,Float64,trans} trans!=:N या :T का एक ऑब्जेक्ट बनाना असंभव है, जो वैकल्पिक रूप से पंक्ति का अर्थ है और एक सामान्य सरणी के transpose सभी आयामों को उलटने का प्रभाव पड़ता है। मुझे लगता है कि उत्तरार्द्ध उन लोगों द्वारा स्वीकार किए गए सम्मेलन भी है जो पेनरोज़ ग्राफिकल नोटेशन (http://en.wikipedia.org/wiki/Penrose_graphical_notation देखें) का उपयोग करते हैं, हालांकि ट्रांसपोज़न की व्याख्या नहीं की गई है, लेकिन Cititanović द्वारा उद्धृत पुस्तक भी देखें।

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

मुझे यकीन है कि इस दृष्टिकोण से संबंधित कुछ नए मुद्दे हैं जिनके बारे में मैंने अभी तक सोचा नहीं है।

मुझे लगता है कि मैंने यहाँ प्रेषण समस्या है ।

@ जूथो का प्रस्ताव दिलचस्प लग रहा है, और मुझे लगता है कि खोज करने लायक है। दुर्भाग्य से, इन चीजों का मूल्यांकन करने का एकमात्र वास्तविक तरीका उन्हें लागू करने का प्रयास करना है।

@ तिवोह ,

• A[2:2,:] भी आयाम बनाए रखेगा, और इसके लिए आवंटन या किसी नए वाक्यविन्यास की आवश्यकता नहीं है।
• newaxis जैसा कुछ प्रख्यात संभव लगता है। वास्तव में, # 8501 में वास्तुकला के साथ यह संभव है कि अनुक्रमण द्वारा सीधे प्रसारण बनाया जाए: एक अनुक्रमणिका प्रकार है जो हमेशा 1 से हल होता है, चाहे कोई भी मूल्य उस स्लॉट में उपयोगकर्ता को भरता है।

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

बहुत अच्छा प्रस्ताव: +1:।

मुझे याद दिलाएं कि हम v' == v क्यों चाहते हैं?

हमें वास्तव में इसकी आवश्यकता नहीं है, लेकिन यह एक तरह का अच्छा है क्योंकि इसमें से एक (परिमित आयामी) सदिश स्थान का द्वीपीय आइसोमॉर्फिक है।

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

मुझे यकीन नहीं है कि हम v = = v चाहते हैं, लेकिन मुझे लगता है कि यह बहुत सुंदर है
बाकी। क्या हम एक स्तंभ मैट्रिक्स और एक वेक्टर चाहते हैं यदि वे बराबर की तुलना करें
समान तत्व हैं?

यह वास्तव में एक अलग मुद्दा है क्योंकि उनके पास विभिन्न आयाम हैं।

विशेष रूप से, यह प्रस्ताव एक वेक्टर और एक कॉलम मैट्रिक्स के बीच की पहचान को प्रभावी ढंग से हटा देता है - क्योंकि यदि आप किसी मैट्रिक्स को क्षैतिज रूप से या लंबवत स्लाइस करते हैं, तो आपको एक वेक्टर भी रास्ता मिल जाता है। पहले आप एक प्रकार के सिंगलटन आयामों को अनदेखा कर सकते थे - या यह दिखावा कर सकते थे कि वास्तव में वहाँ से अधिक थे। ऐसा करना अब एक अच्छा विचार नहीं होगा क्योंकि एक वेक्टर किसी भी सरणी के स्लाइस से आ सकता है।

अनुगामी सिंगलटन आयाम को जोड़कर convert 1-d से 2-d तक

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

एक बात जो मैंने # 8416 में नोट की है, वह यह है कि sparsevec अभी एकल-स्तंभ CSC मैट्रिक्स के रूप में गड़बड़ है। एक बार 1-डी स्पार्स वेक्टर प्रकार लागू होने के बाद स्पार्स इसे काफी अच्छी तरह से फिट करने में सक्षम होना चाहिए (जो सामान्य एनडी सीओओ प्रकार के सबसे सरल उपयोगी मामले के रूप में सामने आएगा, बस लिखने की जरूरत है)।

बस यह सब अंदर ले जाना। तो निम्नलिखित काम नहीं करेगा?

A [1,:] * A * A [:, 1] # मैट्रिक्स से * पंक्ति * मैट्रिक्स * कॉलम मैट्रिक्स से ???

आप ने लिखा

v'w v और w का डॉट उत्पाद है - विशेष रूप से, यह एक स्केलर है, न कि एक-तत्व वेक्टर।

इसके अलावा v '* w एक अदिश राशि है?

मुझे डॉट (x, y) किसी भी दो वस्तुओं को लेने का विचार पसंद है जिनकी आकृतियाँ हैं (1, ..., 1, m, 1, ..., 1) और
डॉट उत्पाद लौटाने से कोई फर्क नहीं पड़ता। लेकिन मैं x * y को इस अर्थ में डॉट (x, y) नहीं देना चाहता
जब तक x एक कोवेक्टर नहीं है और y एक वेक्टर है।

यकीन नहीं होता कि यह इतना हॉट आइडिया है लेकिन शायद यह ठीक होगा
A [:, 1,1] एक वेक्टर था और A [1,:, 1] या A [:, 1,:] कोवेक्टर थे।
वेक्टर के लिए एक आयाम के साथ ट्रेल करना बेहतर लगता है - स्लॉट, जिस पर आप
मानक रेखीय बीजगणित होने के साथ, टेंसर को अनुबंधित करने की अनुमति है
1 (पंक्ति वैक्टर) और 2 स्तंभ वैक्टर।

मेरे विचार में, इस मुद्दे में पहले जो दो प्रमुख चुनौतियाँ थीं, वे थीं:

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

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

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

जब आप कहते हैं, "... इस संबंध में उनकी डिज़ाइन सीमाएँ हैं (जैसा कि मैंने ऊपर चर्चा की है), वे कम से कम समर्थित हैं", क्या आप लापता कार्यक्षमता, या वैक्टर और हस्तांतरण के बारे में कुछ मौलिक बात कर रहे हैं जिन्हें संबोधित नहीं किया जा सकता है एक उच्च स्तर, या कार्यों को जोड़कर?

क्या इस प्रस्ताव के बारे में कुछ भी आपके बिंदुओं (ए) और (बी) में सुधार के साथ _conflict_ है?

मैं वास्तव में यह नहीं देखता कि टेनर के संकुचन को matlabs मानक गुणन ऑपरेटर * द्वारा समर्थित कैसे किया जाता है, या उस मामले के लिए matlab फ़ंक्शन में निर्मित किसी अन्य माध्यम से। Numpy में एक अंतर्निहित फ़ंक्शन है (मैं नाम भूल गया) लेकिन यह भी जहां तक ​​मुझे याद है, सीमित है।

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

Op 19-okt.-2014 om 22:52 heeft thomasmcfish सूचनाएं @github.com het volgende geschreven:

मेरे विचार में, इस मुद्दे में पहले जो दो प्रमुख चुनौतियाँ थीं, वे थीं:

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

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

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

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

यहाँ A के अंतिम सूचकांक और B के पहले सूचकांक पर संकुचन है
गणितज्ञ की बिंदी की तरह

function contract(A,B)
   s=size(A)
   t=size(B)
   reshape(reshape(A, prod(s[1:end-1]), s[end]) *  reshape(B,t[1],prod(t[2:end])) , [s[1:end-1]... t[2:end]...]...)
end

मैं हमेशा reshapes, परमिट और शायद जटिल के साथ सामान्य संकुचन करने में सक्षम रहा हूं
उपरोक्त की तरह कम या ज्यादा की जरूरत होने पर संयुग्मित करता है

यकीन नहीं है कि वास्तव में दसियों के साथ बड़ा मुद्दा क्या है, हम इनमें से कुछ को क्यों लागू नहीं कर सकते हैं
कार्यों?

हाँ बिल्कुल। इस मुद्दे में, हम सभी आगे बढ़ने के लिए समझौता करना चाहते हैं

1. अनुक्रमण में किस आयाम को छोड़ना है? "APL शैली" विवादास्पद लगती है।
2. vector' देता है?

दसियों संकुचन के लिए, उपयुक्त प्रकार और मंचित कार्यों के साथ, मुझे लगता है कि हम वास्तव में बहुत उच्च प्रदर्शन कार्यान्वयन प्राप्त कर सकते हैं।

मेरी भावना यह है कि दसियों खुद का ख्याल रखेंगे और हमें सुनिश्चित होना होगा
कि रैखिक बीजगणित उपयोगकर्ता निराश नहीं होते हैं।

मेरी सबसे बड़ी चिंता यह है कि

(2d सरणी से एक पंक्ति लें) * (2d सरणी) * (2d सरणी से एक कॉलम लें)

जब तक हम नहीं लेंगे तब तक एक सामान्य ऑपरेशन काम नहीं करेगा
(एक पंक्ति ले) कोवेक्टर के साथ या शायद बेहतर अभी तक
इसे सामान्य स्लॉट इंडेक्स के साथ टैग करें।

@JeffBezanson , जब मैं कहता हूं कि ये ऑपरेशन समर्थित हैं, तो मेरा मतलब है कि अंतर्निहित डेटा प्रकार और फ़ंक्शंस विशेष रूप से उनके साथ दिमाग में डिज़ाइन किए गए हैं, उदाहरण के लिए, जैसे कि Mathematica के Dot फ़ंक्शन। इस प्रकार, उपयोगकर्ता के लिए, कुछ काम करने के लिए एक अंतर्निहित, प्रलेखित और / या स्पष्ट तरीका है। किसी भी डिजाइन के लिए, कार्यों को जोड़कर किसी भी चीज के लिए समर्थन प्राप्त करना संभव है, जैसा कि वर्तमान कार्यान्वयन के साथ है; इसलिए यह तकनीकी संघर्ष का मुद्दा नहीं है, यह डिजाइन का मुद्दा है।

@ जूथो , मैं MATLAB का अधिक उपयोग नहीं करता, इसलिए मैं टिप्पणी नहीं कर सकता। मैं मानता हूं कि न्यूमपी का डिज़ाइन मैथमैटिक की तुलना में कम सुसंगत है (जैसा कि मैंने ऊपर चर्चा की है), लेकिन यह व्यवहारों की एक समृद्ध श्रेणी का भी समर्थन करता है। मैं मानता हूं कि बुनियादी रैखिक बीजगणित को उन उपयोगकर्ताओं के लिए सामान्य टेंसर मशीनरी को छोड़ देना चाहिए जिन्हें इसकी आवश्यकता नहीं है, लेकिन जूलिया की भयानक भाषा विशेषताओं के कारण, उनके लिए विचलन कार्यान्वयन शुरू करना आवश्यक नहीं लगता है, जैसा कि न्यूमपी और मैथमेटिका दोनों के पास है। कुछ हद तक करने के लिए मजबूर किया गया। मुझे यह प्रतीत हुआ कि यह मुद्दा कम से कम भाग में था, दोनों के लिए सही एकीकृत प्रणाली खोजने के बारे में, यह बताने के लिए कि सामान्य रैखिक बीजगणित मामलों के लिए क्या विशेषज्ञता का उपयोग किया जाना चाहिए: उदाहरण के लिए, vector' बारे में क्या करना है।

A [1,:] * A * A [:, 1] # मैट्रिक्स से * पंक्ति * मैट्रिक्स * कॉलम मैट्रिक्स से ???

सही - आपको A[1,:]' * A * A[:,1] लिखना होगा।

इसके अलावा v '* w एक अदिश राशि है?

हाँ, v'w एक ही चीज़ हैं। इस प्रस्ताव में एक अच्छी बात यह है कि यह सस्ते सिंटैक्टिक हैक्स को पूरी तरह से समाप्त कर देता है।

यकीन नहीं होता कि क्या ये इतना हॉट आइडिया है ...

मुझे नहीं लगता कि यह है। इस प्रस्ताव के लक्ष्यों में से एक स्लाइसिंग और इंडेक्सिंग नियमों को सममित बनाना है और यह एक सूचकांक को विशेष बना देगा, जो मुझे पूरे उद्देश्य को हराने के लिए लगता है। यदि स्लाइसिंग विषम हो रही है, तो हम वर्तमान व्यवहार को बनाए रख सकते हैं।

@thomasmcfish आपको बस अधिक विशिष्ट होना होगा। बेशक हर कोई चाहता है कि चीजें सुसंगत, प्रलेखित, स्पष्ट आदि हों। सवाल यह है कि क्या टेबल पर प्रस्ताव उन लक्ष्यों को पूरा करता है? हो सकता है कि वर्तमान प्रस्ताव उन लक्ष्यों को बिल्कुल प्रभावित न करे, जो ठीक है --- फिर जब तक यह कहीं और सुधार की ओर ले जाता है, तब भी हमारे पास शुद्ध सुधार है।

सीधे सीधे बात करते हैं

यदि A वर्ग नहीं है

| | करंट | प्रस्तावित | MATLAB |
| --- --- --- ---
| ए * ए [1 ,:] | नहीं | हाँ | नहीं |
| ए * ए [1 ,:] '| हाँ | नहीं | हाँ |
| ए [:, 1] ए | नहीं |
ए [:, 1] ' ए | हाँ | हाँ | हाँ |

और यदि A वर्ग है

| | करंट | प्रस्तावित | MATLAB |
| --- --- --- ---
| ए * ए [:, 1] | हाँ | हाँ | हाँ |
| ए * ए [:, 1] '| नहीं | नहीं | नहीं |
| ए [1,:] ए | नहीं |
ए [1,:] ' ए | नहीं | हाँ | नहीं |

मैं कसम खाता हूं कि मैंने सिर्फ इस बात का जवाब दिया है लेकिन किसी तरह यह गायब हो गया। यह सब सही है। वर्तमान व्यवस्था में, आपको यह विचार करने की आवश्यकता है कि आप पंक्ति स्लाइस ले रहे हैं या कॉलम स्लाइस के साथ-साथ यह भी कि क्या आप बाईं या दाईं ओर गुणा कर रहे हैं, यह निर्णय लेते समय कि क्या स्थानांतरित करना है या नहीं (कॉलम बाईं ओर स्थित हैं, पंक्तियों को स्थानांतरित किया गया है) दायीं ओर प्रत्यारोपित)। प्रस्ताव में, आप केवल इस बात पर विचार करते हैं कि आप किस पक्ष पर गुणा कर रहे हैं - आप हमेशा बाईं ओर स्थानांतरित करते हैं, कभी दाईं ओर नहीं।

क्या यह ठीक होगा अगर

dot(x,y) और dot(x.',y) और dot(x,y.') और dot(x.',y.') सभी एक ही स्केलर देते हैं?

यानी Σᵢ संयुग्मन (xᵢ) * yᵢ

इस तरह से कोई बहुत ज्यादा सोचे बिना डॉट (x, A * y) कर सकता है

एपीएल इंडेक्सिंग के कारण @alanedelman द्वारा उन उदाहरणों को उन स्थानों पर थोडा पिछड़ा A[i; :] ?)?

लेकिन फिर आप चाहते हैं कि ऊपर के मामले में एक कोवेक्टर देने के लिए।

@alanedelman , मुझे dot उन तरीकों का कोई कारण नहीं दिखाई देता है जो मौजूद नहीं होने चाहिए और वही परिणाम देते हैं।

मैं हमेशा reshapes, परमिट और शायद जटिल के साथ सामान्य संकुचन करने में सक्षम रहा हूं
उपरोक्त की तरह कम या ज्यादा की जरूरत होने पर संयुग्मित करता है

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

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

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

स्टीफन के प्रस्ताव के लिए +1। यह अत्यंत स्पष्ट लेकिन पर्याप्त रूप से लचीले शब्दार्थ को देने लगता है। एक रेखीय बीजगणित उपयोगकर्ता के रूप में, यहां तक ​​कि MATLAB शैली वाक्यविन्यास के आदी, मैं नियमों का उपयोग करने के लिए सरल पाऊंगा।

मैं थोड़ा उलझन में हूँ कि सामान्य रूप से ' का क्या अर्थ है। यदि v एक सदिश राशि है, तो v' एक transpose । यदि a 2d सरणी है, तो a' अब transpose भी होगा। ये दोनों आसानी से b के पहले आयाम के साथ a के पहले आयाम को अनुबंधित करके b' * a रूप में सक्षम होने के हित में परिभाषित किए गए लगते हैं।

a' की परिभाषा पर सर्वसम्मति नहीं प्रतीत होती है जब a का आयाम> 2 है। मैंने किसी को भी आयामों को उलटने के अलावा किसी और चीज के बारे में नहीं सुना है, और यह b' * a के साथ b के पहले आयाम के साथ a के पहले आयाम के साथ मेल खाता है।

मुझे लगता है कि यह अच्छा होगा अगर हम यह बता सकते हैं कि जिस चीज़ पर काम हो रहा है, उसके आकार का हवाला दिए बिना ' क्या करना है।

यह एक और संकुचन समारोह अधिक सामान्य परिस्थितियों के लिए बेस में उपलब्ध है, जैसे के लिए उचित लगता है contract(a, b, 2, 3) के 2 आयाम अनुबंध करने के लिए a 3 के साथ b ।

वैसे, dot(a,b) == a'*b जब a और b वैक्टर हैं, लेकिन dot(a,b) वर्तमान में मैट्रिसेस के लिए अपरिभाषित है। क्या हम dot(a,b) = trace(a'*b) ?

@ हस्तरेखा विज्ञान : मैं इस बारे में थोड़ा भ्रमित हूं कि सामान्य रूप से क्या माना जाता है।

मैं इस चिंता को साझा करता हूं। आप मूल रूप से परिभाषित विशेषताओं के रूप में मेरे प्रस्ताव में 2-5, 7, 8 और 10 के गुण ले सकते हैं। यानी आप इसे धारण करना चाहते हैं:

• v' एक आयामी है, लेकिन एक वेक्टर नहीं है
• v'' === v
• v' == v
• v'w एक अदिश राशि है
• v*w' एक मैट्रिक्स है
• v'*M v' तरह ही समान है
• M' द्वि-आयामी है, लेकिन मैट्रिक्स नहीं, शायद एक मैट्रिक्स दृश्य

विशेष रूप से, उच्च आयामी सरणियों के लिए इसका क्या अर्थ है या क्या करता है, इस पर कोई बाधा नहीं है। कोवेटर्स का एक सामान्य सिद्धांत यह है कि उच्च आयामों को शामिल करने से अच्छा होगा, लेकिन मुझे यकीन नहीं है कि यह वास्तव में चीजों को बहुत अधिक जटिल किए बिना किया जा सकता है, जैसे कि ऊपर / नीचे आयाम होने या प्रत्येक आयाम को एक सूचकांक द्वारा लेबल किया जाना।

यह कम से कम स्पष्ट है कि ' लिए सामान्य नियम यह नहीं है कि यह आयामों को उलट देगा, क्योंकि यह वैक्टर और कोवेक्टरों के लिए ऐसा नहीं होगा।

एकमात्र सरल नियम जिसके बारे में मैं सोच सकता हूं कि दोनों वैक्टर, कोवेक्टर, और मैट्रिसेस दोनों के लिए ऊपर के व्यवहार को पकड़ता है, पहले दो आयामों की अनुमति देना है (एक वेक्टर में एक अनुपस्थित दूसरा आयाम है और एक कोवेक्टर में एक अनुपस्थित पहला और वर्तमान दूसरा है)।

20 अक्टूबर 2014 को, 09:05 बजे, toivoh सूचनाओं @ithub.com ने लिखा:

यह कम से कम स्पष्ट है कि 'के लिए सामान्य नियम यह नहीं है कि यह आयामों को उलट देगा, क्योंकि यह वैक्टर और कोवेक्टरों के लिए ऐसा नहीं होगा।

एकमात्र सरल नियम जिसके बारे में मैं सोच सकता हूं कि दोनों वैक्टर, कोवेक्टर, और मैट्रिसेस दोनों के लिए ऊपर के व्यवहार को पकड़ता है, पहले दो आयामों की अनुमति देना है (एक वेक्टर में एक अनुपस्थित दूसरा आयाम है और एक कोवेक्टर में एक अनुपस्थित पहला और वर्तमान दूसरा है)।

मैं यह तर्क दूंगा कि यदि आप सामान्य टेनर्स के बारे में सोचना चाहते हैं तो यह सच नहीं है। यह सच हो सकता है यदि आप केवल संख्या के साथ कुछ ब्लॉकों के रूप में मेट्रिसेस और वैक्टर के बारे में सोचते हैं, और आप एक पंक्ति के रूप में v और एक स्तंभ के रूप में v के बारे में सोचते हैं।

हालाँकि, यदि आप v को सदिश स्थान के कुछ तत्व के रूप में मानते हैं, और डब्लू = v को दोहरे स्पेस V_ के तत्व w में मैप करने के लिए कुछ तरीके के रूप में सोचते हैं, तो w अभी भी एक सदिश, यानी एक-आयामी वस्तु है। सामान्य तौर पर, किसी को इस मैपिंग को V से V_ तक परिभाषित करने के लिए एक मीट्रिक की आवश्यकता होती है, अर्थात w_i = g_ {i, j} v ^ j। अब यदि V एक कार्टेशियन स्पेस है, अर्थात मानक यूक्लिडियन मेट्रिक के साथ R ^ n, तो V * स्वाभाविक रूप से V से आइसोमोर्फिक है। इसका मतलब है कि ऊपरी या निचले सूचकांकों (सहसंयोजक या विपरीतार्थक) की कोई धारणा नहीं है और इसलिए w_i = v_i_ = v ^ i = w ^ i। मैं यह तर्क दूंगा कि यह सबसे प्रोग्रामिंग में उपयोग किया जाने वाला मामला है, अर्थात केस जिसे जूलिया बेस द्वारा समर्थित होने की आवश्यकता है। (एक जटिल सदिश स्थान के लिए, V * प्राकृतिक रूप से वबर, संयुग्मित सदिश स्थान के लिए आइसोमॉर्फिक है, और इसलिए प्राकृतिक मानचित्रण w_i = conj (v ^ i) है।)

संख्याओं के साथ स्तंभों के रूप में वैक्टर को निरूपित करने का सम्मेलन, संख्याओं के साथ पंक्तियों के रूप में दोहरी वैक्टर, और इसलिए संख्याओं के साथ ब्लॉक के रूप में matrices (जो कि V \ otimes V_ के तत्व हैं) बेहद सुविधाजनक है, लेकिन जैसे ही आप भी आयामी विचार करना चाहते हैं वैसे ही रुक जाता है सरणियाँ, अर्थात उच्च क्रम वाले टेंसर उत्पाद रिक्त स्थान के तत्व। उस स्थिति में, एक 'पंक्ति सदिश', यानी द्वि-आयामी वस्तु जहां पहले आयाम का आकार 1 होता है, इसे माटलब / जूलिया शब्दावली में कहने के लिए, एक टेंसर उत्पाद स्थान V1 \ otimes V2 का कुछ तत्व है, जहां V1 होता है। आर (या कुछ अन्य एक आयामी स्थान) हो। मैं मानता हूं कि यह वह नहीं हो सकता है जो आप डिफ़ॉल्ट व्यवहार के रूप में चाहते हैं, लेकिन जैसा कि मैं पसंद करूंगा कि किसी को सिर्फ एक सामान्य सरणी के लिए स्थानांतरण को परिभाषित करने की अनुमति नहीं देनी चाहिए और मतवादियों को संदर्भित करना चाहिए, जैसे कि मटलब। सामान्य टेंसर के लिए पहले दो आयामों को उलट देना डिफ़ॉल्ट सम्मेलन के रूप में मायने नहीं रखता है। कुछ उच्च क्रम वाले टेंसर उत्पाद स्थान V1 \ otimes V2 \ otimes से एक तत्व को स्थानांतरित करना ... \ otimes Vn की कोई अद्वितीय परिभाषा नहीं है। सभी आयामों को उलटने के लिए अधिवेशन पेनरोज़ द्वारा सुविधाजनक चित्रमय प्रतिनिधित्व से उपजा है, जैसा कि ऊपर कहा गया है। इसके अलावा, यह वह है जो मैट्रिक्स स्पेस (V \ otimes V_) को स्वयं (V * \ otimes V * = V \ otimes V ) को

मैं आगे दो तरीके देख सकता हूं:
1) कार्टिसियन टेनर्स (यानी ऊपरी या निचले सूचकांकों के बीच कोई अंतर नहीं) की स्थापना के भीतर, कुछ चुने हुए सम्मेलन का उपयोग करके मनमाने ढंग से उच्च-क्रम सरणियों के साथ सुविधा ऑपरेटर (और शायद * * भी) काम करें। यह विशिष्ट उपयोग के मामलों के लिए कुछ आश्चर्यजनक परिणाम ला सकता है।

2) वैक्टर और मैट्रिसेस पर प्रतिबंध 'और *। उच्चतर आदेश सरणियों में त्रुटि। मुझे लगता है कि यह सबसे लोकप्रिय तरीका है (जैसे मतलाब आदि)।

यह पद पिछले साल मैंने जिस स्थिति में लिया था, उससे दूसरी तरफ ले रहा है

दोनों ओर से व्यापकता का पता लगाएं।

आशा है कि ठीक है।
यह अंततः मुझे मारा कि वर्तमान दृष्टिकोण के लिए एक तर्क है, लेकिन इसे कभी भी स्पष्ट नहीं किया गया था।
यह एक हैक की तरह लग रहा था कि यह सिर्फ मुझे नाराज कर दिया। किसी तरह अब मुझे समझ में आया
यह, मैं इसे और अधिक पसंद कर रहा हूं।

वर्तमान दृष्टिकोण में, सभी सरणियाँ अनंत आयामी हैं जिनमें निहित 1 का गिरा दिया गया है।
एपोस्ट्रोफ ऑपरेटर 'का मतलब पहले दो आयामों को बदलना हो सकता है,
लेकिन वास्तव में यह आज भी मौजूद है, इसका मतलब है

ndim (A) <= 2? interchange_first_two_dims: no_op

खेद है कि अगर बाकी सभी ने देखा और मैंने इसे याद किया। मेरा दिमाग चकरा गया
इस विचार के साथ कि वैक्टर एक आयामी थे, न कि अनंत आयामी, और
इसलिए रिवर्स आयामों के लिए एक संक्रमण चाहिए, इसलिए एक no_op होना चाहिए।

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

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

मुझे पिछले साल इस धागे को शुरू करने का अफसोस नहीं है, लेकिन मैं फिर से सोच रहा हूं कि क्या मामले हैं
वास्तव में आज लोग नाराज हैं ... क्या हम उदाहरणों की एक सूची प्राप्त कर सकते हैं? ... और मौसम
इन मामलों पर प्रकाश डालना हम जो करते हैं उसे बदलने से बेहतर है।

मैंने इस पूरे सूत्र को पढ़ा है और कई सिद्धांतों को देखा है - जो अच्छा है,
लेकिन मेरे सिर को चीजों के इर्द-गिर्द रखने के लिए पर्याप्त उपयोग के मामले नहीं हैं।

मैं कह सकता हूं कि मैं अक्सर नाराज हो गया हूं

[१ २ ३] # ndims == २
[१,२,३] # ndims == १
[१; २; ३] # ndims == १

मुख्य रूप से क्योंकि मैं इसे याद नहीं कर सकता।

सिर्फ एक सोचा प्रयोग। अगर हम नए सिरे से परिभाषित क्या कार्यक्षमता खो जाएगा * क्या @alanedelman के लिए मन में है के लिए इसी तरह एक संकुचन ऑपरेटर के रूप में सेवा करने के लिए '* ? क्या यह लीनियर बीजगणितीय परिचालनों में ' की आवश्यकता को नहीं हटाएगा (मैट्रिस के लिए एक प्रेषण के रूप में कार्य करने के अलावा)? मैं केवल यह देख सकता हूं कि यह हमें बाहरी उत्पाद w*v' से रहित कर देगा, जिसे आसानी से outer(w,v) बदला जा सकता है।

संपादित करें: एपीएल स्लाइसिंग मान रहा है। उदाहरण के लिए A[1,:]*A*A[:,1] ' साथ पहले ऑपरेंड की आवश्यकता के बिना अपेक्षित परिणाम होगा।

मैंने भी यही सोचा था। मुझे लगता है कि v * w एक डॉट उत्पाद होने के नाते सिर्फ स्टेरॉयड पर ओवरलोडिंग की तरह लगता है
वह त्रुटि प्रवण हो सकता है।
यह एक ऐसी जगह है जहां गणितज्ञ की बिंदी इतनी बुरी नहीं लगती है।

इसलिए संक्षेप में, एक अनुबंध पिछले करने के लिए उचित लगता है, लेकिन
चाहे वह एपोस्ट्रोफ-स्टार हो सकता है या * हो सकता है या डॉट होना चाहिए
मुद्दे हैं।

कुछ असंबद्ध लेकिन पूरी तरह से असंबंधित नहीं ...।
मैं यह बताना चाहता हूं कि डॉट-स्टार जिसे सभी लोग मूल रूप से डॉट-स्टार के रूप में पढ़ते हैं (मुझे बताया गया था) था
प्वाइंट-स्टार होने का मतलब है क्योंकि POINTWISE ऑपरेटर क्या था
के कहने का मतलब था

मैं कह सकता हूं कि मैं अक्सर नाराज हो गया हूं

[१ २ ३] # ndims == २
[१,२,३] # ndims == १
[१; २; ३] # ndims == १

मुख्य रूप से क्योंकि मैं इसे याद नहीं कर सकता।

मैं हमेशा "हम केवल , उपयोग क्यों नहीं करते?"

अगर हम @alanedelman के मन में '' के समान संकुचन संचालक के रूप में सेवा करने के लिए * को फिर से परिभाषित करते हैं तो क्या कार्यक्षमता खो जाएगी?

हम सहानुभूति खो देंगे: उदाहरण के लिए (M*v)*v वर्तमान dot(v,M*v) (एक अदिश) देंगे, जबकि M*(v*v) M.*dot(v,v) (एक मैट्रिक्स) को देंगे।

हम सिर्फ dot को संकुचन संचालक (जो किसी भी तरह सहयोगी नहीं है) क्यों नहीं बनाते हैं? हम उच्च आदेश संकुचन को भी परिभाषित कर सकते हैं, जैसे ddot(A::Matrix,B::Matrix) == A⋅⋅B == trace(A'*B) ।

तो क्या मैं सही ढंग से समझता हूं कि वेक्टर हस्तांतरण शुरू करने का एकमात्र उद्देश्य हमें * की गैर-समरूपता से बचाना है? @Alanedelman का उदाहरण की अस्पष्टता वैक्टर में से एक सुर द्वारा निर्धारित किया जा सकता है ( M*v*v' बनाम M*v'*v ), लेकिन एक ही कोष्ठक के साथ किया जा सकता है ( M*(v*v) बनाम (M*v)*v ) वैक्टर के लिए संक्रमण को लागू करने की सभी परेशानी के बिना (जैसा कि @ जूथो ने पहले से ही उच्च आदेश

वास्तव में M*(v*v) और (M*v)*v वर्तमान में दोनों के रूप में हैं

*(M, v, v)

मैट्रिक्स उत्पाद के लिए अनुमति देने के लिए जो तर्कों के आकार के आधार पर गुणन के क्रम का अनुकूलन करता है, इसलिए पार्सर को भी बदलना होगा।

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

(जैसा कि @ जूथो ने पहले ही बताया था कि उच्च

मुझे नहीं लगता कि वास्तव में मैंने ऐसा कहा है।

अगर हम @alanedelman के मन में '' के समान संकुचन संचालक के रूप में सेवा करने के लिए * को फिर से परिभाषित करते हैं तो क्या कार्यक्षमता खो जाएगी?

हम सहानुभूति खो देंगे: जैसे (M_v) _v वर्तमान डॉट (v, M_v) (एक स्केलर) देगा, जबकि M_ (v_v) M._dot (v, v) (एक मैट्रिक्स) देगा।

हम केवल संकुचन ऑपरेटर (जो किसी भी तरह से साहचर्य नहीं है) को डॉट क्यों नहीं बनाते हैं? हम उच्च क्रम के संकुचन को भी परिभाषित कर सकते हैं, उदाहरण के लिए ddot (A :: Matrix, B :: Matrix) == A⋅⋅B == ट्रेस (A '* B)।

तर्क की उस पंक्ति के साथ, हमें अभी वैक्टर और मैट्रिस के लिए गुणन ऑपरेटर की आवश्यकता नहीं है, हम बस डॉट के संदर्भ में सब कुछ लिख सकते हैं:
A ∙ बी
A ∙ वी
वी ∙ ए ∙ डब्ल्यू
v ∙ व

तो यह सिर्फ @pwl प्रस्ताव है लेकिन * के साथ * डॉट के साथ बदल दिया गया।

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

मुझे लगता है कि समस्या का एक हिस्सा यह है कि गणित में भी अलग-अलग परंपराएं हैं। पंक्ति और स्तंभ वैक्टर गणित के संदर्भ में सोच रहा है, या हम रैखिक ऑपरेटरों और दोहरी रिक्त स्थान के संदर्भ में अधिक सार व्यवहार चाहते हैं (जहां मुझे लगता है कि एक ऑपरेटर एक वेक्टर के साथ गुणा नहीं किया जाता है, लेकिन एक वेक्टर पर लागू होता है, इसलिए क्यों नहीं लिखा जाता है A (v) के बजाय A * v या A? V)?

मैं सुविधा सिंटैक्स की बड़ी आवश्यकता नहीं हूं, मैं व्यक्तिगत रूप से हर बार डॉट (v, w) को v * * लिखना पसंद करता हूं, क्योंकि पूर्व में स्पष्ट रूप से आधार स्वतंत्र गणितीय संचालन को व्यक्त करता है (वास्तव में, पहले एक को परिभाषित करने की आवश्यकता है स्केलर उत्पाद वैक्टर से दोहरी वैक्टर तक एक प्राकृतिक मानचित्रण से पहले भी परिभाषित किया जा सकता है)। =

इतना अज्ञानी होने के लिए खेद है, लेकिन M[1, :] एक प्रतिगमन क्यों नहीं हो सकता है, v' जैसा व्यवहार?

मैं उन चीजों की अपनी सूची में जोड़ने जा रहा हूं जो मुझे बग करते हैं

1।

[1 2 3] # ndims == 2
[1,2,3] # ndims == 1
[1;2;3] # ndims == 1

2।
v=rand(3)
v' * v उत्सुकता से ndims == 1 ( @StefanKarpinski का प्रस्ताव यह तय करता है)
(v' * v)/( v' * v ) ndims ==2 (यह वास्तव में मुझे परेशान करता है और तय भी हो जाएगा)

फिर भी मैं वास्तव में कोवेक्टर नहीं चाहता
और apl इंडेक्सिंग कुछ ऐसा है जो मैं आगे और पीछे चलता रहता हूं
--- अभी भी सोच रहा है, लेकिन मैं चीजों की सूची देखना पसंद करूंगा
वर्तमान जूलिया में अन्य लोग बग

मुझे निश्चित रूप से कॉड का विचार पसंद है* ऑपरेटर के अलावा पहले सूचकांक को अंतिम सूचकांक करार
और डॉट (ए, बी, ..) की अनुमति देना बहुत ही सामान्य अंतर्विरोधों के लिए अनुमति देता है।

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

गणित में, डॉट उत्पाद, या स्केलर उत्पाद (या कभी-कभी यूक्लिडियन स्पेस के संदर्भ में आंतरिक उत्पाद), एक बीजीय ऑपरेशन है जो संख्याओं के दो समान-लंबाई अनुक्रम लेता है (आमतौर पर वैक्टर समन्वय करता है) और एक ही नंबर देता है।

मेरे दिमाग में भी, डॉट को एक स्केलर वापस करना चाहिए।

@ brk00 , आपके प्रश्न के साथ समस्या यह है कि यह स्पष्ट नहीं है कि इसे उच्च-आयामी / उच्च-श्रेणी के स्लाइस तक कैसे बढ़ाया जाए (मैं वास्तव में इसके लिए विश्व आयामी नापसंद करता हूं) सरणियाँ।

इतना अज्ञानी होने के लिए क्षमा करें, लेकिन वास्तव में M [1,:] को एक प्रस्ताव क्यों नहीं माना जा सकता, जैसे कि 'v?

यह कर सकते हैं, लेकिन आप इसे कैसे सामान्य करते हैं?

@ जूथो , मुझे खेद है, मुझे इसे अलग तरह से

@alanedelman :

मैं उन चीजों की अपनी सूची में जोड़ने जा रहा हूं जो मुझे बग करते हैं

[१ २ ३] # ndims == २
[१,२,३] # ndims == १
[१; २; ३] # ndims == १

इस मुद्दे से संबंधित व्यवहार एक असंबंधित है। चलो आगे पानी नहीं कीचड़।

मैं निश्चित रूप से * ऑपरेटर के अलावा पहले सूचकांक को अंतिम सूचकांक करार देने का विचार करता हूं
और डॉट (ए, बी, ..) की अनुमति देना बहुत ही सामान्य अंतर्विरोधों के लिए अनुमति देता है।

यह भी मूर्त है। आइए सरणियों और स्लाइसिंग पर ध्यान केंद्रित करें।

वर्तमान दृष्टिकोण में, सभी सरणियाँ अनंत आयामी हैं जिनमें निहित 1 का गिरा दिया गया है।

यह वास्तव में सच नहीं है। यदि यह सच था, तो ones(n) , ones(n,1) , ones(n,1,1) , आदि के बीच कोई अंतर नहीं होगा, लेकिन वे सभी विभिन्न प्रकारों के साथ अलग-अलग वस्तुएं हैं जो प्रत्येक के बराबर भी नहीं हैं। अन्य। हम चीजों को लागू करने के लिए कुछ प्रयास करते हैं ताकि वे _similarly_ व्यवहार करें लेकिन यह वास्तव में असीम आयामी होने वाले सरणियों से बहुत दूर है।

उन चीजों की सूची जो वर्तमान में परेशान कर रहे हैं बड़े पैमाने पर दर्पण (एक सबसेट) मेरे उपरोक्त प्रस्ताव के अच्छे गुण हैं। अर्थात्:

1. असममित स्लाइसिंग व्यवहार - अनुगामी आयाम विशेष हैं।
2. v'' !== v - वास्तव में v'' != v ; इसका कारण यह है कि उनके पास समान रैंक नहीं है।
3. v' != v - समान सौदा।
4. v'w एक-तत्व वेक्टर है, स्केलर नहीं।
5. हमें A*_mul_B* लिए विशेष पार्सिंग की आवश्यकता है, जो अब तक की सबसे भयानक चीज है।

मैं v' == v बिट को छोड़कर, @StefanKarpinski के अधिकांश बिंदुओं से सहमत हूं: मुझे नहीं लगता कि ये समान होने चाहिए। हां, वे आइसोमॉर्फिक हो सकते हैं लेकिन वे अभी भी अलग-अलग वस्तुएं हैं, जिसमें वे बहुत अलग तरह से व्यवहार करते हैं: मैट्रिसेस M और M' भी isomorphic हैं फिर भी मुझे नहीं लगता कि हम कभी भी उनके बराबर होना चाहते हैं। (जब तक कि वे निश्चित रूप से हर्मिटियन न हों)।

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

+1 @simonbyrne के लिए, @StefanKarpinski के

@Simonbyrne से भी सहमत हैं।

हां, v और v' अलग-अलग प्रकार के होते हैं, लेकिन हम पहले से ही समान आकार और डेटा के साथ भिन्न सरणी प्रकारों को समान मानते हैं - उदाहरण के लिए speye(5) == eye(5) । कोवड़ विरल से अलग क्यों है?

मुझे उम्मीद है कि कोवेटर पंक्ति मैट्रिसेस की तरह प्रसारित होंगे। सरणियों के लिए A और B जो समान माना जाता है, यह अब तक रखता है

all(A .== B)

अगर एक सदिश और एक एक कोवेक्टर है तो ऐसा नहीं होगा।

मेरे लिए, एक कोवेक्टर एक वेक्टर या स्तंभ मैट्रिक्स की तुलना में पंक्ति मैट्रिक्स की तरह अधिक है।

मुझे लगता है कि एक महत्वपूर्ण सवाल यह है कि size(v' क्या है? यदि उत्तर (length(v),) तो मुझे लगता है कि v == v' सत्य होना चाहिए। अगर size(v') == (1,length(v)) तो यह शायद गलत होना चाहिए, लेकिन यकीनन v' == reshape(v,1,length(v)) सही होना चाहिए। तो सवाल यह होना चाहिए कि v' एक विशेष प्रकार का वेक्टर या एक विशेष प्रकार का मैट्रिक्स होना चाहिए?

तेजी से मैं आश्वस्त हूं कि यह मुद्दा वास्तव में है कि वास्तव में इसका क्या मतलब है।

Covectors वास्तव में सरणियाँ नहीं हैं, और इसलिए मुझे नहीं लगता कि हम वास्तव में कह सकते हैं कि उनके पास "आकार" क्या है। एक कोवेक्टर वास्तव में परिभाषित करता है कि वह क्या करता है, वह *(::Covector, ::Vector) एक स्केलर है: जैसा कि कोई भी AbstractVector ऐसा नहीं करता है, यह वास्तव में एक ही बात नहीं है।

एक और समस्या जटिल क्षेत्र में होगी: क्या हमारे पास v' == v या v.' == v ?

@simonbyrne :

एक कोवेक्टर वास्तव में परिभाषित करता है कि वह क्या करता है, वह *(::Covector, ::Vector) एक स्केलर है: जैसा कि कोई भी AbstractVector ऐसा नहीं करता है, यह वास्तव में एक ही बात नहीं है।

यह वास्तव में एक अच्छा बिंदु है। हालाँकि, अगर v' उपयोग वस्तु के रूप में नहीं किया जा सकता है तो यह निराशाजनक हो सकता है। शायद सही तरीका एक मज़ेदार वेक्टर के बजाय v' को मज़ेदार पंक्ति मैट्रिक्स के रूप में मानना ​​है।

शायद सही तरीका यह है कि v 'को एक अजीब वेक्टर के बजाय अजीब पंक्ति मैट्रिक्स के रूप में माना जाए।

तरह, लेकिन मुझे नहीं लगता कि यह AbstractMatrix का एक उपप्रकार होना चाहिए: मुझे लगता है कि AbstractCovector एक शीर्ष-स्तरीय प्रकार होना चाहिए। मुझे length(::Covector) परिभाषित करने में खुशी होगी, लेकिन मुझे नहीं लगता कि हमें size पद्धति को परिभाषित करना चाहिए।

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

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

20 अक्टूबर 2014 को, 17:39 पर, साइमन बायरन सूचनाएं @github.com ने लिखा:

मैं v_ == v बिट को छोड़कर, ज्यादातर

इस कथन का किसी भी स्तर पर कोई मतलब नहीं है।

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

V से V * तक एक प्राकृतिक मानचित्रण को परिभाषित किया जा सकता है जब आपके पास एक बिलिनियर फॉर्म V x V -> स्केलर, आमतौर पर एक आंतरिक उत्पाद / मीट्रिक होता है। एक तो phi_i = g_ {i, j} v ^ j को परिभाषित कर सकता है।

2), वास्तव में "एक वेक्टर को स्थानांतरित करने" से जुड़ा कोई प्राकृतिक ऑपरेशन नहीं है (देखें बिंदु 3)। यह भ्रम कॉलम मैट्रीस के साथ वैक्टर की पहचान करने से आता है।
शायद यह बहुत मजबूत है, मैं वास्तव में एक वेक्टर के हस्तांतरण के किसी भी उपयोग के मामले को देखना चाहूंगा जिसे आप डॉट और शायद कुछ बाहरी उत्पाद / टेनसर उत्पाद ऑपरेशन का उपयोग नहीं कर सकते हैं?

हालाँकि, यदि आप वैक्टर को मैप करने के लिए दोहरी वैक्टरों के लिए मार्ग के रूप में उपयोग करना चाहते हैं, अर्थात V में V में कुछ ph = v 'में v को मैप करने के लिए, तो आप मान रहे हैं कि आप मानक यूक्लिडियन इनर प्रोडक्ट (g_ {) के साथ काम कर रहे हैं i, j} = delta_ {i, j})। उस बिंदु पर, आप सहसंयोजक और contravariant सूचकांकों के बीच के अंतर को मिटा रहे हैं, आप अनिवार्य रूप से कार्टेशियन टेनर्स के साथ काम कर रहे हैं, और V_ स्वाभाविक रूप से आइसोमॉर्फिक बन जाते हैं। जैसा कि ऊपर कहा गया है, w_i = v ^ i = v_i = w ^ i, इसलिए हां, v == w और मैं यहां तक ​​कहूंगा कि इन दोनों को अलग करने वाला कुछ भी नहीं है।

3) ऑपरेशन "ट्रांसपोज़" मूल रूप से केवल वी -> डब्ल्यू (http://en.wikipedia.org/wiki/Dual_space#Transpose_of_a_linear_map) से रेखीय मानचित्रों के लिए परिभाषित किया गया है, और वास्तव में यहां तक ​​कि आप क्या सोचते हैं इसका मतलब यह नहीं हो सकता है। एक रेखीय मानचित्र A: V-> W का पारगमन W ^-> V_ से एक नक्शा A ^ T है, अर्थात यह W_0 में वैक्टर पर काम करता है, और V_ के तत्वों का उत्पादन करता है, अर्थात इसका अर्थ V_ covectors है। यदि आप इसे मैट्रिक्स A के A ^ T के पारगमन के संदर्भ में सोचते हैं, तो यह है कि इस मैट्रिक्स A ^ T को W * में वैक्टर का प्रतिनिधित्व करने वाले स्तंभों से गुणा किया जाना है और जो स्तंभ इस से बाहर आता है, वह V के एक covector का प्रतिनिधित्व करता है। तो इस बिंदु पर पंक्ति वैक्टर के साथ दोहरी वैक्टर की पहचान पहले से ही विफल हो जाती है।

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

Matlab / Engineering दृष्टिकोण के अनुसार उच्च आयामी सरणियों के लिए किस स्थानान्तरण का क्या अर्थ होना चाहिए, हम इसे करने के लिए परिवर्तित कर रहे हैं: यह एक त्रुटि होनी चाहिए, यह सामान्य नहीं करता है। इसका मतलब यह नहीं है कि इसे परिभाषित करने का कोई तरीका नहीं है। समस्या यह है कि एक उच्च क्रम सरणी का प्रतिनिधित्व क्या करता है। क्या यह एक टेंसर उत्पाद स्थान V1 \ otimes V2 \ otimes ... \ otimes VN का एक तत्व है, क्या यह V1 x V2 x ... x VN पर अभिनय करने वाला एक बहुरेखीय मानचित्र है, क्या यह कुछ टेनर उत्पाद अंतरिक्ष V1 \ otimes V2 \ otimes से रैखिक मानचित्र है। … \ Otimes VN दूसरे टेनर उत्पाद स्थान W1 \ otimes W2 \ otimes… \ otimes WM? द्वि-आयामी मामले के लिए, एक संकल्प है। लीनियर मैप्स A: V-> W के साथ W \ otimes V_ में वैक्टर की पहचान करना, रैखिक मैप सेंस में ट्रांसपोज़ेशन इस टेंसर प्रोडक्ट स्पेस में स्पेस को उलटने से मेल खाता है, A ^ i_j -> A_j ^ i से A ^ T से V_ \ otimes में। W = V * \ otimes W _, जो वास्तव में W_ -> V से एक मानचित्र है । उच्चतर ऑर्डर ऑब्जेक्ट के लिए आयामों को उलटने के बारे में अच्छी बात यह है कि इसमें एक सुविधाजनक चित्रमय प्रतिनिधित्व है।

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

उस संबंध में, कुछ विषमता है, चूंकि मैट्रिक्स शब्द बहुत कम ओवरलोडेड है, यहां तक ​​कि गणितीय दृष्टिकोण से एक मैट्रिक्स एक निश्चित आधार में एक रेखीय नक्शे का सिर्फ एक सुविधाजनक प्रतिनिधित्व है। ध्यान दें कि ऐसे कई मामले हैं जहां आप एक मैट्रिक्स के रूप में एक रेखीय मानचित्र का प्रतिनिधित्व नहीं करना चाहते हैं, बल्कि एक फ़ंक्शन के रूप में (यह मुद्दा पहले आया है जैसे कि ईगर्स आदि के तर्क)। उस संबंध में, मैं देख सकता हूं कि मतलबी ने भी एक सदिश, वास्तव में एक आयामी संरचना के लिए परेशान क्यों नहीं किया। इस दृष्टिकोण में, सब कुछ बस 'मैट्रिक्स' के रूप में व्याख्या की जाती है, यानी संख्याओं के साथ एक ब्लॉक, वैसे भी।

सवाल? आज्ञा देना covector। एफएफटी (सी) क्या है?

उत्तर: fft (c ')' जो संभावित अप्रत्याशित तरीकों से जटिल संयुग्म लेता है
जब एफएफटी (सी) के साथ तुलना की जाती है

उपयोगकर्ता अपरिभाषित होने से सिर्फ लाभ उठा सकते हैं
(या शायद यह उपयोगकर्ताओं के लिए अच्छा होगा, अगर अच्छी तरह से प्रलेखित किया गया हो ??)

मुझे यकीन है कि इस प्रकार की बहुत सी चीजें हैं

मुझे लगता है कि Base में करने के लिए सही चीज़ पर संदेह करना केवल परिभाषित करना है:

• कोवेक्टर समय एक और वेक्टर
• covector बार एक मैट्रिक्स
• एक वेक्टर पाने के लिए कोवेक्टर '

अब के लिए कोवेटर्स के लिए +1 का न्यूनतम समर्थन।

हाँ, +1।

तो अगर मैं उल्लेख किया है कि मैं बहुत यकीन है कि कर रहा हूँ
मानदंड (कोवेक्टर, क्यू) मानदंड (वेक्टर, पी) होना चाहिए जहां 1 / p + 1 / q = 1
धारक असमानता से, जो लंबे समय तक लागू नहीं होगी। :-)

पी = क्यू = 2 के लिए धन्यवाद

यह सब लागू करने के लिए कठिन नहीं होगा:

norm(c::Covector, q::Integer) = norm(c.vector, q/(1-q))

आप शायद q == 0 और q == 1 से बचने के लिए कुछ अतिरिक्त जाँच चाहते हैं।

मुझे लगता है कि q == 1 ठीक होगा

मेड venlig hilsen

एंड्रियास नैक

2014-10-22 15:19 GMT-04: 00 स्टीफन करपिंस्की सूचनाएं @github.com:

यह सब लागू करने के लिए कठिन नहीं होगा:

मानदंड (c :: Covector, q :: Integer) = मानदंड (c.vector, q / (1-q))

आप शायद q == 0 और q == 1 से बचने के लिए कुछ अतिरिक्त जाँच चाहते हैं।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment -60139762

मैं कोवेक्टर प्रस्ताव (जो मैं ज्यादातर समर्थन करता हूं) के राइटअप पर काम कर रहा हूं, लेकिन अब एक बिंदु पर पोस्ट करना उपयोगी हो सकता है जो "मजेदार पंक्ति मैट्रिक्स" की सटीक @StefanKarpinski की धारणा बनाता है।

कोवेक्टर वैक्टर नहीं हैं, लेकिन इसका वर्णन हमेशा स्पष्ट क्यों नहीं होता है। एक कोवेक्टर (या ब्रा-वेक्टर, जैसा कि भौतिक विज्ञानी इसे कहते हैं) एक रैखिक कार्यात्मक है जो एक वेक्टर खाता है और एक नंबर बाहर थूकता है जो एक डॉट उत्पाद है।

ज्यादा ठीक:

• V = V(F) और W = W(F) तत्वों के किसी न किसी क्षेत्र पर F वेक्टर हो
• v और w वैक्टर जो क्रमशः V और W तत्व हैं।
• <.,.> एक आंतरिक उत्पाद हो जैसे कि <.,.> : V × W → F और v, w ↦ <v, w>

v अनुरूप कोवेक्टर रैखिक कार्यात्मक v' : W → F है जो मानचित्रण w ↦ <v, w> ।

सामान्य विवरण यह कहते हुए समाप्त होता है कि v' एक दोहरे स्थान का एक तत्व है V* जो कि दोहरे स्थान _is_ के बारे में अधिक नहीं कहा गया है।

कंप्यूटर विज्ञान-वाई लोगों के लिए, अपने पहले पैरामीटर के संबंध में आंतरिक उत्पाद की करी के रूप में v' का एक सरल विवरण है, और V* उन कार्यों के संग्रह के रूप में हैं जो एक-पैरामीटर हैं विभिन्न पहले वैक्टर के साथ करी।

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

इसके अलावा, मैंने शुरू में सोचा था कि एक कोवेक्टर में अनुक्रमण को रोक दिया जाना चाहिए। हालाँकि, v'[1] को इंडेक्स करने के लिए v' को कैनोनिकल आधार वेक्टर e₁ = (1, 0, ...) , ताकि v'[1] को <v, e₁> रूप में परिभाषित किया जा सके। अधिक सामान्य अनुक्रमित शब्दार्थ जैसे 1:n स्वाभाविक रूप से v' को एक उपयुक्त प्रक्षेपण मैट्रिक्स पर लागू करने से प्रत्येक स्तंभ के साथ एक विहित आधार वेक्टर होता है।

# 987 के संदर्भ में कोवेक्टर्स के इंडेक्सिंग शब्दार्थ को देखते हुए एक और कारण दिया गया है कि कोवेक्टर AbstractVector s नहीं हैं: यह सामान्य रूप से v' सस्ते में इंडेक्स करना संभव नहीं है क्योंकि यह सब महँगी मात्रा पर निर्भर करता है जैसे <v, e₁> की गणना करना है। सामान्य तौर पर आप एक आंतरिक उत्पाद को मैट्रिक्स <v, w> = v'*A*w संबंध में परिभाषित कर सकते हैं और अनुक्रमण की लागत matvec उत्पाद A*w (या A'*v ) का वर्चस्व है, जो निश्चित रूप से है AbstractVector रूप में अर्हता प्राप्त करने के लिए बहुत महंगा है।

चूंकि हम DFTs और मानदंडों के बारे में बात कर रहे हैं ... यह आज मेरे दिमाग को पार कर गया

यदि f एक सदिश की एक समारोह है और एक अदिश पैदा करता है, तो मैं चाहते हैं diff(f) एक समारोह है कि एक को स्वीकार करता है होना करने के लिए Vector और एक का उत्पादन Covector ताकि f(x) ~= f(x0) + diff(f)(x0) * (x-x0) । ग्रेडिएंट का एक बहुत ही सामान्य उपयोग इनपुट में एक वृद्धिशील परिवर्तन दिए गए फ़ंक्शन के आउटपुट में वृद्धिशील परिवर्तन का एक रैखिक सन्निकटन प्राप्त करना है। यदि इनपुट एक वेक्टर है, तो ढाल के लिए स्वाभाविक रूप से कुछ ऐसा महसूस होता है जो इनपुट के सभी आयामों के साथ अनुबंध करता है।

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

मेरा पेट कहता है "एक बिंदु पर वेक्टर-इनपुट फ़ंक्शन का ढाल एक कोवेक्टर है" अधिक महत्वपूर्ण है।

मुझे संदेह है कि अभी के लिए आधार में सही चीज़ को परिभाषित करना है:

कोवेक्टर समय एक और वेक्टर
covector बार एक मैट्रिक्स
एक वेक्टर पाने के लिए कोवेक्टर '

इस धारणा के बावजूद कि आपने मेरे पिछले भयानक पदों से, इस पर +1 प्राप्त किया होगा।

फिर भी, इस पर कुछ टिप्पणी:

मैं कोवेक्टर प्रस्ताव (जो मैं ज्यादातर समर्थन करता हूं) के राइटअप पर काम कर रहा हूं, लेकिन अब एक बिंदु पर पोस्ट करना उपयोगी हो सकता है जो "मजेदार पंक्ति मैट्रिक्स" की सटीक @StefanKarpinski की धारणा बनाता है।

कोवेक्टर वैक्टर नहीं हैं, लेकिन इसका वर्णन हमेशा स्पष्ट क्यों नहीं होता है। एक कोवेक्टर (या ब्रा-वेक्टर, जैसा कि भौतिक विज्ञानी इसे कहते हैं) एक रैखिक कार्यात्मक है जो एक वेक्टर खाता है और एक नंबर बाहर थूकता है जो एक डॉट उत्पाद है।

मुझे लगता है कि दोहरी वेक्टर / कोवेक्टर (मैं लीनियर फंक्शंस शब्द भी पसंद करता हूं) को एक आंतरिक उत्पाद के बिना परिभाषित किया जा सकता है। यह सिर्फ इतना है कि आपको एक आंतरिक उत्पाद की आवश्यकता है यदि आप V से V तक की मैपिंग को परिभाषित करना चाहते हैं *

ज्यादा ठीक:

V = V (F) और W = W (F) तत्वों F, के कुछ क्षेत्र पर वेक्टर हो।
v और w वैक्टर होंगे जो क्रमशः V और W के तत्व हैं,
<।;>> एक आंतरिक उत्पाद हो जैसे कि <।;>> वी × डब्ल्यू → एफ और वी, डब्ल्यू be
यह बहुत अजीब है, और मुझे लगता है कि असंभव है, एक आंतरिक उत्पाद को दो अलग-अलग वेक्टर रिक्त स्थान वी और डब्ल्यू के बीच परिभाषित किया गया है। आप सकारात्मक निश्चितता की संपत्ति को कैसे परिभाषित करते हैं?
V के अनुरुप covector रैखिक कार्यात्मक v ': W → F है जो मैपिंग w the करता है।

सामान्य विवरण यह कहते हुए समाप्त होता है कि v 'एक दोहरे स्थान V * का एक तत्व है, जिसमें दोहरे स्थान के बारे में अधिक नहीं कहा गया है।

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

# 987 के संदर्भ में कोवेक्टर्स के इंडेक्सिंग शब्दार्थ को ध्यान में रखते हुए एक और कारण दिया गया है कि कोवेक्टर एब्सट्रैक्टर्स नहीं हैं: यह सामान्य रूप से इंडेक्स v के सस्ते में संभव नहीं है क्योंकि यह सब इस बात पर निर्भर करता है कि महंगी मात्रा कितनी है= v'_A_w और अनुक्रमण की लागत का matvec उत्पाद A_w (या A'_v) पर हावी है, जो निश्चित रूप से एक AbstractVector के रूप में अर्हता प्राप्त करने के लिए बहुत महंगा है।

यह एक प्रकार का लूप तर्क है। जैसा कि ऊपर उल्लेख किया गया है, एक रैखिक कार्यात्मक (कोवेक्टर) अधिक सामान्य है और यहां तक ​​कि आंतरिक उत्पाद के बिना वेक्टर रिक्त स्थान के लिए भी मौजूद है। दूसरे, जब मीट्रिक एक सकारात्मक निश्चित मैट्रिक्स ए है, तो वेक्टर वी से एक कोवेक्टर तक प्राकृतिक मानचित्रण वास्तव में v'_A है। हालाँकि, यह v 'यहाँ क्या है? क्या यह पहले से ही मानक यूक्लिडियन मानदंड (महानगर के रूप में एक पहचान के साथ) के संबंध में v से एक मैपिंग से अलग है? नहीं ऐसा नहीं है। यदि वैक्टर में कॉन्ट्रैविरिएंट (अपर) इंडेक्स होते हैं, और कोवेटर्स में सहसंयोजक (निचला) इंडेक्स होता है, तो मेट्रिक ए में दो कम इंडेक्स और आंतरिक उत्पाद होता है।= v ^ i A_ {i, j} v ^ j। और इसलिए इस मैपिंग को phi_j = v ^ i A_ {i, j} के रूप में (phi covector से संबंधित वेक्टर v के रूप में) लिखा जा सकता है। (ध्यान दें, यह एक विशिष्ट लीनियर ऑपरेटर से अलग है, जो कि फॉर्म ^ ^ i = O ^ i_j v ^ j) है। इसलिए, इस अभिव्यक्ति में v'_A अभी भी ऊपरी सूचकांक के साथ एक है, यह अभी भी वही वेक्टर है।

तो वास्तव में, जिन बिंदुओं को मैं ऊपर बनाने की कोशिश कर रहा था, उनमें से एक यह है कि लोग अक्सर v 'लिखते हैं जब वे वास्तव में एक कोवेक्टर के साथ काम करने की कोशिश नहीं कर रहे होते हैं। वे बस उन भावों को लिखने की कोशिश करते हैं जो वैक्टर पर परिभाषित होते हैं, जैसे कि एक आंतरिक उत्पादया v ^_A_w के रूप में v ^ i A_ {i, j} w ^ j जैसे कुछ परिचित मैट्रिक्स प्रतिनिधित्व के भीतर। यहां तक ​​कि मानक यूक्लिडियन आंतरिक उत्पाद v'w को v ^ i delta_ {i, j} w ^ j के रूप में पढ़ा जाना चाहिए और convectors को पेश करने की आवश्यकता नहीं है। जैसा कि ऊपर उल्लेख किया गया है, मुझे लगता है कि वास्तविक उचित कोवेक्टरों का उपयोग जो स्केलर उत्पादों के कुछ छिपे हुए रूप नहीं हैं, बल्कि अधिकांश अनुप्रयोगों में सीमित हैं। लोग सिर्फ सुविधाजनक मैट्रिक्स सिंटैक्स का उपयोग करने में सक्षम होने के लिए v लिखते हैं, लेकिन वे जो वास्तव में कर रहे हैं वह आंतरिक उत्पादों आदि की गणना कर रहा है, जो कि वैक्टर के संबंध में परिभाषित किए जाते हैं, कोवेक्टर नहीं।

एक तरफ, गुणन की सहानुभूति के बारे में पहले कुछ टिप्पणी की गई थी अगर हमारे पास स्टीफन के मूल प्रस्ताव में v = = v होगा। हालांकि, यहां तक ​​कि इसके बिना, मैं यह नहीं कहूंगा कि * साहचर्य है, भले ही v 'एक कोवेक्टर है जिसे सामान्य डॉक्टरों से पहचाना नहीं जाता है:
A_ (v'_w) एक मैट्रिक्स है
(A_v ') _ w एक त्रुटि उत्पन्न कर रहा है

स्केलर वैल्यू फ़ंक्शन का ग्रेडिएंट वास्तव में कॉवेटर्स के उचित अनुप्रयोगों में से एक है, अर्थात बिना तर्क के ग्रेडिएंट एक कॉवेटर है। संयुग्म ग्रेडिएंट जैसे अनुप्रयोगों में स्पष्ट रूप से माना जाता है कि इन कोवेटरों को वापस वैक्टर में मैप करने के लिए एक मीट्रिक (और वास्तव में एक व्युत्क्रम मीट्रिक) है। अन्यथा x ^ i (स्थिति वेक्टर) + अल्फा g_i (ढाल) जैसे कुछ करने का कोई मतलब नहीं है। इसे लिखने का उचित तरीका है x ^ i + Alpha delta ^ {i, j} g_j जहां डेल्टा ^ {i, j} उलटा मीट्रिक है। यदि कोई गैर-तुच्छ मीट्रिक के साथ कई गुना पर अनुकूलन तकनीकों को परिभाषित करने की कोशिश करता है, तो किसी को इसे (उलटा) मीट्रिक को ध्यान में रखना होगा। इस पर एक अच्छी किताब है:
http://sites.uclouvain.be/absil/amsbook/
और इसी मैटलैब पैकेज:
http://www.manopt.org

22 अक्टूबर 2014 को, 22:52 बजे, goretkin सूचनाएं @github.com ने लिखा:

चूंकि हम DFTs और मानदंडों के बारे में बात कर रहे हैं ... यह आज मेरे दिमाग को पार कर गया

यदि एक वेक्टर का एक फंक्शन फंक्शन और एक स्केलर का उत्पादन करता है, तो मैं डिफरेंस (f) एक फंक्शन होना चाहूंगा जो एक वेक्टर स्वीकार करता है और एक Covector का उत्पादन करता है ताकि f (x) ~ = f (x0) + diff (f) ( x0) * (x-x0)। ग्रेडिएंट का एक बहुत ही सामान्य उपयोग इनपुट में एक वृद्धिशील परिवर्तन दिए गए फ़ंक्शन के आउटपुट में वृद्धिशील परिवर्तन का एक रैखिक सन्निकटन प्राप्त करना है। यदि इनपुट एक वेक्टर है, तो ढाल के लिए एक कोवेटर होना स्वाभाविक लगता है।

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

मेरा पेट कहता है कि ढाल एक कोवेटर अधिक महत्वपूर्ण है।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

A_ (v'_w) एक मैट्रिक्स है
(A_v ') _ w एक त्रुटि उत्पन्न कर रहा है

ओह बकवास।

इस चित्र को एक हास्य छवि के साथ एक पद के लिए अतिदेय किया गया था।

@ जूथो मैं स्वीकार करता हूं कि मैं दोहरे स्थान के सबसे सामान्य रूप का उपयोग नहीं कर रहा हूं, लेकिन मैं यह नहीं देखता कि मेरा विवरण

परिपत्र वास्तव में सही शब्द नहीं है। मैं उस पैराग्राफ के साथ क्या कहना चाह रहा था कि मैं प्रविष्टियों के कुशल मूल्यांकन के बारे में तर्क की इस पंक्ति को उलट सकता हूं, उदाहरण के लिए, घुमावदार अभिव्यक्तियों पर (संयुग्मित) ग्रेडिएंट के मामले में, मुझे लगता है कि ढाल (कोवेक्टर) g_i कुशलता से गणना की जा सकती है, लेकिन संबंधित वेक्टर A ^ {i, j} g_ {j} जिसे x ^ i (A ^ {i, j} (उलटा मीट्रिक के साथ) में जोड़ा जाएगा, वह कुशल नहीं हो सकता है। मैंने अभी देखा कि गितुब पर मेरा पिछला संदेश कितनी बुरी तरह प्रकट हुआ था; जब मैंने ईमेल लिखा तो यह ठीक था। मैंने अब इसे ठीक करने की कोशिश की। मैं खुद को दोहराना नहीं चाहता, और न ही मैं (गलत) छाप देना चाहता हूं जैसे कि मैं वर्तमान प्रस्तावों से सहमत नहीं हूं। केवल वही अंक जो मैं बनाने की कोशिश कर रहा था।

1. दोहरे स्थान निश्चित रूप से एक वेक्टर स्थान है, इसलिए इसके तत्व वैक्टर हैं। हालाँकि, उद्देश्य यह नहीं होना चाहिए कि सभी वस्तुएं जिनमें वेक्टर का गणितीय अर्थ है, जूलिया के AbstractVector का उपप्रकार होना चाहिए, और न ही उन सभी वस्तुओं का, जो AbstractVector उपप्रकार हैं उचित गणितीय विशेषताएं हैं एक वेक्टर का। इस संदर्भ में, मैं नाम की तरह Matrix और अधिक नाम से Vector , तो यह उससे बहुत कम अर्थ है के रूप में। इसलिए, मुझे लगता है कि मैं इस तथ्य से सहमत हो सकता हूं कि, जो भी Covector प्रकार इस प्रस्ताव के हिस्से के रूप में पेश किया जा रहा है, वह AbstractVector या AbstractArray उपप्रकार नहीं होना चाहिए , यहां तक ​​कि उन मामलों में जहां V * स्वाभाविक रूप से V से आइसोमॉर्फिक है (कार्टेशियन स्पेस, जो संभवतः अनुप्रयोगों का आधा हिस्सा बनाता है)।
2. आंतरिक उत्पाद आपको V से V_ तक मैपिंग का निर्माण करने की अनुमति देता है, लेकिन यह V_ के अस्तित्व के लिए कोई शर्त नहीं है। निश्चित रूप से, यह ध्वनि एक अप्रासंगिक मुद्दे की तरह है क्योंकि प्रोग्रामिंग में आपके पास हमेशा परिमित-आयामी वेक्टर स्थान होता है और हमेशा एक आंतरिक उत्पाद होता है (भले ही यह अनुप्रयोग के लिए प्रासंगिक नहीं हो सकता है), लेकिन व्यावहारिक बिंदु जो मैं कोशिश कर रहा था यह है। प्रोग्रामिंग, @goretkin से अच्छा ढाल उदाहरण की तरह में covectors के समुचित अनुप्रयोग हैं, लेकिन सबसे अनुप्रयोगों में लोगों लिखने जहां v' , वे वास्तव में एक covector निर्माण करने के लिए प्रयास नहीं कर रहे, वे सिर्फ एक द्विरेखीय लिखने की कोशिश कर रहे हैं दो वैक्टर (जैसे V x V से स्केलर) के बीच मैपिंग, जैसे v'_A_w = v ^ i A_ {i, j} w ^ j या यहां तक ​​कि v'w = v ^ i delta_ {i, j} w> j का उपयोग करके सुविधाजनक मैट्रिक्स प्रतिनिधित्व। मैं स्पष्ट रूप से dot(v,A*w) लिखना पसंद करता हूं, लेकिन यह एक व्यक्तिगत पसंद है। चूंकि हमें मैट्रिस पर ऊपरी या निचले सूचकांकों के बारे में कोई जानकारी नहीं है, v'*A*w ऐसे मामलों का उपयोग किया जा सकता है, जहां स्केलर अभिव्यक्ति में v' और w या तो वैक्टर या कोवेटर हो सकते हैं गणितीय अर्थ में। इसका एकमात्र परिणाम यह है कि मुझे यकीन नहीं है कि क्या मैं v' Covector के प्रकार को कॉल करके वास्तव में खुश हूं, जैसा कि नाम Vector बहुत अधिक गणितीय है अधिकांश अनुप्रयोगों में जो अनुमान उचित नहीं हो सकता है, जो इस तरह से अधिक (अधिकतर अप्रासंगिक) चर्चाओं की ओर ले जाता है।

@jutho ग्रेडिएंट होने के कारण ग्रेडिएंट के लिए +1
मैंने पहली बार स्टीव स्मिथ की पीएचडी थीसिस से यह सीखा है और इस विचार का उपयोग किया है
स्पष्ट रूप से यह स्पष्ट विचार करने के लिए आइजनवायु अभिकलन के लिए संयुग्म ढाल का विचार
कि लोग रसायन विज्ञान और भौतिकी के बारे में बात करते थे।

मैं तेजी से कैसे आंतरिक रूप से सुसंगत हो रहा हूं
और स्व-निहित एक ऊपरी और एक निचले सूचकांक के साथ रैंक 2 टेनर्स की दुनिया है।
इसे हम परम्परागत रूप से मैट्रिक्स संगणना या सिर्फ सादे पुराने रैखिक बीजगणित कहते हैं।
हेक, जबकि मैं कई उदाहरण पा सकता हूं जैसे कि आदर्श (v, p) या fft (v) जहां कार्य करता है
अगर वे वैक्टर या कोवेटर्स हैं तो अलग, मेरे पास वास्तव में एक भी अच्छा उदाहरण नहीं है (अभी तक!)
एक फ़ंक्शन जो एक वेक्टर और एक कॉलम मैट्रिक्स पर स्वाभाविक रूप से भिन्न होता है।
(कोई मेरी मदद करो, निश्चित रूप से एक होना चाहिए, यहां तक ​​कि कई !!

मैं भी कई वर्षों से अब @ जुथो की तरह चिंतित
रिक्त स्थान अभी तक जूलिया में नहीं मिला है, मुझे @StefanKarpinski के साथ चैट करना याद है
इसके बारे में साल पहले मेरे व्हाइटबोर्ड में। फिर भी अति-चिंता की चिंताओं
1) जूलिया के लिए नए लोगों को एक आसान अनुभव होना चाहिए और
2) प्रदर्शन
इस फैंसी सामान को ट्रम्प करना चाहिए।

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

वैसे मुझे लगता है कि यह एक वर्ष के बारे में लिया जाता है यदि अधिक नहीं, लेकिन हम अंततः इसे गंभीरता से ले रहे हैं :-)

के बारे में
A_ (v'_w) एक मैट्रिक्स है
(A_v ') _ w एक त्रुटि उत्पन्न कर रहा है

केवल मैट्रिक्स गुणा "*" सहयोगी है। अतिभारित स्केलर टाइम्स मैट्रिक्स कभी नहीं था
साहचर्य। गणित में भी नहीं, MATLAB में भी नहीं।

A_ (v'_w) एक मैट्रिक्स है
(A_v ') _ w एक त्रुटि उत्पन्न कर रहा है

अच्छी पकड़। क्या ऐसे कोई मामले हैं, जहां गैर-त्रुटियां अलग-अलग जवाब देती हैं? एक संबंधित प्रश्न: एक अदिश * कोवेक्टर क्या करना चाहिए?

अतिभारित स्केलर टाइम्स मैट्रिक्स कभी भी सहयोगी नहीं था। गणित में भी नहीं, MATLAB में भी नहीं।

केवल मेट्रिसेस और स्केलर से जुड़े ऑपरेशन

स्केलर-मैट्रिक्स जोड़ एक बड़ी चिंता है, क्योंकि यह वितरण को बर्बाद कर देता है (हालांकि अगर मैं सही ढंग से याद करता हूं, तो मुझे लगता है कि इसे रखने के लिए बहस का समाधान किया गया है):

(A+s)*v != A*v + s*v

यह एक बहुत अच्छा सारांश है:

@ जियाओ के साथ बात करने के लगी कि दो बहुत ही खास दुनिया हैं:
रैखिक बीजगणित (एक इंजेक्शन के साथ सरणियां, और एक सह) और सरल टेंसर्स हैं
(हर कोई एक सह, कोई विरोधाभास नहीं है)।

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

पूर्व में, सभी वैक्टर v कॉलम हैं, सभी v' कोवेक्टर हैं और सभी मैट्रीज़ लीनियर ऑपरेटर V-> W हैं (जैसे वे W _ V_ में रहते हैं) यह उदाहरण जैसे बिलिनियर के प्रतिनिधित्व को बाहर करता है। मैप्स V x V -> स्केलर (उदाहरण के लिए v ^ i A_ {i, j} w ^ j) क्योंकि इसमें दो कम सूचकांकों के साथ एक मैट्रिक्स की आवश्यकता होती है (जैसे V_ ⊗ W_ में रहने वाले)। बेशक, आप अभी भी इसे व्यवहार में उपयोग कर सकते हैं और इसे v'_A*w रूप में लिख सकते हैं, लेकिन यह वस्तुओं के चुने हुए नामकरण के साथ संघर्ष करता है। इसके अलावा, यह निर्दिष्ट नहीं करता है कि किस स्थान पर उच्च आदेश सरणियाँ रह रही हैं।

बाद का मामला उस मुद्दे को हल करता है क्योंकि इसमें (V == V *) है, लेकिन v' == v रूप में आश्चर्यजनक परिणाम सामने आते हैं। इसके अलावा, यह समाधान वास्तव में वास्तविक वेक्टर रिक्त स्थान तक सीमित है, यहां तक ​​कि एक मानक यूक्लिडियन इनर प्रोडक्ट (यानी 'जटिल कार्टेशियन स्पेस') के साथ जटिल स्थानों में भी, दोहरी स्थान स्वाभाविक रूप से आइसोमॉर्फिक से वी नहीं है, बल्कि संयुग्मन (वी) के लिए है (वी) बार), संयुग्म वेक्टर स्पेस (http://en.wikipedia.org/wiki/Complex_conjugate_vector_space में हिल्बर्ट स्पेस देखें)

गैर-समरूपता के संबंध में, उस व्यवहार के संबंध में, जहां v'*v एक स्केलर का उत्पादन नहीं करता है, लेकिन एक सरणी है, वास्तव में अधिक सुसंगत है, तब से दोनों A*(v'*v) और (A*v')*v एक त्रुटि पैदा करते हैं।

चीजों के "रैखिक बीजगणित" पक्ष को अतिरिक्त रूप से हल किया जा सकता है कि कैसे वैक्टर और कोवेक्टर का प्रतिनिधित्व किया जाए।

• कोवेक्टर, उर्फ ​​"अजीब पंक्ति वेक्टर" प्रस्ताव हमने हाल ही में चर्चा की है।
• "कोई भी सच्चा वैक्टर" शब्दार्थ नहीं है जो N-1-मैट्रिसेस के रूप में एन-वैक्टर (एनएक्स-मेट्रिसेस के रूप में एन-रो-वैक्टर), जो मैटलैब और इस तरह का समर्थन करता है।
• वर्तमान जूलिया तरीका - घने एन-वैक्टर और एनएक्स 1-मैट्रिसेस को भ्रमित नहीं करते हैं, एन-वैक्टर और एनएक्स 1 मैट्रिसेस को भ्रमित करते हैं, 1xN-matrices के रूप में एन-पंक्ति-वैक्टर का प्रतिनिधित्व करते हैं।

मुझे आश्चर्य है कि अगर "कोई भी सच्चा वैक्टर" दुनिया में कंफ़ेक्ट (स्केलर्स, 1-वैक्टर और 1x1-मैट्रिसेस) को कड़ाई से करना आवश्यक है; @alanedelman और मैं कल इस पर चर्चा कर रहे थे और संख्यात्मक रेखीय बीजगणित में वेक्टर * स्केलर और स्केलर * वेक्टर की

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

ऐसा लगता है कि दो विकल्प हैं
1) समवर्ती कार्य करने के लिए टूलबॉक्स, पैच या पर्यावरणीय ध्वज के आयात को सक्षम करें
2) एक ऐसी भाषा का निर्माण करें जो विशेष दुनिया को एकजुट करने में सक्षम हो, फिर भी उपयोग करने में आसान और तेज हो

मुझे यकीन नहीं है कि यह कैसे होनहार है, लेकिन मैं अभी शोध के एक संभावित दिलचस्प क्षेत्र पर ठोकर खाई हूं।

क्या मैं आपका ध्यान आकर्षित कर सकता हूं:

ज्यामितीय बीजगणित अनुसंधान समूह
http://www.mrao.cam.ac.uk/~clifford/pages/introduction.htm

ज्यामितीय बीजगणित में व्याख्यान पाठ्यक्रम
http://www.mrao.cam.ac.uk/~clifford/ptIIIcourse/course99/

ज्यामितीय बीजगणित के भौतिक अनुप्रयोग
http://www.mrao.cam.ac.uk/~clifford/ptIIIcourse/

21 वीं सदी में भौतिकी और इंजीनियरिंग के लिए एक एकीकृत गणितीय भाषा
http://www.mrao.cam.ac.uk/%7Eclifford/publications/ps/dll_millen.pdf

ज्यामितीय बीजगणित
http://arxiv.org/pdf/1205.5935v1.pdf

ज्यामितीय बीजगणित कम्प्यूटिंग की नींव
http://link.springer.com/book/10.1007%2F978-3-642-31794-1

ज्यामितीय बीजगणित कम्प्यूटिंग
http://link.springer.com/book/10.1007%2F978-1-84996-108-0

इसे थोड़ा और देखने के बाद, यह वास्तव में आश्चर्यजनक लगता है।

जब तक बीजगणित और ज्यामिति को अलग किया गया है, उनकी प्रगति धीमी रही है और उनके उपयोग सीमित हैं; लेकिन जब इन दो विज्ञानों को एकजुट किया गया है, तो उन्होंने प्रत्येक पारस्परिक बलों को उधार दिया है, और पूर्णता की ओर एक साथ मार्च किया है।

• जोसेफ लुई लग्रगे

कल्पना कीजिए कि चश्मे की जरूरत है और न कि आपको चश्मे की जरूरत है। फिर, जब आपको चश्मा मिलता है, तो दुनिया अप्रत्याशित रूप से बदल जाती है। जीए आपके मस्तिष्क के अंदर के लिए चश्मे की तरह है।

• पाब्लो कोलापिन्टो

इस आदमी को लगता है कि सही विचार है ... https://github.com/wolftype/versor

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

यह वीडियो वर्श किए गए GA गणित भाषा के बारे में कुछ अच्छे विवरण में चला गया है।
https://www.youtube.com/watch?v=W4p-e-g37tg

इसके लिए ये स्लाइड हैं। https://github.com/boostcon/cppnow_presentations_2014/blob/master/files/generic_spaces.pdf

जब आप संकलन करते हैं, तो आप वास्तव में आसानी से कुछ आश्चर्यजनक टेंसर कंप्यूटेशन कर सकते हैं।

@ esd100 , मुझे लगता है कि शीर्षक में विशिष्ट मुद्दे पर ध्यान केंद्रित करने के लिए चर्चा को बनाए रखना उपयोगी होगा।

@johnmyleswhite मैंने "

@ esd100 ज्यामितीय बीजगणित दिलचस्प हैं, लेकिन इस मुद्दे को कवर करने वाली सबसे सामान्य चीज नहीं हैं। ज्यामितीय बीजगणित हम मुख्य रूप से असली क्लिफर्ड बीजगणित सीएल (आर ^ एन, आई) में रुचि रखते हैं; हालाँकि, हम अन्य क्लिफर्ड अलजेब्रा में भी रुचि लेंगे, जो _not_ जियोमेट्रिक अलजेब्रा हैं, जैसे क्लिफोर्ड एल्जेब्रस जैसे जटिल वैक्टर Cl (C ^ n, I) या यहां तक ​​कि बीजगणित मनमाने खेतों या नॉनकम्यूटेटिव रिंग्स Cl (F ^ n, I) पर । इसके अलावा, हम खुद को आवश्यक रूप से क्लिफर्ड बीजगणित तक सीमित नहीं करना चाहते हैं, लेकिन विचार करना चाहते हैं कि रैखिक बीजगणित सामान्य सामान्य टेंसर बीजगणित की स्थापना के लिए सामान्यीकरण कहां करता है जहां द्विघात रूप (आंतरिक उत्पाद) आवश्यक रूप से परिभाषित नहीं हैं।

दसियों के बीजगणित सेटिंग में, ओपी में " v' एक नो-ऑप" प्रस्ताव सही अर्थ देता है, क्योंकि यह उलटा एंटीअटोमोर्फिज्म को लगातार सामान्य करता है। हालांकि, यह मेज पर कम से कम तीन प्रस्तावों में से एक है। कोई भी द्विअर्थी विस्तार पर विचार कर सकता है जो

@ जियाहौ आपकी बहुत जानकारीपूर्ण प्रतिक्रिया के लिए धन्यवाद। यह अच्छा है कि किसी को इस विषय की महारत के साथ कुछ प्रकाश डाला जाए। मैं बेहतर समझ पाने के लिए उन विषयों पर अधिक ध्यान देना चाहूंगा। मुझे इस बात की उत्सुकता है कि BLAS के लिए सुपर अनुकूलित कोड क्यों मौजूद है, लेकिन अधिक जटिल बीजगणित के लिए सुपर अनुकूलित कोड, जैसे कि Clifford Algebra नहीं करता है।

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

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

सवाल यह है कि रैखिक बीजगणित की गणितीय अवधारणाओं के लिए इन "नंगे" सरणियों को कैसे बढ़ाया जाए? आप सिंटैक्स को सामान्य गणित की तरह कैसे बनाते हैं? क्या लोग सहज होंगे कि v ''! = V? आदि आदि।

पहली बात यह है कि हम ऐरे को कोई भी बदतर नहीं बनाना चाहते हैं, बस इसलिए हम रैखिक बीजगणित कर सकते हैं। हम ऐरे में वेक्टर या अनावश्यक टेम्पलेट तर्क के लिए अतिरिक्त डेटा जोड़ना नहीं चाहते हैं। हम रैखिक बीजगणित नहीं करते हुए C / C ++ के रूप में उपवास करना चाहते हैं (और उम्मीद है कि C / फोरट्रान के रूप में उपवास करते हैं, जब हम होते हैं)।

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

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

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

मुझे चिंता नहीं है कि हम टाइप सिस्टम में जटिलता जोड़ रहे हैं। मेरा मानना ​​है कि यह गणित को घेरने के लिए आवश्यक है क्योंकि उपयोगकर्ताओं ने इसे हाई स्कूल और विश्वविद्यालय में सीखा था: साहचर्य * (जहां अच्छी तरह से परिभाषित) के लिए, v '' = v, दोनों "ब्रा" और "केट्स" (I यहाँ रैखिक बीजगणित के डायक नोटेशन का उपयोग कर रहा हूँ), आदि।

BTW अगर यह सामान जूलिया 0.4 में लागू किया गया है, तो मैं बेखबर हूँ! मैं अभी भी 0.3.4 समझने पर काम कर रहा हूँ ...

@ कैंडीफरिस , मैं आमतौर पर इस सब से सहमत हूं। मुझे लगता है कि यहां मेरे M*v' त्रुटि होने के बजाय, क्या यह एक कोवेक्टर का उत्पादन करता है और v*M एक त्रुटि होने के नाते, क्या यह एक वेक्टर का उत्पादन करता है। मेरे लिए, यह वैचारिक रूप से M बारे में अज्ञेयवादी है कि क्या इसके आयाम ऊपर या नीचे हैं - आप एक आंतरिक उत्पाद के लिए v'*M*w या v*M*w' लिख सकते हैं और या तो एक काम करेगा।

एक विचार जो चारों ओर उछल रहा है वह पंक्ति-प्रमुख और को-मेजर एरे है और M.' एक से दूसरे में बदल रहा है और इसी तरह v' v पर पंक्ति-प्रमुख भिन्नता है।

+1 से @ कैंडीफरिस । मुझे यह भी लगता है कि हम सिर्फ साधारण आवरण प्रकार Transpose और ConjTranspose जो हमें वैक्टर, मेट्रिसेस के उत्पादों को लिखने के लिए संक्षिप्त मैट्रिक्स बीजगणित वाक्यविन्यास का उपयोग करने की अनुमति देता है और इसके हस्तांतरण करता है। @StefanKarpinski के प्रस्ताव के बिंदु 2 के संबंध में, मैं इन रैपरों को AbstractArray वस्तुओं का कंटेनर नहीं होने दूंगा और मैं AbstractArray प्रकार के पदानुक्रम के प्रकारों का हिस्सा नहीं बनूंगा । Transpose(x) केवल एक प्रकार होना चाहिए जो x' एक अभिव्यक्ति में लिखने से उत्पन्न होता है और इसके मूल्यांकन को स्थगित करने की अनुमति देता है / आलसी मूल्यांकन करता है, बाकी की अभिव्यक्ति के आधार पर Transpose पर डिस्पैच करके। Transpose (जो संभवतः 99.9% मामलों में * गुणा गुणक होगा)। हालांकि, लोगों को इस वाक्यविन्यास को नए प्रकारों के लिए भी अर्थ देने में सक्षम होना चाहिए जो AbstractArray पदानुक्रम का हिस्सा नहीं हो सकते हैं, जैसे कि मैट्रिक्स कारक वस्तुएं या अन्य प्रकार जैसे कि रैखिक संचालक को परिभाषित करने के लिए।

मैट्रिस और वैक्टर के विशिष्ट मामले के लिए, मैं वास्तव में M*v' लिए उपयोग के मामले को नहीं देखता, लेकिन मैं आंतरिक रूप से इसके विरोध में नहीं हूं। महत्वपूर्ण बात यह है कि यह बुनियादी अपेक्षाओं को पूरा करता है (यानी स्टीफन के प्रस्ताव के अंत में 2,4,5,6 और 8 नियम)।

चर्चा का मुख्य अंतिम बिंदु संभवतः स्लाइसिंग के साथ परस्पर क्रिया है। क्या मैट्रिक्स का एक पंक्ति टुकड़ा स्वचालित रूप से Transpose ? यहां मेरा वोट एपीएल स्लाइसिंग नियमों पर है जहां ऐसा नहीं है।

@ जूथो , प्रेरणा * सहयोगी है - A*(v'w) और (A*v')*w दोनों काम करते हैं और एक ही परिणाम का उत्पादन करते हैं, अंतर्निहित तत्व प्रकार के modulo गैर-संघातकता (जैसे - अस्थायी) बिंदु)।

(A*v')*w लिए A*(v'*w) , A*v' के समान परिणाम देने के लिए N=3 सरणी की आवश्यकता होगी। क्या आपके मन में ऐसा था? मैं इससे पूरी तरह से चूक गया।

ठीक है, बहुत दिलचस्प, मेरी कुछ टिप्पणियां हैं।

पहले हमें मुख्य उपयोगकर्ताओं को संबोधित करना होगा। मूल रूप से, Array{T,n} n -dimensional स्टोरेज के रूप में उपयोग करने वाला पहला-सबसे महत्वपूर्ण इसका प्राथमिक कार्य है। यह उन प्रोग्रामरों के लिए समझ में आता है, जिनके पास रैखिक बीजगणित के बारे में कोई विचार नहीं है, लेकिन जो जूलिया में डेटा में हेरफेर करना चाहते हैं। इस वजह से, किसी भी परिस्थिति में एक सरणी टुकड़ा एक सह-वेक्टर वापस नहीं कर सकता है! यह एक सख्ती से रैखिक बीजगणित अवधारणा है जो केवल कुछ डेटा प्रकारों पर T जो एक वेक्टर स्थान और उसके दोहरे (जैसे संख्यात्मक डेटा या "फ़ील्ड") को परिभाषित कर सकती है।

मैं एपीएल स्लाइसिंग के साथ किसी भी तरह से जा सकता था। यह काफी सहज लगता है। यह स्थिर है और कुछ भी आश्चर्यजनक नहीं है। हालांकि मुझे नहीं लगता कि रैखिक बीजगणित को सुसंगत बनाने के लिए यह परिवर्तन करना आवश्यक है ... यह अच्छा हो सकता है (हालांकि यह एक टूटने वाला बदलाव हो सकता है)। मुझे यह अनिश्चित लगता है कि M[1,:] का आकार 1xn और M[:,1] का आकार n (nx1 नहीं) है ... यह बहुत असममित लगता है ... लेकिन मुझे लगता है कि यह एक अच्छा अनुस्मारक है कि कैसे चीजें स्मृति में रखा। वैसे भी .. यह परिवर्तन केवल तभी होना चाहिए जब यह सार डेटा भंडारण और हेरफेर के लिए समझ में आता है। मेरे लिए यह परिवर्तन रैखिक बीजगणित चर्चा के लिए रूढ़िवादी है।

इसलिए, भले ही हम एपीएल स्लाइसिंग नियमों को लागू नहीं करते हैं , फिर भी हम सार्थक रैखिक बीजगणित को काफी सरल रूप से निस्तारण कर सकते हैं। यदि आप i M colvec(M,i) चाहते हैं और यदि आप i th पंक्ति के सह- वेक्टर M कॉल चाहते हैं rowvec(M,i) । यदि i एक टपल या वेक्टर होता है तो यह एक टपल या वेक्टर या (सह) वैक्टर वापस कर सकता है (क्या यह कुछ मामलों में समानांतरकरण के तर्क के लिए उपयोगी हो सकता है?)। यदि आप एक मैट्रिक्स पसंद करते हैं, तो बस सामान्य अनुक्रमण संकेतन का उपयोग करें। यदि हम एपीएल स्लाइसिंग नियमों का उपयोग करते हैं, तो * प्रतीक के साथ पंक्ति और स्तंभ स्लाइस की क्रिया को अलग करने के लिए एक ही चीज बहुत उपयोगी है। (एक विचार करने की आवश्यकता है कि rowvec साथ जटिल संयुग्मन कैसे व्यवहार करता है)।

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

* , मुझे लगता है कि जूलिया में मैट्रिक्स / वेक्टर बीजगणित काम करना चाहिए, इसलिए यह गणित को बहु ऑपरेटर के रूप में दिखता है और कभी महसूस नहीं करता है, जैसे दो वैक्टर, दो कोवेक्टर, दो मेट्रिसेस, आदि के बीच M*v' अनुमति नहीं देनी चाहिए, क्योंकि गणित में कड़ाई से आपको "ओटाइम्स" प्रतीक के साथ समीकरण लिखने की आवश्यकता होती है (एक सर्कल के अंदर बार संकेत) मानक गुणा प्रतीक नहीं। गुणा प्रतीक का उपयोग करना इसका अर्थ है कि यह अ-परिभाषित है! हमारे पास w*M*v' == v'*M*w नहीं हो सकते क्योंकि मैट्रिक्स गुणा कम्यूटेटिव नहीं है। के लिए फिर से M*v'*v यह भावना की संबद्धता के बारे में बात करने के लिए नहीं है * । आप इसे या तो innerproduct(outerproduct(M,v'),v) रूप में व्याख्या कर सकते हैं, जिसके लिए दो अलग-अलग बहु प्रतीकों की आवश्यकता होती है, या अदिश गुणन M * innerproduct(v',v) जहाँ यह _does_ दोनों के लिए * का उपयोग करने के लिए समझ में आता है। इस अभिव्यक्ति के साथ हमें ब्रैकेटिंग की आवश्यकता हो सकती है, या शायद संकलक एक सार्थक क्रम संचालन की खोज कर सकता है (यहाँ ध्यान दें कि मूल्यांकन का सबसे तेज़ क्रम भी वही है जिसे मैं मूल्यांकन का एकमात्र वैध क्रम मानता हूँ)।

वैक्टर, कोवेक्टर और मैट्रिस के साथ हमारे पास एक बीजीय प्रणाली हो सकती है जो मानक गणित के अनुरूप है। जब भी आप दो वैक्टर, या दो कोवेक्टर, या दो मेट्रिसेस के बीच बाहरी उत्पाद का प्रदर्शन करना चाहते हैं, तो आप स्वाभाविक रूप से मल्टी-लीनियर बीजगणित, या सामान्य टेंसर बीजगणित में जा रहे हैं। यहाँ आप संभवतः एक नए प्रतीक का उपयोग करके kron(M,N) तरह गुणा करने वाले मैट्रिस और वैक्टर हो सकते हैं। या आप उपयोगकर्ताओं को एक पूर्ण बहु-रेखीय बीजगणित पैकेज का उपयोग करने की आवश्यकता हो सकती है। या जो भी हो ... यह मूल प्रश्न के दायरे से परे लगता है (जो 14 महीने पहले btw था ...)

इसलिए संक्षेप में, मुझे यहां दिखाई देने वाली चार पूरी तरह से अलग चीजें दिखाई दे रही हैं:

1. एपीएल स्लाइसिंग नियमों का उपयोग करते हुए मनमाना डेटा के Array s के स्लाइसिंग में सुधार करें।
2. जूलिया में रैखिक बीजगणित को अधिक सहज और कुछ सरल अवधारणाओं को जोड़कर गणित के साथ पूरी तरह से सुसंगत बनाएं: covectors और matrices से वैक्टर और covectors निकालने की एक विधि, और covectors, matrices, आदि के बीच संचालन। कई उपयोगकर्ता भी covectors मौजूद नहीं हैं, क्योंकि। 1xn और nx1 मैट्रिसेस का उपयोग करना अपेक्षित रूप से काम करना जारी रखेगा, और वेक्टर एक ही व्यवहार करेगा।
3. गति के लिए, कोवेक्टर जैसे रैपिंग प्रकारों का उपयोग करके transpose , conj , के लिए आलसी मूल्यांकन लागू करें, लेकिन साथ ही मैट्रिसेस के लिए भी।
4. एक सामान्य उद्देश्य टेंसर पैकेज विकसित करें और संभवतः इसे मानक पुस्तकालय में जोड़ें।

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

हाँ, क्षमा करें, M*v' की अनुमति देने के मेरे सुझाव का वास्तव में कोई मतलब नहीं है क्योंकि उत्पादों को संबद्ध करने के विभिन्न तरीके पूरी तरह से अलग आकार का उत्पादन करते हैं। इसलिए, मुझे लगता है कि अगर हम इसे बदलने जा रहे हैं तो मेरा मूल प्रस्ताव जाने का रास्ता है। अब तक कि एपीएल स्लाइसिंग व्यवहार के साथ सबसे अच्छा संयोजन प्रतीत होता है। बेशक, हम एपीएल स्लाइसिंग व्यवहार चाहते हैं या नहीं यह एक उच्च स्तर का विचार है।

मैं सिर्फ कुछ बातें कहना चाहता था और कृपया उन्हें नमक के दाने के साथ लें। वे सिर्फ राय हैं और मुझे पता है कि मेरा वजन ज्यादा नहीं है। हालाँकि, मुझे एक बात समझ में आई क्योंकि मैं

@ esd100 सच है, मैंने ऐसा सोचा था। लेकिन जूलिया के साथ, मैंने सोचा था कि हम _greedy _... कई उद्देश्यों को पूरा करना चाहते थे, और कई चीजों में उत्कृष्टता हासिल करना चाहते थे। गैर-संख्यात्मक डेटा में हेरफेर करने के लिए वास्तविक वैज्ञानिक कारण हो सकते हैं। वर्तमान या पूर्व-वैज्ञानिक हो सकते हैं जो जूलिया उपयोगकर्ता हैं जो अधिक सामान्य प्रोग्रामिंग करना चाहते हैं। मेरा पहले का कहना था कि हमें Array धीमा नहीं करना चाहिए और न ही इसे ट्रांसफ़ॉर्म / संयुग्मन के बारे में बात करने के लिए अतिरिक्त क्षेत्र देकर अधिक मेमोरी लेना चाहिए।

यदि कोई एपीएल स्लाइसिंग करता है, तो पंक्ति या स्तंभ स्लाइस को उसी वस्तु को वापस करना चाहिए। सवाल था: एपीएल स्लाइसिंग के बिना, वापसी के लिए M[1,:] लिए सबसे अच्छी बात क्या है? खैर, अगर M[1,:,:,:,:] रिटर्न एक Array{T,n} , मुझे लगता है यह हर किसी के अगर भ्रमित हैं M[1,:] एक लौटे covector{T} । क्या होगा अगर हम M = zeros(3,3,3) और M[1,:] कॉल करें, जो वर्तमान में 1x9 मैट्रिक्स लौटाता है? क्या हमें इसे एक कोवेक्टर भी बनाना चाहिए? क्या होगा अगर M Array{String,3} ?

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

@ esd100 : मुझे पूरा यकीन है कि प्रोग्रामर वे दर्शक हैं जो जूलिया के लिए डिज़ाइन किए गए हैं। वैज्ञानिक कंप्यूटिंग जूलियास ताकत है लेकिन कई जूलिया उपयोगकर्ता हैं जो इसे एक सामान्य उद्देश्य प्रोग्रामिंग भाषा के रूप में उपयोग करते हैं।

मैं @ कैंडी के साथ सहमत दसियों आवश्यकताओं को विभाजित करना होगा।

पूरे सूत्र को पढ़े बिना मेरा व्यक्तिगत मुद्दा यह है कि अगर मेरे पास एक 3D सरणी A (जैसे टोमोग्राफिक डेटा) और है

imagesc( data[1,:,:] )

यह काम नहीं करता। IMHO data[1,:,:] , data[:,1,:] , और data[:,:,1] 2D सरणियाँ (या उपश्रेणियाँ) होनी चाहिए। वर्तमान में मैं इस मुद्दे को दूर करने के लिए एक स्व-परिभाषित squeeze फ़ंक्शन का उपयोग करता हूं।

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

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

सम्मेलनों के एक विशिष्ट सेट के बाद विशिष्ट विषयों की जरूरतों को पूरा करने के लिए समर्पित संकुल रखना बेहतर है।

@ जूथो मेरी आंत की भावना यह है कि आप सही हैं, लेकिन मुझे आश्चर्य है कि आपके निष्कर्ष का आधार क्या है कि पैकेज "बेहतर" हैं और किन विकल्पों की तुलना में?

यह काफी सरल है। जूलिया के अधिकांश उपयोगकर्ताओं के लिए कार्यात्मकता बेस में है। कार्यक्षमता जो अधिक विशेष है वह एक पैकेज में है।

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

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

वर्तमान चर्चा के संबंध में, वैक्टर और मेट्रिक्स के साथ काम करने वाले हर व्यक्ति एक वेक्टर को स्थानांतरित करने की संभावना की उम्मीद करेंगे, और v ^ T * w = स्केलर होगा। लेकिन इन वैक्टर और मेट्रिक्स का उपयोग कई अलग-अलग चीजों का प्रतिनिधित्व करने के लिए किया जा सकता है, और यह संभवतः क्षेत्र / अनुशासन पर निर्भर करेगा। मैंने उदाहरण दिया है कि v ^ T ऊपर के पदों में वास्तविक कोवेक्टर नहीं हो सकता है।

11 जनवरी 2015 को, 18:10 बजे, esd100 सूचनाएं @github.com ने लिखा:

@ जूथो https://github.com/jutho मेरी आंत की भावना यह है कि आप सही हैं, लेकिन मुझे आश्चर्य है कि आपके निष्कर्ष का आधार क्या है कि पैकेज "बेहतर" हैं और क्या विकल्पों की तुलना में?

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub https://github.com/JuliaLang/julia/issues/4774#issuecomment -69501771 पर

यह काफी सरल है। जूलिया के अधिकांश उपयोगकर्ताओं के लिए कार्यात्मकता बेस में है। कार्यक्षमता जो अधिक विशेष है वह एक पैकेज में है।

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

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

(1) यह याद रखने की कोशिश करें कि क्या मैंने उस फाइल में पहले से ही इसका उपयोग किया है, और / या पुष्टि करने के लिए एक पाठ खोज करता हूं (यदि पूरे नाम को किसी चीज का विकल्प है तो उसे सीमित कर दें)
(2) या तो: (ए) आयात को तुरंत जोड़ें, मेरे विचार की ट्रेन को खोने और इसे फिर से खोजने; या (बी) के बाद मैं जो कुछ भी कर रहा था उसे आयात करने के लिए याद रखने की कोशिश करता हूं, एक और चीज को स्मृति में रखते हुए
(3) कम सामान्य कार्यों के लिए, संभवतः यह देखना होगा कि यह किस पैकेज में है

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

वापस विषय पर, हम कार्यक्षमता की कई परतों के बारे में बात कर रहे हैं --- सेरेन्टली नंगे कंटेनर के रूप में सरणियों से जा रहे हैं (जैसा कि Base.AbstractArray में लागू किया गया है), ऊपर / नीचे शब्दार्थ के साथ कार्टेशियन टेंसर ऑब्जेक्ट्स (जैसा कि मेरे द्वारा वर्णित है) AbstractTensorArray प्रस्ताव , सदिश स्थानों के लिए मैप किए गए सूचकांकों के साथ अधिक सामान्य टेंसर ऑब्जेक्ट्स के लिए (जैसा कि @Jutho के TensorToolbox में ) --- सामान्यता में वृद्धि और अनुकूलन क्षमता में कमी।

मुझे लगता है कि उपयोगकर्ताओं के लिए इन परतों के बीच आसानी से संक्रमण करने में सक्षम होना महत्वपूर्ण है, क्योंकि कम से कम उपयोगकर्ताओं को पता नहीं है कि वे वास्तव में किस स्तर की व्यापकता की जरूरत है जब वे बाहर शुरू करते हैं। एक सरल उदाहरण के रूप में, @ जूथो ने बताया कि @jdbates की छवि प्रसंस्करण उदाहरण में, उपयोगकर्ता बहुत अच्छी तरह से सूचकांकों के विभिन्न सबसेट को अलग-अलग ज्यामितीयताओं से जोड़ना चाहते हैं, ताकि छवि को संसाधित करने के लिए एक तरह से और दूसरी तरह से रंग अंतरिक्ष में हो सके; लेकिन अगर उन्होंने इन ज्यामितीय रूप से सिर्फ एक का उपयोग करना शुरू कर दिया है, तो यह अधिक सामान्य प्रतिनिधित्व को बनाए रखने के लिए सुविधाजनक होना चाहिए जो प्रत्येक को अपनी ज्यामिति के साथ उपयोग करने की अनुमति देता है। यदि अतिरिक्त कार्य (या फ़ंक्शन कॉल पैटर्न) जो सामान्यता के प्रत्येक स्तर पर किक करते हैं, तो समझदार चूक का उपयोग करते हैं --- उदाहरण के लिए, AbstractTensorArray उदासीनता और उदासीन सूचकांकों को एकल डिफ़ॉल्ट कार्टियर वेक्टर रिक्त स्थान पर ऊपर / नीचे करना। क्रमशः "अनुक्रम" रिक्त स्थान, --- फिर यह लगभग निर्बाध हो जाता है। कार्यक्षमता की निचली परत के उपयोगकर्ताओं को उच्च परतों के बारे में जानने या देखभाल करने की आवश्यकता नहीं है, जब तक कि उन्हें उनकी आवश्यकता न हो।

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

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

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

धन्यवाद टोनी, मैं दूसरा। इसके अलावा, हमारे पैकेज सिस्टम के साथ "टूलबॉक्स" का पैकेज की तरह होना कोई समस्या नहीं है, जो एक साथ कई समूह बनाते हैं। @reexport मैक्रो के साथ यह अच्छी तरह से काम करता है।

लेकिन एक और बात है। एक पैकेज के भीतर एक विचार को आगे बढ़ाना बहुत आसान है। अगर कोई कुछ बदलना चाहता है तो बस उसे करता है। बेस एक के भीतर बहुत अधिक प्रतिबंधित है।

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

वर्तमान में वेक्टर * मैट्रिक्स करने का सबसे मुहावरेदार तरीका क्या है?
उदाहरण के लिए, मुझे X (K, N) और b (K,) b मिलेंगे। (N,) लंबाई की वेक्टर पाने के लिए छोड़ दिया गया।
क्या मैं BLAS.gemv('T',1.0,X,b) कहता हूं
या reshape(b'*X,size(x,2))
दोनों थोड़े बदसूरत हैं।

मुझे लगता है कि आप X'b

2015-03-13 17:15 GMT-04: 00 joschu सूचनाएं @github.com:

वर्तमान में वेक्टर * मैट्रिक्स करने का सबसे मुहावरेदार तरीका क्या है?
उदाहरण के लिए, मैंने X को आकृति (K, N) और b के साथ आकृति (K,), और मुझे चाहिए
लंबाई के वेक्टर (एन,) को प्राप्त करने के लिए बाईं ओर b से गुणा करें।
क्या मुझे BLAS.gemv ('T', 1.0, X, b) कहते हैं
या फिर आकार (b '* X, आकार (x, 2))
दोनों थोड़े बदसूरत हैं।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment -79405868।

हाँ, मैंने सोचा था कि एक्स की एक प्रति को ट्रिगर करेगा।
लेकिन @ टाइम लगता है कि मेमोरी एलोकेशन के आधार पर कोई कॉपी नहीं है

julia> X = rand(1000,1000); y = rand(1000);

julia> <strong i="8">@time</strong> y'X;
elapsed time: 0.00177384 seconds (15 kB allocated)

julia> <strong i="9">@time</strong> X'y;
elapsed time: 0.000528808 seconds (7 kB allocated)

हम तो की 'फैंसी पार्स कर X'y समाप्त होता है के रूप में Ac_mul_B(X,y) और बनाता है
वही BLAS आपको सुझाया गया कॉल।

2015-03-13 17:28 GMT-04: 00 joschu सूचनाएं @github.com:

हाँ, हालांकि मैंने सोचा था कि एक्स की एक प्रति को ट्रिगर करेगा।
(लेकिन @time https://github.com/time को लगता है कि ऐसा नहीं है
मेमोरी आवंटन के आधार पर कॉपी

जूलिया> एक्स = रैंड (1000,1000); y = रैंड (1000);

julia> @time y'X;
बीता समय: 0.00177384 सेकंड (15 kB आवंटित)

julia> @time X'y;
बीता समय: 0.000528808 सेकंड (7 kB आवंटित)

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment -79421713।

मानो या न मानो, इस पूरे धागे का एक राइटअप भौतिकवाद के करीब हो रहा है।

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

मुझे लगता है कि किसी भी मामले में conj(transpose(x)) ctranspose(x) बराबर होना चाहिए।

जैसा कि ऊपर तर्क दिया गया है, मुझे आशा है कि गैर-रैपर प्रकार transpose और ctranspose बनाए जाएंगे, इसे एक विशिष्ट गणितीय अवधारणा जैसे dual एक नाम दिया जाएगा। जूलिया जैसी वैज्ञानिक भाषा को उपयोगी डेटा संरचनाओं का एक सेट प्रदान करना चाहिए और आम संचालन को लागू करना चाहिए, लेकिन मुझे लगता है कि यह एक सख्त गणितीय संरचना को संबद्ध करने के लिए एक गलती होगी, क्योंकि यह कुछ अनुप्रयोगों और बहुत जटिल के लिए उपयुक्त नहीं होगा अन्य। यह उपयोगकर्ता पर निर्भर है कि वह इन डेटा संरचनाओं और परिचालनों का उपयोग अपने आवेदन में गणितीय कार्यों को लागू करने के लिए करता है। निश्चित रूप से z.' * A * z z एक जटिल सदिश और A कुछ मैट्रिक्स है, भले ही इसका आंतरिक उत्पाद और / या दोहरे से कोई लेना-देना नहीं है। वैक्टर।

@ जूथो क्या आप z.' * A * z लिए उपयोग का मामला दे सकते हैं?

यदि z1 और z2 दो जटिल वैक्टर Z1 और Z2 का प्रतिनिधित्व करते हैं (जैसे कि Kähler के स्पर्शरेखा स्थान के होलोमोर्फिक भाग में स्पर्शरेखा वैक्टर ) और a दो सहसंयोजक सूचकांकों के साथ एक टेनर A का मैट्रिक्स प्रतिनिधित्व है (उदाहरण के लिए एक जटिल (2,0) Kähler के कई गुना) तो A(Z1,Z2) = z.' * a * z ।

ध्यान दें कि मैं यहाँ जोर देता हूं कि जूलिया z1 , z2 और a केवल कुछ गणितीय वस्तुओं का एक संक्षिप्त रूप _ बनाता है (एक चुने हुए आधार / समन्वय के संबंध में और इसलिए) डेटा संरचनाओं पर संचालन विशिष्ट रूप से गणितीय परिचालनों से जुड़ा नहीं हो सकता है, बिना ये जाने कि ये डेटा संरचनाएँ क्या दर्शाती हैं।

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

इस बिंदु पर मैं पूरी तरह से @StefanKarpinski प्रस्ताव के पक्ष में @andyferris द्वारा ही प्रतिध्वनित

1. एपीएल स्टाइल इंडेक्सिंग
2. v 'किसी प्रकार का Covector या Transpose type देता है

बाकी सब एक विस्तार है। row(M,i) और col(M,i) फ़ंक्शंस जोड़ना अच्छा हो सकता है। अन्यथा, एक कोवेक्टर के रूप में एक पंक्ति निकालने के लिए मुझे लगता है कि आपको M[i,:].' आवश्यकता होगी? IIUC, M[i,:]' इस मामले में conj नहीं चाहते थे?

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

तब से मैंने एक कार्यान्वयन के साथ खेलने की कोशिश की और सबसे अधिक भ्रमित करने वाली बात यह थी कि क्या मैट्रिक्स से निकाले गए कोवेक्टर को संयुग्मित किया गया था या नहीं ...

मुझे लगता है कि आप मैट्रिक्स के शाब्दिक मूल्यों को लेना चाहते हैं। Dirac संकेतन का उपयोग करते हुए, विस्तार करें (कोई भी) मैट्रिक्स M = sum_i | i>जैसे [0,0,1, ..., 0], हम निकालना चाहते हैंU हमें row(U,i)' = col(U’,i) जो एक eigendecomposition से बाएँ और दाएँ eigenvectors निकालने के लिए सही समझ में आता है।

एंडी

15 मार्च 2015 को रात 9:36 बजे, जेफ बेजानसन नोटिफिकेशन @github.com ने लिखा:

इस बिंदु पर मैं पूरी तरह से @StefanKarpinski https://github.com/StefanKarpinski प्रस्ताव के पक्ष में हूं , जो कि ज्यादातर @andyferris https://github.com/andyferris द्वारा प्रतिध्वनित है। विशेष रूप से

एपीएल स्टाइल इंडेक्सिंग
v 'किसी प्रकार का Covector या Transpose type देता है
बाकी सब एक विस्तार है। पंक्ति (M, i) और कॉल (M, i) फ़ंक्शन जोड़ना अच्छा हो सकता है। अन्यथा, कोवेक्टर के रूप में एक पंक्ति निकालने के लिए मुझे लगता है कि आपको M [i ,:] की आवश्यकता होगी। ' ? IIUC, M [i ,:] 'क्या एक संयुग्मन इस मामले में नहीं चाहता था?

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub https://github.com/JuliaLang/julia/issues/4774#issuecomment -81228816 पर

कोई स्वयंसेवक इस पर काम शुरू करने के लिए? उदा @mbauman , @jakebolewski जिन्हें हुआ कि मैं पहले से ही इस धागे में नहीं हूँ :)

सब कुछ खोजने की जरूरत है कि थकाऊ हो सकता है, लेकिन अनुक्रमण व्यवहार के लिए बुनियादी परिवर्तन बहुत बुरा नहीं होना चाहिए। संभवत: @jiahao और @andreasnoack इस बारे में अधिक कह सकते हैं कि कोवेक्टर्स को कैसे शामिल किया जाना चाहिए, जैसे कि अगर कुछ भी हो तो उनका सुपरटाइप क्या होना चाहिए।

इससे पहले कि हम आगे बढ़ सकें, हमें 9, 8 और टिप्पणियों की आवश्यकता नहीं है।

मैं उस के साथ मदद कर सकता हूँ।

हम बहुत करीब हैं

एक प्रासंगिक टिप्पणी के रूप में, यदि कोई Transpose और CTranspose रैपर प्रकार होगा, तो उनका सादा Conjugate रैपर प्रकार भी होना चाहिए, जैसे कि conj(A) आलसी भी। BLAS के साथ गुणा करने के लिए यह वास्तव में उपयोगी नहीं है क्योंकि इसके लिए कोई विशेष समर्थन नहीं है (और BLAS में C अर्थ है hermitian संयुग्म), लेकिन अगर कभी भी पूर्ण जूलिया BLAS कार्यान्वयन है तो यह भी समर्थन करने के लिए बहुत अच्छा होगा। conj(A)*B स्पष्ट संयुग्मन के बिना।

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

शायद @andreasnoack और @simonbyrne हमें बता सकते हैं कि क्या # 6837 पर दोबारा विचार किया जाना चाहिए।

मैं @simonbyrne से सहमत Transpose{Array} <: AbstractArray नहीं होना चाहिए।

अन्य सामान्य विचार:

• मुझे एहसास हुआ कि बाहरी उत्पाद गणना में वर्तमान में "स्वचालित रूप से अनुगामी सिंगलटन आयामों को न जोड़ें" नियम शामिल है। यदि u का आकार (n,) , तो u * u' एक संगणना है जिसमें (n,) x (1, n) । मैट्रिक्स गुणन के सामान्य नियमों का उपयोग करके इस उत्पाद की गणना नहीं की जा सकती है _unless_ हम स्वचालित रूप से (n, 1) होने का पहला तर्क फिर से खोलते हैं।
• MATLAB इंडेक्सिंग शब्दार्थ का "स्वचालित रूप से अनुगामी सिंगलटन आयाम" नियम मूल रूप से "ट्रांसपोज़र सभी आयामों" नियम के साथ असंगत है। पूर्व नियम के साथ, आकार (n,) शब्दार्थ (n,1) और आकार (n,1,1) के आकार के सरणियों के समान हैं, लेकिन ध्यान दें कि यदि पारगमन सभी आयामों को उलट देता है, तो परिणामी सरणियों का आकार (n,) , (1, n) , और (1,1,n) , जो कि _cannot_ के बराबर है यदि आपको केवल अनुगामी सिंगलेट्स जोड़ने की अनुमति है। इसे तार्किक चरम पर ले जाने पर, किसी सरणी के हस्तांतरण में मनमाने ढंग से _leading_ singletons की संख्या हो सकती है और इसलिए इसमें अस्पष्ट आकृति होती है, जो तार्किक रूप से असंगत है।

मैंने एक साहित्य सर्वेक्षण भी किया और कुछ दिलचस्प एपीएल इतिहास को उजागर किया। एपीएल इंडेक्सिंग नियम को हमने आइवरसन की 1962 की पुस्तक में नहीं कहा है, लेकिन एपीएल \ 360 (1968; एपीएल का पहला कार्यान्वयन) में मौजूद था। हालांकि, APL \ 360 स्केल और 1-वैक्टर, एक असंगति है जिसे साहित्य में मान्यता नहीं मिली थी (Haegi, 1976)। बहुआयामी सरणियों के औपचारिक शब्दार्थों की चर्चा पहले ब्राउन के पीएचडी थीसिस (1972 में; वह बाद में एपीएल 2 के रूप में हुई) में दिखाई दी, और उनके शब्दार्थों को औपचारिक रूप देते हुए एक पंक्ति में काम किया।

APL2 के लिए अग्रणी विकास का एक उत्कृष्ट सर्वेक्षण है:

• कार्ल फ्रिट्ज रूहर। "एपीएल को एक्सटेंशन का एक सर्वेक्षण।" एपीएल, एपीएल '82 पर अंतर्राष्ट्रीय सम्मेलन की कार्यवाही में, पृष्ठ 277–14, न्यूयॉर्क, एनवाई, यूएसए, 1982। एसीएम।

अनुक्रमण नियमों पर ध्यान देने के लिए साहित्य में उल्लेखनीय हैं:

• टी। मोर। "सरणियों के एक सिद्धांत के लिए स्वयंसिद्ध और सिद्धांत।" आईबीएम जर्नल ऑफ रिसर्च एंड डेवलपमेंट, 17 (मार्च): 135-175, 1973।
  
  
  
  • एक विशाल ठुमके ने क्विन के स्वयंसिद्ध सेट सिद्धांत का उपयोग करते हुए बहुआयामी सरणियों के शब्दार्थ को औपचारिक रूप दिया, यह दिखाते हुए कि कैसे एपीएल साहित्य "फ्लोटिंग एरे" के निर्माण के लिए स्व-युक्त सेटों की धारणा के साथ स्केल को रैंक-0 सरणियों के साथ भ्रमित किया जा सकता है। ([1] == 1, "ग्राउंडेड सरणियों" के विपरीत, जहां [1]! = 1. बाद में शीला एम। सिंगलटन द्वारा उनके 1980 के मास्टर थीसिस में किए गए कार्य से पता चला कि ग्राउंडेड एरे का वर्णन करने के लिए मोर के सरणी सिद्धांत को भी अनुकूलित किया जा सकता है।)
  
  
  • अधिक यह भी वर्णन करता है कि आंतरिक उत्पाद स्केलर को सरणी सरणी शब्दार्थ के मार्गदर्शन के लिए एक महत्वपूर्ण नियम के रूप में लौटाता है।
  
  
  • सामान्य बहुआयामी सरणियों के लिए "अप / डाउन-नेस" को संभालने की जटिलता के लिए और भी अधिक:
    
    "V को एक क्षेत्र में एक n- आयामी वेक्टर स्थान होना चाहिए। वी पर contravariance और covariance के विचारों की अवहेलना करना, V पर वैलेंस q का दसवां भाग सूची V के कार्टेशियन उत्पाद का एक बहुखंडीय मानचित्रण है। V की लंबाई वेक्टर में है यदि वी के पास आधार है, तो वी पर वैलेंस क्यू का एक टेनॉर _component टेन्सर_ द्वारा दर्शाया जा सकता है, जो कि क्यू अक्ष पर एक सरणी है, प्रत्येक लंबाई एन। "
  
  
• जी। लुईस। "एपीएल के लिए एक नई सरणी अनुक्रमण प्रणाली", एपीएल पर सातवें अंतर्राष्ट्रीय सम्मेलन की कार्यवाही - एपीएल '75, 234-239, 1975।
  
  
  
  • यह पेपर पहली बार अनुक्रमणिका संचालन में इंडेक्स ट्यूपल की वकालत करने के लिए एपीएल में प्रथम श्रेणी का ऑब्जेक्ट था, और नोट किया कि इंडेक्सिंग के परिणाम के एक सुसंगत निर्माण को इंडेक्स ट्यूपेले के प्रत्येक रैंक के साथ व्यवस्थित कार्टेशियन उत्पादों द्वारा प्राप्त किया जा सकता है।
  
  
• हंस आर हैगी। "एपीएल का विस्तार ट्रेकलीक डेटा संरचनाओं के लिए।" ACM SIGAPL APL कोट क्वाड, 7 (2): 8–18, 1976।
  
  
  
  • इस पत्र ने शास्त्रीय APL \ 360 में एक विसंगति के बारे में शिकायत की, जिसने स्केलर और 1-सरणियों को स्वीकार किया, और वकालत की कि एपीएल अनुक्रमण नियम ने इस टकराव को पकड़ में नहीं आने की आवश्यकता है।
  
  
  • इस पत्र में लुईस, 1975 के समान एक निर्माण भी शामिल है; कार्य स्वतंत्र प्रतीत होता है।
  
  
• जेए गेरथ और डीएल ऑर्थ। "एपीएल में अनुक्रमण और विलय।" APL, APL '88 पर अंतर्राष्ट्रीय सम्मेलन की कार्यवाही में, पृष्ठ 156-161, न्यूयॉर्क, एनवाई, यूएसए, 1988. एसीएम।
  
  
  
  • यह ध्यान दिया जाता है कि एपीएल इंडेक्सिंग नियम को इंडेक्सिंग के रूप में मूल्य निर्धारण के लिए इंडेक्स सेटिंग ब्रॉडकास्टिंग ऑपरेशन के रूप में अनुक्रमित करने के बारे में सोचकर उचित ठहराया जा सकता है। यह कार्यात्मक व्याख्या स्वाभाविक रूप से रैंक संरक्षण नियम और लुईस और Haegi के कार्टेशियन निर्माण का सुझाव देती है।
  
  

इसके अलावा, "ट्रेलिंग सिंगलटन आयाम जोड़ सकते हैं" नियम के बिना, हम पहचान का पालन नहीं करते हैं

चूंकि बाएं हाथ की ओर एक अदिश (ट्रेस की परिभाषा के अनुसार) है और दाहिने हाथ की तरफ (1, n) x (n, n) x (n,) = (1,) । इसके विपरीत, हम इस पहचान को सदिश वाष्पोत्सर्जन शब्दार्थ के चयन के लिए एक मार्गदर्शक सिद्धांत के रूप में ले सकते हैं। मुख्य बिंदु ट्रेस ऑपरेशन की चक्रीय संपत्ति है जो पहली पहचान को परिभाषित करता है। ट्रेस के अंदर की मात्रा या तो स्केलर या मैट्रिक्स होनी चाहिए (वेक्टर का ट्रेस निर्धारित नहीं है)। Avv' पहले से ही स्पष्ट रूप से एक मैट्रिक्स है: (Av)v' और A(vv') एक ही परिणाम का उत्पादन करते हैं। लेकिन दूसरी मात्रा से भी v'Av का एक मैट्रिक्स _or_ एक अदिश होना चाहिए। (यदि स्केलर, दूसरी पहचान भी रखता है।) v'Av केवल 1-वेक्टर हो सकता है यदि "ट्रेलिंग सिंगलटन आयाम जोड़ सकते हैं" नियम सक्रिय है, तो इस मामले में यह पारदर्शी रूप से 1x3 मैट्रिक्स पर फिर से आकार ले सकता है।

इस प्रकार यदि हम चाहते हैं कि ट्रेस को परिभाषित किया जाए, तो यह आवश्यक रूप से बाहरी उत्पादों के स्वीकार्य आकार पर vv' और द्विघात रूपों का v'Av प्रतिबंध लगाता है।

@ ल्हाओ : मुझे यकीन नहीं है कि आप हमारे खिलाफ क्या बहस कर रहे हैं। क्या आप "स्पष्ट रूप से एकल आयाम नियम जोड़ सकते हैं" को थोड़ा और स्पष्ट रूप से बता सकते हैं? यह कब लागू होता है? क्या आपको लगता है कि हमें इसका समर्थन करना चाहिए?

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

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

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

बी के लिए निर्दिष्ट सब्सक्राइबर्स की संख्या, जिसमें 1 के बराबर ट्रेलिंग सब्सक्राइबर शामिल नहीं हैं, ndims (B) से अधिक नहीं है।

औपचारिक रूप से मुझे लगता है कि इसे निम्न प्रकार से कहा जा सकता है:

इनपुट के रूप में सरणियों के संचालन के लिए, इन कार्यों के लिए वैध तर्क होने के संबंध में (n,) , (n,1) , (n,1,1...) सरणियाँ सभी समान श्रेणी में हैं। (यदि n=1 , तो समतुल्य वर्ग में भी स्केल शामिल हैं।)

उदाहरण:

• A*b और A\b जहां A एक मैट्रिक्स है और b एक सदिश या मैट्रिक्स हो सकता है ( n x 1 matrices के लिए समान शब्दार्थ)
• hcat(A, b) जहां A एक मैट्रिक्स है और b एक वेक्टर या मैट्रिक्स हो सकता है

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

लंबे समय के रूप के रूप में Transpose{A<:AbstractArray} की एक उप प्रकार नहीं है AbstractArray मुझे लगता है कि मैं एक समस्या नहीं दिख रहा है (लेकिन शायद मैं कुछ अनदेखी कर रहा हूँ के रूप में मैं नहीं तुम लोगों के रूप में ज्यादा विचार के रूप में यह दे दिया है) :
साथ में

typealias AbstractVectorTranspose{A<:AbstractVector} Transpose{A}
typealias AbstractMatrixTranspose{A<:AbstractMatrix} Transpose{A}
typealias AbstractTMatrix Union(AbstractMatrix, AbstractMatrixTranspose} 

(और इसी तरह CTranspose ) हमारे पास हो सकता है

AbstractVectorTranspose * AbstractVector = Number
AbstractVector * AbstractVectorTranspose = AbstractMatrix
AbstractVectorTranspose * AbstractTMatrix = AbstractVectorTranspose
AbstractTMatrix * AbstractVector = AbstractVector
AbstractTMatrix * AbstractTMatrix = AbstractTMatrix

एकमात्र खुला सवाल यह है कि क्या AbstractVector * AbstractTMatrix का समर्थन तब किया जाना चाहिए जब AbstractTMatrix में पहले आकार के रूप में 1 हो, या AbstractVector * AbstractVectorTranspose पर्याप्त हो।

इसके अलावा, नए प्रकार की प्रणाली उन typealias और union sa को अधिक ध्यान से व्यक्त करने में मदद कर सकती है।

इसके अलावा, यदि v.'*A की गणना (A.'*v).' , तो Conjugate रैपर की आवश्यकता होती है यदि A ही A=B' ।

मैं @simonbyrne से सहमत Transpose{Array} <: AbstractArray नहीं होना चाहिए।

क्या आप वहाँ विस्तृत कर सकते हैं? मुझे लगा कि https://github.com/JuliaLang/julia/issues/4774#issuecomment -59428215 में राय यह थी कि CoVector AbstractVector का उपप्रकार नहीं होना चाहिए, लेकिन यह मुझे थोड़ा अजीब नहीं लगेगा Transpose{Matrix} <: AbstractArray ।

इसके लायक क्या है, मुझे लगता है कि CoVector को ज्यादातर Vector जैसा व्यवहार करना चाहिए, सिवाय इसके कि Vector एक कॉलम मैट्रिक्स के रूप में Matrix में परिवर्तित हो जाए जबकि CoVector पंक्ति मैट्रिक्स के रूप में Matrix में परिवर्तित होती है।

मुझे लगता है कि एक covector में अनुक्रमण का मतलब होगा कि एक पंक्ति मैट्रिक्स के रूप में ही काम करना चाहिए?

यह एक दिलचस्प विचार है। क्या चीजें आसान या अधिक जटिल हो जाती हैं अगर केवल _leading_ सिंगलटन आयाम को ट्रांसपोज़ / कोवेक्टर प्रकारों में गिरा दिया जाता है?

(मैं इस मुद्दे को ब्याज के साथ पालन कर रहा हूं, लेकिन मेरी रैखिक बीजगणित पर्याप्त रूप से कठोर है कि मैंने योगदान करने के लिए योग्य नहीं महसूस किया है)।

@ मबूमन :

क्या चीजें आसान या अधिक जटिल हो जाती हैं यदि केवल प्रमुख सिंगलटन आयामों को ट्रांसपोज़ / कोवेक्टर प्रकारों में गिरा दिया जाता है?

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

@tkelman :

मुझे लगा कि # 4774 (टिप्पणी) में राय यह थी कि CoVector को AbstractVector का उपप्रकार नहीं होना चाहिए, लेकिन मेरे लिए Trans {{मैट्रिक्स} <: AbstractArray नहीं होना थोड़ा अजीब लगेगा।

यह मेरे लिए स्पष्ट हो गया है कि यह मुद्दा पूरी तरह से सरणी बीजान्टिक्स (cf # 10064) को रैखिक बीजगणित शब्दार्थ से अलग करने के बारे में है, और उन स्थानों की तलाश कर रहा है जहां रुक-रुक कर होते हैं।

• सरणी शब्दार्थ को आकार, लंबाई, गेटिंडेक्स, सेटिंडेक्स, एचसीएटी, वीसीएटी, रिशेप, रोट 90 जैसे कार्यों द्वारा परिभाषित किया जाता है ...
• रैखिक बीजगणित शब्दार्थ +, -, *, /,, ', ट्रेस जैसे कार्यों से परिभाषित होते हैं ...

यदि हम परिभाषित cat कार्यों एक के आवश्यक इंटरफ़ेस का हिस्सा बनने के AbstractArray , तो Transpose{<:AbstractArray} नहीं स्पष्ट रूप से है एक AbstractArray क्योंकि उनके संयोजन व्यवहार अलग हैं । यदि हम केवल आकृति और अनुक्रमण को आवश्यक इंटरफ़ेस का हिस्सा मानते हैं तो स्थिति कम स्पष्ट है।

यदि हम एक के आवश्यक इंटरफ़ेस के भाग के रूप संयोजन की आवश्यकता होती है AbstractArray , तो यह भी आसान सही ठहराने के लिए कारण है कि जैसे प्रकार SymTridiagonal नहीं कर रहे हैं AbstractArray एस, से अधिक संयोजन के संचालन के बाद से SymTridiagonal s जैसे [SymTridiagonal(randn(5), randn(4)) randn(5)] वर्तमान में अपरिभाषित हैं।

@toivoh :

मुझे लगता है कि एक covector में अनुक्रमण का मतलब होगा कि एक पंक्ति मैट्रिक्स के रूप में ही काम करना चाहिए?

ऐसी पहचानें हैं जो बताती हैं कि Transpose{Vector} का अनुक्रमण व्यवहार सामान्य Vector s के समान होना चाहिए। इस बात पर विचार करें कि संख्यात्मक प्रकारों के लिए, v[1] v' * e₁ = v ⋅ e₁ और v[1:2] के समान परिणाम उत्पन्न करता है, v' * [e₁ e₂] , जहाँ e₁ के समान परिणाम होता है विहित आधार Vector{Int} [1, 0, 0, ...] और e₂ [0, 1, 0, 0, ...] । यदि हमें अनुक्रमित, आंतरिक उत्पादों और पकड़ से संबंधित इन पहचानों की आवश्यकता होती है, तो कोई भी दावा कर सकता है

(v')[1] == (e₁' * v'') == (v' * e₁)' == (v ⋅ e₁)' == conj(v ⋅ e₁)* = conj(v[1])

(जहां पहला कदम एक नया स्वयंसिद्ध है और चौथा इस तथ्य का उपयोग करता है कि एक स्केलर को ट्रांसप्लांट करना एक नो-ऑप है) ताकि Transpose{Vector} में अनुक्रमण अनिवार्य रूप से ट्रांसपोज़न को अनदेखा कर सके, और CTranspose{Vector} में अनुक्रमण किया जा सके

मुझे लगता है कि यह मुद्दा पूरी तरह से रैखिक बीजगणित शब्दार्थ से सरणी शब्दार्थ (cf # 10064) को अलग करने के बारे में है, और उन स्थानों की तलाश में है जहां रुक-रुक कर होते हैं।

• सरणी शब्दार्थ को आकार, लंबाई, गेटिंडेक्स, सेटिंडेक्स, एचसीएटी, वीसीएटी, रिशेप, रोट 90 जैसे कार्यों द्वारा परिभाषित किया जाता है ...
• रैखिक बीजगणित शब्दार्थ +, -, *, /,, ', ट्रेस जैसे कार्यों से परिभाषित होते हैं ...

उस दृष्टिकोण से +1 और Transpose <: AbstractArray । इसके अलावा, जब एक कोवेक्टर को अनुक्रमित किया जाता है, तो यह एक एकल सूचकांक के साथ होना चाहिए, क्योंकि अन्यथा कोवेक्टर का परिणाम * वेक्टर (एकल सूचकांक पर अनुबंध) एक स्केलर (शून्य सूचकांकों के साथ एक वस्तु) में परिणाम नहीं कर सकता है।

@jihao : मुझे यकीन नहीं है कि मैं देख पा रहा हूँ कि हमें क्यों चाहिए या चाहिए

(v')[1] == (e₁' * v'')

एक नए स्वयंसिद्ध के रूप में। हालाँकि, भले ही एक covector एक पंक्ति मैट्रिक्स के रूप में अनुक्रमित करेगा, मुझे लगता है कि हम रैखिक अनुक्रमण के कारण उपरोक्त के लिए समान परिणाम प्राप्त करेंगे।

और +1 को कोवेक्टर को रैखिक बीजगणित से संबंधित देखने के लिए।

लेकिन कोई कारण नहीं है कि SymTridiagonal साथ सहमति को परिभाषित नहीं किया जाना चाहिए, है ना?

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

मुझे लगता है कि रैखिक अनुक्रमण भंडारण क्रम के बारे में था, और वास्तव में किसी वेक्टर के रैखिक अनुक्रमण के लिए कोई अन्य समझदार आदेश नहीं है, है ना? (और गलत वर्तनी के बारे में खेद है।)

स्मृति में कोई अद्वितीय समझदार ट्रैवर्सल ऑर्डर नहीं है। यहां तक ​​कि फोरट्रान सरणियों के लिए आप कॉलम मेजर, रो मेजर, या रिवर्स कॉलम मेजर ऑर्डर में तत्वों को स्टोर करने का विकल्प चुन सकते हैं (जो कि मूल आईबीएम फोरट्रान I कंपाइलर ने किया था)। इसके अलावा अन्य डेटा संरचनाएं हैं (# 10064 देखें) ऐसे प्रयास करता है जो सरणियों के रूप में उपयोग किए जा सकते हैं और ट्रैवर्सल ऑर्डर के लिए और भी अधिक विकल्प हैं।

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

@toivoh हाँ सामान्य परिभाषाओं के लिए समान परिभाषाएँ हैं। यह इस तथ्य को परिवर्तित नहीं करता है कि रैखिक अनुक्रमण साधारण (टपल?) से बना है या तो मामले में अनुक्रमण है।

इंडेक्सिंग Transpose ऑब्जेक्ट्स को अस्वीकृत किया जा सकता है। मैं यह नहीं कह रहा हूं कि उन्हें अनुक्रमित होना चाहिए, लेकिन अगर वे हैं, तो जरूरी नहीं कि उनके पास समान अनुक्रमण व्यवहार हो। रूढ़िवादी होने के लिए, हम अभी के लिए अनुक्रमित अपरिभाषित छोड़ सकते हैं और देख सकते हैं कि क्या कोई उपयोग के मामले दिखाई देते हैं।

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

सही, दुआ।

@ जूथो : मैं सहमत हूं। और वहां फिट होने के लिए, कोवेटर्स को पंक्ति मैट्रिसेस की तरह इंडेक्स करना चाहिए, है ना?

@toivoh , अगर आप का मतलब है कि वे

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

@ जूथो : ठीक है, मैं मानता हूं कि यह संभवत: कोई फर्क नहीं पड़ता क्योंकि वापसी प्रकार को वैसे भी अलग होना चाहिए।

यहाँ यह बताने का प्रयास किया जा रहा है कि हम क्या करने की कोशिश कर रहे हैं और कुछ स्वयंसिद्ध शब्द दे रहे हैं:

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

मेरा मानना ​​है कि हम जो करने की कोशिश कर रहे हैं वह शुद्ध मैट्रिक्स सेटिंग को निरंतर रूप से विस्तारित करने और परिष्कृत करने के लिए है, जिसमें सच्चे स्केलर और वैक्टर भी हैं, और क्योंकि यह निरंतरता, कोवेटर्स के लिए आवश्यक लगता है।

यहाँ स्केलर्स और वैक्टर के बारे में मेरा विचार है (जैसा कि शुद्ध मैट्रिक्स के दृष्टिकोण से देखा जाता है): एक स्केलर एक मैट्रिक्स है, जिसके प्रकार 1 x 1 के लिए विवश हैं। एक वेक्टर एक मैट्रिक्स है, जिसके प्रकार से विवश है be nx 1. (मैं नीचे तर्क दूंगा कि एक कोवेक्टर एक मैट्रिक्स है, जिसके प्रकार 1 x n तक सीमित हैं।) इस दृष्टिकोण से हम दो स्वयंसिद्ध संकेत दे सकते हैं: (बहुत औपचारिक रूप से नीचे वर्णित नहीं)

• विस्तार: मैट्रिसेस से मैट्रिसेस के फंक्शन पर विचार करें। यदि यह किसी निश्चित आयाम के दिए गए आयामों में 1 के आकार के साथ हमेशा आउटपुट मैट्रिक्स का उत्पादन करेगा, तो यह तथ्य आउटपुट के प्रकार में एन्कोड हो जाएगा (इसे एक स्केलर / वेक्टर / कोवेक्टर बना देगा)।
• शोधन: यदि कोई फ़ंक्शन जो शुद्ध मैट्रिक्स सेटिंग में एक मैट्रिक्स तर्क लेता है, तो इनपुट को एक या अधिक आयाम में एक के आकार की आवश्यकता होती है, यह एक इनपुट को स्वीकार करने से इंकार कर सकता है जहां यह तथ्य प्रकार में एन्कोडेड नहीं है।

यदि हम ऊपर से सहमत हैं, तो वेक्टर का संक्रमण ऊपर वर्णित कोवेक्टर की तरह होना चाहिए: चिंता का संचरण 1 मैट्रिक्स 1 xn मैट्रिक्स पैदावार देता है। यदि हम इस तथ्य को एनकोड करते हैं कि परिणाम के पहले आयामों के साथ आकार हमेशा एक होता है, तो हमें ऊपर वर्णित के अनुसार कोवेक्टर मिलता है।

यदि आप मैट्रिक्स बीजगणित के दृष्टिकोण से शुरू करते हैं, तो आप जो कहते हैं वह सही है। यह वह मॉडल है जो MATLAB शायद पूरी तरह से लागू करता है। सब कुछ एक मैट्रिक्स है। यह एक बंद प्रणाली है, मैट्रिसेस पर सभी ऑपरेशन नए मैट्रिसेस का उत्पादन करते हैं।

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

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

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

मैं यहाँ @ जूथो से सहमत हूँ; इस मुद्दे का पूरा बिंदु MATLAB के "सब कुछ एक मैट्रिक्स है" शब्दार्थ से दूर जाना है। MATLAB के "अनुगामी एकल आयाम जोड़ सकते हैं" ब्रह्मांड को रेखीय बीजगणित संचालन के तहत बंद करने के लिए नियम आवश्यक है, लेकिन यह नियम समतुल्यता वर्गों को परिभाषित करता है जिसमें T सदस्य होते हैं और अन्य प्रकार के Array{T,N} लिए। सभी N , और इसका मुख्य कारण है कि MATLAB का प्रकार प्रणाली अनिर्दिष्ट है। ( जोइशा और बनर्जी, 2006 के प्रमेय 1 देखें - हालांकि परिणाम आकृतियों के संदर्भ में बताया गया है, समस्या वास्तव में यह है कि बदलते रैंक रैंक कार्यक्रम के शब्दार्थों को कैसे बदल सकते हैं।)

लेकिन मुझे अभी भी लगता है कि हम स्केलर, वैक्टर, कोवेक्टर और मेट्रिसेस के उस गुणन पर बहुत अच्छी आम सहमति रखते थे, जो सहयोगी होना चाहिए ( (v'*v)*v जैसी चीजों के लिए अपवाद के साथ जहां दो गैर-स्केलर एक स्केलर का उत्पादन करने के लिए गुणा करते हैं), और वह जैसे v'*M*v को एक स्केलर, M*v एक वेक्टर और v'*M एक कोवेटर का उत्पादन करना चाहिए। मुझे यकीन नहीं है कि इन स्थितियों को पूरा करते हुए भी यह सब कुछ एक-से-मैट्रिक्स अर्थ-विज्ञान से भटकना संभव है।
इससे अधिक क्या है कि हम बचने की कोशिश कर रहे हैं, और इसके बजाय हम कौन से गुण हासिल करना चाहेंगे?

यह कितना बुरा है अगर हम केवल कुछ मामलों में T और Array{T,0} को भ्रमित करेंगे? (जैसे अनुक्रमण: M[:,2] Array{T,1} , लेकिन M[2,2] Array{T,0} उत्पादन नहीं करता है)

हम अभी भी Transpose{Vector} साथ मान्य शब्दार्थ बनाए रख सकते हैं।

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

मतलाब-प्रकार के शब्दार्थ के साथ समस्या यह है कि M*v' और v*M कभी-कभी काम करते हैं, भले ही उन्हें नहीं करना चाहिए। अगर M m x 1 तो M*v' वैध है और एक बाहरी उत्पाद जैसी मात्रा ( v' 1 x n ) देता है। इसी प्रकार, यदि M 1 x m और हमारे पास "अनुगामी एकल" नियम जोड़ सकते हैं तो v*M का मूल्यांकन n x 1 और 1 x m के उत्पाद के रूप में किया जा सकता है।

APL साहित्य में T और Array{T,0} का मूल्य लगाने का प्रश्न भी उठाया गया था - APL में, बहुआयामी सरणियों का पुनरावर्ती रूप से नेस्ट किया जाता है, जो इस प्रश्न को उठाता है कि क्या Array{T,0} और T भेद हैं। यदि नहीं, तो वे "ग्राउंडेड एरे" हैं (जो T लिए नीचे गिरते हैं), अन्यथा वे "फ़्लोटिंग एरे" हैं (जो Array{T,0} ही घटते हैं)। मेरा मानना ​​है कि अधिक, 1973 वास्तव में साबित हुआ कि या तो विकल्प स्वयंसिद्ध रूप से सुसंगत है। मुझे यकीन नहीं है कि अगर एपीएल ने कभी उस सवाल को हल किया, जिसका उपयोग करने से पहले अधिकांश चिकित्सक सेवानिवृत्त हो गए थे या किसी और चीज़ पर चले गए थे।

@ जियाओ : मुझे महसूस नहीं हुआ कि आपका अवलोकन कितना मौलिक था

v[i] = e_i' * v

एक साथ रैखिक बीजगणित और अनुक्रमण शब्दार्थ को जोड़ने के लिए। लेकिन फिर आपको भी विचार करना चाहिए

M[i,j] = e_i' * M * e_j

जो इंगित करता है कि दाएं से आधार वेक्टर वाला एक आंतरिक उत्पाद दूसरे आयाम के साथ अनुक्रमण के अनुरूप है। इस प्रकार, मैं यह सुनिश्चित करूंगा कि एक covector की i th प्रविष्टि v' रूप में अनुक्रमित की जाए

v' * e_i = v'[1, i]

जहाँ हम निश्चित रूप से 1 को पहले इंडेक्स के रूप में लिखना चाहते हैं, लेकिन क्या?
वैसे भी, जब से हम अनुमति देते हैं

e_i' * v = v[i] = v[i, 1]

तब 1 को एक प्लेसहोल्डर के रूप में भी उपरोक्त मामले में अनुमति दी जानी चाहिए।

v' * e_i एक अदिश e_1' * (v' * e_i) एक कोवियार है, न कि एक अदिश। इसलिए आयाम v'[1, i] = e_1' * v' * e_i विचार से मेल नहीं खाते हैं

संपादित करें: मुझे लगता है कि यह अनुक्रमण में एकल एकल गाने की अनुमति देने के खिलाफ एक तर्क हो सकता है?

हां, मैट्रिक्स इंडेक्सिंग अगला तार्किक कदम है, और e_i' * M * e_j वास्तव में उन अभिव्यक्तियों में से एक है, जहां सहक्रियाशीलता स्वयंसिद्ध उपयोगी हो जाती है, क्योंकि

(e_i' * M) * e_j = m_i' * e_j

e_i' * (M * e_j) = e_i' * m_j

बराबर होना चाहिए। मैट्रिक्स इंडेक्सिंग को वेक्टर इंडेक्सिंग नियम और कोवेक्टर इंडेक्सिंग नियम से प्राप्त किया जा सकता है।

मेरा मानना ​​है कि इस मुद्दे के एक सुसंगत समाधान के लिए v[i, 1] जैसे भावों की आवश्यकता हो सकती है, क्योंकि नियम जो इस अनुक्रमण व्यवहार की अनुमति देता है
a) को A*v' और v*A काम करने के लिए (पूर्व करता है लेकिन बाद वाला नहीं है क्योंकि हम अनुगामी सिंगलटन नियम को असंगत रूप से लागू करते हैं), और
ख) यदि हम v[i] = v[i, 1, 1, 1] की समानता पर विचार करते हैं, तो संबंधित कोवेक्टर अनुक्रमण नियम (v')[1, 1, 1, i] और किसी को संगतता के लिए "अग्रणी एकल गायकों की मनमानी संख्या" नियम की अनुमति होगी। मैं एक विशिष्ट परिभाषित पहले आयाम की कमी को बहुत परेशान करता हूं।

मुझे नहीं लगता कि यह सूचकांक तर्क वास्तव में कहीं जा रहा है। इंडेक्सिंग N -dimensional सरणियों की एक सामान्य संपत्ति है, और यह कि उन्हें N=1 या N=2 लिए सरल मैट्रिक्स अभिव्यक्ति के रूप में लिखा जा सकता है, बल्कि एक तुच्छ है और कोई मौलिक नहीं है जानकारी। लेकिन यह उच्च श्रेणी के सरणियों के लिए सामान्यीकरण नहीं करता है और इस प्रकार यह प्रेरित करने के लिए उपयोग नहीं किया जाना चाहिए कि क्या कोवेक्टर को अनुक्रमित होने के दौरान अग्रणी 1 की आवश्यकता है या नहीं। यह जल्दी से पिछली पोस्ट में देखी गई विसंगतियों की ओर ले जाता है।

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

मुझे यह सब पूरी तरह से हजम नहीं हुआ है लेकिन मेरा मुख्य सवाल बस इतना है: size(covector) (n,) या (1,n) ?

यदि वे AbstractArray परिवार का हिस्सा नहीं हैं, तो यह भी कड़ाई से आवश्यक नहीं है कि size परिभाषित हो।

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

"जब तक बीजगणित और ज्यामिति को अलग किया गया है, उनकी प्रगति धीमी रही है और उनके उपयोग सीमित हैं; लेकिन जब ये दो विज्ञान एकजुट हो गए हैं, तो उन्होंने प्रत्येक पारस्परिक बलों को उधार दिया है, और पूर्णता की ओर एक साथ मार्च किया है।" - जोसेफ लुई लग्रगे

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

http://ocw.mit.edu/resources/res-8-001-applied-geometric-algebra-spring-2009/lecture-notes-contents/

वास्तव में, इसके बारे में सोचने के लिए, यह कहना अधिक उचित है

e_i' * x = x[i, :] # x is a vector or matrix
x * e_j  = x[:, j] # x is a covector or matrix

फिर मैट्रिक्स अनुक्रमण के लिए हमारे पास होगा

e_i' * M * e_j = e_i' * (M * e_j) = e_i' * M[:, j] = M[:, j][i, :] = M[i, j]
e_i' * M * e_j = (e_i' * M) * e_j = M[i, :] * e_j  = M[i, :][:, j] = M[i, j]

वर्तमान में यह जूलिया में काफी पकड़ नहीं रखता है, जैसे v[i, :] वर्तमान में 1x1 सरणी का उत्पादन करता है और स्केलर का नहीं। (लेकिन शायद यह नहीं होना चाहिए)
e_i' * M * e_j में मैट्रिक्स गुणन की संबद्धता अलग-अलग आयामों M[:, j][i, :] = M[i, :][:, j] साथ स्लाइसिंग की अनुकूलता से मेल खाती है, जो कि एक वांछनीय विशेषता की तरह लगती है।
रिओसिंग की उपरोक्त पंक्ति के अनुसार, हमारे पास होना चाहिए

v'[:,i] = conj(v[i])

@ जूथो : मुझे लगता है कि यह "बार-बार स्लाइसिंग के रूप में अनुक्रमण करता है" प्रतिमान उच्च आयामी सरणियों / e_i , आदि के अनुसार पहले क्रम के टेनसरों के साथ संकुचन की एक श्रृंखला से मेल खाती है, किसी भी क्रम में (जब तक कि आप किन आयामों का मिलान करते हैं)।

मुझे लगता है कि इस "अनुक्रमण को बार-बार स्लाइसिंग के रूप में" प्रतिमान उच्च आयामी सरणियों / टेनर्स के लिए सामान्य करता है: आप किसी भी क्रम में अनुक्रमणिका के प्रत्येक आयाम के लिए एक स्लाइसिंग लागू करते हैं। यह किसी भी क्रम में (जब तक आप किन आयामों का मिलान करते हैं, ट्रैक करते हैं) e_i, आदि के अनुरूप फर्स्ट ऑर्डर टेनसरों के साथ संकुचन की एक श्रृंखला से मेल खाती है।

हाँ, मैं टेंसर संकुचन आदि से बहुत परिचित हूँ, और वास्तव में एक मैट्रिक्स तत्व / टेंसर तत्व प्राप्त करना मानक कम्प्यूटेशनल आधार में एक उम्मीद मूल्य लेने के लिए मेल खाता है, अर्थात कुछ आधार वैक्टर के साथ अनुबंध करना (जब तक आपके पास कम से कम एक orgogonal आधार है ), लेकिन इसमें कोई अद्वितीय संबंध नहीं है कि क्या कोई इंडेक्स e_i साथ या e_i' साथ एक संकुचन से मेल खाता है। यह तय करने से मेल खाती है कि क्या संबंधित अनुक्रमणिका सहसंयोजक या कंट्रावेरिएंट स्थिति में दिखाई देती है, और कोई अनूठा निर्णय नहीं है। ऊपरी और निचले सूचकांकों के सभी संभावित संयोजनों में उपयोगी अनुप्रयोग हैं। लेकिन e_i और e_i' साथ अनुबंध करना गणितीय दृष्टिकोण से इस प्रश्न को प्रस्तुत करने का सही तरीका भी नहीं है, क्योंकि जैसा कि मैंने ऊपर कहा है, वास्तव में ऐसा कोई गणितीय मानचित्रण नहीं है एक वेक्टर का संक्रमण। स्थानान्तरण रेखीय मानचित्रों (मेट्रिसेस) के लिए परिभाषित एक ऑपरेशन है और यहां तक ​​कि यह केवल मैट्रिक्स ट्रांसपोज़ से मेल खाता है यदि आप कॉलम वैक्टर के रूप में दोहरी वैक्टर भी लिखते हैं। वेक्टर का ट्रांसपोज़ेशन केवल एक सुविधा चाल है जिसे मैट्रिक्स बीजगणित में प्रस्तुत किया गया है (जहां वास्तव में वैक्टर n x 1 मैट्रिसेस हैं) और यह केवल इसलिए काम करता है क्योंकि आप एक यूक्लिडियन स्पेस में हैं जहाँ से एक संयुग्मन मैपिंग होती है (संयुग्म) ) दोहरी जगह के लिए वेक्टर अंतरिक्ष।

विशेष रूप से, यदि आप ऊपर वर्णित गुणों को चाहते हैं, तो आपके पास M[i,:] एक अलग वस्तु (या तो 1xn मैट्रिक्स या एक कोवेक्टर) होनी चाहिए, तब M[:,i] (जो चाहिए एक nx1 मैट्रिक्स या वेक्टर हो)। यह तथ्य कि यह उच्च आयामों के लिए सामान्य रूप से सामान्यीकृत नहीं है, इस मुद्दे के मुख्य चर्चा बिंदुओं में से एक है, और ऐसा लगता है कि ज्यादातर लोग एपीएल अनुक्रमण के पक्ष में हैं, जहां एक संख्या के साथ अनुक्रमित आयाम गिरा दिए जाते हैं (अर्थात दोनों M[:,i] और M[i,:] एक रैंक 1 सरणी का उत्पादन करते हैं, इसलिए, एक वेक्टर)। इंडेक्सिंग सरणियों की एक संपत्ति है, और यह रैखिक बीजगणित संचालन के साथ अनुक्रमण व्यवहार का मिश्रण है जिसके परिणामस्वरूप सभी भ्रम / असंगतताएं पहले स्थान पर हैं। यह तब तक सुसंगत हो सकता है जब तक आप रैंक N=2 वस्तुओं के बंद पारिस्थितिकी तंत्र के भीतर रहते हैं, अर्थात सब कुछ एक मैट्रिक्स, वैक्टर और संख्याएं भी हैं, और आप कभी भी उच्च आयामी सरणियों पर विचार नहीं करते हैं।

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

यदि आप इसके बारे में सोचते हैं तो यह संघर्ष शायद इतना आश्चर्यजनक नहीं है:

• एपीएल इंडेक्सिंग में, केवल सार्थक, इंडेक्सेबल, परिणाम में आयाम रखे जाते हैं; बाकी को निचोड़ दिया जाता है।
• यदि हम v' साथ ऐसा करेंगे तो हमारे पास v' = conj(v) । इसके बजाय कोवटर को एक लापता पहले आयाम का ट्रैक रखने के रूप में देखा जा सकता है।

मुझे लगता है कि एक अच्छी शुरुआत के रूप में संभव के रूप में covectors को प्रतिबंधित करने के लिए किया जाएगा, मूल रूप से सिर्फ गुणा, जोड़ / घटाव, और उन पर बाएँ विभाजन को परिभाषित करना।

लगता है कि उन्हें <: AbstractArray नहीं बनाना चाहिए। क्या यह समझ में आता है कि उन्हें एक नए LinearOperator प्रकार के उपप्रकार होने चाहिए? (जो मुझे पता है कि पहले चर्चा के लिए गया था, लेकिन निष्कर्ष काफी याद नहीं है।)

मुझे लगता है कि मल्टीपल इनहेरिटेंस या इंटरफेसेस के लिए एक भाषा निर्माण (दोनों की चर्चा चल रही है) की अनुपस्थिति के लिए आवश्यक है कि कुछ अवधारणाओं को केवल 'निहित' इंटरफेस द्वारा लागू किया जाए, अर्थात विधियों का एक सेट जिसे परिभाषित करने की आवश्यकता है। Iterators एक ऐसी अवधारणा है, रैखिक ऑपरेटर शायद एक और होगा जिसे एक प्रकार के पदानुक्रम के बजाय तरीकों के एक सेट द्वारा निर्दिष्ट करने की आवश्यकता होती है। एक अमूर्त प्रकार LinearOperator और फिर Matrix होना इसका एक उप योग होना अजीब होगा।

@toivoh यह एक महत्वपूर्ण विचार है, यही कारण है कि मैंने एक मैट्रिक्स से i th वेक्टर या कोवेक्टर निकालने के लिए row(M,i) और col(M,i) जैसे नए कार्यों का सुझाव दिया। ये कार्य केवल दो-आयामी सरणियों M और उन लोगों के लिए होंगे जो मैट्रिक्स बीजगणित में रुचि रखते हैं। यह MATLAB- शैली अनुक्रमण की तुलना में पहले थोड़ा कम स्पष्ट लग सकता है, लेकिन कुल मिलाकर, वैचारिक रूप से एक सदिश के विचार को अलग कर रहा है और यह दोहरी / संक्रमण / कोवेक्टर चीजों को स्पष्ट करने में मदद करता है। क्वांटम यांत्रिकी के मामले में, एक पूरे क्षेत्र ने डीरेक के ब्रा-केट नोटेशन को केवल इसलिए कूद दिया क्योंकि वेक्टर और कोवेक्टर के बीच का अंतर जटिल वैक्टर के लिए बहुत महत्वपूर्ण है, और डीरेक का अंकन यह स्पष्ट करता है। यह मेरी आशा है कि जूलिया भी ऐसा करेगी, साथ ही उच्च आयामी भंडारण सरणियों और उच्च आयामी रैखिक बीजगणित के लिए एक अच्छा उपकरण होने के नाते! (क्योंकि हम लालची हैं, है ना?)

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

मैंने यह पहले कहा है, लेकिन मैं इसे दोहराऊंगा: मेरे दृष्टिकोण से हमारे पास प्राथमिकताओं की यह सूची है, जिसमें कारण नीचे की ओर हैं:

(1) Arrays मौलिक रूप से भंडारण कंटेनर हैं जो सभी जूलिया उपयोगकर्ता उपयोग करेंगे, और हम इसके लिए सबसे अच्छा शब्दार्थ चाहते हैं। एपीएल-शैली के नियम मुझे वैसे भी, एक बहुत अच्छा समाधान लगते हैं। दूसरी ओर, MATLAB- शैली, 1-आयामी सूचकांकों के साथ मान्यताओं के साथ न्यूनतम-दो आयामी सरणियाँ सिर्फ अप्राकृतिक, भ्रामक लगती हैं, और जैसा कि जूथो ने कहा कि वे मैला प्रोग्रामिंग भी कर सकते हैं जहां आप ठीक से ट्रैक नहीं करते हैं आपके सरणी का आयाम। मैं यहाँ तक कहना चाहूँगा कि वेक्टर v , कोड v[i,:] को v एक आयामी होने के बाद से एक त्रुटि फेंकनी चाहिए। तत्व-वार संचालन जैसे + और .* किसी भी कंटेनर वर्ग के लिए उपयोगी हैं, न कि केवल मैट्रिक्स या मल्टीलाइनर बीजगणित में। नीचे दिए गए सामान के लिए केवल रियायत भंडारण-कंटेनर लोग बनाते हैं .* आदि पर अतिरिक्त डॉट्स।

(2) अधिकांश, लेकिन सभी नहीं, जूलिया उपयोगकर्ता मैट्रिक्स बीजगणित का उपयोग करेंगे, इसलिए हम कुछ वेक्टर और मैट्रिक्स कार्यों के लिए कुछ सिंटैक्टिक चीनी जोड़ते हैं, ज्यादातर * प्रतीक के साथ (लेकिन हमारे पास मैट्रिक्स डिवीजन, आदि हो सकते हैं)। इस प्रणाली में हम क्रमशः एक-दो और दो-स्तरीय सरणियाँ स्तंभ वेक्टर और मैट्रिसेस हैं। एक पूरी तरह कार्यात्मक मैट्रिक्स प्रणाली के लिए हमें पंक्ति वैक्टर (कोवेक्टर) और एक ट्रांसपोज़ ऑपरेशन ' । एक पंक्ति वेक्टर हर संभव अर्थ में एक-आयामी सरणी है, और मैं दावा करता हूं कि इसे इस तरह अनुक्रमित किया जाना चाहिए (और निश्चित रूप से covec[1,i] !!!) एपीएल-नियमों के साथ, हम कुछ बनाने के लिए मजबूर हैं वैक्टर और कोवेक्टरों के बीच अंतर, और प्रकार प्रणाली इसके लिए आदर्श है (याद रखें कि हम भाग्यशाली थे कि हम पहले से ही एक आवरण प्रकार के बजाय एक और दो-आयामी सरणियों के टाइपेलिएसिस के रूप में मैट्रिक्स और वेक्टर का पुन: उपयोग कर सकते हैं ... सिद्धांत रूप में हम के रूप में अच्छी तरह से उन्हें लपेटो, लेकिन मैं बात नहीं देख रहा)। प्रकार प्रणाली के साथ कंपाइलर यह पता लगा सकता है कि CoVector * Vector स्केलर और Vector * CoVector एक मैट्रिक्स है, और इसी तरह। जैसा कि टिवोह ने कहा, _ एक MATLAB पॉइंट-ऑफ-व्यू के अनुसार, CoVector बिल्कुल "लापता" पहले आयाम पर नज़र रख रहा है। आकस्मिक उपयोगकर्ताओं को इन ऑब्जेक्ट्स के निर्माण की आवश्यकता नहीं होगी; वे सिर्फ वैक्टर और मैट्रीक इनपुट करेंगे और * और ' संचालन का उपयोग करेंगे। जो लोग ध्यान रखते हैं वे भेद को नोटिस और सराहेंगे। उपयोगकर्ताओं के लिए _biggest_ परिवर्तन M[i,:] लिए एक नया फ़ंक्शन row(M,i) या Transpose(M[i,:]) या M[i,:]' जैसे कुछ के साथ रैपर वर्ग में परिवर्तित करने की आवश्यकता है। कोई इसे एक लाभ के रूप में सोच सकता है, क्योंकि डिराक संकेतन की तरह आप कभी नहीं भूलते हैं कि कौन सी वस्तुएं वैक्टर हैं और जो कोवेक्टर हैं, और टाइप-एसेर्ट्स वाली वस्तुओं को असाइन करना उन त्रुटियों को बढ़ाएगा जहां उपयुक्त हो। मुझे लगता है कि यह इस बहस पर बहस करने लायक है, हालांकि। भविष्य में, हम कुशल विलंबित मूल्यांकन के लिए रैपर की प्रणाली का विस्तार भी कर सकते हैं। यह सभी के लिए एक जीत है, जहां तक ​​मैं देख सकता हूं।

(३) हममें से कुछ लोग बहु-रेखीय बीजगणित में रुचि रखते हैं, और एक दोहरे स्थान और वाष्पोत्सर्जन के बीच के अंतर को सीखना था, आदि इस पर जुथो ने छुआ है। जूलिया के सरणियाँ उच्च-आयामी टेंसर के लिए पहले से ही महान भंडारण उपकरण हैं, और अतिरिक्त पैकेज (जो कि बेस में रास्ता नहीं मिल सकता है या नहीं) हमारे जैसे लोगों द्वारा उपयोग किया जाएगा। हमें जरूरत नहीं है, न ही चाहते हैं, दो से अधिक आयामी की सरणियों पर * ' या * जैसे संचालन को परिभाषित किया गया है। मैं ' लिए भंडारण-उन्मुख उपयोग का मामला नहीं देख सकता जो स्पष्ट रूप से सूचकांकों को पुन: व्यवस्थित करके अधिक सफाई से नहीं किया जा सकता है। एक-आयामी सूचकांकों को ट्रेस करने का पूरा विचार केवल अवधारणा को कम आकर्षक बनाता है ... इसलिए कृपया ' एक और दो-आयामी सरणियों के लिए रखें - जैसे MATLAB :) (देखें, मेरे पास अच्छी चीजें हैं MATLAB के बारे में ...)

एक पूरी तरह से कार्यात्मक मैट्रिक्स प्रणाली के लिए हमें पंक्ति वैक्टर (कोवेक्टर) और एक ट्रांसपोज़ ऑपरेशन की भी आवश्यकता होती है।

यह कथन वास्तव में समस्या के दिल में कटौती करता है। इंडेक्सिंग, ट्रांसपोज़िशन और * उत्पाद सभी इंटरमिक्स हैं। इसके अलावा, यह आगे की तरह एक क्रिया पेश करने के बिना covectors के लोगों के साथ पंक्ति वैक्टर का पूरा अर्थ विज्ञान सामंजस्य करने के लिए संभव नहीं है row(A, i) वापस जाने के लिए i वीं की पंक्ति A एक के रूप में एक-आयामी सरणी के बजाय कोवेक्टर। वर्तमान में A[1, :] का अर्थ दोनों "ए की पहली पंक्ति लेना" और "ए के दूसरे आयाम के साथ पहली स्लाइस लेना" है, लेकिन ये धारणाएं कोवेक्टर प्रस्ताव में मौलिक रूप से असंगत हैं।

एक पंक्ति वेक्टर हर संभव अर्थ में एक-आयामी सरणी है, और मैं यह दावा करता हूं कि इसे इस तरह अनुक्रमित किया जाना चाहिए।

मेरा मानना ​​है कि आप इस कथन से थोड़ा बहुत हतप्रभ हैं। पूर्ववर्ती चर्चा ने स्पष्ट रूप से स्थापित किया है कि यदि आप पूर्ण रेखीय बीजगणित शब्दार्थ (सही उत्पादों और हस्तांतरण के साथ) चाहते हैं, तो एक पंक्ति वेक्टर में एक आयामी आयाम के समान नहीं हो सकता है। सबसे पहले, एक कोवेक्टर में अनुक्रमण को जटिल संयुग्मित मूल्यों को वापस करना चाहिए, (v')[1] = conj(v[1]) , स्थिरता के लिए आंतरिक उत्पाद dot । दूसरा, कोवेक्टर वैक्टर नहीं हैं, वे एक रैखिक उत्पाद हैं जो एक वेक्टर के साथ एक आंतरिक उत्पाद बनाने के लिए इंतजार कर रहे हैं। तीसरा, वैक्टर और कोवेटर्स के पास hcat और vcat तहत अलग-अलग एरे का कॉन्सेप्ट व्यवहार होता है। इन सभी कारणों से एक पंक्ति वेक्टर "हर संभव अर्थ में एक-आयामी सरणी" नहीं हो सकता है।

मैं अनुगामी एकल से छुटकारा पाने के पक्ष में होऊंगा: मुझे नहीं लगता कि मैंने कभी जूलिया कोड देखा है जिसने इसका उपयोग किया है। मैं मूल रूप से कहने वाला था कि हमें 0-आयामी सरणियों के लिए इसकी आवश्यकता होगी, लेकिन मुझे लगता है कि X[] ठीक काम करता है।

मुझे लगता है कि एपीएल इंडेक्सिंग, पंक्ति वैक्टर के लिए row(M,i) फ़ंक्शन के साथ सबसे अधिक समझ में आता है, और एक अच्छा समझौता जैसा लगता है। मैं पंक्ति वेक्टर अनुक्रमण के बारे में निश्चित नहीं हूं, लेकिन मैं _d't_ जैसे (v')[1,i] ।

अन्य बड़े निर्णय, जिन्हें हमने अभी तक नहीं छुआ है, वे प्रकार हैं। इस पहले में एक जाना पड़ा होने से मेरे एक खोज है कि यह करने के लिए वास्तव में कड़ी मेहनत है v' होना एक AbstractVector , के रूप में यह प्रेषण एक मेस में आता है।

दो संभावित विकल्प:

1. हम मैट्रिक्स और वेक्टर के लिए अलग प्रकार का उपयोग करते हैं:
   
   
   
   • Transpose <: AbstractMatrix
   
   
   • CoVector <: Any
   
   
   • Factorization वस्तुओं के लिए किसी प्रकार का स्थानान्तरण।
   
   
2. हम सभी प्रकार के प्रस्तावों के लिए एक ही प्रकार का उपयोग करते हैं, लेकिन X' _not_ एक AbstractMatrix
   
   
   
   • Transpose <: Any
   
   

संयुग्मन के लिए, हम या तो कर सकते हैं

ए। ConjugateTranspose को परिभाषित करें ( ConjugateCoVector अगर हम ऊपर दिए गए विकल्प 1 के साथ जाएं)

बी Conjugate रैपर प्रकार और घोंसले का उचित रूप से उपयोग करें: हमें कुछ कन्वेंशन की आवश्यकता होगी जैसे कि हम Transpose{Conjugate{T}} या Conjugate{Transpose{T}} ।

मैं Transpose{Matrix} AbstractMatrix का उपप्रकार नहीं होना पसंद करता हूं। मुझे लगता है कि आधार में हमारे पास निकटतम एनालॉग एक विशेष मैट्रिक्स प्रकार है, जैसे Symmetric , जो एक मैट्रिक्स की तरह बीजगणितीय व्यवहार करता है लेकिन इसके अनुक्रमण शब्दार्थ में नहीं। (# 987 ने स्थापित किया है कि कई विरासत या पवित्र लक्षणों के बिना, प्रकार के पदानुक्रम को बीजगणितीय शब्दार्थों पर कंटेनर शब्दार्थ का सम्मान करना पड़ता है।)

ऐसे प्रकारों की रचना की समस्या जो मूल रूप से "शब्दार्थ टैग" हैं, # 8240 में भी दिखाई दिए। मुझे लगता है कि Transpose{Conjugate{T}} बेहतर होगा, क्योंकि संयुग्मन एक धारणा है जो तत्वों के अंतर्निहित क्षेत्र से गुजरती है।

यहां ऐसे उदाहरण दिए गए हैं जो कभी-कभी MATLAB के समान एकल अनुगामी नियम का पालन करते हैं, और अन्य समय पर नहीं:

• अनुक्रमण के संचालन में अनुगामी सिंगलटन की अनुमति है। (MATLAB की तरह)

julia> (1:5)[5,1,1,1,1,1,1]
5

• अनुक्रमण संचालन में अनुगामी स्लाइस की अनुमति नहीं है। (MATLAB के विपरीत, जो उन्हें अनुमति देता है।)

julia> (1:5)[5,:]
ERROR: BoundsError()
 in getindex at abstractarray.jl:451

• रैंक> = 3 सरणियों के लिए, अंतर्निहित अनुगामी सिंगलेट्स को अनुक्रमित असाइनमेंट ऑपरेशन में जोड़ा जाता है जब सरणी के रैंक की तुलना में कम अनुक्रमित होते हैं और अंतिम सूचकांक एक स्केलर होता है (MATLAB की तरह):

julia> A=zeros(2,2,2); A[1,2]=5; A #Same as A[1,2,1]=5
2x2x2 Array{Float64,3}:
[:, :, 1] =
 0.0  5.0
 0.0  0.0

[:, :, 2] =
 0.0  0.0
 0.0  0.0

• रैंक> = 3 सरणियों के लिए, निहित अनुरेखण _slices_ को अनुक्रमित असाइनमेंट ऑपरेशन में जोड़ा जाता है जब सरणी के रैंक की तुलना में कम अनुक्रमणिकाएं होती हैं और अंतिम सूचकांक _not scalar_ (MATLAB की तरह) होता है:

julia> A[:,:]=3; A
2x2x2 Array{Float64,3}:
[:, :, 1] =
 3.0  3.0
 3.0  3.0

[:, :, 2] =
 3.0  3.0
 3.0  3.0

• रैंक> = 3 सरणियों के लिए, अंतर्निहित अनुगामी सिंगलेट्स को अनुक्रमणिका ऑपरेशन में जोड़ा जाता है जब सरणी के रैंक की तुलना में कम अनुक्रमणिकाएं होती हैं और अंतिम सूचकांक एक स्केलर होता है (MATLAB की तरह):

julia> A=reshape(1:8,2,2,2); A[:,1]
2-element Array{Int64,1}:
 1
 2

julia> A[:,1,1]
2-element Array{Int64,1}:
 1
 2

• रैंक r> = 3 सरणियों के लिए, जब k <r इंडेक्स होते हैं, तो एरे के रैंक की तुलना में एक इंडेक्सिंग ऑपरेशन होता है और आखिरी इंडेक्स एक स्लाइस होता है, जो शेष रैंक आरके सरणी को रेखीय रूप से रैखिक करता है। (MATLAB की तरह):

julia> A=reshape(1:8,2,2,2); A[1,:]
1x4 Array{Int64,2}:
 1  3  5  7

julia> A=reshape(1:8,2,2,2); A[1,:,:]
1x2x2 Array{Int64,3}:
[:, :, 1] =
 1  3

[:, :, 2] =
 5  7

• अनुगामी संचालन में अनुगामी सिंगलटन को नहीं छोड़ा जाता है। (MATLAB के विपरीत)

julia> A=zeros(1); A[1] = randn(1,1)
ERROR: `convert` has no method matching convert(::Type{Float64}, ::Array{Float64,2})

You might have used a 2d row vector where a 1d column vector was required.
Note the difference between 1d column vector [1,2,3] and 2d row vector [1 2 3].
You can convert to a column vector with the vec() function.
 in setindex! at array.jl:307

julia> A=zeros(1,1); A[1,1] = randn(1)
ERROR: `convert` has no method matching convert(::Type{Float64}, ::Array{Float64,1})
 in setindex! at array.jl:308

• जूलिया स्वचालित रूप से एक अनुगामी सिंगलटन आयाम को संलग्न नहीं करता है जब ऐसा करने से एक वैध संचालन की अनुमति मिलती है। (मतलब के विपरीत, जो करता है)

julia> 1/[1.0,] #In MATLAB, interpreted as the inverse of a 1x1 matrix
ERROR: `/` has no method matching /(::Int64, ::Array{Float64,1})

• बाहरी उत्पाद काम करते हैं और पिछले नियम के अपवाद हैं; उनके शब्दार्थ पहले तर्क में एक अनुगामी सिंगलटन का उपयोग करते हैं। (मतलब की तरह)

julia> [1:5]*[1:5]' # Shapes are (5,) and (1,5) - promoting to (5,1) x (1,5) works
5x5 Array{Int64,2}:
 1   2   3   4   5
 2   4   6   8  10
 3   6   9  12  15
 4   8  12  16  20
 5  10  15  20  25

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

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

वास्तव में इसे लागू करने के लिए, हमें किसी प्रकार के त्रिकोणीय प्रेषण की आवश्यकता है, अन्यथा मुझे यकीन नहीं है कि आप " Complex64 या Complex128 प्रविष्टियों के साथ एक मैट्रिक्स" जैसी चीजों को कैसे व्यक्त करेंगे, इसका स्थानान्तरण , या इसके संयुग्म संक्रमण "। खासकर यदि हम ऊपर 2 + b विकल्प का उपयोग करते हैं।

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

एक पंक्ति वेक्टर हर संभव अर्थ में एक-आयामी सरणी है, और मैं यह दावा करता हूं कि इसे इस तरह अनुक्रमित किया जाना चाहिए।

मेरा मानना ​​है कि आप इस कथन से थोड़ा बहुत हतप्रभ हैं।

सच! क्षमा करें @jiahao , मैं jetlag को दोष दूँगा। मेरे द्वारा लिखने वाला शब्द "टेंसर" है, और मैं [] अनुक्रमण के व्यवहार का कड़ाई से उल्लेख कर रहा था। आप सही हैं कि सहमति एक महत्वपूर्ण विचार है, और मुझे लगता है कि ऐसा करने का प्राकृतिक तरीका (मैट्रिक्स का निर्माण करना) यथोचित रूप से स्पष्ट है (इस उदाहरण में इसे 1 xn आकार के रूप में सोचकर)। स्पष्ट रूप से एक कोवेक्टर "हर मायने में" एक 1D जूलिया एरे नहीं है ... यह पूरी बात है ...

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

इनमें से कौन अस्पष्ट या खतरनाक हैं?

आगे वाला मुझे अस्पष्ट और खतरनाक दोनों लगता है।

julia> A=zeros(2,2,2); A[:,:]=3; A
2x2x2 Array{Float64,3}:
[:, :, 1] =
 3.0  3.0
 3.0  3.0

[:, :, 2] =
 3.0  3.0
 3.0  3.0

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

मुझे लगता है कि यह सबसे अच्छा है अगर एरे केवल इंडेक्स की सही संख्या या 1 डी रैखिक अनुक्रमण के विशेष मामले के साथ अनुक्रमण की अनुमति देते हैं (क्योंकि यह बेहद आसान है)। इसमें अनुगामी सिंगलेटों को भी शामिल किया जाएगा।

या 1D रैखिक अनुक्रमण का विशेष मामला (क्योंकि यह बेहद आसान है)

हमारे सिद्धांत कितनी आसानी से बिक जाते हैं! :)

मैंने कभी भी रैखिक अनुक्रमण को पसंद नहीं किया है; यह मुझे एक हैक के रूप में मारता है। अक्सर हम एक सरणी पर पुनरावृति करने का सबसे तेज़ तरीका चाहते हैं। और सभी लेकिन सरल घने सरणियों के लिए रैखिक अनुक्रमण वास्तव में धीमा हो सकता है। उस ने कहा, हम रैखिक अनुक्रमण को पूरी तरह से समाप्त नहीं कर सकते (प्रदर्शन कारणों के लिए, और बहुत अधिक कोड तोड़ने के लिए)।

हां, काफी सच है। लेकिन कम से कम 1D अनुक्रमण नेत्रहीन अलग है। जबकि 5D के साथ 6D सरणी को इंडेक्स करना बहुत कम है। किसी भी मामले में, मैं इसके बजाय सख्त अनुक्रमण नियमों का पालन करूंगा और अन्य दिशा की तुलना में 1 डी रैखिक अनुक्रमण को छोड़ दूंगा। खासकर जब से कोई आसानी से मेमोरी साझा करने वाले एरे के लिए एक रेफ़रेड संदर्भ प्राप्त कर सकता है।

क्या हम रैखिक अनुक्रमण के लिए {} कोष्ठक (या कुछ अन्य) का उपयोग कर सकते हैं, और बहुआयामी अनुक्रमण के लिए [] रख सकते हैं? एक विचार है...

23 मार्च 2015 को, 2:36 बजे, बॉब पोर्टमैन नोटिफिकेशन @ithub.com ने लिखा:

हां, काफी सच है। लेकिन कम से कम 1D अनुक्रमण नेत्रहीन अलग है। जबकि 5D के साथ 6D सरणी को इंडेक्स करना बहुत कम है। किसी भी मामले में, मैं इसके बजाय सख्त अनुक्रमण नियमों का पालन करूंगा और अन्य दिशा की तुलना में 1 डी रैखिक अनुक्रमण को छोड़ दूंगा। खासकर जब से कोई आसानी से मेमोरी साझा करने वाले एरे के लिए एक रेफ़रेड संदर्भ प्राप्त कर सकता है।

-
इस ईमेल का जवाब सीधे दें या इसे GitHub https://github.com/JuliaLang/julia/issues/4774#issuecomment -84805310 पर

मुझे भी लगता है कि यह अच्छा होगा कि हम वाक्य रचना को अलग करने में सक्षम हों
नियमित अनुक्रमण वाक्यविन्यास से रैखिक अनुक्रमण के लिए, लेकिन मैं मानता हूं कि यह
हो सकता है कि एक बहुत ही टूटने वाला बदलाव हो।

हालांकि यह मुद्दा बहुत बहस को आकर्षित करता है, लेकिन अनुक्रमण को बेहतर बनाने में अधिकांश वास्तविक कार्य 0.4 चक्र में काफी संख्या में पुल अनुरोधों में हुए हैं। उदाहरण के लिए, अब जब हमारे पास CartesianIndex और दोस्त हैं, तो मुझे नहीं लगता कि किसी को रैखिक और कार्टेशियन अनुक्रमण के लिए वाक्यविन्यास को अलग करने की आवश्यकता क्यों होगी --- वास्तव में अब आप उन्हें (# 10524) जोड़ सकते हैं। मैं रैखिक अनुक्रमण से भी छुटकारा पाना चाहता हूं, लेकिन कभी-कभी यह अधिक प्रदर्शनकारी होता है (शायद # 9080 के कारण; enumerate और zip एक ही समस्या से पीड़ित)। हमें संभवतः fastindex eachindex आसपास रैपर के रूप में fastindex लागू करना चाहिए, जैसा कि # 10507 में है।

यदि आप नियमों को अनुक्रमित करने में रुचि रखते हैं, तो इस मुद्दे को मृत्यु तक पहुंचाने के बजाय सबसे दिलचस्प सीमा पर ध्यान दें। इस समय, यह निर्विवाद रूप से # 10525 है। विशेष रूप से https://github.com/JuliaLang/julia/pull/10525#issuecomment -84597488 पर किसी प्रकार के संकल्प की आवश्यकता है।

@timholy मैंने वास्तव में फास्ट कार्टेसियन इंडेक्सिंग के सभी घटनाक्रमों का पालन नहीं किया है, और बस आधार / बहुआयामी.

कुछ मायनों में, यह जानने के लिए बहुत कुछ नहीं है: जबकि हुड के तहत एक उचित राशि चल रही है, विचार यह है कि इसका उपयोग गंदगी-सरल बनाने के लिए किया जाता है। बहुत शाब्दिक रूप से

k = 0
for I in eachindex(A)
     B[k+=1] = A[I]   # B is being linearly-indexed, A is being cartesian-indexed
end

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

मैं आने वाले कुछ महीनों में इसे लिखने की योजना बना रहा हूं, लेकिन अगर लोग वास्तव में विवरण जानना चाहते हैं तो शायद एक जूलियाकॉन बातचीत उचित होगी। @ जुथो या @ मबूमन उस बात को सिर्फ और सिर्फ मैं ही दे सकते थे।

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

हम शायद # 10507 # के रूप में प्रत्येकindex के आसपास एक आवरण के रूप में Fastindex को लागू करना चाहिए

@timholy क्या कोई कारण नहीं है eachindex तेजी से रैखिक सरणियों के लिए एक UnitRange वापसी? यह अभी भी टाइप-स्थिर होगा, और यदि कॉलर कभी भी यह सुनिश्चित करना चाहता है कि उन्हें कार्टेसियनइंडेक्स मिलता है, तो वे मैन्युअल रूप से कार्टेसियनरेंज का निर्माण कर सकते हैं ( कार्टेसियनऑन निर्यात नहीं होने पर हम eachindex(size(A)) लिए एक विधि भी जोड़ सकते हैं)।

पहले ऐसा ही हुआ, लेकिन मुझे लगता है कि @ जूथो ने इसे बदल दिया। (अगर यह सच नहीं है, तो मैंने शायद इसे साकार किए बिना बदल दिया है।) मुझे लगता है कि परिवर्तन निरंतरता के लिए प्रेरित था (इसलिए आप एक CartesianIndex प्राप्त करने पर भरोसा कर सकते हैं), जिसके पास निश्चित मात्रा में अर्थ है । लेकिन जैसा कि आप बताते हैं, यह सुनिश्चित करने के लिए वैकल्पिक साधन हैं।

@ जूथो , कोई विचार?

मुझे eachindex बदलना याद नहीं है, लेकिन यह हो सकता है। मुझे निश्चित रूप से इसके लिए एक अच्छा कारण याद नहीं है, अन्य प्रकार के सरणी से स्वतंत्र एक सुसंगत परिणाम होने के अलावा। लेकिन अगर कुशल रैखिक अनुक्रमण के साथ और बिना सरणियों के बीच के अंतर को डॉक्स में स्पष्ट रूप से समझाया गया है, तो मुझे कोई कारण नहीं दिखता है कि कुशल रेखीय अनुक्रमण के साथ सरणियों के मामले में eachindex एक रैखिक सीमा वापस नहीं कर सकती।

@timholy , आपकी पिछली पोस्ट के जवाब में, मैं जूलियाकॉन में शामिल होने में असमर्थ हूं इसलिए CartesianIndex सामान के बारे में बात करने के लिए स्वतंत्र महसूस करता हूं (वैसे भी मैंने केवल कुछ अंतिम स्पर्शों में योगदान दिया है)। मैं पहले ही सम्मेलन की रिपोर्ट और वीडियो का इंतजार कर रहा हूं।

एक सनकी सोचा: एक सरणी के लिए A (आयाम> 2 सहित) किसी भी आयाम की, एक हो सकता था A' चक्रीय के सूचकांकों दूसरे स्थान पर रखना A । तो, A'[i, j, k] == A[j, k, i] । यह सामान्य मैट्रिक्स को 2d सरणियों के लिए कम कर देगा, साथ ही साथ MATLAB (जैसे [n, 1] और [1, n] 2d सरणियों के रूप में माना जाता है जब पंक्ति और स्तंभ "वैक्टर" के लिए सामान्य स्थानान्तरण। इस प्रकार यह कभी भी एक 2d कॉलम "वेक्टर" को एक सच्चे कोवेक्टर या 2d पंक्ति "वेक्टर" पर एक सच्चे वेक्टर के लिए मैप नहीं करेगा। (मुझे लगता है कि यह संपत्ति अच्छी है, लेकिन अन्य लोग असहमत हो सकते हैं।) यह पहचान को A'' == A' और v'' == v _for के लिए मैट्रिसेस और वैक्टर सरणी ऑब्जेक्ट_ के रूप में माना जाता है। ऊपर चर्चा की गई प्रकार की पदानुक्रम के प्रकार को देखते हुए (जहां सच्चे वैक्टर और कोवेटर अमूर्त सरणियों से पर्याप्त रूप से भिन्न हैं), ' को अभी भी सच्चे वैक्टर और कोवेक्टरों के लिए एक पूरी तरह से अलग विधि दी जा सकती है जो यह रैखिक बीजगणितीय अवधारणा से मेल खाती है। और v'' == v संतुष्ट करने की आवश्यकता नहीं है (लेकिन अगर ऐसा हो सकता है कि लोगों ने फैसला किया है कि वे चाहते हैं)।

स्पष्ट होने के लिए: मैं एक दूसरे के लिए नहीं सोचता कि ' _needs_ आयाम के सरणियों के लिए कोई भी तरीका है> 2, लेकिन मैंने ऊपर इस प्रस्ताव को नहीं देखा था (जब तक कि इसका मतलब सूचकांकों को उलट देना नहीं था। ") और सोचा कि मैं इसका उल्लेख करूंगा। सबसे अधिक नुकसान मैं यह कर रहा हूं (प्राइमा फेशियल) वैचारिक है: आम तौर पर रैखिक बीजगणित के डोमेन के रूप में लिए गए एक ऑपरेटर के साथ एक (थोड़ा मनमाना) कॉम्बीनेटरियल ऑपरेशन का सामना करना। जब तक हम इस तरह के कम से कम कुछ अनुमानों का जवाब नहीं दे सकते हैं, जब हम रैखिक बीजीय अवधारणाओं को विशुद्ध रूप से डेटा-केंद्रित अवधारणाओं (इस संपूर्ण चर्चा के द्वारा साक्ष्य के रूप में) में विस्तारित करने का प्रयास करते हैं। जैसे, हम बहु-आयामी सरणियों के चक्रीय क्रमपरिवर्तन के लिए एक सुविधाजनक आशुलिपि का निर्धारण कर सकते हैं, यह निर्धारित करने के लिए कि क्या ' बहु-आयामी सरणी आयामों के लिए सामान्य रूप से करना चाहिए, जब तक कि यह अपेक्षित मामले में कम न हो जाए। 2 आयाम। एक भी एक तरीका है कि एक पूर्णांक तर्क लेता जोड़ सकते हैं ताकि A'(k)[I] चक्रीय के सूचकांकों permutes A[I] कश्मीर बार, दे रही है A'(ndims(A))[I] == A[I] और A'(-k)[I] permutes सूचकांक विपरीत दिशा में।

सिर्फ एक विचार।

यदि transpose को बहुआयामी सरणियों के लिए परिभाषित किया जाता है, तो मैं पसंद करूंगा कि यह अभी भी A''=A संतुष्ट करता है, अर्थात यह स्वयं का उलटा है। यह पिछले प्रस्ताव के साथ सीधे संघर्ष में है।

सही है। जैसा कि मैंने कहा, मेरा सुझाव केवल (संभावित रूप से) आकर्षक है अगर कोई सहज है जो संक्रमण के रैखिक बीजीय महत्व के बीच दरार पैदा कर रहा है और जो भी सरणी-केंद्रित महत्व है वह d> 2 मामले में लागू होता है। मेरा तर्क यह था कि जब तक कि दरार पहले से ही है (तरह की) हो रही है, और अगर विधियां अभी पूरी तरह से अप्रयुक्त होंगी, तो सूचकांकों को अनुमति देने के लिए एक आशुलिपि के लिए साफ-सुथरा हो सकता है - जब तक कि इसके लिए कोई आवश्यकता न हो d = 2 केस कार्य करने के लिए विशेष उपचार। जैसा कि आपने (@ जूथो) में उल्लेख किया है, यह एक सुविधाजनक संयोग है कि 2d मामले में आयामों को स्थानांतरित करना इसका रैखिक बीजीय महत्व है (और इस मामले के लिए 2d सरणियों के रूप में पहचानने के बाद ही), इसलिए शायद हम डॉन d> के लिए A'' == A t को transpose के गणितीय गुणों (जैसे A'' == A आवश्यकता) के लिए उपयुक्त होने की आवश्यकता है। 2. यदि कोई इस मार्ग पर जाना चाहता है, तो बहुत सारे संभावित उपयोगी तरीके हैं जो कर सकते हैं असाइन किया जा सकता है, उदाहरण के लिए: A' साइक्लीटिकली परमिट एक बार, A'(k) साइक्लीकली के बार, A'(I) I::Array{Int, 1} लंबाई के साथ <= ndims(A) साइक्लिक रूप से I में सूचीबद्ध सूचकांकों को अनुमति देता है, और A'(p) p::Permutation लंबाई के लिए <= ndims(A) p अनुसार सूचकांकों को अनुमति देता है। लेकिन मुझे लगता है कि शायद सबसे अच्छी बात यह है कि एक पैकेज बनाना है और देखना है कि क्या यह पर्याप्त उपयोगी है।

मैं दो बदलावों / स्पष्टीकरणों का समर्थन करता हूं, जिनका उल्लेख किया गया है, उदाहरण के लिए, StefanKarpinski द्वारा अक्टूबर 16, 2014, और सिमोनबिरने पर Mar 22, 2015 को, लेकिन एक शर्त के साथ:

1. transpose उपयोग केवल वैक्टर और 2-आयामी मैट्रिस के लिए किया जाना चाहिए, न कि सामान्य टेंसरों के लिए।
2. ऑपरेटर्स * और transpose गणना के अंत में ट्रेलिंग सिंगलटन आयामों को हटा देना चाहिए। अन्यथा, अनुगामी सिंगलटन आयाम संरक्षित किए जा सकते हैं।

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

इस प्रस्ताव के तहत, जब मैट्रिक्स गुणा और स्थानांतरण के साथ काम करते हैं, तो अनिवार्य रूप से एक वेक्टर और एक-कॉलम मैट्रिक्स के बीच कोई अंतर नहीं होगा, न ही एक स्केलर, लंबाई 1 और 1-एक-वेक्टर के बीच कोई सार्थक अंतर होगा। -1 मैट्रिक्स। हालांकि, x' 1-बाय-एन मैट्रिक्स होगा, न कि एक वेक्टर।

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

नीचे प्रस्तावित परिवर्तनों के साथ जूलिया सत्र का एक काल्पनिक प्रतिलिपि है।

सबसे पहले, हम एक स्केलर, दो वैक्टर और एक मैट्रिक्स को परिभाषित करते हैं।

julia> alpha = 2.0
2.0

julia> x = [1.0; 2.0; 3.0]
3-element Array{Float64,1}:
 1.0
 2.0
 3.0

julia> y = [4.0; 5.0; 6.0]
3-element Array{Float64,1}:
 4.0
 5.0
 6.0

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3x3 Array{Float64,2}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

स्केलर-सदिश गुणन कार्य तब भी होता है जब बाह्य आयाम मौजूद होते हैं, और परिणाम हमेशा एक सदिश होता है।

julia> alpha*x
3-element Array{Float64,1}:
 2.0
 4.0
 6.0

julia> alpha*x[:,[1]]
3-element Array{Float64,1}:
 2.0
 4.0
 6.0

संक्रमण एक अंतर्क्रिया है।

julia> x'
1x3 Array{Float64,2}:
 1.0  2.0  3.0

julia> x''
3-element Array{Float64,1}:
 1.0
 2.0
 3.0

julia> x==x''
true

julia> x'''
1x3 Array{Float64,2}:
 1.0  2.0  3.0

एक-मैट्रिक्स द्वारा मैट्रिक्स को गुणा करना मैट्रिक्स-वेक्टर उत्पाद के समान परिणाम उत्पन्न करता है।

julia> A*x
3-element Array{Float64,1}:
 14.0
 32.0
 50.0

julia> A*x[:,[1]]
3-element Array{Float64,1}:
 14.0
 32.0
 50.0

एक-पंक्ति मैट्रिक्स बार एक मैट्रिक्स एक-पंक्ति मैट्रिक्स के बराबर होती है।

julia> x'*A
1x3 Array{Float64,2}:
 30.0  36.0  42.0

आंतरिक उत्पाद एक अदिश राशि है और मैट्रिक्स-वेक्टर और मैट्रिक्स-मैट्रिक्स उत्पादों के लिए अधिक सामान्य नियमों द्वारा निर्मित है।

julia> x'*y
32.0

julia> x'*y[:,[1]]
32.0

बाहरी उत्पाद कुछ खास नहीं है।

julia> x*y'
3x3 Array{Float64,2}:
  4.0   5.0   6.0
  8.0  10.0  12.0
 12.0  15.0  18.0

julia> x[:,[1]]*y'
3x3 Array{Float64,2}:
  4.0   5.0   6.0
  8.0  10.0  12.0
 12.0  15.0  18.0

एक वेक्टर समय एक वेक्टर एक त्रुटि है।

julia> x*y
ERROR: `*` has no method matching *(::Array{Float64,1}, ::Array{Float64,1})

एक वेक्टर समय एक मैट्रिक्स एक त्रुटि है।

julia> x*A
ERROR: DimensionMismatch("*")
 in gemm_wrapper! at linalg/matmul.jl:270
 in * at linalg/matmul.jl:74

मैट्रिक्स मल्टीप्लीकेशन इज एसोसिएटिव।

julia> (x*x')*y
3-element Array{Float64,1}:
 32.0
 64.0
 96.0

julia> x'*y
32.0

julia> x*(x'*y)
3-element Array{Float64,1}:
 32.0
 64.0
 96.0

julia> norm((x*x')*y-x*(x'*y))
0.0

संपादित करें: एक उत्पाद में आंतरिक आयाम की भावना को शामिल करने वाले दो उदाहरण हटाए गए। मौजूदा चर्चा पर उनका बहुत असर नहीं हुआ।

मुझे डर है कि इसमें शामिल संक्रियाओं का प्रकार स्थिरता खो देगा, क्योंकि अनुगामी सिंगलटन आयामों को त्यागना एक प्रकार का स्थिर संचालन नहीं है।

जिस तरह से मैं इसे देखता हूं, पूरे कोवेक्टर व्यवसाय में एक सिंगलटन आयाम होता है जिसे यह इस प्रकार के आधार पर जाना जाता है कि इसे हटा दिया जाएगा। इसके अलावा, हम एक वेक्टर और एक मैट्रिक्स के बीच के अंतर को संरक्षित करने के लिए बहुत कठिन प्रयास कर रहे हैं जो कि सिर्फ एक कॉलम होता है, लेकिन यह सुझाव कुछ मामलों में उस अंतर को हटा देगा, जैसे x'' ।

आनुमानिक सुझाव: क्या होगा यदि हमने प्रकार के मापदंडों से आयाम को गिरा दिया, और रनटाइम पर सभी आयामी / आकार की जांच की? (हम वैसे भी उचित मात्रा में करते हैं।) और प्रकार के लिए आयामीता पैरामीटर को छोड़ दें जो आकार को एक प्रकार के पैरामीटर के रूप में भी एन्कोड करता है। (बतख, दो हफ्तों के लिए छिप जाता है, और अपने github खाते को @SomeoneWhoCertainlyIsntTimHolyUhUhNoWay पर बदल देता है।)

(निश्चित रूप से, मैं वास्तव में # 10525 अकेले खाते में खुद पर शिकायत करूंगा।)

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

@timholy प्रश्न: क्या हम रैखिक बीजगणित और वैक्टर के स्थानान्तरण के बारे में इस शब्दार्थ में सुधार कर सकते हैं?

यदि कोई अभी भी CoVector / DualVector / TransposeVector का उपयोग करने में रुचि रखता था, तब भी हमें अपना नया TimHolyArray{DataType} _and_ लपेटना होगा या तो हमें इसका कोई मतलब निकालना होगा दो (या एक) से अधिक आयाम की एक सरणी के पारगमन, या अन्य निर्माण TransposeVector(tharray) लिए मना करते हैं जब tharray का आयाम दो (या एक) से अधिक होता है ... वास्तव में सभी प्रकार की चीजों को रन-टाइम स्तर पर त्रुटियां देनी होंगी जो वर्तमान में संकलन-समय की त्रुटियां हैं (जैसे गुणन जो वर्तमान में अपरिभाषित हैं और इस प्रकार प्रकार प्रणाली द्वारा निषिद्ध हैं)।

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

मैं जरूरी आपके विचार के खिलाफ नहीं हूं - लेकिन यह एक अतिरिक्त मुद्दा प्रतीत होता है जो वेक्टर ट्रांज़ोज़ के समानांतर किया जा सकता है।

@ तीमारदार : मुझे वाकई यकीन है कि यह रास्ता है या नहीं। ऐसी परिस्थितियां हैं जहां मुझे आयाम पर प्रेषण के लिए बहुत उपयोगी लगता है।

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

हाँ, यह आपके कार्टेशियन मैक्रोज़ (या अभी भी उपयोग नहीं किए गए फ़ंक्शन का पूरा बिंदु है जिसका उपयोग :-)) के लिए नहीं है?
मैंने सी ++ में ऐसी ही चीजें कीं, जहां टेम्पलेट पैरामीटर के रूप में आयाम होना एक वास्तविक दर्द है। लेकिन मेरे पास ऐसी परिस्थितियां थीं जहां डायनामिक वेरिएंट सीमित था क्योंकि किसी को विभिन्न सरणी आयामों के लिए बयान के लिए बड़े की आवश्यकता होती है।

प्रस्ताव:

1. वर्तमान मैट्रिक्स गुणन व्यवहार का नाम बदलकर timesfast और वर्तमान व्यवहार को transposefast ।
2. पहले टिप्पणी में (*) और transpose को एकल अनुगामी आयामों को छोटा करने के लिए संशोधित करें। उदाहरण के लिए, u'*v एक स्केलर बन जाएगा, v'' एक वेक्टर बन जाएगा, और (v*v')/(v'*v) को परिभाषित किया जाएगा।

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

मैं कक्षा में जूलिया का उपयोग करना चाहता हूं, इसलिए मैं दक्षता पर मूल्य सुविधा के लिए डिफ़ॉल्ट व्यवहार के लिए वोट करता हूं।

मुझे इस बहुत लंबे धागे को गति देने के लिए कई योगदानकर्ताओं का धन्यवाद!

@briansutton : मुझे लगता है कि आपको वास्तव में पुनर्विचार करना चाहिए कि आप क्या पूछ रहे हैं। मैं आपको प्रतीक्षा करने के लिए प्रोत्साहित करूंगा जब तक कि आपको यह समझने की गहरी समझ नहीं है कि जूलिया यह प्रस्ताव करने से पहले कैसे काम करती है कि हम गुणा के अर्थ को फिर से परिभाषित करें।

यह मुद्दा इस बारे में रहा है कि हम यथासंभव विशेष मामलों से कैसे बच सकते हैं।

नियम जो सिंगलटन आयामों को ठगने की अनुमति देते हैं, उस क्षण को सिंगलटन आयामों में से एक को तोड़ देता है, जिसकी आप वास्तव में परवाह करते हैं। "ट्रंकट [सभी] अनुगामी एकल आयाम" नियम के साथ, यदि v 1-तत्व वेक्टर है, तो v' एक अदिश राशि है, और इसलिए v'' भी v == v'' हमेशा पकड़ नहीं है।

आप नियम को संशोधित करने का प्रयास कर सकते हैं "यदि अंतिम आयाम 2 है तो केवल अंतिम अनुगामी सिंगलटन आयाम को काटें"। लेकिन इस संशोधित नियम के साथ भी, बाहरी उत्पाद v * w' मैट्रिक्स गुणन की परिभाषा से स्वचालित रूप से पालन नहीं करता है, बल्कि इसके बजाय Vector * Matrix अपनी विशेष-आवरण वाली परिभाषा होनी चाहिए, और परिभाषा होनी चाहिए "त्रुटि को तब तक फेंकें जब तक कि आकृतियाँ (N) x (1, M)" न हों।

@ जियाहौ :

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

आपके पहले उदाहरण ( v==v'' ) के बारे में, मैं पहली जगह में 1-तत्व वेक्टर v बनाने से बचना चाहूंगा।

आपके दूसरे उदाहरण के बारे में, हाँ, मुझे लगता है कि v*w' को केवल उसी तरह से हैंडल किया जाना चाहिए जैसा कि आप वर्णन करते हैं। मैट्रिक्स गुणा और हस्तांतरण के साथ काम करते समय, मैं वेक्टर v और N-by-1 मैट्रिक्स v[:,[1]] एक ही गणितीय वस्तु को निरूपित करना चाहता हूं, भले ही उनके पास अलग-अलग आंतरिक अभ्यावेदन हों। इसे एन-वेक्टर समय 1-बाय-एम मैट्रिक्स को संभालने के लिए विशेष कोड की आवश्यकता होगी।

मुझे लगता है कि आप अभी भी आश्वस्त नहीं हैं कि टाइप स्थिरता महत्वपूर्ण है।

@briansutton : मुझे लगता है कि आपको अपना प्रस्ताव चलाने के लिए आवश्यक मशीनरी को लागू करने की कोशिश करना बहुत ही जानकारीपूर्ण लगेगा क्योंकि वर्तमान प्रकार प्रणाली जूलिया कोड को चलाने की अनुमति देती है। मैं, एक के लिए, विश्वास करता हूं कि आपके घोषित लक्ष्य अस्वीकार्य हैं जूलियन को अनुमानित प्रदर्शन और सी मेमोरी-लेआउट संगतता प्रदान करने के लक्ष्य दिए गए हैं।

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

मैं एक भौतिक विज्ञानी और जूलिया का सक्रिय उपयोगकर्ता हूं।

मैं अब सभी अनुगामी सिंगलटन आयामों को रखने या छोड़ने के लिए मौसम पर मजबूत प्राथमिकता नहीं रखता

लेकिन यहां मैं एक संबंधित मुद्दे को उठाना चाहूंगा।

वर्तमान जूलिया कार्यान्वयन:

V को 3-मंद रैंक -1 टेंसर (सदिश) होने दें
V [1] हमें एक स्केलर देगा जो 1-मंद रैंक -1 टेंसर नहीं है

आज्ञा देना एक 3x4x5 रैंक -3 टेन्सर है
बी = ए [1,:,:] हमें ए 1x4x5 रैंक -3 टेंसर देगा।

उपरोक्त दो व्यवहार काफी सुसंगत नहीं हैं।

मैं निम्नलिखित अनुक्रमण / फिसलने की सुविधा को दृढ़ता से पसंद करता हूं:

आज्ञा देना एक 3x4x5 रैंक -3 टेन्सर है
बी = ए [1,:,:] हमें 4x5 रैंक -2 टेंसर देगा।
सी = ए [1: 1,:,:] हमें 1x4x5 रैंक -2 टेंसर देगा।
(वर्तमान में उपरोक्त दोनों समान परिणाम देते हैं)

बता दें कि V एक रैंक -1 टेंसर है
B = V [1] हमें एक स्केलर देगा
C = V [1: 1] हमें 1-मंद रैंक -1 टेंसर देगा।

यह सुविधा हमें अधिक आसानी से टेंसर के आकार को बदलने में मदद करेगी, और सहायक होगी जब हम सिंगलटन इंडेक्स को पीछे छोड़ देंगे।

श्रेष्ठ

जिओ-गिरोह

प्रेषक: esd100 [सूचनाएं@github.com]
प्रेषित: मंगलवार, 09 जून, 2015 9:46 बजे
टू: जूलियांग / जूलिया
Cc: जिओ-गैंग वेन
विषय: पुन: [जूलिया] वेक्टर को गंभीरता से ले जाना (# ४) [४)

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

-
इस ईमेल का उत्तर सीधे दें या इसे Gi tHubhttps: //github.com/JuliaLang/julia/issues/4774#issuecomment -110554622 पर देखें।

मेरा मतलब है: सी = ए [1: 1,:,]] हमें 1x4x5 रैंक -3 टेंसर देगा।

जिओ-गिरोह

प्रेषक: जिओ-गैंग वेन [[email protected]]
प्रेषित: सोमवार, २२ जून २०१५ दोपहर १२:०१
To: जूलियालैंग / जूलिया; JuliaLang / जूलिया
Cc: जिओ-गैंग वेन
विषय: RE: [जूलिया] वेक्टर को गंभीरता से ले जाना (# 4774)

मैं एक भौतिक विज्ञानी और जूलिया का सक्रिय उपयोगकर्ता हूं।

मैं अब सभी अनुगामी सिंगलटन आयामों को रखने या छोड़ने के लिए मौसम पर मजबूत प्राथमिकता नहीं रखता

लेकिन यहां मैं एक संबंधित मुद्दे को उठाना चाहूंगा।

वर्तमान जूलिया कार्यान्वयन:

V को 3-मंद रैंक -1 टेंसर (सदिश) होने दें
V [1] हमें एक स्केलर देगा जो 1-मंद रैंक -1 टेंसर नहीं है

आज्ञा देना एक 3x4x5 रैंक -3 टेन्सर है
बी = ए [1,:,:] हमें ए 1x4x5 रैंक -3 टेंसर देगा।

उपरोक्त दो व्यवहार काफी सुसंगत नहीं हैं।

मैं निम्नलिखित अनुक्रमण / फिसलने की सुविधा को दृढ़ता से पसंद करता हूं:

आज्ञा देना एक 3x4x5 रैंक -3 टेन्सर है
बी = ए [1,:,:] हमें 4x5 रैंक -2 टेंसर देगा।
सी = ए [1: 1,:,:] हमें 1x4x5 रैंक -2 टेंसर देगा।
(वर्तमान में उपरोक्त दोनों समान परिणाम देते हैं)

बता दें कि V एक रैंक -1 टेंसर है
B = V [1] हमें एक स्केलर देगा
C = V [1: 1] हमें 1-मंद रैंक -1 टेंसर देगा।

यह सुविधा हमें अधिक आसानी से टेंसर के आकार को बदलने में मदद करेगी, और सहायक होगी जब हम सिंगलटन इंडेक्स को पीछे छोड़ देंगे।

श्रेष्ठ

जिओ-गिरोह

प्रेषक: esd100 [सूचनाएं@github.com]
प्रेषित: मंगलवार, 09 जून, 2015 9:46 बजे
टू: जूलियांग / जूलिया
Cc: जिओ-गैंग वेन
विषय: पुन: [जूलिया] वेक्टर को गंभीरता से ले जाना (# ४) [४)

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

-
इस ईमेल का उत्तर सीधे दें या इसे Gi tHubhttps: //github.com/JuliaLang/julia/issues/4774#issuecomment -110554622 पर देखें।

आप जो पूछ रहे हैं वह इस समय slice । मेरी समझ में यह है कि A[stuff] slice(A, stuff) लिए एक पर्याय बन जाएगा, और इसलिए आप शायद अपनी इच्छा प्राप्त करेंगे।

प्रिय टिम:

टिप के लिए धन्यवाद। मैंने स्लाइस की कोशिश की है। यह मेरी आवश्यकताओं के अनुरूप नहीं है। स्लाइस एक नया डेटा प्रकार "सबर्रे" का उत्पादन करता है जिसका उपयोग मैं अपने अन्य कोड में नहीं कर सकता जो कि उपयोग करता है :: एरे डेटा प्रकार।

शायद मैं अपने दूसरे कोड को बदल सकता हूं ताकि वे "सबर्रे" डेटा प्रकार की अनुमति दें।

जिओ-गिरोह

प्रेषक: टिम होली [सूचनाएं@github.com]
प्रेषित: सोमवार, २२ जून २०१५ शाम ५:३२
टू: जूलियांग / जूलिया
Cc: जिओ-गैंग वेन
विषय: पुन: [जूलिया] वेक्टर को गंभीरता से ले जाना (# ४) [४)

जो आप पूछ रहे हैं कि वर्तमान में स्लाइस कैसे काम करती है। मेरी समझ में यह है कि A [सामान] स्लाइस (A, सामान) का एक पर्याय बन जाएगा, और इसलिए आप शायद अपनी इच्छा प्राप्त करेंगे।

-
इस ईमेल का उत्तर सीधे दें या इसे Gi tHubhttps: //github.com/JuliaLang/julia/issues/4774#issuecomment -114268796 पर देखें।

क्या आपके कोड में AbstractArray बजाय कंक्रीट Array प्रकारों का उपयोग करने पर वास्तव में निर्भर है? यह एक खोज से ज्यादा कुछ नहीं की आवश्यकता होती है / की जगह ले सकती Array के साथ AbstractArray चीजें काम करने के लिए।

प्रिय स्कॉट

टिप के लिए बहुत-बहुत धन्यवाद।

जिओ-गिरोह

प्रेषक: स्कॉट पी। जोन्स [सूचनाएं@github.com]
प्रेषित: गुरुवार, 25 जून, 2015 9:55 पूर्वाह्न
टू: जूलियांग / जूलिया
Cc: जिओ-गैंग वेन
विषय: पुन: [जूलिया] वेक्टर को गंभीरता से ले जाना (# ४) [४)

क्या वास्तव में आपके कोड में AbstractArray के बजाय कंक्रीट एरे प्रकारों का उपयोग करने पर निर्भर है? यह चीजों को काम करने के लिए AbstractArray के साथ ऐरे की एक खोज / प्रतिस्थापन से अधिक कुछ नहीं की आवश्यकता हो सकती है।

-
इस ईमेल का उत्तर सीधे दें या इसे Gi tHubhttps: //github.com/JuliaLang/julia/issues/4774#issuecomment -115265047 पर देखें।

क्या आपके लिए यह चाल चली गई? मैं मदद करने के लिए खुश हूँ!

@wenxgwen , वैकल्पिक रूप से, आप एक नए Array में स्लाइस की एक प्रति प्राप्त करने के लिए copy(slice(A,...)) कॉल कर सकते हैं, जो तब आपके पहले से मौजूद कार्यों के साथ मूल रूप से काम करना चाहिए।

इस समस्या को हल करना अब एक आकर्षक प्रयास बन गया है

इस समस्या को ठीक करने के बाद से अब 3 कॉमाओं के लिए मेरे रास्ते पर महत्वपूर्ण है ...

लेकिन सभी गंभीरता में। मैंने चर्चा के माध्यम से पूरी तरह से पढ़ने की कोशिश की, लेकिन मैं यह गारंटी नहीं दे सकता कि यह पहले नहीं सुझाया गया है:

क्या हम संभवतः अतिरिक्त विशेषता (LinearIndexing के समान) के लिए AbstractArray परिभाषा का विस्तार कर सकते हैं जो परिभाषित करता है कि अंतर्निहित डेटा पंक्ति-आधारित है या स्तंभ-आधारित संग्रहण है? इसके अलावा निम्नलिखित गुण खुलेंगे (कृपया नामों पर ध्यान न दें ... बस अवधारणाएं):

v --> length-2 Vector{Col}
  [ 1
    2 ]

v'  --> length-2 Vector{Row}
  [ 1 2 ]

m --> 2x2 Matrix{Col}
  [ 1 3 
    2 4 ]

m' --> 2x2 Matrix{Row}
  [ 1 2 
    3 4 ]

Some operations:
v'  --> length-2 Vector{Col}
v'' == v
v*v or v'*v'  --> either error, or do element-wise multiplication
v' * v --> scalar
v * v' --> 2x2 Matrix  (could be Row or Col??)
v' * m --> 2-length Vector{Row}
v * m --> either error or broadcasting operation
m * v --> either error or broadcasting operation
m * v' --> 2-length Vector{Col}

Indexing:
v[2] --> 2
v[1,2] --> error
v'[1,2] --> 2
m[1,2]  --> 3
m'[1,2]  --> 2

Size:
length(v)  --> 2
length(v')  --> 2
size(v)  --> (2,)
size(v')  --> (2,)
length(m)  --> 4
size(m)  --> (2,2)

जाहिर है कि यह प्रस्ताव बहुत सारी परिभाषाओं को याद कर रहा है, लेकिन शायद यह चर्चा शुरू कर सकता है। क्या हम एक ही समय में कॉलम-इंडेक्स और रो-इंडेक्स स्टोरेज दोनों के लिए समर्थन कर सकते हैं, और रास्ते में कुछ मुद्दों को "ठीक" कर सकते हैं?

मैं बहुत चाहता हूं कि जूलिया पंक्ति-आधारित भंडारण था, क्योंकि यह स्वाभाविक रूप से है कि मैं लूप और कई अन्य कार्यों के बारे में कैसे सोचता हूं। (और मुझे नहीं लगता कि मैं केवल एक ही ऐसा हूं जो इस तरह से सोचता है) टिप्पणियाँ कृपया!

यह एक दिलचस्प विचार है, जिसके निर्माणकर्ता पंक्ति या स्तंभ में भी होते हैं। मुझे लगता है कि यह GitHub मुद्दे प्रणाली में कहीं गहरे से पहले चर्चा की गई है। मै गलत हो सकता हूँ!

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

स्तंभ-आधारित बनाम पंक्ति-आधारित इस समस्या के दायरे में नहीं है।

@tbreloff मुझे विचार बहुत पसंद है। यह उन भाषाओं / पुस्तकालयों के साथ अधिक आसानी से इंटरफ़ेस करने में सक्षम होगा जो पंक्ति-प्रमुख हैं।

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

यदि आपको सरणियों में पंक्ति / स्तंभ विशेषता जोड़ने का विचार पसंद नहीं है, तो ए
सटीक एक ही चीज़ को TransposeView {T, N} के साथ पूरा किया जा सकता है, लेकिन मैं
यह अच्छी तरह से लागू करने के लिए और अधिक जटिल हो जाएगा।

अतिरिक्त विशेषता के लिए सबसे बड़ा नकारात्मक पक्ष नए उपयोगकर्ताओं के लिए भ्रम है,
और यह एक ऐसी चीज है जो मेरे पास एक कठिन समय है।

शनिवार, 26 सितंबर, 2015 को, स्कॉट पी। जोन्स सूचनाएं @
लिखा था:

@tbreloff https://github.com/tbreloff मुझे आइडिया बहुत पसंद है। यह
भाषाओं / पुस्तकालयों के साथ अधिक आसानी से इंटरफ़ेस करने में सक्षम होने के लिए बहुत अच्छा होगा
यह पंक्ति-प्रमुख हैं।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment -143436947।

क्या कॉल-ओवरलोडिंग से डिज़ाइन स्पेस बिल्कुल बदल जाता है? ऊपर के समय में * के अर्थ में एक प्रकार की अस्पष्टता प्रतीत होती v::Covector * w::Vector चाहते हैं, तो क्या हम मैट्रिक्स गुणा के बजाय * वास्तव में " w v " के तहत ले रहे हैं? यदि ऐसा है, तो कोई एक समान मांग नहीं कर सकता है कि w::Vector * v::Covector एक अदिश

शायद यह बजाय अधिभार के लिए मददगार होगा call और लिखने v(w) 'के तहत नक्शा निरूपित करने के लिए v पर आपरेशन " w , और इसी के लिए w(v) - दोनों स्केलर लौटेंगे। यह 2d सरणियों के मामले में सरणी संचालन और रैखिक बीजीय संचालन साझा करने वाले शब्दार्थों को समायोजित करने में अधिक लेवे की अनुमति देगा?

यदि ऐसा है, तो एक समान मांग नहीं कर सकता है कि w :: वेक्टर * v :: Covector एक अदिश राशि लौटाता है, क्योंकि वैक्टर स्वयं covectors पर रेखीय नक्शे हैं?

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

कॉल सम्मेलन के रूप में v(w) , हम समान रूप से डॉट उत्पाद हम की राशि चाहते हैं के लिए कह सकते हैं v की दिशा में w जो हम का उपयोग करने का सुझाव अनुक्रमण ऑपरेटर v[w] । (BTW, मैं यह नहीं कह रहा हूँ यह एक अच्छा भाषा डिजाइन विकल्प है - सिर्फ एक अवलोकन!)

हम समान रूप से डॉट उत्पाद के लिए कह सकते हैं कि हम v की दिशा में w की दिशा में चाहते हैं जो बताता है कि हम इंडेक्सिंग ऑपरेटर v[w] ।

यह सुझाव लगभग, लेकिन अनुक्रमण के शब्दार्थ के अनुरूप नहीं है। अगर v Vector{<:Integer} तो यह वेक्टर अनुक्रमण के लिए हमारे वर्तमान समर्थन से भी टकराता है।

विचार करें कि v :: Vector{T<:Real} , v[1] डॉट उत्पाद v⋅e₁ , जहां e₁ पहली अक्ष के साथ विहित आधार वेक्टर है। इसलिए, सरल अनुक्रमण वास्तव में कार्य है

   v[n] : n :: Integer --> y = (v ⋅ eₙ) :: T

वेक्टर इंडेक्सिंग के लिए, v[[1, 2]] [v⋅e₁, v⋅e₂] v[[1, 2]] उत्पादन होता है, जो v को {e₁, e₂} द्वारा प्रायोजित उप-भाग में पेश करने का परिणाम है, या इसके बराबर ही v' * [e₁ e₂] का परिणाम है।

तो वेक्टर इंडेक्सिंग फ़ंक्शन है

   v[I] : I :: Vector{<:Integer} --> y = v' * [eₙ for n in I] :: Vector{T}

v[w] = (w ⋅ v) v बनाने का प्रस्ताव इस परिभाषा के साथ असंगत है क्योंकि यह इंडेक्स n संग्रह से निहित मानचित्रण को समाप्त करता है (जैसा कि w द्वारा निर्दिष्ट किया गया है) एक संग्रह विहित आधार वेक्टर का संग्रह eₙ , जो हमारे वर्तमान अनुक्रमण नियमों के काम करने के लिए आवश्यक है।

अब केवल वेक्टर के लिए गुंजाइश को सीमित करते हुए, मुझे लगता है कि हमारे पास दो विकल्प हैं। हम या तो इसे एक त्रुटि बना सकते हैं या हम विशेष कोवेक्टर प्रकार का परिचय दे सकते हैं। जूलिया में वेक्टर की प्रथम श्रेणी की प्रकृति को देखते हुए मुझे लगता है कि पूर्व एक बहुत ही कठिन बिक्री होगी ... और इसे लगातार करने के लिए हमें संभवतः वैक्टर को पूरी तरह से मैट्रिस के बीजगणित में भाग लेने से पूरी तरह से अलग करना चाहिए।

इसलिए मैंने कोवेक्टर पर एक शॉट लिया। यह बहुत काम है, और दुर्भाग्य से मैं इस पर अधिक समय नहीं दे पाऊंगा। मैं इसे यहां इस उम्मीद में पोस्ट करता हूं कि कोई व्यक्ति या तो इसके साथ भागेगा या कि हम कठिनाइयों से सीखेंगे और भागने का फैसला करेंगे। लेकिन मेरे पास विचारों के रूप में संक्रमण के साथ एक शाखा भवन है, और मैट्रिक्स कई बार कोवेटर्स के साथ लागू किया गया है। कुछ चयनित परीक्षण पास होते हैं, लेकिन केवल depwarn=error (उदा, ./julia -e 'using Base.Test; include("test/matmul.jl")' ) के बिना। https://github.com/JuliaLang/julia/compare/mb/transpose

मैंने दो नए दृश्य प्रकारों को transpose और ctranspose मैट्रिसेस और वैक्टर के लिए उपयोग करने के लिए परिभाषित किया है:

immutable MatrixTranspose{C,T,A} <: AbstractArray{T,2}
    data::A # A <: AbstractMatrix{T}
end
immutable Covector{C,T,V} 
    data::V # V <: AbstractVector{T}
end

C पैरामीटर एक सरल बूलियन है जो यह दर्शाता है कि ट्रांसपोज़ एक संक्रमण है या नहीं। ध्यान दें कि Covector AbstractArray का उपप्रकार _not_ है; यह यथोचित काम करने के लिए प्रेषण के लिए एक बहुत मजबूत आवश्यकता है।

कुछ नुकसान:

• कोवेटर्स निश्चित रूप से जटिल हैं, और वे एक सुलभ और कठोर तरीके से दस्तावेज़ करने के लिए एक चुनौती होगी। भाषा यहाँ मदद कर सकती है - हम उन्हें RowVector s कह सकते हैं। भले ही, इस व्यवहार को समझाने की कोशिश करने के दौरान आपको जो पहली मुश्किल हुई, वह यह है कि आप एक कोवेक्टर ( size अपरिभाषित) के आकार के बारे में कैसे बात करते हैं। यदि (m,n) एक मैट्रिक्स का आकार है, तो (m,) एक सदिश के आकार का प्रतिनिधित्व कर सकता है ... और यदि हम ट्यूल नोटेशन का दुरुपयोग करते हैं, तो हम स्लैंगली का वर्णन कर सकते हैं कि आकृति (,n) । यह हमें एक "लापता" आयाम के साथ मिश्रित वेक्टर / मैट्रिक्स बीजगणित नियमों को व्यक्त करने की अनुमति देता है जो कुछ समझदारी से जोड़ती है और प्रचारित करती है:
  
  
  
  • मैट्रिक्स * वेक्टर (m,n) × (n,) → (m,)
  
  
  • कोवेक्टर * मैट्रिक्स (,m) × (m,n) → (,n)
  
  
  • वेक्टर * कोवेक्टर (n,) × (,n) → (n,n)
  
  
  • कोवेक्टर * वेक्टर (,n) × (n,) → α (स्केलर) है
  
  

• बाइनरी संचालन की संख्या और प्रकार यहाँ कई तरीकों की संख्या में एक विशाल दहनशील विस्फोट की ओर ले जाते हैं जिन्हें परिभाषित करने की आवश्यकता है ... बस हमारे पास गुणा के लिए:

  • उत्परिवर्तन: (उत्परिवर्तन, गैर-उत्परिवर्तन)
  • संक्रमण: (A, Aᵀ, Aᴴ) × (B, Bᴴ, B।)।
  • आकार: (Mat × Mat; Vec × Mat; Mat × Vec, Vec × Vec)। ध्यान दें कि ये सभी ट्रांसपोज़ के सभी संयोजनों में समर्थित नहीं हैं, लेकिन अधिकांश हैं।
  • कार्यान्वयन: (BLAS, स्ट्रेटेड, जेनेरिक, और संरचनात्मक मैट्रिसेस के लिए विशेषज्ञता)

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



• वे सभी अदिश आयामों को छोड़ने के साथ किसी भी कठिनाई को तुरंत हल नहीं करते हैं। जब हम स्केलर आयाम छोड़ते हैं, तो किसी भी प्रकार के वेक्टर ट्रांज़िशन का समर्थन करना हमें जटिल संयुग्म के संबंध में अस्पष्ट क्षेत्र में डालता है (देखें https://github.com/JuliaLang/julia/pull/13612)। हो सकता है कि हमारे पास A[1,:] एक covector हो, लेकिन यह अच्छी तरह से सामान्य नहीं होता है और एक स्लाइस से गैर-AbstractArray को वापस करने के लिए काफी अजीब होगा। यह बहुत अच्छा होगा अगर लोग # 13612 की कोशिश कर सकते हैं और विशेष रूप से ऐसे मामलों की तलाश कर सकते हैं जहां एक वेक्टर के संयुग्मित संक्रमण परेशानी का कारण बनता है - यह वर्तमान वेक्टर ट्रांसफॉर्मेंट शब्दार्थों के साथ उतना ही बुरा होगा और एक्सपोज करने के लिए Covectors की आवश्यकता नहीं है।

कुछ फायदे:

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

अन्य नोट:

• एक बूलियन प्रकार के पैरामीटर द्वारा दर्शाए गए पारगमन की जटिलता होने से ठीक काम होता है, लेकिन मुझे अक्सर ऐसा लगता था कि मैंने गलत क्रम में मापदंडों को परिभाषित किया था। शायद ही मैं वास्तव में दोनों T और C को प्रतिबंधित या कैप्चर करना चाहता था। मुझे यकीन नहीं है कि अगर इसे करने का दूसरा तरीका प्लेसहोल्डर टाइपर्स की संख्या के संदर्भ में बेहतर होगा, तो आपको परिभाषित करने की आवश्यकता होगी, लेकिन बहुत कम से कम यह AbstractArray{T} मेल खाता होगा।
• यह वास्तव में StredArray कठिनाइयों को बढ़ा देता है। के लिए विधि तालिका पढ़ना * काफी की तरह प्रकार के साथ एक चुनौती है ::Union{DenseArray{T<:Union{Complex{Float32},Complex{Float64},Float32,Float64},2},MatrixTranspose{C,T<:Union{Complex{Float32},Complex{Float64},Float32,Float64},A<:Union{DenseArray{T,1},DenseArray{T,2},SubArray{T,1,A<:DenseArray{T,N},I<:Tuple{Vararg{Union{Colon,Int64,Range{Int64}}}},LD},SubArray{T,2,A<:DenseArray{T,N},I<:Tuple{Vararg{Union{Colon,Int64,Range{Int64}}}},LD}}},SubArray{T<:Union{Complex{Float32},Complex{Float64},Float32,Float64},2,A<:DenseArray{T,N},I<:Tuple{Vararg{Union{Colon,Int64,Range{Int64}}}},LD}} । ज़रूर, मैंने इसे एक टाइपेलियास के रूप में लिखा है, लेकिन यहां तक ​​कि इन सभी अलग-अलग प्रकार के उपनामों का प्रबंधन करना भी एक दर्द है ( StridedMatOrTrans , QRCompactWYQorTranspose , आदि)।
• मुझे SparseVector के साथ इसे एकीकृत करने का मौका नहीं मिला है, लेकिन यह एक बड़ी जीत होगी क्योंकि यह CSR की आवश्यकता के बिना कुशलता से पारगमन का प्रतिनिधित्व करेगा।
• क्या हमें Covectors पर स्केलर और / या नॉन-स्केलर इंडेक्सिंग को परिभाषित करने की आवश्यकता है? यदि हां, तो r[:] या r[1:end] का परिणाम क्या है? यह एक सदिश या कोवेक्टर है? मुझे लगता है कि अगर हम कर सकते हैं तो मैं इसे परिभाषित किए बिना दूर जाने की कोशिश करूंगा। दिलचस्प बात यह है कि मतलाब के पास अन्य वैक्टरों के साथ पंक्ति-वेक्टरों को अनुक्रमित करने के लिए बहुत विशेष नियम हैं - वे कुछ अजीब कोने के मामलों की कीमत पर अपने पंक्ति-नेस को बनाए रखने की बहुत कोशिश करते हैं ( r((1:end)') r(1:end) r(:)' )। मेरे पास अभी तक अपनी शाखा में स्केलर इंडेक्सिंग परिभाषित है, लेकिन शायद इसे भी हटा दिया जाना चाहिए। यह स्पष्ट कर देगा कि कोवेक्टर का उपयोग केवल रैखिक बीजगणित संचालन के साथ किया जाना है जो इसके बारे में जानते हैं।

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

जिज्ञासा से बाहर, अगर आप अभी भी @ ममूमन को याद करते हैं, तो आपको बूलियन पैरामीटर C लागू करने के लिए किसने प्रेरित किया? क्या आपके पास बस (छद्मपत्रों में) नहीं है

transpose(::Matrix) -> MatrixTranspose
transpose(::MatrixTranspose) -> Matrix

? मैं यहां आपके (असाधारण) फैसले पर संदेह नहीं कर रहा हूं, बस यह समझना चाहता हूं कि क्या अहसास आपको ऐसा करने के लिए मजबूर करते हैं।

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

आपको संयुग्म ट्रांसजेंड्स को संभालने के लिए किसी तरह की आवश्यकता है (और (A').' लिए अन-ट्रांसपोज़्ड संयुग्म सरणियाँ भी)। मुझे ऐसा करने के तीन स्पष्ट तरीके दिखाई देते हैं:

• एक MatrixTranspose प्रकार के भीतर एक बूलियन क्षेत्र के रूप में संयुग्मन को स्टोर करें। प्रतिबिंब पर, मुझे लगता है कि यह निश्चित रूप से बाहरी बीएलएएस के साथ इंटरफेस करने का सबसे अच्छा विकल्प है। मूल निवासी जूलियाब्लस के संदर्भ में, हालांकि, मैं यह सुनिश्चित करना चाहता हूं कि जूलिया / एलएलवीएम लूप से T.isconjugate ? conj(T[i,j]) : T[i,j] लहरा सके।
• संयुग्मन पैरामीटर के साथ एक प्रकार। यह वही है जिसे मैंने चुना है, और मुझे लगता है कि मैं इस तथ्य से प्रभावित था कि वर्तमान में हम Ac_mul_Bt और दोस्तों के माध्यम से संयुग्म-नेस पर छद्म प्रेषण करते हैं। जूलिया करने में सक्षम शाखाएं हटाने के बारे में भी मजबूत गारंटी देता है। लेकिन मैंने इसके बारे में कठिन नहीं सोचा था ... मैं बस एक स्केच कार्यान्वयन शुरू करना चाहता था, और मैं कोवेक्टर के बारे में अधिक चिंतित था।
• दो अलग-अलग प्रकार, MatrixTranspose और MatrixCTranspose । एक प्रकार के पैरामीटर के लिए आइसोमोर्फिक, लेकिन मुझे दो अलग-अलग रैपर प्रकार परेशान करते हैं। अमूर्त supertypes और यूनियन उपनाम मदद कर सकते हैं, लेकिन मैं अभी भी इस विकल्प पर पैरामीटर चुनूंगा।

मुझे लगता है कि अब टाइप किए गए कार्यों के साथ एक चौथा विकल्प है, ट्रांसपोज़ प्रकार के भीतर किसी भी परिवर्तन फ़ंक्शन को संग्रहीत करना ... लेकिन इसके लिए फ़ंक्शन को तेज़ करने के लिए एक प्रकार का पैरामीटर भी आवश्यक है, और फिर यह एक प्रकार का पैरामीटर है जो आसानी से नहीं भेजा जाता है।

मुझे आश्चर्य है कि अगर हम ConjugateView रैपर हो सकते हैं, तो नियम conj और transpose सुनिश्चित करें कि ConjugateView MatrixTranspose रैपर के अंदर रखे। । यानी, A a Matrix ,
A' = conj(transpose(A)) = transpose(conj(A)) सभी एक MatrixTranspose{ConjugateView{Matrix}} (अनइनफॉर्मेटिव प्रकार के मापदंडों को छोड़ने) का उत्पादन करते हैं।

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

मुझे खुशी है कि आप लोग अभी भी इस पर काम कर रहे हैं! यह एक महाकाव्य धागा है! शाबास!!!

क्रॉस-लिंक https://github.com/JuliaLang/julia/pull/6837#issuecomment -2133383832

क्या यह 1.0 की योजना है?

दो मुद्दों (# 18056, # 18136) में मुझे इस विशाल धागे की ओर इशारा किया गया था।
इसलिए मैं इसे आजमाता हूं।

अब जूलिया के पास सच 1-आयामी वैक्टर हैं, _e.g._ mx[row,:] अब 1xn मैट्रिक्स नहीं है।
यह एक स्वागत योग्य बदलाव है!

लेकिन साइड इफेक्ट के रूप में, कुछ मौजूदा समस्याएं अधिक स्पष्ट हो गईं।
मुझे इस तथ्य से काट दिया गया था कि v*mx 1-आयामी वैक्टर के लिए काम नहीं करता है।
गणितीय रूप से इसे स्वाभाविक रूप से काम करना चाहिए और 1-डी वेक्टर वापस करना चाहिए,
जब सामान्य a*b उत्पाद को अनुबंध द्वारा परिभाषित किया जाता है
पहले पद का अंतिम सूचकांक और दूसरे कार्यकाल का पहला सूचकांक।

वर्तमान में वेक्टर-मैट्रिक्स उत्पाद की विधि हस्ताक्षर है:
(*)(A::AbstractVector, B::AbstractMatrix) = reshape(A,length(A),1)*B
और इस पद्धति का उपयोग v*v' केस के लिए किया जाता है न कि v*mx ।
( इसे इंगित करने के लिए धन्यवाद
जाहिर है, दोनों के लिए एक ही विधि का उपयोग नहीं किया जा सकता है।

ऐसा लगता है कि जूलिया कुछ मतलूब जैसी सहवास से जूझ रही हैं।
लेकिन मतलाब में कोई 1-d वैक्टर नहीं हैं, सिर्फ 1xn और nx1 मैट्रिसेस हैं,
इतनी सारी चीजें जो स्वाभाविक हैं, यहां समस्या हो सकती है।
जूलिया में सच 1-d वैक्टर हैं जिनका एक बड़ा फायदा होना चाहिए।
यह अपने आप में एक सुसंगत स्थिति तक पहुंचना अच्छा होगा।

फोरट्रान इस मामले में पालन करने के लिए एक बेहतर और अधिक सुसंगत उदाहरण है।
transpose ऑपरेशन केवल फोरट्रान में मैट्रिसेस के लिए परिभाषित किया गया है,
एक सच्चे 1-डी वेक्टर से 1xn मैट्रिक्स बनाना केवल एक संक्रमण नहीं है।
matmul के लिए # 18056 में उद्धृत मेटकाफ-पुस्तक का अंश देखें।

मुझे लगता है कि ज्यादातर @alanedelman के मूल अंक सही थे।

तो यहाँ एक सुझाव है जो बस कुछ मौजूदा समस्याओं का इलाज करेगा,
वर्तमान स्थिति का यथासंभव सम्मान करते हुए:

• v' जैसा कि एक सच्चे 1-d वेक्टर v से 1xn मैट्रिक्स बनाने के लिए है
• rowmx और colmx फ़ंक्शंस बेहतर होंगे, लेकिन v' इसे बदलने के लिए बहुत व्यापक है
• हमारे पास पहले से ही vec 1 + सच्ची वेक्टर बनाने की क्रिया
• हालांकि v' का व्युत्क्रम v'' लेकिन vec(v') , हम इसके साथ रह सकते हैं
• a*b उत्पाद हमेशा के अंतिम सूचकांक अनुबंध चाहिए a और के पहले सूचकांक b
• * ऑपरेटर का उपयोग या तो आंतरिक या बाहरी उत्पादों के लिए नहीं किया जाना चाहिए
• आंतरिक उत्पादों के लिए हमारे पास पहले से ही dot फ़ंक्शन है
• बाहरी उत्पादों के लिए * का उपयोग समाप्त किया जाना चाहिए (_i.e._ v*v' सिंटैक्स)
• बाहरी उत्पादों के लिए एक नए फ़ंक्शन का उपयोग किया जाना चाहिए
• एक संबंधित infix ऑपरेटर सिंटैक्स प्रकाश रख सकता है

बाहरी उत्पादों के लिए [संक्षिप्त गणितीय सिंटैक्स] को खोना दुर्भाग्यपूर्ण होगा। मैं व्यक्तिगत रूप से vec * मैट देना चाहता हूँ।

क्या मौजूदा PernutedDimsArray पहले से ही उस मामले को संभाल सकता है जहां माता-पिता और दृश्य के आयाम अलग-अलग हैं? यदि ऐसा है, हो सकता है कि पहले से ही गैर-संयुग्म ट्रांसजेंडर आवरण प्रकार वेक्टर माता-पिता के लिए भी प्रयोग करने योग्य हो।

मुझे प्रलेखन में PermutedDimsArray नहीं मिला।

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

"लापता तरीकों की समस्या" के अलावा, यह एक प्रकार नहीं होगा जिसके बारे में आपको चिंता होगी, यह एक कार्यान्वयन विवरण होगा कि .' एक आलसी आवरण प्रकार (और ' लौटाता है एक संयुग्मित संस्करण)। अन्यथा मुझे नहीं लगता कि हम दोनों vec*mat और vec*vec' दोनों एक ही * ऑपरेटर का उपयोग कर सकते हैं। अगर मैंने एक पेपर में vec*mat देखा तो यह मेरे लिए गलत होगा, लेकिन मैं vec*vec' बहुत बार देखता हूं।

हालांकि इसके बारे में अधिक सोचते हुए, मेरा मानना ​​है कि PermutedDimsArray अपने एलीमेंट्स को सरणियों के सरणियों के लिए पुनरावृत्ति नहीं करता है, इसलिए यह यहां उपयोग करने के लिए रैपर प्रकार के रूप में काफी उपयुक्त नहीं है।

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

मैं सराहना करता हूं कि आप चर्चा के लिए तैयार थे जबकि यह धागा इसके अंत के निकट है।

जबकि v*mx आपको अजीब लग सकता है, लेकिन यह क्रिस्टलोग्राफिक कोड में भारी उपयोग किया जाता है।
यह फोरट्रान के matmul द्वारा भी अच्छी तरह से संभाला जाता है। (# 18056 देखें)

u*v' उत्पाद पर वापस।
जब u और v दोनों nx1 मैट्रीक हैं, तो यह एक सामान्य मैट्रिक्स उत्पाद है,
यह बाहरी उत्पाद के समान परिणाम प्रदान करने के लिए निकला।
लेकिन यह केवल बाहरी उत्पाद का अनुकरण करने के लिए मैट्रिक्स उत्पाद का उपयोग कर रहा है।
यह मतलाब की दुनिया में सहज है जहां सब कुछ एक मैट्रिक्स है।

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

फोरट्रान का बाहरी उत्पादों के लिए कोई आंतरिक कार्य नहीं है।
जूलिया आसानी से v' को 1xn मैट्रिक्स में बदल देती है,
और 1-d वेक्टर और 1xn मैट्रिक्स पर * कार्रवाई करता है।
कई प्रेषण के कारण यह ऐसा करने में सक्षम है,
लेकिन यहाँ * निश्चित रूप से अब एक मैट्रिक्स उत्पाद नहीं है।

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

तो हमें रैखिक बीजगणित के तीन उत्पादों को संभालना होगा:
सामान्य मैट्रिक्स उत्पाद, आंतरिक उत्पाद और बाहरी उत्पाद।
वर्तमान में * ऑपरेटर सामान्य और बाहरी उत्पादों के लिए एक संयुक्त वाक्यविन्यास है।
मैंने सभी को सुझाव दिया है कि इन्हें अलग किया जाए और अधिक सुसंगत स्थिति तक पहुँचाया जाए।

(ओह, मैंने क्रॉस उत्पाद छोड़ दिया है, लेकिन यह पहले से ही अलग है)

मुझे नहीं लगता कि आंतरिक उत्पाद, बाहरी उत्पाद और मैट्रिक्स गुणन उत्पादों को विभाजित / वर्गीकृत करने का एक गणितीय तरीका है। निम्नलिखित निश्चित रूप से उन चीजों की पुनरावृत्ति है जो विभिन्न लोगों द्वारा ऊपर बताई गई हैं, लेकिन इस विषय की लंबाई को देखते हुए, मुझे उम्मीद है कि हर अब और फिर एक सारांश शामिल करना ठीक है। यह मेरा व्यक्तिगत सारांश है और मैं निश्चित रूप से एक विशेषज्ञ नहीं हूं, इसलिए मुझे सही करें जहां मैं गलत हूं।

एक सार रेखीय बीजगणित सेटिंग में, मुख्य खिलाड़ी v (वेक्टर स्पेस V ), रेखीय मानचित्र (एक वेक्टर स्पेस V और मैपिंग करते हैं संभवतः अलग-अलग स्थान W ) और इन मानचित्रों की रचना, रेखीय रूप या कोवेक्टर (दोहरी जगह V* और V स्केलरों से मैपिंग), आंतरिक उत्पाद ( V × V स्केलरों तक), वैक्टर के बीच टेंसर उत्पाद (यानी kron )। बाहरी उत्पाद मैं एक वेक्टर और एक कोवेक्टर के बीच एक टेंसर उत्पाद के रूप में सोचना पसंद करता हूं।

इस मुद्दे के लिए विशेष रूप से रुचि वैक्टर और रैखिक रूपों के बीच समरूपता है, अगर एक आंतरिक उत्पाद को परिभाषित किया जाता है, यानी हर f मैपिंग वैक्टर v स्केलरों के लिए, वहाँ w मौजूद है ऐसे कि f(v) = dot(w,v) किसी भी v । कोवेटर्स हालांकि आंतरिक उत्पादों (जैसे बहुआयामी फ़ंक्शन के ग्रेडिएंट) के संदर्भ के बिना मौजूद हो सकते हैं।

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

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

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

@GaborOszlanyi को अंतिम नोट के रूप में, मुझे अभी भी इस सब में v*A लिए कोई जगह नहीं मिली। यह उन क्षेत्रों में मानक हो सकता है जहां वैक्टर्स को पंक्ति मैट्रिसेस के रूप में डिफ़ॉल्ट रूप से दर्शाया जाता है, लेकिन व्यक्तिगत रूप से मुझे लगता है कि यह एक अजीब विकल्प है। यदि रेखीय नक्शे f और g f(v) = v*A और g(v) = v*B , तो इसका मतलब है कि g(f(v)) = (g ◦ f)(v) = v*A*B जो रचना क्रम से विषम है। आपस में जुड़ा हुआ है। यदि कोई है, तो मैं इसे एक अधूरे आंतरिक उत्पाद के रूप में व्याख्या कर सकता हूं, जैसा कि लिंक की गई तालिका की दूसरी से अंतिम पंक्ति में है।

आपका सारांश गहरा और ठोस है।
इतनी अच्छी तरह से समझाने के लिए धन्यवाद।

मेरे पास दो शेष प्रश्न हैं:

• इस गहन चर्चा के परिणामस्वरूप जूलिया में वास्तव में क्या बदलाव होंगे?
• फोरट्रान ने v*mx matmul लागू क्यों किया?

इस समस्या से दो समस्याएं सामने आती हैं:

ए। लागू गणितज्ञों को गृहस्वामी संकेतन के लिए भेजा जाता है, जो दो प्राकृतिक समसामयिकता का उपयोग करता है:

1. लंबाई N का एक सदिश Nx1 _column मैट्रिक्स_ से अप्रभेद्य है, क्योंकि Nx1 मैट्रिक एक सदिश स्थान बनाता है। ("स्तंभित करें",,)
2. 1x1 मैट्रिक्स एक अदिश संख्या से अप्रभेद्य है, क्योंकि 1x1 मैट्रिक्स को स्केलर के सभी बीजीय गुणों के साथ परिभाषित किया जा सकता है। ("स्केलराइज़", ■)

समस्या यह है कि जूलिया के प्रकारों में इन दोनों में से कोई भी समरूपता स्वाभाविक नहीं है और दोनों में सरणी आकृति के रन समय की जाँच शामिल है। MATLAB के अनुगामी सिंगलटन आयाम नियमों को इन दोनों आइसोमॉर्फिम्स के कार्यान्वयन के रूप में माना जा सकता है।

B. दो आयामी सरणी को सरणियों के एक सरणी के रूप में पुनरावर्ती रूप से परिभाषित किया जा सकता है। हालांकि, एक मैट्रिक्स स्तंभों या स्तंभों की एक पंक्ति है, लेकिन पंक्तियों या स्तंभों की एक पंक्ति कभी नहीं। तथ्य यह है कि matrices परिभाषित नहीं किया जा सकता recursively matrices और n- आयामी सरणियों के विभिन्न दसियों संरचना पर प्रकाश डाला गया। उचित रूप से बोलना, बहुआयामी सरणियाँ एक बहुत ही सीमित प्रकार के टेंसर हैं और बाद वाले को लागू करने के लिए आवश्यक पूर्ण मशीनरी का अभाव है। क्योंकि एक संकुचन कड़ाई से बोल रहा है, अपने दोहरे के साथ एक वेक्टर अंतरिक्ष की जोड़ी पर एक ऑपरेशन है, यह बहुआयामी सरणियों के सूचकांकों के अनुबंध के बारे में बात करने के लिए एक मिथ्या नाम है, जो कभी भी दोहरी वेक्टर अंतरिक्ष की अवधारणा को लागू नहीं करता है। अधिकांश लोग _not_ पूर्ण मशीनरी चाहते हैं, जिसके लिए पंक्ति / स्तंभ प्रकृति के साथ सह-विपरीत या विपरीत / अनुक्रमणिका के बारे में चिंता करने की आवश्यकता होती है। इसके बजाय ज्यादातर लोग चाहते हैं कि सरणियाँ सादे पुराने कंटेनर हों, सभी आयामों में पूरी तरह से विपरीत हों, दो आयामों में _except_, जिससे अधिकांश उपयोगकर्ता मेट्रिसेस के बीजगणित (जो डाउन-अप टेंसर) के रूप में दो आयामी सरणियों के बारे में सोचना चाहते हैं, और कभी नहीं डाउन-डाउन, अप-अप, या अप-डाउन टेंसर्स। दूसरे शब्दों में, दो-आयामी सरणियों को विशेष आवरण बनाना चाहते हैं।

मैं अभी भी अन्यथा राजी हो सकता है, लेकिन यहाँ मेरा वर्तमान 3-भाग प्रस्ताव है:

a) पूरी तरह से वैक्टर को स्थानांतरित करने के लिए, उपयोगकर्ताओं को कॉलम मैट्रिसेस में स्पष्ट रूप से वैक्टर को बदलने की आवश्यकता होती है ताकि हाउसहोल्डर-शैली के भावों को u'v , u*v' , u'*A*v और u'*A*v/u'v लिख सकें। u और v सच्चे वैक्टर हैं, तो u' या u'*A जैसे सबएक्सप्रेस को देना संभव नहीं है, बिना एक विशेष TransposedVector शुरू किए।

(क) के एक सीमा होगी कि सभी हाउसहोल्डर शैली भाव सच scalars के बजाय 1x1 मैट्रिक्स (जो अभी भी खत्म हो गया एक बहुत बड़ा सुधार है उत्पन्न होगा u'v 1-वेक्टर लौटने), की तरह एक अभिव्यक्ति तो (u'*v)*w अभी भी काम नहीं करेगा। व्यवहार में मुझे नहीं लगता कि "ट्रिपल प्रोडक्ट" इस तरह के भाव अक्सर होते हैं।

बी) वैक्टर पर अनुरूप संचालन के लिए एक वैकल्पिक संकेतन प्रस्तुत करता है, जैसे कि

• आंतरिक (डॉट) उत्पाद के लिए u ⋅ v = scalarize(columnify(u)'*columnify(v))
• बाहरी (क्रोनकर) उत्पाद के लिए u ⊗ v = columnify(u)*columnify(v)'
• A(u, v) = scalarize(columnify(u)'*A*columnify(v)) , बिलिनियर फॉर्म के लिए एक पुराना अंकन
• द्विघात रूप के लिए A(u) = A(u, u)

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

ग) 1x1 मेट्रिसेस को सच्चे स्केलर में कन्वर्ट करें, ताकि कोड पसंद आए

M = Array(Int, 1, 1, 1)
a::Int = M

काम कर सकता है। जरूरत है कि कुछ के साथ सरणी आकार के लिए रन समय की जाँच करना है:

function convert{T}(::Type{T}, A::Array{T,N})
    if length(A) == 1
        return A[1]
    else
        error()
    end
end

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

@ जियाओ , इस पोस्ट की पठनीयता हार्ड-टू-रेंडर पात्रों द्वारा सीमित है। ओएस एक्स पर भी सही नहीं दिखता है, जो आमतौर पर अपने फोंट में पूरी तरह से यूनिकोड है।

@ जियाओ , मैं निश्चित रूप से अधिकांश / सभी से सहमत हो सकता हूं, हालांकि मैं दो बिंदुओं को चुनौती देना चाहता हूं:

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

यह केवल मेरे लिए एक तार्किक परिणाम लगता है यदि आप TransposedVector AbstractArray पदानुक्रम का एक उपप्रकार बनाना चाहते हैं, जो मुझे लगा कि यह योजना नहीं थी (कुछ LazyTranspose जो वास्तव में है) AbstractMatrix का एक और प्रकार है)।

बाहरी (क्रोनकर) उत्पाद के लिए u ⊗ v

यदि लक्ष्य निहित आइसोमोर्फिम्स पर निर्भर नहीं करना है और वेक्टर ऑपरेशन और अधिक सार उत्पादों से मैट्रिक्स के अलग-अलग संचालन को साफ करना है, तो मेरा मानना ​​है कि यह निम्नलिखित कारण के लिए विफल रहता है (मैं निम्नलिखित गणितीय परिभाषाओं पर सार्वभौमिक समझौते के बारे में निश्चित नहीं हूं):

• क्रॉंकर उत्पाद A ⊗ B एक ऑपरेशन है जो मैट्रिस पर परिभाषित किया गया है, न कि वैक्टर पर।
• इसलिए, दो वैक्टर के टेनर उत्पाद के रूप में u ⊗ v पढ़ने के बजाय, यह डाउन टाइप के दो-आयामी टेंसर को जन्म देगा। एक उचित 'मैट्रिक्स' प्राप्त करने का एकमात्र तरीका एक वेक्टर के दसियों उत्पाद को कोवेक्टर के साथ लेना होगा। लेकिन जब से आप इन वस्तुओं को शुरू करने से बचना चाहते हैं, तो ऐसा लगता है कि इसमें शामिल दो वैक्टर को स्तंभित करने से पहले इस ऑपरेशन का परिणाम प्राप्त करना असंभव है।
• u ⊗ v लिए एक तीसरा नाम बाहरी उत्पाद है जो आमतौर पर धीरे-धीरे परिभाषित किया गया है, और मुझे यकीन नहीं है कि अगर ऊपर और नीचे के संदर्भ में एक स्वीकृत कठोर परिभाषा है। कुछ स्रोत बताते हैं कि यह दो वैक्टर के दसियों उत्पाद के बराबर है, इसलिए पिछला बिंदु। यदि इसके बजाय आप एक परिभाषा को स्वीकार करते हैं, जहां 'बाहरी उत्पाद' का अर्थ यह भी है कि दूसरे वेक्टर को एक कोवेक्टर में मैप करना ताकि टेनर को नीचे लाया जा सके, तो कोई समस्या नहीं है।

इसके बजाय ज्यादातर लोग चाहते हैं कि सरणियाँ सादे पुराने कंटेनर हों, दो आयामों को छोड़कर, सभी आयामों में पूरी तरह से कंट्राविरेंट हों,

क्या हमने परमाणु विकल्प पर विचार किया है? हम रेखीय बीजगणित शुरू करते हैं, पूरी तरह से AbstractVector और AbstractMatrix लिए टाइपेलियास को हटाते हैं और उनके साथ प्रतिस्थापित करते हैं:

abstract AbstractVector{T} <: AbstractArray{T,1}
abstract AbstractMatrix{T} <: AbstractArray{T,2}

# and we could introduce:
abstract AbstractCoVector{T} <: AbstractArray{T,1}

मैं समझता हूं कि बहुत अधिक गिरावट है, लेकिन हम बहुआयामी भंडारण सरणियों और रैखिक बीजगणित के बीच एक अलग अलगाव के साथ समाप्त हो सकते हैं। हम पूर्ण बहु-आयामी टेंसर बीजगणित, दोहरी वेक्टर रिक्त स्थान आदि को लागू करने के लिए _have_ नहीं करते हैं, हमें बस बिट्स को लागू करना होगा जो बहुत से लोग चाहते हैं: वैक्टर, कोवेक्टर और मैट्रिस। हमें आंतरिक उत्पाद, बाहरी उत्पाद, कोवेक्टर-मैट्रिक्स उत्पाद, मैट्रिक्स-वेक्टर उत्पाद और मैट्रिक्स-मैट्रिक्स उत्पाद मिलते हैं। संक्रमण उपरोक्त सभी पर परिभाषित किया गया है। हमारे पास AbstractMatrix का कार्यान्वयन हो सकता है जो वास्तव में 1D सरणियों के 1D सरणी का उपयोग करते हैं (डिफ़ॉल्ट कार्यान्वयन नहीं, निश्चित रूप से)। हमें हाउसहोल्डर नोटेशन (जो IMHO MATLABs कमजोरियों में से एक है!) का उपयोग करने की आवश्यकता नहीं है, लेकिन हम अभी भी रैखिक बीजगणित की सभी उपयुक्तताओं को प्राप्त कर सकते हैं।

मैं यह सुझाव देने के लिए थोड़ा नर्वस हूं, लेकिन मुझे विश्वास है कि यह जूलिया को "सही" मॉडल की नकल करने की अनुमति देगा, जो कि ज्यादातर लोग उदाहरण के लिए पहले वर्ष के विश्वविद्यालय स्तर के रेखीय बीजगणित में सीखते हैं, जिसमें हाउसहोल्डर सम्मेलनों को कम करने की आवश्यकता नहीं है। एक स्पष्ट अंतर बनाने से Base.LinAlg " Buffer परिवर्तनों और Array मूल कार्यान्वयन के साथ आएगी, इसलिए यह सामान्य "सूची" प्रकार जगह ले सकता है Vector जूलिया के मुख्य भागों से कई के लिए और हमें लोड करते हैं LinAlg पैकेज काफी देर से करते हुए Array और "सूची" काफी जल्दी में परिभाषित किया।

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

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

LA.Vector
LA.CoVector
LA.Tensor{... describing co/contravariance of indices ...}

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

यह @andyferris के सुझाव के करीब है, सिवाय इसके कि यह

@ सेशनेट मुझे लगता है कि पहले इस धागे में यह तय किया गया था कि बहु-रेखीय बीजगणित को जूलिया के बजाय पैकेज के लिए छोड़ दिया जाएगा। मुझे लगता है कि आपके द्वारा सुझाए गए इन विचारों का एक बहुत कुछ एक नए पैकेज में किया जा सकता है, जो टेंसर, वेक्टर रिक्त स्थान, सह-गर्भ-विचरण और इतने पर टाइप प्रणाली के भीतर व्यवहार करता है, जो कि _TensorOperations.jp_ पैकेज से कुछ अलग है जो सुविधा कार्य प्रदान करता है सरणियों को गुणा करने के लिए जैसे कि वे दसियों थे। मुझे लगता है कि इसे विकसित करना चुनौतीपूर्ण होगा लेकिन संभावित रूप से एक सार्थक अमूर्तता!

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

ध्यान दें कि एक सामान्य गैर-यूक्लिडियन जटिल वेक्टर अंतरिक्ष V में 4 संबद्ध स्थान हैं: V , conj(V) , dual(V) और conj(dual(V)) । तो सामान्य टेंसर की तुलना में 4 प्रकार के सूचकांक होते हैं (आमतौर पर ऊपर या नीचे, वर्जित या वर्जित के रूप में निरूपित)। एक जटिल यूक्लिडियन स्थान (जैसे क्वांटम यांत्रिकी) में, dual(V) ≡ conj(V) और conj(dual(V)) = V । एक वास्तविक (गैर-यूक्लिडियन) स्थान (जैसे सामान्य सापेक्षता) में, V ≡ conj(V) । बाद के दोनों मामलों में, केवल ऊपर और नीचे सूचकांकों की आवश्यकता होती है।

एक वास्तविक यूक्लिडियन स्पेस (अधिकांश एप्लिकेशन?) में, सभी समान हैं, और जूलिया के सादे एरेस टेंसर्स का प्रतिनिधित्व करने के लिए पर्याप्त हैं। तो कम से कम वास्तविक संख्याओं के लिए, निम्नलिखित दो ऑपरेशन एक पूर्ण और सुसंगत टेंसर बीजगणित के निर्माण की अनुमति देते हैं।

• अनुबंध / आंतरिक उत्पाद ∙ , जो कि नियम का उपयोग करते हुए रैंक N की मनमानी सरणियों के लिए सामान्यीकृत किया जा सकता है: दूसरे के पहले सूचकांक (या संख्यात्मक dot साथ पहले सरणी के अंतिम सूचकांक का अनुबंध करें A ∙ B रैंक की एक सरणी M+N-2 अगर A और B पास रैंक M और रैंक N ।
• टेनर उत्पाद ⊗ : A ⊗ B रैंक की एक सरणी N+M

वैक्टर के लिए नीचे v , w और matrices A , B , यह निम्नलिखित में से सभी को लिखने की अनुमति देता है:

• वेक्टर आंतरिक उत्पाद v ∙ w -> असाधारण रैंक 0 सरणी के बजाय एक स्केलर देता है
• मैट्रिक्स वेक्टर गुणन A ∙ v
• मैट्रिक्स मैट्रिक्स गुणन A ∙ B
• दसियों / बाहरी उत्पाद v ⊗ w
• कोवेक्टर (=== वेक्टर) मैट्रिक्स गुणन v ∙ A

जबकि कोई * ∙ का उपयोग करना चाह सकता है, लेकिन नुकसान यह है कि ∙ की उपरोक्त परिभाषा सहयोगी नहीं है: (A ∙ v) ∙ w ≠ A ∙ (v ∙ w) जैसा कि बाद में भी नहीं होगा। परिभाषित किया जा सकता है।

लेकिन तब फिर से, यह तभी है जब आप जटिल सरणियों को अनदेखा करने के लिए तैयार हैं।

Tensors की एक पूरी तरह से सामान्य कार्यान्वयन के लिए के रूप में, मैं शुरू कर दिया है (और परित्यक्त) इस एक लंबे समय पहले, इससे पहले कि वहाँ थे ढेर आवंटित tuples, उत्पन्न कार्य करता है और इन सभी अन्य उपहार है कि शायद आज यह और अधिक व्यावहारिक होगा।

दिलचस्प दृष्टिकोण, @ जूथो। काफी सहज लगता है। मैं _guessing_ हूं कि इन परिभाषाओं को जोड़ा जा सकता है, भले ही हम * और ' , और मैं इसका समर्थन करूंगा।

लेकिन तब फिर से, यह तभी है जब आप जटिल सरणियों को अनदेखा करने के लिए तैयार हैं।

मैन्युअल रूप से conj() फ़िक्सेस डाले गए। और मुझे नहीं लगता कि जूलिया जटिल परिपक्वताओं को नजरअंदाज करना चाहता है, क्या यह?

मैंने एक युगल को एक प्रकार के उपनाम के बजाय AbstractMatrix के विशेष उप-प्रकार के रूप में देखा है:

matrix[:,i] -> AbstractVector{T}
matrix[i,:] -> AbstractCoVector{T}
array_2d[:,i] -> AbstractArray{T,1}
array_2d[i,:] -> AbstractArray{T,1}

यह बहुत अच्छा है - हम मैट्रिक्स को अनुक्रमित करने से कॉलम और पंक्ति वैक्टर प्राप्त कर सकते हैं। अगर यह सिर्फ एक 2 डी स्टोरेज कंटेनर है तो हमें 1 डी स्टोरेज एरे मिलता है। सभी उपयोग मामलों को कवर करना चाहिए! और यह अभी भी दोनों AbstractVector{T} <: AbstractArray{T,1} और AbstractCoVector{T} <: AbstractArray{T,1} बाद से APL स्लाइसिंग नियमों के साथ AbstractArray इंटरफ़ेस का पालन करता है।

एक "रोचक" तथ्य है

array_3d[:,:,i] -> AbstractArray{T,2}
matrix(array_3d[:,:,i]) -> `AbstractMatrix {T}

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

यह एक मूर्खतापूर्ण सवाल हो सकता है, लेकिन @ जूथो ने पहले उल्लेख किया था कि लेखन कोड ASCII द्वारा सीमित था। क्यों दुनिया में हम अभी भी अपने आप को 1963 में विकसित पात्रों के 7-बिट सेट तक सीमित कर रहे हैं, और अंतिम बार 1986 में (30 साल पहले) अपडेट किया गया है? यह एक ऐसा युग था जब प्रसिद्ध 640KB 1981 में एक पीसी पर उपलब्ध अधिकतम रैम था। आज के कंप्यूटर बाजार में, हमारे पास अब 64 बिट प्रोसेसर है जिसमें 32GB RAM बिक्री पर है (पिछले अधिकतम 50,000x) और हम कहीं नहीं हैं 64 बिट प्रोसेसर के लिए सैद्धांतिक सीमा। तो, क्यों हम अभी भी 40 साल पहले विकसित एक चरित्र सेट में खुद को सीमित कर रहे हैं?

हम यूनिकोड का उपयोग कर सकते हैं, बस ध्यान रखें कि दुर्भाग्य से कीबोर्ड का आकार पिछले 40 वर्षों में एक समान कारक से नहीं बढ़ा था और न ही उंगलियों की संख्या एक सामान्य व्यक्ति के पास है (पिछले 10000+ वर्षों में)।

IMHO, ASCII को आराम करने के लिए रखा जाना चाहिए। तेज, गणित प्रतीक प्रोग्रामिंग के लिए एक विशेष, गणितीय कीबोर्ड वास्तव में एक अच्छा विचार है! क्या यूएफएफ के साथ आने वाले अधिक प्रतीकों का उपयोग न करने का एक अच्छा कारण है? क्या आप संभवतः एएससीआईआई से बाहर निकलने वाली हर चीज को रस देने की कोशिश के दर्द को सही ठहरा सकते हैं?

@ esd100 : कृपया इस तरह के अत्यधिक सट्टा चर्चा के लिए इस GitHub मुद्दे का उपयोग न करें।

@Johnmyleswhite। मुझे यकीन नहीं है कि आप "सट्टा" से क्या मतलब है। क्या आप सुनिश्चित हैं कि आप जिस शब्द का उपयोग करना चाहते हैं? मुझे लगा कि ASCII बनाम कुछ और का उपयोग चर्चा के लिए प्रासंगिक था, क्योंकि ऐसा लगता है कि भाषा, ऑपरेटर और कार्यक्षमता उपयोग किए गए प्रतीकों से बंधे हैं। मैं किसी भी तरह से एक विशेषज्ञ नहीं हूं, लेकिन यह चर्चा के साथ एक मुद्दे की तरह लगता है, या कम से कम स्पष्ट होने के कारण, कार्यक्षमता से संबंधित है।

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

@ esd100 कृपया ध्यान दें कि उदाहरण के लिए @Jutho की हालिया टिप्पणी (2 यूनिकोड प्रतीकों का उपयोग करके) अच्छी तरह से प्राप्त हुई थी और @yuyichao सहमत हैं कि हम यूनिकोड का उपयोग कर सकते हैं। अधिक यूनिकोड-केवल ऑपरेटरों (उदाहरण के लिए रचनाओं को रचना करने के लिए, # 17184) शुरू करने के बारे में अन्य प्रस्ताव हैं। मुझे नहीं लगता कि लोग आपसे असहमत हैं (हालांकि हमारे पास ध्यान में रखने के लिए व्यावहारिक विचार हैं), लेकिन अगर आपके पास _specific_ है, तो विषय पर सुझाव कृपया हमें बताएं।

मैं v0.5 में इस नए व्यवहार से थोड़ा भ्रमित हूं जो मुझे लगता है कि इस चर्चा से उत्पन्न हुआ है:

julia> [ x for x in 1:4 ]' # this is fine
1×4 Array{Int64,2}:
 1  2  3  4

julia> [ Symbol(x) for x in 1:4 ]' # bit this isn't? What is special about symbols?
WARNING: the no-op `transpose` fallback is deprecated, and no more specific
`transpose` method for Symbol exists. Consider `permutedims(x, [2, 1])` or writing
a specific `transpose(x::Symbol)` method if appropriate.

मैं सूची से बाहर एक (गैर-संख्यात्मक) पंक्ति वेक्टर कैसे बनाऊं? यह एक पंक्ति वेक्टर होना है। (क्या यह एक अलग मुद्दे के रूप में बेहतर होगा या कहीं और चर्चा की जाएगी? यकीन नहीं था कि कहां पोस्ट करना है ...)

आप रिशेप का उपयोग कर सकते हैं: reshape(v, 1, length(v)) । हो सकता है कि इस बात का ज़िक्र डिप्रेसन चेतावनी में भी किया जाए? मुझे लगता है कि विचार यह है कि संक्रमण एक गणितीय ऑपरेशन है और इस प्रकार केवल गणितीय वैक्टर / मेट्रिसेस के लिए परिभाषित किया जाना चाहिए।

यह चित्रण में उल्लिखित है: permutedims(x, [2, 1]) ।

permutedims वैक्टर के लिए काम नहीं करता है। इस ब्रांड का नया मुद्दा देखें: # 18320

मुझे लगता है कि विचार यह है कि संक्रमण एक गणितीय ऑपरेशन है और इस प्रकार केवल गणितीय वैक्टर / मेट्रिसेस के लिए परिभाषित किया जाना चाहिए।

त्रि - आयामी यह बेमतलब का लगता है। क्या यह चर्चा के लिए है? मैं वास्तव में गैर-सांख्यिक सरणियों पर काम करना पसंद करूंगा जब तक कि वास्तव में अच्छा औचित्य न हो।

मुझे लगता है कि विचार यह है कि संक्रमण एक गणितीय ऑपरेशन है और इस प्रकार केवल गणितीय वैक्टर / मेट्रिसेस के लिए परिभाषित किया जाना चाहिए।

त्रि - आयामी यह बेमतलब का लगता है। क्या यह चर्चा के लिए है? मैं वास्तव में गैर-सांख्यिक सरणियों पर काम करना पसंद करूंगा जब तक कि वास्तव में अच्छा औचित्य न हो।

मुझे लगता है कि यह अपेक्षाकृत जटिल है कि आप क्या चाहते हैं _ और गणित के लिए समझ बनाएं। एक गणितीय अर्थ में, ट्रांसफ़ॉर्म को अक्सर वेक्टर रिक्त स्थान और वेक्टर या मैट्रिक्स के अपने दोहरे स्थान को स्वैप करके परिभाषित किया जाता है (ठीक है, ट्रांसजेस बनाम संयुग्म ट्रांसजेस, साथ ही साथ कुछ जटिलता है)। नियमित संख्याओं के एक मैट्रिक्स M के लिए, हमारे पास permutedims(M, (2,1)) रूप में स्थानान्तरण है, लेकिन सामान्य तौर पर आप इस तरह के उप-मैट्रिक्स के संदर्भ में उदाहरण के लिए "ब्लॉक" मैट्रिक्स को परिभाषित कर सकते हैं:

M = [A B;
     C D]

जहां A आदि खुद मैट्रिसेस हैं। मेरी समझ यह है कि जूलिया को पसंद है

M' = [A' C';
      B' D']

जो कि आप पेन-एंड-पेपर गणित का उपयोग कर रहे हैं और इसलिए "वांछनीय वाक्यविन्यास" है।

इसका अर्थ है कि मैट्रिक्स के तत्वों को ' और .' स्वीकार करना होगा। संख्याओं के लिए इन्हें क्रमशः जटिल संयुग्मन और नो-ऑप्स के रूप में परिभाषित किया गया है। IMHO मुझे लगता है कि यह सुविधा का एक दंड है, लेकिन यह काम करता है और, सबसे महत्वपूर्ण बात, यह _simple_ नियमों ("स्थानान्तरण पुनरावर्ती है" के साथ लागू किया गया है - BlockMatrix वर्गों और इसी तरह की आवश्यकता के विपरीत)। लेकिन पारगमन पर यह दंड 0.5 में गैर-प्रकार के प्रकारों से हटा दिया गया है, क्योंकि यह बहुत मायने नहीं रखता है। Symbol का संक्रमण क्या है?

यदि आपके पास _data_ है, तो संख्याएँ नहीं हैं, तो permutedims का उपयोग इसके अर्थ और व्यवहार में पूरी तरह से परिभाषित है: यह गैर-पुनरावर्ती है। .' जैसे गणितीय दंड का उपयोग करने से आपको टाइपिंग करने वाले कुछ वर्णों को बचाया जा सकता है - लेकिन यह किसी और के लिए _lot_ को अधिक अर्थ देगा (जो गणित या MATLAB से बहुत परिचित नहीं हो सकता है) यदि आप उपयोग कर रहे हैं तो अपना कोड पढ़ें reshape और permutedims आवश्यकतानुसार। मेरे लिए, यह _ सबसे महत्वपूर्ण बिंदु_ है।

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

विचारशील प्रतिक्रिया के लिए धन्यवाद। मैं अभी भी बहुत दृढ़ता से असहमत हूं

लेकिन पारगमन पर यह दंड 0.5 में गैर-प्रकार के प्रकारों से हटा दिया गया है, क्योंकि यह बहुत मायने नहीं रखता है। प्रतीक का संक्रमण क्या है?

मुझे यकीन नहीं है कि एक Symbol के ट्रांज़िशन को परिभाषित करने के लिए एक नो-ऑप किसी वास्तविक संख्या पर ट्रांसफ़र को परिभाषित करने की तुलना में कम समझ में आता है। मुझे लगता है कि "दंड" सुविधाजनक है, लेकिन ऐसा लगता है कि "उचित" करने के लिए केवल वैक्टर और मैट्रिस के लिए परिभाषित किया गया स्थानान्तरण होगा और transpose(A::Matrix{Complex}) लागू conj के हिस्से के रूप में होगा। इसका निष्पादन।

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

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

transpose([ f(x) for x = 1:length(A) ])
reshape([ f(x) for x = 1:length(A) ], 1, length(A))

यहां तक ​​कि इस तरह के सरल मामलों में आपको लाइन के शुरू होने से ( reshape पढ़ने के लिए) अंत तक उछालने की जरूरत है (यह समझने के लिए कि length(A) पढ़ने के लिए) क्या चल रहा है। (आप तब यह समझने के लिए कि आपका length(A) पहली जगह में है, अपने काम पर वापस लौटने की संभावना है)

मेरे लिए, बड़ी समस्या यह है कि अगर मैं एक नया जूलिया हूं (जिसका अर्थ है कि मैंने पहले भी खस्ता और MATLAB का उपयोग किया है) और मैं देखता हूं कि ये काम हैं:

[ x for x = 1:10 ]'

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

कुल मिलाकर, मैं यह नहीं देखता कि Symbol पर नो-ऑप ट्रांज़िशन को कैसे रखा जाए और अन्य गैर-संख्यात्मक इनपुट यहाँ प्रस्तावित अच्छे गणितीय ढांचे के साथ हस्तक्षेप करते हैं (एक योग्य लक्ष्य!)। लेकिन नो-ऑप रखना हानिरहित लगता है।

लेकिन नो-ऑप रखना हानिरहित लगता है।

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

मुझे यकीन नहीं है कि एक प्रतीक के हस्तांतरण को एक नो-ऑप के रूप में परिभाषित करना किसी वास्तविक संख्या पर स्थानान्तरण को परिभाषित करने की तुलना में कम समझ में आता है। मुझे लगता है कि "दंड" सुविधाजनक है, लेकिन ऐसा लगता है कि "उचित" करने के लिए ऐसा करना होगा कि केवल वैक्टर और मैट्रिस के लिए परिभाषित किया गया है और transpose(A::Matrix{Complex}) लागू conj के हिस्से के रूप में हो। इसका निष्पादन।

मैं पूरी तरह से असहमत नहीं हूं, लेकिन हमें BlockMatrix कुछ प्रकार को लागू करने की आवश्यकता होगी या Matrix{M<:Matrix} लिए विशेष विधियों को परिभाषित करना होगा। मुझे यकीन नहीं है कि या तो एक लोकप्रिय विचार है या नहीं? (यह उन लोगों के लिए एक गंभीर प्रश्न है, जो निम्नलिखित का पालन कर रहे हैं क्योंकि यह इन संबंधित मुद्दों में से कुछ को सरल बना सकता है)।

ईमानदार रहो, जो जल्दी है

transpose([ f(x) for x = 1:length(A) ])
reshape([ f(x) for x = 1:length(A) ], 1, length(A))

दूसरा, क्योंकि मैं वैक्टरों के जूलिया के वर्तमान ट्रांसपोज़न (स्पष्ट रूप से, _I वेक्टर ट्रांसपोज़_ भी _seriously_ :) से संबंधित / पसंद नहीं करता / rowvec = reshape(colvec, (1, n)) लिखता, या शायद बस। [f(x) for _ = 1:1, x = 1:n] को सही आकार बनाने के लिए समझ बनाने के लिए मजबूर करने के लिए, या यदि आप वास्तव में .' तो map(f, (1:n).') और f.((1:n).') वर्तमान में भी काम करते हैं।

यह पूरी तरह से गैर-गणितीय संचालन के लिए रिश्तेदार अजीब वाक्यविन्यास की अनुमति देने और मूक त्रुटियों से बचने की सुविधा के बीच एक व्यापार है

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

हमें कुछ प्रकार के ब्लॉकमैट्रिक्स को लागू करने की आवश्यकता होगी या मैट्रिक्स {एम <: मैट्रिक्स} के लिए विशेष विधियों को परिभाषित करना होगा।

मैं गलत हो सकता हूं, लेकिन मुझे लगता है कि आपको बस दूसरा करने की आवश्यकता होगी, जो मेरे लिए एक उचित विकल्प की तरह लगता है। लेकिन यह मेरे भुगतान से ऊपर उठने लगा है।

[f (x) _ = 1: 1, x = 1: n] के लिए

मैं इस बारे में भूल गया! यह शायद मैं क्या कर रहा हूँ। कुल मिलाकर, मैं अभी भी पठनीय कोड के लिए आपके स्वाद से असहमत हूं, लेकिन प्रत्येक अपने स्वयं के लिए! ¯\_(ツ)_/¯

स्पष्ट रूप से, मैं वेक्टर हस्तांतरण को गंभीरता से लेता हूं

हाँ। मुझे ऐसा लगता है। 😉

यह (https://github.com/JuliaLang/julia/issues/16790) भी reshape transpose मेरे लिए थोड़ा और अधिक स्वादिष्ट।

मैं गलत हो सकता हूं, लेकिन मुझे लगता है कि आपको केवल दूसरा करने की आवश्यकता होगी (संपादित करें: Matrix{M<:Matrix} लिए परिभाषित विशेष स्थानान्तरण विधियां हैं, जो मेरे लिए एक उचित विकल्प की तरह लगता है।

दुर्भाग्य से अब हम फिर से डेटा और रैखिक बीजगणित के बीच के अंतर को फिर से प्राप्त करते हैं। आप चाहते हैं कि रैखिक बीजगणित ब्लॉक मेट्रिक्स में पुनरावर्ती संक्रमण हो लेकिन 2 डी डेटा सरणियों के सामान्य 2 डी डेटा सरणियों में पुनरावर्ती संक्रमण नहीं होना चाहिए ... लेकिन Matrix{T} और Array{T,2} एक ही चीज़ है जो हम नहीं कर सकते हैं वो करें।

यह (# १६pe ९ ०) भी मेरे लिए थोड़ा और अधिक परिवर्तन करने के स्थान पर फेरबदल का उपयोग कर देगा।

सच!!

आप चाहते हैं कि रैखिक बीजगणित ब्लॉक मेट्रिक्स में पुनरावर्ती संक्रमण हो लेकिन 2 जी डेटा सरणियों के सामान्य 2 डी डेटा सरणियों में पुनरावर्ती संक्रमण नहीं होना चाहिए

ऐसा नहीं लगता है कि मैं स्पष्ट रूप से कुछ चाहूंगा ... इन विभिन्न प्रकार के प्रस्तावों से निपटने के लिए सिर्फ दो अलग-अलग कार्य क्यों नहीं हैं? मुझे लगता है कि मैं रैखिक बीजगणित वस्तुओं और डेटा ऑब्जेक्ट्स के बीच एक बहुत सख्त अंतर होने पर ज्ञापन को याद किया।

इस पूरे सूत्र को पढ़ना एक कठिन काम लगता है, लेकिन शायद मुझे आगे टिप्पणी करने से पहले ऐसा करना चाहिए। मैं बिन बुलाए शोर नहीं जोड़ना चाहता।

मुझे लगता है कि मैं रैखिक बीजगणित वस्तुओं और डेटा ऑब्जेक्ट्स के बीच एक बहुत सख्त अंतर होने पर ज्ञापन को याद किया।

रैखिक बीजगणित वस्तुओं और डेटा ऑब्जेक्ट के बीच एक सख्त अंतर नहीं है।
न वर्तमान कार्यान्वयन में, न ही आदर्श उपयोग में।

यदि वहाँ थे, तो आकार को संशोधित करना ( push! ) या रैखिक बीजगणित की वस्तुओं के मूल्यों का भी समर्थन नहीं किया जाएगा (और ऐसे उपयोगकर्ता StaticArrays.jl आदि का उपयोग करेंगे), और broadcast केवल होगा रैखिक बीजगणित वस्तुओं पर समर्थित होना चाहिए।
डेटा ऑब्जेक्ट्स परिवर्तनीय, विस्तार योग्य होंगे, और map , और reduce , और filter लेकिन broadcast ।

लेकिन हम उस दुनिया में नहीं रहते हैं जहां लोग या तो डेटा ऑब्जेक्ट, बनाम रैखिक बीजगणित वस्तुओं के द्विआधारी सोच रहे हैं।
इस प्रकार यह 2.5 वर्ष, 340 टिप्पणी धागा।

no-op स्थानान्तरण करें।
हम जोड़ सकते हैं, बहुत उच्च प्रकार पदानुक्रम एक Scalar और Nonscalar सार प्रकार।
Scalars सभी नो-ऑप्स ट्रांज़ेक में आते हैं।
Nonscalars में कोई गिरावट नहीं हुई है, (लेकिन अभी के लिए एक डिप्रेसेशन चेतावनी पर वापस गिर जाते हैं)

संख्याएँ, वर्ण, स्ट्रिंग्स और शायद यहाँ तक कि टुपल्स Scalar और इसमें कोई-ऑप ट्रांसफ़ेक्ट परिभाषित नहीं होगा। कुछ स्केलर, उदाहरण के लिए कॉम्प्लेक्स नंबर ट्रांसपोज़ की इस परिभाषा को ओवर-राइट करेंगे।

Arrays (मैट्रिक्स, वैक्टर और अन्य) Nonscalar उप-प्रकार होंगे और इसमें पुनरावर्ती हस्तांतरण होगा।

मुझे यकीन नहीं है कि मुझे यह पसंद है, या नहीं।

पोस्ट की हालिया चर्चा ने # 18320 # 13171 # 13157 # 8974 में _मेट्रिक्स ट्रांसपोज़_ और "स्केलर" प्रकारों के बारे में चर्चा को दोहराया।

मैं वास्तव में इस धारणा को दूर करना चाहूंगा कि transpose(x)=x no-op कमबैक हानिरहित है। मेरे दिमाग में, एक कमबैक अभी भी सही परिणाम का उत्पादन करना चाहिए, बस एक अनुकूलित एल्गोरिथ्म से अधिक धीरे-धीरे। यह खतरनाक है जब फ़ॉलबैक विधि चुपचाप गलत उत्तर की गणना करती है, क्योंकि इसका मतलब है कि फ़ॉलबैक का सही शब्दार्थ नहीं है: transpose(x) अर्थ x के प्रकार पर निर्भर करता है।

नो-ऑप ट्रांसपोज़ फ़ॉलबैक न केवल मेट्रिसेस के मेट्रिक्स के लिए गलत है, बल्कि सभी मैट्रिक्स जैसी वस्तुओं के लिए भी गलत है जो AbstractMatrix (जो कि # 987 का मतलब है कि उनके पास स्पष्ट रूप से संग्रहीत प्रविष्टियाँ नहीं हैं, _not_) कि वे मेट्रिसेस का बीजगणित है)। यहाँ एक पोस्टर बच्चे का उदाहरण है (जो हमारे पास काफी कम है):

julia> A = rand(5,5); F = qrfact(A); R = F[:R]; Q = F[:Q] #Q is an example of a matrix-like object
5x5 Base.LinAlg.QRCompactWYQ{Float64,Array{Float64,2}}:
 -0.518817    0.0315127   0.749223    0.410014  -0.0197446
 -0.613422   -0.16763    -0.609716    0.33472   -0.3344   
 -0.0675866   0.686142    0.0724006  -0.302066  -0.654336 
 -0.582362   -0.0570904   0.010695   -0.735632   0.341065 
 -0.104062    0.704881   -0.248103    0.295724   0.585923 

julia> norm(A - Q*R) #Check an identity of the QR factorization
8.576118402884728e-16

julia> norm(Q'A - R) #Q'A is actually an Ac_mul_B in disguise
8.516860792899701e-16

julia> Base.ctranspose(Q::Base.LinAlg.QRCompactWYQ)=Q; #Reintroduce no-op fallback

julia> norm(ctranspose(Q)*A - R) #silently wrong 
4.554067975428161

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

शायद मैं सघन हो रहा हूं, लेकिन मैंने सोचा होगा कि तुलना यह होगी:

julia> A = rand(5,5); F = qrfact(A); R = F[:R]; Q = F[:Q]
julia> Base.ctranspose(Q::Any) = Q;
WARNING: Method definition ctranspose(Any) in module Base at operators.jl:300 overwritten in module Main at REPL[6]:1.
julia> norm(ctranspose(Q)*A - R) # still works fine
4.369698239720409e-16

इस तरह से transpose ओवरराइटिंग करने से लगता है कि transpose([ :x _=1:4 ]) - यानी जो मैंने पोस्ट किया है। मैंने सोचा होगा कि जब तक आप transpose / ctranspose सही ढंग से हर उस चीज़ के लिए लागू करें, जिसकी आवश्यकता है (जैसे QRCompactWYQ ) तो कभी भी कॉलबैक नहीं कहा जाएगा (अधिक विशिष्ट कॉल के बाद से) बनाया जा सकता है)।

आपका कोड आपके द्वारा लिखे गए ctranspose पद्धति को नहीं बुला रहा है (आप @which साथ इसे सत्यापित कर सकते हैं)। यह जूलिया v0.5 (जो कि v0.4 में मौजूद नहीं है) में एक अलग फॉलबैक विधि कह रहा है, जो अनिवार्य रूप से ctranspose(full(Q)) । यह अन्य गिरावट सही है, लेकिन बहुत ही कारण को हराती है क्योंकि हमारे पास यह फैंसी क्यू-प्रकार है (ताकि इसके साथ गुणा करके इसे सटीक रूप से देखा जा सके)। मेरी टिप्पणी है कि कमियां सही होनी चाहिए अभी भी खड़ा है।

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

धन्यवाद @toivoh जिसने इसे मेरे लिए क्लिक किया। मैं वास्तव में स्पष्टीकरण की सराहना करता हूं।

लेकिन यदि आप एक कमबैक transpose(X::AbstractMatrix) और transpose(X::AbstractVector) कार्यों को परिभाषित करते हैं, तो संभवतः आपको हमेशा सही परिणाम मिलेगा (भले ही यह धीमा था ... उदाहरण के लिए full कॉल करना) नहीं? और आप हमेशा इसे बेहतर / तेज़ करने के लिए एक अधिक विशिष्ट फ़ंक्शन लिख सकते हैं। तब transpose(::Any) को कभी भी पहले बताई गई "सज़ा" के अलावा अन्य मौन त्रुटियों का कारण नहीं बनना चाहिए (यानी Complex संख्या को संभालते समय ... शायद अन्य स्केलर उन मामलों का उपयोग करते हैं जिनके बारे में मुझे नहीं पता?)

ऐतिहासिक कारणों के लिए QRCompactWYQ <: AbstractMatrix , लेकिन # 987 # 10064 के अनुसार यह सबटाइपिंग संबंध सही नहीं है और इसे हटा दिया जाना चाहिए।

मैट्रिक्स जैसी गैर-सरणी का एक और उदाहरण IterativeSolvers.AbstractMatrixFcn , जो AbstractMatrix का उप-प्रकार नहीं है। इस प्रकार की कमियों के लिए आप जिस संदर्भ को भेजते हैं उस पर कभी नहीं भेजा जाएगा, जो फिर से मेरा मुख्य बिंदु था।

हमें इस चर्चा को https://github.com/JuliaLang/julia/issues/13171 पर जारी रखना चाहिए

"टीम लीनियर बीजगणित" से किसी को 0.6 के लिए इस बारे में कुछ करने या करने की आवश्यकता है या इसे अभी तक फिर से टक्कर मिलनी है।

तो रिबूट करने के लिए, वास्तविक योजना क्या है?

मेरी सोच की रेखा मुझे यहां लाती है: transpose(v::AbstractVector) = TransposedVector(v) जहां TransposedVector <: AbstractVector । एकमात्र अर्थपूर्ण चीज़ जो TransposedVector को AbstractVector करेगी, यह * (और सभी A_mul_B s, \ तहत कैसे व्यवहार करेगी , / , ...)। यानी यह निर्धारित करने के लिए कि * (आदि ...) के तहत अनुबंध करने के लिए कौन सा सूचक है। ट्रांसपोज़ेशन एक रैखिक बीजगणित अवधारणा होगी और यदि आप "डेटा" की एक सरणी को पुनर्व्यवस्थित करना चाहते हैं, तो reshape और permutedims को प्रोत्साहित किया जाना चाहिए।

केवल शब्दार्थ चीज जो TransposedVector को AbstractVector करेगी, यह * तहत कैसे व्यवहार करेगा

तो v'==v लेकिन v'*v != v*v' ? हालांकि यह समझ में आ सकता है, यह संभावित रूप से भ्रामक भी दिखता है।

तो v'==v लेकिन v'*v != v*v' ? हालांकि यह समझ में आ सकता है, यह संभावित रूप से भ्रामक भी दिखता है।

IMO यह अपरिहार्य है (हालांकि संभवतः दुर्भाग्यपूर्ण है)।

एक वेक्टर का दोहरी भी एक वेक्टर है। संक्रमण अभी भी एक आयामी डेटा संरचना है जिसमें अच्छी तरह से परिभाषित तत्व हैं जो कि, म्यूटेट, मैप, कम आदि को प्राप्त करने में सक्षम होना चाहिए।

जब तक हम सरणियों से रैखिक बीजगणित को अलग नहीं करते हैं (उदाहरण के लिए Matrix{T} दोनों का एक उपप्रकार और Array{T,2} का अपरिवर्तनीय आवरण, अधिक (रैखिक बीजगणित विशिष्ट) तरीकों से परिभाषित), तब वहाँ सुनिश्चित नहीं है। बहुत पसंद है जो अपने सरणी और रैखिक बीजगणित दोनों गुणों के अनुरूप है।

एक भ्रमित करने वाला प्रश्न (मेरे लिए) यह है कि क्या यह एक वेक्टर की तरह प्रसारित होता है, या इसके दूसरे आयाम पर। यदि इसका आकार (1, n) तो यह परिवर्तन वास्तव में एक मैट्रिक्स की तरह अपने हिस्से को शामिल करने के अलावा बहुत कुछ नहीं कर रहा है, जहां पहले आयाम को 1 माना जाता है। Vector{T} स्थान Array{T,2} (अर्थात Matrix ...) रहना होगा, हालाँकि उस का स्थान Vector फिर से हो सकता है ( उदाहरण के लिए हम v'' === v )।

क्या यह एक बेहतर विचार है? यह कम तोड़ने वाला होगा और अभी भी शब्दार्थ विज्ञान के रेखीय बीजगणित में सुधार करेगा। संपादित करें: और यह अलग तरह से == व्यवहार करता है क्योंकि @martinholters लाता है)।

मेरे लिए, TransposedVector{T <: AbstractVector{Tv}} <: AbstractMatrix{Tv} *) size(::TransposedVector, 1)==1 लेकिन transpose(::TransposedVector{T})::T सबसे पवित्र दृष्टिकोण की तरह लगता है, लेकिन इतनी बहस हुई है कि शायद इसके खिलाफ कुछ अच्छा तर्क है?

*) मुझे पता है कि यह वाक्यविन्यास अमान्य है, लेकिन मुझे आशा है कि अभिप्राय शब्दार्थ स्पष्ट हैं।

हां, कोड में विचारों के साथ खेलने पर मुझे लगता है कि मैं आपसे @martinholters से सहमत हूं।

मैंने https://github.com/andyferris/TransposedVectors.jl पर एक शुरुआत की

एक बड़ा सवाल यह है कि क्या हम जटिल संयुग्मन के लिए CTransposedVector प्रकार के बिना रह सकते हैं, या फिर जो संभाला जाएगा।

मैं एक अलग CTransposedVector उपयोग नहीं करूंगा, क्योंकि यह दो अवधारणाओं (संयुग्मन और पुनर्वसन) को एक वस्तु में जोड़ता है। यह उन दो अवधारणाओं को अलग-अलग संस्थाओं के रूप में लागू करने के लिए बहुत अधिक है। उदाहरण के लिए, MappedArays.jl के साथ यह उतना ही आसान है

conjview(A) = mappedarray((conj,conj), A)

और आपको बहुत अच्छा प्रदर्शन मिलेगा।

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

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

@ कैंडीफरिस : मुझे लगता है कि आपका दृष्टिकोण एक अच्छा है - इसे आगे बढ़ाने के लिए धन्यवाद। यदि कार्यान्वयन अच्छी तरह से काम करता है, तो हम बस बेस में उस कोड का उपयोग कर सकते हैं। एक बात का ध्यान रखें कि हम TransposedMatrix के साथ-साथ https://github.com/JuliaLang/julia/issues/5332 भी चाहते हैं

अब जब हमने रूपांतरण जारी रखा है तो मैं फिर से उल्लेख करूंगा कि हमें एक ट्रांसपोज़्ड वेक्टर प्रकार से बचने की कोशिश करनी चाहिए। ऊपर कुछ समय का उल्लेख किया गया है, लेकिन मुझे संदेह है कि कोई भी कभी भी इस मुद्दे की सभी टिप्पणियों के माध्यम से पढ़ सकेगा। वैक्टर के लिए एक संक्रमण प्रकार का परिचय वास्तव में लगभग कोई लाभ के लिए चीजों को जटिल करता है। यदि आप वास्तव में सोचते हैं कि एक वेक्टर के पास एक दिशा है तो इसे मैट्रिक्स बनाएं और चीजें बस काम करेंगी। यह रेखीय बीजगणित वैक्टर है कि matrices से अलग कर रहे हैं और फिर वैक्टर 1xn matrices की तरह व्यवहार करने के लिए एक नया आवरण प्रकार शुरू करने के लिए बहुत मतलब नहीं है।

अभी असममितता यह है कि x' मैट्रिक्स के लिए x को बढ़ावा देता है जबकि A*x मैट्रिक्स के लिए x को बढ़ावा नहीं देता है। यदि रैखिक बीजगणित का संचालन सिर्फ 2 डी के लिए था, तो A*x को बढ़ावा देना चाहिए और x'x 1x1 मैट्रिक्स होगा। वैकल्पिक रूप से, हम वैक्टर को वैक्टर होने दे सकते हैं और इसलिए A*x वेक्टर भी हो सकते हैं, लेकिन फिर x' एक noop या एक एरर होना चाहिए। एक प्रत्यारोपित वेक्टर का परिचय नई पद्धति परिभाषाओं की बहुत आवश्यकता होगी और एकमात्र लाभ यह प्रतीत होता है कि x'x एक स्केलर बन जाता है।

मुझे लगता है कि मैट्रिक्स का स्थानांतरण बहुत अलग है। यह हमें सभी Ax_mul_Bx तरीकों से छुटकारा पाने की अनुमति देगा और व्यवहार उसी तरह से बहस करने योग्य नहीं है जिस तरह से वेक्टर के व्यवहार का व्यवहार है।

मैं वास्तव में यह नहीं देखता कि एक ट्रांसपोज़्डवेक्टर प्रकार का परिचय एक ट्रांसपोज़मेटमैट्रिक्स प्रकार को पेश करने की तुलना में अधिक समस्याओं का कारण बनता है।

हां, इस ऑपस के बीच में कहीं न कहीं मजबूत सहमति यह थी कि वेक्टर ट्रांसजेंडर अजीब है, और यह कि अगर इसे लागू किया जाता है, तो यह निश्चित रूप से AbstractArray का उपप्रकार नहीं होना चाहिए - मैं size भी अस्वीकार कर दूंगा ऊपर दिया गया मेरा conj लेने की सलाह दूंगा बजाय इसे एक प्रकार के रूप में शामिल करने के बजाय पैरामीटर)।

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

वेक्टर ट्रांसपोज़ होने में एक त्रुटि लगती है जैसे बच्चे को स्नान के पानी के साथ बाहर फेंकना। एक वेक्टर को स्थानांतरित करने के लिए v' लिखने में सक्षम नहीं होने के कारण वास्तव में, वास्तव में कष्टप्रद होगा। मैं वास्तव में एक ट्रांसपोज़्डवेक्टर प्रकार के बारे में इतना बुरा नहीं हूं कि यह एक पंक्ति मैट्रिक्स की तरह व्यवहार करता है कि यह कैसे वैक्टर और मैट्रिस के साथ गुणा करता है।

यह निर्भर करता है कि आप वेक्टर व्यवहार के साथ कितने व्यवहारों को संबोधित करना चाहते हैं। यदि आप v'' == v , तो यह typeof(v') <: AbstractMatrix लिए ठीक है। लेकिन अगर आप इस धागे में typeof(v'v) <: Scalar या typeof(v'A) <: AbstractVector बारे में बात की गई अन्य चीजें चाहते हैं, तो यह एक अलग, अधिक जटिल, जानवर होने की आवश्यकता है।

TransposedVector होने का विचार एक तरह का वेक्टर है जो कई समस्याओं की जड़ में लगता है। ऐसा लगता है कि यह एक प्रकार का मैट्रिक्स होने के लिए बहुत कम विघटनकारी होगा और तब size(v.') == (1,length(v)) जैसा हम अभी करते हैं। फर्क सिर्फ इतना होगा कि एक डबल ट्रांज़िशन आपको एक वेक्टर वापस देता है और v'v एक स्केलर का उत्पादन करेगा। यदि कोई वेक्टर के रूप में एक संक्रमण का इलाज करना चाहता है, तो कोई length(v') सही जवाब दे सकता है और रैखिक अनुक्रमण कार्य अपेक्षित रूप से करता है।

मैं @StefanKarpinski के साथ 110% सहमत हूं। मैं इसे एक प्रकार का सदिश बनाने के लिए तैयार था, लेकिन यह बहुत अधिक मायने नहीं रखता है और बल्कि इस प्रकार के कारणों के लिए टूट रहा है, जो पहले इस धागे में चर्चा की गई थी।

इसे बनाने के दृष्टिकोण का आकार (1, n) अर्थ Array संदर्भ में है जैसा कि यह अब करता है। _Only_ संचालन, जो इसे 1-by-N Matrix से अलग करेगा, ' , .' , * , \ तहत व्यवहार है। । और / ।

उन में से कोई भी "सरणी जैसे" ऑपरेटर नहीं हैं। वे पूरी तरह से मैट्रिस और वैक्टर के बीच रैखिक बीजगणित को लागू करने के लिए हैं, और सीधे MATLAB ("मैट्रिक्स प्रयोगशाला") से आते हैं। यह अंतिम शोधन केवल यह कहता है कि size(tvec, 1) = 1 संकलक _and_ के लिए है कि मैं v'' v होना चाहता हूं। (मैं इसे StaticArray तरह एक बिट के रूप में सोचता हूं जहां एक आयाम तय होता है और दूसरा गतिशील रूप से आकार होता है)।

यदि आप बस v '' == v चाहते हैं, तो यह टाइपोफ़ (v ') के लिए ठीक है <: AbstractMatrix।

सही।

लेकिन यदि आप चाहते हैं कि हम इस थ्रेड में टाइप थ्रेड (v'v) के बारे में बात करें: <: स्केलर या टाइपोफ़ (v'A) <: AbstractVector, तो यह एक अलग, अधिक जटिल, जानवर होने की आवश्यकता है।

क्यों? हम इसके किसी भी प्रकार के गुणों को नहीं तोड़ रहे हैं, इसलिए यह अभी भी एक सरणी हो सकता है। कोई भी डॉट-कॉल पहले की तरह ही काम करेगा, और अन्य सदिश ऑप्स निकाले जा रहे हैं। मुझे लगता है कि * Vector और Matrix के विभिन्न आकारों के ज्ञान पर "विशिष्ट" है और यह इसलिए है क्योंकि हम लिखित रैखिक बीजगणित के व्यवहार का अनुकरण करने की कोशिश कर रहे हैं। v' * v स्केलर होना _very_ मानक गणित है और यह मेरी व्याख्या है कि केवल यही कारण है कि यह शुरुआत से ऐसा नहीं है क्योंकि यह सुसंगत तरीके से लागू करने के लिए तुच्छ नहीं है (और प्रेरणा जूलिया से लेती है) MATLAB), लेकिन स्टीफन उस पर स्पष्ट कर सकता है। आंतरिक उत्पाद को एक स्केलर बनाना केवल बोलने का परिवर्तन है (यहां अन्य बहुत छोटी चीजें हैं) - मुझे यह नहीं दिखता कि अकेले यह Array लिए अनुपयुक्त कैसे होगा (कई प्रकार हैं) Array पास मान्य ' , .' , * , \ और / परिभाषित _at all_ , औसत रैंक 3+)

जिन मुद्दों पर मैं पिछले साल भाग गया था उनमें से एक अस्पष्टता थी; IIRC वे बहुत सरल थे जब सदिश संक्रमण एक सरणी नहीं था।

हां, मैं थोड़ा चिंतित हूं कि मैं समाप्त होने से पहले कितना गहरा हो जाऊंगा ... :)

एक सामान्य नोट के रूप में, यह अद्भुत होगा यदि / जब हम Base कम अखंड करें और इसे मानक पुस्तकालयों में शामिल करें। एक स्व-निहित पैकेज या मॉड्यूल होने से जो AbstractArray और Array परिभाषित करता है, इस तरह के विकास को सरल बना देगा।

@ जूथो के प्रस्ताव के साथ वास्तव में क्या समस्या थी? * स्वचालित रूप से (संयुग्मित) बाईं ओर वेक्टर को स्थानांतरित नहीं कर सकता है?

यदि हमारे पास * मैट्रिक्स गुणन है, तो ' मैट्रिक्स (संयुग्मित) ट्रांसपोज़िशन (वैक्टर अपरिवर्तित छोड़ देता है), और दो ऑपरेटर promote जो एक अनुगामी सिंगलटन और demote जोड़ता है *: (n,m) -> (m,) -> (n,) , एक लेफ्ट एप्लीकेशन *: (n,) -> (n,m) -> (m,) , एक स्केलर उत्पाद *: (n,) -> (m,) -> (,) और एक बाहरी उत्पाद ×: (n,) -> (m,) -> (n,m) ऐसा है कि:

(*)(A::AbstractMatrix, v::AbstractVector) = demote(A*promote(v))
(*)(u::AbstractVector, A::AbstractMatrix) = demote((promote(u)'*A)')
(*)(u::AbstractVector, v::AbstractVector) = demote(demote(promote(u)'*promote(v)))
(×)(u::AbstractVector, v::AbstractVector) = promote(u)*promote(v)'

मुझे यकीन नहीं है कि मुझे कभी भी इन ऑपरेटरों के साथ एक वेक्टर को स्थानांतरित करने की आवश्यकता होगी। क्या मैं कुछ भूल रहा हूँ?

संपादित करें: बिल्कुल @Jutho का प्रस्ताव नहीं।

@Armavica , मुझे पूरा यकीन नहीं है कि यह बिल्कुल * अर्थ देने के लिए मेरा प्रस्ताव था, बल्कि एक नए (यूनिकोड) ऑपरेटर ∙ , जो वर्तमान में dot बराबर है promote और demote प्रकार को एक स्थिर तरीके से लागू कर पाएंगे।

मेरे अंदर का शुद्धतावादी @andreasnoack से सहमत है कि एक वेक्टर के स्थानांतरण से बचा जाना चाहिए (मैं व्यक्तिगत रूप से dot(v,w) v'w या v'*w कभी भी लिखना पसंद करता हूं), लेकिन मैं भी सराहना कर सकता हूं यह @ कैंडीफेरिस द्वारा प्रस्तावित तरीके से काम करने का लचीलापन है। इसलिए मैं इस चर्चा के आगे कुछ भी नहीं जोड़ने जा रहा हूं और वास्तविक कार्यान्वयन को चलाने में किसी भी समझदार प्रयास का समर्थन करता हूं।

सही है, @ जूथो। दिलचस्प है कि दोनों परस्पर अनन्य नहीं हैं: डिफ़ॉल्ट रूप से परिभाषित वेक्टर पर कोई स्थानान्तरण नहीं होने का मतलब है कि यह कार्यक्षमता वैध रूप से एक अलग पैकेज, मॉड्यूल, या "मानक पुस्तकालय" (यानी "प्रकार पायरेसी") के बिना रह सकती है।

(मैं व्यक्तिगत तौर पर v'w या v '* w से अधिक डॉट (v, w) लिखना पसंद करता हूं)

जुथो - दूसरी ओर, मैं शर्त लगाता हूं

बेशक, मैं गणित या विज्ञान के सभी में रैखिक बीजगणित के मानक सूत्रीकरण के रूप में, और जूलिया में विस्तार से डायराक के ब्रेकेट नोटेशन को देखना पसंद करूंगा, लेकिन शायद ऐसा होने वाला नहीं है।

अब आप मुझे पचाने के लिए मजबूर करते हैं, जो मैं अब नहीं करने वाला था। मैं निश्चित रूप से पसंद करने के लिए सहमत हूं <ψ | ψ> आंतरिक उत्पाद के लिए, लेकिन यह इस तथ्य से स्वतंत्र है कि मैं <ring के बारे में नहीं सोचता। के रूप में हर्मिटियन संयुग्म | Herm> | ऑपरेटरों के लिए हर्मिटियन संयुग्मन को परिभाषित किया गया है। वैक्टर और उनके संबंधित दोहरी वैक्टर (कोवेक्टर, लीनियर फ़ंक्शंस, ...) के बीच प्राकृतिक समरूपता को रेज़्ज़ प्रतिनिधित्व प्रमेय के रूप में जाना जाता n व्याख्या करते हुए रेखीय मानचित्रों के रूप में। C से C ^ n तक, अर्थात आकार (n,1) मैट्रीस के रूप में।

बेशक, मैं गणित या विज्ञान के सभी में रैखिक बीजगणित के मानक सूत्रीकरण के रूप में, और जूलिया में विस्तार से डायराक के ब्रेकेट नोटेशन को देखना पसंद करूंगा, लेकिन शायद ऐसा होने वाला नहीं है।

जबरदस्त हंसी

अब आप मुझे पचाने के लिए मजबूर करते हैं, जो मैं अब नहीं करने वाला था।

क्षमा करें ... मुझे वास्तव में इसका उल्लेख नहीं करना चाहिए ... :)

मुझे नहीं लगता कि <ψ | के रूप में हर्मिटियन संयुग्म | Herm> | ऑपरेटरों के लिए हर्मिटियन संयुग्मन को परिभाषित किया गया है।

सच है, मैंने ऐसा नहीं माना था।

वैक्टर और उनके संबंधित दोहरी वैक्टर (कोवेक्टर, लीनियर फ़ंक्शंस, ...) के बीच प्राकृतिक समरूपता को रेज़्ज़ प्रतिनिधित्व प्रमेय के रूप में जाना जाता है, हालांकि पूर्व निश्चित रूप से हर्मिटियन संयुग्मन के बराबर है जब सी से सी में रैखिक नक्शे के रूप में लंबाई n डॉक्टर्स की व्याख्या की जाती है। n, अर्थात आकार के मैट्रिक्स के रूप में (एन, 1)।

मैं पीछे हटना नहीं कोशिश कर रहा हूँ (लेकिन मैं उस पर बुरा कर रहा हूँ), लेकिन मुझे लगता है कि क्योंकि हम जोड़ रहे हैं हम यह पिछले बिट का एक सा मिलता है AbstractVector एक -1 डी के साथ Array । दूसरे शब्दों में AbstractVector अर्थ गणितीय अर्थ में "अमूर्त वेक्टर" नहीं है, बल्कि इसका अर्थ है "वेक्टर के संख्यात्मक तत्व कुछ पूर्वनिर्धारित आधार"। MATLAB इससे आसानी से निकल गया क्योंकि वैक्टर आकार (n,1) ।

विचार के लिए भोजन के रूप में, आप (एंटीलीनियर) ऑपरेटर को क्या कहते हैं जो |a>|b><c| सभी टेंसरों को लेता है और उन्हें |c><a|<b| मैप करता है? मैंने इसे हमेशा सदिश दोहरे और मानक ऑपरेटर संयुग्मन के साथ "हरमिंटियन संयुग्मन" के रूप में एक साथ बांधा, लेकिन शायद यह भी बहुत ही दोषपूर्ण है।

@Alanedelman के साथ एक बातचीत

• Covector या RowVector प्रकार पेश करें;
• रैखिक बीजगणितीय परिचालनों के लिए ( * , ' , .' , / , \ , शायद norm ? दूसरों के लिए) ) यह प्रकार रैखिक बीजगणित में एक कोवेक्टर के रूप में कार्य करता है;
• सरणी संचालन के लिए (बाकी सब कुछ) यह प्रकार 2-आयामी 1 × n सरणी के रूप में कार्य करता है;
• विशेष रूप से, size(v') एक covector की है (1, length(v)) ।

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

मुझे थोड़ा चिंता होगी अगर कोवेक्टरों की पहचान के लिए कोई इंटरफ़ेस नहीं था। अधिकांश ऑपरेशन, जैसे आकार और ndims, कहेंगे कि वे अन्य 2d या 1d सरणियों की तरह हैं। केवल एक डॉट उत्पाद के प्रयास से आप एक अंतर देखते हैं। AFAICT आपको यह जाँचना होगा कि क्या वस्तु एक RowVector है, लेकिन एक निश्चित सामान्य संपत्ति रखने के लिए किसी विशिष्ट प्रकार की वस्तु की आवश्यकता होना बहुत दुर्लभ है।

@StefanKarpinski मैं उस सब से सहमत हूं। विशेष रूप से यह कि फ़ंक्शंस "सरणी" ऑपरेशन या "रैखिक बीजगणित" ऑपरेशन हैं।

मैंने एक आकार में एक शुरुआत की = (1, n) TransposedVector यहाँ जो जैसा आप कहें वैसा ही है। मुझे परीक्षणों की अच्छी कवरेज और सभी संयोजन * , \ , / प्रत्येक संभव c और t विधि और उत्परिवर्तन विधियाँ, जबकि आधार में अन्य विधियों के साथ अस्पष्टता से बचती हैं। यह धीमा है लेकिन व्यवस्थित काम है, और इससे मैं इसे तब तक आधार पर खींच सकता हूं जब इसके तैयार (संभवतः चीजों का नामकरण)।

उनका Covector साथ एक अंतर है, जहां यह वास्तव में संयुग्मित परिवर्तन होना चाहिए (या सामान्य मामले में और भी सामान्य परिवर्तन!), जबकि RowVector या TransposedVector वैचारिक रूप से सरल है।

@JeffBezanson "सिंग्लटन " आयाम के लिए indices() साथ हम कुछ कर सकते हैं?

लेकिन एक विशिष्ट सामान्य संपत्ति के लिए किसी विशिष्ट प्रकार की वस्तु की आवश्यकता के लिए यह बहुत दुर्लभ है।

सही है, अगर यह एक विशेषता या कुछ था तो यह अच्छा होगा। मैं उम्मीद कर रहा था कि हम आम तौर पर सरणियों से रैखिक बीजगणित को अलग कर सकते हैं, लेकिन यह एक बहुत बड़ा बदलाव है। और शायद जूलिया में लागू किए गए अच्छे विशेषता सिंटैक्स के बिना साफ नहीं हो सकता है। मुझे लगता है कि यह मुद्दा यह है कि हम 3 चीजों (वैक्टर, कोवेक्टर और मैट्रीस) को दो प्रकारों ( AbstractArray{1} और AbstractArray{2} ) पर मैप कर रहे हैं, और इसलिए उनमें से एक (covectors) एक विशेष उपप्रकार बन गया है दूसरे का।

मैंने पैकेज में AbstractTransposedVector डाल दिया होता अगर मैं ऐसी जगह के लिए सोच सकता था जहाँ किसी को मूल "आवरण" कार्यान्वयन के अलावा किसी और चीज की आवश्यकता होगी।

@JeffBezanson : मुझे आपकी चिंता नहीं है। विचार यह है कि यह रैखिक बीजगणित कार्यों को छोड़कर केवल 1 × n 2d सार सरणी की तरह व्यवहार करता है, जिसके लिए यह स्तंभ वैक्टर के दोहरे स्थान की तरह व्यवहार करता है (जो कि 1 × n 2d सार सरणियों के लिए आइसोमोर्फिक है)। यदि आप एक कोवेक्टर के लिए जांचना चाहते हैं, तो आप उस पर प्रेषण करके प्रकार की जांच कर सकते हैं।

इससे निपटने के मेरे प्रयासों पर एक अपडेट:

TransposedVectors.jl अब है, मेरा मानना ​​है, "सुविधा पूर्ण"। इसमें वह सारी मशीनरी शामिल है जो करने के लिए आवश्यक है @StefanKarpinski ने यहाँ बात की है - एक वेक्टर का संक्रमण एक वेक्टर का आवरण है जो 2-आयामी, 1xn आकार के सार सरणी के रूप में व्यवहार करता है - लेकिन रैखिक बीजगणित संचालन के लिए ( * , / , \ , ' , .' और norm यह एक पंक्ति वेक्टर (या दोहरी वेक्टर) के रूप में व्यवहार करता है।

आप इसे इस तरह से देख सकते हैं:

julia> Pkg.clone("https://github.com/andyferris/TransposedVectors.jl")
...

julia> using TransposedVectors
WARNING: Method definition transpose(AbstractArray{T<:Any, 1}) in module Base at arraymath.jl:416 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/TransposedVector.jl:28.
WARNING: Method definition ctranspose(AbstractArray{#T<:Any, 1}) in module Base at arraymath.jl:417 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/TransposedVector.jl:29.
WARNING: Method definition *(AbstractArray{T<:Any, 1}, AbstractArray{T<:Any, 2}) in module LinAlg at linalg/matmul.jl:86 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/mul.jl:9.
WARNING: Method definition At_mul_B(AbstractArray{#T<:Real, 1}, AbstractArray{#T<:Real, 1}) in module LinAlg at linalg/matmul.jl:74 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/mul.jl:37.
WARNING: Method definition Ac_mul_B(AbstractArray{T<:Any, 1}, AbstractArray{T<:Any, 1}) in module LinAlg at linalg/matmul.jl:73 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/mul.jl:64.

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

julia> vt = v'
1×3 TransposedVectors.TransposedVector{Int64,Array{Int64,1}}:
 1  2  3

julia> vt*v
14

julia> vt*eye(3)
1×3 TransposedVectors.TransposedVector{Float64,Array{Float64,1}}:
 1.0  2.0  3.0

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

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

क्या लोगों को लगता है कि इस तरह के पीआर को ट्रांसपोज्ड मैट्रिसेस के लिए रैपर प्रकार के बिना v0.6 में कोई मतलब होगा? जबकि ट्रांसपोज़्ड वैक्टर एक सिमेंटिक परिवर्तन हैं, ट्रांसपोज़्ड मेट्रिसेस एक अनुकूलन के अधिक हैं, इसलिए मुझे लगता है कि वे अलग से जा सकते हैं। निश्चित रूप से, यह "अजीब" लग सकता है यदि कुछ परिवर्तन विचार हैं और कुछ प्रतियां हैं - राय? विचार करने के लिए एक और बिंदु यह है कि एक बार ट्रांसपोज्ड मैट्रिसेस और वैक्टर दोनों होने के बाद, At_mul_Bt कार्यों को हटाने के लिए बहुत सारे काम करने होंगे, * तरीकों से, को पूरा करने के लिए। संक्रमण (हालांकि सरलीकरण पुरस्कृत होगा!) - मुझे संदेह है कि कोई भी इस के अंत तक वह सब करने में सक्षम या इच्छुक है ...

महान काम, @ कैंडीफेरिस! क्या आपने एक सामान्य आलसी Conjugate रैपर के साथ प्रयोग किया?

@ कैंडीफेरिस मैंने टायरों को लात मारी, और यह काफी पसंद है। सख्ती से एक सुधार लगता है, और मुझे उम्मीद है कि प्रदर्शन के मुद्दों को संभाला जा सकता है क्योंकि हम उन्हें ढूंढते हैं। आइए देखें कि दूसरों को क्या कहना है।

धन्यवाद दोस्तों :)

क्या आपने एक सामान्य आलसी Conjugate रैपर के साथ प्रयोग किया?

अभी तक नहीं, हालांकि यह बहुत अधिक प्रयास के बिना संभव हो सकता है, लेकिन ईमानदार होने के लिए मैं दिसंबर के अंत तक इसे पूरा नहीं करने के बारे में चिंतित था। भविष्य को देखते हुए, मैं इस बात पर विचार कर रहा था कि अंत में हमारे पास रेखीय बीजगणित के लिए प्रेषण के लिए निम्नलिखित "यूनियनॉल" प्रकार हो सकते हैं:

• AbstractVector
• Conjugate{V where V <: AbstractVector} (या Conj{V} , शायद ConjArray बेशक यह किसी भी आयाम के सरणियों को स्वीकार करेगा)
• TransposedVector (या RowVector ?)
• TransposedVector{Conjugate{V where V <: AbstractVector}}
• AbstractMatrix
• Conjugate{M where M <: AbstractMatrix}
• TransposedMatrix (या बस Transpose{M} ?)
• TransposedMatrix{Conjugate{M where M<:AbstractMatrix}}

(इसके अलावा अंतर्निहित भंडारण के सभी दिए गए लक्षण, जैसे कि अब हम DenseArray और StridedArray - क्या उम्मीद कर रहे हैं # 18457 हो सकता है कि ये भी व्यक्त करना थोड़ा आसान हो जाए)।

नामकरण के अलावा, क्या यह एक उचित योजना की तरह लगता है?

तत्काल बिकेशिंग के लिए, पीआर के लिए जो अभी पैकेज में है, के आधार पर, क्या हम TransposedVector , RowVector , दोनों वैक्टर और मैट्रिसेस के लिए एक सामान्य Transpose रैपर पसंद करते हैं। , या कुछ और?

मुझे लगता है कि @andyferris के कार्यान्वयन द्वारा प्रदान किया गया व्यवहार बहुत अच्छा है, और एक सुधार है। लेकिन मुझे अपनी चिंता को थोड़ा बेहतर ढंग से व्यक्त करने की कोशिश करने दीजिए।

समस्या नई सरणी प्रकारों को परिभाषित करने के साथ है। उदाहरण के लिए DArray AbstractArray का उपप्रकार है, इसलिए DArray भी AbstractVector या AbstractMatrix । आदर्श रूप से, हम सिर्फ वेक्टर / मैट्रिक्स भेद को रो / कॉलम / मैट्रिक्स तक बढ़ाएंगे, इसलिए DArray AbstractRow , AbstractCol , या AbstractMatrix । प्रकार पदानुक्रम कुछ इस तरह होगा

AbstractArray
    AbstractVector
        AbstractRowVector
        AbstractColumnVector
    AbstractMatrix
    ...

कल इस बारे में @jiahao के साथ बात कर रहा था।

यहां कुछ पूर्वता हो सकती है, जिसमें सभी AbstractVector s को कॉलम के रूप में उपयोग नहीं किया जा सकता है, जैसे:

julia> isa(1.0:10.0, AbstractVector)
true

julia> randn(10,10) * 1.0:10.0
ERROR: MethodError: no method matching colon(::Array{Float64,2}, ::Float64)

जो मुद्दों को मैं वापस https://github.com/JuliaLang/julia/issues/4774#issuecomment -59428215 में संबोधित कर सकता था

कि सीमा के चारों ओर बस कोष्ठक गायब है?

यह सिर्फ एक मिसाल है:

julia> randn(10,10) * (1.0:10.0)
10-element Array{Float64,1}:
 -22.4311
  ⋮

मैं मानता हूं कि यहां के इष्टतम समाधान के लिए लक्षणों की आवश्यकता प्रतीत होती है, लेकिन मुझे नहीं लगता कि @andyferris का काम रोकना चाहिए।

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

MIT समूह ने बताया कि मेरे द्वारा वर्णित प्रकार पदानुक्रम को लागू करने का एक तरीका सरणी पदानुक्रम में एक प्रकार का पैरामीटर जोड़ना है:

abstract AbstractArray{T,N,row}

type Array{T,N,row} <: AbstractArray{T,N,row}
end

typealias AbstractVector{T} AbstractArray{T,1}
typealias AbstractRowVector{T} AbstractArray{T,1,true}
typealias AbstractColVector{T} AbstractArray{T,1,false}
typealias AbstractMatrix{T} AbstractMatrix{T,2}

typealias Vector{T} Array{T,1,false}
typealias Matrix{T} Array{T,2,false}

मैंने इस के सभी निहितार्थों पर काम नहीं किया है --- शायद इसका सबसे बुरा यह है कि Array{Int,1} एक अमूर्त प्रकार बन जाता है --- लेकिन ऐसा लगता है कि प्रकार पदानुक्रम और आवश्यक अमूर्त बहुत सटीक रूप से सही हैं।

इसके लायक होने के लिए, यह सटीक रूप से पैरामीटर किए गए सुपरपेप्स के लिए उपयोग-मामला है; वे अंतर्निहित डिफ़ॉल्ट पैरामीटर बन सकते हैं।

abstract AbstractArray{T,N,row}

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

isrow{T,N,row}(::AbstractArray{T,N,row}) = row
isrow{T,N}(::AbstractArray{T,N}) = false

julia> isrow(Array{Int,2}())
false

बेशक, यह थोड़ा गड़बड़ कर देता है ... और यह समर्थन के लायक नहीं हो सकता है। यह सिर्फ एक स्पिट-बॉल है।

मेरे लिए जो परिभाषित करने के बराबर लगता है

type Array{T,N} <: AbstractArray{T,N,false}
end

हम यहाँ क्या चाहते हैं, हालांकि कुछ प्रकार के "डिफ़ॉल्ट प्रकार के पैरामीटर" हैं, जैसे कि Array{X,Y} टाइप करना जहां X और Y के पास कोई मुफ्त चर नहीं है वास्तव में Array{X,Y,false} ।

एक अन्य विचार: आंतरिक उत्पादों के लिए हाउसहोल्डर नोटेशन को संरक्षित करें v'v और बाएं कोवेक्टर को v'A infix करके ' अपने स्वयं के ऑपरेटर के बजाय इन v'*v और v'*A पार्स करने के बजाय v' पहचान बनाने के साथ युग्मित, v*v एक त्रुटि, और v*A एक त्रुटि, यह वही दे सकता है जो वांछित है। आपको बाहरी उत्पादों को outer(v,v) रूप में लिखना होगा।

इस तरह की योजना में, v' एक noop या यहां तक ​​कि एक त्रुटि होगी - क्योंकि ऐसी योजना में वेक्टर को स्थानांतरित करने का कोई कारण नहीं है, यह केवल एक मैट्रिक्स के लिए समझ में आएगा।

@JeffBezanson मैं सहमत हूं कि AbstractRowVector सबसे अच्छा होगा (लेकिन मैं ईमानदारी से एक उपयोग के मामले के बारे में नहीं सोच सकता, इसलिए मैंने इसे पैकेज में लागू नहीं किया)। मैं यह भी इंगित करना चाहता हूं कि यह AbstractMatrix उपप्रकार के रूप में रह सकता है। मेरे द्वारा इस दिशा में ले जाने का कारण यह है कि broadcast जूलिया के लिए एक मूल अवधारणा से अधिक प्रतीत होता है कि रैखिक बीजगणित है, और लोग एक पंक्ति वेक्टर होने की उम्मीद करेंगे, ठीक है, एक पंक्ति!

बेशक RowVector <: AbstractMatrix होना शब्दावली का दुर्भाग्यपूर्ण उपयोग है! मुझे लगता है कि 2 डी सरणियों और अमूर्त मेट्रिसेस को एक ही नाम दिए जाने से यह परिणाम होता है।

मैंने पहले भी कहा है, ऊपर से बहुत दूर है, लेकिन चूंकि यह मुद्दा इतना लंबा है, इसलिए मैं इसे आराम करूंगा: जूलिया जैसी सामान्य भाषा में, "डेटा की सरणी" संपत्ति को AbstractArray लिए प्राथमिक विचार होना चाहिए broadcast कैसे चाहते हैं, यह बताता है कि यह 1 डी या 2 डी है। यदि आप पंक्तियों और स्तंभों के संदर्भ में सोचना चाहते हैं, तो 1 x n पंक्ति वैक्टर सबसे अधिक समझ में आता है। यदि आप दोहरी वैक्टर पर विचार करना चाहते हैं, तो 1 डी सबसे अधिक समझ में आता है - और मैं इसके साथ खुश हूं! लेकिन वेक्टर के दोहरे लेना डेटा को फिर से आकार देने की तुलना में अधिक जटिल है (जैसे हमें कम से कम समर्थन संयुग्मन करना है)।

मुझे लगता है कि "पंक्ति" चित्र "विशिष्ट" प्रोग्रामर की अपेक्षाओं से मेल खाता होगा, जबकि उन्नत गणितीय प्रशिक्षण वाले लोग संभवतः दोहरी वैक्टर से बेहतर उपयोग प्राप्त करेंगे क्योंकि यह एक बेहतर अमूर्त है (हालांकि मुझे यकीन है कि वे सक्षम होंगे केवल मूल रैखिक बीजगणित ज्ञान वाले लोगों के साथ सहानुभूति रखना)। तो - कौन से दर्शक जूलिया को निशाना बनाते हैं - कई विशिष्ट MATLAB उपयोगकर्ताओं की तुलना में अधिक गणितीय चालाकी वाले लोग, या कम वाले लोग?

(मेरा कहना था कि जूलिया एक "जेनेरिक" प्रोग्रामिंग भाषा होने का लक्ष्य लेकर चल रही थी, बाद के दर्शकों का लक्ष्य था)।

चूँकि हम संभावित प्रकार के पेड़ों पर चर्चा कर रहे हैं - भविष्य में, Buffer और रहने योग्य "सूचियों" के साथ, मैं एक अमूर्त पेड़ की कल्पना कर रहा हूँ जो दिशाओं की रेखाओं के साथ कुछ जाता है

AbstractArray{T,N} # interface includes broadcast, Cartesian, getindex, setindex!, etc.
    AbstractArray{T,1}
        AbstractList{T} # resizeable, overloaded with `push!` and so-on
        AbstractVector{T} # non-resizeable, overloaded for *, /, \, ', .', etc
    AbstractArray{T,2}
        AbstractRowVector{T} # non-resizeable, overloaded for *, /, \, ', .', etc
        AbstractMatrix{T} # non-resizeable, overloaded for *, /, \, ', .', etc

बेशक, हम समान रूप से AbstractDualVector{T} <: AbstractArray{T,1} बजाय AbstractRowVector ।

इन सभी को फिट करने के लिए एक लचीला, ठोस Array प्रकार होना मुश्किल (और शायद अनावश्यक) होगा। लक्षण निश्चित रूप से समर्थित अंतरों में इन अंतरों को अधिक आसानी से व्यक्त करने देंगे।

AbstractVector होने से C ++ std::vector और एक रेखीय बीजगणित सदिश मेरे लिए थोड़ा नीच लग रहा है :) (विशेषकर सरणी इंटरफ़ेस का अर्थ है कि यह कभी भी "सार सदिश" नहीं हो सकता है) रेखीय बीजगणित बोध (जैसे आधार मुक्त)

हां, आकार बदलने वाले व्यवहार को अलग करना अच्छा होगा। मैं उस पर सवार हूं।

इस प्रकार की पदानुक्रम का अर्थ है कि हम आधार में "मैट्रिक्स" और "2-डी सरणी" ठोस प्रकारों को अलग करेंगे। हम इसके चारों ओर प्राप्त करने की कोशिश कर सकते हैं जैसे Array{T,2} लिए कंस्ट्रक्टर होने से वास्तव में कुछ अन्य मैट्रिक्स प्रकार वापस करते हैं, लेकिन यह बहुत बदसूरत लगता है। शायद मैं गलतफहमी कर रहा हूँ।

इस प्रकार की पदानुक्रम का अर्थ है कि हम आधार में "मैट्रिक्स" और "2-डी सरणी" ठोस प्रकारों को अलग करेंगे।

ठीक है ... मुझे लगता है कि यह अच्छी तरह से करने के लिए, हमें लक्षणों की आवश्यकता होगी। ध्यान रखें मैंने इसे "इंटरफेस का सार पेड़" कहा था। इस समय यह प्रयास करने से आपको कुछ बुरा लगेगा जैसे आपने कहा था। लेकिन हम शायद डाल सकता है AbstractList <: AbstractVector (और ले जाने के जुड़े विधि) में जल्द ही के रूप में Buffer किया जाता है।

फिलहाल समर्थित इंटरफेस और प्रकार के पेड़ के बीच का कनेक्शन बहुत ढीला है। प्रेषण पर यह पता लगाना मुश्किल है कि क्या एक (सार) सरणी उत्परिवर्तनीय है (जैसे setindex! का समर्थन करता है), चाहे वह रहने योग्य हो, तार केवल Base में परिभाषित प्रकारों के लिए काम करता है, आदि। यह इसे बनाता है उपयोगकर्ताओं को काम करने के तरीकों के साथ एक फ़ंक्शन प्रदान करना कठिन है और इनपुट की एक विस्तृत श्रृंखला के साथ कुशल हैं (यह StaticArrays से मेरा अनुभव है)।

प्रकार के पदानुक्रम क्षेत्रों के बारे में बातचीत के लिए एक विचार और मानकीकृत अमूर्तता के लिए उचित भूमिका। जब प्राप्य है, तो जूलिया के लिए यह अच्छी नीति है कि किसी भी अलगाव को कैसे सरल और हल्का बनाया जाए, यह जानने के लिए कि विशेषज्ञता के इरादे से क्या करना है, यह जानने के लिए कोड लिखा जाता है।

एक कन्वेंशन जिसका हम उपयोग कर सकते हैं, वह एक अमूर्त प्रकार का उपयोग करके सामान्य अभ्यास बनाता है, इसके अलावा किसी भी तरह के फैशन के लिए एक ontotopological क्षेत्र के बीच जो सहवर्ती ठोस प्रकार साझा रीपोज़ आसान लगता है। यह बहुत कम लागत पर, अधिक से अधिक बहु-संवेदी संवेदनशीलता लाएगा - प्रकार पदानुक्रम के कुछ भाग को समझने से किसी एक भाग को देखने में मदद मिलती है।

जैसा कि मैंने यह देखा, यह सामान्यीकृत तालमेल लाने वाला है। एक elucidative अमूर्त एक पड़ोस cointendening सम्मिश्रण के रूप में प्रबुद्ध करता है, निर्माण करता है कि उदार alikenesses। अंतर्ज्ञान की सरल स्पष्टता को ले जाने वाले मापदंडों के साथ, जूलिया कम बकवास समय के साथ कई और अधिक पूरा करती है।

ठीक है, TransposedVectors पर किसी भी अधिक टिप्पणी की सराहना की जाएगी। मुझे लगता है कि यह काफी ठोस हो रहा है और पीआर में बदल जाने के लिए तैयार है, लेकिन कुछ प्रासंगिक मुद्दे हैं जो मैंने यहां सूचीबद्ध किए हैं ।

(उदाहरण के लिए: RowVector TransposedVector से बेहतर नाम है? क्या [1 2 3] RowVector या Matrix ? indices(row, 1) क्या है?

रोवेक्टर के लिए +1

20 दिसंबर, 2016 को 7:01 पूर्वाह्न, "एंडी फेरिस" सूचनाएं @github.com ने लिखा:

ठीक है, TransposedVectors पर किसी भी अधिक टिप्पणी की सराहना की जाएगी। मुझे लगता है
यह काफी ठोस हो रहा है और पीआर में बदल जाने के लिए तैयार है, लेकिन हैं
कुछ प्रासंगिक मुद्दे जो मैंने यहां सूचीबद्ध किए हैं
https://github.com/andyferris/TransposedVectors.jl/issues ।

(उदाहरण के लिए: रोवेक्टर ट्रांसपोज़्डवेक्टर से बेहतर नाम है?] [१ २
3] एक रोवेक्टर या एक मैट्रिक्स? सूचकांक (पंक्ति, 1) क्या है?)

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की है।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/4774#issuecomment-2681703232 ,
या धागा म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAm20YYqsXmprI23GgI5PYyWStpTOq5qks5rJ309gaJpZM4BMOXs
।

मैं वास्तव में पंक्ति-स्तंभ / सम्मेलन को इससे बाहर रखना चाहूंगा, और मुझे लगता है कि Vector और RowVector (या यहां तक ​​कि ColVector और RowVector अजीब लगता है TransposedVector या DualVector

@felixrehren मुझे लगता है कि DualVector जो मैंने लागू किया है, उसके लिए एक अलग अर्थ होना चाहिए, मुख्य रूप से 1-आयामी (गणितीय रूप से, एक वेक्टर का दोहरी एक सदिश है) और अन्य द्वंद्व गुण हैं (जैसे जटिल संयुग्मन) । जो ठीक है, लेकिन मुझे इसे लागू करना थोड़ा कठिन और कम पिछड़ा संगत लगा।

नाम TransposedVector ठीक है। लेकिन यह थोड़ा लंबा है। इसके अलावा, यह सुझाव देता है कि केवल Vector ट्रांसपोज़ करके उस प्रकार का ऑब्जेक्ट प्राप्त किया जा सकता है। लेकिन मुझे लगता है कि आप एक मैट्रिक्स की एक पंक्ति को निकालकर, अन्य तरीकों से TransposedVector बना सकते हैं?

मुझे लगता है कि RowVector एक अच्छा नाम होगा - यह संक्षिप्त, सटीक और सहज है। @felixrehren , मुझे लगता है कि पंक्ति / स्तंभ चित्र सहायक है। यह शायद अपरिहार्य भी है, क्योंकि जब भी आप कॉन्टेक्शन या अन्य सामान्य एरे ऑपरेशन (गुणा के अलावा) करते हैं, तो आपको यह सोचने की जरूरत है कि वेक्टर किस तरह से उन्मुख है।

DualVector भी बुरा नहीं है, लेकिन CoVector कम औपचारिक लगेंगे।

मैंने पहले जिस PR को धमकी दी थी वह अब # 19670 पर सबमिट की गई है। मैं अब के लिए RowVector के साथ चला गया।

लेकिन मुझे लगता है कि आप एक मैट्रिक्स की एक पंक्ति को निकालकर, अन्य माध्यमों से भी ट्रांसपोज़्डवेक्टर बना सकते हैं?

यह वास्तव में एक स्टिकिंग पॉइंट है - मैंने अभी तक इसके लिए महान वाक्यविन्यास के बारे में नहीं सोचा है। कोई विचार?

लेकिन मुझे लगता है कि आप एक मैट्रिक्स की एक पंक्ति को निकालकर, अन्य माध्यमों से भी ट्रांसपोज़्डवेक्टर बना सकते हैं?

यह वास्तव में एक स्टिकिंग पॉइंट है - मैंने अभी तक इसके लिए महान वाक्यविन्यास के बारे में नहीं सोचा है। कोई विचार?

जबकि पहली बार में यह matrix[scalar,range] (और अन्य समान निर्माणों) के लिए एक पंक्ति वेक्टर की अपील करता प्रतीत हुआ था, जो कि बहुआयामी सरणियों के लिए वर्तमान अनुक्रमण शब्दार्थों से एक महत्वपूर्ण प्रस्थान होगा, और विशेष मामले मुझे दुखी करते हैं।

इसके बजाय मैं RowVector (और Vector को उस मामले के लिए) देखना चाहता हूं जो किसी भी प्रकार के चलने योग्य प्रकार को वेक्टर के उपयुक्त प्रकार में परिवर्तित कर दे। तब आप RowVector(matrix[scalar,range]) जैसा कुछ कर सकते थे जो काफी स्पष्ट होगा और सरणी अनुक्रमण के वर्तमान व्यवहार को परेशान नहीं करेगा।

अधिकार, i th पंक्ति को वर्तमान में v0.5 में A[i,:].' द्वारा पंक्ति-आकार में निकाला जा सकता है, और भविष्य में भी ऐसा करना जारी रखेगा ( RowVector या Transpose{V<:AbstractVector} या जो भी हम अंततः तय करते हैं (चल रही चर्चा के लिए यहां देखें)। शायद यही जवाब है।

बस आधार में दो नए कार्यों को जोड़ने के बारे में क्या?
row(A,i) और col(A,i)
उत्तरार्द्ध की जरूरत नहीं है, लेकिन सिर्फ समरूपता के लिए। यह संक्षिप्त है, स्पष्ट है, और A[i,:].' रूप में कई वर्ण हैं

@benninkrs जो समझ में आता है। इसके विपरीत मेरी सहज व्याख्या रैखिक बीजगणित एक है, जहां एक वेक्टर का कोई अभिविन्यास नहीं है। इस पर सभी दृष्टिकोण उचित हैं, मुझे सिर्फ Vector और RowVector एक साथ पसंद नहीं है क्योंकि नामकरण ऐसा लगता है जैसे यह एक सार और एक ठोस प्रतिमान मिलाता है।

इस बिंदु पर, मुझे लगता है कि हमें या तो @andyferris के कार्यान्वयन के आधार पर कुछ के साथ जाने की आवश्यकता है या सदिश स्थानान्तरण को गंभीरता से नहीं लेने का निर्णय लेना चाहिए। एक विकल्प के एक उदाहरण के रूप में, यहां एक दृष्टिकोण है जो सबसे बुरे लक्षणों का इलाज करता है: v' जैसा कि वर्तमान में है - यानी एक पंक्ति मैट्रिक्स का उत्पादन - लेकिन a'b पार्स के रूप में

1. v' एक पंक्ति मैट्रिक्स (ctranspose) है
2. v'v एक अदिश (डॉट उत्पाद) है
3. v'*v 1-तत्व वेक्टर (पंक्ति मैट्रिक्स * वेक्टर) है
4. v*v' एक बाहरी उत्पाद मैट्रिक्स (वेक्टर * पंक्ति मैट्रिक्स) है
5. v'A एक पंक्ति मैट्रिक्स ("vecmat") है
6. v'*A एक पंक्ति मैट्रिक्स (मैट) है
7. v'A*v एक अदिश राशि है (matvec A * v फिर डॉट उत्पाद)
8. (v'A)*v 1-तत्व वेक्टर (वीमैकेट फिर मैटवेक) है
9. v'*A*v 1-तत्व वेक्टर (मैटमैट और फिर मैटवेक) है
10. v'' एक कॉलम मैट्रिक्स है (वेक्टर ctranspose, फिर मैट्रिक्स ctranspose)

वर्तमान सेटअप में 2 और 3 समतुल्य हैं और 7, 8 और 9 समतुल्य हैं, जो कि यह परिवर्तन टूट जाता है। लेकिन महत्वपूर्ण रूप से, बोल्ड आइटम वे लोग हैं जो आमतौर पर लोगों के लिए पहुंचते हैं क्योंकि वे समान रूप से सबसे छोटे और सबसे सुविधाजनक होते हैं - और वे सब करते हैं जो हम उन्हें पसंद करेंगे। कोई नया प्रकार नहीं, सिर्फ एक नया इन्फिक्स ऑपरेटर। मुख्य दोष 10 - v'' अभी भी एक कॉलम मैट्रिक्स है। यकीनन, यह एक लाभ के रूप में देखा जा सकता है क्योंकि पोस्टफ़िक्स '' एक वेक्टर को कॉलम मैट्रिक्स में बदलने के लिए ऑपरेटर है।

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

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

1. v' एक सदिश (संयुग्मित) है
2. v'v एक अदिश (डॉट उत्पाद) है
3. v'*v एक त्रुटि है (आंतरिक उत्पाद के लिए v'v की सिफारिश करें और outer(v,v) बाहरी उत्पाद के लिए outer(v,v)
4. v*v' एक त्रुटि है (आंतरिक उत्पाद के लिए v'v की सिफारिश करें और बाहरी उत्पाद के लिए outer(v,v) )
5. v'A एक सदिश राशि है (vecmat)
6. v'*A एक त्रुटि है (अनुशंसित v'A vecmat के लिए)
7. v'A*v एक अदिश राशि है (matvec A * v तो dot उत्पाद)
8. (v'A)*v एक त्रुटि है ( v'v आंतरिक उत्पाद के लिए outer(v,v) और outer(v,v)
9. v'A'v एक अदिश राशि है ( v'(A'v) - संयुक्ताक्षर तो आंतरिक उत्पाद)
10. v'' एक वेक्टर है ( v'' === v और v.' === v )

अब जब मैं इन सभी गुणों को लिखता हूं, तो यह बेहतर विकल्प हो सकता है: सभी त्रुटि मामले वास्तव में लोगों को खोजे गए सिंटैक्स की खोज और उपयोग करने में मदद करने के लिए सेवा करते हैं, और निश्चित रूप से यह वांछनीय v'' === v संपत्ति (और अच्छी तरह से) है .' एक सामान्य आयाम प्रतिवर्ती ऑपरेटर होने के नाते)। केवल समान रूप से भिन्न होने वाले बहुत समान सिंटैक्स होने से संभवतः अधिक भ्रमित होते हैं।

Precise हम संभावित समय पर अधिक सटीक त्रुटियों के लिए पार्स समय पर इन्हें पकड़ सकते हैं, ऐसे मामलों के लिए जहां उपयोगकर्ता कोड ने ' और * ओवरलोड किया है ताकि ये ऑपरेशन काम करें। मेरा मानना ​​है कि इन सिफारिशों को सही बनाने के लिए एक आलसी संयुग्मक आवरण आवश्यक हो सकता है, लेकिन हमें # 5332 के लिए वैसे भी आवश्यकता है।

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

: 100:

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

साथ एक मुद्दा v.' नो-सेशन जा रहा है कि है A .+ v.' के मूल्यों को जोड़ने से अर्थ बदल जाएगा v के प्रत्येक कॉलम को A मानों को जोड़ने के लिए A की पंक्तियों में। यह आमतौर पर वैक्टर के साथ पंक्ति-जैसा ऑपरेशन करना कठिन बना देता है और कोड को गलत तरीके से करने से बचने के लिए निश्चित रूप से एक पूर्ण अपचयन चक्र की आवश्यकता होगी (इस तरह के मामलों में जहां A वर्ग होता है)।

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

मुझे पता है कि v0.6 के लिए समय सीमा लगभग हम पर है, लेकिन मैं स्नान के साथ बच्चे को बाहर फेंकने के खिलाफ चेतावनी दूंगा। इस स्तर पर, ऐसा प्रतीत होता है कि उल्लेखित RowVector मैट्रिक्स मैट्रिक्स और सरणी संयुग्मन के लिए

• IMO, कुछ और अधिक उचित रैखिक बीजगणित प्रकार (हम अब तक दोहरी वैक्टर के अस्तित्व से इनकार नहीं कर रहे हैं, हालांकि एक पंक्ति वेक्टर को कुछ हद तक दोहरे वेक्टर के विशेष मामले के रूप में देखा जा सकता है)
• v'' === v
• स्टीफन की सूची में कुछ चीजें जैसे v1'v2 एक डॉट उत्पाद है
• लगभग पिछड़े संगत सरणी शब्दार्थ - जैसे size(v') का परिणाम अपरिवर्तित है, लेकिन हमारे पास v'' 1-आयामी है
• आलसी कॉन्सल और ट्रांसपोज़ रैपर कुछ परिस्थितियों में प्रदर्शन बढ़ा सकते हैं और वैसे भी उपयोगी हो सकते हैं
• सभी Ac_mul_Bc कार्यों को * और A_mul_B! (और इसी प्रकार \ , / ) के पक्ष में निकालना।

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

दूसरी तरफ - IMHO उन नियमों को थोड़ा उलझा हुआ लगता है और थोड़ा भ्रमित और / या आश्चर्यजनक हो सकता है कि वे ' * (3, 4, 6 और 8) के साथ कैसे काम करेंगे RowVector )।

और हाँ हमें संभावित बग को उजागर करने के लिए v.' या कुछ और घटाना होगा, जिस समय यह लगभग v.' एक लापता विधि त्रुटि बनाने के लिए बेहतर लगता है (हम बस पंक्ति का समर्थन नहीं करेंगे / दोहरी वैक्टर, लेकिन अगर वे चाहें तो ऐसा करने से पैकेज को नहीं रोकेंगे)

19670 या तो तैयार या उसके करीब दिख रहा है, अगर v0.6 में किसी चीज़ को छीनने की भूख है।

बैम

Woot।

क्या यह हमारा सबसे लंबा मुद्दा था?

नहीं, # 11004 अधिक है

माफ़ करना। आप सही हैं, मुझे ओपन इश्यू थ्रेड निर्दिष्ट करना चाहिए।