npstat::BoxND< Numeric > Struct Template Reference

#include <BoxND.h>

Inheritance diagram for npstat::BoxND< Numeric >:

Public Member Functions
	BoxND ()
	BoxND (const unsigned long dim)
	BoxND (const unsigned long dim, const Interval< Numeric > &v)
template<typename Num2 >
	BoxND (const std::vector< Num2 > &limits)
template<typename Num2 >
	BoxND (const BoxND< Num2 > &r)
template<typename Num2 >
BoxND &	copyFrom (const BoxND< Num2 > &r)
template<typename Num2 >
BoxND< Numeric > &	copyFrom (const BoxND< Num2 > &r)
unsigned long	dim () const
BoxND &	expand (double r)
void	getMidpoint (Numeric *coord, unsigned long coordLen) const
BoxND &	moveToOrigin ()
template<typename Num2 >
BoxND< Numeric > &	operator+= (const std::vector< Num2 > &shifts)
template<typename Num2 >
BoxND< Numeric > &	operator-= (const std::vector< Num2 > &shifts)
double	overlapFraction (const BoxND &r) const
Numeric	overlapVolume (const BoxND &r) const
template<typename Num2 >
BoxND< Numeric > &	shift (const Num2 *shifts, const unsigned long shiftsLen)
Numeric	volume () const
template<typename Num2 >
bool	isInsideLower (const Num2 *coord, unsigned long coordLen) const
template<typename Num2 >
bool	isInsideUpper (const Num2 *coord, unsigned long coordLen) const
template<typename Num2 >
bool	isInsideWithBounds (const Num2 *coord, unsigned long coordLen) const
template<typename Num2 >
bool	isInside (const Num2 *coord, unsigned long coordLen) const
BoxND &	operator*= (double r)
BoxND &	operator/= (double r)
BoxND &	operator*= (const std::vector< double > &scales)
BoxND &	operator/= (const std::vector< double > &scales)
BoxND &	expand (const std::vector< double > &scales)
BoxND &	expand (const double *scales, unsigned long lenScales)
template<typename Num2 >
BoxND &	operator+= (const std::vector< Num2 > &shifts)
template<typename Num2 >
BoxND &	operator-= (const std::vector< Num2 > &shifts)
template<typename Num2 >
BoxND &	shift (const Num2 *shifts, unsigned long lenShifts)
gs::ClassId	classId () const
bool	write (std::ostream &of) const

Static Public Member Functions
static BoxND	allSpace (unsigned long ndim)
static const char *	classname ()
static void	restore (const gs::ClassId &id, std::istream &in, BoxND *box)
static BoxND	sizeTwoBox (unsigned long ndim)
static BoxND	unitBox (unsigned long ndim)
static unsigned	version ()

Detailed Description

template<typename Numeric>
struct npstat::BoxND< Numeric >

Class to represent rectangles, boxes, and hyperboxes

Definition at line 24 of file BoxND.h.

Constructor & Destructor Documentation

BoxND() [1/5]

template<typename Numeric>

npstat::BoxND< Numeric >::BoxND ( )

inline

Default constructor makes a 0-dimensional box

Definition at line 26 of file BoxND.h.

{}

BoxND() [2/5]

template<typename Numeric>

npstat::BoxND< Numeric >::BoxND ( const unsigned long  dim )

inlineexplicit

Interval in each dimension is made by its default constructor

Definition at line 29 of file BoxND.h.

: std::vector<Interval<Numeric> >(dim) {}

BoxND() [3/5]

template<typename Numeric>

npstat::BoxND< Numeric >::BoxND ( const unsigned long  dim, const Interval< Numeric > &  v  )

inline

Use the same interval in each dimension

Definition at line 32 of file BoxND.h.

: std::vector<Interval<Numeric> >(dim, v) {}

BoxND() [4/5]

template<typename Numeric >

template<typename Num2 >

npstat::BoxND< Numeric >::BoxND ( const std::vector< Num2 > &  limits )

explicit

