namespace ietl {
  class indexer;
  template<typename MATRIX, typename VS> class bandlanczos;
}

namespace ietl {
  template<typename SCALAR, unsigned int BICGSTAB_L> class bicgstab_wrapper;
  template<typename SCALAR, unsigned int BICGSTAB_L, typename VECTOR, 
           typename MATRIX> 
    VECTOR ietl_bicgstabl(const MATRIX & A, const VECTOR & b, 
                          const VECTOR & x0, size_t maxiter = 100, 
                          typename number_traits< SCALAR >::magnitude_type abs_tol = 1e-6, 
                          bool verbose = false);
}

namespace ietl {
  template<typename Vector, typename Matrix> 
    Vector ietl_cg(Matrix const & A, Vector const & b, Vector const & x0, 
                   std::size_t max_iter = 100, double abs_tol = 1e-6, 
                   bool verbose = false);
}

namespace ietl {
  template<typename T> struct real_type;

  template<typename T> struct real_type<std::complex< T >>;
  template<typename T> T real(T x);
  template<typename T> T real(std::complex< T > x);
  template<typename T> T conj(T x);
  template<typename T> T conj(std::complex< T > x);
}

namespace ietl {
  template<typename T> class FortranMatrix;
}

namespace ietl {
  template<typename Vector, typename Matrix> 
    Vector ietl_gmres(Matrix const & A, Vector const & b, Vector const & x0, 
                      std::size_t max_iter = 100, double abs_tol = 1e-6, 
                      bool verbose = false);
}

namespace ietl {
  template<typename T> T * get_data(const std::vector< T > & v);
}namespace ietl_lapack_dispatch {
  void stev(const char & jobz, fortran_int_t n, double dd, double de, 
            double dz, fortran_int_t ldz, fortran_int_t info);
  void stev(const char & jobz, fortran_int_t n, double dd, double de, 
            std::complex< double > dz, fortran_int_t ldz, fortran_int_t info);
}namespace ietl2lapack {
  template<typename Vector> 
    fortran_int_t 
    stev(const Vector & alpha, const Vector & beta, Vector & eval, 
         fortran_int_t n);
  template<typename Vector, typename FortranMatrix> 
    int stev(const Vector & alpha, const Vector & beta, Vector & eval, 
             FortranMatrix & z, fortran_int_t n);
}

namespace ietl {
  template<typename Cont, typename Gen> void generate(Cont & c, Gen & gen);
}

namespace ietl {
  template<typename Cont> void clear(Cont & c);
  template<typename T, int D> 
    number_traits< T >::magnitude_type 
    two_norm(const blitz::Array< T, D > & v);
  template<typename T, int D> 
    T dot(const blitz::Array< T, D > & x, const blitz::Array< T, D > & y);
  template<typename T, int D> 
    T dot(const blitz::Array< std::complex< T >, D > & x, 
          const blitz::Array< std::complex< T >, D > & y);
  template<typename T, int D> 
    void copy(const blitz::Array< T, D > & x, blitz::Array< T, D > & y);
}namespace std {
  template<typename T, int D> 
    void swap(blitz::Array< T, D > & x, blitz::Array< T, D > & y);
}

namespace ietl {
  template<typename T, typename Gen> 
    void generate(boost::numeric::ublas::vector< T > & c, Gen & gen);
  template<typename T, typename S> 
    void clear(boost::numeric::ublas::vector< T, S > & c);
  template<typename V> 
    V::value_type 
    dot(boost::numeric::ublas::vector_expression< V > const & x, 
        boost::numeric::ublas::vector_expression< V > const & y);
  template<typename V> 
    number_traits< typename V::value_type >::magnitude_type 
    two_norm(boost::numeric::ublas::vector_expression< V > const & x);
  template<typename T> 
    void copy(boost::numeric::ublas::vector< T > const & x, 
              boost::numeric::ublas::vector< T > & y);
  template<typename M, typename V> 
    void mult(boost::numeric::ublas::matrix_expression< M > const & m, 
              boost::numeric::ublas::vector_expression< V > const & x, V & y);
}

namespace ietl {
  template<typename T> struct add_abs2;

  template<typename T> struct add_abs2<std::complex< T >>;

  template<typename T> struct conj_mult;

  template<typename T> struct conj_mult<std::complex< T >>;
  template<typename T> T * get_data(std::valarray< T > & c);
  template<typename T> const T * get_data(const std::valarray< T > & c);
  template<typename T> void clear(std::valarray< T > & c);
  template<typename T, typename Gen> 
    void generate(std::valarray< T > & c, Gen & gen);
  template<typename T> 
    real_type< T >::type two_norm(const std::valarray< T > & c);
  template<typename T> 
    T dot(const std::valarray< T > & x, const std::valarray< T > & y);
}

namespace ietl {
  template<typename MATRIX, typename GEN, typename SOLVER, typename ITER, 
           typename VS> 
    std::pair< typename vectorspace_traits< VS >::magnitude_type, typename vectorspace_traits< VS >::vector_type > 
    inverse(const MATRIX & matrix, GEN & gen, const SOLVER & solver, 
            ITER & iter, 
            typename vectorspace_traits< VS >::magnitude_type sigma, 
            const VS & vec);
}

