natural 7.0.2 → 7.0.5

package/ts_spec/hamming_distance_spec.ts

@@ -1,66 +0,0 @@
-/*
-Copyright (c) 2018, Hugo ter Doest
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-'use strict'
-
-import { HammingDistance as hammingDistance } from 'lib/natural'
-
-// Convert the following to a Javascript object
-const stringsToCompare = [{
-  string1: 'karolin',
-  string2: 'kathrin',
-  ignoreCase: false,
-  expected: 3
-}, {
-  string1: 'karolin',
-  string2: 'kerstin',
-  ignoreCase: false,
-  expected: 3
-}, {
-  string1: '1011101',
-  string2: '1001001',
-  ignoreCase: false,
-  expected: 2
-}, {
-  string1: '2173896',
-  string2: '2233796',
-  ignoreCase: false,
-  expected: 3
-}, {
-  string1: 'different',
-  string2: 'length',
-  ignoreCase: false,
-  expected: -1
-}, {
-  string1: 'ignorecase',
-  string2: 'IgnoreCase',
-  ignoreCase: true,
-  expected: 0
-}]
-
-describe('The Hamming distance function compares strings of equal length', function () {
-  stringsToCompare.forEach(function (record) {
-    it('should calculate the difference between two strings correctly', function () {
-      expect(hammingDistance(record.string1, record.string2, record.ignoreCase)).toEqual(record.expected)
-    })
-  })
-})

package/ts_spec/jaro-winkler_spec.ts

@@ -1,79 +0,0 @@
-/*
-Copyright (c) 2011, Chris Umbel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-'use strict'
-
-import { JaroWinklerDistance } from 'lib/natural'
-
-/*
-Do not change the prototype of native types
-Number.prototype.approxEql = function (val) {
-  return Math.abs(this - val) < 1e-5
-}
-*/
-
-function approxEql (val1: number, val2: number): boolean {
-  return Math.abs(val1 - val2) < 1e-5
-}
-
-describe('jaro-winkler', function () {
-  it('should evaluate string similarity', function () {
-    expect(approxEql(JaroWinklerDistance('DIXON', 'DICKSONX', {}), 0.81333)).toBeTruthy()
-    expect(approxEql(JaroWinklerDistance('DWAYNE', 'DUANE', {}), 0.84)).toBeTruthy()
-  })
-
-  it('should handle exact matches', function () {
-    expect(JaroWinklerDistance('RICK', 'RICK', {})).toBe(1)
-    expect(JaroWinklerDistance('abc', 'abc', {})).toBe(1)
-    expect(JaroWinklerDistance('abcd', 'abcd', {})).toBe(1)
-    expect(JaroWinklerDistance('seddon', 'seddon', {})).toBe(1)
-  })
-
-  it('should handle total mis-matches', function () {
-    expect(JaroWinklerDistance('NOT', 'SAME', {})).toBe(0)
-  })
-
-  it('should handle partial mis-matches', function () {
-    expect(approxEql(JaroWinklerDistance('aaa', 'abcd', {}), 0.575)).toBeTruthy()
-  })
-
-  it('should handle transpositions', function () {
-    expect(approxEql(JaroWinklerDistance('MARTHA', 'MARHTA', {}), 0.96111)).toBeTruthy()
-  })
-
-  it('should handle transpositions regardless of string order', function () {
-    expect(approxEql(JaroWinklerDistance('class', 'clams', {}), 0.90666)).toBeTruthy()
-    expect(approxEql(JaroWinklerDistance('clams', 'class', {}), 0.90666)).toBeTruthy()
-  })
-
-  it('should ignore case when asked to', function () {
-    expect(JaroWinklerDistance('aaa', 'aAa', { ignoreCase: true })).toEqual(JaroWinklerDistance('aaa', 'aaa', {}))
-    expect(JaroWinklerDistance('aaa', 'aAa', {})).not.toEqual(JaroWinklerDistance('aaa', 'aaa', {}))
-    expect(JaroWinklerDistance('dixon', 'DICKSONX', { ignoreCase: true })).toEqual(JaroWinklerDistance('DIXON', 'DICKSONX', {}))
-    expect(JaroWinklerDistance('seddon', 'SEDDON', { ignoreCase: true })).toEqual(JaroWinklerDistance('SEDDON', 'SEDDON', {}))
-    expect(approxEql(JaroWinklerDistance('MARTHA', 'MARHTA', { ignoreCase: true }), 0.96111)).toBeTruthy()
-    expect(JaroWinklerDistance('abcd', 'ABCD', { ignoreCase: true })).toBe(1)
-  })
-  it('should not fail while passing no options', function () {
-    expect(approxEql(JaroWinklerDistance('check', 'chakk'), 0.78666)).toBeTruthy()
-  })
-})

package/ts_spec/lancaster_stemmer_spec.ts

@@ -1,63 +0,0 @@
-/*
-Copyright (c) 2011, Chris Umbel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-'use strict'
-
-import { LancasterStemmer as stemmer } from 'lib/natural'
-
-describe('lancaster_stemmer', function () {
-  it('should stem', function () {
-    expect(stemmer.stem('marks')).toBe('mark')
-    expect(stemmer.stem('MARKs')).toBe('mark')
-  })
-
-  it('should stop running rules where appropriate', function () {
-    expect(stemmer.stem('living')).toBe('liv')
-    expect(stemmer.stem('thing')).toBe('thing')
-    expect(stemmer.stem('ear')).toBe('ear')
-    expect(stemmer.stem('string')).toBe('string')
-  })
-
-  it('should only pop the size specified by the rule', function () {
-    expect(stemmer.stem('triplicate')).toBe('triply')
-    expect(stemmer.stem('triPlicAte')).toBe('triply')
-  })
-
-  it('should stem and append and recurse', function () {
-    expect(stemmer.stem('classified')).toBe('class')
-    expect(stemmer.stem('ClaSsiFied')).toBe('class')
-  })
-
-  it('should apply intact rules only to intact string', function () {
-    expect(stemmer.stem('maximum')).toBe('maxim')
-    expect(stemmer.stem('presumably')).toBe('presum')
-    expect(stemmer.stem('MAXIMUM')).toBe('maxim')
-    expect(stemmer.stem('PRESUMABLY')).toBe('presum')
-  })
-
-  it('#171 and #174, exceed, anguish, affluxion, discept', function () {
-    expect(stemmer.stem('exceed')).toBe('excess')
-    expect(stemmer.stem('anguish')).toBe('anct')
-    expect(stemmer.stem('affluxion')).toBe('affluct')
-    expect(stemmer.stem('discept')).toBe('disceiv')
-  })
-})

package/ts_spec/levenshtein_spec.ts

@@ -1,107 +0,0 @@
-/*
-Copyright (c) 2011, Chris Umbel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-'use strict'
-
-import {
-  LevenshteinDistance as levenshteinDistance,
-  LevenshteinDistanceSearch as levenshteinDistanceSearch
-} from 'lib/natural/distance/levenshtein_distance'
-
-describe('levenshtein_distance', function () {
-  describe('options.search = true', function () {
-    it('should find cheapest substring', function () {
-      expect(levenshteinDistanceSearch('kitten', 'sitting'))
-        .toEqual({ substring: 'sittin', distance: 2, offset: 0 })
-    })
-
-    it('should find 0 cost substring in target', function () {
-      expect(levenshteinDistanceSearch('doctor', 'the doctor is in'))
-        .toEqual({ substring: 'doctor', distance: 0, offset: 4 })
-    })
-
-    it('should find 1 cost substring in target', function () {
-      expect(levenshteinDistanceSearch('doctor', 'the doktor is in'))
-        .toEqual({ substring: 'doktor', distance: 1, offset: 4 })
-    })
-
-    it('should return empty substring when that is cleapest match', function () {
-      expect(levenshteinDistanceSearch('doctor', '000000000000'))
-        .toEqual({ substring: '', distance: 6, offset: 0 })
-    })
-
-    it('different insertion costs should work', function () {
-      // delete 10 0's at cost 1 and insert the letters for doctor at cost -1
-      expect(levenshteinDistanceSearch('0000000000', 'doctor', { insertion_cost: -1 }))
-        .toEqual({ substring: 'doctor', distance: 4, offset: 0 })
-    })
-
-    it('different deletion costs should work', function () {
-      // delete 10 0's at cost -10
-      expect(levenshteinDistanceSearch('0000000000', 'doctor', { deletion_cost: -1 }))
-        .toEqual({ substring: '', distance: -10, offset: 0 })
-    })
-  })
-
-  describe('default / options.search = false', function () {
-    it('should replace 2', function () {
-      expect(levenshteinDistance('doctor', 'doktor')).toBe(1)
-    })
-
-    it('should allow altering replacement value', function () {
-      expect(levenshteinDistance('doctor', 'doktor', { substitution_cost: 1 })).toBe(1)
-    })
-
-    it('should delete 1', function () {
-      expect(levenshteinDistance('doctor', 'docto')).toBe(1)
-    })
-
-    it('should insert 1', function () {
-      expect(levenshteinDistance('flat', 'flats')).toBe(1)
-    })
-
-    it('should combine operations', function () {
-      expect(levenshteinDistance('flad', 'flaten')).toBe(3)
-      expect(levenshteinDistance('flaten', 'flad')).toBe(3)
-    })
-
-    it('should consider perfect matches 0', function () {
-      expect(levenshteinDistance('one', 'one')).toBe(0)
-    })
-
-    it('different deletion cost should work', function () {
-      expect(levenshteinDistance('ones', 'one', { deletion_cost: 3 })).toBe(3)
-    })
-
-    it('different insertion cost should work', function () {
-      expect(levenshteinDistance('one', 'ones', { deletion_cost: 3, insertion_cost: 5 })).toBe(5)
-    })
-
-    it('delete all characters with -ve cost', function () {
-      expect(levenshteinDistance('delete', '', { deletion_cost: -1 })).toBe(-6)
-    })
-
-    it('insert all characters', function () {
-      expect(levenshteinDistance('', 'insert')).toBe(6)
-    })
-  })
-})

package/ts_spec/logistic_regression_classifier_spec.ts

@@ -1,93 +0,0 @@
-/*
-Copyright (c) 2011, Chris Umbel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-'use strict'
-
-import { LogisticRegressionClassifier } from 'lib/natural'
-
-describe('logistic regression', function () {
-  it('should classify with individually trained documents', function () {
-    const classifier = new LogisticRegressionClassifier()
-
-    classifier.addDocument(['have', 'computer'], 'IT')
-    classifier.addDocument(['have', 'phone'], 'IT')
-    classifier.addDocument(['computer', 'suck'], 'IT')
-    classifier.addDocument(['field', 'goal'], 'sports')
-    classifier.addDocument(['score', 'goal'], 'sports')
-    classifier.addDocument(['great', 'speed'], 'sports')
-
-    classifier.train()
-
-    expect(classifier.classify(['hate', 'computer'])).toBe('IT')
-    expect(classifier.classify(['score', 'please'])).toBe('sports')
-  })
-
-  it('should provide all classification scores', function () {
-    const classifier = new LogisticRegressionClassifier()
-    classifier.addDocument(['fix', 'box'], 'computing')
-    classifier.addDocument(['write', 'code'], 'computing')
-    classifier.addDocument(['script', 'code'], 'computing')
-    classifier.addDocument(['write', 'book'], 'literature')
-    classifier.addDocument(['read', 'book'], 'literature')
-    classifier.addDocument(['study', 'book'], 'literature')
-
-    classifier.train()
-
-    expect(classifier.getClassifications('i write code')[0].label).toBe('computing')
-    expect(classifier.getClassifications('i write code')[1].label).toBe('literature')
-  })
-
-  function createClassifier (): LogisticRegressionClassifier {
-    const classifier = new LogisticRegressionClassifier()
-    classifier.addDocument('i fixed the box', 'computing')
-    classifier.addDocument('i write code', 'computing')
-    classifier.addDocument('nasty script code', 'computing')
-    classifier.addDocument('write a book', 'literature')
-    classifier.addDocument('read a book', 'literature')
-    classifier.addDocument('study the books', 'literature')
-    return classifier
-  }
-
-  it('should classify with arrays', function () {
-    const classifier = createClassifier()
-    classifier.train()
-    expect(classifier.classify('a bug in the code')).toBe('computing')
-    expect(classifier.classify('read all the books')).toBe('literature')
-  })
-
-  it('should serialize and deserialize a working classifier', function () {
-    const classifier = createClassifier()
-    const objString = JSON.stringify(classifier)
-    const obj: Record<string, unknown> = JSON.parse(objString)
-    const newClassifier = LogisticRegressionClassifier.restore(obj)
-
-    newClassifier.addDocument('kick a ball', 'sports')
-    newClassifier.addDocument('hit some balls', 'sports')
-    newClassifier.addDocument('kick and punch', 'sports')
-
-    newClassifier.train()
-
-    expect(newClassifier.classify('a bug in the code')).toBe('computing')
-    expect(newClassifier.classify('read all the books')).toBe('literature')
-    expect(newClassifier.classify('kick butt')).toBe('sports')
-  })
-})

package/ts_spec/longest_path_tree_spec.ts

@@ -1,111 +0,0 @@
-/*
-Copyright (c) 2014, Lee Wenzhu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-'use strict'
-
-import {
-  LongestPathTree as LPT,
-  Topological,
-  EdgeWeightedDigraph
-} from 'lib/natural'
-
-describe('shortest path tree', function () {
-  const digraph = new EdgeWeightedDigraph()
-  digraph.add(5, 4, 0.35)
-  digraph.add(4, 7, 0.37)
-  digraph.add(5, 7, 0.28)
-  digraph.add(5, 1, 0.32)
-  digraph.add(4, 0, 0.38)
-  digraph.add(0, 2, 0.26)
-  digraph.add(3, 7, 0.39)
-  digraph.add(1, 3, 0.29)
-  digraph.add(7, 2, 0.34)
-  digraph.add(6, 2, 0.40)
-  digraph.add(3, 6, 0.52)
-  digraph.add(6, 0, 0.58)
-  digraph.add(6, 4, 0.93)
-  describe('edge weighted digraph normal operations', function () {
-    it('should get the numbers of vertexs', function () {
-      expect(digraph.v()).toBe(8)
-    })
-    it('should get the numbers of edges', function () {
-      expect(digraph.e()).toBe(13)
-    })
-    it('should print all item in digraph', function () {
-      expect(digraph.toString()).toBe('0 -> 2, 0.26\n' +
-                                            '1 -> 3, 0.29\n' +
-                                            '3 -> 7, 0.39\n' +
-                                            '3 -> 6, 0.52\n' +
-                                            '4 -> 7, 0.37\n' +
-                                            '4 -> 0, 0.38\n' +
-                                            '5 -> 4, 0.35\n' +
-                                            '5 -> 7, 0.28\n' +
-                                            '5 -> 1, 0.32\n' +
-                                            '6 -> 2, 0.4\n' +
-                                            '6 -> 0, 0.58\n' +
-                                            '6 -> 4, 0.93\n' +
-                                            '7 -> 2, 0.34')
-    })
-  })
-
-  describe('topo sort for digraph', function () {
-    it('should sort all the vertexs', function () {
-      const topoSort = new Topological(digraph)
-      expect(topoSort.isDAG()).toBe(true)
-      expect(topoSort.order()).toEqual([5, 1, 3, 6, 4, 7, 0, 2])
-    })
-  })
-
-  describe('shortest path tree normal operations', function () {
-    const lpt = new LPT(digraph, 5)
-    it('should determine existence of paths', function () {
-      expect(lpt.hasPathTo(0)).toBe(true)
-      expect(lpt.hasPathTo(1)).toBe(true)
-      expect(lpt.hasPathTo(2)).toBe(true)
-      expect(lpt.hasPathTo(3)).toBe(true)
-      expect(lpt.hasPathTo(4)).toBe(true)
-      expect(lpt.hasPathTo(5)).toBe(false)
-      expect(lpt.hasPathTo(6)).toBe(true)
-      expect(lpt.hasPathTo(7)).toBe(true)
-    })
-    it('should determine paths', function () {
-      expect(lpt.pathTo(0)).toEqual([5, 1, 3, 6, 4, 0])
-      expect(lpt.pathTo(1)).toEqual([5, 1])
-      expect(lpt.pathTo(2)).toEqual([5, 1, 3, 6, 4, 7, 2])
-      expect(lpt.pathTo(3)).toEqual([5, 1, 3])
-      expect(lpt.pathTo(4)).toEqual([5, 1, 3, 6, 4])
-      expect(lpt.pathTo(5)).toEqual([])
-      expect(lpt.pathTo(6)).toEqual([5, 1, 3, 6])
-      expect(lpt.pathTo(7)).toEqual([5, 1, 3, 6, 4, 7])
-    })
-    it('should calculate distances', function () {
-      expect(lpt.getDistTo(0)).toBe(2.44)
-      expect(lpt.getDistTo(1)).toBe(0.32)
-      expect(lpt.getDistTo(2)).toBe(2.77)
-      expect(lpt.getDistTo(3)).toBe(0.61)
-      expect(lpt.getDistTo(4)).toBe(2.06)
-      expect(lpt.getDistTo(5)).toBe(0)
-      expect(lpt.getDistTo(6)).toBe(1.13)
-      expect(lpt.getDistTo(7)).toBe(2.43)
-    })
-  })
-})