rene 0.2.0

Computational geometry.
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
107
108
109
110
111
112
113
114
115
116
117

use pyo3::exceptions::{PyIndexError, PyOverflowError};
use pyo3::PyErr;

pub(super) fn py_long_to_valid_index(
    value: pyo3::Bound<'_, pyo3::types::PyInt>,
    elements_count: usize,
) -> pyo3::PyResult<usize> {
    use pyo3::types::PyAnyMethods;
    if let Ok(index) = value.extract::<isize>() {
        let elements_count = elements_count as isize;
        if !(-elements_count <= index && index < elements_count) {
            Err(PyIndexError::new_err(format!(
                "Index {} is out of range({}, {}).",
                index, -elements_count, elements_count
            )))
        } else {
            Ok((if index < 0 {
                index + elements_count
            } else {
                index
            }) as usize)
        }
    } else {
        Err(PyIndexError::new_err(format!(
            "Index {} is out of index integer range({}, {}).",
            value.repr()?,
            isize::MIN,
            (isize::MAX as usize) + 1
        )))
    }
}

pub(super) fn normalize_index_start(
    start: Option<&pyo3::Bound<'_, pyo3::types::PyInt>>,
    elements_count: usize,
) -> usize {
    use pyo3::types::PyAnyMethods;
    start
        .map(|value| {
            value
                .extract::<isize>()
                .map(|value| {
                    (if value < 0 {
                        (value + (elements_count as isize)).max(0)
                    } else {
                        value
                    }) as usize
                })
                .unwrap_or(elements_count)
        })
        .unwrap_or(0usize)
}

pub(super) fn normalize_index_stop(
    start: Option<&pyo3::Bound<'_, pyo3::types::PyInt>>,
    elements_count: usize,
) -> usize {
    use pyo3::types::PyAnyMethods;
    start
        .map(|value| {
            value
                .extract::<isize>()
                .map(|value| {
                    (if value < 0 {
                        (value + (elements_count as isize)).max(0)
                    } else {
                        value
                    }) as usize
                })
                .unwrap_or(0)
        })
        .unwrap_or(elements_count)
}

pub(super) fn to_next_slice_indices(
    start: isize,
    step: isize,
    length: usize,
    slice: pyo3::Bound<'_, pyo3::types::PySlice>,
) -> Result<(isize, isize, isize), PyErr> {
    use pyo3::types::PySliceMethods;
    let indices = slice.indices(length as isize)?;
    let result_step = try_multiply_isizes(step, indices.step)?;
    let result_start =
        try_sum_isizes(start, try_multiply_isizes(step, indices.start)?)?;
    let result_stop =
        try_sum_isizes(start, try_multiply_isizes(step, indices.stop)?)?;
    Ok((result_start, result_stop, result_step))
}

fn try_multiply_isizes(first: isize, second: isize) -> pyo3::PyResult<isize> {
    if let (result, false) = first.overflowing_mul(second) {
        Ok(result)
    } else {
        Err(PyOverflowError::new_err(format!(
            "Multiplication of {} & {} is out of range({}, {}).",
            first,
            second,
            isize::MIN,
            (isize::MAX as usize) + 1,
        )))
    }
}

fn try_sum_isizes(first: isize, second: isize) -> pyo3::PyResult<isize> {
    if let (result, false) = first.overflowing_add(second) {
        Ok(result)
    } else {
        Err(PyOverflowError::new_err(format!(
            "Addition of {} & {} is out of range({}, {}).",
            first,
            second,
            isize::MIN,
            (isize::MAX as usize) + 1,
        )))
    }
}