SSAGES::GridBase< T > Class Template Reference

Base class for Grids. More...

#include <GridBase.h>

Inheritance diagram for SSAGES::GridBase< T >:

Public Member Functions
size_t	GetDimension () const
	Get the dimension. More...
const std::vector< int > &	GetNumPoints () const
	Get the number of points for all dimensions. More...
int	GetNumPoints (size_t dim) const
	Get the number of points for a specific dimension. More...
const std::vector< double > &	GetLower () const
	Return the lower edges of the Grid. More...
double	GetLower (size_t dim) const
	Get the lower edge for a specific dimension. More...
const std::vector< double > &	GetUpper () const
	Return the upper edges of the Grid. More...
double	GetUpper (size_t dim) const
	Get the upper edge for a specific dimension. More...
const std::vector< bool > &	GetPeriodic () const
	Return the periodicity of the Grid. More...
bool	GetPeriodic (size_t dim) const
	Get the periodicity in a specific dimension. More...
size_t	size () const
	Get the size of the internal storage vector. More...
T *	data ()
	Get pointer to the internal data storage vector. More...
T const *	data () const
	Get pointer to const of the internal data storage vector. More...
std::vector< int >	GetIndices (const std::vector< double > &x) const
	Return the Grid indices for a given point. More...
double	GetInterpolated (const std::vector< double > &x)
	Return linear interpolation on a coordinate. More...
int	GetIndex (double x) const
	Return the Grid index for a one-dimensional grid. More...
std::vector< double >	GetCoordinates (const std::vector< int > &indices)
	Return coordinates of the grid center points. More...
double	GetCoordinate (int index)
	Return center point of 1d-grid. More...
const T &	at (const std::vector< int > &indices) const
	Access Grid element read-only. More...
T &	at (const std::vector< int > &indices)
	Access Grid element read/write. More...
template<typename R >
const T &	at (std::initializer_list< R > &&x) const
	Const access of Grid element via initializer list. More...
template<typename R >
T &	at (std::initializer_list< R > &&x)
	Access Grid element via initializer list. More...
const T &	at (int index) const
	Access 1d Grid by index, read-only. More...
T &	at (int index)
	Access 1d Grid by index, read-write. More...
const T &	at (const std::vector< double > &x) const
	Access Grid element pertaining to a specific point – read-only. More...
T &	at (const std::vector< double > &x)
	Access Grid element pertaining to a specific point – read/write. More...
const T &	at (double x) const
	Access 1d-Grid by point - read-only. More...
T &	at (double x)
	Access 1d-Grid by point - read-write. More...
const T &	operator[] (const std::vector< int > &indices) const
	Access Grid element per [] read-only. More...
T &	operator[] (const std::vector< int > &indices)
	Access Grid element per [] read-write. More...
template<typename R >
const T &	operator[] (std::initializer_list< R > &&x) const
	Const access of Grid element via initializer list. More...
template<typename R >
T &	operator[] (std::initializer_list< R > &&x)
	Access Grid element via initializer list. More...
const T &	operator[] (int index) const
	Access 1d-Grid per [] operator, read-only. More...
T &	operator[] (int index)
	Access 1d-Grid per [] operator, read-write. More...
const T &	operator[] (const std::vector< double > &x) const
	Access Grid element pertaining to a specific point per [] read-only. More...
T &	operator[] (const std::vector< double > &x)
	Access Grid element pertaining to a specific point per [] read-write. More...
const T &	operator[] (double x) const
	Access 1d-Grid via specific point, read-only. More...
T &	operator[] (double x)
	Access 1d-Grid via specific point, read-write. More...

Protected Member Functions
std::vector< int >	wrapIndices (const std::vector< int > &indices) const
	Wrap the index around periodic boundaries.
virtual size_t	mapTo1d (const std::vector< int > &indices) const =0
	This function needs to be implemented by child classes. More...
	GridBase (std::vector< int > numPoints, std::vector< double > lower, std::vector< double > upper, std::vector< bool > isPeriodic)
	Constructor. More...

Protected Attributes
std::vector< T >	data_
	Internal storage of the data.
