sonolus.py 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

sonolus/script/interval.py

@@ -1,112 +1,120 @@
-from typing import Self
-
-from sonolus.backend.ops import Op
-from sonolus.script.debug import error
-from sonolus.script.internal.native import native_function
-from sonolus.script.record import Record
-
-
-class Interval(Record):
-    """A closed interval."""
-
-    start: float
-    end: float
-
-    @property
-    def length(self) -> float:
-        return self.end - self.start
-
-    @property
-    def is_empty(self) -> bool:
-        return self.start > self.end
-
-    @property
-    def mid(self) -> float:
-        return (self.start + self.end) / 2
-
-    @property
-    def tuple(self):
-        return self.start, self.end
-
-    def __contains__(self, item: Self | float | int) -> bool:
-        match item:
-            case Interval(start, end):
-                return self.start <= start and end <= self.end
-            case float() | int() as value:
-                return self.start <= value <= self.end
-            case _:
-                error("Invalid type for interval check")
-
-    def __add__(self, other: float | int) -> Self:
-        return Interval(self.start + other, self.end + other)
-
-    def __sub__(self, other: float | int) -> Self:
-        return Interval(self.start - other, self.end - other)
-
-    def __mul__(self, other: float | int) -> Self:
-        return Interval(self.start * other, self.end * other)
-
-    def __truediv__(self, other: float | int) -> Self:
-        return Interval(self.start / other, self.end / other)
-
-    def __floordiv__(self, other: float | int) -> Self:
-        return Interval(self.start // other, self.end // other)
-
-    def __and__(self, other: Self) -> Self:
-        return Interval(max(self.start, other.start), min(self.end, other.end))
-
-    def shrink(self, value: float | int) -> Self:
-        return Interval(self.start + value, self.end - value)
-
-    def expand(self, value: float | int) -> Self:
-        return Interval(self.start - value, self.end + value)
-
-    def lerp(self, x: float, /) -> float:
-        return lerp(self.start, self.end, x)
-
-    def lerp_clamped(self, x: float, /) -> float:
-        return lerp_clamped(self.start, self.end, x)
-
-    def unlerp(self, x: float, /) -> float:
-        return unlerp(self.start, self.end, x)
-
-    def unlerp_clamped(self, x: float, /) -> float:
-        return unlerp_clamped(self.start, self.end, x)
-
-    def clamp(self, x: float, /) -> float:
-        return clamp(x, self.start, self.end)
-
-
-@native_function(Op.Lerp)
-def lerp(a, b, x, /):
-    return a + (b - a) * x
-
-
-@native_function(Op.LerpClamped)
-def lerp_clamped(a, b, x, /):
-    return a + (b - a) * max(0, min(1, x))
-
-
-@native_function(Op.Unlerp)
-def unlerp(a, b, x, /):
-    return (x - a) / (b - a)
-
-
-@native_function(Op.UnlerpClamped)
-def unlerp_clamped(a, b, x, /):
-    return max(0, min(1, (x - a) / (b - a)))
-
-
-@native_function(Op.Remap)
-def remap(a, b, c, d, x, /):
-    return c + (d - c) * (x - a) / (b - a)
-
-
-@native_function(Op.RemapClamped)
-def remap_clamped(a, b, c, d, x, /):
-    return c + (d - c) * max(0, min(1, (x - a) / (b - a)))
-
-
-@native_function(Op.Clamp)
-def clamp(x, a, b, /):
-    return max(a, min(b, x))
+from typing import Self
+
+from sonolus.backend.ops import Op
+from sonolus.script.debug import error
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+
+
+class Interval(Record):
+    """A closed interval."""
+
+    start: float
+    end: float
+
+    @property
+    def length(self) -> float:
+        return self.end - self.start
+
+    @property
+    def is_empty(self) -> bool:
+        return self.start > self.end
+
+    @property
+    def mid(self) -> float:
+        return (self.start + self.end) / 2
+
+    @property
+    def tuple(self):
+        return self.start, self.end
+
+    def __contains__(self, item: Self | float | int) -> bool:
+        match item:
+            case Interval(start, end):
+                return self.start <= start and end <= self.end
+            case float() | int() as value:
+                return self.start <= value <= self.end
+            case _:
+                error("Invalid type for interval check")
+
+    def __add__(self, other: float | int) -> Self:
+        return Interval(self.start + other, self.end + other)
+
+    def __sub__(self, other: float | int) -> Self:
+        return Interval(self.start - other, self.end - other)
+
+    def __mul__(self, other: float | int) -> Self:
+        return Interval(self.start * other, self.end * other)
+
+    def __truediv__(self, other: float | int) -> Self:
+        return Interval(self.start / other, self.end / other)
+
+    def __floordiv__(self, other: float | int) -> Self:
+        return Interval(self.start // other, self.end // other)
+
+    def __and__(self, other: Self) -> Self:
+        return Interval(max(self.start, other.start), min(self.end, other.end))
+
+    def shrink(self, value: float | int) -> Self:
+        return Interval(self.start + value, self.end - value)
+
+    def expand(self, value: float | int) -> Self:
+        return Interval(self.start - value, self.end + value)
+
+    def lerp(self, x: float, /) -> float:
+        return lerp(self.start, self.end, x)
+
+    def lerp_clamped(self, x: float, /) -> float:
+        return lerp_clamped(self.start, self.end, x)
+
+    def unlerp(self, x: float, /) -> float:
+        return unlerp(self.start, self.end, x)
+
+    def unlerp_clamped(self, x: float, /) -> float:
+        return unlerp_clamped(self.start, self.end, x)
+
+    def clamp(self, x: float, /) -> float:
+        return clamp(x, self.start, self.end)
+
+
+@native_function(Op.Lerp)
+def lerp(a, b, x, /):
+    return a + (b - a) * x
+
+
+@native_function(Op.LerpClamped)
+def lerp_clamped(a, b, x, /):
+    return a + (b - a) * max(0, min(1, x))
+
+
+@native_function(Op.Unlerp)
+def unlerp(a, b, x, /):
+    return (x - a) / (b - a)
+
+
+@native_function(Op.UnlerpClamped)
+def unlerp_clamped(a, b, x, /):
+    return max(0, min(1, (x - a) / (b - a)))
+
+
+@native_function(Op.Remap)
+def remap(a, b, c, d, x, /):
+    return c + (d - c) * (x - a) / (b - a)
+
+
+@native_function(Op.RemapClamped)
+def remap_clamped(a, b, c, d, x, /):
+    return c + (d - c) * max(0, min(1, (x - a) / (b - a)))
+
+
+@native_function(Op.Clamp)
+def clamp(x, a, b, /):
+    return max(a, min(b, x))
+
+
+def generic_lerp[T](a: T, b: T, x: float, /) -> T:
+    return a + (b - a) * x
+
+
+def generic_lerp_clamped[T](a: T, b: T, x: float, /) -> T:
+    return a + (b - a) * max(0, min(1, x))

sonolus/script/iterator.py

@@ -1,211 +1,214 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from collections.abc import Collection, Iterator
-
-from sonolus.script.num import Num
-from sonolus.script.record import Record
-from sonolus.script.values import copy
-
-
-class SonolusIterator[T](Iterator[T]):
-    @abstractmethod
-    def has_next(self) -> bool:
-        raise NotImplementedError
-
-    @abstractmethod
-    def next(self) -> T:
-        raise NotImplementedError
-
-    def __next__(self) -> T:
-        if not self.has_next():
-            raise StopIteration
-        return self.next()
-
-
-class ArrayLike[T](Collection):
-    @abstractmethod
-    def size(self) -> int:
-        pass
-
-    @abstractmethod
-    def __getitem__(self, index: Num) -> T:
-        pass
-
-    @abstractmethod
-    def __setitem__(self, index: Num, value: T):
-        pass
-
-    def __len__(self) -> int:
-        return self.size()
-
-    def __iter__(self) -> SonolusIterator[T]:
-        return ArrayIterator(0, self)
-
-    def __contains__(self, value: T) -> bool:
-        i = 0
-        while i < self.size():
-            if self[i] == value:
-                return True
-            i += 1
-        return False
-
-    def reversed(self) -> ArrayLike[T]:
-        return ArrayReverser(self)
-
-    def iter(self) -> SonolusIterator[T]:
-        return self.__iter__()  # noqa: PLC2801
-
-    def enumerate(self, start: Num = 0) -> SonolusIterator[T]:
-        return ArrayEnumerator(0, start, self)
-
-    def index_of(self, value: T, start: Num = 0) -> Num:
-        i = start
-        while i < self.size():
-            if self[i] == value:
-                return i
-            i += 1
-        return -1
-
-    def last_index_of(self, value: T) -> Num:
-        i = self.size() - 1
-        while i >= 0:
-            if self[i] == value:
-                return i
-            i -= 1
-        return -1
-
-    def index_of_max(self) -> Num:
-        if self.size() == 0:
-            return -1
-        max_index = 0
-        i = 1
-        while i < self.size():
-            if self[i] > self[max_index]:
-                max_index = i
-            i += 1
-        return max_index
-
-    def index_of_min(self) -> Num:
-        if self.size() == 0:
-            return -1
-        min_index = 0
-        i = 1
-        while i < self.size():
-            if self[i] < self[min_index]:
-                min_index = i
-            i += 1
-        return min_index
-
-    def max(self) -> T:
-        return self[self.index_of_max()]
-
-    def min(self) -> T:
-        return self[self.index_of_min()]
-
-    def swap(self, i: Num, j: Num):
-        temp = copy(self[i])
-        self[i] = self[j]
-        self[j] = temp
-
-    def sort(self, *, reverse: bool = False):
-        if self.size() < 15:
-            _insertion_sort(self, 0, self.size(), reverse)
-        else:
-            _heap_sort(self, 0, self.size(), reverse)
-
-
-def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
-    i = start + 1
-    while i < end:
-        value = copy(array[i])
-        j = i - 1
-        while j >= start and (array[j] > value) != reverse:
-            array[j + 1] = array[j]
-            j -= 1
-        array[j + 1] = value
-        i += 1
-
-
-def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
-    while True:
-        left = index * 2 + 1
-        right = left + 1
-        largest = index
-        if left < end and (array[left] > array[largest]) != reverse:
-            largest = left
-        if right < end and (array[right] > array[largest]) != reverse:
-            largest = right
-        if largest == index:
-            break
-        array.swap(index, largest)
-        index = largest
-
-
-# Heap sort is simple to implement iteratively without dynamic memory allocation
-def _heap_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
-    i = end // 2 - 1
-    while i >= start:
-        _heapify(array, end, i, reverse)
-        i -= 1
-    i = end - 1
-    while i > start:
-        array.swap(start, i)
-        _heapify(array, i, start, reverse)
-        i -= 1
-
-
-class ArrayIterator[V: ArrayLike](Record, SonolusIterator):
-    i: int
-    array: V
-
-    def has_next(self) -> bool:
-        return self.i < self.array.size()
-
-    def next(self) -> V:
-        value = self.array[self.i]
-        self.i += 1
-        return value
-
-
-class ArrayReverser[V: ArrayLike](Record, ArrayLike):
-    array: V
-
-    def size(self) -> int:
-        return self.array.size()
-
-    def __getitem__(self, index: Num) -> V:
-        return self.array[self.size() - 1 - index]
-
-    def __setitem__(self, index: Num, value: V):
-        self.array[self.size() - 1 - index] = value
-
-
-class Enumerator[V: SonolusIterator](Record, SonolusIterator):
-    i: int
-    offset: int
-    iterator: V
-
-    def has_next(self) -> bool:
-        return self.iterator.has_next()
-
-    def next(self):
-        value = self.iterator.next()
-        index = self.i + self.offset
-        self.i += 1
-        return index, value
-
-
-class ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
-    i: int
-    offset: int
-    array: V
-
-    def has_next(self) -> bool:
-        return self.i < self.array.size()
-
-    def next(self):
-        value = self.array[self.i]
-        index = self.i + self.offset
-        self.i += 1
-        return index, value
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Collection, Iterator
+
+from sonolus.script.num import Num
+from sonolus.script.record import Record
+from sonolus.script.values import copy
+
+
+class SonolusIterator[T](Iterator[T]):
+    @abstractmethod
+    def has_next(self) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def next(self) -> T:
+        raise NotImplementedError
+
+    def __next__(self) -> T:
+        if not self.has_next():
+            raise StopIteration
+        return self.next()
+
+
+class ArrayLike[T](Collection):
+    @abstractmethod
+    def size(self) -> int:
+        pass
+
+    @abstractmethod
+    def __getitem__(self, index: Num) -> T:
+        pass
+
+    @abstractmethod
+    def __setitem__(self, index: Num, value: T):
+        pass
+
+    def __len__(self) -> int:
+        return self.size()
+
+    def __iter__(self) -> SonolusIterator[T]:
+        return ArrayIterator(0, self)
+
+    def __contains__(self, value: T) -> bool:
+        i = 0
+        while i < self.size():
+            if self[i] == value:
+                return True
+            i += 1
+        return False
+
+    def reversed(self) -> ArrayLike[T]:
+        return ArrayReverser(self)
+
+    def iter(self) -> SonolusIterator[T]:
+        return self.__iter__()  # noqa: PLC2801
+
+    def enumerate(self, start: Num = 0) -> SonolusIterator[T]:
+        return ArrayEnumerator(0, start, self)
+
+    def index_of(self, value: T, start: Num = 0) -> Num:
+        i = start
+        while i < self.size():
+            if self[i] == value:
+                return i
+            i += 1
+        return -1
+
+    def last_index_of(self, value: T) -> Num:
+        i = self.size() - 1
+        while i >= 0:
+            if self[i] == value:
+                return i
+            i -= 1
+        return -1
+
+    def index_of_max(self) -> Num:
+        if self.size() == 0:
+            return -1
+        max_index = 0
+        i = 1
+        while i < self.size():
+            if self[i] > self[max_index]:
+                max_index = i
+            i += 1
+        return max_index
+
+    def index_of_min(self) -> Num:
+        if self.size() == 0:
+            return -1
+        min_index = 0
+        i = 1
+        while i < self.size():
+            if self[i] < self[min_index]:
+                min_index = i
+            i += 1
+        return min_index
+
+    def max(self) -> T:
+        return self[self.index_of_max()]
+
+    def min(self) -> T:
+        return self[self.index_of_min()]
+
+    def swap(self, i: Num, j: Num):
+        temp = copy(self[i])
+        self[i] = self[j]
+        self[j] = temp
+
+    def sort(self, *, reverse: bool = False):
+        if self.size() < 15:
+            _insertion_sort(self, 0, self.size(), reverse)
+        else:
+            _heap_sort(self, 0, self.size(), reverse)
+
+
+def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
+    i = start + 1
+    while i < end:
+        value = copy(array[i])
+        j = i - 1
+        while j >= start and (array[j] > value) != reverse:
+            array[j + 1] = array[j]
+            j -= 1
+        array[j + 1] = value
+        i += 1
+
+
+def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
+    while True:
+        left = index * 2 + 1
+        right = left + 1
+        largest = index
+        if left < end and (array[left] > array[largest]) != reverse:
+            largest = left
+        if right < end and (array[right] > array[largest]) != reverse:
+            largest = right
+        if largest == index:
+            break
+        array.swap(index, largest)
+        index = largest
+
+
+# Heap sort is simple to implement iteratively without dynamic memory allocation
+def _heap_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
+    i = end // 2 - 1
+    while i >= start:
+        _heapify(array, end, i, reverse)
+        i -= 1
+    i = end - 1
+    while i > start:
+        array.swap(start, i)
+        _heapify(array, i, start, reverse)
+        i -= 1
+
+
+class ArrayIterator[V: ArrayLike](Record, SonolusIterator):
+    i: int
+    array: V
+
+    def has_next(self) -> bool:
+        return self.i < self.array.size()
+
+    def next(self) -> V:
+        value = self.array[self.i]
+        self.i += 1
+        return value
+
+
+class ArrayReverser[V: ArrayLike](Record, ArrayLike):
+    array: V
+
+    def size(self) -> int:
+        return self.array.size()
+
+    def __getitem__(self, index: Num) -> V:
+        return self.array[self.size() - 1 - index]
+
+    def __setitem__(self, index: Num, value: V):
+        self.array[self.size() - 1 - index] = value
+
+    def reversed(self) -> ArrayLike[V]:
+        return self.array
+
+
+class Enumerator[V: SonolusIterator](Record, SonolusIterator):
+    i: int
+    offset: int
+    iterator: V
+
+    def has_next(self) -> bool:
+        return self.iterator.has_next()
+
+    def next(self):
+        value = self.iterator.next()
+        index = self.i + self.offset
+        self.i += 1
+        return index, value
+
+
+class ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
+    i: int
+    offset: int
+    array: V
+
+    def has_next(self) -> bool:
+        return self.i < self.array.size()
+
+    def next(self):
+        value = self.array[self.i]
+        index = self.i + self.offset
+        self.i += 1
+        return index, value