package dist.hmm;

import shared.Instance;
import dist.DiscreteDistribution;

/**
 * A hidden markov model implementation that does not
 * use observations when calculating transition
 * probabilities and has no notion of input / output
 * In terms of this implementation it is a
 * HiddenMarkoModel that uses SimpleTransitionDistributions
 * for it's TransitionDistributions
 * @author Andrew Guillory gtg008g@mail.gatech.edu
 * @version 1.0
 */
public class SimpleHiddenMarkovModel extends ModularHiddenMarkovModel {

	/**
	 * Create a new hidden markov model of the given size
	 * @param stateCount the number of states
	 */
	public SimpleHiddenMarkovModel(int stateCount) {
        super(stateCount);
        StateDistribution[] transitionDistributions =
            new StateDistribution[stateCount];
        for (int i = 0; i < stateCount; i++) {
            double[] probabilities = DiscreteDistribution.random(stateCount).getProbabilities();
            transitionDistributions[i] = new SimpleStateDistribution(probabilities);
        }
        setTransitionDistributions(transitionDistributions);
        double[] probabilities = DiscreteDistribution.random(stateCount).getProbabilities();
        setInitialStateDistribution(new SimpleStateDistribution(probabilities));
	}
    
    /** Default constructor */
    public SimpleHiddenMarkovModel() { }
    
    
    /**
     * Set the transition probability matrix
     * @param transitions matrix
     */
    public void setTransitionProbabilities(double[][] transitions) {
        StateDistribution[] transitionDistributions =
            new StateDistribution[getStateCount()];
        for (int i = 0; i < getStateCount(); i++) {
            transitionDistributions[i] = 
                new SimpleStateDistribution(transitions[i]);
        }
        setTransitionDistributions(transitionDistributions);
    }
    
    /**
     * Get the transition probability matrix
     * @return the transitions matrix
     */
    public double[][] getTransitionProbabilities() {
        double[][] probabilities = new double[getStateCount()][];
        for (int i = 0; i < probabilities.length; i++) {
            probabilities[i] = 
              ((SimpleStateDistribution) getTransitionDistributions()[i])
                  .getProbabilities();
        }
        return probabilities;
    }
    
    /**
     * Set the initial state probabilities
     * @param probabilities the probabilites
     */
    public void setInitialStateProbabilities(double[] probabilities) {
        setInitialStateDistribution(new SimpleStateDistribution(probabilities));
    }
    
    /**
     * Get the initial state probabilites
     * @return the probabilities
     */
    public double[] getInitialStateProbabilities() {
        return ((SimpleStateDistribution) getInitialStateDistribution())
            .getProbabilities();
    }
    
    /**
     * Match the initial state distribution to the given expectations 
     * for the initial observation data
     * @param expectations [k][i] is the expected times in state i initially
     * for observation sequence k
     */
    public void estimateIntialStateDistribution(
            double[][] expectations) {
        estimateIntialStateDistribution(expectations, null);    
    }
    
    /**
     * Match the transitions in state i to the given expectations for the
     * transition observation data
     * @param i the start state
     * @param expectations the expected transitions [t][j] for time t to state j
     * @param sequence the transition observatiosn
     * @param sequence the observation sequence
     */
    public void estimateTransitionDistribution(
            int i, double[][] expectations) {
        estimateTransitionDistribution(i, expectations, null);        
    }
    
    /**
     * Get the initial state probability
     * @param i the initial state
     * @return the probability
     */
    public double initialStateProbability(int i) {
        return initialStateProbability(i, null);
    }
    
    /**
     * Get the probability of transitioning from state i to state j.
     * @param i the first state
     * @param j the second state
     * @return the probability
     */
    public double transitionProbability(int i, int j) {
        return transitionProbability(i, j, null);
    }
    /**
     * Sample a next state given the current state and input
     * @param i the current state
     * @return the next state
     */
    public int sampleState(int i) {
        return sampleState(i, null);
    }
    
    /**
     * Sample the initial state given the current state
     * @return the initial state
     */
    public int sampleInitialState() {
        return sampleInitialState(null);
    }
    
    /**
     * Sample an input given the current observation
     * @param i the current state
     * @return the sample observation
     */
    public Instance sampleObservation(int i) {
        return sampleObservation(i, null);
    }
}