SparseMatrix< Real > Class Template Reference

#include <matrix-common.h>

Collaboration diagram for SparseMatrix< Real >:

Public Member Functions
MatrixIndexT	NumRows () const
MatrixIndexT	NumCols () const
MatrixIndexT	NumElements () const
Real	Sum () const
Real	FrobeniusNorm () const
	SparseMatrix (const MatrixBase< Real > &mat)
	This constructor creates a SparseMatrix that just contains the nonzero elements of 'mat'. More...
template<class OtherReal >
void	CopyToMat (MatrixBase< OtherReal > *other, MatrixTransposeType t=kNoTrans) const
	Copy to matrix. It must already have the correct size. More...
void	CopyElementsToVec (VectorBase< Real > *other) const
	Copies the values of all the elements in SparseMatrix into a VectorBase object. More...
template<class OtherReal >
void	CopyFromSmat (const SparseMatrix< OtherReal > &other, MatrixTransposeType trans=kNoTrans)
	Copies data from another sparse matrix. More...
void	AddToMat (BaseFloat alpha, MatrixBase< Real > *other, MatrixTransposeType t=kNoTrans) const
	Does *other = *other + alpha * *this. More...
SparseMatrix< Real > &	operator= (const SparseMatrix< Real > &other)
	SparseMatrix (const SparseMatrix< Real > &other, MatrixTransposeType trans=kNoTrans)
void	Swap (SparseMatrix< Real > *other)
SparseVector< Real > *	Data ()
const SparseVector< Real > *	Data () const
	SparseMatrix (int32 dim, const std::vector< std::vector< std::pair< MatrixIndexT, Real > > > &pairs)
void	SetRandn (BaseFloat zero_prob)
	Sets up to a pseudo-randomly initialized matrix, with each element zero with probability zero_prob and else normally distributed- mostly for purposes of testing. More...
void	Write (std::ostream &os, bool binary) const
void	Read (std::istream &os, bool binary)
const SparseVector< Real > &	Row (MatrixIndexT r) const
void	SetRow (int32 r, const SparseVector< Real > &vec)
	Sets row r to "vec"; makes sure it has the correct dimension. More...
void	SelectRows (const std::vector< int32 > &row_indexes, const SparseMatrix< Real > &smat_other)
	Select a subset of the rows of a SparseMatrix. More...
void	AppendSparseMatrixRows (std::vector< SparseMatrix< Real > > *inputs)
	Sets *this to all the rows of *inputs appended together; this function is destructive of the inputs. More...
	SparseMatrix ()
	SparseMatrix (int32 num_rows, int32 num_cols)
	SparseMatrix (const std::vector< int32 > &indexes, int32 dim, MatrixTransposeType trans=kNoTrans)
	Constructor from an array of indexes. More...
	SparseMatrix (const std::vector< int32 > &indexes, const VectorBase< Real > &weights, int32 dim, MatrixTransposeType trans=kNoTrans)
	Constructor from an array of indexes and an array of weights; requires indexes.Dim() == weights.Dim(). More...
void	Resize (MatrixIndexT rows, MatrixIndexT cols, MatrixResizeType resize_type=kSetZero)
	Resizes the matrix; analogous to Matrix::Resize(). More...
void	Scale (Real alpha)
	Scale all elements in sparse matrix. More...

Private Attributes
std::vector< SparseVector< Real > >	rows_

Detailed Description

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

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

Constructor & Destructor Documentation

SparseMatrix() [1/7]

SparseMatrix ( const MatrixBase< Real > &  mat )

explicit

This constructor creates a SparseMatrix that just contains the nonzero elements of 'mat'.

Definition at line 694 of file sparse-matrix.cc.

                                                            {
  MatrixIndexT num_rows = mat.NumRows();
  rows_.resize(num_rows);
  for (int32 row = 0; row < num_rows; row++) {
    SparseVector<Real> this_row(mat.Row(row));
    rows_[row].Swap(&this_row);
  }
}

SparseMatrix() [2/7]

SparseMatrix ( const SparseMatrix< Real > &  other, MatrixTransposeType  trans = kNoTrans  )

inline

Definition at line 166 of file sparse-matrix.h.

                             {
    this->CopyFromSmat(other, trans);
  }

SparseMatrix() [3/7]

