Vector of fixed size. More...

#include "Imagine/Common.h"

Inheritance diagram for Imagine::FVector< T, dim >:

Public Member Functions
	FVector ()
	Empty constructor. More...

	FVector (const T &v)
	Constructor with constant value. More...

template<typename T2 >
	FVector (const T2 t[dim])
	Constructor from C array. More...

template<typename T2 >
	FVector (const FArray< T2, dim > &a)
	Copy constructor. More...

	FVector (T x, T y)
	2D alias. More...

	FVector (T x, T y, T z)
	3D alias. More...

FVector &	fill (const T &v)
	Filling. More...

FVector &	normalize ()
	Euclidean in-place normalization. More...

T	operator* (const FVector &v) const
	Scalar product. More...

FVector	operator* (T s) const
	Scalar multiplication. More...

FVector &	operator*= (T s)
	Scalar in place multiplication. More...

FVector	operator+ (const FVector &v) const
	Addition. More...

FVector	operator+ (T s) const
	Scalar Addition. More...

FVector &	operator+= (const FVector &v)
	In place Addition. More...

FVector &	operator+= (T s)
	Scalar in place Addition. More...

FVector	operator- (const FVector &v) const
	Substraction. More...

FVector	operator- (T s) const
	Scalar Substraction. More...

FVector	operator- () const
	Opposite. More...

FVector &	operator-= (const FVector &v)
	In place Substraction. More...

FVector &	operator-= (T s)
	Scalar in place substractrion. More...

FVector	operator/ (T s) const
	Scalar division. More...

FVector &	operator/= (T s)
	Scalar in place division. More...

template<typename T2 >
FVector &	operator= (const FArray< T2, dim > &b)
	Assignment. More...

T	operator^ (const FVector< T, 2 > &v) const
	2D cross product. More...

FVector< T, 3 >	operator^ (const FVector< T, 3 > &v) const
	3D cross product. More...

const T &	x () const
	Read alias. More...

T &	x ()
	Write alias. More...

const T &	y () const
	Read alias. More...

T &	y ()
	Write alias. More...

const T &	z () const
	Read alias. More...

T &	z ()
	Write alias. More...

Public Member Functions inherited from Imagine::FArray< T, dim >
	FArray ()
	Empty constructor. More...

	FArray (const T &v)
	Constructor with constant value. More...

	FArray (const T2 t[S])
	Constructor from C array. More...

	FArray (const FArray< T2, S > &a)
	Copy constructor. More...

	FArray (T v0, T v1)
	2D alias. More...

	FArray (T v0, T v1, T v2)
	3D alias. More...

	FArray (T v0, T v1, T v2, T v3)
	4D alias. More...

iterator	begin ()
	Begin iterator. More...

const_iterator	begin () const
	Begin const iterator. More...

FArray &	copy (const T2 t[S])
	C array of different type copy. More...

FArray &	copy (const FArray< T2, S > &b)
	Copy. More...

const T *	data () const
	Data pointer (read). More...

T *	data ()
	Data pointer (write). More...

bool	empty () const
	Is empty. More...

iterator	end ()
	End iterator. More...

const_iterator	end () const
	End const iterator. More...

FArray &	fill (const T &v)
	Filling. More...

bool	operator!= (const FArray &b) const
	Inequality test. More...

FArray &	operator= (const FArray< T2, S > &b)
	Assignment. More...

bool	operator== (const FArray &b) const
	Equality test. More...

const T &	operator[] (int i) const
	Read access. More...

T &	operator[] (int i)
	Write access. More...

int	size () const
	Size. More...

Static Public Member Functions
static FVector	Zero ()
	Zero vector Vector with constant 0 value. More...

Friends
double	dist (const FVector &a, const FVector &b)
	Distance. More...

FVector	div (const FVector &v, const FVector &w)
	Pointwise division. More...

double	doubleNorm (const FVector &v)
	Double Euclidean norm. More...

double	doubleNorm1 (const FVector &v)
	Double L1-norm. More...

