shards Version of the Day
Loading...
Searching...
No Matches
Shards_ArrayVector.hpp
1// @HEADER
2// *****************************************************************************
3// Shards : Shared Discretization Tools
4//
5// Copyright 2008-2011 NTESS and the Shards contributors.
6// SPDX-License-Identifier: BSD-3-Clause
7// *****************************************************************************
8// @HEADER
9
10#ifndef Shards_ArrayVector_hpp
11#define Shards_ArrayVector_hpp
12
13//----------------------------------------------------------------------
14
15#include <Shards_Array.hpp>
16
17//----------------------------------------------------------------------
18
19namespace shards {
20
24
25template< typename Scalar , ArrayOrder Order ,
26 class Tag1 = void , class Tag2 = void ,
27 class Tag3 = void , class Tag4 = void ,
28 class Tag5 = void , class Tag6 = void ,
29 class Tag7 = void , class Tag8 = void >
30class ArrayVector ;
31
32//----------------------------------------------------------------------
33
34template< typename Scalar , ArrayOrder Order >
35class ArrayVector<Scalar,Order,void,void,void,void, void,void,void,void>
36 : public Array<Scalar,Order,void,void,void,void, void,void,void,void>
37{
38private:
39 std::vector<Scalar> m_storage ;
40
41 typedef
42 Array<Scalar,Order,void,void,void,void, void,void,void,void>
43 BaseType ;
44
45 ArrayVector( const ArrayVector & );
46 ArrayVector & operator = ( const ArrayVector & );
47
48 Scalar * get_ptr() { return m_storage.empty() ? NULL : & m_storage[0] ; }
49
50public:
51
52 typedef array_traits::int_t size_type ;
53
54 ArrayVector()
55 : BaseType() , m_storage() {}
56
57 ~ArrayVector() {}
58
59 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
60 class Tag5 , class Tag6 , class Tag7 , class Tag8 >
61 void resize( const size_type n1 , const size_type n2 ,
62 const size_type n3 , const size_type n4 ,
63 const size_type n5 , const size_type n6 ,
64 const size_type n7 , const size_type n8 )
65 {
66 m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 * n8 );
67 BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
68 ( get_ptr() ,n1,n2,n3,n4,n5,n6,n7,n8);
69 }
70
71 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
72 class Tag5 , class Tag6 , class Tag7 >
73 void resize( const size_type n1 , const size_type n2 ,
74 const size_type n3 , const size_type n4 ,
75 const size_type n5 , const size_type n6 ,
76 const size_type n7 )
77 {
78 m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 );
79 BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7>
80 ( get_ptr() ,n1,n2,n3,n4,n5,n6,n7);
81 }
82
83 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
84 class Tag5 , class Tag6 >
85 void resize( const size_type n1 , const size_type n2 ,
86 const size_type n3 , const size_type n4 ,
87 const size_type n5 , const size_type n6 )
88 {
89 m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 );
90 BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6>
91 ( get_ptr() ,n1,n2,n3,n4,n5,n6);
92 }
93
94 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
95 class Tag5 >
96 void resize( const size_type n1 , const size_type n2 ,
97 const size_type n3 , const size_type n4 ,
98 const size_type n5 )
99 {
100 m_storage.resize( n1 * n2 * n3 * n4 * n5 );
101 BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5>
102 ( get_ptr(),n1,n2,n3,n4,n5);
103 }
104
105 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 >
106 void resize( const size_type n1 , const size_type n2 ,
107 const size_type n3 , const size_type n4 )
108 {
109 m_storage.resize( n1 * n2 * n3 * n4 );
110 BaseType::template assign<Tag1,Tag2,Tag3,Tag4>
111 ( get_ptr(),n1,n2,n3,n4);
112 }
113
114 template< class Tag1 , class Tag2 , class Tag3 >
115 void resize( const size_type n1 , const size_type n2 ,
116 const size_type n3 )
117 {
118 m_storage.resize( n1 * n2 * n3 );
119 BaseType::template assign<Tag1,Tag2,Tag3>
120 ( get_ptr(),n1,n2,n3);
121 }
122
123 template< class Tag1 , class Tag2 >
124 void resize( const size_type n1 , const size_type n2 )
125 {
126 m_storage.resize( n1 * n2 );
127 BaseType::template assign<Tag1,Tag2>( get_ptr(),n1,n2);
128 }
129
130 template< class Tag1 >
131 void resize( const size_type n1 )
132 {
133 m_storage.resize( n1 );
134 BaseType::template assign<Tag1>( get_ptr(),n1);
135 }
136};
137
138//----------------------------------------------------------------------
139
140template< typename Scalar , ArrayOrder Order ,
141 class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
142 class Tag5 , class Tag6 , class Tag7 , class Tag8 >
143class ArrayVector
144 : public Array<Scalar,Order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
145{
146private:
147 std::vector<Scalar> m_storage ;
148
149 typedef
150 array_traits::Helper<Scalar,Order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
151 help_type ;
152
153 typedef
154 Array<Scalar,Order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
155 BaseType ;
156
157 ArrayVector( const ArrayVector & );
158 ArrayVector & operator = ( const ArrayVector & );
159
160 Scalar * get_ptr() { return m_storage.empty() ? NULL : & m_storage[0] ; }
161
162public:
163
164 typedef array_traits::int_t size_type ;
165
166 ArrayVector()
167 : BaseType() , m_storage() {}
168
169 ~ArrayVector() {}
170
171 void resize( const size_type * const dims )
172 {
173 help_type::assign( BaseType::m_stride , dims );
174 const typename BaseType::size_type n = BaseType::size();
175 m_storage.resize( n );
176 BaseType::m_ptr = get_ptr();
177 }
178
179 void resize( const size_type n1 , const size_type n2 ,
180 const size_type n3 , const size_type n4 ,
181 const size_type n5 , const size_type n6 ,
182 const size_type n7 , const size_type n8 )
183 {
184 array_traits::CheckRank<8,BaseType::Rank>::ok();
185 m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 * n8 );
186 BaseType::assign( get_ptr() ,n1,n2,n3,n4,n5,n6,n7,n8);
187 }
188
189 void resize( const size_type n1 , const size_type n2 ,
190 const size_type n3 , const size_type n4 ,
191 const size_type n5 , const size_type n6 ,
192 const size_type n7 )
193 {
194 array_traits::CheckRank<7,BaseType::Rank>::ok();
195 m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 );
196 BaseType::assign( get_ptr(),n1,n2,n3,n4,n5,n6,n7);
197 }
198
199 void resize( const size_type n1 , const size_type n2 ,
200 const size_type n3 , const size_type n4 ,
201 const size_type n5 , const size_type n6 )
202 {
203 array_traits::CheckRank<6,BaseType::Rank>::ok();
204 m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 );
205 BaseType::assign( get_ptr(),n1,n2,n3,n4,n5,n6);
206 }
207
208 void resize( const size_type n1 , const size_type n2 ,
209 const size_type n3 , const size_type n4 ,
210 const size_type n5 )
211 {
212 array_traits::CheckRank<5,BaseType::Rank>::ok();
213 m_storage.resize( n1 * n2 * n3 * n4 * n5 );
214 BaseType::assign( get_ptr(),n1,n2,n3,n4,n5);
215 }
216
217 void resize( const size_type n1 , const size_type n2 ,
218 const size_type n3 , const size_type n4 )
219 {
220 array_traits::CheckRank<4,BaseType::Rank>::ok();
221 m_storage.resize( n1 * n2 * n3 * n4 );
222 BaseType::assign( get_ptr(),n1,n2,n3,n4);
223 }
224
225 void resize( const size_type n1 , const size_type n2 ,
226 const size_type n3 )
227 {
228 array_traits::CheckRank<3,BaseType::Rank>::ok();
229 m_storage.resize( n1 * n2 * n3 );
230 BaseType::assign( get_ptr(),n1,n2,n3);
231 }
232
233 void resize( const size_type n1 , const size_type n2 )
234 {
235 array_traits::CheckRank<2,BaseType::Rank>::ok();
236 m_storage.resize( n1 * n2 );
237 BaseType::assign( get_ptr(),n1,n2);
238 }
239
240 void resize( const size_type n1 )
241 {
242 array_traits::CheckRank<1,BaseType::Rank>::ok();
243 m_storage.resize( n1 );
244 BaseType::assign( get_ptr(),n1);
245 }
246
247
248 ArrayVector( const size_type * const dims )
249 : BaseType(), m_storage() { resize( dims ); }
250
251 ArrayVector( const size_type n1 , const size_type n2 ,
252 const size_type n3 , const size_type n4 ,
253 const size_type n5 , const size_type n6 ,
254 const size_type n7 , const size_type n8 )
255 : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5,n6,n7,n8); }
256
257 ArrayVector( const size_type n1 , const size_type n2 ,
258 const size_type n3 , const size_type n4 ,
259 const size_type n5 , const size_type n6 ,
260 const size_type n7 )
261 : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5,n6,n7); }
262
263 ArrayVector( const size_type n1 , const size_type n2 ,
264 const size_type n3 , const size_type n4 ,
265 const size_type n5 , const size_type n6 )
266 : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5,n6); }
267
268 ArrayVector( const size_type n1 , const size_type n2 ,
269 const size_type n3 , const size_type n4 ,
270 const size_type n5 )
271 : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5); }
272
273 ArrayVector( const size_type n1 , const size_type n2 ,
274 const size_type n3 , const size_type n4 )
275 : BaseType(), m_storage() { resize(n1,n2,n3,n4); }
276
277 ArrayVector( const size_type n1 , const size_type n2 ,
278 const size_type n3 )
279 : BaseType(), m_storage() { resize(n1,n2,n3); }
280
281 ArrayVector( const size_type n1 , const size_type n2 )
282 : BaseType(), m_storage() { resize(n1,n2); }
283
284 ArrayVector( const size_type n1 )
285 : BaseType(), m_storage() { resize(n1); }
286
287};
288
290
291}
292
293#endif /* Shards_ArrayVector_hpp */
294
shards::Array
The preferred multi-dimensional Array interface with compile-time user-defined dimension ordinate...
Definition Shards_Array.hpp:3580
shards::Array< Scalar, Order, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7, Tag8 >::assign
Array & assign(value_type *arg_ptr, const size_type *const dims)
Definition Shards_Array.hpp:3801
shards::ArrayOrder
ArrayOrder
Define Natural (C-language) or Fortran ordering of array dimensions. A RankZero array does not ha...
Definition Shards_Array.hpp:46