root/ggpa/ActQNetwork.cpp

/*
 *  ActQNetwork.cpp
 */

#include "ActQNetwork.h"

/*
 * ActQNetwork
 * Parameters:   actionLength - max length on action.toInputs()
 *               stateLength - max length on state.toInputs()
 *               legalMoves - all possible moves
 *
 * Constructor. Creates a mapping of actions to neural networks.
 */
ActQNetwork::ActQNetwork(int actionLength, int stateLength, vector<Action*> legalMoves)
{
    vector<Action*>::iterator moveItr = legalMoves.begin();
    pair<Action, QNeuralNetwork> mapPair;
    for(; moveItr != legalMoves.end(); moveItr++){
        mapPair.first = *(*moveItr);
        mapPair.second = QNeuralNetwork(actionLength, stateLength);
        theMap.insert(mapPair);
    }
}

ActQNetwork::~ActQNetwork()
{
  /*    map<Action, QNeuralNetwork>::iterator mapItr;
    mapItr = theMap.begin(); 
    while(mapItr != theMap.end())
    {
        pair<Action, QNeuralNetwork> *rmPair = mapItr;
        mapItr++;
        delete rmPair;
    }
  */

}

/*
 * 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 ActQNetwork::update(State &state, Action &action, double utility)
{
    map<Action, QNeuralNetwork>::iterator mapItr =  theMap.find(action);
    mapItr->second.update(state, action, utility);
}

/*
 * 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 ActQNetwork::getValue(State &state, Action &action)
{
    map<Action, QNeuralNetwork>::iterator mapItr =  theMap.find(action);
    return mapItr->second.getValue(state, action);
}

/*
 * writeToFile
 *
 * Parameters:   file - String containing the name of the file to write to.
 * Return value: none
 *
 * Writes the QNeuralNetwork 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 ActQNetwork::writeToFile(string filename)
{
  map<Action, QNeuralNetwork>::iterator mapItr;
  for(mapItr = theMap.begin(); mapItr != theMap.end(); mapItr++)
      mapItr->second.writeToFile(filename);   
}

/* 
 * readFromFile
 *
 * Parameters:   file - string containing the name of the file to read from
 * Return value: none
 * 
 * Reads in a QNeuralNetwork from a file.  The current QNeuralNetwork will be set to 
 *    be this saved QNeuralNetwork
 */
void ActQNetwork::readFromFile(string filename)
{
  map<Action, QNeuralNetwork>::iterator mapItr;
  for(mapItr = theMap.begin(); mapItr != theMap.end(); mapItr++)
      mapItr->second.readFromFile(filename);
}