Rstats crates.io GitHub last commit Actions Status

Statistics, Information Measures, Vector Algebra, Linear Algebra, Cholesky Matrix Decomposition, Mahalanobis Distance, Householder QR Decomposition, Multidimensional Data Analysis, Geometric Median, Hulls, Machine Learning, Multithreading ...

Usage

Insert Rstats = "^1" in the Cargo.toml file, under [dependencies].

Use in your source files any of the following structs, as and when needed:

rust use Rstats::{RE,TriangMat,Mstats,MinMax};

and any of the following traits:

rust use Rstats::{Stats,Vecg,Vecu8,MutVecg,VecVec,VecVecg};

and any of the following auxiliary functions:

rust use Rstats::{noop,fromop,sumn,st_error,unit_matrix};

The latest (nightly) version is always available in the github repository Rstats. Sometimes it may be only in some details a little ahead of the crates.io release versions.

It is highly recommended to read and run tests.rs for examples of usage. To run all the tests, use a single thread in order not to print the results in confusing mixed-up order:

bash cargo test --release -- --test-threads=1 --nocapture

However, geometric_medians, which compares multithreading performance, should be run separately in multiple threads, as follows:

bash cargo test -r geometric_medians -- --nocapture

Alternatively, just to get a quick idea of the methods provided and their usage, read the output produced by an automated test run. There are test logs generated for each new push to the github repository. Click the latest (top) one, then Rstats and then Run cargo test ... The badge at the top of this document lights up green when all the tests have passed and clicking it gets you to these logs as well.

Any compilation errors arising out of rstats crate indicate most likely that some of the dependencies are out of date. Issuing cargo update command will usually fix this.

Introduction

Rstats has a small footprint. Only the best methods are implemented, primarily with Data Analysis and Machine Learning in mind. They include multidimensional ('nd' or 'hyperspace') analysis, i.e. characterising clouds of n points in space of d dimensions.

Several branches of mathematics: statistics, information theory, set theory and linear algebra are combined in this one consistent crate, based on the abstraction that they all operate on the same data objects (here Rust Vecs). The only difference being that an ordering of their components is sometimes assumed (in linear algebra, set theory) and sometimes it is not (in statistics, information theory, set theory).

Rstats begins with basic statistical measures, information measures, vector algebra and linear algebra. These provide self-contained tools for the multidimensional algorithms but are also useful in their own right.

Non analytical (non parametric) statistics is preferred, whereby the 'random variables' are replaced by vectors of real data. Probabilities densities and other parameters are in preference obtained from the real data, not from some assumed distributions.

Linear algebra uses Vec<Vec<T>>, generic data structure capable of representing irregular matrices. Also, struct TriangMat is defined and used for symmetric, anti-symmetric, and triangular matrices, and their transposed versions (for memory efficiency reasons).

Our treatment of multidimensional sets of points is constructed from the first principles. Some original concepts, not found elsewhere, are defined and implemented here (see the terminology section below).

Zero median vectors are generally preferable to the commonly used zero mean vectors.

In n dimensions, many authors 'cheat' by using quasi medians (1-d medians along each axis). Quasi medians are a poor start to stable characterisation of multidimensional data. In a highly dimensional space, they are also slower to compute than is our gm.

Specifically, all such 1d measures are sensitive to the choice of axis and thus are affected by their rotation.

In contrast, our methods based on the true geometric median (gm) are axis (rotation) independent. Also, they are more stable, as medians have a 50% breakdown point (the maximum possible). They are computed here by methods gmedian and its parallel version par_gmedian in trait VecVec and their weighted versions wgmedian and par_wgmedian in trait VecVecg.

Additional Documentation

For more detailed comments, plus some examples, see rstats in docs.rs. You may have to go directly to the modules source. These traits are implemented for existing 'out of this crate' rust Vec type and rust docs do not display 'implementations on foreign types' very well.

Terminology (including some original new definitions)

New Concepts and their Definitions

Existing Concepts

Implementation

The main constituent parts of Rstats are its traits. The selection of traits (to use) is primarily determined by the types of objects handled. These are mostly vectors of arbitrary length/dimensionality (d). The main traits are implementing methods applicable to:

In other words, the traits and their methods operate on arguments of their required categories. In classical statistical terminology, the main categories correspond to the number of 'random variables'.

Vec<Vec<T>> type is used for rectangular matrices (could also have irregular rows).

struct TriangMat is used for symmetric / antisymmetric / transposed / triangular matrices. All TriangMat(s) store only n(n+1)/2 items instead of nn, thus saving significant amounts of memory. Plus their transposed versions only set up a flag that is interpreted by software, instead of unnecessarily rewriting the whole matrix. Thus saving some processing as well. All this is put to a good use in our implementation of the Householder matrix decomposition method.

The vectors' end types (of the actual data) are mostly generic: usually some numeric type. End type f64 is mostly used for the computed results.

Errors

