PackedMatrix< Real > Class Template Reference

Packed matrix: base class for triangular and symmetric matrices. More...

#include <matrix-common.h>

Inheritance diagram for PackedMatrix< Real >:

Collaboration diagram for PackedMatrix< Real >:

Public Member Functions
	PackedMatrix ()
	PackedMatrix (MatrixIndexT r, MatrixResizeType resize_type=kSetZero)
	PackedMatrix (const PackedMatrix< Real > &orig)
template<typename OtherReal >
	PackedMatrix (const PackedMatrix< OtherReal > &orig)
void	SetZero ()
void	SetUnit ()
	< Set to zero More...
void	SetRandn ()
	< Set to unit matrix. More...
Real	Trace () const
	< Set to random values of a normal distribution More...
PackedMatrix< Real > &	operator= (const PackedMatrix< Real > &other)
	~PackedMatrix ()
void	Resize (MatrixIndexT nRows, MatrixResizeType resize_type=kSetZero)
	Set packed matrix to a specified size (can be zero). More...
void	AddToDiag (const Real r)
void	ScaleDiag (const Real alpha)
void	SetDiag (const Real alpha)
template<typename OtherReal >
void	CopyFromPacked (const PackedMatrix< OtherReal > &orig)
template<typename OtherReal >
void	CopyFromVec (const SubVector< OtherReal > &orig)
	CopyFromVec just interprets the vector as having the same layout as the packed matrix. More...
Real *	Data ()
const Real *	Data () const
MatrixIndexT	NumRows () const
MatrixIndexT	NumCols () const
size_t	SizeInBytes () const
Real	operator() (MatrixIndexT r, MatrixIndexT c) const
Real &	operator() (MatrixIndexT r, MatrixIndexT c)
Real	Max () const
Real	Min () const
void	Scale (Real c)
void	Read (std::istream &in, bool binary, bool add=false)
void	Write (std::ostream &out, bool binary) const
void	Destroy ()
void	Swap (PackedMatrix< Real > *other)
	Swaps the contents of *this and *other. Shallow swap. More...
void	Swap (Matrix< Real > *other)

Protected Member Functions
void	AddPacked (const Real alpha, const PackedMatrix< Real > &M)

Protected Attributes
Real *	data_
MatrixIndexT	num_rows_

