All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
matrix_proxy.hpp
Go to the documentation of this file.
#ifndef VIENNACL_MATRIX_PROXY_HPP_
#define VIENNACL_MATRIX_PROXY_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/range.hpp"
#include "viennacl/slice.hpp"
#include "viennacl/detail/matrix_def.hpp"
#include "viennacl/traits/size.hpp"
namespace viennacl
{
namespace detail
{
template<typename NumericT, typename MatrixT>
NumericT const & matrix_access(MatrixT const & A, vcl_size_t i, vcl_size_t j)
{
return A(i, j);
}
template<typename NumericT>
NumericT const & matrix_access(std::vector< std::vector<NumericT> > const & A, vcl_size_t i, vcl_size_t j)
{
return A[i][j];
}
template<typename NumericT, typename MatrixT>
NumericT & matrix_access(MatrixT & A, vcl_size_t i, vcl_size_t j)
{
return A(i, j);
}
template<typename NumericT>
NumericT & matrix_access(std::vector< std::vector<NumericT> > & A, vcl_size_t i, vcl_size_t j)
{
return A[i][j];
}
}
template<typename MatrixType>
class matrix_range : public matrix_base<typename MatrixType::cpu_value_type>
{
typedef matrix_base<typename MatrixType::cpu_value_type> base_type;
typedef matrix_range<MatrixType> self_type;
public:
typedef typename MatrixType::value_type value_type;
typedef typename MatrixType::handle_type handle_type;
typedef typename viennacl::result_of::cpu_value_type<value_type>::type cpu_value_type;
typedef range::size_type size_type;
typedef range::difference_type difference_type;
typedef value_type reference;
typedef const value_type & const_reference;
matrix_range(MatrixType const & A,
range const & row_range,
range const & col_range) : base_type(const_cast<handle_type &>(A.handle()),
row_range.size(), row_range.start() * A.stride1() + A.start1(), A.stride1(), A.internal_size1(),
col_range.size(), col_range.start() * A.stride2() + A.start2(), A.stride2(), A.internal_size2(),
A.row_major()) {}
matrix_range(self_type const & A,
range const & row_range,
range const & col_range) : base_type(const_cast<handle_type &>(A.handle()),
row_range.size(), row_range.start() * A.stride1() + A.start1(), A.stride1(), A.internal_size1(),
col_range.size(), col_range.start() * A.stride2() + A.start2(), A.stride2(), A.internal_size2(),
A.row_major()) {}
matrix_range(self_type const & other) : base_type(const_cast<handle_type &>(other.handle()),
other.size1(), other.start1(), other.stride1(), other.internal_size1(),
other.size2(), other.start2(), other.stride2(), other.internal_size2(),
other.row_major()) {}
using base_type::operator=;
// the following are needed for Visual Studio:
template<typename OtherNumericT, typename F>
base_type & operator=(viennacl::matrix<OtherNumericT, F> const & B) { return base_type::operator=(static_cast<viennacl::matrix_base<OtherNumericT> const &>(B)); }
template<typename OtherNumericT, typename F>
base_type & operator=(viennacl::matrix_range<viennacl::matrix<OtherNumericT, F> > const & B) { return base_type::operator=(static_cast<viennacl::matrix_base<OtherNumericT> const &>(B)); }
template<typename OtherNumericT, typename F>
base_type & operator=(viennacl::matrix_slice<viennacl::matrix<OtherNumericT, F> > const & B) { return base_type::operator=(static_cast<viennacl::matrix_base<OtherNumericT> const &>(B)); }
};
template<typename MatrixType>
class matrix_range<matrix_range<MatrixType> > : public matrix_base<typename MatrixType::cpu_value_type>
{
typedef matrix_base<typename MatrixType::cpu_value_type> base_type;
public:
typedef typename MatrixType::handle_type handle_type;
matrix_range(MatrixType const & A,
range const & row_range,
range const & col_range) : base_type(const_cast<handle_type &>(A.handle()),
row_range.size(), row_range.start() * A.stride1() + A.start1(), A.stride1(), A.internal_size1(),
col_range.size(), col_range.start() * A.stride2() + A.start2(), A.stride2(), A.internal_size2(),
A.row_major()) {}
matrix_range(matrix_range<MatrixType> const & A,
range const & row_range,
range const & col_range) : base_type(const_cast<handle_type &>(A.handle()),
row_range.size(), row_range.start() * A.stride1() + A.start1(), A.stride1(), A.internal_size1(),
col_range.size(), col_range.start() * A.stride2() + A.start2(), A.stride2(), A.internal_size2(),
A.row_major()) {}
};
//row_major:
template<typename CPUMatrixT, typename NumericT>
void copy(const CPUMatrixT & cpu_matrix,
matrix_range<matrix<NumericT, row_major, 1> > & gpu_matrix_range )
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_range.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_range.size2())
&& bool("Matrix size mismatch!"));
if ( gpu_matrix_range.start2() != 0)
{
std::vector<NumericT> entries(gpu_matrix_range.size2());
//copy each stride separately:
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
{
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
entries[j] = detail::matrix_access<NumericT>(cpu_matrix, i, j);
vcl_size_t start_offset = (gpu_matrix_range.start1() + i) * gpu_matrix_range.internal_size2() + gpu_matrix_range.start2();
vcl_size_t num_entries = gpu_matrix_range.size2();
viennacl::backend::memory_write(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Strided copy worked!" << std::endl;
}
}
else
{
//full block can be copied:
std::vector<NumericT> entries(gpu_matrix_range.size1()*gpu_matrix_range.internal_size2());
//copy each stride separately:
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
entries[i*gpu_matrix_range.internal_size2() + j] = detail::matrix_access<NumericT>(cpu_matrix, i, j);
vcl_size_t start_offset = gpu_matrix_range.start1() * gpu_matrix_range.internal_size2();
vcl_size_t num_entries = gpu_matrix_range.size1() * gpu_matrix_range.internal_size2();
viennacl::backend::memory_write(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Block copy worked!" << std::endl;
}
}
//column_major:
template<typename CPUMatrixT, typename NumericT>
void copy(const CPUMatrixT & cpu_matrix,
matrix_range<matrix<NumericT, column_major, 1> > & gpu_matrix_range )
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_range.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_range.size2())
&& bool("Matrix size mismatch!"));
if ( gpu_matrix_range.start1() != 0 || gpu_matrix_range.size1() != gpu_matrix_range.size1())
{
std::vector<NumericT> entries(gpu_matrix_range.size1());
//copy each stride separately:
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
{
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
entries[i] = detail::matrix_access<NumericT>(cpu_matrix, i, j);
vcl_size_t start_offset = (gpu_matrix_range.start2() + j) * gpu_matrix_range.internal_size1() + gpu_matrix_range.start1();
vcl_size_t num_entries = gpu_matrix_range.size1();
viennacl::backend::memory_write(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Strided copy worked!" << std::endl;
}
}
else
{
//full block can be copied:
std::vector<NumericT> entries(gpu_matrix_range.internal_size1()*gpu_matrix_range.size2());
//copy each stride separately:
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
entries[i + j*gpu_matrix_range.internal_size1()] = detail::matrix_access<NumericT>(cpu_matrix, i, j);
vcl_size_t start_offset = gpu_matrix_range.start2() * gpu_matrix_range.internal_size1();
vcl_size_t num_entries = gpu_matrix_range.internal_size1() * gpu_matrix_range.size2();
viennacl::backend::memory_write(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Block copy worked!" << std::endl;
}
}
//row_major:
template<typename CPUMatrixT, typename NumericT>
void copy(matrix_range<matrix<NumericT, row_major, 1> > const & gpu_matrix_range,
CPUMatrixT & cpu_matrix)
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_range.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_range.size2())
&& bool("Matrix size mismatch!"));
if ( gpu_matrix_range.start2() != 0)
{
std::vector<NumericT> entries(gpu_matrix_range.size2());
//copy each stride separately:
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
{
vcl_size_t start_offset = (gpu_matrix_range.start1() + i) * gpu_matrix_range.internal_size2() + gpu_matrix_range.start2();
vcl_size_t num_entries = gpu_matrix_range.size2();
viennacl::backend::memory_read(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Strided copy worked!" << std::endl;
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
detail::matrix_access<NumericT>(cpu_matrix, i, j) = entries[j];
}
}
else
{
//full block can be copied:
std::vector<NumericT> entries(gpu_matrix_range.size1()*gpu_matrix_range.internal_size2());
vcl_size_t start_offset = gpu_matrix_range.start1() * gpu_matrix_range.internal_size2();
viennacl::backend::memory_read(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*entries.size(), &(entries[0]));
//std::cout << "Block copy worked!" << std::endl;
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
detail::matrix_access<NumericT>(cpu_matrix, i, j) = entries[i*gpu_matrix_range.internal_size2() + j];
}
}
//column_major:
template<typename CPUMatrixT, typename NumericT>
void copy(matrix_range<matrix<NumericT, column_major, 1> > const & gpu_matrix_range,
CPUMatrixT & cpu_matrix)
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_range.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_range.size2())
&& bool("Matrix size mismatch!"));
if ( gpu_matrix_range.start1() != 0)
{
std::vector<NumericT> entries(gpu_matrix_range.size1());
//copy each stride separately:
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
{
vcl_size_t start_offset = (gpu_matrix_range.start2() + j) * gpu_matrix_range.internal_size1() + gpu_matrix_range.start1();
vcl_size_t num_entries = gpu_matrix_range.size1();
viennacl::backend::memory_read(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Strided copy worked!" << std::endl;
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
detail::matrix_access<NumericT>(cpu_matrix, i, j) = entries[i];
}
}
else
{
//full block can be copied:
std::vector<NumericT> entries(gpu_matrix_range.internal_size1()*gpu_matrix_range.size2());
//copy each stride separately:
vcl_size_t start_offset = gpu_matrix_range.start2() * gpu_matrix_range.internal_size1();
vcl_size_t num_entries = gpu_matrix_range.internal_size1() * gpu_matrix_range.size2();
viennacl::backend::memory_read(gpu_matrix_range.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
//std::cout << "Block copy worked!" << std::endl;
for (vcl_size_t i=0; i < gpu_matrix_range.size1(); ++i)
for (vcl_size_t j=0; j < gpu_matrix_range.size2(); ++j)
detail::matrix_access<NumericT>(cpu_matrix, i, j) = entries[i + j*gpu_matrix_range.internal_size1()];
}
}
//
// Convenience function
//
template<typename MatrixType>
matrix_range<MatrixType> project(MatrixType const & A, viennacl::range const & r1, viennacl::range const & r2)
{
assert(r1.size() <= A.size1() && r2.size() <= A.size2() && bool("Size of range invalid!"));
return matrix_range<MatrixType>(A, r1, r2);
}
template<typename MatrixType>
matrix_range<MatrixType> project(matrix_range<MatrixType> const & A, viennacl::range const & r1, viennacl::range const & r2)
{
assert(r1.size() <= A.size1() && r2.size() <= A.size2() && bool("Size of range invalid!"));
return matrix_range<MatrixType>(A, r1, r2);
}
//
//
//
//
//
//
template<typename MatrixType>
class matrix_slice : public matrix_base<typename MatrixType::cpu_value_type>
{
typedef matrix_base<typename MatrixType::cpu_value_type> base_type;
typedef matrix_slice<MatrixType> self_type;
public:
typedef typename MatrixType::value_type value_type;
typedef typename MatrixType::handle_type handle_type;
typedef typename viennacl::result_of::cpu_value_type<value_type>::type cpu_value_type;
typedef range::size_type size_type;
typedef range::difference_type difference_type;
typedef value_type reference;
typedef const value_type & const_reference;
matrix_slice(MatrixType const & A,
slice const & row_slice,
slice const & col_slice) : base_type(const_cast<handle_type &>(A.handle()),
row_slice.size(), row_slice.start() * A.stride1() + A.start1(), row_slice.stride() * A.stride1(), A.internal_size1(),
col_slice.size(), col_slice.start() * A.stride2() + A.start2(), col_slice.stride() * A.stride2(), A.internal_size2(),
A.row_major()) {}
matrix_slice(self_type const & A,
slice const & row_slice,
slice const & col_slice) : base_type(const_cast<handle_type &>(A.handle()),
row_slice.size(), row_slice.start() * A.stride1() + A.start1(), row_slice.stride() * A.stride1(), A.internal_size1(),
col_slice.size(), col_slice.start() * A.stride2() + A.start2(), col_slice.stride() * A.stride2(), A.internal_size2(),
A.row_major()) {}
matrix_slice(self_type const & other) : base_type(const_cast<handle_type &>(other.handle()),
other.size1(), other.start1(), other.stride1(), other.internal_size1(),
other.size2(), other.start2(), other.stride2(), other.internal_size2(),
other.row_major()) {}
using base_type::operator=;
// the following are needed for Visual Studio:
template<typename OtherNumericT, typename F>
base_type & operator=(viennacl::matrix<OtherNumericT, F> const & B) { return base_type::operator=(static_cast<viennacl::matrix_base<OtherNumericT> const &>(B)); }
template<typename OtherNumericT, typename F>
base_type & operator=(viennacl::matrix_range<viennacl::matrix<OtherNumericT, F> > const & B) { return base_type::operator=(static_cast<viennacl::matrix_base<OtherNumericT> const &>(B)); }
template<typename OtherNumericT, typename F>
base_type & operator=(viennacl::matrix_slice<viennacl::matrix<OtherNumericT, F> > const & B) { return base_type::operator=(static_cast<viennacl::matrix_base<OtherNumericT> const &>(B)); }
};
template<typename MatrixType>
class matrix_slice<matrix_range<MatrixType> > : public matrix_base<typename MatrixType::cpu_value_type>
{
typedef matrix_base<typename MatrixType::cpu_value_type> base_type;
public:
typedef typename MatrixType::handle_type handle_type;
matrix_slice(MatrixType const & A,
slice const & row_slice,
slice const & col_slice) : base_type(const_cast<handle_type &>(A.handle()),
row_slice.size(), row_slice.start() * A.stride1() + A.start1(), row_slice.stride() * A.stride1(), A.internal_size1(),
col_slice.size(), col_slice.start() * A.stride2() + A.start2(), col_slice.stride() * A.stride2(), A.internal_size2(),
A.row_major()) {}
matrix_slice(matrix_slice<MatrixType> const & A,
slice const & row_slice,
slice const & col_slice) : base_type(const_cast<handle_type &>(A.handle()),
row_slice.size(), row_slice.start() * A.stride1() + A.start1(), row_slice.stride() * A.stride1(), A.internal_size1(),
col_slice.size(), col_slice.start() * A.stride2() + A.start2(), col_slice.stride() * A.stride2(), A.internal_size2(),
A.row_major()) {}
};
//row_major:
template<typename CPUMatrixT, typename NumericT>
void copy(const CPUMatrixT & cpu_matrix,
matrix_slice<matrix<NumericT, row_major, 1> > & gpu_matrix_slice )
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_slice.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_slice.size2())
&& bool("Matrix size mismatch!"));
if ( (gpu_matrix_slice.size1() > 0) && (gpu_matrix_slice.size1() > 0) )
{
vcl_size_t num_entries = gpu_matrix_slice.size2() * gpu_matrix_slice.stride2(); //no. of entries per stride
std::vector<NumericT> entries(num_entries);
//copy each stride separately:
for (vcl_size_t i=0; i < gpu_matrix_slice.size1(); ++i)
{
vcl_size_t start_offset = (gpu_matrix_slice.start1() + i * gpu_matrix_slice.stride1()) * gpu_matrix_slice.internal_size2() + gpu_matrix_slice.start2();
viennacl::backend::memory_read(gpu_matrix_slice.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
for (vcl_size_t j=0; j < gpu_matrix_slice.size2(); ++j)
entries[j * gpu_matrix_slice.stride2()] = detail::matrix_access<NumericT>(cpu_matrix, i, j);
viennacl::backend::memory_write(gpu_matrix_slice.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
}
}
}
//column_major:
template<typename CPUMatrixT, typename NumericT>
void copy(const CPUMatrixT & cpu_matrix,
matrix_slice<matrix<NumericT, column_major, 1> > & gpu_matrix_slice )
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_slice.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_slice.size2())
&& bool("Matrix size mismatch!"));
if ( (gpu_matrix_slice.size1() > 0) && (gpu_matrix_slice.size1() > 0) )
{
vcl_size_t num_entries = gpu_matrix_slice.size1() * gpu_matrix_slice.stride1(); //no. of entries per stride
std::vector<NumericT> entries(num_entries);
//copy each column stride separately:
for (vcl_size_t j=0; j < gpu_matrix_slice.size2(); ++j)
{
vcl_size_t start_offset = gpu_matrix_slice.start1() + (gpu_matrix_slice.start2() + j * gpu_matrix_slice.stride2()) * gpu_matrix_slice.internal_size1();
viennacl::backend::memory_read(gpu_matrix_slice.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
for (vcl_size_t i=0; i < gpu_matrix_slice.size1(); ++i)
entries[i * gpu_matrix_slice.stride1()] = detail::matrix_access<NumericT>(cpu_matrix, i, j);
viennacl::backend::memory_write(gpu_matrix_slice.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
}
}
}
//row_major:
template<typename CPUMatrixT, typename NumericT>
void copy(matrix_slice<matrix<NumericT, row_major, 1> > const & gpu_matrix_slice,
CPUMatrixT & cpu_matrix)
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_slice.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_slice.size2())
&& bool("Matrix size mismatch!"));
if ( (gpu_matrix_slice.size1() > 0) && (gpu_matrix_slice.size1() > 0) )
{
vcl_size_t num_entries = gpu_matrix_slice.size2() * gpu_matrix_slice.stride2(); //no. of entries per stride
std::vector<NumericT> entries(num_entries);
//copy each stride separately:
for (vcl_size_t i=0; i < gpu_matrix_slice.size1(); ++i)
{
vcl_size_t start_offset = (gpu_matrix_slice.start1() + i * gpu_matrix_slice.stride1()) * gpu_matrix_slice.internal_size2() + gpu_matrix_slice.start2();
viennacl::backend::memory_read(gpu_matrix_slice.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
for (vcl_size_t j=0; j < gpu_matrix_slice.size2(); ++j)
detail::matrix_access<NumericT>(cpu_matrix, i, j) = entries[j * gpu_matrix_slice.stride2()];
}
}
}
//column_major:
template<typename CPUMatrixT, typename NumericT>
void copy(matrix_slice<matrix<NumericT, column_major, 1> > const & gpu_matrix_slice,
CPUMatrixT & cpu_matrix)
{
assert( (viennacl::traits::size1(cpu_matrix) == gpu_matrix_slice.size1())
&& (viennacl::traits::size2(cpu_matrix) == gpu_matrix_slice.size2())
&& bool("Matrix size mismatch!"));
if ( (gpu_matrix_slice.size1() > 0) && (gpu_matrix_slice.size1() > 0) )
{
vcl_size_t num_entries = gpu_matrix_slice.size1() * gpu_matrix_slice.stride1(); //no. of entries per stride
std::vector<NumericT> entries(num_entries);
//copy each column stride separately:
for (vcl_size_t j=0; j < gpu_matrix_slice.size2(); ++j)
{
vcl_size_t start_offset = gpu_matrix_slice.start1() + (gpu_matrix_slice.start2() + j * gpu_matrix_slice.stride2()) * gpu_matrix_slice.internal_size1();
viennacl::backend::memory_read(gpu_matrix_slice.handle(), sizeof(NumericT)*start_offset, sizeof(NumericT)*num_entries, &(entries[0]));
for (vcl_size_t i=0; i < gpu_matrix_slice.size1(); ++i)
detail::matrix_access<NumericT>(cpu_matrix, i, j) = entries[i * gpu_matrix_slice.stride1()];
}
}
}
//
// Convenience function
//
template<typename MatrixType>
matrix_slice<MatrixType> project(MatrixType const & A, viennacl::slice const & r1, viennacl::slice const & r2)
{
assert(r1.size() <= A.size1() && r2.size() <= A.size2() && bool("Size of slice invalid!"));
return matrix_slice<MatrixType>(A, r1, r2);
}
template<typename MatrixType>
matrix_slice<MatrixType> project(matrix_range<MatrixType> const & A, viennacl::slice const & r1, viennacl::slice const & r2)
{
assert(r1.size() <= A.size1() && r2.size() <= A.size2() && bool("Size of slice invalid!"));
return matrix_slice<MatrixType>(A, r1, r2);
}
template<typename MatrixType>
matrix_slice<MatrixType> project(matrix_slice<MatrixType> const & A, viennacl::slice const & r1, viennacl::slice const & r2)
{
assert(r1.size() <= A.size1() && r2.size() <= A.size2() && bool("Size of slice invalid!"));
return matrix_slice<MatrixType>(A, r1, r2);
}
// TODO: Allow mix of range/slice
}
#endif
viennacl::backend::cpu_ram::handle_type
viennacl::tools::shared_ptr< char > handle_type
Definition: cpu_ram.hpp:40
viennacl::matrix_range::operator=
base_type & operator=(viennacl::matrix_slice< viennacl::matrix< OtherNumericT, F > > const &B)
Definition: matrix_proxy.hpp:116
viennacl::matrix_slice< matrix_range< MatrixType > >::handle_type
MatrixType::handle_type handle_type
Definition: matrix_proxy.hpp:415
viennacl::matrix_slice< matrix_range< MatrixType > >::matrix_slice
matrix_slice(MatrixType const &A, slice const &row_slice, slice const &col_slice)
Definition: matrix_proxy.hpp:417
viennacl::basic_range::difference_type
DistanceT difference_type
Definition: range.hpp:43
viennacl::backend::memory_write
void memory_write(mem_handle &dst_buffer, vcl_size_t dst_offset, vcl_size_t bytes_to_write, const void *ptr, bool async=false)
Writes data from main RAM identified by 'ptr' to the buffer identified by 'dst_buffer'.
Definition: memory.hpp:220
viennacl::matrix_range::operator=
base_type & operator=(viennacl::matrix< OtherNumericT, F > const &B)
Definition: matrix_proxy.hpp:110
viennacl::matrix_slice::reference
value_type reference
Definition: matrix_proxy.hpp:374
viennacl::matrix_range< matrix_range< MatrixType > >::matrix_range
matrix_range(matrix_range< MatrixType > const &A, range const &row_range, range const &col_range)
Definition: matrix_proxy.hpp:133
size.hpp
Generic size and resize functionality for different vector and matrix types.
viennacl::matrix_slice
Class for representing strided submatrices of a bigger matrix A.
Definition: forwards.h:443
viennacl::matrix_base::operator=
self_type & operator=(const self_type &other)
Definition: matrix.hpp:262
viennacl::basic_slice::size
size_type size() const
Definition: slice.hpp:56
viennacl::matrix_range::size_type
range::size_type size_type
Definition: matrix_proxy.hpp:80
viennacl::traits::size1
vcl_size_t size1(MatrixType const &mat)
Generic routine for obtaining the number of rows of a matrix (ViennaCL, uBLAS, etc.)
Definition: size.hpp:163
viennacl::matrix_slice::value_type
MatrixType::value_type value_type
Definition: matrix_proxy.hpp:369
viennacl::matrix_base
Definition: matrix_def.hpp:103
viennacl::matrix_range< matrix_range< MatrixType > >::handle_type
MatrixType::handle_type handle_type
Definition: matrix_proxy.hpp:124
viennacl::matrix_range::matrix_range
matrix_range(MatrixType const &A, range const &row_range, range const &col_range)
Definition: matrix_proxy.hpp:86
viennacl::matrix_range::handle_type
MatrixType::handle_type handle_type
Definition: matrix_proxy.hpp:78
viennacl::matrix_base< MatrixType::cpu_value_type >::stride2
size_type stride2() const
Returns the number of columns.
Definition: matrix_def.hpp:234
viennacl::traits::stride
result_of::size_type< viennacl::vector_base< T > >::type stride(viennacl::vector_base< T > const &s)
Definition: stride.hpp:45
forwards.h
This file provides the forward declarations for the main types used within ViennaCL.
viennacl::matrix
A dense matrix class.
Definition: forwards.h:375
viennacl::backend::memory_read
void memory_read(mem_handle const &src_buffer, vcl_size_t src_offset, vcl_size_t bytes_to_read, void *ptr, bool async=false)
Reads data from a buffer back to main RAM.
Definition: memory.hpp:261
viennacl::matrix_slice::difference_type
range::difference_type difference_type
Definition: matrix_proxy.hpp:373
matrix_def.hpp
Forward declaration of dense matrix classes.
viennacl::matrix_range::reference
value_type reference
Definition: matrix_proxy.hpp:82
viennacl::traits::size2
result_of::size_type< MatrixType >::type size2(MatrixType const &mat)
Generic routine for obtaining the number of columns of a matrix (ViennaCL, uBLAS, etc...
Definition: size.hpp:201
viennacl::matrix_range::cpu_value_type
viennacl::result_of::cpu_value_type< value_type >::type cpu_value_type
Definition: matrix_proxy.hpp:79
viennacl::matrix_slice::matrix_slice
matrix_slice(self_type const &other)
Definition: matrix_proxy.hpp:392
NumericT
float NumericT
Definition: bisect.cpp:40
viennacl::matrix_range::value_type
MatrixType::value_type value_type
Definition: matrix_proxy.hpp:77
viennacl::traits::size
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Definition: size.hpp:239
viennacl::matrix_slice::size_type
range::size_type size_type
Definition: matrix_proxy.hpp:372
viennacl::matrix_range::matrix_range
matrix_range(self_type const &A, range const &row_range, range const &col_range)
Definition: matrix_proxy.hpp:93
viennacl::traits::start
result_of::size_type< T >::type start(T const &obj)
Definition: start.hpp:44
viennacl::matrix_slice::matrix_slice
matrix_slice(MatrixType const &A, slice const &row_slice, slice const &col_slice)
Definition: matrix_proxy.hpp:377
viennacl::matrix_range::difference_type
range::difference_type difference_type
Definition: matrix_proxy.hpp:81
viennacl::matrix_range::const_reference
const value_type & const_reference
Definition: matrix_proxy.hpp:83
viennacl::matrix_base< MatrixType::cpu_value_type >::stride1
size_type stride1() const
Returns the number of rows.
Definition: matrix_def.hpp:232
viennacl::project
matrix_range< MatrixType > project(MatrixType const &A, viennacl::range const &r1, viennacl::range const &r2)
Definition: matrix_proxy.hpp:326
viennacl::matrix_range::matrix_range
matrix_range(self_type const &other)
Definition: matrix_proxy.hpp:101
viennacl::vcl_size_t
std::size_t vcl_size_t
Definition: forwards.h:75
viennacl::matrix_base< MatrixType::cpu_value_type >::size2
size_type size2() const
Returns the number of columns.
Definition: matrix_def.hpp:226
viennacl::matrix_base< MatrixType::cpu_value_type >::handle
handle_type & handle()
Returns the OpenCL handle, non-const-version.
Definition: matrix_def.hpp:244
viennacl::matrix_slice::operator=
base_type & operator=(viennacl::matrix_slice< viennacl::matrix< OtherNumericT, F > > const &B)
Definition: matrix_proxy.hpp:407
viennacl::result_of::cpu_value_type::type
T::ERROR_CANNOT_DEDUCE_CPU_SCALAR_TYPE_FOR_T type
Definition: result_of.hpp:271
viennacl::matrix_base< MatrixType::cpu_value_type >::size1
size_type size1() const
Returns the number of rows.
Definition: matrix_def.hpp:224
viennacl::matrix_slice::handle_type
MatrixType::handle_type handle_type
Definition: matrix_proxy.hpp:370
viennacl::matrix_slice::operator=
base_type & operator=(viennacl::matrix< OtherNumericT, F > const &B)
Definition: matrix_proxy.hpp:401
viennacl::matrix_slice::matrix_slice
matrix_slice(self_type const &A, slice const &row_slice, slice const &col_slice)
Definition: matrix_proxy.hpp:384
viennacl::copy
void copy(std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) ...
Definition: circulant_matrix.hpp:150
slice.hpp
Implementation of a slice object for use with proxy objects.
viennacl::basic_range
A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:424
viennacl::matrix_range::operator=
base_type & operator=(viennacl::matrix_range< viennacl::matrix< OtherNumericT, F > > const &B)
Definition: matrix_proxy.hpp:113
range.hpp
Implementation of a range object for use with proxy objects.
viennacl::matrix_base< MatrixType::cpu_value_type >::start2
size_type start2() const
Returns the number of columns.
Definition: matrix_def.hpp:230
viennacl::matrix_base< MatrixType::cpu_value_type >::internal_size2
size_type internal_size2() const
Returns the internal number of columns. Usually required for launching OpenCL kernels only...
Definition: matrix_def.hpp:240
viennacl::matrix_range
Class for representing non-strided submatrices of a bigger matrix A.
Definition: forwards.h:440
viennacl::detail::matrix_access
NumericT const & matrix_access(MatrixT const &A, vcl_size_t i, vcl_size_t j)
Definition: matrix_proxy.hpp:39
viennacl::matrix_base< MatrixType::cpu_value_type >::internal_size1
size_type internal_size1() const
Returns the internal number of rows. Usually required for launching OpenCL kernels only...
Definition: matrix_def.hpp:238
viennacl::basic_range::size_type
SizeT size_type
Definition: range.hpp:42
viennacl::matrix_slice::cpu_value_type
viennacl::result_of::cpu_value_type< value_type >::type cpu_value_type
Definition: matrix_proxy.hpp:371
viennacl::matrix_slice::const_reference
const value_type & const_reference
Definition: matrix_proxy.hpp:375
viennacl::basic_slice
A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:429
viennacl::row_major
A tag for row-major storage of a dense matrix.
Definition: forwards.h:304
viennacl::matrix_range< matrix_range< MatrixType > >::matrix_range
matrix_range(MatrixType const &A, range const &row_range, range const &col_range)
Definition: matrix_proxy.hpp:126
viennacl::matrix_base< MatrixType::cpu_value_type >::start1
size_type start1() const
Returns the number of rows.
Definition: matrix_def.hpp:228
viennacl::matrix_slice::operator=
base_type & operator=(viennacl::matrix_range< viennacl::matrix< OtherNumericT, F > > const &B)
Definition: matrix_proxy.hpp:404
viennacl::basic_range::size
size_type size() const
Definition: range.hpp:56
viennacl::matrix_slice< matrix_range< MatrixType > >::matrix_slice
matrix_slice(matrix_slice< MatrixType > const &A, slice const &row_slice, slice const &col_slice)
Definition: matrix_proxy.hpp:424