double	doubleNorm2 (const FVector &v)
	Double squared Euclidean norm. More...

FVector	exp (const FVector &a)
	Pointwise exp exps of each coordinate. More...

int	intL1Dist (const FVector &a, const FVector &b)
	Integer L1-distance. More...

int	intNorm1 (const FVector &v)
	Integer L1-norm. More...

int	intNorm2 (const FVector &v)
	Integer squared Euclidean norm. More...

double	L1Dist (const FVector &a, const FVector &b)
	Double L1-distance. More...

FVector	log (const FVector &a)
	Pointwise log logs of each coordinate. More...

T	maxNorm (const FVector &v)
	Maximum norm. More...

FVector	mult (const FVector &v, const FVector &w)
	Pointwise multiplication. More...

T	norm (const FVector &v)
	Euclidean norm. More...

T	norm2 (const FVector &v)
	Squared Euclidean norm. More...

FVector	normalized (const FVector &v)
	Euclidean normalization. More...

FVector	operator* (T s, const FVector &v)
	Scalar multiplication. More...

FVector	operator+ (T s, const FVector &v)
	Scalar addition. More...

FVector	operator- (T s, const FVector &v)
	Scalar substraction. More...

FVector	pmax (const FVector &a, const FVector &b)
	Pointwise max. More...

FVector	pmin (const FVector &a, const FVector &b)
	Pointwise min. More...

FVector	sqrt (const FVector &a)
	Pointwise square root Square roots of each coordinate. More...

double	squaredDist (const FVector &a, const FVector &b)
	Squared distance. More...

T	sum (const FVector &v)
	Sum of coordinates. More...

Additional Inherited Members
Public Types inherited from Imagine::FArray< T, dim >
typedef const T *	const_iterator
	Const iterator type.

typedef T *	iterator
	Iterator type.

Protected Attributes inherited from Imagine::FArray< T, dim >
T	_data [S]
	internal storage.

Detailed Description

template<typename T, int dim>
class Imagine::FVector< T, dim >

Fixed size vectors.

Parameters

T	value type
dim	size

Examples:: Common/test/test.cpp, Graphics/test/example.cpp, Graphics/test/particles.cpp, Graphics/test/test.cpp, Images/test/test.cpp, and LinAlg/test/test.cpp.

Constructor & Destructor Documentation

template<typename T, int dim>

Imagine::FVector< T, dim >::FVector ( )

inline

Constructs an uninitialized vector of dim variables of type T

FVector<double,3> a; // uninitialized

template<typename T, int dim>

Imagine::FVector< T, dim >::FVector ( const T & v )

inlineexplicit

Constructs a vector of dim variables of type T, each initialized to v

Parameters

v	value used for initialization

FVector<double,3> b(1.5); // filled with constant value

template<typename T, int dim>

template<typename T2 >

Imagine::FVector< T, dim >::FVector ( const T2 t[dim] )

inline

Constructs from a C array (with a possibly different type)

Parameters

t	C array used for initialization

Template Parameters

T2	value type of a

double tt[]={1,2,3}; // filled from C array

FVector<double,3> c(tt); // (copying array into fresh memory)

template<typename T, int dim>

template<typename T2 >

Imagine::FVector< T, dim >::FVector ( const FArray< T2, dim > & a )

inline

Constructs from another FArray (with a possibly different type)

Parameters

a	FArray to be copied (has to be of the same size)

Template Parameters

T2	value type of a

FVector<double,3> dd(c); // copy constructor

FVector<int,3> di(c); // copy from different type

template<typename T, int dim>

Imagine::FVector< T, dim >::FVector	(	T	x,
		T	y
	)

inline

Short constructor for 2D FVector

Parameters

x	value for index 0 coordinate
y	value for index 1 coordinate

FVector<double,2> e(1.5,2.5); // alias for 2D case

template<typename T, int dim>

Imagine::FVector< T, dim >::FVector	(	T	x,
		T	y,
		T	z
	)

