naw 0.0.1__py3-none-any.whl

naw/_bfloat16.pyi

@@ -0,0 +1,13 @@
+import collections.abc
+
+def write_bfloat16_array(data: collections.abc.Iterable[float]) -> list[int]: ...
+def write_bfloat16_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_bfloat16_array(data: bytes, n: int) -> tuple[int, list[float]]: ...
+def read_bfloat16_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw/_float16.pyi

@@ -0,0 +1,11 @@
+import collections.abc
+
+def write_float16_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_float16_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw/_float32.pyi

@@ -0,0 +1,11 @@
+import collections.abc
+
+def write_float32_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_float32_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw/_float64.pyi

@@ -0,0 +1,11 @@
+import collections.abc
+
+def write_float64_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_float64_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw/_leb.pyi

@@ -0,0 +1,6 @@
+import collections.abc
+
+def read_unsigned_array(data: bytes, n: int) -> tuple[int, list[int]]: ...
+def read_signed_array(data: bytes, n: int) -> tuple[int, list[int]]: ...
+def write_unsigned_array(data: collections.abc.Iterable[int]) -> list[int]: ...
+def write_signed_array(data: collections.abc.Iterable[int]) -> list[int]: ...

naw/bench_bfloat16.py

@@ -0,0 +1,69 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import bfloat16
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_bf16_data = bytes(bfloat16.write_bfloat16_array(_float_values))
+_bf16_xor_data = bytes(
+    bfloat16.write_bfloat16_xor_array(_float_values, _float_prev_values)
+)
+
+
+def test_py_write_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: bfloat16.write_bfloat16_array(_float_values))
+
+
+def test_py_read_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: bfloat16.read_bfloat16_array(_bf16_data, N))
+
+
+def test_py_write_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: bfloat16.write_bfloat16_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: bfloat16.read_bfloat16_xor_array(_bf16_xor_data, N, _float_prev_values)
+    )
+
+
+def test_cy_write_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.write_bfloat16_array(_float_values))
+
+
+def test_cy_read_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.read_bfloat16_array(_bf16_data, N))
+
+
+def test_cy_write_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.write_bfloat16_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.read_bfloat16_xor_array(_bf16_xor_data, N, _float_prev_values))

naw/bench_byteio.py