Rstats crate produces custom errors RError:

rust pub enum RError<T> where T:Sized+Debug { /// Insufficient data NoDataError(T), /// Wrong kind/size of data DataError(T), /// Invalid result, such as prevented division by zero ArithError(T), /// Other error converted to RError OtherError(T) }

Each of its enum variants also carries a generic payload T. Most commonly this will be a String message giving more helpful explanation, e.g.:

rust if dif <= 0_f64 { return Err(RError::ArithError(format!( "cholesky needs a positive definite matrix {}", dif ))); };

format!(...) is used to insert values of variables to the payload String, as shown. These potential errors are returned and can then be automatically converted (with ?) to users' own errors. Some such conversions are implemented at the bottom of errors.rs file and used in tests.rs.

There is a type alias shortening return declarations to, e.g.: Result<Vec<f64>,RE>, where

rust pub type RE = RError<String>;

Structs

struct MStats

holds the central tendency of 1d data, e.g. some kind of mean or median, and its spread measure, e.g. standard deviation or 'mad'.

struct TriangMat

holds triangular matrices of all kinds, as described in Implementation section above. Beyond the usual conversion to full matrix form, a number of (the best) Linear Algebra methods are implemented directly on TriangMat, in module triangmat.rs, such as:

Also, some methods implemented for VecVecg produce TriangMat matrices, specifically the covariance/comedience calculations: covar and wcovar. Their results are positive definite, which makes the most efficient Cholesky-Banachiewics decomposition applicable.

Quantify Functions

Most methods in medians::Median trait and hashort methods in indxvec crate require explicit closure to tell them how to quantify user data of any end type T into f64. Variety of different quantifying methods can then be dynamically employed.

For example, in text analysis (&str type), it can be the word length, or the numerical value of its first few bytes, etc. Then we can sort them or find their means/medians/dispersions under these different measures. We do not necessarily want to explicitly store all such quantifications, as data can be voluminous. Rather, we want to be able to compute them on demand.

noop

is a shorthand dummy function to supply to these methods, when the data is already of f64 end type. The second line is the full equivalent version that can be used instead:

rust &mut noop &mut |f:&f64| *f

When T is a primitive type, such as i64, u64, usize, that can only be converted to f64 by explicit truncation, use:

rust &mut |f:&T| *f as f64

fromop

When T is a type convertible by an existing From implementation and f64:From<T> has been duly added everywhere as a trait bound, then you can pass in one of these:

rust &mut fromop &mut |&f| f.into() &mut |f:&T| f.into()

This also works for 'smaller' primitive types.

All other cases were previously only possible with manual implementation written for the (global) From trait for each type T and each different conversion method, whereby the different conversions would conflict. Now the user can simply pass in a custom 'quantify' closure. This generality is obtained at the price of one small inconvenience: using the above closures for the simple cases.

Auxiliary Functions

Trait Stats

One dimensional statistical measures implemented for all numeric end types.

Its methods operate on one slice of generic data and take no arguments. For example, s.amean() returns the arithmetic mean of the data in slice s. These methods are checked and will report RError(s), such as an empty input. This means you have to apply ? to their results to pass the errors up, or explicitly match them to take recovery actions, depending on the error variant.

Included in this trait are:

Note that fast implementation of 1d medians is, as of version 1.1.0, performed by a separate crate medians.

Trait Vecg

Generic vector algebra operations between two slices &[T], &[U] of any (common) length (dimensions). Note that it may be necessary to invoke some using the 'turbofish' ::<type> syntax to indicate the type U of the supplied argument, e.g.: datavec.methodname::<f64>(arg). This is because Rust is currently incapable of inferring its type ('the inference bug').

Methods implemented by this trait:

The simpler methods of this trait are sometimes unchecked (for speed), so some caution with data is advisable.

Trait MutVecg

A select few of the Stats and Vecg methods (e.g. mutable vector addition, subtraction and multiplication) are reimplemented under this trait, so that they can mutate self in-place. This is more efficient and convenient in some circumstances, such as in vector iterative methods.

Trait Vecu8

Some vector algebra as above that can be more efficient when the end type happens to be u8 (bytes). These methods have u8 appended to their names to avoid confusion with Vecg methods. These specific algorithms are different to their generic equivalents in Vecg.

Trait VecVec

Relationships between n vectors (in d dimensions). This (hyper-dimensional) data domain is denoted here as (nd). It is in nd where the main original contribution of this library lies. True geometric median (gm) is found by fast and stable iteration, using improved Weiszfeld's algorithm gmedian. This algorithm solves Weiszfeld's convergence and stability problems in the neighbourhoods of existing set points. Its variant, par_gmedian, employs multithreading for faster execution and gives otherwise exactly the same result.

Trait VecVecg

Methods which take an additional generic vector argument, such as a vector of weights for computing weighted geometric medians (where each point has its own weight). Matrices multiplications.

Appendix: Recent Releases