एक स्रोत कोड या यहां तक कि तीन पते (TAC) कोड के नजरिए से आप इस पृष्ठ पर वास्तव में आसानी से समस्या की कल्पना कर सकते हैं ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
यदि आप एक्सप्रेशन ट्री सेक्शन में जाते हैं, और फिर थोड़ा नीचे पेज करते हैं, तो यह ट्री का "टोपोलॉजिकल सॉर्टिंग" और अभिव्यक्ति का मूल्यांकन करने के लिए एल्गोरिदम को दर्शाता है।
तो उस स्थिति में आप अभिव्यक्ति का मूल्यांकन करने के लिए डीएजी का उपयोग कर सकते हैं, जो मूल्यांकन के बाद से सामान्य रूप से व्याख्यायित है और इस तरह के डीएजी मूल्यांकनकर्ता का उपयोग करने से प्रिंसिपल में सरल इंट्रेप्रेटर बन जाएंगे क्योंकि यह एक स्टैक को धक्का और पॉपिंग नहीं कर रहा है और इसलिए भी कि यह समाप्त हो रहा है। सामान्य उप-अभिव्यक्तियाँ।
गैर-प्राचीन मिस्र (यानी अंग्रेजी) में DAG की गणना करने के लिए बुनियादी एल्गोरिदम यह है:
1) अपने डीएजी ऑब्जेक्ट को ऐसा बनाएं
आपको एक लाइव सूची की आवश्यकता है और यह सूची सभी वर्तमान लाइव DAG नोड्स और DAG उप-अभिव्यक्तियों को रखती है। DAG उप अभिव्यक्ति एक DAG नोड है, या आप इसे आंतरिक नोड भी कह सकते हैं। लाइव डीएजी नोड द्वारा मेरा मतलब है कि यदि आप एक चर एक्स को असाइन करते हैं तो यह लाइव हो जाता है। एक सामान्य उप-अभिव्यक्ति जो तब X का उपयोग करती है वह उदाहरण का उपयोग करती है। यदि X को फिर से सौंपा गया है, तो एक नया DAG NODE बनाया गया है और लाइव सूची में जोड़ा गया है और पुरानी X को हटा दिया गया है, इसलिए अगली उप-अभिव्यक्ति जो X का उपयोग करती है, नए उदाहरण को संदर्भित करेगी और इस प्रकार उप-अभिव्यक्तियों के साथ संघर्ष नहीं करेगी जो केवल एक ही चर नाम का उपयोग करें।
एक बार जब आप एक चर X को असाइन करते हैं, तो सह-संयोग से सभी DAG उप-अभिव्यक्ति नोड्स जो असाइनमेंट के बिंदु पर रहते हैं, लाइव नहीं होते हैं, क्योंकि नया असाइनमेंट पुराने मूल्य का उपयोग करके उप अभिव्यक्तियों के अर्थ को अमान्य करता है।
class Dag {
TList LiveList;
DagNode Root;
}
// In your DagNode you need a way to refer to the original things that
// the DAG is computed from. In this case I just assume an integer index
// into the list of variables and also an integer index for the opertor for
// Nodes that refer to operators. Obviously you can create sub-classes for
// different kinds of Dag Nodes.
class DagNode {
int Variable;
int Operator;// You can also use a class
DagNode Left;
DagNode Right;
DagNodeList Parents;
}
तो आप क्या करते हैं अपने पेड़ से अपने कोड में चलते हैं, जैसे कि उदाहरण के लिए स्रोत कोड में अभिव्यक्ति का एक पेड़। उदाहरण के लिए मौजूदा नोड XNodes को कॉल करें।
इसलिए प्रत्येक XNode के लिए आपको यह तय करने की आवश्यकता है कि इसे DAG में कैसे जोड़ा जाए, और इस बात की संभावना है कि यह पहले से ही DAG में है।
यह बहुत ही सरल छद्म कोड है। संकलन का इरादा नहीं है।
DagNode XNode::GetDagNode(Dag dag) {
if (XNode.IsAssignment) {
// The assignment is a special case. A common sub expression is not
// formed by the assignment since it creates a new value.
// Evaluate the right hand side like normal
XNode.RightXNode.GetDagNode();
// And now take the variable being assigned to out of the current live list
dag.RemoveDagNodeForVariable(XNode.VariableBeingAssigned);
// Also remove all DAG sub expressions using the variable - since the new value
// makes them redundant
dag.RemoveDagExpressionsUsingVariable(XNode.VariableBeingAssigned);
// Then make a new variable in the live list in the dag, so that references to
// the variable later on will see the new dag node instead.
dag.AddDagNodeForVariable(XNode.VariableBeingAssigned);
}
else if (XNode.IsVariable) {
// A variable node has no child nodes, so you can just proces it directly
DagNode n = dag.GetDagNodeForVariable(XNode.Variable));
if (n) XNode.DagNode = n;
else {
XNode.DagNode = dag.CreateDagNodeForVariable(XNode.Variable);
}
return XNode.DagNode;
}
else if (XNode.IsOperator) {
DagNode leftDagNode = XNode.LeftXNode.GetDagNode(dag);
DagNode rightDagNode = XNode.RightXNode.GetDagNode(dag);
// Here you can observe how supplying the operator id and both operands that it
// looks in the Dags live list to check if this expression is already there. If
// it is then it returns it and that is how a common sub-expression is formed.
// This is called an internal node.
XNode.DagNode =
dag.GetOrCreateDagNodeForOperator(XNode.Operator,leftDagNode,RightDagNode) );
return XNode.DagNode;
}
}
तो यह देखने का एक तरीका है। पेड़ का एक मूल चलना और इसमें जाते ही डैग नोड्स को जोड़ना और संदर्भित करना। डाग की जड़ जो भी है DagNode पेड़ की जड़ उदाहरण के लिए वापस आती है।
स्पष्ट रूप से उदाहरण प्रक्रिया को छोटे भागों में तोड़ा जा सकता है या आभासी कार्यों के साथ उप-वर्ग के रूप में बनाया जा सकता है।
दाग को छांटने के लिए, आप प्रत्येक दाईं ओर से दाएं तरफ जाते हैं। दूसरे शब्दों में DagNodes बाएं हाथ के किनारे, और फिर दाहिने हाथ की ओर किनारे का पालन करें। संख्याओं को रिवर्स में सौंपा गया है। दूसरे शब्दों में, जब आप बिना बच्चों के डागनोड पर पहुंचते हैं, तो असाइन करें कि वर्तमान छँटाई संख्या को नोड करें और छँटाई संख्या बढ़ाएँ, ताकि पुनरावृत्ति की संख्या बढ़ती क्रम में असाइन हो जाए।
यह उदाहरण केवल शून्य या दो बच्चों वाले पेड़ों को संभालता है। स्पष्ट रूप से कुछ पेड़ों में दो से अधिक बच्चों के साथ नोड्स हैं इसलिए तर्क अभी भी समान है। बाएं और दाएं गणना करने के बजाय, बाएं से दाएं आदि की गणना करें ...
// Most basic DAG topological ordering example.
void DagNode::OrderDAG(int* counter) {
if (this->AlreadyCounted) return;
// Count from left to right
for x = 0 to this->Children.Count-1
this->Children[x].OrderDag(counter)
// And finally number the DAG Node here after all
// the children have been numbered
this->DAGOrder = *counter;
// Increment the counter so the caller gets a higher number
*counter = *counter + 1;
// Mark as processed so will count again
this->AlreadyCounted = TRUE;
}