1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Author: David Alexander
#pragma once
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/tuple/tuple.hpp>
#include <cassert>
#include <ConsensusCore/Interval.hpp>
#include <ConsensusCore/Matrix/DenseMatrix.hpp>
#include <ConsensusCore/Utils.hpp>
using boost::numeric::ublas::matrix_column;
namespace ConsensusCore {
//
// Nullability
//
inline const DenseMatrix& DenseMatrix::Null()
{
static DenseMatrix* nullObj = new DenseMatrix(0, 0);
return *nullObj;
}
inline bool DenseMatrix::IsNull() const { return (Rows() == 0 && Columns() == 0); }
//
// Size information
//
inline int DenseMatrix::Rows() const { return size1(); }
inline int DenseMatrix::Columns() const { return size2(); }
//
// Entry range queries per column
//
inline void DenseMatrix::StartEditingColumn(int j, int, int)
{
assert(columnBeingEdited_ == -1);
columnBeingEdited_ = j;
ClearColumn(j);
}
inline void DenseMatrix::FinishEditingColumn(int j, int usedRowsBegin, int usedRowsEnd)
{
assert(columnBeingEdited_ == j);
usedRanges_[j] = Interval(usedRowsBegin, usedRowsEnd);
DEBUG_ONLY(CheckInvariants(columnBeingEdited_));
columnBeingEdited_ = -1;
}
inline Interval DenseMatrix::UsedRowRange(int j) const
{
assert(0 <= j && j < static_cast<int>(usedRanges_.size()));
return usedRanges_[j];
}
inline bool DenseMatrix::IsColumnEmpty(int j) const
{
assert(0 <= j && j < static_cast<int>(usedRanges_.size()));
return (usedRanges_[j].Begin >= usedRanges_[j].End);
}
//
// Accessors
//
inline void DenseMatrix::Set(int i, int j, float v)
{
assert(columnBeingEdited_ == j);
boost_dense_matrix::operator()(i, j) = v;
}
inline bool DenseMatrix::IsAllocated(int
#ifndef NDEBUG
i
#endif
,
int
#ifndef NDEBUG
j
#endif
) const
{
assert(0 <= i && i < Rows() && 0 <= j && j < Columns());
return true;
}
inline float DenseMatrix::Get(int i, int j) const { return (*this)(i, j); }
inline const float& DenseMatrix::operator()(int i, int j) const
{
return boost_dense_matrix::operator()(i, j);
}
inline void DenseMatrix::ClearColumn(int j)
{
DEBUG_ONLY(CheckInvariants(j);)
// (Rely on the fact that the underlying memory is stored
// contiguously)
int begin, end;
boost::tie(begin, end) = usedRanges_[j];
std::fill_n(reinterpret_cast<float*>(&boost_dense_matrix::operator()(begin, j)), // NOLINT
end - begin, value_type());
usedRanges_[j] = Interval(0, 0);
DEBUG_ONLY(CheckInvariants(j);)
}
//
// SSE
//
inline __m128 DenseMatrix::Get4(int i, int j) const
{
assert(0 <= i && i <= Rows() - 4);
return _mm_loadu_ps(&boost_dense_matrix::operator()(i, j).value);
}
inline void DenseMatrix::Set4(int i, int j, __m128 v4)
{
assert(columnBeingEdited_ == j);
assert(0 <= i && i <= Rows() - 4);
_mm_storeu_ps(&boost_dense_matrix::operator()(i, j).value, v4);
}
}
|
