Biomechanical Joint Model  Author: Anderson Maciel

---

vecarray.h

Go to the documentation of this file.

#ifndef AMAURY_ARRAY_OF_VECS_H
#define AMAURY_ARRAY_OF_VECS_H

#include "vec.h"

namespace LinAlg{

  // class for triple-indexing (can be also used for double indexing)
struct idx3 {
   idx3() {};
   idx3(int i_, int j_, int k_=0) : i(i_), j(j_), k(k_) {};
   idx3(const idx3 &id) : i(id.i), j(id.j), k(id.k) {};
   
   void set(int i_, int j_, int k_=0) { i=i_, j=j_, k=k_; };  
   bool operator ==(const idx3 &id) const { return (i==id.i && j==id.j && k==id.k); };
   bool operator !=(const idx3 &id) const { return (i!=id.i || j!=id.j || k!=id.k); };
   int operator[](int m) const { return (m==0)? i : (m==1)? j: k; };
   int& operator[](int m) { return (m==0)? i : (m==1)? j: k; };
   
   int i, j, k;
};

 idx3 operator+(const idx3 &id1, const idx3 &id2);
 idx3 operator-(const idx3 &id1, const idx3 &id2);
 bool operator<(const idx3 &id1, const idx3 &id2);
 bool operator>(const idx3 &id1, const idx3 &id2); 
 std::ostream& operator<<(std::ostream &s, const idx3 &id);

// container (1,2 or 3D) for VECs that has built-in useful operations (+,-,*,/) 
// 1D is merely a restriction of the more general 2D case (only one column),
// which is in turn a restriction of the 3D case (one-depth cell).
// Internally, everything is linear anyway.
//
// VECArray implements VEC but IS NOT a VEC (hence the private inheritance)
// We simply use the convenient code provided by VEC
// 
// There's a bug with operator = when two operands do not have same size
// It occurs when the left-hand size is empty (size zero) i.e.:
// 
// VECArray A;
// VECArray B(10);
// A = B;          // won't work because A's size is 0
//
// As a work-around, declare A with an initial size>0, for instance "VECArray A(1)"
//
class VECArray : private VEC
{
public:   
   // constructors
   VECArray();
   VECArray(const VECArray &A); // copy constructor
   VECArray(const VEC &A, unsigned row, unsigned col=1, unsigned depth=1);
   VECArray(unsigned row, unsigned col=1, unsigned depth=1, 
            REAL value = REAL(0), unsigned K=dimspace);

   virtual ~VECArray();

    // methods 
   unsigned size() const { return row_ * col_ * depth_; };
   unsigned getNum() const { return size(); };
   unsigned row() const { return row_; }; 
   unsigned col() const { return col_; }; 
   unsigned depth() const { return depth_; }; 


   // container stuff
   typedef         VEC   value_type;
   typedef         VEC*  pointer;
   typedef         VEC*  iterator;
   typedef         VEC&  reference;
   typedef const   VEC*  const_iterator;
   typedef const   VEC&  const_reference;  
   iterator begin() { return vv;}
   iterator end()   { return vv + size(); }
   const_iterator begin() const { return vv;}
   const_iterator end() const  { return vv + size(); }

   // access
   // 1-dim array access
   reference operator[](int i);  // hide base class
   const_reference operator[](int i) const;  
   // 2-dim array access
   reference operator()(int i, int j);
   const_reference operator()(int i, int j) const;
   // 3-dim array access
   reference operator[](const idx3 &id);
   const_reference operator[](const idx3 &id) const;  

   // assignments
   VECArray& operator=(const VECArray &A);
   VECArray& operator+=(const VECArray &A);
   VECArray& operator-=(const VECArray &A);
   VECArray& operator*=(const REAL& scalar);
   VECArray& operator/=(const REAL& scalar);

