operations.hh

Go to the documentation of this file.

 
#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, uint dim>
  Mapping<F,dim>& inverse(Mapping<F,dim>& m) { m = m.inverse(); return m; }
 
  template<class F, uint dim>
  Mapping<F,dim> inverse(const Mapping<F,dim>& m) { return m.inverse(); }
 
  template<class F, uint dim>
  F determinant(const Mapping<F,dim>& m) { return m.determinant(); }
 
  template<class F, uint dim>
  Mapping<F,dim>& adjugate(Mapping<F,dim>& m) { m = m.adjugate(); return m; }
 
  template<class F, uint 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, uint dim>
  Mapping<F,dim>& prodTranspose(Mapping<F,dim>& m)
  { m = m.prodTranspose(); return m; }
 
  template<class F, uint dim>
  Mapping<F,dim> prodTranspose(const Mapping<F,dim>& m) 
  { return m.prodTranspose(); }
 
  template<class F, uint dim>
  Mapping<F,dim>& transpose(Mapping<F,dim>& m)
  { m = m.transpose(); return m; }
 
  template<class F, uint 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;
  }
 
  // Returns the absolute value of an unsigned integer
  inline uint abs(const uint& v) {
    return v;
  }
 
} // namespace std
 
#endif // operations_hh