/************************************************************************/
//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();
}
}