Constructor where one of the limits will be 0 and the other will be generated from the given vector (which also determines the dimensionality)

Definition at line 189 of file BoxND.h.

                                                     {
    const unsigned long dim = limits.size();
    if (dim) {
      this->reserve(dim);
      Numeric zero = Numeric();
      for (unsigned long i = 0; i < dim; ++i) {
        const Numeric value(static_cast<Numeric>(limits[i]));
        if (value >= zero)
          this->push_back(Interval<Numeric>(zero, value));
        else
          this->push_back(Interval<Numeric>(value, zero));
      }
    }
  }

BoxND() [5/5]

template<typename Numeric >

template<typename Num2 >

npstat::BoxND< Numeric >::BoxND ( const BoxND< Num2 > &  r )

explicit

Converting constructor

Definition at line 176 of file BoxND.h.

                                            {
    const unsigned long dim = r.size();
    if (dim) {
      this->reserve(dim);
      for (unsigned long i = 0; i < dim; ++i) {
        const Interval<Num2>& ri(r[i]);
        this->push_back(Interval<Numeric>(ri.min(), ri.max()));
      }
    }
  }

Member Function Documentation

allSpace()

template<typename Numeric >

BoxND< Numeric > npstat::BoxND< Numeric >::allSpace ( unsigned long  ndim )

static

Box with all upper limits set to maximum possible Numeric number and with lower limits set to negative maximum (this will not work with unsigned long types)

Definition at line 451 of file BoxND.h.

                                                                  {
    const Numeric maxval = std::numeric_limits<Numeric>::max();
    Interval<Numeric> i(static_cast<Numeric>(0), maxval);
    if (!gs::IOIsUnsigned<Numeric>::value)
      i.setMin(-maxval);
    return BoxND<Numeric>(ndim, i);
  }

classId()

template<typename Numeric>

gs::ClassId npstat::BoxND< Numeric >::classId ( ) const

inline

Methods related to I/O

Definition at line 147 of file BoxND.h.

{ return gs::ClassId(*this); }

classname()

template<typename Numeric >

const char * npstat::BoxND< Numeric >::classname ( )

static

Definition at line 460 of file BoxND.h.

                                        {
    static const std::string na(gs::template_class_name<Numeric>("npstat::BoxND"));
    return na.c_str();
  }

copyFrom() [1/2]

template<typename Numeric>

template<typename Num2 >

BoxND& npstat::BoxND< Numeric >::copyFrom

(

const BoxND< Num2 > &

r

)

Get the data from a box of a different type. This method works essentially as a converting assignment operator.

copyFrom() [2/2]

template<typename Numeric>

template<typename Num2 >

BoxND<Numeric>& npstat::BoxND< Numeric >::copyFrom

(

const BoxND< Num2 > &

r

)

Definition at line 206 of file BoxND.h.

                                                               {
    if ((void*)this == (void*)(&r))
      return *this;
    const unsigned long n = r.size();
    this->clear();
    this->reserve(n);
    for (unsigned long i = 0; i < n; ++i) {
      const Interval<Num2>& ir(r[i]);
      this->push_back(Interval<Numeric>(ir.min(), ir.max()));
    }
    return *this;
  }

dim()

template<typename Numeric>

unsigned long npstat::BoxND< Numeric >::dim ( ) const

inline

Box dimensionality

Definition at line 54 of file BoxND.h.

Referenced by npstat::ArrayND< Numeric >::processSubrange().

{ return this->size(); }

expand() [1/3]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::expand

(

double

r

)

Scaling of all limits by a constant in such a way that the midpoint remains unchanged

Definition at line 335 of file BoxND.h.

                                                       {
    const unsigned long mydim = this->size();
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i].expand(r);
    return *this;
  }

expand() [2/3]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::expand

(

const std::vector< double > &

scales

)

Scaling of all limits in such a way that the midpoint remains unchanged, using a different scaling factor in each dimension

Definition at line 355 of file BoxND.h.

                                                                        {
    const unsigned long mydim = this->size();
    if (mydim != scales.size())
      throw npstat::NpstatInvalidArgument("In npstat::BoxND::expand: incompatible argument dimensionality");
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i].expand(scales[i]);
    return *this;
  }