Private Member Functions
void	Init (MatrixIndexT dim)
	Init assumes the current contents of the class are is invalid (i.e. More...

Friends
class	CuPackedMatrix< Real >
std::ostream &	operator<< (std::ostream &out, const PackedMatrix< Real > &m)

Detailed Description

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

Packed matrix: base class for triangular and symmetric matrices.

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

Constructor & Destructor Documentation

PackedMatrix() [1/4]

PackedMatrix ( )

inline

Definition at line 45 of file packed-matrix.h.

: data_(NULL), num_rows_(0) {}

PackedMatrix() [2/4]

PackedMatrix ( MatrixIndexT  r, MatrixResizeType  resize_type = kSetZero  )

inlineexplicit

Definition at line 47 of file packed-matrix.h.

                                                                                :
      data_(NULL) {  Resize(r, resize_type);  }

PackedMatrix() [3/4]

PackedMatrix ( const PackedMatrix< Real > &  orig )

inlineexplicit

Definition at line 50 of file packed-matrix.h.

                                                        : data_(NULL) {
    Resize(orig.num_rows_, kUndefined);
    CopyFromPacked(orig);
  }

PackedMatrix() [4/4]

PackedMatrix ( const PackedMatrix< OtherReal > &  orig )

inlineexplicit

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

                                                             : data_(NULL) {
    Resize(orig.NumRows(), kUndefined);
    CopyFromPacked(orig);
  }

~PackedMatrix()

~PackedMatrix ( )

inline

Definition at line 74 of file packed-matrix.h.

                  {
    Destroy();
  }

Member Function Documentation

AddPacked()

void AddPacked ( const Real  alpha, const PackedMatrix< Real > &  M  )

protected

Definition at line 40 of file packed-matrix.cc.

Referenced by SpMatrix< float >::AddSp(), TpMatrix< float >::AddTp(), and PackedMatrix< float >::Min().

                                                                                  {
  KALDI_ASSERT(num_rows_ == rMa.NumRows());
  size_t nr = num_rows_,
      sz = (nr * (nr + 1)) / 2;
  cblas_Xaxpy(sz, alpha, rMa.Data(), 1, data_, 1);
}

AddToDiag()

void AddToDiag

(

const Real

r

)

Definition at line 123 of file packed-matrix.cc.

Referenced by IvectorExtractor::GetIvectorDistPrior(), OnlineIvectorEstimationStats::OnlineIvectorEstimationStats(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), kaldi::UnitTestAddToDiag(), kaldi::UnitTestCuSpMatrixAddToDiag(), kaldi::UnitTestCuSpMatrixInvert(), UnitTestEstimateFullGmm(), and PackedMatrix< float >::~PackedMatrix().

                                         {
  Real *ptr = data_;
  for (MatrixIndexT i = 2; i <= num_rows_+1; i++) {
    *ptr += r;
    ptr += i;
  }
}

CopyFromPacked()

template void CopyFromPacked

(

const PackedMatrix< OtherReal > &

orig

)

Definition at line 153 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::CopyFromPacked(), SpMatrix< float >::CopyFromSp(), TpMatrix< float >::CopyFromTp(), CuPackedMatrix< Real >::CopyToPacked(), PackedMatrix< float >::operator=(), PackedMatrix< float >::PackedMatrix(), and PackedMatrix< float >::~PackedMatrix().

                                                                           {
  KALDI_ASSERT(NumRows() == orig.NumRows());
  if (sizeof(Real) == sizeof(OtherReal)) {
    memcpy(data_, orig.Data(), SizeInBytes());
  } else {
    Real *dst = data_;
    const OtherReal *src = orig.Data();
    size_t nr = NumRows(),
        size = (nr * (nr + 1)) / 2;
    for (size_t i = 0; i < size; i++, dst++, src++)
      *dst = *src;
  }
}

CopyFromVec()

template void CopyFromVec

(

const SubVector< OtherReal > &

orig

)

CopyFromVec just interprets the vector as having the same layout as the packed matrix.

Must have the same dimension, i.e. orig.Dim() == (NumRows()*(NumRows()+1)) / 2;

Definition at line 181 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::CopyFromVec(), CompressedAffineXformStats::ExtractOneG(), kaldi::UnitTestSpVec(), EbwAmSgmm2Updater::UpdateW(), MleAmSgmm2Updater::UpdateW(), and PackedMatrix< float >::~PackedMatrix().

                                                                    {
  MatrixIndexT size = (NumRows()*(NumRows()+1)) / 2;
  KALDI_ASSERT(vec.Dim() == size);
  if (sizeof(Real) == sizeof(OtherReal)) {
    memcpy(data_, vec.Data(), size * sizeof(Real));
  } else {
    Real *dst = data_;
    const OtherReal *src = vec.Data();
    for (MatrixIndexT i = 0; i < size; i++, dst++, src++)
      *dst = *src;
  }
}

Data() [1/2]

Real* Data ( )

inline

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

Referenced by SpMatrix< float >::AddMat2Sp(), PackedMatrix< float >::AddPacked(), MatrixBase< float >::AddSp(), VectorBase< float >::AddSpVec(), SpMatrix< float >::AddVec2Sp(), TpMatrix< float >::Cholesky(), FmllrRawAccs::CommitSingleFrameStats(), IvectorExtractorStats::CommitStatsForM(), IvectorExtractorStats::CommitStatsForWPoint(), IvectorExtractor::ComputeDerivedVars(), FmllrRawAccs::ConvertToSimpleStats(), PackedMatrix< float >::CopyFromPacked(), MatrixBase< float >::CopyFromSp(), MatrixBase< float >::CopyFromTp(), VectorBase< float >::CopyRowFromSp(), IvectorExtractor::GetAcousticAuxfMean(), IvectorExtractor::GetIvectorDistMean(), VectorBase< float >::MulTp(), VectorBase< float >::Solve(), SubVector< Real >::SubVector(), kaldi::TraceSpMat(), kaldi::TraceSpSp(), kaldi::TraceSpSpLower(), IvectorExtractorStats::UpdateVariances(), IvectorExtractorStats::UpdateWeight(), and kaldi::VecSpVec().

{ return data_; }

Data() [2/2]

const Real* Data ( ) const

inline

Definition at line 103 of file packed-matrix.h.

{ return data_; }

Destroy()

void Destroy

(

)

Definition at line 227 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::Min(), and PackedMatrix< float >::~PackedMatrix().

                                 {
  // we need to free the data block if it was defined
  if (data_ != NULL) KALDI_MEMALIGN_FREE(data_);
  data_ = NULL;
  num_rows_ = 0;
}

Init()

void Init ( MatrixIndexT  dim )

inlineprivate

Init assumes the current contents of the class are is invalid (i.e.

junk or has already been freed), and it sets the matrixd to newly allocated memory with the specified dimension. dim == 0 is acceptable. The memory contents pointed to by data_ will be undefined.

Definition at line 56 of file packed-matrix.cc.

                                                   {
  if (r == 0) {
    num_rows_ = 0;
    data_ = 0;
    return;
  }
  size_t size = ((static_cast<size_t>(r) * static_cast<size_t>(r + 1)) / 2);

  if (static_cast<size_t>(static_cast<MatrixIndexT>(size)) != size) {
    KALDI_WARN << "Allocating packed matrix whose full dimension does not fit "
               << "in MatrixIndexT: not all code is tested for this case.";
  }

  void *data;  // aligned memory block
  void *temp;

  if ((data = KALDI_MEMALIGN(16, size * sizeof(Real), &temp)) != NULL) {
    this->data_ = static_cast<Real *> (data);
    this->num_rows_ = r;
  } else {
    throw std::bad_alloc();
  }
}

Max()

Real Max ( ) const

inline

Definition at line 133 of file packed-matrix.h.

Referenced by kaldi::ApproxEqual(), OnlineNaturalGradient::ReorthogonalizeRt1(), OnlinePreconditioner::ReorthogonalizeXt1(), and kaldi::UnitTestMaxMin().

                   {
    KALDI_ASSERT(num_rows_ > 0);
    return * (std::max_element(data_, data_ + ((num_rows_*(num_rows_+1))/2) ));
  }

Min()

Real Min ( ) const

inline

Definition at line 138 of file packed-matrix.h.

Referenced by kaldi::ApproxEqual(), and kaldi::UnitTestMaxMin().

                   {
    KALDI_ASSERT(num_rows_ > 0);
    return * (std::min_element(data_, data_ + ((num_rows_*(num_rows_+1))/2) ));
  }

NumCols()

MatrixIndexT NumCols ( ) const

inline

Definition at line 105 of file packed-matrix.h.

Referenced by VectorBase< float >::CopyDiagFromPacked(), VectorBase< float >::CopyRowFromSp(), kaldi::LinearCgd(), Matrix< BaseFloat >::Matrix(), kaldi::TraceMatSpMatSp(), and kaldi::TraceSpMat().

{ return num_rows_; }

NumRows()

MatrixIndexT NumRows ( ) const

inline

Definition at line 104 of file packed-matrix.h.

Referenced by SpMatrix< float >::AddMat2Sp(), PackedMatrix< float >::AddPacked(), SpMatrix< float >::AddSmat2Sp(), MatrixBase< float >::AddSp(), MatrixBase< float >::AddSpSp(), VectorBase< float >::AddSpVec(), VectorBase< float >::AddTpVec(), SpMatrix< float >::AddVec2Sp(), SpMatrix< float >::ApplyFloor(), kaldi::ApproxEqual(), SpMatrix< float >::ApproxEqual(), kaldi::AssertDiagEqual(), kaldi::AssertEqual(), IvectorExtractorStats::CheckDims(), TpMatrix< float >::Cholesky(), BasisFmllrEstimate::ComputeAmDiagPrecond(), Sgmm2Project::ComputeLdaTransform(), kaldi::ComputeNormalizingTransform(), FastNnetCombiner::ComputePreconditioner(), PackedMatrix< float >::CopyFromPacked(), CuPackedMatrix< Real >::CopyFromPacked(), MatrixBase< float >::CopyFromSp(), MatrixBase< float >::CopyFromTp(), VectorBase< float >::CopyRowFromSp(), CuPackedMatrix< Real >::CopyToPacked(), CovarianceStats::Dim(), LdaEstimate::Estimate(), FeatureTransformEstimate::EstimateInternal(), kaldi::EstimateSgmm2FmllrSubspace(), CompressedAffineXformStats::ExtractOneG(), kaldi::GetLogDetNoFailure(), GetLogLikeTest(), IvectorExtractor::GetPriorAuxf(), kaldi::InitRand(), kaldi::InitRandNonsingular(), IvectorExtractor::InvertWithFlooring(), IvectorExtractor::IvectorExtractor(), kaldi::LinearCgd(), main(), Matrix< BaseFloat >::Matrix(), VectorBase< float >::MulTp(), kaldi::NonDiagonalness(), kaldi::NonUnitness(), CompressedAffineXformStats::PrepareOneG(), Sgmm2Project::ProjectVariance(), kaldi::unittest::RandFullGaussFeatures(), AffineXformStats::Read(), PackedMatrix< float >::Read(), VectorBase< float >::Solve(), kaldi::SolveDoubleQuadraticMatrixProblem(), kaldi::SolveQuadraticMatrixProblem(), kaldi::SolveQuadraticProblem(), SubVector< Real >::SubVector(), CuMatrixBase< float >::SymInvertPosDef(), kaldi::TraceMatSpMat(), kaldi::TraceMatSpMatSp(), kaldi::TraceSpMat(), kaldi::TraceSpSp(), kaldi::TraceSpSpLower(), kaldi::UnitTestCuSpMatrixOperator(), kaldi::UnitTestSpInvert(), kaldi::UnitTestTpInvert(), kaldi::UnitTestTransposeScatter(), IvectorExtractorStats::UpdateVariances(), MleAmSgmm2Updater::UpdateVars(), kaldi::VecSpVec(), and FisherComputationClass::~FisherComputationClass().

{ return num_rows_; }

operator()() [1/2]

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

inline

Definition at line 114 of file packed-matrix.h.

                                                         {
    KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(r) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_) &&
                 static_cast<UnsignedMatrixIndexT>(c) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_)
                 && c <= r);
    return *(data_ + (r * (r + 1)) / 2 + c);
  }

