Relocated "fill*" methods

README.md

@@ -19,6 +19,7 @@ We are using the following technologies in our project,
 4. Google Test
 5. Boost.Python
 
+
 Building from source
 --------------------
 **Linux**
@@ -103,3 +104,4 @@ Please follow the rules and guidelines given below,
 4. Follow the Pull Request policy given [here](https://github.com/codezonediitj/adaboost/wiki/Pull-Request-Policy). All changes are made through Pull Requests, no direct commits to the master branch.
 
 Keep contributing!!
+=======

adaboost/core/data_structures.hpp

@@ -66,14 +66,6 @@ namespace adaboost
                 void set(unsigned int index,
                          data_type_vector value);
 
-                /*
-                * Used for filling the vector with a given value.
-                *
-                * @param value The value with which the vector is
-                *    to be populated.
-                */
-                void fill(data_type_vector value);
-
                 /*
                 * Used for obtaining the size of the vector.
                 */
@@ -158,14 +150,6 @@ namespace adaboost
                          unsigned int y,
                          data_type_matrix value);
 
-                /*
-                * Used for filling the matrix with a given value.
-                *
-                * @param value The value with which the matrix is
-                *    to be populated.
-                */
-                void fill(data_type_matrix value);
-
                 /*
                 * Used for obtaining number of rows in the vector.
                 */
@@ -184,43 +168,6 @@ namespace adaboost
                 ~Matrix();
         };
 
-        /* @overload
-        * Used for taking dot product of two vectors.
-        *
-        * @param vec1 First vector in dot product.
-        * @param vec2 Second vector in dot product.
-        * @param result For storing the result.
-        */
-        template <class data_type_vector>
-        void product(const Vector<data_type_vector>& vec1,
-                     const Vector<data_type_vector>& vec2,
-                     data_type_vector& result);
-
-        /* @overload
-        * Used for multiplying a vector
-        * and a matrix.
-        *
-        * @param vec The vector.
-        * @param mat The matrix.
-        * @param result A vector for storing the result.
-        */
-        template <class data_type_vector, class data_type_matrix>
-        void multiply(const Vector<data_type_vector>& vec,
-                     const Matrix<data_type_matrix>& mat,
-                     Vector<data_type_vector>& result);
-
-        /* @overload
-        * Used for multiplyng two matrices.
-        *
-        * @param vec1 First matrix.
-        * @param vec2 Second matrix.
-        * @param result A matrix for storing the result.
-        */
-        template <class data_type_matrix>
-        void multiply(const Matrix<data_type_matrix>& mat1,
-                      const Matrix<data_type_matrix>& mat2,
-                      Matrix<data_type_matrix>& result);
-
     } // namespace core
 } // namespace adaboost
 

adaboost/core/data_structures_impl.cpp

@@ -51,16 +51,6 @@ namespace adaboost
             this->data[index] = value;
         }
 
-        template <class data_type_vector>
-        void Vector<data_type_vector>::
-        fill(data_type_vector value)
-        {
-            for(unsigned int i = 0; i < this->size; i++)
-            {
-                this->data[i] = value;
-            }
-        }
-
         template <class data_type_vector>
         unsigned int Vector<data_type_vector>::get_size() const
         {
@@ -133,19 +123,6 @@ namespace adaboost
             this->data[x*this->cols + y] = value;
         }
 
-        template <class data_type_matrix>
-        void Matrix<data_type_matrix>::
-        fill(data_type_matrix value)
-        {
-            for(unsigned int i = 0; i < this->rows; i++)
-            {
-                for(unsigned int j = 0; j < this->cols; j++)
-                {
-                    this->data[i*this->cols + j] = value;
-                }
-            }
-        }
-
         template <class data_type_matrix>
         unsigned int Matrix<data_type_matrix>::
         get_rows() const
@@ -176,60 +153,6 @@ namespace adaboost
             }
         }
 
-        template <class data_type_vector>
-        void product(const Vector<data_type_vector>& vec1,
-                     const Vector<data_type_vector>& vec2,
-                     data_type_vector& result)
-        {
-            adaboost::utils::check(vec1.get_size() == vec2.get_size(),
-                                   "Size of vectors don't match.");
-            result = 0;
-            for(unsigned int i = 0; i < vec1.get_size(); i++)
-            {
-                result += (vec1.at(i)*vec2.at(i));
-            }
-        }
-
-        template <class data_type_vector, class data_type_matrix>
-        void multiply(const Vector<data_type_vector>& vec,
-                     const Matrix<data_type_matrix>& mat,
-                     Vector<data_type_vector>& result)
-        {
-            adaboost::utils::check(vec.get_size() == mat.get_rows(),
-                                  "Orders mismatch in the inputs.");
-            for(unsigned int j = 0; j < mat.get_cols(); j++)
-            {
-                data_type_vector _result = 0;
-                for(unsigned int i = 0; i < mat.get_rows(); i++)
-                {
-                    _result += (vec.at(i)*mat.at(i, j));
-                }
-                result.set(j, _result);
-            }
-        }
-
-        template <class data_type_matrix>
-        void multiply(const Matrix<data_type_matrix>& mat1,
-                     const Matrix<data_type_matrix>& mat2,
-                     Matrix<data_type_matrix>& result)
-        {
-            adaboost::utils::check(mat1.get_cols() == mat2.get_rows(),
-                                    "Order of matrices don't match.");
-            unsigned int common_cols = mat1.get_cols();
-            for(unsigned int i = 0; i < result.get_rows(); i++)
-            {
-                for(unsigned int j = 0; j < result.get_cols(); j++)
-                {
-                    data_type_matrix _result = 0;
-                    for(unsigned int k = 0; k < common_cols; k++)
-                    {
-                        _result += (mat1.at(i, k)*mat2.at(k, j));
-                    }
-                    result.set(i, j, _result);
-                }
-            }
-        }
-
         #include "instantiated_templates_data_structures.hpp"
 
     } // namespace core

