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"
2014299Sbbruce@ucdavis.edu#  ifdef __clang__
2114299Sbbruce@ucdavis.edu//   Eigen generates a bunch of implicit-copy-constructor-is-deprecated warnings with -Wdeprecated
2214299Sbbruce@ucdavis.edu//   under Clang, so disable that warning here:
2314299Sbbruce@ucdavis.edu#    pragma GCC diagnostic ignored "-Wdeprecated"
2414299Sbbruce@ucdavis.edu#  endif
2512037Sandreas.sandberg@arm.com#  if __GNUC__ >= 7
2612037Sandreas.sandberg@arm.com#    pragma GCC diagnostic ignored "-Wint-in-bool-context"
2712037Sandreas.sandberg@arm.com#  endif
2811986Sandreas.sandberg@arm.com#endif
2911986Sandreas.sandberg@arm.com
3012037Sandreas.sandberg@arm.com#if defined(_MSC_VER)
3112037Sandreas.sandberg@arm.com#  pragma warning(push)
3212037Sandreas.sandberg@arm.com#  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
3314299Sbbruce@ucdavis.edu#  pragma warning(disable: 4996) // warning C4996: std::unary_negate is deprecated in C++17
3411986Sandreas.sandberg@arm.com#endif
3511986Sandreas.sandberg@arm.com
3614299Sbbruce@ucdavis.edu#include <Eigen/Core>
3714299Sbbruce@ucdavis.edu#include <Eigen/SparseCore>
3814299Sbbruce@ucdavis.edu
3912037Sandreas.sandberg@arm.com// Eigen prior to 3.2.7 doesn't have proper move constructors--but worse, some classes get implicit
4012037Sandreas.sandberg@arm.com// move constructors that break things.  We could detect this an explicitly copy, but an extra copy
4112037Sandreas.sandberg@arm.com// of matrices seems highly undesirable.
4212037Sandreas.sandberg@arm.comstatic_assert(EIGEN_VERSION_AT_LEAST(3,2,7), "Eigen support in pybind11 requires Eigen >= 3.2.7");
4312037Sandreas.sandberg@arm.com
4412391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE)
4512037Sandreas.sandberg@arm.com
4612037Sandreas.sandberg@arm.com// Provide a convenience alias for easier pass-by-ref usage with fully dynamic strides:
4712037Sandreas.sandberg@arm.comusing EigenDStride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>;
4812037Sandreas.sandberg@arm.comtemplate <typename MatrixType> using EigenDRef = Eigen::Ref<MatrixType, 0, EigenDStride>;
4912037Sandreas.sandberg@arm.comtemplate <typename MatrixType> using EigenDMap = Eigen::Map<MatrixType, 0, EigenDStride>;
5012037Sandreas.sandberg@arm.com
5112037Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail)
5212037Sandreas.sandberg@arm.com
5312037Sandreas.sandberg@arm.com#if EIGEN_VERSION_AT_LEAST(3,3,0)
5412037Sandreas.sandberg@arm.comusing EigenIndex = Eigen::Index;
5512037Sandreas.sandberg@arm.com#else
5612037Sandreas.sandberg@arm.comusing EigenIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE;
5711986Sandreas.sandberg@arm.com#endif
5811986Sandreas.sandberg@arm.com
5912037Sandreas.sandberg@arm.com// Matches Eigen::Map, Eigen::Ref, blocks, etc:
6012037Sandreas.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>>;
6112037Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_mutable_map = std::is_base_of<Eigen::MapBase<T, Eigen::WriteAccessors>, T>;
6212037Sandreas.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>>;
6311986Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_sparse = is_template_base_of<Eigen::SparseMatrixBase, T>;
6411986Sandreas.sandberg@arm.com// Test for objects inheriting from EigenBase<Derived> that aren't captured by the above.  This
6511986Sandreas.sandberg@arm.com// basically covers anything that can be assigned to a dense matrix but that don't have a typical
6611986Sandreas.sandberg@arm.com// matrix data layout that can be copied from their .data().  For example, DiagonalMatrix and
6711986Sandreas.sandberg@arm.com// SelfAdjointView fall into this category.
6812037Sandreas.sandberg@arm.comtemplate <typename T> using is_eigen_other = all_of<
6912037Sandreas.sandberg@arm.com    is_template_base_of<Eigen::EigenBase, T>,
7012037Sandreas.sandberg@arm.com    negation<any_of<is_eigen_dense_map<T>, is_eigen_dense_plain<T>, is_eigen_sparse<T>>>
7111986Sandreas.sandberg@arm.com>;
7211986Sandreas.sandberg@arm.com
7312037Sandreas.sandberg@arm.com// Captures numpy/eigen conformability status (returned by EigenProps::conformable()):
7412037Sandreas.sandberg@arm.comtemplate <bool EigenRowMajor> struct EigenConformable {
7512037Sandreas.sandberg@arm.com    bool conformable = false;
7612037Sandreas.sandberg@arm.com    EigenIndex rows = 0, cols = 0;
7712391Sjason@lowepower.com    EigenDStride stride{0, 0};      // Only valid if negativestrides is false!
7812391Sjason@lowepower.com    bool negativestrides = false;   // If true, do not use stride!
7912037Sandreas.sandberg@arm.com
8012037Sandreas.sandberg@arm.com    EigenConformable(bool fits = false) : conformable{fits} {}
8112037Sandreas.sandberg@arm.com    // Matrix type:
8212037Sandreas.sandberg@arm.com    EigenConformable(EigenIndex r, EigenIndex c,
8312037Sandreas.sandberg@arm.com            EigenIndex rstride, EigenIndex cstride) :
8412391Sjason@lowepower.com        conformable{true}, rows{r}, cols{c} {
8512391Sjason@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
8612391Sjason@lowepower.com        if (rstride < 0 || cstride < 0) {
8712391Sjason@lowepower.com            negativestrides = true;
8812391Sjason@lowepower.com        } else {
8912391Sjason@lowepower.com            stride = {EigenRowMajor ? rstride : cstride /* outer stride */,
9012391Sjason@lowepower.com                      EigenRowMajor ? cstride : rstride /* inner stride */ };
9112391Sjason@lowepower.com        }
9212391Sjason@lowepower.com    }
9312037Sandreas.sandberg@arm.com    // Vector type:
9412037Sandreas.sandberg@arm.com    EigenConformable(EigenIndex r, EigenIndex c, EigenIndex stride)
9512037Sandreas.sandberg@arm.com        : EigenConformable(r, c, r == 1 ? c*stride : stride, c == 1 ? r : r*stride) {}
9612037Sandreas.sandberg@arm.com
9712037Sandreas.sandberg@arm.com    template <typename props> bool stride_compatible() const {
9812037Sandreas.sandberg@arm.com        // To have compatible strides, we need (on both dimensions) one of fully dynamic strides,
9912037Sandreas.sandberg@arm.com        // matching strides, or a dimension size of 1 (in which case the stride value is irrelevant)
10012037Sandreas.sandberg@arm.com        return
10112391Sjason@lowepower.com            !negativestrides &&
10212037Sandreas.sandberg@arm.com            (props::inner_stride == Eigen::Dynamic || props::inner_stride == stride.inner() ||
10312037Sandreas.sandberg@arm.com                (EigenRowMajor ? cols : rows) == 1) &&
10412037Sandreas.sandberg@arm.com            (props::outer_stride == Eigen::Dynamic || props::outer_stride == stride.outer() ||
10512037Sandreas.sandberg@arm.com                (EigenRowMajor ? rows : cols) == 1);
10612037Sandreas.sandberg@arm.com    }
10712037Sandreas.sandberg@arm.com    operator bool() const { return conformable; }
10812037Sandreas.sandberg@arm.com};
10912037Sandreas.sandberg@arm.com
11012037Sandreas.sandberg@arm.comtemplate <typename Type> struct eigen_extract_stride { using type = Type; };
11112037Sandreas.sandberg@arm.comtemplate <typename PlainObjectType, int MapOptions, typename StrideType>
11212037Sandreas.sandberg@arm.comstruct eigen_extract_stride<Eigen::Map<PlainObjectType, MapOptions, StrideType>> { using type = StrideType; };
11312037Sandreas.sandberg@arm.comtemplate <typename PlainObjectType, int Options, typename StrideType>
11412037Sandreas.sandberg@arm.comstruct eigen_extract_stride<Eigen::Ref<PlainObjectType, Options, StrideType>> { using type = StrideType; };
11512037Sandreas.sandberg@arm.com
11612037Sandreas.sandberg@arm.com// Helper struct for extracting information from an Eigen type
11712037Sandreas.sandberg@arm.comtemplate <typename Type_> struct EigenProps {
11812037Sandreas.sandberg@arm.com    using Type = Type_;
11912037Sandreas.sandberg@arm.com    using Scalar = typename Type::Scalar;
12012037Sandreas.sandberg@arm.com    using StrideType = typename eigen_extract_stride<Type>::type;
12112037Sandreas.sandberg@arm.com    static constexpr EigenIndex
12212037Sandreas.sandberg@arm.com        rows = Type::RowsAtCompileTime,
12312037Sandreas.sandberg@arm.com        cols = Type::ColsAtCompileTime,
12412037Sandreas.sandberg@arm.com        size = Type::SizeAtCompileTime;
12512037Sandreas.sandberg@arm.com    static constexpr bool
12612037Sandreas.sandberg@arm.com        row_major = Type::IsRowMajor,
12712037Sandreas.sandberg@arm.com        vector = Type::IsVectorAtCompileTime, // At least one dimension has fixed size 1
12812037Sandreas.sandberg@arm.com        fixed_rows = rows != Eigen::Dynamic,
12912037Sandreas.sandberg@arm.com        fixed_cols = cols != Eigen::Dynamic,
13012037Sandreas.sandberg@arm.com        fixed = size != Eigen::Dynamic, // Fully-fixed size
13112037Sandreas.sandberg@arm.com        dynamic = !fixed_rows && !fixed_cols; // Fully-dynamic size
13212037Sandreas.sandberg@arm.com
13312037Sandreas.sandberg@arm.com    template <EigenIndex i, EigenIndex ifzero> using if_zero = std::integral_constant<EigenIndex, i == 0 ? ifzero : i>;
13412037Sandreas.sandberg@arm.com    static constexpr EigenIndex inner_stride = if_zero<StrideType::InnerStrideAtCompileTime, 1>::value,
13512037Sandreas.sandberg@arm.com                                outer_stride = if_zero<StrideType::OuterStrideAtCompileTime,
13612037Sandreas.sandberg@arm.com                                                       vector ? size : row_major ? cols : rows>::value;
13712037Sandreas.sandberg@arm.com    static constexpr bool dynamic_stride = inner_stride == Eigen::Dynamic && outer_stride == Eigen::Dynamic;
13812037Sandreas.sandberg@arm.com    static constexpr bool requires_row_major = !dynamic_stride && !vector && (row_major ? inner_stride : outer_stride) == 1;
13912037Sandreas.sandberg@arm.com    static constexpr bool requires_col_major = !dynamic_stride && !vector && (row_major ? outer_stride : inner_stride) == 1;
14012037Sandreas.sandberg@arm.com
14112037Sandreas.sandberg@arm.com    // Takes an input array and determines whether we can make it fit into the Eigen type.  If
14212037Sandreas.sandberg@arm.com    // the array is a vector, we attempt to fit it into either an Eigen 1xN or Nx1 vector
14312037Sandreas.sandberg@arm.com    // (preferring the latter if it will fit in either, i.e. for a fully dynamic matrix type).
14412037Sandreas.sandberg@arm.com    static EigenConformable<row_major> conformable(const array &a) {
14512037Sandreas.sandberg@arm.com        const auto dims = a.ndim();
14612037Sandreas.sandberg@arm.com        if (dims < 1 || dims > 2)
14712037Sandreas.sandberg@arm.com            return false;
14812037Sandreas.sandberg@arm.com
14912037Sandreas.sandberg@arm.com        if (dims == 2) { // Matrix type: require exact match (or dynamic)
15012037Sandreas.sandberg@arm.com
15112037Sandreas.sandberg@arm.com            EigenIndex
15212037Sandreas.sandberg@arm.com                np_rows = a.shape(0),
15312037Sandreas.sandberg@arm.com                np_cols = a.shape(1),
15412391Sjason@lowepower.com                np_rstride = a.strides(0) / static_cast<ssize_t>(sizeof(Scalar)),
15512391Sjason@lowepower.com                np_cstride = a.strides(1) / static_cast<ssize_t>(sizeof(Scalar));
15612037Sandreas.sandberg@arm.com            if ((fixed_rows && np_rows != rows) || (fixed_cols && np_cols != cols))
15712037Sandreas.sandberg@arm.com                return false;
15812037Sandreas.sandberg@arm.com
15912037Sandreas.sandberg@arm.com            return {np_rows, np_cols, np_rstride, np_cstride};
16012037Sandreas.sandberg@arm.com        }
16112037Sandreas.sandberg@arm.com
16212037Sandreas.sandberg@arm.com        // Otherwise we're storing an n-vector.  Only one of the strides will be used, but whichever
16312037Sandreas.sandberg@arm.com        // is used, we want the (single) numpy stride value.
16412037Sandreas.sandberg@arm.com        const EigenIndex n = a.shape(0),
16512391Sjason@lowepower.com              stride = a.strides(0) / static_cast<ssize_t>(sizeof(Scalar));
16612037Sandreas.sandberg@arm.com
16712037Sandreas.sandberg@arm.com        if (vector) { // Eigen type is a compile-time vector
16812037Sandreas.sandberg@arm.com            if (fixed && size != n)
16912037Sandreas.sandberg@arm.com                return false; // Vector size mismatch
17012037Sandreas.sandberg@arm.com            return {rows == 1 ? 1 : n, cols == 1 ? 1 : n, stride};
17112037Sandreas.sandberg@arm.com        }
17212037Sandreas.sandberg@arm.com        else if (fixed) {
17312037Sandreas.sandberg@arm.com            // The type has a fixed size, but is not a vector: abort
17412037Sandreas.sandberg@arm.com            return false;
17512037Sandreas.sandberg@arm.com        }
17612037Sandreas.sandberg@arm.com        else if (fixed_cols) {
17712037Sandreas.sandberg@arm.com            // Since this isn't a vector, cols must be != 1.  We allow this only if it exactly
17812037Sandreas.sandberg@arm.com            // equals the number of elements (rows is Dynamic, and so 1 row is allowed).
17912037Sandreas.sandberg@arm.com            if (cols != n) return false;
18012037Sandreas.sandberg@arm.com            return {1, n, stride};
18112037Sandreas.sandberg@arm.com        }
18212037Sandreas.sandberg@arm.com        else {
18312037Sandreas.sandberg@arm.com            // Otherwise it's either fully dynamic, or column dynamic; both become a column vector
18412037Sandreas.sandberg@arm.com            if (fixed_rows && rows != n) return false;
18512037Sandreas.sandberg@arm.com            return {n, 1, stride};
18612037Sandreas.sandberg@arm.com        }
18712037Sandreas.sandberg@arm.com    }
18812037Sandreas.sandberg@arm.com
18914299Sbbruce@ucdavis.edu    static constexpr bool show_writeable = is_eigen_dense_map<Type>::value && is_eigen_mutable_map<Type>::value;
19014299Sbbruce@ucdavis.edu    static constexpr bool show_order = is_eigen_dense_map<Type>::value;
19114299Sbbruce@ucdavis.edu    static constexpr bool show_c_contiguous = show_order && requires_row_major;
19214299Sbbruce@ucdavis.edu    static constexpr bool show_f_contiguous = !show_c_contiguous && show_order && requires_col_major;
19312037Sandreas.sandberg@arm.com
19414299Sbbruce@ucdavis.edu    static constexpr auto descriptor =
19514299Sbbruce@ucdavis.edu        _("numpy.ndarray[") + npy_format_descriptor<Scalar>::name +
19614299Sbbruce@ucdavis.edu        _("[")  + _<fixed_rows>(_<(size_t) rows>(), _("m")) +
19714299Sbbruce@ucdavis.edu        _(", ") + _<fixed_cols>(_<(size_t) cols>(), _("n")) +
19814299Sbbruce@ucdavis.edu        _("]") +
19914299Sbbruce@ucdavis.edu        // For a reference type (e.g. Ref<MatrixXd>) we have other constraints that might need to be
20014299Sbbruce@ucdavis.edu        // satisfied: writeable=True (for a mutable reference), and, depending on the map's stride
20114299Sbbruce@ucdavis.edu        // options, possibly f_contiguous or c_contiguous.  We include them in the descriptor output
20214299Sbbruce@ucdavis.edu        // to provide some hint as to why a TypeError is occurring (otherwise it can be confusing to
20314299Sbbruce@ucdavis.edu        // see that a function accepts a 'numpy.ndarray[float64[3,2]]' and an error message that you
20414299Sbbruce@ucdavis.edu        // *gave* a numpy.ndarray of the right type and dimensions.
20514299Sbbruce@ucdavis.edu        _<show_writeable>(", flags.writeable", "") +
20614299Sbbruce@ucdavis.edu        _<show_c_contiguous>(", flags.c_contiguous", "") +
20714299Sbbruce@ucdavis.edu        _<show_f_contiguous>(", flags.f_contiguous", "") +
20814299Sbbruce@ucdavis.edu        _("]");
20912037Sandreas.sandberg@arm.com};
21012037Sandreas.sandberg@arm.com
21112037Sandreas.sandberg@arm.com// Casts an Eigen type to numpy array.  If given a base, the numpy array references the src data,
21212037Sandreas.sandberg@arm.com// otherwise it'll make a copy.  writeable lets you turn off the writeable flag for the array.
21312037Sandreas.sandberg@arm.comtemplate <typename props> handle eigen_array_cast(typename props::Type const &src, handle base = handle(), bool writeable = true) {
21412391Sjason@lowepower.com    constexpr ssize_t elem_size = sizeof(typename props::Scalar);
21512391Sjason@lowepower.com    array a;
21612391Sjason@lowepower.com    if (props::vector)
21712391Sjason@lowepower.com        a = array({ src.size() }, { elem_size * src.innerStride() }, src.data(), base);
21812391Sjason@lowepower.com    else
21912391Sjason@lowepower.com        a = array({ src.rows(), src.cols() }, { elem_size * src.rowStride(), elem_size * src.colStride() },
22012391Sjason@lowepower.com                  src.data(), base);
22112391Sjason@lowepower.com
22212037Sandreas.sandberg@arm.com    if (!writeable)
22312037Sandreas.sandberg@arm.com        array_proxy(a.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
22412037Sandreas.sandberg@arm.com
22512037Sandreas.sandberg@arm.com    return a.release();
22612037Sandreas.sandberg@arm.com}
22712037Sandreas.sandberg@arm.com
22812037Sandreas.sandberg@arm.com// Takes an lvalue ref to some Eigen type and a (python) base object, creating a numpy array that
22912037Sandreas.sandberg@arm.com// reference the Eigen object's data with `base` as the python-registered base class (if omitted,
23012037Sandreas.sandberg@arm.com// the base will be set to None, and lifetime management is up to the caller).  The numpy array is
23112037Sandreas.sandberg@arm.com// non-writeable if the given type is const.
23212037Sandreas.sandberg@arm.comtemplate <typename props, typename Type>
23312037Sandreas.sandberg@arm.comhandle eigen_ref_array(Type &src, handle parent = none()) {
23412037Sandreas.sandberg@arm.com    // none here is to get past array's should-we-copy detection, which currently always
23512037Sandreas.sandberg@arm.com    // copies when there is no base.  Setting the base to None should be harmless.
23612037Sandreas.sandberg@arm.com    return eigen_array_cast<props>(src, parent, !std::is_const<Type>::value);
23712037Sandreas.sandberg@arm.com}
23812037Sandreas.sandberg@arm.com
23912037Sandreas.sandberg@arm.com// Takes a pointer to some dense, plain Eigen type, builds a capsule around it, then returns a numpy
24012037Sandreas.sandberg@arm.com// array that references the encapsulated data with a python-side reference to the capsule to tie
24112037Sandreas.sandberg@arm.com// its destruction to that of any dependent python objects.  Const-ness is determined by whether or
24212037Sandreas.sandberg@arm.com// not the Type of the pointer given is const.
24312037Sandreas.sandberg@arm.comtemplate <typename props, typename Type, typename = enable_if_t<is_eigen_dense_plain<Type>::value>>
24412037Sandreas.sandberg@arm.comhandle eigen_encapsulate(Type *src) {
24512037Sandreas.sandberg@arm.com    capsule base(src, [](void *o) { delete static_cast<Type *>(o); });
24612037Sandreas.sandberg@arm.com    return eigen_ref_array<props>(*src, base);
24712037Sandreas.sandberg@arm.com}
24812037Sandreas.sandberg@arm.com
24912037Sandreas.sandberg@arm.com// Type caster for regular, dense matrix types (e.g. MatrixXd), but not maps/refs/etc. of dense
25012037Sandreas.sandberg@arm.com// types.
25111986Sandreas.sandberg@arm.comtemplate<typename Type>
25212037Sandreas.sandberg@arm.comstruct type_caster<Type, enable_if_t<is_eigen_dense_plain<Type>::value>> {
25312037Sandreas.sandberg@arm.com    using Scalar = typename Type::Scalar;
25412037Sandreas.sandberg@arm.com    using props = EigenProps<Type>;
25511986Sandreas.sandberg@arm.com
25612391Sjason@lowepower.com    bool load(handle src, bool convert) {
25712391Sjason@lowepower.com        // If we're in no-convert mode, only load if given an array of the correct type
25812391Sjason@lowepower.com        if (!convert && !isinstance<array_t<Scalar>>(src))
25912391Sjason@lowepower.com            return false;
26012391Sjason@lowepower.com
26112391Sjason@lowepower.com        // Coerce into an array, but don't do type conversion yet; the copy below handles it.
26212391Sjason@lowepower.com        auto buf = array::ensure(src);
26312391Sjason@lowepower.com
26411986Sandreas.sandberg@arm.com        if (!buf)
26511986Sandreas.sandberg@arm.com            return false;
26611986Sandreas.sandberg@arm.com
26712037Sandreas.sandberg@arm.com        auto dims = buf.ndim();
26812037Sandreas.sandberg@arm.com        if (dims < 1 || dims > 2)
26912037Sandreas.sandberg@arm.com            return false;
27011986Sandreas.sandberg@arm.com
27112037Sandreas.sandberg@arm.com        auto fits = props::conformable(buf);
27212037Sandreas.sandberg@arm.com        if (!fits)
27312391Sjason@lowepower.com            return false;
27411986Sandreas.sandberg@arm.com
27512391Sjason@lowepower.com        // Allocate the new type, then build a numpy reference into it
27612391Sjason@lowepower.com        value = Type(fits.rows, fits.cols);
27712391Sjason@lowepower.com        auto ref = reinterpret_steal<array>(eigen_ref_array<props>(value));
27812391Sjason@lowepower.com        if (dims == 1) ref = ref.squeeze();
27914299Sbbruce@ucdavis.edu        else if (ref.ndim() == 1) buf = buf.squeeze();
28012391Sjason@lowepower.com
28112391Sjason@lowepower.com        int result = detail::npy_api::get().PyArray_CopyInto_(ref.ptr(), buf.ptr());
28212391Sjason@lowepower.com
28312391Sjason@lowepower.com        if (result < 0) { // Copy failed!
28412391Sjason@lowepower.com            PyErr_Clear();
28512391Sjason@lowepower.com            return false;
28612391Sjason@lowepower.com        }
28711986Sandreas.sandberg@arm.com
28811986Sandreas.sandberg@arm.com        return true;
28911986Sandreas.sandberg@arm.com    }
29011986Sandreas.sandberg@arm.com
29112037Sandreas.sandberg@arm.comprivate:
29212037Sandreas.sandberg@arm.com
29312037Sandreas.sandberg@arm.com    // Cast implementation
29412037Sandreas.sandberg@arm.com    template <typename CType>
29512037Sandreas.sandberg@arm.com    static handle cast_impl(CType *src, return_value_policy policy, handle parent) {
29612037Sandreas.sandberg@arm.com        switch (policy) {
29712037Sandreas.sandberg@arm.com            case return_value_policy::take_ownership:
29812037Sandreas.sandberg@arm.com            case return_value_policy::automatic:
29912037Sandreas.sandberg@arm.com                return eigen_encapsulate<props>(src);
30012037Sandreas.sandberg@arm.com            case return_value_policy::move:
30112037Sandreas.sandberg@arm.com                return eigen_encapsulate<props>(new CType(std::move(*src)));
30212037Sandreas.sandberg@arm.com            case return_value_policy::copy:
30312037Sandreas.sandberg@arm.com                return eigen_array_cast<props>(*src);
30412037Sandreas.sandberg@arm.com            case return_value_policy::reference:
30512037Sandreas.sandberg@arm.com            case return_value_policy::automatic_reference:
30612037Sandreas.sandberg@arm.com                return eigen_ref_array<props>(*src);
30712037Sandreas.sandberg@arm.com            case return_value_policy::reference_internal:
30812037Sandreas.sandberg@arm.com                return eigen_ref_array<props>(*src, parent);
30912037Sandreas.sandberg@arm.com            default:
31012037Sandreas.sandberg@arm.com                throw cast_error("unhandled return_value_policy: should not happen!");
31112037Sandreas.sandberg@arm.com        };
31212037Sandreas.sandberg@arm.com    }
31312037Sandreas.sandberg@arm.com
31412037Sandreas.sandberg@arm.compublic:
31512037Sandreas.sandberg@arm.com
31612037Sandreas.sandberg@arm.com    // Normal returned non-reference, non-const value:
31712037Sandreas.sandberg@arm.com    static handle cast(Type &&src, return_value_policy /* policy */, handle parent) {
31812037Sandreas.sandberg@arm.com        return cast_impl(&src, return_value_policy::move, parent);
31912037Sandreas.sandberg@arm.com    }
32012037Sandreas.sandberg@arm.com    // If you return a non-reference const, we mark the numpy array readonly:
32112037Sandreas.sandberg@arm.com    static handle cast(const Type &&src, return_value_policy /* policy */, handle parent) {
32212037Sandreas.sandberg@arm.com        return cast_impl(&src, return_value_policy::move, parent);
32312037Sandreas.sandberg@arm.com    }
32412037Sandreas.sandberg@arm.com    // lvalue reference return; default (automatic) becomes copy
32512037Sandreas.sandberg@arm.com    static handle cast(Type &src, return_value_policy policy, handle parent) {
32612037Sandreas.sandberg@arm.com        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
32712037Sandreas.sandberg@arm.com            policy = return_value_policy::copy;
32812037Sandreas.sandberg@arm.com        return cast_impl(&src, policy, parent);
32912037Sandreas.sandberg@arm.com    }
33012037Sandreas.sandberg@arm.com    // const lvalue reference return; default (automatic) becomes copy
33112037Sandreas.sandberg@arm.com    static handle cast(const Type &src, return_value_policy policy, handle parent) {
33212037Sandreas.sandberg@arm.com        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
33312037Sandreas.sandberg@arm.com            policy = return_value_policy::copy;
33412037Sandreas.sandberg@arm.com        return cast(&src, policy, parent);
33512037Sandreas.sandberg@arm.com    }
33612037Sandreas.sandberg@arm.com    // non-const pointer return
33712037Sandreas.sandberg@arm.com    static handle cast(Type *src, return_value_policy policy, handle parent) {
33812037Sandreas.sandberg@arm.com        return cast_impl(src, policy, parent);
33912037Sandreas.sandberg@arm.com    }
34012037Sandreas.sandberg@arm.com    // const pointer return
34112037Sandreas.sandberg@arm.com    static handle cast(const Type *src, return_value_policy policy, handle parent) {
34212037Sandreas.sandberg@arm.com        return cast_impl(src, policy, parent);
34312037Sandreas.sandberg@arm.com    }
34412037Sandreas.sandberg@arm.com
34514299Sbbruce@ucdavis.edu    static constexpr auto name = props::descriptor;
34612037Sandreas.sandberg@arm.com
34712037Sandreas.sandberg@arm.com    operator Type*() { return &value; }
34812037Sandreas.sandberg@arm.com    operator Type&() { return value; }
34912391Sjason@lowepower.com    operator Type&&() && { return std::move(value); }
35012391Sjason@lowepower.com    template <typename T> using cast_op_type = movable_cast_op_type<T>;
35112037Sandreas.sandberg@arm.com
35212037Sandreas.sandberg@arm.comprivate:
35312037Sandreas.sandberg@arm.com    Type value;
35412037Sandreas.sandberg@arm.com};
35512037Sandreas.sandberg@arm.com
35612037Sandreas.sandberg@arm.com// Base class for casting reference/map/block/etc. objects back to python.
35712037Sandreas.sandberg@arm.comtemplate <typename MapType> struct eigen_map_caster {
35812037Sandreas.sandberg@arm.comprivate:
35912037Sandreas.sandberg@arm.com    using props = EigenProps<MapType>;
36012037Sandreas.sandberg@arm.com
36112037Sandreas.sandberg@arm.compublic:
36212037Sandreas.sandberg@arm.com
36312037Sandreas.sandberg@arm.com    // Directly referencing a ref/map's data is a bit dangerous (whatever the map/ref points to has
36412037Sandreas.sandberg@arm.com    // to stay around), but we'll allow it under the assumption that you know what you're doing (and
36512037Sandreas.sandberg@arm.com    // have an appropriate keep_alive in place).  We return a numpy array pointing directly at the
36612037Sandreas.sandberg@arm.com    // ref's data (The numpy array ends up read-only if the ref was to a const matrix type.) Note
36712037Sandreas.sandberg@arm.com    // that this means you need to ensure you don't destroy the object in some other way (e.g. with
36812037Sandreas.sandberg@arm.com    // an appropriate keep_alive, or with a reference to a statically allocated matrix).
36912037Sandreas.sandberg@arm.com    static handle cast(const MapType &src, return_value_policy policy, handle parent) {
37012037Sandreas.sandberg@arm.com        switch (policy) {
37112037Sandreas.sandberg@arm.com            case return_value_policy::copy:
37212037Sandreas.sandberg@arm.com                return eigen_array_cast<props>(src);
37312037Sandreas.sandberg@arm.com            case return_value_policy::reference_internal:
37412037Sandreas.sandberg@arm.com                return eigen_array_cast<props>(src, parent, is_eigen_mutable_map<MapType>::value);
37512037Sandreas.sandberg@arm.com            case return_value_policy::reference:
37612037Sandreas.sandberg@arm.com            case return_value_policy::automatic:
37712037Sandreas.sandberg@arm.com            case return_value_policy::automatic_reference:
37812037Sandreas.sandberg@arm.com                return eigen_array_cast<props>(src, none(), is_eigen_mutable_map<MapType>::value);
37912037Sandreas.sandberg@arm.com            default:
38012037Sandreas.sandberg@arm.com                // move, take_ownership don't make any sense for a ref/map:
38112037Sandreas.sandberg@arm.com                pybind11_fail("Invalid return_value_policy for Eigen Map/Ref/Block type");
38211986Sandreas.sandberg@arm.com        }
38311986Sandreas.sandberg@arm.com    }
38411986Sandreas.sandberg@arm.com
38514299Sbbruce@ucdavis.edu    static constexpr auto name = props::descriptor;
38611986Sandreas.sandberg@arm.com
38712037Sandreas.sandberg@arm.com    // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return
38812037Sandreas.sandberg@arm.com    // types but not bound arguments).  We still provide them (with an explicitly delete) so that
38912037Sandreas.sandberg@arm.com    // you end up here if you try anyway.
39012037Sandreas.sandberg@arm.com    bool load(handle, bool) = delete;
39112037Sandreas.sandberg@arm.com    operator MapType() = delete;
39212037Sandreas.sandberg@arm.com    template <typename> using cast_op_type = MapType;
39311986Sandreas.sandberg@arm.com};
39411986Sandreas.sandberg@arm.com
39512037Sandreas.sandberg@arm.com// We can return any map-like object (but can only load Refs, specialized next):
39612037Sandreas.sandberg@arm.comtemplate <typename Type> struct type_caster<Type, enable_if_t<is_eigen_dense_map<Type>::value>>
39712037Sandreas.sandberg@arm.com    : eigen_map_caster<Type> {};
39812037Sandreas.sandberg@arm.com
39912037Sandreas.sandberg@arm.com// Loader for Ref<...> arguments.  See the documentation for info on how to make this work without
40012037Sandreas.sandberg@arm.com// copying (it requires some extra effort in many cases).
40112037Sandreas.sandberg@arm.comtemplate <typename PlainObjectType, typename StrideType>
40212037Sandreas.sandberg@arm.comstruct type_caster<
40312037Sandreas.sandberg@arm.com    Eigen::Ref<PlainObjectType, 0, StrideType>,
40412037Sandreas.sandberg@arm.com    enable_if_t<is_eigen_dense_map<Eigen::Ref<PlainObjectType, 0, StrideType>>::value>
40512037Sandreas.sandberg@arm.com> : public eigen_map_caster<Eigen::Ref<PlainObjectType, 0, StrideType>> {
40612037Sandreas.sandberg@arm.comprivate:
40712037Sandreas.sandberg@arm.com    using Type = Eigen::Ref<PlainObjectType, 0, StrideType>;
40812037Sandreas.sandberg@arm.com    using props = EigenProps<Type>;
40912037Sandreas.sandberg@arm.com    using Scalar = typename props::Scalar;
41012037Sandreas.sandberg@arm.com    using MapType = Eigen::Map<PlainObjectType, 0, StrideType>;
41112037Sandreas.sandberg@arm.com    using Array = array_t<Scalar, array::forcecast |
41212037Sandreas.sandberg@arm.com                ((props::row_major ? props::inner_stride : props::outer_stride) == 1 ? array::c_style :
41312037Sandreas.sandberg@arm.com                 (props::row_major ? props::outer_stride : props::inner_stride) == 1 ? array::f_style : 0)>;
41412037Sandreas.sandberg@arm.com    static constexpr bool need_writeable = is_eigen_mutable_map<Type>::value;
41512037Sandreas.sandberg@arm.com    // Delay construction (these have no default constructor)
41612037Sandreas.sandberg@arm.com    std::unique_ptr<MapType> map;
41712037Sandreas.sandberg@arm.com    std::unique_ptr<Type> ref;
41812037Sandreas.sandberg@arm.com    // Our array.  When possible, this is just a numpy array pointing to the source data, but
41912037Sandreas.sandberg@arm.com    // sometimes we can't avoid copying (e.g. input is not a numpy array at all, has an incompatible
42012037Sandreas.sandberg@arm.com    // layout, or is an array of a type that needs to be converted).  Using a numpy temporary
42112037Sandreas.sandberg@arm.com    // (rather than an Eigen temporary) saves an extra copy when we need both type conversion and
42212037Sandreas.sandberg@arm.com    // storage order conversion.  (Note that we refuse to use this temporary copy when loading an
42312037Sandreas.sandberg@arm.com    // argument for a Ref<M> with M non-const, i.e. a read-write reference).
42412037Sandreas.sandberg@arm.com    Array copy_or_ref;
42511986Sandreas.sandberg@arm.compublic:
42612037Sandreas.sandberg@arm.com    bool load(handle src, bool convert) {
42712037Sandreas.sandberg@arm.com        // First check whether what we have is already an array of the right type.  If not, we can't
42812037Sandreas.sandberg@arm.com        // avoid a copy (because the copy is also going to do type conversion).
42912037Sandreas.sandberg@arm.com        bool need_copy = !isinstance<Array>(src);
43011986Sandreas.sandberg@arm.com
43112037Sandreas.sandberg@arm.com        EigenConformable<props::row_major> fits;
43212037Sandreas.sandberg@arm.com        if (!need_copy) {
43312037Sandreas.sandberg@arm.com            // We don't need a converting copy, but we also need to check whether the strides are
43412037Sandreas.sandberg@arm.com            // compatible with the Ref's stride requirements
43512037Sandreas.sandberg@arm.com            Array aref = reinterpret_borrow<Array>(src);
43611986Sandreas.sandberg@arm.com
43712037Sandreas.sandberg@arm.com            if (aref && (!need_writeable || aref.writeable())) {
43812037Sandreas.sandberg@arm.com                fits = props::conformable(aref);
43912037Sandreas.sandberg@arm.com                if (!fits) return false; // Incompatible dimensions
44012037Sandreas.sandberg@arm.com                if (!fits.template stride_compatible<props>())
44112037Sandreas.sandberg@arm.com                    need_copy = true;
44212037Sandreas.sandberg@arm.com                else
44312037Sandreas.sandberg@arm.com                    copy_or_ref = std::move(aref);
44412037Sandreas.sandberg@arm.com            }
44512037Sandreas.sandberg@arm.com            else {
44612037Sandreas.sandberg@arm.com                need_copy = true;
44712037Sandreas.sandberg@arm.com            }
44812037Sandreas.sandberg@arm.com        }
44912037Sandreas.sandberg@arm.com
45012037Sandreas.sandberg@arm.com        if (need_copy) {
45112037Sandreas.sandberg@arm.com            // We need to copy: If we need a mutable reference, or we're not supposed to convert
45212037Sandreas.sandberg@arm.com            // (either because we're in the no-convert overload pass, or because we're explicitly
45312037Sandreas.sandberg@arm.com            // instructed not to copy (via `py::arg().noconvert()`) we have to fail loading.
45412037Sandreas.sandberg@arm.com            if (!convert || need_writeable) return false;
45512037Sandreas.sandberg@arm.com
45612037Sandreas.sandberg@arm.com            Array copy = Array::ensure(src);
45712037Sandreas.sandberg@arm.com            if (!copy) return false;
45812037Sandreas.sandberg@arm.com            fits = props::conformable(copy);
45912037Sandreas.sandberg@arm.com            if (!fits || !fits.template stride_compatible<props>())
46012037Sandreas.sandberg@arm.com                return false;
46112037Sandreas.sandberg@arm.com            copy_or_ref = std::move(copy);
46212391Sjason@lowepower.com            loader_life_support::add_patient(copy_or_ref);
46312037Sandreas.sandberg@arm.com        }
46412037Sandreas.sandberg@arm.com
46512037Sandreas.sandberg@arm.com        ref.reset();
46612037Sandreas.sandberg@arm.com        map.reset(new MapType(data(copy_or_ref), fits.rows, fits.cols, make_stride(fits.stride.outer(), fits.stride.inner())));
46712037Sandreas.sandberg@arm.com        ref.reset(new Type(*map));
46812037Sandreas.sandberg@arm.com
46912037Sandreas.sandberg@arm.com        return true;
47012037Sandreas.sandberg@arm.com    }
47112037Sandreas.sandberg@arm.com
47212037Sandreas.sandberg@arm.com    operator Type*() { return ref.get(); }
47312037Sandreas.sandberg@arm.com    operator Type&() { return *ref; }
47411986Sandreas.sandberg@arm.com    template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>;
47512037Sandreas.sandberg@arm.com
47612037Sandreas.sandberg@arm.comprivate:
47712037Sandreas.sandberg@arm.com    template <typename T = Type, enable_if_t<is_eigen_mutable_map<T>::value, int> = 0>
47812037Sandreas.sandberg@arm.com    Scalar *data(Array &a) { return a.mutable_data(); }
47912037Sandreas.sandberg@arm.com
48012037Sandreas.sandberg@arm.com    template <typename T = Type, enable_if_t<!is_eigen_mutable_map<T>::value, int> = 0>
48112037Sandreas.sandberg@arm.com    const Scalar *data(Array &a) { return a.data(); }
48212037Sandreas.sandberg@arm.com
48312037Sandreas.sandberg@arm.com    // Attempt to figure out a constructor of `Stride` that will work.
48412037Sandreas.sandberg@arm.com    // If both strides are fixed, use a default constructor:
48512037Sandreas.sandberg@arm.com    template <typename S> using stride_ctor_default = bool_constant<
48612037Sandreas.sandberg@arm.com        S::InnerStrideAtCompileTime != Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic &&
48712037Sandreas.sandberg@arm.com        std::is_default_constructible<S>::value>;
48812037Sandreas.sandberg@arm.com    // Otherwise, if there is a two-index constructor, assume it is (outer,inner) like
48912037Sandreas.sandberg@arm.com    // Eigen::Stride, and use it:
49012037Sandreas.sandberg@arm.com    template <typename S> using stride_ctor_dual = bool_constant<
49112037Sandreas.sandberg@arm.com        !stride_ctor_default<S>::value && std::is_constructible<S, EigenIndex, EigenIndex>::value>;
49212037Sandreas.sandberg@arm.com    // Otherwise, if there is a one-index constructor, and just one of the strides is dynamic, use
49312037Sandreas.sandberg@arm.com    // it (passing whichever stride is dynamic).
49412037Sandreas.sandberg@arm.com    template <typename S> using stride_ctor_outer = bool_constant<
49512037Sandreas.sandberg@arm.com        !any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value &&
49612037Sandreas.sandberg@arm.com        S::OuterStrideAtCompileTime == Eigen::Dynamic && S::InnerStrideAtCompileTime != Eigen::Dynamic &&
49712037Sandreas.sandberg@arm.com        std::is_constructible<S, EigenIndex>::value>;
49812037Sandreas.sandberg@arm.com    template <typename S> using stride_ctor_inner = bool_constant<
49912037Sandreas.sandberg@arm.com        !any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value &&
50012037Sandreas.sandberg@arm.com        S::InnerStrideAtCompileTime == Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic &&
50112037Sandreas.sandberg@arm.com        std::is_constructible<S, EigenIndex>::value>;
50212037Sandreas.sandberg@arm.com
50312037Sandreas.sandberg@arm.com    template <typename S = StrideType, enable_if_t<stride_ctor_default<S>::value, int> = 0>
50412037Sandreas.sandberg@arm.com    static S make_stride(EigenIndex, EigenIndex) { return S(); }
50512037Sandreas.sandberg@arm.com    template <typename S = StrideType, enable_if_t<stride_ctor_dual<S>::value, int> = 0>
50612037Sandreas.sandberg@arm.com    static S make_stride(EigenIndex outer, EigenIndex inner) { return S(outer, inner); }
50712037Sandreas.sandberg@arm.com    template <typename S = StrideType, enable_if_t<stride_ctor_outer<S>::value, int> = 0>
50812037Sandreas.sandberg@arm.com    static S make_stride(EigenIndex outer, EigenIndex) { return S(outer); }
50912037Sandreas.sandberg@arm.com    template <typename S = StrideType, enable_if_t<stride_ctor_inner<S>::value, int> = 0>
51012037Sandreas.sandberg@arm.com    static S make_stride(EigenIndex, EigenIndex inner) { return S(inner); }
51112037Sandreas.sandberg@arm.com
51211986Sandreas.sandberg@arm.com};
51311986Sandreas.sandberg@arm.com
51412037Sandreas.sandberg@arm.com// type_caster for special matrix types (e.g. DiagonalMatrix), which are EigenBase, but not
51512037Sandreas.sandberg@arm.com// EigenDense (i.e. they don't have a data(), at least not with the usual matrix layout).
51612037Sandreas.sandberg@arm.com// load() is not supported, but we can cast them into the python domain by first copying to a
51712037Sandreas.sandberg@arm.com// regular Eigen::Matrix, then casting that.
51811986Sandreas.sandberg@arm.comtemplate <typename Type>
51912037Sandreas.sandberg@arm.comstruct type_caster<Type, enable_if_t<is_eigen_other<Type>::value>> {
52011986Sandreas.sandberg@arm.comprotected:
52112037Sandreas.sandberg@arm.com    using Matrix = Eigen::Matrix<typename Type::Scalar, Type::RowsAtCompileTime, Type::ColsAtCompileTime>;
52212037Sandreas.sandberg@arm.com    using props = EigenProps<Matrix>;
52311986Sandreas.sandberg@arm.compublic:
52412037Sandreas.sandberg@arm.com    static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) {
52512037Sandreas.sandberg@arm.com        handle h = eigen_encapsulate<props>(new Matrix(src));
52612037Sandreas.sandberg@arm.com        return h;
52712037Sandreas.sandberg@arm.com    }
52812037Sandreas.sandberg@arm.com    static handle cast(const Type *src, return_value_policy policy, handle parent) { return cast(*src, policy, parent); }
52911986Sandreas.sandberg@arm.com
53014299Sbbruce@ucdavis.edu    static constexpr auto name = props::descriptor;
53111986Sandreas.sandberg@arm.com
53212037Sandreas.sandberg@arm.com    // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return
53312037Sandreas.sandberg@arm.com    // types but not bound arguments).  We still provide them (with an explicitly delete) so that
53412037Sandreas.sandberg@arm.com    // you end up here if you try anyway.
53512037Sandreas.sandberg@arm.com    bool load(handle, bool) = delete;
53612037Sandreas.sandberg@arm.com    operator Type() = delete;
53712037Sandreas.sandberg@arm.com    template <typename> using cast_op_type = Type;
53811986Sandreas.sandberg@arm.com};
53911986Sandreas.sandberg@arm.com
54011986Sandreas.sandberg@arm.comtemplate<typename Type>
54111986Sandreas.sandberg@arm.comstruct type_caster<Type, enable_if_t<is_eigen_sparse<Type>::value>> {
54211986Sandreas.sandberg@arm.com    typedef typename Type::Scalar Scalar;
54312391Sjason@lowepower.com    typedef remove_reference_t<decltype(*std::declval<Type>().outerIndexPtr())> StorageIndex;
54411986Sandreas.sandberg@arm.com    typedef typename Type::Index Index;
54512037Sandreas.sandberg@arm.com    static constexpr bool rowMajor = Type::IsRowMajor;
54611986Sandreas.sandberg@arm.com
54711986Sandreas.sandberg@arm.com    bool load(handle src, bool) {
54811986Sandreas.sandberg@arm.com        if (!src)
54911986Sandreas.sandberg@arm.com            return false;
55011986Sandreas.sandberg@arm.com
55111986Sandreas.sandberg@arm.com        auto obj = reinterpret_borrow<object>(src);
55211986Sandreas.sandberg@arm.com        object sparse_module = module::import("scipy.sparse");
55311986Sandreas.sandberg@arm.com        object matrix_type = sparse_module.attr(
55411986Sandreas.sandberg@arm.com            rowMajor ? "csr_matrix" : "csc_matrix");
55511986Sandreas.sandberg@arm.com
55612391Sjason@lowepower.com        if (!obj.get_type().is(matrix_type)) {
55711986Sandreas.sandberg@arm.com            try {
55811986Sandreas.sandberg@arm.com                obj = matrix_type(obj);
55911986Sandreas.sandberg@arm.com            } catch (const error_already_set &) {
56011986Sandreas.sandberg@arm.com                return false;
56111986Sandreas.sandberg@arm.com            }
56211986Sandreas.sandberg@arm.com        }
56311986Sandreas.sandberg@arm.com
56411986Sandreas.sandberg@arm.com        auto values = array_t<Scalar>((object) obj.attr("data"));
56511986Sandreas.sandberg@arm.com        auto innerIndices = array_t<StorageIndex>((object) obj.attr("indices"));
56611986Sandreas.sandberg@arm.com        auto outerIndices = array_t<StorageIndex>((object) obj.attr("indptr"));
56711986Sandreas.sandberg@arm.com        auto shape = pybind11::tuple((pybind11::object) obj.attr("shape"));
56811986Sandreas.sandberg@arm.com        auto nnz = obj.attr("nnz").cast<Index>();
56911986Sandreas.sandberg@arm.com
57011986Sandreas.sandberg@arm.com        if (!values || !innerIndices || !outerIndices)
57111986Sandreas.sandberg@arm.com            return false;
57211986Sandreas.sandberg@arm.com
57311986Sandreas.sandberg@arm.com        value = Eigen::MappedSparseMatrix<Scalar, Type::Flags, StorageIndex>(
57411986Sandreas.sandberg@arm.com            shape[0].cast<Index>(), shape[1].cast<Index>(), nnz,
57511986Sandreas.sandberg@arm.com            outerIndices.mutable_data(), innerIndices.mutable_data(), values.mutable_data());
57611986Sandreas.sandberg@arm.com
57711986Sandreas.sandberg@arm.com        return true;
57811986Sandreas.sandberg@arm.com    }
57911986Sandreas.sandberg@arm.com
58011986Sandreas.sandberg@arm.com    static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) {
58111986Sandreas.sandberg@arm.com        const_cast<Type&>(src).makeCompressed();
58211986Sandreas.sandberg@arm.com
58311986Sandreas.sandberg@arm.com        object matrix_type = module::import("scipy.sparse").attr(
58411986Sandreas.sandberg@arm.com            rowMajor ? "csr_matrix" : "csc_matrix");
58511986Sandreas.sandberg@arm.com
58612391Sjason@lowepower.com        array data(src.nonZeros(), src.valuePtr());
58712391Sjason@lowepower.com        array outerIndices((rowMajor ? src.rows() : src.cols()) + 1, src.outerIndexPtr());
58812391Sjason@lowepower.com        array innerIndices(src.nonZeros(), src.innerIndexPtr());
58911986Sandreas.sandberg@arm.com
59011986Sandreas.sandberg@arm.com        return matrix_type(
59111986Sandreas.sandberg@arm.com            std::make_tuple(data, innerIndices, outerIndices),
59211986Sandreas.sandberg@arm.com            std::make_pair(src.rows(), src.cols())
59311986Sandreas.sandberg@arm.com        ).release();
59411986Sandreas.sandberg@arm.com    }
59511986Sandreas.sandberg@arm.com
59612037Sandreas.sandberg@arm.com    PYBIND11_TYPE_CASTER(Type, _<(Type::IsRowMajor) != 0>("scipy.sparse.csr_matrix[", "scipy.sparse.csc_matrix[")
59714299Sbbruce@ucdavis.edu            + npy_format_descriptor<Scalar>::name + _("]"));
59811986Sandreas.sandberg@arm.com};
59911986Sandreas.sandberg@arm.com
60011986Sandreas.sandberg@arm.comNAMESPACE_END(detail)
60112391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE)
60211986Sandreas.sandberg@arm.com
60312037Sandreas.sandberg@arm.com#if defined(__GNUG__) || defined(__clang__)
60412037Sandreas.sandberg@arm.com#  pragma GCC diagnostic pop
60512037Sandreas.sandberg@arm.com#elif defined(_MSC_VER)
60612037Sandreas.sandberg@arm.com#  pragma warning(pop)
60711986Sandreas.sandberg@arm.com#endif
608