Base class which provides matrix operations not involving resizing or allocation. More...

#include <kaldi-matrix.h>

Inheritance diagram for MatrixBase< Real >:

[legend]

Collaboration diagram for MatrixBase< Real >:

Public Member Functions
MatrixIndexT	NumRows () const
	Returns number of rows (or zero for empty matrix). More...

MatrixIndexT	NumCols () const
	Returns number of columns (or zero for empty matrix). More...

MatrixIndexT	Stride () const
	Stride (distance in memory between each row). Will be >= NumCols. More...

size_t	SizeInBytes () const
	Returns size in bytes of the data held by the matrix. More...

const Real *	Data () const
	Gives pointer to raw data (const). More...

Real *	Data ()
	Gives pointer to raw data (non-const). More...

Real *	RowData (MatrixIndexT i)
	Returns pointer to data for one row (non-const) More...

const Real *	RowData (MatrixIndexT i) const
	Returns pointer to data for one row (const) More...

Real &	operator() (MatrixIndexT r, MatrixIndexT c)
	Indexing operator, non-const (only checks sizes if compiled with -DKALDI_PARANOID) More...

Real &	Index (MatrixIndexT r, MatrixIndexT c)
	Indexing operator, provided for ease of debugging (gdb doesn't work with parenthesis operator). More...

const Real	operator() (MatrixIndexT r, MatrixIndexT c) const
	Indexing operator, const (only checks sizes if compiled with -DKALDI_PARANOID) More...

void	SetZero ()
	Sets matrix to zero. More...

void	Set (Real)
	Sets all elements to a specific value. More...

void	SetUnit ()
	Sets to zero, except ones along diagonal [for non-square matrices too]. More...

void	SetRandn ()
	Sets to random values of a normal distribution. More...

void	SetRandUniform ()
	Sets to numbers uniformly distributed on (0, 1) More...

template<typename OtherReal >
void	CopyFromMat (const MatrixBase< OtherReal > &M, MatrixTransposeType trans=kNoTrans)
	Copy given matrix. (no resize is done). More...

void	CopyFromMat (const CompressedMatrix &M)
	Copy from compressed matrix. More...

template<typename OtherReal >
void	CopyFromSp (const SpMatrix< OtherReal > &M)
	Copy given spmatrix. (no resize is done). More...

template<typename OtherReal >
void	CopyFromTp (const TpMatrix< OtherReal > &M, MatrixTransposeType trans=kNoTrans)
	Copy given tpmatrix. (no resize is done). More...

template<typename OtherReal >
void	CopyFromMat (const CuMatrixBase< OtherReal > &M, MatrixTransposeType trans=kNoTrans)
	Copy from CUDA matrix. Implemented in ../cudamatrix/cu-matrix.h. More...

void	CopyRowsFromVec (const VectorBase< Real > &v)
	This function has two modes of operation. More...

void	CopyRowsFromVec (const CuVectorBase< Real > &v)
	This version of CopyRowsFromVec is implemented in ../cudamatrix/cu-vector.cc. More...

template<typename OtherReal >
void	CopyRowsFromVec (const VectorBase< OtherReal > &v)

void	CopyColsFromVec (const VectorBase< Real > &v)
	Copies vector into matrix, column-by-column. More...

void	CopyColFromVec (const VectorBase< Real > &v, const MatrixIndexT col)
	Copy vector into specific column of matrix. More...

void	CopyRowFromVec (const VectorBase< Real > &v, const MatrixIndexT row)
	Copy vector into specific row of matrix. More...

void	CopyDiagFromVec (const VectorBase< Real > &v)
	Copy vector into diagonal of matrix. More...

const SubVector< Real >	Row (MatrixIndexT i) const
	Return specific row of matrix [const]. More...

SubVector< Real >	Row (MatrixIndexT i)
	Return specific row of matrix. More...

SubMatrix< Real >	Range (const MatrixIndexT row_offset, const MatrixIndexT num_rows, const MatrixIndexT col_offset, const MatrixIndexT num_cols) const
	Return a sub-part of matrix. More...

SubMatrix< Real >	RowRange (const MatrixIndexT row_offset, const MatrixIndexT num_rows) const

SubMatrix< Real >	ColRange (const MatrixIndexT col_offset, const MatrixIndexT num_cols) const

Real	Sum () const
	Returns sum of all elements in matrix. More...

Real	Trace (bool check_square=true) const
	Returns trace of matrix. More...

Real	Max () const
	Returns maximum element of matrix. More...

Real	Min () const
	Returns minimum element of matrix. More...

void	MulElements (const MatrixBase< Real > &A)
	Element by element multiplication with a given matrix. More...

void	DivElements (const MatrixBase< Real > &A)
	Divide each element by the corresponding element of a given matrix. More...

void	Scale (Real alpha)
	Multiply each element with a scalar value. More...

void	Max (const MatrixBase< Real > &A)
	Set, element-by-element, this = max(this, A) More...

void	Min (const MatrixBase< Real > &A)
	Set, element-by-element, this = min(this, A) More...

void	MulColsVec (const VectorBase< Real > &scale)
	Equivalent to (this) = (this) * diag(scale). More...

void	MulRowsVec (const VectorBase< Real > &scale)
	Equivalent to (this) = diag(scale) (*this). More...

void	MulRowsGroupMat (const MatrixBase< Real > &src)
	Divide each row into src.NumCols() equal groups, and then scale i'th row's j'th group of elements by src(i, j). More...

Real	LogDet (Real *det_sign=NULL) const
	Returns logdet of matrix. More...

void	Invert (Real log_det=NULL, Real det_sign=NULL, bool inverse_needed=true)
	matrix inverse. More...

void	InvertDouble (Real LogDet=NULL, Real det_sign=NULL, bool inverse_needed=true)
	matrix inverse [double]. More...

void	InvertElements ()
	Inverts all the elements of the matrix. More...

void	Transpose ()
	Transpose the matrix. More...

void	CopyCols (const MatrixBase< Real > &src, const MatrixIndexT *indices)
	Copies column r from column indices[r] of src. More...

void	CopyRows (const MatrixBase< Real > &src, const MatrixIndexT *indices)
	Copies row r from row indices[r] of src (does nothing As a special case, if indexes[i] == -1, sets row i to zero. More...

void	AddCols (const MatrixBase< Real > &src, const MatrixIndexT *indices)
	Add column indices[r] of src to column r. More...

void	CopyRows (const Real const src)
	Copies row r of this matrix from an array of floats at the location given by src[r]. More...

void	CopyToRows (Real const dst) const
	Copies row r of this matrix to the array of floats at the location given by dst[r]. More...

void	AddRows (Real alpha, const MatrixBase< Real > &src, const MatrixIndexT *indexes)
	Does for each row r, this.Row(r) += alpha * src.row(indexes[r]). More...

void	AddRows (Real alpha, const Real const src)
	Does for each row r, this.Row(r) += alpha * src[r], treating src[r] as the beginning of a region of memory representing a vector of floats, of the same length as this.NumCols(). More...

void	AddToRows (Real alpha, Real const dst) const
	For each row r of this matrix, adds it (times alpha) to the array of floats at the location given by dst[r]. More...

void	AddToRows (Real alpha, const MatrixIndexT indexes, MatrixBase< Real > dst) const
	For each row i of *this, adds this->Row(i) to dst->Row(indexes(i)) if indexes(i) >= 0, else do nothing. More...

void	ApplyPow (Real power)

void	ApplyPowAbs (Real power, bool include_sign=false)

void	ApplyHeaviside ()

void	ApplyFloor (Real floor_val)

void	ApplyCeiling (Real ceiling_val)

void	ApplyExp ()

void	ApplyExpSpecial ()

void	ApplyExpLimited (Real lower_limit, Real upper_limit)

void	ApplyLog ()

void	Eig (MatrixBase< Real > P, VectorBase< Real > eigs_real, VectorBase< Real > *eigs_imag) const
	Eigenvalue Decomposition of a square NxN matrix into the form (*this) = P D P^{-1}. More...

bool	Power (Real pow)
	The Power method attempts to take the matrix to a power using a method that works in general for fractional and negative powers. More...

void	DestructiveSvd (VectorBase< Real > s, MatrixBase< Real > U, MatrixBase< Real > *Vt)
	Singular value decomposition Major limitations: For nonsquare matrices, we assume m>=n (NumRows >= NumCols), and we return the "skinny" Svd, i.e. More...

void	Svd (VectorBase< Real > s, MatrixBase< Real > U, MatrixBase< Real > *Vt) const
	Compute SVD (*this) = U diag(s) Vt. More...

void	Svd (VectorBase< Real > *s) const
	Compute SVD but only retain the singular values. More...

Real	MinSingularValue () const
	Returns smallest singular value. More...

void	TestUninitialized () const

Real	Cond () const
	Returns condition number by computing Svd. More...

bool	IsSymmetric (Real cutoff=1.0e-05) const
	Returns true if matrix is Symmetric. More...

bool	IsDiagonal (Real cutoff=1.0e-05) const
	Returns true if matrix is Diagonal. More...

bool	IsUnit (Real cutoff=1.0e-05) const
	Returns true if the matrix is all zeros, except for ones on diagonal. More...

bool	IsZero (Real cutoff=1.0e-05) const
	Returns true if matrix is all zeros. More...

Real	FrobeniusNorm () const
	Frobenius norm, which is the sqrt of sum of square elements. More...

bool	ApproxEqual (const MatrixBase< Real > &other, float tol=0.01) const
	Returns true if ((this)-other).FrobeniusNorm() <= tol (*this).FrobeniusNorm(). More...

bool	Equal (const MatrixBase< Real > &other) const
	Tests for exact equality. It's usually preferable to use ApproxEqual. More...

Real	LargestAbsElem () const
	largest absolute value. More...

Real	LogSumExp (Real prune=-1.0) const
	Returns log(sum(exp())) without exp overflow If prune > 0.0, it uses a pruning beam, discarding terms less than (max - prune). More...

Real	ApplySoftMax ()
	Apply soft-max to the collection of all elements of the matrix and return normalizer (log sum of exponentials). More...

void	Sigmoid (const MatrixBase< Real > &src)
	Set each element to the sigmoid of the corresponding element of "src". More...

void	Heaviside (const MatrixBase< Real > &src)
	Sets each element to the Heaviside step function (x > 0 ? 1 : 0) of the corresponding element in "src". More...

void	Exp (const MatrixBase< Real > &src)

void	Pow (const MatrixBase< Real > &src, Real power)

void	Log (const MatrixBase< Real > &src)

void	PowAbs (const MatrixBase< Real > &src, Real power, bool include_sign=false)
	Apply power to the absolute value of each element. More...

void	Floor (const MatrixBase< Real > &src, Real floor_val)

void	Ceiling (const MatrixBase< Real > &src, Real ceiling_val)

void	ExpSpecial (const MatrixBase< Real > &src)
	For each element x of the matrix, set it to (x < 0 ? exp(x) : x + 1). More...

void	ExpLimited (const MatrixBase< Real > &src, Real lower_limit, Real upper_limit)
	This is equivalent to running: Floor(src, lower_limit); Ceiling(src, upper_limit); Exp(src) More...

void	SoftHinge (const MatrixBase< Real > &src)
	Set each element to y = log(1 + exp(x)) More...

void	GroupPnorm (const MatrixBase< Real > &src, Real power)
	Apply the function y(i) = (sum_{j = iG}^{(i+1)G-1} x_j^(power))^(1 / p). More...

void	GroupPnormDeriv (const MatrixBase< Real > &input, const MatrixBase< Real > &output, Real power)
	Calculate derivatives for the GroupPnorm function above... More...

void	GroupMax (const MatrixBase< Real > &src)
	Apply the function y(i) = (max_{j = iG}^{(i+1)G-1} x_j Requires src.NumRows() == this->NumRows() and src.NumCols() % this->NumCols() == 0. More...

void	GroupMaxDeriv (const MatrixBase< Real > &input, const MatrixBase< Real > &output)
	Calculate derivatives for the GroupMax function above, where "input" is the input to the GroupMax function above (i.e. More...

void	Tanh (const MatrixBase< Real > &src)
	Set each element to the tanh of the corresponding element of "src". More...

void	DiffSigmoid (const MatrixBase< Real > &value, const MatrixBase< Real > &diff)

void	DiffTanh (const MatrixBase< Real > &value, const MatrixBase< Real > &diff)

void	SymPosSemiDefEig (VectorBase< Real > s, MatrixBase< Real > P, Real check_thresh=0.001)
	Uses Svd to compute the eigenvalue decomposition of a symmetric positive semi-definite matrix: (this) = rP diag(rS) * rP^T, with rP an orthogonal matrix so rP^{-1} = rP^T. More...

void	Add (const Real alpha)
	Add a scalar to each element. More...

void	AddToDiag (const Real alpha)
	Add a scalar to each diagonal element. More...

template<typename OtherReal >
void	AddVecVec (const Real alpha, const VectorBase< OtherReal > &a, const VectorBase< OtherReal > &b)
	this += alpha a * b^T More...

template<typename OtherReal >
void	AddVecToRows (const Real alpha, const VectorBase< OtherReal > &v)
	[each row of this] += alpha v More...

template<typename OtherReal >
void	AddVecToCols (const Real alpha, const VectorBase< OtherReal > &v)
	[each col of this] += alpha v More...

void	AddMat (const Real alpha, const MatrixBase< Real > &M, MatrixTransposeType transA=kNoTrans)
	this += alpha M [or M^T] More...

void	AddSmat (Real alpha, const SparseMatrix< Real > &A, MatrixTransposeType trans=kNoTrans)
	this += alpha A [or A^T]. More...

void	AddSmatMat (Real alpha, const SparseMatrix< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, Real beta)
	(this) = alpha op(A) * B + beta * (*this), where A is sparse. More...

void	AddMatSmat (Real alpha, const MatrixBase< Real > &A, const SparseMatrix< Real > &B, MatrixTransposeType transB, Real beta)
	(this) = alpha A * op(B) + beta * (*this), where B is sparse and op(B) is either B or trans(B) depending on the 'transB' argument. More...

void	SymAddMat2 (const Real alpha, const MatrixBase< Real > &M, MatrixTransposeType transA, Real beta)
	this = beta this + alpha M M^T, for symmetric matrices. More...

void	AddDiagVecMat (const Real alpha, const VectorBase< Real > &v, const MatrixBase< Real > &M, MatrixTransposeType transM, Real beta=1.0)
	this = beta this + alpha diag(v) * M [or M^T]. More...

void	AddMatDiagVec (const Real alpha, const MatrixBase< Real > &M, MatrixTransposeType transM, VectorBase< Real > &v, Real beta=1.0)
	this = beta this + alpha M [or M^T] * diag(v) The same as adding M but scaling each column M_j by v(j). More...

void	AddMatMatElements (const Real alpha, const MatrixBase< Real > &A, const MatrixBase< Real > &B, const Real beta)
	this = beta this + alpha A .* B (.* element by element multiplication) More...

template<typename OtherReal >
void	AddSp (const Real alpha, const SpMatrix< OtherReal > &S)
	this += alpha S More...

void	AddMatMat (const Real alpha, const MatrixBase< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const Real beta)

void	SetMatMatDivMat (const MatrixBase< Real > &A, const MatrixBase< Real > &B, const MatrixBase< Real > &C)
	this = a b / c (by element; when c = 0, *this = a) More...

void	AddMatSmat (const Real alpha, const MatrixBase< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const Real beta)
	A version of AddMatMat specialized for when the second argument contains a lot of zeroes. More...

void	AddSmatMat (const Real alpha, const MatrixBase< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const Real beta)
	A version of AddMatMat specialized for when the first argument contains a lot of zeroes. More...

void	AddMatMatMat (const Real alpha, const MatrixBase< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const MatrixBase< Real > &C, MatrixTransposeType transC, const Real beta)
	this <– betathis + alphaABC. More...

void	AddSpMat (const Real alpha, const SpMatrix< Real > &A, const MatrixBase< Real > &B, MatrixTransposeType transB, const Real beta)
	this <– betathis + alphaSpA*B. More...

void	AddTpMat (const Real alpha, const TpMatrix< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const Real beta)
	this <– betathis + alphaA*B. More...

void	AddMatSp (const Real alpha, const MatrixBase< Real > &A, MatrixTransposeType transA, const SpMatrix< Real > &B, const Real beta)
	this <– betathis + alphaA*B. More...

void	AddSpMatSp (const Real alpha, const SpMatrix< Real > &A, const MatrixBase< Real > &B, MatrixTransposeType transB, const SpMatrix< Real > &C, const Real beta)
	this <– betathis + alphaABC. More...

void	AddMatTp (const Real alpha, const MatrixBase< Real > &A, MatrixTransposeType transA, const TpMatrix< Real > &B, MatrixTransposeType transB, const Real beta)
	this <– betathis + alphaA*B. More...

void	AddTpTp (const Real alpha, const TpMatrix< Real > &A, MatrixTransposeType transA, const TpMatrix< Real > &B, MatrixTransposeType transB, const Real beta)
	this <– betathis + alphaA*B. More...

void	AddSpSp (const Real alpha, const SpMatrix< Real > &A, const SpMatrix< Real > &B, const Real beta)
	this <– betathis + alphaA*B. More...

void	CopyLowerToUpper ()
	Copy lower triangle to upper triangle (symmetrize) More...

void	CopyUpperToLower ()
	Copy upper triangle to lower triangle (symmetrize) More...

void	OrthogonalizeRows ()
	This function orthogonalizes the rows of a matrix using the Gram-Schmidt process. More...

void	Read (std::istream &in, bool binary, bool add=false)
	stream read. More...

void	Write (std::ostream &out, bool binary) const
	write to stream. More...

void	LapackGesvd (VectorBase< Real > s, MatrixBase< Real > U, MatrixBase< Real > *Vt)

template<>
void	AddVecVec (const float alpha, const VectorBase< float > &ra, const VectorBase< float > &rb)

template<>
void	AddVecVec (const double alpha, const VectorBase< double > &ra, const VectorBase< double > &rb)

template<>
void	AddVecVec (const float alpha, const VectorBase< float > &a, const VectorBase< float > &rb)

template<>
void	AddVecVec (const double alpha, const VectorBase< double > &a, const VectorBase< double > &rb)

template<>
void	CopyFromSp (const SpMatrix< float > &M)

template<>
void	CopyFromSp (const SpMatrix< double > &M)

Protected Member Functions
	MatrixBase (Real *data, MatrixIndexT cols, MatrixIndexT rows, MatrixIndexT stride)
	Initializer, callable only from child. More...

	MatrixBase ()
	Initializer, callable only from child. More...

	~MatrixBase ()

Real *	Data_workaround () const
	A workaround that allows SubMatrix to get a pointer to non-const data for const Matrix. More...

Protected Attributes
Real *	data_
	data memory area More...

MatrixIndexT	num_cols_
	these attributes store the real matrix size as it is stored in memory including memalignment More...

MatrixIndexT	num_rows_
	< Number of columns More...

MatrixIndexT	stride_
	< Number of rows More...

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (MatrixBase)

Friends
class	Matrix< Real >

class	CuMatrixBase< Real >

class	CuMatrix< Real >

class	CuSubMatrix< Real >

class	CuPackedMatrix< Real >

class	PackedMatrix< Real >

class	SparseMatrix< Real >

class	SparseMatrix< float >

class	SparseMatrix< double >

class	SubMatrix< Real >

Real	kaldi::TraceMatMat (const MatrixBase< Real > &A, const MatrixBase< Real > &B, MatrixTransposeType trans)

Detailed Description

template<typename Real>
class kaldi::MatrixBase< Real >

Base class which provides matrix operations not involving resizing or allocation.

Classes Matrix and SubMatrix inherit from it and take care of allocation and resizing.

Definition at line 49 of file kaldi-matrix.h.

Constructor & Destructor Documentation

◆ MatrixBase() [1/2]

MatrixBase	(	Real *	data,
		MatrixIndexT	cols,
		MatrixIndexT	rows,
		MatrixIndexT	stride
	)

inlineexplicitprotected

Initializer, callable only from child.

Definition at line 784 of file kaldi-matrix.h.

                                                                                              :
     data_(data), num_cols_(cols), num_rows_(rows), stride_(stride) {
     KALDI_ASSERT_IS_FLOATING_TYPE(Real);
   }

◆ MatrixBase() [2/2]

MatrixBase ( )

inlineexplicitprotected

Initializer, callable only from child.

Empty initializer, for un-initialized matrix.

Definition at line 791 of file kaldi-matrix.h.

                        : data_(NULL) {
     KALDI_ASSERT_IS_FLOATING_TYPE(Real);
   }

◆ ~MatrixBase()

~MatrixBase ( )

inlineprotected

Definition at line 796 of file kaldi-matrix.h.

796 { }

Member Function Documentation

◆ Add()

void Add ( const Real alpha )

Add a scalar to each element.

Definition at line 1677 of file kaldi-matrix.cc.

Referenced by AmSgmm2::ComponentPosteriors(), AmSgmm2::LogLikelihood(), kaldi::UnitTestApplyExpSpecial(), kaldi::UnitTestCompressedMatrix(), kaldi::UnitTestCuMatrixAdd(), kaldi::UnitTestCuMatrixAdd2(), kaldi::UnitTestCuMatrixApplyLog(), kaldi::UnitTestCuMatrixDivElements(), kaldi::UnitTestGeneralMatrix(), kaldi::UnitTestSetRandUniform(), and kaldi::UnitTestSimpleForMat().

                                            {
   Real *data = data_;
   MatrixIndexT stride = stride_;
   for (MatrixIndexT r = 0; r < num_rows_; r++)
     for (MatrixIndexT c = 0; c < num_cols_; c++)
       data[c + stride*r] += alpha;
 }

◆ AddCols()

void AddCols	(	const MatrixBase< Real > &	src,
		const MatrixIndexT *	indices
	)

Add column indices[r] of src to column r.

As a special case, if indexes[i] == -1, skip column i indices.size() must equal this->NumCols(), all elements of "reorder" must be in [-1, src.NumCols()-1], and src.NumRows() must equal this.NumRows()

Definition at line 2852 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange().

                                                             {
   KALDI_ASSERT(NumRows() == src.NumRows());
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       this_stride = stride_, src_stride = src.stride_;
   Real *this_data = this->data_;
   const Real *src_data = src.data_;
 #ifdef KALDI_PARANOID
   MatrixIndexT src_cols = src.NumCols();
   for (MatrixIndexT i = 0; i < num_cols; i++)
     KALDI_ASSERT(indices[i] >= -1 && indices[i] < src_cols);
 #endif
 
   // For the sake of memory locality we do this row by row, rather
   // than doing it column-wise using cublas_Xcopy
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride, src_data += src_stride) {
     const MatrixIndexT *index_ptr = &(indices[0]);
     for (MatrixIndexT c = 0; c < num_cols; c++, index_ptr++) {
       if (*index_ptr >= 0)
         this_data[c] += src_data[*index_ptr];
     }
   }
 }

◆ AddDiagVecMat()

void AddDiagVecMat	(	const Real	alpha,
		const VectorBase< Real > &	v,
		const MatrixBase< Real > &	M,
		MatrixTransposeType	transM,
		Real	beta = `1.0`
	)

*this = beta * *this + alpha * diag(v) * M [or M^T].

The same as adding M but scaling each row M_i by v(i).

Definition at line 576 of file kaldi-matrix.cc.

Referenced by kaldi::ComputeNormalizingTransform(), kaldi::UnitTestCuDiffNormalizePerRow(), and kaldi::UnitTestCuDiffSoftmax().

                {
   if (beta != 1.0) this->Scale(beta);
 
   if (transM == kNoTrans) {
     KALDI_ASSERT(SameDim(*this, M));
   } else {
     KALDI_ASSERT(M.NumRows() == NumCols() && M.NumCols() == NumRows());
   }
   KALDI_ASSERT(v.Dim() == this->NumRows());
 
   MatrixIndexT M_row_stride = M.Stride(), M_col_stride = 1, stride = stride_,
       num_rows = num_rows_, num_cols = num_cols_;
   if (transM == kTrans) std::swap(M_row_stride, M_col_stride);
   Real *data = data_;
   const Real *Mdata = M.Data(), *vdata = v.Data();
   if (num_rows_ == 0) return;
   for (MatrixIndexT i = 0; i < num_rows; i++, data += stride, Mdata += M_row_stride, vdata++)
     cblas_Xaxpy(num_cols, alpha * *vdata, Mdata, M_col_stride, data, 1);
 }

◆ AddMat()

void AddMat	(	const Real	alpha,
		const MatrixBase< Real > &	M,
		MatrixTransposeType	transA = `kNoTrans`
	)

*this += alpha * M [or M^T]

Definition at line 356 of file kaldi-matrix.cc.

Referenced by Fmpe::AccStats(), BasisFmllrAccus::AccuGradientScatter(), AffineXformStats::Add(), AccumDiagGmm::Add(), IvectorExtractorStats::Add(), CuMatrixBase< float >::AddMatBlocks(), GeneralMatrix::AddToMat(), MatrixBase< float >::ApproxEqual(), kaldi::CalBasisFmllrStepSize(), kaldi::CalcFmllrStepSize(), MleAmSgmm2Updater::ComputeMPrior(), MleAmSgmm2Updater::ComputeSMeans(), BasisFmllrEstimate::ComputeTransform(), kaldi::FmllrAuxfGradient(), FmllrSgmm2Accs::FmllrObjGradient(), LogisticRegression::GetObjfAndGrad(), IvectorExtractorStats::GetOrthogonalIvectorTransform(), MleAmSgmm2Updater::MapUpdateM(), DiagGmm::Perturb(), AffineXformStats::Read(), AccumFullGmm::Read(), LdaEstimate::Read(), OnlineCmvn::SmoothOnlineCmvnStats(), AccumDiagGmm::SmoothWithModel(), kaldi::SolveQuadraticMatrixProblem(), MatrixBase< float >::SymPosSemiDefEig(), test_io(), kaldi::TestFmpe(), kaldi::TypeOneUsage(), kaldi::TypeOneUsageAverage(), kaldi::TypeThreeUsage(), kaldi::UnitTestAddMatDiagVec(), kaldi::UnitTestAddMatMatElements(), kaldi::UnitTestAddMatSelf(), kaldi::UnitTestAddOuterProductPlusMinus(), kaldi::UnitTestAxpy(), kaldi::UnitTestCompressedMatrix(), kaldi::UnitTestCuDiffLogSoftmax(), kaldi::UnitTestCuMatrixAddMat(), kaldi::UnitTestDeterminant(), kaldi::UnitTestGeneralMatrix(), kaldi::UnitTestSparseMatrixAddToMat(), FmllrSgmm2Accs::Update(), EbwAmSgmm2Updater::UpdateM(), EbwAmSgmm2Updater::UpdateN(), IvectorExtractorStats::UpdateVariances(), MleAmSgmm2Updater::UpdateW(), and MleAmSgmm2Updater::UpdateWGetStats().

                                                            {
   if (&A == this) {
     if (transA == kNoTrans) {
       Scale(alpha + 1.0);
     } else {
       KALDI_ASSERT(num_rows_ == num_cols_ && "AddMat: adding to self (transposed): not symmetric.");
       Real *data = data_;
       if (alpha == 1.0) {  // common case-- handle separately.
         for (MatrixIndexT row = 0; row < num_rows_; row++) {
           for (MatrixIndexT col = 0; col < row; col++) {
             Real *lower = data + (row * stride_) + col, *upper = data + (col
                                                                           * stride_) + row;
             Real sum = *lower + *upper;
             *lower = *upper = sum;
           }
           *(data + (row * stride_) + row) *= 2.0;  // diagonal.
         }
       } else {
         for (MatrixIndexT row = 0; row < num_rows_; row++) {
           for (MatrixIndexT col = 0; col < row; col++) {
             Real *lower = data + (row * stride_) + col, *upper = data + (col
                                                                           * stride_) + row;
             Real lower_tmp = *lower;
             *lower += alpha * *upper;
             *upper += alpha * lower_tmp;
           }
           *(data + (row * stride_) + row) *= (1.0 + alpha);  // diagonal.
         }
       }
     }
   } else {
     int aStride = (int) A.stride_, stride = stride_;
     Real *adata = A.data_, *data = data_;
     if (transA == kNoTrans) {
       KALDI_ASSERT(A.num_rows_ == num_rows_ && A.num_cols_ == num_cols_);
       if (num_rows_ == 0) return;
       for (MatrixIndexT row = 0; row < num_rows_; row++, adata += aStride,
                data += stride) {
         cblas_Xaxpy(num_cols_, alpha, adata, 1, data, 1);
       }
     } else {
       KALDI_ASSERT(A.num_cols_ == num_rows_ && A.num_rows_ == num_cols_);
       if (num_rows_ == 0) return;
       for (MatrixIndexT row = 0; row < num_rows_; row++, adata++, data += stride)
         cblas_Xaxpy(num_cols_, alpha, adata, aStride, data, 1);
     }
   }
 }

◆ AddMatDiagVec()

void AddMatDiagVec	(	const Real	alpha,
		const MatrixBase< Real > &	M,
		MatrixTransposeType	transM,
		VectorBase< Real > &	v,
		Real	beta = `1.0`
	)

*this = beta * *this + alpha * M [or M^T] * diag(v) The same as adding M but scaling each column M_j by v(j).

Definition at line 601 of file kaldi-matrix.cc.

                {
 
   if (beta != 1.0) this->Scale(beta);
 
   if (transM == kNoTrans) {
     KALDI_ASSERT(SameDim(*this, M));
   } else {
     KALDI_ASSERT(M.NumRows() == NumCols() && M.NumCols() == NumRows());
   }
   KALDI_ASSERT(v.Dim() == this->NumCols());
 
   MatrixIndexT M_row_stride = M.Stride(),
                M_col_stride = 1,
                stride = stride_,
                num_rows = num_rows_,
                num_cols = num_cols_;
 
   if (transM == kTrans)
     std::swap(M_row_stride, M_col_stride);
 
   Real *data = data_;
   const Real *Mdata = M.Data(), *vdata = v.Data();
   if (num_rows_ == 0) return;
   for (MatrixIndexT i = 0; i < num_rows; i++){
       for(MatrixIndexT j = 0; j < num_cols; j ++ ){
           data[i*stride + j] += alpha * vdata[j] * Mdata[i*M_row_stride + j*M_col_stride];
       }
   }
 }

◆ AddMatMat()

void AddMatMat	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

Definition at line 171 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddMatMatMat(), MatrixBase< float >::AddMatSp(), MatrixBase< float >::AddMatTp(), MatrixBase< float >::AddSpMat(), MatrixBase< float >::AddTpMat(), MatrixBase< float >::AddTpTp(), kaldi::ApplyFeatureTransformToStats(), kaldi::ApplyInvPreXformToChange(), kaldi::ApplyPca(), kaldi::ApplyPreXformToGradient(), Sgmm2Project::ApplyProjection(), Fmpe::ApplyProjection(), Plda::ApplyTransform(), kaldi::CalBasisFmllrStepSize(), kaldi::CalcFmllrStepSize(), kaldi::CholeskyUnitTestTr(), kaldi::ComposeTransforms(), kaldi::ComputeFeatureNormalizingTransform(), AmSgmm2::ComputeFmllrPreXform(), kaldi::ComputeLdaTransform(), AmSgmm2::ComputeNormalizersInternal(), kaldi::ComputePca(), MleAmSgmm2Updater::ComputeSMeans(), LogisticRegression::DoStep(), LdaEstimate::Estimate(), FeatureTransformEstimate::EstimateInternal(), FeatureTransformEstimateMulti::EstimateTransformPart(), IvectorExtractorStats::FlushCache(), kaldi::generate_features(), OnlineTransform::GetFrames(), LogisticRegression::GetLogPosteriors(), PldaEstimator::GetOutput(), DiagGmm::LogLikelihoods(), main(), kaldi::nnet3::PerturbImage(), MatrixBase< float >::Power(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), kaldi::nnet3::ReduceRankOfComponents(), MleAmSgmm2Updater::RenormalizeN(), MleAmSgmm2Updater::RenormalizeV(), kaldi::SlowMatMul(), kaldi::SolveDoubleQuadraticMatrixProblem(), kaldi::SolveQuadraticMatrixProblem(), kaldi::TestOnlineLdaInput(), TestSgmm2PreXform(), SpMatrix< float >::TopEigs(), kaldi::TraceMatMatMat(), kaldi::TraceMatMatMatMat(), kaldi::TraceMatSpMat(), IvectorExtractor::TransformIvectors(), OnlineLdaInput::TransformToOutput(), kaldi::UnitInvert(), kaldi::UnitTestAddDiagMat2(), kaldi::UnitTestAddDiagMatMat(), kaldi::UnitTestAddMat2Sp(), kaldi::UnitTestAddMatMatNans(), kaldi::UnitTestAddMatMatSpeed(), kaldi::UnitTestCholesky(), kaldi::UnitTestCuMatrixAddMatMat(), kaldi::UnitTestDct(), kaldi::UnitTestDeterminant(), kaldi::UnitTestDeterminantSign(), kaldi::UnitTestEig(), kaldi::UnitTestEigSymmetric(), UnitTestEstimateFullGmm(), kaldi::UnitTestInverse(), kaldi::UnitTestInvert(), kaldi::UnitTestLimitCondInvert(), kaldi::UnitTestMatrixAddMatSmat(), kaldi::UnitTestMatrixAddSmatMat(), kaldi::UnitTestMmul(), kaldi::UnitTestNonsymmetricPower(), kaldi::UnitTestOrthogonalizeRows(), kaldi::UnitTestPca(), kaldi::UnitTestPldaEstimation(), kaldi::UnitTestPower(), kaldi::UnitTestRankNUpdate(), kaldi::UnitTestSpInvert(), kaldi::UnitTestSvdNodestroy(), kaldi::UnitTestSymAddMat2(), kaldi::UnitTestTopEigs(), kaldi::UnitTestTpInvert(), kaldi::UnitTestTrace(), kaldi::UnitTestTrain(), kaldi::UnitTestTransposeScatter(), PldaUnsupervisedAdaptor::UpdatePlda(), IvectorExtractorStats::UpdatePrior(), IvectorExtractorStats::UpdateVariances(), MleAmSgmm2Updater::UpdateW(), and MleAmSgmm2Updater::UpdateWGetStats().

                                                    {
   KALDI_ASSERT((transA == kNoTrans && transB == kNoTrans && A.num_cols_ == B.num_rows_ && A.num_rows_ == num_rows_ && B.num_cols_ == num_cols_)
                || (transA == kTrans && transB == kNoTrans && A.num_rows_ == B.num_rows_ && A.num_cols_ == num_rows_ && B.num_cols_ == num_cols_)
                || (transA == kNoTrans && transB == kTrans && A.num_cols_ == B.num_cols_ && A.num_rows_ == num_rows_ && B.num_rows_ == num_cols_)
                || (transA == kTrans && transB == kTrans && A.num_rows_ == B.num_cols_ && A.num_cols_ == num_rows_ && B.num_rows_ == num_cols_));
   KALDI_ASSERT(&A !=  this && &B != this);
   if (num_rows_ == 0) return;
   cblas_Xgemm(alpha, transA, A.data_, A.num_rows_, A.num_cols_, A.stride_,
               transB, B.data_, B.stride_, beta, data_, num_rows_, num_cols_, stride_);
 
 }

◆ AddMatMatElements()

void AddMatMatElements	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		const MatrixBase< Real > &	B,
		const Real	beta
	)

*this = beta * *this + alpha * A .* B (.* element by element multiplication)

Definition at line 636 of file kaldi-matrix.cc.

                                                           {
     KALDI_ASSERT(A.NumRows() == B.NumRows() && A.NumCols() == B.NumCols());
     KALDI_ASSERT(A.NumRows() == NumRows() && A.NumCols() == NumCols());
     Real *data = data_;
     const Real *dataA = A.Data();
     const Real *dataB = B.Data();
 
     for (MatrixIndexT i = 0; i < num_rows_; i++) {
         for (MatrixIndexT j = 0; j < num_cols_; j++) {
             data[j] = beta*data[j] + alpha*dataA[j]*dataB[j];
         }
         data += Stride();
         dataA += A.Stride();
         dataB += B.Stride();
     }
 }

◆ AddMatMatMat()

void AddMatMatMat	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const MatrixBase< Real > &	C,
		MatrixTransposeType	transC,
		const Real	beta
	)

this <– beta*this + alpha*A*B*C.

Definition at line 1741 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddSpMatSp(), kaldi::nnet3::PerturbImage(), UnitTestEstimateLda(), kaldi::UnitTestSvd(), and kaldi::UnitTestTrace().

                                                {
   // Note on time taken with different orders of computation.  Assume not transposed in this /
   // discussion. Firstly, normalize expressions using A.NumCols == B.NumRows and B.NumCols == C.NumRows, prefer
   // rows where there is a choice.
   // time taken for (AB) is:  A.NumRows*B.NumRows*C.Rows
   // time taken for (AB)C is A.NumRows*C.NumRows*C.Cols
   // so this order is A.NumRows*B.NumRows*C.NumRows + A.NumRows*C.NumRows*C.NumCols.
 
   // time taken for (BC) is: B.NumRows*C.NumRows*C.Cols
   // time taken for A(BC) is: A.NumRows*B.NumRows*C.Cols
   // so this order is B.NumRows*C.NumRows*C.NumCols + A.NumRows*B.NumRows*C.Cols
 
   MatrixIndexT ARows = A.num_rows_, ACols = A.num_cols_, BRows = B.num_rows_, BCols = B.num_cols_,
       CRows = C.num_rows_, CCols = C.num_cols_;
   if (transA == kTrans) std::swap(ARows, ACols);
   if (transB == kTrans) std::swap(BRows, BCols);
   if (transC == kTrans) std::swap(CRows, CCols);
 
   MatrixIndexT AB_C_time = ARows*BRows*CRows + ARows*CRows*CCols;
   MatrixIndexT A_BC_time = BRows*CRows*CCols + ARows*BRows*CCols;
 
   if (AB_C_time < A_BC_time) {
     Matrix<Real> AB(ARows, BCols);
     AB.AddMatMat(1.0, A, transA, B, transB, 0.0);  // AB = A * B.
     (*this).AddMatMat(alpha, AB, kNoTrans, C, transC, beta);
   } else {
     Matrix<Real> BC(BRows, CCols);
     BC.AddMatMat(1.0, B, transB, C, transC, 0.0);  // BC = B * C.
     (*this).AddMatMat(alpha, A, transA, BC, kNoTrans, beta);
   }
 }

◆ AddMatSmat() [1/2]

void AddMatSmat	(	Real	alpha,
		const MatrixBase< Real > &	A,
		const SparseMatrix< Real > &	B,
		MatrixTransposeType	transB,
		Real	beta
	)

(*this) = alpha * A * op(B) + beta * (*this), where B is sparse and op(B) is either B or trans(B) depending on the 'transB' argument.

This is multiplication of a dense by a sparse matrix. See also AddSmatMat.

Definition at line 491 of file kaldi-matrix.cc.

Referenced by kaldi::UnitTestMatrixAddMatSmat(), and kaldi::UnitTextCuMatrixAddMatSmat().

                                                                          {
   if (transB == kNoTrans) {
     KALDI_ASSERT(NumRows() == A.NumRows());
     KALDI_ASSERT(NumCols() == B.NumCols());
     KALDI_ASSERT(A.NumCols() == B.NumRows());
 
     this->Scale(beta);
     MatrixIndexT b_num_rows = B.NumRows(),
         this_num_rows = this->NumRows();
     // Iterate over the rows of sparse matrix B and columns of A.
     for (MatrixIndexT k = 0; k < b_num_rows; ++k) {
       const SparseVector<Real> &B_row_k = B.Row(k);
       MatrixIndexT num_elems = B_row_k.NumElements();
       const Real *a_col_k = A.Data() + k;
       for (MatrixIndexT e = 0; e < num_elems; ++e) {
         const std::pair<MatrixIndexT, Real> &p = B_row_k.GetElement(e);
         MatrixIndexT j = p.first;
         Real alpha_B_kj = alpha * p.second;
         Real *this_col_j = this->Data() + j;
         // Add to entire 'j'th column of *this at once using cblas_Xaxpy.
         // pass stride to write a colmun as matrices are stored in row major order.
         cblas_Xaxpy(this_num_rows, alpha_B_kj, a_col_k, A.stride_,
                     this_col_j, this->stride_);
         //for (MatrixIndexT i = 0; i < this_num_rows; ++i)
         // this_col_j[i*this->stride_] +=  alpha_B_kj * a_col_k[i*A.stride_];
       }
     }
   } else {
     KALDI_ASSERT(NumRows() == A.NumRows());
     KALDI_ASSERT(NumCols() == B.NumRows());
     KALDI_ASSERT(A.NumCols() == B.NumCols());
 
     this->Scale(beta);
     MatrixIndexT b_num_rows = B.NumRows(),
         this_num_rows = this->NumRows();
     // Iterate over the rows of sparse matrix B and columns of *this.
     for (MatrixIndexT j = 0; j < b_num_rows; ++j) {
       const SparseVector<Real> &B_row_j = B.Row(j);
       MatrixIndexT num_elems = B_row_j.NumElements();
       Real *this_col_j = this->Data() + j;
       for (MatrixIndexT e = 0; e < num_elems; ++e) {
         const std::pair<MatrixIndexT, Real> &p = B_row_j.GetElement(e);
         MatrixIndexT k = p.first;
         Real alpha_B_jk = alpha * p.second;
         const Real *a_col_k = A.Data() + k;
         // Add to entire 'j'th column of *this at once using cblas_Xaxpy.
         // pass stride to write a column as matrices are stored in row major order.
         cblas_Xaxpy(this_num_rows, alpha_B_jk, a_col_k, A.stride_,
                     this_col_j, this->stride_);
         //for (MatrixIndexT i = 0; i < this_num_rows; ++i) 
         // this_col_j[i*this->stride_] +=  alpha_B_jk * a_col_k[i*A.stride_];
       }
     }
   }
 }

◆ AddMatSmat() [2/2]

void AddMatSmat	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

A version of AddMatMat specialized for when the second argument contains a lot of zeroes.

Definition at line 267 of file kaldi-matrix.cc.

                                                    {
   KALDI_ASSERT((transA == kNoTrans && transB == kNoTrans && A.num_cols_ == B.num_rows_ && A.num_rows_ == num_rows_ && B.num_cols_ == num_cols_)
                || (transA == kTrans && transB == kNoTrans && A.num_rows_ == B.num_rows_ && A.num_cols_ == num_rows_ && B.num_cols_ == num_cols_)
                || (transA == kNoTrans && transB == kTrans && A.num_cols_ == B.num_cols_ && A.num_rows_ == num_rows_ && B.num_rows_ == num_cols_)
                || (transA == kTrans && transB == kTrans && A.num_rows_ == B.num_cols_ && A.num_cols_ == num_rows_ && B.num_rows_ == num_cols_));
   KALDI_ASSERT(&A !=  this && &B != this);
 
   // We iterate over the columns of B.
 
   MatrixIndexT Astride = A.stride_, Bstride = B.stride_, stride = this->stride_,
       Arows = A.num_rows_, Acols = A.num_cols_;
   Real *data = this->data_, *Adata = A.data_, *Bdata = B.data_;
   MatrixIndexT num_cols = this->num_cols_;
   if (transB == kNoTrans) {
     // Iterate over the columns of *this and of B.
     for (MatrixIndexT c = 0; c < num_cols; c++) {
       // for each column of *this, do
       // [this column] = [alpha * A * this column of B] + [beta * this column]
       Xgemv_sparsevec(transA, Arows, Acols, alpha, Adata, Astride,
                       Bdata + c, Bstride, beta, data + c, stride);
     }
   } else {
     // Iterate over the columns of *this and the rows of B.
     for (MatrixIndexT c = 0; c < num_cols; c++) {
       // for each column of *this, do
       // [this column] = [alpha * A * this row of B] + [beta * this column]
       Xgemv_sparsevec(transA, Arows, Acols, alpha, Adata, Astride,
                       Bdata + (c * Bstride), 1, beta, data + c, stride);
     }
   }
 }

◆ AddMatSp()

void AddMatSp	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		MatrixTransposeType	transA,
		const SpMatrix< Real > &	B,
		const Real	beta
	)

