XYZEval< T > Struct Template Reference

#include <types.h>

Collaboration diagram for XYZEval< T >:

Public Member Functions
FI void	reset ()
FI T	magnitude () const
FI	operator T* ()
FI	operator bool ()
FI void	set (const T px)
FI void	set (const T px, const T py)
FI void	set (const T px, const T py, const T pz)
FI void	set (const T px, const T py, const T pz, const T pe)
FI void	set (const XYval< T > pxy)
FI void	set (const XYval< T > pxy, const T pz)
FI void	set (const XYZval< T > pxyz)
FI void	set (const XYval< T > pxy, const T pz, const T pe)
FI void	set (const XYval< T > pxy, const XYval< T > pze)
FI void	set (const XYZval< T > pxyz, const T pe)
FI XYZEval< T >	copy () const
FI XYZEval< T >	ABS () const
FI XYZEval< int16_t >	asInt ()
FI XYZEval< int16_t >	asInt () const
FI XYZEval< int32_t >	asLong () const
FI XYZEval< int32_t >	asLong ()
FI XYZEval< float >	asFloat ()
FI XYZEval< float >	asFloat () const
FI XYZEval< float >	reciprocal () const
FI XYZEval< float >	asLogical () const
FI XYZEval< float >	asNative () const
FI	operator XYval< T > & ()
FI	operator const XYval< T > & () const
FI	operator XYZval< T > & ()
FI	operator const XYZval< T > & () const
FI T &	operator[] (const int i)
const FI T &	operator[] (const int i) const
FI XYZEval< T > &	operator= (const T v)
FI XYZEval< T > &	operator= (const XYval< T > &rs)
FI XYZEval< T > &	operator= (const XYZval< T > &rs)
FI XYZEval< T >	operator+ (const XYval< T > &rs) const
FI XYZEval< T >	operator+ (const XYval< T > &rs)
FI XYZEval< T >	operator- (const XYval< T > &rs) const
FI XYZEval< T >	operator- (const XYval< T > &rs)
FI XYZEval< T >	operator* (const XYval< T > &rs) const
FI XYZEval< T >	operator* (const XYval< T > &rs)
FI XYZEval< T >	operator/ (const XYval< T > &rs) const
FI XYZEval< T >	operator/ (const XYval< T > &rs)
FI XYZEval< T >	operator+ (const XYZval< T > &rs) const
FI XYZEval< T >	operator+ (const XYZval< T > &rs)
FI XYZEval< T >	operator- (const XYZval< T > &rs) const
FI XYZEval< T >	operator- (const XYZval< T > &rs)
FI XYZEval< T >	operator* (const XYZval< T > &rs) const
FI XYZEval< T >	operator* (const XYZval< T > &rs)
FI XYZEval< T >	operator/ (const XYZval< T > &rs) const
FI XYZEval< T >	operator/ (const XYZval< T > &rs)
FI XYZEval< T >	operator+ (const XYZEval< T > &rs) const
FI XYZEval< T >	operator+ (const XYZEval< T > &rs)
FI XYZEval< T >	operator- (const XYZEval< T > &rs) const
FI XYZEval< T >	operator- (const XYZEval< T > &rs)
FI XYZEval< T >	operator* (const XYZEval< T > &rs) const
FI XYZEval< T >	operator* (const XYZEval< T > &rs)
FI XYZEval< T >	operator/ (const XYZEval< T > &rs) const
FI XYZEval< T >	operator/ (const XYZEval< T > &rs)
FI XYZEval< T >	operator* (const float &v) const
FI XYZEval< T >	operator* (const float &v)
FI XYZEval< T >	operator* (const int &v) const
FI XYZEval< T >	operator* (const int &v)
FI XYZEval< T >	operator/ (const float &v) const
FI XYZEval< T >	operator/ (const float &v)
FI XYZEval< T >	operator/ (const int &v) const
FI XYZEval< T >	operator/ (const int &v)
FI XYZEval< T >	operator>> (const int &v) const
FI XYZEval< T >	operator>> (const int &v)
FI XYZEval< T >	operator<< (const int &v) const
FI XYZEval< T >	operator<< (const int &v)
FI XYZEval< T > &	operator+= (const XYval< T > &rs)
FI XYZEval< T > &	operator-= (const XYval< T > &rs)
FI XYZEval< T > &	operator*= (const XYval< T > &rs)
FI XYZEval< T > &	operator/= (const XYval< T > &rs)
FI XYZEval< T > &	operator+= (const XYZval< T > &rs)
FI XYZEval< T > &	operator-= (const XYZval< T > &rs)
FI XYZEval< T > &	operator*= (const XYZval< T > &rs)
FI XYZEval< T > &	operator/= (const XYZval< T > &rs)
FI XYZEval< T > &	operator+= (const XYZEval< T > &rs)
FI XYZEval< T > &	operator-= (const XYZEval< T > &rs)
FI XYZEval< T > &	operator*= (const XYZEval< T > &rs)
FI XYZEval< T > &	operator/= (const XYZEval< T > &rs)
FI XYZEval< T > &	operator*= (const T &v)
FI XYZEval< T > &	operator>>= (const int &v)
FI XYZEval< T > &	operator<<= (const int &v)
FI bool	operator== (const XYZval< T > &rs)
FI bool	operator!= (const XYZval< T > &rs)
FI bool	operator== (const XYZval< T > &rs) const
FI bool	operator!= (const XYZval< T > &rs) const
FI XYZEval< T >	operator- ()
const FI XYZEval< T >	operator- () const

