Bir kaynak kodu veya hatta üç adres (TAC) kodu perspektifinden, sorunu bu sayfada gerçekten kolayca görselleştirebilirsiniz ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
İfade ağacı bölümüne gidip biraz aşağıya giderseniz, ağacın "topolojik sıralaması" ve ifadenin nasıl değerlendirileceğine ilişkin algoritma gösterilir.
Bu durumda, DAG'yi ifadeleri değerlendirmek için kullanabilirsiniz, çünkü değerlendirme normal olarak yorumlanır ve böyle bir DAG değerlendiricisi kullanmak, temelde basit yorumlayıcıları daha hızlı hale getirir çünkü bir yığına itip fırlatmaz ve aynı zamanda ortadan kaldırır. ortak alt ifadeler.
Antik Mısır dilinde olmayan (yani İngilizce) DAG'yi hesaplamak için temel algoritma şudur:
1) DAG nesnenizi böyle yapın
Canlı bir listeye ihtiyacınız vardır ve bu liste tüm mevcut canlı DAG düğümlerini ve DAG alt ifadelerini içerir. DAG alt ifadesi bir DAG Düğümüdür veya buna dahili düğüm de diyebilirsiniz. Canlı DAG Düğümü ile kastettiğim, bir X değişkenine atarsanız o zaman canlı hale gelir. Daha sonra X'i kullanan yaygın bir alt ifade bu örneği kullanır. X'e tekrar atanırsa, YENİ DAG DÜĞÜMÜ oluşturulur ve canlı listeye eklenir ve eski X kaldırılır, böylece X kullanan bir sonraki alt ifade yeni örneğe atıfta bulunacak ve bu nedenle alt ifadelerle çakışmayacaktır. sadece aynı değişken adını kullanın.
Bir X değişkenine atadığınızda, yeni atama eski değeri kullanan alt ifadelerin anlamını geçersiz kıldığından, tesadüfen atama noktasında canlı olan tüm DAG alt ifade düğümleri canlı kalmaz.
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;
}
Öyleyse yaptığınız şey, örneğin kaynak koddaki bir ifade ağacı gibi kendi kodunuzla ağacınızda dolaşmaktır. Örneğin mevcut düğümleri XNodes olarak adlandırın.
Bu nedenle, her XNode için, onu DAG'ye nasıl ekleyeceğinize karar vermeniz gerekir ve zaten DAG'de olma olasılığı vardır.
Bu çok basit sözde koddur. Derleme amaçlı değildir.
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;
}
}
Yani bu ona bakmanın bir yolu. Ağacın basit bir yürüyüşü ve sadece Dag düğümlerine ekleme yapmak ve ilerlerken bunlara atıfta bulunmak. Örneğin dag'ın kökü, ağacın kökünün döndürdüğü DagNode'dur.
Açıktır ki, örnek prosedür daha küçük parçalara bölünebilir veya sanal işlevlerle alt sınıflar olarak yapılabilir.
Dag'ı tasnif etmeye gelince, her DagNode'dan soldan sağa geçersiniz. Başka bir deyişle, DagNodes sol kenarını ve ardından sağ taraftaki kenarı izleyin. Numaralar ters olarak atanır. Başka bir deyişle, alt öğesi olmayan bir DagNode'a ulaştığınızda, bu Düğüme geçerli sıralama numarasını atayın ve sıralama numarasını artırın, böylece özyineleme sayıların artan sırada atanmasını çözer.
Bu örnek, yalnızca sıfır veya iki çocuğu olan düğümleri olan ağaçları ele almaktadır. Açıkçası bazı ağaçların ikiden fazla çocuğu olan düğümleri var, bu yüzden mantık hala aynı. Sola ve sağa hesaplamak yerine soldan sağa vb. Hesaplayın.
// 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;
}