SparseMatrix	(	int32	dim,
		const std::vector< std::vector< std::pair< MatrixIndexT, Real > > > &	pairs
	)

Definition at line 618 of file sparse-matrix.cc.

                                                                     :
    rows_(pairs.size()) {
  MatrixIndexT num_rows = pairs.size();
  for (MatrixIndexT row = 0; row < num_rows; row++) {
    SparseVector<Real> svec(dim, pairs[row]);
    rows_[row].Swap(&svec);
  }
}

SparseMatrix() [4/7]

SparseMatrix ( )

inline

Definition at line 215 of file sparse-matrix.h.

{ }

SparseMatrix() [5/7]

SparseMatrix ( int32  num_rows, int32  num_cols  )

inline

Definition at line 217 of file sparse-matrix.h.

{ Resize(num_rows, num_cols); }

SparseMatrix() [6/7]

SparseMatrix	(	const std::vector< int32 > &	indexes,
		int32	dim,
		MatrixTransposeType	trans = kNoTrans
	)

Constructor from an array of indexes.

If trans == kNoTrans, construct a sparse matrix with num-rows == indexes.Dim() and num-cols = 'dim'. 'indexes' is expected to contain elements in the range [0, dim - 1]. Each row 'i' of *this after calling the constructor will contain a single element at column-index indexes[i] with value 1.0.

If trans == kTrans, the result will be the transpose of the sparse matrix described above.

Definition at line 566 of file sparse-matrix.cc.

                                                            {
  const std::vector<int32>& idx = indexes;
  std::vector<std::vector<std::pair<MatrixIndexT, Real> > > pair(idx.size());
  for (int i = 0; i < idx.size(); ++i) {
    if (idx[i] >= 0) {
      pair[i].push_back( { idx[i], Real(1) });
    }
  }
  SparseMatrix<Real> smat_cpu(dim, pair);
  if (trans == kNoTrans) {
    this->Swap(&smat_cpu);
  } else {
    SparseMatrix<Real> tmp(smat_cpu, kTrans);
    this->Swap(&tmp);
  }
}

SparseMatrix() [7/7]

SparseMatrix	(	const std::vector< int32 > &	indexes,
		const VectorBase< Real > &	weights,
		int32	dim,
		MatrixTransposeType	trans = kNoTrans
	)

Constructor from an array of indexes and an array of weights; requires indexes.Dim() == weights.Dim().

If trans == kNoTrans, construct a sparse matrix with num-rows == indexes.Dim() and num-cols = 'dim'. 'indexes' is expected to contain elements in the range [0, dim - 1]. Each row 'i' of *this after calling the constructor will contain a single element at column-index indexes[i] with value weights[i]. If trans == kTrans, the result will be the transpose of the sparse matrix described above.

Definition at line 585 of file sparse-matrix.cc.

                                                            {
  const std::vector<int32>& idx = indexes;
  const VectorBase<Real>& w = weights;
  std::vector<std::vector<std::pair<MatrixIndexT, Real> > > pair(idx.size());
  for (int i = 0; i < idx.size(); ++i) {
    if (idx[i] >= 0) {
      pair[i].push_back( { idx[i], w(i) });
    }
  }
  SparseMatrix<Real> smat_cpu(dim, pair);
  if (trans == kNoTrans) {
    this->Swap(&smat_cpu);
  } else {
    SparseMatrix<Real> tmp(smat_cpu, kTrans);
    this->Swap(&tmp);
  }
}

Member Function Documentation

AddToMat()

void AddToMat	(	BaseFloat	alpha,
		MatrixBase< Real > *	other,
		MatrixTransposeType	t = kNoTrans
	)		const

Does *other = *other + alpha * *this.

Definition at line 496 of file sparse-matrix.cc.

Referenced by kaldi::UnitTestSparseMatrixAddToMat().

                                                                   {
  if (trans == kNoTrans) {
    MatrixIndexT num_rows = rows_.size();
    KALDI_ASSERT(other->NumRows() == num_rows);
    for (MatrixIndexT i = 0; i < num_rows; i++) {
      SubVector<Real> vec(*other, i);
      rows_[i].AddToVec(alpha, &vec);
    }
  } else {
    Real *other_col_data = other->Data();
    MatrixIndexT other_stride = other->Stride(),
        num_rows = NumRows(), num_cols = NumCols();
    KALDI_ASSERT(num_rows == other->NumCols() && num_cols == other->NumRows());
    for (MatrixIndexT row = 0; row < num_rows; row++, other_col_data++) {
      const SparseVector<Real> &svec = rows_[row];
      MatrixIndexT num_elems = svec.NumElements();
      const std::pair<MatrixIndexT, Real> *sdata = svec.Data();
      for (MatrixIndexT e = 0; e < num_elems; e++)
        other_col_data[sdata[e].first * other_stride] +=
            alpha * sdata[e].second;
    }
  }
}

