Skip to content

GitLab

xerus
xerus
Commit 914c755a authored by Philipp Trunschke's avatar Philipp Trunschke
Browse files
Options

bugfixes in python wrapper

parent f9223e2c
Pipeline #2005 failed with stages
                    in 16 minutes and 47 seconds
                    Hide whitespace changes
                    Inline Side-by-side
                    Showing with 160 additions and 112 deletions
                    src/xerus/python/htnetwork.cpp
                    View file @ 914c755a
                    ......@@ -48,7 +48,7 @@ void expose_htnetwork(module& m) {
                    .def_readonly("corePosition", &HTTensor::corePosition)
                    .def("ranks", &HTTensor::ranks)
                    .def("rank", &HTTensor::rank)
                    // .def("frob_norm", &TTTensor::frob_norm) // NOTE unneccessary because correct call is inherited
                    //.def("frob_norm", &TTTensor::frob_norm) // NOTE unneccessary because correct call is inherited
                    .def_static("random",
                    +[](std::vector<size_t> _dim, std::vector<size_t> _rank) {
                    return xerus::HTTensor::random(_dim, _rank);
                    ......@@ -60,12 +60,7 @@ void expose_htnetwork(module& m) {
                    //.def("use_dense_representations", &TTTensor::use_dense_representations)
                    //.def_static("reduce_to_maximal_ranks", &TTTensor::reduce_to_maximal_ranks)
                    //// .def("degrees_of_freedom", static_cast<size_t (TTTensor::*)()>(&TTTensor::degrees_of_freedom))
                    //.def_static("degrees_of_freedom", static_cast<size_t (*)(const std::vector<size_t>&, const std::vector<size_t>&)>(&TTTensor::degrees_of_freedom))
                    // +[](HTTensor &_this, size_t _pos) {
                    // const auto result = _this.chop(_pos);
                    // return boost::python::make_tuple(result.first, result.second);
                    // }, arg("position"))
                    //.def("degrees_of_freedom", static_cast<size_t (TTTensor::*)()>(&TTTensor::degrees_of_freedom))
                    .def("round", static_cast<void (HTTensor::*)(const std::vector<size_t>&, double)>(&HTTensor::round),
                    arg("ranks"), arg("epsilon")=EPSILON
                    ......@@ -109,7 +104,7 @@ void expose_htnetwork(module& m) {
                    .def_readonly("corePosition", &HTOperator::corePosition)
                    .def("ranks", &HTOperator::ranks)
                    .def("rank", &HTOperator::rank)
                    // .def("frob_norm", &TTOperator::frob_norm) // NOTE unneccessary because correct call is inherited
                    //.def("frob_norm", &TTOperator::frob_norm) // NOTE unneccessary because correct call is inherited
                    .def_static("random",
                    +[](std::vector<size_t> _dim, std::vector<size_t> _rank) {
                    return xerus::HTOperator::random(_dim, _rank);
                    ......@@ -121,14 +116,10 @@ void expose_htnetwork(module& m) {
                    //.def("use_dense_representations", &TTOperator::use_dense_representations)
                    //.def("reduce_to_maximal_ranks", &TTOperator::reduce_to_maximal_ranks).staticmethod("reduce_to_maximal_ranks")
                    // .def("degrees_of_freedom", static_cast<size_t (TTOperator::*)()>(&TTOperator::degrees_of_freedom))
                    //.def("degrees_of_freedom", static_cast<size_t (TTOperator::*)()>(&TTOperator::degrees_of_freedom))
                    //.def("degrees_of_freedom", static_cast<size_t (*)(const std::vector<size_t>&, const std::vector<size_t>&)>(&TTOperator::degrees_of_freedom)).staticmethod("degrees_of_freedom")
                    // .def("chop",
                    // +[](HTOperator &_this, size_t _pos) {
                    // const auto result = _this.chop(_pos);
                    // return boost::python::make_tuple(result.first, result.second);
                    // }, arg("position"))
                    //
                    //.def("chop", ...)
                    .def("round", static_cast<void (HTOperator::*)(const std::vector<size_t>&, double)>(&HTOperator::round),
                    arg("ranks"), arg("epsilon")=EPSILON
                    )
                    ......
                    src/xerus/python/indexedTensor.cpp
                    View file @ 914c755a
                    ......@@ -32,22 +32,19 @@ void expose_indexedTensors(module& m) {
                    )
                    .def(init())
                    .def(init<int64_t>())
                    .def("__pow__", &Index::operator^, "i**d changes the index i to span d indices in the current expression")
                    .def("__xor__", &Index::operator^, "i^d changes the index i to span d indices in the current expression")
                    .def("__div__", &Index::operator/, "i/n changes the index i to span 1/n of all the indices of the current object")
                    .def("__pow__", &Index::operator^, "i**d changes the index i to span d indices in the current expression")
                    .def("__xor__", &Index::operator^, "i^d changes the index i to span d indices in the current expression")
                    .def("__truediv__", &Index::operator/, "i/n changes the index i to span 1/n of all the indices of the current object")
                    .def("__and__", &Index::operator&, "i&d changes the index i to span all but d indices of the current object")
                    // .def("__str__", static_cast<std::string (*)(const Index &)>(&misc::to_string<Index>))
                    .def("__and__", &Index::operator&, "i&d changes the index i to span all but d indices of the current object")
                    .def("__repr__", static_cast<std::string (*)(const Index &)>(&misc::to_string<Index>))
                    ;
                    implicitly_convertible<int64_t, Index>();
                    m.def("indices", [](const size_t n) -> std::vector<Index> { return std::vector<Index>(n); });
                    // NOTE in the following all __mul__ variants are defined for the ReadOnly indexed Tensors, even if they are meant for
                    // the moveable indexed tensors. boost will take care of the proper matching that way. if IndexedTensorMoveable
                    // defined an __mul__ function on its own it would overwrite all overloaded variants of the readonly indexed tensors
                    // and thus loose a lot of functionality.
                    // ---------------------------------------------- indexedTensor<TN>
                    // NOTE In the follwoing all magic methods are defined only for the ReadOnly indexed Tensors.
                    // Since Writable, Movable and the generic IndexedTensor are subclasses they inherit the methods and since the
                    // first argument (except self) is always ReadOnly these methods work for arbitrary combinations.
                    // pybind11 will take care of the proper matching.
                    using namespace internal;
                    #define ADD_MOVE_AND_RESULT_PTR(name, op, lhs_type, rhs_type, res_type) \
                    .def(name, \
                    ......@@ -57,25 +54,21 @@ void expose_indexedTensors(module& m) {
                    }, keep_alive<0, 1>(), keep_alive<0, 2>(), return_value_policy::take_ownership)
                    class_<internal::IndexedTensorReadOnly<TensorNetwork>>(m,"IndexedTensorNetworkReadOnly")
                    ADD_MOVE_AND_RESULT_PTR("__add__", +, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__add__", +, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__sub__", -, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__sub__", -, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorMoveable<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorMoveable<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, value_t, IndexedTensorReadOnly<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__rmul__", *, IndexedTensorReadOnly<TensorNetwork>, value_t, IndexedTensorReadOnly<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__div__", /, IndexedTensorReadOnly<TensorNetwork>, value_t, IndexedTensorReadOnly<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__add__", +, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__add__", +, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__sub__", -, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__sub__", -, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<TensorNetwork>, value_t, IndexedTensorReadOnly<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__rmul__", *, IndexedTensorReadOnly<TensorNetwork>, value_t, IndexedTensorReadOnly<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__truediv__", /, IndexedTensorReadOnly<TensorNetwork>, value_t, IndexedTensorReadOnly<TensorNetwork>)
                    .def("frob_norm", static_cast<value_t (*)(const IndexedTensorReadOnly<TensorNetwork> &)>(&frob_norm<TensorNetwork>))
                    .def("__float__", [](const IndexedTensorReadOnly<TensorNetwork> &_self){ return value_t(_self); })
                    ;
                    class_<internal::IndexedTensorWritable<TensorNetwork>, internal::IndexedTensorReadOnly<TensorNetwork>>(m,"IndexedTensorNetworkWriteable");
                    class_<internal::IndexedTensorMoveable<TensorNetwork>, internal::IndexedTensorWritable<TensorNetwork>>(m,"IndexedTensorNetworkMoveable");
                    class_<internal::IndexedTensor<TensorNetwork>, internal::IndexedTensorWritable<TensorNetwork>>(m,"IndexedTensorNetwork")
                    class_<internal::IndexedTensor<TensorNetwork>, internal::IndexedTensorWritable<TensorNetwork>>(m,"IndexedTensorNetwork")
                    .def("__lshift__",
                    +[](internal::IndexedTensor<TensorNetwork> &_lhs, internal::IndexedTensorReadOnly<Tensor> &_rhs) {
                    std::move(_lhs) = std::move(_rhs);
                    ......@@ -86,24 +79,20 @@ void expose_indexedTensors(module& m) {
                    })
                    ;
                    // --------------------------------------------- indexedTensor<Tensor>
                    class_<internal::IndexedTensorReadOnly<Tensor>>(m,"IndexedTensorReadOnly")
                    ADD_MOVE_AND_RESULT_PTR("__add__", +, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__sub__", -, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__div__", /, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<Tensor>, value_t, IndexedTensorReadOnly<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__rmul__", *, IndexedTensorReadOnly<Tensor>, value_t, IndexedTensorReadOnly<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__div__", /, IndexedTensorReadOnly<Tensor>, value_t, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__add__", +, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__sub__", -, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<TensorNetwork>, IndexedTensorMoveable<TensorNetwork>)
                    ADD_MOVE_AND_RESULT_PTR("__mul__", *, IndexedTensorReadOnly<Tensor>, value_t, IndexedTensorReadOnly<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__rmul__", *, IndexedTensorReadOnly<Tensor>, value_t, IndexedTensorReadOnly<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__truediv__", /, IndexedTensorReadOnly<Tensor>, IndexedTensorReadOnly<Tensor>, IndexedTensorMoveable<Tensor>)
                    ADD_MOVE_AND_RESULT_PTR("__truediv__", /, IndexedTensorReadOnly<Tensor>, value_t, IndexedTensorMoveable<Tensor>)
                    .def("frob_norm", static_cast<value_t (*)(const IndexedTensorReadOnly<Tensor> &)>(&frob_norm<Tensor>))
                    .def("__float__", [](const IndexedTensorReadOnly<Tensor> &_self){ return value_t(_self); })
                    ;
                    class_<internal::IndexedTensorWritable<Tensor>, internal::IndexedTensorReadOnly<Tensor>>(m,"IndexedTensorWriteable")
                    ;
                    class_<internal::IndexedTensorMoveable<Tensor>, internal::IndexedTensorWritable<Tensor>>(m,"IndexedTensorMoveable")
                    ;
                    class_<internal::IndexedTensorWritable<Tensor>, internal::IndexedTensorReadOnly<Tensor>>(m,"IndexedTensorWriteable");
                    class_<internal::IndexedTensorMoveable<Tensor>, internal::IndexedTensorWritable<Tensor>>(m,"IndexedTensorMoveable");
                    class_<internal::IndexedTensor<Tensor>, internal::IndexedTensorWritable<Tensor>>(m,"IndexedTensor")
                    .def("__lshift__",
                    +[](internal::IndexedTensor<Tensor> &_lhs, internal::IndexedTensorReadOnly<Tensor> &_rhs) {
                    ......@@ -119,5 +108,5 @@ void expose_indexedTensors(module& m) {
                    implicitly_convertible<internal::IndexedTensorReadOnly<Tensor>, internal::IndexedTensorMoveable<TensorNetwork>>();
                    implicitly_convertible<internal::IndexedTensorWritable<Tensor>, internal::IndexedTensorMoveable<TensorNetwork>>();
                    implicitly_convertible<internal::IndexedTensorMoveable<Tensor>, internal::IndexedTensorMoveable<TensorNetwork>>();
                    implicitly_convertible<internal::IndexedTensor<Tensor>, internal::IndexedTensorMoveable<TensorNetwork>>();
                    implicitly_convertible<internal::IndexedTensor<Tensor>, internal::IndexedTensorMoveable<TensorNetwork>>();
                    }
                    src/xerus/python/tensor.cpp
                    View file @ 914c755a
                    #include "misc.h"
                    #include<pybind11/numpy.h>
                    std::vector<size_t> strides_from_dimensions_and_item_size(const std::vector<size_t>& _dimensions, const size_t _item_size) {
                    ......@@ -6,14 +7,30 @@ std::vector<size_t> strides_from_dimensions_and_item_size(const std::vector<size
                    std::vector<size_t> strides(ndim, 0);
                    if (ndim > 0) {
                    strides[ndim-1] = _item_size;
                    for (size_t i=0; i<ndim-1; ++i) {
                    size_t rev_i = ndim-1-i;
                    strides[rev_i-1] = _dimensions[rev_i] * strides[rev_i];
                    for (size_t i=ndim-1; i>0; --i) {
                    strides[i-1] = _dimensions[i] * strides[i];
                    }
                    }
                    return strides;
                    }
                    Tensor Tensor_from_buffer(buffer& _b) {
                    // cast buffer into c_contiguous array (removes boilerplate code)
                    auto b = array_t<value_t, array::c_style | array::forcecast>::ensure(_b);
                    buffer_info info = b.request();
                    if (info.shape.size() == 1 and info.shape[0] == 0) {
                    return Tensor({}, Tensor::Representation::Dense, Tensor::Initialisation::None);
                    }
                    std::vector<size_t> dims(info.shape.begin(), info.shape.end());
                    std::vector<size_t> strides(info.strides.begin(), info.strides.end());
                    Tensor result(dims, Tensor::Representation::Dense, Tensor::Initialisation::None);
                    misc::copy(result.get_unsanitized_dense_data(), static_cast<double*>(info.ptr), result.size);
                    return result;
                    }
                    void expose_tensor(module& m) {
                    enum_<Tensor::Representation>(m, "Representation", "Possible representations of Tensor objects.")
                    ......@@ -22,7 +39,7 @@ void expose_tensor(module& m) {
                    ;
                    enum_<Tensor::Initialisation>(m, "Initialisation", "Possible initialisations of new Tensor objects.")
                    .value("Zero", Tensor::Initialisation::Zero)
                    .value("None", Tensor::Initialisation::None)
                    .value("Uninitialized", Tensor::Initialisation::None) /* None is a protected keyword in python */
                    ;
                    class_<Tensor>(m, "Tensor", "a non-decomposed Tensor in either sparse or dense representation", buffer_protocol())
                    ......@@ -58,41 +75,7 @@ void expose_tensor(module& m) {
                    LOG(warning, "Deprecation warning: `from_function` is deprecated and will be removed in Xerus v5.0.0. Use the `Tensor` constructor instead.");
                    return Tensor(_dim, _f);
                    })
                    .def_static("from_buffer", +[](buffer& b){
                    buffer_info info = b.request();
                    if (info.format != format_descriptor<double>::format()) {
                    throw std::runtime_error("Incompatible format: expected a double array!");
                    }
                    if (info.itemsize != sizeof(value_t)) {
                    std::ostringstream msg;
                    msg << "Incompatible size: " << info.itemsize << " (got) vs " << sizeof(value_t) << " (expected)";
                    throw std::runtime_error(msg.str());
                    }
                    if (info.shape.size() == 1 and info.shape[0] == 0) {
                    return Tensor({}, Tensor::Representation::Dense, Tensor::Initialisation::None);
                    }
                    std::vector<size_t> dims(info.shape.begin(), info.shape.end());
                    std::vector<size_t> strides(info.strides.begin(), info.strides.end());
                    if (strides != strides_from_dimensions_and_item_size(dims, info.itemsize)) {
                    std::ostringstream msg;
                    msg << "Incompatible strides: " << strides << " (got) vs " << strides_from_dimensions_and_item_size(dims, info.itemsize) << " (expected). Make sure your buffer is C contiguous." << std::endl;
                    throw std::runtime_error(msg.str());
                    }
                    Tensor result(dims, Tensor::Representation::Dense, Tensor::Initialisation::None);
                    /* *(result.override_dense_data()) = static_cast<double*>(info.ptr); */
                    misc::copy(result.get_unsanitized_dense_data(), static_cast<double*>(info.ptr), result.size);
                    return result;
                    })
                    .def("__float__", [](const Tensor &_self){
                    if (_self.order() != 0) {
                    throw value_error("order must be 0");
                    }
                    return value_t(_self());
                    })
                    .def_static("from_buffer", &Tensor_from_buffer)
                    .def_property_readonly("dimensions", +[](Tensor &_A) {
                    return _A.dimensions;
                    })
                    ......@@ -208,13 +191,25 @@ arg("dim")
                    return new xerus::internal::IndexedTensor<Tensor>(std::move(_this(idx)));
                    }, keep_alive<0,1>(), return_value_policy::take_ownership )
                    .def("__str__", &Tensor::to_string)
                    .def(self * value_t())
                    .def(value_t() * self)
                    .def(self / value_t())
                    /* .def(-self) */
                    .def("__neg__",
                    +[](TTTensor& _self) {
                    return (-1)*_self;
                    })
                    .def(self + self)
                    .def(self - self)
                    .def(self += self)
                    .def(self -= self)
                    .def(self * value_t())
                    .def(value_t() * self)
                    .def(self *= value_t())
                    .def(self / value_t())
                    /* .def(self /= self) */
                    .def("__itruediv__",
                    +[](TTTensor& _self, const value_t _other) {
                    return (_self *= (1/_other));
                    })
                    .def("__getitem__", +[](Tensor &_this, size_t _i) {
                    if (_i >= _this.size) {
                    throw index_error("Index out of range");
                    ......@@ -230,6 +225,65 @@ arg("dim")
                    .def("__setitem__", +[](Tensor &_this, std::vector<size_t> _i, value_t _val) {
                    _this[_i] = _val;
                    })
                    // .def("__float__", [](const Tensor &_self){ return value_t(_self); }) //TODO: does not work! use implicitly_convertible<Tensor, internal::IndexedTensorReadOnly<TensorNetwork>>();
                    .def("__float__", [](const Tensor &_self){
                    if (_self.order() != 0) {
                    throw value_error("order must be 0");
                    }
                    return value_t(_self());
                    })
                    ;
                    }
                    // NOTE The following code (when defined globally) would cast every xerus::Tensor to a numpy.ndarray.
                    // This would allow for cleaner code like the following:
                    // tt = xe.TTTensor([3])
                    // tt.set_component(0, np.arange(3)[None,:,None])
                    /* namespace pybind11 { namespace detail { */
                    /* template <> struct type_caster<Tensor> */
                    /* { */
                    /* public: */
                    /* PYBIND11_TYPE_CASTER(Tensor, _("Tensor")); */
                    /* // Conversion part 1 (Python -> C++) */
                    /* bool load(handle src, bool convert) */
                    /* { */
                    /* if ( !convert and !array_t<value_t>::check_(src) ) */
                    /* return false; */
                    /* auto buf = array_t<value_t, array::c_style | array::forcecast>::ensure(src); */
                    /* if ( !buf ) */
                    /* return false; */
                    /* try { */
                    /* value = Tensor_from_buffer(buf); */
                    /* } catch (const std::runtime_error&) { */
                    /* return false; */
                    /* } */
                    /* return true; */
                    /* } */
                    /* //Conversion part 2 (C++ -> Python) */
                    /* static handle cast(const Tensor& src, return_value_policy policy, handle parent) */
                    /* { */
                    /* std::cerr << "cast Tensor -> array" << std::endl; */
                    /* std::cerr << " create dimension vector" << std::endl; */
                    /* std::vector<size_t> shape = src.dimensions; */
                    /* std::cerr << " create strides vector" << std::endl; */
                    /* std::vector<size_t> strides = strides_from_dimensions_and_item_size(shape, sizeof(value_t)); */
                    /* /1* array a(std::move(shape), std::move(strides), src.get_dense_data()); *1/ */
                    /* /1* return a.release(); *1/ */
                    /* if (src.is_dense()) { */
                    /* std::cerr << " is_dense" << std::endl; */
                    /* array a(std::move(shape), std::move(strides), src.get_unsanitized_dense_data()); */
                    /* return a.release(); */
                    /* } else { */
                    /* std::cerr << " is_sparse" << std::endl; */
                    /* Tensor tmp(src); */
                    /* array a(std::move(shape), std::move(strides), tmp.get_dense_data()); */
                    /* return a.release(); */
                    /* } */
                    /* } */
                    /* }; */
                    /* }} // namespace pybind11::detail */
                    src/xerus/python/ttnetwork.cpp
                    View file @ 914c755a
                    ......@@ -10,6 +10,7 @@ void expose_ttnetwork(module& m) {
                    return misc::deserialize<TTTensor>(_bytes);
                    }
                    ))
                    .def(init<>(), "constructs an empty TTTensor")
                    .def(init<const TTTensor &>())
                    .def(init<const Tensor&>())
                    .def(init<const Tensor&, value_t>())
                    ......@@ -23,7 +24,7 @@ void expose_ttnetwork(module& m) {
                    .def_readonly("corePosition", &TTTensor::corePosition)
                    .def("ranks", &TTTensor::ranks)
                    .def("rank", &TTTensor::rank)
                    // .def("frob_norm", &TTTensor::frob_norm) // NOTE unneccessary because correct call is inherited
                    /* .def("frob_norm", &TTTensor::frob_norm) // NOTE unneccessary because correct call is inherited */
                    .def_static("random",
                    +[](std::vector<size_t> _dim, std::vector<size_t> _rank) {
                    return xerus::TTTensor::random(_dim, _rank);
                    ......@@ -36,13 +37,9 @@ void expose_ttnetwork(module& m) {
                    .def("use_dense_representations", &TTTensor::use_dense_representations)
                    .def_static("reduce_to_maximal_ranks", &TTTensor::reduce_to_maximal_ranks)
                    // .def("degrees_of_freedom", static_cast<size_t (TTTensor::*)() const>(&TTTensor::degrees_of_freedom)) // NOTE overloading a method with both static and instance methods is not supported
                    /* .def("degrees_of_freedom", static_cast<size_t (TTTensor::*)() const>(&TTTensor::degrees_of_freedom)) // NOTE overloading a method with both static and instance methods is not supported */
                    .def_static("degrees_of_freedom", static_cast<size_t (*)(const std::vector<size_t>&, const std::vector<size_t>&)>(&TTTensor::degrees_of_freedom))
                    .def("chop", &TTTensor::chop, arg("position"))
                    /* +[](TTTensor &_this, size_t _pos) { */
                    /* const auto result = _this.chop(_pos); */
                    /* return boost::python::make_tuple(result.first, result.second); */
                    /* }, arg("position")) */
                    .def("round", static_cast<void (TTTensor::*)(const std::vector<size_t>&, double)>(&TTTensor::round),
                    arg("ranks"), arg("epsilon")=EPSILON
                    ......@@ -57,13 +54,24 @@ void expose_ttnetwork(module& m) {
                    .def("assume_core_position", &TTTensor::assume_core_position)
                    .def("canonicalize_left", &TTTensor::canonicalize_left)
                    .def("canonicalize_right", &TTTensor::canonicalize_right)
                    /* .def(-self) */
                    .def("__neg__",
                    +[](TTTensor& _self) {
                    return (-1)*_self;
                    })
                    .def(self + self)
                    .def(self - self)
                    .def(self += self)
                    .def(self -= self)
                    .def(self * value_t())
                    .def(value_t() * self)
                    .def(self *= value_t())
                    .def(self / value_t())
                    .def(self += self)
                    .def(self -= self)
                    /* .def(self /= self) */
                    .def("__itruediv__",
                    +[](TTTensor& _self, value_t _other) {
                    return (_self *= (1/_other));
                    })
                    ;
                    m.def("entrywise_product", static_cast<TTTensor (*)(const TTTensor&, const TTTensor&)>(&entrywise_product));
                    ......@@ -84,7 +92,7 @@ void expose_ttnetwork(module& m) {
                    .def_readonly("corePosition", &TTOperator::corePosition)
                    .def("ranks", &TTOperator::ranks)
                    .def("rank", &TTOperator::rank)
                    // .def("frob_norm", &TTOperator::frob_norm) // NOTE unneccessary because correct call is inherited
                    /* .def("frob_norm", &TTOperator::frob_norm) // NOTE unneccessary because correct call is inherited */
                    .def_static("random", //TODO check error throwing python crashes when error from xerus is thrown
                    +[](std::vector<size_t> _dim, std::vector<size_t> _rank) {
                    return xerus::TTOperator::random(_dim, _rank);
                    ......@@ -97,13 +105,9 @@ void expose_ttnetwork(module& m) {
                    .def("use_dense_representations", &TTOperator::use_dense_representations)
                    .def_static("reduce_to_maximal_ranks", &TTOperator::reduce_to_maximal_ranks)
                    // .def("degrees_of_freedom", static_cast<size_t (TTOperator::*)()>(&TTOperator::degrees_of_freedom))
                    /* .def("degrees_of_freedom", static_cast<size_t (TTOperator::*)()>(&TTOperator::degrees_of_freedom)) */
                    .def_static("degrees_of_freedom", static_cast<size_t (*)(const std::vector<size_t>&, const std::vector<size_t>&)>(&TTOperator::degrees_of_freedom))
                    .def("chop", &TTOperator::chop, arg("position"))
                    /* +[](TTOperator &_this, size_t _pos) { */
                    /* const auto result = _this.chop(_pos); */
                    /* return make_tuple(result.first, result.second); */
                    /* }, arg("position")) */
                    .def("round", static_cast<void (TTOperator::*)(const std::vector<size_t>&, double)>(&TTOperator::round), arg("ranks"), arg("epsilon")=EPSILON)
                    .def("round", static_cast<void (TTOperator::*)(double)>(&TTOperator::round))
                    ......@@ -116,14 +120,24 @@ void expose_ttnetwork(module& m) {
                    .def("assume_core_position", &TTOperator::assume_core_position)
                    .def("canonicalize_left", &TTOperator::canonicalize_left)
                    .def("canonicalize_right", &TTOperator::canonicalize_right)
                    /* .def(-self) */
                    .def("__neg__",
                    +[](TTTensor& _self) {
                    return (-1)*_self;
                    })
                    .def(self + self)
                    .def(self - self)
                    .def(self += self)
                    .def(self -= self)
                    .def(self * value_t())
                    .def(value_t() * self)
                    .def(self *= value_t())
                    .def(self / value_t())
                    /* .def(self /= self) */
                    .def("__itruediv__",
                    +[](TTTensor& _self, value_t _other) {
                    return (_self *= (1/_other));
                    })
                    // for TTOperator only:
                    .def_static("identity", &TTOperator::identity<>)
                    ......
                    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