util.hpp

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef CMR_UTIL_H
#define CMR_UTIL_H

#include <algorithm>
#include <array>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <cmath>

namespace CMR {

struct OutPrefs {
    std::string probname; 


    bool save_tour = true; 
    bool dump_xy = false; 
    bool save_tour_edges = false; 

    bool gif_tour = false;


    bool verbose = false; 

    bool prog_bar = false;

    bool detailed_stats = false;
};


namespace Epsilon {


constexpr double Zero = 0.000001; 
constexpr double MinCut = 0.0001; 

constexpr double CutViol = 0.001;

constexpr double DualDust = 0.001; 

constexpr double TotalDelta = 0.01;

constexpr double PHratio = 0.1; 

}

namespace util {

inline bool var_integral(double d)
{ return fabs(d) < Epsilon::Zero || fabs(d) > 1 - Epsilon::Zero; }

double zeit (void); 
double real_zeit (void); 

template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
    return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
}

template<typename T, typename ...Args>
void ptr_reset(std::unique_ptr<T> &target, Args&& ...args)
{
    target.reset(new T(std::forward<Args>(args)...));
}

template<typename ElemType, typename PredType>
void erase_remove(std::vector<ElemType> &vec, PredType pred)
{
    vec.erase(std::remove_if(vec.begin(), vec.end(), pred), vec.end());
}

template <typename T>
struct C_resource_deleter {
    void operator()(T* ptr) const {
        if (ptr) free(ptr);
        ptr = nullptr;
    }
};



template<typename numtype>
using c_array_ptr = std::unique_ptr<numtype, C_resource_deleter<numtype>>;

template<class T>
class SquareUT {
public:
    SquareUT() = default; 

    SquareUT(SquareUT &&M) noexcept : data(std::move(M.data)) {}

    SquareUT &operator=(SquareUT &&M) noexcept
        { data = std::move(M.data); return *this; }


    SquareUT(size_t size) : data(size)
        {
            for (auto i = 0; i < size; ++i)
                data[i] = std::vector<T>(size - i);
        }

    SquareUT(size_t size, T val) : data(size)
        {
            for (auto i = 0; i < size; ++i)
                data[i] = std::vector<T>(size - i, val);
        }

    T &operator()(size_t row, size_t column)
        {
            return data[row][column - row];
        }

    void fill(const T &val)
        {
            for (std::vector<T> &vec : data)
                std::fill(vec.begin(), vec.end(), val);
        }

private:
    std::vector<std::vector<T>> data;
};

}

struct Segment {
    Segment() = default;

    Segment(int lo, int hi) : start(lo), end(hi) {}

    int size() const { return end - start + 1; }

    bool contains(int vx) const { return start <= vx && vx <= end; }

    bool subset_of(const Segment &seg) const
    { return seg.contains(start) && seg.contains(end); }

    bool operator>(const Segment &rhs) const
    {
        return std::make_tuple(size(), start, end) >
        std::make_tuple(rhs.size(), rhs.start, rhs.end);
    }

    bool operator==(const Segment &rhs) const
    { return start == rhs.start && end == rhs.end; }

    int start; 
    int end; 
};

struct EndPts {
    EndPts()  : end{{-1, -1}} {}
    EndPts(int e0, int e1) : end{{e0, e1}}
        { if (end[0] > end[1]) std::swap(end[0], end[1]); }

    std::array<int, 2> end;
};

inline bool operator==(EndPts e1, EndPts e2)
{
    return e1.end == e2.end;
}

inline std::ostream &operator<<(std::ostream &os, const EndPts &e)
{
    os << "(" << e.end[0] << ", " << e.end[1] << ")";
    return os;
}

}




#endif