Provides a vector abstraction class. More...

#include <kaldi-vector.h>

Inheritance diagram for VectorBase< Real >:

Collaboration diagram for VectorBase< Real >:

Public Member Functions
void	SetZero ()
	Set vector to all zeros. More...

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

void	Set (Real f)
	Set all members of a vector to a specified value. More...

void	SetRandn ()
	Set vector to random normally-distributed noise. More...

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

MatrixIndexT	RandCategorical () const
	This function returns a random index into this vector, chosen with probability proportional to the corresponding element. More...

MatrixIndexT	Dim () const
	Returns the dimension of the vector. More...

MatrixIndexT	SizeInBytes () const
	Returns the size in memory of the vector, in bytes. More...

Real *	Data ()
	Returns a pointer to the start of the vector's data. More...

const Real *	Data () const
	Returns a pointer to the start of the vector's data (const). More...

Real	operator() (MatrixIndexT i) const
	Indexing operator (const). More...

Real &	operator() (MatrixIndexT i)
	Indexing operator (non-const). More...

SubVector< Real >	Range (const MatrixIndexT o, const MatrixIndexT l)
	Returns a sub-vector of a vector (a range of elements). More...

const SubVector< Real >	Range (const MatrixIndexT o, const MatrixIndexT l) const
	Returns a const sub-vector of a vector (a range of elements). More...

void	CopyFromVec (const VectorBase< Real > &v)
	Copy data from another vector (must match own size). More...

template<typename OtherReal >
void	CopyFromPacked (const PackedMatrix< OtherReal > &M)
	Copy data from a SpMatrix or TpMatrix (must match own size). More...

template<typename OtherReal >
void	CopyFromVec (const VectorBase< OtherReal > &v)
	Copy data from another vector of different type (double vs. float) More...

template<typename OtherReal >
void	CopyFromVec (const CuVectorBase< OtherReal > &v)
	Copy from CuVector. This is defined in ../cudamatrix/cu-vector.h. More...

void	Floor (const VectorBase< Real > &v, Real floor_val, MatrixIndexT *floored_count=nullptr)
	Applies floor to all elements. More...

void	Ceiling (const VectorBase< Real > &v, Real ceil_val, MatrixIndexT *ceiled_count=nullptr)
	Applies ceiling to all elements. More...

void	Pow (const VectorBase< Real > &v, Real power)

void	ApplyLog ()
	Apply natural log to all elements. More...

void	ApplyLogAndCopy (const VectorBase< Real > &v)
	Apply natural log to another vector and put result in *this. More...

void	ApplyExp ()
	Apply exponential to each value in vector. More...

void	ApplyAbs ()
	Take absolute value of each of the elements. More...

void	ApplyFloor (Real floor_val, MatrixIndexT *floored_count=nullptr)
	Applies floor to all elements. More...

void	ApplyCeiling (Real ceil_val, MatrixIndexT *ceiled_count=nullptr)
	Applies ceiling to all elements. More...

MatrixIndexT	ApplyFloor (const VectorBase< Real > &floor_vec)
	Applies floor to all elements. Returns number of elements floored. More...

Real	ApplySoftMax ()
	Apply soft-max to vector and return normalizer (log sum of exponentials). More...

Real	ApplyLogSoftMax ()
	Applies log soft-max to vector and returns normalizer (log sum of exponentials). More...

void	Tanh (const VectorBase< Real > &src)
	Sets each element of *this to the tanh of the corresponding element of "src". More...

void	Sigmoid (const VectorBase< Real > &src)
	Sets each element of *this to the sigmoid function of the corresponding element of "src". More...

void	ApplyPow (Real power)
	Take all elements of vector to a power. More...

void	ApplyPowAbs (Real power, bool include_sign=false)
	Take the absolute value of all elements of a vector to a power. More...

Real	Norm (Real p) const
	Compute the p-th norm of the vector. More...

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

void	InvertElements ()
	Invert all elements. More...

template<typename OtherReal >
void	AddVec (const Real alpha, const VectorBase< OtherReal > &v)
	Add vector : this = this + alpha * rv (with casting between floats and doubles) More...

void	AddVec2 (const Real alpha, const VectorBase< Real > &v)
	Add vector : this = this + alpha * rv^2 [element-wise squaring]. More...

template<typename OtherReal >
void	AddVec2 (const Real alpha, const VectorBase< OtherReal > &v)
	Add vector : this = this + alpha * rv^2 [element-wise squaring], with casting between floats and doubles. More...

void	AddMatVec (const Real alpha, const MatrixBase< Real > &M, const MatrixTransposeType trans, const VectorBase< Real > &v, const Real beta)
	Add matrix times vector : this <– betathis + alphaM*v. More...

void	AddMatSvec (const Real alpha, const MatrixBase< Real > &M, const MatrixTransposeType trans, const VectorBase< Real > &v, const Real beta)
	This is as AddMatVec, except optimized for where v contains a lot of zeros. More...

void	AddSpVec (const Real alpha, const SpMatrix< Real > &M, const VectorBase< Real > &v, const Real beta)
	Add symmetric positive definite matrix times vector: this <– betathis + alphaM*v. More...

void	AddTpVec (const Real alpha, const TpMatrix< Real > &M, const MatrixTransposeType trans, const VectorBase< Real > &v, const Real beta)
	Add triangular matrix times vector: this <– betathis + alphaM*v. More...

void	ReplaceValue (Real orig, Real changed)
	Set each element to y = (x == orig ? changed : x). More...

void	MulElements (const VectorBase< Real > &v)
	Multiply element-by-element by another vector. More...

template<typename OtherReal >
void	MulElements (const VectorBase< OtherReal > &v)
	Multiply element-by-element by another vector of different type. More...

void	DivElements (const VectorBase< Real > &v)
	Divide element-by-element by a vector. More...

template<typename OtherReal >
void	DivElements (const VectorBase< OtherReal > &v)
	Divide element-by-element by a vector of different type. More...

void	Add (Real c)
	Add a constant to each element of a vector. More...

void	AddVecVec (Real alpha, const VectorBase< Real > &v, const VectorBase< Real > &r, Real beta)
	Add element-by-element product of vectors: More...

void	AddVecDivVec (Real alpha, const VectorBase< Real > &v, const VectorBase< Real > &r, Real beta)
	Add element-by-element quotient of two vectors. More...

void	Scale (Real alpha)
	Multiplies all elements by this constant. More...

void	MulTp (const TpMatrix< Real > &M, const MatrixTransposeType trans)
	Multiplies this vector by lower-triangular matrix: this <– this *M. More...

void	Solve (const TpMatrix< Real > &M, const MatrixTransposeType trans)
	If trans == kNoTrans, solves M x = b, where b is the value of this at input and x is the value of this at output. More...

void	CopyRowsFromMat (const MatrixBase< Real > &M)
	Performs a row stack of the matrix M. More...

template<typename OtherReal >
void	CopyRowsFromMat (const MatrixBase< OtherReal > &M)

void	CopyRowsFromMat (const CuMatrixBase< Real > &M)
	The following is implemented in ../cudamatrix/cu-matrix.cc. More...

void	CopyColsFromMat (const MatrixBase< Real > &M)
	Performs a column stack of the matrix M. More...

void	CopyRowFromMat (const MatrixBase< Real > &M, MatrixIndexT row)
	Extracts a row of the matrix M. More...

template<typename OtherReal >
void	CopyRowFromMat (const MatrixBase< OtherReal > &M, MatrixIndexT row)
	Extracts a row of the matrix M with type conversion. More...

template<typename OtherReal >
void	CopyRowFromSp (const SpMatrix< OtherReal > &S, MatrixIndexT row)
	Extracts a row of the symmetric matrix S. More...

template<typename OtherReal >
void	CopyColFromMat (const MatrixBase< OtherReal > &M, MatrixIndexT col)
	Extracts a column of the matrix M. More...

void	CopyDiagFromMat (const MatrixBase< Real > &M)
	Extracts the diagonal of the matrix M. More...

void	CopyDiagFromPacked (const PackedMatrix< Real > &M)
	Extracts the diagonal of a packed matrix M; works for Sp or Tp. More...

void	CopyDiagFromSp (const SpMatrix< Real > &M)
	Extracts the diagonal of a symmetric matrix. More...

void	CopyDiagFromTp (const TpMatrix< Real > &M)
	Extracts the diagonal of a triangular matrix. More...

Real	Max () const
	Returns the maximum value of any element, or -infinity for the empty vector. More...

Real	Max (MatrixIndexT *index) const
	Returns the maximum value of any element, and the associated index. More...

Real	Min () const
	Returns the minimum value of any element, or +infinity for the empty vector. More...

Real	Min (MatrixIndexT *index) const
	Returns the minimum value of any element, and the associated index. More...

Real	Sum () const
	Returns sum of the elements. More...

Real	SumLog () const
	Returns sum of the logs of the elements. More...

void	AddRowSumMat (Real alpha, const MatrixBase< Real > &M, Real beta=1.0)
	Does this = alpha (sum of rows of M) + beta * *this. More...

void	AddColSumMat (Real alpha, const MatrixBase< Real > &M, Real beta=1.0)
	Does this = alpha (sum of columns of M) + beta * *this. More...

void	AddDiagMat2 (Real alpha, const MatrixBase< Real > &M, MatrixTransposeType trans=kNoTrans, Real beta=1.0)
	Add the diagonal of a matrix times itself: this = diag(M M^T) + beta this (if trans == kNoTrans), or this = diag(M^T M) + beta * *this (if trans == kTrans). More...

void	AddDiagMatMat (Real alpha, const MatrixBase< Real > &M, MatrixTransposeType transM, const MatrixBase< Real > &N, MatrixTransposeType transN, Real beta=1.0)
	Add the diagonal of a matrix product: *this = diag(M N), assuming the "trans" arguments are both kNoTrans; for transpose arguments, it behaves as you would expect. More...

Real	LogSumExp (Real prune=-1.0) const
	Returns log(sum(exp())) without exp overflow If prune > 0.0, ignores terms less than the max - prune. More...

void	Read (std::istream &in, bool binary, bool add=false)
	Reads from C++ stream (option to add to existing contents). More...

void	Write (std::ostream &Out, bool binary) const
	Writes to C++ stream (option to write in binary). More...

template<>
void	AddVec (const float alpha, const VectorBase< float > &rv)

template<>
void	AddVec (const double alpha, const VectorBase< double > &rv)

template<>
void	AddVec (const float alpha, const VectorBase< float > &v)

template<>
void	AddVec (const double alpha, const VectorBase< double > &v)

Protected Member Functions
	~VectorBase ()
	Destructor; does not deallocate memory, this is handled by child classes. More...

	VectorBase ()
	Empty initializer, corresponds to vector of zero size. More...

void	CopyFromPtr (const Real *Data, MatrixIndexT sz)
	Load data into the vector: sz must match own size. More...

	KALDI_DISALLOW_COPY_AND_ASSIGN (VectorBase)

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

MatrixIndexT	dim_
	dimension of vector More...

Friends
class	VectorBase< double >

class	VectorBase< float >

class	CuVectorBase< Real >

class	CuVector< Real >

Detailed Description

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

Provides a vector abstraction class.

This class provides a way to work with vectors in kaldi. It encapsulates basic operations and memory optimizations.

Definition at line 41 of file kaldi-vector.h.

Constructor & Destructor Documentation

◆ ~VectorBase()

~VectorBase ( )

inlineprotected

Destructor; does not deallocate memory, this is handled by child classes.

This destructor is protected so this object can only be deleted via a child.

Definition at line 376 of file kaldi-vector.h.

376 {}

◆ VectorBase()

VectorBase ( )

inlineexplicitprotected

Empty initializer, corresponds to vector of zero size.

Definition at line 379 of file kaldi-vector.h.

                        : data_(NULL), dim_(0) {
     KALDI_ASSERT_IS_FLOATING_TYPE(Real);
   }

Member Function Documentation

◆ Add()

void Add ( Real c )

Add a constant to each element of a vector.

Definition at line 956 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), AmSgmm2::ComponentLogLikes(), kaldi::ComputeCorrelation(), OnlinePreconditioner::ComputeZt(), OnlineNaturalGradient::ComputeZt(), IvectorExtractor::GetAcousticAuxfWeight(), LogisticRegression::GetLogPosteriors(), Plda::GetNormalizationFactor(), ConstantComponent::InitFromConfig(), ConstantFunctionComponent::InitFromConfig(), Plda::LogLikelihoodRatio(), main(), kaldi::nnet1::MomentStatistics(), OnlinePitchFeatureImpl::OnlinePitchFeatureImpl(), PdfPrior::PdfPrior(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlinePreconditioner::PreconditionDirectionsInternal(), OnlineNaturalGradient::PreconditionDirectionsInternal(), kaldi::ProcessWindow(), AccumDiagGmm::SmoothStats(), AccumDiagGmm::SmoothWithModel(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleAmSgmm2Updater::UpdateSubstateWeights(), MleAmSgmm2Updater::UpdateW(), MleAmSgmm2Updater::UpdateWGetStats(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                  {
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] += c;
   }
 }

◆ AddColSumMat()

void AddColSumMat	(	Real	alpha,
		const MatrixBase< Real > &	M,
		Real	beta = `1.0`
	)

Does *this = alpha * (sum of columns of M) + beta * *this.

Definition at line 734 of file kaldi-vector.cc.

Referenced by VectorBase< float >::CopyDiagFromTp(), kaldi::CuVectorUnitTestAddColSumMat(), KlHmm::PropagateFnc(), kaldi::UnitTestAddColSumMatSpeed(), kaldi::UnitTestCuDiffLogSoftmax(), kaldi::UnitTestCuVectorAddColSumMat(), kaldi::UnitTestCuVectorAddColSumMatLarge(), and kaldi::UnitTestSimpleForVec().

                                                                                     {
   KALDI_ASSERT(dim_ == M.NumRows());
   MatrixIndexT num_cols = M.NumCols();
 
   // implement the function according to a dimension cutoff for computation efficiency
   if (num_cols <= 64) {
     for (MatrixIndexT i = 0; i < dim_; i++) {
       double sum = 0.0;
       const Real *src = M.RowData(i);
       for (MatrixIndexT j = 0; j < num_cols; j++)
         sum += src[j];
       data_[i] = alpha * sum + beta * data_[i];
     }
   } else {
     Vector<Real> ones(M.NumCols());
     ones.Set(1.0);
     this->AddMatVec(alpha, M, kNoTrans, ones, beta);
   }
 }

◆ AddDiagMat2()

void AddDiagMat2	(	Real	alpha,
		const MatrixBase< Real > &	M,
		MatrixTransposeType	trans = `kNoTrans`,
		Real	beta = `1.0`
	)

Add the diagonal of a matrix times itself: *this = diag(M M^T) + beta * *this (if trans == kNoTrans), or *this = diag(M^T M) + beta * *this (if trans == kTrans).

Definition at line 1304 of file kaldi-vector.cc.

Referenced by VectorBase< float >::CopyDiagFromTp(), kaldi::CuVectorUnitTestAddDiagMat2(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), kaldi::SlidingWindowCmnInternal(), kaldi::UnitTestAddDiagMat2(), and kaldi::UnitTestCuDiffNormalizePerRow().

                                           {
   if (trans == kNoTrans) {
     KALDI_ASSERT(this->dim_ == M.NumRows());
     MatrixIndexT rows = this->dim_, cols = M.NumCols(),
            mat_stride = M.Stride();
     Real *data = this->data_;
     const Real *mat_data = M.Data();
     for (MatrixIndexT i = 0; i < rows; i++, mat_data += mat_stride, data++)
       *data = beta * *data + alpha * cblas_Xdot(cols,mat_data,1,mat_data,1);
   } else {
     KALDI_ASSERT(this->dim_ == M.NumCols());
     MatrixIndexT rows = M.NumRows(), cols = this->dim_,
            mat_stride = M.Stride();
     Real *data = this->data_;
     const Real *mat_data = M.Data();
     for (MatrixIndexT i = 0; i < cols; i++, mat_data++, data++)
       *data = beta * *data + alpha * cblas_Xdot(rows, mat_data, mat_stride,
                                                  mat_data, mat_stride);
   }
 }

◆ AddDiagMatMat()

void AddDiagMatMat	(	Real	alpha,
		const MatrixBase< Real > &	M,
		MatrixTransposeType	transM,
		const MatrixBase< Real > &	N,
		MatrixTransposeType	transN,
		Real	beta = `1.0`
	)

Add the diagonal of a matrix product: *this = diag(M N), assuming the "trans" arguments are both kNoTrans; for transpose arguments, it behaves as you would expect.

Definition at line 1328 of file kaldi-vector.cc.

Referenced by VectorBase< float >::CopyDiagFromTp(), kaldi::UnitTestAddDiagMatMat(), kaldi::UnitTestCuDiffNormalizePerRow(), and kaldi::UnitTestCuDiffSoftmax().

                {
   MatrixIndexT dim = this->dim_,
       M_col_dim = (transM == kTrans ? M.NumRows() : M.NumCols()),
       N_row_dim = (transN == kTrans ? N.NumCols() : N.NumRows());
   KALDI_ASSERT(M_col_dim == N_row_dim); // this is the dimension we sum over
   MatrixIndexT M_row_stride = M.Stride(), M_col_stride = 1;
   if (transM == kTrans) std::swap(M_row_stride, M_col_stride);
   MatrixIndexT N_row_stride = N.Stride(), N_col_stride = 1;
   if (transN == kTrans) std::swap(N_row_stride, N_col_stride);
 
   Real *data = this->data_;
   const Real *Mdata = M.Data(), *Ndata = N.Data();
   for (MatrixIndexT i = 0; i < dim; i++, Mdata += M_row_stride, Ndata += N_col_stride, data++) {
     *data = beta * *data + alpha * cblas_Xdot(M_col_dim, Mdata, M_col_stride, Ndata, N_row_stride);
   }
 }

◆ AddMatSvec()

void AddMatSvec	(	const Real	alpha,
		const MatrixBase< Real > &	M,
		const MatrixTransposeType	trans,
		const VectorBase< Real > &	v,
		const Real	beta
	)

This is as AddMatVec, except optimized for where v contains a lot of zeros.

Definition at line 105 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), and kaldi::UnitTestVecmul().

                                                    {
   KALDI_ASSERT((trans == kNoTrans && M.NumCols() == v.dim_ && M.NumRows() == dim_)
                || (trans == kTrans && M.NumRows() == v.dim_ && M.NumCols() == dim_));
   KALDI_ASSERT(&v != this);
   Xgemv_sparsevec(trans, M.NumRows(), M.NumCols(), alpha, M.Data(), M.Stride(),
                   v.Data(), 1, beta, data_, 1);
   return;
   /*
   MatrixIndexT this_dim = this->dim_, v_dim = v.dim_,
       M_stride = M.Stride();
   Real *this_data = this->data_;
   const Real *M_data = M.Data(), *v_data = v.data_;
   if (beta != 1.0) this->Scale(beta);
   if (trans == kNoTrans) {
     for (MatrixIndexT i = 0; i < v_dim; i++) {
       Real v_i = v_data[i];
       if (v_i == 0.0) continue;
       // Add to *this, the i'th column of the Matrix, times v_i.
       cblas_Xaxpy(this_dim, v_i * alpha, M_data + i, M_stride, this_data, 1);
     }
   } else { // The transposed case is slightly more efficient, I guess.
     for (MatrixIndexT i = 0; i < v_dim; i++) {
       Real v_i = v.data_[i];
       if (v_i == 0.0) continue;
       // Add to *this, the i'th row of the Matrix, times v_i.
       cblas_Xaxpy(this_dim, v_i * alpha,
                   M_data + (i * M_stride), 1, this_data, 1);
     }
     }*/
 }

◆ AddMatVec()

void AddMatVec	(	const Real	alpha,
		const MatrixBase< Real > &	M,
		const MatrixTransposeType	trans,
		const VectorBase< Real > &	v,
		const Real	beta
	)

Add matrix times vector : this <– beta*this + alpha*M*v.

Calls BLAS GEMV.

Definition at line 92 of file kaldi-vector.cc.

Referenced by OnlineIvectorEstimationStats::AccStats(), MleSgmm2SpeakerAccs::AccumulateFromPosteriors(), LdaEstimate::AddMeanOffset(), kaldi::ApplyAffineTransform(), ApplyFmllrXform(), VectorBase< float >::ApplyPow(), Fmpe::ApplyProjection(), Plda::ApplyTransform(), IvectorExtractorStats::CommitStatsForWPoint(), AmSgmm2::ComponentLogLikes(), MfccComputer::Compute(), kaldi::ComputeAmGmmFeatureDeriv(), Plda::ComputeDerivedVars(), AmSgmm2::ComputeFmllrPreXform(), MleAmSgmm2Updater::ComputeSMeans(), FmllrRawAccs::ConvertToSimpleStats(), kaldi::CuVectorUnitTestAddMatVec(), BasisFmllrEstimate::EstimateFmllrBasis(), FeatureTransformEstimateMulti::EstimateTransformPart(), kaldi::generate_features(), IvectorExtractor::GetAcousticAuxfMean(), IvectorExtractor::GetAcousticAuxfWeight(), kaldi::GetFeatDeriv(), OnlineTransform::GetFrame(), IvectorExtractor::GetIvectorDistMean(), IvectorExtractor::GetIvectorDistWeight(), LogisticRegression::GetLogPosteriors(), IvectorExtractorStats::GetOrthogonalIvectorTransform(), RegtreeMllrDiagGmm::GetTransformedMeans(), FullGmm::LogLikelihoods(), DiagGmm::LogLikelihoods(), DiagGmm::LogLikelihoodsPreselect(), DecodableAmDiagGmmUnmapped::LogLikelihoodZeroBased(), DecodableAmDiagGmmRegtreeMllr::LogLikelihoodZeroBased(), main(), MleAmSgmm2Updater::RenormalizeV(), kaldi::SolveDoubleQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), Plda::TransformIvector(), UnitTestEstimateLda(), kaldi::UnitTestMul(), kaldi::UnitTestPldaEstimation(), FmllrRawAccs::Update(), EbwAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleSgmm2SpeakerAccs::UpdateWithU(), and kaldi::VecMatVec().

                                                    {
   KALDI_ASSERT((trans == kNoTrans && M.NumCols() == v.dim_ && M.NumRows() == dim_)
                || (trans == kTrans && M.NumRows() == v.dim_ && M.NumCols() == dim_));
   KALDI_ASSERT(&v != this);
   cblas_Xgemv(trans, M.NumRows(), M.NumCols(), alpha, M.Data(), M.Stride(),
               v.Data(), 1, beta, data_, 1);
 }

◆ AddRowSumMat()

void AddRowSumMat	(	Real	alpha,
		const MatrixBase< Real > &	M,
		Real	beta = `1.0`
	)

Does *this = alpha * (sum of rows of M) + beta * *this.

Definition at line 714 of file kaldi-vector.cc.

Referenced by CovarianceStats::AccStats(), PldaStats::AddSamples(), IvectorExtractorStats::CommitStatsForW(), VectorBase< float >::CopyDiagFromTp(), kaldi::CuVectorUnitTestAddRowSumMat(), kaldi::EstPca(), LdaEstimate::GetStats(), main(), AmSgmm2::SplitSubstatesInGroup(), kaldi::TestOnlineCmnInput(), kaldi::UnitTestAddRowSumMatSpeed(), kaldi::UnitTestCuVectorAddRowSumMat(), kaldi::UnitTestCuVectorAddRowSumMatLarge(), UnitTestEstimateFullGmm(), EbwAmSgmm2Updater::Update(), MleAmSgmm2Updater::Update(), and kaldi::nnet2::UpdateHash().

                                                                                     {
   KALDI_ASSERT(dim_ == M.NumCols());
   MatrixIndexT num_rows = M.NumRows(), stride = M.Stride(), dim = dim_;
   Real *data = data_;
 
   // implement the function according to a dimension cutoff for computation efficiency
   if (num_rows <= 64) {
     cblas_Xscal(dim, beta, data, 1);
     const Real *m_data = M.Data();
     for (MatrixIndexT i = 0; i < num_rows; i++, m_data += stride)
       cblas_Xaxpy(dim, alpha, m_data, 1, data, 1);
 
   } else {
     Vector<Real> ones(M.NumRows());
     ones.Set(1.0);
     this->AddMatVec(alpha, M, kTrans, ones, beta);
   }
 }

◆ AddSpVec()

void AddSpVec	(	const Real	alpha,
		const SpMatrix< Real > &	M,
		const VectorBase< Real > &	v,
		const Real	beta
	)

Add symmetric positive definite matrix times vector: this <– beta*this + alpha*M*v.

Calls BLAS SPMV.

Definition at line 141 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), kaldi::CalBasisFmllrStepSize(), AmSgmm2::ComputePerFrameVars(), FullGmmNormal::CopyToFullGmm(), kaldi::CuVectorUnitTestAddSpVec(), kaldi::FmllrAuxfGradient(), kaldi::FmllrAuxFuncDiagGmm(), kaldi::FmllrInnerUpdate(), IvectorExtractor::GetAcousticAuxfMean(), FullGmm::GetComponentMean(), IvectorExtractor::GetIvectorDistribution(), PldaEstimator::GetStatsFromClassMeans(), main(), kaldi::MllrAuxFunction(), FullGmm::SetInvCovars(), FullGmm::SetInvCovarsAndMeans(), kaldi::SolveQuadraticProblem(), AmSgmm2::SplitSubstatesInGroup(), SpMatrix< float >::TopEigs(), kaldi::UnitTestLbfgs(), kaldi::UnitTestLinearCgd(), kaldi::UnitTestMul(), kaldi::UnitTestSolve(), MlltAccs::Update(), EbwAmSgmm2Updater::UpdatePhoneVectorsInternal(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                                   {
   KALDI_ASSERT(M.NumRows() == v.dim_ && dim_ == v.dim_);
   KALDI_ASSERT(&v != this);
   cblas_Xspmv(alpha, M.NumRows(), M.Data(), v.Data(), 1, beta, data_, 1);
 }

◆ AddTpVec()

void AddTpVec	(	const Real	alpha,
		const TpMatrix< Real > &	M,
		const MatrixTransposeType	trans,
		const VectorBase< Real > &	v,
		const Real	beta
	)

Add triangular matrix times vector: this <– beta*this + alpha*M*v.

Works even if rv == *this.

Definition at line 1263 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), FastNnetCombiner::ComputeCurrentNnet(), FastNnetCombiner::ComputeObjfAndGradient(), FullGmmNormal::Rand(), kaldi::UnitTestCuVectorAddTp(), kaldi::UnitTestCuVectorAddTpVec(), kaldi::UnitTestMul(), and kaldi::UnitTestTriVecSolver().

                                                  {
   KALDI_ASSERT(dim_ == v.dim_ && dim_ == M.NumRows());
   if (beta == 0.0) {
     if (&v != this) CopyFromVec(v);
     MulTp(M, trans);
     if (alpha != 1.0) Scale(alpha);
   } else {
     Vector<Real> tmp(v);
     tmp.MulTp(M, trans);
     if (beta != 1.0) Scale(beta);  // *this <-- beta * *this
     AddVec(alpha, tmp);          // *this += alpha * M * v
   }
 }

