sge::math::basic_vector< T, Dim > Class Template Reference

#include <vector.hpp>

List of all members.

Public Types
typedef T	value_type
typedef T &	reference
typedef const T &	const_reference
typedef std::ptrdiff_t	difference_type
typedef std::size_t	size_type
typedef T *	pointer
typedef const T *	const_pointer
typedef pointer	iterator
typedef const_pointer	const_iterator
typedef std::reverse_iterator < iterator >	reverse_iterator
typedef std::reverse_iterator < const_iterator >	const_reverse_iterator
Public Member Functions
template<typename... Args>
	basic_vector (Args...args)
	basic_vector ()
	basic_vector (no_initialization_tag)
template<std::size_t U>
	basic_vector (const basic_vector< T, U > &v, typename boost::enable_if_c< U==Dim-1, const_reference >::type n=0)
	basic_vector (const basic_vector &r)
basic_vector &	operator= (const basic_vector &r)
basic_vector &	operator+= (const basic_vector &r)
basic_vector &	operator-= (const basic_vector &r)
basic_vector	operator+ (const basic_vector &r) const
basic_vector	operator- (const basic_vector &r) const
basic_vector	operator+ () const
basic_vector	operator- () const
basic_vector &	operator*= (const_reference r)
basic_vector &	operator*= (const basic_vector &r)
basic_vector	operator* (const_reference r) const
basic_vector	operator* (const basic_vector &r) const
basic_vector &	operator/= (const_reference r)
basic_vector &	operator/= (const basic_vector &r)
basic_vector	operator/ (const_reference r) const
basic_vector	operator/ (const basic_vector &r) const
basic_vector &	operator%= (const_reference r)
basic_vector &	operator%= (const basic_vector &r)
basic_vector	operator% (const_reference r) const
basic_vector	operator% (const basic_vector &r) const
value_type	dot (const basic_vector &r) const
reference	operator[] (const size_type pos)
const_reference	operator[] (const size_type pos) const
reference	at (const size_type pos)
const_reference	at (const size_type pos) const
bool	operator== (const basic_vector &r) const
bool	operator!= (const basic_vector &r) const
value_type	length_quad () const
value_type	length () const
basic_vector	unit () const
basic_vector &	normalize ()
reference	x ()
const_reference	x () const
reference	y ()
const_reference	y () const
reference	z ()
const_reference	z () const
reference	w ()
const_reference	w () const
basic_vector	cross (const basic_vector &r) const
bool	is_null () const
void	swap (basic_vector &r)
template<typename... Args>
void	set (const_reference arg, Args...args)
bool	nearly_equals (const basic_vector &r, const value_type &radius) const
size_type	size () const
size_type	dim () const
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
pointer	data ()
const_pointer	data () const
Friends
basic_vector	operator* (const_reference l, basic_vector r)

---

Detailed Description

template<typename T, std::size_t Dim>
class sge::math::basic_vector< T, Dim >

This class should be used for representing vectors, so either points or direction vectors. You could also store size values in here, but there are no accessors like "w" or "h". Use sge::math::basic_rect or sge::math::basic_dim for that purpose.

basic_vector uses C++0x variadic templates where available.

---

Member Typedef Documentation

template<typename T, std::size_t Dim>

typedef T sge::math::basic_vector< T, Dim >::value_type

template<typename T, std::size_t Dim>

typedef T& sge::math::basic_vector< T, Dim >::reference

template<typename T, std::size_t Dim>

typedef const T& sge::math::basic_vector< T, Dim >::const_reference

template<typename T, std::size_t Dim>

typedef std::ptrdiff_t sge::math::basic_vector< T, Dim >::difference_type

template<typename T, std::size_t Dim>

typedef std::size_t sge::math::basic_vector< T, Dim >::size_type

template<typename T, std::size_t Dim>

typedef T* sge::math::basic_vector< T, Dim >::pointer

template<typename T, std::size_t Dim>

typedef const T* sge::math::basic_vector< T, Dim >::const_pointer

template<typename T, std::size_t Dim>

typedef pointer sge::math::basic_vector< T, Dim >::iterator

template<typename T, std::size_t Dim>

typedef const_pointer sge::math::basic_vector< T, Dim >::const_iterator

template<typename T, std::size_t Dim>

