/home/pascal/depot/filedata/src/tools.h

/***************************************************************************
 *   Copyright (C) 2005 by Nicolas PASCAL                                  *
 *   nicolas.pascal@icare.univ-lille1.fr                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

/***************************************************************************
 *  History :                                                              *
 *  16/08/05 : start                                                        *
 ***************************************************************************/

#ifndef TOOLS_H
#define TOOLS_H

#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <sstream>
#include <ctype.h>
#include <cmath>
#include <cfloat>
#include <typeinfo>
#include <algorithm>
#include <cassert>
#include <limits>

#include "tools_exceptions.h"
#include "geometry_common.h"

// #define isnan(x) ((x) != (x))

namespace MyTools {
    vector <unsigned short> get_digits (unsigned long long n);

    template <typename NumericType>
    const bool get_intersection(const std::vector < std::vector <NumericType> > &l1, const std::vector < std::vector <NumericType> > &l2, std::vector< NumericType > &intersection) {
          // extract the coordinates of the 2 points -> use double to be as precise as possible
        double x1=l1[0][0];double y1=l1[0][1];
        double x2=l1[1][0];double y2=l1[1][1];
        double x3=l2[0][0];double y3=l2[0][1];
        double x4=l2[1][0];double y4=l2[1][1];
        // some denominators
        double denom=((y4-y3)*(x2-x1)-(x4-x3)*(y2-y1));
        // inetrsection coordinates
        double x=DBL_MAX;
        double y=DBL_MAX;

        if (denom==0.)
            // the 2 lines are parallels
            return false;
        double div_denom=1./denom;

        double ua=((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3))*div_denom;

        // set intersection
        x=x1+ua*(x2-x1);
        y=y1+ua*(y2-y1);

        // fill the output vector
        intersection.clear();
        intersection.push_back(static_cast<NumericType>(x));
        intersection.push_back(static_cast<NumericType>(y));

        return true;
    }

//     template<class ForwardIterator, class T_Value>
//     ForwardIterator find_first_of ( ForwardIterator first1, ForwardIterator last1, const T_Value &value) {
//       return find_first_of(first1,last1,(T_Value*)(&value),(T_Value*)(&value+1));
//     }

    inline static bool is_big_endian(){
        short int word = 0x0001;
        char *byte = (char *) &word;
        return(byte[0] ? true : false);
    };
    inline static int get_endianness() {
        int i = 1;
        char *p = (char *)&i;
        return (p[0] == 1 ? 0 : 1);
    }
    inline void byte_swapper(unsigned char* b, int n) {
      register int i = 0;
      register int j = n-1;
      while (i<j) {
        std::swap(b[i], b[j]);
        i++, j--;
      }
    };

    template<class T>
    inline static void byte_swap (T &nb) {
      byte_swapper((unsigned char*)(&nb),sizeof(nb));
    };

    int string2int(const std::string &s) ;
    float string2float(const std::string &s) ;
    double string2double(const std::string &s) ;
    int char2int(const char &c);
    std::string char2string(const char &c);
    std::string int2string(const int &i, const int &nb_digit = -1) ;
    template<typename NumericType>
    std::string to_string( const NumericType & nb ) {
        std::ostringstream oss;
        oss << nb;
        return oss.str();
    }
    template<typename NumericType>
    NumericType to_num( const string &s_nb ) {
      // generate a flux with the string to be converted
      std::istringstream iss(s_nb);
      NumericType nb ;
      iss >> nb;
      return nb;
    }
    std::string to_bit( void* bit_field, const int size=1 );

    template<typename T_out>
    T_out round(const double &x) {
        return static_cast<T_out>(x + 0.5);
    }
    double angle_2D(double* p1, double* p2);

    const bool is_int(const std::string &s);
    const bool is_float( const std::string & s );
    const bool is_int(const char * start, const int sz);
    template<typename T>
    bool has_type( const std::string & str ) {
      std::istringstream iss( str );
      T val;
      // try to fully convert it. If successfull, the input string has the good type
      return ( iss >> val ) && ( iss.eof() );
    }

    const int count( const std::string & elt, const std::string & s );
    const int count( const char elt, const std::string & s );

    void remove_space(std::string &);
    string strip (const std::string &str, const char c = ' ');

    template <class T>
    const long double avg_array(const T* array, const int& nb_val, const T& fill_value);

    template <class T>
    T abs(const T& val=T(0)) {
        if (val<T(0)) return -val;
        else return val;
    }

    template <class T>
    const long double avg_array(const T* array, const int& nb_val, const T& fill_value) {
        bool good_val_found=false;
        long double acc=0.;
        int nb_good_val=0;
        for (int i = 0 ; i<nb_val ; ++i)
            if (array[i]!=fill_value) {
                if (!good_val_found)
                    good_val_found=true;
                acc+=static_cast<long double>(array[i]);
                ++nb_good_val;
            }
        if (good_val_found)
            return acc/static_cast<long double>(nb_good_val);
        else
            return -LDBL_MAX;
    }

    template<typename T>
    bool gt_comparator ( T i, T j) { return ( i > j ); };
    template<typename T>
    T sum (const T &i, const T &j) { return i+j; }
    template<typename T>
    T prod (const T &i, const T &j) { return i * j; }
    template<typename T>
    T log_op (const T &i) { return log((double)(i)); }

