Skip to content

GitLab

Commit 83aa9ac3 authored by Paul's avatar Paul
Browse files

Enforce correct naming

parent 81778d3d
Show whitespace changes
Inline Side-by-side
Showing with 173 additions and 163 deletions
.clang-tidy
View file @ 83aa9ac3
...@@ -11,91 +11,93 @@ CheckOptions: ...@@ -11,91 +11,93 @@ CheckOptions:
value: '10' value: '10'
- key: readability-function-size.StatementThreshold - key: readability-function-size.StatementThreshold
value: '150' value: '150'
- key: readability-identifier-naming.Namespace - key: readability-identifier-naming.NamespaceCase
value: lower_case value: lower_case
- key: readability-identifier-naming.InlineNamespace - key: readability-identifier-naming.InlineNamespaceCase
value: lower_case value: lower_case
- key: readability-identifier-naming.EnumConstant - key: readability-identifier-naming.EnumConstantCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ConstexprVariable - key: readability-identifier-naming.ConstexprVariableCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ConstantMember - key: readability-identifier-naming.ConstantMemberCase
value: lower_case value: lower_case
- key: readability-identifier-naming.PrivateMember - key: readability-identifier-naming.PrivateMemberCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ProtectedMember - key: readability-identifier-naming.ProtectedMemberCase
value: lower_case value: lower_case
- key: readability-identifier-naming.PublicMember - key: readability-identifier-naming.PublicMemberCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Member - key: readability-identifier-naming.MemberCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ClassConstant - key: readability-identifier-naming.ClassConstantCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ClassMember - key: readability-identifier-naming.ClassMemberCase
value: lower_case value: lower_case
- key: readability-identifier-naming.GlobalConstant - key: readability-identifier-naming.GlobalConstantCase
value: lower_case value: lower_case
- key: readability-identifier-naming.GlobalVariable - key: readability-identifier-naming.GlobalVariableCase
value: lower_case value: lower_case
- key: readability-identifier-naming.LocalConstant - key: readability-identifier-naming.LocalConstantCase
value: lower_case value: lower_case
- key: readability-identifier-naming.LocalVariable - key: readability-identifier-naming.LocalVariableCase
value: lower_case value: lower_case
- key: readability-identifier-naming.StaticConstant - key: readability-identifier-naming.StaticConstantCase
value: lower_case value: lower_case
- key: readability-identifier-naming.StaticVariable - key: readability-identifier-naming.StaticVariableCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Constant - key: readability-identifier-naming.ConstantCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Variable - key: readability-identifier-naming.VariableCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ConstantParameter - key: readability-identifier-naming.ConstantParameterCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ParameterPack - key: readability-identifier-naming.ParameterPackCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Parameter - key: readability-identifier-naming.ParameterCase
value: lower_case value: lower_case
- key: readability-identifier-naming.AbstractClass - key: readability-identifier-naming.AbstractClassCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Struct - key: readability-identifier-naming.StructCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Class - key: readability-identifier-naming.ClassCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Union - key: readability-identifier-naming.UnionCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Enum - key: readability-identifier-naming.EnumCase
value: lower_case value: lower_case
- key: readability-identifier-naming.GlobalFunction - key: readability-identifier-naming.GlobalFunctionCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ConstexprFunction - key: readability-identifier-naming.ConstexprFunctionCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Function - key: readability-identifier-naming.FunctionCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ConstexprMethod - key: readability-identifier-naming.ConstexprMethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.VirtualMethod - key: readability-identifier-naming.VirtualMethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ClassMethod - key: readability-identifier-naming.ClassMethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.PrivateMethod - key: readability-identifier-naming.PrivateMethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.ProtectedMethod - key: readability-identifier-naming.ProtectedMethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.PublicMethod - key: readability-identifier-naming.PublicMethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Method - key: readability-identifier-naming.MethodCase
value: lower_case value: lower_case
- key: readability-identifier-naming.Typedef - key: readability-identifier-naming.TypedefCase
value: lower_case value: lower_case
- key: readability-identifier-naming.TypeTemplateParameter - key: readability-identifier-naming.TypeTemplateParameterCase
value: lower_case value: CamelCase
- key: readability-identifier-naming.ValueTemplateParameter - key: readability-identifier-naming.ValueTemplateParameterCase
value: lower_case value: CamelCase
- key: readability-identifier-naming.TemplateTemplateParameter - key: readability-identifier-naming.TemplateTemplateParameterCase
value: lower_case value: CamelCase
- key: readability-identifier-naming.TemplateParameter - key: readability-identifier-naming.TemplateParameterCase
value: lower_case value: CamelCase
- key: readability-identifier-naming.TypeAlias - key: readability-identifier-naming.TypeAliasCase
value: lower_case
- key: readability-identifier-naming.MacroDefinition
value: lower_case value: lower_case
# - key: readability-identifier-naming.MacroDefinitionCase
# value: UPPER_CASE
# - key: readability-identifier-naming.MacroDefinitionPrefix
# value: RTG_
include/rtg/argument.hpp
View file @ 83aa9ac3
...@@ -11,16 +11,16 @@ struct argument : raw_data<argument> ...@@ -11,16 +11,16 @@ struct argument : raw_data<argument>
{ {
argument() {} argument() {}
argument(shape s, std::function<char*()> d) : data(d), shape_(s) {} argument(shape s, std::function<char*()> d) : data(d), m_shape(s) {}
std::function<char*()> data; std::function<char*()> data;
bool empty() const { return not data; } bool empty() const { return not data; }
const shape& get_shape() const { return this->shape_; } const shape& get_shape() const { return this->m_shape; }
private: private:
shape shape_; shape m_shape;
}; };
} // namespace rtg } // namespace rtg
......
include/rtg/literal.hpp
View file @ 83aa9ac3
...@@ -13,14 +13,14 @@ struct literal : raw_data<literal> ...@@ -13,14 +13,14 @@ struct literal : raw_data<literal>
literal() {} literal() {}
template <class T> template <class T>
literal(T x) : buffer(sizeof(T), 0), shape_(shape::get_type<T>{}) literal(T x) : buffer(sizeof(T), 0), m_shape(shape::get_type<T>{})
{ {
static_assert(std::is_trivial<T>{}, "Literals can only be trivial types"); static_assert(std::is_trivial<T>{}, "Literals can only be trivial types");
*(reinterpret_cast<T*>(buffer.data())) = x; *(reinterpret_cast<T*>(buffer.data())) = x;
} }
template <class T> template <class T>
literal(shape s, const std::vector<T>& x) : buffer(s.bytes(), 0), shape_(s) literal(shape s, const std::vector<T>& x) : buffer(s.bytes(), 0), m_shape(s)
{ {
assert(s.packed()); assert(s.packed());
static_assert(std::is_trivial<T>{}, "Literals can only be trivial types"); static_assert(std::is_trivial<T>{}, "Literals can only be trivial types");
...@@ -28,7 +28,7 @@ struct literal : raw_data<literal> ...@@ -28,7 +28,7 @@ struct literal : raw_data<literal>
} }
template <class T> template <class T>
literal(shape s, const std::initializer_list<T>& x) : buffer(s.bytes(), 0), shape_(s) literal(shape s, const std::initializer_list<T>& x) : buffer(s.bytes(), 0), m_shape(s)
{ {
assert(s.packed()); assert(s.packed());
static_assert(std::is_trivial<T>{}, "Literals can only be trivial types"); static_assert(std::is_trivial<T>{}, "Literals can only be trivial types");
...@@ -36,29 +36,29 @@ struct literal : raw_data<literal> ...@@ -36,29 +36,29 @@ struct literal : raw_data<literal>
} }
template <class Iterator> template <class Iterator>
literal(shape s, Iterator start, Iterator end) : buffer(s.bytes(), 0), shape_(s) literal(shape s, Iterator start, Iterator end) : buffer(s.bytes(), 0), m_shape(s)
{ {
assert(s.packed()); assert(s.packed());
s.visit_type([&](auto as) { std::copy(start, end, as.from(buffer.data())); }); s.visit_type([&](auto as) { std::copy(start, end, as.from(buffer.data())); });
} }
literal(shape s, const char* x) : buffer(x, x + s.bytes()), shape_(s) {} literal(shape s, const char* x) : buffer(x, x + s.bytes()), m_shape(s) {}
bool empty() const { return this->buffer.empty(); } bool empty() const { return this->buffer.empty(); }
const char* data() const { return this->buffer.data(); } const char* data() const { return this->buffer.data(); }
const shape& get_shape() const { return this->shape_; } const shape& get_shape() const { return this->m_shape; }
argument get_argument() const argument get_argument() const
{ {
auto b = buffer; auto b = buffer;
return {shape_, [b]() mutable { return b.data(); }}; return {m_shape, [b]() mutable { return b.data(); }};
} }
private: private:
std::vector<char> buffer; std::vector<char> buffer;
shape shape_; shape m_shape;
}; };
} // namespace rtg } // namespace rtg
......
include/rtg/operand.hpp
View file @ 83aa9ac3
...@@ -28,112 +28,120 @@ struct operand ...@@ -28,112 +28,120 @@ struct operand
// Constructors // Constructors
operand() = default; operand() = default;
template <typename TypeErased_T_> template <typename PrivateDetailTypeErasedT>
operand(TypeErased_T_ value) operand(PrivateDetailTypeErasedT value)
: handle_mem_var_( : private_detail_te_handle_mem_var(
std::make_shared<handle_type_<typename std::remove_reference<TypeErased_T_>::type>>( std::make_shared<private_detail_te_handle_type<
std::forward<TypeErased_T_>(value))) typename std::remove_reference<PrivateDetailTypeErasedT>::type>>(
std::forward<PrivateDetailTypeErasedT>(value)))
{ {
} }
// Assignment // Assignment
template <typename TypeErased_T_> template <typename PrivateDetailTypeErasedT>
operand& operator=(TypeErased_T_ value) operand& operator=(PrivateDetailTypeErasedT value)
{ {
if(handle_mem_var_.unique()) if(private_detail_te_handle_mem_var.unique())
*handle_mem_var_ = std::forward<TypeErased_T_>(value); *private_detail_te_handle_mem_var = std::forward<PrivateDetailTypeErasedT>(value);
else if(!handle_mem_var_) else if(!private_detail_te_handle_mem_var)
handle_mem_var_ = std::make_shared<TypeErased_T_>(std::forward<TypeErased_T_>(value)); private_detail_te_handle_mem_var = std::make_shared<PrivateDetailTypeErasedT>(
std::forward<PrivateDetailTypeErasedT>(value));
return *this; return *this;
} }
std::string name() const std::string name() const
{ {
assert(handle_mem_var_); assert(private_detail_te_handle_mem_var);
return get_handle_().name(); return private_detail_te_get_handle().name();
} }
shape compute_shape(std::vector<shape> input) const shape compute_shape(std::vector<shape> input) const
{ {
assert(handle_mem_var_); assert(private_detail_te_handle_mem_var);
return get_handle_().compute_shape(std::move(input)); return private_detail_te_get_handle().compute_shape(std::move(input));
} }
argument compute(std::vector<argument> input) const argument compute(std::vector<argument> input) const
{ {
assert(handle_mem_var_); assert(private_detail_te_handle_mem_var);
return get_handle_().compute(std::move(input)); return private_detail_te_get_handle().compute(std::move(input));
} }
private: private:
struct handle_base_type_ struct private_detail_te_handle_base_type
{ {
virtual ~handle_base_type_() {} virtual ~private_detail_te_handle_base_type() {}
virtual std::shared_ptr<handle_base_type_> clone() const = 0; virtual std::shared_ptr<private_detail_te_handle_base_type> clone() const = 0;
virtual std::string name() const = 0; virtual std::string name() const = 0;
virtual shape compute_shape(std::vector<shape> input) const = 0; virtual shape compute_shape(std::vector<shape> input) const = 0;
virtual argument compute(std::vector<argument> input) const = 0; virtual argument compute(std::vector<argument> input) const = 0;
}; };
template <typename TypeErased_T_> template <typename PrivateDetailTypeErasedT>
struct handle_type_ : handle_base_type_ struct private_detail_te_handle_type : private_detail_te_handle_base_type
{ {
template <typename TypeErased_U_ = TypeErased_T_> template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
handle_type_( private_detail_te_handle_type(
TypeErased_T_ value, PrivateDetailTypeErasedT value,
typename std::enable_if<std::is_reference<TypeErased_U_>::value>::type* = nullptr) typename std::enable_if<std::is_reference<PrivateDetailTypeErasedU>::value>::type* =
: value_(value) nullptr)
: private_detail_te_value(value)
{ {
} }
template <typename TypeErased_U_ = TypeErased_T_> template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
handle_type_(TypeErased_T_ value, private_detail_te_handle_type(
typename std::enable_if<!std::is_reference<TypeErased_U_>::value, int>::type* = PrivateDetailTypeErasedT value,
nullptr) noexcept typename std::enable_if<!std::is_reference<PrivateDetailTypeErasedU>::value,
: value_(std::move(value)) int>::type* = nullptr) noexcept
: private_detail_te_value(std::move(value))
{ {
} }
std::shared_ptr<handle_base_type_> clone() const override std::shared_ptr<private_detail_te_handle_base_type> clone() const override
{ {
return std::make_shared<handle_type_>(value_); return std::make_shared<private_detail_te_handle_type>(private_detail_te_value);
} }
std::string name() const override { return value_.name(); } std::string name() const override { return private_detail_te_value.name(); }
shape compute_shape(std::vector<shape> input) const override shape compute_shape(std::vector<shape> input) const override
{ {
return value_.compute_shape(std::move(input)); return private_detail_te_value.compute_shape(std::move(input));
} }
argument compute(std::vector<argument> input) const override argument compute(std::vector<argument> input) const override
{ {
return value_.compute(std::move(input)); return private_detail_te_value.compute(std::move(input));
} }
TypeErased_T_ value_; PrivateDetailTypeErasedT private_detail_te_value;
}; };
template <typename TypeErased_T_> template <typename PrivateDetailTypeErasedT>
struct handle_type_<std::reference_wrapper<TypeErased_T_>> : handle_type_<TypeErased_T_&> struct private_detail_te_handle_type<std::reference_wrapper<PrivateDetailTypeErasedT>>
: private_detail_te_handle_type<PrivateDetailTypeErasedT&>
{ {
handle_type_(std::reference_wrapper<TypeErased_T_> ref) private_detail_te_handle_type(std::reference_wrapper<PrivateDetailTypeErasedT> ref)
: handle_type_<TypeErased_T_&>(ref.get()) : private_detail_te_handle_type<PrivateDetailTypeErasedT&>(ref.get())
{ {
} }
}; };
const handle_base_type_& get_handle_() const { return *handle_mem_var_; } const private_detail_te_handle_base_type& private_detail_te_get_handle() const
{
return *private_detail_te_handle_mem_var;
}
handle_base_type_& get_handle_() private_detail_te_handle_base_type& private_detail_te_get_handle()
{ {
if(!handle_mem_var_.unique()) if(!private_detail_te_handle_mem_var.unique())
handle_mem_var_ = handle_mem_var_->clone(); private_detail_te_handle_mem_var = private_detail_te_handle_mem_var->clone();
return *handle_mem_var_; return *private_detail_te_handle_mem_var;
} }
std::shared_ptr<handle_base_type_> handle_mem_var_; std::shared_ptr<private_detail_te_handle_base_type> private_detail_te_handle_mem_var;
}; };
} // namespace rtg } // namespace rtg
......
include/rtg/shape.hpp
View file @ 83aa9ac3
...@@ -110,7 +110,7 @@ struct shape ...@@ -110,7 +110,7 @@ struct shape
template <class Visitor> template <class Visitor>
void visit_type(Visitor v) const void visit_type(Visitor v) const
{ {
switch(this->type_) switch(this->m_type)
{ {
#define RTG_SHAPE_VISITOR_CASE(x, t) \ #define RTG_SHAPE_VISITOR_CASE(x, t) \
case x: v(as<t>()); return; case x: v(as<t>()); return;
...@@ -121,10 +121,10 @@ struct shape ...@@ -121,10 +121,10 @@ struct shape
} }
private: private:
type_t type_; type_t m_type;
std::vector<std::size_t> lens_; std::vector<std::size_t> m_lens;
std::vector<std::size_t> strides_; std::vector<std::size_t> m_strides;
bool packed_; bool m_packed;
void calculate_strides(); void calculate_strides();
std::size_t element_space() const; std::size_t element_space() const;
......
include/rtg/tensor_view.hpp
View file @ 83aa9ac3
...@@ -11,103 +11,103 @@ namespace rtg { ...@@ -11,103 +11,103 @@ namespace rtg {
template <class T> template <class T>
struct tensor_view struct tensor_view
{ {
tensor_view() : data_(nullptr) {} tensor_view() : m_data(nullptr) {}
tensor_view(shape s, T* d) : data_(d), shape_(s) {} tensor_view(shape s, T* d) : m_data(d), m_shape(s) {}
const shape& get_shape() const { return this->shape_; } const shape& get_shape() const { return this->m_shape; }
bool empty() const { return data_ == nullptr || shape_.lens().empty(); } bool empty() const { return m_data == nullptr || m_shape.lens().empty(); }
std::size_t size() const { return shape_.elements(); } std::size_t size() const { return m_shape.elements(); }
T* data() { return this->data_; } T* data() { return this->m_data; }
const T* data() const { return this->data_; } const T* data() const { return this->m_data; }
template <class... Ts> template <class... Ts>
const T& operator()(Ts... xs) const const T& operator()(Ts... xs) const
{ {
return data_[shape_.index({xs...})]; return m_data[m_shape.index({xs...})];
} }
template <class... Ts> template <class... Ts>
T& operator()(Ts... xs) T& operator()(Ts... xs)
{ {
return data_[shape_.index({xs...})]; return m_data[m_shape.index({xs...})];
} }
T& operator[](std::size_t i) T& operator[](std::size_t i)
{ {
assert(!this->empty() && i < this->size()); assert(!this->empty() && i < this->size());
return data_[shape_.index(i)]; return m_data[m_shape.index(i)];
} }
const T& operator[](std::size_t i) const const T& operator[](std::size_t i) const
{ {
assert(!this->empty() && i < this->size()); assert(!this->empty() && i < this->size());
return data_[shape_.index(i)]; return m_data[m_shape.index(i)];
} }
T& front() T& front()
{ {
assert(!this->empty()); assert(!this->empty());
return data_[0]; return m_data[0];
} }
const T& front() const const T& front() const
{ {
assert(!this->empty()); assert(!this->empty());
return data_[0]; return m_data[0];
} }
T& back() T& back()
{ {
assert(!this->empty()); assert(!this->empty());
return data_[shape_.index(this->size() - 1)]; return m_data[m_shape.index(this->size() - 1)];
} }
const T& back() const const T& back() const
{ {
assert(!this->empty()); assert(!this->empty());
return data_[shape_.index(this->size() - 1)]; return m_data[m_shape.index(this->size() - 1)];
} }
// TODO: Add iterators so it can handle nonpacked tensors // TODO: Add iterators so it can handle nonpacked tensors
T* begin() T* begin()
{ {
assert(this->shape_.packed()); assert(this->m_shape.packed());
return data_; return m_data;
} }
T* end() T* end()
{ {
assert(this->shape_.packed()); assert(this->m_shape.packed());
if(this->empty()) if(this->empty())
return data_; return m_data;
else else
return data_ + this->size(); return m_data + this->size();
} }
const T* begin() const const T* begin() const
{ {
assert(this->shape_.packed()); assert(this->m_shape.packed());
return data_; return m_data;
} }
const T* end() const const T* end() const
{ {
assert(this->shape_.packed()); assert(this->m_shape.packed());
if(this->empty()) if(this->empty())
return data_; return m_data;
else else
return data_ + this->size(); return m_data + this->size();
} }
friend bool operator==(const tensor_view<T>& x, const tensor_view<T>& y) friend bool operator==(const tensor_view<T>& x, const tensor_view<T>& y)
{ {
if(x.shape_ == y.shape_) if(x.m_shape == y.m_shape)
{ {
for(std::size_t i = 0; i < x.shape_.elements(); i++) for(std::size_t i = 0; i < x.m_shape.elements(); i++)
{ {
if(!float_equal(x[i], y[i])) if(!float_equal(x[i], y[i]))
return false; return false;
...@@ -124,17 +124,17 @@ struct tensor_view ...@@ -124,17 +124,17 @@ struct tensor_view
if(!x.empty()) if(!x.empty())
{ {
os << x.front(); os << x.front();
for(std::size_t i = 1; i < x.shape_.elements(); i++) for(std::size_t i = 1; i < x.m_shape.elements(); i++)
{ {
os << ", " << x.data_[x.shape_.index(i)]; os << ", " << x.m_data[x.m_shape.index(i)];
} }
} }
return os; return os;
} }
private: private:
T* data_; T* m_data;
shape shape_; shape m_shape;
}; };
template <class T> template <class T>
......
src/shape.cpp
View file @ 83aa9ac3
...@@ -7,35 +7,35 @@ ...@@ -7,35 +7,35 @@
namespace rtg { namespace rtg {
shape::shape() : type_(float_type), packed_(false) {} shape::shape() : m_type(float_type), m_packed(false) {}
shape::shape(type_t t) : type_(t), lens_({1}), strides_({1}), packed_(true) {} shape::shape(type_t t) : m_type(t), m_lens({1}), m_strides({1}), m_packed(true) {}
shape::shape(type_t t, std::vector<std::size_t> l) : type_(t), lens_(std::move(l)), packed_(true) shape::shape(type_t t, std::vector<std::size_t> l) : m_type(t), m_lens(std::move(l)), m_packed(true)
{ {
this->calculate_strides(); this->calculate_strides();
assert(lens_.size() == strides_.size()); assert(m_lens.size() == m_strides.size());
} }
shape::shape(type_t t, std::vector<std::size_t> l, std::vector<std::size_t> s) shape::shape(type_t t, std::vector<std::size_t> l, std::vector<std::size_t> s)
: type_(t), lens_(std::move(l)), strides_(std::move(s)) : m_type(t), m_lens(std::move(l)), m_strides(std::move(s))
{ {
assert(lens_.size() == strides_.size()); assert(m_lens.size() == m_strides.size());
packed_ = this->elements() == this->element_space(); m_packed = this->elements() == this->element_space();
} }
void shape::calculate_strides() void shape::calculate_strides()
{ {
strides_.clear(); m_strides.clear();
strides_.resize(lens_.size(), 0); m_strides.resize(m_lens.size(), 0);
if(strides_.empty()) if(m_strides.empty())
return; return;
strides_.back() = 1; m_strides.back() = 1;
std::partial_sum( std::partial_sum(
lens_.rbegin(), lens_.rend() - 1, strides_.rbegin() + 1, std::multiplies<std::size_t>()); m_lens.rbegin(), m_lens.rend() - 1, m_strides.rbegin() + 1, std::multiplies<std::size_t>());
} }
shape::type_t shape::type() const { return this->type_; } shape::type_t shape::type() const { return this->m_type; }
const std::vector<std::size_t>& shape::lens() const { return this->lens_; } const std::vector<std::size_t>& shape::lens() const { return this->m_lens; }
const std::vector<std::size_t>& shape::strides() const { return this->strides_; } const std::vector<std::size_t>& shape::strides() const { return this->m_strides; }
std::size_t shape::elements() const std::size_t shape::elements() const
{ {
assert(this->lens().size() == this->strides().size()); assert(this->lens().size() == this->strides().size());
...@@ -71,7 +71,7 @@ std::size_t shape::index(std::size_t i) const ...@@ -71,7 +71,7 @@ std::size_t shape::index(std::size_t i) const
std::plus<std::size_t>{}, std::plus<std::size_t>{},
[&](std::size_t len, std::size_t stride) { return ((i / stride) % len) * stride; }); [&](std::size_t len, std::size_t stride) { return ((i / stride) % len) * stride; });
} }
bool shape::packed() const { return this->packed_; } bool shape::packed() const { return this->m_packed; }
std::size_t shape::element_space() const std::size_t shape::element_space() const
{ {
// TODO: Get rid of intermediate vector // TODO: Get rid of intermediate vector
...@@ -89,7 +89,7 @@ std::size_t shape::element_space() const ...@@ -89,7 +89,7 @@ std::size_t shape::element_space() const
std::string shape::type_string() const std::string shape::type_string() const
{ {
switch(this->type_) switch(this->m_type)
{ {
#define RTG_SHAPE_TYPE_STRING_CASE(x, t) \ #define RTG_SHAPE_TYPE_STRING_CASE(x, t) \
case x: return #x; case x: return #x;
......
test/test.hpp
View file @ 83aa9ac3
...@@ -4,8 +4,8 @@ ...@@ -4,8 +4,8 @@
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#ifndef GUARD_TEST_TEST_HPP_ #ifndef GUARD_TEST_TEST_HPP
#define GUARD_TEST_TEST_HPP_ #define GUARD_TEST_TEST_HPP
inline void failed(const char* msg, const char* file, int line) inline void failed(const char* msg, const char* file, int line)
{ {
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment