nightfury7 / universalbasics.js

src/ub.strings.similarity.js

/** global: UB */

var stringFuncs = {
	
	// equality testing
	equals: function(str2){
		return this.isEqual(str2);
	},
	equalsCI: function(str2){
		return this.isEqual(str2, false);
	},
	isEqual: function(str2, caseSensitive = true, str1IsLower = false, str2IsLower = false){
		var str1 = this;
		
		if (!caseSensitive) {
			
			// quick checks
			if (str2 == null) {
				return (str1 == str2);
			}
			if (str1.length != str2.length) {
				return false;
			}
			
			// init casing tables
			if (UB.UTF_lowerToUpper == null){
				UB.initCasing();
			}
			
			// very fast CI comparison
			for (var c = 0, cl = str1.length;c<cl;c++){
				var c1 = str1.charCodeAt(c);
				var c2 = str2.charCodeAt(c);
				
				// CI
				if (!str1IsLower) {
					if (c1 <= UB.UTF_casingTablesMax){
						c1 = UB.UTF_upperToLower[c1];
					}
				}
				if (!str2IsLower) {
					if (c2 <= UB.UTF_casingTablesMax){
						c2 = UB.UTF_upperToLower[c2];
					}
				}
				
				
				if (c1 != c2) {
					return false;
				}
			}
			return true;
			
			
			// causes thousands of HOC in a big loop
			/*str1 = str1.toUpperCase();
			str2 = str2.toUpperCase();*/
		}
		
		return (str1 == str2);
	},
	isEqualAny: function(str2, caseSensitive = true, str1IsLower = false, str2IsLower = false){
		var str1 = this;
		
		for (var s = 0, sl = str2.length;s<sl;s++){
			var s2 = str2[s];
			if (s2 != null) {
				if (caseSensitive) {
					if (str1 == s2) {
						return true;
					}
				}else{
					if (str1.isEqual(s2, false)) {
						return true;
					}
				}
			}
		}
		
		return false;
	},
	isNotEqual: function(str2, caseSensitive = true){
		var str1 = this;
		
		if (!caseSensitive) {
			if (str1 == null || str2 == null) {
				return (str1 != str2);
			}
			
			// very fast CI comparison
			return !str1.isEqual(str2, false);
		}
		
		return (str1 != str2);
	},
	
	// similarity testing
	similarityLevenshtein: function(target){
		var source = this;
		var ed = source.levenshteinDistance(target);
		var maxLen = Math.max(source.length, target.length);
		if (maxLen === 0) {
			return 100;
		}
		return (1 - ed/maxLen) * 100;
	},
	levenshteinDistance: function(target){
		var source = this;
		
		/**
		*	Levenshtein distance is a measure of the similarity between two strings,
		*	The distance is the number of deletions, insertions, or substitutions required to
		*	transform p_source into p_target.
		*/
		var i;
	
		var d = [];
		var cost;
		var n = source.length;
		var m = target.length;
		var j;
	
		if (n === 0) { return m; }
		if (m === 0) { return n; }
	
		for (i=0; i<=n; i++) { d[i] = []; }
		for (i=0; i<=n; i++) { d[i][0] = i; }
		for (j=0; j<=m; j++) { d[0][j] = j; }
	
		for (i=1; i<=n; i++) {
	
			var s_i = source.charAt(i - 1);
			for (j=1; j<=m; j++) {
	
				var t_j = target.charAt(j - 1);
	
				if (s_i == t_j) { cost = 0; }
				else { cost = 1; }
	
				d[i][j] = S._minimum(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+cost);

The variable S seems to be never declared. If this is a global, consider adding a /** global: S */ comment.

			}
		}
		return d[n][m];
	},
	
	similarityScore: function(str2, caseSensitive = false, spaceSensitive = true){
		var str1 = this;
		
		// better for unequal length strings
		
		// returns ~0.9 for "jhonny" and "jonny"
		// returns 0.3 for "ABCD" and "DBCD"
		
		if	(!caseSensitive){
			str1 = str1.toUpperCase();
			str2 = str2.toUpperCase();
		}
		
		if	(!spaceSensitive){
			str1 = str1.removeSpaces();
			str2 = str2.removeSpaces();
		}
		
		if (str1 == str2) {
			return 1;
		}
		
		return N1D.MatchingScore(str1.splitCharPairs(), str2.splitCharPairs());

The variable N1D seems to be never declared. If this is a global, consider adding a /** global: N1D */ comment.

	},
	similarityScoreChars: function(str2, caseSensitive = false){
		var str1 = this;
		
		// better for equal length strings where char by char matching is wanted
		
		// returns 0.75 for "ABCD" and "DBCD"
		
		
		// don't process unequal len strings
		if (str1.length != str2.length) {
			return str1.similarityScore(str2, caseSensitive);
		}
		
		if	(!caseSensitive){
			str1 = str1.toUpperCase();
			str2 = str2.toUpperCase();
		}
		
		// just counts matching chars
		return str1.countMatchingChars(str2) / str1.length;
	},
	countMatchingCharPairs: function(str2, caseSensitive = false){
		var str1 = this;
		
		if	(!caseSensitive){
			str1 = str1.toUpperCase();
			str2 = str2.toUpperCase();
		}
		
		return N1D.MatchingSlots(str1.splitCharPairs(), str2.splitCharPairs());

The variable N1D seems to be never declared. If this is a global, consider adding a /** global: N1D */ comment.

	},
	countMatchingChars: function(str2){
		var str1 = this;
		
		// just counts matching chars
		var count = 0;
		for (var c = 0, cl = str1.length;c<cl;c++){
			if (str1.charAt(c) == str2.charAt(c)) {
				count++;
			}
		}
		return count;
	},
	indexOfBestMatchRepeated: function(caseSensitive, similarChars = 4, minSimilarity = 0.7){
		var text = this;
		
		// finds the starting point of the 2nd instance of any repeated substring .. "zjohn ajohn" will return 7;
		
		// per char set
		var sims = [];
		for (var c = 0, cl = text.length - (similarChars - 1);c<cl;c++){
			var chars = text.substr(c, similarChars);
			
			// per every other char set ahead of this
			var sims2 = UB.newArray(0, cl);
			for (var c2 = c + similarChars;c2<cl;c2++){
				var chars2 = text.substr(c2, similarChars);
				
				
				// calc similarity
				sims2[c2] = chars.similarityScoreChars(chars2, caseSensitive);
			}
			
			// store best similarity match if above wanted similarity
			sims[c] = N1D.MaxIndexInRange(sims2, minSimilarity, 1);

The variable N1D seems to be never declared. If this is a global, consider adding a /** global: N1D */ comment.

		}
		
		// find char nearest to left
		var leftCharIndex = N1D.MinInRange(sims, 0, cl, true);
		var leftCharIndex2 = sims[leftCharIndex];
		
		// now find first exactly matching char after it
		for (c = leftCharIndex, c2 = leftCharIndex2, cl = text.length; c2 < cl; c++, c2++) {
			var leftChar = text.charAt(c);
			var leftChar2 = text.charAt(c2);
			if (!caseSensitive) {
				leftChar = leftChar.toUpperCase();
				leftChar2 = leftChar2.toUpperCase();
			}
			if (leftChar == leftChar2) {
				return c2;
			}
		}
		return leftCharIndex2;
	},
	isSimilar: function(str2, caseSensitive = false, threshold = 0.8){
		var str1 = this;
		return (str1.similarityScore(str2, caseSensitive) >= threshold);
	},
	none:null
};

// register funcs
UB.registerFuncs(String.prototype, stringFuncs);