adaboost/core/operations.hpp

@@ -7,6 +7,120 @@ namespace adaboost
 {
     namespace core
     {
+        /* @overload
+        * Used for filling the vector with a given value.
+        *
+        * @param value The value with which the vector is
+        *    to be populated.
+        * @param vec The Vector    
+        */
+        template <class data_type_vector>
+        void fill(const data_type_vector value,
+		  const Vector<data_type_vector>& vec);
+
+        /*
+        * Used for taking dot product of two vectors.
+        *
+        * @param vec1 First vector in dot product.
+        * @param vec2 Second vector in dot product.
+        * @param result For storing the result.
+        */
+        template <class data_type_vector>
+        void product(const Vector<data_type_vector>& vec1,
+                     const Vector<data_type_vector>& vec2,
+                     data_type_vector& result);
+
+        /*@overload
+        * Used for filling the vector with a given value.
+        * If block size is passed 0 then the values are
+        * filled on the CPU otherwise they are filled on
+        * GPU.
+        *
+        * @param value The value with which the vector is
+        *    to be populated.
+	* @param vec The Vector
+        * @param block_size The number of threads to be
+        *    launched per block on GPU.
+        */
+        template <class data_type_vector>
+        void fill(const data_type_vector value,
+	          const VectorGPU<data_type_vector>& vec,
+                  unsigned block_size=0);
+
+	 /*
+	 * This function computes
+	 * dot product of two vectors on
+	 * GPU.
+	 */
+	 template <class data_type_vector>
+	 void product_gpu(const VectorGPU<data_type_vector>& vec1,
+		          const VectorGPU<data_type_vector>& vec2,
+		          data_type_vector& result,
+		          unsigned block_size=0);
+
+
+        /* @overload
+        * Used for filling the matrix with a given value.
+        *
+        * @param value The value with which the matrix is
+        *    to be populated.
+        * @param mat The Matrix
+        */
+        template <class data_type_matrix>
+        void fill(const data_type_matrix value,
+		  const Matrix<data_type_matrix>& mat);
+
+        /* @overload
+        * Used for multiplyng two matrices.
+        *
+        * @param vec1 First matrix.
+        * @param vec2 Second matrix.
+        * @param result A matrix for storing the result.
+        */
+        template <class data_type_matrix>
+        void multiply(const Matrix<data_type_matrix>& mat1,
+                      const Matrix<data_type_matrix>& mat2,
+                      Matrix<data_type_matrix>& result);
+
+        /* @overload
+        * Used for multiplying a vector
+        * and a matrix.
+        *
+        * @param vec The vector.
+        * @param mat The matrix.
+        * @param result A vector for storing the result.
+        */
+        template <class data_type_vector, class data_type_matrix>
+        void multiply(const Vector<data_type_vector>& vec,
+                      const Matrix<data_type_matrix>& mat,
+                      Vector<data_type_vector>& result);
+
+        /*@overload
+        * Used for filling the matrix with a given value.
+        * If block size x and block size y is passed 0 and 0 then the values are
+        * filled on the CPU otherwise they are filled on
+        * GPU.
+        *
+        * @param value The value with which the matrix is
+        *    to be populated.
+	* @param mat The matrix
+        */
+        template <class data_type_matrix>
+        void fill(const data_type_matrix value,
+		  const MatrixGPU<data_type_matrix>& mat,
+                  unsigned block_size_x=0,
+                  unsigned block_size_y=0);
+
+	/*
+	* This function is
+	* used for multiplyng two matrices on
+	* GPU.
+	*/
+	template <class data_type_matrix>
+        void multiply_gpu(const MatrixGPU<data_type_matrix>& mat1,
+                          const MatrixGPU<data_type_matrix>& mat2,
+                          MatrixGPU<data_type_matrix>& result);
+
         /*
         * This function computes the sum of
         * elements of the given vector and the
@@ -53,6 +167,8 @@ namespace adaboost
         const Vector<data_type_1>& vec,
         data_type_1& result);
 
+
+
     } // namespace core
 } // namespace adaboost