DPoint3 Class Reference

class DPoint3 Description: This class describes a 3D point using double precision x, y and z coordinates. More...

#include <dpoint3.h>

Public Member Functions
	DPoint3 ()=default
	Initializes all vector components to zero.
constexpr	DPoint3 (const DPoint3 &)=default
constexpr	DPoint3 (DPoint3 &&)=default
DPoint3 &	operator= (const DPoint3 &)=default
DPoint3 &	operator= (DPoint3 &&)=default
constexpr	DPoint3 (double X, double Y, double Z)
	Constructor.
constexpr	DPoint3 (const double af[3])
	Constructor.
constexpr	DPoint3 (const Point3 &p)
constexpr DPoint3 &	operator= (const Point3 &p)
double &	operator[] (int i)
	const for (0,0,1)
const double &	operator[] (int i) const
	Allows access to x, y and z using the subscript operator.
constexpr	operator double * ()
	Conversion function.
constexpr	operator const double * () const
constexpr	operator Point3 () const
	Convert DPoint3 to Point3.
constexpr DPoint3	operator- () const
	Unary - operator.
constexpr DPoint3	operator+ () const
	Unary +.
constexpr DPoint3 &	operator-= (const DPoint3 &p)
	Subtracts a DPoint3 from this DPoint3.
constexpr DPoint3 &	operator+= (const DPoint3 &p)
	Adds a DPoint3 to this DPoint3.
constexpr DPoint3 &	operator*= (const DPoint3 &p)
	Member-wise multiplication of two vectors.
DPoint3 &	operator/= (const DPoint3 &p)
	Member-wise, in-place division of this vector.
constexpr DPoint3 &	operator+= (double f)
constexpr DPoint3 &	operator-= (double f)
constexpr DPoint3 &	operator*= (double f)
	Each element of this DPoint3 is multiplied by the specified double.
DPoint3 &	operator/= (double f)
	Each element of this DPoint3 is divided by the specified double.
constexpr DPoint3	operator- (const DPoint3 &p) const
	Subtracts a DPoint3 from a DPoint3.
constexpr DPoint3	operator+ (const DPoint3 &p) const
	Adds a DPoint3 to a DPoint3.
DPoint3	operator/ (const DPoint3 &p) const
DPoint3	operator* (const DPoint3 &p) const
	Member-wise multiplication of two vectors: (x*x, y*y, z*z)
constexpr double	LengthSquared () const
	The 'Length' squared of this point.
double	Length () const
	Returns the 'Length' of this point (vector)
DPoint3	Normalize () const
	Returns unit vector in the same direction as this point.
DPoint3 &	Unify ()
	in place normalize
double	LengthUnify ()
int	MaxComponent () const
int	MinComponent () const
constexpr bool	operator== (const DPoint3 &p) const
	Equality operator.
constexpr bool	operator!= (const DPoint3 &p) const
	Equality operator.
bool	Equals (const DPoint3 &p, double epsilon=1E-6) const
constexpr double	DotProd (const DPoint3 &p) const
constexpr double	operator% (const DPoint3 &p) const
constexpr DPoint3	CrossProd (const DPoint3 &p) const
	Computes the cross product of this DPoint3 and the specified DPoint3.
constexpr DPoint3	operator^ (const DPoint3 &p) const

Public Attributes
double	x = 0.0
double	y = 0.0
double	z = 0.0

Static Public Attributes
static const DPoint3	Origin
static const DPoint3	XAxis
	const for (0,0,0)
static const DPoint3	YAxis
	const for (1,0,0)
static const DPoint3	ZAxis
	const for (0,1,0)

Detailed Description

class DPoint3 Description: This class describes a 3D point using double precision x, y and z coordinates.

Methods are provided to add and subtract points, multiply and divide by scalars, and element by element multiply and divide two points. All methods are implemented by the system. Data Members: double x,y,z;

Constructor & Destructor Documentation

DPoint3() [1/6]

DPoint3 ( )

default

Initializes all vector components to zero.

DPoint3() [2/6]

constexpr DPoint3 ( const DPoint3 &  )

