2.7 Global functions

void                              allocateArrays(TinyVector<int,N>& shape,
                                                 Array<T,N>& A, 
                                                 Array<T,N>& B, ...);

This function will allocate interlaced arrays, but only if interlacing is desirable for your architecture. This is controlled by the BZ_INTERLACE_ARRAYS flag in blitz/tuning.h. You can provide up to 11 arrays as parameters. Any views currently associated with the array objects are lost. Here is a typical use:

Array<int,2> A, B, C;
allocateArrays(shape(64,64),A,B,C);

If array interlacing is enabled, then the arrays are stored in memory like this: A(0,0), B(0,0), C(0,0), A(0,1), B(0,1), ... If interlacing is disabled, then the arrays are allocated in the normal fashion: each array has its own block of memory. Once interlaced arrays are allocated, they can be used just like regular arrays.

#include <blitz/array/convolve.h>
Array<T,1>                        convolve(const Array<T,1>& B, 
                                           const Array<T,1>& C);

This function computes the 1-D convolution of the arrays B and C: A[i] = sum(B[j] * C[i-j], j) If the array B has domain b_l \ldots b_h, and array C has domain c_l \ldots c_h, then the resulting array has domain a_l \ldots a_h, with l = b_l + c_l and a_h = b_h + c_h.

A new array is allocated to contain the result. To avoid copying the result array, you should use it as a constructor argument. For example: Array<float,1> A = convolve(B,C); The convolution is computed in the spatial domain. Frequency-domain transforms are not used. If you are convolving two large arrays, then this will be slower than using a Fourier transform.

Note that if you need a cross-correlation, you can use the convolve function with one of the arrays reversed. For example:

Array<float,1> A = convolve(B,C.reverse());

Autocorrelation can be performed using the same approach.

void                              cycleArrays(Array<T,N>& A, Array<T,N>& B);
void                              cycleArrays(Array<T,N>& A, Array<T,N>& B, 
                                              Array<T,N>& C);
void                              cycleArrays(Array<T,N>& A, Array<T,N>& B, 
                                              Array<T,N>& C, Array<T,N>& D);
void                              cycleArrays(Array<T,N>& A, Array<T,N>& B, 
                                              Array<T,N>& C, Array<T,N>& D, 
                                              Array<T,N>& E);

These routines are useful for time-stepping PDEs. They take a set of arrays such as [A,B,C,D] and cyclically rotate them to [B,C,D,A]; i.e. the A array then refers to what was B’s data, the B array refers to what was C’s data, and the D array refers to what was A’s data. These functions operate in constant time, since only the handles change (i.e. no data is copied; only pointers change).

void                         find(Array<TinyVector<int,Expr::rank>,1>& indices,
                                  const _bz_ArrayExpr<Expr>& expr);
void                         find(Array<TinyVector<int,N>,1>& indices,
                                  const Array<bool,N>& exprVals);

This is an analogue to the Matlab find() method, which takes a boolean array expression or an array of bools and returns a 1d array of indices for all locations where the array or expression is true.

Array<T,N>                        imag(Array<complex<T>,N>&);

This method returns a view of the imaginary portion of the array.

void                              interlaceArrays(TinyVector<int,N>& shape,
                                                  Array<T,N>& A, 
                                                  Array<T,N>& B, ...);

This function is similar to allocateArrays() above, except that the arrays are always interlaced, regardless of the setting of the BZ_INTERLACE_ARRAYS flag.

Array<T,N>                        real(Array<complex<T>,N>&);

This method returns a view of the real portion of the array.

TinyVector<int,1>                 shape(int L);
TinyVector<int,2>                 shape(int L, int M);
TinyVector<int,3>                 shape(int L, int M, int N);
TinyVector<int,4>                 shape(int L, int M, int N, int O);
... [up to 11 dimensions]

These functions may be used to create shape parameters. They package the set of integer arguments as a TinyVector of appropriate length. For an example use, see allocateArrays() above.

void                              swap(Array<T,N>& A, Array<T,N>& B);

This function swaps the storage of two arrays, just like the std::swap() function does for STL container types. This is a synonym for the two-argument version of cycleArrays() above.