Crates.io | datas |
lib.rs | datas |
version | 0.1.8 |
source | src |
created_at | 2023-11-20 21:41:36.787706 |
updated_at | 2024-10-02 16:26:30.894067 |
description | A library for data structures and algorithms and data analisys |
homepage | |
repository | https://github.com/kris007iron/datas |
max_upload_size | |
id | 1042936 |
size | 627,471 |
This Rust library provides statistical, vector algebra, and matrix operations. It includes methods for calculating statistical measures (mean, median, variance, etc.), operations on vectors (addition, dot product, scalar multiplication), and matrix manipulation (addition, multiplication, row swapping, etc.).
The Mean
struct provides statistical functions for both f64
and i64
types and its functions are self-explanatory:
Mean:
mean_f
mean_i
Weighted Average:
weighted_average_f
weighted_average_i
Median:
median_f
median_i
Mode(here i tried some generics usage but i still need some clarification):
mode
: Calculates the mode for any Hash
, Ord
, and Clone
types.mode_f64
: Specialized mode calculation for f64
numbers.Variance and Standard Deviation:
variance_f
variance_i
standard_deviation_f
standard_deviation_i
The CalculusError
struct provides error calculation methods for both f64
and i64
values:
Absolute Error:
absolute_error_f
absolute_error_i
Relative Error:
relative_error_f
relative_error_i
The Vector
struct supports basic vector algebra for both i64
and f64
types:
Creation:
new
: Initializes a new vector with i64
or f64
components.Magnitude:
magnitude
: Computes the magnitude (Euclidean length) of the vector.Addition:
add
: Adds two i64
vectors (mutates the first vector).add_f
: Adds two f64
vectors (mutates the first vector).add_i
: Adds an i64
vector to an f64
vector (mutates the f64
vector).Dot Product:
dot_product
: Computes the dot product of two i64
vectors.dot_product_f
: Computes the dot product of two f64
vectors.dot_product_i
: Computes the dot product between an f64
and i64
vector.Scalar Multiplication:
Mul
trait) for both i64
and f64
scalar multiplication.The Matrix
struct provides support for matrix operations with i64
data types:
Creation:
new
: Initializes a matrix from a Vec<Vec<i64>>
. Returns an error if the rows have inconsistent column sizes.Addition:
add
: Adds two matrices element-wise. Returns an error if the matrices have mismatched dimensions.Row Swapping:
swap_row
: Swaps two rows of the matrix. Returns an error if the row indices are out of bounds.Scalar Multiplication:
scalar_multiplication
: Multiplies each element of the matrix by a scalar.Matrix Multiplication:
matrix_multiplication
: Multiplies two matrices. Returns an error if the number of columns in the first matrix does not match the number of rows in the second matrix.The MatrixError
enum handles errors specific to matrix operations:
InconsistentColumnSizes
: Raised when matrix rows have different column sizes.MultiplicationDimensionMismatch
: Raised when matrix dimensions are incompatible for multiplication.DimensionMismatch
: Raised when matrices have different dimensions during addition.RowOutOfBound
: Raised when trying to swap rows that don't exist.The VectorError
enum handles errors during vector operations:
DimensionMismatch
: Raised when vectors of different dimensions are used in an operation.The library includes comprehensive unit tests, covering:
f64
and i64
.[dependencies]
datas = "0.1.8"
use datas::Mean;
use datas::vector::Vector;
use datas::matrix::Matrix;
// Statistical calculations
let data = vec![1.0, 2.0, 3.0, 4.0];
let mean = Mean::mean_f(&data);
println!("Mean: {}", mean);
// Vector operations
let vec1 = Vector::<i64>::new(vec![1, 2, 3]);
let vec2 = Vector::<i64>::new(vec![4, 5, 6]);
let dot_product = vec1.dot_product(&vec2).unwrap();
println!("Dot product: {}", dot_product);
// Matrix operations
let matrix1 = Matrix::<i64>::new(vec![vec![1, 2], vec![3, 4]]).unwrap();
let matrix2 = Matrix::<i64>::new(vec![vec![2, 0], vec![1, 2]]).unwrap();
let product = matrix1.matrix_multiplication(&matrix2).unwrap();
println!("Matrix Product: {:?}", product);
This library offers efficient and flexible handling of common statistical, vector-based, and matrix-based operations, making it a powerful tool for mathematical computation in Rust projects. Contributions are welcome, as I aim to expand functionality and improve generic handling.