---

matrix_friend_ops_inline.hh

Go to the documentation of this file.

#ifndef _MATRIX_FRIEND_OPS_INLINE_HH_
#define _MATRIX_FRIEND_OPS_INLINE_HH_

// This header contains the inline definitions of the matrix operations.
// It is designed to be included in matrix.hh and should not be used on
// its own.  Definitions of matrix operations not included here are found
// in matrix.cc.

// 
// Arithmetic operators
//
inline Matrix operator + (const Matrix& a) {
  return a;
}
inline MatMTimesMat operator * (const Matrix& a, const Matrix& b) {
  return MatMTimesMat(a,b);
}
inline Matrix operator / (const Matrix& a, const Matrix& b) {
  if (b.IsScalar()) 
    return ldivide(b,a);
  else 
    return ctranspose(mldivide(ctranspose(b),ctranspose(a)));
}

//
// comparison operators
//
// inline bool operator != (const Matrix& a, const Matrix& b) {
//   return !(a == b);
// }

// inline bool operator <= (const Matrix& a, const Matrix& b) {
//   return !(a > b);
// }

// inline bool operator >= (const Matrix& a, const Matrix& b) {
//   return !(a < b);
// }

// 
// Named arithmetic operators
// 
inline Matrix uplus(const Matrix& a) {
  return a;
}
inline Matrix uminus(const Matrix& a) {
  return -a;
}
inline Matrix mplus(const Matrix& a, const Matrix& b) {
  return a + b;
}
inline Matrix mminus(const Matrix& a, const Matrix& b) {
  return a - b;
}
inline MatTimesMat times(const Matrix& a, const Matrix& b) {
  return MatTimesMat(a,b);
}
inline MatMTimesMat mtimes(const Matrix& a, const Matrix& b) {
  return MatMTimesMat(a,b);
}
inline Matrix rdivide(const Matrix& a, const Matrix& b) {
  return ldivide(b,a);
}
inline Matrix mrdivide(Matrix a, Matrix b) {
  return a / b;
}
inline MatCrossMat cross(const Matrix& a, const Matrix& b) {
  return MatCrossMat(a,b);
}
inline Matrix sincos(Matrix& c, const Matrix& a) {
  c = cos(a); 
  return sin(a);
}

// 
// Indexing
//
inline Matrix subsasgn(const Matrix& a, const Matrix& idx, const Matrix& b) {
  return subsasgn(a,idx,Matrix::DIN,b);
}

//
// Elementary matrices
//
inline Matrix zeros(int n) {
  return Matrix(n,n,0.);
}
inline Matrix zeros(int m, int n) {
  return Matrix(m,n,0.);
}
inline Matrix zeros(const Matrix& s) {
  return Matrix(int(s.ref->re[0]), int(s.ref->re[1]),0.);
}
inline Matrix ones(int n) {
  return Matrix(n,n,1.);
}
inline Matrix ones(int m, int n) {
  return Matrix(m,n,1.);
}
inline Matrix ones(const Matrix& s) {
  return Matrix(int(s.ref->re[0]), int(s.ref->re[1]),1.);
}
inline Matrix eye(int n) {
  return eye(n,n);
}
inline Matrix eye(int m, int n) {
  Matrix c(m,n,0.);
  for (int i=1; i<=min(m,n); i++)
    c.ref->index(i,i) = 1;

  return c;
}
inline Matrix eye(const Matrix& s) {
  return eye(int(s.ref->re[0]), int(s.ref->re[1]));
}
inline Matrix colon(double start, double step, double stop) {
  return ramp(start, step, stop);
}
// inline Matrix colon() {
//   Matrix m(1,1);

//   m.ref->m = -1; m.ref->n = -1;
//   return m;
// }

inline Matrix colon() {
  return Matrix::COLON;
}

//
// Matrix information
//
inline int size(int& cols, const Matrix& a) {
  cols = a.ref->n;
  return a.ref->m;
}
inline int size(const Matrix& a, int dim) {
  if (dim == 1)
    return a.ref->m;
  else if (dim == 2)
    return a.ref->n;
  else
    handle_exception(MatrixException(__FILE__,__LINE__,"In size(A,dim), dim must be either 1 or 2."));
}
inline Matrix size(const Matrix& a) {
  Matrix s(1,2);

  s.ref->index(1) = a.ref->m;
  s.ref->index(2) = a.ref->n;

  return s;
}
inline int length(const Matrix& a) {
  return a.ref->l;
}

inline bool isScalar(const Matrix& a) {
  return a.IsScalar();
}

inline Matrix 
mhorzcat(const Matrix& mat1, const Matrix& mat2, const Matrix& mat3,
         const Matrix& mat4, const Matrix& mat5, const Matrix& mat6,
         const Matrix& mat7, const Matrix& mat8, const Matrix& mat9,
         const Matrix& mat10,
         const Matrix& mat11, const Matrix& mat12, const Matrix& mat13,
         const Matrix& mat14, const Matrix& mat15, const Matrix& mat16,
         const Matrix& mat17, const Matrix& mat18, const Matrix& mat19,
         const Matrix& mat20) {
  return horzcat(mat1,mat2,mat3,mat4,mat5,mat6,mat7,mat8,mat9,
                 mat10,mat12,mat13,mat14,mat15,mat16,mat17,mat18,mat19,
                 mat20);
}

inline Matrix 
mvertcat(const Matrix& mat1, const Matrix& mat2, const Matrix& mat3,
         const Matrix& mat4, const Matrix& mat5, const Matrix& mat6,
         const Matrix& mat7, const Matrix& mat8, const Matrix& mat9,
         const Matrix& mat10,
         const Matrix& mat11, const Matrix& mat12, const Matrix& mat13,
         const Matrix& mat14, const Matrix& mat15, const Matrix& mat16,
         const Matrix& mat17, const Matrix& mat18, const Matrix& mat19,
         const Matrix& mat20) {
  return vertcat(mat1,mat2,mat3,mat4,mat5,mat6,mat7,mat8,mat9,
                 mat10,mat12,mat13,mat14,mat15,mat16,mat17,mat18,mat19,
                 mat20);
}
#endif

---