typedef std::reverse_iterator<iterator> sge::math::basic_vector< T, Dim >::reverse_iterator

template<typename T, std::size_t Dim>

typedef std::reverse_iterator<const_iterator> sge::math::basic_vector< T, Dim >::const_reverse_iterator

---

Constructor & Destructor Documentation

template<typename T, std::size_t Dim>

template<typename... Args>

sge::math::basic_vector< T, Dim >::basic_vector

(

Args...

args

)

[inline, explicit]

template<typename T, std::size_t Dim>

sge::math::basic_vector< T, Dim >::basic_vector

(

)

[inline]

This initializes the vector with zero

template<typename T, std::size_t Dim>

sge::math::basic_vector< T, Dim >::basic_vector

(

no_initialization_tag

)

[inline]

This does not initialize any of the coordinates (models the built types)

template<typename T, std::size_t Dim>

template<std::size_t U>

sge::math::basic_vector< T, Dim >::basic_vector	(	const basic_vector< T, U > &	v,
		typename boost::enable_if_c< U==Dim-1, const_reference >::type	n = 0
	)			[inline]

This constructor gets a vector of the same type, but with a dimension lower. This is just a convenience so you can construct, for example, a vector3 from a vector2 by writing

 basic_vector<T,2> small;
 basic_vector<T,3> large(small,0); 

template<typename T, std::size_t Dim>

sge::math::basic_vector< T, Dim >::basic_vector

(

const basic_vector< T, Dim > &

r

)

[inline]

---

Member Function Documentation

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator=

(

const basic_vector< T, Dim > &

r

)

[inline]

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator+=

(

const basic_vector< T, Dim > &

r

)

[inline]

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator-=

(

const basic_vector< T, Dim > &

r

)

[inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator+

(

const basic_vector< T, Dim > &

r

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator-

(

const basic_vector< T, Dim > &

r

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator+

(

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator-

(

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator*=

(

const_reference

r

)

[inline]

Scalar multiplication

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator*=

(

const basic_vector< T, Dim > &

r

)

[inline]

This does not take the dot or cross product but rather multiplies componentwise

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator*

(

const_reference

r

)

const [inline]

Scalar multiplication

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator*

(

const basic_vector< T, Dim > &

r

)

const [inline]

This does not take the dot or cross product but rather multiplies componentwise

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator/=

(

const_reference

r

)

[inline]

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator/=

(

const basic_vector< T, Dim > &

r

)

[inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator/

(

const_reference

r

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator/

(

const basic_vector< T, Dim > &

r

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator%=

(

const_reference

r

)

[inline]

This operator uses sge::math::mod to calculate the modulo

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::operator%=

(

const basic_vector< T, Dim > &

r

)

[inline]

This operator uses sge::math::mod to calculate the modulo

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator%

(

const_reference

r

)

const [inline]

This operator uses sge::math::mod to calculate the modulo

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::operator%

(

const basic_vector< T, Dim > &

r

)

const [inline]

This operator uses sge::math::mod to calculate the modulo

template<typename T, std::size_t Dim>

value_type sge::math::basic_vector< T, Dim >::dot

(

const basic_vector< T, Dim > &

r

)

const [inline]

template<typename T, std::size_t Dim>

reference sge::math::basic_vector< T, Dim >::operator[]

(

const size_type

pos

)

[inline]

Does range checking with an assertion

template<typename T, std::size_t Dim>

const_reference sge::math::basic_vector< T, Dim >::operator[]

(

const size_type

pos

)

const [inline]

Does range checking with an assertion

template<typename T, std::size_t Dim>

reference sge::math::basic_vector< T, Dim >::at

(

const size_type

pos

)

[inline]

Exceptions:

sge::exception

If argument greater than dimension

template<typename T, std::size_t Dim>

const_reference sge::math::basic_vector< T, Dim >::at

(

const size_type

pos

)

const [inline]

Exceptions:

sge::exception

If argument greater than dimension

template<typename T, std::size_t Dim>

bool sge::math::basic_vector< T, Dim >::operator==

(

const basic_vector< T, Dim > &

r

)

const [inline]

Uses sge::math::compare to compare componentwise

template<typename T, std::size_t Dim>

bool sge::math::basic_vector< T, Dim >::operator!=

(

const basic_vector< T, Dim > &

r

)

const [inline]

Uses sge::math::compare to compare componentwise

template<typename T, std::size_t Dim>

value_type sge::math::basic_vector< T, Dim >::length_quad

(

)

const [inline]

Returns the dot product of the vector with itself

template<typename T, std::size_t Dim>

value_type sge::math::basic_vector< T, Dim >::length

(

)

const [inline]

Applies std::sqrt to length_quad.

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::unit

(

)

const [inline]

Returns the normalized vector

template<typename T, std::size_t Dim>

basic_vector& sge::math::basic_vector< T, Dim >::normalize

(

)

[inline]

template<typename T, std::size_t Dim>

reference sge::math::basic_vector< T, Dim >::x

(

)

[inline]

template<typename T, std::size_t Dim>

const_reference sge::math::basic_vector< T, Dim >::x

(

)

const [inline]

template<typename T, std::size_t Dim>

reference sge::math::basic_vector< T, Dim >::y

(

)

[inline]

template<typename T, std::size_t Dim>

const_reference sge::math::basic_vector< T, Dim >::y

(

)

const [inline]

template<typename T, std::size_t Dim>

reference sge::math::basic_vector< T, Dim >::z

(

)

[inline]

template<typename T, std::size_t Dim>

const_reference sge::math::basic_vector< T, Dim >::z

(

)

const [inline]

template<typename T, std::size_t Dim>

reference sge::math::basic_vector< T, Dim >::w

(

)

[inline]

template<typename T, std::size_t Dim>

const_reference sge::math::basic_vector< T, Dim >::w

(

)

const [inline]

template<typename T, std::size_t Dim>

basic_vector sge::math::basic_vector< T, Dim >::cross

(

const basic_vector< T, Dim > &

r

)

const [inline]

template<typename T, std::size_t Dim>

bool sge::math::basic_vector< T, Dim >::is_null

(

)

const [inline]

Compares the vector against the default constructed (and thus "nullified") vector

template<typename T, std::size_t Dim>

void sge::math::basic_vector< T, Dim >::swap

(

basic_vector< T, Dim > &

r

)

[inline]

template<typename T, std::size_t Dim>

template<typename... Args>

void sge::math::basic_vector< T, Dim >::set	(	const_reference	arg,
		Args...	args
	)			[inline]

template<typename T, std::size_t Dim>

bool sge::math::basic_vector< T, Dim >::nearly_equals	(	const basic_vector< T, Dim > &	r,
		const value_type &	radius
	)			const [inline]

template<typename T, std::size_t Dim>

size_type sge::math::basic_vector< T, Dim >::size

(

)

const [inline]

template<typename T, std::size_t Dim>

size_type sge::math::basic_vector< T, Dim >::dim

(

)

const [inline]

template<typename T, std::size_t Dim>

iterator sge::math::basic_vector< T, Dim >::begin

(

)

[inline]

template<typename T, std::size_t Dim>

iterator sge::math::basic_vector< T, Dim >::end

(

)

[inline]

template<typename T, std::size_t Dim>

const_iterator sge::math::basic_vector< T, Dim >::begin

(

)

const [inline]

template<typename T, std::size_t Dim>

const_iterator sge::math::basic_vector< T, Dim >::end

(

)

const [inline]

template<typename T, std::size_t Dim>

reverse_iterator sge::math::basic_vector< T, Dim >::rbegin

(

)

[inline]

template<typename T, std::size_t Dim>

reverse_iterator sge::math::basic_vector< T, Dim >::rend

(

)

[inline]

template<typename T, std::size_t Dim>

const_reverse_iterator sge::math::basic_vector< T, Dim >::rbegin

(

)

const [inline]

template<typename T, std::size_t Dim>

const_reverse_iterator sge::math::basic_vector< T, Dim >::rend

(

)

const [inline]

template<typename T, std::size_t Dim>

pointer sge::math::basic_vector< T, Dim >::data

(

)

[inline]

template<typename T, std::size_t Dim>

const_pointer sge::math::basic_vector< T, Dim >::data

(

)

const [inline]

---

Friends And Related Function Documentation

template<typename T, std::size_t Dim>

basic_vector operator*	(	const_reference	l,
		basic_vector< T, Dim >	r
	)			[friend]

Scalar multiplication

---

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

• include/sge/math/vector.hpp