/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
/*
* PointsClosestToFurthestChildren.java
* Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
*/
package weka.core.neighboursearch.balltrees;
import weka.core.EuclideanDistance;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.RevisionUtils;
import weka.core.TechnicalInformation;
import weka.core.TechnicalInformation.Field;
import weka.core.TechnicalInformation.Type;
import weka.core.TechnicalInformationHandler;
/**
<!-- globalinfo-start -->
* Implements the Moore's method to split a node of a ball tree.<br/>
* <br/>
* For more information please see section 2 of the 1st and 3.2.3 of the 2nd:<br/>
* <br/>
* Andrew W. Moore: The Anchors Hierarchy: Using the Triangle Inequality to Survive High Dimensional Data. In: UAI '00: Proceedings of the 16th Conference on Uncertainty in Artificial Intelligence, San Francisco, CA, USA, 397-405, 2000.<br/>
* <br/>
* Ashraf Masood Kibriya (2007). Fast Algorithms for Nearest Neighbour Search. Hamilton, New Zealand.
* <p/>
<!-- globalinfo-end -->
*
<!-- technical-bibtex-start -->
* BibTeX:
* <pre>
* @inproceedings{Moore2000,
* address = {San Francisco, CA, USA},
* author = {Andrew W. Moore},
* booktitle = {UAI '00: Proceedings of the 16th Conference on Uncertainty in Artificial Intelligence},
* pages = {397-405},
* publisher = {Morgan Kaufmann Publishers Inc.},
* title = {The Anchors Hierarchy: Using the Triangle Inequality to Survive High Dimensional Data},
* year = {2000}
* }
*
* @mastersthesis{Kibriya2007,
* address = {Hamilton, New Zealand},
* author = {Ashraf Masood Kibriya},
* school = {Department of Computer Science, School of Computing and Mathematical Sciences, University of Waikato},
* title = {Fast Algorithms for Nearest Neighbour Search},
* year = {2007}
* }
* </pre>
* <p/>
<!-- technical-bibtex-end -->
*
<!-- options-start -->
<!-- options-end -->
*
* @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
* @version $Revision: 8034 $
*/
//better rename to MidPoint of Furthest Pair/Children
public class PointsClosestToFurthestChildren
extends BallSplitter
implements TechnicalInformationHandler {
/** for serialization. */
private static final long serialVersionUID = -2947177543565818260L;
/**
* Returns a string describing this object.
*
* @return A description of the algorithm for displaying in the
* explorer/experimenter gui.
*/
public String globalInfo() {
return
"Implements the Moore's method to split a node of a ball tree.\n\n"
+ "For more information please see section 2 of the 1st and 3.2.3 of "
+ "the 2nd:\n\n"
+ getTechnicalInformation().toString();
}
/**
* Returns an instance of a TechnicalInformation object, containing detailed
* information about the technical background of this class, e.g., paper
* reference or book this class is based on.
*
* @return The technical information about this class.
*/
public TechnicalInformation getTechnicalInformation() {
TechnicalInformation result;
TechnicalInformation additional;
result = new TechnicalInformation(Type.INPROCEEDINGS);
result.setValue(Field.AUTHOR, "Andrew W. Moore");
result.setValue(Field.TITLE, "The Anchors Hierarchy: Using the Triangle Inequality to Survive High Dimensional Data");
result.setValue(Field.YEAR, "2000");
result.setValue(Field.BOOKTITLE, "UAI '00: Proceedings of the 16th Conference on Uncertainty in Artificial Intelligence");
result.setValue(Field.PAGES, "397-405");
result.setValue(Field.PUBLISHER, "Morgan Kaufmann Publishers Inc.");
result.setValue(Field.ADDRESS, "San Francisco, CA, USA");
additional = result.add(Type.MASTERSTHESIS);
additional.setValue(Field.AUTHOR, "Ashraf Masood Kibriya");
additional.setValue(Field.TITLE, "Fast Algorithms for Nearest Neighbour Search");
additional.setValue(Field.YEAR, "2007");
additional.setValue(Field.SCHOOL, "Department of Computer Science, School of Computing and Mathematical Sciences, University of Waikato");
additional.setValue(Field.ADDRESS, "Hamilton, New Zealand");
return result;
}
/** Constructor. */
public PointsClosestToFurthestChildren() {
}
/**
* Constructor.
* @param instList The master index array.
* @param insts The instances on which the tree
* is (or is to be) built.
* @param e The Euclidean distance function to
* use for splitting.
*/
public PointsClosestToFurthestChildren(int[] instList, Instances insts,
EuclideanDistance e) {
super(instList, insts, e);
}
/**
* Splits a ball into two.
* @param node The node to split.
* @param numNodesCreated The number of nodes that so far have been
* created for the tree, so that the newly created nodes are
* assigned correct/meaningful node numbers/ids.
* @throws Exception If there is some problem in splitting the
* given node.
*/
public void splitNode(BallNode node, int numNodesCreated) throws Exception {
correctlyInitialized();
double maxDist = Double.NEGATIVE_INFINITY, dist = 0.0;
Instance furthest1=null, furthest2=null, pivot=node.getPivot(), temp;
double distList[] = new double[node.m_NumInstances];
for(int i=node.m_Start; i<=node.m_End; i++) {
temp = m_Instances.instance(m_Instlist[i]);
dist = m_DistanceFunction.distance(pivot, temp, Double.POSITIVE_INFINITY);
if(dist > maxDist) {
maxDist = dist; furthest1 = temp;
}
}
maxDist = Double.NEGATIVE_INFINITY;
furthest1 = (Instance)furthest1.copy();
for(int i=0; i < node.m_NumInstances; i++) {
temp = m_Instances.instance(m_Instlist[i+node.m_Start]);
distList[i] = m_DistanceFunction.distance(furthest1, temp,
Double.POSITIVE_INFINITY);
if(distList[i] > maxDist) {
maxDist = distList[i]; furthest2 = temp; //tempidx = i+node.m_Start;
}
}
furthest2 = (Instance) furthest2.copy();
dist = 0.0; int numRight=0;
//moving indices in the right branch to the right end of the array
for(int i=0, j=0; i < node.m_NumInstances-numRight; i++, j++) {
temp = m_Instances.instance(m_Instlist[i+node.m_Start]);
dist = m_DistanceFunction.distance(furthest2, temp, Double.POSITIVE_INFINITY);
if(dist < distList[i]) {
int t = m_Instlist[node.m_End-numRight];
m_Instlist[node.m_End-numRight] = m_Instlist[i+node.m_Start];
m_Instlist[i+node.m_Start] = t;
double d = distList[distList.length-1-numRight];
distList[distList.length-1-numRight] = distList[i];
distList[i] = d;
numRight++;
i--;
}
}
if(!(numRight > 0 && numRight < node.m_NumInstances))
throw new Exception("Illegal value for numRight: "+numRight);
node.m_Left = new BallNode(node.m_Start, node.m_End-numRight, numNodesCreated+1,
(pivot=BallNode.calcCentroidPivot(node.m_Start,
node.m_End-numRight, m_Instlist,
m_Instances)),
BallNode.calcRadius(node.m_Start,
node.m_End-numRight, m_Instlist,
m_Instances, pivot,
m_DistanceFunction)
);
node.m_Right = new BallNode(node.m_End-numRight+1, node.m_End, numNodesCreated+2,
(pivot=BallNode.calcCentroidPivot(node.m_End-numRight+1,
node.m_End, m_Instlist,
m_Instances)),
BallNode.calcRadius(node.m_End-numRight+1, node.m_End,
m_Instlist, m_Instances, pivot,
m_DistanceFunction)
);
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
}