◆ AddVec() [1/5]

void AddVec	(	const float	alpha,
		const VectorBase< float > &	rv
	)

◆ AddVec() [2/5]

void AddVec< double >	(	const double	alpha,
		const VectorBase< double > &	rv
	)

◆ AddVec() [3/5]

void AddVec	(	const float	alpha,
		const VectorBase< float > &	v
	)

Definition at line 75 of file kaldi-vector.cc.

                                                            {
   KALDI_ASSERT(dim_ == v.dim_);
   KALDI_ASSERT(&v != this);
   cblas_Xaxpy(dim_, alpha, v.Data(), 1, data_, 1);
 }

◆ AddVec() [4/5]

void AddVec	(	const double	alpha,
		const VectorBase< double > &	v
	)

Definition at line 84 of file kaldi-vector.cc.

                                                              {
   KALDI_ASSERT(dim_ == v.dim_);
   KALDI_ASSERT(&v != this);
   cblas_Xaxpy(dim_, alpha, v.Data(), 1, data_, 1);
 }

◆ AddVec() [5/5]

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

Add vector : *this = *this + alpha * rv (with casting between floats and doubles)

Definition at line 1044 of file kaldi-vector.cc.

Referenced by OptimizeLbfgs< Real >::AcceptStep(), OnlineIvectorEstimationStats::AccStats(), AccumFullGmm::AccumulateFromPosteriors(), FmllrRawAccs::AccumulateFromPosteriors(), AccumDiagGmm::AccumulateFromPosteriors(), MleAmSgmm2Accs::AccumulateFromPosteriors(), MleSgmm2SpeakerAccs::AccumulateFromPosteriors(), RestrictedAttentionComponent::Add(), AccumDiagGmm::Add(), IvectorExtractorStats::Add(), kaldi::ApplyCmvn(), VectorBase< float >::ApplyPow(), Fmpe::ApplyProjection(), VectorBase< float >::ApproxEqual(), IvectorExtractorStats::CommitStatsForM(), IvectorExtractorStats::CommitStatsForPrior(), AmSgmm2::ComponentLogLikes(), kaldi::ComputeAmGmmFeatureDeriv(), kaldi::ComputeAndSubtractMean(), PitchFrameInfo::ComputeBacktraces(), Fmpe::ComputeC(), kaldi::ComputeFeatureNormalizingTransform(), AmSgmm2::ComputeFmllrPreXform(), AmSgmm2::ComputeGammaI(), Sgmm2Project::ComputeLdaStats(), kaldi::ComputeLocalCost(), OptimizeLbfgs< Real >::ComputeNewDirection(), PldaEstimator::ComputeObjfPart2(), EbwAmSgmm2Updater::ComputePhoneVecStats(), BasisFmllrEstimate::ComputeTransform(), CompressedAffineXformStats::CopyFromAffineXformStats(), kaldi::DiagGmmToStats(), kaldi::EBWUpdateGaussian(), kaldi::FmllrInnerUpdate(), kaldi::GenRandStats(), kaldi::GetFeatureMeanAndVariance(), IvectorExtractor::GetIvectorDistribution(), GetLogLikeTest(), PldaEstimator::GetStatsFromClassMeans(), AmSgmm2::GetSubstateSpeakerMean(), kaldi::LinearCgd(), Plda::LogLikelihoodRatio(), main(), FullGmm::Merge(), DiagGmm::merged_components_logdet(), FullGmm::MergedComponentsLogdet(), SoftmaxComponent::MixUp(), kaldi::operator>>(), OnlineCmnInput::OutputFrame(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), kaldi::nnet2::PrintPriorDiagnostics(), kaldi::nnet3::PrintPriorDiagnostics(), DeltaFeatures::Process(), ShiftedDeltaFeatures::Process(), AccumFullGmm::Read(), LdaEstimate::Read(), OptimizeLbfgs< Real >::Restart(), kaldi::SlidingWindowCmnInternal(), Plda::SmoothWithinClassCovariance(), kaldi::SolveQuadraticProblem(), RestrictedAttentionComponent::StoreStats(), kaldi::TestClusterKMeansVector(), kaldi::TestOnlineCmnInput(), SpMatrix< float >::TopEigs(), kaldi::TypeOneUsage(), kaldi::TypeThreeUsage(), kaldi::UnitTestAddDiagMat2(), kaldi::UnitTestAddDiagMatMat(), kaldi::UnitTestAddDiagVecMat(), kaldi::UnitTestAddVecCross(), kaldi::UnitTestCuVectorAddColSumMat(), kaldi::UnitTestCuVectorAddColSumMatLarge(), kaldi::UnitTestCuVectorAddRowSumMat(), kaldi::UnitTestCuVectorAddRowSumMatLarge(), kaldi::UnitTestCuVectorAddVec(), UnitTestEstimateDiagGmm(), UnitTestEstimateLda(), kaldi::UnitTestEstimateMmieDiagGmm(), kaldi::UnitTestLbfgs(), kaldi::UnitTestLinearCgd(), kaldi::UnitTestSparseVectorAddToVec(), kaldi::UpdateEbwDiagGmm(), EbwAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), PldaUnsupervisedAdaptor::UpdatePlda(), EbwAmSgmm2Updater::UpdateU(), MleAmSgmm2Updater::UpdateU(), EbwAmSgmm2Updater::UpdateW(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                                                               {
   KALDI_ASSERT(dim_ == v.dim_);
   // remove __restrict__ if it causes compilation problems.
   Real *__restrict__ data = data_;
   OtherReal *__restrict__ other_data = v.data_;
   MatrixIndexT dim = dim_;
   if (alpha != 1.0)
     for (MatrixIndexT i = 0; i < dim; i++)
       data[i] += alpha * other_data[i];
   else
     for (MatrixIndexT i = 0; i < dim; i++)
       data[i] += other_data[i];
 }

◆ AddVec2() [1/2]

void AddVec2	(	const Real	alpha,
		const VectorBase< Real > &	v
	)

Add vector : *this = *this + alpha * rv^2 [element-wise squaring].

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

Referenced by VectorBase< float >::ApplyPow(), RegressionTree::BuildTree(), kaldi::ClusterGaussiansToUbm(), BasisFmllrEstimate::ComputeAmDiagPrecond(), SvdApplier::DecomposeComponent(), kaldi::DiagGmmToStats(), kaldi::EBWUpdateGaussian(), kaldi::GetFeatureMeanAndVariance(), kaldi::InitGmmFromRandomFrames(), main(), DiagGmm::merged_components_logdet(), DiagGmm::MergeKmeans(), kaldi::SlidingWindowCmnInternal(), kaldi::UnitTestAddVecCross(), UnitTestEstimateDiagGmm(), and kaldi::UnitTestEstimateMmieDiagGmm().

                                                                           {
   KALDI_ASSERT(dim_ == v.dim_);
   for (MatrixIndexT i = 0; i < dim_; i++)
     data_[i] += alpha * v.data_[i] * v.data_[i];
 }

◆ AddVec2() [2/2]

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

Add vector : *this = *this + alpha * rv^2 [element-wise squaring], with casting between floats and doubles.

Definition at line 1065 of file kaldi-vector.cc.

                                                                                {
   KALDI_ASSERT(dim_ == v.dim_);
   // remove __restrict__ if it causes compilation problems.
   Real *__restrict__ data = data_;
   OtherReal *__restrict__ other_data = v.data_;
   MatrixIndexT dim = dim_;
   if (alpha != 1.0)
     for (MatrixIndexT i = 0; i < dim; i++)
       data[i] += alpha * other_data[i] * other_data[i];
   else
     for (MatrixIndexT i = 0; i < dim; i++)
       data[i] += other_data[i] * other_data[i];
 }

◆ AddVecDivVec()

void AddVecDivVec	(	Real	alpha,
		const VectorBase< Real > &	v,
		const VectorBase< Real > &	r,
		Real	beta
	)

Add element-by-element quotient of two vectors.

this <—- alpha*v/r + beta*this

Definition at line 1034 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), main(), and kaldi::UnitTestSimpleForVec().

                                                                            {
   KALDI_ASSERT((dim_ == v.dim_ && dim_ == rr.dim_));
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] = alpha * v.data_[i]/rr.data_[i] + beta * data_[i] ;
   }
 }

◆ AddVecVec()

void AddVecVec	(	Real	alpha,
		const VectorBase< Real > &	v,
		const VectorBase< Real > &	r,
		Real	beta
	)

Add element-by-element product of vectors:

Definition at line 1000 of file kaldi-vector.cc.

Referenced by FmllrRawAccs::AccumulateFromPosteriors(), VectorBase< float >::ApplyPow(), MleAmSgmm2Accs::CommitStatsForSpk(), kaldi::ComputeAmGmmFeatureDeriv(), kaldi::ComputeLocalCost(), OptimizeLbfgs< Real >::ComputeNewDirection(), kaldi::CuVectorUnitTestAddVecVec(), kaldi::ExtendWaveWithSilence(), kaldi::GetFeatDeriv(), and BatchNormComponent::Info().

                                                                        {
   KALDI_ASSERT(v.data_ != this->data_ && r.data_ != this->data_);
   // We pretend that v is a band-diagonal matrix.
   KALDI_ASSERT(dim_ == v.dim_ && dim_ == r.dim_);
   cblas_Xgbmv(kNoTrans, dim_, dim_, 0, 0, alpha, v.data_, 1,
               r.data_, 1, beta, this->data_, 1);
 }

◆ ApplyAbs()

void ApplyAbs ( )

Take absolute value of each of the elements.

Definition at line 807 of file kaldi-vector.cc.

Referenced by kaldi::CuVectorUnitTestSum(), kaldi::nnet3::PrintPriorDiagnostics(), kaldi::nnet2::PrintPriorDiagnostics(), VectorBase< float >::Range(), and kaldi::UnitTestTopEigs().

                                 {
   for (MatrixIndexT i = 0; i < dim_; i++) { data_[i] = std::abs(data_[i]); }
 }

◆ ApplyCeiling()

void ApplyCeiling	(	Real	ceil_val,
		MatrixIndexT *	ceiled_count = `nullptr`
	)

inline

Applies ceiling to all elements.

Returns number of elements changed in ceiled_count if it is non-null.

Definition at line 155 of file kaldi-vector.h.

Referenced by kaldi::CuVectorUnitTestApplyCeiling(), FeatureTransformEstimate::EstimateInternal(), and kaldi::UnitTestFloorCeiling().

                                                                                 {
     this->Ceiling(*this, ceil_val, ceiled_count);
   };

◆ ApplyExp()

void ApplyExp ( )

Apply exponential to each value in vector.

Definition at line 800 of file kaldi-vector.cc.

Referenced by ComputeLogPosteriors(), kaldi::nnet2::ComputeObjfAndGradient(), IvectorExtractor::GetAcousticAuxfWeight(), VectorBase< float >::Range(), kaldi::nnet2::ShrinkNnet(), kaldi::nnet3::TestNnetDecodable(), kaldi::nnet2::UnitTestAmNnet(), kaldi::nnet2::UnitTestNnetDecodable(), kaldi::UnitTestPosteriors(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleAmSgmm2Updater::UpdateWGetStats(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                 {
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] = Exp(data_[i]);
   }
 }

◆ ApplyFloor() [1/2]

void ApplyFloor	(	Real	floor_val,
		MatrixIndexT *	floored_count = `nullptr`
	)

inline

Applies floor to all elements.

Returns number of elements floored in floored_count if it is non-null.

Definition at line 149 of file kaldi-vector.h.

Referenced by VectorBase< float >::ApplyCeiling(), Plda::ApplyTransform(), SpectrogramComputer::Compute(), FbankComputer::Compute(), AmSgmm2::ComputeFmllrPreXform(), kaldi::ComputeNormalizingTransform(), kaldi::CuVectorUnitTestApplyFloor(), PldaEstimator::GetOutput(), BatchNormComponent::Info(), NonlinearComponent::Info(), IvectorExtractor::InvertWithFlooring(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditioner::PreconditionDirectionsInternal(), OnlineNaturalGradient::PreconditionDirectionsInternal(), kaldi::SlidingWindowCmnInternal(), kaldi::SolveQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), SpMatrix< float >::SymPosSemiDefEig(), kaldi::UnitTestCuDiffNormalizePerRow(), kaldi::UnitTestFloorCeiling(), IvectorExtractorStats::UpdatePrior(), MleAmSgmm2Updater::UpdateVars(), and NonlinearComponent::Write().

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

◆ ApplyFloor() [2/2]

MatrixIndexT ApplyFloor ( const VectorBase< Real > & floor_vec )

Applies floor to all elements. Returns number of elements floored.

Definition at line 854 of file kaldi-vector.cc.

                                                                            {
   KALDI_ASSERT(floor_vec.Dim() == dim_);
   MatrixIndexT num_floored = 0;
   for (MatrixIndexT i = 0; i < dim_; i++) {
     if (data_[i] < floor_vec(i)) {
       data_[i] = floor_vec(i);
       num_floored++;
     }
   }
   return num_floored;
 }

◆ ApplyLog()

void ApplyLog ( )

Apply natural log to all elements.

Throw if any element of the vector is negative (but doesn't complain about zero; the log will be -infinity

Definition at line 783 of file kaldi-vector.cc.

Referenced by AmSgmm2::ComponentLogLikes(), FbankComputer::Compute(), kaldi::FrameLevelLpp(), IvectorExtractor::GetAcousticAuxfWeight(), PdfPrior::PdfPrior(), VectorBase< float >::Range(), LogisticRegression::ScalePriors(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                 {
   for (MatrixIndexT i = 0; i < dim_; i++) {
     if (data_[i] < 0.0)
       KALDI_ERR << "Trying to take log of a negative number.";
     data_[i] = Log(data_[i]);
   }
 }

◆ ApplyLogAndCopy()

void ApplyLogAndCopy ( const VectorBase< Real > & v )

Apply natural log to another vector and put result in *this.

Definition at line 792 of file kaldi-vector.cc.

Referenced by VectorBase< float >::Range(), and kaldi::UnitTestSimple().

                                                                 {
   KALDI_ASSERT(dim_ == v.Dim());
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] = Log(v(i));
   }
 }

◆ ApplyLogSoftMax()

Real ApplyLogSoftMax ( )

Applies log soft-max to vector and returns normalizer (log sum of exponentials).

This is the same as: $x(i) = x(i) - log(\sum_i exp(x(i)))$

Definition at line 877 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyCeiling(), and kaldi::UnitTestSimpleForVec().

                                        {
   Real max = this->Max(), sum = 0.0;
   for (MatrixIndexT i = 0; i < dim_; i++) {
     sum += Exp((data_[i] -= max));
   }
   sum = Log(sum);
   this->Add(-1.0 * sum);
   return max + sum;
 }

◆ ApplyPow()

void ApplyPow ( Real power )

inline

Take all elements of vector to a power.

Definition at line 179 of file kaldi-vector.h.

Referenced by AccumDiagGmm::AccumulateForComponent(), AccumDiagGmm::AccumulateFromPosteriors(), SpMatrix< float >::ApplyFloor(), SpMatrix< float >::ApplyPow(), DiagGmm::ComponentLogLikelihood(), FbankComputer::Compute(), PlpComputer::Compute(), OnlinePreconditioner::ComputeEt(), OnlineNaturalGradient::ComputeEt(), kaldi::ComputeNormalizingTransform(), kaldi::CuVectorUnitTestApplyPow(), Plda::GetNormalizationFactor(), BatchNormComponent::Info(), NonlinearComponent::Info(), Plda::LogLikelihoodRatio(), DiagGmm::LogLikelihoods(), main(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlinePreconditioner::PreconditionDirectionsInternal(), OnlineNaturalGradient::PreconditionDirectionsInternal(), kaldi::SlidingWindowCmnInternal(), Plda::SmoothWithinClassCovariance(), kaldi::SolveQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), MatrixBase< float >::SymPosSemiDefEig(), UnitTestEstimateDiagGmm(), kaldi::UnitTestEstimateMmieDiagGmm(), kaldi::UnitTestPower(), IvectorExtractorStats::UpdatePrior(), and NonlinearComponent::Write().

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

◆ ApplyPowAbs()

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

Take the absolute value of all elements of a vector to a power.

Include the sign of the input element if include_sign == true. If power is negative and the input value is zero, the output is set zero.

Definition at line 479 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), and kaldi::UnitTestPowerAbs().

                                                                 {
   if (power == 1.0)
     for (MatrixIndexT i = 0; i < dim_; i++)
       data_[i] = (include_sign && data_[i] < 0 ? -1 : 1) * std::abs(data_[i]);
   if (power == 2.0) {
     for (MatrixIndexT i = 0; i < dim_; i++)
       data_[i] = (include_sign && data_[i] < 0 ? -1 : 1) * data_[i] * data_[i];
   } else if (power == 0.5) {
     for (MatrixIndexT i = 0; i < dim_; i++) {
       data_[i] = (include_sign && data_[i] < 0 ? -1 : 1) * std::sqrt(std::abs(data_[i]));
     }
   } else if (power < 0.0) {
     for (MatrixIndexT i = 0; i < dim_; i++) {
       data_[i] = (data_[i] == 0.0 ? 0.0 : pow(std::abs(data_[i]), power));
       data_[i] *= (include_sign && data_[i] < 0 ? -1 : 1);
       if (data_[i] == HUGE_VAL) {  // HUGE_VAL is what errno returns on error.
         KALDI_ERR << "Could not raise element "  << i << "to power "
                   << power << ": returned value = " << data_[i];
       }
     }
   } else {
     for (MatrixIndexT i = 0; i < dim_; i++) {
       data_[i] = (include_sign && data_[i] < 0 ? -1 : 1) * pow(std::abs(data_[i]), power);
       if (data_[i] == HUGE_VAL) {  // HUGE_VAL is what errno returns on error.
         KALDI_ERR << "Could not raise element "  << i << "to power "
                   << power << ": returned value = " << data_[i];
       }
     }
   }
 }

◆ ApplySoftMax()

Real ApplySoftMax ( )

Apply soft-max to vector and return normalizer (log sum of exponentials).

This is the same as: $x(i) = exp(x(i)) / \sum_i exp(x(i))$

Definition at line 867 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyCeiling(), Fmpe::ApplyProjection(), Fmpe::ApplyProjectionReverse(), IvectorExtractorStats::CommitStatsForWPoint(), FullGmm::ComponentPosteriors(), DiagGmm::ComponentPosteriors(), AmSgmm2::ComputeFmllrPreXform(), kaldi::CuVectorUnitTestApplySoftMax(), IvectorExtractor::GetIvectorDistWeight(), main(), and EbwAmSgmm2Updater::UpdatePhoneVectorsInternal().

                                     {
   Real max = this->Max(), sum = 0.0;
   for (MatrixIndexT i = 0; i < dim_; i++) {
     sum += (data_[i] = Exp(data_[i] - max));
   }
   this->Scale(1.0 / sum);
   return max + Log(sum);
 }

◆ ApproxEqual()

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

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

Definition at line 556 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), kaldi::ApproxEqual(), AccumDiagGmm::AssertEqual(), kaldi::AssertEqual(), kaldi::CuVectorUnitTestCopyDiagFromPacked(), FmllrRawAccs::DataHasChanged(), FmllrDiagGmmAccs::DataHasChanged(), and kaldi::UnitTestNorm().

                                                                                  {
   if (dim_ != other.dim_) KALDI_ERR << "ApproxEqual: size mismatch "
                                     << dim_ << " vs. " << other.dim_;
   KALDI_ASSERT(tol >= 0.0);
   if (tol != 0.0) {
     Vector<Real> tmp(*this);
     tmp.AddVec(-1.0, other);
     return (tmp.Norm(2.0) <= static_cast<Real>(tol) * this->Norm(2.0));
   } else { // Test for exact equality.
     const Real *data = data_;
     const Real *other_data = other.data_;
     for (MatrixIndexT dim = dim_, i = 0; i < dim; i++)
       if (data[i] != other_data[i]) return false;
     return true;
   }
 }

◆ Ceiling()

void Ceiling	(	const VectorBase< Real > &	v,
		Real	ceil_val,
		MatrixIndexT *	ceiled_count = `nullptr`
	)

Applies ceiling to all elements.

Returns number of elements changed in ceiled_count if it is non-null.

Definition at line 833 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyCeiling(), and VectorBase< float >::Range().

                                                                                                    {
   KALDI_ASSERT(dim_ == v.dim_);
   if (ceiled_count == nullptr) {
     for (MatrixIndexT i = 0; i < dim_; i++) {
       data_[i] = std::min(v.data_[i], ceil_val);
     }
   } else {
     MatrixIndexT num_changed = 0;
     for (MatrixIndexT i = 0; i < dim_; i++) {
       if (v.data_[i] > ceil_val) {
         data_[i] = ceil_val;
         num_changed++;
       } else {
         data_[i] = v.data_[i];
       }
     }
     *ceiled_count = num_changed;
   }
 }

◆ CopyColFromMat()

template void CopyColFromMat	(	const MatrixBase< OtherReal > &	M,
		MatrixIndexT	col
	)

Extracts a column of the matrix M.

Definition at line 656 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), kaldi::ComputeVadEnergy(), kaldi::generate_features(), kaldi::IncreaseTransformDimension(), main(), kaldi::TestOnlineLdaInput(), TestSgmm2PreXform(), kaldi::UnitTestAddDiagVecMat(), kaldi::UnitTestRow(), kaldi::UnitTestSimpleForVec(), kaldi::UnitTestSnipEdges(), and kaldi::UnitTestSpliceRows().

                                                                                         {
   KALDI_ASSERT(col < mat.NumCols());
   KALDI_ASSERT(dim_ == mat.NumRows());
   for (MatrixIndexT i = 0; i < dim_; i++)
     data_[i] = mat(i, col);
   // can't do this very efficiently so don't really bother. could improve this though.
 }

◆ CopyColsFromMat()

void CopyColsFromMat ( const MatrixBase< Real > & M )

Performs a column stack of the matrix M.

Definition at line 390 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), and kaldi::UnitTestSpliceRows().

                                                                   {
   KALDI_ASSERT(dim_ == mat.NumCols() * mat.NumRows());
 
   Real*       inc_data = data_;
   const MatrixIndexT  cols     = mat.NumCols(), rows = mat.NumRows(), stride = mat.Stride();
   const Real *mat_inc_data = mat.Data();
 
   for (MatrixIndexT i = 0; i < cols; i++) {
     for (MatrixIndexT j = 0; j < rows; j++) {
       inc_data[j] = mat_inc_data[j*stride];
     }
     mat_inc_data++;
     inc_data += rows;
   }
 }

◆ CopyDiagFromMat()

void CopyDiagFromMat ( const MatrixBase< Real > & M )

Extracts the diagonal of the matrix M.

Definition at line 674 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), kaldi::CuVectorUnitTestCopyDiagFromMat(), kaldi::UnitTestAddDiagMat2(), kaldi::UnitTestAddDiagMatMat(), kaldi::UnitTestSpliceRows(), and kaldi::UnitTestTopEigs().

                                                                 {
   KALDI_ASSERT(dim_ == std::min(M.NumRows(), M.NumCols()));
   cblas_Xcopy(dim_, M.Data(), M.Stride() + 1, data_, 1);
 }

◆ CopyDiagFromPacked()

void CopyDiagFromPacked ( const PackedMatrix< Real > & M )

Extracts the diagonal of a packed matrix M; works for Sp or Tp.

Definition at line 680 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), VectorBase< float >::CopyDiagFromSp(), VectorBase< float >::CopyDiagFromTp(), DiagGmm::CopyFromFullGmm(), kaldi::CuVectorUnitTestCopyDiagFromPacked(), and SpMatrix< float >::Eig().

                                                                      {
   KALDI_ASSERT(dim_ == M.NumCols());
   for (MatrixIndexT i = 0; i < dim_; i++)
     data_[i] = M(i, i);
   // could make this more efficient.
 }

◆ CopyDiagFromSp()

void CopyDiagFromSp ( const SpMatrix< Real > & M )

inline

Extracts the diagonal of a symmetric matrix.

Definition at line 309 of file kaldi-vector.h.

Referenced by kaldi::SolveQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), and SpMatrix< float >::TopEigs().

309 { CopyDiagFromPacked(M); }

kaldi::VectorBase::CopyDiagFromPacked

void CopyDiagFromPacked(const PackedMatrix< Real > &M)

Extracts the diagonal of a packed matrix M; works for Sp or Tp.

Definition: kaldi-vector.cc:680

◆ CopyDiagFromTp()

void CopyDiagFromTp ( const TpMatrix< Real > & M )

inline

Extracts the diagonal of a triangular matrix.

Definition at line 312 of file kaldi-vector.h.

312 { CopyDiagFromPacked(M); }

kaldi::VectorBase::CopyDiagFromPacked

void CopyDiagFromPacked(const PackedMatrix< Real > &M)

Extracts the diagonal of a packed matrix M; works for Sp or Tp.

Definition: kaldi-vector.cc:680

◆ CopyFromPacked()

template void CopyFromPacked ( const PackedMatrix< OtherReal > & M )

Copy data from a SpMatrix or TpMatrix (must match own size).

Definition at line 237 of file kaldi-vector.cc.

Referenced by VectorBase< float >::Range().

                                                                       {
   SubVector<OtherReal> v(M);
   this->CopyFromVec(v);
 }

◆ CopyFromPtr()

void CopyFromPtr	(	const Real *	Data,
		MatrixIndexT	sz
	)

protected

Load data into the vector: sz must match own size.

Load data into the vector.

Definition at line 249 of file kaldi-vector.cc.

Referenced by VectorBase< float >::VectorBase().

                                                                     {
   KALDI_ASSERT(dim_ == sz);
   std::memcpy(this->data_, data, Dim() * sizeof(Real));
 }

◆ CopyFromVec() [1/3]

void CopyFromVec ( const VectorBase< Real > & v )

Copy data from another vector (must match own size).

Copy data from another vector.

Definition at line 228 of file kaldi-vector.cc.