constexprdefault

DPoint3() [3/6]

constexpr DPoint3 ( DPoint3 &&  )

constexprdefault

DPoint3() [4/6]

constexpr DPoint3 ( double  X, double  Y, double  Z  )

inlineconstexpr

Constructor.

x, y, and z are initialized to the values specified.

: x(X), y(Y), z(Z) {}

DPoint3() [5/6]

constexpr DPoint3 ( const double  af[3] )

inlineconstexpr

Constructor.

x, y, and z are initialized to. af[0], af[1], and af[2] respectively.

: x(af[0]), y(af[1]), z(af[2]) {}

DPoint3() [6/6]

constexpr DPoint3 ( const Point3 &  p )

inlineconstexpr

: x(p.x), y(p.y), z(p.z) {}

Member Function Documentation

operator=() [1/3]

DPoint3 & operator= ( const DPoint3 &  )

default

operator=() [2/3]

DPoint3 & operator= ( DPoint3 &&  )

default

operator=() [3/3]

constexpr DPoint3 & operator= ( const Point3 &  p )

inlineconstexpr

    {
        x = p.x;
        y = p.y;
        z = p.z;
        return *this;
    }

operator[]() [1/2]

double & operator[] ( int  i )

inline

const for (0,0,1)

Allows access to x, y and z using the subscript operator.

Returns

An index of 0 will return x, 1 will return y, 2 will return z.

    {
        assert((i >= 0) && (i <= 2));
        return (&x)[i];
    }

operator[]() [2/2]

const double & operator[] ( int  i ) const

inline

Allows access to x, y and z using the subscript operator.

Returns

An index of 0 will return x, 1 will return y, 2 will return z.

    {
        assert((i >= 0) && (i <= 2));
        return (&x)[i];
    }

operator double *()

constexpr operator double * ( )

inlineconstexpr

Conversion function.

Returns the address of the DPoint3.x

    {
        return &x;
    }

operator const double *()

constexpr operator const double * ( ) const

inlineconstexpr

    {
        return &x;
    }

operator Point3()

constexpr operator Point3 ( ) const

inlineconstexpr

Convert DPoint3 to Point3.

    {
        return Point3(x, y, z);
    }

operator-() [1/2]

constexpr DPoint3 operator- ( ) const

inlineconstexpr

Unary - operator.

Negates both x, y and z.

    {
        return DPoint3(-x, -y, -z);
    }

operator+() [1/2]

constexpr DPoint3 operator+ ( ) const

inlineconstexpr

Unary +.

Returns the point unaltered.

    {
        return *this;
    }

operator-=() [1/2]

constexpr DPoint3 & operator-= ( const DPoint3 &  p )

inlineconstexpr

Subtracts a DPoint3 from this DPoint3.

    {
        x -= p.x;
        y -= p.y;
        z -= p.z;
        return *this;
    }

operator+=() [1/2]

constexpr DPoint3 & operator+= ( const DPoint3 &  p )

inlineconstexpr

Adds a DPoint3 to this DPoint3.

    {
        x += p.x;
        y += p.y;
        z += p.z;
        return *this;
    }

operator*=() [1/2]

constexpr DPoint3 & operator*= ( const DPoint3 &  p )

inlineconstexpr

Member-wise multiplication of two vectors.

    {
        x *= p.x;
        y *= p.y;
        z *= p.z;
        return *this;
    }

operator/=() [1/2]

DPoint3 & operator/= ( const DPoint3 &  p )

inline

Member-wise, in-place division of this vector.

    {
        assert(p.x != 0 && p.y != 0 && p.z != 0);
        x /= p.x;
        y /= p.y;
        z /= p.z;
        return *this;
    }

operator+=() [2/2]

constexpr DPoint3 & operator+= ( double  f )

inlineconstexpr

Remarks

Adds floating point value to this DPoint3.

    {
        x += f;
        y += f;
        z += f;
        return *this;
    }

operator-=() [2/2]

constexpr DPoint3 & operator-= ( double  f )

inlineconstexpr

Remarks