operator()() [2/2]

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

inline

Definition at line 124 of file packed-matrix.h.

                                                    {
    KALDI_ASSERT(static_cast<UnsignedMatrixIndexT>(r) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_) &&
                 static_cast<UnsignedMatrixIndexT>(c) <
                 static_cast<UnsignedMatrixIndexT>(num_rows_)
                 && c <= r);
    return *(data_ + (r * (r + 1)) / 2 + c);
  }

operator=()

PackedMatrix<Real>& operator= ( const PackedMatrix< Real > &  other )

inline

Definition at line 68 of file packed-matrix.h.

Referenced by TpMatrix< float >::operator=(), and SpMatrix< float >::operator=().

                                                                   {
    Resize(other.NumRows());
    CopyFromPacked(other);
    return *this;
  }

Read()

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

Definition at line 298 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::Min(), AffineXformStats::Read(), AccumFullGmm::Read(), LdaEstimate::Read(), CuPackedMatrix< Real >::Read(), PackedMatrix< float >::Read(), IvectorExtractorStats::Read(), kaldi::UnitTestIo(), and kaldi::UnitTestIoCross().

                                                                   {
  if (add) {
    PackedMatrix<Real> tmp;
    tmp.Read(is, binary, false);  // read without adding.
    if (this->NumRows() == 0) this->Resize(tmp.NumRows());
    else {
      if (this->NumRows() != tmp.NumRows()) {
        if (tmp.NumRows() == 0) return;  // do nothing in this case.
        else KALDI_ERR << "PackedMatrix::Read, size mismatch " << this->NumRows()
                       << " vs. " << tmp.NumRows();
      }
    }
    this->AddPacked(1.0, tmp);
    return;
  } // now assume add == false.

  std::ostringstream specific_error;
  MatrixIndexT pos_at_start = is.tellg();
  int peekval = Peek(is, binary);
  const char *my_token =  (sizeof(Real) == 4 ? "FP" : "DP");
  const char *new_format_token = "[";
  bool is_new_format = false;//added by hxu
  char other_token_start = (sizeof(Real) == 4 ? 'D' : 'F');
  int32 size;
  MatrixIndexT num_elems;

  if (peekval == other_token_start) {  // need to instantiate the other type to read it.
    typedef typename OtherReal<Real>::Real OtherType;  // if Real == float, OtherType == double, and vice versa.
    PackedMatrix<OtherType> other(this->NumRows());
    other.Read(is, binary, false);  // add is false at this point.
    this->Resize(other.NumRows());
    this->CopyFromPacked(other);
    return;
  }
  std::string token;
  ReadToken(is, binary, &token);
  if (token != my_token) {
    if(token != new_format_token) {
      specific_error << ": Expected token " << my_token << ", got " << token;
      goto bad;
    }
    //new format it is
    is_new_format = true; 
  }
  if(!is_new_format) {
    ReadBasicType(is, binary, &size);  // throws on error.
    if ((MatrixIndexT)size != this->NumRows()) {
      KALDI_ASSERT(size>=0);
      this->Resize(size);
    }
    num_elems = ((size+1)*(MatrixIndexT)size)/2;
    if (!binary) {
      for (MatrixIndexT i = 0; i < num_elems; i++) {
        ReadBasicType(is, false, data_+i);  // will throw on error.
      }
    } else {
      if (num_elems)
        is.read(reinterpret_cast<char*>(data_), sizeof(Real)*num_elems);
    }
    if (is.fail()) goto bad;
    return;
  }
  else {
    std::vector<Real> data;
    while(1) {
      int32 num_lines = 0;
      int i = is.peek();
      if (i == -1) { specific_error << "Got EOF while reading matrix data"; goto bad; }
      else if (static_cast<char>(i) == ']') {  // Finished reading matrix.
        is.get();  // eat the "]".
        i = is.peek();
        if (static_cast<char>(i) == '\r') {
          is.get();
          is.get();  // get \r\n (must eat what we wrote)
        }// I don't actually understand what it's doing here
        else if (static_cast<char>(i) == '\n') { is.get(); } // get \n (must eat what we wrote)

        if (is.fail()) {
          KALDI_WARN << "After end of matrix data, read error.";
          // we got the data we needed, so just warn for this error.
        }
        //now process the data:
        num_lines = int32(sqrt(data.size()*2));
        
        KALDI_ASSERT(data.size() == num_lines*(num_lines+1)/2);

        this->Resize(num_lines);

        //std::cout<<data.size()<<' '<<num_lines<<'\n';

        for(int32 i = 0; i < data.size(); i++) {
          data_[i] = data[i];
        }
        return;
        //std::cout<<"here!!!!!hxu!!!!!"<<std::endl;
      }
      else if ( (i >= '0' && i <= '9') || i == '-' ) {  // A number...
        Real r; 
        is >> r;
        if (is.fail()) {
          specific_error << "Stream failure/EOF while reading matrix data.";
          goto bad;
        } 
        data.push_back(r);
      }
      else if (isspace(i)) {
        is.get();  // eat the space and do nothing.
      } else {  // NaN or inf or error.
        std::string str;
        is >> str;
        if (!KALDI_STRCASECMP(str.c_str(), "inf") ||
            !KALDI_STRCASECMP(str.c_str(), "infinity")) {
          data.push_back(std::numeric_limits<Real>::infinity());
          KALDI_WARN << "Reading infinite value into matrix.";
        } else if (!KALDI_STRCASECMP(str.c_str(), "nan")) {
          data.push_back(std::numeric_limits<Real>::quiet_NaN());
          KALDI_WARN << "Reading NaN value into matrix.";
        } else {
          specific_error << "Expecting numeric matrix data, got " << str;
          goto bad;
        } 
      }       
    } 
  }
bad:
  KALDI_ERR << "Failed to read packed matrix from stream. " << specific_error.str()
            << " File position at start is "
            << pos_at_start << ", currently " << is.tellg();
}

