vnl_vector_fixed< T, n > Class Template Reference

#include <vnl_vector_fixed.h>

Detailed Description

template<class T, unsigned int n>
class vnl_vector_fixed< T, n >

Fixed length stack-stored, space-efficient vector.

vnl_vector_fixed is a fixed-length, stack storage vector. It has the same storage size as a C-style array. It is not related via inheritance to vnl_vector. However, it can be converted cheaply to a vnl_vector_ref.

In most cases, a vnl_vector_fixed can be used where a vnl_vector is expected. There are some situations, however, when the automatic conversion cannot be applied. In those cases, you need to call the as_ref() method to perform an explicit conversion. This occurs most often when the called function is templated, since the user-defined conversion operators are then suppressed.

    template<class T>
    void do_something( const vnl_vector<T>& v );
    ...
    vnl_vector_fixed<double,4> my_vec;

    do_something( my_vec );
      // Error: no do_something( vnl_vector_fixed<double,4> ) found

    do_something( my_vec.as_ref() );  // works

Since the conversion operator creates a temporary vnl_vector_ref object, the conversion cannot be used directly to a function that expects a non-const vnl_vector reference. Use vnl_vector_ref::non_const method for this (and only this).

    void mutator( vnl_vector<double>& v );
    ...
    vnl_vector_fixed<double,4> my_vec;
    mutator( my_vec.as_ref().non_const() );

If the mutator only accesses the data, all should be fine. If the mutator attempts to resize the vector, you are doomed.

vnl_vector_fixed defines most of the operators defined by vnl_vector, and does so efficiently. If you try to mix vnl_vector_fixed and vnl_vector, however, you will probably get a vnl_vector result, with the corresponding malloc cost.

Definition at line 84 of file vnl_vector_fixed.h.


Public Types
enum	{ SIZE = n }
typedef vnl_vector_fixed< T, n >	self
typedef unsigned int	size_type
typedef T	element_type
	Type defs for iterators.
typedef T *	iterator
	Type defs for iterators.
typedef T const *	const_iterator
	Const iterator type.
typedef vnl_c_vector< T >::abs_t	abs_t
Public Member Functions
	vnl_vector_fixed ()
	Construct an uninitialized n-vector.
	vnl_vector_fixed (const vnl_vector_fixed< T, n > &rhs)
	Copy constructor.
	vnl_vector_fixed (const vnl_vector< T > &rhs)
	Construct a fixed-n-vector copy of rhs.
	vnl_vector_fixed (const T &v)
	Constructs n-vector with all elements initialised to v.
	vnl_vector_fixed (const T *datablck)
	Construct an fixed-n-vector initialized from datablck.
	vnl_vector_fixed (const T &x0, const T &x1)
	Convenience constructor for 2-D vectors.
	vnl_vector_fixed (const T &x0, const T &x1, const T &x2)
	Convenience constructor for 3-D vectors.
	vnl_vector_fixed (const T &x0, const T &x1, const T &x2, const T &x3)
	Convenience constructor for 4-D vectors.
vnl_vector_fixed< T, n > &	operator= (const vnl_vector_fixed< T, n > &rhs)
	Copy operator.
vnl_vector_fixed< T, n > &	operator= (const vnl_vector< T > &rhs)
	Copy data from a dynamic vector.
unsigned	size () const
	Length of the vector.
void	put (unsigned int i, T const &v)
	Put value at given position in vector.
T	get (unsigned int i) const
	Get value at element i.
void	fill (T const &v)
	Set all values to v.
void	copy_in (T const *ptr)
	Sets elements to ptr[i].
void	copy_out (T *ptr) const
	Copy elements to ptr[i].
void	set (T const *ptr)
	Sets elements to ptr[i].
T &	operator() (unsigned int i)
	Return reference to the element at specified index.
T const &	operator() (unsigned int i) const
	Return reference to the element at specified index.
T &	operator[] (unsigned int i)
	Return the i-th element.
const T &	operator[] (unsigned int i) const
	Return the i-th element.
T const *	data_block () const
	Access the contiguous block storing the elements in the vector.
T *	data_block ()
	Access the contiguous block storing the elements in the vector.
vnl_vector_ref< T >	as_ref ()
	Explicit conversion to a vnl_vector_ref.
const vnl_vector_ref< T >	as_ref () const
	Explicit conversion to a vnl_vector_ref.
	operator const vnl_vector_ref () const
	Cheap conversion to vnl_vector_ref.
iterator	begin ()
	Iterator pointing to start of data.
iterator	end ()
	Iterator pointing to element beyond end of data.
const_iterator	begin () const
	Iterator pointing to start of data.
const_iterator	end () const
	Iterator pointing to element beyond end of data.
vnl_vector_fixed< T, n >	apply (T(*f)(T))
	Apply f to each element.
vnl_vector_fixed< T, n >	apply (T(*f)(const T &))
	Apply f to each element.