Subtracts floating point value from this DPoint3.

    {
        return *this += -f;
    }

operator*=() [2/2]

constexpr DPoint3 & operator*= ( double  f )

inlineconstexpr

Each element of this DPoint3 is multiplied by the specified double.

    {
        x *= f;
        y *= f;
        z *= f;
        return *this;
    }

operator/=() [2/2]

DPoint3 & operator/= ( double  f )

inline

Each element of this DPoint3 is divided by the specified double.

    {
        assert(f != 0);
        return *this *= (1.0 / f);
    }

operator-() [2/2]

constexpr DPoint3 operator- ( const DPoint3 &  p ) const

inlineconstexpr

Subtracts a DPoint3 from a DPoint3.

    {
        return DPoint3(x - p.x, y - p.y, z - p.z);
    }

operator+() [2/2]

constexpr DPoint3 operator+ ( const DPoint3 &  p ) const

inlineconstexpr

Adds a DPoint3 to a DPoint3.

    {
        return Point3(x + p.x, y + p.y, z + p.z);
    }

operator/()

DPoint3 operator/ ( const DPoint3 &  p ) const

inline

Remarks

Divides a DPoint3 by a DPoint3 element by element.

    {
        assert(p.x != 0 && p.y != 0 && p.z != 0);
        return DPoint3(x / p.x, y / p.y, z / p.z);
    }

operator*()

DPoint3 operator* ( const DPoint3 &  p ) const

inline

Member-wise multiplication of two vectors: (x*x, y*y, z*z)

    {
        return DPoint3(x * p.x, y * p.y, z * p.z);
    }

LengthSquared()

constexpr double LengthSquared ( ) const

inlineconstexpr

The 'Length' squared of this point.

    {
        return x * x + y * y + z * z;
    }

Length()

double Length ( ) const

inline

Returns the 'Length' of this point (vector)

    {
        return sqrt(LengthSquared());
    }

Normalize()

DPoint3 Normalize

(

)

const

Returns unit vector in the same direction as this point.

Unify()

DPoint3 & Unify

(

)

in place normalize

LengthUnify()

double LengthUnify

(

)

MaxComponent()

int MaxComponent

(

)

const

Returns

The largest axis

MinComponent()

int MinComponent

(

)

const

Returns

The smallest axis

operator==()

constexpr bool operator== ( const DPoint3 &  p ) const

inlineconstexpr

Equality operator.

Test for equality between two DPoint3's.

Returns

true if the DPoint3's are equal.

    {
        return (p.x == x) && (p.y == y) && (p.z == z);
    }

operator!=()

constexpr bool operator!= ( const DPoint3 &  p ) const

inlineconstexpr

Equality operator.

Test for nonequality between two DPoint3's.

Returns

true if the DPoint3's are not equal.

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

Equals()

bool Equals	(	const DPoint3 &	p,
		double	epsilon = 1E-6
	)		const

Remarks

Returns true if the absolute difference between point components is less or equal to the given epsilon for each component

DotProd()

constexpr double DotProd ( const DPoint3 &  p ) const

inlineconstexpr

Remarks

The dot product of two DPoint3's (vectors).

    {
        return x * p.x + y * p.y + z * p.z;
    }

operator%()

constexpr double operator% ( const DPoint3 &  p ) const

inlineconstexpr

    {
        return DotProd(p);
    }

CrossProd()

constexpr DPoint3 CrossProd ( const DPoint3 &  p ) const

inlineconstexpr

Computes the cross product of this DPoint3 and the specified DPoint3.

    {
        return DPoint3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);
    }

operator^()

constexpr DPoint3 operator^ ( const DPoint3 &  p ) const

inlineconstexpr

    {
        return CrossProd(p);
    }

Member Data Documentation

x

double x = 0.0

y

double y = 0.0

z

double z = 0.0

Origin

const DPoint3 Origin

static

XAxis

const DPoint3 XAxis

static

const for (0,0,0)

YAxis

const DPoint3 YAxis

static

const for (1,0,0)

ZAxis

const DPoint3 ZAxis

static

const for (0,1,0)