Resize()

void Resize	(	MatrixIndexT	nRows,
		MatrixResizeType	resize_type = kSetZero
	)

Set packed matrix to a specified size (can be zero).

The value of the new data depends on resize_type: -if kSetZero, the new data will be zero -if kUndefined, the new data will be undefined -if kCopyData, the new data will be the same as the old data in any shared positions, and zero elsewhere. This function takes time proportional to the number of data elements.

Definition at line 94 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::operator=(), PackedMatrix< float >::PackedMatrix(), SpMatrix< float >::Resize(), TpMatrix< float >::Resize(), CuPackedMatrix< Real >::Swap(), and PackedMatrix< float >::~PackedMatrix().

                                                                            {
  // the next block uses recursion to handle what we have to do if
  // resize_type == kCopyData.
  if (resize_type == kCopyData) {
    if (this->data_ == NULL || r == 0) resize_type = kSetZero;  // nothing to copy.
    else if (this->num_rows_ == r) { return; } // nothing to do.
    else {
      // set tmp to a packed matrix of the desired size.
      PackedMatrix<Real> tmp(r, kUndefined);
      size_t r_min = std::min(r, num_rows_);
      size_t mem_size_min = sizeof(Real) * (r_min*(r_min+1))/2,
          mem_size_full = sizeof(Real) * (r*(r+1))/2;
      // Copy the contents to tmp.
      memcpy(tmp.data_, data_, mem_size_min);
      char *ptr = static_cast<char*>(static_cast<void*>(tmp.data_));
      // Set the rest of the contents of tmp to zero.
      memset(static_cast<void*>(ptr + mem_size_min), 0, mem_size_full-mem_size_min);
      tmp.Swap(this);
      return;
    }
  }
  if (data_ != NULL) Destroy();
  Init(r);
  if (resize_type == kSetZero) SetZero();
}

Scale()

void Scale

(

Real

c

)

Definition at line 33 of file packed-matrix.cc.

Referenced by SpMatrix< float >::ApplyFloor(), Fmpe::ComputeC(), kaldi::ComputeFeatureNormalizingTransform(), AmSgmm2::ComputeHsmFromModel(), FastNnetCombiner::ComputePreconditioner(), PldaEstimator::EstimateFromStats(), kaldi::EstPca(), IvectorExtractor::GetAcousticAuxfVariance(), LdaEstimate::GetStats(), CovarianceStats::GetTotalCovar(), CovarianceStats::GetWithinCovar(), IvectorExtractorStats::IvectorVarianceDiagnostic(), main(), MleAmSgmm2Updater::MapUpdateM(), FullGmm::MergedComponentsLogdet(), PackedMatrix< float >::Min(), kaldi::MleFullGmmUpdate(), OnlinePreconditioner::PreconditionDirectionsInternal(), OnlineNaturalGradient::PreconditionDirectionsInternal(), CompressedAffineXformStats::PrepareOneG(), IvectorExtractorStats::PriorDiagnostics(), MleAmSgmm2Updater::RenormalizeN(), MleAmSgmm2Updater::RenormalizeV(), LdaEstimate::Scale(), kaldi::UnitTestCuPackedMatrixScale(), kaldi::UnitTestDeterminantSign(), UnitTestEstimateLda(), kaldi::UnitTestFloorChol(), kaldi::UnitTestIo(), kaldi::UnitTestIoCross(), kaldi::UnitTestMat2Vec(), kaldi::UnitTestNorm(), kaldi::UnitTestTraceSpSpLower(), EbwAmSgmm2Updater::UpdateM(), EbwAmSgmm2Updater::UpdateN(), EbwAmSgmm2Updater::UpdatePhoneVectorsInternal(), PldaUnsupervisedAdaptor::UpdatePlda(), IvectorExtractorStats::UpdatePrior(), EbwAmSgmm2Updater::UpdateU(), IvectorExtractorStats::UpdateVariances(), EbwAmSgmm2Updater::UpdateVars(), and MleAmSgmm2Updater::UpdateVars().

                                         {
  size_t nr = num_rows_,
      sz = (nr * (nr + 1)) / 2;
  cblas_Xscal(sz, alpha, data_, 1);
}

ScaleDiag()

void ScaleDiag

(

const Real

alpha

)

Definition at line 132 of file packed-matrix.cc.

Referenced by FullGmm::LogLikelihoodsPreselect(), kaldi::UnitTestCuPackedMatrixScaleDiag(), kaldi::UnitTestScaleDiag(), kaldi::UnitTestTraceSpSpLower(), and PackedMatrix< float >::~PackedMatrix().

                                             {
  Real *ptr = data_;
  for (MatrixIndexT i = 2; i <= num_rows_+1; i++) {
    *ptr *= alpha;
    ptr += i;
  }
}

SetDiag()

void SetDiag

(

const Real

alpha

)

Definition at line 141 of file packed-matrix.cc.

Referenced by kaldi::UnitTestCuSpMatrixConstructor(), kaldi::UnitTestSetDiag(), and PackedMatrix< float >::~PackedMatrix().

                                           {
  Real *ptr = data_;
  for (MatrixIndexT i = 2; i <= num_rows_+1; i++) {
    *ptr = alpha;
    ptr += i;
  }
}

SetRandn()

void SetRandn

(

)

< Set to unit matrix.

Definition at line 48 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::PackedMatrix(), kaldi::UnitTestAddMat2(), kaldi::UnitTestAddMat2Sp(), kaldi::UnitTestAddSp(), kaldi::UnitTestAddToDiag(), kaldi::UnitTestAddVec2Sp(), kaldi::UnitTestCuMatrixAddMatTp(), kaldi::UnitTestCuMatrixAddTpMat(), kaldi::UnitTestCuMatrixCopyFromTp(), kaldi::UnitTestCuPackedMatrixAddToDiag(), kaldi::UnitTestCuPackedMatrixConstructor(), kaldi::UnitTestCuPackedMatrixCopy(), kaldi::UnitTestCuPackedMatrixScale(), kaldi::UnitTestCuPackedMatrixScaleDiag(), kaldi::UnitTestCuPackedMatrixTrace(), kaldi::UnitTestCuSpMatrixAddMat2(), kaldi::UnitTestCuSpMatrixAddSp(), kaldi::UnitTestCuSpMatrixAddToDiag(), kaldi::UnitTestCuSpMatrixAddVec2(), kaldi::UnitTestCuSpMatrixApproxEqual(), kaldi::UnitTestCuSpMatrixOperator(), kaldi::UnitTestCuSpMatrixTraceSpSp(), kaldi::UnitTestCuTpMatrixCholesky(), kaldi::UnitTestCuTpMatrixCopyFromTp(), kaldi::UnitTestCuTpMatrixInvert(), kaldi::UnitTestCuVectorAddTp(), kaldi::UnitTestCuVectorAddTpVec(), kaldi::UnitTestCuVectorMulTp(), kaldi::UnitTestEigSymmetric(), kaldi::UnitTestInnerProd(), kaldi::UnitTestIo(), kaldi::UnitTestIoCross(), kaldi::UnitTestMaxAbsEig(), kaldi::UnitTestMaxMin(), kaldi::UnitTestMul(), kaldi::UnitTestMulTp(), kaldi::UnitTestNorm(), kaldi::UnitTestResize(), kaldi::UnitTestScaleDiag(), kaldi::UnitTestSimpleForMat(), kaldi::UnitTestSpAddDiagVec(), kaldi::UnitTestSpAddVecVec(), kaldi::UnitTestSvdSpeed(), kaldi::UnitTestTp2(), kaldi::UnitTestTp2Sp(), kaldi::UnitTestTrace(), kaldi::UnitTestTraceSpSpLower(), and kaldi::UnitTestTriVecSolver().

                                  {
  Real *data = data_;
  size_t dim = num_rows_, size = ((dim*(dim+1))/2);
  for (size_t i = 0; i < size; i++)
    data[i] = RandGauss();  
}

