मैं एक संगत 2 डी सरणी को स्टोर/हेरफेर करने के लिए std :: valarray का उपयोग कैसे कर सकता हूं?

Question

मैं 2 डी सरणी को स्टोर/हेरफेर करने के लिए std::valarray का उपयोग कैसे कर सकता हूं?

मैं पंक्ति/कॉलम इंडेक्स द्वारा उपयोग किए गए तत्वों के साथ 2 डी सरणी का एक उदाहरण देखना चाहता हूं। इस छद्म कोड की तरह कुछ:

matrix(i,j) = 42; 

इस तरह के एक सरणी को प्रारंभ करने का एक उदाहरण भी अच्छा होगा।

मुझे पहले से ही Boost.MultiArray, Boost.uBlas, और ब्लिट्ज ++ के बारे में पता है।

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

Answer 1

मेरे सिर के ऊपर बंद:

template <class element_type> 
class matrix 
{ 
public: 
    matrix(size_t width, size_t height): m_stride(width), m_height(height), m_storage(width*height) { } 

    element_type &operator()(size_t row, size_t column) 
    { 
     // column major 
     return m_storage[std::slice(column, m_height, m_stride)][row]; 

     // row major 
     return m_storage[std::slice(row, m_stride, m_height)][column]; 
    } 

private: 
    std::valarray<element_type> m_storage; 
    size_t m_stride; 
    size_t m_height; 
}; 

std::valarray तत्वों का उपयोग करने के कई दिलचस्प तरीके स्लाइस, मास्क, multidimentional स्लाइस, या एक अविवेक तालिका के माध्यम से प्रदान करता है। अधिक जानकारी के लिए std::slice_array, std::gslice_array, std::mask_array, और std::indirect_array देखें।

Answer 2

Here's एक उदाहरण है कि valarray पर मैट्रिक्स हेरफेर

Answer 3

#include <iostream> 
#include <valarray> 

using namespace std; 

typedef valarray<valarray<int> > va2d; 

int main() 
{ 
    int data[][3] = { {1, 2, 3}, {4, 5, 6} }; 
    va2d mat(valarray<int>(3), 2); 
    for (int i = 0; i < 2; ++i) 
    { 
     for (int j = 0; j < 3; ++j) 
      mat[ i ][ j ] = data[ i ][ j ]; 
    } 
    for (int i = 0; i < 2; ++i) 
     for (int j = 0; j < 3; ++j) 
      cout << mat[ i ][ j ] << endl; 
} 

अधिक का एक सा शामिल हैं:

• यह संख्यात्मक गणना के लिए अनुकूलित है।
• यह vector स्लाइसिंग और डाइसिंग के लिए विशेष सदस्य कार्यों वाले कंटेनर की तरह है।
• नहीं iterators
• वेक्टर मशीन के लिए बनाया गया है और मौजूदा लोगों पर खराब प्रदर्शन: vector पहुँच तेजी
• सभी compilers द्वारा समर्थित नहीं था (प्रलेखन जाँच)/खराब कार्यान्वित
• प्रकार के लिए 26.1 देखें हो सकता है कि उदाहरण के लिए:: करने के लिए valarray<T> एक पैरामीटर के रूप में इस्तेमाल किया जा सकता है valarray की

3 इसके अलावा, कई सदस्य और संबंधित कार्यों हो सकता है सफलतापूर्वक तत्काल और अच्छी तरह से परिभाषित व्यवहार प्रदर्शित करेगा अगर केवल तभी टीप्रत्येक ऐसे सदस्य या संबंधित फ़ंक्शन के लिए निर्दिष्ट अतिरिक्त आवश्यकताओं को पूरा करता है।

4 [ उदाहरण: यह valarray का दृष्टांत को मान्य है, लेकिन ऑपरेटर>() सफलतापूर्वक valarray ऑपरेंड के लिए instantiated नहीं किया जाएगा, के बाद से जटिल किसी भी आदेश देने ऑपरेटरों जरूरत नहीं है। उदाहरण के लिए]

संपादित करें # 2: मानक गुरुत्वाकर्षण vector, सरणी की तरह, हमेशा संयम स्मृति का उपयोग करते हैं। इसके अलावा, हम है:

26.5.2 कक्षा टेम्पलेट valarray

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

और आगे:

26.5.2.3 valarray तत्व पहुंच

4 इसी तरह, अभिव्यक्ति & एक [i] = & बी [जे] के रूप में सच किसी के लिए मूल्यांकन करता है! दो सरणी ए और बी और किसी भी आकार_टी के लिए और size_t j जैसे कि मैं से कम है और जे की लंबाई ली से कम है बी के एनजीएच यह संपत्ति को एलियासिंग की अनुपस्थिति इंगित करती है और कंप्यूटर्स को अनुकूलित करके लाभ के लिए का उपयोग किया जा सकता है।

Answer 4

यदि आप बहुआयामी सरणी के लिए एक संगत (कॉलम एक्स पंक्तियां) ब्लॉक होने के लिए परीक्षण करना चाहते हैं। आप इस उदाहरण को वैलारे के साथ देख सकते हैं।

template<class T> 
class Array: public std::valarray<T> { 
    size_t row,col; 
public: 
    Array(){} 
    Array(size_t nx) : std::valarray<T>(nx){row=nx,col=1;} 
    Array(size_t nx, size_t ny) : std::valarray<T>(nx*ny){row=nx,col=ny;} 
    virtual ~Array(){} 
    T& operator()(size_t i,size_t j) { return (*this)[i*col+j];} 
    size_t Size(size_t n) const { return (n<2) ? col: row;} 
};