1# -*- coding: utf-8 -*-
2import pytest
3from pybind11_tests import ConstructorStats
4
5np = pytest.importorskip("numpy")
6m = pytest.importorskip("pybind11_tests.eigen")
7
8
9ref = np.array(
10    [
11        [0.0, 3, 0, 0, 0, 11],
12        [22, 0, 0, 0, 17, 11],
13        [7, 5, 0, 1, 0, 11],
14        [0, 0, 0, 0, 0, 11],
15        [0, 0, 14, 0, 8, 11],
16    ]
17)
18
19
20def assert_equal_ref(mat):
21    np.testing.assert_array_equal(mat, ref)
22
23
24def assert_sparse_equal_ref(sparse_mat):
25    assert_equal_ref(sparse_mat.toarray())
26
27
28def test_fixed():
29    assert_equal_ref(m.fixed_c())
30    assert_equal_ref(m.fixed_r())
31    assert_equal_ref(m.fixed_copy_r(m.fixed_r()))
32    assert_equal_ref(m.fixed_copy_c(m.fixed_c()))
33    assert_equal_ref(m.fixed_copy_r(m.fixed_c()))
34    assert_equal_ref(m.fixed_copy_c(m.fixed_r()))
35
36
37def test_dense():
38    assert_equal_ref(m.dense_r())
39    assert_equal_ref(m.dense_c())
40    assert_equal_ref(m.dense_copy_r(m.dense_r()))
41    assert_equal_ref(m.dense_copy_c(m.dense_c()))
42    assert_equal_ref(m.dense_copy_r(m.dense_c()))
43    assert_equal_ref(m.dense_copy_c(m.dense_r()))
44
45
46def test_partially_fixed():
47    ref2 = np.array([[0.0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
48    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2), ref2)
49    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2), ref2)
50    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2[:, 1]), ref2[:, [1]])
51    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2[0, :]), ref2[[0], :])
52    np.testing.assert_array_equal(
53        m.partial_copy_four_rm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)]
54    )
55    np.testing.assert_array_equal(
56        m.partial_copy_four_rm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :]
57    )
58
59    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2), ref2)
60    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2), ref2)
61    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2[:, 1]), ref2[:, [1]])
62    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2[0, :]), ref2[[0], :])
63    np.testing.assert_array_equal(
64        m.partial_copy_four_cm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)]
65    )
66    np.testing.assert_array_equal(
67        m.partial_copy_four_cm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :]
68    )
69
70    # TypeError should be raise for a shape mismatch
71    functions = [
72        m.partial_copy_four_rm_r,
73        m.partial_copy_four_rm_c,
74        m.partial_copy_four_cm_r,
75        m.partial_copy_four_cm_c,
76    ]
77    matrix_with_wrong_shape = [[1, 2], [3, 4]]
78    for f in functions:
79        with pytest.raises(TypeError) as excinfo:
80            f(matrix_with_wrong_shape)
81        assert "incompatible function arguments" in str(excinfo.value)
82
83
84def test_mutator_descriptors():
85    zr = np.arange(30, dtype="float32").reshape(5, 6)  # row-major
86    zc = zr.reshape(6, 5).transpose()  # column-major
87
88    m.fixed_mutator_r(zr)
89    m.fixed_mutator_c(zc)
90    m.fixed_mutator_a(zr)
91    m.fixed_mutator_a(zc)
92    with pytest.raises(TypeError) as excinfo:
93        m.fixed_mutator_r(zc)
94    assert (
95        "(arg0: numpy.ndarray[numpy.float32[5, 6],"
96        " flags.writeable, flags.c_contiguous]) -> None" in str(excinfo.value)
97    )
98    with pytest.raises(TypeError) as excinfo:
99        m.fixed_mutator_c(zr)
100    assert (
101        "(arg0: numpy.ndarray[numpy.float32[5, 6],"
102        " flags.writeable, flags.f_contiguous]) -> None" in str(excinfo.value)
103    )
104    with pytest.raises(TypeError) as excinfo:
105        m.fixed_mutator_a(np.array([[1, 2], [3, 4]], dtype="float32"))
106    assert "(arg0: numpy.ndarray[numpy.float32[5, 6], flags.writeable]) -> None" in str(
107        excinfo.value
108    )
109    zr.flags.writeable = False
110    with pytest.raises(TypeError):
111        m.fixed_mutator_r(zr)
112    with pytest.raises(TypeError):
113        m.fixed_mutator_a(zr)
114
115
116def test_cpp_casting():
117    assert m.cpp_copy(m.fixed_r()) == 22.0
118    assert m.cpp_copy(m.fixed_c()) == 22.0
119    z = np.array([[5.0, 6], [7, 8]])
120    assert m.cpp_copy(z) == 7.0
121    assert m.cpp_copy(m.get_cm_ref()) == 21.0
122    assert m.cpp_copy(m.get_rm_ref()) == 21.0
123    assert m.cpp_ref_c(m.get_cm_ref()) == 21.0
124    assert m.cpp_ref_r(m.get_rm_ref()) == 21.0
125    with pytest.raises(RuntimeError) as excinfo:
126        # Can't reference m.fixed_c: it contains floats, m.cpp_ref_any wants doubles
127        m.cpp_ref_any(m.fixed_c())
128    assert "Unable to cast Python instance" in str(excinfo.value)
129    with pytest.raises(RuntimeError) as excinfo:
130        # Can't reference m.fixed_r: it contains floats, m.cpp_ref_any wants doubles
131        m.cpp_ref_any(m.fixed_r())
132    assert "Unable to cast Python instance" in str(excinfo.value)
133    assert m.cpp_ref_any(m.ReturnTester.create()) == 1.0
134
135    assert m.cpp_ref_any(m.get_cm_ref()) == 21.0
136    assert m.cpp_ref_any(m.get_cm_ref()) == 21.0
137
138
139def test_pass_readonly_array():
140    z = np.full((5, 6), 42.0)
141    z.flags.writeable = False
142    np.testing.assert_array_equal(z, m.fixed_copy_r(z))
143    np.testing.assert_array_equal(m.fixed_r_const(), m.fixed_r())
144    assert not m.fixed_r_const().flags.writeable
145    np.testing.assert_array_equal(m.fixed_copy_r(m.fixed_r_const()), m.fixed_r_const())
146
147
148def test_nonunit_stride_from_python():
149    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
150    second_row = counting_mat[1, :]
151    second_col = counting_mat[:, 1]
152    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
153    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
154    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
155    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
156    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
157    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
158
159    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
160    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
161    for ref_mat in slices:
162        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
163        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
164
165    # Mutator:
166    m.double_threer(second_row)
167    m.double_threec(second_col)
168    np.testing.assert_array_equal(counting_mat, [[0.0, 2, 2], [6, 16, 10], [6, 14, 8]])
169
170
171def test_negative_stride_from_python(msg):
172    """Eigen doesn't support (as of yet) negative strides. When a function takes an Eigen matrix by
173    copy or const reference, we can pass a numpy array that has negative strides.  Otherwise, an
174    exception will be thrown as Eigen will not be able to map the numpy array."""
175
176    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
177    counting_mat = counting_mat[::-1, ::-1]
178    second_row = counting_mat[1, :]
179    second_col = counting_mat[:, 1]
180    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
181    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
182    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
183    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
184    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
185    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
186
187    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
188    counting_3d = counting_3d[::-1, ::-1, ::-1]
189    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
190    for ref_mat in slices:
191        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
192        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
193
194    # Mutator:
195    with pytest.raises(TypeError) as excinfo:
196        m.double_threer(second_row)
197    assert (
198        msg(excinfo.value)
199        == """
200        double_threer(): incompatible function arguments. The following argument types are supported:
201            1. (arg0: numpy.ndarray[numpy.float32[1, 3], flags.writeable]) -> None
202
203        Invoked with: """  # noqa: E501 line too long
204        + repr(np.array([5.0, 4.0, 3.0], dtype="float32"))
205    )
206
207    with pytest.raises(TypeError) as excinfo:
208        m.double_threec(second_col)
209    assert (
210        msg(excinfo.value)
211        == """
212        double_threec(): incompatible function arguments. The following argument types are supported:
213            1. (arg0: numpy.ndarray[numpy.float32[3, 1], flags.writeable]) -> None
214
215        Invoked with: """  # noqa: E501 line too long
216        + repr(np.array([7.0, 4.0, 1.0], dtype="float32"))
217    )
218
219
220def test_nonunit_stride_to_python():
221    assert np.all(m.diagonal(ref) == ref.diagonal())
222    assert np.all(m.diagonal_1(ref) == ref.diagonal(1))
223    for i in range(-5, 7):
224        assert np.all(
225            m.diagonal_n(ref, i) == ref.diagonal(i)
226        ), "m.diagonal_n({})".format(i)
227
228    assert np.all(m.block(ref, 2, 1, 3, 3) == ref[2:5, 1:4])
229    assert np.all(m.block(ref, 1, 4, 4, 2) == ref[1:, 4:])
230    assert np.all(m.block(ref, 1, 4, 3, 2) == ref[1:4, 4:])
231
232
233def test_eigen_ref_to_python():
234    chols = [m.cholesky1, m.cholesky2, m.cholesky3, m.cholesky4]
235    for i, chol in enumerate(chols, start=1):
236        mymat = chol(np.array([[1.0, 2, 4], [2, 13, 23], [4, 23, 77]]))
237        assert np.all(
238            mymat == np.array([[1, 0, 0], [2, 3, 0], [4, 5, 6]])
239        ), "cholesky{}".format(i)
240
241
242def assign_both(a1, a2, r, c, v):
243    a1[r, c] = v
244    a2[r, c] = v
245
246
247def array_copy_but_one(a, r, c, v):
248    z = np.array(a, copy=True)
249    z[r, c] = v
250    return z
251
252
253def test_eigen_return_references():
254    """Tests various ways of returning references and non-referencing copies"""
255
256    master = np.ones((10, 10))
257    a = m.ReturnTester()
258    a_get1 = a.get()
259    assert not a_get1.flags.owndata and a_get1.flags.writeable
260    assign_both(a_get1, master, 3, 3, 5)
261    a_get2 = a.get_ptr()
262    assert not a_get2.flags.owndata and a_get2.flags.writeable
263    assign_both(a_get1, master, 2, 3, 6)
264
265    a_view1 = a.view()
266    assert not a_view1.flags.owndata and not a_view1.flags.writeable
267    with pytest.raises(ValueError):
268        a_view1[2, 3] = 4
269    a_view2 = a.view_ptr()
270    assert not a_view2.flags.owndata and not a_view2.flags.writeable
271    with pytest.raises(ValueError):
272        a_view2[2, 3] = 4
273
274    a_copy1 = a.copy_get()
275    assert a_copy1.flags.owndata and a_copy1.flags.writeable
276    np.testing.assert_array_equal(a_copy1, master)
277    a_copy1[7, 7] = -44  # Shouldn't affect anything else
278    c1want = array_copy_but_one(master, 7, 7, -44)
279    a_copy2 = a.copy_view()
280    assert a_copy2.flags.owndata and a_copy2.flags.writeable
281    np.testing.assert_array_equal(a_copy2, master)
282    a_copy2[4, 4] = -22  # Shouldn't affect anything else
283    c2want = array_copy_but_one(master, 4, 4, -22)
284
285    a_ref1 = a.ref()
286    assert not a_ref1.flags.owndata and a_ref1.flags.writeable
287    assign_both(a_ref1, master, 1, 1, 15)
288    a_ref2 = a.ref_const()
289    assert not a_ref2.flags.owndata and not a_ref2.flags.writeable
290    with pytest.raises(ValueError):
291        a_ref2[5, 5] = 33
292    a_ref3 = a.ref_safe()
293    assert not a_ref3.flags.owndata and a_ref3.flags.writeable
294    assign_both(a_ref3, master, 0, 7, 99)
295    a_ref4 = a.ref_const_safe()
296    assert not a_ref4.flags.owndata and not a_ref4.flags.writeable
297    with pytest.raises(ValueError):
298        a_ref4[7, 0] = 987654321
299
300    a_copy3 = a.copy_ref()
301    assert a_copy3.flags.owndata and a_copy3.flags.writeable
302    np.testing.assert_array_equal(a_copy3, master)
303    a_copy3[8, 1] = 11
304    c3want = array_copy_but_one(master, 8, 1, 11)
305    a_copy4 = a.copy_ref_const()
306    assert a_copy4.flags.owndata and a_copy4.flags.writeable
307    np.testing.assert_array_equal(a_copy4, master)
308    a_copy4[8, 4] = 88
309    c4want = array_copy_but_one(master, 8, 4, 88)
310
311    a_block1 = a.block(3, 3, 2, 2)
312    assert not a_block1.flags.owndata and a_block1.flags.writeable
313    a_block1[0, 0] = 55
314    master[3, 3] = 55
315    a_block2 = a.block_safe(2, 2, 3, 2)
316    assert not a_block2.flags.owndata and a_block2.flags.writeable
317    a_block2[2, 1] = -123
318    master[4, 3] = -123
319    a_block3 = a.block_const(6, 7, 4, 3)
320    assert not a_block3.flags.owndata and not a_block3.flags.writeable
321    with pytest.raises(ValueError):
322        a_block3[2, 2] = -44444
323
324    a_copy5 = a.copy_block(2, 2, 2, 3)
325    assert a_copy5.flags.owndata and a_copy5.flags.writeable
326    np.testing.assert_array_equal(a_copy5, master[2:4, 2:5])
327    a_copy5[1, 1] = 777
328    c5want = array_copy_but_one(master[2:4, 2:5], 1, 1, 777)
329
330    a_corn1 = a.corners()
331    assert not a_corn1.flags.owndata and a_corn1.flags.writeable
332    a_corn1 *= 50
333    a_corn1[1, 1] = 999
334    master[0, 0] = 50
335    master[0, 9] = 50
336    master[9, 0] = 50
337    master[9, 9] = 999
338    a_corn2 = a.corners_const()
339    assert not a_corn2.flags.owndata and not a_corn2.flags.writeable
340    with pytest.raises(ValueError):
341        a_corn2[1, 0] = 51
342
343    # All of the changes made all the way along should be visible everywhere
344    # now (except for the copies, of course)
345    np.testing.assert_array_equal(a_get1, master)
346    np.testing.assert_array_equal(a_get2, master)
347    np.testing.assert_array_equal(a_view1, master)
348    np.testing.assert_array_equal(a_view2, master)
349    np.testing.assert_array_equal(a_ref1, master)
350    np.testing.assert_array_equal(a_ref2, master)
351    np.testing.assert_array_equal(a_ref3, master)
352    np.testing.assert_array_equal(a_ref4, master)
353    np.testing.assert_array_equal(a_block1, master[3:5, 3:5])
354    np.testing.assert_array_equal(a_block2, master[2:5, 2:4])
355    np.testing.assert_array_equal(a_block3, master[6:10, 7:10])
356    np.testing.assert_array_equal(
357        a_corn1, master[0 :: master.shape[0] - 1, 0 :: master.shape[1] - 1]
358    )
359    np.testing.assert_array_equal(
360        a_corn2, master[0 :: master.shape[0] - 1, 0 :: master.shape[1] - 1]
361    )
362
363    np.testing.assert_array_equal(a_copy1, c1want)
364    np.testing.assert_array_equal(a_copy2, c2want)
365    np.testing.assert_array_equal(a_copy3, c3want)
366    np.testing.assert_array_equal(a_copy4, c4want)
367    np.testing.assert_array_equal(a_copy5, c5want)
368
369
370def assert_keeps_alive(cl, method, *args):
371    cstats = ConstructorStats.get(cl)
372    start_with = cstats.alive()
373    a = cl()
374    assert cstats.alive() == start_with + 1
375    z = method(a, *args)
376    assert cstats.alive() == start_with + 1
377    del a
378    # Here's the keep alive in action:
379    assert cstats.alive() == start_with + 1
380    del z
381    # Keep alive should have expired:
382    assert cstats.alive() == start_with
383
384
385def test_eigen_keepalive():
386    a = m.ReturnTester()
387    cstats = ConstructorStats.get(m.ReturnTester)
388    assert cstats.alive() == 1
389    unsafe = [a.ref(), a.ref_const(), a.block(1, 2, 3, 4)]
390    copies = [
391        a.copy_get(),
392        a.copy_view(),
393        a.copy_ref(),
394        a.copy_ref_const(),
395        a.copy_block(4, 3, 2, 1),
396    ]
397    del a
398    assert cstats.alive() == 0
399    del unsafe
400    del copies
401
402    for meth in [
403        m.ReturnTester.get,
404        m.ReturnTester.get_ptr,
405        m.ReturnTester.view,
406        m.ReturnTester.view_ptr,
407        m.ReturnTester.ref_safe,
408        m.ReturnTester.ref_const_safe,
409        m.ReturnTester.corners,
410        m.ReturnTester.corners_const,
411    ]:
412        assert_keeps_alive(m.ReturnTester, meth)
413
414    for meth in [m.ReturnTester.block_safe, m.ReturnTester.block_const]:
415        assert_keeps_alive(m.ReturnTester, meth, 4, 3, 2, 1)
416
417
418def test_eigen_ref_mutators():
419    """Tests Eigen's ability to mutate numpy values"""
420
421    orig = np.array([[1.0, 2, 3], [4, 5, 6], [7, 8, 9]])
422    zr = np.array(orig)
423    zc = np.array(orig, order="F")
424    m.add_rm(zr, 1, 0, 100)
425    assert np.all(zr == np.array([[1.0, 2, 3], [104, 5, 6], [7, 8, 9]]))
426    m.add_cm(zc, 1, 0, 200)
427    assert np.all(zc == np.array([[1.0, 2, 3], [204, 5, 6], [7, 8, 9]]))
428
429    m.add_any(zr, 1, 0, 20)
430    assert np.all(zr == np.array([[1.0, 2, 3], [124, 5, 6], [7, 8, 9]]))
431    m.add_any(zc, 1, 0, 10)
432    assert np.all(zc == np.array([[1.0, 2, 3], [214, 5, 6], [7, 8, 9]]))
433
434    # Can't reference a col-major array with a row-major Ref, and vice versa:
435    with pytest.raises(TypeError):
436        m.add_rm(zc, 1, 0, 1)
437    with pytest.raises(TypeError):
438        m.add_cm(zr, 1, 0, 1)
439
440    # Overloads:
441    m.add1(zr, 1, 0, -100)
442    m.add2(zr, 1, 0, -20)
443    assert np.all(zr == orig)
444    m.add1(zc, 1, 0, -200)
445    m.add2(zc, 1, 0, -10)
446    assert np.all(zc == orig)
447
448    # a non-contiguous slice (this won't work on either the row- or
449    # column-contiguous refs, but should work for the any)
450    cornersr = zr[0::2, 0::2]
451    cornersc = zc[0::2, 0::2]
452
453    assert np.all(cornersr == np.array([[1.0, 3], [7, 9]]))
454    assert np.all(cornersc == np.array([[1.0, 3], [7, 9]]))
455
456    with pytest.raises(TypeError):
457        m.add_rm(cornersr, 0, 1, 25)
458    with pytest.raises(TypeError):
459        m.add_cm(cornersr, 0, 1, 25)
460    with pytest.raises(TypeError):
461        m.add_rm(cornersc, 0, 1, 25)
462    with pytest.raises(TypeError):
463        m.add_cm(cornersc, 0, 1, 25)
464    m.add_any(cornersr, 0, 1, 25)
465    m.add_any(cornersc, 0, 1, 44)
466    assert np.all(zr == np.array([[1.0, 2, 28], [4, 5, 6], [7, 8, 9]]))
467    assert np.all(zc == np.array([[1.0, 2, 47], [4, 5, 6], [7, 8, 9]]))
468
469    # You shouldn't be allowed to pass a non-writeable array to a mutating Eigen method:
470    zro = zr[0:4, 0:4]
471    zro.flags.writeable = False
472    with pytest.raises(TypeError):
473        m.add_rm(zro, 0, 0, 0)
474    with pytest.raises(TypeError):
475        m.add_any(zro, 0, 0, 0)
476    with pytest.raises(TypeError):
477        m.add1(zro, 0, 0, 0)
478    with pytest.raises(TypeError):
479        m.add2(zro, 0, 0, 0)
480
481    # integer array shouldn't be passable to a double-matrix-accepting mutating func:
482    zi = np.array([[1, 2], [3, 4]])
483    with pytest.raises(TypeError):
484        m.add_rm(zi)
485
486
487def test_numpy_ref_mutators():
488    """Tests numpy mutating Eigen matrices (for returned Eigen::Ref<...>s)"""
489
490    m.reset_refs()  # In case another test already changed it
491
492    zc = m.get_cm_ref()
493    zcro = m.get_cm_const_ref()
494    zr = m.get_rm_ref()
495    zrro = m.get_rm_const_ref()
496
497    assert [zc[1, 2], zcro[1, 2], zr[1, 2], zrro[1, 2]] == [23] * 4
498
499    assert not zc.flags.owndata and zc.flags.writeable
500    assert not zr.flags.owndata and zr.flags.writeable
501    assert not zcro.flags.owndata and not zcro.flags.writeable
502    assert not zrro.flags.owndata and not zrro.flags.writeable
503
504    zc[1, 2] = 99
505    expect = np.array([[11.0, 12, 13], [21, 22, 99], [31, 32, 33]])
506    # We should have just changed zc, of course, but also zcro and the original eigen matrix
507    assert np.all(zc == expect)
508    assert np.all(zcro == expect)
509    assert np.all(m.get_cm_ref() == expect)
510
511    zr[1, 2] = 99
512    assert np.all(zr == expect)
513    assert np.all(zrro == expect)
514    assert np.all(m.get_rm_ref() == expect)
515
516    # Make sure the readonly ones are numpy-readonly:
517    with pytest.raises(ValueError):
518        zcro[1, 2] = 6
519    with pytest.raises(ValueError):
520        zrro[1, 2] = 6
521
522    # We should be able to explicitly copy like this (and since we're copying,
523    # the const should drop away)
524    y1 = np.array(m.get_cm_const_ref())
525
526    assert y1.flags.owndata and y1.flags.writeable
527    # We should get copies of the eigen data, which was modified above:
528    assert y1[1, 2] == 99
529    y1[1, 2] += 12
530    assert y1[1, 2] == 111
531    assert zc[1, 2] == 99  # Make sure we aren't referencing the original
532
533
534def test_both_ref_mutators():
535    """Tests a complex chain of nested eigen/numpy references"""
536
537    m.reset_refs()  # In case another test already changed it
538
539    z = m.get_cm_ref()  # numpy -> eigen
540    z[0, 2] -= 3
541    z2 = m.incr_matrix(z, 1)  # numpy -> eigen -> numpy -> eigen
542    z2[1, 1] += 6
543    z3 = m.incr_matrix(z, 2)  # (numpy -> eigen)^3
544    z3[2, 2] += -5
545    z4 = m.incr_matrix(z, 3)  # (numpy -> eigen)^4
546    z4[1, 1] -= 1
547    z5 = m.incr_matrix(z, 4)  # (numpy -> eigen)^5
548    z5[0, 0] = 0
549    assert np.all(z == z2)
550    assert np.all(z == z3)
551    assert np.all(z == z4)
552    assert np.all(z == z5)
553    expect = np.array([[0.0, 22, 20], [31, 37, 33], [41, 42, 38]])
554    assert np.all(z == expect)
555
556    y = np.array(range(100), dtype="float64").reshape(10, 10)
557    y2 = m.incr_matrix_any(y, 10)  # np -> eigen -> np
558    y3 = m.incr_matrix_any(
559        y2[0::2, 0::2], -33
560    )  # np -> eigen -> np slice -> np -> eigen -> np
561    y4 = m.even_rows(y3)  # numpy -> eigen slice -> (... y3)
562    y5 = m.even_cols(y4)  # numpy -> eigen slice -> (... y4)
563    y6 = m.incr_matrix_any(y5, 1000)  # numpy -> eigen -> (... y5)
564
565    # Apply same mutations using just numpy:
566    yexpect = np.array(range(100), dtype="float64").reshape(10, 10)
567    yexpect += 10
568    yexpect[0::2, 0::2] -= 33
569    yexpect[0::4, 0::4] += 1000
570    assert np.all(y6 == yexpect[0::4, 0::4])
571    assert np.all(y5 == yexpect[0::4, 0::4])
572    assert np.all(y4 == yexpect[0::4, 0::2])
573    assert np.all(y3 == yexpect[0::2, 0::2])
574    assert np.all(y2 == yexpect)
575    assert np.all(y == yexpect)
576
577
578def test_nocopy_wrapper():
579    # get_elem requires a column-contiguous matrix reference, but should be
580    # callable with other types of matrix (via copying):
581    int_matrix_colmajor = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], order="F")
582    dbl_matrix_colmajor = np.array(
583        int_matrix_colmajor, dtype="double", order="F", copy=True
584    )
585    int_matrix_rowmajor = np.array(int_matrix_colmajor, order="C", copy=True)
586    dbl_matrix_rowmajor = np.array(
587        int_matrix_rowmajor, dtype="double", order="C", copy=True
588    )
589
590    # All should be callable via get_elem:
591    assert m.get_elem(int_matrix_colmajor) == 8
592    assert m.get_elem(dbl_matrix_colmajor) == 8
593    assert m.get_elem(int_matrix_rowmajor) == 8
594    assert m.get_elem(dbl_matrix_rowmajor) == 8
595
596    # All but the second should fail with m.get_elem_nocopy:
597    with pytest.raises(TypeError) as excinfo:
598        m.get_elem_nocopy(int_matrix_colmajor)
599    assert "get_elem_nocopy(): incompatible function arguments." in str(
600        excinfo.value
601    ) and ", flags.f_contiguous" in str(excinfo.value)
602    assert m.get_elem_nocopy(dbl_matrix_colmajor) == 8
603    with pytest.raises(TypeError) as excinfo:
604        m.get_elem_nocopy(int_matrix_rowmajor)
605    assert "get_elem_nocopy(): incompatible function arguments." in str(
606        excinfo.value
607    ) and ", flags.f_contiguous" in str(excinfo.value)
608    with pytest.raises(TypeError) as excinfo:
609        m.get_elem_nocopy(dbl_matrix_rowmajor)
610    assert "get_elem_nocopy(): incompatible function arguments." in str(
611        excinfo.value
612    ) and ", flags.f_contiguous" in str(excinfo.value)
613
614    # For the row-major test, we take a long matrix in row-major, so only the third is allowed:
615    with pytest.raises(TypeError) as excinfo:
616        m.get_elem_rm_nocopy(int_matrix_colmajor)
617    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
618        excinfo.value
619    ) and ", flags.c_contiguous" in str(excinfo.value)
620    with pytest.raises(TypeError) as excinfo:
621        m.get_elem_rm_nocopy(dbl_matrix_colmajor)
622    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
623        excinfo.value
624    ) and ", flags.c_contiguous" in str(excinfo.value)
625    assert m.get_elem_rm_nocopy(int_matrix_rowmajor) == 8
626    with pytest.raises(TypeError) as excinfo:
627        m.get_elem_rm_nocopy(dbl_matrix_rowmajor)
628    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
629        excinfo.value
630    ) and ", flags.c_contiguous" in str(excinfo.value)
631
632
633def test_eigen_ref_life_support():
634    """Ensure the lifetime of temporary arrays created by the `Ref` caster
635
636    The `Ref` caster sometimes creates a copy which needs to stay alive. This needs to
637    happen both for directs casts (just the array) or indirectly (e.g. list of arrays).
638    """
639
640    a = np.full(shape=10, fill_value=8, dtype=np.int8)
641    assert m.get_elem_direct(a) == 8
642
643    list_of_a = [a]
644    assert m.get_elem_indirect(list_of_a) == 8
645
646
647def test_special_matrix_objects():
648    assert np.all(m.incr_diag(7) == np.diag([1.0, 2, 3, 4, 5, 6, 7]))
649
650    asymm = np.array([[1.0, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
651    symm_lower = np.array(asymm)
652    symm_upper = np.array(asymm)
653    for i in range(4):
654        for j in range(i + 1, 4):
655            symm_lower[i, j] = symm_lower[j, i]
656            symm_upper[j, i] = symm_upper[i, j]
657
658    assert np.all(m.symmetric_lower(asymm) == symm_lower)
659    assert np.all(m.symmetric_upper(asymm) == symm_upper)
660
661
662def test_dense_signature(doc):
663    assert (
664        doc(m.double_col)
665        == """
666        double_col(arg0: numpy.ndarray[numpy.float32[m, 1]]) -> numpy.ndarray[numpy.float32[m, 1]]
667    """
668    )
669    assert (
670        doc(m.double_row)
671        == """
672        double_row(arg0: numpy.ndarray[numpy.float32[1, n]]) -> numpy.ndarray[numpy.float32[1, n]]
673    """
674    )
675    assert doc(m.double_complex) == (
676        """
677        double_complex(arg0: numpy.ndarray[numpy.complex64[m, 1]])"""
678        """ -> numpy.ndarray[numpy.complex64[m, 1]]
679    """
680    )
681    assert doc(m.double_mat_rm) == (
682        """
683        double_mat_rm(arg0: numpy.ndarray[numpy.float32[m, n]])"""
684        """ -> numpy.ndarray[numpy.float32[m, n]]
685    """
686    )
687
688
689def test_named_arguments():
690    a = np.array([[1.0, 2], [3, 4], [5, 6]])
691    b = np.ones((2, 1))
692
693    assert np.all(m.matrix_multiply(a, b) == np.array([[3.0], [7], [11]]))
694    assert np.all(m.matrix_multiply(A=a, B=b) == np.array([[3.0], [7], [11]]))
695    assert np.all(m.matrix_multiply(B=b, A=a) == np.array([[3.0], [7], [11]]))
696
697    with pytest.raises(ValueError) as excinfo:
698        m.matrix_multiply(b, a)
699    assert str(excinfo.value) == "Nonconformable matrices!"
700
701    with pytest.raises(ValueError) as excinfo:
702        m.matrix_multiply(A=b, B=a)
703    assert str(excinfo.value) == "Nonconformable matrices!"
704
705    with pytest.raises(ValueError) as excinfo:
706        m.matrix_multiply(B=a, A=b)
707    assert str(excinfo.value) == "Nonconformable matrices!"
708
709
710def test_sparse():
711    pytest.importorskip("scipy")
712    assert_sparse_equal_ref(m.sparse_r())
713    assert_sparse_equal_ref(m.sparse_c())
714    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_r()))
715    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_c()))
716    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_c()))
717    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_r()))
718
719
720def test_sparse_signature(doc):
721    pytest.importorskip("scipy")
722    assert (
723        doc(m.sparse_copy_r)
724        == """
725        sparse_copy_r(arg0: scipy.sparse.csr_matrix[numpy.float32]) -> scipy.sparse.csr_matrix[numpy.float32]
726    """  # noqa: E501 line too long
727    )
728    assert (
729        doc(m.sparse_copy_c)
730        == """
731        sparse_copy_c(arg0: scipy.sparse.csc_matrix[numpy.float32]) -> scipy.sparse.csc_matrix[numpy.float32]
732    """  # noqa: E501 line too long
733    )
734
735
736def test_issue738():
737    """Ignore strides on a length-1 dimension (even if they would be incompatible length > 1)"""
738    assert np.all(m.iss738_f1(np.array([[1.0, 2, 3]])) == np.array([[1.0, 102, 203]]))
739    assert np.all(
740        m.iss738_f1(np.array([[1.0], [2], [3]])) == np.array([[1.0], [12], [23]])
741    )
742
743    assert np.all(m.iss738_f2(np.array([[1.0, 2, 3]])) == np.array([[1.0, 102, 203]]))
744    assert np.all(
745        m.iss738_f2(np.array([[1.0], [2], [3]])) == np.array([[1.0], [12], [23]])
746    )
747
748
749def test_issue1105():
750    """Issue 1105: 1xN or Nx1 input arrays weren't accepted for eigen
751    compile-time row vectors or column vector"""
752    assert m.iss1105_row(np.ones((1, 7)))
753    assert m.iss1105_col(np.ones((7, 1)))
754
755    # These should still fail (incompatible dimensions):
756    with pytest.raises(TypeError) as excinfo:
757        m.iss1105_row(np.ones((7, 1)))
758    assert "incompatible function arguments" in str(excinfo.value)
759    with pytest.raises(TypeError) as excinfo:
760        m.iss1105_col(np.ones((1, 7)))
761    assert "incompatible function arguments" in str(excinfo.value)
762
763
764def test_custom_operator_new():
765    """Using Eigen types as member variables requires a class-specific
766    operator new with proper alignment"""
767
768    o = m.CustomOperatorNew()
769    np.testing.assert_allclose(o.a, 0.0)
770    np.testing.assert_allclose(o.b.diagonal(), 1.0)
771