SetUnit()

void SetUnit

(

)

< Set to zero

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

Referenced by AmSgmm2::ComputeHsmFromModel(), PldaEstimator::InitParameters(), kaldi::NonOrthogonality(), kaldi::NonUnitness(), PackedMatrix< float >::PackedMatrix(), kaldi::UnitTestCuSpMatrixSetUnit(), and MleAmSgmm2Updater::UpdateVars().

                                 {
  memset(data_, 0, SizeInBytes());
  for (MatrixIndexT row = 0;row < num_rows_;row++)
    (*this)(row, row) = 1.0;
}

SetZero()

void SetZero

(

)

Definition at line 207 of file packed-matrix.cc.

Referenced by IvectorExtractorUtteranceStats::AccStats(), RegtreeMllrDiagGmmAccs::AccumulateForGmm(), FmllrRawAccs::CommitSingleFrameStats(), AmSgmm2::ComputeHsmFromModel(), PackedMatrix< float >::PackedMatrix(), LdaEstimate::Read(), kaldi::UnitTestCopySp(), kaldi::UnitTestCuSpMatrixConstructor(), kaldi::UnitTestSimpleForMat(), MleAmSgmm2Updater::UpdateWGetStats(), and LdaEstimate::ZeroAccumulators().

                                 {
  memset(data_, 0, SizeInBytes());
}

SizeInBytes()

size_t SizeInBytes ( ) const

inline

Definition at line 106 of file packed-matrix.h.

Referenced by SpMatrix< float >::AddMat2Sp(), and CuPackedMatrix< Real >::CopyFromPacked().

                             {
    size_t nr = static_cast<size_t>(num_rows_);
    return ((nr * (nr+1)) / 2) * sizeof(Real);
  }

Swap() [1/2]

void Swap

(

PackedMatrix< Real > *

other

)

Swaps the contents of *this and *other. Shallow swap.

