Algoritmo Simil

Descripción:

El algoritmo Simil busca la subcadena más larga en común, y luego busca en la derecha e izquierda
de lo que queda otra subcadena que sea la más larga en común, y este procedimiento se repite
recursivamente hasta no encontrar más cadenas comunes. Entonces el algoritmo nos retornara el
grado de similitud con un valor entre 0 y 1, que nos resulta de la división de la suma de los tamaños
de las subcadenas entre las longitudes de las cadenas misma.

La siguiente tabla nos muestra un ejemplo para dos cadenas que representan Pennsylvania pero han
tenido una falla al ser escritas una de ellas. El algoritmo encuentra la cadena común más larga
“lvan”, y luego repite con las cadenas restantes hasta que no haya más subcadenas comunes.

Simil es case sensitive los que quiere decir que LUIS y luis no son lo mismo. Si deseamos que
ignore las mayúsculas con minúsculas podríamos convertir ambas cadenas a mayúsculas o
minúsculas antes de hacer el llamado a Simil.
Simil tiene un buen rendimiento y es fácil de entenderlo.

Como ejemplo la siguiente imagen muestra cuánto tarda en encontrar todas las cadenas parecidas al
nombre “Valen Corporation” en una base de datos de un millón de filas. Simil tardo 3 segundos
para retornar las tres filas de la figura.
Simil está implementado en .NET , SQL Server , y la versión en C de Steve Grubb la cual tomaremos como
referencia ya que un lenguaje de bajo nivel en el cual podemos medir rendimientos con más precisión.

Sabemos que el duplicado o entradas similares a la base de datos siempre han sido un gran problema porque
desafortunadamente los humanos cometemos errores al editar y tenemos que lidiar con ellos. Y por lo general
los desarrolladores atienden este problema al final cuando el sistema está casi completo. Entonces dado este
problema lo que recomendaremos es siempre antes de que el problema aparezca debemos prevenir estas
situaciones y ¿cómo hacemos eso? Fácil cuando el usuario se proponga a insertar un nuevo registro en la base
de datos verificaremos si esta cadena tiene algún parecido con otra en la base de datos (con la ayuda de simil)
con el fin de evitar ingresar un duplicado escrito de otra manera incorrecta posiblemente. Una vez que simil
encuentre todas las coincidencias el sistema deberá mostrar al usuario un mensaje si este desea agregar ese
registro de todas maneras o usar una que ya existe en la base de datos. Veamos el siguiente ejemplo como el
sistema advierte al usuario cuando quiso ingresar un nombre de compañía con “Hungry Howie Night Store”.
Entonces el usuario tomara la decisión si es un nuevo registro o ya es uno de los que está en la base de datos.

Como este caso es lo ideal que se debe hacer en todo procedimiento de desarrollo de un sistema no siempre es
así muchas veces ya tenemos una base de datos con entradas parecidas por los usuarios que representan una
solo cadena entonces debemos desinfectar esas entradas de usuario que ya se encuentran en la base de datos.
En este caso lo podemos trabajar con las frecuencias de las apariciones de un mismo registro en la base de
datos asumiendo que el de mayor frecuencia en aparecer es la mejor cadena para representar a todas las
parecidas a ella pero claro esta suposición no prueba nada pues la de mayor frecuencia no necesariamente es
la mejor escrita. Otro punto de vista sería que el desarrollador sabe cuál es la cadena correcta, simil encuentra
todas las cadenas parecidas a esta y todos los registros encontrados por simil son corregidos.
Algoritmo Simil:

