/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/a2

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_a2
#define inlib_a2

// Inheritance :
#include "sqm"

namespace inlib {
namespace a2 { //2 is a dimension.

// vec is an a2

template <class T>
class vec : public array<T> {
public:
  vec():array<T>(1,2){}
  vec(const T a_vec[2]):array<T>(1,2) {
    array<T>::m_vector[0] = a_vec[0];
    array<T>::m_vector[1] = a_vec[1];
  }
  vec(const T& a0,const T& a1):array<T>(1,2) {
    array<T>::m_vector[0] = a0;
    array<T>::m_vector[1] = a1;
  }
  virtual ~vec() {}
public:
  vec(const vec& a_from):array<T>(a_from){}
  vec& operator=(const vec& a_from) {
    array<T>::operator=(a_from);
    return *this;
  }
public:
  T v0() const { return array<T>::m_vector[0];}
  T v1() const { return array<T>::m_vector[1];}

  void v0(const T& a_value) { array<T>::m_vector[0] = a_value;}
  void v1(const T& a_value) { array<T>::m_vector[1] = a_value;}

  void v01(const T& a1,const T& a2) {
    array<T>::m_vector[0] = a1;
    array<T>::m_vector[1] = a2;
  }
  void v01(const T aV[2]) {
    array<T>::m_vector[0] = aV[0];
    array<T>::m_vector[1] = aV[1];
  }
  void v01(T& a1,T& a2) const {
    a1 = array<T>::m_vector[0];
    a2 = array<T>::m_vector[1];
  }    
  void set_value(const T& a1,const T& a2) {
    array<T>::m_vector[0] = a1;
    array<T>::m_vector[1] = a2;
  }
};

// sqm is an a22

template <class T>
class sqm : public inlib::sqm<T> {
public:
  sqm(): inlib::sqm<T>(2){}
  virtual ~sqm() {}
public:
  sqm(const sqm& a_from): inlib::sqm<T>(a_from){}
  sqm& operator=(const sqm& a_from) {
    inlib::sqm<T>::operator=(a_from);
    return *this;
  }
public:
  T v00() const {return array<T>::m_vector[0 + 0 * 2];}
  T v01() const {return array<T>::m_vector[0 + 1 * 2];}
  T v10() const {return array<T>::m_vector[1 + 0 * 2];}
  T v11() const {return array<T>::m_vector[1 + 1 * 2];}

  void v00(const T& a_value) {array<T>::m_vector[0+0*2] = a_value;}
  void v10(const T& a_value) {array<T>::m_vector[1+0*2] = a_value;}
  void v01(const T& a_value) {array<T>::m_vector[0+1*2] = a_value;}
  void v11(const T& a_value) {array<T>::m_vector[1+1*2] = a_value;}

  virtual T determinant() const {
    return v00() * v11() - v10() * v01();
  }

  bool invert(sqm& a_result) const {
    T deter = determinant();
    if(deter==array<T>::zero()) return false;
    a_result.v00( v11());
    a_result.v11( v00());
    a_result.v01(-v01());
    a_result.v10(-v10());
    a_result.multiply(1./deter);  
    return true;
  }

};

template <class T>
inline sqm<T> commutator(const sqm<T>& a1,const sqm<T>& a2) {
  return a1*a2-a2*a1;
}
template <class T>
inline sqm<T> anticommutator(const sqm<T>& a1,const sqm<T>& a2) {
  return a1*a2+a2*a1;
}

template <class T>
inline sqm<T> operator-(const sqm<T>& a1,const sqm<T>& a2) {
  sqm<T> res(a1);
  res.subtract(a2);
  return res;
}

template <class T>
inline sqm<T> operator+(const sqm<T>& a1,const sqm<T>& a2) {
  sqm<T> res(a1);
  res.add(a2);
  return res;
}

template <class T>
inline sqm<T> operator*(const sqm<T>& a1,const sqm<T>& a2) {
  sqm<T> res;
  a1.mx_mul(a2,res);
  return res;
}

}}

#endif