एक परिवर्तन पदानुक्रम का प्रतिनिधित्व करने के लिए कुशल संरचना

Question

क्या कोई मैट्रिस के पेड़ का प्रतिनिधित्व करने के लिए एक स्मृति कुशल तरीका सुझा सकता है, उदाहरण के लिए एक पदानुक्रम मॉडल?

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

साथ ही कई जंजीरदार मैट्रिक्स संगणनाएं, इस संरचना को संभवतः स्मृति में एक उचित बिट के चारों ओर कॉपी किया जाएगा, इसलिए सन्निहित भंडारण एक बड़ा बोनस होगा।

Answer 1

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

struct Transform
{
   Matrix m; // whatever you like
   int parent;   // index or offset, you choose!
   int sibling;
   int firstchild;
};

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

struct Transform
{
   Matrix m; // whatever you like
   int parent;  // negative byte offest
   int numchildren;
   int child[0]; // can't remember if you put a 0 there or leave it empty;
                 // but it's an array of positive byte offsets
};

... तो आपको केवल यह सुनिश्चित करने की आवश्यकता है कि आपने क्रमिक ट्रांसफ़ॉर्म को सही जगह पर रखा है।

यहां बताया गया है कि आप एम्बेडेड चाइल्ड "पॉइंटर्स" के साथ पूरी तरह से स्व-निहित पेड़ का निर्माण कैसे करते हैं।

int BuildTransforms(Entity* e, OutputStream& os, int parentLocation)
{
    int currentLocation = os.Tell();

    os.Write(e->localMatrix);
    os.Write(parentLocation);
    int numChildren = e->GetNumChildren();
    os.Write(numChildren);

    int childArray = os.Tell();
    os.Skip(numChildren * sizeof(int));
    os.AlignAsNecessary();  // if you need to align transforms

    childLocation = os.Tell();
    for (int i = 0; i < numChildren; ++i) {
        os.Seek(childArray + (i * sizeof(int)));
        os.Write(childLocation);
        os.Seek(childLocation);
        childLocation = BuildTransforms(e->GetChild(i), os, currentLocation);
    }

    return os.Tell();
}

void BuildTransforms(Entity* root)
{
    OutputStream os;
    BuildTransforms(root, os, -1, 0);
}

(यदि आप रिश्तेदार स्थानों को संग्रहीत करना चाहते हैं, तो बस - currentLocationदो "स्थान" लिखने के लिए जोड़ें।)

Comments

यदि हम C ++ की बात कर रहे हैं, तो आपको अपने बच्चे के सरणी के लिए एक आकार निर्दिष्ट करना होगा या इसे मेमोरी आवंटन के साथ रनटाइम पर बनाना होगा।

— तेनपैन

आधिकारिक C99- अनुमोदित तरीका सरणी आकार विनिर्देश को खाली छोड़ना है।

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

— डैश -टोम-बैंग

इसे "स्ट्रक्चर हैक" कहा जाता है। इन्हें भी देखें: Informit.com/guides/content.aspx?g=cplusplus&seqNum=288

— Neverender

@ एंटन Aka चर-लंबाई संरचना। उचित रूप से प्रयुक्त वे ढेर आवंटन की संख्या को आधा कर सकते हैं।

Answer 2

मैट्रिस की सरणी में अनुक्रमण संभवत: सबसे सीधा आगे, स्मृति कुशल दृष्टिकोण होगा।

परिवर्तनों की एक श्रृंखला LIFO में पॉइंटर्स या पूर्णांकों या अन्य छोटी संरचना की श्रृंखला के रूप में आयोजित की जा सकती है जो मैट्रिक्स सरणी में अनुक्रमित होती है। यह अतिक्रमण को रोकने में मदद करेगा और डेटा एक्सेस कोड से डेटा स्टोरेज कोड को अलग करेगा।

अंततः आप LIFO से अपनी ट्रांसफ़ॉर्म चेन को स्टोर या प्ले करने के लिए बस पुश और पॉप इंडेक्स वैल्यूज़ को बढ़ाएँगे।

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