vnl_vector.h

InsightToolkit-1.4.0(有大量的优化算法程序)

// This is core/vnl/vnl_vector.h
#ifndef vnl_vector_h_
#define vnl_vector_h_
#ifdef VCL_NEEDS_PRAGMA_INTERFACE
#pragma interface
#endif
//:
// \file
// \author Andrew W. Fitzgibbon
//
// \verbatim
// Modifications
// Comments re-written by Tim Cootes, for his sins.
//   Feb.2002 - Peter Vanroose - brief doxygen comment placed on single line
// \endverbatim

#include <vcl_iosfwd.h>
#include <vnl/vnl_tag.h>
#include <vnl/vnl_c_vector.h>
#ifndef NDEBUG
# include <vnl/vnl_error.h>
# include "vnl_config.h"
# if VNL_CONFIG_CHECK_BOUNDS
#  include <vcl_cassert.h>
# endif
#else
# undef VNL_CONFIG_CHECK_BOUNDS
# define VNL_CONFIG_CHECK_BOUNDS 0
# undef ERROR_CHECKING
#endif

#include <vxl_config_itk.h>

export template <class T> class vnl_vector;
export template <class T> class vnl_matrix;


typedef vnl_vector<double> vnl_vecd;
typedef vnl_vector<float> vnl_vecf;
//----------------------------------------------------------------------

#define v vnl_vector<T>
#define m vnl_matrix<T>
template <class T> T      dot_product (v const&, v const&);
template <class T> T      inner_product (v const&, v const&);
template <class T> T      bracket (v const &, m const &, v const &);
template <class T> T      cos_angle(v const&, v const& );
template <class T> double angle (v const&, v const&);
template <class T> m      outer_product (v const&, v const&);
template <class T> v      operator+(T, v const&);
template <class T> v      operator-(T, v const&);
template <class T> v      operator*(T, v const&);
// also exists as method: template <class T> v      operator*(m const&, v const&);
template <class T> v      operator*(v const&, m const&);
template <class T> v      element_product(v const&,v const&);
template <class T> v      element_quotient(v const&,v const&);
template <class T> T      cross_2d (v const&, v const&);
template <class T> v      cross_3d (v const&, v const&);
template <class T> T      vnl_vector_ssd(v const&, v const&);
template <class T> void   swap(v &, v &);
#undef v
#undef m

//----------------------------------------------------------------------

//: Mathematical vector class, templated by type of element.
// The vnl_vector<T> class implements one-dimensional arithmetic
// vectors to be used with the vnl_matrix<T> class. vnl_vector<T>
// has size fixed by constructor time or changed by assignment
// operator.
// For faster, non-mallocing vectors with size known at compile
// time, use vnl_vector_fixed* or vnl_T_n (e.g. vnl_double_3).
//
// NOTE: Vectors are indexed from zero!  Thus valid elements are [0,size()-1].
#ifdef VXL_CXX_SLICED_DESTRUCTOR_BUG
class vnl_vector_base_own
{
public:
  vnl_vector_base_own(): vnl_vector_own_data(1) {}
protected:
  int vnl_vector_own_data;
};

