adaptive-triangulation/python/adaptive_triangulation/_rust.pyi at a2745e65351f2e308a7749da67e5b6e19c2aea93 · python-adaptive/adaptive-triangulation · GitHub

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
118
119
120
121
122
123
124
125
126
127
from collections.abc import Iterable, Iterator, Sequence
from typing import TypeAlias

import numpy as np
import numpy.typing as npt

PointLike: TypeAlias = Sequence[float] | npt.ArrayLike
PointsLike: TypeAlias = Sequence[Sequence[float]] | npt.ArrayLike
SimplexLike: TypeAlias = Sequence[int]
Simplex: TypeAlias = tuple[int, ...]
SimplexSet: TypeAlias = set[Simplex]
CircumscribedCircle: TypeAlias = tuple[tuple[float, ...], float]
TransformLike: TypeAlias = Sequence[Sequence[float]] | npt.ArrayLike

__version__: str

class SimplicesProxy:
    def __contains__(self, simplex: Simplex) -> bool: ...
    def __iter__(self) -> Iterator[Simplex]: ...
    def __len__(self) -> int: ...

class VerticesProxy:
    def __getitem__(self, index: int) -> tuple[float, ...]: ...
    def __iter__(self) -> Iterator[tuple[float, ...]]: ...
    def __len__(self) -> int: ...

class VertexToSimplicesProxy:
    def __getitem__(self, index: int) -> SimplexSet: ...
    def __iter__(self) -> Iterator[SimplexSet]: ...
    def __len__(self) -> int: ...

class Triangulation:
    def __init__(self, coords: PointsLike) -> None: ...
    @property
    def vertices(self) -> VerticesProxy: ...
    @property
    def simplices(self) -> SimplicesProxy: ...
    @property
    def vertex_to_simplices(self) -> VertexToSimplicesProxy: ...
    @property
    def hull(self) -> set[int]: ...
    @property
    def dim(self) -> int: ...
    @property
    def default_transform(self) -> npt.NDArray[np.float64]: ...
    def add_simplex(self, simplex: SimplexLike) -> None: ...
    def delete_simplex(self, simplex: SimplexLike) -> None: ...
    def has_simplex(self, simplex: Simplex) -> bool: ...
    def add_point(
        self,
        point: PointLike,
        simplex: SimplexLike | None = None,
        transform: TransformLike | None = None,
    ) -> tuple[SimplexSet, SimplexSet]: ...
    def get_vertices(self, indices: Sequence[int]) -> list[tuple[float, ...]]: ...
    def locate_point(self, point: PointLike) -> tuple[int, ...]: ...
    def get_reduced_simplex(
        self,
        point: PointLike,
        simplex: SimplexLike,
        eps: float = 1e-8,
    ) -> list[int]: ...
    def circumscribed_circle(
        self,
        simplex: SimplexLike,
        transform: TransformLike | None = None,
    ) -> CircumscribedCircle: ...
    def point_in_circumcircle(
        self,
        pt_index: int,
        simplex: SimplexLike,
        transform: TransformLike | None = None,
    ) -> bool: ...
    def point_in_cicumcircle(
        self,
        pt_index: int,
        simplex: SimplexLike,
        transform: TransformLike | None = None,
    ) -> bool: ...
    def volume(self, simplex: SimplexLike) -> float: ...
    def volumes(self) -> list[float]: ...
    def faces(
        self,
        dim: int | None = None,
        simplices: Iterable[SimplexLike] | None = None,
        vertices: Iterable[int] | None = None,
    ) -> Iterator[Simplex]: ...
    def containing(self, face: Sequence[int]) -> SimplexSet: ...
    def reference_invariant(self) -> bool: ...
    def vertex_to_simplices_for(self, vertex: int) -> SimplicesProxy: ...
    def point_in_simplex(
        self,
        point: PointLike,
        simplex: SimplexLike,
        eps: float = 1e-8,
    ) -> bool: ...
    def simplices_containing(
        self,
        point: PointLike,
        simplex: SimplexLike | None = None,
        candidates: Iterable[SimplexLike] | None = None,
        eps: float = 1e-8,
    ) -> list[Simplex]: ...
    def bowyer_watson(
        self,
        pt_index: int,
        containing_simplex: SimplexLike | None = None,
        transform: TransformLike | None = None,
    ) -> tuple[SimplexSet, SimplexSet]: ...
    def vertex_invariant(self, vertex: int) -> bool: ...
    def convex_invariant(self, vertex: int) -> bool: ...

def circumsphere(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
def default_loss(
    simplex: PointsLike,
    values: Sequence[float] | PointsLike,
    value_scale: float | None = None,
) -> float: ...
def fast_2d_circumcircle(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
def fast_2d_point_in_simplex(point: PointLike, simplex: PointsLike, eps: float = 1e-8) -> bool: ...
def fast_3d_circumcircle(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
def fast_3d_circumsphere(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
def fast_norm(point: PointLike) -> float: ...
def orientation(face: PointsLike, origin: PointLike) -> int: ...
def point_in_simplex(point: PointLike, simplex: PointsLike, eps: float = 1e-8) -> bool: ...
def simplex_volume_in_embedding(vertices: PointsLike) -> float: ...
def volume(simplex: PointsLike) -> float: ...