meshsimilarity.java

dragontoolkit用于机器学习

package dragon.nlp.ontology.mesh;

import dragon.matrix.*;
import dragon.nlp.*;
import dragon.nlp.compare.*;
import dragon.nlp.ontology.*;
import dragon.util.*;
import java.util.*;

/**
 * <p>Similarity measures of comparing two MeSH nodes </p>
 * <p> </p>
 * <p>Copyright: Copyright (c) 2006</p>
 * <p>Company: Drexel University</p>
 * @author Xiaodan Zhang
 * @version 1.0
 */

public class MeshSimilarity implements SimilarityMetric{
    //declared similarity measure by author's name
    public static final int MIN_LEN = 0;
    public static final int WU_PALMER = 1;
    public static final int LI = 2;
    public static final int LEACOCK = 3;
    public static final int JING = 4;
    public static final int LIN = 5;
    public static final int JIANG = 6;
    public static final int RESINK = 7;
    public static final int MAO = 8;
    public static final int FEATURE=9;
    public static final int KNAPPE=10;

    private MeshNodeList meshNodeList;
    private SortedArray maxTaxoLenList;
    private int similarityMode;

    public MeshSimilarity(String hierFile, int similarityMode){
        meshNodeList = new MeshNodeList(hierFile);
        if(similarityMode==LEACOCK)
            maxTaxoLenList=genMaxTaxoLenList();
        else
            maxTaxoLenList=null;
        this.similarityMode =similarityMode;
    }

    public String getParent(String path){
        if (path.indexOf(".") < 0)
            return null;
        return path.substring(0, path.lastIndexOf("."));
    }

    public String[] getAncestors(String path){
        int i;
        String[] ancestors;
        ArrayList parents;

        if(path.indexOf(".")<0){
            ancestors = new String[1];
            ancestors[0] = path;
            return ancestors;
        }

        parents = new ArrayList(5);
        while(path.indexOf(".")>0){
            path=path.substring(0, path.lastIndexOf("."));
            parents.add(path);
        }
        ancestors = new String[parents.size()];
        for(i=0;i<ancestors.length;i++){
            ancestors[i]=(String)parents.get(i);
        }
        return ancestors;
    }

    public String[] getSharedAncestors(String path1, String path2){
        int i,j;
        String[] ancestors1,ancestors2,sharedAncestors;
        ArrayList sharedParents;

        if(path1.equals(path2))
            return getAncestors(path1);
        ancestors1=getAncestors(path1);
        ancestors2=getAncestors(path2);
        sharedParents= new ArrayList(5);
        for(i=0;i<ancestors1.length;i++){
            for(j=0;j<ancestors2.length;j++){
                if(ancestors1[i].equals(ancestors2[j]))
                    sharedParents.add(ancestors1[i]);
            }
        }
        if(sharedParents.size()==0) return null;
        sharedAncestors = new String[sharedParents.size()];
        for(i=0;i<sharedAncestors.length;i++)
            sharedAncestors[i]=(String)sharedParents.get(i);
        return sharedAncestors;
    }

    public String[] getUnionAncestors(String path1, String path2){
        int i;
        SortedArray unionParents;
        String[] ancestors1,ancestors2,unionAncestors;

        if(path1.equals(path2))
            return getAncestors(path1);
        ancestors1=getAncestors(path1);
        ancestors2=getAncestors(path2);
        unionParents= new SortedArray(new AlphabetaComparator());
        for(i=0;i<ancestors1.length;i++)
            unionParents.add(ancestors1[i]);
        for(i=0;i<ancestors2.length;i++)
            unionParents.add(ancestors2[i]);

        unionAncestors= new String[unionParents.size()];
        for(i=0;i<unionAncestors.length;i++)
            unionAncestors[i]=(String)unionParents.get(i);
        return unionAncestors;
    }

    public String getRoot(String path){
        if (path.indexOf(".") < 0)
            return path;
        return path.substring(0, path.indexOf("."));
    }

    public boolean isRoot(String path){
        if (path.indexOf(".") < 0)
            return true;
        return false;
    }

    public String getCommonParent(String path1,String path2){
        String temp;
        if(!getRoot(path1).equals(getRoot(path2)))
            return null;

        if(getDepth(path2)>getDepth(path1)){
            temp = path1;
            path1=path2;
            path2=temp;
        }
        while (path1 != null) {
            while (path2 != null) {
                if (path1.indexOf(path2) >= 0)
                    return path2;
                else if (path2.indexOf(path1) >= 0)
                    return path1;
                path2 = getParent(path2);
            }
            path1 = getParent(path1);
        }
        return null;
    }

    public int getDescendantNum(String path){
        MeshNode cur;

        cur=meshNodeList.lookup(path);
        if(cur==null)
            return 0;
        else
            return cur.getDescendantNum();
    }

    public ArrayList getDescendant(String path){
        ArrayList nodeList;
        MeshNode cur,child;
        int pos;

        pos=meshNodeList.binarySearch(new MeshNode(path));
        nodeList = new ArrayList();
        cur = (MeshNode) meshNodeList.get(pos);
        while(pos<=meshNodeList.size()-2){
            pos++;
            child=(MeshNode) meshNodeList.get(pos);
            if(!child.getPath().startsWith(cur.getPath()))
                break;
            nodeList.add(child);
        }
        return nodeList;
    }

    public int getMaxPathLen(String path){
        ArrayList nodeList;
        int i,max,length;

        nodeList = getDescendant(path);
        if (nodeList.size() == 0)
            return getDepth(path);

        max = 0;
        for (i = 0; i < nodeList.size(); i++) {
            length = getDepth( ( (MeshNode) nodeList.get(i)).getPath());
            if (max < length)
                max = length;
        }
        return max;
    }

    public int getMinLen(String path1, String path2){
        String coParent;
        int parLen;
        coParent=getCommonParent(path1,path2);
        if(coParent==null)
            return -1;
        parLen=getDepth(coParent);
        return getDepth(path1)+getDepth(path2)-2*parLen;
    }

    public int getMinLen(String path1, String path2, String coParent){
        int parLen;
        if(coParent==null)
            return -1;
        parLen=getDepth(coParent);
        return getDepth(path1)+getDepth(path2)-2*parLen;
    }

    public int getDepth(String path){
        int count;
        if(path.indexOf(".")<0)
            return 1;
        count=0;
        while(getParent(path)!=null){
            path=getParent(path);
            count++;
        }
        count++;
        return count;
    }

    private double getWuPalmerSimilarity(String path1, String path2){
        String coParent;
        int parLen;
        coParent = getCommonParent(path1, path2);
        if (coParent == null)
            return -1;
        parLen = getDepth(coParent);
        return (2*parLen)/(double)(getDepth(path1)-parLen + getDepth(path2)-parLen + 2 * parLen);
    }

   private double getLiSimilarity(String path1, String path2,double minPathScaler, double parentDepthScaler) {
        String coParent;
        int parentDepth,path1Depth,path2Depth;
        double dist,minLen;
        coParent = getCommonParent(path1, path2);
        if (coParent == null)
            return -1;
        parentDepth = getDepth(coParent);
        path1Depth = getDepth(path1);
        path2Depth = getDepth(path2);
        minLen = path1Depth+path2Depth-2*parentDepth;
        dist = Math.exp(-minPathScaler*minLen);
        dist = dist*(Math.exp(parentDepthScaler*parentDepth)-Math.exp(-parentDepthScaler*parentDepth));
        dist = dist/(Math.exp(parentDepthScaler*parentDepth)+Math.exp(-parentDepthScaler*parentDepth));
        return dist;