inline

this <– beta*this + alpha*A*B.

Definition at line 708 of file kaldi-matrix.h.

Referenced by AmSgmm2::ComputeNormalizersInternal(), MleAmSgmm2Updater::MapUpdateM(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), kaldi::TraceMatSpMatSp(), kaldi::UnitTestAddMat2Sp(), kaldi::UnitTestSolve(), EbwAmSgmm2Updater::UpdateM(), and EbwAmSgmm2Updater::UpdateN().

                                  {
     Matrix<Real> M(B);
     return AddMatMat(alpha, A, transA, M, kNoTrans, beta);
   }

◆ AddMatTp()

void AddMatTp	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		MatrixTransposeType	transA,
		const TpMatrix< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

inline

this <– beta*this + alpha*A*B.

Definition at line 725 of file kaldi-matrix.h.

Referenced by IvectorExtractorStats::CommitStatsForW(), Sgmm2Project::ComputeLdaTransform(), kaldi::UnitTestCuMatrixAddMatTp(), and PldaUnsupervisedAdaptor::UpdatePlda().

                                  {
     Matrix<Real> M(B);
     return AddMatMat(alpha, A, transA, M, transB, beta);
   }

◆ AddRows() [1/2]

void AddRows	(	Real	alpha,
		const MatrixBase< Real > &	src,
		const MatrixIndexT *	indexes
	)

