Array4D< T > Class Template Reference

#include <lib-array.h>

Public Member Functions
	Array4D (size_t x, size_t y, size_t z, size_t w)
	Array4D (const Array4D &other)
	~Array4D ()
size_t	dim () const
size_t	dim1 () const
size_t	dim2 () const
size_t	dim3 () const
size_t	dim4 () const
valarray< T > &	array () const
T &	operator() (size_t i, size_t j, size_t k, size_t l)
T	operator() (size_t i, size_t j, size_t k, size_t l) const
T &	operator() (size_t i)
T	operator() (size_t i) const
GSlice_iter< T >	d1c (size_t b, size_t e)
GSlice_iter< T >	d2c (size_t b, size_t e)
GSlice_iter< T >	d3c (size_t b, size_t e)
GSlice_iter< T >	d4c (size_t b, size_t e)
GSlice_iter< T >	SubArray4D (size_t st, size_t nx, size_t ny, size_t nz, size_t nw)
CGSlice_iter< T >	d1c (size_t b, size_t e) const
CGSlice_iter< T >	d2c (size_t b, size_t e) const
CGSlice_iter< T >	d3c (size_t b, size_t e) const
CGSlice_iter< T >	d4c (size_t b, size_t e) const
CGSlice_iter< T >	SubArray4D (size_t st, size_t nx, size_t ny, size_t nz, size_t nw) const
Array4D &	operator= (const T &d)
Array4D &	operator= (const Array4D &other)
Array4D &	operator*= (const T &d)
Array4D &	operator*= (const Array4D &vmulti)
Array4D &	operator+= (const T &d)
Array4D &	operator+= (const Array4D &vadd)
Array4D &	operator-= (const T &d)
Array4D &	operator-= (const Array4D &vmin)
Array4D &	multid1 (const valarray< T > &vmulti)
Array4D &	multid2 (const valarray< T > &vmulti)
Array4D &	multid3 (const valarray< T > &vmulti)
Array4D &	multid4 (const valarray< T > &vmulti)
Array4D &	multid2d3d4 (const Array3D< T > &vd2d3d4)
Array4D &	Dd1 ()
Array4D &	Dd2 ()
Array4D &	Dd3 ()
Array4D &	Dd4 ()
Array4D &	Filterd1 (size_t N)

Private Attributes
valarray< T > *	v
size_t	d1
size_t	d2
size_t	d3
size_t	d4
size_t	d1d2
size_t	d1d2d3

Detailed Description

template<class T>
class Array4D< T >

Definition at line 1879 of file lib-array.h.

Constructor & Destructor Documentation

Array4D() [1/2]

template<class T >

Array4D< T >::Array4D	(	size_t	x,
		size_t	y,
		size_t	z,
		size_t	w
	)

Definition at line 1962 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d2, Array4D< T >::d3, Array4D< T >::d4, and Array4D< T >::v.

Referenced by Array4D< T >::array().

                                                : d1(x), d2(y), d3(z), d4(w) {
    v = new valarray<T>(d1*d2*d3*d4);
    d1d2   = d1*d2;
    d1d2d3 = d1*d2*d3;
}

Here is the caller graph for this function:

Array4D() [2/2]

template<class T >

Array4D< T >::Array4D

(

const Array4D< T > &

other

)

Definition at line 1968 of file lib-array.h.

References Array4D< T >::array(), Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d2, Array4D< T >::d3, Array4D< T >::d4, Array4D< T >::dim1(), Array4D< T >::dim2(), Array4D< T >::dim3(), Array4D< T >::dim4(), and Array4D< T >::v.

                                                          {
    d1  = other.dim1();
    d2  = other.dim2();
    d3  = other.dim3();
    d4  = other.dim4();
    d1d2 = d1*d2;
    d1d2d3 = d1*d2*d3;
    v = new valarray<T>(d1*d2*d3*d4);
    (*v) = other.array();
}

Here is the call graph for this function:

~Array4D()

template<class T >

Array4D< T >::~Array4D

(

)

Definition at line 1979 of file lib-array.h.

References Array4D< T >::v.

                                       {
    delete v;
}

Member Function Documentation

array()

template<class T>

valarray<T>& Array4D< T >::array ( ) const

inline

Definition at line 1902 of file lib-array.h.

