rutils.h

Go to the documentation of this file.

 
#ifndef RUTILS_H
#define RUTILS_H
 
#include "OACommonDefines.h"
#include "runif.h"
 
namespace oacpp
{
    /*
     Namespace for utilities based on runif
    */
    namespace rutils
    {
        void unifperm( std::vector<int> & pi, int q, RUnif & randomClass );
 
        template <class T>
        void findranks_slow_zero(const std::vector<T> & v, std::vector<int> & indx)
        {
            if (indx.size() != v.size())
            {
                indx.resize(v.size());
            }
            for (size_t i = 0; i < v.size(); i++)
            {
                indx[i] = static_cast<int>(i);
            }
            std::vector<T> vsort(v);
            std::sort<typename std::vector<T>::iterator>(vsort.begin(), vsort.end());
 
            for (size_t i = 0; i < v.size(); i++)
            {
                indx[i] = static_cast<int>(std::find(vsort.begin(), vsort.end(), v[i]) - vsort.begin());
            }
        }
 
        template <class T>
        void findranks_slow(const std::vector<T> & v, std::vector<int> & indx)
        {
            findranks_slow_zero(v, indx);
            for (size_t i = 0; i < indx.size(); i++)
            {
                indx[i] += 1;
            }
        }
 
        template <class T>
        bool findranksCompare(const std::pair<T, int> & first, const std::pair<T, int> & second)
        {
            return (first.first < second.first);
        }
 
        template <class T>
        void findranks_zero(const std::vector<T> & v, std::vector<int> & rank)
        {
            // create a vector of pairs to hold the value and the integer rank
            std::vector<std::pair<T, int> > p(v.size());
            std::vector<int> temp(p.size());
            for (size_t i = 0; i < v.size(); i++)
            {
                p[i] = std::pair<T, int>(v[i], static_cast<int>(i));
            }
 
            // if the rank vector is not the right size, resize it (the original values may be lost)
            if (rank.size() != v.size())
            {
                rank.resize(v.size());
            }
 
            // sort the pairs of values
            std::sort(p.begin(), p.end(), findranksCompare<double>);
 
            // take the ranks from the pairs and put them in the rank vector
            for (size_t i = 0; i < v.size(); i++)
            {
                rank[p[i].second] = static_cast<int>(i);
            }
        }
 
        template <class T>
        void findranks(const std::vector<T> & v, std::vector<int> & rank)
        {
            findranks_zero(v, rank);
            for (size_t i = 0; i < rank.size(); i++)
            {
                rank[i] += 1;
            }
        }
    } // end namespace
} // end namespace
 
#endif