latextablewriter.hh

#ifndef DUNE_FEM_LATEXTABLEWRITER_HH
#define DUNE_FEM_LATEXTABLEWRITER_HH
 
#include <cmath>
#include <fstream>
#include <iomanip>
#include <limits>
#include <sstream>
#include <tuple>
#include <vector>
 
#include <dune/common/exceptions.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // NoDataException
    // ---------------
 
    struct NoDataException {};
 
 
 
    // AbstractColumnWriter
    // --------------------
 
    template< class DataTuple >
    struct AbstractColumnWriter
    {
      enum Alignment { AlignLeft, AlignCenter, AlignRight };
 
      virtual ~AbstractColumnWriter () {}
 
      virtual Alignment alignment () const { return AlignCenter; }
      virtual std::string entry ( const DataTuple & ) const = 0;
      virtual std::string header () const = 0;
    };
 
 
 
    // TupleDataSource
    // ---------------
 
    template< int N >
    struct TupleDataSource
    {
      template< class DataTuple >
      struct Value { typedef typename std::tuple_element< N, DataTuple >::type Type; };
 
      template< class DataTuple >
      typename Value< DataTuple >::Type get ( const DataTuple &data ) const
      throw ()
      {
        return std::get< N >( data );
      }
    };
 
 
 
    // ArrayDataSource
    // ---------------
 
    template< class DataSource >
    struct ArrayDataSource
    {
      template< class DataTuple >
      struct Value
      {
        typedef typename DataSource::template Value< DataTuple >::Type::value_type Type;
      };
 
      ArrayDataSource ( const int index, const DataSource &source = DataSource() )
      : index_( index ), source_( source )
      {}
 
      template< class DataTuple >
      typename Value< DataTuple >::Type get ( const DataTuple &data ) const
      throw ()
      {
        return source_.get( data )[ index_ ];
      }
 
    private:
      int index_;
      DataSource source_;
    };
 
 
 
    // EOCDataSource
    // -------------
 
    template< class WidthDataSource, class ErrorDataSource >
    struct EOCDataSource
    {
      template< class DataTuple >
      struct Value
      {
        typedef double Type;
      };
 
      explicit EOCDataSource ( const WidthDataSource &widthSource = WidthDataSource(),
                               const ErrorDataSource &errorSource = ErrorDataSource() )
      : widthSource_( widthSource ),
        errorSource_( errorSource ),
        hOld_( std::numeric_limits< double >::infinity() )
      {}
 
      explicit EOCDataSource ( const ErrorDataSource &errorSource )
      : errorSource_( errorSource ),
        hOld_( std::numeric_limits< double >::infinity() )
      {}
 
      template< class DataTuple >
      typename Value< DataTuple >::Type get ( const DataTuple &data ) const
      {
        double h = widthSource_.get( data );
        double e = errorSource_.get( data );
        std::swap( h, hOld_ );
        std::swap( e, eOld_ );
        if( h < std::numeric_limits< double >::infinity() )
          return std::log( eOld_ / e ) / std::log( hOld_ / h );
        else
          throw NoDataException();
      }
 
    private:
      WidthDataSource widthSource_;
      ErrorDataSource errorSource_;
      mutable double hOld_;
      mutable double eOld_;
    };
 
 
 
    // NumberColumnWriter
    // ------------------
 
    template< class DataTuple, class DataSource >
    class NumberColumnWriter
    : public AbstractColumnWriter< DataTuple >
    {
      typedef AbstractColumnWriter< DataTuple > BaseType;
 
    public:
      explicit NumberColumnWriter ( const std::string &header, const int decimals = 6,
                                    const DataSource &source = DataSource() )
      : header_( header ),
        decimals_( decimals ),
        source_( source )
      {}
 
      NumberColumnWriter ( const std::string &header, const DataSource &source )
      : header_( header ),
        decimals_( 6 ),
        source_( source )
      {}
 
      typename BaseType::Alignment alignment () const
      {
        return BaseType::AlignRight;
      }
 
      std::string entry ( const DataTuple &data ) const
      {
        return toString( source_.get( data ) );
      }
 
      std::string header () const { return header_; }
 
    protected:
      template< class Number >
      std::string toString ( const Number &number ) const
      {
        std::ostringstream s;
        s << std::fixed << std::setprecision( decimals_ );
        s << "$" << number << "$";
        return s.str();
      }
 
    private:
      std::string header_;
      int decimals_;
      DataSource source_;
    };
 
 
 
    // LatexTableWriter
    // ----------------
 
    template< class DataTuple >
    struct LatexTableWriter
    {
      typedef AbstractColumnWriter< DataTuple > ColumnWriterType;
      typedef std::vector< const ColumnWriterType * > ColumnWriterVectorType;
 
      LatexTableWriter ( const std::string &filename, const ColumnWriterVectorType &columnWriter );
      ~LatexTableWriter ();
 
      void writeRow ( const DataTuple &data );
      void writeSeparator ();
 
    private:
      typedef typename ColumnWriterVectorType::const_iterator ColumnWriterIteratorType;
 
      void cleanUp ();
 
      std::string preamble () const;
      std::string header () const;
 
      ColumnWriterVectorType columnWriters_;
      std::ofstream out_;
    };
 
 
 
    // Implementation of LatexTableWriter
    // ----------------------------------
 
    template< class DataTuple >
    inline LatexTableWriter< DataTuple >
      ::LatexTableWriter ( const std::string &filename, const ColumnWriterVectorType &columnWriters )
    : columnWriters_( columnWriters ),
      out_( filename.c_str() )
    {
      if( !out_ )
      {
        cleanUp();
        DUNE_THROW( IOError, "Unable to open '" << filename << "'." );
      }
      out_ << "\\begin{tabular}{" << preamble() << "}" << std::endl;
      writeSeparator();
      out_ << header() << " \\\\"<< std::endl;
      writeSeparator();
    }
 
 
    template< class DataTuple >
    inline LatexTableWriter< DataTuple >::~LatexTableWriter ()
    {
      writeSeparator();
      out_ << "\\end{tabular}" << std::endl;
      cleanUp();
    }
 
 
    template< class DataTuple >
    inline void LatexTableWriter< DataTuple >::writeRow ( const DataTuple &data )
    {
      std::string separator = "";
      const ColumnWriterIteratorType end = columnWriters_.end();
      for( ColumnWriterIteratorType it = columnWriters_.begin(); it != end; ++it )
      {
        out_ << separator;
        separator = " & ";
        if( *it )
        {
          try
          {
            out_ << (*it)->entry( data );
          }
          catch( const NoDataException & )
          {
            out_ << "\\multicolumn{1}{|c|}{---}";
          }
        }
      }
      out_ << " \\\\" << std::endl;
    }
 
 
    template< class DataTuple >
    inline void LatexTableWriter< DataTuple >::writeSeparator ()
    {
      int b = 0, e = 0;
 
      const ColumnWriterIteratorType end = columnWriters_.end();
      for( ColumnWriterIteratorType it = columnWriters_.begin(); it != end; ++it, ++e )
      {
        if( !(*it) )
        {
          if( b < e )
            out_ << "\\cline{" << (b+1) << "-" << e << "}";
          b = e+1;
        }
      }
      if( b < e )
        out_ << "\\cline{" << (b+1) << "-" << e << "}";
      out_ << std::endl;
    }
 
 
    template< class DataTuple >
    inline void LatexTableWriter< DataTuple >::cleanUp ()
    {
      const ColumnWriterIteratorType end = columnWriters_.end();
      for( ColumnWriterIteratorType it = columnWriters_.begin(); it != end; ++it )
      {
        if( *it )
          delete( *it );
      }
    }
 
 
    template< class DataTuple >
    inline std::string LatexTableWriter< DataTuple >::header () const
    {
      std::string header, separator;
      const ColumnWriterIteratorType end = columnWriters_.end();
      for( ColumnWriterIteratorType it = columnWriters_.begin(); it != end; ++it )
      {
        header += separator;
        separator = " & ";
        if( *it )
          header += "\\multicolumn{1}{|c|}{" + (*it)->header() + "}";
      }
      return header;
    }
 
 
    template< class DataTuple >
    inline std::string LatexTableWriter< DataTuple >::preamble () const
    {
      const char alignment[] = { 'l', 'c', 'r' };
 
      std::string preamble( "|" );
      const ColumnWriterIteratorType end = columnWriters_.end();
      for( ColumnWriterIteratorType it = columnWriters_.begin(); it != end; ++it )
      {
        if( *it )
          preamble += alignment[ (*it)->alignment() ];
        else
          preamble += "@{}p{0.2em}@{}";
        preamble += "|";
      }
      return preamble;
    }
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_LATEXTABLEWRITER_HH