References Array4D< T >::Array4D(), Array3D_cmplx< T >::d1c(), Array3D_cmplx< T >::d2c(), Array3D_cmplx< T >::d3c(), Array3D_cmplx< T >::Dd1(), Array3D_cmplx< T >::Dd2(), Array3D_cmplx< T >::Dd3(), Array3D_cmplx< T >::Filterd1(), Array3D_cmplx< T >::multid1(), Array3D_cmplx< T >::multid2(), Array3D_cmplx< T >::multid3(), Array3D_cmplx< T >::operator*=(), Array3D_cmplx< T >::operator+=(), Array3D_cmplx< T >::operator-=(), Array3D_cmplx< T >::operator=(), and Array3D_cmplx< T >::v.

Referenced by Array4D< T >::Array4D(), Array4D< T >::operator*=(), Array4D_cmplx< T >::operator*=(), Array4D< T >::operator+=(), Array4D_cmplx< T >::operator+=(), Array4D< T >::operator-=(), Array4D_cmplx< T >::operator-=(), Array4D< T >::operator=(), and Array4D_cmplx< T >::operator=().

{return *v;};

Here is the call graph for this function:

Here is the caller graph for this function:

d1c() [1/2]

template<class T >

GSlice_iter< T > Array4D< T >::d1c ( size_t  b, size_t  e  )

inline

Definition at line 2014 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d2, Array4D< T >::d3, Array4D< T >::d4, and Array4D< T >::v.

Referenced by Array4D_cmplx< T >::array().

                                                       {
    valarray<size_t> sz(4), str(4);
    str[3] = d1; str[2] = d1d2; str[1] = d1d2d3; str[0] = 1;
    sz[3]  = d2; sz[2]  = d3;   sz[1] = d4; sz[0] = e-b+1;
    return GSlice_iter<T>(v,gslice(b,sz,str));
}

Here is the caller graph for this function:

d1c() [2/2]

template<class T >

CGSlice_iter< T > Array4D< T >::d1c ( size_t  b, size_t  e  ) const

inline

Definition at line 2022 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d2, Array4D< T >::d3, Array4D< T >::d4, and Array4D< T >::v.

                                                              {
    valarray<size_t> sz(4), str(4);
    str[3] = d1; str[2] = d1d2; str[1] = d1d2d3; str[0] = 1;
    sz[3]  = d2; sz[2]  = d3;   sz[1] = d4; sz[0] = e-b+1;
    return CGSlice_iter<T>(v,gslice(b,sz,str));
}

d2c() [1/2]

template<class T >

GSlice_iter< T > Array4D< T >::d2c ( size_t  b, size_t  e  )

inline

Definition at line 2030 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d3, Array4D< T >::d4, and Array4D< T >::v.

Referenced by Array4D_cmplx< T >::array().

                                                       {
    valarray<size_t> sz(4), str(4);
    str[3] = 1;  str[2] = d1d2; str[1] = d1d2d3; str[0] = d1;
    sz[3]  = d1; sz[2]  = d3;   sz[1] = d4; sz[0] = e-b+1;
    return GSlice_iter<T>(v,gslice(b*d1,sz,str));
}

Here is the caller graph for this function:

d2c() [2/2]

template<class T >

CGSlice_iter< T > Array4D< T >::d2c ( size_t  b, size_t  e  ) const

inline

Definition at line 2038 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d3, Array4D< T >::d4, and Array4D< T >::v.

                                                              {
    valarray<size_t> sz(4), str(4);
    str[3] = 1;  str[2] = d1d2; str[1] = d1d2d3; str[0] = d1;
    sz[3]  = d1; sz[2]  = d3;   sz[1] = d4; sz[0] = e-b+1;
    return CGSlice_iter<T>(v,gslice(b*d1,sz,str));
}

d3c() [1/2]

template<class T >

GSlice_iter< T > Array4D< T >::d3c ( size_t  b, size_t  e  )

inline

Definition at line 2046 of file lib-array.h.

References Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d4, and Array4D< T >::v.

Referenced by Array4D_cmplx< T >::array().

                                                       {
    valarray<size_t> sz(3), str(3);
    str[2] = 1;    str[1] = d1d2d3; str[0] = d1d2;
    sz[2]  = d1d2; sz[1]  = d4;     sz[0]  = e-b+1;
    return GSlice_iter<T>(v,gslice(b*d1d2,sz,str));
}

