STK_TExpAlgebra.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  Serge Iovleff

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser 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

    Contact : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  Algebra
 * Purpose:  Allow to inline Algebraic expressions using template.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_TEXPALGEBRA_H
#define STK_TEXPALGEBRA_H

#include "../../Arrays/include/STK_MatrixSquare.h"
#include "../../Arrays/include/STK_MatrixLowerTriangular.h"
#include "../../Arrays/include/STK_MatrixUpperTriangular.h"

#include "STK_TOperator.h"


namespace STK
{
template<class Op, class ExpLeft, class ExpRight>
class BinOpBase
{
  protected:
    const ExpLeft&  lhs_;        
    const ExpRight& rhs_;        

    BinOpBase(const ExpLeft& X, const ExpRight& Y) : lhs_(X), rhs_(Y)
    { ;}
  
    ~BinOpBase() { ;}

  public:
    inline Real operator[](Integer i) const
    { return Op::apply(lhs_[i], rhs_[i]);}

    inline Real operator()(Integer i, Integer j) const
    { return Op::apply(lhs_(i,j), rhs_(i,j));}
};

template<class Op, class ExpRight>
class BinOpBase<Op, Real, ExpRight>
{
  protected:
    Real const&     lhs_;      
    const ExpRight& rhs_;      

    BinOpBase(Real const& y, const ExpRight& X) : lhs_(y), rhs_(X)
    { ;}
  
    ~BinOpBase(){ ;}

  public:
    inline Real operator[](Integer i) const
    { return Op::apply(lhs_,rhs_[i]);}

    inline Real operator()(Integer i, Integer j) const
    { return Op::apply(lhs_,rhs_(i,j));}
};

template<class Op, class ExpLeft>
class BinOpBase<Op, ExpLeft, Real>
{
  protected:
    const ExpLeft& lhs_;      
    Real const&    rhs_;      

    BinOpBase(const ExpLeft& X, Real const& y) : lhs_(X), rhs_(y)
    { ;}

    ~BinOpBase(){ ;}

 public:
    inline Real operator[](Integer i) const
    { return Op::apply(lhs_[i],rhs_);}

    inline Real operator()(Integer i, Integer j) const
    { return Op::apply(lhs_(i,j),rhs_);}
};


template<class ExpRight>
class BinOpBase<Mult, Matrix, ExpRight>
{
  protected:
    Matrix const&   lhs_;      
    const ExpRight& rhs_;      

    BinOpBase(const Matrix& y, const ExpRight& X) : lhs_(y), rhs_(X)
    { ;}
  
    ~BinOpBase(){ ;}

  public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = lhs_.firstCol(); j <=lhs_.lastCol(); j++)
        aux += Mult::apply(lhs_(i,j),rhs_[j]);
      return aux;
    }
};

template<class ExpLeft>
class BinOpBase<Mult, ExpLeft, Matrix>
{
  protected:
    const ExpLeft& lhs_;      
    Matrix const&  rhs_;      

    BinOpBase(const ExpLeft& X, Matrix const& y) : lhs_(X), rhs_(y)
    { ;}

    ~BinOpBase(){ ;}

 public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = rhs_.firstRow(); j<= rhs_.lastRow(); j++)
        aux += Mult::apply(lhs_[j],rhs_(j,i));
      return aux;
    }
};

template<class ExpRight>
class BinOpBase<Mult, MatrixSquare, ExpRight>
{
  protected:
    MatrixSquare const&   lhs_;      
    const ExpRight& rhs_;      

    BinOpBase(MatrixSquare const& y, const ExpRight& X) : lhs_(y), rhs_(X)
    { ;}
  
    ~BinOpBase(){ ;}

  public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = lhs_.firstCol(); j <=lhs_.lastCol(); j++)
        aux += Mult::apply(lhs_(i,j),rhs_[j]);
      return aux;
    }
};

template<class ExpLeft>
class BinOpBase<Mult, ExpLeft, MatrixSquare>
{
  protected:
    const ExpLeft& lhs_;      
    MatrixSquare const&  rhs_;      

    BinOpBase(const ExpLeft& X, MatrixSquare const& y) : lhs_(X), rhs_(y)
    { ;}

    ~BinOpBase(){ ;}