Definition at line 81 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::Min(), PackedMatrix< float >::Resize(), and CuPackedMatrix< Real >::Swap().

                                                       {
  std::swap(data_, other->data_);
  std::swap(num_rows_, other->num_rows_);
}

Swap() [2/2]

void Swap

(

Matrix< Real > *

other

)

Definition at line 87 of file packed-matrix.cc.

                                                 {
  std::swap(data_, other->data_);
  std::swap(num_rows_, other->num_rows_);
}

Trace()

Real Trace

(

)

const

< Set to random values of a normal distribution

Definition at line 219 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::PackedMatrix(), kaldi::UnitTestCuPackedMatrixTrace(), and kaldi::UnitTestCuTpMatrixCopyFromMat().

                                     {
  Real ans = 0.0;
  for (MatrixIndexT row = 0;row < num_rows_;row++)
    ans += (*this)(row, row);
  return ans;
}

Write()

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

Definition at line 236 of file packed-matrix.cc.

Referenced by PackedMatrix< float >::Min(), kaldi::UnitTestIoCross(), AffineXformStats::Write(), AccumFullGmm::Write(), LdaEstimate::Write(), CuPackedMatrix< Real >::Write(), and IvectorExtractorStats::Write().

                                                                {
  if (!os.good()) {
    KALDI_ERR << "Failed to write vector to stream: stream not good";
  }

  int32 size = this->NumRows();  // make the size 32-bit on disk.
  KALDI_ASSERT(this->NumRows() == (MatrixIndexT) size);
  MatrixIndexT num_elems = ((size+1)*(MatrixIndexT)size)/2;

  if(binary) {  
    std::string my_token = (sizeof(Real) == 4 ? "FP" : "DP");
    WriteToken(os, binary, my_token);
    WriteBasicType(os, binary, size);
  // We don't use the built-in Kaldi write routines for the floats, as they are
  // not efficient enough.
    os.write((const char*) data_, sizeof(Real) * num_elems);
  }
  else {
    if(size == 0)
      os<<"[ ]\n";
    else {
      os<<"[\n";
      MatrixIndexT i = 0;
      for (int32 j = 0; j < size; j++) {  
        for (int32 k = 0; k < j + 1; k++) {
          WriteBasicType(os, binary, data_[i++]);
        }
        os << ( (j==size-1)? "]\n" : "\n");
      }
      KALDI_ASSERT(i == num_elems);
    }
  }
  if (os.fail()) {
    KALDI_ERR << "Failed to write packed matrix to stream";
  }
}

Friends And Related Function Documentation

CuPackedMatrix< Real >

friend class CuPackedMatrix< Real >

friend

Definition at line 41 of file packed-matrix.h.

operator<<

std::ostream& operator<< ( std::ostream &  out, const PackedMatrix< Real > &  m  )

friend

Definition at line 181 of file packed-matrix.h.

                                                                        {
  M.Write(os, false);
  return os;
}

Member Data Documentation

data_

Real* data_

protected

Definition at line 163 of file packed-matrix.h.

Referenced by CuPackedMatrix< Real >::CopyFromPacked(), CuPackedMatrix< Real >::CopyToPacked(), PackedMatrix< float >::Data(), PackedMatrix< float >::Max(), PackedMatrix< float >::Min(), TpMatrix< float >::operator()(), SpMatrix< float >::operator()(), PackedMatrix< float >::operator()(), PackedMatrix< float >::Resize(), SpMatrix< float >::Swap(), TpMatrix< float >::Swap(), CuPackedMatrix< Real >::Swap(), and PackedMatrix< float >::Swap().

num_rows_

MatrixIndexT num_rows_

protected

Definition at line 164 of file packed-matrix.h.

Referenced by CuPackedMatrix< Real >::CuPackedMatrix(), PackedMatrix< float >::Max(), PackedMatrix< float >::Min(), PackedMatrix< float >::NumCols(), PackedMatrix< float >::NumRows(), TpMatrix< float >::operator()(), SpMatrix< float >::operator()(), PackedMatrix< float >::operator()(), PackedMatrix< float >::SizeInBytes(), SpMatrix< float >::Swap(), TpMatrix< float >::Swap(), CuPackedMatrix< Real >::Swap(), and PackedMatrix< float >::Swap().

---

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

• matrix/matrix-common.h
• matrix/packed-matrix.h
• matrix/packed-matrix.cc