namespace ietl {
  template<typename T> class basic_iteration;
  template<typename T, typename Derived> class basic_lanczos_iteration;
  template<typename T> class lanczos_iteration_nlowest;
  template<typename T> class lanczos_nlowest_better;
  template<typename T> class lanczos_iteration_nhighest;
  template<typename T> class fixed_lanczos_iteration;
  template<typename T> class bandlanczos_iteration_nlowest;
  template<typename T> class bandlanczos_iteration_nhighest;
}

namespace ietl {
  template<typename MATRIX, typename VS> class jcd_left_preconditioner;
  template<typename MATRIX, typename VS> class jcd_simple_solver;
  template<typename Matrix, typename VS, typename Vector> 
    class jcd_gmres_solver_operator;
  template<typename Matrix, typename VS> class jcd_gmres_solver;
  template<typename MATRIX, typename VS> class jacobi_davidson;

  enum DesiredEigenvalue { Largest, Smallest };
  template<typename Matrix, typename VS, typename Vector> 
    void mult(jcd_gmres_solver_operator<Matrix, VS, Vector > const & m, 
              typename jcd_gmres_solver_operator<Matrix, VS, Vector >::vector_type const & x, 
              typename jcd_gmres_solver_operator<Matrix, VS, Vector >::vector_type & y);
}

MAKE_WRAPPER(name, solver)

namespace ietl {
  template<typename T> class jd_iteration;
  template<typename MATRIX, typename VS> class jd;
  namespace solver {
    template<typename SOLV, typename MATRIX, typename VS, typename PREC> 
      class left_prec_solver;
    template<typename SOLV, typename MATRIX, typename VS> class jd_solver;
    template<typename SOLV, typename MATRIX, typename VS, typename PREC, 
             typename VECTOR> 
      void mult(const left_prec_solver< SOLV, MATRIX, VS, PREC > &, 
                const VECTOR &, VECTOR &);
  }
}

namespace ietl {
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Preconditioner, typename Iteration> 
    class cg_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Preconditioner, typename Iteration> 
    class cgs_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Preconditioner, typename Iteration> 
    class bicg_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Precond1, typename Precond2, typename Iteration> 
    class qmr_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Precond1, typename Precond2, typename Iteration> 
    class tfqmr_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Preconditioner, typename Iteration> 
    class gcr_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Preconditioner, typename Iteration> 
    class cheby_wrapper;
  template<typename Matrix, typename VectorX, typename VectorB, 
           typename Preconditioner, typename Iteration> 
    class richardson_wrapper;
}

namespace ietl {
  template<typename magnitude_type = double> class Info;
  template<typename MATRIX, typename VS> class lanczos;
}

namespace ietl {
  template<typename MATRIX, typename GEN, typename IT, typename VS> 
    std::pair< typename vectorspace_traits< VS >::scalar_type, typename vectorspace_traits< VS >::vector_type > 
    power(const MATRIX & m, GEN & start, IT & iter, const VS & vec);
}

namespace ietl {
  template<typename MATRIX, typename GEN, typename SOLVER, typename ITER, 
           typename VS> 
    std::pair< typename ietl::number_traits< typename vectorspace_traits< VS >::scalar_type >::magnitude_type, typename vectorspace_traits< VS >::vector_type > 
    rayleigh(const MATRIX & matrix, GEN & gen, SOLVER & solver, ITER & iter, 
             const VS & vec);
}

namespace ietl {
  template<typename T> class arnoldi_iteration;
  template<typename Matrix, typename VS, typename Gen> class simple_arnoldi;
}

namespace ietl {
  template<typename VS> class Tmatrix;
}

namespace ietl {
  template<typename T> struct number_traits;

  template<typename T> struct number_traits<std::complex< T >>;

  template<typename VS> struct vectorspace_traits;
}

namespace ietl {
  template<typename V> class vectorspace;
  template<typename V> class vector_wrapper;
  template<typename V> class wrapper_vectorspace;
  template<typename V, typename S> class scaled_vector_wrapper;
  template<typename VS> 
    void project(typename ietl::vectorspace_traits< VS >::vector_type & v, 
                 const VS & vs);
  template<typename VS> 
    ietl::vectorspace_traits< VS >::vector_type new_vector(const VS & vs);
  template<typename VS> 
    ietl::vectorspace_traits< VS >::size_type vec_dimension(const VS & vs);
  template<typename V> 
    void copy(const ietl::vector_wrapper< V > & src, 
              ietl::vector_wrapper< V > & dst);
  template<typename V> 
    number_traits< typename V::value_type >::magnitude_type 
    two_norm(const ietl::vector_wrapper< V > & src);
  template<typename V> 
    V::value_type 
    dot(const ietl::vector_wrapper< V > & src1, 
        const ietl::vector_wrapper< V > & src2);
  template<typename A, typename V> 
    void mult(A a, const ietl::vector_wrapper< V > & src, 
              ietl::vector_wrapper< V > & dst);
  template<typename V, typename GEN> 
    void generate(ietl::vector_wrapper< V > & src, GEN & gen);
  template<typename V, typename S> 
    ietl::scaled_vector_wrapper< V, S > 
    operator*(const ietl::vector_wrapper< V > & v, S s);
  template<typename V, typename S> 
    ietl::scaled_vector_wrapper< V, S > 
    operator*(S s, const ietl::vector_wrapper< V > & v);
  template<typename V, typename S> 
    ietl::scaled_vector_wrapper< V, S > 
    operator/(const ietl::vector_wrapper< V > & v, S s);
}