inline

Short constructor for 3D FVector

Parameters

x	value for index 0 coordinate
y	value for index 1 coordinate
z	value for index 2 coordinate

FVector<double,3> f(1.5,2.5,3.5); // alias for 3D case

Member Function Documentation

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::fill ( const T & v )

inline

Fills with constant value

Parameters

v	value to be copied to each element

Returns: self reference

a.fill(1.3); // Fills with constant value

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::normalize ( )

inline

In-place normalization using Euclidean norm

Returns: self reference

dd.normalize(); // Euclidean in-place normalization

template<typename T, int dim>

T Imagine::FVector< T, dim >::operator* ( const FVector< T, dim > & v ) const

inline

Scalar product of FVector

Parameters

v	FVector to be combined with myself

Returns: Scalar product

x=a*b; // scalar product

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator* ( T s ) const

inline

Multiplies each coordinate by a scalar

Parameters

s	The scalar

Returns: Result

c=a*2; // * scalar

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::operator*= ( T s )

inline

Multiplies each coordinate by a scalar

Parameters

s	The scalar

Returns: self reference

c*=2; // *= scalar

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator+ ( const FVector< T, dim > & v ) const

inline

Addition of two FVector

Parameters

v	FVector to be added to myself

Returns: sum

c=a+b; // +

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator+ ( T s ) const

inline

Adds a scalar to each coordinate

Parameters

s	Scalar to be added to myself

Returns: sum

c=a+3.; // + scalar

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::operator+= ( const FVector< T, dim > & v )

inline

In place Addition of FVector

Parameters

v	FVector to be added to myself

Returns: self reference

c+=a; // +=

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::operator+= ( T s )

inline

Adds a scalar to each own coordinate

Parameters

s	Scalar to be added to myself

Returns: self reference

c+=3.; // += scalar

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator- ( const FVector< T, dim > & v ) const

inline

Substraction of two FVector

Parameters

v	FVector to be substracted from myself

Returns: difference

c=a-b; // -

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator- ( T s ) const

inline

Substracts a scalar to each coordinate

Parameters

s	Scalar to be substracted from myself

Returns: difference

c=a-3.; // - scalar

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator- ( ) const

inline

Opposite of a FVector

Returns: Opposite

b=-a; // unary -

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::operator-= ( const FVector< T, dim > & v )

inline

In place Substraction of FVector

Parameters

v	FVector to be substracted from myself

Returns: self reference

c-=a; // -=

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::operator-= ( T s )

inline

Subtracts a scalar to each own coordinate

Parameters

s	Scalar to be substracted from myself

Returns: self reference

c-=3.; // -= scalar

template<typename T, int dim>

FVector Imagine::FVector< T, dim >::operator/ ( T s ) const

inline

Divides each coordinate by a scalar

Parameters

s	The scalar

Returns: Result

x=a*b; // scalar product

template<typename T, int dim>

FVector& Imagine::FVector< T, dim >::operator/= ( T s )

inline

Divides each coordinate by a scalar

Parameters

s	The scalar

Returns: self reference

c/=2; // /= scalar

template<typename T, int dim>

template<typename T2 >

FVector& Imagine::FVector< T, dim >::operator= ( const FArray< T2, dim > & b )

inline

Assigns from another FVector (of possibly different type but same size)

Parameters

b	Source FVector

Template Parameters

T2	value type of b

Returns: self reference

dd=c; // assignment (copies values)

di=c; // assignment from different type

template<typename T, int dim>

T Imagine::FVector< T, dim >::operator^ ( const FVector< T, 2 > & v ) const

inline

Scalar Cross product of 2D FVector (dim must be 2)

Parameters

v	FVector to be combined with myself

Returns: Cross product

x=e^FVector<double,2>(2,1); // 2D cross product

template<typename T, int dim>

FVector<T,3> Imagine::FVector< T, dim >::operator^ ( const FVector< T, 3 > & v ) const