AppendSparseMatrixRows()

void AppendSparseMatrixRows

(

std::vector< SparseMatrix< Real > > *

inputs

)

Sets *this to all the rows of *inputs appended together; this function is destructive of the inputs.

Requires, obviously, that the inputs all have the same dimension (although some may be empty).

Definition at line 656 of file sparse-matrix.cc.

Referenced by kaldi::AppendGeneralMatrixRows().

                                            {
  rows_.clear();
  size_t num_rows = 0;
  typename std::vector<SparseMatrix<Real> >::iterator
      input_iter = inputs->begin(),
      input_end = inputs->end();
  for (; input_iter != input_end; ++input_iter)
    num_rows += input_iter->rows_.size();
  rows_.resize(num_rows);
  typename std::vector<SparseVector<Real> >::iterator
      row_iter = rows_.begin(),
      row_end = rows_.end();
  for (input_iter = inputs->begin(); input_iter != input_end; ++input_iter) {
    typename std::vector<SparseVector<Real> >::iterator
        input_row_iter = input_iter->rows_.begin(),
        input_row_end = input_iter->rows_.end();
    for (; input_row_iter != input_row_end; ++input_row_iter, ++row_iter)
      row_iter->Swap(&(*input_row_iter));
  }
  KALDI_ASSERT(row_iter == row_end);
  int32 num_cols = NumCols();
  for (row_iter = rows_.begin(); row_iter != row_end; ++row_iter) {
    if (row_iter->Dim() != num_cols)
      KALDI_ERR << "Appending rows with inconsistent dimensions, "
                << row_iter->Dim() << " vs. " << num_cols;
  }
  inputs->clear();
}

CopyElementsToVec()

void CopyElementsToVec

(

VectorBase< Real > *

other

)

const

Copies the values of all the elements in SparseMatrix into a VectorBase object.

Definition at line 391 of file sparse-matrix.cc.

                                                                        {
  KALDI_ASSERT(other->Dim() == NumElements());
  Real *dst_data = other->Data();
  int32 dst_index = 0;
  for (int32 i = 0; i < rows_.size(); ++i) {
    for (int32 j = 0; j < rows_[i].NumElements(); ++j) {
      dst_data[dst_index] =
          static_cast<Real>(rows_[i].GetElement(j).second);
      dst_index++;
    }
  }
}

CopyFromSmat()

template void CopyFromSmat	(	const SparseMatrix< OtherReal > &	other,
		MatrixTransposeType	trans = kNoTrans
	)

Copies data from another sparse matrix.

Definition at line 406 of file sparse-matrix.cc.

Referenced by SparseMatrix< float >::CopyFromSmat(), and CuSparseMatrix< Real >::CopyToSmat().

                                                                 {
  if (trans == kNoTrans) {
    rows_.resize(other.NumRows());
    if (rows_.size() == 0)
      return;
    for (int32 r = 0; r < rows_.size(); ++r) {
      rows_[r].CopyFromSvec(other.Row(r));
    }
  } else {
    std::vector<std::vector<std::pair<MatrixIndexT, Real> > > pairs(
        other.NumCols());
    for (MatrixIndexT i = 0; i < other.NumRows(); ++i) {
      for (int id = 0; id < other.Row(i).NumElements(); ++id) {
        MatrixIndexT j = other.Row(i).GetElement(id).first;
        Real v = static_cast<Real>(other.Row(i).GetElement(id).second);
        pairs[j].push_back( { i, v });
      }
    }
    SparseMatrix<Real> temp(other.NumRows(), pairs);
    Swap(&temp);
  }
}

CopyToMat()

template void CopyToMat	(	MatrixBase< OtherReal > *	other,
		MatrixTransposeType	t = kNoTrans
	)		const

Copy to matrix. It must already have the correct size.

Definition at line 352 of file sparse-matrix.cc.

