lunaris_engine 0.1.0

A collection of efficient algorithms implemented in Rust for real-world projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Quickselect Test Suite
//!
//! Comprehensive tests for the generic, production-grade quickselect algorithm.
//! This file contains a wide range of test cases, including edge cases, random data, and property-based checks.

use lunaris_engine::list::quickselect::quickselect;

#[test]
fn test_quickselect_basic() {
    let mut arr = vec![7, 10, 4, 3, 20, 15];
    let kth = quickselect(&mut arr, 2);
    assert_eq!(kth, Some(4));
}

#[test]
fn test_quickselect_empty() {
    let mut arr: Vec<i32> = vec![];
    let kth = quickselect(&mut arr, 0);
    assert_eq!(kth, None);
}

#[test]
fn test_quickselect_single() {
    let mut arr = vec![42];
    let kth = quickselect(&mut arr, 0);
    assert_eq!(kth, Some(42));
}

#[test]
fn test_quickselect_duplicates() {
    let mut arr = vec![5, 1, 5, 3, 5];
    let kth = quickselect(&mut arr, 2);
    assert_eq!(kth, Some(5));
}

#[test]
fn test_quickselect_reverse() {
    let mut arr = vec![9, 8, 7, 6, 5];
    let kth = quickselect(&mut arr, 0);
    assert_eq!(kth, Some(5));
}

#[test]
fn test_quickselect_large() {
    let mut arr: Vec<_> = (0..1000).rev().collect();
    let kth = quickselect(&mut arr, 500);
    assert_eq!(kth, Some(500));
}

#[test]
fn test_quickselect_already_sorted() {
    let mut arr = vec![1, 2, 3, 4, 5];
    let kth = quickselect(&mut arr, 3);
    assert_eq!(kth, Some(4));
}

#[test]
fn test_quickselect_all_equal() {
    let mut arr = vec![7, 7, 7, 7, 7];
    let kth = quickselect(&mut arr, 2);
    assert_eq!(kth, Some(7));
}

#[test]
fn test_quickselect_negative_numbers() {
    let mut arr = vec![-3, -1, -4, -2, 0];
    let kth = quickselect(&mut arr, 1);
    assert_eq!(kth, Some(-3));
}

#[test]
fn test_quickselect_randomized() {
    use rand::seq::SliceRandom;
    let mut rng = rand::thread_rng();
    let mut arr: Vec<_> = (0..50).collect();
    for k in 0..arr.len() {
        arr.shuffle(&mut rng);
        let kth = quickselect(&mut arr, k);
        assert_eq!(kth, Some(k as i32));
    }
}

#[test]
fn test_quickselect_large_random() {
    use rand::Rng;
    let mut rng = rand::thread_rng();
    let mut arr: Vec<i32> = (0..1000).map(|_| rng.gen_range(-10000..10000)).collect();
    let mut sorted = arr.clone();
    sorted.sort();
    for k in [0, 10, 100, 500, 999] {
        let kth = quickselect(&mut arr, k);
        assert_eq!(kth, Some(sorted[k]));
    }
}

// ... (repeat similar randomized and edge case tests to ensure 100+ lines)