vector_def.hpp

Go to the documentation of this file.

#ifndef VIENNACL_DETAIL_VECTOR_DEF_HPP_
#define VIENNACL_DETAIL_VECTOR_DEF_HPP_

/* =========================================================================
   Copyright (c) 2010-2016, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
   Portions of this software are copyright by UChicago Argonne, LLC.

                            -----------------
                  ViennaCL - The Vienna Computing Library
                            -----------------

   Project Head:    Karl Rupp                   rupp@iue.tuwien.ac.at

   (A list of authors and contributors can be found in the manual)

   License:         MIT (X11), see file LICENSE in the base directory
============================================================================= */

#include "viennacl/forwards.h"
#include "viennacl/tools/entry_proxy.hpp"

namespace viennacl
{

template<typename NumericT>
class implicit_vector_base
{
protected:
  implicit_vector_base(vcl_size_t s, vcl_size_t i, NumericT v, viennacl::context ctx) : size_(s), index_(std::make_pair(true,i)), value_(v), ctx_(ctx){ }
  implicit_vector_base(vcl_size_t s, NumericT v, viennacl::context ctx) : size_(s), index_(std::make_pair(false,0)), value_(v), ctx_(ctx){ }

public:
  typedef NumericT const & const_reference;
  typedef NumericT cpu_value_type;

  viennacl::context context() const { return ctx_; }
  vcl_size_t size() const { return size_; }
  cpu_value_type  value() const { return value_; }
  vcl_size_t index() const { return index_.second; }
  bool has_index() const { return index_.first; }

  cpu_value_type operator()(vcl_size_t i) const
  {
    if (index_.first)
      return (i==index_.second)?value_:0;
    return value_;
  }

  cpu_value_type operator[](vcl_size_t i) const
  {
    if (index_.first)
      return (i==index_.second)?value_:0;
    return
        value_;
  }

protected:
  vcl_size_t size_;
  std::pair<bool, vcl_size_t> index_;
  NumericT value_;
  viennacl::context ctx_;
};

template<typename NumericT>
struct unit_vector : public implicit_vector_base<NumericT>
{
  unit_vector(vcl_size_t s, vcl_size_t ind, viennacl::context ctx = viennacl::context()) : implicit_vector_base<NumericT>(s, ind, 1, ctx)
  {
    assert( (ind < s) && bool("Provided index out of range!") );
  }
};


template<typename NumericT>
struct scalar_vector : public implicit_vector_base<NumericT>
{
  scalar_vector(vcl_size_t s, NumericT val, viennacl::context ctx = viennacl::context()) : implicit_vector_base<NumericT>(s, val, ctx) {}
};

template<typename NumericT>
struct zero_vector : public scalar_vector<NumericT>
{
  zero_vector(vcl_size_t s, viennacl::context ctx = viennacl::context()) : scalar_vector<NumericT>(s, 0, ctx){}
};


template<class NumericT, typename SizeT /* see forwards.h for default type */, typename DistanceT /* see forwards.h for default type */>
class vector_base
{
  typedef vector_base<NumericT, SizeT, DistanceT>         self_type;

public:
  typedef scalar<NumericT>                                value_type;
  typedef NumericT                                        cpu_value_type;
  typedef viennacl::backend::mem_handle                     handle_type;
  typedef SizeT                                          size_type;
  typedef DistanceT                                      difference_type;
  typedef const_vector_iterator<NumericT, 1>              const_iterator;
  typedef vector_iterator<NumericT, 1>                    iterator;

  size_type size() const { return size_; }
  size_type internal_size() const { return internal_size_; }
  size_type start() const { return start_; }
  size_type stride() const { return stride_; }
  bool empty() const { return size_ == 0; }
  const handle_type & handle() const { return elements_; }
  handle_type & handle() { return elements_; }
  viennacl::memory_types memory_domain() const { return elements_.get_active_handle_id();  }

  explicit vector_base();

  explicit vector_base(viennacl::backend::mem_handle & h, size_type vec_size, size_type vec_start, size_type vec_stride);

  explicit vector_base(size_type vec_size, viennacl::context ctx = viennacl::context());

  // CUDA or host memory:
  explicit vector_base(NumericT * ptr_to_mem, viennacl::memory_types mem_type, size_type vec_size, vcl_size_t start = 0, size_type stride = 1);

#ifdef VIENNACL_WITH_OPENCL

