Operartor_times_dot


Functions

template<typename eT >
arma_inline eT operator* (const Row< eT > &A, const Col< eT > &B)
 Row vector multiplied by a column vector (i.e. a dot product).
template<typename eT >
arma_inline eT operator* (const Op< Col< eT >, op_trans > &X, const Col< eT > &Y)
 Transpose of a column vector multiplied by a column vector (i.e. a dot product).
template<typename eT >
arma_inline eT operator* (const Row< eT > &X, const Op< Row< eT >, op_trans > &Y)
 Row vector multiplied by the transpose of a row vector (i.e. a dot product).
template<typename eT >
arma_inline eT operator* (const Op< Col< eT >, op_trans > &X, const Op< Row< eT >, op_trans > &Y)
 Transpose of a column vector multiplied by the transpose of a row vector (i.e. a dot product).
template<typename eT >
eT operator* (const Glue< Row< eT >, Mat< eT >, glue_times_vec > &X, const Col< eT > &Y)
 rowvec * mat * colvec
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Mat< eT >, glue_times > &X, const Col< eT > &Y)
 trans(colvec) * mat * colvec
template<typename eT >
eT operator* (const Glue< Row< eT >, Mat< eT >, glue_times_vec > &X, const Op< Row< eT >, op_trans > &Y)
 rowvec * mat * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Mat< eT >, glue_times > &X, const Op< Row< eT >, op_trans > &Y)
 trans(colvec) * mat * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &X, const Col< eT > &Y)
 rowvec * diagmat(mat) * colvec
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &X, const Col< eT > &Y)
 trans(colvec) * diagmat(mat) * colvec
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &X, const Op< Row< eT >, op_trans > &Y)
 rowvec * diagmat(mat) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &X, const Op< Row< eT >, op_trans > &Y)
 trans(colvec) * diagmat(mat) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Mat< eT >, op_diagmat_vec >, glue_times_vec > &X, const Col< eT > &Y)
 rowvec * diagmat(colvec or rowvec) * colvec
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat_vec >, glue_times > &X, const Col< eT > &Y)
 trans(colvec) * diagmat(colvec or rowvec) * colvec
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Mat< eT >, op_diagmat_vec >, glue_times_vec > &X, const Op< Row< eT >, op_trans > &Y)
 rowvec * diagmat(colvec or rowvec) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat_vec >, glue_times > &X, const Op< Row< eT >, op_trans > &Y)
 trans(colvec) * diagmat(colvec or rowvec) * trans(rowvec)
template<typename T1 >
T1::elem_type operator* (const Glue< Row< typename T1::elem_type >, Op< T1, op_inv >, glue_times_vec > &X, const Col< typename T1::elem_type > &Y)
 rowvec * inv(T1) * colvec
template<typename T1 >
T1::elem_type operator* (const Glue< Op< Col< typename T1::elem_type >, op_trans >, Op< T1, op_inv >, glue_times > &X, const Col< typename T1::elem_type > &Y)
 trans(colvec) * inv(T1) * colvec
template<typename T1 >
T1::elem_type operator* (const Glue< Row< typename T1::elem_type >, Op< T1, op_inv >, glue_times_vec > &X, const Op< Row< typename T1::elem_type >, op_trans > &Y)
 rowvec * inv(T1) * trans(rowvec)
template<typename T1 >
T1::elem_type operator* (const Glue< Op< Col< typename T1::elem_type >, op_trans >, Op< T1, op_inv >, glue_times > &X, const Op< Row< typename T1::elem_type >, op_trans > &Y)
 trans(colvec) * inv(T1) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times_vec > &X, const Col< eT > &Y)
 rowvec * inv(diagmat(mat)) * colvec
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times > &X, const Col< eT > &Y)
 trans(colvec) * inv(diagmat(mat)) * colvec
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times_vec > &X, const Op< Row< eT >, op_trans > &Y)
 rowvec * inv(diagmat(mat)) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times > &X, const Op< Row< eT >, op_trans > &Y)
 trans(colvec) * inv(diagmat(mat)) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times_vec > &X, const Col< eT > &Y)
 rowvec * inv(diagmat(colvec or rowvec)) * colvec
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times > &X, const Col< eT > &Y)
 trans(colvec) * inv(diagmat(colvec or rowvec)) * colvec
