82 PhoneticStringUtilities::PhoneticStringComparator subclass:#DoubleMetaphoneStringComparator

   106 PhoneticStringUtilities::SingleResultPhoneticStringComparator subclass:#Caverphone2StringComparator

    83 	instanceVariableNames:'inputKey primaryTranslation secondaryTranslation startIndex

   107 	instanceVariableNames:''

    84 		currentIndex skipCount'

   108 	classVariableNames:'CharacterTranslationDict'

    85 	classVariableNames:''

   166     name        soundex   soundex   metaphone   phonet  phonet2     phonix      daitsch phonem      koeln

   198     name        soundex   soundex   metaphone   phonet  phonet2     phonix      daitsch phonem      koeln  caverphone2  mra

   167 

   199 

   168     müller      M460    54600000    MLR         MÜLA    NILA        M4000000    689000  MYLR        657

   200     müller      M460    54600000    MLR         MÜLA    NILA        M4000000    689000  MYLR        657    MLA1111111   MLR

   169     schmidt     S253    25300000    SKMTT       SHMIT   ZNIT        S5300000    463000  CMYD        8628

   201     schmidt     S530    25300000    SKMTT       SHMIT   ZNIT        S5300000    463000  CMYD        862    SKMT111111   SCHMDT

   170     schneider   S253    25360000    SKNTR       SHNEIDA ZNEITA      S5300000    463900  CNAYDR      8627

   202     schneider   S536    25360000    SKNTR       SHNEIDA ZNEITA      S5300000    463900  CNAYDR      8627   SKNTA11111   SCHNDR

   171     fischer     F260    12600000    FSKR        FISHA   FIZA        F8000000    749000  VYCR        387

   203     fischer     F260    12600000    FSKR        FISHA   FIZA        F8000000    749000  VYCR        387    FSKA111111   FSCHR

   172     weber       W160    16000000    WBR         WEBA    FEBA        $1000000    779000  VBR         317

   204     weber       W160    16000000    WBR         WEBA    FEBA        $1000000    779000  VBR         317    WPA1111111   WBR

   173     meyer       M600    56000000    MYR         MEIA    NEIA        M0000000    619000  MAYR        67

   205     meyer       M600    56000000    MYR         MEIA    NEIA        M0000000    619000  MAYR        67     MA11111111   MYR

   174     wagner      W256    25600000    WKNR        WAKNA   FAKNA       $2500000    756900  VACNR       367

   206     wagner      W256    25600000    WKNR        WAKNA   FAKNA       $2500000    756900  VACNR       3467   WKNA111111   WGNR

   175     schulz      S242    24200000    SKLS        SHULS   ZULZ        S4800000    484000  CULC        85

   207     schulz      S420    24200000    SKLS        SHULS   ZULZ        S4800000    484000  CULC        858    SKS1111111   SCHLZ

   176     becker      B260    12600000    BKR         BEKA    BEKA        B2000000    759000  BCR         147

   208     becker      B260    12600000    BKR         BEKA    BEKA        B2000000    759000  BCR         147    PKA1111111   BCKR

   177     hoffmann    H155    15500000    HFMN        HOFMAN  UFNAN       $7550000    576600  OVMAN       036

   209     hoffmann    H155    15500000    HFMN        HOFMAN  UFNAN       $7550000    576600  OVMAN       036    AFMN111111   HFMN

   178     schäfer     S216    21600000    SKFR        SHEFA   ZEFA        S7000000    479000  CVR         837

   210     schäfer     S16ß    21600000    SKFR        SHEFA   ZEFA        S7000000    479000  CVR         837    SKFA111111   SCHFR

   211 

   212     |cls|

   213     

   214     cls := MRAStringComparator.

   215     cls := SoundexStringComparator.

   216     cls := KoelnerPhoneticCodeStringComparator.

   217     cls := Caverphone2StringComparator.

   218     #('müller' 'schmidt' 'schneider' 'fischer' 'weber' 'meyer' 

   219       'wagner' 'schulz'  'becker'    'hoffmann' 'schäfer')

   220     do:[:name |

   221         Transcript show:''''; show:name; show:''' -> '''; show:(cls encode:name); showCR:''''.

   222     ].

   223 

   224     KoelnerPhoneticCodeStringComparator encode:'Müller-Lüdenscheidt'  -> '65752682'

   519 !PhoneticStringUtilities::ExtendedSoundexStringComparator class methodsFor:'documentation'!

   581 !PhoneticStringUtilities::DaitchMokotoffStringComparator class methodsFor:'documentation'!

   523     There are many extended and enhanced soundex variants around;

   585     self encode:'AUERBACH' -> 097400, 097500

   524     here is one, called 'extended soundex'. It is destribed for example in

   586 

   525     http://www.epidata.dk/documentation.php.

   587     Encodes a string into a Daitch-Mokotoff Soundex value.

   526     An author or origin is unknown.

   588     The Daitch-Mokotoff Soundex algorithm is a refinement of the Russel and American Soundex algorithms, 

   527 

   589     yielding greater accuracy in matching especially Slavish and Yiddish surnames with similar pronunciation 

   528     The number of digits is increased to 5 or 8;

   590     but differences in spelling.

   529     The first character is not used literally; instead it is encoded like the rest.

   591 

   530     This might have a negative effect on names starting with a vovel, though.

   592     The main differences compared to the other soundex variants are:

   531 

   593         - coded names are 6 digits long

   532     Overall, it can be doubted if this is really an enhancement after all.

   594         - the initial character of the name is coded

   595         - rules to encoded multi-character n-grams

   596         - multiple possible encodings for the same name (branching)

   597 

   598     This implementation supports branching, depending on the used method:

   599         encode:aString            - branching disabled, only the first code will be returned

   600         phoneticStringsFor:String - branching enabled, all codes will be returned, separated by '|'

   601 

   602     [see also:]

   603         'Wikipedia - Daitch-Mokotoff Soundex'

   604             http://en.wikipedia.org/wiki/Daitch%E2%80%93Mokotoff_Soundex 

   605 

   606         'Avotaynu - Soundexing and Genealogy'    

   607             http://www.avotaynu.com/soundex.htm

   534 ! !

   609 !

   535 

   610 

   536 !PhoneticStringUtilities::ExtendedSoundexStringComparator methodsFor:'api'!

   611 javaCode

   537 

   538 phoneticStringsFor:aString

   539     "generates both an extended soundex of length 5 and one of length 8"

   540 

   541     |first second u t prevCode|

   542 

   543     u := aString asUppercase.

   544     first := second := ''.

   545     u do:[:c | 

   546         t := self translate:c.

   547         (t notNil and:[ t ~= '0' and:[ t ~= prevCode ]]) ifTrue:[

   548             first := first , t.

   549             second := second , t.

   550             second size == 8 ifTrue:[

   551                 ^ Array with:(first copyTo:5) with:second 

   552             ].

   553         ].

   554         prevCode := t

   555     ].

   556     [ first size < 5 ] whileTrue:[

   557         first := first , '0'.

   558         second := second , '0'.

   559     ].

   560     [ second size < 8 ] whileTrue:[

   561         second := second , '0'

   562     ].

   563     ^ Array with:first with:second

   564 

   565     "

   566      self basicNew phoneticStringsFor:'müller'  #('87900' '87900000')  

   567      self basicNew phoneticStringsFor:'miller'  #('87900' '87900000')   

   568      self basicNew phoneticStringsFor:'muller'  #('87900' '87900000')    

   569      self basicNew phoneticStringsFor:'muler'   #('87900' '87900000')

   570      self basicNew phoneticStringsFor:'schmidt'    #('38600' '38600000')

   571      self basicNew phoneticStringsFor:'schneider'  #('38690' '38690000')

   572      self basicNew phoneticStringsFor:'fischer'    #('23900' '23900000')

   573      self basicNew phoneticStringsFor:'weber'      #('19000' '19000000')

   574      self basicNew phoneticStringsFor:'meyer'      #('89000' '89000000')

   575      self basicNew phoneticStringsFor:'wagner'     #('48900' '48900000')

   576      self basicNew phoneticStringsFor:'schulz'     #('37500' '37500000')

   577      self basicNew phoneticStringsFor:'becker'     #('13900' '13900000')

   578      self basicNew phoneticStringsFor:'hoffmann'   #('28800' '28800000')

   579      self basicNew phoneticStringsFor:'schäfer'    #('32900' '32900000')

   580     "

   581 ! !

   582 

   583 !PhoneticStringUtilities::ExtendedSoundexStringComparator methodsFor:'private'!

   584 

   585 translate:aCharacter

   586     "use simple if's for more speed when compiled"

   587 

   588     "vowels serve as separators"

   589     aCharacter == $A ifTrue:[^ '0' ].         

   590     aCharacter == $E ifTrue:[^ '0' ].

   591     aCharacter == $I ifTrue:[^ '0' ].

   592     aCharacter == $O ifTrue:[^ '0' ].

   593     aCharacter == $U ifTrue:[^ '0' ].

   594     aCharacter == $Y ifTrue:[^ '0' ].

   595 

   596     aCharacter == $B ifTrue:[^ '1' ]. 

   597     aCharacter == $P ifTrue:[^ '1' ].

   598 

   599     aCharacter == $F ifTrue:[^ '2' ]. 

   600     aCharacter == $V ifTrue:[^ '2' ]. 

   601 

   602     aCharacter == $C ifTrue:[^ '3' ]. 

   603     aCharacter == $S ifTrue:[^ '3' ]. 

   604     aCharacter == $K ifTrue:[^ '3' ].

   605 

   606     aCharacter == $G ifTrue:[^ '4' ]. 

   607     aCharacter == $J ifTrue:[^ '4' ].

   608 

   609     aCharacter == $Q ifTrue:[^ '5' ]. 

   610     aCharacter == $X ifTrue:[^ '5' ]. 

   611     aCharacter == $Z ifTrue:[^ '5' ]. 

   612 

   613     aCharacter == $D ifTrue:[^ '6' ]. 

   614     aCharacter == $G ifTrue:[^ '6' ]. 

   615     aCharacter == $T ifTrue:[^ '6' ]. 

   616 

   617     aCharacter == $L ifTrue:[^ '7' ]. 

   618 

   619     aCharacter == $M ifTrue:[^ '8' ]. 

   620     aCharacter == $N ifTrue:[^ '8' ]. 

   621 

   622     aCharacter == $R ifTrue:[^ '9' ]. 

   623     ^ nil

   624 ! !

   625 

   626 !PhoneticStringUtilities::SingleResultPhoneticStringComparator class methodsFor:'documentation'!

   627 

   628 documentation

   629 "

   630     documentation to be added.

   631 

   632     [author:]

   633         cg

   634 

   635     [instance variables:]

   636 

   637     [class variables:]

   638 

   639     [see also:]

   640 

   641 "

   642 ! !

   643 

   644 !PhoneticStringUtilities::SingleResultPhoneticStringComparator methodsFor:'api'!

   645 

   646 encode:word

   647     ^ self subclassResponsibility

   648 

   649     "Created: / 28-07-2017 / 15:20:49 / cg"

   650 !

   651 

   652 phoneticStringsFor:word 

   653     ^ Array with:(self encode:word)

   654 

   655     "Created: / 28-07-2017 / 15:20:38 / cg"

   656 ! !

   657 

   658 !PhoneticStringUtilities::MRAStringComparator class methodsFor:'documentation'!

   659 

   660 documentation

   661 "

   662     Match Rating Approach Encoder

   663 

   664     The Western Airlines matching rating approach name encoder

   665 

   666     [see also:]

   667         https://en.wikipedia.org/wiki/Match_Rating_Approach

   668         

   669         G.B. Moore, J.L. Kuhns, J.L. Treffzs, and C.A. Montgomery,

   670             ''Accessing Individual Records from Personal Data Files Using Nonunique Identifiers'' 

   671             US National Institute of Standards and Technology, SP-500-2 (1977), p. 17.

   672 "

   673 !

   674 

   675 rCode

   677 ## Copyright (c) 2015, James P. Howard, II <jh@jameshoward.us>

   613 /*

   678 ##

   614  * Licensed to the Apache Software Foundation (ASF) under one or more

   679 ## Redistribution and use in source and binary forms, with or without

   615  * contributor license agreements.  See the NOTICE file distributed with

   680 ## modification, are permitted provided that the following conditions are

   616  * this work for additional information regarding copyright ownership.

   681 ## met:

   617  * The ASF licenses this file to You under the Apache License, Version 2.0

   682 ##

   618  * (the "License"); you may not use this file except in compliance with

   683 ##     Redistributions of source code must retain the above copyright

   619  * the License.  You may obtain a copy of the License at

   684 ##     notice, this list of conditions and the following disclaimer.

   620  *

   685 ##

   621  *      http://www.apache.org/licenses/LICENSE-2.0

   686 ##     Redistributions in binary form must reproduce the above copyright

   622  *

   687 ##     notice, this list of conditions and the following disclaimer in

   623  * Unless required by applicable law or agreed to in writing, software

   688 ##     the documentation and/or other materials provided with the

   624  * distributed under the License is distributed on an "AS IS" BASIS,

   689 ##     distribution.

   625  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   690 ##

   626  * See the License for the specific language governing permissions and

   691 ## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

   627  * limitations under the License.

   692 ## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

   628  */

   693 ## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

   629 package org.apache.commons.codec.language;

   694 ## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

   630 

   695 ## HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

   631 import org.apache.commons.codec.CharEncoding;

   696 ## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

   632 import org.apache.commons.codec.EncoderException;

   697 ## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

   633 import org.apache.commons.codec.StringEncoder;

   698 ## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

   634 

   699 ## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

   635 import java.io.InputStream;

   700 ## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

   636 import java.util.*;

   701 ## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

   637 

   702 

   638 /**

   703 #' @rdname mra

   639  * Encodes a string into a Daitch-Mokotoff Soundex value.

   704 #' @title Match Rating Approach Encoder

   640  * <p>

   705 #'

   641  * The Daitch-Mokotoff Soundex algorithm is a refinement of the Russel and American Soundex algorithms, yielding greater

   706 #' @description

   642  * accuracy in matching especially Slavish and Yiddish surnames with similar pronunciation but differences in spelling.

   707 #' The Western Airlines matching rating approach name encoder

   643  * </p>

   708 #'

   644  * <p>

   709 #' @param word string or vector of strings to encode

   645  * The main differences compared to the other soundex variants are:

   710 #' @param x MRA-encoded character vector

   646  * </p>

   711 #' @param y MRA-encoded character vector

   647  * <ul>

   712 #'

   648  * <li>coded names are 6 digits long

   713 #' @details

   649  * <li>the initial character of the name is coded

   714 #'

   650  * <li>rules to encoded multi-character n-grams

   715 #' The variable \code{word} is the name to be encoded.  The variable

   651  * <li>multiple possible encodings for the same name (branching)

   716 #' \code{maxCodeLen} is \emph{not} supported in this algorithm encoder

   652  * </ul>

   717 #' because the algorithm itself is dependent upon its six-character

   653  * <p>

   718 #' length.  The variables \code{x} and \code{y} are MRA-encoded and are

   654  * This implementation supports branching, depending on the used method:

   719 #' compared to each other using the MRA comparison specification.

   655  * <ul>

   720 #'

   656  * <li>{@link #encode(String)} - branching disabled, only the first code will be returned

   721 #' @return The \code{mra_encode} function returns match rating approach

   657  * <li>{@link #soundex(String)} - branching enabled, all codes will be returned, separated by '|'

   722 #' encoded character vector.  The \code{mra_compare} returns a boolean

   658  * </ul>

   723 #' vector which is \code{TRUE} if \code{x} and \code{y} pass the MRA

   659  * <p>

   724 #' comparison test.

   660  * Note: this implementation has additional branching rules compared to the original description of the algorithm. The

   725 #'

   661  * rules can be customized by overriding the default rules contained in the resource file

   726 #' @references

   662  * {@code org/apache/commons/codec/language/dmrules.txt}.

   727 #'

   663  * </p>

   728 #' G.B. Moore, J.L. Kuhns, J.L. Treffzs, and C.A. Montgomery,

   664  * <p>

   729 #' \emph{Accessing Individual Records from Personal Data Files Using

   665  * This class is thread-safe.

   730 #' Nonunique Identifiers,} US National Institute of Standards and

   666  * </p>

   731 #' Technology, SP-500-2 (1977), p. 17.

   667  *

   732 #'

   668  * @see Soundex

   733 #' @family phonics

   669  * @see <a href="http://en.wikipedia.org/wiki/Daitch%E2%80%93Mokotoff_Soundex"> Wikipedia - Daitch-Mokotoff Soundex</a>

   734 #'

   670  * @see <a href="http://www.avotaynu.com/soundex.htm">Avotaynu - Soundexing and Genealogy</a>

   735 #' @examples

   671  *

   736 #' mra_encode("William")

   672  * @version $Id$

   737 #' mra_encode(c("Peter", "Peady"))

   673  * @since 1.10

   738 #' mra_encode("Stevenson")

   674  */

   739 

   675 public class DaitchMokotoffSoundex implements StringEncoder {

   740 #' @rdname mra

   676 

   741 #' @name mra_encode

   677     /**

   742 #' @export

   678      * Inner class representing a branch during DM soundex encoding.

   743 mra_encode <- function(word) {

   679      */

   744 

   680     private static final class Branch {

   745     ## First, remove any nonalphabetical characters and uppercase it

   681         private final StringBuilder builder;

   746     word <- gsub("[^[:alpha:]]*", "", word)

   682         private String cachedString;

   747     word <- toupper(word)

   683         private String lastReplacement;

   748 

   684 

   749     ## First character of key = first character of name

   685         private Branch() {

   750     first <- substr(word, 1, 1)

   686             builder = new StringBuilder();

   751     word <- substr(word, 2, nchar(word))

   687             lastReplacement = null;

   752 

   688             cachedString = null;

   753     ## Delete vowels not at the start of the word

   689         }

   754     word <- gsub("[AEIOU]", "", word)

   690 

   755     word <- paste(first, word, sep = "")

   691         /**

   756 

   692          * Creates a new branch, identical to this branch.

   757     ## Remove duplicate consecutive characters

   693          *

   758     word <- gsub("([A-Z])\\1+", "\\1", word)

   694          * @return a new, identical branch

   759 

   695          */

   760     ## If longer than 6 characters, take first and last 3...and we have

   696         public Branch createBranch() {

   761     ## to vectorize it

   697             final Branch branch = new Branch();

   762     for(i in 1:length(word)) {

   698             branch.builder.append(toString());

   763         if((l = nchar(word[i])) > 6) {

   699             branch.lastReplacement = this.lastReplacement;

   764             first <- substr(word[i], 1, 3)

   700             return branch;

   765             last <- substr(word[i], l - 2, l)

   701         }

   766             word[i] <- paste(first, last, sep = "");

   702 

   703         @Override

   704         public boolean equals(final Object other) {

   705             if (this == other) {

   706                 return true;

   707             }

   708             if (!!(other instanceof Branch)) {

   709                 return false;

   710             }

   711 

   712             return toString().equals(((Branch) other).toString());

   713         }

   714 

   715         /**

   716          * Finish this branch by appending '0's until the maximum code length has been reached.

   717          */

   718         public void finish() {

   719             while (builder.length() < MAX_LENGTH) {

   720                 builder.append('0');

   721                 cachedString = null;

   722             }

   723         }

   724 

   725         @Override

   726         public int hashCode() {

   727             return toString().hashCode();

   728         }

   729 

   730         /**

   731          * Process the next replacement to be added to this branch.

   732          *

   733          * @param replacement

   734          *            the next replacement to append

   735          * @param forceAppend

   736          *            indicates if the default processing shall be overridden

   737          */

   738         public void processNextReplacement(final String replacement, final boolean forceAppend) {

   739             final boolean append = lastReplacement == null || !!lastReplacement.endsWith(replacement) || forceAppend;

   740 

   741             if (append && builder.length() < MAX_LENGTH) {

   742                 builder.append(replacement);

   743                 // remove all characters after the maximum length

   744                 if (builder.length() > MAX_LENGTH) {

   745                     builder.delete(MAX_LENGTH, builder.length());

   746                 }

   747                 cachedString = null;

   748             }

   749 

   750             lastReplacement = replacement;

   751         }

   752 

   753         @Override

   754         public String toString() {

   755             if (cachedString == null) {

   756                 cachedString = builder.toString();

   757             }

   758             return cachedString;

   770     return(word)

   762     /**

   763      * Inner class for storing rules.

   764      */

   765     private static final class Rule {

   766         private final String pattern;

   767         private final String[] replacementAtStart;

   768         private final String[] replacementBeforeVowel;

   769         private final String[] replacementDefault;

   770 

   771         protected Rule(final String pattern, final String replacementAtStart, final String replacementBeforeVowel,

   772                 final String replacementDefault) {

   773             this.pattern = pattern;

   774             this.replacementAtStart = replacementAtStart.split("\\|");

   775             this.replacementBeforeVowel = replacementBeforeVowel.split("\\|");

   776             this.replacementDefault = replacementDefault.split("\\|");

   777         }

   778 

   779         public int getPatternLength() {

   780             return pattern.length();

   781         }

   782 

   783         public String[] getReplacements(final String context, final boolean atStart) {

   784             if (atStart) {

   785                 return replacementAtStart;

   786             }

   787 

   788             final int nextIndex = getPatternLength();

   789             final boolean nextCharIsVowel = nextIndex < context.length() ? isVowel(context.charAt(nextIndex)) : false;

   790             if (nextCharIsVowel) {

   791                 return replacementBeforeVowel;

   792             }

   793 

   794             return replacementDefault;

   795         }

   796 

   797         private boolean isVowel(final char ch) {

   798             return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';

   799         }

   800 

   801         public boolean matches(final String context) {

   802             return context.startsWith(pattern);

   803         }

   804 

   805         @Override

   806         public String toString() {

   807             return String.format("%s=(%s,%s,%s)", pattern, Arrays.asList(replacementAtStart),

   808                     Arrays.asList(replacementBeforeVowel), Arrays.asList(replacementDefault));

   809         }

   810     }

   811 

   812     private static final String COMMENT = "//";

   813     private static final String DOUBLE_QUOTE = "\"";

   814 

   815     private static final String MULTILINE_COMMENT_END = "*/";

   816 

   817     private static final String MULTILINE_COMMENT_START = "/*";

   818 

   819     /** The resource file containing the replacement and folding rules */

   820     private static final String RESOURCE_FILE = "org/apache/commons/codec/language/dmrules.txt";

   821 

   822     /** The code length of a DM soundex value. */

   823     private static final int MAX_LENGTH = 6;

   824 

   825     /** Transformation rules indexed by the first character of their pattern. */

   826     private static final Map<Character, List<Rule>> RULES = new HashMap<Character, List<Rule>>();

   827 

   828     /** Folding rules. */

   829     private static final Map<Character, Character> FOLDINGS = new HashMap<Character, Character>();

   830 

   831     static {

   832         final InputStream rulesIS = DaitchMokotoffSoundex.class.getClassLoader().getResourceAsStream(RESOURCE_FILE);

   833         if (rulesIS == null) {

   834             throw new IllegalArgumentException("Unable to load resource: " + RESOURCE_FILE);

   835         }

   836 

   837         final Scanner scanner = new Scanner(rulesIS, CharEncoding.UTF_8);

   838         parseRules(scanner, RESOURCE_FILE, RULES, FOLDINGS);

   839         scanner.close();

   840 

   841         // sort RULES by pattern length in descending order

   842         for (final Map.Entry<Character, List<Rule>> rule : RULES.entrySet()) {

   843             final List<Rule> ruleList = rule.getValue();

   844             Collections.sort(ruleList, new Comparator<Rule>() {

   845                 @Override

   846                 public int compare(final Rule rule1, final Rule rule2) {

   847                     return rule2.getPatternLength() - rule1.getPatternLength();

   848                 }

   849             });

   850         }

   851     }

   852 

   853     private static void parseRules(final Scanner scanner, final String location,

   854             final Map<Character, List<Rule>> ruleMapping, final Map<Character, Character> asciiFoldings) {

   855         int currentLine = 0;

   856         boolean inMultilineComment = false;

   857 

   858         while (scanner.hasNextLine()) {

   859             currentLine++;

   860             final String rawLine = scanner.nextLine();

   861             String line = rawLine;

   862 

   863             if (inMultilineComment) {

   864                 if (line.endsWith(MULTILINE_COMMENT_END)) {

   865                     inMultilineComment = false;

   866                 }

   867                 continue;

   868             }

   869 

   870             if (line.startsWith(MULTILINE_COMMENT_START)) {

   871                 inMultilineComment = true;

   872             } else {

   873                 // discard comments

   874                 final int cmtI = line.indexOf(COMMENT);

   875                 if (cmtI >= 0) {

   876                     line = line.substring(0, cmtI);

   877                 }

   878 

   879                 // trim leading-trailing whitespace

   880                 line = line.trim();

   881 

   882                 if (line.length() == 0) {

   883                     continue; // empty lines can be safely skipped

   884                 }

   885 

   886                 if (line.contains("=")) {

   887                     // folding

   888                     final String[] parts = line.split("=");

   889                     if (parts.length !!= 2) {

   890                         throw new IllegalArgumentException("Malformed folding statement split into " + parts.length +

   891                                 " parts: " + rawLine + " in " + location);

   892                     } else {

   893                         final String leftCharacter = parts[0];

   894                         final String rightCharacter = parts[1];

   895 

   896                         if (leftCharacter.length() !!= 1 || rightCharacter.length() !!= 1) {

   897                             throw new IllegalArgumentException("Malformed folding statement - " +

   898                                     "patterns are not single characters: " + rawLine + " in " + location);

   899                         }

   900 

   901                         asciiFoldings.put(leftCharacter.charAt(0), rightCharacter.charAt(0));

   902                     }

   903                 } else {

   904                     // rule

   905                     final String[] parts = line.split("\\s+");

   906                     if (parts.length !!= 4) {

   907                         throw new IllegalArgumentException("Malformed rule statement split into " + parts.length +

   908                                 " parts: " + rawLine + " in " + location);

   909                     } else {

   910                         try {

   911                             final String pattern = stripQuotes(parts[0]);

   912                             final String replacement1 = stripQuotes(parts[1]);

   913                             final String replacement2 = stripQuotes(parts[2]);

   914                             final String replacement3 = stripQuotes(parts[3]);

   915 

   916                             final Rule r = new Rule(pattern, replacement1, replacement2, replacement3);

   917                             final char patternKey = r.pattern.charAt(0);

   918                             List<Rule> rules = ruleMapping.get(patternKey);

   919                             if (rules == null) {

   920                                 rules = new ArrayList<Rule>();

   921                                 ruleMapping.put(patternKey, rules);

   922                             }

   923                             rules.add(r);

   924                         } catch (final IllegalArgumentException e) {

   925                             throw new IllegalStateException(

   926                                     "Problem parsing line '" + currentLine + "' in " + location, e);

   927                         }

   928                     }

   929                 }

   930             }

   931         }

   932     }

   933 

   934     private static String stripQuotes(String str) {

   935         if (str.startsWith(DOUBLE_QUOTE)) {

   936             str = str.substring(1);

   937         }

   938 

   939         if (str.endsWith(DOUBLE_QUOTE)) {

   940             str = str.substring(0, str.length() - 1);

   941         }

   942 

   943         return str;

   944     }

   945 

   946     /** Whether to use ASCII folding prior to encoding. */

   947     private final boolean folding;

   948 

   949     /**

   950      * Creates a new instance with ASCII-folding enabled.

   951      */

   952     public DaitchMokotoffSoundex() {

   953         this(true);

   954     }

   955 

   956     /**

   957      * Creates a new instance.

   958      * <p>

   959      * With ASCII-folding enabled, certain accented characters will be transformed to equivalent ASCII characters, e.g.

   960      * è -> e.

   961      * </p>

   962      *

   963      * @param folding

   964      *            if ASCII-folding shall be performed before encoding

   965      */

   966     public DaitchMokotoffSoundex(final boolean folding) {

   967         this.folding = folding;

   968     }

   969 

   970     /**

   971      * Performs a cleanup of the input string before the actual soundex transformation.

   972      * <p>

   973      * Removes all whitespace characters and performs ASCII folding if enabled.

   974      * </p>

   975      *

   976      * @param input

   977      *            the input string to cleanup

   978      * @return a cleaned up string

   979      */

   980     private String cleanup(final String input) {

   981         final StringBuilder sb = new StringBuilder();

   982         for (char ch : input.toCharArray()) {

   983             if (Character.isWhitespace(ch)) {

   984                 continue;

   985             }

   986 

   987             ch = Character.toLowerCase(ch);

   988             if (folding && FOLDINGS.containsKey(ch)) {

   989                 ch = FOLDINGS.get(ch);

   990             }

   991             sb.append(ch);

   992         }

   993         return sb.toString();

   994     }

   995 

   996     /**

   997      * Encodes an Object using the Daitch-Mokotoff soundex algorithm without branching.

   998      * <p>

   999      * This method is provided in order to satisfy the requirements of the Encoder interface, and will throw an

  1000      * EncoderException if the supplied object is not of type java.lang.String.

  1001      * </p>

  1002      *

  1003      * @see #soundex(String)

  1004      *

  1005      * @param obj

  1006      *            Object to encode

  1007      * @return An object (of type java.lang.String) containing the DM soundex code, which corresponds to the String

  1008      *         supplied.

  1009      * @throws EncoderException

  1010      *             if the parameter supplied is not of type java.lang.String

  1011      * @throws IllegalArgumentException

  1012      *             if a character is not mapped

  1013      */

  1014     @Override

  1015     public Object encode(final Object obj) throws EncoderException {

  1016         if (!!(obj instanceof String)) {

  1017             throw new EncoderException(

  1018                     "Parameter supplied to DaitchMokotoffSoundex encode is not of type java.lang.String");

  1019         }

  1020         return encode((String) obj);

  1021     }

  1022 

  1023     /**

  1024      * Encodes a String using the Daitch-Mokotoff soundex algorithm without branching.

  1025      *

  1026      * @see #soundex(String)

  1027      *

  1028      * @param source

  1029      *            A String object to encode

  1030      * @return A DM Soundex code corresponding to the String supplied

  1031      * @throws IllegalArgumentException

  1032      *             if a character is not mapped

  1033      */

  1034     @Override

  1035     public String encode(final String source) {

  1036         if (source == null) {

  1037             return null;

  1038         }

  1039         return soundex(source, false)[0];

  1040     }

  1041 

  1042     /**

  1043      * Encodes a String using the Daitch-Mokotoff soundex algorithm with branching.

  1044      * <p>

  1045      * In case a string is encoded into multiple codes (see branching rules), the result will contain all codes,

  1046      * separated by '|'.

  1047      * </p>

  1048      * <p>

  1049      * Example: the name "AUERBACH" is encoded as both

  1050      * </p>

  1051      * <ul>

  1052      * <li>097400</li>

  1053      * <li>097500</li>

  1054      * </ul>

  1055      * <p>

  1056      * Thus the result will be "097400|097500".

  1057      * </p>

  1058      *

  1059      * @param source

  1060      *            A String object to encode

  1061      * @return A string containing a set of DM Soundex codes corresponding to the String supplied

  1062      * @throws IllegalArgumentException

  1063      *             if a character is not mapped

  1064      */

  1065     public String soundex(final String source) {

  1066         final String[] branches = soundex(source, true);

  1067         final StringBuilder sb = new StringBuilder();

  1068         int index = 0;

  1069         for (final String branch : branches) {

  1070             sb.append(branch);

  1071             if (++index < branches.length) {

  1072                 sb.append('|');

  1073             }

  1074         }

  1075         return sb.toString();

  1076     }

  1077 

  1078     /**

  1079      * Perform the actual DM Soundex algorithm on the input string.

  1080      *

  1081      * @param source

  1082      *            A String object to encode

  1083      * @param branching

  1084      *            If branching shall be performed

  1085      * @return A string array containing all DM Soundex codes corresponding to the String supplied depending on the

  1086      *         selected branching mode

  1087      */

  1088     private String[] soundex(final String source, final boolean branching) {

  1089         if (source == null) {

  1090             return null;

  1091         }

  1092 

  1093         final String input = cleanup(source);

  1094 

  1095         final Set<Branch> currentBranches = new LinkedHashSet<Branch>();

  1096         currentBranches.add(new Branch());

  1097 

  1098         char lastChar = '\0';

  1099         for (int index = 0; index < input.length(); index++) {

  1100             final char ch = input.charAt(index);

  1101 

  1102             // ignore whitespace inside a name

  1103             if (Character.isWhitespace(ch)) {

  1104                 continue;

  1105             }

  1106 

  1107             final String inputContext = input.substring(index);

  1108             final List<Rule> rules = RULES.get(ch);

  1109             if (rules == null) {

  1110                 continue;

  1111             }

  1112 

  1113             // use an EMPTY_LIST to avoid false positive warnings wrt potential null pointer access

  1114             @SuppressWarnings("unchecked")

  1115             final List<Branch> nextBranches = branching ? new ArrayList<Branch>() : Collections.EMPTY_LIST;

  1116 

  1117             for (final Rule rule : rules) {

  1118                 if (rule.matches(inputContext)) {

  1119                     if (branching) {

  1120                         nextBranches.clear();

  1121                     }

  1122                     final String[] replacements = rule.getReplacements(inputContext, lastChar == '\0');

  1123                     final boolean branchingRequired = replacements.length > 1 && branching;

  1124 

  1125                     for (final Branch branch : currentBranches) {

  1126                         for (final String nextReplacement : replacements) {

  1127                             // if we have multiple replacements, always create a new branch

  1128                             final Branch nextBranch = branchingRequired ? branch.createBranch() : branch;

  1129 

  1130                             // special rule: occurrences of mn or nm are treated differently

  1131                             final boolean force = (lastChar == 'm' && ch == 'n') || (lastChar == 'n' && ch == 'm');

  1132 

  1133                             nextBranch.processNextReplacement(nextReplacement, force);

  1134 

  1135                             if (branching) {

  1136                                 nextBranches.add(nextBranch);

  1137                             } else {

  1138                                 break;

  1139                             }

  1140                         }

  1141                     }

  1142 

  1143                     if (branching) {

  1144                         currentBranches.clear();

  1145                         currentBranches.addAll(nextBranches);

  1146                     }

  1147                     index += rule.getPatternLength() - 1;

  1148                     break;

  1149                 }

  1150             }

  1151 

  1152             lastChar = ch;

  1153         }

  1154 

  1155         final String[] result = new String[currentBranches.size()];

  1156         int index = 0;

  1157         for (final Branch branch : currentBranches) {

  1158             branch.finish();

  1159             result[index++] = branch.toString();

  1160         }

  1161 

  1162         return result;

  1163     }

   772 

  1165 END>>"

   773 #' @rdname mra

   774 #' @name mra_compare

   775 #' @export

   776 mra_compare <- function(x, y) {

   777     mra <- data.frame(x = x, y = y, sim = 0, min = 100, stringsAsFactors = FALSE)

   778 

   779     ## Obtain the minimum rating value by calculating the length sum of

   780     ## the encoded strings and using table A (from Wikipedia).  We start

   781     ## by setting the minimum to be the sum and move from there.

   782     mra$lensum <- nchar(mra$x) + nchar(mra$y)

   783     mra$min[mra$lensum == 12] <- 2

   784     mra$min[mra$lensum > 7 && mra$lensum <= 11] <- 3

   785     mra$min[mra$lensum > 4 && mra$lensum <= 7] <- 4

   786     mra$min[mra$lensum <= 4] <- 5

   787 

   788     ## If the length difference between the encoded strings is 3 or

   789     ## greater, then no similarity comparison is done.  For us, we

   790     ## continue the similarity comparison out of laziness and ensure the

   791     ## minimum is impossibly high to meet.

   792     mra$min[abs(nchar(mra$x) - nchar(mra$y)) >= 3] <- 100

   793 

   794     ## Start the comparison.

   795     x <- strsplit(mra$x, split = "")

   796     y <- strsplit(mra$y, split = "")

   797     rows <- nrow(mra)

   798     for(i in 1:rows) {

   799         ## Process the encoded strings from left to right and remove any

   800         ## identical characters found from both strings respectively.

   801         j <- 1

   802         while(j < min(length(x[[i]]), length(y[[i]]))) {

   803             if(x[[i]][j] == y[[i]][j]) {

   804                 x[[i]] <- x[[i]][-j]

   805                 y[[i]] <- y[[i]][-j]

   806             } else

   807                 j <- j + 1

   808         }

   809 

   810         ## Process the unmatched characters from right to left and

   811         ## remove any identical characters found from both names

   812         ## respectively.

   813         x[[i]] <- rev(x[[i]])

   814         y[[i]] <- rev(y[[i]])

   815         j <- 1

   816         while(j < min(length(x[[i]]), length(y[[i]]))) {

   817             if(x[[i]][j] == y[[i]][j]) {

   818                 x[[i]] <- x[[i]][-j]

   819                 y[[i]] <- y[[i]][-j]

   820             } else

   821                 j <- j + 1

   822         }

   823         ## Subtract the number of unmatched characters from 6 in the

   824         ## longer string. This is the similarity rating.

   825         len <- min(length(x[[i]]), length(y[[i]]))

   826         mra$sim[i] <- 6 - len

   827     }

   828 

   829     ## If the similarity is greater than or equal to the minimum

   830     ## required, it is a successful match.

   831     mra$match <- (mra$sim >= mra$min)

   832     return(mra$match)

   833 }

   834 

   835 END>>

   836 ! !

   837 

   838 !PhoneticStringUtilities::MRAStringComparator methodsFor:'api'!

   839 

   840 encode:wordIn 

   841     "see https://en.wikipedia.org/wiki/Match_Rating_Approach"

   842     

   843     |word prev|

   844 

   845     word := wordIn.

   846     

   847     "/ First, remove any nonalphabetical characters and uppercase it

   848 

   849     word := word select:#isLetter thenCollect:#asUppercase.

   850 

   851     "/ Delete vowels not at the start of the word

   852 

   853     word := word first asString , ((word from:2) reject:#isVowel).

   854 

   855     "/ Remove duplicate consecutive characters

   856 

   857     prev := nil.

   858     word := word 

   859                 collect:[:char |

   860                     char == prev ifTrue:[

   861                         $*

   862                     ] ifFalse:[

   863                         prev := char.

   864                         char.

   865                     ].    

   866                 ]

   867                 thenSelect:[:char | char ~~ $*].

   868 

   869     "/ If longer than 6 characters, take first and last 3            

   870     word size > 6 ifTrue:[

   871         word := (word copyFirst:3),(word copyLast:3)

   872     ].

   873     ^ word.

   874 

   875     "

   876      self new encode:'Catherine'            -> 'CTHRN'

   877      self new encode:'CatherineCatherine'   -> 'CTHHRN'

   878      self new encode:'Butter'               -> 'BTR'

   879      self new encode:'Byrne'                -> 'BYRN'

   880      self new encode:'Boern'                -> 'BRN'

   881      self new encode:'Smith'                -> 'SMTH'

   882      self new encode:'Smyth'                -> 'SMYTH'

   883      self new encode:'Kathryn'              -> 'KTHRYN'

   884     "

   885 

   886     "Created: / 28-07-2017 / 15:19:22 / cg"

   887     "Modified (comment): / 31-07-2017 / 15:14:31 / cg"

   888 ! !

   889 

   890 !PhoneticStringUtilities::SoundexStringComparator class methodsFor:'documentation'!

   891 

   892 documentation

   893 "

   894     WARNING: this is the so called 'simplified soundex' algorithm;

   895       there are more variants like miracode (american soundex) or

   896       mysqlSoundex around.

   897       

   898       Be sure to use the correct algorithm, if the generated strings must be compatible

   899       (otherwise, the differences are probably too small to be noticed as effect, but

   900       your search will be different)

   901 

   902     The following was copied from http://www.civilsolutions.com.au/publications/dedup.htm

   903 

   904     SOUNDEX is a phonetic coding algorithm that ignores many of the unreliable

   905     components of names, but by doing so reports more matches. 

   906 

   907     There are some variations around in the literature; 

   908     the following is called 'simplified soundex', and the rules for coding a name are:

   909 

   910     1. The first letter of the name is used in its un-coded form to serve as the prefix

   911        character of the code. (The rest of the code is numerical).

   912 

   913     2. Thereafter, W and H are ignored entirely.

   914 

   915     3. A, E, I, 0, U, Y are not assigned a code number, but do serve as 'separators' (see Step 5).

   916 

   917     4. Other letters of the name are converted to a numerical equivalent:

   918                  B, P, F, V              1 

   919                  C, G, J, K, Q, S, X, Z  2 

   920                  D, T                    3 

   921                  L                       4 

   922                  M, N                    5 

   923                  R                       6 

   924 

   925     5. There are two exceptions: 

   926         1. Letters that follow prefix letters which would, if coded, have the same

   927            numerical code, are ignored in all cases unless a ''separator'' (see Step 3) precedes them.

   928 

   929         2. The second letter of any pair of consonants having the same code number is likewise ignored, 

   930            i.e. unless there is a ''separator'' between them in the name.

   931 

   932     6. The final SOUNDEX code consists of the prefix letter plus three numerical characters.

   933        Longer codes are truncated to this length, and shorter codes are extended to it by adding zeros.

   934 

   935     Notice, that in another variant, w and h are treated slightly differently.

   936     This is only of relevance, if you need to reconstruct original soundex codes of other programs

   937     or for the original 1880 us census data.

   938     

   939     Also notice, that soundex deals better with english. 

   940     For german and other languages, other algorithms may provide better results.

   941 "

   942 ! !

   943 

   944 !PhoneticStringUtilities::SoundexStringComparator methodsFor:'api'!

   945 

   946 encode:word 

   947     |u p t prevCode|

   948 

   949     u := word asUppercase.

   950     p := u first asString.

   951     prevCode := self translate:u first.

   952     u from:2 to:u size do:[:c | 

   953         t := self translate:c.

   954         (t notNil and:[ t ~= '0' and:[ t ~= prevCode ]]) ifTrue:[

   955             p := p , t.

   956             p size == 4 ifTrue:[^ p ].

   957         ].

   958         prevCode := t

   959     ].

   960     [ p size < 4 ] whileTrue:[

   961         p := p , '0'

   962     ].

   963     ^ (p copyFrom:1 to:4)

   964 

   965     "

   966      self new encode:'washington' -> 'W252'

   967      self new encode:'lee'        -> 'L000'

   968      self new encode:'Gutierrez'  -> 'G362'

   969      self new encode:'Pfister'    -> 'P236'

   970      self new encode:'Jackson'    -> 'J250'

   971      self new encode:'Tymczak'    -> 'T522'

   972     "

   973     

   974     "notice:

   975      MiracodeStringComparator new encode:'Ashcraft' -> 'A261'

   976      self new encode:'Ashcraft'   -> 'A226'

   977     "

   978 

   979     "Created: / 28-07-2017 / 15:21:23 / cg"

   980     "Modified (comment): / 01-08-2017 / 19:01:43 / cg"

   981 ! !

   982 

   983 !PhoneticStringUtilities::SoundexStringComparator methodsFor:'private'!

   984 

   985 translate:aCharacter

   986     "use simple if's for more speed when compiled"

   987 

   988     "vowels serve as separators"

   989     aCharacter == $A ifTrue:[^ '0' ].         

   990     aCharacter == $E ifTrue:[^ '0' ].

   991     aCharacter == $I ifTrue:[^ '0' ].

   992     aCharacter == $O ifTrue:[^ '0' ].

   993     aCharacter == $U ifTrue:[^ '0' ].

   994     aCharacter == $Y ifTrue:[^ '0' ].

   995 

   996     aCharacter == $B ifTrue:[^ '1' ]. 

   997     aCharacter == $P ifTrue:[^ '1' ]. 

   998     aCharacter == $F ifTrue:[^ '1' ]. 

   999     aCharacter == $V ifTrue:[^ '1' ]. 

  1000 

  1001     aCharacter == $C ifTrue:[^ '2' ]. 

  1002     aCharacter == $S ifTrue:[^ '2' ]. 

  1003     aCharacter == $K ifTrue:[^ '2' ]. 

  1004     aCharacter == $G ifTrue:[^ '2' ]. 

  1005     aCharacter == $J ifTrue:[^ '2' ]. 

  1006     aCharacter == $Q ifTrue:[^ '2' ]. 

  1007     aCharacter == $X ifTrue:[^ '2' ]. 

  1008     aCharacter == $Z ifTrue:[^ '2' ]. 

  1009 

  1010     aCharacter == $D ifTrue:[^ '3' ]. 

  1011     aCharacter == $T ifTrue:[^ '3' ]. 

  1012 

  1013     aCharacter == $L ifTrue:[^ '4' ]. 

  1014 

  1015     aCharacter == $M ifTrue:[^ '5' ]. 

  1016     aCharacter == $N ifTrue:[^ '5' ]. 

  1017 

  1018     aCharacter == $R ifTrue:[^ '6' ]. 

  1019     ^ nil

  1020 ! !

  1021 

  1022 !PhoneticStringUtilities::MySQLSoundexStringComparator class methodsFor:'documentation'!

  1023 

  1024 documentation

  1025 "

  1026     MySQL soundex is like american Soundex (i.e. miracode) without the 4 character limitation,

  1027     and also removing vokals first, then removing duplicate codes

  1028     (whereas the soundex code does this in reverse order).

  1029 

  1030     These variations are important, if you need the miracode soundex codes to be generated.

  1031 "

  1032 ! !

  1033 

  1034 !PhoneticStringUtilities::MySQLSoundexStringComparator methodsFor:'api'!

  1035 

  1036 encode:word 

  1037     |u p t prevCode|