util.h

Go to the documentation of this file.

/* This file is part of the Palabos library.
 *
 * Copyright (C) 2011 FlowKit Sarl
 * Avenue de Chailly 23
 * 1012 Lausanne, Switzerland
 * E-mail contact: contact@flowkit.com
 *
 * The most recent release of Palabos can be downloaded at 
 * <http://www.palabos.org/>
 *
 * The library Palabos is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * The library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef UTIL_H
#define UTIL_H

#include "core/globalDefs.h"
#include "core/plbDebug.h"
#include "core/runTimeDiagnostics.h"
#include "core/plbTypenames.h"
#include <algorithm>
#include <string>
#include <sstream>
#include <cmath>
#include <cstring>
#include <utility>
#include <vector>
#include <set>
#include <limits>

namespace plb {

namespace util {

template<typename T>
T sqr(T arg) {
    return arg*arg;
}

inline plint kronDelta(plint iA, plint iB) {
    if (iA == iB) return 1;
    else return 0;
}




inline bool boolIsEqual(bool val1, bool val2) {
    return ( (val1 && val2) || !(val1 || val2) );
}

template<typename T>
plint roundToInt(T value) {
    return value>0 ?
               static_cast<plint>(value+(T)0.5) :
               static_cast<plint>(value-(T)0.5);
}

inline plint roundUp(plint value, plint step) {
    plint modulo = value % step;
    plint result = value-modulo;
    if (modulo>0) {
        result += step;
    }
    return result;
}

inline plint roundDown(plint value, plint step) {
    plint modulo = value % step;
    plint result = value-modulo;
    if (modulo<0) {
        result -= step;
    }
    return result;
}

inline double twoToThePower(int power) {
    switch(power) {
        case 0: return 1.;
        case 1: return 2.;
        case 2: return 4.;
        case 3: return 8.;
        case 4: return 16.;
        case 5: return 32.;
        case 6: return 64.;
        case 7: return 128.;
        case 8: return 256.;
        case -1: return 1./2.;
        case -2: return 1./4.;
        case -3: return 1./8.;
        case -4: return 1./16.;
        case -5: return 1./32.;
        case -6: return 1./64.;
        case -7: return 1./128.;
        case -8: return 1./256.;
        default: return pow(2., (double)power);
    }
}

template<typename T>
std::string val2str(T val) {
    std::stringstream valstr;
    valstr << val;
    return valstr.str();
}

template<typename T1, typename T2>
std::string val2str(T1 val1, T2 val2) {
    std::stringstream valstr;
    valstr << val1 << " " << val2;
    return valstr.str();
}

template<typename T1, typename T2, typename T3>
std::string val2str(T1 val1, T2 val2, T3 val3) {
    std::stringstream valstr;
    valstr << val1 << " " << val2 << " " << val3;
    return valstr.str();
}

template<typename T>
void str2val(std::string str, T& val) {
    std::stringstream stream(str);
    if (!(stream >> val)) {
        plbLogicError (
                std::string("Could not convert string \"") + str +
                std::string("\" to type ") +
                std::string(NativeType<T>::getName()) );
    }
}

inline
std::vector<std::string> split(std::string str) {
    std::stringstream stream(str);
    std::string buf;
    std::vector<std::string> result;
    while (stream>>buf) {
        result.push_back(buf);
    }
    return result;
}

template<typename T>
std::string consume(std::string str, T& val) {
    std::vector<std::string> tokens = split(str);
    if (tokens.size()>=1) {
        str2val(tokens[0], val);
    }
    else {
        plbLogicError("Could not read value from empty string.");
    }
    std::string remaining;
    for (plint i=1; i<(plint)tokens.size(); ++i) {
        remaining += tokens[i];
        if (i != (plint)tokens.size()-1) {
            remaining += " ";
        }
    }
    return remaining;
}

template<typename T1, typename T2>
std::string consume(std::string str, T1& val1, T2& val2) {
    std::vector<std::string> tokens = split(str);
    if (tokens.size()>=2) {
        str2val(tokens[0], val1);
        str2val(tokens[1], val2);
    }
    else {
        plbLogicError (
                std::string("Could not read two values from string \"") + str +
                std::string("\"") );
    }
    std::string remaining;
    for (plint i=2; i<(plint)tokens.size(); ++i) {
        remaining += tokens[i];
        if (i != (plint)tokens.size()-1) {
            remaining += " ";
        }
    }
    return remaining;
}

template<typename T1, typename T2, typename T3>
std::string consume(std::string str, T1& val1, T2& val2, T3& val3) {
    std::vector<std::string> tokens = split(str);
    if (tokens.size()>=3) {
        str2val(tokens[0], val1);
        str2val(tokens[1], val2);
        str2val(tokens[2], val3);
    }
    else {
        plbLogicError (
                std::string("Could not read three values from string \"") + str +
                std::string("\"") );
    }
    std::string remaining;
    for (plint i=3; i<(plint)tokens.size(); ++i) {
        remaining += tokens[i];
        if (i != (plint)tokens.size()-1) {
            remaining += " ";
        }
    }
    return remaining;
}

inline std::string tolower(std::string arg) {
    std::string result(arg.size(), ' ');
    std::transform(arg.begin(), arg.end(), result.begin(), ::tolower);
    return result;
}

inline std::string toupper(std::string arg) {
    std::string result(arg.size(), ' ');
    std::transform(arg.begin(), arg.end(), result.begin(), ::toupper);
    return result;
}



template<typename T>
class Buffer {
public:
    Buffer()
        : bufferSize(0),
          data(0)
    { }
    Buffer(pluint bufferSize_)
        : bufferSize(bufferSize_),
          data(new T[bufferSize])
    { }
    Buffer(Buffer<T> const& rhs)
        : bufferSize(rhs.bufferSize),
          data(new T[bufferSize])
    {
        for (pluint iData=0; iData<bufferSize; ++iData) {
            data[iData] = rhs.data[iData];
        }
    }
    ~Buffer() {
        delete [] data;
    }
    Buffer<T>& operator=(Buffer<T> const& rhs) {
        Buffer<T> newBuffer(rhs);
        swap(newBuffer);
        return *this;
    }
    void swap(Buffer<T>& rhs) {
        std::swap(bufferSize, rhs.bufferSize);
        std::swap(data, rhs.data);
    }
    void resize(pluint newBufferSize) {
        if (newBufferSize > bufferSize) {
            Buffer<T> newBuffer(newBufferSize);
            for (pluint iData=0; iData<bufferSize; ++iData) {
                newBuffer.data[iData] = data[iData];
            }
            swap(newBuffer);
        }
    }
    void reallocate(pluint newBufferSize) {
        if (newBufferSize > bufferSize) {
            Buffer<T> newBuffer(newBufferSize);
            swap(newBuffer);
        }
    }
    T* get() {
        return data;
    }
    T const* get() const {
        return data;
    }
    T& operator[](pluint index) {
        PLB_PRECONDITION( index<bufferSize );
        return data[index];
    }
    T const& operator[](pluint index) const {
        PLB_PRECONDITION( index<bufferSize );
        return data[index];
    }
    pluint size() const {
        return bufferSize;
    }
private:
    pluint bufferSize;
    T* data;
};

inline void linearRepartition(plint x0, plint x1, plint nBlocks,
                              std::vector<std::pair<plint,plint> >& ranges)
{
    PLB_PRECONDITION(nBlocks>0);
    plint totalSize = x1-x0+1;
    PLB_PRECONDITION( nBlocks<=totalSize );
    ranges.resize(nBlocks);
    plint basicLength = totalSize/nBlocks;
    plint currentPos=0;
    for (plint iRange=0; iRange<nBlocks; ++iRange) {
        plint currentLength = basicLength;
        if (iRange<totalSize%nBlocks) {
            ++currentLength;
        }
        ranges[iRange] = std::pair<plint,plint>(x0+currentPos, x0+currentPos+currentLength-1);
        currentPos+=currentLength;
    }
}

inline void extendVectorSize(std::vector<int>& vect, pluint fullSize) {
    pluint currentSize = vect.size();
    if (currentSize<fullSize) {
        vect.resize(fullSize);
        for (pluint i=currentSize; i<fullSize; ++i) {
            vect[i] = -1;
        }
    }
}

template<typename T>
bool fpequal(T x, T y, T eps)
{
    bool val;

    if (fabs(x) <= 2.0 * eps)
        x = 0.0;

    if (fabs(y) <= 2.0 * eps)
        y = 0.0;

    if (x == 0.0 || y == 0.0) {
        if (fabs(x - y) <= 2.0 * eps)
            val = true;
        else
            val = false;
    } else {
        if (fabs(x - y) <= eps * fabs(x) &&
            fabs(x - y) <= eps * fabs(y))
            val = true;
        else
            val = false;
    }

    return val;
}

template<typename T>
bool fpequal_abs(T x, T y, T eps)
{
    return fabs(x-y) <= eps;
}

class UniqueId {
public:
    UniqueId() : currentId(0) { }
    id_t getId() {
        if (currentId==std::numeric_limits<id_t>::max()) {
            plbLogicError("Too many unique IDs requested.");
        }
        assignedIds.insert(currentId);
        return currentId++;
    }
    void releaseId(id_t id) {
        std::set<id_t>::iterator it = assignedIds.find(id);
        if (it==assignedIds.end()) {
            plbLogicError("Releasing a non-assigned ID.");
        }
        assignedIds.erase(it);
    }
private:
    UniqueId(UniqueId const& rhs) { }
    UniqueId& operator=(UniqueId const& rhs) { return *this; }
private:
    id_t currentId;
    std::set<id_t> assignedIds;
};

}  // namespace util

}  // namespace plb

#endif  // UTIL_H