Nektar::NekPoint< data_type > Class Template Reference

#include <NekPoint.hpp>

Public Types
typedef data_type	DataType
typedef ThreeD	dim

Public Member Functions
	NekPoint ()
	NekPoint (const std::string &pointValues)
	NekPoint (typename boost::call_traits< DataType >::param_type x, typename boost::call_traits< DataType >::param_type y, typename boost::call_traits< DataType >::param_type z)
	NekPoint (typename boost::call_traits< DataType >::const_reference a)
	NekPoint (const NekPoint< DataType > &rhs)
	~NekPoint ()
NekPoint< DataType > &	operator= (const NekPoint< DataType > &rhs)
boost::call_traits< DataType >::reference	operator() (unsigned int i)
	Returns i^{th} element. More...
boost::call_traits< DataType >::const_reference	operator() (unsigned int i) const
boost::call_traits< DataType >::reference	operator[] (unsigned int i)
boost::call_traits< DataType >::const_reference	operator[] (unsigned int i) const
boost::call_traits< DataType >::const_reference	x () const
boost::call_traits< DataType >::const_reference	y () const
boost::call_traits< DataType >::const_reference	z () const
boost::call_traits< DataType >::const_reference	a () const
boost::call_traits< DataType >::const_reference	b () const
boost::call_traits< DataType >::const_reference	c () const
boost::call_traits< DataType >::const_reference	r () const
boost::call_traits< DataType >::const_reference	s () const
boost::call_traits< DataType >::const_reference	t () const
void	SetX (typename boost::call_traits< DataType >::const_reference val)
void	SetY (typename boost::call_traits< DataType >::const_reference val)
void	SetZ (typename boost::call_traits< DataType >::const_reference val)
boost::call_traits< DataType >::reference	x ()
boost::call_traits< DataType >::reference	y ()
boost::call_traits< DataType >::reference	z ()
const DataType *	GetPtr () const
bool	operator== (const NekPoint< DataType > &rhs) const
bool	operator!= (const NekPoint< DataType > &rhs) const
void	negate ()
	Arithmetic Routines. More...
NekPoint< DataType >	operator- () const
NekPoint< DataType > &	operator+= (const NekPoint< DataType > &rhs)
NekPoint< DataType > &	operator+= (typename boost::call_traits< DataType >::param_type rhs)
NekPoint< DataType > &	operator-= (const NekPoint< DataType > &rhs)
NekPoint< DataType > &	operator-= (typename boost::call_traits< DataType >::param_type rhs)
NekPoint< DataType > &	operator*= (typename boost::call_traits< DataType >::param_type rhs)
NekPoint< DataType > &	operator/= (typename boost::call_traits< DataType >::param_type rhs)
std::string	AsString () const

Static Public Member Functions
static unsigned int	dimension ()
	Returns the number of dimensions for the point. More...

Private Attributes
DataType	m_data [dim::Value]

Detailed Description

template<typename data_type>
class Nektar::NekPoint< data_type >

Definition at line 53 of file NekPoint.hpp.

Member Typedef Documentation

DataType

template<typename data_type>

typedef data_type Nektar::NekPoint< data_type >::DataType

Definition at line 56 of file NekPoint.hpp.

dim

template<typename data_type>

typedef ThreeD Nektar::NekPoint< data_type >::dim

Definition at line 57 of file NekPoint.hpp.

Constructor & Destructor Documentation

NekPoint() [1/5]

template<typename data_type>

Nektar::NekPoint< data_type >::NekPoint ( )

inline

Definition at line 60 of file NekPoint.hpp.

            {
                // This may be suboptimal if DataType isn't numeric.
                // If we use them then maybe we could look at an enable_if
                // template to choose a better constructor.
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    // If you get a compile error pointing you here then
                    // the DataType being stored in the point doesn't have an
                    // accessible operator= or default copy constructor.
                    m_data[i] = DataType();
                }
            }

NekPoint() [2/5]

