eigen.h revision 12391
111986Sandreas.sandberg@arm.com/* 211986Sandreas.sandberg@arm.com pybind11/eigen.h: Transparent conversion for dense and sparse Eigen matrices 311986Sandreas.sandberg@arm.com 411986Sandreas.sandberg@arm.com Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 511986Sandreas.sandberg@arm.com 611986Sandreas.sandberg@arm.com All rights reserved. Use of this source code is governed by a 711986Sandreas.sandberg@arm.com BSD-style license that can be found in the LICENSE file. 811986Sandreas.sandberg@arm.com*/ 911986Sandreas.sandberg@arm.com 1011986Sandreas.sandberg@arm.com#pragma once 1111986Sandreas.sandberg@arm.com 1211986Sandreas.sandberg@arm.com#include "numpy.h" 1311986Sandreas.sandberg@arm.com 1411986Sandreas.sandberg@arm.com#if defined(__INTEL_COMPILER) 1511986Sandreas.sandberg@arm.com# pragma warning(disable: 1682) // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 1611986Sandreas.sandberg@arm.com#elif defined(__GNUG__) || defined(__clang__) 1711986Sandreas.sandberg@arm.com# pragma GCC diagnostic push 1811986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wconversion" 1911986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wdeprecated-declarations" 2012037Sandreas.sandberg@arm.com# if __GNUC__ >= 7 2112037Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wint-in-bool-context" 2212037Sandreas.sandberg@arm.com# endif 2311986Sandreas.sandberg@arm.com#endif 2411986Sandreas.sandberg@arm.com 2511986Sandreas.sandberg@arm.com#include <Eigen/Core> 2611986Sandreas.sandberg@arm.com#include <Eigen/SparseCore> 2711986Sandreas.sandberg@arm.com 2812037Sandreas.sandberg@arm.com#if defined(_MSC_VER) 2912037Sandreas.sandberg@arm.com# pragma warning(push) 3012037Sandreas.sandberg@arm.com# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant 3111986Sandreas.sandberg@arm.com#endif 3211986Sandreas.sandberg@arm.com 3312037Sandreas.sandberg@arm.com// Eigen prior to 3.2.7 doesn't have proper move constructors--but worse, some classes get implicit 3412037Sandreas.sandberg@arm.com// move constructors that break things. We could detect this an explicitly copy, but an extra copy 3512037Sandreas.sandberg@arm.com// of matrices seems highly undesirable. 3612037Sandreas.sandberg@arm.comstatic_assert(EIGEN_VERSION_AT_LEAST(3,2,7), "Eigen support in pybind11 requires Eigen >= 3.2.7"); 3712037Sandreas.sandberg@arm.com 3812391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE) 3912037Sandreas.sandberg@arm.com 4012037Sandreas.sandberg@arm.com// Provide a convenience alias for easier pass-by-ref usage with fully dynamic strides: 4112037Sandreas.sandberg@arm.comusing EigenDStride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>; 4212037Sandreas.sandberg@arm.comtemplate <typename MatrixType> using EigenDRef = Eigen::Ref<MatrixType, 0, EigenDStride>; 4312037Sandreas.sandberg@arm.comtemplate <typename MatrixType> using EigenDMap = Eigen::Map<MatrixType, 0, EigenDStride>; 4412037Sandreas.sandberg@arm.com 4512037Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 4612037Sandreas.sandberg@arm.com 4712037Sandreas.sandberg@arm.com#if EIGEN_VERSION_AT_LEAST(3,3,0) 4812037Sandreas.sandberg@arm.comusing EigenIndex = Eigen::Index; 4912037Sandreas.sandberg@arm.com#else 5012037Sandreas.sandberg@arm.comusing EigenIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE; 5111986Sandreas.sandberg@arm.com#endif 5211986Sandreas.sandberg@arm.com 5312037Sandreas.sandberg@arm.com// Matches Eigen::Map, Eigen::Ref, blocks, etc: 5412037Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_dense_map = all_of<is_template_base_of<Eigen::DenseBase, T>, std::is_base_of<Eigen::MapBase<T, Eigen::ReadOnlyAccessors>, T>>; 5512037Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_mutable_map = std::is_base_of<Eigen::MapBase<T, Eigen::WriteAccessors>, T>; 5612037Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_dense_plain = all_of<negation<is_eigen_dense_map<T>>, is_template_base_of<Eigen::PlainObjectBase, T>>; 5711986Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_sparse = is_template_base_of<Eigen::SparseMatrixBase, T>; 5811986Sandreas.sandberg@arm.com// Test for objects inheriting from EigenBase<Derived> that aren't captured by the above. This 5911986Sandreas.sandberg@arm.com// basically covers anything that can be assigned to a dense matrix but that don't have a typical 6011986Sandreas.sandberg@arm.com// matrix data layout that can be copied from their .data(). For example, DiagonalMatrix and 6111986Sandreas.sandberg@arm.com// SelfAdjointView fall into this category. 6212037Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_other = all_of< 6312037Sandreas.sandberg@arm.com is_template_base_of<Eigen::EigenBase, T>, 6412037Sandreas.sandberg@arm.com negation<any_of<is_eigen_dense_map<T>, is_eigen_dense_plain<T>, is_eigen_sparse<T>>> 6511986Sandreas.sandberg@arm.com>; 6611986Sandreas.sandberg@arm.com 6712037Sandreas.sandberg@arm.com// Captures numpy/eigen conformability status (returned by EigenProps::conformable()): 6812037Sandreas.sandberg@arm.comtemplate <bool EigenRowMajor> struct EigenConformable { 6912037Sandreas.sandberg@arm.com bool conformable = false; 7012037Sandreas.sandberg@arm.com EigenIndex rows = 0, cols = 0; 7112391Sjason@lowepower.com EigenDStride stride{0, 0}; // Only valid if negativestrides is false! 7212391Sjason@lowepower.com bool negativestrides = false; // If true, do not use stride! 7312037Sandreas.sandberg@arm.com 7412037Sandreas.sandberg@arm.com EigenConformable(bool fits = false) : conformable{fits} {} 7512037Sandreas.sandberg@arm.com // Matrix type: 7612037Sandreas.sandberg@arm.com EigenConformable(EigenIndex r, EigenIndex c, 7712037Sandreas.sandberg@arm.com EigenIndex rstride, EigenIndex cstride) : 7812391Sjason@lowepower.com conformable{true}, rows{r}, cols{c} { 7912391Sjason@lowepower.com // TODO: when Eigen bug #747 is fixed, remove the tests for non-negativity. http://eigen.tuxfamily.org/bz/show_bug.cgi?id=747 8012391Sjason@lowepower.com if (rstride < 0 || cstride < 0) { 8112391Sjason@lowepower.com negativestrides = true; 8212391Sjason@lowepower.com } else { 8312391Sjason@lowepower.com stride = {EigenRowMajor ? rstride : cstride /* outer stride */, 8412391Sjason@lowepower.com EigenRowMajor ? cstride : rstride /* inner stride */ }; 8512391Sjason@lowepower.com } 8612391Sjason@lowepower.com } 8712037Sandreas.sandberg@arm.com // Vector type: 8812037Sandreas.sandberg@arm.com EigenConformable(EigenIndex r, EigenIndex c, EigenIndex stride) 8912037Sandreas.sandberg@arm.com : EigenConformable(r, c, r == 1 ? c*stride : stride, c == 1 ? r : r*stride) {} 9012037Sandreas.sandberg@arm.com 9112037Sandreas.sandberg@arm.com template <typename props> bool stride_compatible() const { 9212037Sandreas.sandberg@arm.com // To have compatible strides, we need (on both dimensions) one of fully dynamic strides, 9312037Sandreas.sandberg@arm.com // matching strides, or a dimension size of 1 (in which case the stride value is irrelevant) 9412037Sandreas.sandberg@arm.com return 9512391Sjason@lowepower.com !negativestrides && 9612037Sandreas.sandberg@arm.com (props::inner_stride == Eigen::Dynamic || props::inner_stride == stride.inner() || 9712037Sandreas.sandberg@arm.com (EigenRowMajor ? cols : rows) == 1) && 9812037Sandreas.sandberg@arm.com (props::outer_stride == Eigen::Dynamic || props::outer_stride == stride.outer() || 9912037Sandreas.sandberg@arm.com (EigenRowMajor ? rows : cols) == 1); 10012037Sandreas.sandberg@arm.com } 10112037Sandreas.sandberg@arm.com operator bool() const { return conformable; } 10212037Sandreas.sandberg@arm.com}; 10312037Sandreas.sandberg@arm.com 10412037Sandreas.sandberg@arm.comtemplate <typename Type> struct eigen_extract_stride { using type = Type; }; 10512037Sandreas.sandberg@arm.comtemplate <typename PlainObjectType, int MapOptions, typename StrideType> 10612037Sandreas.sandberg@arm.comstruct eigen_extract_stride<Eigen::Map<PlainObjectType, MapOptions, StrideType>> { using type = StrideType; }; 10712037Sandreas.sandberg@arm.comtemplate <typename PlainObjectType, int Options, typename StrideType> 10812037Sandreas.sandberg@arm.comstruct eigen_extract_stride<Eigen::Ref<PlainObjectType, Options, StrideType>> { using type = StrideType; }; 10912037Sandreas.sandberg@arm.com 11012037Sandreas.sandberg@arm.com// Helper struct for extracting information from an Eigen type 11112037Sandreas.sandberg@arm.comtemplate <typename Type_> struct EigenProps { 11212037Sandreas.sandberg@arm.com using Type = Type_; 11312037Sandreas.sandberg@arm.com using Scalar = typename Type::Scalar; 11412037Sandreas.sandberg@arm.com using StrideType = typename eigen_extract_stride<Type>::type; 11512037Sandreas.sandberg@arm.com static constexpr EigenIndex 11612037Sandreas.sandberg@arm.com rows = Type::RowsAtCompileTime, 11712037Sandreas.sandberg@arm.com cols = Type::ColsAtCompileTime, 11812037Sandreas.sandberg@arm.com size = Type::SizeAtCompileTime; 11912037Sandreas.sandberg@arm.com static constexpr bool 12012037Sandreas.sandberg@arm.com row_major = Type::IsRowMajor, 12112037Sandreas.sandberg@arm.com vector = Type::IsVectorAtCompileTime, // At least one dimension has fixed size 1 12212037Sandreas.sandberg@arm.com fixed_rows = rows != Eigen::Dynamic, 12312037Sandreas.sandberg@arm.com fixed_cols = cols != Eigen::Dynamic, 12412037Sandreas.sandberg@arm.com fixed = size != Eigen::Dynamic, // Fully-fixed size 12512037Sandreas.sandberg@arm.com dynamic = !fixed_rows && !fixed_cols; // Fully-dynamic size 12612037Sandreas.sandberg@arm.com 12712037Sandreas.sandberg@arm.com template <EigenIndex i, EigenIndex ifzero> using if_zero = std::integral_constant<EigenIndex, i == 0 ? ifzero : i>; 12812037Sandreas.sandberg@arm.com static constexpr EigenIndex inner_stride = if_zero<StrideType::InnerStrideAtCompileTime, 1>::value, 12912037Sandreas.sandberg@arm.com outer_stride = if_zero<StrideType::OuterStrideAtCompileTime, 13012037Sandreas.sandberg@arm.com vector ? size : row_major ? cols : rows>::value; 13112037Sandreas.sandberg@arm.com static constexpr bool dynamic_stride = inner_stride == Eigen::Dynamic && outer_stride == Eigen::Dynamic; 13212037Sandreas.sandberg@arm.com static constexpr bool requires_row_major = !dynamic_stride && !vector && (row_major ? inner_stride : outer_stride) == 1; 13312037Sandreas.sandberg@arm.com static constexpr bool requires_col_major = !dynamic_stride && !vector && (row_major ? outer_stride : inner_stride) == 1; 13412037Sandreas.sandberg@arm.com 13512037Sandreas.sandberg@arm.com // Takes an input array and determines whether we can make it fit into the Eigen type. If 13612037Sandreas.sandberg@arm.com // the array is a vector, we attempt to fit it into either an Eigen 1xN or Nx1 vector 13712037Sandreas.sandberg@arm.com // (preferring the latter if it will fit in either, i.e. for a fully dynamic matrix type). 13812037Sandreas.sandberg@arm.com static EigenConformable<row_major> conformable(const array &a) { 13912037Sandreas.sandberg@arm.com const auto dims = a.ndim(); 14012037Sandreas.sandberg@arm.com if (dims < 1 || dims > 2) 14112037Sandreas.sandberg@arm.com return false; 14212037Sandreas.sandberg@arm.com 14312037Sandreas.sandberg@arm.com if (dims == 2) { // Matrix type: require exact match (or dynamic) 14412037Sandreas.sandberg@arm.com 14512037Sandreas.sandberg@arm.com EigenIndex 14612037Sandreas.sandberg@arm.com np_rows = a.shape(0), 14712037Sandreas.sandberg@arm.com np_cols = a.shape(1), 14812391Sjason@lowepower.com np_rstride = a.strides(0) / static_cast<ssize_t>(sizeof(Scalar)), 14912391Sjason@lowepower.com np_cstride = a.strides(1) / static_cast<ssize_t>(sizeof(Scalar)); 15012037Sandreas.sandberg@arm.com if ((fixed_rows && np_rows != rows) || (fixed_cols && np_cols != cols)) 15112037Sandreas.sandberg@arm.com return false; 15212037Sandreas.sandberg@arm.com 15312037Sandreas.sandberg@arm.com return {np_rows, np_cols, np_rstride, np_cstride}; 15412037Sandreas.sandberg@arm.com } 15512037Sandreas.sandberg@arm.com 15612037Sandreas.sandberg@arm.com // Otherwise we're storing an n-vector. Only one of the strides will be used, but whichever 15712037Sandreas.sandberg@arm.com // is used, we want the (single) numpy stride value. 15812037Sandreas.sandberg@arm.com const EigenIndex n = a.shape(0), 15912391Sjason@lowepower.com stride = a.strides(0) / static_cast<ssize_t>(sizeof(Scalar)); 16012037Sandreas.sandberg@arm.com 16112037Sandreas.sandberg@arm.com if (vector) { // Eigen type is a compile-time vector 16212037Sandreas.sandberg@arm.com if (fixed && size != n) 16312037Sandreas.sandberg@arm.com return false; // Vector size mismatch 16412037Sandreas.sandberg@arm.com return {rows == 1 ? 1 : n, cols == 1 ? 1 : n, stride}; 16512037Sandreas.sandberg@arm.com } 16612037Sandreas.sandberg@arm.com else if (fixed) { 16712037Sandreas.sandberg@arm.com // The type has a fixed size, but is not a vector: abort 16812037Sandreas.sandberg@arm.com return false; 16912037Sandreas.sandberg@arm.com } 17012037Sandreas.sandberg@arm.com else if (fixed_cols) { 17112037Sandreas.sandberg@arm.com // Since this isn't a vector, cols must be != 1. We allow this only if it exactly 17212037Sandreas.sandberg@arm.com // equals the number of elements (rows is Dynamic, and so 1 row is allowed). 17312037Sandreas.sandberg@arm.com if (cols != n) return false; 17412037Sandreas.sandberg@arm.com return {1, n, stride}; 17512037Sandreas.sandberg@arm.com } 17612037Sandreas.sandberg@arm.com else { 17712037Sandreas.sandberg@arm.com // Otherwise it's either fully dynamic, or column dynamic; both become a column vector 17812037Sandreas.sandberg@arm.com if (fixed_rows && rows != n) return false; 17912037Sandreas.sandberg@arm.com return {n, 1, stride}; 18012037Sandreas.sandberg@arm.com } 18112037Sandreas.sandberg@arm.com } 18212037Sandreas.sandberg@arm.com 18312037Sandreas.sandberg@arm.com static PYBIND11_DESCR descriptor() { 18412037Sandreas.sandberg@arm.com constexpr bool show_writeable = is_eigen_dense_map<Type>::value && is_eigen_mutable_map<Type>::value; 18512037Sandreas.sandberg@arm.com constexpr bool show_order = is_eigen_dense_map<Type>::value; 18612037Sandreas.sandberg@arm.com constexpr bool show_c_contiguous = show_order && requires_row_major; 18712037Sandreas.sandberg@arm.com constexpr bool show_f_contiguous = !show_c_contiguous && show_order && requires_col_major; 18812037Sandreas.sandberg@arm.com 18912391Sjason@lowepower.com return type_descr(_("numpy.ndarray[") + npy_format_descriptor<Scalar>::name() + 19012391Sjason@lowepower.com _("[") + _<fixed_rows>(_<(size_t) rows>(), _("m")) + 19112391Sjason@lowepower.com _(", ") + _<fixed_cols>(_<(size_t) cols>(), _("n")) + 19212391Sjason@lowepower.com _("]") + 19312391Sjason@lowepower.com // For a reference type (e.g. Ref<MatrixXd>) we have other constraints that might need to be 19412391Sjason@lowepower.com // satisfied: writeable=True (for a mutable reference), and, depending on the map's stride 19512391Sjason@lowepower.com // options, possibly f_contiguous or c_contiguous. We include them in the descriptor output 19612391Sjason@lowepower.com // to provide some hint as to why a TypeError is occurring (otherwise it can be confusing to 19712391Sjason@lowepower.com // see that a function accepts a 'numpy.ndarray[float64[3,2]]' and an error message that you 19812391Sjason@lowepower.com // *gave* a numpy.ndarray of the right type and dimensions. 19912391Sjason@lowepower.com _<show_writeable>(", flags.writeable", "") + 20012391Sjason@lowepower.com _<show_c_contiguous>(", flags.c_contiguous", "") + 20112391Sjason@lowepower.com _<show_f_contiguous>(", flags.f_contiguous", "") + 20212391Sjason@lowepower.com _("]") 20312391Sjason@lowepower.com ); 20412037Sandreas.sandberg@arm.com } 20512037Sandreas.sandberg@arm.com}; 20612037Sandreas.sandberg@arm.com 20712037Sandreas.sandberg@arm.com// Casts an Eigen type to numpy array. If given a base, the numpy array references the src data, 20812037Sandreas.sandberg@arm.com// otherwise it'll make a copy. writeable lets you turn off the writeable flag for the array. 20912037Sandreas.sandberg@arm.comtemplate <typename props> handle eigen_array_cast(typename props::Type const &src, handle base = handle(), bool writeable = true) { 21012391Sjason@lowepower.com constexpr ssize_t elem_size = sizeof(typename props::Scalar); 21112391Sjason@lowepower.com array a; 21212391Sjason@lowepower.com if (props::vector) 21312391Sjason@lowepower.com a = array({ src.size() }, { elem_size * src.innerStride() }, src.data(), base); 21412391Sjason@lowepower.com else 21512391Sjason@lowepower.com a = array({ src.rows(), src.cols() }, { elem_size * src.rowStride(), elem_size * src.colStride() }, 21612391Sjason@lowepower.com src.data(), base); 21712391Sjason@lowepower.com 21812037Sandreas.sandberg@arm.com if (!writeable) 21912037Sandreas.sandberg@arm.com array_proxy(a.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_; 22012037Sandreas.sandberg@arm.com 22112037Sandreas.sandberg@arm.com return a.release(); 22212037Sandreas.sandberg@arm.com} 22312037Sandreas.sandberg@arm.com 22412037Sandreas.sandberg@arm.com// Takes an lvalue ref to some Eigen type and a (python) base object, creating a numpy array that 22512037Sandreas.sandberg@arm.com// reference the Eigen object's data with `base` as the python-registered base class (if omitted, 22612037Sandreas.sandberg@arm.com// the base will be set to None, and lifetime management is up to the caller). The numpy array is 22712037Sandreas.sandberg@arm.com// non-writeable if the given type is const. 22812037Sandreas.sandberg@arm.comtemplate <typename props, typename Type> 22912037Sandreas.sandberg@arm.comhandle eigen_ref_array(Type &src, handle parent = none()) { 23012037Sandreas.sandberg@arm.com // none here is to get past array's should-we-copy detection, which currently always 23112037Sandreas.sandberg@arm.com // copies when there is no base. Setting the base to None should be harmless. 23212037Sandreas.sandberg@arm.com return eigen_array_cast<props>(src, parent, !std::is_const<Type>::value); 23312037Sandreas.sandberg@arm.com} 23412037Sandreas.sandberg@arm.com 23512037Sandreas.sandberg@arm.com// Takes a pointer to some dense, plain Eigen type, builds a capsule around it, then returns a numpy 23612037Sandreas.sandberg@arm.com// array that references the encapsulated data with a python-side reference to the capsule to tie 23712037Sandreas.sandberg@arm.com// its destruction to that of any dependent python objects. Const-ness is determined by whether or 23812037Sandreas.sandberg@arm.com// not the Type of the pointer given is const. 23912037Sandreas.sandberg@arm.comtemplate <typename props, typename Type, typename = enable_if_t<is_eigen_dense_plain<Type>::value>> 24012037Sandreas.sandberg@arm.comhandle eigen_encapsulate(Type *src) { 24112037Sandreas.sandberg@arm.com capsule base(src, [](void *o) { delete static_cast<Type *>(o); }); 24212037Sandreas.sandberg@arm.com return eigen_ref_array<props>(*src, base); 24312037Sandreas.sandberg@arm.com} 24412037Sandreas.sandberg@arm.com 24512037Sandreas.sandberg@arm.com// Type caster for regular, dense matrix types (e.g. MatrixXd), but not maps/refs/etc. of dense 24612037Sandreas.sandberg@arm.com// types. 24711986Sandreas.sandberg@arm.comtemplate<typename Type> 24812037Sandreas.sandberg@arm.comstruct type_caster<Type, enable_if_t<is_eigen_dense_plain<Type>::value>> { 24912037Sandreas.sandberg@arm.com using Scalar = typename Type::Scalar; 25012037Sandreas.sandberg@arm.com using props = EigenProps<Type>; 25111986Sandreas.sandberg@arm.com 25212391Sjason@lowepower.com bool load(handle src, bool convert) { 25312391Sjason@lowepower.com // If we're in no-convert mode, only load if given an array of the correct type 25412391Sjason@lowepower.com if (!convert && !isinstance<array_t<Scalar>>(src)) 25512391Sjason@lowepower.com return false; 25612391Sjason@lowepower.com 25712391Sjason@lowepower.com // Coerce into an array, but don't do type conversion yet; the copy below handles it. 25812391Sjason@lowepower.com auto buf = array::ensure(src); 25912391Sjason@lowepower.com 26011986Sandreas.sandberg@arm.com if (!buf) 26111986Sandreas.sandberg@arm.com return false; 26211986Sandreas.sandberg@arm.com 26312037Sandreas.sandberg@arm.com auto dims = buf.ndim(); 26412037Sandreas.sandberg@arm.com if (dims < 1 || dims > 2) 26512037Sandreas.sandberg@arm.com return false; 26611986Sandreas.sandberg@arm.com 26712037Sandreas.sandberg@arm.com auto fits = props::conformable(buf); 26812037Sandreas.sandberg@arm.com if (!fits) 26912391Sjason@lowepower.com return false; 27011986Sandreas.sandberg@arm.com 27112391Sjason@lowepower.com // Allocate the new type, then build a numpy reference into it 27212391Sjason@lowepower.com value = Type(fits.rows, fits.cols); 27312391Sjason@lowepower.com auto ref = reinterpret_steal<array>(eigen_ref_array<props>(value)); 27412391Sjason@lowepower.com if (dims == 1) ref = ref.squeeze(); 27512391Sjason@lowepower.com 27612391Sjason@lowepower.com int result = detail::npy_api::get().PyArray_CopyInto_(ref.ptr(), buf.ptr()); 27712391Sjason@lowepower.com 27812391Sjason@lowepower.com if (result < 0) { // Copy failed! 27912391Sjason@lowepower.com PyErr_Clear(); 28012391Sjason@lowepower.com return false; 28112391Sjason@lowepower.com } 28211986Sandreas.sandberg@arm.com 28311986Sandreas.sandberg@arm.com return true; 28411986Sandreas.sandberg@arm.com } 28511986Sandreas.sandberg@arm.com 28612037Sandreas.sandberg@arm.comprivate: 28712037Sandreas.sandberg@arm.com 28812037Sandreas.sandberg@arm.com // Cast implementation 28912037Sandreas.sandberg@arm.com template <typename CType> 29012037Sandreas.sandberg@arm.com static handle cast_impl(CType *src, return_value_policy policy, handle parent) { 29112037Sandreas.sandberg@arm.com switch (policy) { 29212037Sandreas.sandberg@arm.com case return_value_policy::take_ownership: 29312037Sandreas.sandberg@arm.com case return_value_policy::automatic: 29412037Sandreas.sandberg@arm.com return eigen_encapsulate<props>(src); 29512037Sandreas.sandberg@arm.com case return_value_policy::move: 29612037Sandreas.sandberg@arm.com return eigen_encapsulate<props>(new CType(std::move(*src))); 29712037Sandreas.sandberg@arm.com case return_value_policy::copy: 29812037Sandreas.sandberg@arm.com return eigen_array_cast<props>(*src); 29912037Sandreas.sandberg@arm.com case return_value_policy::reference: 30012037Sandreas.sandberg@arm.com case return_value_policy::automatic_reference: 30112037Sandreas.sandberg@arm.com return eigen_ref_array<props>(*src); 30212037Sandreas.sandberg@arm.com case return_value_policy::reference_internal: 30312037Sandreas.sandberg@arm.com return eigen_ref_array<props>(*src, parent); 30412037Sandreas.sandberg@arm.com default: 30512037Sandreas.sandberg@arm.com throw cast_error("unhandled return_value_policy: should not happen!"); 30612037Sandreas.sandberg@arm.com }; 30712037Sandreas.sandberg@arm.com } 30812037Sandreas.sandberg@arm.com 30912037Sandreas.sandberg@arm.compublic: 31012037Sandreas.sandberg@arm.com 31112037Sandreas.sandberg@arm.com // Normal returned non-reference, non-const value: 31212037Sandreas.sandberg@arm.com static handle cast(Type &&src, return_value_policy /* policy */, handle parent) { 31312037Sandreas.sandberg@arm.com return cast_impl(&src, return_value_policy::move, parent); 31412037Sandreas.sandberg@arm.com } 31512037Sandreas.sandberg@arm.com // If you return a non-reference const, we mark the numpy array readonly: 31612037Sandreas.sandberg@arm.com static handle cast(const Type &&src, return_value_policy /* policy */, handle parent) { 31712037Sandreas.sandberg@arm.com return cast_impl(&src, return_value_policy::move, parent); 31812037Sandreas.sandberg@arm.com } 31912037Sandreas.sandberg@arm.com // lvalue reference return; default (automatic) becomes copy 32012037Sandreas.sandberg@arm.com static handle cast(Type &src, return_value_policy policy, handle parent) { 32112037Sandreas.sandberg@arm.com if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference) 32212037Sandreas.sandberg@arm.com policy = return_value_policy::copy; 32312037Sandreas.sandberg@arm.com return cast_impl(&src, policy, parent); 32412037Sandreas.sandberg@arm.com } 32512037Sandreas.sandberg@arm.com // const lvalue reference return; default (automatic) becomes copy 32612037Sandreas.sandberg@arm.com static handle cast(const Type &src, return_value_policy policy, handle parent) { 32712037Sandreas.sandberg@arm.com if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference) 32812037Sandreas.sandberg@arm.com policy = return_value_policy::copy; 32912037Sandreas.sandberg@arm.com return cast(&src, policy, parent); 33012037Sandreas.sandberg@arm.com } 33112037Sandreas.sandberg@arm.com // non-const pointer return 33212037Sandreas.sandberg@arm.com static handle cast(Type *src, return_value_policy policy, handle parent) { 33312037Sandreas.sandberg@arm.com return cast_impl(src, policy, parent); 33412037Sandreas.sandberg@arm.com } 33512037Sandreas.sandberg@arm.com // const pointer return 33612037Sandreas.sandberg@arm.com static handle cast(const Type *src, return_value_policy policy, handle parent) { 33712037Sandreas.sandberg@arm.com return cast_impl(src, policy, parent); 33812037Sandreas.sandberg@arm.com } 33912037Sandreas.sandberg@arm.com 34012391Sjason@lowepower.com static PYBIND11_DESCR name() { return props::descriptor(); } 34112037Sandreas.sandberg@arm.com 34212037Sandreas.sandberg@arm.com operator Type*() { return &value; } 34312037Sandreas.sandberg@arm.com operator Type&() { return value; } 34412391Sjason@lowepower.com operator Type&&() && { return std::move(value); } 34512391Sjason@lowepower.com template <typename T> using cast_op_type = movable_cast_op_type<T>; 34612037Sandreas.sandberg@arm.com 34712037Sandreas.sandberg@arm.comprivate: 34812037Sandreas.sandberg@arm.com Type value; 34912037Sandreas.sandberg@arm.com}; 35012037Sandreas.sandberg@arm.com 35112037Sandreas.sandberg@arm.com// Eigen Ref/Map classes have slightly different policy requirements, meaning we don't want to force 35212037Sandreas.sandberg@arm.com// `move` when a Ref/Map rvalue is returned; we treat Ref<> sort of like a pointer (we care about 35312037Sandreas.sandberg@arm.com// the underlying data, not the outer shell). 35412037Sandreas.sandberg@arm.comtemplate <typename Return> 35512037Sandreas.sandberg@arm.comstruct return_value_policy_override<Return, enable_if_t<is_eigen_dense_map<Return>::value>> { 35612037Sandreas.sandberg@arm.com static return_value_policy policy(return_value_policy p) { return p; } 35712037Sandreas.sandberg@arm.com}; 35812037Sandreas.sandberg@arm.com 35912037Sandreas.sandberg@arm.com// Base class for casting reference/map/block/etc. objects back to python. 36012037Sandreas.sandberg@arm.comtemplate <typename MapType> struct eigen_map_caster { 36112037Sandreas.sandberg@arm.comprivate: 36212037Sandreas.sandberg@arm.com using props = EigenProps<MapType>; 36312037Sandreas.sandberg@arm.com 36412037Sandreas.sandberg@arm.compublic: 36512037Sandreas.sandberg@arm.com 36612037Sandreas.sandberg@arm.com // Directly referencing a ref/map's data is a bit dangerous (whatever the map/ref points to has 36712037Sandreas.sandberg@arm.com // to stay around), but we'll allow it under the assumption that you know what you're doing (and 36812037Sandreas.sandberg@arm.com // have an appropriate keep_alive in place). We return a numpy array pointing directly at the 36912037Sandreas.sandberg@arm.com // ref's data (The numpy array ends up read-only if the ref was to a const matrix type.) Note 37012037Sandreas.sandberg@arm.com // that this means you need to ensure you don't destroy the object in some other way (e.g. with 37112037Sandreas.sandberg@arm.com // an appropriate keep_alive, or with a reference to a statically allocated matrix). 37212037Sandreas.sandberg@arm.com static handle cast(const MapType &src, return_value_policy policy, handle parent) { 37312037Sandreas.sandberg@arm.com switch (policy) { 37412037Sandreas.sandberg@arm.com case return_value_policy::copy: 37512037Sandreas.sandberg@arm.com return eigen_array_cast<props>(src); 37612037Sandreas.sandberg@arm.com case return_value_policy::reference_internal: 37712037Sandreas.sandberg@arm.com return eigen_array_cast<props>(src, parent, is_eigen_mutable_map<MapType>::value); 37812037Sandreas.sandberg@arm.com case return_value_policy::reference: 37912037Sandreas.sandberg@arm.com case return_value_policy::automatic: 38012037Sandreas.sandberg@arm.com case return_value_policy::automatic_reference: 38112037Sandreas.sandberg@arm.com return eigen_array_cast<props>(src, none(), is_eigen_mutable_map<MapType>::value); 38212037Sandreas.sandberg@arm.com default: 38312037Sandreas.sandberg@arm.com // move, take_ownership don't make any sense for a ref/map: 38412037Sandreas.sandberg@arm.com pybind11_fail("Invalid return_value_policy for Eigen Map/Ref/Block type"); 38511986Sandreas.sandberg@arm.com } 38611986Sandreas.sandberg@arm.com } 38711986Sandreas.sandberg@arm.com 38812037Sandreas.sandberg@arm.com static PYBIND11_DESCR name() { return props::descriptor(); } 38911986Sandreas.sandberg@arm.com 39012037Sandreas.sandberg@arm.com // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return 39112037Sandreas.sandberg@arm.com // types but not bound arguments). We still provide them (with an explicitly delete) so that 39212037Sandreas.sandberg@arm.com // you end up here if you try anyway. 39312037Sandreas.sandberg@arm.com bool load(handle, bool) = delete; 39412037Sandreas.sandberg@arm.com operator MapType() = delete; 39512037Sandreas.sandberg@arm.com template <typename> using cast_op_type = MapType; 39611986Sandreas.sandberg@arm.com}; 39711986Sandreas.sandberg@arm.com 39812037Sandreas.sandberg@arm.com// We can return any map-like object (but can only load Refs, specialized next): 39912037Sandreas.sandberg@arm.comtemplate <typename Type> struct type_caster<Type, enable_if_t<is_eigen_dense_map<Type>::value>> 40012037Sandreas.sandberg@arm.com : eigen_map_caster<Type> {}; 40112037Sandreas.sandberg@arm.com 40212037Sandreas.sandberg@arm.com// Loader for Ref<...> arguments. See the documentation for info on how to make this work without 40312037Sandreas.sandberg@arm.com// copying (it requires some extra effort in many cases). 40412037Sandreas.sandberg@arm.comtemplate <typename PlainObjectType, typename StrideType> 40512037Sandreas.sandberg@arm.comstruct type_caster< 40612037Sandreas.sandberg@arm.com Eigen::Ref<PlainObjectType, 0, StrideType>, 40712037Sandreas.sandberg@arm.com enable_if_t<is_eigen_dense_map<Eigen::Ref<PlainObjectType, 0, StrideType>>::value> 40812037Sandreas.sandberg@arm.com> : public eigen_map_caster<Eigen::Ref<PlainObjectType, 0, StrideType>> { 40912037Sandreas.sandberg@arm.comprivate: 41012037Sandreas.sandberg@arm.com using Type = Eigen::Ref<PlainObjectType, 0, StrideType>; 41112037Sandreas.sandberg@arm.com using props = EigenProps<Type>; 41212037Sandreas.sandberg@arm.com using Scalar = typename props::Scalar; 41312037Sandreas.sandberg@arm.com using MapType = Eigen::Map<PlainObjectType, 0, StrideType>; 41412037Sandreas.sandberg@arm.com using Array = array_t<Scalar, array::forcecast | 41512037Sandreas.sandberg@arm.com ((props::row_major ? props::inner_stride : props::outer_stride) == 1 ? array::c_style : 41612037Sandreas.sandberg@arm.com (props::row_major ? props::outer_stride : props::inner_stride) == 1 ? array::f_style : 0)>; 41712037Sandreas.sandberg@arm.com static constexpr bool need_writeable = is_eigen_mutable_map<Type>::value; 41812037Sandreas.sandberg@arm.com // Delay construction (these have no default constructor) 41912037Sandreas.sandberg@arm.com std::unique_ptr<MapType> map; 42012037Sandreas.sandberg@arm.com std::unique_ptr<Type> ref; 42112037Sandreas.sandberg@arm.com // Our array. When possible, this is just a numpy array pointing to the source data, but 42212037Sandreas.sandberg@arm.com // sometimes we can't avoid copying (e.g. input is not a numpy array at all, has an incompatible 42312037Sandreas.sandberg@arm.com // layout, or is an array of a type that needs to be converted). Using a numpy temporary 42412037Sandreas.sandberg@arm.com // (rather than an Eigen temporary) saves an extra copy when we need both type conversion and 42512037Sandreas.sandberg@arm.com // storage order conversion. (Note that we refuse to use this temporary copy when loading an 42612037Sandreas.sandberg@arm.com // argument for a Ref<M> with M non-const, i.e. a read-write reference). 42712037Sandreas.sandberg@arm.com Array copy_or_ref; 42811986Sandreas.sandberg@arm.compublic: 42912037Sandreas.sandberg@arm.com bool load(handle src, bool convert) { 43012037Sandreas.sandberg@arm.com // First check whether what we have is already an array of the right type. If not, we can't 43112037Sandreas.sandberg@arm.com // avoid a copy (because the copy is also going to do type conversion). 43212037Sandreas.sandberg@arm.com bool need_copy = !isinstance<Array>(src); 43311986Sandreas.sandberg@arm.com 43412037Sandreas.sandberg@arm.com EigenConformable<props::row_major> fits; 43512037Sandreas.sandberg@arm.com if (!need_copy) { 43612037Sandreas.sandberg@arm.com // We don't need a converting copy, but we also need to check whether the strides are 43712037Sandreas.sandberg@arm.com // compatible with the Ref's stride requirements 43812037Sandreas.sandberg@arm.com Array aref = reinterpret_borrow<Array>(src); 43911986Sandreas.sandberg@arm.com 44012037Sandreas.sandberg@arm.com if (aref && (!need_writeable || aref.writeable())) { 44112037Sandreas.sandberg@arm.com fits = props::conformable(aref); 44212037Sandreas.sandberg@arm.com if (!fits) return false; // Incompatible dimensions 44312037Sandreas.sandberg@arm.com if (!fits.template stride_compatible<props>()) 44412037Sandreas.sandberg@arm.com need_copy = true; 44512037Sandreas.sandberg@arm.com else 44612037Sandreas.sandberg@arm.com copy_or_ref = std::move(aref); 44712037Sandreas.sandberg@arm.com } 44812037Sandreas.sandberg@arm.com else { 44912037Sandreas.sandberg@arm.com need_copy = true; 45012037Sandreas.sandberg@arm.com } 45112037Sandreas.sandberg@arm.com } 45212037Sandreas.sandberg@arm.com 45312037Sandreas.sandberg@arm.com if (need_copy) { 45412037Sandreas.sandberg@arm.com // We need to copy: If we need a mutable reference, or we're not supposed to convert 45512037Sandreas.sandberg@arm.com // (either because we're in the no-convert overload pass, or because we're explicitly 45612037Sandreas.sandberg@arm.com // instructed not to copy (via `py::arg().noconvert()`) we have to fail loading. 45712037Sandreas.sandberg@arm.com if (!convert || need_writeable) return false; 45812037Sandreas.sandberg@arm.com 45912037Sandreas.sandberg@arm.com Array copy = Array::ensure(src); 46012037Sandreas.sandberg@arm.com if (!copy) return false; 46112037Sandreas.sandberg@arm.com fits = props::conformable(copy); 46212037Sandreas.sandberg@arm.com if (!fits || !fits.template stride_compatible<props>()) 46312037Sandreas.sandberg@arm.com return false; 46412037Sandreas.sandberg@arm.com copy_or_ref = std::move(copy); 46512391Sjason@lowepower.com loader_life_support::add_patient(copy_or_ref); 46612037Sandreas.sandberg@arm.com } 46712037Sandreas.sandberg@arm.com 46812037Sandreas.sandberg@arm.com ref.reset(); 46912037Sandreas.sandberg@arm.com map.reset(new MapType(data(copy_or_ref), fits.rows, fits.cols, make_stride(fits.stride.outer(), fits.stride.inner()))); 47012037Sandreas.sandberg@arm.com ref.reset(new Type(*map)); 47112037Sandreas.sandberg@arm.com 47212037Sandreas.sandberg@arm.com return true; 47312037Sandreas.sandberg@arm.com } 47412037Sandreas.sandberg@arm.com 47512037Sandreas.sandberg@arm.com operator Type*() { return ref.get(); } 47612037Sandreas.sandberg@arm.com operator Type&() { return *ref; } 47711986Sandreas.sandberg@arm.com template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>; 47812037Sandreas.sandberg@arm.com 47912037Sandreas.sandberg@arm.comprivate: 48012037Sandreas.sandberg@arm.com template <typename T = Type, enable_if_t<is_eigen_mutable_map<T>::value, int> = 0> 48112037Sandreas.sandberg@arm.com Scalar *data(Array &a) { return a.mutable_data(); } 48212037Sandreas.sandberg@arm.com 48312037Sandreas.sandberg@arm.com template <typename T = Type, enable_if_t<!is_eigen_mutable_map<T>::value, int> = 0> 48412037Sandreas.sandberg@arm.com const Scalar *data(Array &a) { return a.data(); } 48512037Sandreas.sandberg@arm.com 48612037Sandreas.sandberg@arm.com // Attempt to figure out a constructor of `Stride` that will work. 48712037Sandreas.sandberg@arm.com // If both strides are fixed, use a default constructor: 48812037Sandreas.sandberg@arm.com template <typename S> using stride_ctor_default = bool_constant< 48912037Sandreas.sandberg@arm.com S::InnerStrideAtCompileTime != Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic && 49012037Sandreas.sandberg@arm.com std::is_default_constructible<S>::value>; 49112037Sandreas.sandberg@arm.com // Otherwise, if there is a two-index constructor, assume it is (outer,inner) like 49212037Sandreas.sandberg@arm.com // Eigen::Stride, and use it: 49312037Sandreas.sandberg@arm.com template <typename S> using stride_ctor_dual = bool_constant< 49412037Sandreas.sandberg@arm.com !stride_ctor_default<S>::value && std::is_constructible<S, EigenIndex, EigenIndex>::value>; 49512037Sandreas.sandberg@arm.com // Otherwise, if there is a one-index constructor, and just one of the strides is dynamic, use 49612037Sandreas.sandberg@arm.com // it (passing whichever stride is dynamic). 49712037Sandreas.sandberg@arm.com template <typename S> using stride_ctor_outer = bool_constant< 49812037Sandreas.sandberg@arm.com !any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value && 49912037Sandreas.sandberg@arm.com S::OuterStrideAtCompileTime == Eigen::Dynamic && S::InnerStrideAtCompileTime != Eigen::Dynamic && 50012037Sandreas.sandberg@arm.com std::is_constructible<S, EigenIndex>::value>; 50112037Sandreas.sandberg@arm.com template <typename S> using stride_ctor_inner = bool_constant< 50212037Sandreas.sandberg@arm.com !any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value && 50312037Sandreas.sandberg@arm.com S::InnerStrideAtCompileTime == Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic && 50412037Sandreas.sandberg@arm.com std::is_constructible<S, EigenIndex>::value>; 50512037Sandreas.sandberg@arm.com 50612037Sandreas.sandberg@arm.com template <typename S = StrideType, enable_if_t<stride_ctor_default<S>::value, int> = 0> 50712037Sandreas.sandberg@arm.com static S make_stride(EigenIndex, EigenIndex) { return S(); } 50812037Sandreas.sandberg@arm.com template <typename S = StrideType, enable_if_t<stride_ctor_dual<S>::value, int> = 0> 50912037Sandreas.sandberg@arm.com static S make_stride(EigenIndex outer, EigenIndex inner) { return S(outer, inner); } 51012037Sandreas.sandberg@arm.com template <typename S = StrideType, enable_if_t<stride_ctor_outer<S>::value, int> = 0> 51112037Sandreas.sandberg@arm.com static S make_stride(EigenIndex outer, EigenIndex) { return S(outer); } 51212037Sandreas.sandberg@arm.com template <typename S = StrideType, enable_if_t<stride_ctor_inner<S>::value, int> = 0> 51312037Sandreas.sandberg@arm.com static S make_stride(EigenIndex, EigenIndex inner) { return S(inner); } 51412037Sandreas.sandberg@arm.com 51511986Sandreas.sandberg@arm.com}; 51611986Sandreas.sandberg@arm.com 51712037Sandreas.sandberg@arm.com// type_caster for special matrix types (e.g. DiagonalMatrix), which are EigenBase, but not 51812037Sandreas.sandberg@arm.com// EigenDense (i.e. they don't have a data(), at least not with the usual matrix layout). 51912037Sandreas.sandberg@arm.com// load() is not supported, but we can cast them into the python domain by first copying to a 52012037Sandreas.sandberg@arm.com// regular Eigen::Matrix, then casting that. 52111986Sandreas.sandberg@arm.comtemplate <typename Type> 52212037Sandreas.sandberg@arm.comstruct type_caster<Type, enable_if_t<is_eigen_other<Type>::value>> { 52311986Sandreas.sandberg@arm.comprotected: 52412037Sandreas.sandberg@arm.com using Matrix = Eigen::Matrix<typename Type::Scalar, Type::RowsAtCompileTime, Type::ColsAtCompileTime>; 52512037Sandreas.sandberg@arm.com using props = EigenProps<Matrix>; 52611986Sandreas.sandberg@arm.compublic: 52712037Sandreas.sandberg@arm.com static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) { 52812037Sandreas.sandberg@arm.com handle h = eigen_encapsulate<props>(new Matrix(src)); 52912037Sandreas.sandberg@arm.com return h; 53012037Sandreas.sandberg@arm.com } 53112037Sandreas.sandberg@arm.com static handle cast(const Type *src, return_value_policy policy, handle parent) { return cast(*src, policy, parent); } 53211986Sandreas.sandberg@arm.com 53312037Sandreas.sandberg@arm.com static PYBIND11_DESCR name() { return props::descriptor(); } 53411986Sandreas.sandberg@arm.com 53512037Sandreas.sandberg@arm.com // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return 53612037Sandreas.sandberg@arm.com // types but not bound arguments). We still provide them (with an explicitly delete) so that 53712037Sandreas.sandberg@arm.com // you end up here if you try anyway. 53812037Sandreas.sandberg@arm.com bool load(handle, bool) = delete; 53912037Sandreas.sandberg@arm.com operator Type() = delete; 54012037Sandreas.sandberg@arm.com template <typename> using cast_op_type = Type; 54111986Sandreas.sandberg@arm.com}; 54211986Sandreas.sandberg@arm.com 54311986Sandreas.sandberg@arm.comtemplate<typename Type> 54411986Sandreas.sandberg@arm.comstruct type_caster<Type, enable_if_t<is_eigen_sparse<Type>::value>> { 54511986Sandreas.sandberg@arm.com typedef typename Type::Scalar Scalar; 54612391Sjason@lowepower.com typedef remove_reference_t<decltype(*std::declval<Type>().outerIndexPtr())> StorageIndex; 54711986Sandreas.sandberg@arm.com typedef typename Type::Index Index; 54812037Sandreas.sandberg@arm.com static constexpr bool rowMajor = Type::IsRowMajor; 54911986Sandreas.sandberg@arm.com 55011986Sandreas.sandberg@arm.com bool load(handle src, bool) { 55111986Sandreas.sandberg@arm.com if (!src) 55211986Sandreas.sandberg@arm.com return false; 55311986Sandreas.sandberg@arm.com 55411986Sandreas.sandberg@arm.com auto obj = reinterpret_borrow<object>(src); 55511986Sandreas.sandberg@arm.com object sparse_module = module::import("scipy.sparse"); 55611986Sandreas.sandberg@arm.com object matrix_type = sparse_module.attr( 55711986Sandreas.sandberg@arm.com rowMajor ? "csr_matrix" : "csc_matrix"); 55811986Sandreas.sandberg@arm.com 55912391Sjason@lowepower.com if (!obj.get_type().is(matrix_type)) { 56011986Sandreas.sandberg@arm.com try { 56111986Sandreas.sandberg@arm.com obj = matrix_type(obj); 56211986Sandreas.sandberg@arm.com } catch (const error_already_set &) { 56311986Sandreas.sandberg@arm.com return false; 56411986Sandreas.sandberg@arm.com } 56511986Sandreas.sandberg@arm.com } 56611986Sandreas.sandberg@arm.com 56711986Sandreas.sandberg@arm.com auto values = array_t<Scalar>((object) obj.attr("data")); 56811986Sandreas.sandberg@arm.com auto innerIndices = array_t<StorageIndex>((object) obj.attr("indices")); 56911986Sandreas.sandberg@arm.com auto outerIndices = array_t<StorageIndex>((object) obj.attr("indptr")); 57011986Sandreas.sandberg@arm.com auto shape = pybind11::tuple((pybind11::object) obj.attr("shape")); 57111986Sandreas.sandberg@arm.com auto nnz = obj.attr("nnz").cast<Index>(); 57211986Sandreas.sandberg@arm.com 57311986Sandreas.sandberg@arm.com if (!values || !innerIndices || !outerIndices) 57411986Sandreas.sandberg@arm.com return false; 57511986Sandreas.sandberg@arm.com 57611986Sandreas.sandberg@arm.com value = Eigen::MappedSparseMatrix<Scalar, Type::Flags, StorageIndex>( 57711986Sandreas.sandberg@arm.com shape[0].cast<Index>(), shape[1].cast<Index>(), nnz, 57811986Sandreas.sandberg@arm.com outerIndices.mutable_data(), innerIndices.mutable_data(), values.mutable_data()); 57911986Sandreas.sandberg@arm.com 58011986Sandreas.sandberg@arm.com return true; 58111986Sandreas.sandberg@arm.com } 58211986Sandreas.sandberg@arm.com 58311986Sandreas.sandberg@arm.com static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) { 58411986Sandreas.sandberg@arm.com const_cast<Type&>(src).makeCompressed(); 58511986Sandreas.sandberg@arm.com 58611986Sandreas.sandberg@arm.com object matrix_type = module::import("scipy.sparse").attr( 58711986Sandreas.sandberg@arm.com rowMajor ? "csr_matrix" : "csc_matrix"); 58811986Sandreas.sandberg@arm.com 58912391Sjason@lowepower.com array data(src.nonZeros(), src.valuePtr()); 59012391Sjason@lowepower.com array outerIndices((rowMajor ? src.rows() : src.cols()) + 1, src.outerIndexPtr()); 59112391Sjason@lowepower.com array innerIndices(src.nonZeros(), src.innerIndexPtr()); 59211986Sandreas.sandberg@arm.com 59311986Sandreas.sandberg@arm.com return matrix_type( 59411986Sandreas.sandberg@arm.com std::make_tuple(data, innerIndices, outerIndices), 59511986Sandreas.sandberg@arm.com std::make_pair(src.rows(), src.cols()) 59611986Sandreas.sandberg@arm.com ).release(); 59711986Sandreas.sandberg@arm.com } 59811986Sandreas.sandberg@arm.com 59912037Sandreas.sandberg@arm.com PYBIND11_TYPE_CASTER(Type, _<(Type::IsRowMajor) != 0>("scipy.sparse.csr_matrix[", "scipy.sparse.csc_matrix[") 60011986Sandreas.sandberg@arm.com + npy_format_descriptor<Scalar>::name() + _("]")); 60111986Sandreas.sandberg@arm.com}; 60211986Sandreas.sandberg@arm.com 60311986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 60412391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE) 60511986Sandreas.sandberg@arm.com 60612037Sandreas.sandberg@arm.com#if defined(__GNUG__) || defined(__clang__) 60712037Sandreas.sandberg@arm.com# pragma GCC diagnostic pop 60812037Sandreas.sandberg@arm.com#elif defined(_MSC_VER) 60912037Sandreas.sandberg@arm.com# pragma warning(pop) 61011986Sandreas.sandberg@arm.com#endif 611