size_t	dimension_
	Dimension of the grid.
std::vector< int >	numPoints_
	Number of points in each dimension.
std::pair< std::vector< double > , std::vector< double > >	edges_
	Edges of the Grid in each dimension.
std::vector< bool >	isPeriodic_
	Periodicity of the Grid.

Detailed Description

template<typename T>
class SSAGES::GridBase< T >

Base class for Grids.

Template Parameters

Type	of data stored on the grid

Base class for all grids. Currently, these are 'Grid' and 'Histogram'.

Definition at line 38 of file GridBase.h.

Constructor & Destructor Documentation

template<typename T>

SSAGES::GridBase< T >::GridBase ( std::vector< int >  numPoints, std::vector< double >  lower, std::vector< double >  upper, std::vector< bool >  isPeriodic  )

inlineprotected

Constructor.

Parameters

numPoints	Number of grid points in each dimension.
lower	Lower edges of the grid.
upper	Upper edges of the grid.
isPeriodic	Bools specifying the periodicity in the respective dimension.

The constructor is protected by design. This makes sure that only child classes of GridBase are constructed.

Definition at line 97 of file GridBase.h.

        : dimension_(numPoints.size()),
          numPoints_(numPoints),
          edges_(std::pair< std::vector<double>, std::vector<double> >(lower, upper)),
          isPeriodic_(isPeriodic)
    {
        // Check that vector sizes are correct
        if (edges_.first.size() != dimension_ ||
            edges_.second.size() != dimension_) {
            throw std::invalid_argument("Size of vector containing upper or "
                "lower edges, does not match size of vector containing "
                "number of grid points.");
        }
        if (isPeriodic_.size() == 0) {
            // Default: Non-periodic in all dimensions
            isPeriodic.resize(dimension_, false);
        } else if (isPeriodic_.size() != dimension_) {
            throw std::invalid_argument("Size of vector isPeriodic does not "
                    "match size of vector containing number of grid points.");
        }
        
    }

Member Function Documentation

template<typename T>

const T& SSAGES::GridBase< T >::at ( const std::vector< int > &  indices ) const

inline

Access Grid element read-only.

Parameters

indices

Vector of integers specifying the grid point.

Returns

const reference of the value stored at the given grid point.

In non-periodic dimensions, the index needs to be in the interval [-1, numPoints]. Grid::at(-1) accessed the underflow bin, Grid::at(numPoints) accesses the overflow bin.

In periodic dimensions, the index may take any integer value and will be mapped back to the interval [0, numPoints-1]. Thus, Grid::at(-1) will access the same value as Grid::at(numPoints-1).

Definition at line 452 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::at(), SSAGES::GridBase< int >::GetCoordinate(), SSAGES::GridBase< int >::GetIndex(), SSAGES::GridBase< int >::GetInterpolated(), and SSAGES::GridBase< int >::operator[]().

    {
        // Check that indices are in bound.
        if (indices.size() != GetDimension()) {
            throw std::invalid_argument("Dimension of indices does not match "
                    "dimension of the grid.");
        }

        return data_.at(mapTo1d(indices));
    }

Here is the caller graph for this function:

template<typename T>

T& SSAGES::GridBase< T >::at ( const std::vector< int > &  indices )

inline

Access Grid element read/write.

Parameters

indices

Vector of integers specifying the grid point.

Returns

Reference to value at the specified grid point.

Definition at line 468 of file GridBase.h.

    {
        return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(indices));
    }

template<typename T>

template<typename R >

const T& SSAGES::GridBase< T >::at ( std::initializer_list< R > &&  x ) const

inline

Const access of Grid element via initializer list.

Template Parameters

R	Datatype in the initializer list

Parameters

x	initializer list

Returns

Const reference to value at the specified point.

This function avoids abiguity if at() is called with a brace-enclosed initializer list. The template parameter makes sure that this function can be called with either ints, specifying a grid point, or doubles, specifying coordinates in space, inside the initializer list.

Definition at line 485 of file GridBase.h.

    {
        return at(static_cast<std::vector<R> >(x));
    }

template<typename T>