Does for each row r, this.Row(r) += alpha * src.row(indexes[r]).

If indexes[r] < 0, does not add anything. all elements of "indexes" must be in [-1, src.NumRows()-1], and src.NumCols() must equal this.NumCols().

Definition at line 2918 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange().

                                                             {
   KALDI_ASSERT(NumCols() == src.NumCols());
   MatrixIndexT num_rows = num_rows_,
       num_cols = num_cols_, this_stride = stride_;
   Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     MatrixIndexT index = indexes[r];
     KALDI_ASSERT(index >= -1 && index < src.NumRows());
     if (index != -1)
       cblas_Xaxpy(num_cols, alpha, src.RowData(index), 1, this_data, 1);
   }
 }

◆ AddRows() [2/2]

void AddRows	(	Real	alpha,
		const Real const	src
	)

Does for each row r, this.Row(r) += alpha * src[r], treating src[r] as the beginning of a region of memory representing a vector of floats, of the same length as this.NumCols().

If src[r] is NULL, does not add anything.

Definition at line 2935 of file kaldi-matrix.cc.

                                                                  {
   MatrixIndexT num_rows = num_rows_,
       num_cols = num_cols_, this_stride = stride_;
   Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     const Real *const src_data = src[r];
     if (src_data != NULL)
       cblas_Xaxpy(num_cols, alpha, src_data, 1, this_data, 1);
   }
 }

◆ AddSmat()

void AddSmat	(	Real	alpha,
		const SparseMatrix< Real > &	A,
		MatrixTransposeType	trans = `kNoTrans`
	)

*this += alpha * A [or A^T].

Definition at line 407 of file kaldi-matrix.cc.

Referenced by kaldi::UnitTextCuMatrixAddSmat().

                                                           {
   if (trans == kNoTrans) {
     KALDI_ASSERT(NumRows() == A.NumRows());
     KALDI_ASSERT(NumCols() == A.NumCols());
     MatrixIndexT a_num_rows = A.NumRows();
     for (MatrixIndexT i = 0; i < a_num_rows; ++i) {
       const SparseVector<Real> &row = A.Row(i);
       MatrixIndexT num_elems = row.NumElements();
       for (MatrixIndexT id = 0; id < num_elems; ++id) {
         (*this)(i, row.GetElement(id).first) += alpha
             * row.GetElement(id).second;
       }
     }
   } else {
     KALDI_ASSERT(NumRows() == A.NumCols());
     KALDI_ASSERT(NumCols() == A.NumRows());
     MatrixIndexT a_num_rows = A.NumRows();
     for (MatrixIndexT i = 0; i < a_num_rows; ++i) {
       const SparseVector<Real> &row = A.Row(i);
       MatrixIndexT num_elems = row.NumElements();
       for (MatrixIndexT id = 0; id < num_elems; ++id) {
         (*this)(row.GetElement(id).first, i) += alpha
             * row.GetElement(id).second;
       }
     }
   }
 }

◆ AddSmatMat() [1/2]

void AddSmatMat	(	Real	alpha,
		const SparseMatrix< Real > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< Real > &	B,
		Real	beta
	)

(*this) = alpha * op(A) * B + beta * (*this), where A is sparse.

Multiplication of sparse with dense matrix. See also AddMatSmat.

Definition at line 437 of file kaldi-matrix.cc.

Referenced by SpMatrix< float >::AddSmat2Sp(), kaldi::UnitTestAddMatSmat(), kaldi::UnitTestMatrixAddSmatMat(), and kaldi::UnitTextCuMatrixAddSmatMat().

                                                                         {
   if (transA == kNoTrans) {
     KALDI_ASSERT(NumRows() == A.NumRows());
     KALDI_ASSERT(NumCols() == B.NumCols());
     KALDI_ASSERT(A.NumCols() == B.NumRows());
 
     this->Scale(beta);
     MatrixIndexT a_num_rows = A.NumRows(),
         this_num_cols = this->NumCols();
     for (MatrixIndexT i = 0; i < a_num_rows; ++i) {
       Real *this_row_i = this->RowData(i);
       const SparseVector<Real> &A_row_i = A.Row(i);
       MatrixIndexT num_elems = A_row_i.NumElements();
       for (MatrixIndexT e = 0; e < num_elems; ++e) {
         const std::pair<MatrixIndexT, Real> &p = A_row_i.GetElement(e);
         MatrixIndexT k = p.first;
         Real alpha_A_ik = alpha * p.second;
         const Real *b_row_k = B.RowData(k);
         cblas_Xaxpy(this_num_cols, alpha_A_ik, b_row_k, 1,
                     this_row_i, 1);
         //for (MatrixIndexT j = 0; j < this_num_cols; ++j)
         //  this_row_i[j] += alpha_A_ik * b_row_k[j];
       }
     }
   } else {
     KALDI_ASSERT(NumRows() == A.NumCols());
     KALDI_ASSERT(NumCols() == B.NumCols());
     KALDI_ASSERT(A.NumRows() == B.NumRows());
 
     this->Scale(beta);
     Matrix<Real> buf(NumRows(), NumCols(), kSetZero);
     MatrixIndexT a_num_rows = A.NumRows(),
         this_num_cols = this->NumCols();
     for (int k = 0; k < a_num_rows; ++k) {
       const Real *b_row_k = B.RowData(k);
       const SparseVector<Real> &A_row_k = A.Row(k);
       MatrixIndexT num_elems = A_row_k.NumElements();
       for (MatrixIndexT e = 0; e < num_elems; ++e) {
         const std::pair<MatrixIndexT, Real> &p = A_row_k.GetElement(e);
         MatrixIndexT i = p.first;
         Real alpha_A_ki = alpha * p.second;
         Real *this_row_i = this->RowData(i);
         cblas_Xaxpy(this_num_cols, alpha_A_ki, b_row_k, 1,
                     this_row_i, 1);
         //for (MatrixIndexT j = 0; j < this_num_cols; ++j)
         // this_row_i[j] += alpha_A_ki * b_row_k[j];
       }
     }
   }
 }

◆ AddSmatMat() [2/2]

void AddSmatMat	(	const Real	alpha,
		const MatrixBase< Real > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

A version of AddMatMat specialized for when the first argument contains a lot of zeroes.

Definition at line 305 of file kaldi-matrix.cc.

                                                    {
   KALDI_ASSERT((transA == kNoTrans && transB == kNoTrans && A.num_cols_ == B.num_rows_ && A.num_rows_ == num_rows_ && B.num_cols_ == num_cols_)
                || (transA == kTrans && transB == kNoTrans && A.num_rows_ == B.num_rows_ && A.num_cols_ == num_rows_ && B.num_cols_ == num_cols_)
                || (transA == kNoTrans && transB == kTrans && A.num_cols_ == B.num_cols_ && A.num_rows_ == num_rows_ && B.num_rows_ == num_cols_)
                || (transA == kTrans && transB == kTrans && A.num_rows_ == B.num_cols_ && A.num_cols_ == num_rows_ && B.num_rows_ == num_cols_));
   KALDI_ASSERT(&A !=  this && &B != this);
 
   MatrixIndexT Astride = A.stride_, Bstride = B.stride_, stride = this->stride_,
       Brows = B.num_rows_, Bcols = B.num_cols_;
   MatrixTransposeType invTransB = (transB == kTrans ? kNoTrans : kTrans);
   Real *data = this->data_, *Adata = A.data_, *Bdata = B.data_;
   MatrixIndexT num_rows = this->num_rows_;
   if (transA == kNoTrans) {
     // Iterate over the rows of *this and of A.
     for (MatrixIndexT r = 0; r < num_rows; r++) {
       // for each row of *this, do
       // [this row] = [alpha * (this row of A) * B^T] + [beta * this row]
       Xgemv_sparsevec(invTransB, Brows, Bcols, alpha, Bdata, Bstride,
                       Adata + (r * Astride), 1, beta, data + (r * stride), 1);
     }
   } else {
     // Iterate over the rows of *this and the columns of A.
     for (MatrixIndexT r = 0; r < num_rows; r++) {
       // for each row of *this, do
       // [this row] = [alpha * (this column of A) * B^T] + [beta * this row]
       Xgemv_sparsevec(invTransB, Brows, Bcols, alpha, Bdata, Bstride,
                       Adata + r, Astride, beta, data + (r * stride), 1);
     }
   }
 }

◆ AddSp()

template void AddSp	(	const Real	alpha,
		const SpMatrix< OtherReal > &	S
	)

*this += alpha * S

Definition at line 551 of file kaldi-matrix.cc.

Referenced by RegtreeFmllrDiagGmmAccs::AccumulateForGmm(), and kaldi::UnitTestAddSp().

                                                                            {
   KALDI_ASSERT(S.NumRows() == NumRows() && S.NumRows() == NumCols());
   Real *data = data_; const OtherReal *sdata = S.Data();
   MatrixIndexT num_rows = NumRows(), stride = Stride();
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     for (MatrixIndexT j = 0; j < i; j++, sdata++) {
       data[i*stride + j] += alpha * *sdata;
       data[j*stride + i] += alpha * *sdata;
     }
     data[i*stride + i] += alpha * *sdata++;
   }
 }

◆ AddSpMat()

void AddSpMat	(	const Real	alpha,
		const SpMatrix< Real > &	A,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

inline

this <– beta*this + alpha*SpA*B.

Definition at line 692 of file kaldi-matrix.h.

Referenced by FmllrSgmm2Accs::FmllrObjGradient(), and MleAmSgmm2Updater::MapUpdateM().

                                  {
     Matrix<Real> M(A);
     return AddMatMat(alpha, M, kNoTrans, B, transB, beta);
   }

◆ AddSpMatSp()

void AddSpMatSp	(	const Real	alpha,
		const SpMatrix< Real > &	A,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const SpMatrix< Real > &	C,
		const Real	beta
	)

inline

this <– beta*this + alpha*A*B*C.

Definition at line 716 of file kaldi-matrix.h.

                                  {
     Matrix<Real> M(A), N(C);
     return AddMatMatMat(alpha, M, kNoTrans, B, transB, N, kNoTrans, beta);
   }

◆ AddSpSp()

void AddSpSp	(	const Real	alpha,
		const SpMatrix< Real > &	A,
		const SpMatrix< Real > &	B,
		const Real	beta
	)

this <– beta*this + alpha*A*B.

Definition at line 342 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp(), and kaldi::UnitTestMmulSym().

                                                                              {
   MatrixIndexT sz = num_rows_;
   KALDI_ASSERT(sz == num_cols_ && sz == A_in.NumRows() && sz == B_in.NumRows());
 
   Matrix<Real> A(A_in), B(B_in);
   // CblasLower or CblasUpper would work below as symmetric matrix is copied
   // fully (to save work, we used the matrix constructor from SpMatrix).
   // CblasLeft means A is on the left: C <-- alpha A B + beta C
   if (sz == 0) return;
   cblas_Xsymm(alpha, sz, A.data_, A.stride_, B.data_, B.stride_, beta, data_, stride_);
 }

◆ AddToDiag()

void AddToDiag ( const Real alpha )

Add a scalar to each diagonal element.

Definition at line 1686 of file kaldi-matrix.cc.

Referenced by kaldi::UnitTestCuMatrixAddToDiag().

                                                  {
   Real *data = data_;
   MatrixIndexT this_stride = stride_ + 1,
       num_to_add = std::min(num_rows_, num_cols_);
   for (MatrixIndexT r = 0; r < num_to_add; r++)
     data[r * this_stride] += alpha;
 }

◆ AddToRows() [1/2]

void AddToRows	(	Real	alpha,
		Real const	dst
	)		const

For each row r of this matrix, adds it (times alpha) to the array of floats at the location given by dst[r].

If dst[r] is NULL, does not do anything for that row. Requires that none of the memory regions pointed to by the pointers in "dst" overlap (e.g. none of the pointers should be the same).

Definition at line 2965 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), and kaldi::UnitTestAddToRows().

                                                                    {
   MatrixIndexT num_rows = num_rows_,
       num_cols = num_cols_, this_stride = stride_;
   const Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     Real *const dst_data = dst[r];
     if (dst_data != NULL)
       cblas_Xaxpy(num_cols, alpha, this_data, 1, dst_data, 1);
   }
 }

◆ AddToRows() [2/2]

void AddToRows	(	Real	alpha,
		const MatrixIndexT *	indexes,
		MatrixBase< Real > *	dst
	)		const

For each row i of *this, adds this->Row(i) to dst->Row(indexes(i)) if indexes(i) >= 0, else do nothing.

Requires that all the indexes[i] that are >= 0 be distinct, otherwise the behavior is undefined.

Definition at line 2948 of file kaldi-matrix.cc.

                                                               {
   KALDI_ASSERT(NumCols() == dst->NumCols());
   MatrixIndexT num_rows = num_rows_,
       num_cols = num_cols_, this_stride = stride_;
   Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     MatrixIndexT index = indexes[r];
     KALDI_ASSERT(index >= -1 && index < dst->NumRows());
     if (index != -1)
       cblas_Xaxpy(num_cols, alpha, this_data, 1, dst->RowData(index), 1);
   }
 }

◆ AddTpMat()

void AddTpMat	(	const Real	alpha,
		const TpMatrix< Real > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

inline

this <– beta*this + alpha*A*B.

Definition at line 700 of file kaldi-matrix.h.

Referenced by kaldi::UnitTestCuMatrixAddTpMat().

                                  {
     Matrix<Real> M(A);
     return AddMatMat(alpha, M, transA, B, transB, beta);
   }

◆ AddTpTp()

void AddTpTp	(	const Real	alpha,
		const TpMatrix< Real > &	A,
		MatrixTransposeType	transA,
		const TpMatrix< Real > &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

inline

this <– beta*this + alpha*A*B.

Definition at line 734 of file kaldi-matrix.h.

                                 {
     Matrix<Real> M(A), N(B);
     return AddMatMat(alpha, M, transA, N, transB, beta);
   }

◆ AddVecToCols()

template void AddVecToCols	(	const Real	alpha,
		const VectorBase< OtherReal > &	v
	)

[each col of *this] += alpha * v

Definition at line 3061 of file kaldi-matrix.cc.

Referenced by kaldi::UnitTestAddVecToCols(), kaldi::UnitTestAddVecToColsSpeed(), and kaldi::UnitTestCuMatrixAddVecToCols().

                                                                                     {
   const MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       stride = stride_;
   KALDI_ASSERT(v.Dim() == num_rows);
 
   if (num_rows <= 64) {
     Real *data = data_;
     const OtherReal *vdata = v.Data();
     for (MatrixIndexT i = 0; i < num_rows; i++, data += stride) {
       Real to_add = alpha * vdata[i];
       for (MatrixIndexT j = 0; j < num_cols; j++)
         data[j] += to_add;
     }
 
   } else {
     Vector<OtherReal> ones(num_cols);
     ones.Set(1.0);
     this->AddVecVec(alpha, v, ones);
   }
 }

◆ AddVecToRows()

template void AddVecToRows	(	const Real	alpha,
		const VectorBase< OtherReal > &	v
	)

[each row of *this] += alpha * v

Definition at line 3030 of file kaldi-matrix.cc.

Referenced by kaldi::ApplyCmvn(), kaldi::ApplyCmvnReverse(), AmSgmm2::ComponentLogLikes(), DecodableAmNnetParallel::Compute(), OnlineLdaInput::TransformToOutput(), kaldi::UnitTestAddVecToRows(), kaldi::UnitTestAddVecToRowsSpeed(), kaldi::UnitTestCuMatrixAddVecToRows(), and kaldi::UnitTestPldaEstimation().

                                                                                     {
   const MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       stride = stride_;
   KALDI_ASSERT(v.Dim() == num_cols);
   if(num_cols <= 64) {
     Real *data = data_;
     const OtherReal *vdata = v.Data();
     for (MatrixIndexT i = 0; i < num_rows; i++, data += stride) {
       for (MatrixIndexT j = 0; j < num_cols; j++)
         data[j] += alpha * vdata[j];
     }
 
   } else {
     Vector<OtherReal> ones(num_rows);
     ones.Set(1.0);
     this->AddVecVec(alpha, ones, v);
    }
 }

◆ AddVecVec() [1/5]

void AddVecVec	(	const float	alpha,
		const VectorBase< float > &	ra,
		const VectorBase< float > &	rb
	)

◆ AddVecVec() [2/5]

void AddVecVec	(	const double	alpha,
		const VectorBase< double > &	ra,
		const VectorBase< double > &	rb
	)

◆ AddVecVec() [3/5]

void AddVecVec	(	const float	alpha,
		const VectorBase< float > &	a,
		const VectorBase< float > &	rb
	)

Definition at line 119 of file kaldi-matrix.cc.

                                                                {
   KALDI_ASSERT(a.Dim() == num_rows_ && rb.Dim() == num_cols_);
   cblas_Xger(a.Dim(), rb.Dim(), alpha, a.Data(), 1, rb.Data(),
              1, data_, stride_);
 }

◆ AddVecVec() [4/5]

void AddVecVec	(	const double	alpha,
		const VectorBase< double > &	a,
		const VectorBase< double > &	rb
	)

Definition at line 161 of file kaldi-matrix.cc.

                                                                  {
   KALDI_ASSERT(a.Dim() == num_rows_ && rb.Dim() == num_cols_);
   if (num_rows_ == 0) return;
   cblas_Xger(a.Dim(), rb.Dim(), alpha, a.Data(), 1, rb.Data(),
              1, data_, stride_);
 }

◆ AddVecVec() [5/5]

void AddVecVec	(	const Real	alpha,
		const VectorBase< OtherReal > &	a,
		const VectorBase< OtherReal > &	b
	)

*this += alpha * a * b^T

Definition at line 129 of file kaldi-matrix.cc.

Referenced by AccumFullGmm::AccumulateFromPosteriors(), AccumDiagGmm::AccumulateFromPosteriors(), FmllrRawAccs::CommitSingleFrameStats(), FmllrDiagGmmAccs::CommitSingleFrameStats(), MleAmSgmm2Accs::CommitStatsForSpk(), IvectorExtractorStats::CommitStatsForWPoint(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), IvectorExtractor::GetAcousticAuxfWeight(), main(), kaldi::UnitInvert(), kaldi::UnitTestAddVecToCols(), kaldi::UnitTestAddVecToRows(), kaldi::UnitTestAddVecVec(), kaldi::UnitTestCholesky(), kaldi::UnitTestCuMatrixAddVecVec(), UnitTestEstimateFullGmm(), kaldi::UnitTestInvert(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), kaldi::UnitTestSger(), kaldi::UnitTestSpAddVecVec(), and IvectorExtractorStats::UpdatePrior().

                                                                  {
   KALDI_ASSERT(a.Dim() == num_rows_ && b.Dim() == num_cols_);
   if (num_rows_ * num_cols_ > 100) { // It's probably worth it to allocate
     // temporary vectors of the right type and use BLAS.
     Vector<Real> temp_a(a), temp_b(b);
     cblas_Xger(num_rows_, num_cols_, alpha, temp_a.Data(), 1,
                temp_b.Data(), 1, data_, stride_);
   } else {
     const OtherReal *a_data = a.Data(), *b_data = b.Data();
     Real *row_data = data_;
     for (MatrixIndexT i = 0; i < num_rows_; i++, row_data += stride_) {
       BaseFloat alpha_ai = alpha * a_data[i];
       for (MatrixIndexT j = 0; j < num_cols_; j++)
         row_data[j] += alpha_ai * b_data[j];
     }
   }
 }

◆ ApplyCeiling()

void ApplyCeiling ( Real ceiling_val )

inline

Definition at line 358 of file kaldi-matrix.h.

Referenced by kaldi::UnitTestCuMatrixApplyCeiling(), and kaldi::UnitTestCuMatrixApplyExpLimited().

                                              {
     this -> Ceiling(*this, ceiling_val);
   }

◆ ApplyExp()

void ApplyExp ( )

inline

Definition at line 362 of file kaldi-matrix.h.

Referenced by AmSgmm2::ComponentPosteriors(), ComputeScores(), AmSgmm2::LogLikelihood(), main(), kaldi::UnitTestCuDiffLogSoftmax(), kaldi::UnitTestCuMatrixApplyExp(), kaldi::UnitTestCuMatrixApplyExpLimited(), and kaldi::UnitTestSimple().

                          {
     this -> Exp(*this);
   }

◆ ApplyExpLimited()

void ApplyExpLimited	(	Real	lower_limit,
		Real	upper_limit
	)

inline

Definition at line 370 of file kaldi-matrix.h.

                                                                   {
     this -> ExpLimited(*this, lower_limit, upper_limit);
   }

◆ ApplyExpSpecial()

void ApplyExpSpecial ( )

inline

Definition at line 366 of file kaldi-matrix.h.

Referenced by kaldi::UnitTestApplyExpSpecial(), and kaldi::UnitTestCuMatrixApplyExpSpecial().

                                 {
     this -> ExpSpecial(*this);
   }

◆ ApplyFloor()

void ApplyFloor ( Real floor_val )

inline

Definition at line 354 of file kaldi-matrix.h.

Referenced by DecodableAmNnetParallel::Compute(), main(), KlHmm::PropagateFnc(), kaldi::UnitTestApplyExpSpecial(), kaldi::UnitTestCuMathNormalizePerRow_v2(), kaldi::UnitTestCuMatrixApplyExpLimited(), kaldi::UnitTestCuMatrixApplyFloor(), kaldi::UnitTestCuMatrixDiffGroupPnorm(), kaldi::UnitTestCuMatrixGroupMax(), kaldi::UnitTestCuMatrixGroupMaxDeriv(), and kaldi::UnitTestCuMatrixGroupPnorm().

                                          {
     this -> Floor(*this, floor_val);
   }

◆ ApplyHeaviside()

void ApplyHeaviside ( )

inline

Definition at line 350 of file kaldi-matrix.h.

Referenced by kaldi::UnitTestCuMatrixApplyHeaviside(), kaldi::UnitTestCuMatrixHeaviside(), and kaldi::UnitTestHeaviside().

                                {
     this -> Heaviside(*this);
   }

◆ ApplyLog()

void ApplyLog ( )

inline

Definition at line 374 of file kaldi-matrix.h.

Referenced by DecodableAmNnetParallel::Compute(), main(), KlHmm::PropagateFnc(), and kaldi::UnitTestCuMatrixApplyLog().

                          {
     this -> Log(*this);
   }

◆ ApplyPow()

void ApplyPow ( Real power )

inline

Definition at line 341 of file kaldi-matrix.h.

Referenced by Fmpe::ComputeStddevs(), DiagGmm::LogLikelihoods(), main(), kaldi::UnitTestCuMatrixApplyPow(), kaldi::UnitTestSetRandn(), and kaldi::UnitTestSetRandUniform().

                                    {
     this -> Pow(*this, power);
   }

◆ ApplyPowAbs()

void ApplyPowAbs	(	Real	power,
		bool	include_sign = `false`
	)

inline

Definition at line 346 of file kaldi-matrix.h.

Referenced by kaldi::UnitTestCuMatrixApplyPowAbs().

                                                                {
     this -> PowAbs(*this, power, include_sign);
   }

◆ ApplySoftMax()

Real ApplySoftMax ( )

Apply soft-max to the collection of all elements of the matrix and return normalizer (log sum of exponentials).

Definition at line 2751 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and kaldi::UnitTestSimpleForMat().

                                     {
   Real max = this->Max(), sum = 0.0;
   // the 'max' helps to get in good numeric range.
   for (MatrixIndexT i = 0; i < num_rows_; i++)
     for (MatrixIndexT j = 0; j < num_cols_; j++)
       sum += ((*this)(i, j) = kaldi::Exp((*this)(i, j) - max));
   this->Scale(1.0 / sum);
   return max + kaldi::Log(sum);
 }

◆ ApproxEqual()

bool ApproxEqual	(	const MatrixBase< Real > &	other,
		float	tol = `0.01`
	)		const

Returns true if ((*this)-other).FrobeniusNorm() <= tol * (*this).FrobeniusNorm().

Definition at line 1915 of file kaldi-matrix.cc.

Referenced by kaldi::ApproxEqual(), AccumDiagGmm::AssertEqual(), kaldi::AssertEqual(), MatrixBase< float >::MinSingularValue(), SingleUtteranceGmmDecoder::RescoringIsNeeded(), kaldi::TestOnlineCmnInput(), kaldi::TestOnlineDeltaFeature(), kaldi::TestOnlineDeltaInput(), kaldi::TestOnlineLdaInput(), kaldi::TestOnlineSpliceFrames(), kaldi::UnitTestExtractCompressedMatrix(), kaldi::UnitTestNorm(), kaldi::UnitTestPosteriors(), and kaldi::UnitTestTableRandomBothDoubleMatrix().

                                                                                  {
   if (num_rows_ != other.num_rows_ || num_cols_ != other.num_cols_)
     KALDI_ERR << "ApproxEqual: size mismatch.";
   Matrix<Real> tmp(*this);
   tmp.AddMat(-1.0, other);
   return (tmp.FrobeniusNorm() <= static_cast<Real>(tol) *
           this->FrobeniusNorm());
 }

◆ Ceiling()

void Ceiling	(	const MatrixBase< Real > &	src,
		Real	ceiling_val
	)

Definition at line 2173 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyCeiling(), and MatrixBase< float >::MinSingularValue().

                                                                             {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++)
       row_data[col] = (src_row_data[col] > ceiling_val ? ceiling_val : src_row_data[col]);
   }
 }

