eigen/formatters.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_LINEAR_ALGEBRA_FORMATTERS_HPP_
#define ECL_LINEAR_ALGEBRA_FORMATTERS_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/formatters.hpp>
#include <ecl/mpl/enable_if.hpp>
#include <ecl/type_traits/fundamental_types.hpp>

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace Eigen {

/*****************************************************************************
** Interface [MatrixFormatter]
*****************************************************************************/

template <typename Derived, typename Scalar, typename Enable = void>
class MatrixFormatter {
private:
        MatrixFormatter() {}
};

/*****************************************************************************
** Interface [FloatMatrixFormatter]
*****************************************************************************/

template<typename Derived>
class FloatMatrixFormatter {
public:
        /******************************************
        ** C&D's
        *******************************************/
        FloatMatrixFormatter(const int &w = -1, const unsigned int &p = 2) :
                tmp_formatting(false),
                ready_to_format(false),
                _matrix(NULL)
        {
                format.width(w);
                format.precision(p);
        }
        virtual ~FloatMatrixFormatter() {}

        /******************************************
        ** Configuration
        *******************************************/
        FloatMatrixFormatter<Derived>& precision( const unsigned int &p ) {
                format.precision(p);
                return *this;
        }

        FloatMatrixFormatter<Derived>& width( const int &w ) {
                format.width(w);
                return *this;
        }

        unsigned int precision() { return format.precision(); }

        int width() { return format.width(); }

        /******************************************
        ** Format a value
        *******************************************/
        FloatMatrixFormatter< Derived >& operator() (const Derived & matrix ) {
                _matrix = &matrix;
                ready_to_format = true;
                return (*this);
        }
        FloatMatrixFormatter< Derived >& operator() (const Derived & matrix, const int &w, const unsigned int &p) {
                _matrix = &matrix;
                tmp_precision = p;
                tmp_width = w;
                tmp_formatting = true;
                ready_to_format = true;
                return (*this);
        }

        template <typename OutputStream, typename Derived_ >
        friend OutputStream& operator << ( OutputStream& ostream, FloatMatrixFormatter<Derived_> & formatter );

    private:
                ecl::Format<typename Derived::Scalar> format;
                int tmp_width;
                unsigned int tmp_precision;
                bool tmp_formatting;
                bool ready_to_format;
                const Derived *_matrix;
};

template <typename OutputStream, typename Derived_ >
OutputStream& operator << (OutputStream& ostream, FloatMatrixFormatter< Derived_ > & formatter )
{
    ecl_assert_throw( formatter._matrix, ecl::StandardException(LOC,ecl::UsageError,"The formatter cannot print any data - "
            "_matrix was not initialised "
            "please pass the your matrix through () operator") );
    ecl_assert_throw(formatter.ready_to_format, ecl::StandardException(LOC,ecl::UsageError,"The formatter cannot print any data - "
            "either there is no data available, or you have tried to use the "
            "formatter more than once in a single streaming operation. "
            "C++ produces unspecified results when functors are used multiply "
            "in the same stream sequence, so this is not permitted here.") );


    if ( formatter.ready_to_format ) {
        unsigned int prm_precision = formatter.format.precision();;
        int prm_width = formatter.format.width();
                if ( formatter.tmp_formatting ) {
                        formatter.format.precision(formatter.tmp_precision);
                        formatter.format.width(formatter.tmp_width);
                }

                /*********************
                ** Stream Matrix
                **********************/
                // write matrix data
                // @note norma matrix allows matrix(i,j) however sparse matrix does not.
                // So i put coeff(i,j) function which can be used for accessing each element for both of sparse and dense.
                int rows = formatter._matrix->rows();
                int cols = formatter._matrix->cols();
                for( int i=0; i<rows; i++ )
                {
                        for( int j=0; j<cols; j++ )
                        {
                                ostream <<  formatter.format(formatter._matrix->coeff( i, j )) << "  ";
                        }
                        if ( rows != 1 ) {  // special condition for row vectors so we can do inline the formatting.
                          ostream << "\n";
                        }
                }

                if ( formatter.tmp_formatting ) {
                        formatter.format.precision(prm_precision);
                        formatter.format.width(prm_width);
                        formatter.tmp_formatting = false;
                }
        formatter.ready_to_format = false;
    }
    return ostream;
}

/*****************************************************************************
** Interface [MatrixFormatter][Float Types]
*****************************************************************************/

template <typename Derived, typename Scalar>
class MatrixFormatter<Derived, Scalar, typename ecl::enable_if< ecl::is_float<Scalar> >::type> : public FloatMatrixFormatter<Derived> {
public:
        MatrixFormatter(const int &w = -1, const unsigned int &p = 2) : FloatMatrixFormatter<Derived>(w, p) {};
};

} // namespace Eigen

#endif /* ECL_LINEAR_ALGEBRA_FORMATTERS_HPP_ */