basics/outputMatlab.hh

Go to the documentation of this file.

/* matlab output function
 */

#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 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 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 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 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 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