◆ ColRange()

SubMatrix<Real> ColRange	(	const MatrixIndexT	col_offset,
		const MatrixIndexT	num_cols
	)		const

inline

Definition at line 213 of file kaldi-matrix.h.

Referenced by kaldi::AppendPostToFeats(), kaldi::AppendVectorToFeats(), OnlineFeaturePipeline::Init(), and main().

                                                                      {
     return SubMatrix<Real>(*this, 0, num_rows_, col_offset, num_cols);
   }

◆ Cond()

Real Cond ( ) const

Returns condition number by computing Svd.

Works even if cols > rows. Returns infinity if all singular values are zero.

Definition at line 1696 of file kaldi-matrix.cc.

Referenced by SpMatrix< float >::Cond(), InitRand(), kaldi::InitRand(), kaldi::InitRandNonsingular(), MatrixBase< float >::MinSingularValue(), rand_posdef_spmatrix(), kaldi::RandFullCova(), kaldi::unittest::RandPosdefSpMatrix(), RandPosdefSpMatrix(), kaldi::UnitTestPldaEstimation(), and kaldi::UnitTestRegtreeFmllrDiagGmm().

                                   {
   KALDI_ASSERT(num_rows_ > 0&&num_cols_ > 0);
   Vector<Real> singular_values(std::min(num_rows_, num_cols_));
   Svd(&singular_values);  // Get singular values...
   Real min = singular_values(0), max = singular_values(0);  // both absolute values...
   for (MatrixIndexT i = 1;i < singular_values.Dim();i++) {
     min = std::min((Real)std::abs(singular_values(i)), min); max = std::max((Real)std::abs(singular_values(i)), max);
   }
   if (min > 0) return max/min;
   else return std::numeric_limits<Real>::infinity();
 }

◆ CopyColFromVec()

void CopyColFromVec	(	const VectorBase< Real > &	v,
		const MatrixIndexT	col
	)

Copy vector into specific column of matrix.

Definition at line 1102 of file kaldi-matrix.cc.

Referenced by LdaEstimate::AddMeanOffset(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), AmSgmm2::InitializeMw(), main(), MatrixBase< float >::operator()(), ArbitraryResample::Resample(), kaldi::UnitTestCuMathNormalizePerRow(), and kaldi::UnitTestSpliceRows().

                                                               {
   KALDI_ASSERT(rv.Dim() == num_rows_ &&
                static_cast<UnsignedMatrixIndexT>(col) <
                static_cast<UnsignedMatrixIndexT>(num_cols_));
 
   const Real *rv_data = rv.Data();
   Real *col_data = data_ + col;
 
   for (MatrixIndexT r = 0; r < num_rows_; r++)
     col_data[r * stride_] = rv_data[r];
 }

◆ CopyCols()

void CopyCols	(	const MatrixBase< Real > &	src,
		const MatrixIndexT *	indices
	)

Copies column r from column indices[r] of src.

As a special case, if indexes[i] == -1, sets column i to zero. all elements of "indices" must be in [-1, src.NumCols()-1], and src.NumRows() must equal this.NumRows()

Definition at line 2826 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange().

                                                              {
   KALDI_ASSERT(NumRows() == src.NumRows());
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       this_stride = stride_, src_stride = src.stride_;
   Real *this_data = this->data_;
   const Real *src_data = src.data_;
 #ifdef KALDI_PARANOID
   MatrixIndexT src_cols = src.NumCols();
   for (MatrixIndexT i = 0; i < num_cols; i++)
     KALDI_ASSERT(indices[i] >= -1 && indices[i] < src_cols);
 #endif
 
   // For the sake of memory locality we do this row by row, rather
   // than doing it column-wise using cublas_Xcopy
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride, src_data += src_stride) {
     const MatrixIndexT *index_ptr = &(indices[0]);
     for (MatrixIndexT c = 0; c < num_cols; c++, index_ptr++) {
       if (*index_ptr < 0) this_data[c] = 0;
       else this_data[c] = src_data[*index_ptr];
     }
   }
 }

◆ CopyColsFromVec()

void CopyColsFromVec ( const VectorBase< Real > & v )

Copies vector into matrix, column-by-column.

Note that rv.Dim() must either equal NumRows()*NumCols() or NumRows(); this has two modes of operation.

Definition at line 1053 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::operator()(), kaldi::UnitTestCuMatrixCopyColsFromVec(), and kaldi::UnitTestSpliceRows().

                                                                  {
   if (rv.Dim() == num_rows_*num_cols_) {
     const Real *v_inc_data = rv.Data();
     Real *m_inc_data = data_;
 
     for (MatrixIndexT c = 0; c < num_cols_; c++) {
       for (MatrixIndexT r = 0; r < num_rows_; r++) {
         m_inc_data[r * stride_] = v_inc_data[r];
       }
       v_inc_data += num_rows_;
       m_inc_data ++;
     }
   } else if (rv.Dim() == num_rows_) {
     const Real *v_inc_data = rv.Data();
     Real *m_inc_data = data_;
     for (MatrixIndexT r = 0; r < num_rows_; r++) {
       Real value = *(v_inc_data++);
       for (MatrixIndexT c = 0; c < num_cols_; c++)
         m_inc_data[c] = value;
       m_inc_data += stride_;
     }
   } else {
     KALDI_ERR << "Wrong size of arguments.";
   }
 }

◆ CopyDiagFromVec()

void CopyDiagFromVec ( const VectorBase< Real > & v )

Copy vector into diagonal of matrix.

Definition at line 1093 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::operator()(), kaldi::UnitTestAddVec2Sp(), kaldi::UnitTestSpliceRows(), and kaldi::UnitTestSvd().

                                                                  {
   KALDI_ASSERT(rv.Dim() == std::min(num_cols_, num_rows_));
   const Real *rv_data = rv.Data(), *rv_end = rv_data + rv.Dim();
   Real *my_data = this->Data();
   for (; rv_data != rv_end; rv_data++, my_data += (this->stride_+1))
     *my_data = *rv_data;
 }

◆ CopyFromMat() [1/3]

void CopyFromMat	(	const MatrixBase< OtherReal > &	M,
		MatrixTransposeType	trans = `kNoTrans`
	)

Copy given matrix. (no resize is done).

Definition at line 862 of file kaldi-matrix.cc.

                                                               {
   if (sizeof(Real) == sizeof(OtherReal) &&
       static_cast<const void*>(M.Data()) ==
       static_cast<const void*>(this->Data())) {
     // CopyFromMat called on same data.  Nothing to do (except sanity checks).
     KALDI_ASSERT(Trans == kNoTrans && M.NumRows() == NumRows() &&
                  M.NumCols() == NumCols() && M.Stride() == Stride());
     return;
   }
   if (Trans == kNoTrans) {
     KALDI_ASSERT(num_rows_ == M.NumRows() && num_cols_ == M.NumCols());
     for (MatrixIndexT i = 0; i < num_rows_; i++)
       (*this).Row(i).CopyFromVec(M.Row(i));
   } else {
     KALDI_ASSERT(num_cols_ == M.NumRows() && num_rows_ == M.NumCols());
     int32 this_stride = stride_, other_stride = M.Stride();
     Real *this_data = data_;
     const OtherReal *other_data = M.Data();
     for (MatrixIndexT i = 0; i < num_rows_; i++)
       for (MatrixIndexT j = 0; j < num_cols_; j++)
         this_data[i * this_stride + j] = other_data[j * other_stride + i];
   }
 }

◆ CopyFromMat() [2/3]

void CopyFromMat ( const CompressedMatrix & M )

Copy from compressed matrix.

Definition at line 2057 of file kaldi-matrix.cc.

                                                               {
   mat.CopyToMat(this);
 }

◆ CopyFromMat() [3/3]

void CopyFromMat	(	const CuMatrixBase< OtherReal > &	M,
		MatrixTransposeType	trans = `kNoTrans`
	)

Copy from CUDA matrix. Implemented in ../cudamatrix/cu-matrix.h.

Definition at line 975 of file cu-matrix.h.

                                                               {
   cu.CopyToMat(this, trans);
 }

◆ CopyFromSp() [1/3]

void CopyFromSp ( const SpMatrix< OtherReal > & M )

Copy given spmatrix. (no resize is done).

Definition at line 938 of file kaldi-matrix.cc.

Referenced by AmSgmm2::GetNtransSigmaInv(), SpMatrix< float >::Invert(), Matrix< BaseFloat >::Matrix(), MatrixBase< float >::operator()(), kaldi::RandFullCova(), kaldi::UnitTestAddMat2(), and kaldi::UnitTestTransposeScatter().

                                                                {
   KALDI_ASSERT(num_rows_ == M.NumRows() && num_cols_ == num_rows_);
   // MORE EFFICIENT IF LOWER TRIANGULAR!  Reverse code otherwise.
   for (MatrixIndexT i = 0; i < num_rows_; i++) {
     for (MatrixIndexT j = 0; j < i; j++) {
       (*this)(j, i)  = (*this)(i, j) = M(i, j);
     }
     (*this)(i, i) = M(i, i);
   }
 }

◆ CopyFromSp() [2/3]

void CopyFromSp ( const SpMatrix< float > & M )

Definition at line 904 of file kaldi-matrix.cc.

                                                             {
   KALDI_ASSERT(num_rows_ == M.NumRows() && num_cols_ == num_rows_);
   MatrixIndexT num_rows = num_rows_, stride = stride_;
   const float *Mdata = M.Data();
   float *row_data = data_, *col_data = data_;
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     cblas_scopy(i+1, Mdata, 1, row_data, 1); // copy to the row.
     cblas_scopy(i, Mdata, 1, col_data, stride); // copy to the column.
     Mdata += i+1;
     row_data += stride;
     col_data += 1;
   }
 }

◆ CopyFromSp() [3/3]

void CopyFromSp ( const SpMatrix< double > & M )

Definition at line 921 of file kaldi-matrix.cc.

                                                               {
   KALDI_ASSERT(num_rows_ == M.NumRows() && num_cols_ == num_rows_);
   MatrixIndexT num_rows = num_rows_, stride = stride_;
   const double *Mdata = M.Data();
   double *row_data = data_, *col_data = data_;
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     cblas_dcopy(i+1, Mdata, 1, row_data, 1); // copy to the row.
     cblas_dcopy(i, Mdata, 1, col_data, stride); // copy to the column.
     Mdata += i+1;
     row_data += stride;
     col_data += 1;
   }
 }

◆ CopyFromTp()

template void CopyFromTp	(	const TpMatrix< OtherReal > &	M,
		MatrixTransposeType	trans = `kNoTrans`
	)

Copy given tpmatrix. (no resize is done).

Definition at line 958 of file kaldi-matrix.cc.

Referenced by kaldi::ComputeFeatureNormalizingTransform(), AmSgmm2::ComputeFmllrPreXform(), kaldi::ComputeNormalizingTransform(), BasisFmllrEstimate::EstimateFmllrBasis(), Matrix< BaseFloat >::Matrix(), MatrixBase< float >::operator()(), MleAmSgmm2Updater::RenormalizeV(), OnlineNaturalGradient::ReorthogonalizeRt1(), OnlinePreconditioner::ReorthogonalizeXt1(), kaldi::UnitTestCuMatrixCopyFromTp(), and kaldi::UnitTestMul().

                                                              {
   if (Trans == kNoTrans) {
     KALDI_ASSERT(num_rows_ == M.NumRows() && num_cols_ == num_rows_);
     SetZero();
     Real *out_i = data_;
     const OtherReal *in_i = M.Data();
     for (MatrixIndexT i = 0; i < num_rows_; i++, out_i += stride_, in_i += i) {
       for (MatrixIndexT j = 0; j <= i; j++)
         out_i[j] = in_i[j];
     }
   } else {
     SetZero();
     KALDI_ASSERT(num_rows_ == M.NumRows() && num_cols_ == num_rows_);
     MatrixIndexT stride = stride_;
     Real *out_i = data_;
     const OtherReal *in_i = M.Data();
     for (MatrixIndexT i = 0; i < num_rows_; i++, out_i ++, in_i += i) {
       for (MatrixIndexT j = 0; j <= i; j++)
         out_i[j*stride] = in_i[j];
     }
   }
 }

◆ CopyLowerToUpper()

void CopyLowerToUpper ( )

Copy lower triangle to upper triangle (symmetrize)

Definition at line 212 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp(), OnlinePreconditioner::PreconditionDirectionsInternal(), and OnlineNaturalGradient::PreconditionDirectionsInternal().

                                         {
   KALDI_ASSERT(num_rows_ == num_cols_);
   Real *data = data_;
   MatrixIndexT num_rows = num_rows_, stride = stride_;
   for (int32 i = 0; i < num_rows; i++)
     for (int32 j = 0; j < i; j++)
       data[j * stride + i ] = data[i * stride + j];
 }

◆ CopyRowFromVec()

void CopyRowFromVec	(	const VectorBase< Real > &	v,
		const MatrixIndexT	row
	)

Copy vector into specific row of matrix.

Definition at line 1081 of file kaldi-matrix.cc.

Referenced by kaldi::ClusterGaussiansToUbm(), kaldi::FmllrAuxfGradient(), kaldi::GetOutput(), main(), kaldi::MapDiagGmmUpdate(), kaldi::MleDiagGmmUpdate(), kaldi::MleFullGmmUpdate(), MatrixBase< float >::operator()(), DiagGmm::SetComponentMean(), kaldi::UnitTestSpliceRows(), and kaldi::UpdateEbwDiagGmm().

                                                                                         {
   KALDI_ASSERT(rv.Dim() == num_cols_ &&
                static_cast<UnsignedMatrixIndexT>(row) <
                static_cast<UnsignedMatrixIndexT>(num_rows_));
 
   const Real *rv_data = rv.Data();
   Real *row_data = RowData(row);
 
   std::memcpy(row_data, rv_data, num_cols_ * sizeof(Real));
 }

◆ CopyRows() [1/2]

void CopyRows	(	const MatrixBase< Real > &	src,
		const MatrixIndexT *	indices
	)

Copies row r from row indices[r] of src (does nothing As a special case, if indexes[i] == -1, sets row i to zero.

all elements of "indices" must be in [-1, src.NumRows()-1], and src.NumCols() must equal this.NumCols()

Definition at line 2877 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange().

                                                              {
   KALDI_ASSERT(NumCols() == src.NumCols());
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       this_stride = stride_;
   Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     MatrixIndexT index = indices[r];
     if (index < 0) memset(this_data, 0, sizeof(Real) * num_cols_);
     else cblas_Xcopy(num_cols, src.RowData(index), 1, this_data, 1);
   }
 }

◆ CopyRows() [2/2]

void CopyRows ( const Real *const * src )

Copies row r of this matrix from an array of floats at the location given by src[r].

If any src[r] is NULL then this.Row(r) will be set to zero. Note: we are using "pointer to const pointer to const object" for "src", because we may create "src" by calling Data() of const CuArray

Definition at line 2892 of file kaldi-matrix.cc.

                                                       {
   MatrixIndexT num_rows = num_rows_,
       num_cols = num_cols_, this_stride = stride_;
   Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     const Real *const src_data = src[r];
     if (src_data == NULL) memset(this_data, 0, sizeof(Real) * num_cols);
     else cblas_Xcopy(num_cols, src_data, 1, this_data, 1);
   }
 }

◆ CopyRowsFromVec() [1/3]

void CopyRowsFromVec ( const VectorBase< Real > & v )

This function has two modes of operation.

If v.Dim() == NumRows() * NumCols(), then treats the vector as a row-by-row concatenation of a matrix and copies to *this. if v.Dim() == NumCols(), it sets each row of *this to a copy of v.

Definition at line 997 of file kaldi-matrix.cc.

Referenced by DecodableNnetLoopedOnlineBase::AdvanceChunk(), DecodableNnetSimpleLooped::AdvanceChunk(), kaldi::nnet2::CombineNnets(), FastNnetCombiner::ComputeCurrentNnet(), FmllrRawAccs::ConvertToPerRowStats(), kaldi::CuVectorUnitTestCopyFromMat(), LogisticRegression::DoStep(), kaldi::nnet2::FormatNnetInput(), OnlineTransform::GetFrames(), DiagGmm::LogLikelihoods(), MatrixBase< float >::operator()(), LogisticRegression::TrainParameters(), kaldi::UnitTestCopyRowsAndCols(), kaldi::UnitTestCuMatrixCopyRowsFromVec(), and kaldi::UnitTestSpliceRows().

                                                                  {
   if (rv.Dim() == num_rows_*num_cols_) {
     if (stride_ == num_cols_) {
       // one big copy operation.
       const Real *rv_data = rv.Data();
       std::memcpy(data_, rv_data, sizeof(Real)*num_rows_*num_cols_);
     } else {
       const Real *rv_data = rv.Data();
       for (MatrixIndexT r = 0; r < num_rows_; r++) {
         Real *row_data = RowData(r);
         for (MatrixIndexT c = 0; c < num_cols_; c++) {
           row_data[c] = rv_data[c];
         }
         rv_data += num_cols_;
       }
     }
   } else if (rv.Dim() == num_cols_) {
     const Real *rv_data = rv.Data();
     for (MatrixIndexT r = 0; r < num_rows_; r++)
       std::memcpy(RowData(r), rv_data, sizeof(Real)*num_cols_);
   } else {
     KALDI_ERR << "Wrong sized arguments";
   }
 }

◆ CopyRowsFromVec() [2/3]

void CopyRowsFromVec ( const CuVectorBase< Real > & v )

This version of CopyRowsFromVec is implemented in ../cudamatrix/cu-vector.cc.

Definition at line 246 of file cu-vector.cc.

                                                                   {
   KALDI_ASSERT(v.Dim() == NumCols() * NumRows());
 #if HAVE_CUDA == 1
   if (CuDevice::Instantiate().Enabled()) {
     if (num_rows_ == 0) return;
     CuTimer tim;
     if (Stride() == NumCols()) {
       CU_SAFE_CALL(cudaMemcpyAsync(data_, v.Data(),
                               sizeof(Real)*v.Dim(),
                               cudaMemcpyDeviceToHost,
                               cudaStreamPerThread));
     } else {
       const Real* vec_data = v.Data();
       for (MatrixIndexT r = 0; r < NumRows(); r++) {
         CU_SAFE_CALL(cudaMemcpyAsync(RowData(r), vec_data,
                                 sizeof(Real) * NumCols(),
                                 cudaMemcpyDeviceToHost,
                                 cudaStreamPerThread));
         vec_data += NumCols();
       }
     }
     CU_SAFE_CALL(cudaStreamSynchronize(cudaStreamPerThread));
     CuDevice::Instantiate().AccuProfile(__func__, tim);
   } else
 #endif
   {
     CopyRowsFromVec(v.Vec());
   }
 }

◆ CopyRowsFromVec() [3/3]

void CopyRowsFromVec ( const VectorBase< OtherReal > & v )

Definition at line 1024 of file kaldi-matrix.cc.

                                                                       {
   if (rv.Dim() == num_rows_*num_cols_) {
     const OtherReal *rv_data = rv.Data();
     for (MatrixIndexT r = 0; r < num_rows_; r++) {
       Real *row_data = RowData(r);
       for (MatrixIndexT c = 0; c < num_cols_; c++) {
         row_data[c] = static_cast<Real>(rv_data[c]);
       }
       rv_data += num_cols_;
     }
   } else if (rv.Dim() == num_cols_) {
     const OtherReal *rv_data = rv.Data();
     Real *first_row_data = RowData(0);
     for (MatrixIndexT c = 0; c < num_cols_; c++)
       first_row_data[c] = rv_data[c];
     for (MatrixIndexT r = 1; r < num_rows_; r++)
       std::memcpy(RowData(r), first_row_data, sizeof(Real)*num_cols_);
   } else {
     KALDI_ERR << "Wrong sized arguments.";
   }
 }

◆ CopyToRows()

void CopyToRows ( Real *const * dst ) const

Copies row r of this matrix to the array of floats at the location given by dst[r].

If dst[r] is NULL, does not copy anywhere. Requires that none of the memory regions pointed to by the pointers in "dst" overlap (e.g. none of the pointers should be the same).