vnl_vector_fixed< T, n > &	operator+= (T s)
vnl_vector_fixed< T, n > &	operator-= (T s)
vnl_vector_fixed< T, n > &	operator *= (T s)
vnl_vector_fixed< T, n > &	operator/= (T s)
vnl_vector_fixed< T, n > &	operator+= (const vnl_vector_fixed< T, n > &v)
vnl_vector_fixed< T, n > &	operator-= (const vnl_vector_fixed< T, n > &v)
vnl_vector_fixed< T, n > &	operator+= (const vnl_vector< T > &v)
vnl_vector_fixed< T, n > &	operator-= (const vnl_vector< T > &v)
vnl_vector_fixed< T, n >	operator- () const
vnl_vector< T >	extract (unsigned int len, unsigned int start=0) const
	Returns a subvector specified by the start index and length. O(n).
vnl_vector< T >	as_vector () const
	Convert to a vnl_vector.
vnl_vector_fixed &	update (vnl_vector< T > const &, unsigned int start=0)
	Replaces elements with index beginning at start, by values of v. O(n).
abs_t	squared_magnitude () const
	Return sum of squares of elements.
abs_t	magnitude () const
	Return magnitude (length) of vector.
abs_t	one_norm () const
	Return sum of absolute values of the elements.
abs_t	two_norm () const
	Return sqrt of sum of squares of values of elements.
abs_t	inf_norm () const
	Return largest absolute element value.
vnl_vector_fixed< T, n > &	normalize ()
	Normalise by dividing through by the magnitude.
abs_t	rms () const
	Root Mean Squares of values.
T	min_value () const
	Smallest value.
T	max_value () const
	Largest value.
unsigned	arg_min () const
	Location of smallest value.
unsigned	arg_max () const
	Location of largest value.
T	mean () const
	Mean of values in vector.
T	sum () const
	Sum of values in a vector.
void	flip ()
	Reverse the order of the elements.
void	assert_size (unsigned sz) const
	Check that size()==sz if not, abort();.
void	assert_finite () const
	Check that this is finite if not, abort();.
bool	is_finite () const
	Return true if its finite.
bool	is_zero () const
	Return true iff all the entries are zero.
bool	empty () const
	Return true iff the size is zero.
bool	operator_eq (vnl_vector_fixed< T, n > const &v) const
	Return true if *this == v.
bool	operator_eq (vnl_vector< T > const &v) const
	Return true if *this == v.
bool	read_ascii (vcl_istream &s)
	Read from text stream.
void	print (vcl_ostream &s) const
	Display the vector.
Static Public Member Functions
static void	add (const T a, const T b, T *r)
static void	add (const T a, T b, T r)
static void	sub (const T a, const T b, T *r)
static void	sub (const T a, T b, T r)
static void	sub (T a, const T b, T r)
static void	mul (const T a, const T b, T *r)
static void	mul (const T a, T b, T r)
static void	div (const T a, const T b, T *r)
static void	div (const T a, T b, T r)
Protected Attributes
T	data_ [n]
Private Member Functions
void	assert_finite_internal () const
	See assert_finite().
Related Functions
(Note that these are not member functions.)
void	vsl_b_write (vsl_b_ostream &os, const vnl_vector_fixed< T, n > &v)
	Binary save vnl_vector_fixed to stream.
void	vsl_b_read (vsl_b_istream &is, vnl_vector_fixed< T, n > &v)
	Binary load vnl_vector_fixed from stream.
void	vsl_print_summary (vcl_ostream &os, const vnl_vector_fixed< T, n > &b)
	Print human readable summary of object to a stream.
T	vnl_cross_2d (const vnl_vector_fixed< T, 2 > &v1, const vnl_vector_fixed< T, 2 > &v2)
	Compute the 2-D cross product.
T	vnl_cross_2d (vnl_vector_fixed< T, 2 > const &v1, vnl_vector< T > const &v2)
	Compute the 2-D cross product.
T	vnl_cross_2d (vnl_vector< T > const &v1, vnl_vector_fixed< T, 2 > const &v2)
	Compute the 2-D cross product.
vnl_vector_fixed< T, 3 >	vnl_cross_3d (const vnl_vector_fixed< T, 3 > &v1, const vnl_vector_fixed< T, 3 > &v2)
	Compute the 3-D cross product.