 public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = rhs_.firstRow(); j<= rhs_.lastRow(); j++)
        aux += Mult::apply(lhs_[j],rhs_(j,i));
      return aux;
    }
};

template<class ExpRight>
class BinOpBase<Mult, MatrixUpperTriangular, ExpRight>
{
  protected:
    const MatrixUpperTriangular&   lhs_; 
    const ExpRight& rhs_;      

    BinOpBase( const MatrixUpperTriangular& y, const ExpRight& X)
             : lhs_(y), rhs_(X)
    { ;}
  
    ~BinOpBase(){ ;}

  public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = lhs_.compFirstHo(i); j <=lhs_.lastCol(); j++)
        aux += Mult::apply(lhs_(i,j),rhs_[j]);
      return aux;
    }
};

template<class ExpLeft>
class BinOpBase<Mult, ExpLeft, MatrixUpperTriangular>
{
  protected:
    const ExpLeft& lhs_;      
    const MatrixUpperTriangular&  rhs_;  

    BinOpBase( const ExpLeft& X, const MatrixUpperTriangular& y)
             : lhs_(X), rhs_(y)
    { ;}

    ~BinOpBase(){ ;}

 public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = rhs_.firstRow(); j<= rhs_.compLastVe(i); j++)
        aux += Mult::apply(lhs_[j], rhs_(j,i));
      return aux;
    }
};

template<class ExpRight>
class BinOpBase<Mult, MatrixLowerTriangular, ExpRight>
{
  protected:
    const MatrixLowerTriangular&   lhs_; 
    const ExpRight& rhs_;      

    BinOpBase( const MatrixLowerTriangular& y, const ExpRight& X)
             : lhs_(y), rhs_(X)
    { ;}
  
    ~BinOpBase(){ ;}

  public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = lhs_.firstCol(); j <=lhs_.compLastHo(i); j++)
        aux += Mult::apply(lhs_(i,j),rhs_[j]);
      return aux;
    }
};

template<class ExpLeft>
class BinOpBase<Mult, ExpLeft, MatrixLowerTriangular>
{
  protected:
    const ExpLeft& lhs_;      
    const MatrixLowerTriangular&  rhs_;  

    BinOpBase( const ExpLeft& X, const MatrixLowerTriangular& y)
             : lhs_(X), rhs_(y)
    { ;}

    ~BinOpBase(){ ;}

 public:
    inline Real operator[](Integer i) const
    {
      Real aux = 0.0;
      for (Integer j = rhs_.compFirstVe(i); j<= rhs_.lastRow(); j++)
        aux += Mult::apply(lhs_[j], rhs_(j,i));
      return aux;
    }
};

template<class Op, class ExpLeft, class ExpRight>
class BinOp : public BinOpBase<Op, ExpLeft, ExpRight>
{
  typedef BinOp<Op, ExpLeft, ExpRight> _This;
 
  public:
    /* constructor                                                          */
    BinOp( const ExpLeft& X, const ExpRight& Y)
         : BinOpBase<Op, ExpLeft, ExpRight>(X,Y)
    { ;}

    ~BinOp(){ ;}
};  

template<class Op, class Exp>
class UnOp
{
  typedef UnOp<Op, Exp> _This;

  protected:
    const Exp& rhs_;    

  public:
    UnOp(const Exp& X) : rhs_(X)
    { ;}

    ~UnOp(){}

    Real operator[](Integer i) const
    { return Op::apply(rhs_[i]);}

    Real operator()(Integer i) const
    { return Op::apply(rhs_(i));}

    template<class Right>
    BinOp<Plus, _This, Right> operator+(const Right& rhs)
    { return BinOp<Plus, _This, Right>(*this, rhs); }

    template<class Right>
    BinOp<Minus, _This, Right> operator-(const Right& rhs)
    { return BinOp<Minus, _This, Right>(*this, rhs);}

    template<class Right>
    BinOp<Mult, _This, Right> operator*(const Right& rhs)
    { return BinOp<Mult, _This, Right>(*this, rhs);}

    template<class Right>
    BinOp<Div, _This, Right>
    operator/(const Right& rhs)
    { return BinOp<Div, _This, Right>(*this, rhs);}
};

} // Namespace STK

#endif //STK_TEXPALGEBRA_H