MMseqs2

NibbleAndAHalf is a fast ANSI C library for base64 encoding and decoding. It is distributed as a single-header library, making it easy to integrate into C projects.

To use the library in your project, you only need to include the main header file: #include "base64.h".

Note that all test-related functions have been moved to a separate header, testbase64.h, so they are not included in the standard base64.h import.

This repository provides a lightweight version of the SIMDe library containing only the core functionality. It is designed to be used as a git submodule in projects that require SIMD emulation but want to avoid the overhead and size of the full SIMDe test suite.

Note: This is a generated repository. All development and issue reporting should be directed to the main SIMDe repository. Do not file issues or pull requests here.

Corrosion (formerly cmake-cargo) is a tool designed to integrate Rust code into existing CMake projects. It automates the process of importing Rust-generated executables, static libraries, and dynamic libraries into the CMake build system by reading the Cargo.toml manifest.

Key capabilities include:

• Automatic import of executables, static, and shared libraries from Rust crates.
• Easy installation of Rust executables.
• Trivial linking of Rust executables to C/C++ libraries within the project tree.
• Support for Multi-Config generators and simple cross-compilation.

largeNbDicts is a benchmark tool designed to test dictionary decompression performance in scenarios where a very large number of dictionaries are used. It specifically targets the 'cold' dictionary scenario, where frequent dictionary changes cause increased latency due to cache misses. The tool allows users to investigate performance and experiment with mitigation techniques for this specific workload.

largeNbDicts [Options] filename(s)

Corrosion (formerly cmake-cargo) is a tool designed to integrate Rust into existing CMake projects. It automatically imports Rust executables, static libraries, and dynamic libraries from a Rust package or workspace as native CMake targets.

Key integration features:

• Libraries: Imported static and dynamic libraries can be linked into C/C++ CMake targets using standard CMake commands like target_link_libraries().
• Rust Targets: For Rust executables and dynamic libraries, Corrosion provides a helper function corrosion_link_libraries to simplify adding the necessary flags required to link C/C++ libraries into the Rust target.

Zstandard defines two distinct frame formats:

1. Zstandard frames: These are the standard frames used to store compressed data.
2. Skippable frames: These are specialized frames used to store custom user metadata. They are designed to be skippable by decoders that do not recognize the metadata, allowing the stream to continue to the next valid Zstandard frame.

The benchmarking output follows a specific structure for comparing optimized vs. non-optimized parameters:

• Cover Comparison: The first Cover value represents the optimized cover. The second Cover value uses the optimized d and k parameters derived from the first one.
• fastCover Comparison: For every f value of fastCover, the first entry is the optimized fastCover. The second entry uses the optimized d and k from the first entry. This is evaluated for accel values ranging from 1 to 10.
• Parameter Columns: In the output, the fourth column represents the chosen d value, and the fifth column represents the chosen k value.

To transform a list of decoded weights into Huffman prefix codes, follow these steps:

1. Calculate Bits: For each symbol, calculate Number_of_Bits = (Weight > 0) ? Max_Number_of_Bits + 1 - Weight : 0.
2. Sort: Sort symbols by Weight. If weights are equal, maintain their natural sequential order.
3. Filter: Remove symbols with a Weight of zero.
4. Distribute: Starting from the lowest Weight, distribute prefix codes in sequential order.

Example Transformation:

Sorted Distribution: