array_dec.h 8.14 KB
Newer Older
1
2
3
4
5
/*! \file array_dec.h
 * \brief array class declarations (prototypes)
 * 
 * ----------------------------------------------------------------------------
 * 
thomas.forbriger's avatar
thomas.forbriger committed
6
 * $Id: array_dec.h,v 1.4 2002-12-12 22:08:19 forbrig Exp $
7
 * \author Thomas Forbriger
8
 * \since 08/12/2002
9
10
 * 
 * array class declarations (prototypes)
11
12
13
14
15
16
 *
 * \note
 * This should never be included directly. Use array.h or binarray.h instead.
 *
 * \todo 
 * Do we need the using directive?
17
18
19
20
 * 
 * Copyright (c) 2002 by Thomas Forbriger (IMG Frankfurt) 
 * 
 * REVISIONS and CHANGES 
21
 *  - 08/12/2002   V1.0   copied from libcontxx
22
23
24
25
26
 * 
 * ============================================================================
 */

// include guard
27
#ifndef AFF_ARRAY_DEC_H_VERSION
28

29
30
31
#define AFF_ARRAY_DEC_H_VERSION \
  "AFF_ARRAY_DEC_H   V1.0   "
#define AFF_ARRAY_DEC_H_CVSID \
thomas.forbriger's avatar
thomas.forbriger committed
32
  "$Id: array_dec.h,v 1.4 2002-12-12 22:08:19 forbrig Exp $"
33

34
35
36
#include <aff/sharedheap.h>
#include <aff/strided.h>
#include <aff/range.h>
37

38
namespace aff {
39

40
#ifdef AFF_PREBUILT
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
namespace prebuilt {
#endif

  /*! \brief Full multi-dimensional array functionality.
   *
   * The array class highly depends on base classes from which inherts most of
   * its functionality. 
   * The user may select from several provided array designs through template
   * parameters:
   * \param T element type of array (passed to Subscriptor base class)
   * \param N dimensionality of array (passed to Subscriptor base class)
   * \param Representation Representation (engine for memory access) base
   *        class type (passed to Subscriptor base class)
   * \param Subscriptor Subscriptor base class type
   *
   * \sa \ref page_shapes_and_subscriptors
   * \sa \ref page_representation
   * \sa \ref sec_main_modules
   * \sa tests/arraytest.cc
60
   *
thomas.forbriger's avatar
thomas.forbriger committed
61
62
63
64
65
66
67
68
   * \note
   * We may just use the default copy constructor and default copy operator.
   *
   * If you want to create an array for externally managed memory (e.g. arrays
   * taken from Fortran code): First create a SharedHeap representation for the
   * given memory pointer and size. Second create a shape, defining the memory
   * layout and then create the array object from these both.
   *
69
70
71
72
73
74
75
76
   * \todo
   * documentation of class Array must be reworked
   *
   * \todo
   * class Array must be reworked itself entirely
   *
   * \todo 
   * Explain the new concept of multidimensional array indexing
77
   */
thomas.forbriger's avatar
thomas.forbriger committed
78
  template<class T>
79
    class Array:
thomas.forbriger's avatar
thomas.forbriger committed
80
      public aff::Strided, public aff::SharedHeap<T>
81
    {
thomas.forbriger's avatar
thomas.forbriger committed
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
      public:
        //! Type of representation
        typedef aff::SharedHeap<T> Trepresentation;
        //! Type of subscriptor
        typedef aff::Strided Tshape;
        //! Element type
        typedef typename Trepresentation::Tvalue Tvalue;
        //! Type of pointer to element
        typedef typename Trepresentation::Tpointer Tpointer;
        //! Type of reference to element
        typedef typename Trepresentation::Treference Treference;
        //! Type of const reference to element
        typedef typename Trepresentation::Tconst_reference Tconst_reference;
        //! Type to be used as data representation
        typedef typename Trepresentation::Tmutable_value Tmutable_value;
        //! Type to be used as element for const version
        typedef typename Trepresentation::Tconst_value Tconst_value;
        //! Type of this array
        typedef Array<T> Tcontainer;
        //! Type of the array of const values
        typedef Array<Tconst_value> Tcontainer_of_const;
thomas.forbriger's avatar
thomas.forbriger committed
103
104
        //! short for container of const
        typedef Array<Tconst_value> Tcoc;
thomas.forbriger's avatar
thomas.forbriger committed
105
106
107
108
109
110
111
112

        //! construct from nothing (empty)
        Array() { }
        //! construct from shape and representation
        Array(const Tshape& shape, 
              const Trepresentation& representation);
        //! construct from shape (defines size and layout)
        explicit Array(const Tshape& shape);
thomas.forbriger's avatar
thomas.forbriger committed
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
        //! construct from index range limit
        explicit Array(const Tsize& s0);
        //! construct from index range limits
        Array(const Tsize& s0, const Tsize& s1);
        //! construct from index range limits
        Array(const Tsize& s0, const Tsize& s1, const Tsize& s2);
        //! construct from index range limits
        Array(const Tsize& s0, const Tsize& s1, 
              const Tsize& s2, const Tsize& s3);
      
        //! full dimensionality access
        Tvalue& operator()(const TIndexVec& index) 
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(index))); }
        //! access from 1 index value
        Tvalue& operator()(const Tsubscript& i0) 
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0))); }
        //! access from 2 index values
        Tvalue& operator()(const Tsubscript& i0,
                            const Tsubscript& i1) 
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0, i1))); }
        //! access from 3 index values
        Tvalue& operator()(const Tsubscript& i0,
                            const Tsubscript& i1,
                            const Tsubscript& i2) 
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0, i1, i2))); }
        //! access from 4 index values
        Tvalue& operator()(const Tsubscript& i0,
                            const Tsubscript& i1,
                            const Tsubscript& i2,
                            const Tsubscript& i3) 
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0, i1, i2, i3))); }
      
        //! full dimensionality access
        const Tvalue& operator()(const TIndexVec& index) const
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(index))); }
        //! access from 1 index value
        const Tvalue& operator()(const Tsubscript& i0) const
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0))); }
        //! access from 2 index values
        const Tvalue& operator()(const Tsubscript& i0,
                            const Tsubscript& i1) const
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0, i1))); }
        //! access from 3 index values
        const Tvalue& operator()(const Tsubscript& i0,
                            const Tsubscript& i1,
                            const Tsubscript& i2) const
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0, i1, i2))); }
        //! access from 4 index values
        const Tvalue& operator()(const Tsubscript& i0,
                            const Tsubscript& i1,
                            const Tsubscript& i2,
                            const Tsubscript& i3) const
        { return(this->Trepresentation::operator[](
                       this->Tshape::offset(i0, i1, i2, i3))); }
thomas.forbriger's avatar
thomas.forbriger committed
176
177
178
179
180
181
182
183

        //! conversion to container of const values
        operator Tcontainer_of_const() const
        {
          Tcontainer_of_const retval(*this, *this);
          return(retval);
        }

thomas.forbriger's avatar
thomas.forbriger committed
184
185
186
187
188
189
190
        //! return first index of dimension i
        const Tsubscript& f(const Tsubscript& i) const
        { return(this->Tshape::first(i)); }
        //! return last index of dimension i
        const Tsubscript& l(const Tsubscript& i) const
        { return(this->Tshape::last(i)); }

thomas.forbriger's avatar
thomas.forbriger committed
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
        //! by size we mean the size defined by the shape
        Tsize size(const Tsubscript& i) const
        { return(this->Tshape::size(i)); }
        //! by size we mean the size defined by the shape
        Tsize size() const
        { return(this->Tshape::size()); }
          
        //! set whole array to value
        Array& operator=(const T& value);

        //! create an identical COPY (deep copy) of this array
        Array copyout() const;

        //! COPY values (deep copy) from other array of convertible type
        //! (returns itself)
        template<class TT>
          Array& copyin(const Array<TT>& a);
208
209
210

    }; // class Array

211
212
#ifdef AFF_PREBUILT
} // namespace prebuilt
213
214
#endif

215
} // namespace aff
216

217
218
#ifndef AFF_NO_DEFINITIONS
#include <aff/array_def.h>
219
220
#endif

221
#endif // AFF_ARRAY_DEC_H_VERSION (includeguard)
222
223

/* ----- END OF array_dec.h ----- */