Util.cpp

Go to the documentation of this file.

//SpikeStream includes
#include "Util.h"
#include "NumberConversionException.h"
using namespace spikestream;

//Qt includes
#include <QDebug>
#include <QTime>
#include <QStringList>
#include <QCoreApplication>

//Other includes
#include <stdint.h>
#include "math.h"
#include <iostream>
using namespace std;


mpf_class Util::factorial (unsigned int num){
        mpz_class result=1;
        for (unsigned int i=1; i<=num; ++i)
                result *= i;
        return result;
}


void Util::fillSelectionArray(bool* selectionArray, int arraySize, int selectionSize){
        int nonSelectionSize = arraySize - selectionSize;

        //Add zeros at start of array up to the non-selection size
        for(int i=0; i<nonSelectionSize; ++i)
                selectionArray[i] = false;

        //Add 1s to the rest of the array
        for(int i=nonSelectionSize; i<arraySize; ++i)
                selectionArray[i] = true;
}


bool Util::getBool(const QString& str){
        if(str.toLower() == "true")
                return true;
        else if (str.toLower() == "false")
                return false;
        throw NumberConversionException("Error converting '" + str + "' to boolean.");
}


bool Util::getBoolParameter(const QString& paramName, QHash<QString, double>& paramMap){
        if(!paramMap.contains(paramName))
                throw SpikeStreamException("Parameter '" + paramName + "'' not found in parameter map.");
        if(paramMap[paramName] == 0.0)
                return false;
        return true;
}


float Util::getFloat(const QString& str){
        bool ok = true;
        float newFloat = str.toFloat(&ok);
        if(!ok)
                throw NumberConversionException("Error converting '" + str + "' to float.");
        return newFloat;
}


int Util::getInt(const QString& str){
        bool ok = true;
        int newInt = str.toInt(&ok);
        if(!ok)
                throw NumberConversionException("Error converting '" + str + "' to integer.");
        return newInt;
}


unsigned int Util::getUInt(const QString& str){
        bool ok = true;
        unsigned int newInt = str.toUInt(&ok);
        if(!ok)
                throw NumberConversionException("Error converting '" + str + "' to unsigned integer.");
        return newInt;
}


QList<unsigned int> Util::getUIntList(const QString& str){
        QStringList strList = str.split(",", QString::SkipEmptyParts);
        QList<unsigned int> uIntList;
        foreach(QString tmpStr, strList)
                uIntList.append(Util::getUInt(tmpStr.trimmed()));
        return uIntList;
}


double Util::getDouble(const QString& str){
        bool ok = true;
        double newDouble = str.toDouble(&ok);
        if(!ok)
                throw NumberConversionException("Error converting '" + str + "' to double.");
        return newDouble;
}


double Util::getDoubleParameter(const QString& paramName, QHash<QString, double>& paramMap){
        if(!paramMap.contains(paramName))
                throw SpikeStreamException("Parameter '" + paramName + "'' not found in parameter map.");
        return paramMap[paramName];
}

double Util::getPositiveDoubleParameter(const QString& paramName, QHash<QString, double>& paramMap){
        if(!paramMap.contains(paramName))
                throw SpikeStreamException("Parameter '" + paramName + "'' not found in parameter map.");
        if(paramMap[paramName] < 0.0)
                throw SpikeStreamException("Parameter '" + paramName + "'' should be greater than 0: " + QString::number(paramMap[paramName]));
        return paramMap[paramName];
}


float Util::getFloatParameter(const QString& paramName, QHash<QString, double>& paramMap){
        if(!paramMap.contains(paramName))
                throw SpikeStreamException("Parameter '" + paramName + "'' not found in parameter map.");
        return (float)paramMap[paramName];
}


int Util::getIntParameter(const QString& paramName, QHash<QString, double>& paramMap){
        if(!paramMap.contains(paramName))
                throw SpikeStreamException("Parameter '" + paramName + "'' not found in parameter map.");
        if(rint(paramMap[paramName]) != paramMap[paramName])
                throw SpikeStreamException("Parameter '" + paramName + "'' is not an integer.");
        return (int) paramMap[paramName];
}