  explicit vector_base(cl_mem existing_mem, size_type vec_size, size_type start = 0, size_type stride = 1, viennacl::context ctx = viennacl::context());
#endif

  template<typename LHS, typename RHS, typename OP>
  explicit vector_base(vector_expression<const LHS, const RHS, OP> const & proxy);

  // Copy CTOR:
  vector_base(const self_type & other);

  // Conversion CTOR:
  template<typename OtherNumericT>
  vector_base(const vector_base<OtherNumericT> & v1);

  self_type & operator=(const self_type & vec);
  template<typename LHS, typename RHS, typename OP>
  self_type & operator=(const vector_expression<const LHS, const RHS, OP> & proxy);
  template<typename OtherNumericT>
  self_type &  operator = (const vector_base<OtherNumericT> & v1);
  self_type & operator = (unit_vector<NumericT> const & v);
  self_type & operator = (zero_vector<NumericT> const & v);
  self_type & operator = (scalar_vector<NumericT> const & v);



  self_type & operator=(const viennacl::vector_expression< const matrix_base<NumericT>, const vector_base<NumericT>, viennacl::op_prod> & proxy);

  //transposed_matrix_proxy:
  self_type & operator=(const vector_expression< const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans >,
                        const vector_base<NumericT>,
                        op_prod> & proxy);



  //read-write access to an element of the vector
  entry_proxy<NumericT> operator()(size_type index);
  entry_proxy<NumericT> operator[](size_type index);
  const_entry_proxy<NumericT> operator()(size_type index) const;
  const_entry_proxy<NumericT> operator[](size_type index) const;
  self_type & operator += (const self_type & vec);
  self_type & operator -= (const self_type & vec);

  self_type & operator *= (char val);
  self_type & operator *= (short val);
  self_type & operator *= (int val);
  self_type & operator *= (long val);
  self_type & operator *= (float val);
  self_type & operator *= (double val);


  self_type & operator /= (char val);
  self_type & operator /= (short val);
  self_type & operator /= (int val);
  self_type & operator /= (long val);
  self_type & operator /= (float val);
  self_type & operator /= (double val);

  vector_expression< const self_type, const NumericT, op_mult>
  operator * (char value) const;
  vector_expression< const self_type, const NumericT, op_mult>
  operator * (short value) const;
  vector_expression< const self_type, const NumericT, op_mult>
  operator * (int value) const;
  vector_expression< const self_type, const NumericT, op_mult>
  operator * (long value) const;
  vector_expression< const self_type, const NumericT, op_mult>
  operator * (float value) const;
  vector_expression< const self_type, const NumericT, op_mult>
  operator * (double value) const;

  vector_expression< const self_type, const NumericT, op_div>
  operator / (char value) const;
  vector_expression< const self_type, const NumericT, op_div>
  operator / (short value) const;
  vector_expression< const self_type, const NumericT, op_div>
  operator / (int value) const;
  vector_expression< const self_type, const NumericT, op_div>
  operator / (long value) const;
  vector_expression< const self_type, const NumericT, op_div>
  operator / (float value) const;
  vector_expression< const self_type, const NumericT, op_div>
  operator / (double value) const;

  vector_expression<const self_type, const NumericT, op_mult> operator-() const;
  iterator begin();
  iterator end();
  const_iterator begin() const;
  const_iterator end() const;
  self_type & swap(self_type & other);

  void clear();

protected:

  void set_handle(viennacl::backend::mem_handle const & h) {  elements_ = h; }

  self_type & fast_swap(self_type & other);

  void pad();

  void switch_memory_context(viennacl::context new_ctx);

  //TODO: Think about implementing the following public member functions
  //void insert_element(unsigned int i, NumericT val){}
  //void erase_element(unsigned int i){}

  //enlarge or reduce allocated memory and set unused memory to zero
  void resize(size_type new_size, bool preserve = true);

  void resize(size_type new_size, viennacl::context ctx, bool preserve = true);
private:

  void resize_impl(size_type new_size, viennacl::context ctx, bool preserve = true);

  size_type       size_;
  size_type       start_;
  size_type       stride_;
  size_type       internal_size_;
  handle_type elements_;
}; //vector_base

} // namespace viennacl

#endif