vnl_vector_fixed< T, n >	vnl_cross_3d (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
	Compute the 3-D cross product.
vnl_vector_fixed< T, n >	vnl_cross_3d (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
	Compute the 3-D cross product.
vnl_vector_fixed< T, N >	operator * (vnl_diag_matrix_fixed< T, N > const &D, vnl_vector_fixed< T, N > const &A)
	Multiply a vnl_diag_matrix_fixed by a vnl_vector_fixed. n flops.
vnl_vector_fixed< T, N >	operator * (vnl_vector_fixed< T, N > const &A, vnl_diag_matrix_fixed< T, N > const &D)
	Multiply a vnl_vector_fixed by a vnl_diag_matrix_fixed. n flops.
double	vnl_cross_2d (vnl_double_2 const &v1, vnl_double_2 const &v2)
	Cross product of two 2-vectors.
vnl_double_3	vnl_cross_3d (vnl_double_3 const &v1, vnl_double_3 const &v2)
	Cross product of two 3-vectors.
float	vnl_cross_2d (vnl_float_2 const &v1, vnl_float_2 const &v2)
	Cross product of two 2-vectors.
vnl_float_3	vnl_cross_3d (vnl_float_3 const &v1, vnl_float_3 const &v2)
	Cross product of two 3-vectors.
vnl_double_3	operator+ (const vnl_double_3 &a, const vnl_double_3 &b)
	The binary addition operator.
vcl_ostream &	vnl_matlab_print (vcl_ostream &, vnl_vector_fixed< T, n > const &, char const *variable_name=0, vnl_matlab_print_format=vnl_matlab_print_format_default)
	print a vnl_vector_fixed<T>.
vnl_matrix_fixed< T, m, n >	outer_product (vnl_vector_fixed< T, m > const &a, vnl_vector_fixed< T, n > const &b)
bool	operator< (vnl_vector_fixed< T, n > const &lhs, vnl_vector_fixed< T, n > const &rhs)
	Define a complete ordering on vnl_vector_fixed.
vnl_vector_fixed< T, n >	operator+ (const vnl_vector_fixed< T, n > &v, T s)
vnl_vector_fixed< T, n >	operator+ (const T &s, const vnl_vector_fixed< T, n > &v)
vnl_vector_fixed< T, n >	operator- (const vnl_vector_fixed< T, n > &v, T s)
vnl_vector_fixed< T, n >	operator- (const T &s, const vnl_vector_fixed< T, n > &v)
vnl_vector_fixed< T, n >	operator * (const vnl_vector_fixed< T, n > &v, T s)
vnl_vector_fixed< T, n >	operator * (const T &s, const vnl_vector_fixed< T, n > &v)
vnl_vector_fixed< T, n >	operator/ (const vnl_vector_fixed< T, n > &v, T s)
vnl_vector_fixed< T, n >	operator+ (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector< T >	operator+ (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
vnl_vector< T >	operator+ (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector_fixed< T, n >	operator- (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector< T >	operator- (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
vnl_vector< T >	operator- (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector_fixed< T, n >	element_product (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector< T >	element_product (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
vnl_vector< T >	element_product (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector_fixed< T, n >	element_quotient (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
vnl_vector< T >	element_quotient (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
vnl_vector< T >	element_quotient (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
T	dot_product (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
T	dot_product (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
T	dot_product (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
vnl_matrix< T >	outer_product (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
vnl_matrix< T >	outer_product (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
T	angle (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
T	angle (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
T	angle (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
T	vnl_vector_ssd (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
T	vnl_vector_ssd (const vnl_vector_fixed< T, n > &a, const vnl_vector< T > &b)
T	vnl_vector_ssd (const vnl_vector< T > &a, const vnl_vector_fixed< T, n > &b)
bool	operator== (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
bool	operator== (vnl_vector_fixed< T, n > const &a, vnl_vector< T > const &b)
bool	operator== (vnl_vector< T > const &a, vnl_vector_fixed< T, n > const &b)
bool	operator!= (const vnl_vector_fixed< T, n > &a, const vnl_vector_fixed< T, n > &b)
bool	operator!= (vnl_vector_fixed< T, n > const &a, vnl_vector< T > const &b)
bool	operator!= (vnl_vector< T > const &a, vnl_vector_fixed< T, n > const &b)
vcl_ostream &	operator<< (vcl_ostream &ostr, const vnl_vector_fixed< T, n > &v)
vcl_istream &	operator>> (vcl_istream &ostr, vnl_vector_fixed< T, n > &v)
vnl_vector_fixed< T, n >	operator+ (const vnl_vector_fixed_ref_const< T, n > &v, T s)

vnl_vector_fixed< T, n >	operator+ (T s, const vnl_vector_fixed_ref_const< T, n > &v)

vnl_vector_fixed< T, n >	operator- (const vnl_vector_fixed_ref_const< T, n > &v, T s)

vnl_vector_fixed< T, n >	operator- (T s, const vnl_vector_fixed_ref_const< T, n > &v)

vnl_vector_fixed< T, n >	operator * (const vnl_vector_fixed_ref_const< T, n > &v, T s)

vnl_vector_fixed< T, n >	operator * (T s, const vnl_vector_fixed_ref_const< T, n > &v)

vnl_vector_fixed< T, n >	operator/ (const vnl_vector_fixed_ref_const< T, n > &v, T s)

vnl_vector_fixed< T, n >	operator+ (const vnl_vector_fixed_ref_const< T, n > &a, const vnl_vector_fixed_ref_const< T, n > &b)

vnl_vector_fixed< T, n >	operator- (const vnl_vector_fixed_ref_const< T, n > &a, const vnl_vector_fixed_ref_const< T, n > &b)

vcl_ostream &	operator<< (vcl_ostream &o, const vnl_vector_fixed_ref_const< T, n > &v)

vcl_istream &	operator>> (vcl_istream &i, const vnl_vector_fixed_ref< T, n > &v)

void	x_write (vcl_ostream &os, const vnl_vector_fixed< T, n > &v, vcl_string name="vnl_vector_fixed")
	XML save vnl_vector_fixed to stream.