Referenced by OptimizeLbfgs< Real >::AcceptStep(), RegtreeMllrDiagGmmAccs::AccumulateForGaussian(), RegtreeMllrDiagGmmAccs::AccumulateForGmm(), AccumFullGmm::AccumulateFromPosteriors(), BatchedXvectorComputer::AddChunkToBatch(), kaldi::ApplyAffineTransform(), Fmpe::ApplyC(), Plda::ApplyTransform(), kaldi::ClusterGaussiansToUbm(), kaldi::nnet2::CombineNnets(), kaldi::nnet2::CombineNnetsA(), FullGmm::ComponentPosteriors(), DiagGmm::ComponentPosteriors(), SpectrogramComputer::Compute(), kaldi::ComputeAndSubtractMean(), OnlinePreconditioner::ComputeEt(), OnlineNaturalGradient::ComputeEt(), kaldi::ComputeFeatureNormalizingTransform(), OnlineGenericBaseFeature< C >::ComputeFeatures(), OnlineLdaInput::ComputeNextRemainder(), EbwAmSgmm2Updater::ComputePhoneVecStats(), OnlineCmvn::ComputeStatsForFrame(), LstmNonlinearityComponent::ConsolidateMemory(), FmllrRawAccs::ConvertToSimpleStats(), kaldi::ConvolveSignals(), DiagGmmNormal::CopyFromDiagGmm(), FullGmmNormal::CopyFromFullGmm(), CuVectorBase< float >::CopyToVec(), kaldi::CuVectorUnitTestCopyCross2(), DiscriminativeExampleSplitter::DoExcise(), kaldi::EBWUpdateGaussian(), DecodableNnetSimple::EnsureFrameIsComputed(), OnlinePitchFeatureImpl::ExtractFrame(), kaldi::ExtractObjectRange(), kaldi::ExtractRowRangeWithPadding(), kaldi::FFTbasedBlockConvolveSignals(), kaldi::FFTbasedConvolveSignals(), kaldi::FilterMatrixRows(), FullGmm::GetComponentMean(), FullGmm::GetCovarsAndMeans(), kaldi::GetFeatureMeanAndVariance(), OnlineGenericBaseFeature< C >::GetFrame(), OnlineMatrixFeature::GetFrame(), OnlineIvectorFeature::GetFrame(), OnlineTransform::GetFrame(), OnlineCacheFeature::GetFrame(), IvectorExtractor::GetIvectorDistribution(), RegtreeFmllrDiagGmm::GetLogDets(), LogisticRegression::GetLogPosteriors(), FullGmm::GetMeans(), LogisticRegression::GetObjfAndGrad(), DecodableNnetSimple::GetOutputForFrame(), DecodableNnetSimpleLooped::GetOutputForFrame(), SentenceAveragingComponent::GetParams(), OnlineCmvn::GetState(), AmSgmm2::GetSubstateMean(), AmSgmm2::GetVarScaledSubstateSpeakerMean(), kaldi::IsmoothStatsDiagGmm(), IvectorExtractor::IvectorExtractor(), kaldi::LinearCgd(), FullGmm::LogLikelihoods(), DiagGmm::LogLikelihoods(), DiagGmm::LogLikelihoodsPreselect(), main(), DiagGmm::merged_components_logdet(), FullGmm::MergedComponentsLogdet(), DiagGmm::MergeKmeans(), SoftmaxComponent::MixUp(), Vector< float >::operator=(), OnlineCmnInput::OutputFrame(), OnlinePreconditionerSimple::PreconditionDirections(), OnlineNaturalGradientSimple::PreconditionDirections(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), kaldi::nnet3::ProcessFile(), kaldi::nnet2::ProcessFile(), FullGmmNormal::Rand(), VectorBase< float >::Range(), OnlineVectorSource::Read(), kaldi::RealFftInefficient(), OptimizeLbfgs< Real >::Restart(), kaldi::ReverseFrames(), kaldi::nnet3::RunNnetComputation(), DiagGmm::SetComponentInvVar(), FullGmm::SetInvCovars(), kaldi::SlidingWindowCmnInternal(), kaldi::SolveQuadraticProblem(), OnlineLdaInput::SpliceFrames(), SpMatrix< float >::TopEigs(), Plda::TransformIvector(), kaldi::UnitTestAddDiagVecMat(), kaldi::UnitTestComplexFft(), kaldi::UnitTestCuVectorCopyFromVec(), kaldi::UnitTestDiagGmm(), UnitTestEstimateLda(), UnitTestFullGmm(), kaldi::UnitTestIoCross(), kaldi::UnitTestPower(), kaldi::UnitTestPowerAbs(), UnitTestReadWave(), kaldi::UnitTestRealFft(), kaldi::UnitTestRegtreeFmllrDiagGmm(), kaldi::UnitTestSimpleForVec(), kaldi::UnitTestSplitRadixComplexFft(), kaldi::UnitTestSplitRadixComplexFft2(), kaldi::UnitTestSplitRadixRealFft(), kaldi::UnitTestSubvector(), FmllrRawAccs::Update(), kaldi::UpdateEbwDiagGmm(), kaldi::UpdateEbwWeightsDiagGmm(), MleSgmm2SpeakerAccs::UpdateNoU(), PldaUnsupervisedAdaptor::UpdatePlda(), IvectorExtractorStats::UpdateProjection(), IvectorExtractorStats::UpdateVariances(), IvectorExtractorStats::UpdateWeight(), MleSgmm2SpeakerAccs::UpdateWithU(), Vector< float >::Vector(), ConstantComponent::Vectorize(), PerElementScaleComponent::Vectorize(), PerElementOffsetComponent::Vectorize(), ConstantFunctionComponent::Vectorize(), and NonlinearComponent::Write().

                                                             {
   KALDI_ASSERT(Dim() == v.Dim());
   if (data_ != v.data_) {
     std::memcpy(this->data_, v.data_, dim_ * sizeof(Real));
   }
 }

◆ CopyFromVec() [2/3]

void CopyFromVec ( const VectorBase< OtherReal > & v )

Copy data from another vector of different type (double vs. float)

Definition at line 256 of file kaldi-vector.cc.

                                                                      {
   KALDI_ASSERT(dim_ == other.Dim());
   Real * __restrict__  ptr = data_;
   const OtherReal * __restrict__ other_ptr = other.Data();
   for (MatrixIndexT i = 0; i < dim_; i++)
     ptr[i] = other_ptr[i];
 }

◆ CopyFromVec() [3/3]

void CopyFromVec ( const CuVectorBase< OtherReal > & v )

Copy from CuVector. This is defined in ../cudamatrix/cu-vector.h.

Definition at line 383 of file cu-vector.h.

                                                                     {
   cu.CopyToVec(this);
 }

◆ CopyRowFromMat() [1/2]

void CopyRowFromMat	(	const MatrixBase< Real > &	M,
		MatrixIndexT	row
	)

Extracts a row of the matrix M.

Could also do this with this->Copy(M[row]).

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

Referenced by RegtreeFmllrDiagGmmAccs::AccumulateForGaussian(), RegtreeFmllrDiagGmmAccs::AccumulateForGmm(), VectorBase< float >::ApplyPow(), DiagGmm::GetComponentMean(), DiagGmm::GetComponentVariance(), LdaEstimate::GetStats(), main(), UnitTestEstimateDiagGmm(), kaldi::UnitTestEstimateMmieDiagGmm(), kaldi::UnitTestPosteriors(), kaldi::UnitTestRow(), and kaldi::UnitTestSpliceRows().

                                                                                    {
   KALDI_ASSERT(row < mat.NumRows());
   KALDI_ASSERT(dim_ == mat.NumCols());
   const Real *mat_row = mat.RowData(row);
   memcpy(data_, mat_row, sizeof(Real)*dim_);
 }

◆ CopyRowFromMat() [2/2]

void CopyRowFromMat	(	const MatrixBase< OtherReal > &	M,
		MatrixIndexT	row
	)

Extracts a row of the matrix M with type conversion.

Definition at line 416 of file kaldi-vector.cc.

                                                                                         {
   KALDI_ASSERT(row < mat.NumRows());
   KALDI_ASSERT(dim_ == mat.NumCols());
   const OtherReal *mat_row = mat.RowData(row);
   for (MatrixIndexT i = 0; i < dim_; i++)
     data_[i] = static_cast<Real>(mat_row[i]);
 }

◆ CopyRowFromSp()

template void CopyRowFromSp	(	const SpMatrix< OtherReal > &	S,
		MatrixIndexT	row
	)

Extracts a row of the symmetric matrix S.

Definition at line 431 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), and CompressedAffineXformStats::CopyFromAffineXformStats().

                                                                                     {
   KALDI_ASSERT(row < sp.NumRows());
   KALDI_ASSERT(dim_ == sp.NumCols());
 
   const OtherReal *sp_data = sp.Data();
 
   sp_data += (row*(row+1)) / 2; // takes us to beginning of this row.
   MatrixIndexT i;
   for (i = 0; i < row; i++) // copy consecutive elements.
     data_[i] = static_cast<Real>(*(sp_data++));
   for(; i < dim_; ++i, sp_data += i)
     data_[i] = static_cast<Real>(*sp_data);
 }

◆ CopyRowsFromMat() [1/3]

void CopyRowsFromMat ( const MatrixBase< Real > & M )

Performs a row stack of the matrix M.

Definition at line 348 of file kaldi-vector.cc.

Referenced by BasisFmllrAccus::AccuGradientScatter(), FmllrSgmm2Accs::AccumulateForFmllrSubspace(), VectorBase< float >::ApplyPow(), LstmNonlinearityComponent::ConsolidateMemory(), kaldi::CuVectorUnitTestCopyFromMat(), FmllrRawAccs::GetAuxf(), LinearTransform::GetGradient(), LinearTransform::GetParams(), kaldi::nnet1::MomentStatistics(), LogisticRegression::TrainParameters(), kaldi::UnitTestSpliceRows(), LstmNonlinearityComponent::Vectorize(), and LinearComponent::Vectorize().

                                                                   {
   KALDI_ASSERT(dim_ == mat.NumCols() * mat.NumRows());
 
   Real *inc_data = data_;
   const MatrixIndexT cols = mat.NumCols(), rows = mat.NumRows();
 
   if (mat.Stride() == mat.NumCols()) {
     memcpy(inc_data, mat.Data(), cols*rows*sizeof(Real));
   } else {
     for (MatrixIndexT i = 0; i < rows; i++) {
       // copy the data to the propper position
       memcpy(inc_data, mat.RowData(i), cols * sizeof(Real));
       // set new copy position
       inc_data += cols;
     }
   }
 }

◆ CopyRowsFromMat() [2/3]

void CopyRowsFromMat ( const MatrixBase< OtherReal > & M )

Definition at line 368 of file kaldi-vector.cc.

                                                                        {
   KALDI_ASSERT(dim_ == mat.NumCols() * mat.NumRows());
   Real *vec_data = data_;
   const MatrixIndexT cols = mat.NumCols(),
       rows = mat.NumRows();
 
   for (MatrixIndexT i = 0; i < rows; i++) {
     const OtherReal *mat_row = mat.RowData(i);
     for (MatrixIndexT j = 0; j < cols; j++) {
       vec_data[j] = static_cast<Real>(mat_row[j]);
     }
     vec_data += cols;
   }
 }

◆ CopyRowsFromMat() [3/3]

void CopyRowsFromMat ( const CuMatrixBase< Real > & M )

The following is implemented in ../cudamatrix/cu-matrix.cc.

Definition at line 2621 of file cu-matrix.cc.

                                                                     {
   KALDI_ASSERT(dim_ == mat.NumCols() * mat.NumRows());
 #if HAVE_CUDA == 1
   if (CuDevice::Instantiate().Enabled()) {
     CuTimer tim;
     if (mat.Stride() == mat.NumCols()) {
       CU_SAFE_CALL(cudaMemcpyAsync(data_, mat.Data(), sizeof(Real)*dim_,
                    cudaMemcpyDeviceToHost, cudaStreamPerThread));
     } else {
       // we could definitely do better than the following.
       Real* vec_data = data_;
       for (MatrixIndexT r = 0; r < mat.NumRows(); r++) {
         CU_SAFE_CALL(cudaMemcpyAsync(vec_data, mat.RowData(r),
                      sizeof(Real) * mat.NumCols(), cudaMemcpyDeviceToHost,
                      cudaStreamPerThread));
         vec_data += mat.NumCols();
       }
     }
     CU_SAFE_CALL(cudaStreamSynchronize(cudaStreamPerThread));
     CuDevice::Instantiate().AccuProfile("CuVectorBase::CopyRowsFromMat", tim);
   } else
 #endif
   {
     CopyRowsFromMat(mat.Mat());
   }
 }

◆ Data() [1/2]

Real* Data ( )

inline

Returns a pointer to the start of the vector's data.

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

70 { return data_; }

kaldi::VectorBase::data_

Real * data_

data memory area

Definition: kaldi-vector.h:395

◆ Data() [2/2]

const Real* Data ( ) const

inline

Returns a pointer to the start of the vector's data (const).

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

73 { return data_; }

kaldi::VectorBase::data_

Real * data_

data memory area

Definition: kaldi-vector.h:395

◆ Dim()

MatrixIndexT Dim ( ) const

inline

Returns the dimension of the vector.

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

64 { return dim_; }

kaldi::VectorBase::dim_

MatrixIndexT dim_

dimension of vector

Definition: kaldi-vector.h:397

◆ DivElements() [1/2]

void DivElements ( const VectorBase< Real > & v )

Divide element-by-element by a vector.