Referenced by CuMatrixBase< float >::CopyFromGeneralMat(), SparseMatrix< float >::CopyToMat(), kaldi::UnitTestCuSparseMatrixConstructFromIndexes(), kaldi::UnitTestGeneralMatrix(), kaldi::UnitTestSparseMatrixAddToMat(), kaldi::UnitTestSparseMatrixConstructor(), kaldi::UnitTestSparseMatrixFrobeniusNorm(), kaldi::UnitTestSparseMatrixSum(), and kaldi::UnitTestSparseMatrixTraceMatSmat().

                                                                    {
  if (trans == kNoTrans) {
    MatrixIndexT num_rows = rows_.size();
    KALDI_ASSERT(other->NumRows() == num_rows);
    for (MatrixIndexT i = 0; i < num_rows; i++) {
      SubVector<OtherReal> vec(*other, i);
      rows_[i].CopyElementsToVec(&vec);
    }
  } else {
    OtherReal *other_col_data = other->Data();
    MatrixIndexT other_stride = other->Stride(),
        num_rows = NumRows(), num_cols = NumCols();
    KALDI_ASSERT(num_rows == other->NumCols() && num_cols == other->NumRows());
    other->SetZero();
    for (MatrixIndexT row = 0; row < num_rows; row++, other_col_data++) {
      const SparseVector<Real> &svec = rows_[row];
      MatrixIndexT num_elems = svec.NumElements();
      const std::pair<MatrixIndexT, Real> *sdata = svec.Data();
      for (MatrixIndexT e = 0; e < num_elems; e++)
        other_col_data[sdata[e].first * other_stride] = sdata[e].second;
    }
  }
}

Data() [1/2]

SparseVector< Real > * Data

(

)

Definition at line 314 of file sparse-matrix.cc.

Referenced by CuSparseMatrix< Real >::CopyFromSmat().

                                             {
  if (rows_.empty())
    return NULL;
  else
    return rows_.data();
}

Data() [2/2]

const SparseVector< Real > * Data

(

)

const

Definition at line 322 of file sparse-matrix.cc.

                                                         {
  if (rows_.empty())
    return NULL;
  else
    return rows_.data();
}

FrobeniusNorm()

Real FrobeniusNorm

(

)

const

Definition at line 339 of file sparse-matrix.cc.

Referenced by kaldi::UnitTestSparseMatrixFrobeniusNorm().

                                             {
  Real squared_sum = 0;
  for (int32 i = 0; i < rows_.size(); ++i) {
    const std::pair<MatrixIndexT, Real> *row_data = rows_[i].Data();
    for (int32 j = 0; j < rows_[i].NumElements(); ++j) {
      squared_sum += row_data[j].second * row_data[j].second;
    }
  }
  return std::sqrt(squared_sum);
}

NumCols()

MatrixIndexT NumCols

(

)

const

Definition at line 297 of file sparse-matrix.cc.

Referenced by MatrixBase< float >::AddMatSmat(), MatrixBase< float >::AddSmat(), MatrixBase< float >::AddSmatMat(), CuSparseMatrix< Real >::CopyFromSmat(), SparseMatrix< float >::CopyFromSmat(), kaldi::ExtractRowRangeWithPadding(), kaldi::FilterSparseMatrixRows(), SparseMatrix< float >::SelectRows(), kaldi::TraceMatSmat(), kaldi::UnitTestCuSparseMatrixConstructFromIndexes(), and kaldi::UnitTestCuSparseMatrixSwap().

                                               {
  if (rows_.empty())
    return 0.0;
  else
    return rows_[0].Dim();
}

NumElements()

MatrixIndexT NumElements

(

)

const

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

Referenced by CuSparseMatrix< Real >::CopyFromSmat().

                                                   {
  int32 num_elements = 0;
  for (int32 i = 0; i < rows_.size(); ++i) {
    num_elements += rows_[i].NumElements();
  }
  return num_elements;
}

NumRows()

MatrixIndexT NumRows

(

)

const

Definition at line 292 of file sparse-matrix.cc.

Referenced by MatrixBase< float >::AddMatSmat(), MatrixBase< float >::AddSmat(), MatrixBase< float >::AddSmatMat(), CuSparseMatrix< Real >::CopyFromSmat(), SparseMatrix< float >::CopyFromSmat(), kaldi::ExtractRowRangeWithPadding(), kaldi::FilterSparseMatrixRows(), kaldi::TraceMatSmat(), kaldi::UnitTestCuSparseMatrixConstructFromIndexes(), and kaldi::UnitTestCuSparseMatrixSwap().

                                               {
  return rows_.size();
}

operator=()

SparseMatrix< Real > & operator=

(

const SparseMatrix< Real > &

other

)

Definition at line 606 of file sparse-matrix.cc.

                                     {
  rows_ = other.rows_;
  return *this;
}

Read()

void Read	(	std::istream &	os,
		bool	binary
	)

Definition at line 467 of file sparse-matrix.cc.

Referenced by CuSparseMatrix< Real >::Read().

                                                         {
  if (binary) {
    ExpectToken(is, binary, "SM");
    int32 num_rows;
    ReadBasicType(is, binary, &num_rows);
    KALDI_ASSERT(num_rows >= 0 && num_rows < 10000000);
    rows_.resize(num_rows);
    for (int32 row = 0; row < num_rows; row++)
      rows_[row].Read(is, binary);
  } else {
    std::string str;
    is >> str;
    if (str.substr(0, 5) != "rows=")
      KALDI_ERR << "Reading sparse matrix, expected 'rows=xxx', got " << str;
    std::string rows_str = str.substr(5, std::string::npos);
    std::istringstream rows_istr(rows_str);
    int32 num_rows = -1;
    rows_istr >> num_rows;
    if (num_rows < 0 || rows_istr.fail()) {
      KALDI_ERR << "Reading sparse vector, expected 'rows=[int]', got " << str;
    }
    rows_.resize(num_rows);
    for (int32 row = 0; row < num_rows; row++)
      rows_[row].Read(is, binary);
  }
}

Resize()

void Resize	(	MatrixIndexT	rows,
		MatrixIndexT	cols,
		MatrixResizeType	resize_type = kSetZero
	)

Resizes the matrix; analogous to Matrix::Resize().

resize_type == kUndefined behaves the same as kSetZero.

Definition at line 637 of file sparse-matrix.cc.

Referenced by CuSparseMatrix< Real >::CopyToSmat(), and kaldi::FilterSparseMatrixRows().

                                                              {
  KALDI_ASSERT(num_rows >= 0 && num_cols >= 0);
  if (resize_type == kSetZero || resize_type == kUndefined) {
    rows_.clear();
    Resize(num_rows, num_cols, kCopyData);
  } else {
    // Assume resize_type == kCopyData from here.
    int32 old_num_rows = rows_.size(), old_num_cols = NumCols();
    SparseVector<Real> initializer(num_cols);
    rows_.resize(num_rows, initializer);
    if (num_cols != old_num_cols)
      for (int32 row = 0; row < old_num_rows; row++)
        rows_[row].Resize(num_cols, kCopyData);
  }
}

Row()

const SparseVector< Real > & Row

(

MatrixIndexT

r

)

const

Definition at line 543 of file sparse-matrix.cc.

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), MatrixBase< float >::AddMatSmat(), MatrixBase< float >::AddSmat(), MatrixBase< float >::AddSmatMat(), kaldi::nnet3::ComputeAccuracy(), SparseMatrix< float >::CopyFromSmat(), kaldi::ExtractRowRangeWithPadding(), kaldi::FilterSparseMatrixRows(), SparseMatrix< float >::SelectRows(), and kaldi::TraceMatSmat().

                                                                      {
  KALDI_ASSERT(static_cast<size_t>(r) < rows_.size());
  return rows_[r];
}

Scale()

void Scale

(

Real

alpha

)

Scale all elements in sparse matrix.

Definition at line 687 of file sparse-matrix.cc.

                                         {
  MatrixIndexT num_rows = rows_.size();
  for (MatrixIndexT row = 0; row < num_rows; row++)
    rows_[row].Scale(alpha);
}

SelectRows()

void SelectRows	(	const std::vector< int32 > &	row_indexes,
		const SparseMatrix< Real > &	smat_other
	)

Select a subset of the rows of a SparseMatrix.

Sets *this to only the rows of 'smat_other' that are listed in 'row_indexes'. 'row_indexes' must satisfy 0 <= row_indexes[i] < smat_other.NumRows().

Definition at line 557 of file sparse-matrix.cc.