template<typename R >

T& SSAGES::GridBase< T >::at ( std::initializer_list< R > &&  x )

inline

Access Grid element via initializer list.

Template Parameters

R	Datatype in the initializer list

Parameters

x	initializer list

Returns

Reference to value at the specified point.

This function avoids abiguity if at() is called with a brace-enclosed initializer list. The template parameter makes sure that this function can be called with either ints, specifying a grid point, or doubles, specifying coordinates in space, inside the initializer list.

Definition at line 502 of file GridBase.h.

    {
        return at(static_cast<std::vector<R> >(x));
    }

template<typename T>

const T& SSAGES::GridBase< T >::at ( int  index ) const

inline

Access 1d Grid by index, read-only.

Parameters

index

Index specifying the grid point.

Returns

Const reference of value at the given index.

Note

This function can only be used for 1d-Grids.

Definition at line 514 of file GridBase.h.

    {
        if (dimension_ != 1) {
            throw std::invalid_argument("Only 1d-Grids can be accessed with a "
                    "single integer as the index.");
        }
        return at({index});
    }

template<typename T>

T& SSAGES::GridBase< T >::at ( int  index )

inline

Access 1d Grid by index, read-write.

Parameters

index

Index specifying the grid point.

Returns

Reference of value at the given grid point.

Note

This function can only be used for 1d-Grids.

Definition at line 530 of file GridBase.h.

    {
        return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(index));
    }

template<typename T>

const T& SSAGES::GridBase< T >::at ( const std::vector< double > &  x ) const

inline

Access Grid element pertaining to a specific point – read-only.

Parameters

x	Vector of doubles specifying a point.

Returns

Const reference of the value at the given coordinates.

This function is provided for convenience. It is identical to GridBase::at(GridBase::GetIndices(x)).

Definition at line 543 of file GridBase.h.

    {
        return at(GetIndices(x));
    }

template<typename T>

T& SSAGES::GridBase< T >::at ( const std::vector< double > &  x )

inline

Access Grid element pertaining to a specific point – read/write.

Parameters

x	Vector of doubles specifying a point.

Returns

Reference to the value at the given coordinates.

This function is provided for convenience. It is identical to GridBase::at(GridBase::GetIndices(x)).

Definition at line 556 of file GridBase.h.

    {
        return at(GetIndices(x));
    }

template<typename T>

const T& SSAGES::GridBase< T >::at ( double  x ) const

inline

Access 1d-Grid by point - read-only.

Parameters

x	Access grid point pertaining to this value.

Returns

Const reference to the value pertaining to the specified coordinate.

Note

This function can only be used for 1d-Grids.

Definition at line 569 of file GridBase.h.

    {
        if (dimension_ != 1) {
            throw std::invalid_argument("Only 1d-Grids can be accessed with a "
                    "single float as the specified point.");
        }
        return at({x});
    }

template<typename T>

T& SSAGES::GridBase< T >::at ( double  x )

inline

Access 1d-Grid by point - read-write.

Parameters

x	Access grid point pertaining to this value.

Returns

Reference to the value pertaining to the specified coordinate.

Note

This function can only be used for 1d Grids.

Definition at line 585 of file GridBase.h.

    {
        return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(x));
    }

template<typename T>

T* SSAGES::GridBase< T >::data ( )

inline

Get pointer to the internal data storage vector.

Returns

Pointer to data in the internal storage vector.

It is discouraged to directly access the internal data storage. It might, however be necessary. For example when communicating the data over MPI.

Definition at line 262 of file GridBase.h.

Referenced by SSAGES::Basis::UpdateBias().

    {
        return data_.data();
    }

Here is the caller graph for this function:

template<typename T>

T const* SSAGES::GridBase< T >::data ( ) const

inline

Get pointer to const of the internal data storage vector.

Returns

Const pointer to data in the internal storage vector.

It is discouraged to directly access the internal data storage. It might, however be necessary. For example when communicating data over MPI.

Definition at line 274 of file GridBase.h.

    {
        return data_.data();
    }

template<typename T>

double SSAGES::GridBase< T >::GetCoordinate ( int  index )