Definition at line 2905 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), and kaldi::UnitTestCopyToRows().

                                                         {
   MatrixIndexT num_rows = num_rows_,
       num_cols = num_cols_, this_stride = stride_;
   const Real *this_data = this->data_;
 
   for (MatrixIndexT r = 0; r < num_rows; r++, this_data += this_stride) {
     Real *const dst_data = dst[r];
     if (dst_data != NULL)
       cblas_Xcopy(num_cols, this_data, 1, dst_data, 1);
   }
 }

◆ CopyUpperToLower()

void CopyUpperToLower ( )

Copy upper triangle to lower triangle (symmetrize)

Definition at line 223 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp().

                                         {
   KALDI_ASSERT(num_rows_ == num_cols_);
   Real *data = data_;
   MatrixIndexT num_rows = num_rows_, stride = stride_;
   for (int32 i = 0; i < num_rows; i++)
     for (int32 j = 0; j < i; j++)
       data[i * stride + j] = data[j * stride + i];
 }

◆ Data() [1/2]

const Real* Data ( ) const

inline

Gives pointer to raw data (const).

Definition at line 79 of file kaldi-matrix.h.

                                   {
     return data_;
   }

◆ Data() [2/2]

Real* Data ( )

inline

Gives pointer to raw data (non-const).

Definition at line 84 of file kaldi-matrix.h.

84 { return data_; }

kaldi::MatrixBase::data_

Real * data_

data memory area

Definition: kaldi-matrix.h:808

◆ Data_workaround()

Real* Data_workaround ( ) const

inlineprotected

A workaround that allows SubMatrix to get a pointer to non-const data for const Matrix.

Unfortunately C++ does not allow us to declare a "public const" inheritance or anything like that, so it would require a lot of work to make the SubMatrix class totally const-correct– we would have to override many of the Matrix functions.

Definition at line 803 of file kaldi-matrix.h.

Referenced by SubMatrix< Real >::SubMatrix().

                                         {
     return data_;
   }

◆ DestructiveSvd()

void DestructiveSvd	(	VectorBase< Real > *	s,
		MatrixBase< Real > *	U,
		MatrixBase< Real > *	Vt
	)

Singular value decomposition Major limitations: For nonsquare matrices, we assume m>=n (NumRows >= NumCols), and we return the "skinny" Svd, i.e.

the matrix in the middle is diagonal, and the one on the left is rectangular.

In Svd, *this = U*diag(S)*Vt. Null pointers for U and/or Vt at input mean we do not want that output. We expect that S.Dim() == m, U is either NULL or m by n, and v is either NULL or n by n. The singular values are not sorted (use SortSvd for that).

Definition at line 1781 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyLog(), kaldi::ComputePca(), AffineComponent::LimitRank(), and MatrixBase< float >::Svd().

                                                                                                     {
   // Svd, *this = U*diag(s)*Vt.
   // With (*this).num_rows_ == m, (*this).num_cols_ == n,
   // Support only skinny Svd with m>=n (NumRows>=NumCols), and zero sizes for U and Vt mean
   // we do not want that output.  We expect that s.Dim() == m,
   // U is either 0 by 0 or m by n, and rv is either 0 by 0 or n by n.
   // Throws exception on error.
 
   KALDI_ASSERT(num_rows_>=num_cols_ && "Svd requires that #rows by >= #cols.");  // For compatibility with JAMA code.
   KALDI_ASSERT(s->Dim() == num_cols_);  // s should be the smaller dim.
   KALDI_ASSERT(U == NULL || (U->num_rows_ == num_rows_&&U->num_cols_ == num_cols_));
   KALDI_ASSERT(Vt == NULL || (Vt->num_rows_ == num_cols_&&Vt->num_cols_ == num_cols_));
 
   Real prescale = 1.0;
   if ( std::abs((*this)(0, 0) ) < 1.0e-30) {  // Very tiny value... can cause problems in Svd.
     Real max_elem = LargestAbsElem();
     if (max_elem != 0) {
       prescale = 1.0 / max_elem;
       if (std::abs(prescale) == std::numeric_limits<Real>::infinity()) { prescale = 1.0e+40; }
       (*this).Scale(prescale);
     }
   }
 
 #if !defined(HAVE_ATLAS) && !defined(USE_KALDI_SVD)
   // "S" == skinny Svd (only one we support because of compatibility with Jama one which is only skinny),
   // "N"== no eigenvectors wanted.
   LapackGesvd(s, U, Vt);
 #else
   /*  if (num_rows_ > 1 && num_cols_ > 1 && (*this)(0, 0) == (*this)(1, 1)
       && Max() == Min() && (*this)(0, 0) != 0.0) { // special case that JamaSvd sometimes crashes on.
       KALDI_WARN << "Jama SVD crashes on this type of matrix, perturbing it to prevent crash.";
       for(int32 i = 0; i < NumRows(); i++)
       (*this)(i, i)  *= 1.00001;
       }*/
   bool ans = JamaSvd(s, U, Vt);
   if (Vt != NULL) Vt->Transpose();  // possibly to do: change this and also the transpose inside the JamaSvd routine.  note, Vt is square.
   if (!ans) {
     KALDI_ERR << "Error doing Svd";  // This one will be caught.
   }
 #endif
   if (prescale != 1.0) s->Scale(1.0/prescale);
 }

◆ DiffSigmoid()

void DiffSigmoid	(	const MatrixBase< Real > &	value,
		const MatrixBase< Real > &	diff
	)

Definition at line 2994 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and kaldi::UnitTestSigmoid().

                                                                  {
   KALDI_ASSERT(SameDim(*this, value) && SameDim(*this, diff));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       stride = stride_, value_stride = value.stride_, diff_stride = diff.stride_;
   Real *data = data_;
   const Real *value_data = value.data_, *diff_data = diff.data_;
   for (MatrixIndexT r = 0; r < num_rows; r++) {
     for (MatrixIndexT c = 0; c < num_cols; c++)
       data[c] = diff_data[c] * value_data[c] * (1.0 - value_data[c]);
     data += stride;
     value_data += value_stride;
     diff_data += diff_stride;
   }
 }

◆ DiffTanh()

void DiffTanh	(	const MatrixBase< Real > &	value,
		const MatrixBase< Real > &	diff
	)

Definition at line 3011 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and kaldi::UnitTestTanh().

                                                                  {
   KALDI_ASSERT(SameDim(*this, value) && SameDim(*this, diff));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_,
       stride = stride_, value_stride = value.stride_, diff_stride = diff.stride_;
   Real *data = data_;
   const Real *value_data = value.data_, *diff_data = diff.data_;
   for (MatrixIndexT r = 0; r < num_rows; r++) {
     for (MatrixIndexT c = 0; c < num_cols; c++)
       data[c] = diff_data[c] * (1.0 - (value_data[c] * value_data[c]));
     data += stride;
     value_data += value_stride;
     diff_data += diff_stride;
   }
 }

◆ DivElements()

void DivElements ( const MatrixBase< Real > & A )

Divide each element by the corresponding element of a given matrix.

Definition at line 1157 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), and kaldi::UnitTestCuMatrixDivElements().

                                                             {
   KALDI_ASSERT(a.NumRows() == num_rows_ && a.NumCols() == num_cols_);
   MatrixIndexT i;
   MatrixIndexT j;
 
   for (i = 0; i < num_rows_; i++) {
     for (j = 0; j < num_cols_; j++) {
       (*this)(i, j) /= a(i, j);
     }
   }
 }

◆ Eig()

void Eig	(	MatrixBase< Real > *	P,
		VectorBase< Real > *	eigs_real,
		VectorBase< Real > *	eigs_imag
	)		const

Eigenvalue Decomposition of a square NxN matrix into the form (*this) = P D P^{-1}.

Be careful: the relationship of D to the eigenvalues we output is slightly complicated, due to the need for P to be real. In the symmetric case D is diagonal and real, but in the non-symmetric case there may be complex-conjugate pairs of eigenvalues. In this case, for the equation (*this) = P D P^{-1} to hold, D must actually be block diagonal, with 2x2 blocks corresponding to any such pairs. If a pair is lambda +- i*mu, D will have a corresponding 2x2 block [lambda, mu; -mu, lambda]. Note that if the input matrix (*this) is non-invertible, P may not be invertible so in this case instead of the equation (*this) = P D P^{-1} holding, we have instead (*this) P = P D.

The non-member function CreateEigenvalueMatrix creates D from eigs_real and eigs_imag.

Definition at line 2280 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyLog(), kaldi::UnitTestEig(), and kaldi::UnitTestEigSymmetric().

                                                       {
   EigenvalueDecomposition<Real>  eig(*this);
   if (P) eig.GetV(P);
   if (r) eig.GetRealEigenvalues(r);
   if (i) eig.GetImagEigenvalues(i);
 }

◆ Equal()

bool Equal ( const MatrixBase< Real > & other ) const

Tests for exact equality. It's usually preferable to use ApproxEqual.

Definition at line 1925 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue().

                                                                 {
   if (num_rows_ != other.num_rows_ || num_cols_ != other.num_cols_)
     KALDI_ERR << "Equal: size mismatch.";
   for (MatrixIndexT i = 0; i < num_rows_; i++)
     for (MatrixIndexT j = 0; j < num_cols_; j++)
       if ( (*this)(i, j) != other(i, j))
         return false;
   return true;
 }

◆ Exp()

void Exp ( const MatrixBase< Real > & src )

Definition at line 2115 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyExp(), and MatrixBase< float >::MinSingularValue().

                                                       {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++)
       row_data[col] = kaldi::Exp(src_row_data[col]);
   }
 }

◆ ExpLimited()

void ExpLimited	(	const MatrixBase< Real > &	src,
		Real	lower_limit,
		Real	upper_limit
	)

This is equivalent to running: Floor(src, lower_limit); Ceiling(src, upper_limit); Exp(src)

Definition at line 2212 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyExpLimited(), and MatrixBase< float >::MinSingularValue().

                                                                                                  {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++) {
       const Real x = src_row_data[col];
       if (!(x >= lower_limit))
         row_data[col] = kaldi::Exp(lower_limit);
       else if (x > upper_limit)
         row_data[col] = kaldi::Exp(upper_limit);
       else
         row_data[col] = kaldi::Exp(x);
     }
   }
 }

◆ ExpSpecial()

void ExpSpecial ( const MatrixBase< Real > & src )

For each element x of the matrix, set it to (x < 0 ? exp(x) : x + 1).

This function is used in our RNNLM training.

Definition at line 2199 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyExpSpecial(), and MatrixBase< float >::MinSingularValue().

                                                              {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++)
       row_data[col] = (src_row_data[col] < Real(0) ? kaldi::Exp(src_row_data[col]) : (src_row_data[col] + Real(1)));
   }
 }

◆ Floor()

void Floor	(	const MatrixBase< Real > &	src,
		Real	floor_val
	)

Definition at line 2160 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyFloor(), and MatrixBase< float >::MinSingularValue().

                                                                         {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++)
       row_data[col] = (src_row_data[col] < floor_val ? floor_val : src_row_data[col]);
   }
 }

◆ FrobeniusNorm()

Real FrobeniusNorm ( ) const

Frobenius norm, which is the sqrt of sum of square elements.

Same as Schatten 2-norm, or just "2-norm".

Definition at line 1910 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApproxEqual(), MleAmSgmm2Accs::Check(), MatrixBase< float >::MinSingularValue(), MatrixBase< float >::SymPosSemiDefEig(), kaldi::UnitTestCompressedMatrix(), kaldi::UnitTestGeneralMatrix(), kaldi::UnitTestNorm(), and kaldi::UnitTestSparseMatrixFrobeniusNorm().

                                           {
   return std::sqrt(TraceMatMat(*this, *this, kTrans));
 }

◆ GroupMax()

void GroupMax ( const MatrixBase< Real > & src )

Apply the function y(i) = (max_{j = i*G}^{(i+1)*G-1} x_j Requires src.NumRows() == this->NumRows() and src.NumCols() % this->NumCols() == 0.

Definition at line 2806 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), kaldi::UnitTestCuMatrixGroupMax(), and kaldi::UnitTestCuMatrixGroupMaxDeriv().

                                                            {
   KALDI_ASSERT(src.NumCols() % this->NumCols() == 0 &&
                src.NumRows() == this->NumRows());
   int group_size = src.NumCols() / this->NumCols(),
       num_rows = this->NumRows(), num_cols = this->NumCols();
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     const Real *src_row_data = src.RowData(i);
     for (MatrixIndexT j = 0; j < num_cols; j++) {
       Real max_val = -1e20;
       for (MatrixIndexT k = 0; k < group_size; k++) {
         Real src_data = src_row_data[j * group_size + k];
         if (src_data > max_val)
           max_val = src_data;
       }
       (*this)(i, j) = max_val;
     }
   }
 }

◆ GroupMaxDeriv()

void GroupMaxDeriv	(	const MatrixBase< Real > &	input,
		const MatrixBase< Real > &	output
	)

Calculate derivatives for the GroupMax function above, where "input" is the input to the GroupMax function above (i.e.

the "src" variable), and "output" is the result of the computation (i.e. the "this" of that function call), and *this must have the same dimension as "input". Each element of *this will be set to 1 if the corresponding input equals the output of the group, and 0 otherwise. The equals the function derivative where it is defined (it's not defined where multiple inputs in the group are equal to the output).

Definition at line 1299 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and kaldi::UnitTestCuMatrixGroupMaxDeriv().

                                                                      {
   KALDI_ASSERT(input.NumCols() == this->NumCols() &&
               input.NumRows() == this->NumRows());
   KALDI_ASSERT(this->NumCols() % output.NumCols() == 0 &&
                this->NumRows() == output.NumRows());
 
   int group_size = this->NumCols() / output.NumCols(),
       num_rows = this->NumRows(), num_cols = this->NumCols();
 
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     for (MatrixIndexT j = 0; j < num_cols; j++) {
       Real input_val = input(i, j);
       Real output_val = output(i, j / group_size);
       (*this)(i, j) = (input_val == output_val ? 1 : 0);
     }
   }
 }

◆ GroupPnorm()

void GroupPnorm	(	const MatrixBase< Real > &	src,
		Real	power
	)

Apply the function y(i) = (sum_{j = i*G}^{(i+1)*G-1} x_j^(power))^(1 / p).

Requires src.NumRows() == this->NumRows() and src.NumCols() % this->NumCols() == 0.

Definition at line 2795 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), kaldi::UnitTestCuMatrixDiffGroupPnorm(), and kaldi::UnitTestCuMatrixGroupPnorm().

                                                                          {
   KALDI_ASSERT(src.NumCols() % this->NumCols() == 0 &&
                src.NumRows() == this->NumRows());
   int group_size = src.NumCols() / this->NumCols(),
     num_rows = this->NumRows(), num_cols = this->NumCols();
   for (MatrixIndexT i = 0; i < num_rows; i++)
     for (MatrixIndexT j = 0; j < num_cols; j++)
       (*this)(i, j) = src.Row(i).Range(j * group_size,  group_size).Norm(power);
 }

◆ GroupPnormDeriv()

void GroupPnormDeriv	(	const MatrixBase< Real > &	input,
		const MatrixBase< Real > &	output,
		Real	power
	)

Calculate derivatives for the GroupPnorm function above...

if "input" is the input to the GroupPnorm function above (i.e. the "src" variable), and "output" is the result of the computation (i.e. the "this" of that function call), and *this has the same dimension as "input", then it sets each element of *this to the derivative d(output-elem)/d(input-elem) for each element of "input", where "output-elem" is whichever element of output depends on that input element.

Definition at line 1255 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and kaldi::UnitTestCuMatrixDiffGroupPnorm().

                                                    {
   KALDI_ASSERT(input.NumCols() == this->NumCols() && input.NumRows() == this->NumRows());
   KALDI_ASSERT(this->NumCols() % output.NumCols() == 0 &&
                this->NumRows() == output.NumRows());
 
   int group_size = this->NumCols() / output.NumCols(),
     num_rows = this->NumRows(), num_cols = this->NumCols();
 
   if (power == 1.0) {
     for (MatrixIndexT i = 0; i < num_rows; i++) {
       for (MatrixIndexT j = 0; j < num_cols; j++) {
         Real input_val = input(i, j);
         (*this)(i, j) = (input_val == 0 ? 0 : (input_val > 0 ? 1 : -1));
       }
     }
   } else if (power == std::numeric_limits<Real>::infinity()) {
     for (MatrixIndexT i = 0; i < num_rows; i++) {
       for (MatrixIndexT j = 0; j < num_cols; j++) {
         Real output_val = output(i, j / group_size), input_val = input(i, j);
         if (output_val == 0)
           (*this)(i, j) = 0;
         else
           (*this)(i, j) = (std::abs(input_val) == output_val ? 1.0 : 0.0)
               * (input_val >= 0 ? 1 : -1);
       }
     }
   } else {
     for (MatrixIndexT i = 0; i < num_rows; i++) {
       for (MatrixIndexT j = 0; j < num_cols; j++) {
         Real output_val = output(i, j / group_size),
           input_val = input(i, j);
         if (output_val == 0)
           (*this)(i, j) = 0;
          else
             (*this)(i, j) = pow(std::abs(input_val), power - 1) *
               pow(output_val, 1 - power) * (input_val >= 0 ? 1 : -1) ;
       }
     }
   }
 }

◆ Heaviside()

void Heaviside ( const MatrixBase< Real > & src )

Sets each element to the Heaviside step function (x > 0 ? 1 : 0) of the corresponding element in "src".

Note: in general you can make different choices for x = 0, but for now please leave it as it (i.e. returning zero) because it affects the RectifiedLinearComponent in the neural net code.

Definition at line 2102 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyHeaviside(), and MatrixBase< float >::MinSingularValue().

                                                             {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++)
       row_data[col] = (src_row_data[col] > 0 ? 1.0 : 0.0);
   }
 }

◆ Index()

Real& Index	(	MatrixIndexT	r,
		MatrixIndexT	c
	)

inline

