#ifndef TENSOR_CONTENT

#define TENSOR_CONTENT

#include "tensor.hh"

#undef TENSOR_CONTENT

#endif // !TENSOR_CONTENT

#include <thread>

#include <forward_list>

#include <unordered_set>

#include <cassert>

#include <cstring>

#include "data_type_wrapper.hh"

#define USING_DATA_TYPE_FLOAT() (float)(double)

#define USING_DATA_TYPE_SINT() (int8_t)(int16_t)(int32_t)(int64_t)

#define USING_DATA_TYPE_UINT() (uint8_t)(uint16_t)(uint32_t)(uint64_t)

#define USING_DATA_TYPE USING_DATA_TYPE_SINT() USING_DATA_TYPE_UINT() USING_DATA_TYPE_FLOAT()

#define LOOP(seq) END(A seq)

#define BODY(x) ADD_CODE(x)

#define A(x) BODY(x) B

#define B(x) BODY(x) A

#define A_END

#define B_END

#define END(...) END_(__VA_ARGS__)

#define END_(...) __VA_ARGS__##_END

namespace tensor_array

{

namespace value

{

bool use_grad = true;

bool is_use_grad()

{

return use_grad;

}

void set_use_grad(bool use)

{

use_grad = use;

}

class Tensor::TensorContent

{

private:

const TensorBase buf;

protected:

std::mutex tensor_mutex;

std::unordered_set<const Tensor::TensorContent*> forward_back;

TensorBase grad;

public:

friend const TensorBase& Tensor::get_buffer() const;

TensorContent() = delete;

TensorContent(const TensorBase&);

TensorContent(TensorBase&&);

TensorContent(const TensorContent&) = delete;

TensorContent(TensorContent&&) = delete;

virtual ~TensorContent() = default;

virtual void reset_grad();

virtual void calc_grad(const Tensor&);

void reset_grad_thread(const Tensor* tensor_ptr);

void calc_grad_thread(Tensor grad, const std::pair<const Tensor, std::vector<Derivation>>* data_ptr);

Tensor get_grad() const;

};

class TensorContentDerivation final : public Tensor::TensorContent

};

Derivation::Derivation(const Tensor& derive_value, const multiply_type multi, bool is_value_before, const DataBuffer& option) :

}

std::unordered_map<Tensor, std::vector<Derivation>> check_derive_data(const std::vector<std::pair<Tensor, Derivation>>& derive_data)

}

Tensor Derivation::calc_grad_temp(const Tensor& grad) const

{

return (this->is_value_before) ? this->multi(this->derive_value, grad, false, this->option) : this->multi(grad, this->derive_value, false, this->option);

}

bool& TensorContentDerivation::multithread_derive()

{

return this->derive_multithread;

}

Tensor Tensor::TensorContent::get_grad() const

{

return (this->grad.has_tensor()) ? Tensor(this->grad) : Tensor();

}

void Tensor::TensorContent::reset_grad_thread(const Tensor* tensor_ptr)

{

if (tensor_ptr->tensor_data->forward_back.find(this) == tensor_ptr->tensor_data->forward_back.end())

{

tensor_ptr->tensor_data->reset_grad();

tensor_ptr->tensor_data->forward_back.insert(this);

}

}

void TensorContentDerivation::reset_grad()

}

void Tensor::TensorContent::reset_grad()

{

std::lock_guard tensor_lock(this->tensor_mutex);

this->grad = zeros<int>(this->buf.shape()).tensor_cast(this->buf.type()).get_buffer();

}

void Tensor::TensorContent::calc_grad_thread(Tensor grad, const std::pair<const Tensor, std::vector<Derivation>>* data_ptr)

{

auto& [child, derive_data] = *data_ptr;

Tensor temp_sum = zeros<int>(child.get_buffer().shape()).tensor_cast(child.get_buffer().type(), false);

for (auto& it : derive_data)

temp_sum = add(temp_sum, it.calc_grad_temp(grad), false);

child.tensor_data->forward_back.erase(this);

child.tensor_data->calc_grad(temp_sum);

}