Referenced by kaldi::UnitTestCuSparseMatrixSelectRowsAndTranspose().

                                                                          {
  Resize(row_indexes.size(), smat_other.NumCols());
  for (int i = 0; i < row_indexes.size(); ++i) {
    SetRow(i, smat_other.Row(row_indexes[i]));
  }
}

SetRandn()

void SetRandn

(

BaseFloat

zero_prob

)

Sets up to a pseudo-randomly initialized matrix, with each element zero with probability zero_prob and else normally distributed- mostly for purposes of testing.

Definition at line 630 of file sparse-matrix.cc.

Referenced by CuSparseMatrix< Real >::SetRandn(), kaldi::UnitTestCuSparseMatrixCopyToSmat(), kaldi::UnitTestCuSparseMatrixFrobeniusNorm(), kaldi::UnitTestCuSparseMatrixSelectRowsAndTranspose(), kaldi::UnitTestCuSparseMatrixSum(), kaldi::UnitTestCuSparseMatrixSwap(), kaldi::UnitTestCuSparseMatrixTraceMatSmat(), kaldi::UnitTestGeneralMatrix(), kaldi::UnitTestMatrixAddMatSmat(), kaldi::UnitTestMatrixAddSmatMat(), kaldi::UnitTestSparseMatrixAddToMat(), kaldi::UnitTestSparseMatrixFrobeniusNorm(), kaldi::UnitTestSparseMatrixSum(), kaldi::UnitTestSparseMatrixTraceMatSmat(), kaldi::UnitTextCuMatrixAddMatSmat(), kaldi::UnitTextCuMatrixAddSmat(), and kaldi::UnitTextCuMatrixAddSmatMat().

                                                     {
  MatrixIndexT num_rows = rows_.size();
  for (MatrixIndexT row = 0; row < num_rows; row++)
    rows_[row].SetRandn(zero_prob);
}

SetRow()

void SetRow	(	int32	r,
		const SparseVector< Real > &	vec
	)

Sets row r to "vec"; makes sure it has the correct dimension.

Definition at line 549 of file sparse-matrix.cc.

Referenced by kaldi::ExtractRowRangeWithPadding(), and kaldi::FilterSparseMatrixRows().

                                                                      {
  KALDI_ASSERT(static_cast<size_t>(r) < rows_.size() &&
               vec.Dim() == rows_[0].Dim());
  rows_[r] = vec;
}

Sum()

Real Sum

(

)

const

Definition at line 330 of file sparse-matrix.cc.

Referenced by kaldi::UnitTestSparseMatrixSum().

                                   {
  Real sum = 0;
  for (int32 i = 0; i < rows_.size(); ++i) {
    sum += rows_[i].Sum();
  }
  return sum;
}

Swap()

void Swap

(

SparseMatrix< Real > *

other

)

Definition at line 613 of file sparse-matrix.cc.

Referenced by CuSparseMatrix< Real >::CopyToSmat(), and GeneralMatrix::SwapSparseMatrix().

                                                       {
  rows_.swap(other->rows_);
}

Write()

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

Definition at line 443 of file sparse-matrix.cc.

Referenced by CuSparseMatrix< Real >::Write().

                                                                {
  if (binary) {
    // Note: we can use the same marker for float and double SparseMatrix,
    // because internally we use WriteBasicType and ReadBasicType to read the
    // floats and doubles, and this will automatically take care of type
    // conversion.
    WriteToken(os, binary, "SM");
    int32 num_rows = rows_.size();
    WriteBasicType(os, binary, num_rows);
    for (int32 row = 0; row < num_rows; row++)
      rows_[row].Write(os, binary);
  } else {
    // The format is "rows=10 dim=20 [ 1 0.4  9 1.2 ] dim=20 [ 3 1.7 19 0.6 ] ..
    // not 100% efficient, but easy to work with, and we can re-use the
    // read/write code from SparseVector.
    int32 num_rows = rows_.size();
    os << "rows=" << num_rows << " ";
    for (int32 row = 0; row < num_rows; row++)
      rows_[row].Write(os, binary);
    os << "\n";  // Might make it a little more readable.
  }
}

Member Data Documentation

rows_

std::vector<SparseVector<Real> > rows_

private

Definition at line 261 of file sparse-matrix.h.

Referenced by SparseMatrix< float >::operator=(), and SparseMatrix< float >::Swap().

---

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

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