inline

Return center point of 1d-grid.

Parameters

index

Index of the 1d grid.

Returns

Coordinate in real/CV space.

Note

This function is only available for 1d grids.

Definition at line 434 of file GridBase.h.

    {
        return GetCoordinates({index}).at(0);
    }

template<typename T>

std::vector<double> SSAGES::GridBase< T >::GetCoordinates ( const std::vector< int > &  indices )

inline

Return coordinates of the grid center points.

Parameters

indices

Grid indices specifying a grid point.

Returns

Vector of double specifying the position of the grid point.

The grid is a discretization of real or cv space. Thus, each grid point is associated with an interval of the underlying space. This function returns the center point of this interval.

Definition at line 409 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::GetCoordinate(), and SSAGES::GridBase< int >::GetInterpolated().

    {
        if (indices.size() != dimension_) {
            throw std::invalid_argument(
                    "Grid indices specified for GetCoordinates() do not have "
                    "the same dimensionality as the grid.");
        }

        std::vector<double> v(dimension_);

        for (size_t i = 0; i < dimension_; ++i) {
            double spacing = (GetUpper(i) - GetLower(i)) / GetNumPoints(i);
            v.at(i) = GetLower(i) + (indices[i] + 0.5)*spacing;
        }

        return v;
    }

Here is the caller graph for this function:

template<typename T>

size_t SSAGES::GridBase< T >::GetDimension ( ) const

inline

Get the dimension.

Returns

Dimensionality of the grid.

Definition at line 128 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::at(), SSAGES::GridBase< int >::GetLower(), SSAGES::GridBase< int >::GetNumPoints(), SSAGES::GridBase< int >::GetPeriodic(), and SSAGES::GridBase< int >::GetUpper().

    {
        return dimension_;
    }

Here is the caller graph for this function:

template<typename T>

int SSAGES::GridBase< T >::GetIndex ( double  x ) const

inline

Return the Grid index for a one-dimensional grid.

Parameters

x	Point in space.

Returns

Grid index to which the point pertains.

Return the Grid index pertaining to the given point in space. This function is for convenience when accessing 1d-Grids. For higher-dimensional grids, x needs to be a vector of doubles.

Definition at line 391 of file GridBase.h.

    {
        if (dimension_ != 1) {
            throw std::invalid_argument("1d Grid index can only be accessed for "
                   "1d-Grids can be accessed with a.");
        }
        return GetIndices({x}).at(0);
    }

template<typename T>

std::vector<int> SSAGES::GridBase< T >::GetIndices ( const std::vector< double > &  x ) const

inline

Return the Grid indices for a given point.

Parameters

x	Point in space.

Returns

Indices of the grid point to which the point in space pertains.

The grid discretizes the continuous space. For a given point in this continuous space, this function will return the indices of the grid point covering the point in space.

If the grid is non-periodic in a given dimension and x is lower than the lower edge in this dimension, the function will return -1, the index of the underflow bin. Similarly, it will return numPoints, the index of the overflow bin, if x is larger than the upper edge.

In periodic dimensions, the index can take any integer value and will be wrapped to the interval [0, numPoints).

Definition at line 296 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::at(), SSAGES::GridBase< int >::GetIndex(), and SSAGES::GridBase< int >::GetInterpolated().

    {
        // Check that input vector has the correct dimensionality
        if (x.size() != dimension_) {
            throw std::invalid_argument("Specified point has a larger "
                    "dimensionality than the grid.");
        }

        std::vector<int> indices(dimension_);
        for (size_t i = 0; i < dimension_; ++i) {
            double xpos = x.at(i);
            if (!GetPeriodic(i)) {
                if (xpos < GetLower(i)) {
                    indices.at(i) = -1;
                    continue;
                } else if (xpos > GetUpper(i)) {
                    indices.at(i) = GetNumPoints(i);
                    continue;
                }
            }

            // To make sure, the value is rounded in the correct direction.
            double spacing = (GetUpper(i) - GetLower(i)) / GetNumPoints(i);
            indices.at(i) = std::floor( (xpos - GetLower(i)) / spacing);
        }

        return wrapIndices(indices);
    }