inline

Vector Cross product of 3D FVector (dim must be 3)

Parameters

v	FVector to be combined with myself

Returns: Cross product

c=a^b; // 3D cross product

template<typename T, int dim>

const T& Imagine::FVector< T, dim >::x ( ) const

inline

Alias to element of index 0

Returns: Const reference to Element 0

x=f.x(); // read alias 0

Examples:: Graphics/test/example.cpp, and Graphics/test/particles.cpp.

template<typename T, int dim>

T& Imagine::FVector< T, dim >::x ( )

inline

Alias to element of index 0

Returns: Reference to element 0

f.x()=x; // write alias 0

template<typename T, int dim>

const T& Imagine::FVector< T, dim >::y ( ) const

inline

Alias to element of index 1

Returns: Const reference to Element 1

y=f.y(); // read alias 1

Examples:: Graphics/test/example.cpp, and Graphics/test/particles.cpp.

template<typename T, int dim>

T& Imagine::FVector< T, dim >::y ( )

inline

Alias to element of index 1

Returns: Reference to element 1

f.y()=y; // write alias 1

template<typename T, int dim>

const T& Imagine::FVector< T, dim >::z ( ) const

inline

Alias to element of index 2

Returns: Const reference to Element 2

z=f.z(); // read alias 2

Examples:: Graphics/test/example.cpp, and Graphics/test/particles.cpp.

template<typename T, int dim>

T& Imagine::FVector< T, dim >::z ( )

inline

Alias to element of index 2

Returns: Reference to element 2

f.z()=z; // write alias 2

template<typename T, int dim>

static FVector Imagine::FVector< T, dim >::Zero ( )

inlinestatic

Returns: vector

b=FVector<double,3>::Zero(); // Vector with const 0 value

Friends And Related Function Documentation

template<typename T, int dim>

double dist	(	const FVector< T, dim > &	a,
		const FVector< T, dim > &	b
	)

friend

Distance between two vectors, whatever their type

Parameters

a,b FVector

Returns: Result

x=squaredDist(di,di); // squared distance

template<typename T, int dim>

FVector div	(	const FVector< T, dim > &	v,
		const FVector< T, dim > &	w
	)

friend

Divides coordinates two by two

Parameters

v,w FVector

Returns: v/w

c=div(a,b); // pointwise /

template<typename T, int dim>

double doubleNorm ( const FVector< T, dim > & v )

friend

Double Euclidean norm

Parameters

v argument

Returns: Double Euclidean norm

x=doubleNorm(di); // double Euclidean norm

template<typename T, int dim>

double doubleNorm1 ( const FVector< T, dim > & v )

friend

Double L1-norm

Parameters

v argument

Returns: Double L1-norm

x=doubleNorm1(di); // double L1-norm

template<typename T, int dim>

double doubleNorm2 ( const FVector< T, dim > & v )

friend

Double squared Euclidean norm

Parameters

v argument

Returns: Double squared Euclidean norm

x=doubleNorm2(di); // double squared Euclidean norm

template<typename T, int dim>

FVector exp ( const FVector< T, dim > & a )

friend

Parameters

a FVector

Returns: Result

c=exp(a); // pointwise exp

template<typename T, int dim>

int intL1Dist	(	const FVector< T, dim > &	a,
		const FVector< T, dim > &	b
	)

friend

Integer L1-distance between two vectors with integer coordinates

Parameters

a,b FVector

Returns: Result

x=intL1Dist(di,di); // Integer L1-distance

template<typename T, int dim>

int intNorm1 ( const FVector< T, dim > & v )

friend