template<typename eT >
eT operator* (const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times_vec > &X, const Op< Row< eT >, op_trans > &Y)
 rowvec * inv(diagmat(colvec or rowvec)) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times > &X, const Op< Row< eT >, op_trans > &Y)
 trans(colvec) * inv(diagmat(colvec or rowvec)) * trans(rowvec)
template<typename eT >
eT operator* (const Glue< Op< Glue< Col< eT >, Col< eT >, glue_minus >, op_trans >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times > &X, const Glue< Col< eT >, Col< eT >, glue_minus > &Y)
 trans(colvec-colvec) * inv(diagmat(colvec or rowvec)) * (colvec-colvec)

Function Documentation

template<typename eT >
arma_inline eT operator* ( const Row< eT > &  A,
const Col< eT > &  B 
) [inline]

Row vector multiplied by a column vector (i.e. a dot product).

Definition at line 26 of file operator_times_dot.hpp.

References op_dot::direct_dot(), Mat< eT >::mem, and Mat< eT >::n_elem.

00030   {
00031   arma_extra_debug_sigprint();
00032   
00033   arma_debug_check( (A.n_elem != B.n_elem), "incompatible matrix dimensions" );
00034   
00035   return op_dot::direct_dot(A.n_elem, A.mem, B.mem);
00036   
00037   }

template<typename eT >
arma_inline eT operator* ( const Op< Col< eT >, op_trans > &  X,
const Col< eT > &  Y 
) [inline]

Transpose of a column vector multiplied by a column vector (i.e. a dot product).

Definition at line 46 of file operator_times_dot.hpp.

References op_dot::direct_dot(), Op< T1, op_type >::m, Mat< eT >::mem, and Mat< eT >::n_elem.

00050   {
00051   arma_extra_debug_sigprint();
00052   
00053   const Col<eT>& A = X.m;
00054   const Col<eT>& B = Y;
00055   
00056   arma_debug_check( (A.n_elem != B.n_elem), "incompatible matrix dimensions" );
00057   
00058   return op_dot::direct_dot(A.n_elem, A.mem, B.mem);
00059   
00060   }

