forked from IF-LK-2020/entscheidungsbaum
Initial commit
This commit is contained in:
commit
ce5d70b3a8
|
|
@ -0,0 +1,26 @@
|
|||
# ---> Java
|
||||
# Compiled class file
|
||||
*.class
|
||||
|
||||
# Log file
|
||||
*.log
|
||||
|
||||
# BlueJ files
|
||||
*.ctxt
|
||||
Dokumente*
|
||||
|
||||
# Mobile Tools for Java (J2ME)
|
||||
.mtj.tmp/
|
||||
|
||||
# Package Files #
|
||||
*.jar
|
||||
*.war
|
||||
*.nar
|
||||
*.ear
|
||||
*.zip
|
||||
*.tar.gz
|
||||
*.rar
|
||||
|
||||
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
|
||||
hs_err_pid*
|
||||
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
/**
|
||||
* <p>
|
||||
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
|
||||
* </p>
|
||||
* <p>
|
||||
* Generische Klasse BinaryTree<ContentType>
|
||||
* </p>
|
||||
* <p>
|
||||
* Mithilfe der generischen Klasse BinaryTree koennen beliebig viele
|
||||
* Inhaltsobjekte vom Typ ContentType in einem Binaerbaum verwaltet werden. Ein
|
||||
* Objekt der Klasse stellt entweder einen leeren Baum dar oder verwaltet ein
|
||||
* Inhaltsobjekt sowie einen linken und einen rechten Teilbaum, die ebenfalls
|
||||
* Objekte der generischen Klasse BinaryTree sind.
|
||||
* </p>
|
||||
*
|
||||
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
|
||||
* @version Generisch_03 2014-03-01
|
||||
*/
|
||||
public class BinaryTree<ContentType> {
|
||||
|
||||
/* --------- Anfang der privaten inneren Klasse -------------- */
|
||||
|
||||
/**
|
||||
* Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum
|
||||
* null ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
|
||||
* nicht-null-Teilbaeume, ggf. leere Teilbaeume hat.
|
||||
*/
|
||||
private class BTNode<CT> {
|
||||
|
||||
private CT content;
|
||||
private BinaryTree<CT> left, right;
|
||||
|
||||
public BTNode(CT pContent) {
|
||||
// Der Knoten hat einen linken und einen rechten Teilbaum, die
|
||||
// beide von null verschieden sind. Also hat ein Blatt immer zwei
|
||||
// leere Teilbaeume unter sich.
|
||||
this.content = pContent;
|
||||
left = new BinaryTree<CT>();
|
||||
right = new BinaryTree<CT>();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* ----------- Ende der privaten inneren Klasse -------------- */
|
||||
|
||||
private BTNode<ContentType> node;
|
||||
|
||||
/**
|
||||
* Nach dem Aufruf des Konstruktors existiert ein leerer Binaerbaum.
|
||||
*/
|
||||
public BinaryTree() {
|
||||
this.node = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn der Parameter pContent ungleich null ist, existiert nach dem Aufruf
|
||||
* des Konstruktors der Binaerbaum und hat pContent als Inhaltsobjekt und
|
||||
* zwei leere Teilbaeume. Falls der Parameter null ist, wird ein leerer
|
||||
* Binaerbaum erzeugt.
|
||||
*
|
||||
* @param pContent
|
||||
* das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
|
||||
*/
|
||||
public BinaryTree(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
this.node = new BTNode<ContentType>(pContent);
|
||||
} else {
|
||||
this.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn der Parameter pContent ungleich null ist, wird ein Binaerbaum mit
|
||||
* pContent als Inhalt und den beiden Teilbaeume pLeftTree und pRightTree
|
||||
* erzeugt. Sind pLeftTree oder pRightTree gleich null, wird der
|
||||
* entsprechende Teilbaum als leerer Binaerbaum eingefuegt. So kann es also
|
||||
* nie passieren, dass linke oder rechte Teilbaeume null sind. Wenn der
|
||||
* Parameter pContent gleich null ist, wird ein leerer Binaerbaum erzeugt.
|
||||
*
|
||||
* @param pContent
|
||||
* das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
|
||||
* @param pLeftTree
|
||||
* der linke Teilbaum vom Typ BinaryTree<ContentType>
|
||||
* @param pRightTree
|
||||
* der rechte Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public BinaryTree(ContentType pContent, BinaryTree<ContentType> pLeftTree, BinaryTree<ContentType> pRightTree) {
|
||||
if (pContent != null) {
|
||||
this.node = new BTNode<ContentType>(pContent);
|
||||
if (pLeftTree != null) {
|
||||
this.node.left = pLeftTree;
|
||||
} else {
|
||||
this.node.left = new BinaryTree<ContentType>();
|
||||
}
|
||||
if (pRightTree != null) {
|
||||
this.node.right = pRightTree;
|
||||
} else {
|
||||
this.node.right = new BinaryTree<ContentType>();
|
||||
}
|
||||
} else {
|
||||
// Da der Inhalt null ist, wird ein leerer BinarySearchTree erzeugt.
|
||||
this.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den Wahrheitswert true, wenn der Binaerbaum leer
|
||||
* ist, sonst liefert sie den Wert false.
|
||||
*
|
||||
* @return true, wenn der Binaerbaum leer ist, sonst false
|
||||
*/
|
||||
public boolean isEmpty() {
|
||||
return this.node == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn pContent null ist, geschieht nichts. <br />
|
||||
* Ansonsten: Wenn der Binaerbaum leer ist, wird der Parameter pContent als
|
||||
* Inhaltsobjekt sowie ein leerer linker und rechter Teilbaum eingefuegt.
|
||||
* Ist der Binaerbaum nicht leer, wird das Inhaltsobjekt durch pContent
|
||||
* ersetzt. Die Teilbaeume werden nicht geaendert.
|
||||
*
|
||||
* @param pContent
|
||||
* neues Inhaltsobjekt vom Typ ContentType
|
||||
*/
|
||||
public void setContent(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
if (this.isEmpty()) {
|
||||
node = new BTNode<ContentType>(pContent);
|
||||
this.node.left = new BinaryTree<ContentType>();
|
||||
this.node.right = new BinaryTree<ContentType>();
|
||||
}
|
||||
this.node.content = pContent;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert das Inhaltsobjekt des Binaerbaums. Wenn der
|
||||
* Binaerbaum leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return das Inhaltsobjekt der Wurzel vom Typ ContentType bzw. null, wenn
|
||||
* der Binaerbaum leer ist
|
||||
*/
|
||||
public ContentType getContent() {
|
||||
if (this.isEmpty()) {
|
||||
return null;
|
||||
} else {
|
||||
return this.node.content;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer
|
||||
* ist, wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
|
||||
* uebergebenen BinaryTree als linken Teilbaum.
|
||||
*
|
||||
* @param pTree
|
||||
* neuer linker Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public void setLeftTree(BinaryTree<ContentType> pTree) {
|
||||
if (!this.isEmpty() && pTree != null) {
|
||||
this.node.left = pTree;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer
|
||||
* ist, wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
|
||||
* uebergebenen BinaryTree als rechten Teilbaum.
|
||||
*
|
||||
* @param pTree
|
||||
* neuer linker Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public void setRightTree(BinaryTree<ContentType> pTree) {
|
||||
if (!this.isEmpty() && pTree != null) {
|
||||
this.node.right = pTree;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den linken Teilbaum des Binaerbaumes. Wenn der
|
||||
* Binaerbaum leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return linker Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn
|
||||
* der aktuelle Binaerbaum leer ist
|
||||
*/
|
||||
public BinaryTree<ContentType> getLeftTree() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.node.left;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den rechten Teilbaum des Binaerbaumes. Wenn der
|
||||
* Binaerbaum (this) leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return rechter Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn
|
||||
* der aktuelle Binaerbaum (this) leer ist
|
||||
*/
|
||||
public BinaryTree<ContentType> getRightTree() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.node.right;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
/**
|
||||
* Blattknoten eines Entscheidungsbaums. Klassifiziert einen Datensatz,
|
||||
* nachdem alle Entscheidungen des Pfades getroffen wurden.
|
||||
*/
|
||||
public class Classification extends DecisionNode {
|
||||
|
||||
// Die Klassifikation als String
|
||||
private String classification;
|
||||
|
||||
/**
|
||||
* Erstellt eine Klassifikation
|
||||
*
|
||||
* @param pClassification Name der Klasse (z.B. "Ja" oder "Nein")
|
||||
*/
|
||||
public Classification( String pClassification ) {
|
||||
classification = pClassification;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String decide( Dataset pDataset ) {
|
||||
return classification;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/**
|
||||
* Ein Datensatz, der vom {@link DecisionTreeBuilder} im Entscheidungsbaum
|
||||
* klassifiziert werden kann.
|
||||
* <p>
|
||||
* Basiert auf einer {@link java.util.HashMap}.
|
||||
*/
|
||||
public class Dataset {
|
||||
|
||||
// Speicher für die Daten
|
||||
private java.util.HashMap<String, String> data;
|
||||
|
||||
/**
|
||||
* Erzeugt einen leeren Datensatz
|
||||
*/
|
||||
public Dataset() {
|
||||
data = new java.util.HashMap<String, String>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gibt den Wert für ein Attribut in diesem Datensatz zurück oder
|
||||
* <code>null</code>, wenn das Attribut im Datensatz nicht existiert.
|
||||
*
|
||||
* @param pAttribute Name des Attributs.
|
||||
* @return Wert im Datensatz oder <code>null</code>.
|
||||
*/
|
||||
public String get( String pAttribute ) {
|
||||
return data.getOrDefault(pAttribute, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Setzt den Wert eines Attributs in diesem Datensatz.
|
||||
*
|
||||
* @param pAttribute Name des Attributs.
|
||||
* @param pValue Neuer Wert des Attributs.
|
||||
*/
|
||||
public void set( String pAttribute, String pValue ) {
|
||||
data.put(pAttribute, pValue);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
/**
|
||||
* Innerer Knoten eines Entscheidungsbaums. Entscheidet basierend auf
|
||||
* dem Wert eines Attributs eines {@link Dataset Datensatzes}, ob im linken oder
|
||||
* rechten Teilbaum weitergesucht werden muss.
|
||||
* <p>
|
||||
* Da es sich um <em>binäre Entscheidungen</em> handelt wird immer nur der Wert
|
||||
* für den linken Teilbaum angegeben und für alle anderen Werte der rechte
|
||||
* Teilbaum gewählt.
|
||||
* </p>
|
||||
*/
|
||||
public class Decision extends DecisionNode {
|
||||
|
||||
// Name des Attributs
|
||||
private String attribute;
|
||||
|
||||
// Wert, bei dem links weitergesucht werden soll
|
||||
private String valueLeft;
|
||||
|
||||
/**
|
||||
* Erstellt eine binäre Entscheidung.
|
||||
*
|
||||
* @param pAttribute Name des Attributs.
|
||||
* @param pValueLeft Wert, wann im linken Teilbaum weitergesucht werden muss.
|
||||
*/
|
||||
public Decision( String pAttribute, String pValueLeft ) {
|
||||
attribute = pAttribute;
|
||||
valueLeft = pValueLeft;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String decide( Dataset pDataset ) {
|
||||
if( pDataset.get(attribute).equals(valueLeft) ) {
|
||||
return "left";
|
||||
} else {
|
||||
return "right";
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
/**
|
||||
* Ein Knoten im Entscheidungsbaum. Knoten sind entweder {@link Decision Entscheidungen}
|
||||
* (innere Knoten) oder {@link Classification Klassifikationen} (Blattknoten).
|
||||
*/
|
||||
public abstract class DecisionNode {
|
||||
|
||||
/**
|
||||
* Führt den Test der Entscheidung durch. Die Methode
|
||||
* bekommt den Datensatz als Parameter und gibt einen
|
||||
* von drei Strings zurück:
|
||||
* <ol>
|
||||
* <li>"left": Folge dem linken Teilbaum</li>
|
||||
* <li>"right": Folge dem rechten Teilbaum</li>
|
||||
* <li>Die finale Klassifikation, wenn dies ein Blatt des Baumes ist (z.B. "yes" oder "no")</li>
|
||||
* </ol>
|
||||
*/
|
||||
public abstract String decide( Dataset pDataset );
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
/**
|
||||
* Enthält einen Entscheidungsbaum und kann {@link Dataset Datensätze} damit
|
||||
* klassifizieren.
|
||||
*/
|
||||
public class DecisionTreeBuilder {
|
||||
|
||||
// Wurzel des Entscheidungsbaums
|
||||
private BinaryTree<DecisionNode> decisionTree;
|
||||
|
||||
public DecisionTreeBuilder() {
|
||||
// Vorbereiten der Klassifikationen (Blätter)
|
||||
BinaryTree<DecisionNode> classYes = new BinaryTree<>(
|
||||
new Classification("ja")
|
||||
);
|
||||
BinaryTree<DecisionNode> classNo = new BinaryTree<>(
|
||||
new Classification("nein")
|
||||
);
|
||||
|
||||
|
||||
/*aufg*
|
||||
// TODO: Hier den Entscheidungsbaum aufbauen.
|
||||
//
|
||||
// Der Baum wird von den Blättern nach "oben" zur Wurzel aufgebaut.
|
||||
// z.B.
|
||||
// BinaryTree<DecisionNode> wind = new BinaryTree<>(
|
||||
// new Decision("wind", "stark"), // Entscheide Merkmal "wind", gehe links bei "stark"
|
||||
// classNo, // Linker Teilbaum
|
||||
// classYes // rechter Teilbaum
|
||||
// );
|
||||
// usw...
|
||||
*aufg*/
|
||||
//ml*
|
||||
BinaryTree<DecisionNode> wind = new BinaryTree<>(
|
||||
new Decision("wind", "stark"),
|
||||
classNo,
|
||||
classYes
|
||||
);
|
||||
BinaryTree<DecisionNode> vorhersage = new BinaryTree<>(
|
||||
new Decision("vorhersage", "sonnig"),
|
||||
wind,
|
||||
classYes
|
||||
);
|
||||
BinaryTree<DecisionNode> feuchtigkeit = new BinaryTree<>(
|
||||
new Decision("feuchtigkeit", "hoch"),
|
||||
classNo,
|
||||
classYes
|
||||
);
|
||||
//*ml
|
||||
// Die Wurzel zuletzt
|
||||
decisionTree = new BinaryTree<>(
|
||||
new Decision("vorhersage", "regnerisch"),
|
||||
feuchtigkeit,
|
||||
vorhersage
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Schickt die {@link #getTestdata() Testdaten} durch den Entscheidungsbaum
|
||||
* und gibt die Entscheidungen auf der Kommandozeile aus.
|
||||
*
|
||||
* @see #testDataset(Dataset)
|
||||
*/
|
||||
public void testTestdata() {
|
||||
Dataset[] testdata = getTestdata();
|
||||
for( int i = 0; i < testdata.length; i++ ) {
|
||||
Dataset d = testdata[i];
|
||||
String result = testDataset(d);
|
||||
System.out.printf("(%s, %s, %s, %s) = %s",
|
||||
d.get("vorhersage"), d.get("temperatur"),
|
||||
d.get("feuchtigkeit"), d.get("wind"),
|
||||
result);
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Schickt einen Datensatz durch den Entscheidungsbaum und gibt die
|
||||
* Klasse als String zurück.
|
||||
*
|
||||
* @param pDataset Der zu testende Datensatz.
|
||||
* @return Die Klasse, der der Datensatz zugeordnet wurde.
|
||||
*/
|
||||
public String testDataset( Dataset pDataset ) {
|
||||
BinaryTree<DecisionNode> node = decisionTree;
|
||||
|
||||
String result = "";
|
||||
while( result.equals("") || result.equals("left")
|
||||
|| result.equals("right") ) {
|
||||
/*aufg* 1
|
||||
// TODO: Impementiere den Durchlauf durch den Entschiedungsbaum,
|
||||
// indem bei jedem inneren Knoten die Entscheidung getroffen wird,
|
||||
// ob links oder rechts weitergemacht wird.
|
||||
*aufg*/
|
||||
/*aufg* 2
|
||||
// TODO: Impementiere den Durchlauf durch den Entschiedungsbaum,
|
||||
// indem bei jedem inneren Knoten die Entscheidung getroffen wird,
|
||||
// ob links oder rechts weitergemacht wird.
|
||||
|
||||
DecisionNode e = null;
|
||||
result = "???";
|
||||
|
||||
if( result.equals("left") ) {
|
||||
// ...
|
||||
} else if( result.equals("right") ) {
|
||||
// ...
|
||||
}
|
||||
*aufg*/
|
||||
//ml*
|
||||
DecisionNode e = node.getContent();
|
||||
result = e.decide(pDataset);
|
||||
|
||||
if( result.equals("left") ) {
|
||||
// Im linken Teilbaum weiter
|
||||
node = node.getLeftTree();
|
||||
} else if( result.equals("right") ) {
|
||||
// Im rechten Teilbaum weiter
|
||||
node = node.getRightTree();
|
||||
}
|
||||
//*ml
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Erstellt ein Array mit Test-Datensätzen für den Entscheidungsbaum.
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public Dataset[] getTestdata() {
|
||||
String[][] testdata = {
|
||||
{"sonnig", "heiß", "hoch", "schwach"},
|
||||
{"sonnig", "heiß", "hoch", "stark"},
|
||||
{"bewölkt", "heiß", "hoch", "schwach"},
|
||||
{"regnerisch", "mild", "hoch", "schwach"},
|
||||
{"regnerisch", "kalt", "normal", "schwach"},
|
||||
{"regnerisch", "kalt", "normal", "stark"},
|
||||
{"bewölkt", "mild", "hoch", "stark"},
|
||||
{"sonnig", "mild", "hoch", "schwach"},
|
||||
{"sonnig", "kalt", "normal", "schwach"},
|
||||
{"regnerisch", "mild", "normal", "schwach"},
|
||||
{"sonnig", "mild", "normal", "stark"},
|
||||
{"bewölkt", "heiß", "normal", "schwach"},
|
||||
{"bewölkt", "kalt", "normal", "stark"},
|
||||
{"regnerisch", "mild", "hoch", "stark"}
|
||||
};
|
||||
|
||||
Dataset[] data = new Dataset[testdata.length];
|
||||
for( int i = 0; i < testdata.length; i++ ) {
|
||||
data[i] = new Dataset();
|
||||
data[i].set("vorhersage", testdata[i][0]);
|
||||
data[i].set("temperatur", testdata[i][1]);
|
||||
data[i].set("feuchtigkeit", testdata[i][2]);
|
||||
data[i].set("wind", testdata[i][3]);
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
|
||||
import static org.junit.Assert.*;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
public class DecisionTreeTest {
|
||||
|
||||
private static final String[][] known_data = {
|
||||
{"sonnig", "heiß", "hoch", "schwach", "ja"},
|
||||
{"sonnig", "heiß", "hoch", "stark", "nein"},
|
||||
{"bewölkt", "heiß", "hoch", "schwach", "ja"},
|
||||
{"regnerisch", "mild", "hoch", "schwach", "nein"},
|
||||
{"regnerisch", "kalt", "normal", "schwach", "ja"},
|
||||
{"regnerisch", "kalt", "normal", "stark", "ja"},
|
||||
{"bewölkt", "mild", "hoch", "stark", "ja"},
|
||||
{"sonnig", "mild", "hoch", "schwach", "ja"},
|
||||
{"sonnig", "kalt", "normal", "schwach", "ja"},
|
||||
{"regnerisch", "mild", "normal", "schwach", "ja"},
|
||||
{"sonnig", "mild", "normal", "stark", "nein"},
|
||||
{"bewölkt", "heiß", "normal", "schwach", "ja"},
|
||||
{"bewölkt", "kalt", "normal", "stark", "ja"},
|
||||
{"regnerisch", "mild", "hoch", "stark", "nein"}
|
||||
};
|
||||
|
||||
private static final String[][] unknown_data = {
|
||||
{"regnerisch", "heiß", "hoch", "schwach", "nein"},
|
||||
{"sonnig", "kalt", "hoch", "stark", "nein"}
|
||||
};
|
||||
|
||||
private DecisionTreeBuilder tree;
|
||||
|
||||
private Dataset[] known_datasets, unknown_datasets;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
known_datasets = new Dataset[known_data.length];
|
||||
for( int i = 0; i < known_data.length; i++ ) {
|
||||
known_datasets[i] = new Dataset();
|
||||
known_datasets[i].set("vorhersage", known_data[i][0]);
|
||||
known_datasets[i].set("temperatur", known_data[i][1]);
|
||||
known_datasets[i].set("feuchtigkeit", known_data[i][2]);
|
||||
known_datasets[i].set("wind", known_data[i][3]);
|
||||
}
|
||||
|
||||
unknown_datasets = new Dataset[unknown_data.length];
|
||||
for( int i = 0; i < unknown_data.length; i++ ) {
|
||||
unknown_datasets[i] = new Dataset();
|
||||
unknown_datasets[i].set("vorhersage", unknown_data[i][0]);
|
||||
unknown_datasets[i].set("temperatur", unknown_data[i][1]);
|
||||
unknown_datasets[i].set("feuchtigkeit", unknown_data[i][2]);
|
||||
unknown_datasets[i].set("wind", unknown_data[i][3]);
|
||||
}
|
||||
|
||||
tree = new DecisionTreeBuilder();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testKnownData() {
|
||||
for( int i = 0; i < known_datasets.length; i++ ) {
|
||||
String result = tree.testDataset(known_datasets[i]);
|
||||
assertEquals(known_data[i][4], result);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUnknownData() {
|
||||
for( int i = 0; i < unknown_datasets.length; i++ ) {
|
||||
String result = tree.testDataset(unknown_datasets[i]);
|
||||
assertEquals(unknown_data[i][4], result);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
------------------------------------------------------------------------
|
||||
Dies ist die README-Datei des Projekts. Hier sollten Sie Ihr Projekt
|
||||
beschreiben.
|
||||
Erzählen Sie dem Leser (jemand, der nichts über dieses Projekt weiss),
|
||||
alles, was er/sie wissen muss. Üblicherweise sollte der Kommentar
|
||||
zumindest die folgenden Angaben umfassen:
|
||||
------------------------------------------------------------------------
|
||||
|
||||
PROJEKTBEZEICHNUNG:
|
||||
PROJEKTZWECK:
|
||||
VERSION oder DATUM:
|
||||
WIE IST DAS PROJEKT ZU STARTEN:
|
||||
AUTOR(EN):
|
||||
BENUTZERHINWEISE:
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#BlueJ package file
|
||||
dependency1.from=DecisionNode
|
||||
dependency1.to=Dataset
|
||||
dependency1.type=UsesDependency
|
||||
dependency2.from=Classification
|
||||
dependency2.to=Dataset
|
||||
dependency2.type=UsesDependency
|
||||
dependency3.from=Decision
|
||||
dependency3.to=Dataset
|
||||
dependency3.type=UsesDependency
|
||||
dependency4.from=DecisionTreeBuilder
|
||||
dependency4.to=BinaryTree
|
||||
dependency4.type=UsesDependency
|
||||
dependency5.from=DecisionTreeBuilder
|
||||
dependency5.to=DecisionNode
|
||||
dependency5.type=UsesDependency
|
||||
dependency6.from=DecisionTreeBuilder
|
||||
dependency6.to=Classification
|
||||
dependency6.type=UsesDependency
|
||||
dependency7.from=DecisionTreeBuilder
|
||||
dependency7.to=Decision
|
||||
dependency7.type=UsesDependency
|
||||
dependency8.from=DecisionTreeBuilder
|
||||
dependency8.to=Dataset
|
||||
dependency8.type=UsesDependency
|
||||
editor.fx.0.height=722
|
||||
editor.fx.0.width=800
|
||||
editor.fx.0.x=388
|
||||
editor.fx.0.y=50
|
||||
objectbench.height=66
|
||||
objectbench.width=1201
|
||||
package.divider.horizontal=0.6
|
||||
package.divider.vertical=0.8983286908077994
|
||||
package.editor.height=622
|
||||
package.editor.width=1078
|
||||
package.editor.x=39
|
||||
package.editor.y=24
|
||||
package.frame.height=776
|
||||
package.frame.width=1241
|
||||
package.numDependencies=8
|
||||
package.numTargets=6
|
||||
package.showExtends=true
|
||||
package.showUses=true
|
||||
project.charset=UTF-8
|
||||
readme.height=58
|
||||
readme.name=@README
|
||||
readme.width=47
|
||||
readme.x=10
|
||||
readme.y=10
|
||||
target1.height=40
|
||||
target1.name=Classification
|
||||
target1.showInterface=false
|
||||
target1.type=ClassTarget
|
||||
target1.width=210
|
||||
target1.x=40
|
||||
target1.y=460
|
||||
target2.height=50
|
||||
target2.name=Decision
|
||||
target2.showInterface=false
|
||||
target2.type=ClassTarget
|
||||
target2.width=190
|
||||
target2.x=300
|
||||
target2.y=460
|
||||
target3.height=120
|
||||
target3.name=BinaryTree
|
||||
target3.showInterface=false
|
||||
target3.type=ClassTarget
|
||||
target3.width=440
|
||||
target3.x=890
|
||||
target3.y=250
|
||||
target4.height=40
|
||||
target4.name=Dataset
|
||||
target4.showInterface=false
|
||||
target4.type=ClassTarget
|
||||
target4.width=270
|
||||
target4.x=430
|
||||
target4.y=30
|
||||
target5.height=50
|
||||
target5.name=DecisionNode
|
||||
target5.showInterface=false
|
||||
target5.type=AbstractTarget
|
||||
target5.width=110
|
||||
target5.x=210
|
||||
target5.y=290
|
||||
target6.height=60
|
||||
target6.name=DecisionTreeBuilder
|
||||
target6.showInterface=false
|
||||
target6.type=ClassTarget
|
||||
target6.width=270
|
||||
target6.x=580
|
||||
target6.y=230
|
||||
Loading…
Reference in New Issue