cparameters.cpp

强化学习算法（R-Learning）难得的珍贵资料

// Copyright (C) 2003
// Gerhard Neumann ([e-mail])

//                
// This file is part of RL Toolbox.
// http://www.igi.tugraz.at/ril_toolbox
//
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
//    derived from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <time.h>
#include <stdio.h>

#include "cparameters.h"
#include "cutility.h"

#include <math.h>
#include <assert.h>



CParameters::CParameters()
{
	parameters = new std::map<string, rlt_real>();
}

CParameters::CParameters(CParameters &copy)
{
	parameters = new std::map<string, rlt_real>();

	addParameters(&copy);
}


CParameters::~CParameters()
{
	delete parameters;
}

void CParameters::loadParametersStream(istream *stream)
{
	char description[50];
	char line[250];
	int numParams;
	(*stream) >> description;
	(*stream) >> numParams;

	rlt_real value = 0.0;
	for (int i = 0; i < numParams; i ++)
	{
		stream->getline(line, 250);
		sscanf(line, "%s : %lf\n", description, &value);
		addParameter(description,value);
	}
}

void CParameters::saveParametersStream(ostream *stream)
{
	(*stream) << "Parameters " << parameters->size() << endl;

	std::map<string, rlt_real>::iterator it;

	for (it = parameters->begin(); it != parameters->end(); it ++)
	{
		(*stream) << (*it).first.c_str() << " : " << (*it).second << endl;
	}
}


void CParameters::loadParameters(FILE *stream)
{
	char description[50];
	int numParams;

	char buffer[80];
	//fscanf(stream, "%s %d\n", buffer, &numParams);

	int result = fscanf(stream, "%s %d\n", buffer, &numParams);

	rlt_real value = 0.0;
	
	if (result == 2)
	{
		for (int i = 0; i < numParams; i ++)
		{
			fscanf(stream, "%s : %lf\n", description, &value);
			
			if (getParameterIndex(description) >= 0)
			{
				setParameter(description, value);
			}
			else
			{
				addParameter(description,value);
			}
		}
	}
}

void CParameters::saveParameters(FILE *stream)
{
	fprintf(stream, "Parameters %d\n", parameters->size());

	std::map<string, rlt_real>::iterator it;

	for (it = parameters->begin(); it != parameters->end(); it ++)
	{
		fprintf(stream, "%s : %f\n",(*it).first.c_str(), (*it).second);
	}
}

void CParameters::saveParametersXML(FILE *stream)
{
	fprintf(stream, "<Parameters>\n");

	std::map<string, rlt_real>::iterator it;

	for (it = parameters->begin(); it != parameters->end(); it ++)
	{
		fprintf(stream, "<%s> %f </%s>\n",(*it).first.c_str(), (*it).second, (*it).first.c_str());
	}

	fprintf(stream, "</Parameters>\n");
}

void CParameters::loadParametersXML(FILE *stream)
{
	char buffer1[256];
	char paramName[256];
	rlt_real value = 0.0;

	fscanf(stream, "<Parameters>\n");

	std::map<string, rlt_real>::iterator it;

	fscanf(stream, "%s", buffer1);
	while (strcmp(buffer1, "</Parameters>") != 0)
	{
		if (fscanf(stream, " %lf </%s>\n", &value, paramName) != 2)
		{
			break;
		}
		paramName[strlen(paramName) - 1] = '\0';
		if (getParameterIndex(paramName) >= 0)
		{
			setParameter(paramName, value);
		}
		else
		{
			addParameter(paramName,value);
		}fscanf(stream, "%s", buffer1);
	}
	fscanf(stream, "\n");
}



void CParameters::addParameter(string name, rlt_real value)
{
	std::map<string, rlt_real>::iterator it;

	it = parameters->find(name);

	if (it == parameters->end())
	{
		(*parameters)[name] = value;
	}
}

void CParameters::removeParameter(string name)
{
	std::map<string, rlt_real>::iterator it = parameters->find(name);

	if (it != parameters->end())
	{
		parameters->erase(it);
	}
}