void TensorContentDerivation::calc_grad(const Tensor& grad)

}

void Tensor::TensorContent::calc_grad(const Tensor& grad)

{

std::lock_guard tensor_lock(this->tensor_mutex);

this->grad = add(this->grad, grad, false).get_buffer();

}

Tensor derive_dim_added(const Tensor& children, const Tensor&, bool, const DataBuffer& dat)

{

return children[*static_cast<const unsigned int*>(dat.get_data())];

}

Tensor add_dim(const std::vector<Tensor>& list)

}

std::pair<Tensor, Tensor> Tensor::max(unsigned char dim) const

}

std::pair<Tensor, Tensor> Tensor::min(unsigned char dim) const

}

bool operator==(const Tensor::Iterator& a, const Tensor::Iterator& b)

{

return (&a.ref == &b.ref) && (a.index == b.index);

}

bool operator!=(const Tensor::Iterator& a, const Tensor::Iterator& b)

{

return (&a.ref != &b.ref) || (a.index != b.index);

}

std::pair<Tensor, Tensor> tensor_broadcasting(const Tensor& a, const Tensor& b, unsigned char begin_dim, unsigned char end_dim)

}

unsigned long long calculate_size(const std::initializer_list<unsigned int>& list)

}

Tensor Tensor::unslice(const std::initializer_list<unsigned int>& shape_arr, const std::initializer_list<Slice>& slice_arr) const

}

Tensor derive_slice(const Tensor& in_value, const Tensor& out_shape, bool, const DataBuffer& dat)

}

Tensor Tensor::slice(const std::initializer_list<Slice>& slice_arr, bool is_derive) const

}

Tensor::Tensor(const TensorBase& t, const std::vector<std::pair<Tensor, Derivation>>& derive_data) :

tensor_data(std::make_shared<TensorContentDerivation>(t, derive_data))

{

}

Tensor::Tensor(TensorBase&& t, std::vector<std::pair<Tensor, Derivation>>&& derive_data) :

tensor_data(std::make_shared<TensorContentDerivation>(std::forward<TensorBase>(t), std::forward<std::vector<std::pair<Tensor, Derivation>>>(derive_data)))

{

}

Tensor::Tensor(const TensorBase& t) :

tensor_data(std::make_shared<TensorContent>(t))

{

}

Tensor::Tensor(TensorBase&& t):

tensor_data(std::make_shared<TensorContent>(std::forward<TensorBase>(t)))

{

}

Tensor::Tensor(const std::shared_ptr<TensorContent>& tensor_data):

tensor_data(tensor_data)

{

}

Tensor::Tensor(std::shared_ptr<TensorContent>&& tensor_data):

tensor_data(std::forward<std::shared_ptr<TensorContent>>(tensor_data))

{

}

Tensor::~Tensor()

{

}

Tensor Tensor::clone() const

{

return Tensor(this->get_buffer());

}

void Tensor::save(const char* dir) const

}

int Tensor::real_index(int index) const

}

Tensor::Slice Tensor::correct_slice(const Slice& input_value) const

}

bool& Tensor::multithread_derive()

{

TensorContentDerivation* temp = dynamic_cast<TensorContentDerivation*>(this->tensor_data.get());

assert(temp);

return temp->multithread_derive();

}

long Tensor::tensor_use_count()

{

return this->tensor_data.use_count();

}

std::mutex calc_grad_mutex;

void Tensor::calc_grad()

}

Tensor Tensor::transpose(unsigned char dim0, unsigned char dim1, bool is_derive) const

}

bool Tensor::has_tensor() const

{

return static_cast<bool>(this->tensor_data);

}

Tensor Tensor::transpose(unsigned char dim0, unsigned char dim1) const

{

return this->transpose(dim0, dim1, true);

}

Tensor Tensor::loss(const Tensor& real_value) const

}

Tensor Tensor::mean(unsigned char dim) const

}

Tensor Tensor::variance(unsigned char dim) const

{

return power(*this - this->mean(dim), Tensor(TensorArray<float>{ 1.f })).mean(dim);

}

Tensor Tensor::mean(const std::initializer_list<unsigned char>& list_dims) const

}