unsigned Util::getUIntParameter(const QString& paramName, QHash<QString, double>& paramMap){
        if(!paramMap.contains(paramName))
                throw SpikeStreamException("Parameter '" + paramName + "'' not found in parameter map.");
        if(rint(paramMap[paramName]) != paramMap[paramName])
                throw SpikeStreamException("Parameter '" + paramName + "'' is not a whole number.");
        if(paramMap[paramName] < 0.0)
                throw SpikeStreamException("Expecting a positive number, but parameter '" + paramName + "'' is less than 0.");
        return (unsigned) paramMap[paramName];
}


void Util::printParameterMap(const QHash<QString, double>& paramMap){
        cout<<"---------------  Parameter map  -------------"<<endl;
        for(QHash<QString, double>::const_iterator iter = paramMap.begin(); iter != paramMap.end(); ++iter){
                cout<<"\tKey: "<<iter.key().toStdString().data()<<" value: "<<iter.value()<<endl;
        }
        cout<<endl;
}


int Util::getRandom(int min, int max){
        if(max <= min)
                throw SpikeStreamException("Incorrect range for random number: maximum <= minimum.");

        int randomNum = min;
        randomNum += Util::rUInt((max-1-min) * ((double)qrand() / (double)RAND_MAX));
        return randomNum;
}


double Util::getRandomDouble(double min, double max){
        if(min > max)
                throw SpikeStreamException("Minimum cannot be greater than maximum");
        if(min == max)
                return min;
        double ranNum = (double)rand() / (double) RAND_MAX;
        return min + (max-min)*ranNum;
}


float Util::getRandomFloat(float min, float max){
        if(min > max)
                throw SpikeStreamException("Minimum cannot be greater than maximum");
        if(min == max)
                return min;
        float ranNum = (float)rand() / (float) RAND_MAX;
        return min + (max-min)*ranNum;
}


unsigned int Util::getRandomUInt(unsigned min, unsigned max){
        if(min > max)
                throw SpikeStreamException("Minimum cannot be greater than maximum");
        if(min == max)
                return min;
        return min + rand() % (max-min);
}


QString Util::getRootDirectory(){
        //Get the working directory - this varies depending on the operating system
        QString rootDirectory = QCoreApplication::applicationDirPath();
        #ifdef MAC32_SPIKESTREAM
                rootDirectory = rootDirectory.section("/bin", -2, -2, QString::SectionSkipEmpty);
        #else//Windows or Linux
                rootDirectory.truncate(rootDirectory.size() - 4);//Trim the "/bin" off the end
        #endif
        return rootDirectory;
}

bool Util::isNumber(const QString& str){
        //Is it a float - return true if no exception is thrown
        try{
                getFloat(str);
                return true;
        }
        catch(SpikeStreamException&){}

        //Is it a double - return true if no exception is thrown
        try{
                getDouble(str);
                return true;
        }
        catch(SpikeStreamException&){}

        //Is it an integer - return true if no exception is thrown
        try{
                getInt(str);
                return true;
        }
        catch(SpikeStreamException&){}

        //Is it an unsigned integer - return true if no exception is thrown
        try{
                getUInt(str);
                return true;
        }
        catch(SpikeStreamException&){}

        //If we have got to here no number conversion method will work on the string.
        return false;
}


float Util::min(float n1, float n2, float n3){
        if(n1 < n2 && n1 < n3)//Is n1 the minimum?
                return n1;
        if(n2 < n3)//n1 is not the minimum, is n2 the minimum?
                return n2;
        return n3;

}


void Util::printBinary(uint64_t number){
        int numBits = sizeof(number) * 8;
        uint64_t probe = 2;// 0x8000000000000000;
        for(int i=0; i<numBits; ++i){
                if(probe & number)
                        cout<<"1";
                else
                        cout<<"0";
                probe >>=1;
        }
        cout<<endl;
}


void Util::printBoolArray(bool arr[], int arrLen){
        cout<<"Bool Array: ";
        for(int i=0; i< arrLen; ++i){
                if(arr[i])
                        cout<<"1";
                else
                        cout<<"0";
        }
        cout<<endl;
}


