cutility.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.

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#include "ril_debug.h"
#include "cutility.h"
#include <assert.h>
#include <math.h>

int my_round(rlt_real value)
{
	int intvalue = (int) floor(value);
	if (value - intvalue > 0.5)
	{
		intvalue ++;
	}
	return intvalue;
}

rlt_real my_exp(rlt_real value)
{
	if (value > MAX_EXP)
	{
		value = MAX_EXP;
	}
	else
	{
		if (value < MIN_EXP)
		{
			value = MIN_EXP;
		}
	}
	return exp(value);
}


CMyVector::CMyVector(unsigned int dimensions, rlt_real *data)
{
	this->dimensions = dimensions;
	this->data = new rlt_real[dimensions];
	
	if (data)
	{
		memcpy(this->data, data, dimensions * sizeof(rlt_real));
	}
	else
	{
		for (unsigned int i = 0; i < dimensions; i++)
		{
			this->data[i] = 0.0;
		}
	}
}

CMyVector::~CMyVector()
{
	delete [] data;
}

void CMyVector::dotVector(CMyVector *vector)
{
	rlt_real *data_vec =  vector->getData();
	for (unsigned int i = 0;i < getNumDimensions(); i++)
	{
		data[i] *= data_vec[i];
	}
}

rlt_real CMyVector::scalarProduct(CMyVector *vector)
{
	assert(getNumDimensions() == vector->getNumDimensions());
	rlt_real *data2 = vector->getData();
	rlt_real skalarprod = 0.0;

	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		skalarprod += data[i] * data2[i];
	}
	return skalarprod;
}

rlt_real CMyVector::getDistance(CMyVector *vector)
{
	assert(getNumDimensions() == vector->getNumDimensions());
	rlt_real *data2 = vector->getData();
	rlt_real distance = 0.0;

	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		distance += pow(data[i] - data2[i], 2);
	}
	return sqrt(distance);
}

void CMyVector::addVector(CMyVector *vector)
{
	assert(getNumDimensions() == vector->getNumDimensions());
	rlt_real *data2 = vector->getData();
	
	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		data[i] += data2[i];
	}
}

void CMyVector::addScalar(rlt_real factor)
{
	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		data[i] += factor;
	}
}

void CMyVector::multMatrix(CMyMatrix *matrix, CMyVector *output)
{
	assert(getNumDimensions() == matrix->getNumRows() && output->getNumDimensions() == matrix->getNumColumns());
	rlt_real *dataRow;
	rlt_real *dataOutput = output->getData();
	
	rlt_real *vectorData;
	bool newVec = false;

	if (dataOutput == data)
	{
		vectorData = new rlt_real[getNumDimensions()];
		memcpy(vectorData, data, getNumDimensions() * sizeof(rlt_real));
		newVec = true;
	}
	else
	{
		vectorData = data;
	}

	output->initVector(0.0);

	for (unsigned int i = 0; i < matrix->getNumRows(); i++)
	{
		dataRow = matrix->getRow(i);

		for (unsigned int j = 0; j < matrix->getNumColumns(); j++)
		{
			dataOutput[j] += dataRow[j] * vectorData[i];
		}
	}
	if (newVec)
	{
		delete vectorData;
	}
}

void CMyVector::multMatrix(CMyMatrix *matrix)
{
	assert(getNumDimensions() == matrix->getNumColumns() && getNumDimensions() == matrix->getNumRows());

    multMatrix(matrix, this);
}


void CMyVector::multVector(CMyVector *vector, CMyMatrix *output)
{
	assert(getNumDimensions() == output->getNumRows() && vector->getNumDimensions() == output->getNumColumns());
	rlt_real *data2 = vector->getData();
	rlt_real *dataRow = NULL;

	for (unsigned int j = 0; j < output->getNumRows(); j++)
	{
		dataRow = output->getRow(j);
		for (unsigned int i = 0; i < output->getNumColumns(); i++)
		{
			dataRow[i] = data[j] * data2[i];
		}
	}
}

void CMyVector::multScalar(rlt_real scalar)
{
	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		data[i] *= scalar;
	}
}

rlt_real CMyVector::getElement(unsigned int index)
{
	assert(index < getNumDimensions());
	return data[index];
}

void CMyVector::saveASCII(FILE *stream)
{
	fprintf(stream,"[ ");
	for(unsigned int i = 0; i < getNumDimensions(); i++)
	{
		fprintf(stream, "%f ", data[i]);
	}
	fprintf(stream, "]\n");
}