void CParameters::addParameters(CParameters *lparameters)
{
	std::map<string, rlt_real>::iterator it;

	
	for (int i = 0; i < lparameters->getNumParameters(); i ++)
	{
		string name = lparameters->getParameterName(i);
		it = parameters->find(name);

		if (it == parameters->end())
		{
			(*parameters)[name] = lparameters->getParameter(name);
		}
	}
}


rlt_real CParameters::getParameter(string name)
{
	if (parameters->find(name) != parameters->end())
	{
//		printf("Getting Paramter %s: %f\n", name.c_str(),(*parameters->find(name)).second);
		return (*parameters->find(name)).second;
	}
	else
	{
		printf("Getting unknown Parameter %s, Abort!!\n", name.c_str());
		assert(false);
		return -1;
	}
}

void CParameters::setParameter(string name, rlt_real value)
{
	std::map<string, rlt_real>::iterator it;

	it = parameters->find(name);

	if (it != parameters->end())
	{
		(*it).second = value;
	}
	else
	{
		printf("Setting Parameter, Warning : Unknown Parameter %s (Value %f)\n", name.c_str(), value);
	}
}

void CParameters::setParameters(CParameters *lparameters)
{
	std::map<string, rlt_real>::iterator it = parameters->begin();

	for (; it != parameters->end(); it ++)
	{
		if (lparameters->getParameterIndex((*it).first) >= 0)
		{
			(*it).second = lparameters->getParameter((*it).first);
		}
	}
}


rlt_real CParameters::getParameterFromIndex(unsigned int index)
{
	return getParameter(getParameterName(index));
}

string CParameters::getParameterName(unsigned int index)
{
	std::map<string, rlt_real>::iterator it;

	assert(index < parameters->size());

	unsigned int i = 0;
	for (it = parameters->begin(); i < index; it ++, i++);

	return (*it).first;
}

void CParameters::setParameterWithIndex(unsigned int index, rlt_real value)
{
	std::map<string, rlt_real>::iterator it;

	unsigned int i = 0;
	for (it = parameters->begin(); it != parameters->end(),i < index; it ++, i++);

	if (it != parameters->end())
	{
		(*it).second = value;
	}
}

int CParameters::getParameterIndex(string name)
{
	std::map<string, rlt_real>::iterator it = parameters->begin();

	int i = 0;
	while (it != parameters->end() && name != (*it).first)
	{
		it++;
		i++;
	}

	if (it != parameters->end())
	{
		return i;
	}
	else
	{
		return -1;
	}
}

int CParameters::getNumParameters()
{
	return parameters->size();
}

bool CParameters::operator == (CParameters &parameterObject)
{
	std::map<string, rlt_real>::iterator it = parameters->begin();

	if (parameterObject.getNumParameters() != getNumParameters())
	{
		return false;
	}

	for (int i = 0 ;it != parameters->end(); it++, i++)
	{
		if (parameterObject.getParameterIndex((*it).first) >= 0)
		{
			if (fabs((*it).second - parameterObject.getParameter((*it).first)) > 0.00001)
			{
				//printf("Different Param Values for Parameter %s, %f %f\n", (*it).first.c_str(), (*it).second, parameterObject.getParameter((*it).first));
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	return true;
}

bool CParameters::operator < (CParameters &compareParams)
{
	std::map<string, rlt_real>::iterator it = parameters->begin();
	while (it != parameters->end() && (*it).second == compareParams.getParameter((*it).first))
	{
		it ++;
	}
	if (it != parameters->end())
	{
		return (*it).second < compareParams.getParameter((*it).first);
	}
	else 
	{
		return false;
	}
}


CParameterObject::CParameterObject()
{
	parameterObjects = new std::list<paramPair>();
	adaptiveParameters = new std::map<string, CAdaptiveParameterCalculator *>();

}

CParameterObject::~CParameterObject()
{
	delete parameterObjects;
	delete adaptiveParameters;
}

void CParameterObject::addAdaptiveParameter(string name, CAdaptiveParameterCalculator *paramCalc)
{
	string paramName = name;
	(*adaptiveParameters)[name] = paramCalc;

	std::list<paramPair>::iterator it = parameterObjects->begin();