outputMatlab.hh

Go to the documentation of this file.

 
#ifndef ToolboxOutputMatlab_h
#define ToolboxOutputMatlab_h
 
#include <iomanip>
#include "basics/outputMatlab.hh"
#include "array.hh"
#include "stiffArray.hh"
#include "sequence.hh"
 
#define OutputMatlabArray_D      0
#define OutputMatlabStiffArray_D 0
#define OutputMatlabSequence_D   0
 
namespace concepts {
 
  // ************************************************ OutputMatlab<Array<F> > **
 
  template<typename F>
  class OutputMatlab<Array<F> > : public virtual OutputOperator {
  public:
    OutputMatlab(const Array<F>& val, const bool transposed = false) 
      : val_(val), transposed_(transposed) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const Array<F>& val_;
    const bool transposed_;
  };
 
  template<typename F>
  std::ostream& OutputMatlab<Array<F> >::info(std::ostream& os) const {
    std::stringstream s;
    s.setf(os.flags());
    s.precision(os.precision());
    s << "[";
    const F* d = (const F*)val_;
    DEBUGL(OutputMatlabArray_D, 
           "transposed = " << std::boolalpha << transposed_);
    DEBUGL(OutputMatlabArray_D, val_);
    for (uint i = val_.size(); i--;)
      s << OutputMatlab<F>(*d++) 
        << ((i == 0) ? "" : (transposed_ ? " " : "; "));
    s << ']';
    DEBUGL(OutputMatlabArray_D, "s = " << s.str());
    return os << s.str();
  }
 
  // *************************************** OutputMatlab<StiffArray<dim,F> > **
 
  template<uint dim, typename F>
  class OutputMatlab<StiffArray<dim,F> > : public virtual OutputOperator {
  public:
    OutputMatlab(const StiffArray<dim,F>& val, const bool transposed = false) 
      : val_(val), transposed_(transposed) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const StiffArray<dim,F>& val_;
    const bool transposed_;
  };
 
  template<uint dim, typename F>
  std::ostream& OutputMatlab<StiffArray<dim,F> >::info(std::ostream& os) const
  {
    std::stringstream s;
    s.setf(os.flags());
    s.precision(os.precision());
    s << "[";
    const F* d = (const F*)val_;
    DEBUGL(OutputMatlabStiffArray_D, 
           "transposed = " << std::boolalpha << transposed_);
    DEBUGL(OutputMatlabStiffArray_D, val_);
    for (uint i = dim; i--;)
      s << OutputMatlab<F>(*d++) 
        << ((i == 0) ? "" : (transposed_ ? " " : "; "));
    s << ']';
    DEBUGL(OutputMatlabStiffArray_D, "s = " << s.str());
    return os << s.str();
  }
 
  // ******************************************** OutputMatlab<Sequence<F> > **
 
  template<typename F>
  class OutputMatlab<Sequence<F> > : public virtual OutputOperator {
  public:
    OutputMatlab(const Sequence<F>& seq, const bool transposed = false) 
      : seq_(seq), transposed_(transposed) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const Sequence<F>& seq_;
    const bool transposed_;
  };
 
  template<typename F>
  std::ostream& OutputMatlab<Sequence<F> >::info(std::ostream& os) const {
    std::stringstream s;
    s.setf(os.flags());
    s.precision(os.precision());
    s << concepts::typeOf(*this) << "[";
    DEBUGL(OutputMatlabSequence_D, 
           "transposed = " << std::boolalpha << transposed_);
    DEBUGL(OutputMatlabSequence_D, seq_);
    for (uint i = 0; i < seq_.size(); ++i)
      s << OutputMatlab<F>(seq_[i]) 
        << ((i == seq_.size()-1) ? "" : (transposed_ ? " " : "; "));
    s << ']';
    DEBUGL(OutputMatlabSequence_D, "s = " << s.str());
    return os << s.str();
  }
 
} // namespace concepts
 
#endif // ToolboxOutputMatlab_h