zeck 0.1.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Ryszkiewicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,285 @@
+# Zeckendorf Compression
+
+A Rust library for compressing and decompressing data using the Zeckendorf representation algorithm.
+
+## Overview
+
+The Zeckendorf algorithm represents numbers as a sum of non-consecutive Fibonacci numbers. This library interprets input data as a big integer (either big-endian or little-endian), converts it to its Zeckendorf representation, and sometimes achieves compression. However, compression is not guaranteed; the algorithm may result in a larger representation depending on the input data. The library can automatically try both endian interpretations and select the one that produces the best compression.
+
+## Features
+
+- **Compression & Decompression**: Convert data to/from Zeckendorf representation
+- **Multiple Endian Interpretations**: Support for both big-endian and little-endian input interpretations
+- **Automatic Best Compression**: Try both endian interpretations and automatically select the best result
+- **Multiple Fibonacci Algorithms**: 
+  - Slow recursive (memoized, for small numbers)
+  - Slow iterative (memoized, for large numbers)
+  - Fast Doubling (optimized, ~160x faster for large indices)
+- **BigInt Support**: Handle arbitrarily large numbers using `num-bigint`
+- **Memoization**: Thread-safe caching for improved performance
+- **Statistics & Visualization**: Generate compression statistics and plots
+- **Benchmarking**: Comprehensive performance benchmarks
+- **WebAssembly Support**: Available as a WebAssembly module for use in web browsers
+
+## WebAssembly
+
+This library is also available as a WebAssembly module for use in web browsers. Available functions are marked with the `#[wasm_bindgen]` attribute. The WebAssembly module can be built using the convenience script at `scripts/build_wasm_bundle.sh` that builds the WebAssembly module with the `wasm-pack` tool.
+
+You can see a live demo of the WebAssembly module in action at <https://prizz.github.io/zeckendorf-webapp/>. The source code for the demo is available at <https://github.com/pRizz/zeckendorf-webapp>.
+
+## Installation
+
+### Install from crates.io
+
+Run:
+```bash
+cargo add zeckendorf
+```
+
+Or add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+zeckendorf = "0.1.0"
+```
+
+For plotting features:
+
+```toml
+[dependencies]
+zeckendorf = { version = "0.1.0", features = ["plotting"] }
+```
+
+### Install from GitHub (development version)
+
+Run:
+```bash
+cargo add zeckendorf --git https://github.com/pRizz/zeckendorf
+```
+
+Or add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+zeckendorf = { git = "https://github.com/pRizz/zeckendorf" }
+```
+
+For plotting features:
+
+```toml
+[dependencies]
+zeckendorf = { git = "https://github.com/pRizz/zeckendorf", features = ["plotting"] }
+```
+
+## Usage
+
+### Basic Compression/Decompression
+
+#### Big-Endian Interpretation
+
+```rust
+use zeckendorf_rs::{zeckendorf_compress_be, zeckendorf_decompress_be};
+
+// Compress data (interpreted as big-endian integer)
+let data = vec![12u8];
+let compressed = zeckendorf_compress_be(&data);
+
+// Decompress data
+let decompressed = zeckendorf_decompress_be(&compressed);
+assert_eq!(data, decompressed);
+```
+
+#### Little-Endian Interpretation
+
+```rust
+use zeckendorf_rs::{zeckendorf_compress_le, zeckendorf_decompress_le};
+
+// Compress data (interpreted as little-endian integer)
+let data = vec![12u8];
+let compressed = zeckendorf_compress_le(&data);
+
+// Decompress data
+let decompressed = zeckendorf_decompress_le(&compressed);
+assert_eq!(data, decompressed);
+```
+
+#### Automatic Best Compression
+
+```rust
+use zeckendorf_rs::{zeckendorf_compress_best, zeckendorf_decompress_be, zeckendorf_decompress_le, CompressionResult};
+
+// Try both endian interpretations and get the best result
+let data = vec![1, 0];
+let result = zeckendorf_compress_best(&data);
+
+match result {
+    CompressionResult::BigEndianBest { compressed_data, le_size } => {
+        // Big-endian produced the best compression
+        let decompressed = zeckendorf_decompress_be(&compressed_data);
+        assert_eq!(data, decompressed);
+    }
+    CompressionResult::LittleEndianBest { compressed_data, be_size } => {
+        // Little-endian produced the best compression
+        let decompressed = zeckendorf_decompress_le(&compressed_data);
+        assert_eq!(data, decompressed);
+    }
+    CompressionResult::Neither { be_size, le_size } => {
+        // Neither method compressed the data (both were larger than original)
+        println!("Neither method compressed: BE size = {}, LE size = {}", be_size, le_size);
+    }
+}
+```
+
+### Fibonacci Numbers
+
+```rust
+use zeckendorf_rs::memoized_slow_fibonacci_recursive;
+
+// Calculate Fibonacci numbers (for indices up to 93)
+let fib_10 = memoized_slow_fibonacci_recursive(10); // Returns 55
+
+// For larger numbers, use BigInt versions
+use zeckendorf_rs::fast_doubling_fibonacci_bigint;
+let fib_100 = fast_doubling_fibonacci_bigint(100);
+```
+
+### Zeckendorf Representation
+
+```rust
+use zeckendorf_rs::memoized_zeckendorf_list_descending_for_integer;
+
+// Get Zeckendorf representation as a list of Fibonacci indices
+let zld = memoized_zeckendorf_list_descending_for_integer(12);
+// Returns [6, 4, 2] meaning F(6) + F(4) + F(2) = 8 + 3 + 1 = 12
+```
+
+## Binaries
+
+The project includes several utility binaries:
+
+### Main Playground
+
+```bash
+cargo run --release --bin zeckendorf
+```
+
+A playground/scratchpad for testing library functions.
+
+### Generate Test Data
+
+```bash
+cargo run --release --bin generate_data <size_in_bytes> [filename]
+```
+
+Generates random test data files in the `generated_data/` directory.
+
+Example:
+```bash
+cargo run --release --bin generate_data 1024 my_file.bin
+```
+
+### Generate Statistics
+
+```bash
+cargo run --release --bin generate_statistics --features plotting
+```
+
+Generates comprehensive compression statistics and plots:
+- Compression ratios across different input sizes
+- Chance of compression being favorable
+- Average and median compression ratios
+- Statistics saved to `statistics_history/` directory
+- Plots saved to `plots/` directory
+
+### Plot Compression Ratios
+
+```bash
+cargo run --release --bin plot --features plotting
+```
+
+Generates visualization plots of:
+- Fibonacci numbers
+- Compression ratios for various input ranges
+
+## Benchmarks
+
+### Zeckendorf Compression Benchmarks
+
+```bash
+cargo bench --bench zeckendorf_bench
+```
+
+Benchmarks compression, decompression, and round-trip performance for various data sizes (4 bytes to 16KB).
+
+### Fibonacci Benchmarks
+
+```bash
+cargo bench --bench fibonacci_bench
+```
+
+Compares performance of different Fibonacci calculation algorithms:
+- Slow iterative method
+- Fast doubling method (~160x faster for large indices)
+
+### Working with Benchmark Baselines
+
+Save a new baseline:
+```bash
+cargo bench --bench zeckendorf_bench -- --save-baseline <name>
+```
+
+Compare to an existing baseline:
+```bash
+cargo bench --bench zeckendorf_bench -- --baseline <name>
+```
+
+## Performance Characteristics
+
+- **Fast Doubling Fibonacci**: ~160x faster than iterative method for the 100,000th Fibonacci number
+- **Memoization**: Thread-safe caching significantly improves repeated calculations. The trade-off is that the cache takes up memory.
+- **Compression Effectiveness**: Varies by input; compression ratios oscillate and become less favorable as input size increases
+
+## Algorithm Details
+
+### Zeckendorf Representation
+
+Every positive integer can be uniquely represented as a sum of non-consecutive Fibonacci numbers. For example:
+- 12 = 8 + 3 + 1 = F(6) + F(4) + F(2)
+
+### Compression Process
+
+1. Input data is interpreted as either a big-endian or little-endian integer (you can choose, or use `zeckendorf_compress_best` to try both)
+2. The integer is converted to its Zeckendorf representation (list of Fibonacci indices)
+3. The representation is encoded as bits (use/skip bits)
+4. Bits are packed into bytes (little-endian output)
+
+The library provides functions to compress with either interpretation, or you can use `zeckendorf_compress_best` to automatically try both and select the one that produces the smallest output.
+
+### Effective Fibonacci Indices
+
+The library uses "Effective Fibonacci Indices" (EFI) starting from 0, where:
+- EFI 0 = Fibonacci Index 2 (value 1)
+- EFI 1 = Fibonacci Index 3 (value 2)
+- etc.
+
+This avoids redundant Fibonacci numbers (F(0)=0 and F(1)=F(2)=1).
+
+## Limitations
+
+- Compression is not guaranteed—some inputs may result in larger output
+- Compression effectiveness decreases as input size increases
+- The library supports both big-endian and little-endian interpretations, but other byte orderings or word boundaries are not currently explored
+- Compression of large amounts of data causes memory issues. It is currently not recommended to compress files larger than 100,000 bytes.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+## References
+
+- [Fast Fibonacci Algorithms](https://www.nayuki.io/page/fast-fibonacci-algorithms) - Fast doubling algorithm reference
+- [Zeckendorf's Theorem](https://en.wikipedia.org/wiki/Zeckendorf%27s_theorem) - Every positive integer has a unique representation as a sum of non-consecutive Fibonacci numbers

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "zeck",
+  "type": "module",
+  "collaborators": [
+    "Peter Ryszkiewicz"
+  ],
+  "description": "A Rust library for compressing and decompressing data using the Zeckendorf representation algorithm",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pRizz/zeckendorf"
+  },
+  "files": [
+    "zeckendorf_rs_bg.wasm",
+    "zeckendorf_rs.js",
+    "zeckendorf_rs_bg.js",
+    "zeckendorf_rs.d.ts",
+    "LICENSE.txt"
+  ],
+  "main": "zeckendorf_rs.js",
+  "types": "zeckendorf_rs.d.ts",
+  "sideEffects": [
+    "./zeckendorf_rs.js",
+    "./snippets/*"
+  ],
+  "keywords": [
+    "compression",
+    "zeckendorf",
+    "fibonacci",
+    "algorithm",
+    "data-compression"
+  ]
+}

