smatrix.hh

Go to the documentation of this file.

 
#ifndef smatrix_hh
#define smatrix_hh
 
#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "toolbox/array.hh"
 
namespace concepts {
 
  // forward declaration
  template<class F>
  class TColumn;
 
  template<class F>
  class ShapeFunction1D;
 
  // *********************************************************** SMatrixBase **
 
  template<class F>
  class SMatrixBase : public virtual OutputOperator {
  public:
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const = 0;
 
    virtual uint size() const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ************************************************************* SMatrix1D **
 
  class SMatrix1D : public SMatrixBase<Real> {
  public:
    SMatrix1D(const ShapeFunction1D<Real>& small,
        const ShapeFunction1D<Real>& left,
        const ShapeFunction1D<Real>& right);
 
    SMatrix1D(const SMatrix1D& s, const bool flip = false);
    virtual void operator()(const TColumn<Real>& src,
          TColumn<Real>& dest) const;
    void scale(const Real factor);
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const uint n_;
 
    Array<Real> data_;
 
    Real* left_;
 
    Real* right_;
  };
 
  // ********************************************************* SMatrixTensor **
 
  template<class F, int dim>
  class SMatrixTensor : public SMatrixBase<F> {
  public:
    SMatrixTensor(const SMatrixBase<F>& matrix, const uint position);
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<Real>& matrix_;
    const uint position_;
  };
 
  // ******************************************************** SMatrixCompose **
 
  template<class F>
  class SMatrixCompose : public SMatrixBase<F> {
  public:
    inline SMatrixCompose(const SMatrixBase<F>& A, const SMatrixBase<F>& B,
        const SMatrixBase<F>* C = 0) : A_(A), B_(B), C_(C) {}
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<F>& A_;
    const SMatrixBase<F>& B_;
    const SMatrixBase<F>* C_;
  };
 
 
  // ************************************************** SMatrixGeneralTensor **
 
  template<class F, int dim>
  class SMatrixGeneralTensor : public SMatrixBase<F> {
  public:
    SMatrixGeneralTensor(const SMatrixBase<F>& matrix, const uint* n,
       const uint position);
    SMatrixGeneralTensor(const SMatrixBase<F>& matrix, const uint position);
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<Real>& matrix_;
    uint n_[dim];
    const uint position_;
  };
 
 
  // ********************************************************** SMatrixBlock **
 
  template<class F, int dim>
  class SMatrixBlock : public SMatrixBase<F> {
  public:
    SMatrixBlock(const SMatrixBase<F>& A, const SMatrixBase<F>& B,
     const SMatrixBase<F>* C = 0);
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    inline uint size() const { return size_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<F>& A_;
    const SMatrixBase<F>& B_;
    const SMatrixBase<F>* C_;
    uint* n_;
    uint size_;
  };
 
} // namespace concepts
 
#endif // smatrix_hh