    class KeyComparator {
    public:
        string key;
        KeyComparator (const string & key) : key(key){};
        bool operator ()(pair <string, string> const& key_val) const {
            return key_val.first == key;
        }
    };
    template <class T>
    class NotEqualComparator {
    public:
        T val;
        NotEqualComparator (const T &val) : val(val){};
        bool operator ()(const T ignored_val) const {
            return val != ignored_val;
        }
    };
    template<typename T>
    double get_abscissa ( const T val, const vector < T > & vec ) {
        return get_abscissa ( val, vec.begin(), vec.size() );
    };

    template<typename T>
    double get_abscissa ( const T val, const T * v_abs, const int n_abs ) {
        double invalid = numeric_limits<double>::signaling_NaN();
        if ( n_abs <= 1 )
            return invalid;

        // find insertion position of v in the abscissa vector
        T * v_abs_begin = const_cast < T * > ( v_abs );
        T * v_abs_end   = v_abs_begin + n_abs;

        bool is_ascending_order = ( v_abs [1] > v_abs [0] );
        T * it = v_abs_begin;

        if ( is_ascending_order ) { // ascending order
            it = lower_bound ( v_abs_begin, v_abs_end, val );
        } else { // descending order -> use ">" as comparator
            it = lower_bound ( v_abs_begin, v_abs_end, val, gt_comparator < T > );
        }

        if ( it == v_abs_begin || it == v_abs_end )
            return invalid;

        size_t ilow = ( it - 1 ) - v_abs;
        T lower_bound = * ( it - 1 );
        T upper_bound = * ( it );
// printf ( "bound = ( %f, %f )\tratio = %f\n", lower_bound, upper_bound, ( val - lower_bound ) / ( upper_bound - lower_bound ) );
        return ilow + ( val - lower_bound ) / ( upper_bound - lower_bound );
    };
    template <typename Txout, typename Tyout, typename Txin>
    void get_abscissa_sequential (Tyout * y_out, const Txout * x_out, const int sz_out, const Txin * x_in, const int sz_in) {
        // check if x_in are sorted in ascending or descending order
        bool is_asc = ( x_in [1] > x_in [0] );

        // compute the linear abscissa of x_out in x_in coordinates
        Tyout nan = numeric_limits<Tyout>::signaling_NaN();
        int j;
        for (int i = 0 ; i < sz_out ; ++i) {
            j = 0;
            while ((j < (sz_in - 1)) &&
                   ((  is_asc && (x_out[i] > x_in [j+1])) ||
                    (! is_asc && (x_out[i] < x_in [j+1]))
                   ))
                ++j;
            if (j >= (sz_in - 1) || isnan (x_out[i]))
                y_out [i] = nan;
            else {
                y_out [i] = j + (x_out[i] - x_in [j]) / (x_in [j+1] - x_in [j]);
            }
        }
    }

    template <typename Txout, typename Tyout, typename Txin>
    void get_log_abscissa_sequential (Tyout * y_out, const Txout * x_out, const int sz_out, const Txin * x_in, const int sz_in) {
        // build log of searched x
        double x_out_log[sz_out];
        for (int i = 0 ; i < sz_out ; ++i )
            x_out_log [i] = log(double(x_out[i]));

        // build log(P) of reference x coordinates
        double x_in_log [sz_in];
        for (int i = 0 ; i < sz_in ; ++i )
            x_in_log [i] = log((double)(x_in[i]));

        get_abscissa_sequential (y_out, x_out_log, sz_out, x_in_log, sz_in);
    }

    template<typename T>
    vector <T> arange (const T &val_min, const T &val_max, const T &inc = (T)(1));
    template<typename T>
    void arange (vector <T> & v, const T &val_min, const T &val_max, const T &inc = (T)(1));
    template<typename T>
    void push_back (const vector <T> & v_in, vector <T> & v_out);

    template <typename T>
    std::string vec2str (const T * vec, const size_t sz) {
        std::ostringstream oss;
        oss << "[";
        for (size_t i = 0 ; i < sz ; ++i) {
            oss << vec[i];
            if (i < (sz - 1))
                oss << ", ";
        }
        oss << "]";
        return oss.str();
    };
    template <typename T>
    std::string vec2str ( const vector <T> & vec ) {
        return vec2str ((T*)(&vec[0]), vec.size());
    };
    template <typename T>
    void print_vec ( const T * vec, const size_t sz ) {
        cout << vec2str(vec, sz) << endl;
    };
    template <typename T>
    void print_vec ( const vector <T> & vec ) {
        print_vec ((T*)(&vec[0]), vec.size());
    };
};

template<typename T>
void MyTools::push_back(const std::vector<T> & v_in, std::vector<T> & v_out) {
    if (! v_in.empty()) {
        v_out.reserve (v_out.size() + v_in.size());
        for (typename std::vector<T>::const_iterator it = v_in.begin() ; it != v_in.end() ; ++it)
            v_out.push_back(*it);
    }
};

template<typename T>
vector< T > MyTools::arange(const T & val_min, const T & val_max, const T & inc) {
    vector <T> v(0);
    arange (v, val_min, val_max, inc);
    return v;
}

template<typename T>
void MyTools::arange(vector< T > & v, const T & val_min, const T & val_max, const T & inc) {
    v.clear();
    size_t sz = (size_t)((val_max - val_min) / inc);
    v.reserve (sz);
    for (T val = val_min ; val < val_max ; val = (T)(val + inc))
        v.push_back (val);
}

#endif