basics/operations.hh

Go to the documentation of this file.

/* basic operations 
 */

#ifndef operations_hh
#define operations_hh

#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"

namespace concepts {

  template<class F>
  F& inverse(F& f) { f = 1.0 / f; return f; }

  template<class F>
  F inverse(const F& f) { return 1.0 / f; }

  template<class F, int dim>
  Mapping<F,dim>& inverse(Mapping<F,dim>& m) { m = m.inverse(); return m; }

  template<class F, int dim>
  Mapping<F,dim> inverse(const Mapping<F,dim>& m) { return m.inverse(); }

  template<class F, int dim>
  F determinant(const Mapping<F,dim>& m) { return m.determinant(); }

  template<class F, int dim>
  Mapping<F,dim>& adjugate(Mapping<F,dim>& m) { m = m.adjugate(); return m; }

  template<class F, int dim>
  Mapping<F,dim> adjugate(const Mapping<F,dim>& m) { return m.adjugate(); }

  template<class F, class G>
  G& product(const F& m, G& v) {
    v = m * v; return v;
  }

  template<class F, class G>
  G product(const F& m, const G& v) {
    return m * v;
  }

  template<class F, int dim>
  Mapping<F,dim>& prodTranspose(Mapping<F,dim>& m)
  { m = m.prodTranspose(); return m; }

  template<class F, int dim>
  Mapping<F,dim> prodTranspose(const Mapping<F,dim>& m) 
  { return m.prodTranspose(); }

  template<class F, int dim>
  Mapping<F,dim>& transpose(Mapping<F,dim>& m)
  { m = m.transpose(); return m; }

  template<class F, int dim>
  Mapping<F,dim> transpose(const Mapping<F,dim>& m) 
  { return m.transpose(); }


  template <class F, class G, class H>
  class multiplies : public std::binary_function<F, G, H>,
         public OutputOperator 
  {
  public:
    H operator()(const F& x, const G& y) const { return x * y; }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "*";
    }
  };    

} // namespace concepts

namespace std {

  inline const concepts::Real conj(const concepts::Real& v) { return v; }

  inline const concepts::Real norm(const concepts::Real& v) { 
    return v * v;
  }

} // namespace std

#endif // operations_hh