---

Distance.java

gehe zur Dokumentation dieser Datei

/*
 * $Source: /shared/cvsroot/diplom/app/src/java/de/picana/math/Distance.java,v $
 * $Author: mstolpe $
 * $Date: 2003/04/22 09:51:29 $
 * $Revision: 1.7 $
 * $Release$
 *
 * Created on 18. November, 23:47
 *
 * Copyright 2002 by Marco Stolpe
 */

package de.picana.math;

import weka.core.*;

import java.util.*;


public class Distance {

    public static double getMMD(Instances[] clusters, double[] min_dists, int[] min_cls) {
        
        double avg_min_dist = 0.0;
        
        for (int cl1=0; cl1 < clusters.length; cl1++) {
            if (clusters[cl1] != null) {
                double[] mean_cl1 = Stats.getMean(clusters[cl1]);
                double min_dist = Double.MAX_VALUE;
                int min_cl = -1;
                
                for (int cl2=0; cl2 < clusters.length; cl2++) {
                    if (clusters[cl2] != null) {
                        double[] mean_cl2 = Stats.getMean(clusters[cl2]);
                        double dist = euklidian(mean_cl1, mean_cl2);
                        if ((cl1 != cl2) && (dist < min_dist)) {
                            min_dist = dist;
                            min_cl = cl2;
                        }
                    }
                }
                avg_min_dist += min_dist;
                min_dists[cl1] = min_dist;
                min_cls[cl1] = min_cl;
            }
        }
        
        return avg_min_dist / clusters.length;
    }
    
    
    public static double getGMMD(Instances[] clusters, double a,
                                 double[] min_dists, int[] min_cls,
                                 double[] stats) {
        
        double gmmd_di = 0.0;
        double gini = 0.0;
        
        double[] ordered_min_dists = new double[clusters.length];
        int[] unordered_min_cls = new int[clusters.length];
        getMMD(clusters, ordered_min_dists, unordered_min_cls);
        
        Arrays.sort(ordered_min_dists);
        
        double weight_lower = 0.0;
        double q = (double)clusters.length;
        double D1 = (1-a) / ((q+1)/2 - 1);
        double D2 = (a-1) / (q - (q+1)/2);
        
        for (int j=1; j <= q; j++) {
                    
            if ((double)j <= (q/2)) 
                weight_lower += D1 * j + a - D1;
            else
                weight_lower += D2 * j + 1 - ((q+1)/2) * D2;
        }
        
        double[] weights = new double[(int)q];
        
        for (int i=1; i <= q; i++) {
            
            if ((double)i <= (q/2))
                weights[i-1] = (D1 * i + a - D1) / weight_lower;
            else
                weights[i-1] = (D2 * i + 1 - ((q+1)/2) * D2) / weight_lower;
        }
        
        for (int i=1; i <= q; i++) {
            gmmd_di += weights[i-1] * ordered_min_dists[i-1];    
        }
        
        stats[0] = gmmd_di;
        
        double sum_di = 0.0;
        
        for (int i=1; i <= q; i++)
            sum_di += ordered_min_dists[i-1];
        
        for (int i=1; i <= q; i++) {
            double temp1 = ((double)(i-1))/q + ((double)i)/q;
            double temp2 = ordered_min_dists[i-1] / sum_di;
            gini += temp1 * temp2;
        }
        
        gini = gini - 1;
        
        stats[1] = gini;
        
        return gmmd_di / Math.sqrt(gini);
    }
    
    public static double euklidian(double[] a1, double[] a2) {
        double dist = 0.0;
        for (int i=0; i < a1.length; i++)
            dist += (a1[i] - a2[i]) * (a1[i] - a2[i]);
        return Math.sqrt(dist);
    }
    
    public static double euklidian(double[] a1, Instance inst) {
        double dist = 0.0;
        for (int i=0; i < a1.length; i++)
            dist += (a1[i] - inst.value(i)) * (a1[i] - inst.value(i));
        return Math.sqrt(dist);
    }
    
    public static double weighted_euklidian(double[] a1, int freq1,
                                            double[] a2, int freq2,
                                            double rho, int size) {
                                                
        double lambda = rho * ((double)freq1 * (double)freq2) /
            ((double)size * (double)size) + (1.0 - rho);
        return Math.pow(lambda,rho) * euklidian(a1, a2);
    }   
    
    public static double weighted_euklidian(double[] a1, int freq1,
                                            double[] a2, double rho, int size) {
                                                
        double lambda = rho * ((double)freq1 / (double)size) + (1.0 - rho);
        return Math.pow(lambda,rho) * euklidian(a1, a2);
    }   
}

---