FreePOOMA  2.4.1
Public Types | Public Member Functions
Interval< Dim > Class Template Reference

Interval<N> is a domain representing a set of N numeric sequences, one for each dimension N. More...

#include <Interval.h>

Inheritance diagram for Interval< Dim >:
Inheritance graph
[legend]
Collaboration diagram for Interval< Dim >:
Collaboration graph
[legend]

List of all members.

Public Types

enum  { domain = DT_t::domain }
enum  { dimensions = DT_t::dimensions, sliceDimensions = DT_t::sliceDimensions }
enum  { loopAware = DT_t::loopAware }
enum  { singleValued = DT_t::singleValued }
enum  { unitStride = DT_t::unitStride }
enum  { wildcard = DT_t::wildcard }
typedef Base_t::iterator iterator
typedef Base_t::const_iterator const_iterator
 Iterator typedefs.
typedef Base_t::blockIterator blockIterator
typedef Base_t::const_blockIterator const_blockIterator
 Block iterator typedefs.
typedef DT_t::Element_t Element_t
typedef DT_t::Domain_t Domain_t
typedef DT_t::OneDomain_t OneDomain_t
typedef DT_t::BlockDomain_t BlockDomain_t
typedef DT_t::AskDomain_t AskDomain_t
typedef DT_t::AddResult_t AddResult_t
typedef DT_t::MultResult_t MultResult_t
typedef DT_t::Storage_t Storage_t

Public Member Functions

 Interval ()
 Interval (const Interval< Dim > &a)
 Interval (const Pooma::NoInit &a)
template<class T1 >
 Interval (const T1 &a)
template<class T1 , class T2 >
 Interval (const T1 &a, const T2 &b)
template<class T1 , class T2 , class T3 >
 Interval (const T1 &a, const T2 &b, const T3 &c)
template<class T1 , class T2 , class T3 , class T4 >
 Interval (const T1 &a, const T2 &b, const T3 &c, const T4 &d)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
 Interval (const T1 &a, const T2 &b, const T3 &c, const T4 &d, const T5 &e)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
 Interval (const T1 &a, const T2 &b, const T3 &c, const T4 &d, const T5 &e, const T6 &f)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
 Interval (const T1 &a, const T2 &b, const T3 &c, const T4 &d, const T5 &e, const T6 &f, const T7 &g)
 ~Interval ()
template<class T >
Interval< Dim > & operator= (const T &newdom)
Interval< Dim > & operator= (const Interval< Dim > &newdom)

Detailed Description

template<int Dim>
class Interval< Dim >

Interval<N> is a domain representing a set of N numeric sequences, one for each dimension N.

The sequences have endpoints [a,b], and a hard-coded stride of +1.

You can construct an Interval object using other domain objects. The constructors accept up to 7 domain objects of various types. Domain types are, for example, Loc, Range, Interval. int may also be used in the constructor for Interval; it acts like a Loc<1> object in that context. The domain arguments for the Interval constructors are combined together to form a single domain object with a dimension equal to the sum of the arguments' dimensions; for example, if you try to create an Interval<3> from a Loc<2> and an Interval<1>, e.g. Interval<3> a(Loc<2>(1,2), Interval<1>(3,5)); the Loc<2> and Interval arguments are combined into a (2+1=3) dimensional domain object, used to initialize the Interval<3>. The number of dimensions for the arguments must be <= number of dimensions of the newly constructed Interval.

For Interval<1>, the list of constructors is limited to just the following:

The default Interval<1> constructor initializes the Interval to be empty, that is, to have a length() of zero. In that case, the endpoints are undefined, as is any operation involving the Interval.

In addition to the constructors, Interval has the following public interface, similar to all domain objects. There are two classes of interface methods, one class which includes methods which any Interval<N> object has, regardless of dimensions, the other class which includes extra interface methods that are available for just Interval<1> objects.

Interval<N> interface:

Interval<1> interface: all of the methods for Interval<N> are also available for Interval<1>.

Interval inherits much of its activity from Domain<DomainTraits<Interval>>.

For the special case of Interval<1>, there is a specialization given after the general case that has different constructors (listed above).