Here is the caller graph for this function:

d3c() [2/2]

template<class T >

CGSlice_iter< T > Array4D< T >::d3c ( size_t  b, size_t  e  ) const

inline

Definition at line 2054 of file lib-array.h.

References Array4D< T >::d1d2, Array4D< T >::d1d2d3, Array4D< T >::d4, and Array4D< T >::v.

                                                              {
    valarray<size_t> sz(3), str(3);
    str[2] = 1;    str[1] = d1d2d3; str[0] = d1d2;
    sz[2]  = d1d2; sz[1]  = d4;     sz[0]  = e-b+1;
    return CGSlice_iter<T>(v,gslice(b*d1d2,sz,str));
}

d4c() [1/2]

template<class T >

GSlice_iter< T > Array4D< T >::d4c ( size_t  b, size_t  e  )

inline

Definition at line 2062 of file lib-array.h.

References Array4D< T >::d1d2d3, and Array4D< T >::v.

Referenced by Array4D_cmplx< T >::array().

                                                        {
    valarray<size_t> sz(2), str(2);
    str[1] = 1;     str[0] = d1d2d3;
    sz[1]  = d1d2d3; sz[0] = e-b+1;
    return GSlice_iter<T>(v,gslice(b*d1d2d3,sz,str));
}

Here is the caller graph for this function:

d4c() [2/2]

template<class T >

CGSlice_iter< T > Array4D< T >::d4c ( size_t  b, size_t  e  ) const

inline

Definition at line 2070 of file lib-array.h.

References Array4D< T >::d1d2d3, and Array4D< T >::v.

                                                               {
    valarray<size_t> sz(2), str(2);
    str[1] = 1;     str[0] = d1d2d3;
    sz[1]  = d1d2d3; sz[0] = e-b+1;
    return CGSlice_iter<T>(v,gslice(b*d1d2d3,sz,str));
}

Dd1()

template<class T >

Array4D< T > & Array4D< T >::Dd1

(

)

Definition at line 2218 of file lib-array.h.

References Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                             {
    for(long i(0); i< dim()-2; ++i) {
        (*v)[i] -= (*v)[i+2];
    }
    for(long i(dim()-3); i>-1; --i) {
        (*v)[i+1] = (*v)[i];
    }
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dd2()

template<class T >

Array4D< T > & Array4D< T >::Dd2

(

)

Definition at line 2229 of file lib-array.h.

References Array4D< T >::d1, and Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                             {
    long twod1 = 2*d1;
    for(long i(0); i< dim()-twod1; ++i) {
        (*v)[i] -= (*v)[i+twod1];
    }
    for(long i(dim()-twod1-1); i>-1; --i) {
        (*v)[i+d1] = (*v)[i];
    }
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dd3()

template<class T >

Array4D< T > & Array4D< T >::Dd3

(

)

Definition at line 2241 of file lib-array.h.

References Array4D< T >::d1d2, and Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                              {
    long twod1d2 = 2*d1d2;
    for(long i(0); i< dim()-twod1d2; ++i) {
        (*v)[i] -= (*v)[i+twod1d2];
    }
    for(long i(dim()-twod1d2-1); i>-1; --i) {
        (*v)[i+d1d2] = (*v)[i];
    }
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dd4()

template<class T >

Array4D< T > & Array4D< T >::Dd4

(

)

Definition at line 2253 of file lib-array.h.

References Array4D< T >::d1d2d3, and Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                              {
    long twod1d2d3 = 2*d1d2d3;
    for(long i(0); i< dim()-twod1d2d3; ++i) {
        (*v)[i] -= (*v)[i+twod1d2d3];
    }
    for(long i(dim()-twod1d2d3-1); i>-1; --i) {
        (*v)[i+d1d2d3] = (*v)[i];
    }
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dim()

template<class T>

size_t Array4D< T >::dim ( ) const

inline

Definition at line 1897 of file lib-array.h.

Referenced by Array4D< T >::Dd1(), Array4D< T >::Dd2(), Array4D< T >::Dd3(), Array4D< T >::Dd4(), Array4D< T >::multid1(), Array4D< T >::multid2(), and Array4D< T >::multid3().

{return d1*d2*d3*d4;}

Here is the caller graph for this function:

dim1()

template<class T>

size_t Array4D< T >::dim1 ( ) const

inline

Definition at line 1898 of file lib-array.h.

References Array3D_cmplx< T >::d1.

Referenced by Array4D< T >::Array4D().

{return d1;}

Here is the caller graph for this function:

dim2()

template<class T>

size_t Array4D< T >::dim2 ( ) const

inline

Definition at line 1899 of file lib-array.h.

References Array3D_cmplx< T >::d2.

Referenced by Array4D< T >::Array4D().

{return d2;}

Here is the caller graph for this function:

dim3()

template<class T>

size_t Array4D< T >::dim3 ( ) const

inline

Definition at line 1900 of file lib-array.h.

References Array3D_cmplx< T >::d3.

Referenced by Array4D< T >::Array4D().

{return d3;}

Here is the caller graph for this function:

dim4()

template<class T>

size_t Array4D< T >::dim4 ( ) const

inline

Definition at line 1901 of file lib-array.h.

Referenced by Array4D< T >::Array4D().

{return d4;}

Here is the caller graph for this function:

Filterd1()

template<class T >

Array4D< T > & Array4D< T >::Filterd1

(

size_t

N

)

Definition at line 2266 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d2, Array4D< T >::d3, and Array4D< T >::d4.

Referenced by Array4D_cmplx< T >::array().

                                                           {
    for (size_t j(0); j < d2*d3*d4; ++j ){
        for (size_t i(j*d1); i< j*d1+N; ++i ){
            (*v)[i] = 0.0;
        }
    }
    return *this;
}

Here is the caller graph for this function:

multid1()

template<class T >

Array4D< T > & Array4D< T >::multid1

(

const valarray< T > &

vmulti

)

Definition at line 2148 of file lib-array.h.

References Array4D< T >::d1, and Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                                                          {
    for (size_t j(0); j< dim(); j+=d1 ){
        for (size_t i(0); i< d1; ++i ){
            (*v)[i+j] *= vmulti[i];
        }
    }
    //for(size_t i(0); i< d1; ++i) {
    //    for(GSlice_iter<T> it(d1c(i,i)); it!=it.end(); ++it) *it *= vmulti[i];
    // }
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multid2()

template<class T >

Array4D< T > & Array4D< T >::multid2

(

const valarray< T > &

vmulti

)

Definition at line 2161 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d2, and Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                                                          {
    for (size_t k(0); k< dim(); k+=d1*d2 ) {
        for (size_t j(0); j< d2; ++j ) {
            for (size_t i(j*d1); i< (j+1)*d1; ++i ){
                (*v)[i+k] *= vmulti[j];
            }
        }
    }
    /*for(size_t j(0); j< d2; ++j) {
        for(GSlice_iter<T> it(d2c(j,j)); it!=it.end(); ++it) *it *= vmulti[j];
    }*/
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multid2d3d4()

template<class T >

Array4D< T > & Array4D< T >::multid2d3d4

(

const Array3D< T > &

vd2d3d4

)

Definition at line 2205 of file lib-array.h.

References Array3D< T >::array(), Array4D< T >::d1, Array4D< T >::d2, Array4D< T >::d3, and Array4D< T >::d4.

Referenced by Array4D_cmplx< T >::array().

                                                                              {
    for (size_t j(0); j < d2*d3*d4; ++j ){
        for (size_t i(j*d1); i< (j+1)*d1; ++i ){
            (*v)[i] *= vd2d3d4.array()[j];
        }
    }
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multid3()

template<class T >

Array4D< T > & Array4D< T >::multid3

(

const valarray< T > &

vmulti

)

Definition at line 2176 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d2, Array4D< T >::d3, and Array4D< T >::dim().

Referenced by Array4D_cmplx< T >::array().

                                                                          {
    for (size_t l(0); l< dim(); l+=d1*d2*d3) {
        for (size_t k(0); k< d3; ++k) {
            for (size_t i(k*d1*d2); i< (k+1)*d1*d2; ++i ){
                (*v)[i+l] *= vmulti[k];
            }
        }
    }
    //for(size_t k(0); k< d3; ++k) {
    //    for(GSlice_iter<T> it(d3c(k,k)); it!=it.end(); ++it) *it *= vmulti[k];
    //}
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multid4()

template<class T >

Array4D< T > & Array4D< T >::multid4

(

const valarray< T > &

vmulti

)

Definition at line 2191 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d2, Array4D< T >::d3, and Array4D< T >::d4.

Referenced by Array4D_cmplx< T >::array().

                                                                          {
    for (size_t k(0); k< d4; ++k) {
        for (size_t i(k*d1*d2*d3); i< (k+1)*d1*d2*d3; ++i ){
            (*v)[i] *= vmulti[k];
        }
    }
    //for(size_t l(0); l< d4; ++l) {
    //    for(GSlice_iter<T> it(d4c(l,l)); it!=it.end(); ++it) *it *= vmulti[l];
    //}
    return *this;
}

Here is the caller graph for this function:

operator()() [1/4]

template<class T >

T & Array4D< T >::operator() ( size_t  i, size_t  j, size_t  k, size_t  l  )

inline

Definition at line 1989 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, and Array4D< T >::v.

                                                                       {
    return (*v)[i+j*d1+k*d1d2+l*d1d2d3];
}

operator()() [2/4]

template<class T >

T Array4D< T >::operator() ( size_t  i, size_t  j, size_t  k, size_t  l  ) const

inline

Definition at line 1995 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, and Array4D< T >::v.

                                                                             {
    return (*v)[i+j*d1+k*d1d2+l*d1d2d3];
}

operator()() [3/4]

template<class T >

T & Array4D< T >::operator() ( size_t  i )

inline

Definition at line 2001 of file lib-array.h.

References Array4D< T >::v.

                                         {
    return (*v)[i];
}

operator()() [4/4]

template<class T >

T Array4D< T >::operator() ( size_t  i ) const

inline

Definition at line 2007 of file lib-array.h.

References Array4D< T >::v.

                                               {
    return (*v)[i];
}

operator*=() [1/2]

template<class T >

Array4D< T > & Array4D< T >::operator*=

(

const T &

d

)

Definition at line 2115 of file lib-array.h.

Referenced by Array4D_cmplx< T >::array().

                                                              {
    (*v) *=d;
    return *this;
}

Here is the caller graph for this function:

operator*=() [2/2]

template<class T >

Array4D< T > & Array4D< T >::operator*=

(

const Array4D< T > &

vmulti

)

Definition at line 2119 of file lib-array.h.

References Array4D< T >::array().

                                                                         {
    (*v) *= vmulti.array();
    return *this;
}

Here is the call graph for this function:

operator+=() [1/2]

template<class T >

Array4D< T > & Array4D< T >::operator+=

(

const T &

d

)

Definition at line 2125 of file lib-array.h.

Referenced by Array4D_cmplx< T >::array().

                                                              {
    (*v) +=d;
    return *this;
}

Here is the caller graph for this function:

operator+=() [2/2]

template<class T >

Array4D< T > & Array4D< T >::operator+=

(

const Array4D< T > &

vadd

)

Definition at line 2129 of file lib-array.h.

References Array4D< T >::array().

                                                                       {
    (*v) += vadd.array();
    return *this;
}

Here is the call graph for this function:

operator-=() [1/2]

template<class T >

Array4D< T > & Array4D< T >::operator-=

(

const T &

d

)

Definition at line 2135 of file lib-array.h.

Referenced by Array4D_cmplx< T >::array().

                                                              {
    (*v) -=d;
    return *this;
}

Here is the caller graph for this function:

operator-=() [2/2]

template<class T >

Array4D< T > & Array4D< T >::operator-=

(

const Array4D< T > &

vmin

)

Definition at line 2139 of file lib-array.h.

References Array4D< T >::array().

                                                                       {
    (*v) -= vmin.array();
    return *this;
}

Here is the call graph for this function:

operator=() [1/2]

template<class T >

Array4D< T > & Array4D< T >::operator=

(

const T &

d

)

Definition at line 2102 of file lib-array.h.

Referenced by Array4D_cmplx< T >::array().

                                                             {
    (*v) = d;
    return *this;
}

Here is the caller graph for this function:

operator=() [2/2]

template<class T >

Array4D< T > & Array4D< T >::operator=

(

const Array4D< T > &

other

)

Definition at line 2107 of file lib-array.h.

References Array4D< T >::array().

                                                                       {
    if (this != &other) {   //self-assignment
        (*v) = other.array();
    }
    return *this;
}

Here is the call graph for this function:

SubArray4D() [1/2]

template<class T >

GSlice_iter< T > Array4D< T >::SubArray4D ( size_t  st, size_t  nx, size_t  ny, size_t  nz, size_t  nw  )

inline

Definition at line 2081 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, and Array4D< T >::v.

Referenced by Array4D_cmplx< T >::array().

                                                                                                 {
    valarray<size_t> sz(4), str(4);
    str[3] = 1;   str[2] = d1;  str[1] = d1d2; str[0] = d1d2d3;
    sz[3]  = nx;  sz[2]  = ny;  sz[1]  = nz;   sz[0]  = nw;
    return GSlice_iter<T>(v,gslice(st,sz,str));
}

Here is the caller graph for this function:

SubArray4D() [2/2]

template<class T >

CGSlice_iter< T > Array4D< T >::SubArray4D ( size_t  st, size_t  nx, size_t  ny, size_t  nz, size_t  nw  ) const

inline

Definition at line 2090 of file lib-array.h.

References Array4D< T >::d1, Array4D< T >::d1d2, Array4D< T >::d1d2d3, and Array4D< T >::v.

                                                                                                        {
    valarray<size_t> sz(3), str(3);
    str[3] = 1;   str[2] = d1;  str[1] = d1d2; str[0] = d1d2d3;
    sz[3]  = nx;  sz[2]  = ny;  sz[1]  = nz;   sz[0]  = nw;
    return CGSlice_iter<T>(v,gslice(st,sz,str));
}

Field Documentation

d1

template<class T>

size_t Array4D< T >::d1

private

Definition at line 1886 of file lib-array.h.

Referenced by Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D< T >::d2c(), Array4D< T >::Dd2(), Array4D_cmplx< T >::dim1(), Array4D< T >::Filterd1(), Array4D< T >::multid1(), Array4D< T >::multid2(), Array4D< T >::multid2d3d4(), Array4D< T >::multid3(), Array4D< T >::multid4(), Array4D< T >::operator()(), and Array4D< T >::SubArray4D().

d1d2

template<class T>

size_t Array4D< T >::d1d2

private

Definition at line 1887 of file lib-array.h.

Referenced by Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D< T >::d2c(), Array4D< T >::d3c(), Array4D< T >::Dd3(), Array4D< T >::operator()(), and Array4D< T >::SubArray4D().

d1d2d3

template<class T>

size_t Array4D< T >::d1d2d3

private

Definition at line 1888 of file lib-array.h.

Referenced by Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D< T >::d2c(), Array4D< T >::d3c(), Array4D< T >::d4c(), Array4D< T >::Dd4(), Array4D< T >::operator()(), and Array4D< T >::SubArray4D().

d2

template<class T>

size_t Array4D< T >::d2

private

Definition at line 1886 of file lib-array.h.

Referenced by Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D_cmplx< T >::dim2(), Array4D< T >::Filterd1(), Array4D< T >::multid2(), Array4D< T >::multid2d3d4(), Array4D< T >::multid3(), and Array4D< T >::multid4().

d3

template<class T>

size_t Array4D< T >::d3

private

Definition at line 1886 of file lib-array.h.

Referenced by Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D< T >::d2c(), Array4D_cmplx< T >::dim3(), Array4D< T >::Filterd1(), Array4D< T >::multid2d3d4(), Array4D< T >::multid3(), and Array4D< T >::multid4().

d4

template<class T>

size_t Array4D< T >::d4

private

Definition at line 1886 of file lib-array.h.

Referenced by Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D< T >::d2c(), Array4D< T >::d3c(), Array4D_cmplx< T >::dim(), Array4D_cmplx< T >::dim4(), Array4D< T >::Filterd1(), Array4D< T >::multid2d3d4(), and Array4D< T >::multid4().

v

template<class T>

valarray<T>* Array4D< T >::v

private

Definition at line 1885 of file lib-array.h.

Referenced by Array4D_cmplx< T >::array(), Array4D< T >::Array4D(), Array4D< T >::d1c(), Array4D< T >::d2c(), Array4D< T >::d3c(), Array4D< T >::d4c(), Array4D< T >::operator()(), Array4D< T >::SubArray4D(), and Array4D< T >::~Array4D().

---

The documentation for this class was generated from the following file:

• /Users/archis/Dropbox/work/dev/oshun/oshun-OS/OSHUN/1d_cpp/source/lib-array.h