Public Attributes
union {
struct {
T   x
T   y
T   z
T   e
}
struct {
T   a
T   b
T   c
}
T   pos [4]
};

Member Function Documentation

reset()

template<typename T>

FI void XYZEval< T >::reset

(

)

{ x = y = z = e = 0; }

Here is the caller graph for this function:

magnitude()

template<typename T>

FI T XYZEval< T >::magnitude

(

)

const

{ return (T)sqrtf(x*x + y*y + z*z + e*e); }

operator T*()

template<typename T>

FI XYZEval< T >::operator T*

(

)

{ return pos; }

operator bool()

template<typename T>

FI XYZEval< T >::operator bool

(

)

{ return e || z || x || y; }

set() [1/10]

template<typename T>

FI void XYZEval< T >::set

(

const T

px

)

{ x = px;                                        }

Here is the caller graph for this function:

set() [2/10]

template<typename T>

FI void XYZEval< T >::set	(	const T	px,
		const T	py
	)

{ x = px;     y = py;                            }

set() [3/10]

template<typename T>

FI void XYZEval< T >::set	(	const T	px,
		const T	py,
		const T	pz
	)

{ x = px;     y = py;     z = pz;                }

set() [4/10]

template<typename T>

FI void XYZEval< T >::set	(	const T	px,
		const T	py,
		const T	pz,
		const T	pe
	)

{ x = px;     y = py;     z = pz;     e = pe;    }

set() [5/10]

template<typename T>

FI void XYZEval< T >::set

(

const XYval< T >

pxy

)

{ x = pxy.x;  y = pxy.y;                         }

set() [6/10]

template<typename T>

FI void XYZEval< T >::set	(	const XYval< T >	pxy,
		const T	pz
	)

{ x = pxy.x;  y = pxy.y;  z = pz;                }

set() [7/10]

template<typename T>

FI void XYZEval< T >::set

(

const XYZval< T >

pxyz

)

{ x = pxyz.x; y = pxyz.y; z = pxyz.z;            }

set() [8/10]

template<typename T>

FI void XYZEval< T >::set	(	const XYval< T >	pxy,
		const T	pz,
		const T	pe
	)

{ x = pxy.x;  y = pxy.y;  z = pz;     e = pe;    }

set() [9/10]

template<typename T>

FI void XYZEval< T >::set	(	const XYval< T >	pxy,
		const XYval< T >	pze
	)

{ x = pxy.x;  y = pxy.y;  z = pze.z;  e = pze.e; }

set() [10/10]

template<typename T>

FI void XYZEval< T >::set	(	const XYZval< T >	pxyz,
		const T	pe
	)

