Upgrade pinned vector dependencies and concurrent iter

Upgrades PinnedVec for improved safety guarantees: https://github.com/orxfun/orx-pinned-vec/releases/tag/3.21.0

Upgrades ConcurrentIter for fused iterator behavior of the concurrent iter implementation: https://github.com/orxfun/orx-concurrent-iter/releases/tag/3.3.0

Performance optimization on From<Vec<T>> for split vectors with doubling growth. Further, this optimization relaxes the T: Clone requirement on the implementation. Thanks @TechnoPorg .

Extend ConcurrentPinnedVec api with IntoIter

Merge pull request #89 from orxfun/into-iter-for-concurrent-pinned-vec

Into iter for concurrent pinned vec

Extend ConcurrentPinnedVec api to support concurrent queues.

Merge pull request #86 from orxfun/support-for-concurrent-queue

Support for concurrent queue

Upgrade concurrent iterator dependency

Upgrades to latest concurrent iterator version, enabling new parallelization features.

Upgrade concurrent iterator dependency

Merge pull request #84 from orxfun/new-concurrent-iter-version

New concurrent iter version

Parallelization

Support for Parallelization

Concurrent iterator optimized for the split vector is implemented. This enables parallel computation over split vector elements.

Concurrent Iterator

Concurrent iterator over references of split vector is implemented. Furthermore, a consuming concurrent iterator yielding owned elements is implemented.

impl<'a, T, G> IntoConcurrentIter<Item = &'a T> for &'a SplitVec<T, G>
impl<'a, T, G> IntoConcurrentIter<Item = T> for SplitVec<T, G>

They together imply that the split vectors for all growth strategies defined in this crate implement ConcurrentCollection.

This allows for creating concurrent iterators over references of items of the split vector that can be shared among threads.

Parallelization

This applies that the following is automatically implemented:

impl<'a, T, G> IntoParIter<Item = &'a T> for &'a SplitVec<T, G>
impl<'a, T, G> IntoParIter<Item = T> for SplitVec<T, G>

Or in brief, SplitVec<T, G>: ParallelizableCollection<Item = T>.

This means that the split vector can be used as the input source for all parallel computations defined by the ParIter. The benchmarks show that parallelization over the defined concurrent iterators is very efficient.

• split_vec.par() returns a parallel iterator over references to its elements, and
• split_vec.into_par() consumes the vector and returns a parallel iterator of the owned elements.

You may find demonstrations in demo_parallelization and bench_parallelization examples.

2024edition

Changes

Migrated to 2024edition.

32bit support is provided fixing the bugs in boundary checks.

iter_over and iter_over_mut are implemented as a generalization of slicing a vector. Slices and SlicesMut iterators are improved. Test over iterators are extended.

CI action is added.

SplitVec::iter() Revision

Necessary Iterator methods are overwritten in order to improve performance:

• nth is implemented. This also improves the performance of skip. Fixes #75
• last method is implemented to avoid iterating the entire range.
• max and min are implemented to reduce over the fragments' default reductions.
• Similarly, reduction methods fold, reduce, all, any, count are implemented.

In addition, Clone is implemented for the split vector iterator.

Finally, ExactSizeIterator is implemented.

Upgrade PseudoDefault dependency

Merge pull request #72 from orxfun/Upgrade-PseudoDefault-dependency

Upgrade PseudoDefault dependency

Dual license

Merge pull request #70 from orxfun/dual-license

dual-license

SplitVec implements Collection and CollectionMut

3.12.0

Merge pull request #69 from orxfun/SplitVec-implements-Collection-and…