Definition at line 1011 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), DiagGmm::GetComponentMean(), main(), and kaldi::SolveQuadraticProblem().

                                                             {
   KALDI_ASSERT(dim_ == v.dim_);
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] /= v.data_[i];
   }
 }

◆ DivElements() [2/2]

void DivElements ( const VectorBase< OtherReal > & v )

Divide element-by-element by a vector of different type.

Definition at line 1020 of file kaldi-vector.cc.

                                                                  {
   KALDI_ASSERT(dim_ == v.Dim());
   const OtherReal *other_ptr = v.Data();
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] /= other_ptr[i];
   }
 }

◆ Floor()

void Floor	(	const VectorBase< Real > &	v,
		Real	floor_val,
		MatrixIndexT *	floored_count = `nullptr`
	)

Applies floor to all elements.

Returns number of elements floored in floored_count if it is non-null.

Definition at line 812 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyFloor(), and VectorBase< float >::Range().

                                                                                                    {
   KALDI_ASSERT(dim_ == v.dim_);
   if (floored_count == nullptr) {
     for (MatrixIndexT i = 0; i < dim_; i++) {
       data_[i] = std::max(v.data_[i], floor_val);
     }
   } else {
     MatrixIndexT num_floored = 0;
     for (MatrixIndexT i = 0; i < dim_; i++) {
       if (v.data_[i] < floor_val) {
         data_[i] = floor_val;
         num_floored++;
       } else {
         data_[i] = v.data_[i];
       }
     }
     *floored_count = num_floored;
   }
 }

◆ InvertElements()

void InvertElements ( )

Invert all elements.

Definition at line 776 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), OnlinePreconditioner::ComputeEt(), OnlineNaturalGradient::ComputeEt(), OnlinePreconditioner::ComputeWt1(), OnlineNaturalGradient::ComputeWt1(), DiagGmm::CopyFromFullGmm(), CuMatrixBase< float >::DivRowsVec(), DiagGmm::GetComponentVariance(), kaldi::GetFeatureMeanAndVariance(), Plda::GetNormalizationFactor(), IvectorExtractor::InvertWithFlooring(), Plda::LogLikelihoodRatio(), main(), DiagGmm::MergeKmeans(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), DiagGmm::SetComponentInvVar(), AccumDiagGmm::SmoothStats(), kaldi::SolveQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), kaldi::UnitTestCuMatrixDivRowsVec(), and kaldi::UnitTestCuVectorInvertElements().

                                       {
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] = static_cast<Real>(1 / data_[i]);
   }
 }

◆ IsZero()

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

Returns true if matrix is all zeros.

Definition at line 293 of file kaldi-vector.cc.

Referenced by MleAmSgmm2Accs::Check(), MleAmSgmm2Accs::CommitStatsForSpk(), main(), and kaldi::UnitTestSimpleForVec().

                                                {
   Real abs_max = 0.0;
   for (MatrixIndexT i = 0; i < Dim(); i++)
     abs_max = std::max(std::abs(data_[i]), abs_max);
   return (abs_max <= cutoff);
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( VectorBase< Real > )

protected

◆ LogSumExp()

Real LogSumExp ( Real prune = -1.0 ) const

Returns log(sum(exp())) without exp overflow If prune > 0.0, ignores terms less than the max - prune.

[Note: in future, if prune = 0.0, it will take the max. For now, use -1 if you don't want it to prune.]

Definition at line 755 of file kaldi-vector.cc.

Referenced by VectorBase< float >::CopyDiagFromTp(), IvectorExtractor::GetAcousticAuxfWeight(), LogisticRegression::GetLogPosteriors(), FullGmm::LogLikelihood(), DiagGmm::LogLikelihood(), DecodableAmDiagGmmRegtreeMllr::LogLikelihoodZeroBased(), main(), kaldi::UnitTestDiagGmm(), UnitTestFullGmm(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleAmSgmm2Updater::UpdateW(), MleAmSgmm2Updater::UpdateWGetStats(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                                  {
   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 < dim_; i++) {
     BaseFloat f = data_[i];
     if (f >= cutoff)
       sum_relto_max_elem += Exp(f - max_elem);
   }
   return max_elem + Log(sum_relto_max_elem);
 }

◆ Max() [1/2]

Real Max ( ) const

Returns the maximum value of any element, or -infinity for the empty vector.

Definition at line 574 of file kaldi-vector.cc.

Referenced by kaldi::nnet3::ComputeAccuracy(), kaldi::ComputeEarlyReverbEnergy(), VectorBase< float >::CopyDiagFromTp(), kaldi::CuVectorUnitTestMax(), OptimizeLbfgs< Real >::DoStep(), FeatureTransformEstimate::EstimateInternal(), kaldi::InitGmmFromRandomFrames(), SpMatrix< float >::LimitCond(), main(), CuVectorBase< float >::Max(), SpMatrix< float >::MaxAbsEig(), kaldi::MaxAbsolute(), kaldi::nnet1::MomentStatistics(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditioner::PreconditionDirectionsInternal(), OnlineNaturalGradient::PreconditionDirectionsInternal(), kaldi::nnet2::PrintPriorDiagnostics(), kaldi::nnet3::PrintPriorDiagnostics(), kaldi::SolveQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), SpMatrix< float >::SymPosSemiDefEig(), kaldi::TestVectorToPosteriorEntry(), kaldi::UnitTestMaxAbsEig(), kaldi::UnitTestMaxMin(), kaldi::UnitTestSparseVectorMax(), kaldi::UnitTestVectorMax(), IvectorExtractorStats::UpdatePrior(), and kaldi::VectorToPosteriorEntry().

                                  {
   Real ans = - std::numeric_limits<Real>::infinity();
   const Real *data = data_;
   MatrixIndexT i, dim = dim_;
   for (i = 0; i + 4 <= dim; i += 4) {
     Real a1 = data[i], a2 = data[i+1], a3 = data[i+2], a4 = data[i+3];
     if (a1 > ans || a2 > ans || a3 > ans || a4 > ans) {
       Real b1 = (a1 > a2 ? a1 : a2), b2 = (a3 > a4 ? a3 : a4);
       if (b1 > ans) ans = b1;
       if (b2 > ans) ans = b2;
     }
   }
   for (; i < dim; i++)
     if (data[i] > ans) ans = data[i];
   return ans;
 }

◆ Max() [2/2]

Real Max ( MatrixIndexT * index ) const

Returns the maximum value of any element, and the associated index.

Error if vector is empty.

Definition at line 592 of file kaldi-vector.cc.

                                                         {
   if (dim_ == 0) KALDI_ERR << "Empty vector";
   Real ans = - std::numeric_limits<Real>::infinity();
   MatrixIndexT index = 0;
   const Real *data = data_;
   MatrixIndexT i, dim = dim_;
   for (i = 0; i + 4 <= dim; i += 4) {
     Real a1 = data[i], a2 = data[i+1], a3 = data[i+2], a4 = data[i+3];
     if (a1 > ans || a2 > ans || a3 > ans || a4 > ans) {
       if (a1 > ans) { ans = a1; index = i; }
       if (a2 > ans) { ans = a2; index = i + 1; }
       if (a3 > ans) { ans = a3; index = i + 2; }
       if (a4 > ans) { ans = a4; index = i + 3; }
     }
   }
   for (; i < dim; i++)
     if (data[i] > ans) { ans = data[i]; index = i; }
   *index_out = index;
   return ans;
 }

◆ Min() [1/2]

Real Min ( ) const

Returns the minimum value of any element, or +infinity for the empty vector.

Definition at line 614 of file kaldi-vector.cc.

Referenced by kaldi::ApplyHessianXformToGradient(), kaldi::ApplyInvHessianXformToChange(), Plda::ApplyTransform(), VectorBase< float >::CopyDiagFromTp(), kaldi::CuVectorUnitTestMin(), OptimizeLbfgs< Real >::DoStep(), kaldi::EBWUpdateGaussian(), kaldi::GetFeatureMeanAndVariance(), PldaEstimator::GetOutput(), main(), SpMatrix< float >::MaxAbsEig(), kaldi::MaxAbsolute(), CuVectorBase< float >::Min(), MatrixBase< float >::MinSingularValue(), kaldi::nnet1::MomentStatistics(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), Nnet::SetLearningRates(), SpMatrix< float >::SymPosSemiDefEig(), kaldi::UnitTestFloorUnit(), kaldi::UnitTestMaxAbsEig(), kaldi::UnitTestMaxMin(), kaldi::UnitTestVectorMin(), and IvectorExtractorStats::UpdatePrior().

                                  {
   Real ans = std::numeric_limits<Real>::infinity();
   const Real *data = data_;
   MatrixIndexT i, dim = dim_;
   for (i = 0; i + 4 <= dim; i += 4) {
     Real a1 = data[i], a2 = data[i+1], a3 = data[i+2], a4 = data[i+3];
     if (a1 < ans || a2 < ans || a3 < ans || a4 < ans) {
       Real b1 = (a1 < a2 ? a1 : a2), b2 = (a3 < a4 ? a3 : a4);
       if (b1 < ans) ans = b1;
       if (b2 < ans) ans = b2;
     }
   }
   for (; i < dim; i++)
     if (data[i] < ans) ans = data[i];
   return ans;
 }

◆ Min() [2/2]

Real Min ( MatrixIndexT * index ) const

Returns the minimum value of any element, and the associated index.

Error if vector is empty.

Definition at line 632 of file kaldi-vector.cc.

                                                         {
   if (dim_ == 0) KALDI_ERR << "Empty vector";
   Real ans = std::numeric_limits<Real>::infinity();
   MatrixIndexT index = 0;
   const Real *data = data_;
   MatrixIndexT i, dim = dim_;
   for (i = 0; i + 4 <= dim; i += 4) {
     Real a1 = data[i], a2 = data[i+1], a3 = data[i+2], a4 = data[i+3];
     if (a1 < ans || a2 < ans || a3 < ans || a4 < ans) {
       if (a1 < ans) { ans = a1; index = i; }
       if (a2 < ans) { ans = a2; index = i + 1; }
       if (a3 < ans) { ans = a3; index = i + 2; }
       if (a4 < ans) { ans = a4; index = i + 3; }
     }
   }
   for (; i < dim; i++)
     if (data[i] < ans) { ans = data[i]; index = i; }
   *index_out = index;
   return ans;
 }

◆ MulElements() [1/2]

void MulElements ( const VectorBase< Real > & v )

Multiply element-by-element by another vector.

Definition at line 968 of file kaldi-vector.cc.

Referenced by RegtreeMllrDiagGmmAccs::AccumulateForGaussian(), RegtreeMllrDiagGmmAccs::AccumulateForGmm(), VectorBase< float >::ApplyPow(), MfccComputer::Compute(), PlpComputer::Compute(), EbwAmSgmm2Updater::ComputePhoneVecStats(), DiagGmm::MergeKmeans(), kaldi::nnet1::MomentStatistics(), kaldi::ProcessWindow(), kaldi::SlidingWindowCmnInternal(), kaldi::SolveQuadraticProblem(), kaldi::UnitTestSimpleForVec(), and kaldi::UnitTestVector().

                                                             {
   KALDI_ASSERT(dim_ == v.dim_);
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] *= v.data_[i];
   }
 }

◆ MulElements() [2/2]

void MulElements ( const VectorBase< OtherReal > & v )

Multiply element-by-element by another vector of different type.

Definition at line 985 of file kaldi-vector.cc.

                                                                  {
   KALDI_ASSERT(dim_ == v.Dim());
   const OtherReal *other_ptr = v.Data();
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] *= other_ptr[i];
   }
 }

◆ MulTp()

void MulTp	(	const TpMatrix< Real > &	M,
		const MatrixTransposeType	trans
	)

Multiplies this vector by lower-triangular matrix: *this <– *this *M.

Definition at line 152 of file kaldi-vector.cc.

Referenced by VectorBase< float >::AddTpVec(), VectorBase< float >::ApplyPow(), FullGmm::Perturb(), FullGmm::Split(), kaldi::UnitTestCuVectorMulTp(), and kaldi::UnitTestMulTp().

                                                                {
   KALDI_ASSERT(M.NumRows() == dim_);
   cblas_Xtpmv(trans,M.Data(),M.NumRows(),data_,1);
 }

◆ Norm()

Real Norm ( Real p ) const

Compute the p-th norm of the vector.

Definition at line 512 of file kaldi-vector.cc.

