similaritycombiner.cs

In the previous article, we presented an approach for capturing similarity between words that was co

//Author : Thanh Ngoc Dao, [e-mail] or [e-mail]
using System;

namespace ServiceRanking
{
    /// <summary>
    /// Summary description for SimilarityCombiner
    /// </summary>
    public class SimilarityCombiner
    {

        public SimilarityCombiner()
        {
        }

        public static float[][] Aggregate(float[][][] simCube, int aggregationStrategy, float[] weights)
        {
            if (simCube == null)
                return null;
            if (weights == null)
                if (aggregationStrategy == 3)
                    aggregationStrategy = 2;
                else if (aggregationStrategy == 7)
                    aggregationStrategy = 6;
            int k = simCube.Length;
            int m = simCube[0].Length;
            int n = simCube[0][0].Length;
            float[][] simMatrix = new float[m][];
            for (int i = 0; i < m; i++)
                simMatrix[i] = new float[n];


            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    float maxSim = 0.0F;
                    float sumSim = 0.0F;
                    float weightedSim = 0.0F;
                    float minSim = 3.402823e+038F;
                    for (int l = 0; l < k; l++)
                    {
                        float sim = simCube[l][i][j];
                        switch (aggregationStrategy)
                        {
                            case 1:
                                if (sim > maxSim)
                                    maxSim = sim;
                                break;

                            case 2:
                                sumSim += sim;
                                break;

                            case 3:
                                weightedSim += sim * weights[l];
                                break;

                            case 4:
                                if (sim < minSim)
                                    minSim = sim;
                                break;

                            default:
                                break;
                        }
                    }

                    switch (aggregationStrategy)
                    {

                        case 1:
                            simMatrix[i][j] = maxSim;
                            break;

                        case 2:

                        case 6:
                            simMatrix[i][j] = sumSim / (float)k;
                            break;


                        case 3:

                        case 7:
                            simMatrix[i][j] = weightedSim;
                            break;


                        case 4:
                            simMatrix[i][j] = minSim;
                            break;
                    }
                }
            }

            return simMatrix;
        }

        public static float[][] Aggregate(float[][][] simCube, int aggregation)
        {
            if (aggregation == 3)
                return Aggregate(simCube, 2, null);
            if (aggregation == 7)
                return Aggregate(simCube, 6, null);
            else
                return Aggregate(simCube, aggregation, null);
        }


        public static float ComputeSetSimilarity(float[][] simMatrix, int setStrategy, float threshold)
        {
            if (simMatrix == null)
                return 0.0F;
            int m = simMatrix.Length;
            int n = simMatrix[0].Length;
            float sim = 0.0F;
            if (setStrategy == 1)
            {
                float maxSim_i = 0.0F;
                float maxSim_j = 0.0F;
                float sumSim_i = 0.0F;
                float sumSim_j = 0.0F;
                for (int i = 0; i < m; i++)
                {
                    maxSim_i = 0.0F;
                    for (int j = 0; j < n; j++)
                        if (maxSim_i < simMatrix[i][j])
                            maxSim_i = simMatrix[i][j];

                    sumSim_i += maxSim_i;
                }

                for (int j = 0; j < n; j++)
                {
                    maxSim_j = 0.0F;
                    for (int i = 0; i < m; i++)
                        if (maxSim_j < simMatrix[i][j])
                            maxSim_j = simMatrix[i][j];

                    sumSim_j += maxSim_j;
                }

                sim = (sumSim_i + sumSim_j) / (float)(m + n);
            }
            else if (setStrategy == 2)
            {
                int matchCount_i = 0;
                int matchCount_j = 0;
                for (int i = 0; i < m; i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        if (simMatrix[i][j] <= threshold)
                            continue;
                        matchCount_i++;
                        break;
                    }
                }

                for (int j = 0; j < n; j++)
                {
                    for (int i = 0; i < m; i++)
                    {
                        if (simMatrix[i][j] <= threshold)
                            continue;
                        matchCount_j++;
                        break;
                    }
                }

                sim = (float)(matchCount_i + matchCount_j) / (float)(m + n);
            }
            return sim;
        }

        public static float ComputeSetSimilarity(float[][] simMatrix, int setStrategy)
        {
            float sim = 0.0F;
            if (setStrategy == 1)
                sim = ComputeSetSimilarity(simMatrix, 1, 0.0F);
            else
                sim = ComputeSetSimilarity(simMatrix, 2, 0.5F);
            return sim;
        }

    }
}