Java DistanceFunction类代码示例

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * Parses a given list of options. Valid options are:
 * 
 * <!-- options-start --> <!-- options-end -->
 * 
 * @param options the list of options as an array of strings
 * @throws Exception if an option is not supported
 */
@Override
public void setOptions(String[] options) throws Exception {
  String nnSearchClass = Utils.getOption('A', options);
  if (nnSearchClass.length() != 0) {
    String nnSearchClassSpec[] = Utils.splitOptions(nnSearchClass);
    if (nnSearchClassSpec.length == 0) {
      throw new Exception("Invalid DistanceFunction specification string.");
    }
    String className = nnSearchClassSpec[0];
    nnSearchClassSpec[0] = "";

    setDistanceFunction((DistanceFunction) Utils.forName(
      DistanceFunction.class, className, nnSearchClassSpec));
  } else {
    setDistanceFunction(new EuclideanDistance());
  }

  setMeasurePerformance(Utils.getFlag('P', options));
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * Parses a given list of options. Valid options are:
 *
 <!-- options-start -->
 <!-- options-end -->
 *
 * @param options 	the list of options as an array of strings
 * @throws Exception 	if an option is not supported
 */
public void setOptions(String[] options) throws Exception {
  String nnSearchClass = Utils.getOption('A', options);
  if(nnSearchClass.length() != 0) {
    String nnSearchClassSpec[] = Utils.splitOptions(nnSearchClass);
    if(nnSearchClassSpec.length == 0) { 
      throw new Exception("Invalid DistanceFunction specification string."); 
    }
    String className = nnSearchClassSpec[0];
    nnSearchClassSpec[0] = "";

    setDistanceFunction( (DistanceFunction)
                          Utils.forName( DistanceFunction.class, 
                                         className, nnSearchClassSpec) );
  }
  else {
    setDistanceFunction(new EuclideanDistance());
  }
  
  setMeasurePerformance(Utils.getFlag('P',options));
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
private IBk useCosine() {
	IBk ibk = new IBk();
	Instances data = ClassificationModel.getInstance().getInstances();
	Normalize normalizer = new Normalize(); 
	
	try {
		normalizer.setInputFormat(data);

		// Euclidean Distance working over normalized instances = Cosine Similarity according to Foundations of Statistical Natural Processing Language p.301
		// As long as attribute normalization is disabled.
		Instances normalizedInstances; 
		normalizedInstances = Filter.useFilter(data, normalizer); 
		ClassificationModel.getInstance().setInstances(normalizedInstances);
		DistanceFunction df = new EuclideanDistance(); 
		((EuclideanDistance) df).setDontNormalize(true); 		                        
		ibk.getNearestNeighbourSearchAlgorithm().setDistanceFunction(df); 
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
	return ibk;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * sets the distance function to use for instance comparison.
 * 
 * @param df the new distance function to use
 * @throws Exception if instances cannot be processed
 */
public void setDistanceFunction(DistanceFunction df) throws Exception {
  if (!(df instanceof EuclideanDistance)
    && !(df instanceof ManhattanDistance)) {
    throw new Exception(
      "SimpleKMeans currently only supports the Euclidean and Manhattan distances.");
  }
  m_DistanceFunction = df;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * sets the distance function to use for instance comparison.
 * 
 * @param df the new distance function to use
 * @throws Exception if instances cannot be processed
 */
public void setDistanceFunction(DistanceFunction df) throws Exception {
  if (!(df instanceof EuclideanDistance)
    && !(df instanceof ManhattanDistance)) {
    throw new Exception(
      "KMeansPlusPlus only supports the Euclidean and Manhattan distances.");
  }
  m_DistanceFunction = df;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
  * Gets the distance specification string, which contains the class name of
  * the distance and any options to the distance
  *
  * @return the distance string.
  */
 protected String getDistanceSpec() {
   
   DistanceFunction c = getDistance();
   if (c instanceof OptionHandler) {
     return c.getClass().getName() + " "
+ Utils.joinOptions(((OptionHandler)c).getOptions());
   }
   return c.getClass().getName();
 }
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * Sets the distance function to use for nearest neighbour search. Currently
 * only EuclideanDistance is supported.
 * 
 * @param df the distance function to use
 * @throws Exception if not EuclideanDistance
 */
@Override
public void setDistanceFunction(DistanceFunction df) throws Exception {
  if (!(df instanceof EuclideanDistance)) {
    throw new Exception("CoverTree currently only works with "
      + "EuclideanDistanceFunction.");
  }
  m_DistanceFunction = m_EuclideanDistance = (EuclideanDistance) df;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * sets the distance function to use for nearest neighbour search.
 * 
 * @param df		the distance function to use
 * @throws Exception	if not EuclideanDistance
 */
public void setDistanceFunction(DistanceFunction df) throws Exception {
  if (!(df instanceof EuclideanDistance))
    throw new Exception("KDTree currently only works with "
        + "EuclideanDistanceFunction.");
  m_DistanceFunction = m_EuclideanDistance = (EuclideanDistance) df;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
  * sets the distance function to use for instance comparison.
  * 
  * @param df the new distance function to use
  * @throws Exception if instances cannot be processed
  */
 public void setDistanceFunction(DistanceFunction df) throws Exception {
   if (!(df instanceof EuclideanDistance) && 
!(df instanceof ManhattanDistance))      {
     throw new Exception("SimpleKMeans currently only supports the Euclidean and Manhattan distances.");
   }
   m_DistanceFunction = df;
 }
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
  * Gets the distance function specification string, which contains the 
  * class name of the distance function class and any options to it.
  *
  * @return the distance function specification string
  */
 protected String getDistanceFSpec() {
   
   DistanceFunction d = getDistanceF();
   if (d instanceof OptionHandler) {
     return d.getClass().getName() + " "
+ Utils.joinOptions(((OptionHandler) d).getOptions());
   }
   return d.getClass().getName();
 }
 

import weka.core.DistanceFunction; //导入依赖的package包/类
public DistanceFunction getDistanceFunction() {
  return m_DistanceFunction;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
public void setDistanceFunction(DistanceFunction distanceFunction) {
  m_DistanceFunction = distanceFunction;
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * Parses a given list of options.
 * <p/>
 * 
 * <!-- options-start --> Valid options are:
 * <p/>
 * 
 * <!-- options-end -->
 * 
 * @param options the list of options as an array of strings
 * @throws Exception if an option is not supported
 */
@Override
public void setOptions(String[] options) throws Exception {
  m_bPrintNewick = Utils.getFlag('P', options);

  String optionString = Utils.getOption('N', options);
  if (optionString.length() != 0) {
    Integer temp = new Integer(optionString);
    setNumClusters(temp);
  } else {
    setNumClusters(2);
  }

  setDistanceIsBranchLength(Utils.getFlag('B', options));

  String sLinkType = Utils.getOption('L', options);

  if (sLinkType.compareTo("SINGLE") == 0) {
    setLinkType(new SelectedTag(SINGLE, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("COMPLETE") == 0) {
    setLinkType(new SelectedTag(COMPLETE, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("AVERAGE") == 0) {
    setLinkType(new SelectedTag(AVERAGE, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("MEAN") == 0) {
    setLinkType(new SelectedTag(MEAN, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("CENTROID") == 0) {
    setLinkType(new SelectedTag(CENTROID, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("WARD") == 0) {
    setLinkType(new SelectedTag(WARD, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("ADJCOMPLETE") == 0) {
    setLinkType(new SelectedTag(ADJCOMPLETE, TAGS_LINK_TYPE));
  }
  if (sLinkType.compareTo("NEIGHBOR_JOINING") == 0) {
    setLinkType(new SelectedTag(NEIGHBOR_JOINING, TAGS_LINK_TYPE));
  }

  String nnSearchClass = Utils.getOption('A', options);
  if (nnSearchClass.length() != 0) {
    String nnSearchClassSpec[] = Utils.splitOptions(nnSearchClass);
    if (nnSearchClassSpec.length == 0) {
      throw new Exception("Invalid DistanceFunction specification string.");
    }
    String className = nnSearchClassSpec[0];
    nnSearchClassSpec[0] = "";

    setDistanceFunction((DistanceFunction) Utils.forName(
      DistanceFunction.class, className, nnSearchClassSpec));
  } else {
    setDistanceFunction(new EuclideanDistance());
  }

  super.setOptions(options);

  Utils.checkForRemainingOptions(options);
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * Calculates the radius of a node.
 * 
 * @param start The start index of the portion in indices array 
 * that belongs to the node.
 * @param end The end index of the portion in indices array 
 * that belongs to the node. 
 * @param instList The indices array holding indices of 
 * instances. 
 * @param insts The actual instances. instList points to 
 * instances in this object. 
 * @param pivot The centre/pivot of the node. 
 * @param distanceFunction The distance function to use to 
 * calculate the radius. 
 * @return The radius of the node. 
 * @throws Exception If there is some problem calculating the 
 * radius. 
 */
public static double calcRadius(int start, int end, int[] instList, 
                               Instances insts, Instance pivot, 
                               DistanceFunction distanceFunction) 
                                                           throws Exception {
  double radius = Double.NEGATIVE_INFINITY;
  
  for(int i=start; i<=end; i++) {
    double dist = distanceFunction.distance(pivot, 
                                            insts.instance(instList[i]), Double.POSITIVE_INFINITY);
    
    if(dist>radius)
      radius = dist;
  }
  return Math.sqrt(radius);
}
 

import weka.core.DistanceFunction; //导入依赖的package包/类
/**
 * Parses a given list of options. <p/>
 *
  <!-- options-start -->
 * Valid options are: <p/>
 * 
  <!-- options-end -->
 *
 * @param options the list of options as an array of strings
 * @throws Exception if an option is not supported
 */
public void setOptions(String[] options) throws Exception {
  m_bPrintNewick = Utils.getFlag('P', options);

  String optionString = Utils.getOption('N', options); 
  if (optionString.length() != 0) {
    Integer temp = new Integer(optionString);
    setNumClusters(temp);
  }
  else {
    setNumClusters(2);
  }

  setDebug(Utils.getFlag('D', options));
  setDistanceIsBranchLength(Utils.getFlag('B', options));

  String sLinkType = Utils.getOption('L', options);


  if (sLinkType.compareTo("SINGLE") == 0) {setLinkType(new SelectedTag(SINGLE, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("COMPLETE") == 0) {setLinkType(new SelectedTag(COMPLETE, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("AVERAGE") == 0) {setLinkType(new SelectedTag(AVERAGE, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("MEAN") == 0) {setLinkType(new SelectedTag(MEAN, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("CENTROID") == 0) {setLinkType(new SelectedTag(CENTROID, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("WARD") == 0) {setLinkType(new SelectedTag(WARD, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("ADJCOMLPETE") == 0) {setLinkType(new SelectedTag(ADJCOMLPETE, TAGS_LINK_TYPE));}
  if (sLinkType.compareTo("NEIGHBOR_JOINING") == 0) {setLinkType(new SelectedTag(NEIGHBOR_JOINING, TAGS_LINK_TYPE));}

  String nnSearchClass = Utils.getOption('A', options);
  if(nnSearchClass.length() != 0) {
    String nnSearchClassSpec[] = Utils.splitOptions(nnSearchClass);
    if(nnSearchClassSpec.length == 0) { 
      throw new Exception("Invalid DistanceFunction specification string."); 
    }
    String className = nnSearchClassSpec[0];
    nnSearchClassSpec[0] = "";

    setDistanceFunction( (DistanceFunction)
        Utils.forName( DistanceFunction.class, 
            className, nnSearchClassSpec) );
  }
  else {
    setDistanceFunction(new EuclideanDistance());
  }

  Utils.checkForRemainingOptions(options);
}