root/ggpa/Table.cpp

#include "Table.h"
#include <iostream>
#include <fstream>
#include <map>
#define INVALID -.000001

/*
 * update
 * Parameters:   state - a State object that represents a state in the game
 *               action - an Action object that represents an action in the
 *                        game
 *               utility - a double that represents the utility to insert
 *                         for this State/Action pair
 * No return value
 *
 * Updates the entry for the given State/Action pair.
 */
void Table::update(State &state, Action &action, double utility)
{
    pair<State, Action> thePair(state, action);
    tableMap[thePair] = utility;

    return;
}

/*
 * getValue
 * Parameters:   state - a State object that represents a state in the game
 *               action - an Action object that represents an action in the
 *                        game
 * Return value: a double representing the utility of the given State/
 *   Action pair.
 * This function will return the current utility of the given State/Action 
 *   pair.  In other words, it will return a value representing how good 
 *   the action is from the state.
 */
double Table::getValue(State &state, Action &action)
{
    pair<State, Action> thePair(state, action);

    //check to see if the value is present in the map already
    if (tableMap.find(thePair) != tableMap.end()) {
        // if so, just return the value
        return tableMap[thePair];
    }

    // otherwise, generate a default value (either small random number or 0),
    // and insert it into the map so that it will be consistent
    double newUtility = 0;
    if (!DEFAULT_ZERO) {
        // create a small random number between NUM_MIN and NUM_MAX
        // get a random number between 0 and 1
        double num = (double) rand() / ((double) RAND_MAX + (double) 1);
        // scale it to the range NUM_MIN to NUM_MAX
        newUtility = num * (NUM_MAX - NUM_MIN) + NUM_MIN;
    
    }

    // set thePair to use copies of state and action
    //thePair.first = new State(state);
    //thePair.second = new Action(action);
        
    // add the new value to the map
    tableMap[thePair] = newUtility;

    return newUtility;

    /*
    map<pair<State*, Action*>, double, StateActionCmp>::iterator findItr = tableMap.begin();
    while(!(*findItr == tableMap.end()) && (!(findItr->first.first == state) 
                || !(findItr->first.second == action)))

    {
        findItr++;
    }
    if(findItr != tableMap.end())
        return findItr->second;
    else
        return INVALID;
    */
    //return 0;
}

/*
 * writeToFile
 *
 * Parameters:   file - String containing the name of the file to write to.
 * Return value: none
 *
 * Writes the QFunction to the given file.  If the file does not exist, it
 *   will be created.  If it does exist, then it will be written to the 
 *   end of the file
 */
void Table::writeToFile(string filename)
{
    /*
    ofstream filename;
    filename.open ("filename");
    iterator itr;
    for(itr = tableMap.begin(); itr != tableMap.end(); itr++)
    {
        filename << itr->first.first << "\n";
        filename << itr->first.second << "\n";
        filename << itr->second << "\n";
    }
    filename << "End.\n";
    filename.close();
    */
}

/* 
 * readFromFile
 *
 * Parameters:   file - string containing the name of the file to read from
 * Return value: none
 * 
 * Reads in a QFunction from a file.  The current QFunction will be set to 
 *    be this saved QFunction
 */
void Table::readFromFile(string filename)
{
    /*
    ifstream myfile;
    String state;
    String action;
    pair<Action, State> thePair;
    String utility;
    myfile.open ("filename");
    if (myfile.is_open())
    {
        state << myfile;
        while(state != "End.")
        {
            action << myfile;
            utility << myfile;
            thePair.first = state;
            thePair.second = action;
            tableMap.insert(make_pair(thePair, utility));
            state << filename;
        }

        }
        
        myfile.close();
    }

  else cout << "Unable to open file"; 
  */
}