xc
Array3dBase.h
1 // -*-c++-*-
2 //----------------------------------------------------------------------------
3 // xc utils library; general purpose classes and functions.
4 //
5 // Copyright (C) Luis C. Pérez Tato
6 //
7 // XC utils is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11 //
12 // This software is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program.
19 // If not, see <http://www.gnu.org/licenses/>.
20 //----------------------------------------------------------------------------
21 //Array3dBase.h
22 //Array of point matrices.
23 
24 #ifndef ARRAY3DBASE_H
25 #define ARRAY3DBASE_H
26 
27 #include <iostream>
28 #include "Array3dBoxConstRef.h"
29 #include "ConstantILayerConstRef.h"
30 #include "ConstantJLayerConstRef.h"
31 #include "ConstantKLayerConstRef.h"
32 #include "IRowConstRef.h"
33 #include "JRowConstRef.h"
34 #include "KRowConstRef.h"
35 #include "Array3dBoxVarRef.h"
36 #include "ConstantILayerVarRef.h"
37 #include "ConstantJLayerVarRef.h"
38 #include "ConstantKLayerVarRef.h"
39 #include "IRowVarRef.h"
40 #include "JRowVarRef.h"
41 #include "KRowVarRef.h"
42 
43 
44 
47 //
50 template <class Array>
51 class Array3dBase: public std::vector<Array>
52  {
53  public:
54  typedef typename Array::value_type value_type;
55  typedef typename Array::reference reference;
56  typedef typename Array::const_reference const_reference;
57  typedef typename std::vector<Array>::value_type matrix_type;
58  typedef typename std::vector<Array>::iterator iterator;
59  typedef typename std::vector<Array>::const_iterator const_iterator;
60 
61  typedef Array3dBoxConstRef<Array3dBase<Array> > box_const_ref;
62  typedef ConstantILayerConstRef<Array3dBase<Array> > constant_i_layer_const_ref;
63  typedef ConstantJLayerConstRef<Array3dBase<Array> > constant_j_layer_const_ref;
64  typedef ConstantKLayerConstRef<Array3dBase<Array> > constant_k_layer_const_ref;
65  typedef IRowConstRef<Array3dBase<Array> > const_ref_i_row;
66  typedef JRowConstRef<Array3dBase<Array> > const_ref_j_row;
67  typedef KRowConstRef<Array3dBase<Array> > const_ref_k_row;
68 
69  typedef Array3dBoxVarRef<Array3dBase<Array> > box_var_ref;
70  typedef ConstantILayerVarRef<Array3dBase<Array> > constant_i_layer_variable_ref;
71  typedef ConstantJLayerVarRef<Array3dBase<Array> > constant_j_layer_variable_ref;
72  typedef ConstantKLayerVarRef<Array3dBase<Array> > constant_k_layer_variable_ref;
73  typedef IRowVarRef<Array3dBase<Array> > var_ref_i_row;
74  typedef JRowVarRef<Array3dBase<Array> > var_ref_j_row;
75  typedef KRowVarRef<Array3dBase<Array> > var_ref_k_row;
76 
77  protected:
78  inline matrix_type &get_layer(const size_t &iLayer)
79  { return (*this)[iLayer-1]; }
80  inline const matrix_type &get_layer(const size_t &iLayer) const
81  { return (*this)[iLayer-1]; }
82  public:
83  Array3dBase(const size_t &n_layers= 0);
84  Array3dBase(const size_t &n_layers,const Array &);
85  Array3dBase(const size_t &,const size_t &,const size_t &, const value_type &def_value= value_type());
86 
87  bool check_range(const size_t &,const size_t &,const size_t &) const;
88  void resize(const size_t &);
89  void resize(const size_t &,const size_t &,const size_t &,const value_type &def_value= value_type());
90  size_t getNumberOfLayers(void) const;
91  size_t getNumberOfRows(const size_t &layer= 1) const;
92  size_t getNumberOfColumns(const size_t &layer= 1) const;
93  size_t getNumberOfComponents(void) const;
94  size_t GetDim(void) const;
95  bool isIRow(void) const;
96  bool isJRow(void) const;
97  bool isKRow(void) const;
98  bool isIConstantLayer(void) const;
99  bool isJConstantLayer(void) const;
100  bool isKConstantLayer(void) const;
101  size_t NumPtrs(void) const;
102  bool Null(void) const;
103  bool HasNull(void) const;
104  void clear(void);
105 
106  void dim(const size_t &,const size_t &,const size_t &, const value_type &default_value= value_type());
107 
108  const Array &operator()(const size_t &layer) const;
109  Array &operator()(const size_t &layer);
110  inline void assign(const size_t &i,const size_t &j,const size_t &k, const bool &value)
111  { get_layer(i).assign(j,k,value); }
112  inline const_reference operator()(const size_t &i,const size_t &j,const size_t &k) const
113  { return ((*this)(i))(j,k); }
114  inline reference operator()(const size_t &i,const size_t &j,const size_t &k)
115  { return ((*this)(i))(j,k); }
116  reference getAtI(const size_t &i);
117  const_reference getAtI(const size_t &) const;
118  reference getAtIJ(const size_t &,const size_t &);
119  const_reference getAtIJ(const size_t &,const size_t &) const;
120  value_type getAtIJK(const size_t &,const size_t &,const size_t &);
121 
122  box_const_ref getBoxConstRef(size_t layer=1,size_t f=1, size_t c=1) const;
123  box_const_ref getBoxConstRef(const Array3dRange &rango) const;
124 
125  constant_i_layer_const_ref getConstantILayerConstRef(size_t layer=1,size_t f=1, size_t c=1) const;
126  constant_i_layer_const_ref getConstantILayerConstRef(size_t layer,const RangoIndice &,const RangoIndice &) const;
127  constant_j_layer_const_ref getConstantJLayerConstRef(size_t f=1,size_t layer=1, size_t c=1) const;
128  constant_j_layer_const_ref getConstantJLayerConstRef(const RangoIndice &,const size_t &f,const RangoIndice &) const;
129  constant_k_layer_const_ref getConstantKLayerConstRef(size_t c=1,size_t layer=1, size_t f=1) const;
130  constant_k_layer_const_ref getConstantKLayerConstRef(const RangoIndice &,const RangoIndice &,const size_t &) const;
131 
132  const_ref_i_row getIRowConstRef(size_t f=1,size_t c=1) const;
133  const_ref_i_row getIRowConstRef(const RangoIndice &,const size_t &f,const size_t &c) const;
134  const_ref_j_row getJRowConstRef(size_t layer=1,size_t c=1) const;
135  const_ref_j_row getJRowConstRef(const size_t &layer,const RangoIndice &,const size_t &c) const;
136  const_ref_k_row getKRowConstRef(size_t layer=1,size_t f=1) const;
137  const_ref_k_row getKRowConstRef(const size_t &layer,const size_t &f,const RangoIndice &) const;
138 
139  box_var_ref getBoxVarRef(size_t layer=1,size_t f=1, size_t c=1);
140  box_var_ref getBoxVarRef(const Array3dRange &);
141 
142  constant_i_layer_variable_ref getConstantILayerVarRef(size_t layer=1,size_t f=1, size_t c=1);
143  constant_i_layer_variable_ref getConstantILayerVarRef(const size_t &layer,const RangoIndice &,const RangoIndice &);
144  constant_j_layer_variable_ref getConstantJLayerVarRef(size_t f=1,size_t layer=1, size_t c=1);
145  constant_j_layer_variable_ref getConstantJLayerVarRef(const RangoIndice &,const size_t &f,const RangoIndice &);
146  constant_k_layer_variable_ref getConstantKLayerVarRef(size_t c=1,size_t layer=1, size_t f=1);
147  constant_k_layer_variable_ref getConstantKLayerVarRef(const RangoIndice &,const RangoIndice &,const size_t &c);
148 
149  var_ref_i_row getVarRefIRow(size_t f=1,size_t c=1);
150  var_ref_i_row getVarRefIRow(const RangoIndice &,const size_t &f,const size_t &c);
151  var_ref_j_row getVarRefJRow(size_t layer=1,size_t c=1);
152  var_ref_j_row getVarRefJRow(const size_t &layer,const RangoIndice &,const size_t &c);
153  var_ref_k_row getVarRefKRow(size_t layer=1,size_t f=1);
154  var_ref_k_row getVarRefKRow(const size_t &layer,const size_t &f,const RangoIndice &);
155 
156  void putBox(size_t layer_offset,size_t row_offset,size_t offset_col,const Array3dBase<Array> &);
157 
158  };
159 
161 template <class Array>
162 Array3dBase<Array>::Array3dBase(const size_t &n_layers)
163  : std::vector<Array>(n_layers)
164  {}
165 
167 template <class Array>
168 Array3dBase<Array>::Array3dBase(const size_t &n_layers,const Array &m)
169  : std::vector<Array>(n_layers,m)
170  {}
171 
173 template <class Array>
174 Array3dBase<Array>::Array3dBase(const size_t &n_layers,const size_t &n_rows,const size_t &cols, const value_type &def_value)
175  : std::vector<Array>(n_layers)
176  {
177  for(size_t i=0;i<n_layers;i++)
178  (*this)[i]= Array(n_rows,cols,def_value);
179  }
180 
182 template <class T>
183 void Array3dBase<T>::dim(const size_t &nLayers,const size_t &nRows,const size_t &numberOfColumns, const value_type &def_value)
184  { this->resize(nLayers,nRows,numberOfColumns,def_value); }
185 
187 template <class Array>
188 void Array3dBase<Array>::resize(const size_t &n_layers)
189  {
190  std::vector<Array>::resize(n_layers);
191  }
192 
194 template <class Array>
195 void Array3dBase<Array>::resize(const size_t &n_layers,const size_t &n_rows,const size_t &cols,const value_type &v)
196  {
197  std::vector<Array>::resize(n_layers);
198  for(size_t i= 0;i<n_layers;i++)
199  (*this)[i].resize(n_rows,cols,v);
200  }
201 
202 template <class Array>
203 bool Array3dBase<Array>::check_range(const size_t &layer,const size_t &iRow,const size_t &iCol) const
204  {
205  if(layer<=getNumberOfLayers())
206  return Array3dBase<Array>::operator()(layer).CheckIndices(iRow,iCol);
207  else
208  return false;
209  }
210 
211 
212 template <class Array>
213 size_t Array3dBase<Array>::getNumberOfLayers(void) const
214  { return this->size(); }
215 
216 template <class Array>
217 size_t Array3dBase<Array>::getNumberOfRows(const size_t &layer) const
218  {
219  size_t retval= 0;
220  if(this->size())
221  retval= get_layer(layer).getNumberOfRows();
222  return retval;
223  }
224 template <class Array>
225 size_t Array3dBase<Array>::getNumberOfColumns(const size_t &layer) const
226  {
227  size_t retval= 0;
228  if(this->size())
229  retval= get_layer(layer).getNumberOfColumns();
230  return retval;
231  }
232 
234 template <class Array>
235 size_t Array3dBase<Array>::getNumberOfComponents(void) const
236  {
237  const size_t sz= this->size();
238  if(sz<1)
239  return 0;
240  else
241  {
242  const matrix_type &layer= (*this)(1);
243  return sz*layer.getNumberOfRows()*layer.getNumberOfColumns();
244  }
245  }
246 
247 template <class Array>
248 size_t Array3dBase<Array>::GetDim(void) const
249  {
250  size_t retval= 0;
251  if(this->size()>1) retval++;
252  if(this->getNumberOfRows()>1) retval++;
253  if(this->getNumberOfColumns()>1) retval++;
254  return retval;
255  }
256 
258 template <class Array>
259 size_t Array3dBase<Array>::NumPtrs(void) const
260  {
261  const size_t sz= this->size();
262  if(sz<1)
263  return 0;
264  else
265  {
266  const Array &layer= (*this)(1);
267  return sz*layer.getNumberOfRows()*layer.getNumberOfColumns();
268  }
269  }
270 
272 template <class Array>
273 bool Array3dBase<Array>::Null(void) const
274  {
275  if(this->empty())
276  return true;
277  else
278  return (*this)[0].Null();
279  }
280 
282 template <class Array>
283 bool Array3dBase<Array>::HasNull(void) const
284  {
285  bool retval= false;
286  if(this->empty())
287  retval= true;
288  else
289  {
290  const size_t numberOfLayers= this->getNumberOfLayers();
291  for(size_t i=0;i<numberOfLayers;i++)
292  if((*this)[i].Null())
293  {
294  retval= true;
295  break;
296  }
297  }
298  return retval;
299  }
300 
302 template <class Array>
303 void Array3dBase<Array>::clear(void)
304  {
305  std::vector<Array>::clear();
306  }
307 
308 
310 template <class Array>
311 bool Array3dBase<Array>::isIRow(void) const
312  {
313  if((this->getNumberOfRows()>1) || (this->getNumberOfColumns()>1)) return false;
314  return true;
315  }
316 
318 template <class Array>
319 bool Array3dBase<Array>::isJRow(void) const
320  {
321  if((this->getNumberOfLayers()>1) || (this->getNumberOfColumns()>1)) return false;
322  return true;
323  }
324 
326 template <class Array>
327 bool Array3dBase<Array>::isKRow(void) const
328  {
329  if((this->getNumberOfLayers()>1) || (this->getNumberOfRows()>1)) return false;
330  return true;
331  }
332 
334 template <class Array>
335 bool Array3dBase<Array>::isIConstantLayer(void) const
336  { return (this->getNumberOfLayers()==1); }
337 
339 template <class Array>
340 bool Array3dBase<Array>::isJConstantLayer(void) const
341  { return (this->getNumberOfRows()==1); }
342 
344 template <class Array>
345 bool Array3dBase<Array>::isKConstantLayer(void) const
346  { return (this->getNumberOfColumns()==1); }
347 
349 template <class Array>
350 const Array &Array3dBase<Array>::operator()(const size_t &i) const
351  { return get_layer(i); }
352 
354 template <class Array>
355 Array &Array3dBase<Array>::operator()(const size_t &i)
356  { return get_layer(i); }
357 
358 
359 template <class Array>
360 typename Array3dBase<Array>::reference Array3dBase<Array>::getAtI(const size_t &i)
361  { return const_cast<reference>(static_cast<const Array3dBase<Array> &>(*this).getAtI(i)); }
362 
363 template <class Array>
364 typename Array3dBase<Array>::const_reference Array3dBase<Array>::getAtI(const size_t &i) const
365  {
366  if(isIRow())
367  return operator()(i,1,1);
368  else if(isJRow())
369  return operator()(1,i,1);
370  else if(isKRow())
371  return operator()(1,1,i);
372  else
373  {
374  std::cerr << "Array3dBase::getAtI; the set is not one-dimensional." << std::endl;
375  return operator()(1,1,1);
376  }
377  }
378 
379 template <class Array>
380 typename Array3dBase<Array>::value_type Array3dBase<Array>::getAtIJK(const size_t &i,const size_t &j,const size_t &k)
381  {
382  typename Array3dBase<Array>::value_type retval= value_type();
383  if(this->check_range(i,j,k))
384  retval= (*this)(i,j,k);
385  return retval;
386  }
387 
388 template <class Array>
389 typename Array3dBase<Array>::reference Array3dBase<Array>::getAtIJ(const size_t &i, const size_t &j)
390  { return const_cast<reference>(static_cast<const Array3dBase<Array> &>(*this).getAtIJ(i)); }
391 
392 template <class Array>
393 typename Array3dBase<Array>::const_reference Array3dBase<Array>::getAtIJ(const size_t &i, const size_t &j) const
394  {
395  //XXX We still need to get the layer
396  // (It will not necessarily be the first one).
397  if(isIConstantLayer())
398  return operator()(1,i,j);
399  else if(isJConstantLayer())
400  return operator()(i,1,j);
401  else if(isKConstantLayer())
402  return operator()(i,j,1);
403  else
404  {
405  std::cerr << "Array3dBase::" << __FUNCTION__
406  << "; not bidimensional." << std::endl;
407  return nullptr;
408  }
409  }
410 
411 template <class Array>
412 typename Array3dBase<Array>::box_const_ref Array3dBase<Array>::getBoxConstRef(size_t layer,size_t f, size_t c) const
413  { return box_const_ref(*this,layer,f,c); }
414 template <class Array>
415 typename Array3dBase<Array>::box_const_ref Array3dBase<Array>::getBoxConstRef(const Array3dRange &rango) const
416  { return box_const_ref(*this,rango); }
417 
418 template <class Array>
419 typename Array3dBase<Array>::constant_i_layer_const_ref Array3dBase<Array>::getConstantILayerConstRef(size_t layer,size_t f, size_t c) const
420  { return constant_i_layer_const_ref(*this,layer,f,c); }
421 template <class Array>
422 typename Array3dBase<Array>::constant_i_layer_const_ref Array3dBase<Array>::getConstantILayerConstRef(size_t layer,const RangoIndice &row_range,const RangoIndice &column_range) const
423  { return constant_i_layer_const_ref(*this,layer,row_range,column_range); }
424 template <class Array>
425 typename Array3dBase<Array>::constant_j_layer_const_ref Array3dBase<Array>::getConstantJLayerConstRef(size_t f,size_t layer, size_t c) const
426  { return constant_j_layer_const_ref(*this,layer,f,c); }
427 template <class Array>
428 typename Array3dBase<Array>::constant_j_layer_const_ref Array3dBase<Array>::getConstantJLayerConstRef(const RangoIndice &layer_range,const size_t &f,const RangoIndice &column_range) const
429  { return constant_j_layer_const_ref(*this,layer_range,f,column_range); }
430 template <class Array>
431 typename Array3dBase<Array>::constant_k_layer_const_ref Array3dBase<Array>::getConstantKLayerConstRef(size_t c,size_t layer, size_t f) const
432  { return constant_k_layer_const_ref(*this,c,layer,f); }
433 template <class Array>
434 typename Array3dBase<Array>::constant_k_layer_const_ref Array3dBase<Array>::getConstantKLayerConstRef(const RangoIndice &layer_range, const RangoIndice &row_range, const size_t &c) const
435  { return constant_k_layer_const_ref(*this,layer_range,row_range,c); }
436 
437 template <class Array>
438 typename Array3dBase<Array>::const_ref_i_row Array3dBase<Array>::getIRowConstRef(size_t f,size_t c) const
439  { return const_ref_i_row(*this,f,c); }
440 template <class Array>
441 typename Array3dBase<Array>::const_ref_i_row Array3dBase<Array>::getIRowConstRef(const RangoIndice &layer_range,const size_t &f,const size_t &c) const
442  { return const_ref_i_row(*this,layer_range,f,c); }
443 template <class Array>
444 typename Array3dBase<Array>::const_ref_j_row Array3dBase<Array>::getJRowConstRef(size_t layer,size_t c) const
445  { return const_ref_j_row(*this,layer,c); }
446 template <class Array>
447 typename Array3dBase<Array>::const_ref_j_row Array3dBase<Array>::getJRowConstRef(const size_t &layer,const RangoIndice &row_range,const size_t &c) const
448  { return const_ref_j_row(*this,layer,row_range,c); }
449 template <class Array>
450 typename Array3dBase<Array>::const_ref_k_row Array3dBase<Array>::getKRowConstRef(size_t layer,size_t f) const
451  { return const_ref_k_row(*this,layer,f); }
452 template <class Array>
453 typename Array3dBase<Array>::const_ref_k_row Array3dBase<Array>::getKRowConstRef(const size_t &layer,const size_t &f,const RangoIndice &column_range) const
454  { return const_ref_k_row(*this,layer,f,column_range); }
455 
456 template <class Array>
457 typename Array3dBase<Array>::box_var_ref Array3dBase<Array>::getBoxVarRef(size_t layer,size_t f, size_t c)
458  { return box_var_ref(*this,layer,f,c); }
459 template <class Array>
460 typename Array3dBase<Array>::box_var_ref Array3dBase<Array>::getBoxVarRef(const Array3dRange &rango)
461  { return box_var_ref(*this,rango); }
462 
463 template <class Array>
464 typename Array3dBase<Array>::constant_i_layer_variable_ref Array3dBase<Array>::getConstantILayerVarRef(size_t layer,size_t f, size_t c)
465  { return constant_i_layer_variable_ref(*this,layer,f,c); }
466 template <class Array>
467 typename Array3dBase<Array>::constant_i_layer_variable_ref Array3dBase<Array>::getConstantILayerVarRef(const size_t &layer,const RangoIndice &row_range,const RangoIndice &rcols)
468  { return constant_i_layer_variable_ref(*this,layer,row_range,rcols); }
469 template <class Array>
470 typename Array3dBase<Array>::constant_j_layer_variable_ref Array3dBase<Array>::getConstantJLayerVarRef(size_t f,size_t layer, size_t c)
471  { return constant_j_layer_variable_ref(*this,layer,f,c); }
472 template <class Array>
473 typename Array3dBase<Array>::constant_j_layer_variable_ref Array3dBase<Array>::getConstantJLayerVarRef(const RangoIndice &layer_range,const size_t &f,const RangoIndice &rcols)
474  { return constant_j_layer_variable_ref(*this,layer_range,f,rcols); }
475 template <class Array>
476 typename Array3dBase<Array>::constant_k_layer_variable_ref Array3dBase<Array>::getConstantKLayerVarRef(size_t c,size_t layer, size_t f)
477  { return constant_k_layer_variable_ref(*this,c,layer,f); }
478 template <class Array>
479 typename Array3dBase<Array>::constant_k_layer_variable_ref Array3dBase<Array>::getConstantKLayerVarRef(const RangoIndice &layer_range, const RangoIndice &row_range,const size_t &c)
480  { return constant_k_layer_variable_ref(*this,layer_range,row_range,c); }
481 
482 template <class Array>
483 typename Array3dBase<Array>::var_ref_i_row Array3dBase<Array>::getVarRefIRow(size_t f,size_t c)
484  { return var_ref_i_row(*this,f,c); }
485 template <class Array>
486 typename Array3dBase<Array>::var_ref_i_row Array3dBase<Array>::getVarRefIRow(const RangoIndice &layer_range,const size_t &f,const size_t &c)
487  { return var_ref_i_row(*this,layer_range,f,c); }
488 template <class Array>
489 typename Array3dBase<Array>::var_ref_j_row Array3dBase<Array>::getVarRefJRow(size_t layer,size_t c)
490  { return var_ref_j_row(*this,layer,c); }
491 template <class Array>
492 typename Array3dBase<Array>::var_ref_j_row Array3dBase<Array>::getVarRefJRow(const size_t &layer,const RangoIndice &row_range,const size_t &c)
493  { return var_ref_j_row(*this,layer,row_range,c); }
494 template <class Array>
495 typename Array3dBase<Array>::var_ref_k_row Array3dBase<Array>::getVarRefKRow(size_t layer,size_t f)
496  { return var_ref_k_row(*this,layer,f); }
497 template <class Array>
498 typename Array3dBase<Array>::var_ref_k_row Array3dBase<Array>::getVarRefKRow(const size_t &layer,const size_t &f,const RangoIndice &rcols)
499  { return var_ref_k_row(*this,layer,f,rcols); }
500 
502 template <class Array>
503 void Array3dBase<Array>::putBox(size_t layer_offset,size_t row_offset,size_t offset_col,const Array3dBase<Array> &other)
504  {
505  const size_t numberOfLayers= other.getNumberOfLayers();
506  const size_t numberOfRows= other.getNumberOfRows();
507  const size_t numberOfColumns= other.getNumberOfColumns();
508  if((numberOfLayers+layer_offset)>getNumberOfLayers())
509  {
510  std::cerr << "Array3dBase::" << __FUNCTION__
511  << "; layer index out of range." << std::endl;
512  return;
513  }
514  if((numberOfRows+row_offset)>this->getNumberOfRows())
515  {
516  std::cerr << "Array3dBase::" << __FUNCTION__
517  << "; row index out of range." << std::endl;
518  return;
519  }
520  if((numberOfColumns+offset_col)>this->getNumberOfColumns())
521  {
522  std::cerr << "Array3dBase::" << __FUNCTION__
523  << "; column index out of range." << std::endl;
524  return;
525  }
526  for(size_t i=1;i<=numberOfLayers;i++)
527  for(size_t j=1;j<=numberOfRows;j++)
528  for(size_t k=1;k<=numberOfColumns;k++)
529  (*this)(layer_offset+i,row_offset+j,offset_col+k)= other(i,j,k);
530  }
531 
533 template <class Array>
534 inline std::ostream &operator<<(std::ostream &os,const Array3dBase<Array> &t)
535  {
536  const size_t n_layers= t.getNumberOfLayers();
537  for(size_t i=1;i<=n_layers;i++)
538  os << t(i);
539  return os;
540  }
541 
542 #endif
Array3dBase::dim
void dim(const size_t &, const size_t &, const size_t &, const value_type &default_value=value_type())
Matrix dimensions.
Definition: Array3dBase.h:183
Array3dBase::Array3dBase
Array3dBase(const size_t &n_layers=0)
Default constructor.
Definition: Array3dBase.h:162
Array3dBase::clear
void clear(void)
Clears container.
Definition: Array3dBase.h:303
Array3dBase::isKRow
bool isKRow(void) const
Returns true if only index K varies.
Definition: Array3dBase.h:327
KRowVarRef
Reference to a row of the array which points have constant K indexes.
Definition: KRowVarRef.h:32
ConstantJLayerVarRef
Reference to a layer of the array which points have constant J index.
Definition: ConstantJLayerVarRef.h:34
Array3dBase::Null
bool Null(void) const
Returns true if it&#39;s empty or the pointers are null.
Definition: Array3dBase.h:273
Array3dBase::NumPtrs
size_t NumPtrs(void) const
Return the number of elements of the array.
Definition: Array3dBase.h:259
IRowConstRef
Reference to a layer row from the array which points have constant J and K indices.
Definition: IRowConstRef.h:32
Array3dBase::isKConstantLayer
bool isKConstantLayer(void) const
Returns true if the indexes that vary are los I y J.
Definition: Array3dBase.h:345
ConstantJLayerConstRef
Reference to a layer of the array which points have constant J index.
Definition: ConstantJLayerConstRef.h:34
Array3dBoxVarRef
Reference to a "sub-array".
Definition: Array3dBoxVarRef.h:33
ConstantKLayerVarRef
Reference to a layer of the array which points have constant K index.
Definition: ConstantKLayerVarRef.h:32
Array3dBase::putBox
void putBox(size_t layer_offset, size_t row_offset, size_t offset_col, const Array3dBase< Array > &)
Put in the array the array argument.
Definition: Array3dBase.h:503
Array3dBase::getNumberOfComponents
size_t getNumberOfComponents(void) const
Return the number of components in the container.
Definition: Array3dBase.h:235
Array3dBase::operator()
const Array & operator()(const size_t &layer) const
Return the i-th layer.
Definition: Array3dBase.h:350
ConstantILayerVarRef
Reference to a layer of the array which points have constant I index.
Definition: ConstantILayerVarRef.h:33
Array3dBoxConstRef
Referencia a una "sub array 3D".
Definition: Array3dBoxConstRef.h:34
Array3dBase::HasNull
bool HasNull(void) const
Returns true if it&#39;s empty or some of the pointers are null.
Definition: Array3dBase.h:283
ConstantILayerConstRef
Reference to a layer of the array which points have constant I index.
Definition: ConstantILayerConstRef.h:34
Array3dBase::isJRow
bool isJRow(void) const
Returns true if only index J varies.
Definition: Array3dBase.h:319
JRowVarRef
Reference to a row of the array which points have constant J and K indices.
Definition: JRowVarRef.h:32
ConstantKLayerConstRef
Reference to a layer of the array which points have constant K index.
Definition: ConstantKLayerConstRef.h:35
Array3dRange
Rangos de variación de tres índices, se emplea en BoxConstRef.
Definition: Array3dRange.h:32
Array3dBase::isJConstantLayer
bool isJConstantLayer(void) const
Returns true if the indexes that vary are los I y K.
Definition: Array3dBase.h:340
IRowVarRef
Reference to a row of the array which points have constant J and K indices.
Definition: IRowVarRef.h:32
Array3dBase::isIRow
bool isIRow(void) const
Returns true if only index I varies.
Definition: Array3dBase.h:311
JRowConstRef
Reference to a layer of the array which points have constant J and K indexes.
Definition: JRowConstRef.h:32
KRowConstRef
Reference to a layer row of the array which points have constant J and K indices. ...
Definition: KRowConstRef.h:32
Array3dBase
arrays3d
Definition: Array3dBase.h:51
Array3dBase::resize
void resize(const size_t &)
Resize the array.
Definition: Array3dBase.h:188
RangoIndice
Rango de variación de un índice, se emplea en BoxConstRef.
Definition: RangoIndice.h:30
Array3dBase::isIConstantLayer
bool isIConstantLayer(void) const
Returns true if the indexes that vary are los J y K.
Definition: Array3dBase.h:335
Generated by   doxygen 1.8.13