boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/ublas/opencl/transpose.hpp

@@ -0,0 +1,142 @@
+// Boost.uBLAS
+//
+// Copyright (c) 2018 Fady Essam
+// Copyright (c) 2018 Stefan Seefeld
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef boost_numeric_ublas_opencl_transpose_hpp_
+#define boost_numeric_ublas_opencl_transpose_hpp_
+
+#include <boost/numeric/ublas/opencl/library.hpp>
+#include <boost/numeric/ublas/opencl/vector.hpp>
+#include <boost/numeric/ublas/opencl/matrix.hpp>
+
+// Kernel for transposition of various data types
+#define OPENCL_TRANSPOSITION_KERNEL(DATA_TYPE)	\
+"__kernel void transpose(__global "  #DATA_TYPE "* in, __global " #DATA_TYPE "* result, unsigned int width, unsigned int height) \n"                       \
+"{ \n"								        \
+"  unsigned int column_index = get_global_id(0); \n"			\
+"  unsigned int row_index = get_global_id(1); \n"			\
+"  if (column_index < width && row_index < height) \n"			\
+"  { \n"							      	\
+"    unsigned int index_in = column_index + width * row_index; \n"	\
+"    unsigned int index_result = row_index + height * column_index; \n"	\
+"    result[index_result] = in[index_in]; \n"				\
+"  } \n"								\
+"} \n"
+
+
+namespace boost { namespace numeric { namespace ublas { namespace opencl {
+
+template<class T, class L1, class L2>
+typename std::enable_if<is_numeric<T>::value>::type
+change_layout(ublas::matrix<T, L1, opencl::storage> const &m,
+	      ublas::matrix<T, L2, opencl::storage> &result,
+	      compute::command_queue& queue)
+{
+  assert(m.size1() == result.size1() && m.size2() == result.size2());
+  assert(m.device() == result.device() && m.device() == queue.get_device());
+  assert(!(std::is_same<L1, L2>::value));
+  char const *kernel;
+  if (std::is_same<T, float>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(float);
+  else if (std::is_same<T, double>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(double);
+  else if (std::is_same<T, std::complex<float>>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(float2);
+  else if (std::is_same<T, std::complex<double>>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(double2);
+  size_t len = strlen(kernel);
+  cl_int err;
+  cl_context c_context = queue.get_context().get();
+  cl_program program = clCreateProgramWithSource(c_context, 1, &kernel, &len, &err);
+  clBuildProgram(program, 1, &queue.get_device().get(), NULL, NULL, NULL);
+  cl_kernel c_kernel = clCreateKernel(program, "transpose", &err);
+  size_t width = std::is_same < L1, ublas::basic_row_major<>>::value ? m.size2() : m.size1();
+  size_t height = std::is_same < L1, ublas::basic_row_major<>>::value ? m.size1() : m.size2();
+  size_t global_size[2] = { width , height };
+  clSetKernelArg(c_kernel, 0, sizeof(T*), &m.begin().get_buffer().get());
+  clSetKernelArg(c_kernel, 1, sizeof(T*), &result.begin().get_buffer().get());
+  clSetKernelArg(c_kernel, 2, sizeof(unsigned int), &width);
+  clSetKernelArg(c_kernel, 3, sizeof(unsigned int), &height);
+  cl_command_queue c_queue = queue.get();
+  cl_event event = NULL;
+  clEnqueueNDRangeKernel(c_queue, c_kernel, 2, NULL, global_size, NULL, 0, NULL, &event);
+  clWaitForEvents(1, &event);
+}
+
+template<class T, class L1, class L2, class A>
+typename std::enable_if<is_numeric<T>::value>::type
+change_layout(ublas::matrix<T, L1, A> const &m,
+	      ublas::matrix<T, L2, A> &result,
+	      compute::command_queue& queue)
+{
+  ublas::matrix<T, L1, opencl::storage> mdev(m, queue);
+  ublas::matrix<T, L2, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
+  change_layout(mdev, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template<class T, class L>
+typename std::enable_if<is_numeric<T>::value>::type
+trans(ublas::matrix<T, L, opencl::storage> const &m,
+      ublas::matrix<T, L, opencl::storage> &result,
+      compute::command_queue& queue)
+{
+  assert(m.size1() == result.size2() && m.size2() == result.size1());
+  assert(m.device() == result.device() && m.device() == queue.get_device());
+  char const *kernel;
+  if (std::is_same<T, float>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(float);
+  else if (std::is_same<T, double>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(double);
+  else if (std::is_same<T, std::complex<float>>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(float2);
+  else if (std::is_same<T, std::complex<double>>::value)
+    kernel = OPENCL_TRANSPOSITION_KERNEL(double2);
+  size_t len = strlen(kernel);
+  cl_int err;
+  cl_context c_context = queue.get_context().get();
+  cl_program program = clCreateProgramWithSource(c_context, 1, &kernel, &len, &err);
+  clBuildProgram(program, 1, &queue.get_device().get(), NULL, NULL, NULL);
+  cl_kernel c_kernel = clCreateKernel(program, "transpose", &err);
+  size_t width = std::is_same <L, ublas::basic_row_major<>>::value ? m.size2() : m.size1();
+  size_t height = std::is_same <L, ublas::basic_row_major<>>::value ? m.size1() : m.size2();
+  size_t global_size[2] = { width , height };
+  clSetKernelArg(c_kernel, 0, sizeof(T*), &m.begin().get_buffer().get());
+  clSetKernelArg(c_kernel, 1, sizeof(T*), &result.begin().get_buffer().get());
+  clSetKernelArg(c_kernel, 2, sizeof(unsigned int), &width);
+  clSetKernelArg(c_kernel, 3, sizeof(unsigned int), &height);
+  cl_command_queue c_queue = queue.get();
+  cl_event event = NULL;
+  clEnqueueNDRangeKernel(c_queue, c_kernel, 2, NULL, global_size, NULL, 0, NULL, &event);
+  clWaitForEvents(1, &event);
+}
+
+template<class T, class L, class A>
+typename std::enable_if<is_numeric<T>::value>::type
+trans(ublas::matrix<T, L, A> const &m,
+      ublas::matrix<T, L, A> &result,
+      compute::command_queue& queue)
+{
+  ublas::matrix<T, L, opencl::storage> mdev(m, queue);
+  ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
+  trans(mdev, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template<class T, class L, class A>
+typename std::enable_if<is_numeric<T>::value, ublas::matrix<T, L, A>>::type
+trans(ublas::matrix<T, L, A>& m, compute::command_queue& queue)
+{
+  ublas::matrix<T, L, A> result(m.size2(), m.size1());
+  trans(m, result, queue);
+  return result;
+}
+
+}}}}
+
+#endif

package/boost/numeric/ublas/opencl/vector.hpp

@@ -0,0 +1,90 @@
+// Boost.uBLAS
+//
+// Copyright (c) 2018 Fady Essam
+// Copyright (c) 2018 Stefan Seefeld
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef boost_numeric_ublas_opencl_vector_hpp_
+#define boost_numeric_ublas_opencl_vector_hpp_
+
+#include <boost/numeric/ublas/opencl/library.hpp>
+#include <boost/numeric/ublas/functional.hpp>
+#include <boost/compute/core.hpp>
+#include <boost/compute/algorithm.hpp>
+#include <boost/compute/buffer.hpp>
+#include <boost/compute/container/vector.hpp>
+
+namespace boost { namespace numeric { namespace ublas { namespace opencl {
+
+class storage;
+
+namespace compute = boost::compute;
+
+} // namespace opencl
+
+template <class T>
+class vector<T, opencl::storage> : public boost::compute::vector<T>
+{
+  typedef std::size_t size_type;
+public:
+  vector() : compute::vector<T>() {}
+  vector(size_type size, compute::context context)
+    : compute::vector<T>(size, context)
+  { device_ = context.get_device();}
+  vector(size_type size, T value, compute::command_queue queue)
+    : compute::vector<T>(size, value, queue.get_context())
+  {
+    queue.finish();
+    device_ = queue.get_device();
+  }
+
+  template <typename A>
+  vector(vector<T, A> const &v, compute::command_queue &queue)
+    : vector(v.size(), queue.get_context())
+  {
+    this->from_host(v, queue);
+  }
+  
+
+  const compute::device device() const { return device_;}
+  compute::device device() { return device_;}
+
+  template<class A>
+  void from_host(ublas::vector<T, A> const &v, compute::command_queue & queue)
+  {
+    assert(this->device() == queue.get_device());
+    compute::copy(v.begin(),
+		  v.end(),
+		  this->begin(),
+		  queue);
+    queue.finish();
+  }
+
+  template<class A>
+  void to_host(ublas::vector<T, A>& v, compute::command_queue& queue) const
+  {
+    assert(this->device() == queue.get_device());
+    compute::copy(this->begin(),
+		  this->end(),
+		  v.begin(),
+		  queue);
+    queue.finish();
+  }
+
+  void fill(T value, compute::command_queue & queue)
+  {
+    assert(this->device() == queue.get_device());
+    compute::fill(this->begin(), this->end(), value, queue);
+    queue.finish();
+  }
+
+private:
+  compute::device device_;
+};
+
+}}}
+
+#endif

package/boost/numeric/ublas/opencl.hpp

@@ -0,0 +1,16 @@
+//
+// Copyright (c) 2018 Stefan Seefeld
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef boost_numeric_ublas_opencl_hpp_
+#define boost_numeric_ublas_opencl_hpp_
+
+#include <boost/numeric/ublas/opencl/library.hpp>
+#include <boost/numeric/ublas/opencl/vector.hpp>
+#include <boost/numeric/ublas/opencl/matrix.hpp>
+#include <boost/numeric/ublas/opencl/operations.hpp>
+
+#endif

package/boost/numeric/ublas/operation/begin.hpp

@@ -0,0 +1,318 @@
+/**
+ * -*- c++ -*-
+ *
+ * \file begin.hpp
+ *
+ * \brief The \c begin operation.
+ *
+ * Copyright (c) 2009, Marco Guazzone
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * \author Marco Guazzone, marco.guazzone@gmail.com
+ */
+
+#ifndef BOOST_NUMERIC_UBLAS_OPERATION_BEGIN_HPP
+#define BOOST_NUMERIC_UBLAS_OPERATION_BEGIN_HPP
+
+
+#include <boost/numeric/ublas/expression_types.hpp>
+#include <boost/numeric/ublas/fwd.hpp>
+#include <boost/numeric/ublas/traits/const_iterator_type.hpp>
+#include <boost/numeric/ublas/traits/iterator_type.hpp>
+
+
+namespace boost { namespace numeric { namespace ublas {
+
+    namespace detail {
+
+		    /**
+				 * \brief Auxiliary class for implementing the \c begin operation.
+				 * \tparam CategoryT The expression category type (e.g., vector_tag).
+				 * \tparam TagT The dimension type tag (e.g., tag::major).
+				 * \tparam OrientationT The orientation category type (e.g., row_major_tag).
+				 */
+		    template <typename CategoryT, typename TagT=void, typename OrientationT=void>
+		    struct begin_impl;
+
+
+				/// \brief Specialization of \c begin_impl for iterating vector expressions.
+				template <>
+				struct begin_impl<vector_tag,void,void>
+				{
+					  /**
+						 * \brief Return an iterator to the first element of the given vector
+						 *  expression.
+						 * \tparam ExprT A model of VectorExpression type.
+						 * \param e A vector expression.
+						 * \return An iterator over the given vector expression.
+						 */
+					  template <typename ExprT>
+					  static typename ExprT::iterator apply(ExprT& e)
+						{
+							  return e.begin();
+						}
+
+
+						/**
+						 * \brief Return a const iterator to the first element of the given vector
+						 *  expression.
+						 * \tparam ExprT A model of VectorExpression type.
+						 * \param e A vector expression.
+						 * \return A const iterator to the first element of the given vector
+						 *  expression.
+						 */
+						template <typename ExprT>
+						static typename ExprT::const_iterator apply(ExprT const& e)
+						{
+							  return e.begin();
+						}
+				};
+
+
+				/// \brief Specialization of \c begin_impl for iterating matrix expressions with
+				///  a row-major orientation over the major dimension.
+				template <>
+				struct begin_impl<matrix_tag,tag::major,row_major_tag>
+				{
+					  /**
+						 * \brief Return an iterator to the first element of the given row-major
+						 *  matrix expression over the major dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return An iterator over the major dimension of the given matrix
+						 *  expression.
+						 */
+					  template <typename ExprT>
+					  static typename ExprT::iterator1 apply(ExprT& e)
+						{
+							  return e.begin1();
+						}
+
+
+						/**
+						 * \brief Return a const iterator to the first element of the given
+						 *  row-major matrix expression over the major dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return A const iterator over the major dimension of the given matrix
+						 *  expression.
+						 */
+						template <typename ExprT>
+						static typename ExprT::const_iterator1 apply(ExprT const& e)
+						{
+							  return e.begin1();
+						}
+				};
+
+
+				/// \brief Specialization of \c begin_impl for iterating matrix expressions with
+				///  a column-major orientation over the major dimension.
+				template <>
+				struct begin_impl<matrix_tag,tag::major,column_major_tag>
+				{
+					  /**
+						 * \brief Return an iterator to the first element of the given column-major
+						 *  matrix expression over the major dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return An iterator over the major dimension of the given matrix
+						 *  expression.
+						 */
+					  template <typename ExprT>
+					  static typename ExprT::iterator2 apply(ExprT& e)
+						{
+							  return e.begin2();
+						}
+
+
+						/**
+						 * \brief Return a const iterator to the first element of the given
+						 *  column-major matrix expression over the major dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return A const iterator over the major dimension of the given matrix
+						 *  expression.
+						 */
+						template <typename ExprT>
+						static typename ExprT::const_iterator2 apply(ExprT const& e)
+						{
+							  return e.begin2();
+						}
+				};
+
+
+				/// \brief Specialization of \c begin_impl for iterating matrix expressions with
+				///  a row-major orientation over the minor dimension.
+				template <>
+				struct begin_impl<matrix_tag,tag::minor,row_major_tag>
+				{
+					  /**
+						 * \brief Return an iterator to the first element of the given row-major
+						 *  matrix expression over the minor dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return An iterator over the minor dimension of the given matrix
+						 *  expression.
+						 */
+					  template <typename ExprT>
+					  static typename ExprT::iterator2 apply(ExprT& e)
+						{
+							  return e.begin2();
+						}
+
+
+						/**
+						 * \brief Return a const iterator to the first element of the given
+						 *  row-major matrix expression over the minor dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return A const iterator over the minor dimension of the given matrix
+						 *  expression.
+						 */
+						template <typename ExprT>
+						static typename ExprT::const_iterator2 apply(ExprT const& e)
+						{
+							  return e.begin2();
+						}
+				};
+
+
+
+				/// \brief Specialization of \c begin_impl for iterating matrix expressions with
+				///  a column-major orientation over the minor dimension.
+				template <>
+				struct begin_impl<matrix_tag,tag::minor,column_major_tag>
+				{
+					  /**
+						 * \brief Return an iterator to the first element of the given column-major
+						 *  matrix expression over the minor dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return An iterator over the minor dimension of the given matrix
+						 *  expression.
+						 */
+					  template <typename ExprT>
+					  static typename ExprT::iterator1 apply(ExprT& e)
+						{
+							  return e.begin1();
+						}
+
+
+						/**
+						 * \brief Return a const iterator to the first element of the given
+						 *  column-major matrix expression over the minor dimension.
+						 * \tparam ExprT A model of MatrixExpression type.
+						 * \param e A matrix expression.
+						 * \return A const iterator over the minor dimension of the given matrix
+						 *  expression.
+						 */
+						template <typename ExprT>
+						static typename ExprT::const_iterator1 apply(ExprT const& e)
+						{
+							  return e.begin1();
+						}
+				};
+
+		} // Namespace detail
+
+
+		/**
+		 * \brief An iterator to the first element of the given vector expression.
+		 * \tparam ExprT A model of VectorExpression type.
+		 * \param e A vector expression.
+		 * \return An iterator to the first element of the given vector expression.
+		 */
+		template <typename ExprT>
+		BOOST_UBLAS_INLINE
+		typename ExprT::iterator begin(vector_expression<ExprT>& e)
+		{
+			  return detail::begin_impl<typename ExprT::type_category>::apply(e());
+		}
+
+
+		/**
+		 * \brief A const iterator to the first element of the given vector expression.
+		 * \tparam ExprT A model of VectorExpression type.
+		 * \param e A vector expression.
+		 * \return A const iterator to the first element of the given vector expression.
+		 */
+		template <typename ExprT>
+		BOOST_UBLAS_INLINE
+		typename ExprT::const_iterator begin(vector_expression<ExprT> const& e)
+		{
+			  return detail::begin_impl<typename ExprT::type_category>::apply(e());
+		}
+
+
+		/**
+		 * \brief An iterator to the first element of the given matrix expression
+		 *  according to its orientation.
+		 * \tparam DimTagT A dimension tag type (e.g., tag::major).
+		 * \tparam ExprT A model of MatrixExpression type.
+		 * \param e A matrix expression.
+		 * \return An iterator to the first element of the given matrix expression
+		 *  according to its orientation.
+		 */
+		template <typename TagT, typename ExprT>
+		BOOST_UBLAS_INLINE
+		typename iterator_type<ExprT,TagT>::type begin(matrix_expression<ExprT>& e)
+		{
+			  return detail::begin_impl<typename ExprT::type_category, TagT, typename ExprT::orientation_category>::apply(e());
+		}
+
+
+		/**
+		 * \brief A const iterator to the first element of the given matrix expression
+		 *  according to its orientation.
+		 * \tparam TagT A dimension tag type (e.g., tag::major).
+		 * \tparam ExprT A model of MatrixExpression type.
+		 * \param e A matrix expression.
+		 * \return A const iterator to the first element of the given matrix expression
+		 *  according to its orientation.
+		 */
+		template <typename TagT, typename ExprT>
+		BOOST_UBLAS_INLINE
+		typename const_iterator_type<ExprT,TagT>::type begin(matrix_expression<ExprT> const& e)
+		{
+			  return detail::begin_impl<typename ExprT::type_category, TagT, typename ExprT::orientation_category>::apply(e());
+		}
+
+
+		/**
+		 * \brief An iterator to the first element over the dual dimension of the given
+		 *  iterator.
+		 * \tparam IteratorT A model of Iterator type.
+		 * \param it An iterator.
+		 * \return An iterator to the first element over the dual dimension of the given
+		 *  iterator.
+		 */
+		template <typename IteratorT>
+		BOOST_UBLAS_INLINE
+		typename IteratorT::dual_iterator_type begin(IteratorT& it)
+		{
+			  return it.begin();
+		}
+
+
+		/**
+		 * \brief A const iterator to the first element over the dual dimension of the
+		 *  given iterator.
+		 * \tparam IteratorT A model of Iterator type.
+		 * \param it An iterator.
+		 * \return A const iterator to the first element over the dual dimension of the
+		 *  given iterator.
+		 */
+		template <typename IteratorT>
+		BOOST_UBLAS_INLINE
+		typename IteratorT::dual_iterator_type begin(IteratorT const& it)
+		{
+			  return it.begin();
+		}
+
+}}} // Namespace boost::numeric::ublas
+
+
+#endif // BOOST_NUMERIC_UBLAS_OPERATION_BEGIN_HPP

package/boost/numeric/ublas/operation/c_array.hpp

@@ -0,0 +1,41 @@
+/**
+ * -*- c++ -*-
+ *
+ * \file c_array.hpp
+ *
+ * \brief provides specializations of matrix and vector operations for c arrays and c matrices.
+ *
+ * Copyright (c) 2009, Gunter Winkler
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * \author Gunter Winkler (guwi17 at gmx dot de)
+ */
+
+#ifndef BOOST_NUMERIC_UBLAS_OPERATION_C_ARRAY_HPP
+#define BOOST_NUMERIC_UBLAS_OPERATION_C_ARRAY_HPP
+
+#include <boost/numeric/ublas/traits/c_array.hpp>
+
+namespace boost { namespace numeric { namespace ublas {
+
+    namespace detail {
+
+    
+    
+    } // namespace boost::numeric::ublas::detail
+
+
+    template <typename T>
+    BOOST_UBLAS_INLINE
+    typename ExprT::const_iterator begin(vector_expression<ExprT> const& e)
+    {
+        return detail::begin_impl<typename ExprT::type_category>::apply(e());
+    }
+
+
+}}} // Namespace boost::numeric::ublas
+
+#endif