该功能适用于 RangeInclusive<T>，指定搜索的范围。其二分搜索方法不仅限于特定类型的显式数据。数据探测是通过比较闭包 cmpr 实现的，该闭包从某处捕获一些数据项和目标，并定义它们的比较。数据索引不仅限于 usize。调用中指定的比较器可以很容易地进行逻辑反转，例如 |data_item,target| target.cmp(data_item)。这些方法将对隐式降序排列的数据进行操作。

/// Binary search algoritms implemented on RangeInclusive<T>.
/// Using a closure `cmpr` to sample and compare data to captured target.
pub trait Search<T> {
    /// Unchecked  Ok(first hit) or Err(insert order of a missing item).
    fn binary_by(self, cmpr: impl FnMut(T) -> Ordering) -> Result <T,T>;
    /// Unchecked first hit or insert order, and the final search range.
    fn binary_any(&self, cmpr: impl FnMut(T) -> Ordering) -> (T, Range<T>);
    /// General Binary Search, returns the range of all matching items
    fn binary_all(&self, cmpr: impl FnMut(T)-> Ordering) -> Range<T>;
}

binary_by

在包含范围内进行二分搜索。如果目标不存在，则返回其插入位置为 Err<T>。
与 std::slice::binary_search_by() 相同，但更通用。

binary_any

找到并返回第一个命中项及其最后一个包含范围。返回的范围由 binary_all 使用以限制其搜索所有匹配项。此外，当任何匹配项都行时，也可以单独使用 binary_any。例如，为了迭代解决非线性方程，使用 f64 类型的范围值（参见 tests/tests.rs）。

binary_all

找到所有匹配项的二分搜索。这种实现是独一无二的通用。它也非常快，特别是在长范围内。

在给定的 RangeInclusive<T>（自身）内进行搜索。它可以在功能链式 'builder' 风格 API 中使用，该 API 选择更接近目标的子范围。

范围值可以是任何泛型类型 T（满足列出的限制），例如 usize 用于内存中的索引，u128 用于搜索整个磁盘或互联网，f64 用于解决方程...

比较闭包 cmpr 是将数据与其环境中的目标进行比较。使用闭包可以自定义用户自己数据类型的比较。此外，此代码对目标（和数据）的类型一无所知！

当目标在 self.start 之前时，返回空 self.start..self.start 范围。
当目标在 self.end 之后时，返回 self.end..self.end。
当目标未找到时，则返回 ip..ip，其中 ip 是其插入位置。

否则返回与目标 PartiallyEqual 的所有连续值的范围。

遇到的第一个命中项将位于一些未知数量的匹配项中的任何位置。然后算法在主搜索中找到的第一个命中项两侧进行两次更多二分搜索。这些次要搜索仅在主搜索期间找到的最后一个（最窄）范围内应用。找到两个方向上的第一个非匹配项，给出完整的包含匹配范围。

特质 Indices

use indxvec::{Indices};

本特性的方法实现了对子索引切片的处理，即它们以类型 &[usize]（self）作为输入，并生成新的索引 Vec<usize>、新的数据向量 Vec<T> 或 Vec<f64>，或其他适当的结果。请参阅术语表以了解索引及其操作的描述。

pub trait Indices {
    /// Indices::newindex(n) creates a new index without rePartialOrdering
    fn newindex(n: usize) -> Vec<usize> {
        Vec::from_iter(0..n)
    }
    /// Invert an index - turns a sort order into rank order and vice-versa
    fn invindex(self) -> Vec<usize>;
    /// complement of an index - reverses the ranking order
    fn complindex(self) -> Vec<usize>;
    /// Using a subspace index, projects `v`, into it. 
    fn select<T:Clone>(self, v: &[T]) -> Vec<T>;
    /// Given a complete (sort) index, extracts indicated values from `v`
    fn unindex<T:Clone>(self, v: &[T], ascending: bool) -> Vec<T>;
    /// Correlation coefficient of two &[usize] slices.
    /// Pearsons on raw data, Spearman's when applied to ranks.
    fn ucorrelation(self, v: &[usize]) -> f64;
    /// Potentially useful clone-recast of &[usize] to Vec<f64>
    fn indx_to_f64(self) -> Vec<f64>;
}

Trait Vecops

use indxvec::Vecops;

本特性的方法适用于所有泛型切片 &[T]（数据）。因此，它们将在所有Rust原始数值端类型上工作，例如f64。只要为T实现了通常所需的特性 Ord 和/或 Clone，它们也可以在包含任何任意复杂端类型的切片上工作。这里无法列出所有方法，请参阅 lib.rs 中的声明和 vecops.rs 中的源代码。

Trait Mutops

use indxvec::Mutops;

本特性包含可变逆序和可变排序方法。它们都将输出覆盖到 self 上。当我们不需要保留原始顺序时，这通常是排序的最高效方式。在 Vecops 特性中实现了非破坏性版本。

mutisort

避免对要排序的端类型（如 Ord 或 Partial_Ord）的特性和约束通常很有用。这些约束是“粘性”的，并必须随后应用于所有地方。我们新的 mutisort（插入日志排序）通过使用自定义闭包比较器绕过这些问题。其复杂度是比较器排序可达到的最佳。它几乎与std提供的排序一样快，但它之所以最终更快，只是因为它可以利用不稳定的Rust mem moves。在浮点数上测试表明，mutisort 实际上比数据长度约为4500更快。此外，mutisort 允许仅对指定范围（子切片）内的数据进行排序。

