import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Returns an identity string similarity metric. The metric returns 1.0 when
 * the inputs are equals, and 0.0 when they're not.
 * 
 * @return an identity similarity metric
 * 
 * @see Identity
 */
public static StringMetric identity() {
	return new StringMetric() {

		private final Identity<String> metric = new Identity<>();

		@Override
		public float compare(String a, String b) {
			return metric.compare(a, b);
		}

		@Override
		public String toString() {
			return metric.toString();
		}
	};
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public double getSimilarity(String sentence1, String sentence2){
    double predictedScore = 0;
    if (PARAGRAPHVECS != null) {
        try {
            INDArray inferredVectorA = produceParagraphVectorOfGivenSentence(sentence1);
            INDArray inferredVectorB = produceParagraphVectorOfGivenSentence(sentence2);
            predictedScore = Transforms.cosineSim(inferredVectorA, inferredVectorB);
        } catch (Exception e) {
            logger.error("No word is matched with the given sentence and any sentence in training set - model file. " + sentence1
                    + ";" + sentence2);
            System.out.println("No word is matched with the given sentence and any sentence in training set - model file. " + sentence1
                    + ";" + sentence2);
            StringMetric metric = StringMetrics.qGramsDistance();
            predictedScore = metric.compare(sentence1, sentence2);
        }
    }

    return predictedScore;
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
@Override
public StringMetric build() {

	if (simplifiers.isEmpty()) {
		return create(metric);
	}
	return create(metric, chainSimplifiers());
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
private static double getSmsSimilarityScore(String algo, String sms1, String sms2) {
    Method method;
    try {
        method = StringMetrics.class.getMethod(algo);
        StringMetric m = (StringMetric) method.invoke(null);
        return m.compare(sms1, sms2);
    } catch (IllegalAccessException | InvocationTargetException | SecurityException | NoSuchMethodException e) {
        Log.e("GM/simError", e.toString());
        return 0.0;
    }
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Calculate the similarity of two strings. At the moment Cosine 
 * distance is used for that. The returned float value is limited to
 * 0 all characters different and 1 all are the same. -1 is returned if
 * stringA is empty. 
 * @param stringA
 * @param stringB
 * @return The returned float value is limited to 0 all characters
 * different and 1 all are the same. -1 is returned if stringA is empty.
 */
public static float similarityStringsLevenshstein(String stringA, String stringB) {

	if(stringA.equals("")){
		return -1;
	}else{
		StringMetric metric = with(new Levenshtein())
				.simplify(Simplifiers.removeNonWord())
				.simplify(Simplifiers.toLowerCase()).build();

		return metric.compare(stringA, stringB);			
	}
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public static float similarityStringsCosine(String stringA, String stringB) {

		if(stringA.equals("")){
			return -1;
		}else{
			StringMetric metric = 
					with(new CosineSimilarity<String>())
					.simplify(Simplifiers.toLowerCase())
					.tokenize(Tokenizers.whitespace())
					.build();

			return metric.compare(stringA, stringB);	
		}
	}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
@Ignore
@Test public void testDistances()
{
	StringMetric similarity = StringMetrics.qGramsDistance();
	System.out.println(similarity.compare("amountsextended","amountsextended"));
	System.out.println(similarity.compare("amounts extended","extended amounts"));
	System.out.println(similarity.compare("amountsextended","extendedamounts"));
	System.out.println(similarity.compare("nestle","nestlé"));
	System.out.println(similarity.compare("nerf","berg"));
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public static StringMetric create(Metric<String> metric) {
	return org.simmetrics.metrics.StringMetrics.create(metric);
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public static StringMetric createForListMetric(Metric<List<String>> metric, Simplifier simplifier,
		Tokenizer tokenizer) {
	return org.simmetrics.metrics.StringMetrics.createForListMetric(metric,simplifier, tokenizer);

}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public static StringMetric createForSetMetric(Metric<Set<String>> metric, Simplifier simplifier,
		Tokenizer tokenizer) {
	return org.simmetrics.metrics.StringMetrics.createForSetMetric(metric,simplifier, tokenizer);
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public static StringMetric createForMultisetMetric(Metric<Multiset<String>> metric, Simplifier simplifier,
		Tokenizer tokenizer) {
	return org.simmetrics.metrics.StringMetrics.createForMultisetMetric(metric,simplifier, tokenizer);
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
@WebMethod
public double calculateSimilarityScoreForGivenPair(String s1, String s2, int methodType) throws SLIB_Exception, IOException {
    double similarityScore = 0;
    System.out.println("REQUEST has been received for: " + s1 + " " + s2 + " " + methodType);

    String preprocessedS1 = fileOperations.removeStopWordsFromSentence(s1, stopWordsList);
    String preprocessedS2 = fileOperations.removeStopWordsFromSentence(s2, stopWordsList);

    String example_1 = "It has recently been shown that Craf is essential for Kras G12D-induced NSCLC.";
    String example_2 = "It has recently become evident that Craf is essential for the onset of Kras-driven non-small cell lung cancer.";

    switch (methodType){
        case 1:
            //WordNet-based similarity was selected
            CombinedOntologyMethod measureOfWordNet = new CombinedOntologyMethod(stopWordsList);
            similarityScore = measureOfWordNet.getSimilarityForWordnet(s1, s2);
            System.out.println("SCOREOFWORDNET: " + similarityScore);
            break;

        case 2:
            //UMLS-based similarity option was selected
            CombinedOntologyMethod measureOfUmls = new CombinedOntologyMethod(stopWordsList);
            similarityScore = measureOfUmls.getSimilarityForUMLS(s1, s2);
            System.out.println("SCOREOFUMLS: " + similarityScore);
            break;
        case 3:
            //COMBINED ontology based similarity option was selected
            CombinedOntologyMethod score_wordnet = new CombinedOntologyMethod(stopWordsList);
            double score_1 =score_wordnet.getSimilarityForWordnet(s1, s2);
            double score2 = score_wordnet.getSimilarityForUMLS(s1,s2);
            similarityScore = (score2+score_1)/2;
            System.out.println("SCOREOFCOMBINED: " + similarityScore);
            break;

        case 4:
            //qgram string similarity option was selected.
            StringMetric metric = StringMetrics.qGramsDistance();
            similarityScore = metric.compare(preprocessedS1, preprocessedS2); //0.4767
            System.out.println("SCOREOFQGRAM: "+similarityScore);
            break;

        case 5:
            //paragraph vector model based similarity was selected as an option.
            SentenceVectorsBasedSimilarity sentenceVectorsBasedSimilarity = new SentenceVectorsBasedSimilarity();
            similarityScore = sentenceVectorsBasedSimilarity.getSimilarity(preprocessedS1, preprocessedS2);
            System.out.println("SCOREOFPARAGRAPHVEC:" + similarityScore);
            break;

        case 6:
            //Supervised Semantic Similarity was selected from the options list.
            LinearRegressionMethod linearRegressionMethod = new LinearRegressionMethod();
            similarityScore = linearRegressionMethod.getSimilarity(preprocessedS1, preprocessedS2);
            System.out.println("SCOREOFSUPERVISED:  " + similarityScore);
            break;
    }
    return similarityScore;
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public double getSimilarity(String sentence1, String sentence2) throws IOException {

        StringMetric metric = StringMetrics.needlemanWunch();
        float result = metric.compare(sentence1, sentence2); //0.4767
        return result;
    }
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
protected String processTypoCustomProperties(String liferayVersion,
		Properties customPortalProperties) throws IOException {
	if (customPortalProperties.isEmpty()) {
		return StringPool.BLANK;
	}

	SortedSet<String> customKeys = new TreeSet<String>(
			customPortalProperties.stringPropertyNames());
	StringBuilder stringBuilder = new StringBuilder();

	boolean processedContext = false;
	StringMetric metric = StringMetricBuilder
			.with(new CosineSimilarity<String>())
			.simplify(new Case.Lower(Locale.ENGLISH))
			.simplify(new WordCharacters()).tokenize(new Whitespace())
			.tokenize(new QGram(2)).build();
	Set<String> defaultKeys = getProperyKeys(liferayVersion);

	for (String customKey : customKeys) {
		float distance = 0;
		String key = null;

		for (String defaultKey : defaultKeys) {
			float temp = metric.compare(defaultKey, customKey);

			if (temp > distance) {
				distance = temp;
				key = defaultKey;
			}
		}

		if (distance > 0.9) {
			if (!processedContext) {
				stringBuilder.append("##\n## Typo properties\n##");
				stringBuilder.append("\n\n");
				stringBuilder.append("    #\n");
				stringBuilder
						.append("    # The properties listed below looks like that has a typo in its declaration\n");
				stringBuilder
						.append("    # which means that they don't have any influence in how Liferay is configured.\n");
				stringBuilder
						.append("    # The system suggested the correct property name in the comments.\n");
				stringBuilder.append("    #");

				processedContext = true;
			}
			String value = fixLineBreak(customPortalProperties
					.getProperty(customKey));

			stringBuilder.append("\n");
			stringBuilder.append("    #" + key + "=" + value);
			stringBuilder.append("\n");
			stringBuilder.append("    " + customKey + "=" + value);
			customPortalProperties.remove(customKey);
		}
	}

	if (processedContext) {
		stringBuilder.append("\n");
		stringBuilder.append("\n");
	}

	return stringBuilder.toString();
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Either constructs a new string similarity metric or returns the original
 * metric.
 * 
 * @param metric
 *            a metric for strings
 * 
 * @return a similarity metric.
 * 
 * @deprecated Use {@link StringMetricBuilder} in favor of directly
 *             constructing a metric.
 */
@Deprecated
public static StringMetric create(Metric<String> metric) {
	if (metric instanceof StringMetric) {
		return (StringMetric) metric;
	}

	return new ForString(metric);
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Creates a new composite string similarity metric.The tokenizer is used to
 * tokenize the simplified strings. The set metric compares the the tokens.
 * 
 * @param metric
 *            a list metric
 * @param simplifier
 *            a simplifier
 * @param tokenizer
 *            a tokenizer
 * @return a new composite similarity metric
 * 
 * @throws NullPointerException
 *             when either metric, simplifier or tokenizer are null
 * 
 * @see StringMetricBuilder
 * 
 * @deprecated Use {@link StringMetricBuilder} in favor of directly
 *             constructing a metric.
 */
@Deprecated
public static StringMetric createForMultisetMetric(
		Metric<Multiset<String>> metric, Simplifier simplifier,
		Tokenizer tokenizer) {
	return new ForMultisetWithSimplifier(metric, simplifier, tokenizer);
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
public static float jaccardSimilarity(String sentence1, String sentence2){

        StringMetric metric = StringMetrics.jaccard();
        float result = metric.compare(sentence1, sentence2); //0.4767
        return result;

    }
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Returns a cosine similarity metric over tokens in a string. The tokens
 * are created by splitting the string on whitespace.
 * 
 * @return a cosine similarity metric
 * 
 * @see CosineSimilarity
 */
public static StringMetric cosineSimilarity() {
	return with(new CosineSimilarity<String>())
		.tokenize(whitespace())
		.build();
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Returns a block distance similarity metric over tokens in a string. The
 * tokens are created by splitting the string on whitespace.
 * 
 * @return a block distance metric
 * 
 * @see BlockDistance
 */
public static StringMetric blockDistance() {
	return with(new BlockDistance<String>()).tokenize(whitespace()).build();
}
 

import org.simmetrics.StringMetric; //导入依赖的package包/类
/**
 * Returns a Damerau-Levenshtein similarity metric over tokens in a string.
 * The tokens are created by splitting the string on whitespace.
 * 
 * @return a Damerau-Levenshtein metric
 * 
 * @see DamerauLevenshtein
 */
public static StringMetric damerauLevenshtein() {
	return new DamerauLevenshtein();
}