void Util::printByteArray(byte* byteArr, int arrLen){
        cout<<"Byte array: ";
        for(int i=0; i< arrLen*8; ++i){
                if(byteArr[i/8] & 1<<(i%8))
                        cout<<"1";
                else
                        cout<<"0";
        }
        cout<<endl;
}


void Util::printByteArray(const QByteArray& byteArr){
        cout<<"QByteArray: ";
        for(int i=0; i< byteArr.size(); ++i){
                byte tmpByte = (unsigned char) byteArr.at(i);
                for(int j=0; j<8; ++j){
                        if(tmpByte & 1<<j)
                                cout<<"1";
                        else
                                cout<<"0";
                }
        }
        cout<<endl;
}


double Util::rDouble(double num, int numPlaces){
        double tempDoub = num * ( pow(10.0, (double)numPlaces) );
        tempDoub = rint(tempDoub);
        tempDoub /= ( pow(10.0, (double)numPlaces) );
        return tempDoub;
}


int Util::rInt(double num){
        num = rint(num);
        return (int) num;
}


unsigned int Util::rUInt(double num){
        num = rint(num);
        return (unsigned int) num;
}


void Util::safeCStringCopy(char target[], const char source[], int targetSize){
        int newLength = strlen(source);
        if(newLength > targetSize){
                throw SpikeStreamException("Source cstring too large for destination cstring.");
        }
        int i;
        for(i=0; i< newLength; ++i) //Copy everything up to newLength-1
                target[i] = source[i];
        target[i] = '\0';//Finish string with null character
}



void Util::seedRandom(int seed){
        if(seed == 0){
                QTime midnight(0, 0, 0);
                qsrand(midnight.secsTo(QTime::currentTime()));
        }
        else
                qsrand(seed);
}


void Util::addTraining(WeightlessNeuron& neuron, QString trainingPattern, int output){
        unsigned char* byteArr;
        int arrLen;
        fillByteArray(byteArr, arrLen, trainingPattern);
        QByteArray qByteArr = QByteArray::fromRawData((const char*)byteArr, arrLen);
        neuron.addTraining(qByteArr, output);
        delete [] byteArr;
}


bool Util::bitsEqual(unsigned char* byteArr, QString bitPattStr, int output){
        if(byteArr[0] != output)
                return false;

        for(int i=0; i<bitPattStr.length(); ++i){
                if(bitPattStr[i] == '1' && (byteArr[1 + i/8] & ( 1<<(i % 8) )))//1 is equal
                        ;//do nothing
                else if(bitPattStr[i] == '0' && !(byteArr[1 + i/8] & ( 1<<(i % 8) )))//0 is equal
                        ;//Do nothing
                else
                        return false;//String and byte array do not match
        }
        return true;
}


void Util::fillByteArray(unsigned char*& byteArr, int& arrLen, QString byteStr){
        if(byteStr.length() % 8 == 0)
                arrLen = byteStr.length() / 8;
        else
                arrLen = byteStr.length() / 8 + 1;
        byteArr = new unsigned char[arrLen];

        //Initialize array
        for(int i=0; i<arrLen; ++i)
                byteArr[i] = 0;

        //Set bits corresponding to 1's in byte string
        for(int i=0; i<byteStr.length(); ++i){
                if(byteStr[i] == '1')
                        byteArr[i/8] |= 1<<(i % 8);
        }
}


void Util::setGeneralization(QHash<unsigned int, WeightlessNeuron*>& weiNeurMap, double gen){
        for(QHash<unsigned int, WeightlessNeuron*>::iterator iter = weiNeurMap.begin(); iter != weiNeurMap.end(); ++iter)
                iter.value()->setGeneralization(gen);
}


double Util::toPositive(double num){
        if (num > 0.0)
                return num;
        return num * -1.0;
}


float Util::toPositive(float num){
        if (num > 0.0f)
                return num;
        return num * -1.0f;
}


int Util::toPositive(int num){
        if (num >= 0)
                return num;
        return num * -1;
}