Referenced by OptimizeLbfgs< Real >::AcceptStep(), VectorBase< float >::ApplyPow(), VectorBase< float >::ApproxEqual(), OptimizeLbfgs< Real >::ComputeHifNeeded(), IvectorExtractor::GetIvectorDistribution(), PldaEstimator::GetOutput(), main(), VectorBase< float >::Norm(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlineIvectorFeature::PrintDiagnostics(), OptimizeLbfgs< Real >::Restart(), Plda::TransformIvector(), kaldi::UnitTestLbfgs(), kaldi::UnitTestLinearCgd(), kaldi::UnitTestNorm(), kaldi::UnitTestSimpleForVec(), IvectorExtractorStats::UpdatePrior(), and IvectorExtractTask::~IvectorExtractTask().

                                         {
   KALDI_ASSERT(p >= 0.0);
   Real sum = 0.0;
   if (p == 0.0) {
     for (MatrixIndexT i = 0; i < dim_; i++)
       if (data_[i] != 0.0) sum += 1.0;
     return sum;
   } else if (p == 1.0) {
     for (MatrixIndexT i = 0; i < dim_; i++)
       sum += std::abs(data_[i]);
     return sum;
   } else if (p == 2.0) {
     for (MatrixIndexT i = 0; i < dim_; i++)
       sum += data_[i] * data_[i];
     return std::sqrt(sum);
   } else if (p == std::numeric_limits<Real>::infinity()){
     for (MatrixIndexT i = 0; i < dim_; i++)
       sum = std::max(sum, std::abs(data_[i]));
     return sum;
   } else {
     Real tmp;
     bool ok = true;
     for (MatrixIndexT i = 0; i < dim_; i++) {
       tmp = pow(std::abs(data_[i]), p);
       if (tmp == HUGE_VAL) // HUGE_VAL is what pow returns on error.
         ok = false;
       sum += tmp;
     }
     tmp = pow(sum, static_cast<Real>(1.0/p));
     KALDI_ASSERT(tmp != HUGE_VAL); // should not happen here.
     if (ok) {
       return tmp;
     } else {
       Real maximum = this->Max(), minimum = this->Min(),
           max_abs = std::max(maximum, -minimum);
       KALDI_ASSERT(max_abs > 0); // Or should not have reached here.
       Vector<Real> tmp(*this);
       tmp.Scale(1.0 / max_abs);
       return tmp.Norm(p) * max_abs;
     }
   }
 }

◆ operator()() [1/2]

Real operator() ( MatrixIndexT i ) const

inline

Indexing operator (const).

Definition at line 76 of file kaldi-vector.h.

                                                 {
     KALDI_PARANOID_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                  static_cast<UnsignedMatrixIndexT>(dim_));
     return *(data_ + i);
   }

◆ operator()() [2/2]

Real& operator() ( MatrixIndexT i )

inline

Indexing operator (non-const).

Definition at line 83 of file kaldi-vector.h.

                                             {
     KALDI_PARANOID_ASSERT(static_cast<UnsignedMatrixIndexT>(i) <
                  static_cast<UnsignedMatrixIndexT>(dim_));
     return *(data_ + i);
   }

◆ Pow()

void Pow	(	const VectorBase< Real > &	v,
		Real	power
	)

Definition at line 468 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), and VectorBase< float >::Range().

                                                                 {
   KALDI_ASSERT(dim_ == v.dim_);
   for (MatrixIndexT i = 0; i < dim_; i++) {
     data_[i] = pow(v.data_[i], power);
   }
 }

◆ RandCategorical()

MatrixIndexT RandCategorical ( ) const

This function returns a random index into this vector, chosen with probability proportional to the corresponding element.

Requires that this->Min() >= 0 and this->Sum() > 0.

Definition at line 319 of file kaldi-vector.cc.

Referenced by FullGmmNormal::Rand(), and kaldi::UnitTestRandCategorical().

                                                      {
   kaldi::RandomState rstate;
   Real sum = this->Sum();
   KALDI_ASSERT(this->Min() >= 0.0 && sum > 0.0);
   Real r = RandUniform(&rstate) * sum;
   Real *data = this->data_;
   MatrixIndexT dim = this->dim_;
   Real running_sum = 0.0;
   for (MatrixIndexT i = 0; i < dim; i++) {
     running_sum += data[i];
     if (r < running_sum) return i;
   }
   return dim_ - 1; // Should only happen if RandUniform()
                    // returns exactly 1, or due to roundoff.
 }

◆ Range() [1/2]

SubVector<Real> Range	(	const MatrixIndexT	o,
		const MatrixIndexT	l
	)

inline

Returns a sub-vector of a vector (a range of elements).

Parameters

o	[in] Origin, 0 < o < Dim()
l	[in] Length 0 < l < Dim()-o

Returns: A SubVector object that aliases the data of the Vector object. See SubVector class for details

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

Referenced by OnlineSpeexEncoder::AcceptWaveform(), OnlineGenericBaseFeature< C >::AcceptWaveform(), RegtreeFmllrDiagGmmAccs::AccumulateForGaussian(), RegtreeFmllrDiagGmmAccs::AccumulateForGmm(), FmllrSgmm2Accs::AccumulateFromPosteriors(), kaldi::AddVectorsOfUnequalLength(), kaldi::AddVectorsWithOffset(), kaldi::AppendVector(), Fmpe::ApplyProjection(), Fmpe::ApplyProjectionReverse(), FmllrRawAccs::CommitSingleFrameStats(), FmllrDiagGmmAccs::CommitSingleFrameStats(), MelBanks::Compute(), PlpComputer::Compute(), OnlineFeInput< E >::Compute(), BasisFmllrEstimate::ComputeAmDiagPrecond(), kaldi::ComputeEarlyReverbEnergy(), Sgmm2Project::ComputeLdaTransform(), kaldi::ExtendWaveWithSilence(), OnlinePitchFeatureImpl::ExtractFrame(), kaldi::ExtractObjectRange(), CompressedAffineXformStats::ExtractOneG(), kaldi::ExtractWindow(), kaldi::FFTbasedBlockConvolveSignals(), kaldi::FFTbasedConvolveSignals(), kaldi::FindQuietestSegment(), FmllrDiagGmmAccs::FmllrDiagGmmAccs(), kaldi::FmllrInnerUpdate(), ParametricRelu::GetGradient(), Nnet::GetGradient(), AffineTransform::GetGradient(), RecurrentComponent::GetGradient(), ParallelComponent::GetGradient(), LstmProjected::GetGradient(), ConvolutionalComponent::GetGradient(), BlstmProjected::GetGradient(), IvectorExtractor::GetIvectorDistribution(), Nnet::GetParams(), ParametricRelu::GetParams(), AffineTransform::GetParams(), RecurrentComponent::GetParams(), ParallelComponent::GetParams(), FramePoolingComponent::GetParams(), MultiBasisComponent::GetParams(), LstmProjected::GetParams(), ConvolutionalComponent::GetParams(), BlstmProjected::GetParams(), SingleUtteranceNnet2DecoderThreaded::GetRemainingWaveform(), FramePoolingComponent::InitData(), OnlineSpeexEncoder::InputFinished(), OnlineGenericBaseFeature< C >::InputFinished(), main(), MelBanks::MelBanks(), kaldi::MergeFullGmm(), SoftmaxComponent::MixUp(), kaldi::RealFftInefficient(), Nnet::SetParams(), ParametricRelu::SetParams(), AffineTransform::SetParams(), RecurrentComponent::SetParams(), ParallelComponent::SetParams(), MultiBasisComponent::SetParams(), ConvolutionalComponent::SetParams(), LstmProjected::SetParams(), BlstmProjected::SetParams(), SpMatrix< float >::TopEigs(), kaldi::UnitTestCuVectorSum(), UnitTestLinearResample(), kaldi::UnitTestRange(), UnitTestVectorRandomizer(), ConvolutionComponent::UnVectorize(), TimeHeightConvolutionComponent::UnVectorize(), Nnet::UnVectorize(), TdnnComponent::UnVectorize(), RepeatedAffineComponent::UnVectorize(), AffineComponent::UnVectorize(), BlockAffineComponent::UnVectorize(), ScaleAndOffsetComponent::UnVectorize(), ConvolutionComponent::Vectorize(), TimeHeightConvolutionComponent::Vectorize(), TdnnComponent::Vectorize(), RepeatedAffineComponent::Vectorize(), AffineComponent::Vectorize(), BlockAffineComponent::Vectorize(), and ScaleAndOffsetComponent::Vectorize().

                                                                     {
     return SubVector<Real>(*this, o, l);
   }

◆ Range() [2/2]

const SubVector<Real> Range	(	const MatrixIndexT	o,
		const MatrixIndexT	l
	)		const

inline

Returns a const sub-vector of a vector (a range of elements).

Parameters

o	[in] Origin, 0 < o < Dim()
l	[in] Length 0 < l < Dim()-o

Returns: A SubVector object that aliases the data of the Vector object. See SubVector class for details

Definition at line 103 of file kaldi-vector.h.

                                                           {
     return SubVector<Real>(*this, o, l);
   }

◆ Read()

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

Reads from C++ stream (option to add to existing contents).

Throws exception on failure

Definition at line 1086 of file kaldi-vector.cc.

Referenced by VectorBase< float >::CopyDiagFromTp(), kaldi::operator>>(), and Vector< float >::~Vector().

                                                                   {
   if (add) {
     Vector<Real> tmp(Dim());
     tmp.Read(is, binary, false);  // read without adding.
     if (this->Dim() != tmp.Dim()) {
       KALDI_ERR << "VectorBase::Read, size mismatch " << this->Dim()<<" vs. "<<tmp.Dim();
     }
     this->AddVec(1.0, tmp);
     return;
   } // now assume add == false.
 
   //  In order to avoid rewriting this, we just declare a Vector and
   // use it to read the data, then copy.
   Vector<Real> tmp;
   tmp.Read(is, binary, false);
   if (tmp.Dim() != Dim())
     KALDI_ERR << "VectorBase<Real>::Read, size mismatch "
               << Dim() << " vs. " << tmp.Dim();
   CopyFromVec(tmp);
 }

◆ ReplaceValue()

void ReplaceValue	(	Real	orig,
		Real	changed
	)

Set each element to y = (x == orig ? changed : x).

Definition at line 976 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), kaldi::UnitTestCuVectorReplaceValue(), and kaldi::UnitTestReplaceValue().

                                                            {
   Real *data = data_;
   for (MatrixIndexT i = 0; i < dim_; i++)
     if (data[i] == orig) data[i] = changed;
 }

◆ Scale()

void Scale ( Real alpha )

Multiplies all elements by this constant.

Definition at line 963 of file kaldi-vector.cc.