void CMyVector::loadASCII(FILE *stream)
{
	fscanf(stream,"[ ");
	for(unsigned int i = 0; i < getNumDimensions(); i++)
	{
		fscanf(stream, "%f ", &data[i]);
	}
	fscanf(stream, "]\n");
}

void CMyVector::setElement(unsigned int index, rlt_real value)
{
	assert(index < getNumDimensions());
	data[index] = value;
}

unsigned int CMyVector::getNumDimensions()
{
	return dimensions;
}

rlt_real *CMyVector::getData()
{
	return data;
}

void CMyVector::setVector(CMyVector *vector)
{
	assert(vector->getNumDimensions() == getNumDimensions());
	memcpy(data, vector->getData(), getNumDimensions() * sizeof(rlt_real));
}

void CMyVector::initVector(rlt_real init)
{
	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		data[i] = init;
	}
}

rlt_real CMyVector::getLength()
{
	rlt_real length = 0;
	for (unsigned int i = 0; i < getNumDimensions(); i++)
	{
		length += pow(data[i], 2);
	}
	return sqrt(length);
}

void CMyVector::normalizeVector()
{
	rlt_real length = getLength();
	if (length > 0.00001)
	{
		multScalar(1.0 / length);
	}
}


CMyMatrix::CMyMatrix(unsigned int rows, unsigned int columns, rlt_real *data)
{
	this->rows = rows;
	this->columns = columns;
	this->data = new rlt_real[rows * columns];

	if (data != NULL)
	{
		memcpy(this->data, data, rows * columns * sizeof(rlt_real));
	}
}

CMyMatrix::~CMyMatrix()
{
	delete data;
}

void CMyMatrix::addVector(CMyVector *vector)
{
	rlt_real *rowData;
	
	for (unsigned int i = 0; i < getNumRows(); i++)
	{
		rowData = getRow(i);
		for (unsigned int j = 0; j < getNumColumns(); j++)
		{
			rowData[j] += vector->getElement(i);
		}
	}
}

void CMyMatrix::addScalar(rlt_real scalar)
{	
	rlt_real *rowData;

	for (unsigned int i = 0; i < getNumRows(); i++)
	{
		rowData = getRow(i);
		for (unsigned int j = 0; j < getNumColumns(); j++)
		{
			rowData[j] += scalar;
		}
	}
}


void CMyMatrix::multMatrix(CMyMatrix *matrix, CMyMatrix *output)
{
	assert(this->getNumColumns() == matrix->getNumRows() && output->getNumRows() == this->getNumRows() && output->getNumColumns() == matrix->getNumColumns());

	rlt_real *rowData = NULL;

	for (unsigned int i = 0; i < getNumRows(); i++)
	{
		rowData = output->getRow(i);
		for (unsigned int j = 0; j < getNumColumns(); j++)
		{
			rowData[j] = 0.0;
			for (unsigned int k = 0; k < getNumColumns(); k++)
			{
				rowData[j] += getElement(i, k) * matrix->getElement(k, j);
			}
		}
	}
}

void CMyMatrix::multVector(CMyVector *vector, CMyVector *output)
{
	assert(vector->getNumDimensions() == getNumColumns() && output->getNumDimensions() == getNumRows());
	rlt_real *dataRow;
	rlt_real *dataOutput = output->getData();

	rlt_real *vectorData = vector->getData();

	for (unsigned int i = 0; i < getNumRows(); i++)
	{
		dataRow = getRow(i);
		dataOutput[i] = 0.0;
		for (unsigned int j = 0; j < getNumColumns(); j++)
		{
			dataOutput[i] += dataRow[j] * vectorData[j];
		}
	}
}

void CMyMatrix::multScalar(rlt_real scalar)
{
	rlt_real *rowData;

	for (unsigned int i = 0; i < getNumRows(); i++)
	{
		rowData = getRow(i);
		for (unsigned int j = 0; j < getNumColumns(); j++)
		{
			rowData[j] *= scalar;
		}
	}
}

rlt_real CMyMatrix::getElement(unsigned int row, unsigned int column)
{
	return data[row * getNumColumns() + column];
}

void CMyMatrix::setElement(unsigned int row, unsigned int column, rlt_real value)
{
	data[row * getNumColumns() + column] = value;
}

rlt_real *CMyMatrix::getRow(unsigned int row)
{
	return (data + row * getNumColumns());
}

rlt_real *CMyMatrix::getData()
{
	return data;
}

unsigned int CMyMatrix::getNumRows()
{
	return rows;
}

unsigned int CMyMatrix::getNumColumns()
{