nalgebra-numpy 0.1.2

conversions between nalgebra and numpy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

#![feature(proc_macro_hygiene)]

use inline_python::{python, Context};
use nalgebra_numpy::{Error, matrix_from_python};
use nalgebra::{U1, U2, U3};

#[macro_use]
mod assert;

#[test]
fn wrong_type() {
	let gil = pyo3::Python::acquire_gil();
	let py  = gil.python();
	let context = Context::new_with_gil(py).unwrap();

	python! {
		#![context = &context]
		float = 3.4
		int   = 8
		list  = [1.0, 2.0, 3.0]
	}

	let get_global = |name| context.globals(py).get_item(name).unwrap();

	assert_match!(Err(Error::WrongObjectType(_)) = matrix_from_python::<f64, U1, U1>(get_global("float")));
	assert_match!(Err(Error::WrongObjectType(_)) = matrix_from_python::<i32, U1, U1>(get_global("int")));
	assert_match!(Err(Error::WrongObjectType(_)) = matrix_from_python::<f64, U1, U3>(get_global("list")));
}

#[test]
fn wrong_shape() {
	let gil = pyo3::Python::acquire_gil();
	let py  = gil.python();
	let context = Context::new_with_gil(py).unwrap();

	python! {
		#![context = &context]
		import numpy as np
		matrix  = np.array([
			[1.0, 2.0, 3.0],
			[4.0, 5.0, 6.0],
		]);
	}

	let get_global = |name| context.globals(py).get_item(name).unwrap();

	assert_match!(Ok(_) = matrix_from_python::<f64, U2, U3>(get_global("matrix")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f64, U1, U1>(get_global("matrix")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f64, U3, U2>(get_global("matrix")));
}

#[test]
fn wrong_data_type() {
	let gil = pyo3::Python::acquire_gil();
	let py  = gil.python();
	let context = Context::new_with_gil(py).unwrap();

	python! {
		#![context = &context]
		import numpy as np
		matrix_f32 = np.array([[1.0]]).astype(np.float32);
		matrix_f64 = np.array([[1.0]]).astype(np.float64);
		matrix_i32 = np.array([[1]]).astype(np.int32);
		matrix_i64 = np.array([[1]]).astype(np.int64);
	}

	let get_global = |name| context.globals(py).get_item(name).unwrap();

	assert_match!(Ok(_) = matrix_from_python::<f32, U1, U1>(get_global("matrix_f32")));
	assert_match!(Ok(_) = matrix_from_python::<f64, U1, U1>(get_global("matrix_f64")));
	assert_match!(Ok(_) = matrix_from_python::<i32, U1, U1>(get_global("matrix_i32")));
	assert_match!(Ok(_) = matrix_from_python::<i64, U1, U1>(get_global("matrix_i64")));

	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f32, U1, U1>(get_global("matrix_f64")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f32, U1, U1>(get_global("matrix_i32")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f32, U1, U1>(get_global("matrix_i64")));

	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f64, U1, U1>(get_global("matrix_f32")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f64, U1, U1>(get_global("matrix_i32")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<f64, U1, U1>(get_global("matrix_i64")));

	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<i32, U1, U1>(get_global("matrix_f32")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<i32, U1, U1>(get_global("matrix_f64")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<i32, U1, U1>(get_global("matrix_i64")));

	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<i64, U1, U1>(get_global("matrix_f32")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<i64, U1, U1>(get_global("matrix_f64")));
	assert_match!(Err(Error::IncompatibleArray(_)) = matrix_from_python::<i64, U1, U1>(get_global("matrix_i32")));
}

#[test]
fn unaligned_data() {
	let gil = pyo3::Python::acquire_gil();
	let py  = gil.python();
	let context = Context::new_with_gil(py).unwrap();

	python! {
		#![context = &context]
		import numpy as np
		unaligned = np.array([range(8)], dtype=np.uint8)[:, 1:7].view(np.uint16)
	}

	let get_global = |name| context.globals(py).get_item(name).unwrap();

	assert_match!(Err(Error::UnalignedArray(_)) = matrix_from_python::<u16, U1, U3>(get_global("unaligned")));
}