Referenced by FmllrSgmm2Accs::AccumulateForFmllrSubspace(), FmllrDiagGmmAccs::AccumulateForGmm(), FmllrRawAccs::AccumulateForGmm(), RegtreeMllrDiagGmmAccs::AccumulateForGmm(), RegtreeFmllrDiagGmmAccs::AccumulateForGmm(), AccumAmDiagGmm::AccumulateForGmmTwofeats(), kaldi::AddNoise(), kaldi::AlignUtteranceWrapper(), VectorBase< float >::ApplyPow(), RegressionTree::BuildTree(), kaldi::ClusterGaussiansToUbm(), PlpComputer::Compute(), kaldi::ComputeAmGmmFeatureDeriv(), Fmpe::ComputeC(), kaldi::ComputeFeatureNormalizingTransform(), AmSgmm2::ComputeFmllrPreXform(), EbwAmSgmm2Updater::ComputePhoneVecStats(), LstmNonlinearityComponent::ConsolidateMemory(), FmllrRawAccs::ConvertToSimpleStats(), kaldi::CuVectorUnitTestScale(), DeltaFeatures::DeltaFeatures(), MatrixBase< float >::DestructiveSvd(), kaldi::EBWUpdateGaussian(), BasisFmllrEstimate::EstimateFmllrBasis(), kaldi::EstPca(), kaldi::FFTbasedBlockConvolveSignals(), kaldi::FFTbasedConvolveSignals(), kaldi::FmllrInnerUpdate(), kaldi::GenRandStats(), IvectorExtractor::GetAcousticAuxfVariance(), kaldi::GetFeatDeriv(), kaldi::GetFeatureMeanAndVariance(), SingleUtteranceGmmDecoder::GetGaussianPosteriors(), PldaEstimator::GetOutput(), LdaEstimate::GetStats(), BatchNormComponent::Info(), LstmNonlinearityComponent::Info(), NonlinearComponent::Info(), ConstantComponent::InitFromConfig(), ConstantFunctionComponent::InitFromConfig(), kaldi::unittest::InitRandDiagGmm(), kaldi::unittest::InitRandFullGmm(), kaldi::InitRandomGmm(), kaldi::IsmoothStatsDiagGmm(), main(), kaldi::MapDiagGmmUpdate(), FullGmm::Merge(), DiagGmm::merged_components_logdet(), FullGmm::MergedComponentsLogdet(), DiagGmm::MergeKmeans(), kaldi::MleDiagGmmUpdate(), kaldi::MleFullGmmUpdate(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), VectorBase< float >::Norm(), PdfPrior::PdfPrior(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditioner::PreconditionDirectionsInternal(), OnlineNaturalGradient::PreconditionDirectionsInternal(), DiscriminativeObjectiveInfo::Print(), IvectorExtractorStats::PriorDiagnostics(), rand_diag_gmm(), kaldi::RealFft(), LdaEstimate::Scale(), AccumFullGmm::Scale(), AccumDiagGmm::Scale(), RestrictedAttentionComponent::Scale(), kaldi::SlidingWindowCmnInternal(), AccumDiagGmm::SmoothStats(), kaldi::TestClusterKMeansVector(), kaldi::nnet3::TestNnetComponentUpdatable(), kaldi::TestVectorToPosteriorEntry(), SpMatrix< float >::TopEigs(), Plda::TransformIvector(), kaldi::UnitTestAddDiagMat2(), kaldi::UnitTestAddDiagMatMat(), kaldi::UnitTestAddDiagVecMat(), kaldi::nnet2::UnitTestAmNnet(), kaldi::UnitTestComplexFft(), kaldi::UnitTestComplexFt(), kaldi::UnitTestCuVectorAddColSumMat(), kaldi::UnitTestCuVectorAddColSumMatLarge(), kaldi::UnitTestCuVectorAddRowSumMat(), kaldi::UnitTestCuVectorAddRowSumMatLarge(), kaldi::UnitTestCuVectorAddVec(), UnitTestEstimateDiagGmm(), UnitTestEstimateFullGmm(), UnitTestEstimateLda(), kaldi::UnitTestEstimateMmieDiagGmm(), kaldi::UnitTestIo(), kaldi::UnitTestIoCross(), kaldi::UnitTestLbfgs(), kaldi::nnet2::UnitTestNnetDecodable(), kaldi::UnitTestNorm(), kaldi::UnitTestPldaEstimation(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), kaldi::UnitTestRealFft(), kaldi::UnitTestSimpleForVec(), kaldi::UnitTestSplitRadixComplexFft(), kaldi::UnitTestSplitRadixRealFft(), kaldi::UnitTestVector(), kaldi::nnet3::UpdateNnetWithMaxChange(), IvectorExtractorStats::UpdatePrior(), EbwAmSgmm2Updater::UpdateSubstateWeights(), EbwAmSgmm2Updater::UpdateU(), MleAmSgmm2Updater::UpdateU(), MleAmSgmm2Updater::UpdateW(), MleSgmm2SpeakerAccs::UpdateWithU(), VectorClusterable::VectorClusterable(), LstmNonlinearityComponent::Write(), and NonlinearComponent::Write().

                                        {
   cblas_Xscal(dim_, alpha, data_, 1);
 }

◆ Set()

void Set ( Real f )

Set all members of a vector to a specified value.

Definition at line 336 of file kaldi-vector.cc.

Referenced by VectorBase< float >::AddColSumMat(), VectorBase< float >::AddRowSumMat(), MatrixBase< float >::AddVecToCols(), MatrixBase< float >::AddVecToRows(), kaldi::nnet2::CombineNnetsA(), kaldi::nnet3::ComputeAccuracy(), kaldi::ComputeLocalCost(), kaldi::nnet2::GetInitialModel(), FastNnetCombiner::GetInitialModel(), FastNnetCombiner::GetInitialParams(), kaldi::nnet2::GetInitialScaleParams(), LogisticRegression::GetLogPosteriors(), kaldi::nnet2::GetUpdateDirection(), OnlinePreconditionerSimple::InitDefault(), OnlineNaturalGradientSimple::InitDefault(), main(), kaldi::ReadData(), kaldi::SlidingWindowCmnInternal(), Plda::SmoothWithinClassCovariance(), kaldi::TestRecyclingVector(), TestSgmm2FmllrAccsIO(), TestSgmm2FmllrSubspace(), TestSgmm2PreXform(), kaldi::TrainOneIter(), kaldi::UnitTestAddVecToCols(), kaldi::UnitTestAddVecToRows(), UnitTestRegressionTree(), kaldi::UnitTestSimpleForVec(), and kaldi::nnet3::time_height_convolution::ZeroBlankRows().

                                  {
   // Why not use memset here?
   // The basic unit of memset is a byte.
   // If f != 0 and sizeof(Real) > 1, then we cannot use memset.
   if (f == 0) {
     this->SetZero(); // calls std::memset
   } else {
     for (MatrixIndexT i = 0; i < dim_; i++) { data_[i] = f; }
   }
 }

◆ SetRandn()

void SetRandn ( )

Set vector to random normally-distributed noise.

Definition at line 301 of file kaldi-vector.cc.

                                 {
   kaldi::RandomState rstate;
   MatrixIndexT last = (Dim() % 2 == 1) ? Dim() - 1 : Dim();
   for (MatrixIndexT i = 0; i < last; i += 2) {
     kaldi::RandGauss2(data_ + i, data_ + i + 1, &rstate);
   }
   if (Dim() != last) data_[last] = static_cast<Real>(kaldi::RandGauss(&rstate));
 }

◆ SetRandUniform()

void SetRandUniform ( )

Sets to numbers uniformly distributed on (0,1)

Definition at line 311 of file kaldi-vector.cc.

                                       {
   kaldi::RandomState rstate;
   for (MatrixIndexT i = 0; i < Dim(); i++) {
     *(data_+i) = RandUniform(&rstate);
   }
 }

◆ SetZero()

void SetZero ( )

Set vector to all zeros.

Definition at line 288 of file kaldi-vector.cc.

Referenced by MinimumBayesRisk::AccStats(), OnlineIvectorEstimationStats::AccStats(), MleSgmm2SpeakerAccs::Clear(), MleAmSgmm2Accs::CommitStatsForSpk(), MfccComputer::Compute(), OptimizeLbfgs< Real >::ComputeNewDirection(), kaldi::ConvolveSignals(), SparseVector< Real >::CopyElementsToVec(), kaldi::DiagGmmToStats(), kaldi::EBWUpdateGaussian(), OnlinePitchFeatureImpl::ExtractFrame(), kaldi::FFTbasedBlockConvolveSignals(), FullGmm::GetComponentMean(), OnlineIvectorEstimationStats::GetIvector(), FmllrRawAccs::InitSingleFrameStats(), main(), FullGmm::Merge(), FullGmm::MergePreselect(), DeltaFeatures::Process(), ShiftedDeltaFeatures::Process(), AccumFullGmm::Read(), LdaEstimate::Read(), AccumFullGmm::SetZero(), AccumDiagGmm::SetZero(), CuMatrixBase< float >::SetZeroAboveDiag(), kaldi::TestOnlineCmnInput(), kaldi::UnitTestCuVectorAddColSumMat(), kaldi::UnitTestCuVectorAddColSumMatLarge(), kaldi::UnitTestCuVectorAddRowSumMat(), kaldi::UnitTestCuVectorAddRowSumMatLarge(), LdaEstimate::ZeroAccumulators(), and RestrictedAttentionComponent::ZeroStats().

                                {
   std::memset(data_, 0, dim_ * sizeof(Real));
 }

◆ Sigmoid()

void Sigmoid ( const VectorBase< Real > & src )

Sets each element of *this to the sigmoid function of the corresponding element of "src".

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

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

                                                           {
   KALDI_ASSERT(dim_ == src.dim_);
   for (MatrixIndexT i = 0; i < dim_; i++) {
     Real x = src.data_[i];
     // We aim to avoid floating-point overflow here.
     if (x > 0.0) {
       x = 1.0 / (1.0 + Exp(-x));
     } else {
       Real ex = Exp(x);
       x = ex / (ex + 1.0);
     }
     data_[i] = x;
   }
 }

◆ SizeInBytes()

MatrixIndexT SizeInBytes ( ) const

inline

Returns the size in memory of the vector, in bytes.

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

67 { return (dim_*sizeof(Real)); }

kaldi::VectorBase::dim_

MatrixIndexT dim_

dimension of vector

Definition: kaldi-vector.h:397

◆ Solve()

void Solve	(	const TpMatrix< Real > &	M,
		const MatrixTransposeType	trans
	)

If trans == kNoTrans, solves M x = b, where b is the value of *this at input and x is the value of *this at output.

If trans == kTrans, solves M' x = b. Does not test for M being singular or near-singular, so test it before calling this routine.

Definition at line 159 of file kaldi-vector.cc.

Referenced by VectorBase< float >::ApplyPow(), and kaldi::UnitTestTriVecSolver().

                                                          {
   KALDI_ASSERT(M.NumRows() == dim_);
   cblas_Xtpsv(trans, M.Data(), M.NumRows(), data_, 1);
 }

◆ Sum()

Real Sum ( ) const

Returns sum of the elements.

Definition at line 688 of file kaldi-vector.cc.

                                  {
   // Do a dot-product with a size-1 array with a stride of 0 to
   // implement sum. This allows us to access SIMD operations in a
   // cross-platform way via your BLAS library.
   Real one(1);
   return cblas_Xdot(dim_, data_, 1, &one, 0);
 }

◆ SumLog()

Real SumLog ( ) const

Returns sum of the logs of the elements.

More efficient than just taking log of each. Will return NaN if any elements are negative.

Definition at line 697 of file kaldi-vector.cc.

Referenced by VectorBase< float >::CopyDiagFromTp(), Plda::LogLikelihoodRatio(), main(), and GaussClusterable::Objf().

                                     {
   double sum_log = 0.0;
   double prod = 1.0;
   for (MatrixIndexT i = 0; i < dim_; i++) {
     prod *= data_[i];
     // Possible future work (arnab): change these magic values to pre-defined
     // constants
     if (prod < 1.0e-10 || prod > 1.0e+10) {
       sum_log += Log(prod);
       prod = 1.0;
     }
   }
   if (prod != 1.0) sum_log += Log(prod);
   return sum_log;
 }

◆ Tanh()

void Tanh ( const VectorBase< Real > & src )

Sets each element of *this to the tanh of the corresponding element of "src".

Definition at line 900 of file kaldi-vector.cc.

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

                                                        {
   KALDI_ASSERT(dim_ == src.dim_);
   for (MatrixIndexT i = 0; i < dim_; i++) {
     Real x = src.data_[i];
     if (x > 0.0) {
       Real inv_expx = Exp(-x);
       x = -1.0 + 2.0 / (1.0 + inv_expx * inv_expx);
     } else {
       Real expx = Exp(x);
       x = 1.0 - 2.0 / (1.0 + expx * expx);
     }
     data_[i] = x;
   }
 }

◆ Write()

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

Writes to C++ stream (option to write in binary).

Definition at line 1231 of file kaldi-vector.cc.

Referenced by LstmNonlinearityComponent::ConsolidateMemory(), VectorBase< float >::CopyDiagFromTp(), main(), kaldi::UnitTestIo(), kaldi::UnitTestIoCross(), UnitTestRegressionTree(), AccumFullGmm::Write(), LdaEstimate::Write(), Plda::Write(), RestrictedAttentionComponent::Write(), CuVector< float >::Write(), LstmNonlinearityComponent::Write(), IvectorExtractorStats::Write(), NonlinearComponent::Write(), and kaldi::nnet3::WriteVectorAsChar().

                                                                {
   if (!os.good()) {
     KALDI_ERR << "Failed to write vector to stream: stream not good";
   }
   if (binary) {
     std::string my_token = (sizeof(Real) == 4 ? "FV" : "DV");
     WriteToken(os, binary, my_token);
 
     int32 size = Dim();  // make the size 32-bit on disk.
     KALDI_ASSERT(Dim() == (MatrixIndexT) size);
     WriteBasicType(os, binary, size);
     os.write(reinterpret_cast<const char*>(Data()), sizeof(Real) * size);
   } else {
     os << " [ ";
     for (MatrixIndexT i = 0; i < Dim(); i++)
       os << (*this)(i) << " ";
     os << "]\n";
   }
   if (!os.good())
     KALDI_ERR << "Failed to write vector to stream";
 }

Friends And Related Function Documentation

◆ CuVector< Real >

friend class CuVector< Real >

friend

Definition at line 371 of file kaldi-vector.h.

◆ CuVectorBase< Real >

friend class CuVectorBase< Real >

friend

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

◆ VectorBase< double >

friend class VectorBase< double >

friend

Definition at line 368 of file kaldi-vector.h.

◆ VectorBase< float >

friend class VectorBase< float >

friend

Definition at line 369 of file kaldi-vector.h.

Member Data Documentation

◆ data_

Real* data_

protected

◆ dim_

MatrixIndexT dim_

protected

dimension of vector

Definition at line 397 of file kaldi-vector.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

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

Constructor & Destructor Documentation

◆ ~VectorBase()

◆ VectorBase()

Member Function Documentation

◆ Add()

◆ AddColSumMat()

◆ AddDiagMat2()

◆ AddDiagMatMat()

◆ AddMatSvec()

◆ AddMatVec()

◆ AddRowSumMat()

◆ AddSpVec()

◆ AddTpVec()

◆ AddVec() [1/5]

◆ AddVec() [2/5]

◆ AddVec() [3/5]

◆ AddVec() [4/5]

◆ AddVec() [5/5]

◆ AddVec2() [1/2]

◆ AddVec2() [2/2]

◆ AddVecDivVec()

◆ AddVecVec()

◆ ApplyAbs()

◆ ApplyCeiling()

◆ ApplyExp()

◆ ApplyFloor() [1/2]

◆ ApplyFloor() [2/2]

◆ ApplyLog()

◆ ApplyLogAndCopy()

◆ ApplyLogSoftMax()

◆ ApplyPow()

◆ ApplyPowAbs()

◆ ApplySoftMax()

◆ ApproxEqual()

◆ Ceiling()

◆ CopyColFromMat()

◆ CopyColsFromMat()

◆ CopyDiagFromMat()

◆ CopyDiagFromPacked()

◆ CopyDiagFromSp()

◆ CopyDiagFromTp()

◆ CopyFromPacked()

◆ CopyFromPtr()

◆ CopyFromVec() [1/3]

◆ CopyFromVec() [2/3]

◆ CopyFromVec() [3/3]

◆ CopyRowFromMat() [1/2]

◆ CopyRowFromMat() [2/2]

◆ CopyRowFromSp()

◆ CopyRowsFromMat() [1/3]

◆ CopyRowsFromMat() [2/3]

◆ CopyRowsFromMat() [3/3]

◆ Data() [1/2]

◆ Data() [2/2]

◆ Dim()

◆ DivElements() [1/2]

◆ DivElements() [2/2]

◆ Floor()

◆ InvertElements()

◆ IsZero()

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

◆ LogSumExp()

◆ Max() [1/2]

◆ Max() [2/2]

◆ Min() [1/2]

◆ Min() [2/2]

◆ MulElements() [1/2]

◆ MulElements() [2/2]

◆ MulTp()

◆ Norm()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ Pow()

◆ RandCategorical()

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