Changeset 789 for trunk/yat

Timestamp:

Mar 10, 2007, 9:07:13 PM (15 years ago)

Author:

Jari Häkkinen

Message:

Addresses #193. vector now works as outlined here. Added some
functionality. Added a clone function that facilitates resizing of
vectors. clone is needed since assignement operator functionality is
changed.

Location:

trunk/yat

Files:

• classifier/IGP.cc (modified) (1 diff)
• classifier/NCC.cc (modified) (1 diff)
• classifier/utility.cc (modified) (2 diffs)
• regression/Local.cc (modified) (1 diff)
• regression/MultiDimensional.cc (modified) (1 diff)
• regression/MultiDimensionalWeighted.cc (modified) (3 diffs)
• statistics/Score.cc (modified) (3 diffs)
• utility/PCA.cc (modified) (3 diffs)
• utility/vector.cc (modified) (6 diffs)
• utility/vector.h (modified) (3 diffs)

trunk/yat/classifier/IGP.cc

@@ -45 +45 @@
     
     // Calculate IGP for each class
-    igp_=utility::vector(target_.nof_classes());
+    igp_.clone(utility::vector(target_.nof_classes()));
     for(u_int i=0; i<target_.size(); i++) {
       u_int neighbor=i;

trunk/yat/classifier/NCC.cc

@@ -110 +110 @@
                     utility::vector& prediction) const
   {
-    prediction=utility::vector(centroids_.columns());   
+    prediction.clone(utility::vector(centroids_.columns()));
 
     utility::vector value(input.size(),0);

trunk/yat/classifier/utility.cc

@@ -34 +34 @@
   void convert(const DataLookup1D& lookup, utility::vector& vector) 
   {
-    vector=utility::vector(lookup.size());
+    vector.clone(utility::vector(lookup.size()));
     for(u_int i=0; i<lookup.size(); i++)
       vector(i)=lookup(i);
@@ -43 +43 @@
   {
     
-    value=utility::vector(lookup.size());
-    weight=utility::vector(lookup.size());
+    value.clone(utility::vector(lookup.size()));
+    weight.clone(utility::vector(lookup.size()));
     for(u_int i=0; i<lookup.size(); i++){
       value(i)=lookup.data(i);

trunk/yat/regression/Local.cc

@@ -58 +58 @@
 
     size_t nof_fits=data_.size()/step_size;
-    x_= utility::vector(nof_fits);
-    y_predicted_ = utility::vector(x_.size());
-    y_err_ = utility::vector(x_.size());
+    x_.clone(utility::vector(nof_fits));
+    y_predicted_.clone(utility::vector(x_.size()));
+    y_err_.clone(utility::vector(x_.size()));
     sort(data_.begin(), data_.end());
 

trunk/yat/regression/MultiDimensional.cc

@@ -57 +57 @@
     assert(x.rows()==y.size());
     covariance_=utility::matrix(x.columns(),x.columns());
-    fit_parameters_=utility::vector(x.columns());
+    fit_parameters_.clone(utility::vector(x.columns()));
     if (work_)
       gsl_multifit_linear_free(work_);

trunk/yat/regression/MultiDimensionalWeighted.cc

@@ -59 +59 @@
 
     covariance_=utility::matrix(x.columns(),x.columns());
-    fit_parameters_=utility::vector(x.columns());
+    fit_parameters_.clone(utility::vector(x.columns()));
     if (work_)
       gsl_multifit_linear_free(work_);
@@ -85 +85 @@
   }
 
+
   double MultiDimensionalWeighted::predict(const utility::vector& x) const
   {
@@ -90 +91 @@
     return fit_parameters_ * x;
   }
+
 
   double MultiDimensionalWeighted::prediction_error2(const utility::vector& x,

trunk/yat/statistics/Score.cc

@@ -54 +54 @@
   {
     assert(target.size()==value.size());
-    utility::vector a;
+    utility::vector a(value.size());
     classifier::convert(value,a);
     return score(target,a);
@@ -64 +64 @@
   {
     assert(target.size()==value.size());
-    utility::vector a;
-    utility::vector b;
+    utility::vector a(value.size());
+    utility::vector b(value.size());
     classifier::convert(value,a,b);
     return score(target,a,b);
@@ -75 +75 @@
                       const classifier::DataLookup1D& weight) const
   {
-    utility::vector a;
+    utility::vector a(value.size());
     classifier::convert(value,a);
-    utility::vector b;
+    utility::vector b(value.size());
     classifier::convert(weight,a);
     return score(target,a,b);

trunk/yat/utility/PCA.cc

@@ -69 +69 @@
     eigenvectors_ = U;
     eigenvectors_ .transpose();
-    eigenvalues_ = pSVD->s();
+    eigenvalues_.clone(pSVD->s());
 
     // T
@@ -109 +109 @@
     eigenvectors_=V;
     eigenvectors_.transpose();
-    eigenvalues_ = pSVD->s();
+    eigenvalues_.clone(pSVD->s());
 
     // Transform back when done with SVD!
@@ -139 +139 @@
   void PCA::row_center(utility::matrix& A_center)
   {
-    meanvalues_ = utility::vector( A_.rows() );
+    meanvalues_.clone(utility::vector(A_.rows()));
     utility::vector A_row_sum(A_.rows());
     for (size_t i=0; i<A_row_sum.size(); ++i)

trunk/yat/utility/vector.cc

@@ -30 +30 @@
 
 #include <cassert>
+#include <cmath>
 #include <iostream>
 #include <sstream>
@@ -83 +84 @@
       throw utility::GSL_error("vector::vector failed to setup view");
     proxy_v_ = &(view_const_->vector);
-    const_cast<const gsl_vector*>(proxy_v_);
   }
 
@@ -210 +210 @@
 
 
+  const vector& vector::clone(const vector& other)
+  {
+    if (this!=&other) {
+
+      if (view_)
+        delete view_;
+      else if (view_const_)
+        delete view_const_;
+      else if (v_)
+        gsl_vector_free(v_);
+
+      if (other.view_) {
+        view_ = new gsl_vector_view(*other.view_);
+        proxy_v_ = v_ = &(view_->vector);
+      }
+      else if (other.view_const_) {
+        view_const_ = new gsl_vector_const_view(*other.view_const_);
+        proxy_v_ = &(view_const_->vector);
+        v_=NULL;
+      }
+      else if (other.v_)
+        proxy_v_ = v_ = other.create_gsl_vector_copy();
+
+    }
+    return *this;
+  } 
+
+
   void vector::div(const vector& other)
   {
@@ -216 +244 @@
     if (status)
       throw utility::GSL_error(std::string("vector::div",status));
+  }
+
+
+  bool vector::equal(const vector& other, const double d) const
+  {
+    if (this==&other)
+      return true;
+    if (size()!=other.size())
+      return false;
+    // if gsl error handler disabled, out of bounds index will not
+    // abort the program.
+    for (size_t i=0; i<size(); ++i)
+      // The two last condition checks are needed for NaN detection
+      if (fabs( (*this)(i)-other(i) ) > d ||
+          (*this)(i)!=(*this)(i) || other(i)!=other(i))
+        return false;
+    return true;
   }
 
@@ -316 +361 @@
 
 
-  bool vector::operator==(const vector& a) const
-  {
-    if (size()!=a.size())
-      return false;
-    // if gsl error handler disabled, out of bounds index will not
-    // abort the program.
-    for (size_t i=0; i<size(); ++i)
-      if (gsl_vector_get(proxy_v_,i)!=a(i))
-        return false;
-    return true;
+  bool vector::operator==(const vector& other) const
+  {
+    return equal(other);
+  }
+
+
+  bool vector::operator!=(const vector& other) const
+  {
+    return !equal(other);
   }
 
@@ -341 +385 @@
   {
     if( this != &other ) {
-      if (view_)
-        delete view_;
-      else if (view_const_)
-        delete view_const_;
-      else if ( v_ )
-        gsl_vector_free( v_ );
-      proxy_v_ = v_ = other.create_gsl_vector_copy();
+      if (size()!=other.size())
+        throw utility::GSL_error("vector::operator= vector sizes differ");
+      for (size_t i=0; i<size(); ++i)
+        gsl_vector_set(v_, i, other(i));
     }
     return *this;

trunk/yat/utility/vector.h

@@ -219 +219 @@
 
     /**
+       \brief Make a copy of \a other.
+
+       This function will make a deep copy of \a other. Memory is
+       resized and view state is changed if needed.
+    */
+    const vector& clone(const vector& other);
+
+    /**
        \brief This function performs element-wise division, \f$ this_i =
        this_i/other_i \; \forall i \f$.
@@ -225 +233 @@
     */
     void div(const vector& other);
+
+    /**
+       \brief Check whether vectors are equal within a user defined
+       precision, set by \a precision.
+
+       \return True if each element deviates less or equal than \a
+       d. If any vector contain a NaN, false is always returned.
+
+       \see operator== and operator!=
+    */
+    bool equal(const vector&, const double precision=0) const;
 
     ///
@@ -321 +340 @@
     const double& operator[](size_t i) const;
 
-    ///
-    /// Comparison operator. Takes linear time.
-    ///
-    /// @return True if the sequence of the elements in the vectors
-    /// are element/wise equal.
-    ///
+    /**
+       \brief Comparison operator. Takes linear time.
+
+       Checks are performed with exact matching, i.e., rounding off
+       effects may destroy comparison. Use the equal function for
+       comparing elements within a user defined precision.
+
+       \return True if all elements are equal otherwise false.
+
+       \see equal
+    */
     bool operator==(const vector&) const;
+
+    /**
+       \brief Comparison operator. Takes linear time.
+
+       Checks are performed with exact matching, i.e., rounding off
+       effects may destroy comparison. Use the equal function for
+       comparing elements within a user defined precision.
+
+       \return False if all elements are equal otherwise true.
+
+       \see equal
+    */
+    bool operator!=(const vector&) const;
 
     ///