utils.h (59)

/*
    $Id: utils.h 59 2009-03-01 18:25:07Z matwey $
    Copyright (C) 2008  Matwey V. Kornilov <matwey.kornilov@gmail.com>

    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 3 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, see <http://www.gnu.org/licenses/>.
*/

#ifndef _UTILS_H
#define _UTILS_H

#include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>

namespace lsp {
template<class T> class less_abs:
        public std::binary_function<T, T, bool> {
private:
        std::less< T > m_less;
public:
        bool operator() (T x, T y) const {
                return m_less( std::abs(x), std::abs(y) );
        }
};

template<class T, class Less = std::less< typename T::value_type > > class vector_less:
        public std::binary_function< typename T::value_type, typename T::value_type, bool> {
private:
        typedef T                                vector_type;
        typedef typename vector_type::value_type value_type;
        typedef typename vector_type::size_type  size_type;
        typedef Less                             less_type;

        const vector_type& m_vector;
        less_type m_less;
public:
        vector_less( const vector_type& v ):
                m_vector( v ) {
        }
        bool operator() (size_type x, size_type y) const {
                return m_less( m_vector( x ), m_vector( y ) );
        }
};

template<class T, class Less = std::less< typename T::value_type > > class vector_less_nnls1:
        public std::binary_function< typename T::value_type, typename T::value_type, bool> {
private:
        typedef T                                vector_type;
        typedef typename vector_type::value_type value_type;
        typedef typename vector_type::size_type  size_type;
        typedef Less                             less_type;

        const vector_type& m_vector1,m_vector2;
        less_type m_less;
public:
        vector_less_nnls1( const vector_type& v1, const vector_type& v2 ):
                m_vector1( v1 ),m_vector2( v2 ) {
        }
        bool operator() (size_type x, size_type y) const {
                if( m_vector2( x ) > 0 )
                        return false;
                if( m_vector2( y ) > 0 )
                        return true;
                return m_less( m_vector1( x )/(m_vector1( x )-m_vector2( x )), m_vector1( y )/(m_vector1( y )-m_vector2( y )) );
        }
};

template<class V, class IS, class Cond > bool is_vector_elem( const V& vec, const IS& index_space ){
        typedef typename V::value_type value_type;
        typedef V vector_type;
        typedef IS index_space_type;
        typedef Cond condition_type;

        condition_type cond;
        for( typename index_space_type::const_iterator it = index_space.begin(); it != index_space.end(); ++it ) {
                assert( *it < vec.size() );
                if( ! cond( vec(*it), 0 ) ) return false;
        }
        return true;
}

template<class IS,class IT> void swap_indexes( IS& src, IS& dest, const IT& index ) {
        typedef IS index_space_type;
        typedef IT index_type;

        typename index_space_type::iterator it = std::find( src.begin(), src.end(), index );
        if( it != src.end() ){
                dest.push_back( index );
                std::swap( *it, src.back() );
                src.pop_back();
        }
}

class null_type {

public:

static null_type s_null;

public:

};

};

#endif // _UTILS_H

---