Private Type
structSubString
o1 As Integer
o2 As Integer
len1 As Integer
End Type
Public Function Simil(ByVal s1 As String, ByVal s2 As String) As Double
Dim returnValue As Double
Dim tlen As Integer
Dim s1len As Integer
Dim s2len As Integer
' Added by Jamie West, removes spaces before and after string
s1 = Trim(s1)
s2 = Trim(s2)
returnValue = 0
s1len = Len(s1)
s2len = Len(s2)
If s1len = 0 Or s2len = 0 Then
returnValue = 0#
Else
Dim tcnt As Integer
tcnt = 0
tlen = s1len + s2len
Call rsimil(s1, s1len, s2, s2len, tcnt)
returnValue = tcnt / tlen
End If
Simil = returnValue
End Function
Private Sub rsimil(ByVal s1 As String, ByVal s1len As Integer, ByVal s2
As String, ByVal s2len As Integer, ByRef tcnt As Integer)
Dim ss As structSubString
If s1len = 0 Or s2len = 0 Then Exit Sub
Call find_biggest_substring(s1, s1len, s2, s2len, ss)

If ss.len1 <> 0 Then

tcnt = tcnt + (ss.len1 * 2)
'Check left half...
Call rsimil(s1, ss.o1, s2, ss.o2, tcnt)
'Check right half...
Dim delta1 As Integer
delta1 = ss.o1 + ss.len1

Dim delta2 As Integer

delta2 = ss.o2 + ss.len1
 If delta1 < s1len And delta2 < s2len Then
Call rsimil(Mid(s1, delta1 + 1, Len(s1) - delta1), s1len -
delta1, Mid(s2, delta2 + 1, Len(s2) - delta2), s2len - delta2, tcnt)
End If
End If
End Sub
Private Sub find_biggest_substring(ByVal s1 As String, ByVal s1len As
Integer, ByVal s2 As String, ByVal s2len As Integer, ByRef ss As
structSubString)
Dim i As Integer
Dim j As Integer
Dim size As Integer

size = 1
ss.o2 = -1
i = 0
Do While i <= (s1len - size)
j = 0
Do While j <= (s2len - size)
Dim test_size As Integer
test_size = size
Do While (1)
If ((test_size <= (s1len - i)) And (test_size <= (s2len
- j))) Then
'While things match, keep trying...
'Note:
If Mid(s1, i + 1, test_size) = Mid(s2, j + 1,
test_size) Then
If ((test_size > size) Or (ss.o2 < 0)) Then
ss.o1 = i
ss.o2 = j
size = test_size
End If
test_size = test_size + 1
Else
'Not equal
Exit Do
End If
Else
'Gone past the end of a string - we're done.
Exit Do
End If
Loop
j = j + 1
Loop
 i = i + 1
Loop
If ss.o2 < 0 Then
ss.len1 = 0
Else
ss.len1 = size
End If
End Sub

Referencias:

[1] http://www.accessmvp.com/tomvanstiphout/simil.htm

[2] http://www.dirkstrauss.com/simil/#.VpOdf_nhC1v

[3] https://github.com/vaportrail/VBA/blob/master/basSimil.bas

[4] http://web.archive.org/web/20050213075957/www.gate.net/~ddata/utilities/simil.c
 Bibliografía

[1] Distancia de Levenshtein

Aurelio López Ovando

[2] Algoritmos de Similaridad y Distancia

Recuperación de Información
M.Sc. Kryscia Daviana Ramírez Benavides

[3] Tesis Doctoral \Aportaciones al modelado conexionista de lenguaje y su

Aplicación al reconocimiento de secuencias y traducción automática"
Francisco Zamora Martínez.

[4] Procesado de cadenas de caracteres

Universidad Politécnica de Valencia.

[5] Generación de características lexicológicas para el

Procesamiento del Lenguaje Natural.
Jósval Díaz Blanco.
Universidad de Matanzas “Camilo Cienfuegos"
Facultad de Informática.

[6] Diseño de un nuevo sistema de vigilancia de dominios de internet

Rodrigo Andrés Zumaeta Morales
Universidad de Chile
Facultad de Ciencias Físico Matemáticas.

[7] CS 533: Natural Language Processing

Lecture 03 N-Gram Models and Algorithms
Professor NcCarty

[8] Modelos de Markov Ocultos (HMM)

Miguel A. Alonso, Jorge Graña y Jesús Vilares
Departamento de Computación Universidad de Coruña.