Indexing operator, provided for ease of debugging (gdb doesn't work with parenthesis operator).

Definition at line 111 of file kaldi-matrix.h.

111 { return (*this)(r, c); }

◆ Invert()

void Invert	(	Real *	log_det = `NULL`,
		Real *	det_sign = `NULL`,
		bool	inverse_needed = `true`
	)

matrix inverse.

if inverse_needed = false, will fill matrix with garbage. (only useful if logdet wanted).

Definition at line 38 of file kaldi-matrix.cc.

Referenced by kaldi::CholeskyUnitTestTr(), MatrixBase< float >::ColRange(), LdaEstimate::Estimate(), FeatureTransformEstimate::EstimateInternal(), kaldi::FmllrInnerUpdate(), kaldi::generate_features(), IvectorExtractorStats::GetOrthogonalIvectorTransform(), SpMatrix< float >::Invert(), MatrixBase< float >::InvertDouble(), MatrixBase< float >::LogDet(), MatrixBase< float >::Power(), MleAmSgmm2Updater::RenormalizeV(), kaldi::SolveDoubleQuadraticMatrixProblem(), IvectorExtractor::TransformIvectors(), kaldi::UnitTestEig(), kaldi::UnitTestNonsymmetricPower(), MlltAccs::Update(), and PldaUnsupervisedAdaptor::UpdatePlda().

                                                    {
   KALDI_ASSERT(num_rows_ == num_cols_);
   if (num_rows_ == 0) {
     if (det_sign) *det_sign = 1;
     if (log_det) *log_det = 0.0;
     return;
   }
 #ifndef HAVE_ATLAS
   KaldiBlasInt *pivot = new KaldiBlasInt[num_rows_];
   KaldiBlasInt M = num_rows_;
   KaldiBlasInt N = num_cols_;
   KaldiBlasInt LDA = stride_;
   KaldiBlasInt result = -1;
   KaldiBlasInt l_work = std::max<KaldiBlasInt>(1, N);
   Real *p_work;
   void *temp;
   if ((p_work = static_cast<Real*>(
           KALDI_MEMALIGN(16, sizeof(Real)*l_work, &temp))) == NULL) {
     delete[] pivot;
     throw std::bad_alloc();
   }
 
   clapack_Xgetrf2(&M, &N, data_, &LDA, pivot, &result);
   const int pivot_offset = 1;
 #else
   int *pivot = new int[num_rows_];
   int result;
   clapack_Xgetrf(num_rows_, num_cols_, data_, stride_, pivot, &result);
   const int pivot_offset = 0;
 #endif
   KALDI_ASSERT(result >= 0 && "Call to CLAPACK sgetrf_ or ATLAS clapack_sgetrf "
                "called with wrong arguments");
   if (result > 0) {
     if (inverse_needed) {
       KALDI_ERR << "Cannot invert: matrix is singular";
     } else {
       if (log_det) *log_det = -std::numeric_limits<Real>::infinity();
       if (det_sign) *det_sign = 0;
       delete[] pivot;
 #ifndef HAVE_ATLAS
       KALDI_MEMALIGN_FREE(p_work);
 #endif
       return;
     }
   }
   if (det_sign != NULL) {
     int sign = 1;
     for (MatrixIndexT i = 0; i < num_rows_; i++)
       if (pivot[i] != static_cast<int>(i) + pivot_offset) sign *= -1;
     *det_sign = sign;
   }
   if (log_det != NULL || det_sign != NULL) {  // Compute log determinant.
     if (log_det != NULL) *log_det = 0.0;
     Real prod = 1.0;
     for (MatrixIndexT i = 0; i < num_rows_; i++) {
       prod *= (*this)(i, i);
       if (i == num_rows_ - 1 || std::fabs(prod) < 1.0e-10 ||
           std::fabs(prod) > 1.0e+10) {
         if (log_det != NULL) *log_det += kaldi::Log(std::fabs(prod));
         if (det_sign != NULL) *det_sign *= (prod > 0 ? 1.0 : -1.0);
         prod = 1.0;
       }
     }
   }
 #ifndef HAVE_ATLAS
   if (inverse_needed) clapack_Xgetri2(&M, data_, &LDA, pivot, p_work, &l_work,
                               &result);
   delete[] pivot;
   KALDI_MEMALIGN_FREE(p_work);
 #else
   if (inverse_needed)
     clapack_Xgetri(num_rows_, data_, stride_, pivot, &result);
   delete [] pivot;
 #endif
   KALDI_ASSERT(result == 0 && "Call to CLAPACK sgetri_ or ATLAS clapack_sgetri "
                "called with wrong arguments");
 }

◆ InvertDouble()

void InvertDouble	(	Real *	LogDet = `NULL`,
		Real *	det_sign = `NULL`,
		bool	inverse_needed = `true`
	)

matrix inverse [double].

if inverse_needed = false, will fill matrix with garbage (only useful if logdet wanted). Does inversion in double precision even if matrix was not double.

Definition at line 2046 of file kaldi-matrix.cc.

Referenced by kaldi::CalBasisFmllrStepSize(), kaldi::CalcFmllrStepSize(), MatrixBase< float >::ColRange(), kaldi::ComputeFeatureNormalizingTransform(), and BasisFmllrEstimate::ComputeTransform().

                                                          {
   double log_det_tmp, det_sign_tmp;
   Matrix<double> dmat(*this);
   dmat.Invert(&log_det_tmp, &det_sign_tmp, inverse_needed);
   if (inverse_needed) (*this).CopyFromMat(dmat);
   if (log_det) *log_det = log_det_tmp;
   if (det_sign) *det_sign = det_sign_tmp;
 }

◆ InvertElements()

void InvertElements ( )

Inverts all the elements of the matrix.

Definition at line 2070 of file kaldi-matrix.cc.

Referenced by kaldi::ClusterGaussiansToUbm(), MatrixBase< float >::ColRange(), DiagGmmNormal::CopyFromDiagGmm(), DiagGmmNormal::CopyToDiagGmm(), DiagGmm::GetMeans(), DiagGmm::GetVars(), init_rand_diag_gmm(), DiagGmm::Merge(), KlHmm::PropagateFnc(), rand_diag_gmm(), DiagGmm::SetInvVars(), kaldi::UnitTestCuMatrixInvertElements(), kaldi::UnitTestDiagGmm(), UnitTestEstimateDiagGmm(), kaldi::UnitTestEstimateMmieDiagGmm(), and kaldi::UnitTestRegtreeFmllrDiagGmm().

                                       {
   for (MatrixIndexT r = 0; r < num_rows_; r++) {
     for (MatrixIndexT c = 0; c < num_cols_; c++) {
       (*this)(r, c) = static_cast<Real>(1.0 / (*this)(r, c));
     }
   }
 }

◆ IsDiagonal()

bool IsDiagonal ( Real cutoff = 1.0e-05 ) const

Returns true if matrix is Diagonal.

Definition at line 1864 of file kaldi-matrix.cc.

Referenced by kaldi::ApplyModelTransformToStats(), MatrixBase< float >::MinSingularValue(), UnitTestEstimateLda(), and kaldi::UnitTestSimple().

                                                   {
   MatrixIndexT R = num_rows_, C = num_cols_;
   Real bad_sum = 0.0, good_sum = 0.0;
   for (MatrixIndexT i = 0;i < R;i++) {
     for (MatrixIndexT j = 0;j < C;j++) {
       if (i == j) good_sum += std::abs((*this)(i, j));
       else bad_sum += std::abs((*this)(i, j));
     }
   }
   return (!(bad_sum > good_sum * cutoff));
 }

◆ IsSymmetric()

bool IsSymmetric ( Real cutoff = 1.0e-05 ) const

Returns true if matrix is Symmetric.

Definition at line 1848 of file kaldi-matrix.cc.

Referenced by BasisFmllrEstimate::ComputeAmDiagPrecond(), EigenvalueDecomposition< Real >::EigenvalueDecomposition(), MatrixBase< float >::MinSingularValue(), MatrixBase< float >::SymPosSemiDefEig(), and kaldi::UnitTestSimple().

                                                     {
   MatrixIndexT R = num_rows_, C = num_cols_;
   if (R != C) return false;
   Real bad_sum = 0.0, good_sum = 0.0;
   for (MatrixIndexT i = 0;i < R;i++) {
     for (MatrixIndexT j = 0;j < i;j++) {
       Real a = (*this)(i, j), b = (*this)(j, i), avg = 0.5*(a+b), diff = 0.5*(a-b);
       good_sum += std::abs(avg); bad_sum += std::abs(diff);
     }
     good_sum += std::abs((*this)(i, i));
   }
   if (bad_sum > cutoff*good_sum) return false;
   return true;
 }

◆ IsUnit()

bool IsUnit ( Real cutoff = 1.0e-05 ) const

Returns true if the matrix is all zeros, except for ones on diagonal.

(it does not have to be square). More specifically, this function returns false if for any i, j, (*this)(i, j) differs by more than cutoff from the expression (i == j ? 1 : 0).

Definition at line 1890 of file kaldi-matrix.cc.

Referenced by kaldi::CholeskyUnitTestTr(), kaldi::ComputeFmllrMatrixDiagGmm(), MatrixBase< float >::MinSingularValue(), kaldi::nnet3::PerturbImage(), TestSgmm2PreXform(), kaldi::UnitTestDct(), UnitTestEstimateLda(), kaldi::UnitTestLimitCondInvert(), kaldi::UnitTestOrthogonalizeRows(), kaldi::UnitTestPca(), kaldi::UnitTestSimple(), kaldi::UnitTestSpInvert(), and kaldi::UnitTestTpInvert().

                                                {
   MatrixIndexT R = num_rows_, C = num_cols_;
   Real bad_max = 0.0;
   for (MatrixIndexT i = 0; i < R;i++)
     for (MatrixIndexT j = 0; j < C;j++)
       bad_max = std::max(bad_max, static_cast<Real>(std::abs( (*this)(i, j) - (i == j?1.0:0.0))));
   return (bad_max <= cutoff);
 }

◆ IsZero()

bool IsZero ( Real cutoff = 1.0e-05 ) const

Returns true if matrix is all zeros.

Definition at line 1900 of file kaldi-matrix.cc.

Referenced by BasisFmllrEstimate::ComputeTransform(), MatrixBase< float >::MinSingularValue(), test_io(), kaldi::TestFmpe(), kaldi::UnitTestDeterminant(), kaldi::UnitTestResize(), kaldi::UnitTestSimple(), FmllrDiagGmmAccs::Update(), and FmllrRawAccs::Update().

                                               {
   MatrixIndexT R = num_rows_, C = num_cols_;
   Real bad_max = 0.0;
   for (MatrixIndexT i = 0;i < R;i++)
     for (MatrixIndexT j = 0;j < C;j++)
       bad_max = std::max(bad_max, static_cast<Real>(std::abs( (*this)(i, j) )));
   return (bad_max <= cutoff);
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( MatrixBase< Real > )

private

◆ LapackGesvd()

void LapackGesvd	(	VectorBase< Real > *	s,
		MatrixBase< Real > *	U,
		MatrixBase< Real > *	Vt
	)

Impementation notes: Lapack works in column-order, therefore the dimensions of *this are swapped as well as the U and V matrices.

Definition at line 660 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp(), and MatrixBase< float >::DestructiveSvd().

                                                            {
   KALDI_ASSERT(s != NULL && U_in != this && V_in != this);
 
   Matrix<Real> tmpU, tmpV;
   if (U_in == NULL) tmpU.Resize(this->num_rows_, 1);  // work-space if U_in empty.
   if (V_in == NULL) tmpV.Resize(1, this->num_cols_);  // work-space if V_in empty.
 
 
   KaldiBlasInt M   = num_cols_;
   KaldiBlasInt N   = num_rows_;
   KaldiBlasInt LDA = Stride();
 
   KALDI_ASSERT(N>=M);  // NumRows >= columns.
 
   if (U_in) {
     KALDI_ASSERT((int)U_in->num_rows_ == N && (int)U_in->num_cols_ == M);
   }
   if (V_in) {
     KALDI_ASSERT((int)V_in->num_rows_ == M && (int)V_in->num_cols_ == M);
   }
   KALDI_ASSERT((int)s->Dim() == std::min(M, N));
 
   MatrixBase<Real> *U = (U_in ? U_in : &tmpU);
   MatrixBase<Real> *V = (V_in ? V_in : &tmpV);
 
   KaldiBlasInt V_stride      = V->Stride();
   KaldiBlasInt U_stride      = U->Stride();
 
   // Original LAPACK recipe
   // KaldiBlasInt l_work = std::max(std::max<long int>
   //   (1, 3*std::min(M, N)+std::max(M, N)), 5*std::min(M, N))*2;
   KaldiBlasInt l_work = -1;
   Real   work_query;
   KaldiBlasInt result;
 
   // query for work space
   char *u_job = const_cast<char*>(U_in ? "s" : "N");  // "s" == skinny, "N" == "none."
   char *v_job = const_cast<char*>(V_in ? "s" : "N");  // "s" == skinny, "N" == "none."
   clapack_Xgesvd(v_job, u_job,
                  &M, &N, data_, &LDA,
                  s->Data(),
                  V->Data(), &V_stride,
                  U->Data(), &U_stride,
                  &work_query, &l_work,
                  &result);
 
   KALDI_ASSERT(result >= 0 && "Call to CLAPACK dgesvd_ called with wrong arguments");
 
   l_work = static_cast<KaldiBlasInt>(work_query);
   Real *p_work;
   void *temp;
   if ((p_work = static_cast<Real*>(
           KALDI_MEMALIGN(16, sizeof(Real)*l_work, &temp))) == NULL)
     throw std::bad_alloc();
 
   // perform svd
   clapack_Xgesvd(v_job, u_job,
                  &M, &N, data_, &LDA,
                  s->Data(),
                  V->Data(), &V_stride,
                  U->Data(), &U_stride,
                  p_work, &l_work,
                  &result);
 
   KALDI_ASSERT(result >= 0 && "Call to CLAPACK dgesvd_ called with wrong arguments");
 
   if (result != 0) {
     KALDI_WARN << "CLAPACK sgesvd_ : some weird convergence not satisfied";
   }
   KALDI_MEMALIGN_FREE(p_work);
 }

◆ LargestAbsElem()

Real LargestAbsElem ( ) const

largest absolute value.

Definition at line 1937 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::DestructiveSvd(), and MatrixBase< float >::MinSingularValue().

                                            {
   MatrixIndexT R = num_rows_, C = num_cols_;
   Real largest = 0.0;
   for (MatrixIndexT i = 0;i < R;i++)
     for (MatrixIndexT j = 0;j < C;j++)
       largest = std::max(largest, (Real)std::abs((*this)(i, j)));
   return largest;
 }

◆ Log()

void Log ( const MatrixBase< Real > & src )

Definition at line 2186 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyLog(), and MatrixBase< float >::MinSingularValue().

                                                       {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++)
       row_data[col] = kaldi::Log(src_row_data[col]);
   }
 }

◆ LogDet()

Real LogDet ( Real * det_sign = NULL ) const

Returns logdet of matrix.

Definition at line 2038 of file kaldi-matrix.cc.

Referenced by kaldi::CalBasisFmllrStepSize(), kaldi::CalcFmllrStepSize(), MatrixBase< float >::ColRange(), kaldi::ComputeFmllrLogDet(), RegtreeFmllrDiagGmm::ComputeLogDets(), kaldi::FmllrAuxfGradient(), kaldi::FmllrAuxFuncDiagGmm(), FmllrSgmm2Accs::FmllrObjGradient(), FmllrRawAccs::GetAuxf(), kaldi::UnitTestDeterminant(), kaldi::UnitTestDeterminantSign(), kaldi::UnitTestEig(), UnitTestEstimateFullGmm(), kaldi::UnitTestSimpleForMat(), and FmllrSgmm2Accs::Update().

                                                   {
   Real log_det;
   Matrix<Real> tmp(*this);
   tmp.Invert(&log_det, det_sign, false);  // false== output not needed (saves some computation).
   return log_det;
 }

◆ LogSumExp()

Real LogSumExp ( Real prune = -1.0 ) const

Returns log(sum(exp())) without exp overflow If prune > 0.0, it uses a pruning beam, discarding terms less than (max - prune).

Note: in future we may change this so that if prune = 0.0, it takes the max, so use -1 if you don't want to prune.

Definition at line 2728 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and kaldi::UnitTestSimpleForMat().

                                                  {
   Real sum;
   if (sizeof(sum) == 8) sum = kLogZeroDouble;
   else sum = kLogZeroFloat;
   Real max_elem = Max(), cutoff;
   if (sizeof(Real) == 4) cutoff = max_elem + kMinLogDiffFloat;
   else cutoff = max_elem + kMinLogDiffDouble;
   if (prune > 0.0 && max_elem - prune > cutoff) // explicit pruning...
     cutoff = max_elem - prune;
 
   double sum_relto_max_elem = 0.0;
 
   for (MatrixIndexT i = 0; i < num_rows_; i++) {
     for (MatrixIndexT j = 0; j < num_cols_; j++) {
       BaseFloat f = (*this)(i, j);
       if (f >= cutoff)
         sum_relto_max_elem += kaldi::Exp(f - max_elem);
     }
   }
   return max_elem + kaldi::Log(sum_relto_max_elem);
 }

◆ Max() [1/2]

Real Max ( ) const

Returns maximum element of matrix.

Definition at line 1717 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), AmSgmm2::ComponentPosteriors(), CompressedMatrix::ComputeGlobalHeader(), AmSgmm2::LogLikelihood(), MatrixBase< float >::Svd(), kaldi::UnitTestCuMatrixMax(), kaldi::UnitTestCuMatrixReduceMax(), kaldi::UnitTestMax2(), and kaldi::UnitTestMaxMin().

                                  {
   KALDI_ASSERT(num_rows_ > 0 && num_cols_ > 0);
   Real ans= *data_;
   for (MatrixIndexT r = 0; r < num_rows_; r++)
     for (MatrixIndexT c = 0; c < num_cols_; c++)
       if (data_[c + stride_*r] > ans)
         ans = data_[c + stride_*r];
   return ans;
 }

◆ Max() [2/2]

void Max ( const MatrixBase< Real > & A )

Set, element-by-element, *this = max(*this, A)

Definition at line 1182 of file kaldi-matrix.cc.

                                                                             {
   KALDI_ASSERT(A.NumRows() == NumRows() && A.NumCols() == NumCols());
   for (MatrixIndexT row = 0; row < num_rows_; row++) {
     Real *row_data = RowData(row);
     const Real *other_row_data = A.RowData(row);
     MatrixIndexT num_cols = num_cols_;
     for (MatrixIndexT col = 0; col < num_cols; col++) {
       row_data[col] = std::max(row_data[col],
                                other_row_data[col]);
     }
   }
 }

◆ Min() [1/2]

Real Min ( ) const

Returns minimum element of matrix.

Definition at line 1728 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), CompressedMatrix::ComputeGlobalHeader(), MatrixBase< float >::Svd(), kaldi::UnitTestCuMatrixMin(), kaldi::UnitTestCuMatrixReduceMin(), kaldi::UnitTestMaxMin(), and Fmpe::Update().

                                  {
   KALDI_ASSERT(num_rows_ > 0 && num_cols_ > 0);
   Real ans= *data_;
   for (MatrixIndexT r = 0; r < num_rows_; r++)
     for (MatrixIndexT c = 0; c < num_cols_; c++)
       if (data_[c + stride_*r] < ans)
         ans = data_[c + stride_*r];
   return ans;
 }

◆ Min() [2/2]

void Min ( const MatrixBase< Real > & A )

Set, element-by-element, *this = min(*this, A)

Definition at line 1195 of file kaldi-matrix.cc.

                                                                             {
   KALDI_ASSERT(A.NumRows() == NumRows() && A.NumCols() == NumCols());
   for (MatrixIndexT row = 0; row < num_rows_; row++) {
     Real *row_data = RowData(row);
     const Real *other_row_data = A.RowData(row);
     MatrixIndexT num_cols = num_cols_;
     for (MatrixIndexT col = 0; col < num_cols; col++) {
       row_data[col] = std::min(row_data[col],
                                other_row_data[col]);
     }
   }
 }

◆ MinSingularValue()

Real MinSingularValue ( ) const

inline

Returns smallest singular value.

Definition at line 430 of file kaldi-matrix.h.

                                 {
     Vector<Real> tmp(std::min(NumRows(), NumCols()));
     Svd(&tmp);
     return tmp.Min();
   }

◆ MulColsVec()

void MulColsVec ( const VectorBase< Real > & scale )

Equivalent to (*this) = (*this) * diag(scale).

Scaling each column by a scalar taken from that dimension of the vector.

Definition at line 1319 of file kaldi-matrix.cc.

Referenced by kaldi::ApplyCmvn(), kaldi::ApplyCmvnReverse(), SpMatrix< float >::ApplyFloor(), SpMatrix< float >::ApplyPow(), MatrixBase< float >::ColRange(), AmSgmm2::ComponentPosteriors(), SvdApplier::DecomposeComponent(), SpMatrix< float >::LimitCond(), main(), MleAmSgmm2Updater::RenormalizeN(), kaldi::SolveQuadraticMatrixProblem(), MatrixBase< float >::SymPosSemiDefEig(), kaldi::UnitTestAddMatDiagVec(), kaldi::UnitTestCuMatrixMulColsVec(), kaldi::UnitTestEigSymmetric(), and kaldi::UnitTestScale().

                                                                {
   KALDI_ASSERT(scale.Dim() == num_cols_);
   for (MatrixIndexT i = 0; i < num_rows_; i++) {
     for (MatrixIndexT j = 0; j < num_cols_; j++) {
       Real this_scale = scale(j);
       (*this)(i, j) *= this_scale;
     }
   }
 }

◆ MulElements()

void MulElements ( const MatrixBase< Real > & A )

Element by element multiplication with a given matrix.

Definition at line 1140 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), DiagGmmNormal::CopyFromDiagGmm(), DiagGmm::CopyFromFullGmm(), DiagGmmNormal::CopyToDiagGmm(), DiagGmm::GetMeans(), DiagGmm::Merge(), DiagGmm::SetInvVars(), DiagGmm::SetInvVarsAndMeans(), DiagGmm::SetMeans(), kaldi::UnitTestAddMatMatElements(), kaldi::UnitTestCuDiffSoftmax(), kaldi::UnitTestCuMatrixApplyLog(), kaldi::UnitTestCuMatrixApplyPow(), kaldi::UnitTestCuMatrixMulElements(), kaldi::UnitTestCuMatrixSigmoid(), kaldi::UnitTestCuMatrixSoftHinge(), kaldi::UnitTestMulElements(), and kaldi::UnitTestSimpleForMat().

                                                             {
   KALDI_ASSERT(a.NumRows() == num_rows_ && a.NumCols() == num_cols_);
 
   if (num_cols_ == stride_ && num_cols_ == a.stride_) {
     mul_elements(num_rows_ * num_cols_, a.data_, data_);
   } else {
     MatrixIndexT a_stride = a.stride_, stride = stride_;
     Real *data = data_, *a_data = a.data_;
     for (MatrixIndexT i = 0; i < num_rows_; i++) {
       mul_elements(num_cols_, a_data, data);
       a_data += a_stride;
       data += stride;
     }
   }
 }

◆ MulRowsGroupMat()

void MulRowsGroupMat ( const MatrixBase< Real > & src )

Divide each row into src.NumCols() equal groups, and then scale i'th row's j'th group of elements by src(i, j).

Requires src.NumRows() == this->NumRows() and this->NumCols() % src.NumCols() == 0.

Definition at line 1238 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), kaldi::UnitTestCuMatrixDiffGroupPnorm(), and kaldi::UnitTestCuMatrixMulRowsGroupMat().

                                                                   {
   KALDI_ASSERT(src.NumRows() == this->NumRows() &&
                this->NumCols() % src.NumCols() == 0);
   int32 group_size = this->NumCols() / src.NumCols(),
       num_groups = this->NumCols() / group_size,
       num_rows = this->NumRows();
 
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     Real *data = this->RowData(i);
     for (MatrixIndexT j = 0; j < num_groups; j++, data += group_size) {
       Real scale = src(i, j);
       cblas_Xscal(group_size, scale, data, 1);
     }
   }
 }

◆ MulRowsVec()

void MulRowsVec ( const VectorBase< Real > & scale )

Equivalent to (*this) = diag(scale) * (*this).

Scaling each row by a scalar taken from that dimension of the vector.

Definition at line 1224 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), FeatureTransformEstimate::EstimateInternal(), AffineComponent::LimitRank(), LimitRankClass::operator()(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), KlHmm::PropagateFnc(), AccumDiagGmm::SmoothStats(), Plda::SmoothWithinClassCovariance(), kaldi::UnitTestCuDiffLogSoftmax(), kaldi::UnitTestCuDiffNormalizePerRow(), kaldi::UnitTestCuMathNormalizePerRow_v2(), kaldi::UnitTestCuMatrixDivRowsVec(), kaldi::UnitTestCuMatrixMulRowsVec(), kaldi::UnitTestScale(), and IvectorExtractorStats::UpdatePrior().

                                                                {
   KALDI_ASSERT(scale.Dim() == num_rows_);
   MatrixIndexT M = num_rows_, N = num_cols_;
 
   for (MatrixIndexT i = 0; i < M; i++) {
     Real this_scale = scale(i);
     for (MatrixIndexT j = 0; j < N; j++) {
       (*this)(i, j) *= this_scale;
     }
   }
 }

◆ NumCols()

MatrixIndexT NumCols ( ) const

inline

Returns number of columns (or zero for empty matrix).

Definition at line 67 of file kaldi-matrix.h.

67 { return num_cols_; }

kaldi::MatrixBase::num_cols_

MatrixIndexT num_cols_

these attributes store the real matrix size as it is stored in memory including memalignment ...

Definition: kaldi-matrix.h:812

◆ NumRows()

MatrixIndexT NumRows ( ) const

inline

Returns number of rows (or zero for empty matrix).

Definition at line 64 of file kaldi-matrix.h.

64 { return num_rows_; }

kaldi::MatrixBase::num_rows_

MatrixIndexT num_rows_

< Number of columns

Definition: kaldi-matrix.h:813

◆ operator()() [1/2]

Real& operator()	(	MatrixIndexT	r,
		MatrixIndexT	c
	)

inline

Indexing operator, non-const (only checks sizes if compiled with -DKALDI_PARANOID)

Definition at line 102 of file kaldi-matrix.h.

                                                             {
     KALDI_PARANOID_ASSERT(static_cast<UnsignedMatrixIndexT>(r) <
                           static_cast<UnsignedMatrixIndexT>(num_rows_) &&
                           static_cast<UnsignedMatrixIndexT>(c) <
                           static_cast<UnsignedMatrixIndexT>(num_cols_));
     return *(data_ + r * stride_ + c);
   }

◆ operator()() [2/2]

const Real operator()	(	MatrixIndexT	r,
		MatrixIndexT	c
	)		const

inline

Indexing operator, const (only checks sizes if compiled with -DKALDI_PARANOID)

Definition at line 115 of file kaldi-matrix.h.

                                                                       {
     KALDI_PARANOID_ASSERT(static_cast<UnsignedMatrixIndexT>(r) <
                           static_cast<UnsignedMatrixIndexT>(num_rows_) &&
                           static_cast<UnsignedMatrixIndexT>(c) <
                           static_cast<UnsignedMatrixIndexT>(num_cols_));
     return *(data_ + r * stride_ + c);
   }

◆ OrthogonalizeRows()

void OrthogonalizeRows ( )

This function orthogonalizes the rows of a matrix using the Gram-Schmidt process.

It is only applicable if NumRows() <= NumCols(). It will use random number generation to fill in rows with something nonzero, in cases where the original matrix was of deficient row rank.