{ x = pxyz.x; y = pxyz.y; z = pxyz.z; e = pe;    }

copy()

template<typename T>

FI XYZEval<T> XYZEval< T >::copy

(

)

const

{ return *this; }

ABS()

template<typename T>

FI XYZEval<T> XYZEval< T >::ABS

(

)

const

{ return { T(_ABS(x)), T(_ABS(y)), T(_ABS(z)), T(_ABS(e)) }; }

asInt() [1/2]

template<typename T>

FI XYZEval<int16_t> XYZEval< T >::asInt

(

)

{ return { int16_t(x), int16_t(y), int16_t(z), int16_t(e) }; }

asInt() [2/2]

template<typename T>

FI XYZEval<int16_t> XYZEval< T >::asInt

(

)

const

{ return { int16_t(x), int16_t(y), int16_t(z), int16_t(e) }; }

asLong() [1/2]

template<typename T>

FI XYZEval<int32_t> XYZEval< T >::asLong

(

)

const

{ return { int32_t(x), int32_t(y), int32_t(z), int32_t(e) }; }

asLong() [2/2]

template<typename T>

FI XYZEval<int32_t> XYZEval< T >::asLong

(

)

{ return { int32_t(x), int32_t(y), int32_t(z), int32_t(e) }; }

asFloat() [1/2]

template<typename T>

FI XYZEval<float> XYZEval< T >::asFloat

(

)

{ return {   float(x),   float(y),   float(z),   float(e) }; }

Here is the caller graph for this function:

asFloat() [2/2]

template<typename T>

FI XYZEval<float> XYZEval< T >::asFloat

(

)

const

{ return {   float(x),   float(y),   float(z),   float(e) }; }

reciprocal()

template<typename T>

FI XYZEval<float> XYZEval< T >::reciprocal

(

)

const

{ return {  _RECIP(x),  _RECIP(y),  _RECIP(z),  _RECIP(e) }; }

asLogical()

template<typename T>

FI XYZEval<float> XYZEval< T >::asLogical

(

)

const

{ XYZEval<float> o = asFloat(); toLogical(o); return o; }

Here is the caller graph for this function:

asNative()

template<typename T>

FI XYZEval<float> XYZEval< T >::asNative

(

)

const

{ XYZEval<float> o = asFloat(); toNative(o);  return o; }

operator XYval< T > &()

template<typename T>

FI XYZEval< T >::operator XYval< T > &

(

)

{ return *(XYval<T>*)this; }

operator const XYval< T > &()

template<typename T>

FI XYZEval< T >::operator const XYval< T > &

(

)

const

{ return *(const XYval<T>*)this; }

operator XYZval< T > &()

template<typename T>

FI XYZEval< T >::operator XYZval< T > &

(

)

{ return *(XYZval<T>*)this; }

operator const XYZval< T > &()

template<typename T>

FI XYZEval< T >::operator const XYZval< T > &

(

)

const

{ return *(const XYZval<T>*)this; }

operator[]() [1/2]

template<typename T>

FI T& XYZEval< T >::operator[]

(

const int

i

)

{ return pos[i]; }

operator[]() [2/2]

template<typename T>

const FI T& XYZEval< T >::operator[]

(

const int

i

)

const

{ return pos[i]; }

operator=() [1/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator=

(

const T

v

)

{ set(v, v, v, v); return *this; }

operator=() [2/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator=

(

const XYval< T > &

rs

)

{ set(rs.x, rs.y); return *this; }

operator=() [3/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator=

(

const XYZval< T > &

rs

)

{ set(rs.x, rs.y, rs.z); return *this; }

operator+() [1/6]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator+

(

const XYval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x += rs.x; ls.y += rs.y;                             return ls; }

operator+() [2/6]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator+

(

const XYval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x += rs.x; ls.y += rs.y;                             return ls; }

operator-() [1/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

const XYval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x -= rs.x; ls.y -= rs.y;                             return ls; }

operator-() [2/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

const XYval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x -= rs.x; ls.y -= rs.y;                             return ls; }

operator*() [1/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const XYval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y;                             return ls; }

operator*() [2/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const XYval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y;                             return ls; }

operator/() [1/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const XYval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y;                             return ls; }

operator/() [2/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const XYval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y;                             return ls; }

operator+() [3/6]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator+

(

const XYZval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x += rs.x; ls.y += rs.y; ls.z += rs.z;               return ls; }

operator+() [4/6]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator+

(

const XYZval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x += rs.x; ls.y += rs.y; ls.z += rs.z;               return ls; }

operator-() [3/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

const XYZval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x -= rs.x; ls.y -= rs.y; ls.z -= rs.z;               return ls; }

operator-() [4/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

const XYZval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x -= rs.x; ls.y -= rs.y; ls.z -= rs.z;               return ls; }

operator*() [3/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const XYZval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y; ls.z *= rs.z;               return ls; }

operator*() [4/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const XYZval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y; ls.z *= rs.z;               return ls; }

operator/() [3/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const XYZval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; ls.z /= rs.z;               return ls; }

operator/() [4/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const XYZval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; ls.z /= rs.z;               return ls; }

operator+() [5/6]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator+

(

const XYZEval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x += rs.x; ls.y += rs.y; ls.z += rs.z; ls.e += rs.e; return ls; }

operator+() [6/6]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator+

(

const XYZEval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x += rs.x; ls.y += rs.y; ls.z += rs.z; ls.e += rs.e; return ls; }

operator-() [5/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

const XYZEval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x -= rs.x; ls.y -= rs.y; ls.z -= rs.z; ls.e -= rs.e; return ls; }

operator-() [6/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

const XYZEval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x -= rs.x; ls.y -= rs.y; ls.z -= rs.z; ls.e -= rs.e; return ls; }

operator*() [5/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const XYZEval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y; ls.z *= rs.z; ls.e *= rs.e; return ls; }

operator*() [6/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const XYZEval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y; ls.z *= rs.z; ls.e *= rs.e; return ls; }

operator/() [5/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const XYZEval< T > &

rs

)

const

{ XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; ls.z /= rs.z; ls.e /= rs.e; return ls; }

operator/() [6/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const XYZEval< T > &

rs

)

{ XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; ls.z /= rs.z; ls.e /= rs.e; return ls; }

operator*() [7/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const float &

v

)

const

{ XYZEval<T> ls = *this; ls.x *= v;    ls.y *= v;    ls.z *= v;    ls.e *= v;    return ls; }

operator*() [8/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const float &

v

)

{ XYZEval<T> ls = *this; ls.x *= v;    ls.y *= v;    ls.z *= v;    ls.e *= v;    return ls; }

operator*() [9/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const int &

v

)

const

{ XYZEval<T> ls = *this; ls.x *= v;    ls.y *= v;    ls.z *= v;    ls.e *= v;    return ls; }

operator*() [10/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator*

(

const int &

v

)

{ XYZEval<T> ls = *this; ls.x *= v;    ls.y *= v;    ls.z *= v;    ls.e *= v;    return ls; }

operator/() [7/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const float &

v

)

const

{ XYZEval<T> ls = *this; ls.x /= v;    ls.y /= v;    ls.z /= v;    ls.e /= v;    return ls; }

operator/() [8/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const float &

v

)

{ XYZEval<T> ls = *this; ls.x /= v;    ls.y /= v;    ls.z /= v;    ls.e /= v;    return ls; }

operator/() [9/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const int &

v

)

const

{ XYZEval<T> ls = *this; ls.x /= v;    ls.y /= v;    ls.z /= v;    ls.e /= v;    return ls; }

operator/() [10/10]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator/

(

const int &

v

)

{ XYZEval<T> ls = *this; ls.x /= v;    ls.y /= v;    ls.z /= v;    ls.e /= v;    return ls; }

operator>>() [1/2]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator>>

(

const int &

v

)

const

{ XYZEval<T> ls = *this; _RS(ls.x);    _RS(ls.y);    _RS(ls.z);    _RS(ls.e);    return ls; }

operator>>() [2/2]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator>>

(

const int &

v

)

{ XYZEval<T> ls = *this; _RS(ls.x);    _RS(ls.y);    _RS(ls.z);    _RS(ls.e);    return ls; }

operator<<() [1/2]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator<<

(

const int &

v

)

const

{ XYZEval<T> ls = *this; _LS(ls.x);    _LS(ls.y);    _LS(ls.z);    _LS(ls.e);    return ls; }

operator<<() [2/2]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator<<

(

const int &

v

)

{ XYZEval<T> ls = *this; _LS(ls.x);    _LS(ls.y);    _LS(ls.z);    _LS(ls.e);    return ls; }

operator+=() [1/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator+=

(

const XYval< T > &

rs

)

{ x += rs.x; y += rs.y;                       return *this; }

operator-=() [1/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator-=

(

const XYval< T > &

rs

)

{ x -= rs.x; y -= rs.y;                       return *this; }

operator*=() [1/4]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator*=

(

const XYval< T > &

rs

)

{ x *= rs.x; y *= rs.y;                       return *this; }

operator/=() [1/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator/=

(

const XYval< T > &

rs

)

{ x /= rs.x; y /= rs.y;                       return *this; }

operator+=() [2/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator+=

(

const XYZval< T > &

rs

)

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

operator-=() [2/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator-=

(

const XYZval< T > &

rs

)

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

operator*=() [2/4]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator*=

(

const XYZval< T > &

rs

)

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

operator/=() [2/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator/=

(

const XYZval< T > &

rs

)

{ x /= rs.x; y /= rs.y; z /= rs.z;            return *this; }

operator+=() [3/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator+=

(

const XYZEval< T > &

rs

)

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

operator-=() [3/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator-=

(

const XYZEval< T > &

rs

)

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

operator*=() [3/4]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator*=

(

const XYZEval< T > &

rs

)

{ x *= rs.x; y *= rs.y; z *= rs.z; e *= rs.e; return *this; }

operator/=() [3/3]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator/=

(

const XYZEval< T > &

rs

)

{ x /= rs.x; y /= rs.y; z /= rs.z; e /= rs.e; return *this; }

operator*=() [4/4]

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator*=

(

const T &

v

)

{ x *= v;    y *= v;    z *= v;    e *= v;    return *this; }

operator>>=()

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator>>=

(

const int &

v

)

{ _RS(x);    _RS(y);    _RS(z);    _RS(e);    return *this; }

operator<<=()

template<typename T>

FI XYZEval<T>& XYZEval< T >::operator<<=

(

const int &

v

)

{ _LS(x);    _LS(y);    _LS(z);    _LS(e);    return *this; }

operator==() [1/2]

template<typename T>

FI bool XYZEval< T >::operator==

(

const XYZval< T > &

rs

)

{ return x == rs.x && y == rs.y && z == rs.z; }

Here is the caller graph for this function:

operator!=() [1/2]

template<typename T>

FI bool XYZEval< T >::operator!=

(

const XYZval< T > &

rs

)

{ return !operator==(rs); }

operator==() [2/2]

template<typename T>

FI bool XYZEval< T >::operator==

(

const XYZval< T > &

rs

)

const

{ return x == rs.x && y == rs.y && z == rs.z; }

operator!=() [2/2]

template<typename T>

FI bool XYZEval< T >::operator!=

(

const XYZval< T > &

rs

)

const

{ return !operator==(rs); }

operator-() [7/8]

template<typename T>

FI XYZEval<T> XYZEval< T >::operator-

(

)

{ return { -x, -y, -z, -e }; }

operator-() [8/8]

template<typename T>

const FI XYZEval<T> XYZEval< T >::operator-

(

)

const

{ return { -x, -y, -z, -e }; }

Member Data Documentation

x

template<typename T>

T XYZEval< T >::x

y

template<typename T>

T XYZEval< T >::y

z

template<typename T>

T XYZEval< T >::z

e

template<typename T>

T XYZEval< T >::e

a

template<typename T>

T XYZEval< T >::a

b

template<typename T>

T XYZEval< T >::b

c

template<typename T>

T XYZEval< T >::c

pos

template<typename T>

T XYZEval< T >::pos[4]

@14

union { ... }