template<typename data_type>

Nektar::NekPoint< data_type >::NekPoint ( const std::string &  pointValues )

inline

Definition at line 74 of file NekPoint.hpp.

            {
                bool result = fromString(pointValues, *this);
                ASSERTL0(result, "Unable to create a point from a string.");
            }

NekPoint() [3/5]

template<typename data_type>

Nektar::NekPoint< data_type >::NekPoint ( typename boost::call_traits< DataType >::param_type  x, typename boost::call_traits< DataType >::param_type  y, typename boost::call_traits< DataType >::param_type  z  )

inline

Definition at line 80 of file NekPoint.hpp.

            {
                m_data[0] = x;
                m_data[1] = y;
                m_data[2] = z;
            }

NekPoint() [4/5]

template<typename data_type>

Nektar::NekPoint< data_type >::NekPoint ( typename boost::call_traits< DataType >::const_reference  a )

inlineexplicit

Definition at line 89 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] = a;
                }
            }

NekPoint() [5/5]

template<typename data_type>

Nektar::NekPoint< data_type >::NekPoint ( const NekPoint< DataType > &  rhs )

inline

Definition at line 98 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] = rhs.m_data[i];
                }
            }

~NekPoint()

template<typename data_type>

Nektar::NekPoint< data_type >::~NekPoint ( )

inline

Definition at line 106 of file NekPoint.hpp.

            {
            }

Member Function Documentation

a()

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::a ( ) const

inline

Definition at line 176 of file NekPoint.hpp.

Referenced by Nektar::NekPoint< NekDouble >::NekPoint().

            {
                static_assert(dim::Value >= 1, "invalid dimension");
                return m_data[0];
            }

AsString()

template<typename data_type>

std::string Nektar::NekPoint< data_type >::AsString ( ) const

inline

Definition at line 346 of file NekPoint.hpp.

            {
                std::string result = "(";
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    result += boost::lexical_cast<std::string>(m_data[i]);
                    if( i < dim::Value-1 )
                    {
                        result += ", ";
                    }
                }
                result += ")";
                return result;
            }

b()

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::b ( ) const

inline

Definition at line 182 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 2, "invalid dimension");
                return (*this)[1];
            }

c()

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::c ( ) const

inline

Definition at line 188 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 3, "invalid dimension");
                return (*this)[2];
            }

dimension()

template<typename data_type>

static unsigned int Nektar::NekPoint< data_type >::dimension ( )

inlinestatic

Returns the number of dimensions for the point.

Definition at line 121 of file NekPoint.hpp.

{ return dim::Value; }

GetPtr()

template<typename data_type>

const DataType* Nektar::NekPoint< data_type >::GetPtr ( ) const

inline

Definition at line 248 of file NekPoint.hpp.

            {
                return &m_data[0];
            }

negate()

template<typename data_type>

void Nektar::NekPoint< data_type >::negate ( )

inline

Arithmetic Routines.

Definition at line 275 of file NekPoint.hpp.

Referenced by Nektar::negate(), and Nektar::NekPoint< NekDouble >::operator-().

            {
                for(int i=0; i < dim::Value; ++i)
                {
                    (*this)[i] = -(*this)[i];
                }
            }

operator!=()

template<typename data_type>

bool Nektar::NekPoint< data_type >::operator!= ( const NekPoint< DataType > &  rhs ) const

inline

Definition at line 267 of file NekPoint.hpp.

            {
                return !(*this == rhs);
            }

operator()() [1/2]

template<typename data_type>

boost::call_traits<DataType>::reference Nektar::NekPoint< data_type >::operator() ( unsigned int  i )

inline

Returns i^{th} element.

Parameters

i	The element to return.

Precondition

i < dim

Returns

A reference to the i^{th} element.

Retrieves the i^{th} element. Since it returns a reference you may assign a new value (i.e., p(2) = 3.2;)

This operator performs range checking.