expand() [3/3]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::expand	(	const double *	scales,
		unsigned long	lenScales
	)

Definition at line 365 of file BoxND.h.

                                                                                            {
    const unsigned long mydim = this->size();
    if (mydim != lenScales)
      throw npstat::NpstatInvalidArgument("In npstat::BoxND::expand: incompatible argument dimensionality");
    if (mydim) {
      assert(scales);
      for (unsigned long i = 0; i < mydim; ++i)
        (*this)[i].expand(scales[i]);
    }
    return *this;
  }

getMidpoint()

template<typename Numeric>

void npstat::BoxND< Numeric >::getMidpoint	(	Numeric *	coord,
		unsigned long	coordLen
	)		const

Midpoint for every coordinate. The size of the "coord" array should be at least as large as the box dimensionality.

Definition at line 253 of file BoxND.h.

                                                                                     {
    const unsigned long mydim = this->size();
    if (coordLen < mydim)
      throw npstat::NpstatInvalidArgument("In npstat::BoxND::getMidpoint: insufficient output buffer length");
    if (mydim) {
      assert(coord);
      for (unsigned long i = 0U; i < mydim; ++i)
        coord[i] = (*this)[i].midpoint();
    }
  }

isInside()

template<typename Numeric >

template<typename Num2 >

bool npstat::BoxND< Numeric >::isInside	(	const Num2 *	coord,
		unsigned long	coordLen
	)		const

Definition at line 308 of file BoxND.h.

                                                                                      {
    if (coordLen != this->size())
      throw npstat::NpstatInvalidArgument("In npstat::BoxND::isInside: incompatible point dimensionality");
    const Interval<Numeric>* myptr = &(*this)[0];
    for (unsigned long i = 0; i < coordLen; ++i)
      if (!myptr[i].isInside(coords[i]))
        return false;
    return true;
  }

isInsideLower()

template<typename Numeric >

template<typename Num2 >

bool npstat::BoxND< Numeric >::isInsideLower	(	const Num2 *	coord,
		unsigned long	coordLen
	)		const

This method return "true" if the corresponding function of the Interval returns "true" for every coordinate. There must be an automatic conversion from Num2 type into Numeric.

Definition at line 266 of file BoxND.h.

                                                                                           {
    if (coordLen != this->size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::isInsideLower: "
          "incompatible point dimensionality");
    const Interval<Numeric>* myptr = &(*this)[0];
    for (unsigned long i = 0; i < coordLen; ++i)
      if (!myptr[i].isInsideLower(coords[i]))
        return false;
    return true;
  }

isInsideUpper()

template<typename Numeric >

template<typename Num2 >

bool npstat::BoxND< Numeric >::isInsideUpper	(	const Num2 *	coord,
		unsigned long	coordLen
	)		const

Definition at line 280 of file BoxND.h.

                                                                                           {
    if (coordLen != this->size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::isInsideUpper: "
          "incompatible point dimensionality");
    const Interval<Numeric>* myptr = &(*this)[0];
    for (unsigned long i = 0; i < coordLen; ++i)
      if (!myptr[i].isInsideUpper(coords[i]))
        return false;
    return true;
  }

isInsideWithBounds()

template<typename Numeric >

template<typename Num2 >

bool npstat::BoxND< Numeric >::isInsideWithBounds	(	const Num2 *	coord,
		unsigned long	coordLen
	)		const

Definition at line 294 of file BoxND.h.

                                                                                                {
    if (coordLen != this->size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::isInsideWithBounds: "
          "incompatible point dimensionality");
    const Interval<Numeric>* myptr = &(*this)[0];
    for (unsigned long i = 0; i < coordLen; ++i)
      if (!myptr[i].isInsideWithBounds(coords[i]))
        return false;
    return true;
  }

moveToOrigin()

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::moveToOrigin

(

)

Moving this object so that the midpoint is (0, 0, ..., 0)

