mlxrs 0.1.0

Safe Rust bindings for Apple's MLX array framework, with LM, VLM, audio, and embeddings support
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Method-form bridges for the extended linalg ops.

use std::ffi::CStr;

use crate::{array::Array, error::Result, ops::linalg_full::Uplo};

impl Array {
  /// Matrix inverse. See [`crate::ops::linalg_full::inv`].
  pub fn inv(&self) -> Result<Array> {
    crate::ops::linalg_full::inv(self)
  }

  /// Triangular inverse. See [`crate::ops::linalg_full::tri_inv`].
  pub fn tri_inv(&self, upper: bool) -> Result<Array> {
    crate::ops::linalg_full::tri_inv(self, upper)
  }

  /// Moore-Penrose pseudo-inverse. See [`crate::ops::linalg_full::pinv`].
  pub fn pinv(&self) -> Result<Array> {
    crate::ops::linalg_full::pinv(self)
  }

  /// Cholesky inverse. See [`crate::ops::linalg_full::cholesky_inv`].
  pub fn cholesky_inv(&self, upper: bool) -> Result<Array> {
    crate::ops::linalg_full::cholesky_inv(self, upper)
  }

  /// Cholesky factor. See [`crate::ops::linalg_full::cholesky`].
  pub fn cholesky(&self, upper: bool) -> Result<Array> {
    crate::ops::linalg_full::cholesky(self, upper)
  }

  /// QR decomposition. See [`crate::ops::linalg_full::qr`].
  pub fn qr(&self) -> Result<(Array, Array)> {
    crate::ops::linalg_full::qr(self)
  }

  /// Singular value decomposition. See [`crate::ops::linalg_full::svd`].
  pub fn svd(&self, compute_uv: bool) -> Result<Vec<Array>> {
    crate::ops::linalg_full::svd(self, compute_uv)
  }

  /// LU decomposition (`[P, L, U]`). See [`crate::ops::linalg_full::lu`].
  pub fn lu(&self) -> Result<Vec<Array>> {
    crate::ops::linalg_full::lu(self)
  }

  /// Pivoted LU factorization. See [`crate::ops::linalg_full::lu_factor`].
  pub fn lu_factor(&self) -> Result<(Array, Array)> {
    crate::ops::linalg_full::lu_factor(self)
  }

  /// Solve `self @ x = b` for `x`. See [`crate::ops::linalg_full::solve`].
  pub fn solve(&self, b: &Array) -> Result<Array> {
    crate::ops::linalg_full::solve(self, b)
  }

  /// Solve triangular `self @ x = b`. See [`crate::ops::linalg_full::solve_triangular`].
  pub fn solve_triangular(&self, b: &Array, upper: bool) -> Result<Array> {
    crate::ops::linalg_full::solve_triangular(self, b, upper)
  }

  /// Eigendecomposition (general). See [`crate::ops::linalg_full::eig`].
  pub fn eig(&self) -> Result<(Array, Array)> {
    crate::ops::linalg_full::eig(self)
  }

  /// Eigendecomposition (symmetric / Hermitian). See [`crate::ops::linalg_full::eigh`].
  pub fn eigh(&self, uplo: Uplo) -> Result<(Array, Array)> {
    crate::ops::linalg_full::eigh(self, uplo)
  }

  /// Eigenvalues only (general). See [`crate::ops::linalg_full::eigvals`].
  pub fn eigvals(&self) -> Result<Array> {
    crate::ops::linalg_full::eigvals(self)
  }

  /// Eigenvalues only (symmetric / Hermitian). See [`crate::ops::linalg_full::eigvalsh`].
  pub fn eigvalsh(&self, uplo: Uplo) -> Result<Array> {
    crate::ops::linalg_full::eigvalsh(self, uplo)
  }

  /// p-norm reduction. See [`crate::ops::linalg_full::norm`].
  pub fn norm(&self, ord: f64, axis: &[i32], keepdims: bool) -> Result<Array> {
    crate::ops::linalg_full::norm(self, ord, axis, keepdims)
  }

  /// String-named matrix norm. See [`crate::ops::linalg_full::norm_matrix`].
  pub fn norm_matrix(&self, ord: &CStr, axis: &[i32], keepdims: bool) -> Result<Array> {
    crate::ops::linalg_full::norm_matrix(self, ord, axis, keepdims)
  }

  /// L2 / Frobenius norm. See [`crate::ops::linalg_full::norm_l2`].
  pub fn norm_l2(&self, axis: &[i32], keepdims: bool) -> Result<Array> {
    crate::ops::linalg_full::norm_l2(self, axis, keepdims)
  }

  /// Cross product. See [`crate::ops::linalg_full::cross`].
  pub fn cross(&self, b: &Array, axis: i32) -> Result<Array> {
    crate::ops::linalg_full::cross(self, b, axis)
  }
}