Using Eigen objects as properties (nOOb question)

[tvatter]

Hi,

Mostly for performance reasons, I am porting pyvinecopulib from pybind11 to nanobind. In pybind11, I used def_property and def_property_readonly for private internal variables (Eigen objects) that can only be accessed via setters and getters. I tried to do the same with nanobind, and an MWE is below:

#include <nanobind/nanobind.h>
#include <nanobind/eigen/dense.h>

namespace nb = nanobind;

using namespace nb::literals;

class EigenVector
{

private:
  Eigen::VectorXd vec;

public:
  EigenVector() : vec(Eigen::VectorXd::Zero(3)) {}

  EigenVector(const Eigen::VectorXd &vec) : vec(vec) {}

  Eigen::VectorXd get() const
  {
    return vec;
  }

  void set(const Eigen::VectorXd &vec)
  {
    this->vec = vec;
  }
};

NB_MODULE(nanobind_example_ext, m) {

  m.doc() = "An example with Eigen vectors";

  nb::class_<EigenVector>(m, "EigenVector")
      .def(nb::init<>())
      .def(nb::init<const Eigen::VectorXd &>(), "vec"_a)
      .def_prop_rw("vec", &EigenVector::get, &EigenVector::set)
      .def_prop_ro("vec_ro", &EigenVector::get)
      .def("vec_def", &EigenVector::get)
      .def_prop_ro("vec_ro_nbcast", [](const EigenVector &v)
                   { return nb::cast(v.get()); })
      .def_prop_rw("vec_rw_nbcast", [](EigenVector &v)
                   { return nb::cast(v.get()); }, &EigenVector::set);
}

However, when trying to use this in Python, something weird happens:

>>> import numpy as np
>>> import nanobind_example as m
>>> v = np.array([1, 2, 3])
>>> v2 = m.EigenVector(v)
>>> print(v2.vec)
[5.50215936e-310 0.00000000e+000 3.00000000e+000]
>>> print(v2.vec_ro)
[ 5.50216011e-310 -1.84063345e+286  3.00000000e+000]
>>> print(v2.vec_def())
[1. 2. 3.]
>>> print(v2.vec_ro_nbcast)
[1. 2. 3.]
>>> print(v2.vec_rw_nbcast)
[1. 2. 3.]

I am sure that there's something that I don't understand with how objects are passed between C++ and Python. I've read attentively nanobind's related doc page but for the life of me, I don't understand what I'm doing wrong. Why are we supposed to cast the output of the getter in this way?

[dograt]

@wjakob I am also curious about whether or not there is an idiomatic way of exposing an Eigen type that is a member of a C++ class as an attribute in Python, to allow for copy-free indexing, slicing, and dicing.

Currently, it seems that an nb::array initialized from a member data pointer still performs a copy when returned from C++, e.g.

using NbMatrixXb_t = nb::ndarray<bool, nb::numpy, nb::shape<-1, -1>, nb::device::cpu, nb::c_contig>;

.def_prop_rw("my_property",
    [](const MyType& self) {
        return NumpyMat_t(self.my_property_.data()).cast();;
    },
    [](MyType& self, const NbMatrixXb_t& val) {
        self.my_property_= <convert the other way here>
    })

The below does not work:

my_thing = MyType()
my_thing.my_property[0, 0] = 777

So, my_thing.my_property is, to my understanding (which may be wrong), a new numpy array that doesn't actually point to the internal storage of MyType. This is confusing to me, since the getter is pointing to the data from self.my_property, but I'm assuming that a copy of some kind is happening here?

[dograt]

Thanks for the reply, @wjakob . Is there documentation on def_prop_array ? I can't seem to find it. If I pull master, would the syntax be something like this?

.def_prop_array("my_property",
    [](const MyType& self) {
        return NumpyMat_t(self.my_property_.data()).cast();;
    },
    [](MyType& self, const NbMatrixXb_t& val) {
        self.my_property_= Eigen::Map<MyMatrixType>(val.data());
    })

[dograt]

Additionally, is there a tag I can pull from besides master? I'm using FetchContent to grab nanobind in CMake, and I worry that I'll forget to update this and end up with a dependency that's a moving target.

[dograt]

@wjakob I actually wasn't aware of the nanobind/eigen/dense.h header, and that a lot of my machinery around the property is unnecessary. I found your fix in this commit.

My understanding is that the solution can be as simple as this:

#include <nanobind/eigen/dense.h>

struct ClassWithEigenMember {
    Eigen::MatrixXd member = Eigen::Matrix2d::Ones();
    const Eigen::MatrixXd &get_member_ref() { return member; }
    const Eigen::MatrixXd get_member_copy() { return member; }
};

nb::class_<ClassWithEigenMember>(m, "ClassWithEigenMember")
    .def(nb::init<>())
    .def_prop_ro("member_ro_ref", &ClassWithEigenMember::get_member_ref)
    .def_prop_ro("member_ro_copy", &ClassWithEigenMember::get_member_copy)
    .def_rw("member", &ClassWithEigenMember::member);

Would it be possible to get a bugfix release with the Eigen changes? That'd save me a lot of trouble, and make my code much prettier :)

[wjakob]

I plan to do another release in the 2-3 week timeframe. You will have to reference a Git hash in your project to use master until then.

[wjakob]

The release is out now.

[tvatter]

@wjakob thanks a lot and sorry for the delayed answer. With the release, the "issue" I mentioned initially has indeed disappeared.

One question remains: which version is "right"? E.g., &EigenVector::get or [](const EigenVector &v) { return nb::cast(v.get()); }?

For what it's worth, I tried the following:

v2.vec[0] = 10
print(v2.vec)

v2.vec_rw_nbcast[0] = 10
print(v2.vec_rw_nbcast)

And neither seems to work (i.e., output is [1. 2. 3.])...

Also, I could not find def_prop_array that is mentioned in the answer to @dograt anywhere. What am I missing?