Integer L1-Euclidean norm ((to avoid overflow for vectors of char or short ints)

Parameters

v argument

Returns: Integer L1-norm.

i=intNorm1(di); // integer L1-norm

template<typename T, int dim>

int intNorm2 ( const FVector< T, dim > & v )

friend

Integer squared Euclidean norm ((to avoid overflow for vectors of char or short ints)

Parameters

v argument

Returns: Integer squared Euclidean norm

int i=intNorm2(di); // integer squared Euclidean norm

template<typename T, int dim>

double L1Dist	(	const FVector< T, dim > &	a,
		const FVector< T, dim > &	b
	)

friend

Double L1-distance between two vectors, regardless of their type

Parameters

a,b FVector

Returns: Result

x=intL1Dist(di,di); // Integer L1-distance

template<typename T, int dim>

FVector log ( const FVector< T, dim > & a )

friend

Parameters

a FVector

Returns: Result

c=log(a); // pointwise log

template<typename T, int dim>

T maxNorm ( const FVector< T, dim > & v )

friend

Maximum norm

Parameters

v argument

Returns: Maximum norm

x=maxNorm(a); // Maximum norm

template<typename T, int dim>

FVector mult	(	const FVector< T, dim > &	v,
		const FVector< T, dim > &	w
	)

friend

Multiplies coordinates two by two

Parameters

v,w FVector

Returns: v*w

c=mult(a,b); // pointwise *

template<typename T, int dim>

T norm ( const FVector< T, dim > & v )

friend

Euclidean norm (NB: assuming T type is OK)

Parameters

v argument

Returns: Euclidean norm

x=norm2(a); // squared Euclidean norm

template<typename T, int dim>

T norm2 ( const FVector< T, dim > & v )

friend

Squared Euclidean norm (NB: assuming T type is OK)

Parameters

v argument

Returns: squared Euclidean norm

x=norm2(a); // squared Euclidean norm

template<typename T, int dim>

FVector normalized ( const FVector< T, dim > & v )

friend

Normalization using Euclidean norm

Parameters

v	FVector to normalize

Returns: normalized vector

c=normalized(dd); // Euclidean normalization

template<typename T, int dim>

FVector operator*	(	T	s,
		const FVector< T, dim > &	v
	)

friend

Multiplies each coordinate by a scalar

Parameters

s	The scalar
v	The FVector

Returns: The result

c=2.*a; // scalar * FVector

template<typename T, int dim>

FVector operator+	(	T	s,
		const FVector< T, dim > &	v
	)

friend

Adds a scalar to each coordinate

Parameters

s	The scalar
v	The FVector

Returns: The result

c=2.+a; // scalar + FVector

template<typename T, int dim>

FVector operator-	(	T	s,
		const FVector< T, dim > &	v
	)

friend

Substract each coordinate to a scalar

Parameters

s	The scalar
v	The FVector

Returns: The result

c=2.-a; // scalar - FVector

template<typename T, int dim>

FVector pmax	(	const FVector< T, dim > &	a,
		const FVector< T, dim > &	b
	)

friend

Max of each coordinate

Parameters

a,b FVector

Returns: Result

c=pmax(a,b); // pointwise max

template<typename T, int dim>

FVector pmin	(	const FVector< T, dim > &	a,
		const FVector< T, dim > &	b
	)

friend

Min of each coordinate

Parameters

a,b FVector

Returns: Result

c=pmin(a,b); // pointwise min

template<typename T, int dim>

FVector sqrt ( const FVector< T, dim > & a )

friend

Parameters

a FVector

Returns: Result

c=sqrt(a); // pointwise sqrt

template<typename T, int dim>

double squaredDist	(	const FVector< T, dim > &	a,
		const FVector< T, dim > &	b
	)

friend

Squared distance between two vectors, whatever their type

Parameters

a,b FVector

Returns: Result

x=squaredDist(di,di); // squared distance

template<typename T, int dim>

T sum ( const FVector< T, dim > & v )

friend

Sum of coordinates (beware of overflow)

Parameters

v argument

Returns: Result

x=sum(a); // sum of coordinates

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

/Users/pascal/ImagineQt2/Imagine/Common/src/Imagine/Common/FVector.h

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

template<typename T, int dim> class Imagine::FVector< T, dim >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

template<typename T, int dim>
class Imagine::FVector< T, dim >