LevenshteinTransformation.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\Refinery\String\Transformation;

use ILIAS\Refinery\DeriveApplyToFromTransform;
use ILIAS\Refinery\DeriveInvokeFromTransform;
use ILIAS\Refinery\Transformation;
use InvalidArgumentException;
use ilStr;

class LevenshteinTransformation implements Transformation
{
    use DeriveApplyToFromTransform;
    use DeriveInvokeFromTransform;

    private $primary_string;
    private $maximum_distance;
    private $cost_insertion;
    private $cost_replacement;
    private $cost_deletion;

    public function __construct(
        string $primary_string = "",
        int    $maximum_distance = 0,
        float  $cost_insertion = 1.0,
        float  $cost_replacement = 1.0,
        float  $cost_deletion = 1.0
    ) {
        $this->primary_string= $primary_string;
        $this->maximum_distance = $maximum_distance;
        $this->cost_insertion = $cost_insertion;
        $this->cost_replacement = $cost_replacement;
        $this->cost_deletion = $cost_deletion;
    }

    protected function levenshtein(string $secondary_string): float
    {
        $cost_matrix = [];
        $primary_string_array = $this->stringToCharacterArray($this->primary_string);
        $secondary_string_array = $this->stringToCharacterArray($secondary_string);
        $primary_string_length = count($primary_string_array);
        $secondary_string_length = count($secondary_string_array);

        // if the difference between string length is bigger than the maximum allowed levenshtein distance
        // the code can be skipped
        if (abs($primary_string_length - $secondary_string_length) > $this->maximum_distance && $this->maximum_distance != 0) {
            return -1.0;
        }

        $current_row = [];
        $current_row[0] = 0.0;
        for ($j = 1; $j < $secondary_string_length + 1; $j++) {
            $current_row[$j] = $j * $this->cost_insertion;
        }

        $cost_matrix[0] = $current_row;
        for ($i = 0; $i < $primary_string_length; $i++) {
            $current_row = [];
            $current_row[0] = ($i + 1) * $this->cost_deletion;
            for ($j = 0; $j < $secondary_string_length; $j++) {
                $current_row[$j + 1] = min(
                    $cost_matrix[$i][$j + 1] + $this->cost_deletion,
                    $current_row[$j] + $this->cost_insertion,
                    $cost_matrix[$i][$j] + ($primary_string_array[$i] === $secondary_string_array[$j] ? 0.0 : $this->cost_replacement)
                );
            }
            // maximum distance reached
            if (min($current_row) > $this->maximum_distance && $this->maximum_distance != 0) {
                return -1.0;
            }
            $cost_matrix[$i + 1] = $current_row;
        }
        if ($cost_matrix[$primary_string_length][$secondary_string_length] > $this->maximum_distance && $this->maximum_distance != 0) {
            return -1.0;
        }
        return $cost_matrix[$primary_string_length][$secondary_string_length];
    }

    private function stringToCharacterArray(string $string_to_convert): array
    {
        $length = ilStr::strLen($string_to_convert);
        $character_array = [];
        for ($index = 0; $index < $length; $index++) {
            $character_array[$index] = ilStr::subStr($string_to_convert, $index, 1);
        }
        return $character_array;
    }

    public function transform($from): float
    {
        // check if $from is string otherwise exception
        if (!is_string($from)) {
            throw new InvalidArgumentException(__METHOD__ . " the argument is not a string.");
        }

        // call levenshtein methode return result
        return $this->levenshtein($from);
    }
}