MedUtils.h

//
// MedUtils: Collection of several needed utilities (Files IO, Matrix data type, Data structures, etc)
//
 
// This is a simple h file to include all library parts
 
#ifndef __MED_UTILS_H__
#define __MED_UTILS_H__
 
//#include "MedGenUtils.h"
//#include "MedMat.h"
//#include "MedMedical.h"
//#include "MedDataStructures.h"
#include <Logger/Logger/Logger.h>
#include "assert.h"
#include "MedPlot.h"
#if !defined(MES_LIBRARY)
#include <boost/program_options.hpp>
#endif
#include <boost/spirit/home/support/detail/hold_any.hpp>
#include <boost/algorithm/string.hpp>
#include <unordered_map>
#include <MedMat/MedMat/MedMatConstants.h>
#include "MedRunPath.h"
#include "MedSamplingHelper.h"
 
using namespace std;
 
enum MedBinningType {
    BIN_EQUIDIST,
    BIN_EQUISIZE,
    BIN_LAST
};
 
// Discretization
template <class S> int discretize(vector<S>& x, vector<int>& binned_x, int& nbins, int max_bins);
template <class S> int discretize(vector<S>& x, vector<int>& binned_x, int& nbins, int max_bins, float missing_value);
template <class S> int discretize(vector<S>& x, vector<int>& binned_x, int& nbins, int max_bins, MedBinningType binning);
template <class S> int discretize(vector<S>& x, vector<int>& binned_x, int& nbins, int max_bins, float missing_value, MedBinningType binning);
 
#if !defined(MES_LIBRARY)
namespace po = boost::program_options;
#endif
 
namespace medial {
    namespace print {
        template<class T> string print_obj(T obj, const string &format);
        template<class T> void print_vec(const vector<T> &vec, const string &title, const string &format, const string &delimeter = ", ");
        void print_vec(const vector<string> &vec, const string &title, const string &delimeter = ", ");
        template<class T> void print_hist_vec(const vector<T> &vec, const string &title, const string &format, const vector<double> *prctile_samples = NULL);
        #if !defined(MES_LIBRARY)
        string print_any(po::variable_value &a);
        #endif
 
        void log_with_file(ofstream &fw, const char *format_str, ...);
    }
    namespace process {
        template<class T> void prctils(const vector<T> &x, const vector<double> &prc, vector<T> &res, const vector<float> *weights = NULL);
        template<typename T> int binary_search_index(const T *begin, const T *end, T val);
        template<typename T> int binary_search_position(const T *begin, const T *end, T val, bool reversed = false);
        template<typename T> int binary_search_position_last(const T *begin, const T *end, T val, bool reversed = false);
 
        template<class T> int binary_search_position(const vector<T> &v, T search);
        template<class T> int binary_search_position(const vector<T> &v, T search,int start, int end);
    }
 
    namespace sort_ops {
        template<typename T> void get_sort_indexes(const vector<T> &x, const bool descending_order, bool const abs_val, vector<int> &indexes);
    }
 
 
    namespace io {
        void read_codes_file(const string &file_path, vector<string> &tokens);
        template<class T> string get_list(const unordered_map<string, T> &ls, const string &delimeter = ",") {
            string res = "";
            for (auto it = ls.begin(); it != ls.end(); ++it)
                if (it == ls.begin())
                    res += it->first;
                else
                    res += delimeter + it->first;
            return res;
        }
        template<class T> string get_list_op(const unordered_map<T, string> &ls, const string &delimeter = ",") {
            string res = "";
            for (auto it = ls.begin(); it != ls.end(); ++it)
                if (it == ls.begin())
                    res += it->second;
                else
                    res += delimeter + it->second;
            return res;
        }
        template<class ContainerType> string get_list(const ContainerType &ls, const string &delimeter = ",");
        
        #if !defined(MES_LIBRARY)
        class ProgramArgs_base {
        private:
            string base_config; 
            bool init_called; 
 
            po::options_description desc; 
            virtual void post_process() {};
            string get_section(const string &full_help, const string &search);
 
            void list_sections(const string &full_help, vector<string> &all_sec);
        protected:
            void init(po::options_description &prg_options, const string &app_l = "");
            ProgramArgs_base() { init_called = false; debug = false; }
        public:
            bool debug; 
            po::variables_map vm;
            string app_logo = "\
##     ## ######## ########  ####    ###    ## \n\
###   ### ##       ##     ##  ##    ## ##   ##    \n\
#### #### ##       ##     ##  ##   ##   ##  ##       \n\
## ### ## ######   ##     ##  ##  ##     ## ##       \n\
##     ## ##       ##     ##  ##  ######### ##       \n\
##     ## ##       ##     ##  ##  ##     ## ##       \n\
##     ## ######## ########  #### ##     ## ######## "; 
 
 
 
            virtual int parse_parameters(int argc, char *argv[]);
 
        };
        #endif
    }
 
    
    string get_git_version();
}
 
#include "MedUtils_imp.h"
 
#endif