package/zeckendorf_rs.d.ts

@@ -0,0 +1,346 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Returns the number of bits required to represent the given number. Returns 0 if the number is less than or equal to 0.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::bit_count_for_number;
+ * assert_eq!(bit_count_for_number(0), 0);
+ * assert_eq!(bit_count_for_number(1), 1);  // 0b1
+ * assert_eq!(bit_count_for_number(2), 2);  // 0b10
+ * assert_eq!(bit_count_for_number(3), 2);  // 0b11
+ * assert_eq!(bit_count_for_number(4), 3);  // 0b100
+ * ```
+ */
+export function bit_count_for_number(n: number): number;
+
+/**
+ * Effective Fibonacci Index to Fibonacci Index: FI(efi) === efi + 2, where efi is the Effective Fibonacci Index
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::efi_to_fi;
+ * assert_eq!(efi_to_fi(0), 2);
+ * assert_eq!(efi_to_fi(1), 3);
+ * assert_eq!(efi_to_fi(2), 4);
+ * ```
+ */
+export function efi_to_fi(efi: bigint): bigint;
+
+/**
+ * ezba is Effective Zeckendorf Bits Ascending ; ezld is Effective Zeckendorf List Descending
+ *
+ * The bits represent whether the corresponding effective Fibonacci index is used. I call these "use bits" and "skip bits" where a use bit is 1 and a skip bit is 0. This is by convention that I, Peter Ryszkiewicz decided, but it is theoretically possible to use skip bits and use bits flipped.
+ *
+ * If we use a bit, we then skip the next bit, because it is impossible to use two consecutive bits, or Fibonacci numbers, due to the Zeckendorf principle.
+ * The first bit in the ezba represents whether the first effective Fibonacci index is used.
+ * The first effective Fibonacci index is always 0 and represents the Fibonacci index 2 which has a value of 1. We use effective Fibonacci indices because the first Fibonacci number, 0, is not useful for sums, and the second Fibonacci number, 1, is redundant because it is the same as the third Fibonacci number.
+ *
+ * TODO: Optimize the size of the output by using a bit vector instead of a vector of [`u8`]s. I made an initial attempt at this in the `use-bitvec` branch, but the benchmarks were slower.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::ezba_from_ezld;
+ * assert_eq!(ezba_from_ezld(&[]), vec![0]);
+ * assert_eq!(ezba_from_ezld(&[0]), vec![1]); // 0th EFI is 2nd FI, which is 1
+ * assert_eq!(ezba_from_ezld(&[1]), vec![0, 1]); // 1st EFI is 3rd FI, which is 2
+ * assert_eq!(ezba_from_ezld(&[2]), vec![0, 0, 1]); // 2nd EFI is 4th FI, which is 3
+ * assert_eq!(ezba_from_ezld(&[2, 0]), vec![1, 1]); // 2nd EFI is 4th FI, which is 3 and 0th EFI is 2nd FI, which is 1, which sums to 4
+ * assert_eq!(ezba_from_ezld(&[3]), vec![0, 0, 0, 1]); // 3rd EFI is 5th FI, which is 5
+ * ```
+ */
+export function ezba_from_ezld(effective_zeckendorf_list_descending: BigUint64Array): Uint8Array;
+
+/**
+ * Converts a vector of bits (0s and 1s) from an ezba (Effective Zeckendorf Bits Ascending) into a vector of effective Fibonacci indices,
+ * the Effective Zeckendorf List Ascending.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::ezba_to_ezla;
+ * assert_eq!(ezba_to_ezla(&[0, 0, 0, 0, 0, 0, 0, 0]), vec![]);
+ * assert_eq!(ezba_to_ezla(&[1, 0, 0, 0, 0, 0, 0, 0]), vec![0]);
+ * assert_eq!(ezba_to_ezla(&[1, 1, 1, 0, 0, 0, 0, 0]), vec![0, 2, 4]);
+ * ```
+ */
+export function ezba_to_ezla(ezba_bits: Uint8Array): BigUint64Array;
+
+/**
+ * Converts an Effective Zeckendorf List to a Zeckendorf List.
+ * It does not matter if the list is ascending or descending; it retains the directionality of the original list.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::ezl_to_zl;
+ * assert_eq!(ezl_to_zl(&[0]), vec![2]);
+ * assert_eq!(ezl_to_zl(&[1]), vec![3]);
+ * assert_eq!(ezl_to_zl(&[2]), vec![4]);
+ * ```
+ */
+export function ezl_to_zl(ezl: BigUint64Array): BigUint64Array;
+
+/**
+ * Fibonacci Index to Effective Fibonacci Index: EFI(fi) === fi - 2, where fi is the Fibonacci Index
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::fi_to_efi;
+ * # use num_bigint::BigUint;
+ * # use num_traits::{One, Zero};
+ * assert_eq!(fi_to_efi(2), 0);
+ * assert_eq!(fi_to_efi(3), 1);
+ * assert_eq!(fi_to_efi(4), 2);
+ * ```
+ */
+export function fi_to_efi(fi: bigint): bigint;
+
+/**
+ * Returns a [`u64`] value with only the most significant set bit of n preserved.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::highest_one_bit;
+ * assert_eq!(highest_one_bit(0), 0);
+ * assert_eq!(highest_one_bit(1), 1);
+ * assert_eq!(highest_one_bit(2), 2);
+ * assert_eq!(highest_one_bit(3), 2);
+ * assert_eq!(highest_one_bit(4), 4);
+ * assert_eq!(highest_one_bit(5), 4);
+ * assert_eq!(highest_one_bit(6), 4);
+ * assert_eq!(highest_one_bit(7), 4);
+ * assert_eq!(highest_one_bit(8), 8);
+ * assert_eq!(highest_one_bit(9), 8);
+ * assert_eq!(highest_one_bit(10), 8);
+ * assert_eq!(highest_one_bit(11), 8);
+ * assert_eq!(highest_one_bit(12), 8);
+ * assert_eq!(highest_one_bit(13), 8);
+ * assert_eq!(highest_one_bit(14), 8);
+ * ```
+ */
+export function highest_one_bit(n: bigint): bigint;
+
+/**
+ * The memoized Fibonacci function taking an Effective Fibonacci Index as input.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::memoized_effective_fibonacci;
+ * # use num_bigint::BigUint;
+ * # use num_traits::{One, Zero};
+ * assert_eq!(memoized_effective_fibonacci(0), 1);
+ * assert_eq!(memoized_effective_fibonacci(1), 2);
+ * assert_eq!(memoized_effective_fibonacci(2), 3);
+ * assert_eq!(memoized_effective_fibonacci(3), 5);
+ * assert_eq!(memoized_effective_fibonacci(4), 8);
+ * assert_eq!(memoized_effective_fibonacci(5), 13);
+ * assert_eq!(memoized_effective_fibonacci(6), 21);
+ * assert_eq!(memoized_effective_fibonacci(7), 34);
+ * assert_eq!(memoized_effective_fibonacci(8), 55);
+ * assert_eq!(memoized_effective_fibonacci(9), 89);
+ * assert_eq!(memoized_effective_fibonacci(10), 144);
+ * ```
+ */
+export function memoized_effective_fibonacci(efi: bigint): bigint;
+
+/**
+ * fibonacci(x) is equal to 0 if x is 0; 1 if x is 1; else return fibonacci(x - 1) + fibonacci(x - 2)
+ *
+ * This function is slow and should not be used for large numbers. If you want a [`u64`] result, use the faster [`memoized_slow_fibonacci_biguint_iterative`] function instead. If you want a [`BigUint`] result, use the [`fast_doubling_fibonacci_biguint`] function instead.
+ *
+ * This function fails for large numbers (e.g. 100_000) with a stack overflow error.
+ *
+ * `fi` stands for Fibonacci Index.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::memoized_slow_fibonacci_recursive;
+ * // Base cases
+ * assert_eq!(memoized_slow_fibonacci_recursive(0), 0);
+ * assert_eq!(memoized_slow_fibonacci_recursive(1), 1);
+ *
+ * // Small Fibonacci numbers
+ * assert_eq!(memoized_slow_fibonacci_recursive(2), 1);
+ * assert_eq!(memoized_slow_fibonacci_recursive(3), 2);
+ * assert_eq!(memoized_slow_fibonacci_recursive(4), 3);
+ * assert_eq!(memoized_slow_fibonacci_recursive(5), 5);
+ * assert_eq!(memoized_slow_fibonacci_recursive(6), 8);
+ * assert_eq!(memoized_slow_fibonacci_recursive(7), 13);
+ * assert_eq!(memoized_slow_fibonacci_recursive(8), 21);
+ * assert_eq!(memoized_slow_fibonacci_recursive(9), 34);
+ * assert_eq!(memoized_slow_fibonacci_recursive(10), 55);
+ * ```
+ */
+export function memoized_slow_fibonacci_recursive(fi: bigint): bigint;
+
+/**
+ * A descending Zeckendorf list is a sorted list of unique Fibonacci indices, in descending order, that sum to the given number.
+ *
+ * A Fibonacci index is the index of the Fibonacci number in the Fibonacci sequence.
+ * fibonacci(fibonacci_index) = fibonacci_number
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::memoized_zeckendorf_list_descending_for_integer;
+ * // Base cases
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(0), vec![]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(1), vec![2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(2), vec![3]);
+ *
+ * // Small Zeckendorf numbers
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(3), vec![4]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(4), vec![4, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(5), vec![5]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(6), vec![5, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(7), vec![5, 3]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(8), vec![6]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(9), vec![6, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(10), vec![6, 3]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(11), vec![6, 4]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(12), vec![6, 4, 2]);
+ * ```
+ */
+export function memoized_zeckendorf_list_descending_for_integer(n: bigint): BigUint64Array;
+
+/**
+ * Packs a slice of bits (0s and 1s) from an ezba (Effective Zeckendorf Bits Ascending) into bytes.
+ *
+ * The output bytes are in little endian order, so the first byte is the least significant byte and the last byte is the most significant byte.
+ *
+ * Input bits and output bits are in ascending significance: bits\[0\] = LSB, bits\[7\] = MSB.
+ * Every 8 bits become a [`u8`] in the output.
+ * The last byte is padded with 0s if the number of bits is not a multiple of 8.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::pack_ezba_bits_to_bytes;
+ * assert_eq!(pack_ezba_bits_to_bytes(&[0]), vec![0]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[1]), vec![1]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[0, 1]), vec![0b10]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[0, 0, 1]), vec![0b100]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[1, 1]), vec![0b11]);
+ * ```
+ */
+export function pack_ezba_bits_to_bytes(ezba: Uint8Array): Uint8Array;
+
+/**
+ * Unpacks a vector of bytes into a vector of bits (0s and 1s) from an ezba (Effective Zeckendorf Bits Ascending).
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::unpack_bytes_to_ezba_bits;
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[0]), vec![0, 0, 0, 0, 0, 0, 0, 0]);
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[1]), vec![1, 0, 0, 0, 0, 0, 0, 0]);
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[0b111]), vec![1, 1, 1, 0, 0, 0, 0, 0]);
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[1, 1]), vec![1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]);
+ * ```
+ */
+export function unpack_bytes_to_ezba_bits(bytes: Uint8Array): Uint8Array;
+
+/**
+ * Compresses a slice of bytes using the Zeckendorf algorithm.
+ *
+ * Assumes the input data is interpreted as a big endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
+ *
+ * TODO: Technically, the way the input data is interpreted is arbitrary; we could interpret it as little endian which could result in a more compact representation. We could go even further and interpret the data at different byte or word boundaries to see if it results in a more compact representation, and signify to the caller which interpretation was used. We probably need a better understanding of random distributions of data to determine what is the optimal interpretation. More investigation is needed here.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_compress_be;
+ * assert_eq!(zeckendorf_compress_be(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_be(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_be(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_be(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_be(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_be(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_be(&[1, 0]), vec![34, 2]);
+ * ```
+ */
+export function zeckendorf_compress_be(data: Uint8Array): Uint8Array;
+
+/**
+ * Compresses a slice of bytes using the Zeckendorf algorithm.
+ *
+ * Assumes the input data is interpreted as a little endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_compress_le;
+ * assert_eq!(zeckendorf_compress_le(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_le(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_le(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_le(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_le(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_le(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_le(&[0, 1]), vec![34, 2]);
+ * ```
+ */
+export function zeckendorf_compress_le(data: Uint8Array): Uint8Array;
+
+/**
+ * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the big endian bytes interpretation.
+ *
+ * Assume the original input data was interpreted as a big endian integer, for now. See the TODO in the [`zeckendorf_compress_be`] function for more information.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_decompress_be;
+ * assert_eq!(zeckendorf_decompress_be(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_be(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_be(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_be(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_be(&[34, 2]), vec![1, 0]);
+ * ```
+ */
+export function zeckendorf_decompress_be(compressed_data: Uint8Array): Uint8Array;
+
+/**
+ * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the little endian bytes interpretation.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_decompress_le;
+ * assert_eq!(zeckendorf_decompress_le(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_le(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_le(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_le(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_le(&[34, 2]), vec![0, 1]);
+ * ```
+ */
+export function zeckendorf_decompress_le(compressed_data: Uint8Array): Uint8Array;
+
+/**
+ * An Effective Zeckendorf List (EZL) has a lowest EFI of 0, which is an FI of 2.
+ * This is because it doesn't make sense for the lists to contain FIs 0 or 1 because
+ * 0 can never be added to a number and will therefore never be in a Zeckendorf List
+ * and an FI of 1 is equivalent to an FI of 2 which has a Fibonacci value of 1
+ * so let's just use FI starting at 2, which is an EFI of 0.
+ * It does not matter if the list is ascending or descending; it retains the directionality of the original list.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zl_to_ezl;
+ * assert_eq!(zl_to_ezl(&[2]), vec![0]);
+ * assert_eq!(zl_to_ezl(&[3]), vec![1]);
+ * assert_eq!(zl_to_ezl(&[4]), vec![2]);
+ * ```
+ */
+export function zl_to_ezl(zl: BigUint64Array): BigUint64Array;