template<typename eT >
arma_inline eT operator* ( const Row< eT > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

Row vector multiplied by the transpose of a row vector (i.e. a dot product).

Definition at line 69 of file operator_times_dot.hpp.

References op_dot::direct_dot(), Mat< eT >::mem, and Mat< eT >::n_elem.

00073   {
00074   arma_extra_debug_sigprint();
00075   
00076   const Row<eT>& A = X;
00077   const Row<eT>& B = Y.m;
00078   
00079   arma_debug_check( (A.n_elem != B.n_elem), "incompatible matrix dimensions" );
00080   
00081   return op_dot::direct_dot(A.n_elem, A.mem, B.mem);
00082   }

template<typename eT >
arma_inline eT operator* ( const Op< Col< eT >, op_trans > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

Transpose of a column vector multiplied by the transpose of a row vector (i.e. a dot product).

Definition at line 91 of file operator_times_dot.hpp.

References op_dot::direct_dot(), Op< T1, op_type >::m, Mat< eT >::mem, and Mat< eT >::n_elem.

00095   {
00096   arma_extra_debug_sigprint();
00097   
00098   const Col<eT>& A = X.m;
00099   const Row<eT>& B = Y.m;
00100   
00101   arma_debug_check( (A.n_elem != B.n_elem), "incompatible matrix dimensions" );
00102   
00103   return op_dot::direct_dot(A.n_elem, A.mem, B.mem);
00104   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Mat< eT >, glue_times_vec > &  X,
const Col< eT > &  Y 
) [inline]

rowvec * mat * colvec

Definition at line 119 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00122   {
00123   arma_extra_debug_sigprint();
00124   
00125   const Row<eT>& A = X.A;
00126   const Mat<eT>& B = X.B;
00127   const Col<eT>& C = Y;
00128   
00129   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00130   
00131   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00132   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Mat< eT >, glue_times > &  X,
const Col< eT > &  Y 
) [inline]

trans(colvec) * mat * colvec

Definition at line 141 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00145   {
00146   arma_extra_debug_sigprint();
00147   
00148   const Col<eT>& A = X.A.m;
00149   const Mat<eT>& B = X.B;
00150   const Col<eT>& C = Y;
00151   
00152   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00153   
00154   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00155   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Mat< eT >, glue_times_vec > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

rowvec * mat * trans(rowvec)

Definition at line 164 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00168   {
00169   arma_extra_debug_sigprint();
00170   
00171   const Row<eT>& A = X.A;
00172   const Mat<eT>& B = X.B;
00173   const Row<eT>& C = Y.m;
00174   
00175   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00176   
00177   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00178   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Mat< eT >, glue_times > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

trans(colvec) * mat * trans(rowvec)

Definition at line 187 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00191   {
00192   arma_extra_debug_sigprint();
00193   
00194   const Col<eT>& A = X.A.m;
00195   const Mat<eT>& B = X.B;
00196   const Row<eT>& C = Y.m;
00197   
00198   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00199   
00200   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00201   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &  X,
const Col< eT > &  Y 
) [inline]

rowvec * diagmat(mat) * colvec

Definition at line 215 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_diagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00219   {
00220   arma_extra_debug_sigprint();
00221   
00222   const Row<eT>& A = X.A;
00223   const Mat<eT>& B = X.B.m;
00224   const Col<eT>& C = Y;
00225   
00226   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00227   
00228   return glue_times::direct_rowvec_diagmat_colvec(A.mem, B, C.mem);
00229   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &  X,
const Col< eT > &  Y 
) [inline]

trans(colvec) * diagmat(mat) * colvec

Definition at line 238 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_diagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00242   {
00243   arma_extra_debug_sigprint();
00244   
00245   const Col<eT>& A = X.A.m;
00246   const Mat<eT>& B = X.B.m;
00247   const Col<eT>& C = Y;
00248   
00249   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00250   
00251   return glue_times::direct_rowvec_diagmat_colvec(A.mem, B, C.mem);
00252   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

rowvec * diagmat(mat) * trans(rowvec)

Definition at line 261 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_diagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00265   {
00266   arma_extra_debug_sigprint();
00267   
00268   const Row<eT>& A = X.A;
00269   const Mat<eT>& B = X.B.m;
00270   const Row<eT>& C = Y.m;
00271   
00272   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00273   
00274   return glue_times::direct_rowvec_diagmat_colvec(A.mem, B, C.mem);
00275   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat >, glue_times_diag > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

trans(colvec) * diagmat(mat) * trans(rowvec)

Definition at line 284 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_diagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00288   {
00289   arma_extra_debug_sigprint();
00290   
00291   const Col<eT>& A = X.A.m;
00292   const Mat<eT>& B = X.B.m;
00293   const Row<eT>& C = Y.m;
00294   
00295   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00296   
00297   return glue_times::direct_rowvec_diagmat_colvec(A.mem, B, C.mem);
00298   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Mat< eT >, op_diagmat_vec >, glue_times_vec > &  X,
const Col< eT > &  Y 
) [inline]

rowvec * diagmat(colvec or rowvec) * colvec

Definition at line 311 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, op_dot::direct_dot(), Mat< eT >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00315   {
00316   arma_extra_debug_sigprint();
00317 
00318   const Row<eT>& A = X.A;
00319   const Mat<eT>& B = X.B.m;
00320   const Col<eT>& C = Y;
00321   
00322   arma_debug_check( (A.n_cols != B.n_elem) || (B.n_elem != C.n_rows), "operator*(): incompatible matrix dimensions" );
00323   
00324   return op_dot::direct_dot(A.n_cols, A.mem, B.mem, C.mem);
00325   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat_vec >, glue_times > &  X,
const Col< eT > &  Y 
) [inline]

trans(colvec) * diagmat(colvec or rowvec) * colvec

Definition at line 334 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, op_dot::direct_dot(), Mat< eT >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00338   {
00339   arma_extra_debug_sigprint();
00340 
00341   const Col<eT>& A = X.A.m;
00342   const Mat<eT>& B = X.B.m;
00343   const Col<eT>& C = Y;
00344   
00345   arma_debug_check( (A.n_rows != B.n_elem) || (B.n_elem != C.n_rows), "operator*(): incompatible matrix dimensions" );
00346   
00347   return op_dot::direct_dot(A.n_cols, A.mem, B.mem, C.mem);
00348   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Mat< eT >, op_diagmat_vec >, glue_times_vec > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

rowvec * diagmat(colvec or rowvec) * trans(rowvec)

Definition at line 357 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, op_dot::direct_dot(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_elem.

00361   {
00362   arma_extra_debug_sigprint();
00363 
00364   const Row<eT>& A = X.A;
00365   const Mat<eT>& B = X.B.m;
00366   const Row<eT>& C = Y.m;
00367   
00368   arma_debug_check( (A.n_cols != B.n_elem) || (B.n_elem != C.n_cols), "operator*(): incompatible matrix dimensions" );
00369   
00370   return op_dot::direct_dot(A.n_cols, A.mem, B.mem, C.mem);
00371   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Mat< eT >, op_diagmat_vec >, glue_times > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

trans(colvec) * diagmat(colvec or rowvec) * trans(rowvec)

Definition at line 380 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, op_dot::direct_dot(), Mat< eT >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00384   {
00385   arma_extra_debug_sigprint();
00386   
00387   const Col<eT>& A = X.A.m;
00388   const Mat<eT>& B = X.B.m;
00389   const Row<eT>& C = Y.m;
00390   
00391   arma_debug_check( (A.n_rows != B.n_elem) || (B.n_elem != C.n_cols), "operator*(): incompatible matrix dimensions" );
00392   
00393   return op_dot::direct_dot(A.n_cols, A.mem, B.mem, C.mem);
00394   }

template<typename T1 >
T1::elem_type operator* ( const Glue< Row< typename T1::elem_type >, Op< T1, op_inv >, glue_times_vec > &  X,
const Col< typename T1::elem_type > &  Y 
) [inline]

rowvec * inv(T1) * colvec

Definition at line 409 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, op_inv::apply(), Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00413   {
00414   arma_extra_debug_sigprint();
00415   
00416   typedef typename T1::elem_type eT;
00417   
00418   const Row<eT>& A = X.A;
00419         Mat<eT>  B; op_inv::apply(B, X.B.m);
00420   const Col<eT>& C = Y;
00421   
00422   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00423   
00424   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00425   }

template<typename T1 >
T1::elem_type operator* ( const Glue< Op< Col< typename T1::elem_type >, op_trans >, Op< T1, op_inv >, glue_times > &  X,
const Col< typename T1::elem_type > &  Y 
) [inline]

trans(colvec) * inv(T1) * colvec

Definition at line 434 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, op_inv::apply(), Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00438   {
00439   arma_extra_debug_sigprint();
00440 
00441   typedef typename T1::elem_type eT;
00442   
00443   const Col<eT>& A = X.A.m;
00444         Mat<eT>  B; op_inv::apply(B, X.B.m);
00445   const Col<eT>& C = Y;
00446   
00447   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00448   
00449   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00450   }

template<typename T1 >
T1::elem_type operator* ( const Glue< Row< typename T1::elem_type >, Op< T1, op_inv >, glue_times_vec > &  X,
const Op< Row< typename T1::elem_type >, op_trans > &  Y 
) [inline]

rowvec * inv(T1) * trans(rowvec)

Definition at line 459 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, op_inv::apply(), Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00463   {
00464   arma_extra_debug_sigprint();
00465   
00466   typedef typename T1::elem_type eT;
00467 
00468   const Row<eT>& A = X.A;
00469         Mat<eT>  B;  op_inv::apply(B, X.B.m);
00470   const Row<eT>& C = Y.m;
00471   
00472   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00473   
00474   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00475   }

template<typename T1 >
T1::elem_type operator* ( const Glue< Op< Col< typename T1::elem_type >, op_trans >, Op< T1, op_inv >, glue_times > &  X,
const Op< Row< typename T1::elem_type >, op_trans > &  Y 
) [inline]

trans(colvec) * inv(T1) * trans(rowvec)

Definition at line 484 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, op_inv::apply(), Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_mat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00488   {
00489   arma_extra_debug_sigprint();
00490   
00491   typedef typename T1::elem_type eT;
00492   
00493   const Col<eT>& A = X.A.m;
00494         Mat<eT>  B;  op_inv::apply(B, X.B.m);
00495   const Row<eT>& C = Y.m;
00496   
00497   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00498   
00499   return glue_times::direct_rowvec_mat_colvec(A.mem, B, C.mem);
00500   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times_vec > &  X,
const Col< eT > &  Y 
) [inline]

rowvec * inv(diagmat(mat)) * colvec

Definition at line 515 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00519   {
00520   arma_extra_debug_sigprint();
00521   
00522   const Row<eT>& A = X.A;
00523   const Mat<eT>& B = X.B.m.m;
00524   const Col<eT>& C = Y;
00525   
00526   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00527   
00528   return glue_times::direct_rowvec_invdiagmat_colvec(A.mem, B, C.mem);
00529   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times > &  X,
const Col< eT > &  Y 
) [inline]

trans(colvec) * inv(diagmat(mat)) * colvec

Definition at line 538 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00542   {
00543   arma_extra_debug_sigprint();
00544   
00545   const Col<eT>& A = X.A.m;
00546   const Mat<eT>& B = X.B.m.m;
00547   const Col<eT>& C = Y;
00548   
00549   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_rows), "operator*(): incompatible matrix dimensions" );
00550   
00551   return glue_times::direct_rowvec_invdiagmat_colvec(A.mem, B, C.mem);
00552   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times_vec > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

rowvec * inv(diagmat(mat)) * trans(rowvec)

Definition at line 561 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00565   {
00566   arma_extra_debug_sigprint();
00567 
00568   const Row<eT>& A = X.A;
00569   const Mat<eT>& B = X.B.m.m;
00570   const Row<eT>& C = Y.m;
00571   
00572   arma_debug_check( (A.n_cols != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00573   
00574   return glue_times::direct_rowvec_invdiagmat_colvec(A.mem, B, C.mem);
00575   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat >, op_inv >, glue_times > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

trans(colvec) * inv(diagmat(mat)) * trans(rowvec)

Definition at line 584 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagmat_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_rows.

00588   {
00589   arma_extra_debug_sigprint();
00590   
00591   const Col<eT>& A = X.A.m;
00592   const Mat<eT>& B = X.B.m.m;
00593   const Row<eT>& C = Y.m;
00594   
00595   arma_debug_check( (A.n_rows != B.n_rows) || (B.n_rows != B.n_cols) || (B.n_cols != C.n_cols), "operator*(): incompatible matrix dimensions" );
00596   
00597   return glue_times::direct_rowvec_invdiagmat_colvec(A.mem, B, C.mem);
00598   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times_vec > &  X,
const Col< eT > &  Y 
) [inline]

rowvec * inv(diagmat(colvec or rowvec)) * colvec

Definition at line 613 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagvec_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00617   {
00618   arma_extra_debug_sigprint();
00619 
00620   const Row<eT>& A = X.A;
00621   const Mat<eT>& B = X.B.m.m;
00622   const Col<eT>& C = Y;
00623   
00624   arma_debug_check( (A.n_cols != B.n_elem) || (B.n_elem != C.n_rows), "operator*(): incompatible matrix dimensions" );
00625   
00626   return glue_times::direct_rowvec_invdiagvec_colvec(A.mem, B, C.mem);
00627   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times > &  X,
const Col< eT > &  Y 
) [inline]

trans(colvec) * inv(diagmat(colvec or rowvec)) * colvec

Definition at line 636 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagvec_colvec(), Mat< eT >::mem, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00640   {
00641   arma_extra_debug_sigprint();
00642 
00643   const Col<eT>& A = X.A.m;
00644   const Mat<eT>& B = X.B.m.m;
00645   const Col<eT>& C = Y;
00646   
00647   arma_debug_check( (A.n_rows != B.n_elem) || (B.n_elem != C.n_rows), "operator*(): incompatible matrix dimensions" );
00648   
00649   return glue_times::direct_rowvec_invdiagvec_colvec(A.mem, B, C.mem);
00650   }

template<typename eT >
eT operator* ( const Glue< Row< eT >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times_vec > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

rowvec * inv(diagmat(colvec or rowvec)) * trans(rowvec)

Definition at line 659 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagvec_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, and Mat< eT >::n_elem.

00663   {
00664   arma_extra_debug_sigprint();
00665 
00666   const Row<eT>& A = X.A;
00667   const Mat<eT>& B = X.B.m.m;
00668   const Row<eT>& C = Y.m;
00669   
00670   arma_debug_check( (A.n_cols != B.n_elem) || (B.n_elem != C.n_cols), "operator*(): incompatible matrix dimensions" );
00671   
00672   return glue_times::direct_rowvec_invdiagvec_colvec(A.mem, B, C.mem);
00673   }

template<typename eT >
eT operator* ( const Glue< Op< Col< eT >, op_trans >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times > &  X,
const Op< Row< eT >, op_trans > &  Y 
) [inline]

trans(colvec) * inv(diagmat(colvec or rowvec)) * trans(rowvec)

Definition at line 682 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, glue_times::direct_rowvec_invdiagvec_colvec(), Mat< eT >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00686   {
00687   arma_extra_debug_sigprint();
00688   
00689   const Col<eT>& A = X.A.m;
00690   const Mat<eT>& B = X.B.m.m;
00691   const Row<eT>& C = Y.m;
00692   
00693   arma_debug_check( (A.n_rows != B.n_elem) || (B.n_elem != C.n_cols), "operator*(): incompatible matrix dimensions" );
00694   
00695   return glue_times::direct_rowvec_invdiagvec_colvec(A.mem, B, C.mem);
00696   }

template<typename eT >
eT operator* ( const Glue< Op< Glue< Col< eT >, Col< eT >, glue_minus >, op_trans >, Op< Op< Mat< eT >, op_diagmat_vec >, op_inv >, glue_times > &  X,
const Glue< Col< eT >, Col< eT >, glue_minus > &  Y 
) [inline]

trans(colvec-colvec) * inv(diagmat(colvec or rowvec)) * (colvec-colvec)

Definition at line 711 of file operator_times_dot.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, Mat< eT >::mem, Mat< eT >::n_elem, and Mat< eT >::n_rows.

00720   {
00721   arma_extra_debug_sigprint();
00722   
00723   const Col<eT>& A1 = X.A.m.A;
00724   const Col<eT>& A2 = X.A.m.B;
00725   
00726   const Mat<eT>& B  = X.B.m.m;
00727   
00728   const Col<eT>& C1 = Y.A;
00729   const Col<eT>& C2 = Y.B;
00730   
00731   arma_debug_check
00732     (
00733     (A1.n_rows != A2.n_rows)
00734     ||
00735     (A2.n_rows != B.n_rows)
00736     ||
00737     (B.n_elem != C1.n_rows)
00738     ||
00739     (C1.n_rows != C2.n_rows)
00740     ,
00741     "operator*(): incompatible matrix dimensions"
00742     );
00743   
00744   
00745   if( (&A1 == &C1) && (&A2 == &C2) )
00746     {
00747     eT val = eT(0);
00748     for(u32 i=0; i<A1.n_rows; ++i)
00749       {
00750       const eT tmp = (A1.mem[i] - A2.mem[i]);
00751       val += (tmp*tmp) / B.mem[i];
00752       }
00753     return val;
00754     }
00755   else
00756     {
00757     eT val = eT(0);
00758     for(u32 i=0; i<A1.n_rows; ++i)
00759       {
00760       val += ( (A1.mem[i] - A2.mem[i]) * (C1.mem[i] - C2.mem[i]) ) / B.mem[i];
00761       }
00762     return val;
00763     }
00764 
00765   }