template<class T>
class vnl_vector: public vnl_vector_base_own
#else
template<class T>
class vnl_vector
#endif
{
 public:
  friend class vnl_matrix<T>;

  //: Creates an empty vector. O(1).
  vnl_vector () : num_elmts(0) , data(0) {}

  //: Creates vector containing n elements.
  // Elements are not initialized.
  explicit vnl_vector (unsigned len);

  //: Creates vector of len elements, all set to v0
  vnl_vector (unsigned len, T const& v0);

  //: Creates a vector of specified length and initialize first n elements with values. O(n).
  vnl_vector (unsigned len, int n, T const values[]);
 private: // deprecated!
  //: Creates a vector of length 3 and initializes with the arguments, x,y,z.
  vnl_vector (T const&, T const&, T const&);
 public:
  //: Create n element vector and copy data from data_block
  vnl_vector (T const* data_block,unsigned int n);

  //: Copy constructor
  vnl_vector (vnl_vector<T> const&);

#ifndef VXL_DOXYGEN_SHOULD_SKIP_THIS 
// <internal>
  // These constructors are here so that operator* etc can take
  // advantage of the C++ return value optimization.
  vnl_vector (vnl_vector<T> const &, vnl_vector<T> const &, vnl_tag_add); // v + v
  vnl_vector (vnl_vector<T> const &, vnl_vector<T> const &, vnl_tag_sub); // v - v
  vnl_vector (vnl_vector<T> const &, T,                     vnl_tag_mul); // v * s
  vnl_vector (vnl_vector<T> const &, T,                     vnl_tag_div); // v / s
  vnl_vector (vnl_vector<T> const &, T,                     vnl_tag_add); // v + s
  vnl_vector (vnl_vector<T> const &, T,                     vnl_tag_sub); // v - s
  vnl_vector (vnl_matrix<T> const &, vnl_vector<T> const &, vnl_tag_mul); // M * v
  vnl_vector (vnl_vector<T> const &, vnl_matrix<T> const &, vnl_tag_mul); // v * M
  vnl_vector (vnl_vector<T> &that, vnl_tag_grab)
    : num_elmts(that.num_elmts), data(that.data)
  { that.num_elmts=0; that.data=0; } // "*this" now uses "that"'s data.
// </internal>
#endif

  //: Destructor
  ~vnl_vector() { if (data) destroy(); }

  //: Return the length, number of elements, dimension of this vector.
  unsigned size() const { return num_elmts; }

  //: Put value at given position in vector.
  inline void put (unsigned int i, T const&);

  //: Get value at element i
  inline T get (unsigned int i) const;

  //: Set all values to v
  void fill (T const& v);

  //: Sets elements to ptr[i]
  //  Note: ptr[i] must be valid for i=0..size()-1
  void copy_in(T const * ptr);

  //: Copy elements to ptr[i]
  //  Note: ptr[i] must be valid for i=0..size()-1
  void copy_out(T *) const; // from vector to array[].


  //: Sets elements to ptr[i]
  //  Note: ptr[i] must be valid for i=0..size()-1
  void set (T const *ptr) { copy_in(ptr); }

  //: Return reference to the element at specified index.
  // There are assert style boundary checks - #define NDEBUG to turn them off.
  T       & operator() (unsigned int i)
  {
#if VNL_CONFIG_CHECK_BOUNDS  && (!defined NDEBUG)
    assert(i<size());   // Check the index is valid.
#endif
    return data[i];
  }
  //: Return reference to the element at specified index. No range checking.
  // There are assert style boundary checks - #define NDEBUG to turn them off.
  T const & operator() (unsigned int i) const
  {
#if VNL_CONFIG_CHECK_BOUNDS  && (!defined NDEBUG)
    assert(i<size());   // Check the index is valid
#endif
    return data[i];
  }

  //: Return reference to the element at specified index. No range checking.
  T       & operator[] (unsigned int i) { return data[i]; }
  //: Return reference to the element at specified index. No range checking.
  T const & operator[] (unsigned int i) const { return data[i]; }

  //: Set all elements to value v
  vnl_vector<T>& operator= (T const&v) { fill(v); return *this; }

  //: Copy operator
  vnl_vector<T>& operator= (vnl_vector<T> const& rhs);

  //: Add scalar value to all elements
  vnl_vector<T>& operator+= (T );

  //: Subtract scalar value from all elements
  vnl_vector<T>& operator-= (T value) { return *this += (-value); }

  //: Multiply all elements by scalar
  vnl_vector<T>& operator*= (T );

  //: Divide all elements by scalar
  vnl_vector<T>& operator/= (T );

  //: Add rhs to this and return *this
  vnl_vector<T>& operator+= (vnl_vector<T> const& rhs);

  //: Subtract rhs from this and return *this
  vnl_vector<T>& operator-= (vnl_vector<T> const& rhs);

  //: *this = M*(*this) where M is a suitable matrix.
  //  this is treated as a column vector
  vnl_vector<T>& pre_multiply (vnl_matrix<T> const& M);

  //: *this = (*this)*M where M is a suitable matrix.
  //  this is treated as a row vector
  vnl_vector<T>& post_multiply (vnl_matrix<T> const& M);

  //: *this = (*this)*M where M is a suitable matrix.
  //  this is treated as a row vector
  vnl_vector<T>& operator*= (vnl_matrix<T> const& m) { return this->post_multiply(m); }

  //: Unary plus operator
  // Return new vector = (*this)
  vnl_vector<T> operator+ () const { return *this; }

  //: Unary minus operator
  // Return new vector = -1*(*this)
  vnl_vector<T> operator- () const;

  vnl_vector<T> operator+ (T v) const { return vnl_vector<T>(*this, v, vnl_tag_add()); }
  vnl_vector<T> operator- (T v) const { return vnl_vector<T>(*this, v, vnl_tag_sub()); }
  vnl_vector<T> operator* (T v) const { return vnl_vector<T>(*this, v, vnl_tag_mul()); }
  vnl_vector<T> operator/ (T v) const { return vnl_vector<T>(*this, v, vnl_tag_div()); }

  vnl_vector<T> operator+ (vnl_vector<T> const& v) const { return vnl_vector<T>(*this, v, vnl_tag_add()); }
  vnl_vector<T> operator- (vnl_vector<T> const& v) const { return vnl_vector<T>(*this, v, vnl_tag_sub()); }
  vnl_vector<T> operator* (vnl_matrix<T> const& M) const { return vnl_vector<T>(*this, M, vnl_tag_mul()); }

  //--------------------------------------------------------------------------------

  //: Access the contiguous block storing the elements in the vector. O(1).
  //  data_block()[0] is the first element of the vector
  T const* data_block () const { return data; }

  //: Access the contiguous block storing the elements in the vector. O(1).
  //  data_block()[0] is the first element of the vector
  T      * data_block () { return data; }

  //: Type defs for iterators
  typedef T element_type;
  //: Type defs for iterators
  typedef T       *iterator;
  //: Iterator pointing to start of data
  iterator begin() { return data; }

  //: Iterator pointing to element beyond end of data
  iterator end() { return data+num_elmts; }

  //: Const iterator type
  typedef T const *const_iterator;
  //: Iterator pointing to start of data
  const_iterator begin() const { return data; }
  //: Iterator pointing to element beyond end of data
  const_iterator end() const { return data+num_elmts; }