outputMatlab.hh

Go to the documentation of this file.

 
#ifndef OutputMatlab_hh
#define OutputMatlab_hh
 
#include <iostream>
#include <complex>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include "outputOperator.hh"
#include "vectorsMatrices.hh"
#include <iomanip>
 
namespace concepts {
 
  // ********************************************************** outputMatlab **
 
  // general matlab output
  template<typename T>
  std::ostream& outputMatlab(std::ostream& os, const T& val) {
    return os << std::setw(13) << std::scientific << val;
  }
 
  // special matlab output for complex numbers
  template<typename T>
    std::ostream& outputMatlab(std::ostream& os, const std::complex<T>& val) {
      const T r = std::real(val), 
            i = std::imag(val);
      /*
      if (r != 0 || i == 0) 
        os << std::setw(12) << std::scientific << r;
      if (i != 0) {
        if (i > 0) {
          if (r != 0) 
            os << '+';
        } else 
          os << '-';
#if _GLIBCPP_USE_C99
        if (std::isnan(i)) 
          os << "NaN*i";
        else
#endif
        {
          if (std::abs(i) != 1) 
            os << std::setw(12) <<  std::scientific << std::abs(i);
          os << 'i';
        }
      }*/
      os << std::setw(13) << std::scientific << r;
      if (i > 0) {
        os << '+';
      } else 
        os << '-';
 
#if _GLIBCPP_USE_C99
        if (std::isnan(i)) 
          os << "NaN*i";
        else
#endif
        {
          if (std::abs(i) != 1) 
            os << std::setw(13) <<  std::scientific << std::abs(i);
          os << 'i';
        }
 
 
      return os;
    }
 
  // ********************************************************** OutputMatlab **
 
  template<typename F>
  class OutputMatlab : public virtual OutputOperator {
  public:
    OutputMatlab(const F& val) : val_(val) {}
  protected:
    std::ostream& info(std::ostream& os) const {
      return outputMatlab(os, val_);
    }
  private:
    const F& val_;
  };
 
  template<typename F, int dim>
  class OutputMatlab<Point<F,dim> > : public virtual OutputOperator {
  public:
    OutputMatlab(const Point<F,dim>& val) : val_(val) {}
  protected:
    std::ostream& info(std::ostream& os) const {
      os << '[' << OutputMatlab<F>(val_[0]) << ';' << OutputMatlab<F>(val_[1]);
      if (dim == 3) os << ';' << OutputMatlab<F>(val_[2]);
      return os << ']';
    }
  private:
    const Point<F,dim>& val_;
  };
 
  template<typename F, int dim>
  class OutputMatlab<Mapping<F,dim> > : public virtual OutputOperator {
  public:
    OutputMatlab(const Mapping<F,dim>& val) : val_(val) {}
  protected:
    std::ostream& info(std::ostream& os) const {
      os << '[';
      for(uint i = 0; i < dim; ++i)
        for(uint j = 0; j < dim; ++j)
          os << OutputMatlab<F>(val_(i,j)) << ';';
      return os << ']';
    }
  private:
    const Mapping<F,dim>& val_;
  };
  
  template<typename F>
  class OutputMatlab<F*> : public virtual OutputOperator {
      public:
        OutputMatlab(const F* val) : val_(val) {}
      protected:
        std::ostream& info(std::ostream& os) const {
          if (val_) return os << OutputMatlab<F>(*val_);
          return os << 0;
        }
      private:
        const F* val_;
    };
 
  template<>
    class OutputMatlab<std::string> : public virtual OutputOperator {
      public:
        OutputMatlab(const std::string val) : val_(val) {}
      protected:
        std::ostream& info(std::ostream& os) const {
          return os << "'" << val_ << "'";
        }
      private:
        const std::string val_;
    };
 
  template<>
    class OutputMatlab<char*> : public OutputMatlab<std::string> {
      public:
        OutputMatlab(const char* val) : OutputMatlab<std::string>(val) {}
    };
 
  template<>
    class OutputMatlab<bool> :  public OutputOperator {
      public:
        OutputMatlab(const bool val) : val_(val) {}
      protected:
        std::ostream& info(std::ostream& os) const {
          bool nobool = !(os.flags() & std::ios_base::boolalpha);
          os << std::boolalpha << val_;
          if (nobool) os << std::noboolalpha;
          return os;
        }
      private:
        const bool val_;
    };
 
  template<class F>
    class OutputMatlab<std::set<F> > :  public OutputOperator {
      public:
        OutputMatlab(const std::set<F>& val) : val_(val) {}
      protected:
        std::ostream& info(std::ostream& os) const {
          os << '[';
          typename std::set<F>::const_iterator i = val_.begin();
          for(; i != val_.end(); ) {
            os << OutputMatlab<F>(*i);
            if (++i != val_.end()) os << ", ";
          }
          return os << ']';
        }
      private:
        const std::set<F> val_;
    };
 
  template<class F, class G>
  class OutputMatlab<std::map<F,G> > :  public OutputOperator {
  public:
    OutputMatlab(const std::map<F,G>& val) : val_(val) {}
  protected:
    std::ostream& info(std::ostream& os) const {
      os << '[';
      typename std::map<F,G>::const_iterator i = val_.begin();
      for(; i != val_.end(); ++i)
        os << "(" 
           << OutputMatlab<F>(i->first ) << ", "
           << OutputMatlab<G>(i->second) << ") ";
      return os << ']';
    }
  private:
    const std::map<F,G> val_;
  };
 
  template<class F>
    class OutputMatlab<std::vector<F> > :  public OutputOperator {
      public:
        OutputMatlab(const std::vector<F>& val) : val_(val) {}
      protected:
        std::ostream& info(std::ostream& os) const {
          os << '[';
          typename std::vector<F>::const_iterator i = val_.begin();
          for(; i != val_.end();) {
            os << OutputMatlab<F>(*i);
            if (++i != val_.end()) os << ", ";
          }
          return os << ']';
        }
      private:
        const std::vector<F> val_;
    };
 
  template<class F>
    class OutputMatlab<std::queue<F> > :  public OutputOperator {
      public:
        OutputMatlab(const std::queue<F>& val) : val_(val) {}
      protected:
        std::ostream& info(std::ostream& os) const {
          std::queue<F> val = val_;
          os << '[';
          const uint size = val.size();
          for(uint i = 0; i < size; ++i) {
            os << OutputMatlab<F>(val.front());
            if (i < size - 1) os << ", ";
            val.pop();               // erase first element
          }
          return os << ']';
        }
      private:
        const std::queue<F> val_;
    };
 
} // namespace concepts
 
#endif // OutputMatlab_hh