/*********************************************************************/ /// <summary> /// Konstruktor /// </summary> public CTree() { mGraph = new CTreeGraph(); mEdgeList = new List <CTreeEdge>(); mVertexList = new List <CTreeVertex>(); mRoot = addVertex(null); mVertexList.Add(mRoot); }
internal CTreeEdge addEdge(CTreeVertex parent, CTreeVertex child, CAttributeValue attributeValue) { CTreeEdge edge = new CTreeEdge(parent, child, attributeValue); mGraph.AddEdge(edge); mEdgeList.Add(edge); return(edge); }
/*********************************************************************/ /// <summary> /// Erstellt einen Vertex und fügt ihn in den Baum ein. /// </summary> /// <param name="parent">Übergeordneter Knoten im Baum</param> /// <param name="attributeType">Attributtyp nach dem aufgeteilt werden soll</param> /// <returns>Hinzugefügter Vertex</returns> public CTreeVertex addVertex(CTreeVertex parent, CAttributeType attributeType = null) { CTreeVertex vertex = new CTreeVertex(parent, mGraph, attributeType); mVertexList.Add(vertex); mGraph.AddVertex(vertex); if (parent != null) { parent.ChildList.Add(vertex); } return(vertex); }
public double getEntropy(CTreeVertex vertex) { if (vertex.CountObjectsPerClass[CTreeVertex.YES_INDEX] == 0 || vertex.CountObjectsPerClass[CTreeVertex.NO_INDEX] == 0) { return(0); } else { double yesFactor = (double)vertex.CountObjectsPerClass[CTreeVertex.YES_INDEX] / (double)vertex.CountObjects; double noFactor = (double)vertex.CountObjectsPerClass[CTreeVertex.NO_INDEX] / (double)vertex.CountObjects; return(-(yesFactor * Math.Log(yesFactor, 2) + noFactor * Math.Log(noFactor, 2))); } }
private void updateVertexValue(CTreeVertex vertex, Logic.CTableLogic tableLogic) { CEntropyCalculator entropyCalc = new CEntropyCalculator(); vertex.CountObjects = tableLogic.getFilteredTableData(vertex).Count; updateVertexClassCount(vertex, tableLogic); foreach (CTreeVertex child in vertex.ChildList) { updateVertexValue(child, tableLogic); } vertex.Entropy = entropyCalc.getEntropy(vertex); vertex.WeightedEntropy = entropyCalc.getWeightedEntropy(vertex); }
/*********************************************************************/ /// <summary> /// Löscht die Kindelement des übergebenen Vertex und die dazugehörigen /// Verbindungen. /// </summary> /// <param name="vertex">Vertex dessen Kindknoten entfernt werden sollen</param> /// <returns>Erfolg der Operation</returns> public bool removeChildVertices(CTreeVertex vertex) { if (vertex.ChildList.Count > 0) { foreach (CTreeVertex child in vertex.ChildList) { // von dem Kind die Kindelmente löschen removeChildVertices(child); // Die Verbindungzum Parent löschen removeEdge(child.ParentEdge); // und den Kindknoten selbst removeVertex(child); } vertex.ChildList.Clear(); return(true); } // es wurden kein Elemente gelöscht return(false); }
private void updateVertexClassCount(CTreeVertex vertex, Logic.CTableLogic tableLogic) { CTableEntryList entryList = tableLogic.getFilteredTableData(vertex); CAttributeType targetAttribute = getTargetAttribute(tableLogic); int[] counts = new int[2]; counts[CTreeVertex.YES_INDEX] = 0; counts[CTreeVertex.NO_INDEX] = 0; if (targetAttribute != null) { bool bFirst = true; int targetAttributeIndex = 0; foreach (CTableEntry entry in entryList) { if (bFirst == true) { for (int i = 0; i < entry.Size; i++) { if (entry[i].AttributeType.InternalName == targetAttribute.InternalName) { targetAttributeIndex = i; } } bFirst = false; } // TODO Bei Zielattr nicht nur Binär Verzweigen if (entry[targetAttributeIndex].TableValue == "j") { counts[CTreeVertex.YES_INDEX]++; } else if (entry[targetAttributeIndex].TableValue == "n") { counts[CTreeVertex.NO_INDEX]++; } } } vertex.CountObjectsPerClass = counts; }
/*********************************************************************/ /// <summary> /// Setzt den Baum auf den Initalzustand mit einem leeren Root-Knoten /// zurück /// </summary> public void resetTree() { // alle bestehenden Knoten und Verbindungen des Baumes löschen /*foreach (CTreeEdge edge in mEdgeList) * { * mGraph.RemoveEdge(edge); * }*/ mEdgeList.Clear(); /*foreach (CTreeVertex vertex in mVertexList) * { * mGraph.RemoveVertex(vertex); * }*/ mGraph = new CTreeGraph(); mVertexList.Clear(); mRoot = null; mRoot = addVertex(null); }
public double getWeightedEntropy(CTreeVertex vertex) { double sumEntropy = 0.0; // für jedes Kind die Teilentropie berechnen lassen foreach (CTreeVertex child in vertex.ChildList) { double childEntityFactor = (double)child.CountObjects / (double)vertex.CountObjects; double childYesFactor = (double)child.CountObjectsPerClass[CTreeVertex.YES_INDEX] / child.CountObjects; double childNoFactor = (double)child.CountObjectsPerClass[CTreeVertex.NO_INDEX] / child.CountObjects; // sichergehen das wir kein NaN oder sonstiges auf sumEntropy aufaddieren if ((childEntityFactor != 0) && (double.IsNaN(childEntityFactor) == false) && (childYesFactor != 0) && (double.IsNaN(childYesFactor) == false) && (childNoFactor != 0) && (double.IsNaN(childNoFactor) == false)) { sumEntropy += childEntityFactor * (-childYesFactor * Math.Log(childYesFactor, 2) - childNoFactor * Math.Log(childNoFactor, 2)); } } return(sumEntropy); }
/*protected int mNumObjects; * protected int mNumObjectsYes; * protected int mNumObjectsNo; * protected double mEntropy; * * public void setDemoData(string vertexName, int countObjects, int countObjectsYes, int countObjectsNo, double entropy) * { * if (vertexName != "") * { * mAttributeType = new CAttributeType(0); * mAttributeType.Name = vertexName; * } * * mNumObjects = countObjects; * mNumObjectsYes = countObjectsYes; * mNumObjectsNo = countObjectsNo; * mEntropy = entropy; * }*/ #endregion /*********************************************************************/ /// <summary> /// Konstruktor /// </summary> /// <param name="parent">Übergeordneter Knoten im Baum</param> /// <param name="attributeType">Attributtyp nach dem aufgeteilt werden soll</param> public CTreeVertex(CTreeVertex parent, CTreeGraph graph, CAttributeType attributeType = null) { mParentVertex = parent; mGraph = graph; AttributeType = attributeType; }
internal bool removeVertex(CTreeVertex vertex) { mVertexList.Remove(vertex); return(mGraph.RemoveVertex(vertex)); }
/*********************************************************************/ /// <summary> /// Löscht einen Vertex aus dem Graphen. /// !!Dabei werden KEINE Edges gelöscht!! /// </summary> /// <param name="vertex">zu Entfernender Vertex</param> /// <returns>Erfolg der Operation</returns> public bool removeVertex(CTreeVertex vertex) { return(mActiveTree.removeVertex(vertex)); }
/*********************************************************************/ /// <summary> /// Fügt einen Knoten zum Graphen hinzu /// </summary> /// <param name="parent">Parent-Knoten des Knotens</param> /// <param name="type">Typ des Attributes welches der Knoten /// repräsentiert</param> /// <returns>erstellter Vertex</returns> public CTreeVertex addVertex(CTreeVertex parent, CAttributeType type) { return(mActiveTree.addVertex(parent, type)); }
public CTreeEdge addEdge(CTreeVertex parent, CTreeVertex child, CAttributeValue attributeValue) { return(mActiveTree.addEdge(parent, child, attributeValue)); }