   bool operator >=(const REAL& scalar) { return VEC::operator>=(scalar);};
   bool operator <=(const REAL& scalar) { return VEC::operator<=(scalar);};
   bool operator >(const REAL& scalar) { return VEC::operator>(scalar);};
   bool operator <(const REAL& scalar) { return VEC::operator<(scalar);};

    // binary operators
   friend VECArray operator+(const VECArray &A, const VECArray &B);
   friend VECArray operator-(const VECArray &A, const VECArray &B);
   friend VECArray operator*(const VECArray &A, double s);
   friend VECArray operator*(double s, const VECArray &A);
   friend VECArray operator/(const VECArray &A, double s);

   // unary operators
   friend VECArray operator-(const VECArray &A);
   friend std::ostream& operator<<(std::ostream &s, const VECArray &A);
   friend VECArray& abs(VECArray &A);

private:
   unsigned k_; // dimension of a contained VEC element
   unsigned row_, col_, depth_;

   virtual void initialize(unsigned N);
   virtual void destroy();

   void init_vv();

    // special Vector whose dimension CANNOT (and MAY NOT anyway) be changed
    // during a copy. ONLY to be used in class VECArray!!!
   struct specialVEC : public VEC
   {
      specialVEC() {};
      virtual ~specialVEC() { f_ = NULL; v_ = NULL; n_ = nf_ = 0; };
      void redirect(REAL* v) { v_ = v; };
      void resize(unsigned N) { n_ = N; };
      virtual VEC& operator=(const VEC &A);
   } *vv;  // vv = vec-vector
};

 // binary operators
  VECArray operator+(const VECArray &A, const VECArray &B);
  VECArray operator-(const VECArray &A, const VECArray &B);
  VECArray operator*(const VECArray &A, double s);
  VECArray operator*(double s, const VECArray &A);
  VECArray operator/(const VECArray &A, double s);
  
