/************************************************************************/

//Please read the following comments about the prototypes of

//   three function to implement in model.cpp for Programming #1A and #1B

/************************************************************************/

 

/************************************************************************/

//Calculate and return the probability of charGenerated actually typed

//given charOfTheState as the underlying cognitive state.

/************************************************************************/

double prCharGivenCharOfState(char charGenerated, char charOfTheState)

{   // KEYBOARD STATE

    // CharGenerated = What we actually touched (typed)

    // CharOfTheState = What we want to type in our mind (our cognitive state)

 

       //**************************************************

       //Replace the following with your own implementation

       //**************************************************

       return 0;

}

 

 

/************************************************************************/

//The following function implement part of the spelling model for

// spelling a word with sizeOfTable characters,

//This function

//(i) calculates for each cognitive state excluding the special states I and F,

//     the probability of that cognitive state being the first cognitive state

//     after the transition out of the special state I, and

//(ii) stores these probabilities in a prTable array of sizeOfTable elements.

//Note that the value of the parameter sizeOfTable should be

//     exactly the number characters in the word.

/************************************************************************/

void getPrTableForPossibleInitialStates(double prTable[], int sizeOfTable)

{

       //It is a word of sizeOfTable characters:

       //     i.e. the number of character states is sizeOfTable.

       //     let's index these characters from 0 to sizeOfTable-1.

       //

 

       //First calculate the sum of ratios of probabilities of

       //     going from the special I state into these character states.

       //This allows you to calculate the scaling factor to determine the probabilities.

 

       

       //Second, for each character state calculate the probability

       //     transitioning from the special I state into the character state.

 

       //**************************************************

       //Replace the following with your own implementation

       //**************************************************

 

 

}

 

 

 

 

/************************************************************************/

//The following function implement part of the spelling model for

// spelling a word with sizeOfTable-1 characters,

// i.e. sizeOfTable should be 1 + the number characters in the word.

//This function

//(i) calculates for each actual cognitive state for a word

//     (excluding the special I state but including the special F state),

//     the probability of that cognitive state being the next cognitive state

//     given currentState as the index of the current state in the word, and

//(ii) stores these probabilities in a transitionPrTable array of sizeOfTable elements.

//Note that the value of the parameter sizeOfTable should be

//     1 + the number characters in the word.

/************************************************************************/

void getPrTableForPossibleNextStates

(double transitionPrTable[], int sizeOfTable, int currentState)

{

       //We are working on a word of sizeOfTable-1 characters:

       //     i.e. the number of character states is sizeOfTable-1.

       //Index these character states from 0 to sizeOfTable-2 respectively, while

       //     the index of the special final state F is sizeOfTable-1.

       //currentState is the index of the current state in the word

 

       //First calculate the sum of ratios of probabilities of

       //     going from the current state into the other down-stream states down in word

       //     including all the down-stream character states and the

       //     special F final state.

       //This allows you to calculate the scaling factor to determine the probabilities.

        

       //Second, for each state (excluding the special I state)

       //     calculate the probability of

       //     transitioning from the current state into the character state

       //     and store the probability into the table.

 

 

       //**************************************************

       //Replace the following with your own implementation

       //**************************************************

 

}

 

 

 

 

/************************************************************************/

//     Please also read and check how these three function above

//            are called in the following demo functions in demo.cpp

/************************************************************************/

 

 

 

/************************************************************************/

/************************************************************************/

void demoOfKeyboardModel()

{

       cout << endl << endl

               << "*********************************************************" << endl

               << "Test the correctness of the keyboard model implementation, and" << endl

               << "show the probabilities of generating (touching) various characters" << endl

               << "when mentally you are in a state of trying to type something." << endl

               << "*********************************************************" << endl;

       cout<<endl<<"Press space to continue."<<endl;

 

       _getch();

       char asciiMap[] = "abcdefghijklmnopqrstuvwxyz";

       for (int i=0; i< 26; i++)

       {double prSum;

        prSum = 0;

        cout << "Probability distribution regarding " << endl

                << "all possible resulting characters when trying to type "

                << asciiMap[i] << endl;

        for (int j=0; j< 26; j++)

       {     

                     cout << '\t'

                            << "Pr[Char=" << asciiMap[j] << "|State=" << asciiMap[i] << "]="

                            << prCharGivenCharOfState(asciiMap[j], asciiMap[i]) << endl;

                     prSum += prCharGivenCharOfState(asciiMap[j], asciiMap[i]);

       }

        cout << "The sum of probability distribution over " << endl

                << "all possible resulting characters when trying to type \'" << endl

                << asciiMap[i]

                << "\' has been verified as "

                << prSum  << endl << endl;

 

        cout<<endl<<"Press space to continue."<<endl;             

        _getch();

 

       }

       cout << endl << endl ;

}

 

 

 