@@ -0,0 +1,241 @@
+import pytest_benchmark.fixture
+
+from . import byteio
+
+N = 1000
+
+_int_values = list(range(N))
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+
+
+def test_write_sleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_sleb_array(_int_values)
+
+    benchmark(run)
+
+
+def test_read_sleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    w = byteio.Writer()
+    w.write_sleb_array(_int_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_sleb_array(N)
+
+    benchmark(run)
+
+
+def test_write_uleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_uleb_array(_int_values)
+
+    benchmark(run)
+
+
+def test_read_uleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    w = byteio.Writer()
+    w.write_uleb_array(_int_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_uleb_array(N)
+
+    benchmark(run)
+
+
+def test_write_float16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float16_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_float16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float16_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float16_array(N)
+
+    benchmark(run)
+
+
+def test_write_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float16_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float16_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float16_xor_array(N, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_write_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_bfloat16_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_bfloat16_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_bfloat16_array(N)
+
+    benchmark(run)
+
+
+def test_write_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_bfloat16_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_bfloat16_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_bfloat16_xor_array(N, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_write_float32_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float32_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_float32_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float32_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float32_array(N)
+
+    benchmark(run)
+
+
+def test_write_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float32_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float32_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float32_xor_array(N, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_write_float64_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float64_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_float64_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float64_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float64_array(N)
+
+    benchmark(run)
+
+
+def test_write_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float64_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float64_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float64_xor_array(N, _float_prev_values)
+
+    benchmark(run)

naw/bench_float16.py

@@ -0,0 +1,38 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import float16
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_xor_data = bytes(float16.write_float16_xor_array(_float_values, _float_prev_values))
+
+
+def test_py_write_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: float16.write_float16_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: float16.read_float16_xor_array(_xor_data, N, _float_prev_values))
+
+
+def test_cy_write_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float16")
+    benchmark(lambda: cy.write_float16_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float16")
+    benchmark(lambda: cy.read_float16_xor_array(_xor_data, N, _float_prev_values))

naw/bench_float32.py

@@ -0,0 +1,38 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import float32
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_xor_data = bytes(float32.write_float32_xor_array(_float_values, _float_prev_values))
+
+
+def test_py_write_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: float32.write_float32_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: float32.read_float32_xor_array(_xor_data, N, _float_prev_values))
+
+
+def test_cy_write_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float32")
+    benchmark(lambda: cy.write_float32_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float32")
+    benchmark(lambda: cy.read_float32_xor_array(_xor_data, N, _float_prev_values))

naw/bench_float64.py

@@ -0,0 +1,38 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import float64
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_xor_data = bytes(float64.write_float64_xor_array(_float_values, _float_prev_values))
+
+
+def test_py_write_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: float64.write_float64_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: float64.read_float64_xor_array(_xor_data, N, _float_prev_values))
+
+
+def test_cy_write_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float64")
+    benchmark(lambda: cy.write_float64_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float64")
+    benchmark(lambda: cy.read_float64_xor_array(_xor_data, N, _float_prev_values))

naw/bench_leb.py

@@ -0,0 +1,62 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import leb
+
+N = 1000
+
+_int_values = list(range(N))
+_uleb_data = bytes(leb.write_unsigned_array(_int_values))
+_sleb_data = bytes(leb.write_signed_array(_int_values))
+
+
+def test_py_write_uleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: leb.write_unsigned_array(_int_values))
+
+
+def test_py_read_uleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: leb.read_unsigned_array(_uleb_data, N))
+
+
+def test_py_write_sleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: leb.write_signed_array(_int_values))
+
+
+def test_py_read_sleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: leb.read_signed_array(_sleb_data, N))
+
+
+def test_cy_write_uleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._leb")
+    benchmark(lambda: cy.write_unsigned_array(_int_values))
+
+
+def test_cy_read_uleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._leb")
+    benchmark(lambda: cy.read_unsigned_array(_uleb_data, N))
+
+
+def test_cy_write_sleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._leb")
+    benchmark(lambda: cy.write_signed_array(_int_values))
+
+
+def test_cy_read_sleb_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._leb")
+    benchmark(lambda: cy.read_signed_array(_sleb_data, N))

naw/bfloat16.py

@@ -0,0 +1,53 @@
+import collections.abc
+import struct
+
+try:
+    from . import _leb as leb
+except ImportError:
+    from . import leb
+
+
+def write_bfloat16_array(values: collections.abc.Iterable[float]) -> list[int]:
+    result: list[int] = []
+    for v in values:
+        packed = struct.pack(">f", v)
+        result.append(packed[0])
+        result.append(packed[1])
+    return result
+
+
+def write_bfloat16_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]:
+    xored = [
+        struct.unpack(">H", struct.pack(">f", v)[:2])[0]
+        ^ struct.unpack(">H", struct.pack(">f", p)[:2])[0]
+        for v, p in zip(values, previous_values)
+    ]
+    return leb.write_unsigned_array(xored)
+
+
+def read_bfloat16_array(data: bytes, n: int) -> tuple[int, list[float]]:
+    result: list[float] = []
+    offset = 0
+    for _ in range(n):
+        v = struct.unpack(">f", data[offset : offset + 2] + b"\x00\x00")[0]
+        result.append(v)
+        offset += 2
+    return offset, result
+
+
+def read_bfloat16_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]:
+    offset, xored_current = leb.read_unsigned_array(data, n)
+    result: list[float] = []
+    for c, p in zip(xored_current, previous_values):
+        prev_bits = struct.unpack(">H", struct.pack(">f", p)[:2])[0]
+        curr_bits = c ^ prev_bits
+        v = struct.unpack(">f", struct.pack(">H", curr_bits) + b"\x00\x00")[0]
+        result.append(v)
+    return offset, result