/************************************************************************/
//Please read these revised comments about how the prototypes of
// the
three function to implement in model.cpp for Programming #1
/************************************************************************/
/************************************************************************/
//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;
}
/************************************************************************/
//Calculate 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.
//Note
that the value of the parameter sizeOfTable should be
// exactly the number characters in the word.
//Store these prbabilities in the prTable
array.
/************************************************************************/
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
//**************************************************
}
/************************************************************************/
//Calculate for each actual cognitive
state for a word
// (excluding
the special I state),
// the
probability of that cognitive state being the next cognitive state
// given
that currentState is the index of the current state.
//Note
that the value of the parameter sizeOfTable should be
// 1 + the number characters in the word,
//Store
these probabilities in the transitionPrTable[] array.
/************************************************************************/
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();
}
}