看了两个库
boost和Eigen
boost的resize每次都会重新申请内存，这样效率比较低
Eigen有tensor类型，但是没有使用文档支持，不会用
因此想自己实现，有好用的库推荐吗？
【一些基本的操作】
resize改变tensor大小,有容量capacity，当tensor大小小于容量时不重新申请内存
reshape改变tensor形状，不改变其大小
transpose转置指定的维度
flip翻转指定的维度
squeeze去除大小为1的维度
operator[](size_t)当数据存放是连续时，按一维下标访问元素
转置和翻转是常数时间操作，只改变访问tensor元素的方式(线性索引)，不复制数据
【tensor】
tensor持有数据，支持resize，其数据存放是连续的，支持reshape，切割后返回tensor_view
【tensor_view】
tensor_view将某段内存按tensor解释，不支持resize，其数据存放可以是不连续的，
当其查看的数据是连续时，支持reshape，切割后返回tensor_view
【tensor_base】
tensor和tensor_view继承自tensor_base，tensor_base提供tensor和tensor_view的共同成员
为了访问效率，编译时应该确定tensor的rank维度数？
tensor内部数据data_采用共享指针std::share_ptr<std::vector<T>>管理new出的std::vector，
tensor_view内部数据data_准备采用数据指针或者std::vector<T>::iterator迭代器
为了避免直接用原始指针访问数据带来的不安全，有更好的方案提供内部数据吗？
以下是代码：
tensor_view_t.h 空
const_tensor_view_t.h 空
tensor_base_t.h
#include <vector>
#include <memory>
#include <algorithm>
#include <assert.h>
typedef int layer_size_t;
template<typename T>
class range_t
{
public:
range_t()
{
full_ = true;
}
range_t(T begin, T end, T step = T(1))
{
assert(begin < end);
begin_ = begin;
end_ = end;
step_ = step;
full_ = false;
}
size_t size()
{
size_t ret = (end_ - begin_) / step_ + 1;
if ((end_ - begin_) % step_ == 0) ret--;
return ret;
}
size_t size() const
{
size_t ret = (end_ - begin_) / step_ + 1;
if ((end_ - begin_) % step_ == 0) ret--;
return ret;
}
T begin_;
T end_;
T step_;
bool full_;
};
typedef range_t<size_t> range_type;
template<typename T>
class extents_t
{
public:
extents_t<T>& operator[](const range_t<T>& range)
{
ranges.push_back(range);
return *this;
}
extents_t<T>& operator[](T index)
{
ranges.push_back(range_t<T>(index, index + 1));
return *this;
}
std::vector<range_t<T>> ranges;
};
typedef extents_t<size_t> extents_type;
template<typename derived,typename value_type,typename data_type>
class tensor_base_t
{
public:
typedef typename int index_value;//signed
typedef typename std::vector<index_value> shape_type;
typedef typename shape_type index_type;
typedef typename derived tensor_type;
typedef typename value_type value_type;
typedef typename std::vector<value_type> vector_type;
typedef typename data_type data_type;
protected:
data_type data_;
bool continuous_;
int offset_;
shape_type shape_;
index_type steps_;
size_t size_;
public:
tensor_base_t() = default;
void assign(const std::initializer_list<value_type>& vec)
{
assert(size_ == vec.size());
(*data_).assign(vec.begin(), vec.end());
}
derived& operator =(derived& tensor)
{
data_ = tensor.data();
offset_ = tensor.offset();
size_ = tensor.size();
shape_ = tensor.shape();
steps_ = tensor.steps();
return *this;
}
void reshape(const std::initializer_list<size_t>& sizes_list)
{
reshape(shape_type(sizes_list));
}
void reshape(const shape_type& shape)//if this failed please clone this tensor to itself
{
size_t size = calculate_size(shape);
assert(offset_ == 0 && size_ == (*data).size());
assert(size == size_);
shape_ = shape;
init_steps();
}
const data_type& data()
{
return data_;
}
bool continuous()
{
return continuous_;
}
derived clone()//iterate through view and copy data
{
derived ret(shape_);
index_type index(shape_.size(), 0);
bool finish = false;
while (true)
{
for (size_t i = 0; i < shape_.size(); ++i)
{
if (index[i] == shape_[i])
{
if (i == shape_.size() - 1)
{
finish = true;
break;
}
index[i] = 0;
index[i + 1]++;
}
else{
break;
}
}
if (finish) break;
ret(index) = (*this)(index);
index[0]++;
}
return ret;
}
derived operator()(const extents_type& extents)
{
derived ret(*static_cast<derived*>(this));
const auto& ranges = extents.ranges;
assert(dims() == ranges.size());
for (size_t i = 0; i < ranges.size(); ++i)
{
if (ranges[i].full_) continue;
ret.offset_ += ranges[i].begin_ * ret.steps_[i];
ret.shape_[i] = ranges[i].size();
ret.steps_[i] *= ranges[i].step_;
ret.update_size();
}
ret.squeeze();
return ret;
}
void squeeze()//去除大小为1的维度
{
for (size_t i = 0; i < shape_.size(); ++i)
{
if (shape_[i] == 1)
{
shape_.erase(shape_.begin() + i);
steps_.erase(steps_.begin() + i);
}
}
}
void transpose(const std::initializer_list<size_t>& permutation)
{
assert(permutation.size() == dims());
index_type index(dims());
for (size_t i = 0; i < dims(); ++i)
{
index[i] = i;
}
assert(std::is_permutation(permutation.begin(), permutation.end(), index.begin()));
index_type steps(dims());
for (size_t i = 0; i < dims(); ++i)
{
steps[permutation.begin()[i]] = steps_[i];
}
steps_ = steps;
}
void flip(const std::initializer_list<bool>& flip_flags)
{
assert(flip_flags.size() == dims());
for (size_t i = 0; i < shape_.size(); ++i)
{
if (flip_flags.begin()[i] == false) continue;
offset_ += (shape_[i] - 1) * steps_[i];
steps_[i] *= -1;
}
}
value_type& operator()(const std::initializer_list<index_value>& index)
{
return (*data_)[_index(index)];
}
const value_type& operator()(const std::initializer_list<index_value>& index) const
{
return (*data_)[_index(index)];
}
value_type& operator()(const index_type& index)
{
return (*data_)[_index(index)];
}
const value_type& operator()(const index_type&& index) const
{
return (*data_)[_index(index)];
}
value_type& operator[](size_t index)
{
#if _ITERATOR_DEBUG_LEVEL == 2
assert(offset_ == 0 && size_ == (*data_).size());
#endif
return (*data_)[index];
}
const value_type& operator[](size_t index) const
{
#if _ITERATOR_DEBUG_LEVEL == 2
assert(offset_ == 0 && size_ == (*data_).size());
#endif
return (*data_)[index];
}
private:
/*
template<int ndims>
size_t index(const std::vector<T>& coordinate)
{
return coordinate[ndims - 1] * steps_[ndims - 1] + index<ndims - 1>(coordinate);
}
template<>
size_t index<0>(const std::vector<T>& coordinate)
{
return 0;
}
*/
size_t _index(const std::initializer_list<index_value>& coordinate)
{
return _index(index_type(coordinate));
}
size_t _index(const index_type& coordinate)
{
int ret = offset_;
const size_t ndims = coordinate.size();
#if _ITERATOR_DEBUG_LEVEL == 2
assert(ndims == dims());
#endif
for (size_t i = 0; i < ndims; ++i)
{
#if _ITERATOR_DEBUG_LEVEL == 2
if (coordinate[i] >= shape_[i])
{ // report error
_DEBUG_ERROR("tensor subscript out of range");
_SCL_SECURE_OUT_OF_RANGE;
}
#endif
ret += coordinate[i] * steps_[i];
}
return ret;
}
public:
const index_type& shape()
{
return shape_;
}
const index_type& shape() const
{
return shape_;
}
index_value shape(size_t i)
{
return shape_[i];
}
index_value shape(size_t i) const
{
return shape_[i];
}
const index_type& steps()
{
return steps_;
}
const index_type& steps() const
{
return steps_;
}
size_t size()
{
return size_;
}
size_t size() const
{
return size_;
}
size_t dims()
{
return shape_.size();
}
size_t dims() const
{
return shape_.size();
}
int offset()
{
return offset_;
}
int offset() const
{
return offset_;
}
protected:
size_t calculate_size(const shape_type& shape)
{
double product = 1;
size_t size = 1;
for (auto& v : shape)
{
product *= v;
size *= v;
}
assert(product < std::numeric_limits<size_t>::max());//check whether size overflow
return size;
}
void update_size()
{
size_ = calculate_size(shape_);
}
void init_steps()
{
steps_.resize(shape_.size());
std::fill(steps_.begin(), steps_.end(), 1);
for (size_t i = 1; i < steps_.size(); ++i)
for (size_t k = 0; k < i; ++k)
steps_[i] *= shape_[k];
}
public:
friend class tensor_base_t<derived,value_type,data_type>;
};