/************************************************************************/

/************************************************************************/

void demoInitialProbability()

{

      

       cout << endl << endl

               << "*********************************************************" << endl

               << "Consider the 3-character word \"his\" "<< endl

               << "Demonstrate the probability distribution over the possible cognitive states" << endl

               << "after the transition from the special initial state I."  << endl

               << "*********************************************************" << endl;

       cout<<endl<<"Press space to continue."<<endl;       

       _getch();

 

       int sizeOfTable = strlen("his");

       int currentState;

       double prSum = 0;

       double initialPrTable[3];

       getPrTableForPossibleInitialStates(initialPrTable,3);

 

       string word = "his";

       for (currentState=0; currentState < sizeOfTable; currentState++)

       {      cout << '\t'

                            << "Pr[State=" << word[currentState]  << "]="

                            << initialPrTable[currentState] << endl;

                     prSum += initialPrTable[currentState];

       }

 

       cout << "The sum of probability distribution over " << endl

               << "all possible states after the first transition" << endl

               << "has been verified as " << prSum  << endl << endl;

       cout<<endl<<"Press space to continue." << endl;           

       _getch();

 

}

 

 

/************************************************************************/

/************************************************************************/

void demoTransitionProbability()

{

 

       cout << endl << endl

               << "*********************************************************" << endl

               << "Consider the 3-character word \"his\" "<< endl

               << "Show the transition probabilities when spelling the word." << endl

               << "*********************************************************" << endl

               << "Demonstrate transition probabilities from current state to the next state."  << endl

               << "We use special character \'_\' to represent the special final state F."  << endl

               << "*********************************************************" << endl; 

       cout<<endl<<"Press space to continue."<<endl;       

       _getch();

 

       //One more example

       int sizeOfSpace = strlen("his")+1;

       string word="his_";

       for (int currentState=0; currentState< sizeOfSpace-1; currentState++)

       {      double prSum, transitionPrTable[4];

              cout << "Probability distribution over " << endl

                     << "all possible next states given that the current state is "

                     << word[currentState] << endl;

 

              prSum = 0;

              //nextStatePrTableGivenCurrentState(currentState,transitionPrTable,6);

              getPrTableForPossibleNextStates

              (transitionPrTable, 4, currentState);

 

              for (int nextState=0; nextState< sizeOfSpace; nextState++)

              {      cout << '\t'

                            << "Pr[NextState=" << word[nextState] << "|CurrentState=" << word[currentState] << "]="

                            << transitionPrTable[nextState] << endl;

                     prSum += transitionPrTable[nextState];

              }

 

              cout << "The sum of probabilities over " << endl

                << "all possible next states given that CurrentState="

                << word[currentState] << endl

                << "is verified as "

                << prSum  << endl << endl;

 

              cout<<endl<<"Press space to continue."<<endl;       

              _getch();

       }

 

 

       //One more example

       cout << endl << endl

               << "*********************************************************" << endl

               << "Consider the 5-character word \"right\" "<< endl

               << "Show the transition probabilities when spelling the word." << endl

               << "*********************************************************" << endl

               << "Demonstrate transition probabilities from current state to the next state."  << endl

               << "We use special character \'_\' to represent the special final state F."  << endl

               << "*********************************************************" << endl; 

       cout<<endl<<"Press space to continue."<<endl;       

       _getch();

       sizeOfSpace = strlen("right")+1;

       word="right_";

       for (int currentState=0; currentState< sizeOfSpace-1; currentState++)

       {      double prSum, transitionPrTable[6];

              cout << "Probability distribution over " << endl

                     << "all possible next states given that the current state is "

                     << word[currentState] << endl;

 

              prSum = 0;

              //nextStatePrTableGivenCurrentState(currentState,transitionPrTable,6);

              getPrTableForPossibleNextStates

              (transitionPrTable, 6, currentState);

 

              for (int nextState=0; nextState< sizeOfSpace; nextState++)

              {      cout << '\t'

                            << "Pr[NextState=" << word[nextState] << "|CurrentState=" << word[currentState] << "]="

                            << transitionPrTable[nextState] << endl;

                     prSum += transitionPrTable[nextState];

              }

 

              cout << "The sum of probabilities over " << endl

                << "all possible next states given that CurrentState="

                << word[currentState] << endl

                << "is verified as "

                << prSum  << endl << endl;

 

              cout<<endl<<"Press space to continue."<<endl;       

              _getch();

       }

 

}