#file-io #matlab #bindings #mat

matio-rs

Rust wrapper to MATLAB MAT file I/O library

22 releases (12 stable)

1.4.1 Jun 2, 2025
1.3.3 Jan 14, 2025
1.3.2 Mar 13, 2024
1.3.1 Mar 10, 2023
0.2.0 Jul 11, 2022

#171 in Math

Download history 24/week @ 2025-02-18 38/week @ 2025-02-25 10/week @ 2025-03-04 25/week @ 2025-03-11 19/week @ 2025-03-18 24/week @ 2025-03-25 8/week @ 2025-04-01 19/week @ 2025-04-08 156/week @ 2025-04-15 58/week @ 2025-04-22 35/week @ 2025-04-29 31/week @ 2025-05-06 39/week @ 2025-05-13 9/week @ 2025-05-20 51/week @ 2025-05-27 73/week @ 2025-06-03

183 downloads per month
Used in 25 crates (22 directly)

MIT license

1.5MB
28K SLoC

C 20K SLoC // 0.1% comments FORTRAN Modern 3K SLoC // 0.1% comments Visual Studio Project 1.5K SLoC M4 1K SLoC // 0.4% comments Rust 847 SLoC // 0.1% comments Automake 585 SLoC // 0.2% comments Objective-C 364 SLoC Shell 207 SLoC // 0.1% comments Visual Studio Solution 112 SLoC C++ 10 SLoC // 0.6% comments

Rust wrapper to MATLAB MAT file I/O library

This crate provides bindings and wrappers for MATIO: MATLAB MAT file I/O C library

Dependencies

  • cmake
  • zlib

Installing dependencies on Ubuntu/Debian

sudo apt install cmake zlib1g-dev

Installing dependencies on Windows

Download and install LLVM 15.0.7

winget install cmake
vcpkg install zlib

Set environment variable ZLIB_LIB_DIR to <vcpkg>\packages\zlib_x64-windows\lib


lib.rs:

Rust bindings and wrappers for MATIO

This crate provides bindings and wrappers for MATIO: MATLAB MAT file I/O C library

Examples

Saving to a Mat file

use matio_rs::MatFile;
MatFile::save(data_path)?
.var("a", 1i8)?
.var("b", 2f32)?
.var("c", &vec![3u16; 3])?;

and then loading the data back into Rust

let mat_file = MatFile::load(data_path)?;
let a: i8 = mat_file.var("a")?;
let b: f32 = mat_file.var("b")?;
let c: Vec<u16> = mat_file.var("c")?;

Saving data to a Matlab structure

use matio_rs::{MatFile, Mat, MayBeFrom};
let mat_a = Mat::maybe_from("fa", 123f64)?;
let b = vec![0i32, 1, 2, 3, 4];
let mat_v = Mat::maybe_from("fb", &b)?;
let data = vec![mat_a, mat_v];
let mat_struct = Mat::maybe_from("s", data)?;
let mat_file = MatFile::save(data_path)?;
mat_file.write(mat_struct);

and then loading the structure fields back into Rust variables

use matio_rs::{MatFile, Mat, MayBeInto};
let mat_file = MatFile::load(&data_path)?;
let mat: Mat = mat_file.var("s")?;
let a: f64 = mat
.field("fa")?
.get(0).unwrap()
.maybe_into()?;
let b: Vec<i32> = mat
.field("fb")?
.get(0).unwrap()
.maybe_into()?;

Rust structure with the [MatIO] derive attribute can be dispatched like any other variables:

use matio_rs::{MatFile, MatIO};

#[derive(Debug, Default, MatIO)]
struct SMat {
a: f64,
b: Vec<u32>,
s: Nested,
}
#[derive(Debug, Default, MatIO)]
struct Nested {
a: f64,
b: Vec<u32>,
}
let n = Nested {
a: 1f64,
b: vec![2, 3, 4, 5],
};
let a = SMat {
a: 1f64,
b: vec![2, 3, 4, 5],
s: n,
};
MatFile::save(&file)?.var("a", &a)?;
let aa: SMat = MatFile::load(file)?.var("a")?;

Saving a Rust vector into a 3D Matlab array

use matio_rs::{MatFile, MatArray};
let data: Vec<_> = (0..24).collect();
MatFile::save(&file)?
.array("array", &data, vec![3, 4, 2])?;

nalgebra vectors and matrices can be read from and written to Mat files providing the nalgebra feature

use matio_rs::MatFile;
let na_v = nalgebra::DVector::from_iterator(5, 0..5);
MatFile::save(&file).unwrap().var("na_v", &na_v).unwrap();
let v: nalgebra::DMatrix<i32> = MatFile::load(file).unwrap().var("na_v").unwrap();
use matio_rs::MatFile;
let na_m = nalgebra::DMatrix::from_iterator(3, 2, 0..6);
MatFile::save(&file).unwrap().var("na_m", &na_m).unwrap();
let m: nalgebra::DMatrix<i32> = MatFile::load(file).unwrap().var("na_m").unwrap();

Dependencies

~0.3–5MB
~105K SLoC