src/2geom/numeric/vector.h

   1 #ifndef _NL_VECTOR_H_
   2 #define _NL_VECTOR_H_
   3
   4 #include <cassert>
   5 #include <utility>
   6
   7 #include <gsl/gsl_vector.h>
   8
   9
  10 namespace Geom { namespace NL {
  11
  12 class Vector;
  13 void swap(Vector & v1, Vector & v2);
  14
  15
  16 class Vector
  17 {
  18 public:
  19         Vector(size_t n)
  20                 : m_size(n)
  21         {
  22                 m_vector = gsl_vector_alloc(n);
  23         }
  24
  25         Vector(size_t n, double x)
  26                 : m_size(n)
  27         {
  28                 m_vector = gsl_vector_alloc(n);
  29                 gsl_vector_set_all(m_vector, x);
  30         }
  31
  32         // create a vector with n elements all set to zero
  33         // but the i-th that is set to 1
  34         Vector(size_t n, size_t i)
  35                 : m_size(n)
  36         {
  37                 m_vector = gsl_vector_alloc(n);
  38                 gsl_vector_set_basis(m_vector, i);
  39         }
  40
  41         Vector(Vector const& _vector)
  42                 : m_size(_vector.size())
  43         {
  44                 m_vector = gsl_vector_alloc(size());
  45                 gsl_vector_memcpy(m_vector, _vector.m_vector);
  46         }
  47
  48         virtual ~Vector()
  49         {
  50                 gsl_vector_free(m_vector);
  51         }
  52
  53         Vector & operator=(Vector const& _vector)
  54         {
  55                 assert( size() == _vector.size() );
  56                 gsl_vector_memcpy(m_vector, _vector.m_vector);
  57                 return (*this);
  58         }
  59
  60         void set_all(double x = 0)
  61         {
  62                 gsl_vector_set_all(m_vector, x);
  63         }
  64
  65         void set_basis(size_t i)
  66         {
  67                 gsl_vector_set_basis(m_vector, i);
  68         }
  69
  70         double const& operator[](size_t i) const
  71         {
  72                 return *gsl_vector_const_ptr(m_vector, i);
  73         }
  74
  75         double & operator[](size_t i)
  76         {
  77                 return *gsl_vector_ptr(m_vector, i);
  78         }
  79
  80         gsl_vector* get_gsl_vector()
  81         {
  82                 return m_vector;
  83         }
  84
  85         void swap_elements(size_t i, size_t j)
  86         {
  87                 gsl_vector_swap_elements(m_vector, i, j);
  88         }
  89
  90         void reverse()
  91         {
  92                 gsl_vector_reverse(m_vector);
  93         }
  94
  95         Vector & scale(double x)
  96         {
  97                 gsl_vector_scale(m_vector, x);
  98                 return (*this);
  99         }
 100
 101         Vector & translate(double x)
 102         {
 103                 gsl_vector_add_constant(m_vector, x);
 104                 return (*this);
 105         }
 106
 107         Vector & operator+=(Vector const& _vector)
 108         {
 109                 gsl_vector_add(m_vector, _vector.m_vector);
 110                 return (*this);
 111         }
 112
 113         Vector & operator-=(Vector const& _vector)
 114         {
 115                 gsl_vector_sub(m_vector, _vector.m_vector);
 116                 return (*this);
 117         }
 118
 119         bool is_zero() const
 120         {
 121                 return gsl_vector_isnull(m_vector);
 122         }
 123
 124         bool is_positive() const
 125         {
 126                 return gsl_vector_ispos(m_vector);
 127         }
 128
 129         bool is_negative() const
 130         {
 131                 return gsl_vector_isneg(m_vector);
 132         }
 133
 134         bool is_non_negative() const
 135         {
 136                 for ( size_t i = 0; i < size(); ++i )
 137                 {
 138                         if ( (*this)[i] < 0 ) return false;
 139                 }
 140                 return true;
 141         }
 142
 143         double max() const
 144         {
 145                 return gsl_vector_max(m_vector);
 146         }
 147
 148         double min() const
 149         {
 150                 return gsl_vector_min(m_vector);
 151         }
 152
 153         size_t max_index() const
 154         {
 155                 return gsl_vector_max_index(m_vector);
 156         }
 157
 158         size_t min_index() const
 159         {
 160                 return gsl_vector_min_index(m_vector);
 161         }
 162
 163         friend
 164         void swap(Vector & v1, Vector & v2);
 165
 166         size_t size() const
 167         {
 168                 return m_size;
 169         }
 170
 171 private:
 172         size_t m_size;
 173         gsl_vector* m_vector;
 174 };
 175
 176 void swap(Vector & v1, Vector & v2)
 177 {
 178         assert( v1.size() == v2.size() );
 179         std::swap(v1.m_vector, v2.m_vector);
 180 }
 181
 182 } } // end namespaces
 183
 184
 185 #endif /*_NL_VECTOR_H_*/