print.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2007,2010 Oak Ridge National Laboratory

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  For more information please contact:

  Robert J. Harrison
  Oak Ridge National Laboratory
  One Bethel Valley Road
  P.O. Box 2008, MS-6367

  email: harrisonrj@ornl.gov
  tel:   865-241-3937
  fax:   865-572-0680


  $Id$
*/


#ifndef MADNESS_WORLD_PRINT_H__INCLUDED
#define MADNESS_WORLD_PRINT_H__INCLUDED



#include <iostream>
#include <complex>
#include <list>
#include <vector>
#include <madness/world/typestuff.h>
#include <madness/world/enable_if.h>

#ifdef BRAINDEAD
// Cray XT nonsense
#define ENDL "\n"

#else

#define ENDL std::endl

#endif


namespace madness {

    template <typename T>
    std::ostream& operator<<(std::ostream& s, const std::complex<T>& c) {
        s << c.real() << "+" << c.imag() << "j";
        return s;
    }

    template <typename T, typename U>
    std::ostream& operator<<(std::ostream& s, const std::pair<T,U>& p) {
        s << "(" << p.first << "," << p.second << ")";
        return s;
    }

    template <typename T>
    std::ostream& operator<<(std::ostream& s, const std::list<T>& c) {
        s << "[";
        typename std::list<T>::const_iterator it = c.begin();
        while (it != c.end()) {
            s << *it;
            ++it;
            if (it != c.end()) s << ", ";
        };
        s << "]";
        return s;
    }

    template <typename T>
    std::ostream& operator<<(std::ostream& s, const std::vector<T>& c) {
        s << "[";
        typename std::vector<T>::const_iterator it = c.begin();
        while (it != c.end()) {
            s << *it;
            ++it;
            if (it != c.end()) s << ", ";
        };
        s << "]";
        return s;
    }


    template <typename T, std::size_t N>
    typename disable_if<std::is_same<T,char>, std::ostream&>::type
    operator<<(std::ostream& s, const T(&v)[N]) {
        s << "[";
        for (std::size_t i=0; i<N; ++i) {
            s << v[i];
            if (i != (N-1)) s << ",";
        }
        s << "]";
        return s;
    }

    template <class A>
    void print(const A& a) {
        std::cout << a << ENDL;
    }

    template <class A, class B>
    void print(const A& a, const B& b) {
        std::cout << a << " " << b << ENDL;
    }

    template <class A, class B, class C>
    void print(const A& a, const B& b, const C& c) {
        std::cout << a << " " << b << " " << c << ENDL;
    }

    template <class A, class B, class C, class D>
    void print(const A& a, const B& b, const C& c, const D& d) {
        std::cout << a << " " << b << " " << c << " " << d << ENDL;
    }

    template <class A, class B, class C, class D, class E>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H, class I>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h, const I& i) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << " " << i << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h, const I& i, const J& j) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << " " << i << " " << j << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h, const I& i, const J& j, const K& k) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << " " << i << " " << j << " " << k << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h, const I& i, const J& j, const K& k, const L& l) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << " " << i << " " << j << " " << k << " " << l << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L, class M>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h, const I& i, const J& j, const K& k, const L& l, const M& m) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << " " << i << " " << j << " " << k << " " << l << " " << m << ENDL;
    }

    template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L, class M, class N>
    void print(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h, const I& i, const J& j, const K& k, const L& l, const M& m, const N& n) {
        std::cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << g << " " << h << " " << i << " " << j << " " << k << " " << l << " " << m << " " << n << ENDL;
    }

    void print_justified(const char* s, int column=0, bool underline=true);

    void print_centered(const char* s, int column=40, bool underline=true);

}
#endif // MADNESS_WORLD_PRINT_H__INCLUDED