Definition at line 132 of file NekPoint.hpp.

            {
                ASSERTL0(i < dim::Value,
                        "Invalid access to NekPoint data via parenthesis "
                        "operator: index out of range");
                return m_data[i];
            }

operator()() [2/2]

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::operator() ( unsigned int  i ) const

inline

Definition at line 140 of file NekPoint.hpp.

            {
                ASSERTL0(i < dim::Value,
                        "Invalid access to NekPoint data via parenthesis "
                        "operator: index out of range");
                return m_data[i];
            }

operator*=()

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator*= ( typename boost::call_traits< DataType >::param_type  rhs )

inline

Definition at line 328 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] *= rhs;
                }
                return *this;
            }

operator+=() [1/2]

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator+= ( const NekPoint< DataType > &  rhs )

inline

Definition at line 291 of file NekPoint.hpp.

            {
                for(unsigned int i=0; i < dim::Value; ++i)
                {
                    m_data[i] += rhs.m_data[i];
                }
                return *this;
            }

operator+=() [2/2]

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator+= ( typename boost::call_traits< DataType >::param_type  rhs )

inline

Definition at line 300 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] += rhs;
                }
                return *this;
            }

operator-()

template<typename data_type>

NekPoint<DataType> Nektar::NekPoint< data_type >::operator- ( ) const

inline

Definition at line 283 of file NekPoint.hpp.

            {
                NekPoint<DataType> result(*this);
                result.negate();
                return result;
            }

operator-=() [1/2]

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator-= ( const NekPoint< DataType > &  rhs )

inline

Definition at line 309 of file NekPoint.hpp.

            {
                for(unsigned int i=0; i < dim::Value; ++i)
                {
                    m_data[i] -= rhs.m_data[i];
                }
                return *this;
            }

operator-=() [2/2]

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator-= ( typename boost::call_traits< DataType >::param_type  rhs )

inline

Definition at line 319 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] -= rhs;
                }
                return *this;
            }

operator/=()

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator/= ( typename boost::call_traits< DataType >::param_type  rhs )

inline

Definition at line 337 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] /= rhs;
                }
                return *this;
            }

operator=()

template<typename data_type>

NekPoint<DataType>& Nektar::NekPoint< data_type >::operator= ( const NekPoint< DataType > &  rhs )

inline

Definition at line 111 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    m_data[i] = rhs.m_data[i];
                }
                return *this;
            }

operator==()

template<typename data_type>

bool Nektar::NekPoint< data_type >::operator== ( const NekPoint< DataType > &  rhs ) const

inline

Definition at line 253 of file NekPoint.hpp.

            {
                for(unsigned int i = 0; i < dim::Value; ++i)
                {
                    // If you get a compile error here then you have to
                    // add a != operator to the DataType class.
                    if( m_data[i] != rhs.m_data[i] )
                    {
                        return false;
                    }
                }
                return true;
            }

operator[]() [1/2]

template<typename data_type>

boost::call_traits<DataType>::reference Nektar::NekPoint< data_type >::operator[] ( unsigned int  i )

inline

Definition at line 148 of file NekPoint.hpp.

            {
                return m_data[i];
            }

operator[]() [2/2]

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::operator[] ( unsigned int  i ) const

inline

Definition at line 153 of file NekPoint.hpp.

            {
                return m_data[i];
            }

r()

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::r ( ) const

inline

Definition at line 194 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 1, "invalid dimension");
                return m_data[0];
            }

s()

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::s ( ) const

inline

Definition at line 200 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 2, "invalid dimension");
                return (*this)[1];
            }

SetX()

template<typename data_type>

void Nektar::NekPoint< data_type >::SetX ( typename boost::call_traits< DataType >::const_reference  val )

inline

Definition at line 212 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 1, "invalid dimension");
                m_data[0] = val;
            }

SetY()

template<typename data_type>

void Nektar::NekPoint< data_type >::SetY ( typename boost::call_traits< DataType >::const_reference  val )