Definition at line 327 of file BoxND.h.

                                               {
    const unsigned long mydim = this->size();
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i].moveMidpointTo0();
    return *this;
  }

operator*=() [1/2]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::operator*=

(

double

r

)

Scaling of all limits by a constant

Definition at line 319 of file BoxND.h.

                                                           {
    const unsigned long mydim = this->size();
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i] *= r;
    return *this;
  }

operator*=() [2/2]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::operator*=

(

const std::vector< double > &

scales

)

Scaling by a different constant in each dimension

Definition at line 343 of file BoxND.h.

                                                                            {
    const unsigned long mydim = this->size();
    if (mydim != scales.size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::operator*=: "
          "incompatible argument dimensionality");
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i] *= scales[i];
    return *this;
  }

operator+=() [1/2]

template<typename Numeric>

template<typename Num2 >

BoxND& npstat::BoxND< Numeric >::operator+=

(

const std::vector< Num2 > &

shifts

)

Shifting this object

operator+=() [2/2]

template<typename Numeric>

template<typename Num2 >

BoxND<Numeric>& npstat::BoxND< Numeric >::operator+=

(

const std::vector< Num2 > &

shifts

)

Definition at line 399 of file BoxND.h.

                                                                          {
    const unsigned long mydim = this->size();
    if (mydim != shifts.size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::operator+=: "
          "incompatible argument dimensionality");
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i] += static_cast<Numeric>(shifts[i]);
    return *this;
  }

operator-=() [1/2]

template<typename Numeric>

template<typename Num2 >

BoxND& npstat::BoxND< Numeric >::operator-=

(

const std::vector< Num2 > &

shifts

)

operator-=() [2/2]

template<typename Numeric>

template<typename Num2 >

BoxND<Numeric>& npstat::BoxND< Numeric >::operator-=

(

const std::vector< Num2 > &

shifts

)

Definition at line 426 of file BoxND.h.

                                                                          {
    const unsigned long mydim = this->size();
    if (mydim != shifts.size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::operator-=: "
          "incompatible argument dimensionality");
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i] -= static_cast<Numeric>(shifts[i]);
    return *this;
  }

operator/=() [1/2]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::operator/=

(

double

r

)

Definition at line 378 of file BoxND.h.

                                                           {
    const unsigned long mydim = this->size();
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i] /= r;
    return *this;
  }

operator/=() [2/2]

template<typename Numeric >

BoxND< Numeric > & npstat::BoxND< Numeric >::operator/=

(

const std::vector< double > &

scales

)

Definition at line 386 of file BoxND.h.

                                                                            {
    const unsigned long mydim = this->size();
    if (mydim != scales.size())
      throw npstat::NpstatInvalidArgument(
          "In npstat::BoxND::operator/=: "
          "incompatible argument dimensionality");
    for (unsigned long i = 0; i < mydim; ++i)
      (*this)[i] /= scales[i];
    return *this;
  }

overlapFraction()

template<typename Numeric >

double npstat::BoxND< Numeric >::overlapFraction

(

const BoxND< Numeric > &

r

)

const

A faster way to calculate overlapVolume(r)/volume()

Definition at line 241 of file BoxND.h.

                                                             {
    const unsigned long mydim = this->size();
    if (mydim == r.size()) {
      double f = 1.0;
      for (unsigned long i = 0U; i < mydim; ++i)
        f *= (*this)[i].overlapFraction(r[i]);
      return f;
    } else
      return 0.0;
  }

overlapVolume()

template<typename Numeric >

Numeric npstat::BoxND< Numeric >::overlapVolume

(

const BoxND< Numeric > &

r

)

const

Overlap volume with another box

Definition at line 229 of file BoxND.h.

                                                            {
    const unsigned long mydim = this->size();
    if (mydim == r.size()) {
      Numeric v(static_cast<Numeric>(1));
      for (unsigned long i = 0U; i < mydim; ++i)
        v *= (*this)[i].overlapLength(r[i]);
      return v;
    } else
      return static_cast<Numeric>(0);
  }

