Skip to content

Commit 978323b

Browse files
vitalsongvitalsong
committed
- Rename slice_t to mut_slice_t;
- Rename `const_slice_t` to `slice_t`; - Add const initialization for `base_slice_t`;
1 parent 68c3d7b commit 978323b

File tree

3 files changed

+101
-91
lines changed

3 files changed

+101
-91
lines changed

‎include/dsplib/array.h

Lines changed: 17 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -72,9 +72,12 @@ constexpr bool is_array_convertible() noexcept {
7272
return true;
7373
}
7474

75-
//base dsplib array type
76-
//TODO: add array_view as parent for array/slice
77-
//TODO: add slice(vector<bool>)
75+
/**
76+
* @brief base dsplib array type
77+
* @todo add array_view as parent for array/slice
78+
* @todo add slice(vector<bool>)
79+
* @tparam T real_t/cmplx_t/int
80+
*/
7881
template<typename T>
7982
class base_array
8083
{
@@ -85,13 +88,13 @@ class base_array
8588
: _vec(n, 0) {
8689
}
8790

88-
base_array(const const_slice_t<T>& rhs)
91+
base_array(const slice_t<T>& rhs)
8992
: base_array(rhs.size()) {
9093
this->slice(0, indexing::end) = rhs;
9194
}
9295

93-
base_array(const slice_t<T>& rhs)
94-
: base_array(const_slice_t<T>(rhs)) {
96+
base_array(const mut_slice_t<T>& rhs)
97+
: base_array(slice_t<T>(rhs)) {
9598
}
9699

97100
base_array(const std::vector<T>& v)
@@ -131,13 +134,13 @@ class base_array
131134
}
132135

133136
template<typename T2>
134-
explicit base_array(span_t<T2> v) {
137+
explicit base_array(const span_t<T2>& v) {
135138
static_assert(is_array_convertible<T2, T>(), "Only real2real/cmplx2cmplx array cast support");
136139
_vec.assign(v.begin(), v.end());
137140
}
138141

139142
template<typename T2>
140-
explicit base_array(mut_span_t<T2> v)
143+
explicit base_array(const mut_span_t<T2>& v)
141144
: base_array(span_t<T2>(v)) {
142145
}
143146

@@ -275,20 +278,20 @@ class base_array
275278
}
276279

277280
//--------------------------------------------------------------------
278-
slice_t<T> slice(int i1, int i2, int m) {
279-
return slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
281+
mut_slice_t<T> slice(int i1, int i2, int m) {
282+
return mut_slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
280283
}
281284

282-
const_slice_t<T> slice(int i1, int i2, int m) const {
283-
return const_slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
285+
slice_t<T> slice(int i1, int i2, int m) const {
286+
return slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
284287
}
285288

286289
//TODO: add slice(end, first, -1) like x[::-1] numpy
287-
slice_t<T> slice(int i1, indexing::end_t, int m) {
290+
mut_slice_t<T> slice(int i1, indexing::end_t, int m) {
288291
return this->slice(i1, size(), m);
289292
}
290293

291-
const_slice_t<T> slice(int i1, indexing::end_t, int m) const {
294+
slice_t<T> slice(int i1, indexing::end_t, int m) const {
292295
return this->slice(i1, size(), m);
293296
}
294297

‎include/dsplib/slice.h

Lines changed: 59 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -11,92 +11,83 @@ namespace dsplib {
1111
template<typename T>
1212
class base_array;
1313

14-
//TODO: rename `slice_t` to `mut_slice_t`
1514
template<typename T>
16-
class slice_t;
15+
class mut_slice_t;
1716

18-
//TODO: rename `const_slice_t` to `slice_t`
1917
template<typename T>
20-
class const_slice_t;
18+
class slice_t;
2119

22-
//----------------------------------------------------------------------------------------
23-
//TODO: support empty slices
2420
class base_slice_t
2521
{
2622
public:
2723
base_slice_t() = default;
2824

29-
explicit base_slice_t(int n, int i1, int i2, int m) {
30-
//is empty
31-
if (n == 0) {
25+
explicit base_slice_t(int n, int i1, int i2, int m)
26+
: _m{m}
27+
, _n{n}
28+
, _i1{(i1 < 0) ? (_n + i1) : (i1)}
29+
, _i2{(i2 < 0) ? (_n + i2) : (i2)}
30+
, _nc{_count()} {
31+
if (_n == 0) {
3232
return;
3333
}
3434

3535
DSPLIB_ASSERT(m != 0, "Slice stride cannot be zero");
36-
37-
_m = m;
38-
_n = n;
39-
_i1 = (i1 < 0) ? (_n + i1) : (i1);
40-
_i2 = (i2 < 0) ? (_n + i2) : (i2);
41-
const int d = std::abs(_i2 - _i1);
42-
const int tm = std::abs(_m);
43-
_nc = (d % tm != 0) ? (d / tm + 1) : (d / tm);
44-
45-
if ((_i1 < 0) || (_i1 >= _n)) {
46-
DSPLIB_THROW("Left slice index out of range");
47-
}
48-
49-
if ((_i2 < 0) || (_i2 > _n)) {
50-
DSPLIB_THROW("Right slice index out of range");
51-
}
52-
53-
if ((_m < 0) && (_i1 < _i2)) {
54-
DSPLIB_THROW("First index is smaller for negative step");
55-
}
56-
57-
if ((_m > 0) && (_i1 > _i2)) {
58-
DSPLIB_THROW("First index is greater for positive step");
59-
}
60-
61-
if (_nc > _n) {
62-
DSPLIB_THROW("Slice range is greater vector size");
63-
}
36+
DSPLIB_ASSERT((_i1 >= 0) && (_i1 < _n), "Left slice index out of range");
37+
DSPLIB_ASSERT((_i2 >= 0) && (_i2 <= _n), "Right slice index out of range");
38+
DSPLIB_ASSERT(!((_m < 0) && (_i1 < _i2)), "First index is smaller for negative step");
39+
DSPLIB_ASSERT(!((_m > 0) && (_i1 > _i2)), "First index is greater for positive step");
40+
DSPLIB_ASSERT(_nc <= _n, "Slice range is greater array size");
6441
}
6542

6643
bool empty() const noexcept {
6744
return (_nc == 0);
6845
}
6946

7047
protected:
71-
int _i1{0};
72-
int _i2{0};
73-
int _m{0};
74-
int _n{0};
75-
int _nc{0};
48+
const int _m{1};
49+
const int _n{0};
50+
const int _i1{0};
51+
const int _i2{0};
52+
const int _nc{0};
53+
54+
private:
55+
int _count() const noexcept {
56+
if (_n == 0) {
57+
return 0;
58+
}
59+
const int d = std::abs(_i2 - _i1);
60+
const int tm = std::abs(_m);
61+
const int size = (d % tm != 0) ? (d / tm + 1) : (d / tm);
62+
return size;
63+
}
7664
};
7765

78-
//----------------------------------------------------------------------------------------
79-
//TODO: add concatenate array = slice | array
66+
/**
67+
* @brief Non-mutable slice object
68+
* @todo add concatenate array = slice | array
69+
* @tparam T real_t/cmplx_t
70+
*/
8071
template<typename T>
81-
class const_slice_t : public base_slice_t
72+
class slice_t : public base_slice_t
8273
{
8374
public:
84-
friend class slice_t<T>;
75+
friend class mut_slice_t<T>;
8576
using const_iterator = SliceIterator<const T>;
8677

87-
const_slice_t() = default;
78+
slice_t() = default;
8879

89-
const_slice_t(const T* data, int size, int i1, int i2, int m)
80+
slice_t(const T* data, int size, int i1, int i2, int m)
9081
: base_slice_t(size, i1, i2, m)
9182
, _data{data} {
9283
}
9384

94-
const_slice_t(const const_slice_t& rhs)
85+
slice_t(const slice_t& rhs)
9586
: base_slice_t(rhs.size(), rhs._i1, rhs._i2, rhs._m)
9687
, _data{rhs._data} {
9788
}
9889

99-
const_slice_t(const slice_t<T>& rhs)
90+
slice_t(const mut_slice_t<T>& rhs)
10091
: base_slice_t(rhs._n, rhs._i1, rhs._i2, rhs._m)
10192
, _data{rhs._data} {
10293
}
@@ -127,23 +118,26 @@ class const_slice_t : public base_slice_t
127118
const T* _data{nullptr};
128119
};
129120

130-
//----------------------------------------------------------------------------------------
121+
/**
122+
* @brief Mutable slice object
123+
* @tparam T real_t/cmplx_t
124+
*/
131125
template<typename T>
132-
class slice_t : public base_slice_t
126+
class mut_slice_t : public base_slice_t
133127
{
134128
public:
135-
friend class const_slice_t<T>;
129+
friend class slice_t<T>;
136130
using iterator = SliceIterator<T>;
137131
using const_iterator = SliceIterator<const T>;
138132

139-
slice_t() = default;
133+
mut_slice_t() = default;
140134

141-
slice_t(T* data, int size, int i1, int i2, int m)
135+
mut_slice_t(T* data, int size, int i1, int i2, int m)
142136
: base_slice_t(size, i1, i2, m)
143137
, _data{data} {
144138
}
145139

146-
slice_t(const slice_t& rhs)
140+
mut_slice_t(const mut_slice_t& rhs)
147141
: base_slice_t(rhs._n, rhs._i1, rhs._i2, rhs._m)
148142
, _data{rhs._data} {
149143
}
@@ -156,7 +150,7 @@ class slice_t : public base_slice_t
156150
return _m;
157151
}
158152

159-
slice_t& operator=(const const_slice_t<T>& rhs) {
153+
mut_slice_t& operator=(const slice_t<T>& rhs) {
160154
DSPLIB_ASSERT(this->size() == rhs.size(), "Slices size must be equal");
161155
const int count = this->size();
162156

@@ -189,22 +183,23 @@ class slice_t : public base_slice_t
189183
return *this;
190184
}
191185

192-
slice_t& operator=(const slice_t<T>& rhs) {
193-
*this = const_slice_t<T>(rhs);
186+
mut_slice_t& operator=(const mut_slice_t<T>& rhs) {
187+
*this = slice_t<T>(rhs);
194188
return *this;
195189
}
196190

197-
slice_t& operator=(const base_array<T>& rhs) {
191+
mut_slice_t& operator=(const base_array<T>& rhs) {
198192
DSPLIB_ASSERT(!_is_same_array(rhs.slice(0, rhs.size())), "Assigned array to same slice");
199-
return (*this = rhs.slice(0, rhs.size()));
193+
*this = rhs.slice(0, rhs.size());
194+
return *this;
200195
}
201196

202-
slice_t& operator=(const T& value) {
197+
mut_slice_t& operator=(const T& value) {
203198
std::fill(begin(), end(), value);
204199
return *this;
205200
}
206201

207-
slice_t& operator=(const std::initializer_list<T>& rhs) {
202+
mut_slice_t& operator=(const std::initializer_list<T>& rhs) {
208203
std::copy(rhs.begin(), rhs.end(), this->begin());
209204
return *this;
210205
}
@@ -234,7 +229,7 @@ class slice_t : public base_slice_t
234229
}
235230

236231
protected:
237-
bool _is_same_array(const const_slice_t<T>& rhs) const noexcept {
232+
bool _is_same_array(const slice_t<T>& rhs) const noexcept {
238233
auto l1 = _data;
239234
auto r1 = _data + _nc;
240235
auto l2 = rhs._data;

‎include/dsplib/span.h

Lines changed: 25 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -23,19 +23,21 @@ class span_t;
2323

2424
//mutable span
2525
template<typename T>
26-
class mut_span_t : public slice_t<T>
26+
class mut_span_t : public mut_slice_t<T>
2727
{
2828
public:
2929
friend class span_t<T>;
3030

31-
mut_span_t() = default;
32-
3331
explicit mut_span_t(T* data, int size)
34-
: slice_t<T>(data, size, 0, size, 1)
32+
: mut_slice_t<T>(data, size, 0, size, 1)
3533
, _ptr{data}
3634
, _len{size} {
3735
}
3836

37+
mut_span_t(const mut_span_t& v)
38+
: mut_span_t(v._ptr, v._len) {
39+
}
40+
3941
mut_span_t(base_array<T>& v)
4042
: mut_span_t(v.data(), v.size()) {
4143
}
@@ -63,18 +65,28 @@ class mut_span_t : public slice_t<T>
6365

6466
//TODO: override fast implementation for span
6567

66-
mut_span_t& operator=(const const_slice_t<T>& rhs) {
67-
slice_t<T>::operator=(rhs);
68+
mut_span_t& operator=(const mut_span_t& rhs) {
69+
if (this == &rhs) {
70+
return *this;
71+
}
72+
mut_slice_t<T>::operator=(rhs);
6873
return *this;
6974
}
7075

7176
mut_span_t& operator=(const slice_t<T>& rhs) {
72-
slice_t<T>::operator=(rhs);
77+
//TODO: check if slice ~ span (but check overlap memory)
78+
mut_slice_t<T>::operator=(rhs);
79+
return *this;
80+
}
81+
82+
mut_span_t& operator=(const mut_slice_t<T>& rhs) {
83+
//TODO: check if slice ~ span
84+
mut_slice_t<T>::operator=(rhs);
7385
return *this;
7486
}
7587

7688
mut_span_t& operator=(const base_array<T>& rhs) {
77-
slice_t<T>::operator=(rhs);
89+
*this = span_t<T>(rhs.data(), rhs.size());
7890
return *this;
7991
}
8092

@@ -84,7 +96,7 @@ class mut_span_t : public slice_t<T>
8496
}
8597

8698
mut_span_t& operator=(const std::initializer_list<T>& rhs) {
87-
slice_t<T>::operator=(rhs);
99+
mut_slice_t<T>::operator=(rhs);
88100
return *this;
89101
}
90102

@@ -116,20 +128,20 @@ class mut_span_t : public slice_t<T>
116128

117129
private:
118130
T* _ptr{nullptr};
119-
int _len{0};
131+
const int _len{0};
120132
};
121133

122134
//immutable span
123135
template<typename T>
124-
class span_t : public const_slice_t<T>
136+
class span_t : public slice_t<T>
125137
{
126138
public:
127139
friend class mut_span_t<T>;
128140

129141
span_t() = default;
130142

131143
explicit span_t(const T* data, int size)
132-
: const_slice_t<T>(data, size, 0, size, 1)
144+
: slice_t<T>(data, size, 0, size, 1)
133145
, _ptr{data}
134146
, _len{size} {
135147
}
@@ -177,7 +189,7 @@ class span_t : public const_slice_t<T>
177189

178190
private:
179191
const T* _ptr{nullptr};
180-
int _len{0};
192+
const int _len{0};
181193
};
182194

183195
//------------------------------------------------------------------------------------------------

0 commit comments

Comments
 (0)