algebra/atra.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner                                     |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_ATRA_H
#define _MATHTL_ATRA_H

namespace MathTL
{
  template <class MATRIX>
  class AtrA
  {
  public:
    typedef typename MATRIX::size_type size_type;

    AtrA(const MATRIX& A) : A_(A) {}

    const size_type row_dimension() const { return A_.column_dimension(); }
    
    const size_type column_dimension() const { return A_.column_dimension(); }
    
    template <class VECTOR>
    void apply(const VECTOR& x, VECTOR& AtrAx) const;
    
    template <class VECTOR>
    void apply_transposed(const VECTOR& x, VECTOR& AtrAx) const { apply(x, AtrAx); }

  private:
    const MATRIX& A_;
  };

  template <class MATRIX> template <class VECTOR>
  void AtrA<MATRIX>::apply(const VECTOR& x, VECTOR& AtrAx) const
  {
    VECTOR y(A_.row_dimension(), false);
    A_.apply(x, y);
    A_.apply_transposed(y, AtrAx);
  }

  template <class MATRIX>
  class AAtr
  {
  public:
    typedef typename MATRIX::size_type size_type;

    AAtr(const MATRIX& A) : A_(A) {}

    const size_type row_dimension() const { return A_.row_dimension(); }
    
    const size_type column_dimension() const { return A_.row_dimension(); }
    
    template <class VECTOR>
    void apply(const VECTOR& x, VECTOR& AAtrx) const;
    
    template <class VECTOR>
    void apply_transposed(const VECTOR& x, VECTOR& AAtrx) const { apply(x, AAtrx); }

  private:
    const MATRIX& A_;
  };

  template <class MATRIX>
  std::ostream& operator << (std::ostream& os, const AAtr<MATRIX>& M);

  
  template <class MATRIX> template <class VECTOR>
  void AAtr<MATRIX>::apply(const VECTOR& x, VECTOR& AAtrx) const
  {
    VECTOR y(A_.column_dimension(), false);
    A_.apply_transposed(x, y);
    A_.apply(y, AAtrx);
  }
}

#endif