Definition at line 1948 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp(), kaldi::ComputePca(), OnlineNaturalGradient::ReorthogonalizeRt1(), and OnlinePreconditioner::ReorthogonalizeXt1().

                                          {
   KALDI_ASSERT(NumRows() <= NumCols());
   MatrixIndexT num_rows = num_rows_;
   for (MatrixIndexT i = 0; i < num_rows; i++) {
     int32 counter = 0;
     while (1) {
       Real start_prod = VecVec(this->Row(i), this->Row(i));
       if (start_prod - start_prod != 0.0 || start_prod == 0.0) {
         KALDI_WARN << "Self-product of row " << i << " of matrix is "
                    << start_prod << ", randomizing.";
         this->Row(i).SetRandn();
         counter++;
         continue;  // loop again.
       }
       for (MatrixIndexT j = 0; j < i; j++) {
         Real prod = VecVec(this->Row(i), this->Row(j));
         this->Row(i).AddVec(-prod, this->Row(j));
       }
       Real end_prod = VecVec(this->Row(i), this->Row(i));
       if (end_prod <= 0.01 * start_prod) { // We removed
         // almost all of the vector during orthogonalization,
         // so we have reason to doubt (for roundoff reasons)
         // that it's still orthogonal to the other vectors.
         // We need to orthogonalize again.
         if (end_prod == 0.0) { // Row is exactly zero:
           // generate random direction.
           this->Row(i).SetRandn();
         }
         counter++;
         if (counter > 100)
           KALDI_ERR << "Loop detected while orthogalizing matrix.";
       } else {
         this->Row(i).Scale(1.0 / std::sqrt(end_prod));
         break;
       }
     }
   }
 }

◆ Pow()

void Pow	(	const MatrixBase< Real > &	src,
		Real	power
	)

Definition at line 2128 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyPow(), and MatrixBase< float >::MinSingularValue().

                                                                   {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col++) {
       row_data[col] = pow(src_row_data[col], power);
     }
   }
 }

◆ PowAbs()

void PowAbs	(	const MatrixBase< Real > &	src,
		Real	power,
		bool	include_sign = `false`
	)

Apply power to the absolute value of each element.

If include_sign is true, the result will be multiplied with the sign of the input value. If the power is negative and the input to the power is zero, The output will be set zero. If include_sign is true, it will multiply the result by the sign of the input.

Definition at line 2142 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyPowAbs(), and MatrixBase< float >::MinSingularValue().

                                                                                         {
   KALDI_ASSERT(SameDim(*this, src));
   MatrixIndexT num_rows = num_rows_, num_cols = num_cols_;
   Real *row_data = data_;
   const Real *src_row_data = src.Data();
   for (MatrixIndexT row = 0; row < num_rows;
        row++,row_data += stride_, src_row_data += src.stride_) {
     for (MatrixIndexT col = 0; col < num_cols; col ++) {
       if (include_sign == true && src_row_data[col] < 0) {
         row_data[col] = -pow(std::abs(src_row_data[col]), power);
       } else {
         row_data[col] = pow(std::abs(src_row_data[col]), power);
       }
     }
   }
 }

◆ Power()

bool Power ( Real pow )

The Power method attempts to take the matrix to a power using a method that works in general for fractional and negative powers.

The input matrix must be invertible and have reasonable condition (or we don't guarantee the results. The method is based on the eigenvalue decomposition. It will return false and leave the matrix unchanged, if at entry the matrix had real negative eigenvalues (or if it had zero eigenvalues and the power was negative).

Definition at line 2232 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyLog(), and kaldi::UnitTestNonsymmetricPower().

                                        {
   KALDI_ASSERT(num_rows_ > 0 && num_rows_ == num_cols_);
   MatrixIndexT n = num_rows_;
   Matrix<Real> P(n, n);
   Vector<Real> re(n), im(n);
   this->Eig(&P, &re, &im);
   // Now attempt to take the complex eigenvalues to this power.
   for (MatrixIndexT i = 0; i < n; i++)
     if (!AttemptComplexPower(&(re(i)), &(im(i)), power))
       return false;  // e.g. real and negative, or zero, eigenvalues.
 
   Matrix<Real> D(n, n);  // D to the power.
   CreateEigenvalueMatrix(re, im, &D);
 
   Matrix<Real> tmp(n, n);  // P times D
   tmp.AddMatMat(1.0, P, kNoTrans, D, kNoTrans, 0.0);  // tmp := P*D
   P.Invert();
   // next line is: *this = tmp * P^{-1} = P * D * P^{-1}
   (*this).AddMatMat(1.0, tmp, kNoTrans, P, kNoTrans, 0.0);
   return true;
 }

◆ Range()

SubMatrix<Real> Range	(	const MatrixIndexT	row_offset,
		const MatrixIndexT	num_rows,
		const MatrixIndexT	col_offset,
		const MatrixIndexT	num_cols
	)		const

inline

Return a sub-part of matrix.

Definition at line 202 of file kaldi-matrix.h.

Referenced by kaldi::nnet2::AppendDiscriminativeExamples(), kaldi::AppendFeats(), OnlineDeltaInput::AppendFrames(), kaldi::ApplyInvPreXformToChange(), kaldi::ApplyPreXformToGradient(), Fmpe::ApplyProjection(), kaldi::nnet2::AverageConstPart(), OnlineMatrixInput::Compute(), BasisFmllrEstimate::ComputeAmDiagPrecond(), kaldi::ComputeFmllrMatrixDiagGmmDiagonal(), AmSgmm2::ComputeFmllrPreXform(), Sgmm2Project::ComputeProjection(), LinearVtln::ComputeTransform(), BasisFmllrEstimate::ComputeTransform(), kaldi::ConcatFeats(), OnlineDeltaInput::DeltaComputation(), LdaEstimate::Estimate(), FeatureTransformEstimateMulti::Estimate(), FeatureTransformEstimate::EstimateInternal(), kaldi::ExtractObjectRange(), IvectorExtractorStats::FlushCache(), kaldi::FmllrAuxfGradient(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), kaldi::FmllrInnerUpdate(), FmllrSgmm2Accs::FmllrObjGradient(), FmllrRawAccs::FmllrRawAccs(), OnlineCacheInput::GetCachedData(), AmSgmm2::IncreasePhoneSpaceDim(), AmSgmm2::IncreaseSpkSpaceDim(), AmSgmm2::InitializeMw(), AmSgmm2::InitializeNu(), kaldi::nnet2::LatticeToDiscriminativeExample(), main(), kaldi::MergeFullGmm(), SoftmaxComponent::MixUp(), OnlineLdaInput::OnlineLdaInput(), OnlineTransform::OnlineTransform(), DiscriminativeExampleSplitter::OutputOneSplit(), Matrix< BaseFloat >::Resize(), FullGmm::Split(), DiagGmm::Split(), SpMatrix< float >::TopEigs(), UnitTestFullGmm(), and kaldi::UnitTestRange().

                                                                   {
     return SubMatrix<Real>(*this, row_offset, num_rows,
                            col_offset, num_cols);
   }

◆ Read()

void Read	(	std::istream &	in,
		bool	binary,
		bool	add = `false`
	)

stream read.

Use instead of stream<<*this, if you want to add to existing contents.

Definition at line 1423 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp(), Matrix< BaseFloat >::Matrix(), and kaldi::operator>>().

                                                                   {
   if (add) {
     Matrix<Real> tmp(num_rows_, num_cols_);
     tmp.Read(is, binary, false);  // read without adding.
     if (tmp.num_rows_ != this->num_rows_ || tmp.num_cols_ != this->num_cols_)
       KALDI_ERR << "MatrixBase::Read, size mismatch "
                 << this->num_rows_ << ", " << this->num_cols_
                 << " vs. " << tmp.num_rows_ << ", " << tmp.num_cols_;
     this->AddMat(1.0, tmp);
     return;
   }
   // now assume add == false.
 
   //  In order to avoid rewriting this, we just declare a Matrix and
   // use it to read the data, then copy.
   Matrix<Real> tmp;
   tmp.Read(is, binary, false);
   if (tmp.NumRows() != NumRows() || tmp.NumCols() != NumCols()) {
     KALDI_ERR << "MatrixBase<Real>::Read, size mismatch "
               << NumRows() << " x " << NumCols() << " versus "
               << tmp.NumRows() << " x " << tmp.NumCols();
   }
   CopyFromMat(tmp);
 }

◆ Row() [1/2]

const SubVector<Real> Row ( MatrixIndexT i ) const

inline

Return specific row of matrix [const].

Definition at line 188 of file kaldi-matrix.h.

Referenced by kaldi::AccCmvnStats(), kaldi::AccCmvnStatsForPair(), OnlineCmnInput::AcceptFrame(), OnlinePitchFeatureImpl::AcceptWaveform(), OnlineIvectorEstimationStats::AccStats(), kaldi::AccStatsForUtterance(), BasisFmllrAccus::AccuGradientScatter(), LdaEstimate::Accumulate(), KlHmm::Accumulate(), AccumFullGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateForComponent(), RegtreeMllrDiagGmmAccs::AccumulateForGaussian(), RegtreeMllrDiagGmmAccs::AccumulateForGmm(), kaldi::AccumulateForUtterance(), AccumFullGmm::AccumulateFromPosteriors(), FmllrRawAccs::AccumulateFromPosteriors(), MleAmSgmm2Accs::AccumulateFromPosteriors(), FmllrDiagGmmAccs::AccumulateFromPosteriorsPreselect(), kaldi::AccumulateTreeStats(), AccumDiagGmm::AddStatsForComponent(), kaldi::ApplyCmvn(), kaldi::ApplyCmvnReverse(), Fmpe::ApplyContext(), Fmpe::ApplyContextReverse(), Fmpe::ApplyProjection(), Fmpe::ApplyProjectionReverse(), kaldi::ApplySoftMaxPerRow(), kaldi::CalBasisFmllrStepSize(), kaldi::ClusterGaussiansToUbm(), IvectorExtractorStats::CommitStatsForM(), FullGmm::ComponentLogLikelihood(), DiagGmm::ComponentLogLikelihood(), AmSgmm2::ComponentLogLikes(), OnlineLdaInput::Compute(), OnlineDeltaInput::Compute(), BasisFmllrEstimate::ComputeAmDiagPrecond(), Fmpe::ComputeC(), IvectorExtractor::ComputeDerivedVars(), kaldi::ComputeFeatureNormalizingTransform(), AmSgmm2::ComputeFmllrPreXform(), FullGmm::ComputeGconsts(), Sgmm2Project::ComputeLdaStats(), kaldi::ComputeLdaTransform(), kaldi::ComputeMllrMatrix(), OnlineLdaInput::ComputeNextRemainder(), AmSgmm2::ComputeNormalizersInternal(), kaldi::ComputePca(), AmSgmm2::ComputePerFrameVars(), AmSgmm2::ComputePerSpkDerivedVars(), EbwAmSgmm2Updater::ComputePhoneVecStats(), ComputeScores(), OnlineCmvn::ComputeStatsForFrame(), BasisFmllrEstimate::ComputeTransform(), FmllrRawAccs::ConvertToSimpleStats(), FullGmmNormal::CopyFromFullGmm(), DiagGmm::CopyFromFullGmm(), MatrixBase< float >::CopyFromMat(), FullGmmNormal::CopyToFullGmm(), DiagGmm::DiagGmm(), kaldi::DiagGmmToStats(), LdaEstimate::Estimate(), BasisFmllrEstimate::EstimateFmllrBasis(), FeatureTransformEstimate::EstimateInternal(), kaldi::EstimateIvectorsOnline(), kaldi::FmllrAuxfGradient(), kaldi::FmllrAuxFuncDiagGmm(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), kaldi::FmllrInnerUpdate(), GaussClusterable::GaussClusterable(), kaldi::GenRandStats(), IvectorExtractor::GetAcousticAuxfMean(), IvectorExtractor::GetAcousticAuxfVariance(), FullGmm::GetComponentMean(), FullGmm::GetCovarsAndMeans(), kaldi::GetFeatureMeanAndVariance(), OnlineCacheFeature::GetFrames(), kaldi::GetGmmLike(), GetLogLikeTest(), LogisticRegression::GetLogPosteriors(), FullGmm::GetMeans(), LogisticRegression::GetObjfAndGrad(), DecodableNnetSimpleLooped::GetOutputForFrame(), OnlineCmvn::GetState(), AmSgmm2::GetSubstateSpeakerMean(), RegtreeMllrDiagGmm::GetTransformedMeans(), MatrixBase< float >::GroupPnorm(), kaldi::InitGmmFromRandomFrames(), IvectorExtractor::IvectorExtractor(), kaldi::nnet2::LatticeToDiscriminativeExample(), FullGmm::LogLikelihoodsPreselect(), DiagGmm::LogLikelihoodsPreselect(), DecodableAmDiagGmmRegtreeFmllr::LogLikelihoodZeroBased(), DecodableAmDiagGmmUnmapped::LogLikelihoodZeroBased(), DecodableAmDiagGmmRegtreeMllr::LogLikelihoodZeroBased(), CuMatrixBase< float >::LogSoftMaxPerRow(), main(), kaldi::MapDiagGmmUpdate(), FullGmm::Merge(), DiagGmm::Merge(), FullGmm::MergePreselect(), LogisticRegression::MixUp(), kaldi::MleDiagGmmUpdate(), kaldi::MleFullGmmUpdate(), kaldi::MllrAuxFunction(), MatrixBase< float >::OrthogonalizeRows(), OnlineCmnInput::OutputFrame(), FullGmm::Perturb(), DeltaFeatures::Process(), ShiftedDeltaFeatures::Process(), kaldi::nnet2::ProcessFile(), kaldi::nnet3::ProcessFile(), FullGmmNormal::Rand(), kaldi::unittest::RandDiagGaussFeatures(), kaldi::unittest::RandFullGaussFeatures(), kaldi::cu::Randomize(), AccumFullGmm::Read(), LdaEstimate::Read(), MleAmSgmm2Updater::RenormalizeV(), DiagGmm::SetComponentInvVar(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), FullGmm::SetMeans(), kaldi::ShiftFeatureMatrix(), AccumDiagGmm::SmoothWithAccum(), CuMatrixBase< float >::SoftMaxPerRow(), kaldi::SolveDoubleQuadraticMatrixProblem(), kaldi::SortSvd(), SparseMatrix< float >::SparseMatrix(), OnlineLdaInput::SpliceFrames(), FullGmm::Split(), DiagGmm::Split(), AmSgmm2::SplitSubstatesInGroup(), test_flags_driven_update(), test_io(), TestAmDiagGmmAccsIO(), TestComponentAcc(), kaldi::TestIvectorExtraction(), TestMllrAccsIO(), kaldi::TestOnlineCmnInput(), kaldi::TestOnlineFeatureMatrix(), kaldi::TestOnlineTransform(), TestSgmm2AccsIO(), TestSgmm2Fmllr(), TestSgmm2FmllrAccsIO(), TestSgmm2FmllrSubspace(), TestXformMean(), kaldi::TraceMatSmat(), kaldi::TransformIvectors(), kaldi::UnitTestAddDiagVecMat(), UnitTestArbitraryResample(), kaldi::UnitTestCompressedMatrix(), kaldi::UnitTestCuLogSoftmax(), kaldi::UnitTestCuMatrixApplyHeaviside(), kaldi::UnitTestCuMatrixApplyPow(), kaldi::UnitTestCuMatrixApplyPowAbs(), kaldi::UnitTestCuMatrixHeaviside(), kaldi::UnitTestCuSoftmax(), kaldi::UnitTestDeterminantSign(), UnitTestEstimateDiagGmm(), UnitTestEstimateFullGmm(), UnitTestEstimateLda(), UnitTestEstimateSgmm2(), UnitTestFullGmm(), UnitTestFullGmmEst(), kaldi::UnitTestGeneralMatrix(), UnitTestHTKCompare1(), UnitTestHTKCompare2(), UnitTestHTKCompare3(), UnitTestHTKCompare4(), UnitTestHTKCompare5(), UnitTestHTKCompare6(), UnitTestLinearResample(), UnitTestMleAmDiagGmm(), kaldi::UnitTestPosteriors(), UnitTestRegressionTree(), FmllrRawAccs::Update(), kaldi::UpdateEbwDiagGmm(), kaldi::nnet2::UpdateHash(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), PldaUnsupervisedAdaptor::UpdatePlda(), OnlineIvectorFeature::UpdateStatsForFrames(), EbwAmSgmm2Updater::UpdateU(), MleAmSgmm2Updater::UpdateU(), IvectorExtractorStats::UpdateVariances(), EbwAmSgmm2Updater::UpdateW(), MleAmSgmm2Updater::UpdateW(), IvectorExtractorStats::UpdateWeight(), MleAmSgmm2Updater::UpdateWGetStats(), MleSgmm2SpeakerAccs::UpdateWithU(), AccumFullGmm::Write(), and LdaEstimate::Write().

                                                          {
     KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                  static_cast<UnsignedMatrixIndexT>(num_rows_));
     return SubVector<Real>(data_ + (i * stride_), NumCols());
   }

◆ Row() [2/2]

SubVector<Real> Row ( MatrixIndexT i )

inline

Return specific row of matrix.

Definition at line 195 of file kaldi-matrix.h.

                                              {
     KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                  static_cast<UnsignedMatrixIndexT>(num_rows_));
     return SubVector<Real>(data_ + (i * stride_), NumCols());
   }

◆ RowData() [1/2]

Real* RowData ( MatrixIndexT i )

inline

Returns pointer to data for one row (non-const)

Definition at line 87 of file kaldi-matrix.h.

                                         {
     KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                  static_cast<UnsignedMatrixIndexT>(num_rows_));
     return data_ + i * stride_;
   }

◆ RowData() [2/2]

const Real* RowData ( MatrixIndexT i ) const

inline

Returns pointer to data for one row (const)

Definition at line 94 of file kaldi-matrix.h.

                                                    {
     KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                  static_cast<UnsignedMatrixIndexT>(num_rows_));
     return data_ + i * stride_;
   }

◆ RowRange()

SubMatrix<Real> RowRange	(	const MatrixIndexT	row_offset,
		const MatrixIndexT	num_rows
	)		const

inline

Definition at line 209 of file kaldi-matrix.h.

Referenced by DecodableMatrixMappedOffset::AcceptLoglikes(), kaldi::ComputeAndProcessKaldiPitch(), kaldi::ComputeKaldiPitchFirstPass(), NnetBatchComputer::FormatOutputs(), kaldi::nnet3::MergeTaskOutput(), OnlineCmvn::SmoothOnlineCmvnStats(), and UnitTestMatrixRandomizer().

                                                                      {
     return SubMatrix<Real>(*this, row_offset, num_rows, 0, num_cols_);
   }

◆ Scale()

void Scale ( Real alpha )

Multiply each element with a scalar value.

Definition at line 1209 of file kaldi-matrix.cc.

                                                                {
   if (alpha == 1.0) return;
   if (num_rows_ == 0) return;
   if (num_cols_ == stride_) {
     cblas_Xscal(static_cast<size_t>(num_rows_) * static_cast<size_t>(num_cols_),
                 alpha, data_,1);
   } else {
     Real *data = data_;
     for (MatrixIndexT i = 0; i < num_rows_; ++i, data += stride_) {
       cblas_Xscal(num_cols_, alpha, data,1);
     }
   }
 }

◆ Set()

void Set ( Real value )

Sets all elements to a specific value.

Definition at line 1339 of file kaldi-matrix.cc.

Referenced by LogisticRegression::GetLogPosteriors(), GeneralDropoutComponent::GetMemo(), main(), MatrixBase< float >::operator()(), DiagGmm::Resize(), kaldi::ResizeModel(), VectorClusterable::SetZero(), kaldi::UnitTestCuMatrixSet(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), kaldi::UnitTestSvdBad(), and kaldi::UnitTestTridiagonalize().

                                      {
   for (MatrixIndexT row = 0; row < num_rows_; row++) {
     for (MatrixIndexT col = 0; col < num_cols_; col++) {
       (*this)(row, col) = value;
     }
   }
 }

◆ SetMatMatDivMat()

void SetMatMatDivMat	(	const MatrixBase< Real > &	A,
		const MatrixBase< Real > &	B,
		const MatrixBase< Real > &	C
	)

*this = a * b / c (by element; when c = 0, *this = a)

o / i is either zero or "scale".

Just imagine the scale was 1.0. This is somehow true in

expectation; anyway, this case should basically never happen so it doesn't really matter.

Definition at line 189 of file kaldi-matrix.cc.

                                                                   {
   KALDI_ASSERT(A.NumRows() == B.NumRows() && A.NumCols() == B.NumCols());
   KALDI_ASSERT(A.NumRows() == C.NumRows() && A.NumCols() == C.NumCols());
   for (int32 r = 0; r < A.NumRows(); r++) { // each frame...
     for (int32 c = 0; c < A.NumCols(); c++) {
       BaseFloat i = C(r, c), o = B(r, c), od = A(r, c),
           id;
       if (i != 0.0) {
         id = od * (o / i); 
       } else {
         id = od; 
       }
       (*this)(r, c) = id;
     }
   }
 }

◆ SetRandn()

void SetRandn ( )

Sets to random values of a normal distribution.

Definition at line 1355 of file kaldi-matrix.cc.

                                 {
   kaldi::RandomState rstate;
   for (MatrixIndexT row = 0; row < num_rows_; row++) {
     Real *row_data = this->RowData(row);
     MatrixIndexT nc = (num_cols_ % 2 == 1) ? num_cols_ - 1 : num_cols_;
     for (MatrixIndexT col = 0; col < nc; col += 2) {
       kaldi::RandGauss2(row_data + col, row_data + col + 1, &rstate);
     }
     if (nc != num_cols_) row_data[nc] = static_cast<Real>(kaldi::RandGauss(&rstate));
   }
 }

◆ SetRandUniform()

void SetRandUniform ( )

Sets to numbers uniformly distributed on (0, 1)

Definition at line 1368 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::operator()(), kaldi::UnitTestCuMatrixApplyLog(), kaldi::UnitTestCuMatrixDivElements(), and kaldi::UnitTestSetRandUniform().

                                       {
   kaldi::RandomState rstate;
   for (MatrixIndexT row = 0; row < num_rows_; row++) {
     Real *row_data = this->RowData(row);
     for (MatrixIndexT col = 0; col < num_cols_; col++, row_data++) {
       *row_data = static_cast<Real>(kaldi::RandUniform(&rstate));
     }
   }
 }

◆ SetUnit()

void SetUnit ( )

Sets to zero, except ones along diagonal [for non-square matrices too].

Definition at line 1348 of file kaldi-matrix.cc.