Tensor Tensor::variance(const std::initializer_list<unsigned char>& list_dims) const

}

Tensor Tensor::mean(const std::vector<unsigned char>& list_dims) const

{

return this->mean(wrapper::initializer_wrapper<unsigned char>(list_dims.begin().operator->(), list_dims.end().operator->()));

}

Tensor Tensor::variance(const std::vector<unsigned char>& list_dims) const

{

return this->variance(wrapper::initializer_wrapper(list_dims.begin().operator->(), list_dims.end().operator->()));

}

Tensor Tensor::value_scalar() const

{

return dot(*this, values(this->get_buffer().shape(), 1.f));

}

Tensor Tensor::get_grad() const

{

return this->tensor_data.get()->get_grad();

}

Tensor::Iterator Tensor::begin() const

{

return Iterator(*this, 0);

}

Tensor::Iterator Tensor::end() const

{

return Iterator(*this, this->get_buffer().shape().begin()[0]);

}

Tensor::Iterator Tensor::cbegin() const

{

return Iterator(*this, 0);

}

Tensor::Iterator Tensor::cend() const

{

return Iterator(*this, this->get_buffer().shape().begin()[0]);

}

const TensorBase& Tensor::get_buffer() const

{

return static_cast<bool>(this->tensor_data) ? this->tensor_data->buf : throw 0;

}

Tensor derive_reshape_cast(const Tensor& dat, const Tensor& new_shape, bool, const DataBuffer&)

{

return dat.reshape(new_shape.get_buffer().shape(), false).tensor_cast(new_shape.get_buffer().type(), false);

}

Tensor Tensor::reshape(const std::initializer_list<unsigned int>& list_dim, bool is_derive) const

}

Tensor Tensor::tensor_cast(const std::type_info& dtype) const

{

return tensor_cast(dtype, true);

}

Tensor Tensor::expand(unsigned char dim, unsigned int size)

}

Tensor Tensor::reshape(const std::initializer_list<unsigned int>& dim_sizes) const

{

return this->reshape(dim_sizes, true);

}

Tensor Tensor::reshape(const std::vector<unsigned int>& dim_sizes) const

{

return this->reshape(wrapper::initializer_wrapper(dim_sizes.begin().operator->(), dim_sizes.end().operator->()));

}

Tensor derive_index(const Tensor& in_value, const Tensor&, bool, const DataBuffer& dat)

}

Tensor Tensor::operator[](unsigned int index) const

{

unsigned int temp_arr[2] {this->get_buffer().shape().begin()[0],index};

return Tensor(this->get_buffer()[index], { std::make_pair(std::forward<const Tensor>(*this), Derivation(Tensor(), derive_index, false, temp_arr)) });

}

Tensor Tensor::operator[](const std::initializer_list<Slice>& slice_arr) const

{

return this->slice(slice_arr, true);

}

Tensor Tensor::operator+() const

{

return multiply(*this, values(this->get_buffer().shape(), 1));

}

Tensor operator+(const Tensor& a, const Tensor& b)

{

return add(a, b);

}

Tensor Tensor::operator-() const

{

return multiply(*this, values(this->get_buffer().shape(), -1.f));

}

Tensor& Tensor::operator+=(const Tensor& other)

{

return this->operator=((*this) + other);

}

Tensor& Tensor::operator-=(const Tensor& other)

{

return this->operator=((*this) - other);

}

Tensor& Tensor::operator*=(const Tensor& other)

{

return this->operator=((*this) * other);

}

Tensor& Tensor::operator/=(const Tensor& other)

{

return this->operator=((*this) / other);

}

Tensor operator-(const Tensor& a, const Tensor& b)

{

return add(a, -b);

}

Tensor operator*(const Tensor& a, const Tensor& b)

{

return multiply(a, b);

}

Tensor operator/(const Tensor& a, const Tensor& b)

{

return divide(a, b);

}

Tensor Tensor::exp() const

{

return this->exp(true);

}

Tensor Tensor::sin() const

{

return this->sin(true);

}

Tensor Tensor::cos() const

{

return this->cos(true);

}

Tensor Tensor::tan() const

{

return this->tan(true);

}

Tensor Tensor::sinh() const

{

return this->sinh(true);

}

Tensor Tensor::cosh() const

{

return this->cosh(true);

}

Tensor Tensor::tanh() const

{

return this->tanh(true);

}

Tensor Tensor::sigmoid() const

{

return this->sigmoid(true);

}

Tensor tensor_file_load(const char* dir)

}

std::ostream& operator<<(std::ostream& out_stream, const Tensor& tensor_out)

{

std::string enter;

if (tensor_out.get_buffer().shape().size())

{

out_stream << '{';

for (Tensor it : tensor_out)

{

out_stream << enter << it;

if (enter.size() == 0)

{

if (tensor_out.get_buffer().shape().size() == 1)

enter = ", ";

else

enter = ", \n";

}

}

out_stream << '}';

}

else

{

#define ADD_CODE(TEMP)\

if (tensor_out.get_buffer().type() == typeid(TEMP))\

out_stream << static_cast<TEMP>(tensor_out);

LOOP((bool)USING_DATA_TYPE);

#undef ADD_CODE

}

return out_stream;

}

Tensor power(const Tensor& a, const Tensor& b)

}

Tensor add(const Tensor& a, const Tensor& b)

}

Tensor multiply(const Tensor& a, const Tensor& b)

}

Tensor divide(const Tensor& a, const Tensor& b)

}

Tensor dot(const Tensor& a, const Tensor& b)

}

Tensor matmul(const Tensor& a, const Tensor& b)

}

Tensor condition(const Tensor& value_bool, const Tensor& value_true, const Tensor& value_false)

{

return condition(value_bool, value_true, value_false, true);

}

Tensor tensor_rand(const std::vector<unsigned int>& shape_vector, unsigned int seed)

{

return tensor_rand(wrapper::initializer_wrapper(shape_vector.begin().operator->(), shape_vector.end().operator->()), seed);

}

Tensor::Iterator::Iterator(reference_left ref, unsigned int index):

ref(ref),

index(index)

{

}

Tensor::Iterator::reference Tensor::Iterator::operator*() const

{

return this->ref[index];

}

Tensor::Iterator& Tensor::Iterator::operator++()

{

index++;

return *this;

}

Tensor::Iterator& Tensor::Iterator::operator--()

{

index--;

return *this;

}

Tensor::Iterator Tensor::Iterator::operator++(int)

{

Iterator temp(*this);

index++;

return temp;

}

Tensor::Iterator Tensor::Iterator::operator--(int)

{

Iterator temp(*this);

index--;

return temp;

}

bool typeinfo_is_floating_point(const std::type_info& dtype)

{

return dtype == typeid(float) || dtype == typeid(double);

}

const std::type_info& comparison_type(const std::type_info& a, const std::type_info& b)

{

if (typeinfo_is_floating_point(a) == typeinfo_is_floating_point(b))

return (get_sizeof_type(a) > get_sizeof_type(b)) ? a : b;

if (typeinfo_is_floating_point(a))

return a;

if (typeinfo_is_floating_point(b))

return b;

throw std::exception();

}

TensorContentDerivation::TensorContentDerivation(const TensorBase& buf, const std::vector<std::pair<Tensor, Derivation>>& derive_data):

}

TensorContentDerivation::TensorContentDerivation(TensorBase&& buf, std::vector<std::pair<Tensor, Derivation>>&& derive_data) :

}

void* create_mem_101(std::size_t s, const void* dat)

{

void* temp_sizes = operator new(s);

std::memcpy(temp_sizes, dat, s);

return temp_sizes;

}

bool operator==(const DataBuffer& a, const DataBuffer& b)

{

return a.data_size == b.data_size && std::memcmp(a.data, b.data, std::min(a.data_size, b.data_size)) == 0;

}

DataBuffer::DataBuffer():

}

DataBuffer::DataBuffer(std::nullptr_t null):

}

DataBuffer::DataBuffer(const DataBuffer& other):

}

DataBuffer::~DataBuffer()