casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Arrays.h
Go to the documentation of this file.
1 //# Arrays.h: A module implementing multidimensional arrays and operations
2 //# Copyright (C) 1995,1999,2000
3 //# Associated Universities, Inc. Washington DC, USA.
4 //#
5 //# This library is free software; you can redistribute it and/or modify it
6 //# under the terms of the GNU Library General Public License as published by
7 //# the Free Software Foundation; either version 2 of the License, or (at your
8 //# option) any later version.
9 //#
10 //# This library is distributed in the hope that it will be useful, but WITHOUT
11 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 //# License for more details.
14 //#
15 //# You should have received a copy of the GNU Library General Public License
16 //# along with this library; if not, write to the Free Software Foundation,
17 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 //#
19 //# Correspondence concerning AIPS++ should be addressed as follows:
20 //# Internet email: aips2-request@nrao.edu.
21 //# Postal address: AIPS++ Project Office
22 //# National Radio Astronomy Observatory
23 //# 520 Edgemont Road
24 //# Charlottesville, VA 22903-2475 USA
25 //#
26 //# $Id$
27 
28 #ifndef CASA_ARRAYS_H
29 #define CASA_ARRAYS_H
30 
31 #include <casacore/casa/aips.h>
32 
36 
41 
45 
52 
57 
63 
64 
65 namespace casacore { //# NAMESPACE CASACORE - BEGIN
66 
67 // <module>
68 //
69 // <summary>
70 // A module implementing multidimensional arrays and operations.
71 // </summary>
72 
73 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" demos="">
74 // </reviewed>
75 
76 // <etymology>
77 // This module provides classes and global functions for multidimensional
78 // arrays.
79 // </etymology>
80 //
81 // <synopsis>
82 // Arrays have traditionally played an important role in scientific
83 // computation. While it is certainly true that some of the reliance on
84 // arrays was due to the paucity of other data structures in FORTRAN, it
85 // is also true that computation on arrays reflects the common occurrence
86 // of regularly sampled multi-dimensioned data in science.
87 //
88 // The <linkto module=Lattices>Lattices</linkto> are a generalization
89 // of Arrays. They can handle memory- and disk-based arrays as well
90 // as other types of arrays (eg. expressions).
91 //
92 // The module consists of various parts:
93 // <ul>
94 
95 // <li>
96 // <linkto class=Array>Array</linkto> is the basic array class. It is
97 // only templated on data type, not on dimensionality like the array
98 // classes in Blitz and boost.
99 // It has a non-templated base class ArrayBase.
100 //
101 // <linkto class=Vector>Vector</linkto>,
102 // <linkto class=Matrix>Matrix</linkto>, and
103 // <linkto class=Cube>Cube</linkto>
104 // are the one, two, and three dimensional specializations respectively of
105 // Array.
106 //
107 // <li>
108 // <linkto class=MaskedArray>MaskedArray</linkto> is the class used to mask
109 // an Array for operations on that Array.
110 //
111 // <li>
112 // <linkto class=ArrayError>ArrayError</linkto> is the base class for all
113 // Array exception classes.
114 //
115 // <li>
116 // There are several ways o iterate through an array:
117 // <ul>
118 // <li> The STL-style Array iterators can be used to iterate
119 // element by element through an array. This is the fastest way.
120 // They also make it possible to virtually extend an array (called
121 // shape broadcasting in numpy) and to reorder the iteration axes.
122 // <li> <linkto class=ArrayIterator>ArrayIterator</linkto> can be used to
123 // iterate line by line, plane by plane, etc. through an array.
124 // Each subset is an array in itself, thus can be iterated again.
125 // <li> The Array function operators () can be used to get a subset from
126 // an array. They can be used for iteration, but that is slower than
127 // the ways mentioned above.
128 // <li> The array operator[] can be used to get the i-th subset. It can
129 // be used for iteration, but ArrayIterator does the same and is faster.
130 // <li> ArrayAccessor is useful when neighbours of an array element have
131 // to be visited.
132 // <li> <linkto class=LatticeIterator>LatticeIterator</linkto> can be used on
133 // a <linkto class=ArrayLattice>ArrayLattice</linkto> object for more
134 // advanced iteration. However, they are part of the lattices packages.
135 // </ul>
136 //
137 // <li>
138 // <linkto group="ArrayMath.h#Array mathematical operations">Mathematical</linkto>,
139 // <linkto group="ArrayLogical.h#Array logical operations">logical</linkto>,
140 // <linkto group="ArrayPartMath.h#Array partial operations">chunked mathematical and logical</linkto>,
141 // <linkto group="ArrayIO.h#Array IO">IO</linkto>,
142 // and other useful operations are provided for
143 // Arrays and MaskedArrays.
144 //
145 // ArrayMath also defines various STL-style transform functions that use the
146 // Array iterators and functors like Plus to apply the mathematical and logical
147 // operations. They can, however, also be used directly on arrays of
148 // different types making it possible to, say, add a Complex and double array
149 // with a DComplex result.
150 // <br>It also has a <src>transformInPlace</src> to avoid needless incrementing
151 // of iterators which have to be done when using <src>std::transform</src>
152 // for in-place operations.
153 //
154 // <li>
155 // Orthogonal n-space descriptors - useful when a shape of an Array is
156 // needed or when a sub-region within an Array is required.
157 // <ul>
158 // <li> The <linkto class="IPosition">IPosition</linkto> class name is a
159 // concatenation of "Integer Position." IPosition objects are normally
160 // used to index into, and define the shapes of, Arrays and Lattices. For
161 // example, if you have a 5-dimensional array, you need an IPosition of
162 // length 5 to index into the array (or to define its shape, etc.). It is
163 // essentially a vector of integers. The IPosition vector may point to
164 // the "top right corner" of some shape, or it may be an indicator of a
165 // specific position in n-space. The interpretation is context dependent.
166 // The constructor consists of an initial argument which specifies the
167 // number of axes, followed by the appropriate number of respective axis
168 // lengths. Thus the constructor needs N+1 arguments for an IPosition
169 // of length N. IPositions have the standard integer math relationships
170 // defined. The dimensionality of the operator arguments must be the
171 // same.
172 //<srcblock>
173 // // Make a shape with three axes, x = 24, y = 48, z = 16;
174 // IPosition threeSpace(3, 24, 48, 16);
175 //
176 // // get the value of the ith axis (note: C++ is zero based!)
177 // Int xShape = threeSpace(0);
178 // Int zShape = threeSpace(2);
179 //
180 // // construct another with all three axes values equal to 666;
181 // IPosition threeSpaceAlso(3,666);
182 //
183 // // do math with the IPositions...
184 // threeSpace += threeSpaceAlso;
185 // AlwaysAssert(threeSpace(1) == 714, AipsError);
186 // </srcblock>
187 //
188 // <li> The <linkto class="Slicer">Slicer</linkto> class name may be
189 // thought of as a short form of "n-Dimensional Slice Specifier."
190 // This object is used to bundle into one place all the information
191 // necessary to specify a regular subregion within an Array or Lattice.
192 // In other words, Slicer holds the location of a "slice" of a
193 // greater whole. Construction is with up to 3 IPositions: the start
194 // location of the subspace within the greater space; the shape or end
195 // location of the subspace within the greater space; and the stride,
196 // or multiplier to be used for each axis. The stride gives the user
197 // the chance to use every i-th piece of data, rather than every
198 // position on the axis.
199 // <br>
200 // It is possible to leave some values in the given start or end/length
201 // unspecified. Such unspecified values default to the boundaries of the
202 // array to which the slicer will be applied.
203 // It is also possible to use a non-zero origin when applying the slicer
204 // to an array.
205 //
206 // <srcblock>
207 // // Define the shape of an array.
208 // IPosition shape(2,20,30);
209 //
210 // // Also define an origin.
211 // IPosition origin(2,-5,15);
212 //
213 // // Now define some Slicers, initially only specify the start
214 // // Its length and stride will be 1.
215 // Slicer ns0(IPosition(2,0,24));
216 //
217 // // make some IPositions as holders for the rest of the information
218 // IPosition blc,trc,inc;
219 //
220 // // Use the shape and origin to fill our holders assuming we want to use
221 // // as much of the Array as possible.
222 // ns0.inferShapeFromSource (shape, origin, blc,trc,inc);
223 //
224 // // print out the new info ie. blc=[5,9],trc=[5,9],inc=[1,1]
225 // cout << blc << trc << inc << endl;
226 //
227 // // Build a slicer with temporaries for arguments. The arguments are:
228 // // start position, end position and step increment. The Slicer::endIsLast
229 // // argument specifies that the end position is the trc. The alternative
230 // // is Slicer::endIsLength which specifies that the end argument is the
231 // // shape of the resulting subregion.
232 // //
233 // Slicer ns1(IPosition(2,3,5), IPosition(2,13,21), IPosition(2,3,2),
234 // Slicer::endIsLast);
235 // IPosition shp = ns1.inferShapeFromSource (shape, blc,trc,inc);
236 // //
237 // // print out the new info ie. shp=[4,9],blc=[3,5],trc=[12,21],inc=[3,2]
238 // cout << shp << blc << trc << inc << endl;
239 // </srcblock>
240 // </ul>
241 // </ul>
242 
243 // The <linkto module=Arrays:classes>detailed discussions</linkto> for the
244 // classes and global functions will describe how to use them.
245 // </synopsis>
246 //
247 // </module>
248 
249 
250 } //# NAMESPACE CASACORE - END
251 
252 #endif
#define casacore
&lt;X11/Intrinsic.h&gt; #defines true, false, casacore::Bool, and String.
Definition: X11Intrinsic.h:42