Answered! Fill in the TODO blanks in ModelMatcher.java and MatcherController.java //ModelMatcher.java import java.util.HashMap;…

import java.util.HashMap;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.SortedSet;
import java.util.TreeSet;

public class ModelMatcher
{

/** log likelihoods for a teststring under a given model */
private HashMap<String,Double> logLikelihoodMap;
/** summary statistic for this setting */
private double averageLogLikelihood;

/**
* Constructor to initialise the fields for the log likelihood map for
* a test string and a given Markov model and
* the average log likelihood summary statistic
* @param MarkovModel model a given Markov model object
* @param String teststring the string to check compatability with the model
*/
public ModelMatcher(MarkovModel model, String testString)
{
logLikelihoodMap = new HashMap<String, Double>();
int kVal = model.getK();
String seq;
for (int curPos = 0; (curPos) < testString.length(); curPos++)
{
if (curPos + (kVal + 1) <= testString.length())
{
seq = testString.substring(curPos, (curPos + kVal + 1));
}
else
{
String fromEnd = testString.substring(curPos, (testString.length()));
String fromStart = testString.substring(0, ((kVal + 1) – fromEnd.length()));
seq = fromEnd + fromStart;
}

// seq should be of length k+1
// context should be the first k chars of seq
String context = seq.substring(0, kVal);
// impChar should be the last character of seq
String impChar = seq.substring(kVal, seq.length());

double loggedProb = Math.log10(model.laplaceEstimate(seq));
if (logLikelihoodMap.containsKey(seq))
{
logLikelihoodMap.put(seq, (logLikelihoodMap.get(seq) + loggedProb));
}
else
{
logLikelihoodMap.put(seq, loggedProb);
}
}
averageLogLikelihood = averageLogLikelihood(logLikelihoodMap, testString.length());

}

/** Helper method that calculates the average log likelihood statistic
* given a HashMap of strings and their Laplace probabilities
* and the total number of ngrams in the model.
*
* @param logs map of ngram strings and their log likelihood
* @param ngramCount int number of ngrams in the original test string
* @return average log likelihood: the total of loglikelihoods
*    divided by the ngramCount
*/
private double averageLogLikelihood(HashMap<String,Double> logs, int ngramCount)
{
double totalLogs = 0.0;
for (String i : logs.keySet())
{
totalLogs += logs.get(i);
}
double avg = totalLogs/ngramCount;
return avg;
}

/** Helper method to calculate the total log likelihood statistic
* given a HashMap of strings and their Laplace probabilities
* and the total number of ngrams in the model.
*
* @param logs map of ngram strings and their log likelihood
* @return total log likelihood: the sum of loglikelihoods in logs
*/
private double totalLogLikelihood(HashMap<String,Double> logs)
{
double totalLogs = 0.0;
for (String i : logs.keySet())
{
totalLogs += logs.get(i);
}
return totalLogs;
}

/**
* @return the average log likelihood statistic
*/
public double getAverageLogLikelihood()
{
return averageLogLikelihood;
}

/**
* @param ngram String the ngram to find the log likelihood of.
* @return the log likelihood value for a given ngram from the input string
*/
public double getLogLikelihood(String ngram)
{
return (logLikelihoodMap.get(ngram));
}

/**
* Make a String summarising the log likelihood map and its statistics
* @return String of ngrams and their loglikeihood differences between the models
* The likelihood table should be ordered from highest to lowest likelihood
*/
public String toString()
{
SortedSet<String> keysArray = new TreeSet<String>(logLikelihoodMap.keySet());
String toRet = “”;
for (String key : keysArray)
{
double logLike = logLikelihoodMap.get(key);
String logLikeS = Double.toString(logLike);
String thisKey = (key + ”     ” + logLikeS + “n”);
toRet += thisKey;
}
return toRet;
}

}

MatcherController.java

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class MatcherController {

/** list of training data string used to generate markov models */
ArrayList<String> trainingDataList;
/** test data to be matched with the models */
String testData;
/** order of the markov models*/
int k;
/** generated list of markov models for the given training data*/
ArrayList<MarkovModel> modelList;
/** generated list of matchers for the given markov models and test data*/
ArrayList<ModelMatcher> matcherList;

/** Generate models for analysis
* @param k order of the markov models to be used
* @param trainingDataList List of strings used to generate Markov Models
* @param testData String to check against different models
* @throw unchecked exceptions if the input order or data inputs are invalid
*/
public MatcherController(int k, ArrayList<String> trainingDataList, String testData)
{
if (k < 0)
{
throw new IllegalArgumentException(“K cannot be less than zero”);
}
if (testData == “” || testData == null)
{
throw new IllegalArgumentException(“The data to test cannot be blank”);
}

modelList = new ArrayList<MarkovModel>();
matcherList = new ArrayList<ModelMatcher>();

this.trainingDataList = trainingDataList;

//Create a markov model for each entry in trainingDataList
for (String i : trainingDataList)
{
modelList.add(new MarkovModel(k, i));
}
// For each Markov Model a Model Matcher
for (MarkovModel i : modelList)
{
matcherList.add(new ModelMatcher(i, testData));
}

//Find the best modelmatcher
ModelMatcher best = getBestMatch(matcherList);
String bestMatch = explainBestMatch(best);
}

/** @return a string containing all lines from a file
* @param the name of the file to import
*
* ff file contents can be got, otherwise null
* This method should process any exceptions that arise.
* @throws IOException
*/
private static String getFileContents(String filename) throws IOException
{
byte[] encoded = Files.readAllBytes(Paths.get(filename));
return new String(encoded);
}

/**
* @param an arraylist of ModelMatchers
* @return the ModelMatcher object that has the highest average loglikelihood
* (where all candidates are trained for the same test string
*/
public ModelMatcher getBestMatch(ArrayList<ModelMatcher> candidates)
{
ModelMatcher currentHighest = null;
for (ModelMatcher i : candidates)
{
ModelMatcher thisLog = i;
if (currentHighest == null)
{
currentHighest = i;
}
if (thisLog.getAverageLogLikelihood() > currentHighest.getAverageLogLikelihood())
{
currentHighest = thisLog;
}
}
return currentHighest;
}

/** @return String an *explanation* of
* why the test string is the match from the candidate models
*/
public String explainBestMatch(ModelMatcher best)
{
double normalProb = Math.pow(10, best.getAverageLogLikelihood());
String toRet = “This model was the best as the average likelihood was ” + normalProb + “n”;
return null;
}

/** Display an error to the user in a manner appropriate
* for the interface being used.
*
* @param message
*/
public void displayError(String message) {
// LEAVE THIS METHOD EMPTY
}

}