proto/Source/utils.h

Go to the documentation of this file.

#ifndef _UTILS_H
#define _UTILS_H

#include <bitset>
#include <map>
#include <string>
#include <utility>
#include <vector>

// bits_in_char value
#include "config.h"

namespace ace {

template<class T>
struct select1st: public std::unary_function<T, typename T::first_type> {
    typename T::first_type operator()(const T& pair_arg) const {
        return pair_arg.first;
    }
};

template<class T>
struct select2nd: public std::unary_function<T, typename T::second_type> {
    typename T::second_type operator()(const T& pair_arg) const {
        return pair_arg.second;
    }
};

template<typename _Type>
inline bool ith_bit(_Type expr, size_t i) {
    return (expr >> i) & 1;
}

template<typename _Type>
inline _Type set_ith_bit(_Type expr, size_t i, bool on = true) {
    return expr | (static_cast<_Type>(on) << i);
}

template<typename _Type>
size_t bits_in(_Type expr) {
    size_t counter = 0;
    for ( size_t i = 0; i < sizeof(_Type)*constants::bits_per_char; ++i ) {
        counter += ith_bit<_Type>(expr, i);
    }
    return counter;
}

template<typename _Type>
inline _Type ff(void) {
    return ~ static_cast<_Type>(0);
}


std::string unsigned2str(size_t num);

std::string double2str(double num, unsigned precision = 0);

#ifdef _DEPENDENCY_MODE

typedef std::vector<std::vector<size_t> > sum_decompositions_t;

class SumDecompositions {
    typedef std::map<size_t, sum_decompositions_t*> overflow_sum_decompositions_mapping_t;
    size_t _n, _m;
    sum_decompositions_t **_tables;
    overflow_sum_decompositions_mapping_t _overflow;

    void _init(void);

    // No copy constructs.
    SumDecompositions(const SumDecompositions& sum_decompositions);
    // No assignments.
    SumDecompositions& operator=(const SumDecompositions& sum_decompositions);
public:
    
    SumDecompositions(size_t sum, size_t addends): _n(sum), _m(addends), _tables(NULL), _overflow() {
        _tables = new sum_decompositions_t*[_n*_m];
        _init();
    }
    ~SumDecompositions(void);
    const sum_decompositions_t * get_decompositions_table(size_t sum, size_t addends);
};

#else

typedef std::vector<std::vector<bool> > bools_table_t;
bools_table_t bools_table(size_t ones, size_t length);
#endif

} // namespace ace

#endif

---