/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* TwoWayNumericSplit.java
* Copyright (C) 2001 University of Waikato, Hamilton, New Zealand
*
*/
package weka.classifiers.trees.adtree;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.RevisionUtils;
import weka.core.Utils;
import java.util.Enumeration;
/**
* Class representing a two-way split on a numeric attribute, of the form:
* either 'is < some_value' or 'is >= some_value'.
*
* @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
* @version $Revision: 1.6 $
*/
public class TwoWayNumericSplit
extends Splitter {
/** for serialization */
private static final long serialVersionUID = 449769177903158283L;
/** The index of the attribute the split depends on */
private int attIndex;
/** The attribute value that is compared against */
private double splitPoint;
/** The children of this split */
private PredictionNode[] children;
/**
* Creates a new two-way numeric splitter.
*
* @param _attIndex the index of the attribute this split depeneds on
* @param _splitPoint the attribute value that the splitter splits on
*/
public TwoWayNumericSplit(int _attIndex, double _splitPoint) {
attIndex = _attIndex;
splitPoint = _splitPoint;
children = new PredictionNode[2];
}
/**
* Gets the number of branches of the split.
*
* @return the number of branches (always = 2)
*/
public int getNumOfBranches() {
return 2;
}
/**
* Gets the index of the branch that an instance applies to. Returns -1 if no branches
* apply.
*
* @param inst the instance
* @return the branch index
*/
public int branchInstanceGoesDown(Instance inst) {
if (inst.isMissing(attIndex)) return -1;
else if (inst.value(attIndex) < splitPoint) return 0;
else return 1;
}
/**
* Gets the subset of instances that apply to a particluar branch of the split. If the
* branch index is -1, the subset will consist of those instances that don't apply to
* any branch.
*
* @param branch the index of the branch
* @param instances the instances from which to find the subset
* @return the set of instances that apply
*/
public ReferenceInstances instancesDownBranch(int branch, Instances instances) {
ReferenceInstances filteredInstances = new ReferenceInstances(instances, 1);
if (branch == -1) {
for (Enumeration e = instances.enumerateInstances(); e.hasMoreElements(); ) {
Instance inst = (Instance) e.nextElement();
if (inst.isMissing(attIndex)) filteredInstances.addReference(inst);
}
} else if (branch == 0) {
for (Enumeration e = instances.enumerateInstances(); e.hasMoreElements(); ) {
Instance inst = (Instance) e.nextElement();
if (!inst.isMissing(attIndex) && inst.value(attIndex) < splitPoint)
filteredInstances.addReference(inst);
}
} else {
for (Enumeration e = instances.enumerateInstances(); e.hasMoreElements(); ) {
Instance inst = (Instance) e.nextElement();
if (!inst.isMissing(attIndex) && inst.value(attIndex) >= splitPoint)
filteredInstances.addReference(inst);
}
}
return filteredInstances;
}
/**
* Gets the string describing the attributes the split depends on.
* i.e. the left hand side of the description of the split.
*
* @param dataset the dataset that the split is based on
* @return a string describing the attributes
*/
public String attributeString(Instances dataset) {
return dataset.attribute(attIndex).name();
}
/**
* Gets the string describing the comparision the split depends on for a particular
* branch. i.e. the right hand side of the description of the split.
*
* @param branchNum the branch of the split
* @param dataset the dataset that the split is based on
* @return a string describing the comparison
*/
public String comparisonString(int branchNum, Instances dataset) {
return ((branchNum == 0 ? "< " : ">= ") + Utils.doubleToString(splitPoint, 3));
}
/**
* Tests whether two splitters are equivalent.
*
* @param compare the splitter to compare with
* @return whether or not they match
*/
public boolean equalTo(Splitter compare) {
if (compare instanceof TwoWayNumericSplit) { // test object type
TwoWayNumericSplit compareSame = (TwoWayNumericSplit) compare;
return (attIndex == compareSame.attIndex &&
splitPoint == compareSame.splitPoint);
} else return false;
}
/**
* Sets the child for a branch of the split.
*
* @param branchNum the branch to set the child for
* @param childPredictor the new child
*/
public void setChildForBranch(int branchNum, PredictionNode childPredictor) {
children[branchNum] = childPredictor;
}
/**
* Gets the child for a branch of the split.
*
* @param branchNum the branch to get the child for
* @return the child
*/
public PredictionNode getChildForBranch(int branchNum) {
return children[branchNum];
}
/**
* Clones this node. Performs a deep copy, recursing through the tree.
*
* @return a clone
*/
public Object clone() {
TwoWayNumericSplit clone = new TwoWayNumericSplit(attIndex, splitPoint);
clone.orderAdded = orderAdded;
if (children[0] != null)
clone.setChildForBranch(0, (PredictionNode) children[0].clone());
if (children[1] != null)
clone.setChildForBranch(1, (PredictionNode) children[1].clone());
return clone;
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 1.6 $");
}
}