Merge pull request #32 from orxfun/major-revision-v3

major-revision-v3

Author: orxfun

Cargo.toml

@@ -1,27 +1,31 @@
 [package]
 name = "orx-linked-list"
-version = "2.7.0"
+version = "3.0.0"
 edition = "2021"
 authors = ["orxfun <orx.ugur.arikan@gmail.com>"]
-description = "An efficient and recursive singly and doubly linked list implementation."
+description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."
 license = "MIT"
 repository = "https://github.com/orxfun/orx-linked-list/"
-keywords = ["linked", "list", "vec", "array", "pinned"]
-categories = ["data-structures", "rust-patterns"]
+keywords = ["linked", "list", "doubly", "singly", "pinned"]
+categories = ["data-structures", "rust-patterns", "no-std"]
 
 [dependencies]
-orx-pseudo-default = "1.2"
-orx-pinned-vec = "3.3"
-orx-split-vec = "3.3"
-orx-selfref-col = "1.8"
-
+orx-pseudo-default = { version = "1.4", default-features = false }
+orx-pinned-vec = "3.9"
+orx-split-vec = "3.9"
+orx-selfref-col = "2.0"
 
 [dev-dependencies]
-rand = "0.8"
-rand_chacha = "0.3"
-criterion = { version = "0.5", features = ["html_reports"] }
-test-case = "3.3"
+clap = { version = "4.5.17", features = ["derive"] }
+criterion = "0.5"
+rand = "0.8.5"
+rand_chacha = "0.3.1"
+test-case = "3.3.1"
+
+[features]
+default = ["validation"]
+validation = []
 
 [[bench]]
-name = "mutation_ends"
+name = "doubly_shuffling_around"
 harness = false

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ugur Arikan
+
+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.

README.md

@@ -0,0 +1,190 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use orx_linked_list::*;
+use orx_selfref_col::MemoryPolicy;
+use rand::prelude::*;
+use rand_chacha::ChaCha8Rng;
+
+#[derive(Clone)]
+enum Action {
+    PushBack(String),
+    PushFront(String),
+    PopBack,
+    PopFront,
+}
+
+fn get_test_data(n: usize) -> Vec<Action> {
+    let mut rng = ChaCha8Rng::seed_from_u64(56456);
+    let mut vec: Vec<_> = (0..n)
+        .map(|_| match rng.gen::<f32>() {
+            x if x < 0.5 => Action::PushBack(rng.gen_range(0..n).to_string()),
+            _ => Action::PushFront(rng.gen_range(0..n).to_string()),
+        })
+        .collect();
+    for _ in 0..2 * n {
+        let action = match rng.gen::<f32>() {
+            x if x < 0.25 => Action::PushBack(rng.gen_range(0..n).to_string()),
+            x if x < 0.50 => Action::PushFront(rng.gen_range(0..n).to_string()),
+            x if x < 0.75 => Action::PopBack,
+            _ => Action::PopFront,
+        };
+        vec.push(action)
+    }
+    vec
+}
+
+// variants
+
+fn fill_doubly_list<M: MemoryPolicy<Doubly<String>>>(
+    actions: &[Action],
+    list: &mut List<Doubly<String>, M>,
+) {
+    for action in actions {
+        match action {
+            Action::PushBack(x) => {
+                list.push_back(x.clone());
+            }
+            Action::PushFront(x) => {
+                list.push_front(x.clone());
+            }
+            Action::PopBack => {
+                _ = list.pop_back();
+            }
+            Action::PopFront => {
+                _ = list.pop_front();
+            }
+        }
+    }
+}
+
+fn doubly_iter<M: MemoryPolicy<Doubly<String>>>(list: &List<Doubly<String>, M>) -> i64 {
+    list.iter()
+        .enumerate()
+        .map(|(i, x)| match i % 2 {
+            0 => x.len() as i64,
+            _ => -(x.len() as i64),
+        })
+        .sum()
+}
+
+fn doubly_iter_x<M: MemoryPolicy<Doubly<String>>>(list: &List<Doubly<String>, M>) -> i64 {
+    list.iter_x()
+        .enumerate()
+        .map(|(i, x)| match i % 2 {
+            0 => x.len() as i64,
+            _ => -(x.len() as i64),
+        })
+        .sum()
+}
+
+fn fill_std_linked_list(actions: &[Action], list: &mut std::collections::LinkedList<String>) {
+    for action in actions {
+        match action {
+            Action::PushBack(x) => {
+                list.push_back(x.clone());
+            }
+            Action::PushFront(x) => {
+                list.push_front(x.clone());
+            }
+            Action::PopBack => {
+                _ = list.pop_back();
+            }
+            Action::PopFront => {
+                _ = list.pop_front();
+            }
+        }
+    }
+}
+
+fn std_linked_list(list: &std::collections::LinkedList<String>) -> i64 {
+    list.iter()
+        .enumerate()
+        .map(|(i, x)| match i % 2 {
+            0 => x.len() as i64,
+            _ => -(x.len() as i64),
+        })
+        .sum()
+}
+
+fn fill_vec_deque(actions: &[Action], list: &mut std::collections::VecDeque<String>) {
+    for action in actions {
+        match action {
+            Action::PushBack(x) => {
+                list.push_back(x.clone());
+            }
+            Action::PushFront(x) => {
+                list.push_front(x.clone());
+            }
+            Action::PopBack => {
+                _ = list.pop_back();
+            }
+            Action::PopFront => {
+                _ = list.pop_front();
+            }
+        }
+    }
+}
+
+fn std_vec_deque(list: &std::collections::VecDeque<String>) -> i64 {
+    list.iter()
+        .enumerate()
+        .map(|(i, x)| match i % 2 {
+            0 => x.len() as i64,
+            _ => -(x.len() as i64),
+        })
+        .sum()
+}
+
+fn bench(c: &mut Criterion) {
+    let treatments = vec![1_024 * 64 * 4];
+
+    let mut group = c.benchmark_group("doubly_iter");
+
+    for n in &treatments {
+        let data = get_test_data(*n);
+
+        let mut std_list = std::collections::LinkedList::new();
+        fill_std_linked_list(&data, &mut std_list);
+        let expected = std_linked_list(&std_list);
+
+        group.bench_with_input(BenchmarkId::new("LinkedList", n), n, |b, _| {
+            let mut std_list = std::collections::LinkedList::new();
+            fill_std_linked_list(&data, &mut std_list);
+            b.iter(|| {
+                let result = std_linked_list(&std_list);
+                assert_eq!(result, expected);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("VecDeque", n), n, |b, _| {
+            let mut list = std::collections::VecDeque::new();
+            fill_vec_deque(&data, &mut list);
+            b.iter(|| {
+                let result = std_vec_deque(&list);
+                assert_eq!(result, expected);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("DoublyList", n), n, |b, _| {
+            let mut list = DoublyList::new();
+            fill_doubly_list(&data, &mut list);
+            b.iter(|| {
+                let result = doubly_iter(&list);
+                assert_eq!(result, expected);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("DoublyList(x)", n), n, |b, _| {
+            let mut list = DoublyList::new();
+            fill_doubly_list(&data, &mut list);
+            b.iter(|| {
+                let _result = doubly_iter_x(&list);
+                // assert_eq!(result, expected);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);