package/zeckendorf_rs.js

@@ -0,0 +1,5 @@
+import * as wasm from "./zeckendorf_rs_bg.wasm";
+export * from "./zeckendorf_rs_bg.js";
+import { __wbg_set_wasm } from "./zeckendorf_rs_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/zeckendorf_rs_bg.js

@@ -0,0 +1,527 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+/**
+ * Returns the number of bits required to represent the given number. Returns 0 if the number is less than or equal to 0.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::bit_count_for_number;
+ * assert_eq!(bit_count_for_number(0), 0);
+ * assert_eq!(bit_count_for_number(1), 1);  // 0b1
+ * assert_eq!(bit_count_for_number(2), 2);  // 0b10
+ * assert_eq!(bit_count_for_number(3), 2);  // 0b11
+ * assert_eq!(bit_count_for_number(4), 3);  // 0b100
+ * ```
+ * @param {number} n
+ * @returns {number}
+ */
+export function bit_count_for_number(n) {
+    const ret = wasm.bit_count_for_number(n);
+    return ret >>> 0;
+}
+
+/**
+ * Effective Fibonacci Index to Fibonacci Index: FI(efi) === efi + 2, where efi is the Effective Fibonacci Index
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::efi_to_fi;
+ * assert_eq!(efi_to_fi(0), 2);
+ * assert_eq!(efi_to_fi(1), 3);
+ * assert_eq!(efi_to_fi(2), 4);
+ * ```
+ * @param {bigint} efi
+ * @returns {bigint}
+ */
+export function efi_to_fi(efi) {
+    const ret = wasm.efi_to_fi(efi);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * ezba is Effective Zeckendorf Bits Ascending ; ezld is Effective Zeckendorf List Descending
+ *
+ * The bits represent whether the corresponding effective Fibonacci index is used. I call these "use bits" and "skip bits" where a use bit is 1 and a skip bit is 0. This is by convention that I, Peter Ryszkiewicz decided, but it is theoretically possible to use skip bits and use bits flipped.
+ *
+ * If we use a bit, we then skip the next bit, because it is impossible to use two consecutive bits, or Fibonacci numbers, due to the Zeckendorf principle.
+ * The first bit in the ezba represents whether the first effective Fibonacci index is used.
+ * The first effective Fibonacci index is always 0 and represents the Fibonacci index 2 which has a value of 1. We use effective Fibonacci indices because the first Fibonacci number, 0, is not useful for sums, and the second Fibonacci number, 1, is redundant because it is the same as the third Fibonacci number.
+ *
+ * TODO: Optimize the size of the output by using a bit vector instead of a vector of [`u8`]s. I made an initial attempt at this in the `use-bitvec` branch, but the benchmarks were slower.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::ezba_from_ezld;
+ * assert_eq!(ezba_from_ezld(&[]), vec![0]);
+ * assert_eq!(ezba_from_ezld(&[0]), vec![1]); // 0th EFI is 2nd FI, which is 1
+ * assert_eq!(ezba_from_ezld(&[1]), vec![0, 1]); // 1st EFI is 3rd FI, which is 2
+ * assert_eq!(ezba_from_ezld(&[2]), vec![0, 0, 1]); // 2nd EFI is 4th FI, which is 3
+ * assert_eq!(ezba_from_ezld(&[2, 0]), vec![1, 1]); // 2nd EFI is 4th FI, which is 3 and 0th EFI is 2nd FI, which is 1, which sums to 4
+ * assert_eq!(ezba_from_ezld(&[3]), vec![0, 0, 0, 1]); // 3rd EFI is 5th FI, which is 5
+ * ```
+ * @param {BigUint64Array} effective_zeckendorf_list_descending
+ * @returns {Uint8Array}
+ */
+export function ezba_from_ezld(effective_zeckendorf_list_descending) {
+    const ptr0 = passArray64ToWasm0(effective_zeckendorf_list_descending, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ezba_from_ezld(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Converts a vector of bits (0s and 1s) from an ezba (Effective Zeckendorf Bits Ascending) into a vector of effective Fibonacci indices,
+ * the Effective Zeckendorf List Ascending.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::ezba_to_ezla;
+ * assert_eq!(ezba_to_ezla(&[0, 0, 0, 0, 0, 0, 0, 0]), vec![]);
+ * assert_eq!(ezba_to_ezla(&[1, 0, 0, 0, 0, 0, 0, 0]), vec![0]);
+ * assert_eq!(ezba_to_ezla(&[1, 1, 1, 0, 0, 0, 0, 0]), vec![0, 2, 4]);
+ * ```
+ * @param {Uint8Array} ezba_bits
+ * @returns {BigUint64Array}
+ */
+export function ezba_to_ezla(ezba_bits) {
+    const ptr0 = passArray8ToWasm0(ezba_bits, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ezba_to_ezla(ptr0, len0);
+    var v2 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Converts an Effective Zeckendorf List to a Zeckendorf List.
+ * It does not matter if the list is ascending or descending; it retains the directionality of the original list.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::ezl_to_zl;
+ * assert_eq!(ezl_to_zl(&[0]), vec![2]);
+ * assert_eq!(ezl_to_zl(&[1]), vec![3]);
+ * assert_eq!(ezl_to_zl(&[2]), vec![4]);
+ * ```
+ * @param {BigUint64Array} ezl
+ * @returns {BigUint64Array}
+ */
+export function ezl_to_zl(ezl) {
+    const ptr0 = passArray64ToWasm0(ezl, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ezl_to_zl(ptr0, len0);
+    var v2 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Fibonacci Index to Effective Fibonacci Index: EFI(fi) === fi - 2, where fi is the Fibonacci Index
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::fi_to_efi;
+ * # use num_bigint::BigUint;
+ * # use num_traits::{One, Zero};
+ * assert_eq!(fi_to_efi(2), 0);
+ * assert_eq!(fi_to_efi(3), 1);
+ * assert_eq!(fi_to_efi(4), 2);
+ * ```
+ * @param {bigint} fi
+ * @returns {bigint}
+ */
+export function fi_to_efi(fi) {
+    const ret = wasm.fi_to_efi(fi);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * Returns a [`u64`] value with only the most significant set bit of n preserved.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::highest_one_bit;
+ * assert_eq!(highest_one_bit(0), 0);
+ * assert_eq!(highest_one_bit(1), 1);
+ * assert_eq!(highest_one_bit(2), 2);
+ * assert_eq!(highest_one_bit(3), 2);
+ * assert_eq!(highest_one_bit(4), 4);
+ * assert_eq!(highest_one_bit(5), 4);
+ * assert_eq!(highest_one_bit(6), 4);
+ * assert_eq!(highest_one_bit(7), 4);
+ * assert_eq!(highest_one_bit(8), 8);
+ * assert_eq!(highest_one_bit(9), 8);
+ * assert_eq!(highest_one_bit(10), 8);
+ * assert_eq!(highest_one_bit(11), 8);
+ * assert_eq!(highest_one_bit(12), 8);
+ * assert_eq!(highest_one_bit(13), 8);
+ * assert_eq!(highest_one_bit(14), 8);
+ * ```
+ * @param {bigint} n
+ * @returns {bigint}
+ */
+export function highest_one_bit(n) {
+    const ret = wasm.highest_one_bit(n);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * The memoized Fibonacci function taking an Effective Fibonacci Index as input.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::memoized_effective_fibonacci;
+ * # use num_bigint::BigUint;
+ * # use num_traits::{One, Zero};
+ * assert_eq!(memoized_effective_fibonacci(0), 1);
+ * assert_eq!(memoized_effective_fibonacci(1), 2);
+ * assert_eq!(memoized_effective_fibonacci(2), 3);
+ * assert_eq!(memoized_effective_fibonacci(3), 5);
+ * assert_eq!(memoized_effective_fibonacci(4), 8);
+ * assert_eq!(memoized_effective_fibonacci(5), 13);
+ * assert_eq!(memoized_effective_fibonacci(6), 21);
+ * assert_eq!(memoized_effective_fibonacci(7), 34);
+ * assert_eq!(memoized_effective_fibonacci(8), 55);
+ * assert_eq!(memoized_effective_fibonacci(9), 89);
+ * assert_eq!(memoized_effective_fibonacci(10), 144);
+ * ```
+ * @param {bigint} efi
+ * @returns {bigint}
+ */
+export function memoized_effective_fibonacci(efi) {
+    const ret = wasm.memoized_effective_fibonacci(efi);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * fibonacci(x) is equal to 0 if x is 0; 1 if x is 1; else return fibonacci(x - 1) + fibonacci(x - 2)
+ *
+ * This function is slow and should not be used for large numbers. If you want a [`u64`] result, use the faster [`memoized_slow_fibonacci_biguint_iterative`] function instead. If you want a [`BigUint`] result, use the [`fast_doubling_fibonacci_biguint`] function instead.
+ *
+ * This function fails for large numbers (e.g. 100_000) with a stack overflow error.
+ *
+ * `fi` stands for Fibonacci Index.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::memoized_slow_fibonacci_recursive;
+ * // Base cases
+ * assert_eq!(memoized_slow_fibonacci_recursive(0), 0);
+ * assert_eq!(memoized_slow_fibonacci_recursive(1), 1);
+ *
+ * // Small Fibonacci numbers
+ * assert_eq!(memoized_slow_fibonacci_recursive(2), 1);
+ * assert_eq!(memoized_slow_fibonacci_recursive(3), 2);
+ * assert_eq!(memoized_slow_fibonacci_recursive(4), 3);
+ * assert_eq!(memoized_slow_fibonacci_recursive(5), 5);
+ * assert_eq!(memoized_slow_fibonacci_recursive(6), 8);
+ * assert_eq!(memoized_slow_fibonacci_recursive(7), 13);
+ * assert_eq!(memoized_slow_fibonacci_recursive(8), 21);
+ * assert_eq!(memoized_slow_fibonacci_recursive(9), 34);
+ * assert_eq!(memoized_slow_fibonacci_recursive(10), 55);
+ * ```
+ * @param {bigint} fi
+ * @returns {bigint}
+ */
+export function memoized_slow_fibonacci_recursive(fi) {
+    const ret = wasm.memoized_slow_fibonacci_recursive(fi);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * A descending Zeckendorf list is a sorted list of unique Fibonacci indices, in descending order, that sum to the given number.
+ *
+ * A Fibonacci index is the index of the Fibonacci number in the Fibonacci sequence.
+ * fibonacci(fibonacci_index) = fibonacci_number
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::memoized_zeckendorf_list_descending_for_integer;
+ * // Base cases
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(0), vec![]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(1), vec![2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(2), vec![3]);
+ *
+ * // Small Zeckendorf numbers
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(3), vec![4]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(4), vec![4, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(5), vec![5]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(6), vec![5, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(7), vec![5, 3]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(8), vec![6]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(9), vec![6, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(10), vec![6, 3]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(11), vec![6, 4]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(12), vec![6, 4, 2]);
+ * ```
+ * @param {bigint} n
+ * @returns {BigUint64Array}
+ */
+export function memoized_zeckendorf_list_descending_for_integer(n) {
+    const ret = wasm.memoized_zeckendorf_list_descending_for_integer(n);
+    var v1 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Packs a slice of bits (0s and 1s) from an ezba (Effective Zeckendorf Bits Ascending) into bytes.
+ *
+ * The output bytes are in little endian order, so the first byte is the least significant byte and the last byte is the most significant byte.
+ *
+ * Input bits and output bits are in ascending significance: bits\[0\] = LSB, bits\[7\] = MSB.
+ * Every 8 bits become a [`u8`] in the output.
+ * The last byte is padded with 0s if the number of bits is not a multiple of 8.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::pack_ezba_bits_to_bytes;
+ * assert_eq!(pack_ezba_bits_to_bytes(&[0]), vec![0]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[1]), vec![1]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[0, 1]), vec![0b10]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[0, 0, 1]), vec![0b100]);
+ * assert_eq!(pack_ezba_bits_to_bytes(&[1, 1]), vec![0b11]);
+ * ```
+ * @param {Uint8Array} ezba
+ * @returns {Uint8Array}
+ */
+export function pack_ezba_bits_to_bytes(ezba) {
+    const ptr0 = passArray8ToWasm0(ezba, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pack_ezba_bits_to_bytes(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Unpacks a vector of bytes into a vector of bits (0s and 1s) from an ezba (Effective Zeckendorf Bits Ascending).
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::unpack_bytes_to_ezba_bits;
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[0]), vec![0, 0, 0, 0, 0, 0, 0, 0]);
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[1]), vec![1, 0, 0, 0, 0, 0, 0, 0]);
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[0b111]), vec![1, 1, 1, 0, 0, 0, 0, 0]);
+ * assert_eq!(unpack_bytes_to_ezba_bits(&[1, 1]), vec![1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]);
+ * ```
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+export function unpack_bytes_to_ezba_bits(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.unpack_bytes_to_ezba_bits(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Compresses a slice of bytes using the Zeckendorf algorithm.
+ *
+ * Assumes the input data is interpreted as a big endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
+ *
+ * TODO: Technically, the way the input data is interpreted is arbitrary; we could interpret it as little endian which could result in a more compact representation. We could go even further and interpret the data at different byte or word boundaries to see if it results in a more compact representation, and signify to the caller which interpretation was used. We probably need a better understanding of random distributions of data to determine what is the optimal interpretation. More investigation is needed here.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_compress_be;
+ * assert_eq!(zeckendorf_compress_be(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_be(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_be(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_be(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_be(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_be(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_be(&[1, 0]), vec![34, 2]);
+ * ```
+ * @param {Uint8Array} data
+ * @returns {Uint8Array}
+ */
+export function zeckendorf_compress_be(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.zeckendorf_compress_be(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Compresses a slice of bytes using the Zeckendorf algorithm.
+ *
+ * Assumes the input data is interpreted as a little endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_compress_le;
+ * assert_eq!(zeckendorf_compress_le(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_le(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_le(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_le(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_le(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_le(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_le(&[0, 1]), vec![34, 2]);
+ * ```
+ * @param {Uint8Array} data
+ * @returns {Uint8Array}
+ */
+export function zeckendorf_compress_le(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.zeckendorf_compress_le(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the big endian bytes interpretation.
+ *
+ * Assume the original input data was interpreted as a big endian integer, for now. See the TODO in the [`zeckendorf_compress_be`] function for more information.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_decompress_be;
+ * assert_eq!(zeckendorf_decompress_be(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_be(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_be(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_be(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_be(&[34, 2]), vec![1, 0]);
+ * ```
+ * @param {Uint8Array} compressed_data
+ * @returns {Uint8Array}
+ */
+export function zeckendorf_decompress_be(compressed_data) {
+    const ptr0 = passArray8ToWasm0(compressed_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.zeckendorf_decompress_be(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the little endian bytes interpretation.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zeckendorf_decompress_le;
+ * assert_eq!(zeckendorf_decompress_le(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_le(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_le(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_le(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_le(&[34, 2]), vec![0, 1]);
+ * ```
+ * @param {Uint8Array} compressed_data
+ * @returns {Uint8Array}
+ */
+export function zeckendorf_decompress_le(compressed_data) {
+    const ptr0 = passArray8ToWasm0(compressed_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.zeckendorf_decompress_le(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * An Effective Zeckendorf List (EZL) has a lowest EFI of 0, which is an FI of 2.
+ * This is because it doesn't make sense for the lists to contain FIs 0 or 1 because
+ * 0 can never be added to a number and will therefore never be in a Zeckendorf List
+ * and an FI of 1 is equivalent to an FI of 2 which has a Fibonacci value of 1
+ * so let's just use FI starting at 2, which is an EFI of 0.
+ * It does not matter if the list is ascending or descending; it retains the directionality of the original list.
+ *
+ * # Examples
+ *
+ * ```
+ * # use zeckendorf_rs::zl_to_ezl;
+ * assert_eq!(zl_to_ezl(&[2]), vec![0]);
+ * assert_eq!(zl_to_ezl(&[3]), vec![1]);
+ * assert_eq!(zl_to_ezl(&[4]), vec![2]);
+ * ```
+ * @param {BigUint64Array} zl
+ * @returns {BigUint64Array}
+ */
+export function zl_to_ezl(zl) {
+    const ptr0 = passArray64ToWasm0(zl, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.zl_to_ezl(ptr0, len0);
+    var v2 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+};