Cheetah - SKA - PSS - Prototype Time Domain Search Pipeline
DataSequence2D.cpp
1 /*
2  * The MIT License (MIT)
3  *
4  * Copyright (c) 2016 The SKA organisation
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 namespace ska {
25 namespace cheetah {
26 namespace data {
27 
28 template <typename T>
30 
31 template <typename T>
32 DataSequence2D<Cpu,T>::DataSequence2D(std::size_t fast_axis_length, std::size_t slow_axis_length)
33  : _fast_axis_length(fast_axis_length)
34  , _slow_axis_length(slow_axis_length)
35  , _data()
36 {
37  this->_data.resize(fast_axis_length*slow_axis_length);
38 }
39 
40 template <typename T>
41 DataSequence2D<Cpu,T>::DataSequence2D(std::size_t fast_axis_length, std::size_t slow_axis_length, const T &fill)
42  : _fast_axis_length(fast_axis_length)
43  , _slow_axis_length(slow_axis_length)
44  , _data(fast_axis_length*slow_axis_length,fill)
45 {
46 }
47 
48 template <typename T>
50 
51 template <typename T>
52 std::size_t DataSequence2D<Cpu,T>::fast_axis_length() const { return this->_fast_axis_length;}
53 
54 template <typename T>
55 std::size_t DataSequence2D<Cpu,T>::slow_axis_length() const { return this->_slow_axis_length;}
56 
57 template <typename T>
58 std::size_t DataSequence2D<Cpu,T>::size() const { return this->_data.size();}
59 
60 template <typename T>
61 void DataSequence2D<Cpu,T>::resize(std::size_t fast_axis_length, std::size_t slow_axis_length, const T &fill)
62 {
63  this->_fast_axis_length = fast_axis_length;
64  this->_slow_axis_length = slow_axis_length;
65  this->_data.resize(this->_fast_axis_length*this->_slow_axis_length);
66  std::fill(this->_data.begin(),this->_data.end(), fill);
67 }
68 
69 template <typename T>
70 void DataSequence2D<Cpu,T>::resize(std::size_t fast_axis_length, std::size_t slow_axis_length)
71 {
72  this->_fast_axis_length = fast_axis_length;
73  this->_slow_axis_length = slow_axis_length;
74  this->_data.resize(this->_fast_axis_length*this->_slow_axis_length);
75 }
76 
77 template <typename T>
78 T const* DataSequence2D<Cpu,T>::data() const {return &(this->_data[0]);}
79 
80 template <typename T>
81 T* DataSequence2D<Cpu,T>::data() {return &(this->_data[0]);}
82 
83 template <typename T>
85  return Iterator(*this);
86 }
87 
88 template <typename T>
90  return ConstIterator(*this);
91 }
92 
93 template <typename T>
95  return ConstIterator(*this);
96 }
97 
98 
99 template <typename T>
101  return Iterator(*this)+this->_data.size();
102 }
103 
104 template <typename T>
106  return ConstIterator(*this)+this->_data.size();
107 }
108 
109 template <typename T>
111  return ConstIterator(*this)+this->_data.size();
112 }
113 
114 template <typename T>
116  std::size_t fend,
117  std::size_t sbegin,
118  std::size_t send){
119 
120  BOOST_ASSERT(fend <= this->fast_axis_length());
121  BOOST_ASSERT(send <= this->slow_axis_length());
122 
123  return DataSequence2DPartialIterator<Cpu,T>(*this, fbegin,fend,sbegin,send);
124 }
125 
126 template<typename Arch, typename DataType>
127 bool operator==(DataSequence2D<Arch, DataType> const& a, DataSequence2D<Arch, DataType> const& b)
128 {
129  if( !(a.fast_axis_length() == b.fast_axis_length()
130  && a.slow_axis_length() == b.slow_axis_length()) )
131  {
132  return false; // different dimensions
133  }
134  auto it_a = a.cbegin();
135  auto it_b = b.cbegin();
136 
137  while(it_a != a.cend()) {
138  if(*it_a != *it_b) return false; // values differ
139  ++it_a;
140  ++it_b;
141  }
142  return true;
143 }
144 
145 } // namespace data
146 } // namespace cheetah
147 } // namespace ska
148 
149 
150 
Iterator over DataSequence2D types, over "fast" axis. Generic type.
Some limits and constants for FLDO.
Definition: Brdz.h:35
A 2-dimensional sequencial data of type T.
Iterator over partial ranges of DataSequence2D types, "fast" axis. Generic type.