inline

Definition at line 218 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 2, "invalid dimension");
                m_data[1] = val;
            }

SetZ()

template<typename data_type>

void Nektar::NekPoint< data_type >::SetZ ( typename boost::call_traits< DataType >::const_reference  val )

inline

Definition at line 224 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 2, "invalid dimension");
                m_data[2] = val;
            }

t()

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::t ( ) const

inline

Definition at line 206 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 3, "invalid dimension");
                return (*this)[2];
            }

x() [1/2]

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::x ( ) const

inline

Definition at line 158 of file NekPoint.hpp.

Referenced by Nektar::SpatialDomains::PointGeom::dist(), Nektar::SpatialDomains::PointGeom::dot(), Nektar::NekPoint< NekDouble >::NekPoint(), and Nektar::SpatialDomains::PointGeom::Rotate().

            {
                static_assert(dim::Value >= 1, "invalid dimension");
                return m_data[0];
            }

x() [2/2]

template<typename data_type>

boost::call_traits<DataType>::reference Nektar::NekPoint< data_type >::x ( )

inline

Definition at line 230 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 1, "invalid dimension");
                return (*this)(0);
            }

y() [1/2]

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::y ( ) const

inline

Definition at line 164 of file NekPoint.hpp.

Referenced by Nektar::SpatialDomains::PointGeom::dist(), Nektar::SpatialDomains::PointGeom::dot(), Nektar::NekPoint< NekDouble >::NekPoint(), and Nektar::SpatialDomains::PointGeom::Rotate().

            {
                static_assert(dim::Value >= 2, "invalid dimension");
                return (*this)[1];
            }

y() [2/2]

template<typename data_type>

boost::call_traits<DataType>::reference Nektar::NekPoint< data_type >::y ( )

inline

Definition at line 236 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 2, "invalid dimension");
                return (*this)(1);
            }

z() [1/2]

template<typename data_type>

boost::call_traits<DataType>::const_reference Nektar::NekPoint< data_type >::z ( ) const

inline

Definition at line 170 of file NekPoint.hpp.

Referenced by Nektar::SpatialDomains::PointGeom::dist(), Nektar::SpatialDomains::PointGeom::dot(), Nektar::NekPoint< NekDouble >::NekPoint(), and Nektar::SpatialDomains::PointGeom::Rotate().

            {
                static_assert(dim::Value >= 3, "invalid dimension");
                return (*this)[2];
            }

z() [2/2]

template<typename data_type>

boost::call_traits<DataType>::reference Nektar::NekPoint< data_type >::z ( )

inline

Definition at line 242 of file NekPoint.hpp.

            {
                static_assert(dim::Value >= 3, "invalid dimension");
                return (*this)(2);
            }

Member Data Documentation

m_data

template<typename data_type>

DataType Nektar::NekPoint< data_type >::m_data[dim::Value]

private

Definition at line 362 of file NekPoint.hpp.

Referenced by Nektar::NekPoint< NekDouble >::a(), Nektar::NekPoint< NekDouble >::AsString(), Nektar::NekPoint< NekDouble >::GetPtr(), Nektar::NekPoint< NekDouble >::NekPoint(), Nektar::NekPoint< NekDouble >::operator()(), Nektar::NekPoint< NekDouble >::operator*=(), Nektar::NekPoint< NekDouble >::operator+=(), Nektar::NekPoint< NekDouble >::operator-=(), Nektar::NekPoint< NekDouble >::operator/=(), Nektar::NekPoint< NekDouble >::operator=(), Nektar::NekPoint< NekDouble >::operator==(), Nektar::NekPoint< NekDouble >::operator[](), Nektar::NekPoint< NekDouble >::r(), Nektar::NekPoint< NekDouble >::SetX(), Nektar::NekPoint< NekDouble >::SetY(), Nektar::NekPoint< NekDouble >::SetZ(), and Nektar::NekPoint< NekDouble >::x().