  // unary operators
  VECArray operator-(const VECArray &A);
  std::ostream& operator<<(std::ostream &s, const VECArray &A);
  VECArray& abs(VECArray &A);

inline idx3 operator+(const idx3 &id1, const idx3 &id2) 
{
   idx3 id(id1);
   id.i += id2.i; id.j += id2.j; id.k += id2.k;
   return id;
}

inline idx3 operator-(const idx3 &id1, const idx3 &id2) 
{
   idx3 id(id1);
   id.i -= id2.i; id.j -= id2.j; id.k -= id2.k;
   return id;
}

inline bool operator<(const idx3 &id1, const idx3 &id2) 
{
   return (id1.i<id2.i && id1.j<id2.j && id1.k<id2.k);
}

inline bool operator>(const idx3 &id1, const idx3 &id2) 
{
   return (id1.i>id2.i && id1.j>id2.j && id1.k>id2.k);
}  

inline std::ostream& operator<<(std::ostream &s, const idx3 &id)
{
   s << "(" << id.i << ", " << id.j << ", " << id.k << ")";   
   return s;   
}

/**************[ implementation of class VECArray ]********************/

// constructors
inline VECArray::VECArray() : VEC(), k_(0), vv(NULL), row_(0), col_(0), depth_(0)
{}

// copy ctor
inline VECArray::VECArray(const VECArray &A) 
  : k_(A.k_), vv(NULL), row_(A.row_), col_(A.col_), depth_(A.depth_)
{
  initialize(A.n_);
  copy(A.v_);
}

inline VECArray::VECArray(const VEC &A, unsigned row, unsigned col, unsigned depth) 
  : k_(A.dim()), vv(NULL), row_(row), col_(col), depth_(depth)
{  
  initialize(row*col*depth*k_);
  for (int i=0; i<dim()/k_; i++)
    for (int j=0; j<k_; j++)
      v_[i*k_+j] = A[j];
}


inline VECArray::VECArray(unsigned row, unsigned col, unsigned depth, REAL value, unsigned K) 
  : k_(K), vv(NULL), row_(row), col_(col), depth_(depth)
{
  initialize(row*col*depth*K);
  set(value);
}

inline VECArray& VECArray::operator=(const VECArray &A)
{
  VEC::operator=(A);
  if (k_ != A.k_)
  {      
    delete [] vv;
    vv = NULL;
    k_ = A.k_;
    init_vv();
  }
  return *this;
}

// access member
inline VECArray::reference VECArray::operator[](int i)
{
#ifdef BOUNDS_CHECK
  assert(0<=i && i<dim()/k_);
#endif
  return vv[i];
}

inline VECArray::const_reference VECArray::operator[](int i) const
{
#ifdef BOUNDS_CHECK
  assert(0<=i && i<dim()/k_);
#endif
  return vv[i];
}

inline VECArray::reference VECArray::operator()(int i, int j)
{
#ifdef BOUNDS_CHECK
  assert(0<=i && 0<=j);
  assert(i < row());
  assert(j < col());
  assert(depth() == 1);
#endif
  return vv[i*col()+j];
}

inline VECArray::const_reference VECArray::operator()(int i, int j) const
{
#ifdef BOUNDS_CHECK
  assert(0<=i && 0<=j);
  assert(i < row());
  assert(j < col());
  assert(depth() == 1);
#endif
  return vv[i*col()+j];
}

inline VECArray::reference VECArray::operator[](const idx3 &id)
{
  int i=id.i, j=id.j, k=id.k;     
#ifdef BOUNDS_CHECK
  assert(0<=i && 0<=j &&0<=k);
  assert(i < row());
  assert(j < col());
  assert(k < depth());
#endif
  return vv[ (i*col()+j)*depth() + k];
}

inline VECArray::const_reference VECArray::operator[](const idx3 &id) const
{
  int i=id.i, j=id.j, k=id.k;     
#ifdef BOUNDS_CHECK
  assert(0<=i && 0<=j &&0<=k);
  assert(i < row());
  assert(j < col());
  assert(k < depth());
#endif
  return vv[ (i*col()+j)*depth() + k];
}


// assignments

inline VECArray& VECArray::operator+=(const VECArray &A)
{
  VEC::operator+=(A);
  return *this;
}

inline VECArray& VECArray::operator-=(const VECArray &A)
{
  VEC::operator-=(A);
  return *this;
}

inline VECArray& VECArray::operator*=(const REAL& scalar)
{
  VEC::operator*=(scalar);
  return *this;
}

inline VECArray& VECArray::operator/=(const REAL& scalar)
{
  VEC::operator/=(scalar);
  return *this;
}

// protected members


/****************************  I/O  ********************************/

inline std::ostream& operator<<(std::ostream &s, const VECArray &A)
{
    unsigned N=A.dim()/A.k_;

    for (unsigned i=0; i<N; i++)
        s   << A[i] << " ";
    return s;
}


/**************[ Basic Operations on VECArrays ]********************/

inline VECArray operator+(const VECArray &A, const VECArray &B)
{
  VECArray tmp(A);
  tmp += B;
  return tmp;
}

inline VECArray operator-(const VECArray &A, const VECArray &B)
{
  VECArray tmp(A);
  tmp -= B;
  return tmp;
}

inline VECArray operator*(const VECArray &A, double s)
{
  VECArray tmp(A);
  tmp *= s;
  return tmp;
}

inline VECArray operator*(double s, const VECArray &A)
{
  VECArray tmp(A);
  tmp *= s;
  return tmp;
}

inline VECArray operator/(const VECArray &A, double s)
{
  VECArray tmp(A);
  tmp /= s;
  return tmp;
}

// unary operators
inline VECArray operator-(const VECArray &A)
{
  VECArray tmp(A);
  tmp *= -1;
  return tmp;
}

inline VECArray& abs(VECArray &A)
{
   for (int i=0; i<A.size(); i++)
      abs(A.vv[i]);
   return A;
}




}

#endif
// ARRAY_OF_VECS_H

---