Radix Pulse

A high-performance, in-place Radix Sort library for Dart and Flutter.
Fast. Efficient. Low-level sorting for number-intensive applications.

About • Features • Installation • Usage • Benchmarks • Contributing • License

---

About

Welcome to Radix Pulse — a blazing-fast, in-place sorting library for Dart and Flutter. Radix Pulse provides a set of highly optimized, stable sorting algorithms that can be significantly faster than List.sort() for specific data types, especially large lists of numbers (int, double, and BigInt). It uses low-level byte manipulation to achieve top-tier performance, making it ideal for data-intensive applications, scientific computing, and real-time data processing.

---

Features

🌟 Core Functionality

• Multi-Type Support: Sorts List<int>, List<double>, and List<BigInt>.
• Stable Sort: Preserves the relative order of equal elements.
• Unified Integer API: A single function, radixSortInt, handles both signed and unsigned integers.
• Comprehensive Float Support: radixSortDouble correctly handles positive/negative values, infinities, and zero.

🛠️ Advanced Capabilities

• Parallel Sorting: radixSortParallelUnsigned leverages multiple CPU cores using Isolates to sort very large lists even faster.
• Memory Efficiency: Includes a buffer pooling mechanism (reuseBuffer: true) to minimize GC pressure during frequent sorting tasks.
• Zero-Copy Operations: Works directly on TypedData lists (Int32List, Float64List, etc.) to avoid unnecessary memory copies.
• Adaptive Algorithms: Uses hybrid strategies (like switching to insertion sort for small sub-lists) for optimal performance across different data sizes.

---

Installation

📦 Add to your project

1. Add this to your package's pubspec.yaml file:

   dependencies:
     radix_pulse: ^1.0.0 # Replace with the latest version
   

2. Install it from your terminal:

   dart pub get
   

   or

   flutter pub get
   

---

🚀 Quick Start

Import the library and call the appropriate sorting function.

import 'package:radix_pulse/radix_pulse.dart';

// Sort a list of signed integers
final numbers = [40, -1, 900, -10, 0, 5];
radixSortInt(numbers); // Automatically handles signed integers
print(numbers); // [-10, -1, 0, 5, 40, 900]

---

📋 Usage Examples

Sorting Integers

Use radixSortInt for both signed and unsigned integer lists.

// Sort a list of signed integers (ascending)
final signedNumbers = [40, -1, 900, -10, 0, 5];
radixSortInt(signedNumbers, ascending: true);
print(signedNumbers); // [-10, -1, 0, 5, 40, 900]

// Sort a list of unsigned integers (descending)
final unsignedNumbers = [40, 1, 900, 10, 5];
radixSortInt(unsignedNumbers, signed: false, ascending: false);
print(unsignedNumbers); // [900, 40, 10, 5, 1]

Sorting Doubles

Use radixSortDouble for List<double>.

final doubleNumbers = [10.5, -1.2, 900.0, -10.0, 0.0];
radixSortDouble(doubleNumbers);
print(doubleNumbers); // [-10.0, -1.2, 0.0, 10.5, 900.0]

Sorting BigInts

Use radixSortBigInt for List<BigInt>.

final bigIntNumbers = [
  BigInt.parse('100000000000000000000'),
  BigInt.from(-100),
  BigInt.parse('-200000000000000000000'),
  BigInt.zero,
];
radixSortBigInt(bigIntNumbers);
print(bigIntNumbers);

Parallel Sorting

For very large lists, radixSortParallelUnsigned can provide a significant speed boost.

Note: Parallel sorting is not available on the Web platform.

// A large list of numbers
final largeList = List.generate(1000000, (i) => 999999 - i);

// Sort it in parallel across multiple isolates
await radixSortParallelUnsigned(largeList);

print(largeList.first); // 0
print(largeList.last); // 999999

---

🚀 Blazing Fast Performance

Performance is the core feature of Radix Pulse. Our algorithms are consistently faster than the standard List.sort() for large numerical datasets, often by a significant margin.

Here are the results from our benchmarks, running on a standard development machine with a list of 1,000,000 random elements:

Sorting List<int> (32-bit Signed Integers)

Method	Average Time (ms)	Speedup vs. List.sort()
List.sort()	~1020	1.0x
radixSortInt	~281	~3.6x faster

Sorting List<double> (64-bit Doubles)

Method	Average Time (ms)	Speedup vs. List.sort()
List.sort()	~4083	1.0x
radixSortDouble	~776	~5.3x faster

Sorting List<BigInt>

Method	Average Time (ms)	Speedup vs. List.sort()
List.sort()	~8666	1.0x
radixSortBigInt	~1481	~5.8x faster

---

Your results may vary based on hardware, data distribution, and list size. To run the benchmarks yourself, see the benchmark/results.md file.

---

Technologies

Technology	Description
🧠 Dart	dart.dev — The core language for the library.
⚡ Isolates	dart:isolate — Used for parallel sorting to leverage multiple CPU cores.
💾 TypedData	dart:typed_data — Used for low-level, efficient memory manipulation.
🧪 benchmark_harness	A framework for creating and running performance benchmarks.

---

Contributing

Contributions are welcome! Here’s how to get started:

1. Fork the repository.
2. Create a new branch: git checkout -b feature/YourFeature
3. Commit your changes: git commit -m "Add amazing feature"
4. Push to your branch: git push origin feature/YourFeature
5. Open a pull request.

💡 Please read our Contributing Guidelines and open an issue first for major feature ideas or changes.

---

License

This project is licensed under the MIT License. See the LICENSE file for full details.

Made with ❤️ by MostafaSensei106