PrimitiveSimilarity.cpp

Go to the documentation of this file.

#include "PrimitiveSimilarity.h"
 
#include <algorithm>
#include <cmath>
 
namespace armarx::aron::similarity::variant::primitive
{
    namespace
    {
        template <typename ValueT>
        float normalizedAbsDistanceSimilarity(ValueT oldValue, ValueT newValue)
        {
            const double oldAsDouble = static_cast<double>(oldValue);
            const double newAsDouble = static_cast<double>(newValue);
            const double denom =
                std::max(std::max(std::abs(oldAsDouble), std::abs(newAsDouble)), 0.0001);
 
            return static_cast<float>(1.0 - (std::abs(oldAsDouble - newAsDouble) / denom));
        }
 
        // taken from https://github.com/guilhermeagostinelli/levenshtein/blob/master/levenshtein.cpp 
        int levenshteinDist(const std::string& word1, const std::string& word2) {
            const int size1 = word1.size();
            const int size2 = word2.size();
            std::vector<std::vector<int>> verif(size1 + 1, std::vector<int>(size2 + 1));
 
            // If one of the words has zero length, the distance is equal to the size of the other word.
            if (size1 == 0)
                return size2;
            if (size2 == 0)
                return size1;
 
            // Sets the first row and the first column of the verification matrix with the numerical order from 0 to the length of each word.
            for (int i = 0; i <= size1; i++)
                verif[i][0] = i;
            for (int j = 0; j <= size2; j++)
                verif[0][j] = j;
 
            // Verification step / matrix filling.
            for (int i = 1; i <= size1; i++) {
                for (int j = 1; j <= size2; j++) {
                    // Sets the modification cost.
                    // 0 means no modification (i.e. equal letters) and 1 means that a modification is needed (i.e. unequal letters).
                    int cost = (word2[j - 1] == word1[i - 1]) ? 0 : 1;
 
                    // Sets the current position of the matrix as the minimum value between a (deletion), b (insertion) and c (substitution).
                    // a = the upper adjacent value plus 1: verif[i - 1][j] + 1
                    // b = the left adjacent value plus 1: verif[i][j - 1] + 1
                    // c = the upper left adjacent value plus the modification cost: verif[i - 1][j - 1] + cost
                    verif[i][j] = std::min(
                        std::min(verif[i - 1][j] + 1, verif[i][j - 1] + 1),
                        verif[i - 1][j - 1] + cost
                    );
                }
            }
 
            // The last position of the matrix will contain the Levenshtein distance.
            return verif[size1][size2];
        }
    }
 
    float
    calculateSimilarity(const aron::data::Bool& oldValue, const aron::data::Bool& newValue)
    {
        return oldValue.getValue() == newValue.getValue() ? 1.0f : 0.0f;
    }
 
    float
    calculateSimilarity(const aron::data::Int& oldValue, const aron::data::Int& newValue)
    {
        return normalizedAbsDistanceSimilarity(oldValue.getValue(), newValue.getValue());
    }
 
    float
    calculateSimilarity(const aron::data::Long& oldValue, const aron::data::Long& newValue)
    {
        return normalizedAbsDistanceSimilarity(oldValue.getValue(), newValue.getValue());
    }
 
    float
    calculateSimilarity(const aron::data::Float& oldValue, const aron::data::Float& newValue)
    {
        return normalizedAbsDistanceSimilarity(oldValue.getValue(), newValue.getValue());
    }
 
    float
    calculateSimilarity(const aron::data::Double& oldValue, const aron::data::Double& newValue)
    {
        return normalizedAbsDistanceSimilarity(oldValue.getValue(), newValue.getValue());
    }
 
    float
    calculateSimilarity(const aron::data::String& oldValue, const aron::data::String& newValue)
    {
        const std::string& oldString = oldValue.getValue();
        const std::string& newString = newValue.getValue();
        const float denom =
            std::max(static_cast<float>(std::max(oldString.size(), newString.size())), 0.0001f);
 
        return 1.0f - (static_cast<float>(levenshteinDist(oldString, newString)) / denom);
    }
}