Here is the caller graph for this function:

template<typename T>

double SSAGES::GridBase< T >::GetInterpolated ( const std::vector< double > &  x )

inline

Return linear interpolation on a coordinate.

Parameters

x	Point in space.

Returns

Linearly interpolated value of grid at that point. This function performs a n-linear interpolation on the grid. The formula is bilinear/trilinear interpolation generalized to N-dimensional space.

Definition at line 333 of file GridBase.h.

    {
        double interpvalue = 0;
        int tempindex;
        for (size_t i = 0 ; i < pow(2,dimension_) ; ++i)
        {
            
            std::vector<double> shiftedvector = x;
            tempindex = i;
                
            double accumulatedweight = 1;
            for(size_t j = 0; j < dimension_ ; ++j)
            {
                double spacing = (GetUpper(j) - GetLower(j)) / GetNumPoints(j);
                shiftedvector[j] += ((tempindex%2)-0.5)*spacing;
                tempindex = tempindex/2;
            }
            
            std::vector<int> shiftedindices = GetIndices(shiftedvector);
            std::vector<double> shiftedcenters = GetCoordinates(shiftedindices);
            
            for(size_t j = 0; j < dimension_ ; ++j)
            {   
                double spacing = (GetUpper(j) - GetLower(j)) / GetNumPoints(j);
                //Handle Edges
                if(shiftedindices[j] == -1)
                    {
                    accumulatedweight *= ((std::abs(x[j]-GetCoordinates(GetIndices(x))[j])/spacing));
                    shiftedvector[j] += spacing/2;
                    }
                else if (shiftedindices[j] == GetNumPoints(j))
                    {
                    accumulatedweight *= ((std::abs(x[j]-GetCoordinates(GetIndices(x))[j])/spacing));
                    shiftedvector[j] -= spacing/2;
                    }
                else
                    {
                    // Handle Periodicity
                    if(std::abs(x[j]-shiftedcenters[j]) > spacing)
                        accumulatedweight *= (1-(std::abs(std::abs(x[j]-shiftedcenters[j]) - (GetUpper(j) - GetLower(j)))/spacing));
                    else
                        accumulatedweight *= (1-(std::abs(x[j]-shiftedcenters[j])/spacing));
                    }
            }           
            interpvalue += accumulatedweight*at(shiftedvector);
        }
        return interpvalue;
    }

template<typename T>

const std::vector<double>& SSAGES::GridBase< T >::GetLower ( ) const

inline

Return the lower edges of the Grid.

Returns

Vector containing the lower edges of the grid.

Definition at line 165 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::GetCoordinates(), SSAGES::GridBase< int >::GetIndices(), SSAGES::GridBase< int >::GetInterpolated(), and SSAGES::GridBase< int >::GetLower().

    {
        return edges_.first;
    }

Here is the caller graph for this function:

template<typename T>

double SSAGES::GridBase< T >::GetLower ( size_t  dim ) const

inline

Get the lower edge for a specific dimension.

Parameters

dim	Index of the dimension.

Returns

Value of the lower edge in the requested dimension.

Note

The first dimension has the index 0.

Definition at line 177 of file GridBase.h.

    {
        if (dim >= GetDimension()) {
            std::cerr << "Warning! Lower edge requested for a dimension larger "
                         "than the grid dimensionality!\n";
            return 0.0;
        }
        return GetLower().at(dim);
    }

template<typename T>

const std::vector<int>& SSAGES::GridBase< T >::GetNumPoints ( ) const

inline

Get the number of points for all dimensions.

Returns

Vector of ints containing the number of grid points for each dimension.

Definition at line 138 of file GridBase.h.

Referenced by SSAGES::Grid< int >::end(), SSAGES::Histogram< int >::end(), SSAGES::GridBase< int >::GetCoordinates(), SSAGES::GridBase< int >::GetIndices(), SSAGES::GridBase< int >::GetInterpolated(), SSAGES::Grid< int >::Grid(), SSAGES::Histogram< int >::Histogram(), SSAGES::Grid< int >::mapTo1d(), SSAGES::Histogram< int >::mapTo1d(), and SSAGES::GridBase< int >::wrapIndices().

    {
        return numPoints_;
    }