Referenced by BasisFmllrAccus::AccuGradientScatter(), FmllrSgmm2Accs::AccumulateForFmllrSubspace(), kaldi::ComputeFmllrMatrixDiagGmm(), AmSgmm2::ComputeFmllrPreXform(), kaldi::ComputeMllrMatrix(), LinearVtln::ComputeTransform(), BasisFmllrEstimate::ComputeTransform(), MultiBasisComponent::InitData(), kaldi::InitFmllr(), main(), MatrixBase< float >::operator()(), kaldi::nnet3::PerturbImage(), TestSgmm2FmllrAccsIO(), TestSgmm2FmllrSubspace(), SpMatrix< float >::TopEigs(), SpMatrix< float >::Tridiagonalize(), kaldi::UnitTestFmllrDiagGmm(), kaldi::UnitTestFmllrDiagGmmDiagonal(), kaldi::UnitTestFmllrDiagGmmOffset(), kaldi::UnitTestFmllrRaw(), kaldi::UnitTestSimple(), RegtreeMllrDiagGmmAccs::Update(), RegtreeFmllrDiagGmmAccs::Update(), and IvectorExtractorStats::UpdatePrior().

                                {
   SetZero();
   for (MatrixIndexT row = 0; row < std::min(num_rows_, num_cols_); row++)
     (*this)(row, row) = 1.0;
 }

◆ SetZero()

void SetZero ( )

Sets matrix to zero.

Definition at line 1330 of file kaldi-matrix.cc.

Referenced by BasisFmllrEstimate::ComputeTransform(), SparseMatrix< float >::CopyToMat(), kaldi::CreateEigenvalueMatrix(), kaldi::generate_features(), OnlineCmvn::GetMostRecentCachedFrame(), IvectorExtractorStats::GetOrthogonalIvectorTransform(), MatrixBase< float >::operator()(), AccumFullGmm::Read(), LdaEstimate::Read(), AffineXformStats::SetZero(), AccumFullGmm::SetZero(), AccumDiagGmm::SetZero(), FmllrRawAccs::SetZero(), LogisticRegression::Train(), kaldi::UnitTestAddOuterProductPlusMinus(), kaldi::UnitTestDeterminant(), kaldi::UnitTestDiagGmm(), UnitTestFullGmm(), kaldi::UnitTestSimple(), kaldi::UnitTestSvd(), kaldi::UnitTestSvdZero(), FmllrSgmm2Accs::Update(), MleAmSgmm2Updater::UpdateW(), and LdaEstimate::ZeroAccumulators().

                                {
   if (num_cols_ == stride_)
     memset(data_, 0, sizeof(Real)*num_rows_*num_cols_);
   else
     for (MatrixIndexT row = 0; row < num_rows_; row++)
       memset(data_ + row*stride_, 0, sizeof(Real)*num_cols_);
 }

◆ Sigmoid()

void Sigmoid ( const MatrixBase< Real > & src )

Set each element to the sigmoid of the corresponding element of "src".

Definition at line 2978 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), kaldi::UnitTestCuMatrixSigmoid(), and kaldi::UnitTestSigmoid().

                                                           {
   KALDI_ASSERT(SameDim(*this, src));
 
   if (num_cols_ == stride_ && src.num_cols_ == src.stride_) {
     SubVector<Real> src_vec(src.data_, num_rows_ * num_cols_),
         dst_vec(this->data_, num_rows_ * num_cols_);
     dst_vec.Sigmoid(src_vec);
   } else {
     for (MatrixIndexT r = 0; r < num_rows_; r++) {
       SubVector<Real> src_vec(src, r), dest_vec(*this, r);
       dest_vec.Sigmoid(src_vec);
     }
   }
 }

◆ SizeInBytes()

size_t SizeInBytes ( ) const

inline

Returns size in bytes of the data held by the matrix.

Definition at line 73 of file kaldi-matrix.h.

                               {
     return static_cast<size_t>(num_rows_) * static_cast<size_t>(stride_) *
         sizeof(Real);
   }

◆ SoftHinge()

void SoftHinge ( const MatrixBase< Real > & src )

Set each element to y = log(1 + exp(x))

Definition at line 2778 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), kaldi::UnitTestCuMatrixSoftHinge(), and kaldi::UnitTestSoftHinge().

                                                             {
   KALDI_ASSERT(SameDim(*this, src));
   int32 num_rows = num_rows_, num_cols = num_cols_;
   for (MatrixIndexT r = 0; r < num_rows; r++) {
     Real *row_data = this->RowData(r);
     const Real *src_row_data = src.RowData(r);
     for (MatrixIndexT c = 0; c < num_cols; c++) {
       Real x = src_row_data[c], y;
       if (x > 10.0) y = x; // avoid exponentiating large numbers; function
       // approaches y=x.
       else y = Log1p(kaldi::Exp(x)); // these defined in kaldi-math.h
       row_data[c] = y;
     }
   }
 }

◆ Stride()

MatrixIndexT Stride ( ) const

inline

Stride (distance in memory between each row). Will be >= NumCols.

Definition at line 70 of file kaldi-matrix.h.

70 { return stride_; }

kaldi::MatrixBase::stride_

MatrixIndexT stride_

< Number of rows

Definition: kaldi-matrix.h:816

◆ Sum()

Real Sum ( ) const

Returns sum of all elements in matrix.

Definition at line 1170 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), AmSgmm2::ComponentPosteriors(), main(), kaldi::UnitTestAddMatMatNans(), kaldi::UnitTestCuMatrixReduceSum(), kaldi::UnitTestCuMatrixTraceMatMat(), kaldi::UnitTestPca(), kaldi::UnitTestRange(), kaldi::UnitTestScale(), kaldi::UnitTestSetRandn(), kaldi::UnitTestSetRandUniform(), kaldi::UnitTestSimpleForMat(), kaldi::UnitTestSparseMatrixSum(), and kaldi::UnitTestSymAddMat2().

                                  {
   double sum = 0.0;
 
   for (MatrixIndexT i = 0; i < num_rows_; i++) {
     for (MatrixIndexT j = 0; j < num_cols_; j++) {
       sum += (*this)(i, j);
     }
   }
 
   return (Real)sum;
 }

◆ Svd() [1/2]

void Svd	(	VectorBase< Real > *	s,
		MatrixBase< Real > *	U,
		MatrixBase< Real > *	Vt
	)		const

Compute SVD (*this) = U diag(s) Vt.

Note that the V in the call is already transposed; the normal formulation is U diag(s) V^T. Null pointers for U or V mean we don't want that output (this saves compute). The singular values are not sorted (use SortSvd for that).

Definition at line 1825 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ApplyLog(), MatrixBase< float >::Cond(), LdaEstimate::Estimate(), FeatureTransformEstimate::EstimateInternal(), MatrixBase< float >::MinSingularValue(), kaldi::nnet3::PrintParameterStats(), MatrixBase< float >::SymPosSemiDefEig(), kaldi::UnitTestDeterminantSign(), kaldi::UnitTestSvdBad(), kaldi::UnitTestSvdJustvec(), kaldi::UnitTestSvdNodestroy(), and kaldi::UnitTestSvdSpeed().

                                                                                                {
   try {
     if (num_rows_ >= num_cols_) {
       Matrix<Real> tmp(*this);
       tmp.DestructiveSvd(s, U, Vt);
     } else {
       Matrix<Real> tmp(*this, kTrans);  // transpose of *this.
       // rVt will have different dim so cannot transpose in-place --> use a temp matrix.
       Matrix<Real> Vt_Trans(Vt ? Vt->num_cols_ : 0, Vt ? Vt->num_rows_ : 0);
       // U will be transpose
       tmp.DestructiveSvd(s, Vt ? &Vt_Trans : NULL, U);
       if (U) U->Transpose();
       if (Vt) Vt->CopyFromMat(Vt_Trans, kTrans);  // copy with transpose.
     }
   } catch (...) {
     KALDI_ERR << "Error doing Svd (did not converge), first part of matrix is\n"
               << SubMatrix<Real>(*this, 0, std::min((MatrixIndexT)10, num_rows_),
                                  0, std::min((MatrixIndexT)10, num_cols_))
               << ", min and max are: " << Min() << ", " << Max();
   }
 }

◆ Svd() [2/2]

void Svd ( VectorBase< Real > * s ) const

inline

Compute SVD but only retain the singular values.

Definition at line 426 of file kaldi-matrix.h.

Referenced by MatrixBase< float >::Svd().

426 { Svd(s, NULL, NULL); }

kaldi::MatrixBase::Svd

void Svd(VectorBase< Real > *s, MatrixBase< Real > *U, MatrixBase< Real > *Vt) const

Compute SVD (*this) = U diag(s) Vt.

Definition: kaldi-matrix.cc:1825

◆ SymAddMat2()

void SymAddMat2	(	const Real	alpha,
		const MatrixBase< Real > &	M,
		MatrixTransposeType	transA,
		Real	beta
	)

*this = beta * *this + alpha * M M^T, for symmetric matrices.

It only updates the lower triangle of *this. It will leave the matrix asymmetric; if you need it symmetric as a regular matrix, do CopyLowerToUpper().

When the matrix dimension(this->num_rows_) is not less than 56 and the transpose type transA == kTrans, the cblas_Xsyrk(...) function will produce NaN in the output. This is a bug in the ATLAS library. To overcome this, the AddMatMat function, which calls cblas_Xgemm(...) rather than cblas_Xsyrk(...), is used in this special sitation. Wei Shi: Note this bug is observerd for single precision matrix on a 64-bit machine

Definition at line 233 of file kaldi-matrix.cc.

Referenced by kaldi::UnitTestAddMat2(), and kaldi::UnitTestSymAddMat2().

                                              {
   KALDI_ASSERT(num_rows_ == num_cols_ &&
                ((transA == kNoTrans && A.num_rows_ == num_rows_) ||
                 (transA == kTrans && A.num_cols_ == num_cols_)));
   KALDI_ASSERT(A.data_ != data_);
   if (num_rows_ == 0) return;
 
 #ifdef HAVE_ATLAS
   if (transA == kTrans && num_rows_ >= 56) {
     this->AddMatMat(alpha, A, kTrans, A, kNoTrans, beta);
     return;
   }
 #endif // HAVE_ATLAS
 
   MatrixIndexT A_other_dim = (transA == kNoTrans ? A.num_cols_ : A.num_rows_);
 
   // This function call is hard-coded to update the lower triangle.
   cblas_Xsyrk(transA, num_rows_, A_other_dim, alpha, A.Data(),
               A.Stride(), beta, this->data_, this->stride_);
 }

◆ SymPosSemiDefEig()

void SymPosSemiDefEig	(	VectorBase< Real > *	s,
		MatrixBase< Real > *	P,
		Real	check_thresh = `0.001`
	)

Uses Svd to compute the eigenvalue decomposition of a symmetric positive semi-definite matrix: (*this) = rP * diag(rS) * rP^T, with rP an orthogonal matrix so rP^{-1} = rP^T.

Throws exception if input was not positive semi-definite (check_thresh controls how stringent the check is; set it to 2 to ensure it won't ever complain, but it will zero out negative dimensions in your matrix.

Caution: if you want the eigenvalues, it may make more sense to convert to SpMatrix and use Eig() function there, which uses eigenvalue decomposition directly rather than SVD.

Definition at line 1996 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), and UnitTestEstimateFullGmm().

 {
   const MatrixIndexT D = num_rows_;
 
   KALDI_ASSERT(num_rows_ == num_cols_);
   KALDI_ASSERT(IsSymmetric() && "SymPosSemiDefEig: expecting input to be symmetrical.");
   KALDI_ASSERT(rU->num_rows_ == D && rU->num_cols_ == D && rs->Dim() == D);
 
   Matrix<Real>  Vt(D, D);
   Svd(rs, rU, &Vt);
 
   // First just zero any singular values if the column of U and V do not have +ve dot product--
   // this may mean we have small negative eigenvalues, and if we zero them the result will be closer to correct.
   for (MatrixIndexT i = 0;i < D;i++) {
     Real sum = 0.0;
     for (MatrixIndexT j = 0;j < D;j++) sum += (*rU)(j, i) * Vt(i, j);
     if (sum < 0.0) (*rs)(i) = 0.0;
   }
 
   {
     Matrix<Real> tmpU(*rU); Vector<Real> tmps(*rs); tmps.ApplyPow(0.5);
     tmpU.MulColsVec(tmps);
     SpMatrix<Real> tmpThis(D);
     tmpThis.AddMat2(1.0, tmpU, kNoTrans, 0.0);
     Matrix<Real> tmpThisFull(tmpThis);
     float new_norm = tmpThisFull.FrobeniusNorm();
     float old_norm = (*this).FrobeniusNorm();
     tmpThisFull.AddMat(-1.0, (*this));
 
     if (!(old_norm == 0 && new_norm == 0)) {
       float diff_norm = tmpThisFull.FrobeniusNorm();
       if (std::abs(new_norm-old_norm) > old_norm*check_thresh || diff_norm > old_norm*check_thresh) {
         KALDI_WARN << "SymPosSemiDefEig seems to have failed " << diff_norm << " !<< "
                    << check_thresh << "*" << old_norm << ", maybe matrix was not "
                    << "positive semi definite.  Continuing anyway.";
       }
     }
   }
 }

◆ Tanh()

void Tanh ( const MatrixBase< Real > & src )

Set each element to the tanh of the corresponding element of "src".

Definition at line 2762 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue(), kaldi::UnitTestCuTanh(), and kaldi::UnitTestTanh().

                                                        {
   KALDI_ASSERT(SameDim(*this, src));
 
   if (num_cols_ == stride_ && src.num_cols_ == src.stride_) {
     SubVector<Real> src_vec(src.data_, num_rows_ * num_cols_),
         dst_vec(this->data_, num_rows_ * num_cols_);
     dst_vec.Tanh(src_vec);
   } else {
     for (MatrixIndexT r = 0; r < num_rows_; r++) {
       SubVector<Real> src_vec(src, r), dest_vec(*this, r);
       dest_vec.Tanh(src_vec);
     }
   }
 }

◆ TestUninitialized()

void TestUninitialized ( ) const

Definition at line 1879 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::MinSingularValue().

                                                {
   MatrixIndexT R = num_rows_, C = num_cols_, positive = 0;
   for (MatrixIndexT i = 0; i < R; i++)
     for (MatrixIndexT j = 0; j < C; j++)
       if ((*this)(i, j) > 0.0) positive++;
   if (positive > R * C)
     KALDI_ERR << "Error....";
 }

◆ Trace()

Real Trace ( bool check_square = true ) const

Returns trace of matrix.

Definition at line 1709 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), kaldi::CuVectorUnitTestCopyDiagFromMat(), kaldi::TraceMat(), kaldi::UnitTestCuMatrixCopyLowerToUpper(), kaldi::UnitTestCuMatrixCopyUpperToLower(), and kaldi::UnitTestTrace().

                                                      {
   KALDI_ASSERT(!check_square || num_rows_ == num_cols_);
   Real ans = 0.0;
   for (MatrixIndexT r = 0;r < std::min(num_rows_, num_cols_);r++) ans += data_ [r + stride_*r];
   return ans;
 }

◆ Transpose()

void Transpose ( )

Transpose the matrix.

This one is only applicable to square matrices (the one in the Matrix child class works also for non-square.

Definition at line 2079 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::ColRange(), MatrixBase< float >::DestructiveSvd(), SpMatrix< float >::Eig(), Matrix< BaseFloat >::Matrix(), and MatrixBase< float >::Svd().

                                  {
   KALDI_ASSERT(num_rows_ == num_cols_);
   MatrixIndexT M = num_rows_;
   for (MatrixIndexT i = 0;i < M;i++)
     for (MatrixIndexT j = 0;j < i;j++) {
       Real &a = (*this)(i, j), &b = (*this)(j, i);
       std::swap(a, b);
     }
 }

◆ Write()

void Write	(	std::ostream &	out,
		bool	binary
	)		const

write to stream.

Definition at line 1379 of file kaldi-matrix.cc.

Referenced by MatrixBase< float >::AddTpTp(), main(), kaldi::UnitTestCompressedMatrix(), kaldi::UnitTestIo(), kaldi::UnitTestIoCross(), kaldi::UnitTestKeele(), kaldi::UnitTestKeeleNccfBallast(), kaldi::UnitTestPenaltyFactor(), kaldi::UnitTestProcess(), AffineXformStats::Write(), CompressedAffineXformStats::Write(), LogisticRegression::Write(), AccumFullGmm::Write(), LdaEstimate::Write(), Sgmm2FmllrGlobalParams::Write(), FullGmm::Write(), MleAmSgmm2Accs::Write(), Plda::Write(), CompressedMatrix::Write(), DiagGmm::Write(), Fmpe::Write(), OnlineGmmAdaptationState::Write(), OnlineCmvnState::Write(), LstmNonlinearityComponent::Write(), IvectorExtractorStats::Write(), CuMatrixBase< float >::Write(), and KlHmm::WriteData().

                                                               {
   if (!os.good()) {
     KALDI_ERR << "Failed to write matrix to stream: stream not good";
   }
   if (binary) {  // Use separate binary and text formats,
     // since in binary mode we need to know if it's float or double.
     std::string my_token = (sizeof(Real) == 4 ? "FM" : "DM");
 
     WriteToken(os, binary, my_token);
     {
       int32 rows = this->num_rows_;  // make the size 32-bit on disk.
       int32 cols = this->num_cols_;
       KALDI_ASSERT(this->num_rows_ == (MatrixIndexT) rows);
       KALDI_ASSERT(this->num_cols_ == (MatrixIndexT) cols);
       WriteBasicType(os, binary, rows);
       WriteBasicType(os, binary, cols);
     }
     if (Stride() == NumCols())
       os.write(reinterpret_cast<const char*> (Data()), sizeof(Real)
                * static_cast<size_t>(num_rows_) * static_cast<size_t>(num_cols_));
     else
       for (MatrixIndexT i = 0; i < num_rows_; i++)
         os.write(reinterpret_cast<const char*> (RowData(i)), sizeof(Real)
                  * num_cols_);
     if (!os.good()) {
       KALDI_ERR << "Failed to write matrix to stream";
     }
   } else {  // text mode.
     if (num_cols_ == 0) {
       os << " [ ]\n";
     } else {
       os << " [";
       for (MatrixIndexT i = 0; i < num_rows_; i++) {
         os << "\n  ";
         for (MatrixIndexT j = 0; j < num_cols_; j++)
           os << (*this)(i, j) << " ";
       }
       os << "]\n";
     }
   }
 }

Friends And Related Function Documentation

◆ CuMatrix< Real >

friend class CuMatrix< Real >

friend

Definition at line 55 of file kaldi-matrix.h.

◆ CuMatrixBase< Real >

friend class CuMatrixBase< Real >

friend

Definition at line 54 of file kaldi-matrix.h.

◆ CuPackedMatrix< Real >

friend class CuPackedMatrix< Real >

friend

Definition at line 57 of file kaldi-matrix.h.

◆ CuSubMatrix< Real >

friend class CuSubMatrix< Real >

friend

Definition at line 56 of file kaldi-matrix.h.

◆ kaldi::TraceMatMat

Real kaldi::TraceMatMat	(	const MatrixBase< Real > &	A,
		const MatrixBase< Real > &	B,
		MatrixTransposeType	trans
	)

friend

◆ Matrix< Real >

friend class Matrix< Real >

friend

Definition at line 52 of file kaldi-matrix.h.

◆ PackedMatrix< Real >

friend class PackedMatrix< Real >

friend

Definition at line 58 of file kaldi-matrix.h.

◆ SparseMatrix< double >

friend class SparseMatrix< double >

friend

Definition at line 61 of file kaldi-matrix.h.

◆ SparseMatrix< float >

friend class SparseMatrix< float >

friend

Definition at line 60 of file kaldi-matrix.h.

◆ SparseMatrix< Real >

friend class SparseMatrix< Real >

friend

Definition at line 59 of file kaldi-matrix.h.

◆ SubMatrix< Real >

friend class SubMatrix< Real >

friend

Definition at line 586 of file kaldi-matrix.h.

Member Data Documentation

◆ data_

Real* data_

protected

data memory area

Definition at line 808 of file kaldi-matrix.h.

◆ num_cols_

MatrixIndexT num_cols_

protected

these attributes store the real matrix size as it is stored in memory including memalignment

Definition at line 812 of file kaldi-matrix.h.

◆ num_rows_

MatrixIndexT num_rows_

protected

< Number of columns

Definition at line 813 of file kaldi-matrix.h.

◆ stride_

MatrixIndexT stride_

protected

< Number of rows

True number of columns for the internal matrix. This number may differ from num_cols_ as memory alignment might be used.

Definition at line 816 of file kaldi-matrix.h.

The documentation for this class was generated from the following files:

matrix/kaldi-matrix.h
matrix/kaldi-matrix.cc
cudamatrix/cu-matrix.h
cudamatrix/cu-vector.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

template<typename Real> class kaldi::MatrixBase< Real >

Constructor & Destructor Documentation

◆ MatrixBase() [1/2]

◆ MatrixBase() [2/2]

◆ ~MatrixBase()

Member Function Documentation

◆ Add()

◆ AddCols()

◆ AddDiagVecMat()

◆ AddMat()

◆ AddMatDiagVec()

◆ AddMatMat()

◆ AddMatMatElements()

◆ AddMatMatMat()

◆ AddMatSmat() [1/2]

◆ AddMatSmat() [2/2]

◆ AddMatSp()

◆ AddMatTp()

◆ AddRows() [1/2]

◆ AddRows() [2/2]

◆ AddSmat()

◆ AddSmatMat() [1/2]

◆ AddSmatMat() [2/2]

◆ AddSp()

◆ AddSpMat()

◆ AddSpMatSp()

◆ AddSpSp()

◆ AddToDiag()

◆ AddToRows() [1/2]

◆ AddToRows() [2/2]

◆ AddTpMat()

◆ AddTpTp()

◆ AddVecToCols()

◆ AddVecToRows()

◆ AddVecVec() [1/5]

◆ AddVecVec() [2/5]

◆ AddVecVec() [3/5]

◆ AddVecVec() [4/5]

◆ AddVecVec() [5/5]

◆ ApplyCeiling()

◆ ApplyExp()

◆ ApplyExpLimited()

◆ ApplyExpSpecial()

◆ ApplyFloor()

◆ ApplyHeaviside()

◆ ApplyLog()

◆ ApplyPow()

◆ ApplyPowAbs()

◆ ApplySoftMax()

◆ ApproxEqual()

◆ Ceiling()

◆ ColRange()

◆ Cond()

◆ CopyColFromVec()

◆ CopyCols()

◆ CopyColsFromVec()

◆ CopyDiagFromVec()

◆ CopyFromMat() [1/3]

◆ CopyFromMat() [2/3]

◆ CopyFromMat() [3/3]

◆ CopyFromSp() [1/3]

◆ CopyFromSp() [2/3]

◆ CopyFromSp() [3/3]

◆ CopyFromTp()

◆ CopyLowerToUpper()

◆ CopyRowFromVec()

◆ CopyRows() [1/2]

◆ CopyRows() [2/2]

◆ CopyRowsFromVec() [1/3]

◆ CopyRowsFromVec() [2/3]

◆ CopyRowsFromVec() [3/3]

◆ CopyToRows()

◆ CopyUpperToLower()

◆ Data() [1/2]

template<typename Real>
class kaldi::MatrixBase< Real >