Member Typedef Documentation

template<int Dim>
typedef Base_t::iterator Interval< Dim >::iterator
template<int Dim>
typedef Base_t::const_iterator Interval< Dim >::const_iterator

Iterator typedefs.

An N-dimensional iterator is a forward iterator, it works only with operator++ (it does not have operator--).

Reimplemented from Domain< Dim, DomainTraits< Interval< Dim > > >.

template<int Dim>
typedef Base_t::blockIterator Interval< Dim >::blockIterator
template<int Dim>
typedef Base_t::const_blockIterator Interval< Dim >::const_blockIterator

Block iterator typedefs.

All domains use the DomainBlockIterator class to iterate through blocks defined by the domain points. A block iterator is a forward iterator, it works only with operator++.

Reimplemented from Domain< Dim, DomainTraits< Interval< Dim > > >.

template<int Dim>
typedef DT_t::Element_t Interval< Dim >::Element_t
template<int Dim>
typedef DT_t::Domain_t Interval< Dim >::Domain_t
template<int Dim>
typedef DT_t::OneDomain_t Interval< Dim >::OneDomain_t
template<int Dim>
typedef DT_t::BlockDomain_t Interval< Dim >::BlockDomain_t
template<int Dim>
typedef DT_t::AskDomain_t Interval< Dim >::AskDomain_t
template<int Dim>
typedef DT_t::AddResult_t Interval< Dim >::AddResult_t
template<int Dim>
typedef DT_t::MultResult_t Interval< Dim >::MultResult_t
template<int Dim>
typedef DT_t::Storage_t Interval< Dim >::Storage_t

Member Enumeration Documentation

template<int Dim>
anonymous enum
Enumerator:
domain 
template<int Dim>
anonymous enum
Enumerator:
dimensions 
sliceDimensions 
template<int Dim>
anonymous enum
Enumerator:
loopAware 
template<int Dim>
anonymous enum
Enumerator:
singleValued 
template<int Dim>
anonymous enum
Enumerator:
unitStride 
template<int Dim>
anonymous enum
Enumerator:
wildcard 

Constructor & Destructor Documentation

template<int Dim>
Interval< Dim >::Interval ( ) [inline]
template<int Dim>
Interval< Dim >::Interval ( const Interval< Dim > &  a) [inline]
template<int Dim>
Interval< Dim >::Interval ( const Pooma::NoInit a) [inline]
template<int Dim>
template<class T1 >
Interval< Dim >::Interval ( const T1 &  a) [inline, explicit]
template<int Dim>
template<class T1 , class T2 >
Interval< Dim >::Interval ( const T1 &  a,
const T2 &  b 
) [inline]
template<int Dim>
template<class T1 , class T2 , class T3 >
Interval< Dim >::Interval ( const T1 &  a,
const T2 &  b,
const T3 &  c 
) [inline]
template<int Dim>
template<class T1 , class T2 , class T3 , class T4 >
Interval< Dim >::Interval ( const T1 &  a,
const T2 &  b,
const T3 &  c,
const T4 &  d 
) [inline]
template<int Dim>
template<class T1 , class T2 , class T3 , class T4 , class T5 >
Interval< Dim >::Interval ( const T1 &  a,
const T2 &  b,
const T3 &  c,
const T4 &  d,
const T5 &  e 
) [inline]
template<int Dim>
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
Interval< Dim >::Interval ( const T1 &  a,
const T2 &  b,
const T3 &  c,
const T4 &  d,
const T5 &  e,
const T6 &  f 
) [inline]
template<int Dim>
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
Interval< Dim >::Interval ( const T1 &  a,
const T2 &  b,
const T3 &  c,
const T4 &  d,
const T5 &  e,
const T6 &  f,
const T7 &  g 
) [inline]
template<int Dim>
Interval< Dim >::~Interval ( ) [inline]

Member Function Documentation

template<int Dim>
template<class T >
Interval<Dim>& Interval< Dim >::operator= ( const T &  newdom) [inline]
template<int Dim>
Interval<Dim>& Interval< Dim >::operator= ( const Interval< Dim > &  newdom) [inline]

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