projects-jenz/ArtificialAutism/src/main/java/FunctionLayer/LevenshteinDistance.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package FunctionLayer;

import com.google.common.collect.MapMaker;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;

/**
 *
 * @author install1
 */
public class LevenshteinDistance implements Callable<ConcurrentMap<String, Integer>> {

    private CharSequence lhs;
    private CharSequence rhs;
    private ConcurrentMap<String, Integer> distanceEntry = new MapMaker().concurrencyLevel(2).makeMap();

    private static int minimum(int a, int b, int c) {
        return Math.min(Math.min(a, b), c);
    }

    public LevenshteinDistance(CharSequence lhs, CharSequence rhs) {
        this.lhs = lhs;
        this.rhs = rhs;
    }

    public double computeLevenshteinDistance() {
        int[][] distance = new int[lhs.length() + 1][rhs.length() + 1];
        for (int i = 0; i <= lhs.length(); i++) {
            distance[i][0] = i;
        }
        for (int j = 1; j <= rhs.length(); j++) {
            distance[0][j] = j;
        }
        for (int i = 1; i <= lhs.length(); i++) {
            for (int j = 1; j <= rhs.length(); j++) {
                distance[i][j] = minimum(
                        distance[i - 1][j] + 1,
                        distance[i][j - 1] + 1,
                        distance[i - 1][j - 1] + ((lhs.charAt(i - 1) == rhs.charAt(j - 1)) ? 0 : 1));
            }
        }
        return distance[lhs.length()][rhs.length()];
    }

    @Override
    public ConcurrentMap<String, Integer> call() {
        int[][] distance = new int[lhs.length() + 1][rhs.length() + 1];
        for (int i = 0; i <= lhs.length(); i++) {
            distance[i][0] = i;
        }
        for (int j = 1; j <= rhs.length(); j++) {
            distance[0][j] = j;
        }
        for (int i = 1; i <= lhs.length(); i++) {
            for (int j = 1; j <= rhs.length(); j++) {
                distance[i][j] = minimum(
                        distance[i - 1][j] + 1,
                        distance[i][j - 1] + 1,
                        distance[i - 1][j - 1] + ((lhs.charAt(i - 1) == rhs.charAt(j - 1)) ? 0 : 1));
            }
        }
        distanceEntry.put(lhs.toString(), distance[lhs.length()][rhs.length()]);
        return distanceEntry;
    }
}