portelli/LatAnalyze
1
0
Fork 0
mirror of https://github.com/aportelli/LatAnalyze.git synced 2024-11-10 08:55:37 +00:00
Code Releases Activity

DMatSample: block access

Browse Source
This commit is contained in:
Antonin Portelli 2014-03-04 17:16:51 +00:00
parent 559a29f92d
commit 104b21d72e
2 changed files with 200 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
latan/Sample.cpp
View File

@ -34,10 +34,76 @@ DMatSample::DMatSample(const Index nSample, const Index nRow,
resizeMat(nRow, nCol);
}
DMatSample::DMatSample(ConstBlock &sampleBlock)
: DMatSample(sampleBlock.getSample().size(), sampleBlock.getNRow(),
sampleBlock.getNCol())
{
const DMatSample &sample = sampleBlock.getSample();
FOR_STAT_ARRAY(*this, s)
{
(*this)[s] = sample[s].block(sampleBlock.getStartRow(),
sampleBlock.getStartCol(),
sampleBlock.getNRow(),
sampleBlock.getNCol());
}
}
DMatSample::DMatSample(ConstBlock &&sampleBlock)
: DMatSample(sampleBlock)
{}
// assignement operator ////////////////////////////////////////////////////////
DMatSample & DMatSample::operator=(Block &sampleBlock)
{
DMatSample tmp(sampleBlock);
this->swap(tmp);
return *this;
}
DMatSample & DMatSample::operator=(Block &&sampleBlock)
{
*this = sampleBlock;
return *this;
}
DMatSample & DMatSample::operator=(ConstBlock &sampleBlock)
{
DMatSample tmp(sampleBlock);
this->swap(tmp);
return *this;
}
DMatSample & DMatSample::operator=(ConstBlock &&sampleBlock)
{
*this = sampleBlock;
return *this;
}
// block access ////////////////////////////////////////////////////////////////
DMatSample::ConstBlock DMatSample::block(const Index i, const Index j,
const Index nRow,
const Index nCol) const
{
return ConstBlock(*this, i, j, nRow, nCol);
}
DMatSample::Block DMatSample::block(const Index i, const Index j,
const Index nRow, const Index nCol)
{
return Block(*this, i, j, nRow, nCol);
}
// resize all matrices /////////////////////////////////////////////////////////
void DMatSample::resizeMat(const Index nRow, const Index nCol)
{
FOR_VEC(*this, s)
FOR_STAT_ARRAY(*this, s)
{
(*this)[s].resize(nRow, nCol);
}

133
latan/Sample.hpp
View File

@ -50,21 +50,154 @@ public:
/******************************************************************************
* DMatSample class *
******************************************************************************/
class DMatSample: public Sample<DMat>, public IoObject
{
public:
// block type template
template <class S>
class BlockTemplate
{
private:
typedef typename std::remove_const<S>::type NonConstType;
public:
// constructors
BlockTemplate(S &sample, const Index i, const Index j, const Index nRow,
const Index nCol);
BlockTemplate(BlockTemplate<NonConstType> &b);
BlockTemplate(BlockTemplate<NonConstType> &&b);
// destructor
~BlockTemplate(void) = default;
// access
S & getSample(void);
const S & getSample(void) const;
Index getStartRow(void) const;
Index getStartCol(void) const;
Index getNRow(void) const;
Index getNCol(void) const;
// assignement operators
BlockTemplate<S> & operator=(const S &sample);
BlockTemplate<S> & operator=(const S &&sample);
private:
S &sample_;
const Index i_, j_, nRow_, nCol_;
};
// block types
typedef BlockTemplate<DMatSample> Block;
typedef const BlockTemplate<const DMatSample> ConstBlock;
public:
// constructors
DMatSample(void) = default;
DMatSample(const Index nSample, const Index nRow, const Index nCol);
DMatSample(ConstBlock &sampleBlock);
DMatSample(ConstBlock &&sampleBlock);
using Sample<DMat>::Sample;
// destructor
virtual ~DMatSample(void) = default;
// assignement operator
DMatSample & operator=(Block &sampleBlock);
DMatSample & operator=(Block &&sampleBlock);
DMatSample & operator=(ConstBlock &sampleBlock);
DMatSample & operator=(ConstBlock &&sampleBlock);
// block access
ConstBlock block(const Index i, const Index j, const Index nRow,
const Index nCol) const;
Block block(const Index i, const Index j, const Index nRow,
const Index nCol);
// resize all matrices
void resizeMat(const Index nRow, const Index nCol);
// IO type
virtual IoType getType(void) const;
};
/******************************************************************************
* Block template implementation *
******************************************************************************/
// constructors ////////////////////////////////////////////////////////////////
template <class S>
DMatSample::BlockTemplate<S>::BlockTemplate(S &sample, const Index i,
const Index j, const Index nRow,
const Index nCol)
: sample_(sample)
, i_(i)
, j_(j)
, nRow_(nRow)
, nCol_(nCol)
{}
template <class S>
DMatSample::BlockTemplate<S>::BlockTemplate(BlockTemplate<NonConstType> &b)
: sample_(b.getSample())
, i_(b.getStartRow())
, j_(b.getStartCol())
, nRow_(b.getNRow())
, nCol_(b.getNCol())
{}
template <class S>
DMatSample::BlockTemplate<S>::BlockTemplate(BlockTemplate<NonConstType> &&b)
: BlockTemplate(b)
{}
// access //////////////////////////////////////////////////////////////////////
template <class S>
S & DMatSample::BlockTemplate<S>::getSample(void)
{
return sample_;
}
template <class S>
const S & DMatSample::BlockTemplate<S>::getSample(void) const
{
return sample_;
}
template <class S>
Index DMatSample::BlockTemplate<S>::getStartRow(void) const
{
return i_;
}
template <class S>
Index DMatSample::BlockTemplate<S>::getStartCol(void) const
{
return j_;
}
template <class S>
Index DMatSample::BlockTemplate<S>::getNRow(void) const
{
return nRow_;
}
template <class S>
Index DMatSample::BlockTemplate<S>::getNCol(void) const
{
return nCol_;
}
// assignement operators ///////////////////////////////////////////////////////
template <class S>
DMatSample::BlockTemplate<S> &
DMatSample::BlockTemplate<S>::operator=(const S &sample)
{
FOR_STAT_ARRAY(sample_, s)
{
sample_[s].block(i_, j_, nRow_, nCol_) = sample[s];
}
return *this;
}
template <class S>
DMatSample::BlockTemplate<S> &
DMatSample::BlockTemplate<S>::operator=(const S &&sample)
{
*this = sample;
return *this;
}
END_NAMESPACE
#endif // Latan_Sample_hpp_