Here is the caller graph for this function:

template<typename T>

int SSAGES::GridBase< T >::GetNumPoints ( size_t  dim ) const

inline

Get the number of points for a specific dimension.

Parameters

dim	Index of the dimension.

Returns

Number of grid points in the requested dimension.

Note

The first dimension uses the index 0.

Definition at line 150 of file GridBase.h.

    {
        if (dim >= GetDimension()) {
            std::cerr << "Warning! Grid size requested for a dimension larger "
                         "than the grid dimensionality!\n";
            return 0;
        }

        return numPoints_.at(dim);
    }

template<typename T>

const std::vector<bool>& SSAGES::GridBase< T >::GetPeriodic ( ) const

inline

Return the periodicity of the Grid.

Returns

Vector of bools. The values are True (False ) if the grid is periodic (non-periodic) in the given dimension.

Definition at line 219 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::GetIndices(), SSAGES::GridBase< int >::GetPeriodic(), SSAGES::Histogram< int >::mapTo1d(), and SSAGES::GridBase< int >::wrapIndices().

    {
        return isPeriodic_;
    }

Here is the caller graph for this function:

template<typename T>

bool SSAGES::GridBase< T >::GetPeriodic ( size_t  dim ) const

inline

Get the periodicity in a specific dimension.

Parameters

dim	Index of the dimension.

Returns

True (False ) if the grid is periodic (non-periodic) in the specified dimension.

Note

The dimensions are indexed starting with 0.

Definition at line 232 of file GridBase.h.

    {
        if (dim >= GetDimension()) {
            std::cerr << "Warning! Periodicity requested for a dimension larger "
                         "than the grid dimensionality!\n";
            return false;
        }
        return GetPeriodic().at(dim);
    }

template<typename T>

const std::vector<double>& SSAGES::GridBase< T >::GetUpper ( ) const

inline

Return the upper edges of the Grid.

Returns

Vector containing the upper edges of the grid.

Definition at line 191 of file GridBase.h.

Referenced by SSAGES::GridBase< int >::GetCoordinates(), SSAGES::GridBase< int >::GetIndices(), SSAGES::GridBase< int >::GetInterpolated(), and SSAGES::GridBase< int >::GetUpper().

    {
        return edges_.second;
    }

Here is the caller graph for this function:

template<typename T>

double SSAGES::GridBase< T >::GetUpper ( size_t  dim ) const

inline

Get the upper edge for a specific dimension.

Parameters

dim	Index of the dimension.

Returns

Value of the upper edge in the given dimension.

Note

The dimensions are indexed starting with 0.

Definition at line 204 of file GridBase.h.

    {
        if (dim >= GetDimension()) {
            std::cerr << "Warning! Upper edge requested for a dimension larger "
                         "than the grid dimensionality!\n";
            return 0.0;
        }
        return GetUpper().at(dim);
    }

template<typename T>

virtual size_t SSAGES::GridBase< T >::mapTo1d ( const std::vector< int > &  indices ) const

protectedpure virtual

This function needs to be implemented by child classes.

Parameters

indices

The indices specifying the grid point.

Returns

Index of the grid point in the 1d storage vector.

mapTo1d maps the indices onto a single index to access the data stored in the data_ vector. This mapping will be different for different grid implementations.

Implemented in SSAGES::Histogram< T >, SSAGES::Histogram< int >, SSAGES::Grid< T >, SSAGES::Grid< double >, SSAGES::Grid< Vector >, and SSAGES::Grid< int >.

Referenced by SSAGES::GridBase< int >::at().

Here is the caller graph for this function:

template<typename T>

const T& SSAGES::GridBase< T >::operator[] ( const std::vector< int > &  indices ) const

inline

Access Grid element per [] read-only.

Parameters

indices

Vector of integers specifying the grid point.

Returns

Const reference to value to the given grid point.

Definition at line 595 of file GridBase.h.

    {
        return at(indices);
    }