比较器闭包参数可以很容易地反转以执行降序排序。

其非破坏性版本是 Vecops::isort_indexed，它返回显式的排序索引和 Vcops::isort_refs()，它返回按排序顺序的引用 Vec<&T>，这要快一点。这两个版本都不会复制可能庞大的端类型（数据项）。

/// Mutable Operators on `&mut[T]`
pub trait Mutops<T> {
    /// Associated method `part` partitions `s: &mut [&T]` within range `rng`, using comparator `c`.  
    /// Suitable pivot should be selected and placed in `s[rng.start]`.  
    /// Returns the boundaries of the rearranged partitions, (eqstart,gtstart), where  
    /// `rng.start..eqstart` (may be empty) contains references to items lesser than the pivot,  
    /// `gtstart-eqstart` is the number (>= 1) of items equal to the pivot (contains undefined references)  
    /// `gtstart..rng.end` (may be empty) contains references to items greater than the pivot.
    fn part(
        s: &mut [&T],
        rng: &Range<usize>,
        c: &mut impl FnMut(&T, &T) -> Ordering,
    ) -> (usize, usize) {
        // get pivot from the first location
        let pivot = s[rng.start];
        let mut eqstart = rng.start;
        let mut gtstart = eqstart + 1;
        for t in rng.start + 1..rng.end {
            match c(s[t], pivot) {
                Less => {
                    s[eqstart] = s[t];
                    eqstart += 1;
                    s[t] = s[gtstart];
                    gtstart += 1;
                }
                Equal => {
                    s[t] = s[gtstart];
                    gtstart += 1;
                }
                Greater => (),
            }
        }
        (eqstart, gtstart)
    }

    /// partitions by bitmask
    fn part_binary(self, rng: &Range<usize>, bitmask: u64) -> usize
    where
        T: Copy, u64: From<T>;
    /// mutable reversal of &mut[T]
    fn mutrevs(self);
    /// swaps two indexed items into ascending order
    fn mutsorttwo(self, i0: usize, i1: usize) -> bool
    where
        T: PartialOrd;
    /// mutably sorts three indexed items into ascending order
    fn mutsortthree(self, i0: usize, i1: usize, i2: usize)
    where
        T: PartialOrd;
    /// Possibly the fastest sort for long lists. Wrapper for `muthashsortslice`.
    fn muthashsort(self, quantify: impl Copy + Fn(&T) -> f64)
    where
        T: PartialOrd + Clone;
    /// Sorts n items from i in self. Used by muthashsort.
    fn muthashsortslice(
        self,
        i: usize,
        n: usize,
        min: f64,
        max: f64,
        quantify: impl Copy + Fn(&T) -> f64,
    ) where
        T: PartialOrd + Clone;
    /// Mutable insert logsort. Pass in reversed comparator `c` for descending sort
    fn mutisort<F>(self, rng: Range<usize>, c: F)
    where
        T: Copy,
        F: Fn(&T, &T) -> Ordering;
}

Trait Printing

use indxvec::Printing;    // the trait methods
use indxvec::printing::*; // the ANSI colour constants

请参阅 tests/tests.rs 了解使用示例。

适用于打印或写入文件，最多包含不同类型项的4元组、所有类型的Vec和切片以及不规则形状的2D矩阵。

序列化元组： &(T,U)，&(T,U,V)，&(T,U,V,W)
以及切片： &[T]，&[&[T]]，&[Vec<T>]。

此外，wvec将自身的内容作为普通空格分隔的值（.ssv）写入文件，可能会抛出io::Error(s)

fn wvec(self,f:&mut File) -> Result<(), io::Error> where Self: Sized;

同样，pvec输出到stdout

fn pvec(self) where Self: Sized;

上述所有类型都转换为字符串，并可选地进行装饰和着色。包括方法和常量，用于将结果字符串渲染为六种主要加粗ANSI终端颜色。

请注意，所有这些类型在标准Rust中都是不可打印的（它们没有实现Display）。这对初学者来说是一个大障碍。此特质的这些方法将这些类型转换为可打印（可写入）的字符串。

着色方法将相关颜色添加到字符串输出中。这使得测试输出看起来更漂亮，并避免了在生产代码中依赖调试模式。为了对着色进行更精细的控制，从printing::*导入颜色常量，并手动在格式化字符串中使用它们。例如，切换颜色

use indxvec::printing::*; // ANSI colours constants
println!("{GR}green text, {RD}red warning, {BL}feeling blue{UN}");

请注意，所有这些颜色插值都会设置自己的新颜色，而不管之前的设置如何。插值{UN}会将终端重置为默认的前景色渲染。UN会自动附加到颜色方法生成的字符串的末尾rd()..cy()。务必始终以其中一个或显式的{UN}结束。否则，所有后续输出将继续使用最后选择的颜色前景渲染！

println!("Memsearch for {BL}{midval}{UN}, found at: {}", 
    vm.memsearch(midval)
    .map_or_else(||"None".rd(),|x| x.gr())
);

use indxvec::{MinMax,here};