सी # डबल [,] सरणी को दोहरी [] में प्रतिलिपि बनाना संभव है [] एक प्रतिलिपि बनाने के बिना

Question

मेरे पास .NET अनुप्रयोग में संख्याओं का विशाल 3 डी सरणी है। मुझे उन्हें एक COM पुस्तकालय में पास करने के लिए उन्हें 1 डी सरणी में परिवर्तित करने की आवश्यकता है। क्या सभी डेटा की एक प्रति बनाये बिना सरणी को बदलने का कोई तरीका है?

मैं इस तरह रूपांतरण कर सकते हैं, लेकिन फिर मैं स्मृति के दो बार राशि जो अपने आवेदन में एक मुद्दा है का उपयोग करें:

double[] result = new double[input.GetLength(0) * input.GetLength(1) * input.GetLength(2)]; 
    for (i = 0; i < input.GetLength(0); i++) 
    for (j = 0; j < input.GetLength(1); j++) 
     for (k = 0; k < input.GetLength(2); k++) 
     result[i * input.GetLength(1) * input.GetLength(2) + j * input.GetLength(2) + k)] = input[i,j,l]; 
    return result; 

Answer 1

मुझे विश्वास नहीं है कि जिस तरह से सी # स्टोर्स मेमोरी में डेटा को सी में एक साधारण कलाकार के रूप में व्यवहार्य बना देगा। क्यों शुरू करने के लिए 1 डी सरणी का उपयोग न करें और शायद इस प्रकार के लिए कक्षा बनाएं ताकि आप इसे अपने प्रोग्राम में एक्सेस कर सकें जैसे कि यह 3 डी सरणी थी?

Answer 2

दुर्भाग्य से, सी # सरणियों की तरह सन्निहित स्मृति में होने की गारंटी नहीं कर रहे हैं वे सी के रूप में करीब-करीब धातु भाषाओं में हैं, तो, नहीं। एक तत्व-दर-तत्व प्रति के बिना डबल [,] से डबल [] को परिवर्तित करने का कोई तरीका नहीं है।

Answer 3

अपनी COM लाइब्रेरी के विवरण जानने के बिना, मैं .NET में एक मुखौटा वर्ग बनाने और यदि आवश्यक हो, तो COM को उजागर करने के लिए देखता हूं।
आपका मुखौटा एक डबल ले जाएगा [,] और एक सूचकांक है जो [] से [,,] तक मैप करेगा।

संपादित करें: मैं टिप्पणियों में किए गए अंकों के बारे में सहमत हूं, लॉरेन सुझाव बेहतर है।

Answer 4

एक वर्कअराउंड के रूप में आप एक वर्ग बना सकते हैं जो सरणी को एक आयामी रूप में रखता है (शायद यहां तक ​​कि नंगे धातु के रूप में भी, ताकि आप इसे आसानी से COM लाइब्रेरी में पास कर सकें?) और उसके बाद इस वर्ग पर अधिभार ऑपरेटर [] इसे अपने सी # कोड में एक बहुआयामी सरणी के रूप में उपयोग करने योग्य बनाने के लिए।

Answer 5

Proxy (डेटारेटर/स्मार्ट-पॉइंटर्स के समान सी ++) के साथ डेटा तक पहुंचने पर विचार करें। दुर्भाग्यवश, सिंटैक्स सी ++ के रूप में उतना साफ नहीं है जितना ऑपरेटर() ओवरलोड और ऑपरेटर के लिए उपलब्ध नहीं है [] एकल-तर्क है, लेकिन अभी भी बंद है।

बेशक, इस अतिरिक्त स्तर का अमूर्तता जटिलता और स्वयं का काम जोड़ती है, लेकिन यह आपको मौजूदा कोड में न्यूनतम परिवर्तन करने की अनुमति देगी जो डबल [,] ऑब्जेक्ट्स का उपयोग करती है, जबकि आप एक डबल का उपयोग करने की अनुमति देते हैं [ ] इंटरऑप और आपके इन-सी # गणना दोनों के लिए सरणी।

class Matrix3 
{ 
    // referece-to-element object 
    public struct Matrix3Elem{ 
     private Matrix3Impl impl; 
     private uint dim0, dim1, dim2; 
     // other constructors 
     Matrix3Elem(Matrix3Impl impl_, uint dim0_, uint dim1_, uint dim2_) { 
      impl = impl_; dim0 = dim0_; dim1 = dim1_; dim2 = dim2_; 
     } 
     public double Value{ 
      get { return impl.GetAt(dim0,dim1,dim2); } 
      set { impl.SetAt(dim0, dim1, dim2, value); } 
     } 
    } 

    // implementation object 
    internal class Matrix3Impl 
    { 
     private double[] data; 
     uint dsize0, dsize1, dsize2; // dimension sizes 
     // .. Resize() 
     public double GetAt(uint dim0, uint dim1, uint dim2) { 
      // .. check bounds 
      return data[ (dim2 * dsize1 + dim1) * dsize0 + dim0 ]; 
     } 
     public void SetAt(uint dim0, uint dim1, uint dim2, double value) { 
      // .. check bounds 
      data[ (dim2 * dsize1 + dim1) * dsize0 + dim0 ] = value; 
     } 
    } 

    private Matrix3Impl impl; 

    public Matrix3Elem Elem(uint dim0, uint dim1, uint dim2){ 
     return new Matrix2Elem(dim0, dim1, dim2); 
    } 
    // .. Resize 
    // .. GetLength0(), GetLength1(), GetLength1() 
} 

और फिर इस प्रकार का उपयोग कर दोनों पढ़ना और लिखना - 'foo [1,2,3]' अब 'के रूप में foo.Elem (1,2,3) .Value', दोनों में लिखा है असाइनमेंट और मूल्य अभिव्यक्ति के बाईं तरफ मूल्यों और लेखन मूल्यों को पढ़ना।

void normalize(Matrix3 m){ 

    double s = 0; 
    for (i = 0; i < input.GetLength0; i++)  
     for (j = 0; j < input.GetLength(1); j++)  
      for (k = 0; k < input.GetLength(2); k++) 
    { 
     s += m.Elem(i,j,k).Value; 
    } 
    for (i = 0; i < input.GetLength0; i++)  
     for (j = 0; j < input.GetLength(1); j++)  
      for (k = 0; k < input.GetLength(2); k++) 
    { 
     m.Elem(i,j,k).Value /= s; 
    } 
} 

फिर, विकास की लागत, लेकिन शेयरों डेटा जोड़ा, ओवरहेड को कॉपी और नकल संबंधित developtment लागत को हटाने। यह एक व्यापार है।