template<typename T>

T& SSAGES::GridBase< T >::operator[] ( const std::vector< int > &  indices )

inline

Access Grid element per [] read-write.

Parameters

indices

Vector of integers specifying the grid point.

Returns

Reference to value at the specified grid point.

Definition at line 605 of file GridBase.h.

    {
        return at(indices);
    }

template<typename T>

template<typename R >

const T& SSAGES::GridBase< T >::operator[] ( std::initializer_list< R > &&  x ) const

inline

Const access of Grid element via initializer list.

Template Parameters

R	Datatype in the initializer list

Parameters

x	initializer list

Returns

Const reference to the value at the specified point.

This function avoids abiguity if operator[] is called with a brace-enclosed initializer list.

Example: grid[{0,1}] or grid[{-1.23, 4.2, 0.0}]

Definition at line 622 of file GridBase.h.

    {
        return at(static_cast<std::vector<R> >(x));
    }

template<typename T>

template<typename R >

T& SSAGES::GridBase< T >::operator[] ( std::initializer_list< R > &&  x )

inline

Access Grid element via initializer list.

Template Parameters

R	Datatype in the initializer list

Parameters

x	initializer list

Returns

Reference to the value at the specified point.

This function avoids abiguity if operator[] is called with a brace-enclosed initializer list.

Example: grid[{0,1}]

Definition at line 639 of file GridBase.h.

    {
        return at(static_cast<std::vector<R> >(x));
    }

template<typename T>

const T& SSAGES::GridBase< T >::operator[] ( int  index ) const

inline

Access 1d-Grid per [] operator, read-only.

Parameters

index

Index of the grid point.

Returns

Const reference to the value at the given grid point.

Note

This function can only be used for 1d grids.

Definition at line 651 of file GridBase.h.

    {
        return at(index);
    }

template<typename T>

T& SSAGES::GridBase< T >::operator[] ( int  index )

inline

Access 1d-Grid per [] operator, read-write.

Parameters

index

Index of the grid point.

Returns

Reference to the value at the given grid point.

Note

This function can only be used for 1d grids.

Definition at line 663 of file GridBase.h.

    {
        return at(index);
    }

template<typename T>

const T& SSAGES::GridBase< T >::operator[] ( const std::vector< double > &  x ) const

inline

Access Grid element pertaining to a specific point per [] read-only.

Parameters

x	Vector of doubles specifying the point in space.

Returns

Const reference to the value pertaining to the given coordinates.

Definition at line 673 of file GridBase.h.

    {
        return at(x);
    }

template<typename T>

T& SSAGES::GridBase< T >::operator[] ( const std::vector< double > &  x )

inline

Access Grid element pertaining to a specific point per [] read-write.

Parameters

x	Vector of doubles specifying the point in space.

Returns

Reference to the value pertaining to the given coordinates.

Definition at line 683 of file GridBase.h.

    {
        return at(x);
    }

template<typename T>

const T& SSAGES::GridBase< T >::operator[] ( double  x ) const

inline

Access 1d-Grid via specific point, read-only.

Parameters

x	Point specifying the desired Grid point.

Returns

Const reference to the value at the specified coordinate.

Note

This function can only be used for 1d grids.

Definition at line 695 of file GridBase.h.

    {
        return at(x);
    }

template<typename T>

T& SSAGES::GridBase< T >::operator[] ( double  x )

inline

Access 1d-Grid via specific point, read-write.

Parameters

x	Point specifying the desired Grid point.

Returns

Reference to value at the specified coordinate.

Note

This function can only be used for 1d grids.

Definition at line 707 of file GridBase.h.

    {
        return at(x);
    }

template<typename T>

size_t SSAGES::GridBase< T >::size ( ) const

inline

Get the size of the internal storage vector.

Returns

Size of the internal storage vector.

This function returns the size of the internal storage vector. This is also the total number of grid points including the over/underflow bins in case of a histogram.

Definition at line 250 of file GridBase.h.

    {
        return data_.size();
    }

---

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

• /home/cody/SSAGES/src/Grids/GridBase.h