restore()

template<typename Numeric >

void npstat::BoxND< Numeric >::restore ( const gs::ClassId &  id, std::istream &  in, BoxND< Numeric > *  box  )

static

Definition at line 478 of file BoxND.h.

                                                                            {
    static const gs::ClassId current(gs::ClassId::makeId<BoxND<Numeric> >());
    current.ensureSameId(id);

    std::vector<Numeric> limits;
    gs::restore_item(in, &limits);
    if (in.fail())
      throw gs::IOReadFailure("In npstat::BoxND::restore: input stream failure");
    const unsigned long nlimits = limits.size();
    if (nlimits % 2UL)
      throw gs::IOInvalidData("In npstat::BoxND::restore: bad limits");
    assert(b);
    b->clear();
    b->reserve(nlimits / 2UL);
    for (unsigned long i = 0; i < nlimits / 2UL; ++i)
      b->push_back(npstat::Interval<Numeric>(limits[2U * i], limits[2U * i + 1U]));
  }

shift() [1/2]

template<typename Numeric>

template<typename Num2 >

BoxND& npstat::BoxND< Numeric >::shift	(	const Num2 *	shifts,
		unsigned long	lenShifts
	)

shift() [2/2]

template<typename Numeric>

template<typename Num2 >

BoxND<Numeric>& npstat::BoxND< Numeric >::shift	(	const Num2 *	shifts,
		const unsigned long	shiftsLen
	)

Definition at line 412 of file BoxND.h.

                                                                                         {
    const unsigned long mydim = this->size();
    if (mydim != shiftsLen)
      throw npstat::NpstatInvalidArgument("In npstat::BoxND::shift: incompatible argument dimensionality");
    if (mydim) {
      assert(shifts);
      for (unsigned long i = 0; i < mydim; ++i)
        (*this)[i] += static_cast<Numeric>(shifts[i]);
    }
    return *this;
  }

sizeTwoBox()

template<typename Numeric >

BoxND< Numeric > npstat::BoxND< Numeric >::sizeTwoBox ( unsigned long  ndim )

static

Box with lower limit -1 and upper limit 1 in all coordinates. Note that this will produce nonsense in case the Numeric type is unsigned.

Definition at line 444 of file BoxND.h.

                                                                    {
    const Numeric one = static_cast<Numeric>(1);
    Interval<Numeric> i(-one, one);
    return BoxND<Numeric>(ndim, i);
  }

unitBox()

template<typename Numeric >

BoxND< Numeric > npstat::BoxND< Numeric >::unitBox ( unsigned long  ndim )

static

Box with lower limit 0 and upper limit 1 in all coordinates

Definition at line 438 of file BoxND.h.

                                                                 {
    Interval<Numeric> unit(static_cast<Numeric>(0), static_cast<Numeric>(1));
    return BoxND<Numeric>(ndim, unit);
  }

version()

template<typename Numeric>

static unsigned npstat::BoxND< Numeric >::version ( )

inlinestatic

Definition at line 152 of file BoxND.h.

Referenced by validation.Sample::datasetpattern(), and validation.Sample::filename().

{ return 1; }

volume()

template<typename Numeric >

Numeric npstat::BoxND< Numeric >::volume

(

void

)

const

Box volume

Definition at line 220 of file BoxND.h.

                                       {
    Numeric v(static_cast<Numeric>(1));
    const unsigned long mydim = this->size();
    for (unsigned long i = 0U; i < mydim; ++i)
      v *= (*this)[i].length();
    return v;
  }

write()

template<typename Numeric >

bool npstat::BoxND< Numeric >::write

(

std::ostream &

of

)

const

Definition at line 466 of file BoxND.h.

                                                 {
    const unsigned long mydim = this->size();
    std::vector<Numeric> limits;
    limits.reserve(2UL * mydim);
    for (unsigned long i = 0; i < mydim; ++i) {
      limits.push_back((*this)[i].min());
      limits.push_back((*this)[i].max());
    }
    return gs::write_item(of, limits);
  }