pub struct Matrix {
pub data: Vec<f64>,
pub row: usize,
pub col: usize,
pub shape: Shape,
}
Expand description
R-like matrix structure
§Examples
use peroxide::fuga::*;
let a = Matrix {
data: vec![1f64,2f64,3f64,4f64],
row: 2,
col: 2,
shape: Row,
}; // [[1,2],[3,4]]
Fields§
§data: Vec<f64>
§row: usize
§col: usize
§shape: Shape
Implementations§
source§impl Matrix
impl Matrix
Main matrix structure
sourcepub fn as_slice(&self) -> &[f64]
pub fn as_slice(&self) -> &[f64]
Slice of self.data
§Examples
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4], 2, 2, Col);
let b = a.as_slice();
assert_eq!(b, &[1f64,2f64,3f64,4f64]);
sourcepub fn as_mut_slice(&mut self) -> &mut [f64]
pub fn as_mut_slice(&mut self) -> &mut [f64]
Mutable slice of self.data
§Examples
use peroxide::fuga::*;
let mut a = matrix(vec![1,2,3,4], 2, 2, Col);
let mut b = a.as_mut_slice();
b[0] = 5f64;
assert_eq!(b, &[5f64, 2f64, 3f64, 4f64]);
assert_eq!(a, matrix(vec![5,2,3,4], 2, 2, Col));
sourcepub fn change_shape(&self) -> Self
pub fn change_shape(&self) -> Self
Change Bindings
Row
-> Col
or Col
-> Row
§Examples
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a.shape, Row);
let b = a.change_shape();
assert_eq!(b.shape, Col);
sourcepub fn change_shape_mut(&mut self)
pub fn change_shape_mut(&mut self)
Change Bindings Mutably
Row
-> Col
or Col
-> Row
§Examples
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a.shape, Row);
let b = a.change_shape();
assert_eq!(b.shape, Col);
sourcepub fn spread(&self) -> String
pub fn spread(&self) -> String
Spread data(1D vector) to 2D formatted String
§Examples
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4],2,2,Row);
println!("{}", a.spread()); // same as println!("{}", a);
// Result:
// c[0] c[1]
// r[0] 1 3
// r[1] 2 4
sourcepub fn col(&self, index: usize) -> Vec<f64>
pub fn col(&self, index: usize) -> Vec<f64>
Extract Column
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix(c!(1,2,3,4), 2, 2, Row);
assert_eq!(a.col(0), c!(1,3));
}
sourcepub fn row(&self, index: usize) -> Vec<f64>
pub fn row(&self, index: usize) -> Vec<f64>
Extract Row
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix(c!(1,2,3,4), 2, 2, Row);
assert_eq!(a.row(0), c!(1,2));
}
sourcepub fn diag(&self) -> Vec<f64>
pub fn diag(&self) -> Vec<f64>
Extract diagonal components
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(a.diag(), c!(1,4));
}
sourcepub fn transpose(&self) -> Self
pub fn transpose(&self) -> Self
Transpose
§Examples
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4], 2, 2, Row);
println!("{}", a); // [[1,3],[2,4]]
sourcepub fn t(&self) -> Self
pub fn t(&self) -> Self
R-like transpose function
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(a.transpose(), a.t());
}
sourcepub fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix
pub fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix
From index operations
pub fn to_diag(&self) -> Matrix
sourcepub fn submat(&self, start: (usize, usize), end: (usize, usize)) -> Matrix
pub fn submat(&self, start: (usize, usize), end: (usize, usize)) -> Matrix
Submatrix
§Description
Return below elements of matrix to new matrix
$$ \begin{pmatrix} \ddots & & & & \\ & start & \cdots & end.1 & \\ & \vdots & \ddots & \vdots & \\ & end.0 & \cdots & end & \\ & & & & \ddots \end{pmatrix} $$
§Examples
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("1 2 3;4 5 6;7 8 9");
let b = ml_matrix("5 6;8 9");
let c = a.submat((1, 1), (2, 2));
assert_eq!(b, c);
}
sourcepub fn subs_mat(
&mut self,
start: (usize, usize),
end: (usize, usize),
m: &Matrix,
)
pub fn subs_mat( &mut self, start: (usize, usize), end: (usize, usize), m: &Matrix, )
Substitute matrix to specific position
§Description
Substitute below elements of matrix
$$ \begin{pmatrix} \ddots & & & & \\ & start & \cdots & end.1 & \\ & \vdots & \ddots & \vdots & \\ & end.0 & \cdots & end & \\ & & & & \ddots \end{pmatrix} $$
§Examples
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let mut a = ml_matrix("1 2 3;4 5 6;7 8 9");
let b = ml_matrix("1 2;3 4");
let c = ml_matrix("1 2 3;4 1 2;7 3 4");
a.subs_mat((1,1), (2,2), &b);
assert_eq!(a, c);
}
sourcepub fn from_series(
series: &Series,
row: usize,
col: usize,
shape: Shape,
) -> Self
pub fn from_series( series: &Series, row: usize, col: usize, shape: Shape, ) -> Self
Matrix from series
§Example
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = Series::new(c!(1,2,3,4));
let m = Matrix::from_series(&a, 2, 2, Row);
assert_eq!(m, matrix(c!(1,2,3,4), 2, 2, Row));
}
Trait Implementations§
source§impl Add<Matrix> for f64
impl Add<Matrix> for f64
Element-wise addition between f64 & matrix
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(1f64 + a, matrix!(2;5;1, 2, 2, Row));
}
source§impl Add<Matrix> for i32
impl Add<Matrix> for i32
Element-wise addition between i32 & Matrix
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(1 + a, matrix!(2;5;1, 2, 2, Row));
}
source§impl Add<Matrix> for usize
impl Add<Matrix> for usize
Element-wise addition between usize & matrix
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(1usize + a, matrix!(2;5;1, 2, 2, Row));
}
source§impl<T> Add<T> for Matrix
impl<T> Add<T> for Matrix
Element-wise addition between Matrix & f64
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(a + 1, matrix!(2;5;1, 2, 2, Row));
}
source§impl Add for Matrix
impl Add for Matrix
Element-wise addition of Matrix
§Caution
You should remember ownership. If you use Matrix
a,b
then you can’t use them after.
source§impl FPMatrix for Matrix
impl FPMatrix for Matrix
source§fn col_map<F>(&self, f: F) -> Matrix
fn col_map<F>(&self, f: F) -> Matrix
Column map
§Example
use peroxide::fuga::*;
fn main() {
let x = ml_matrix("1 2;3 4;5 6");
let y = x.col_map(|c| c.fmap(|t| t - c.mean()));
assert_eq!(y, ml_matrix("-2 -2;0 0;2 2"));
}
source§fn row_map<F>(&self, f: F) -> Matrix
fn row_map<F>(&self, f: F) -> Matrix
Row map
§Example
use peroxide::fuga::*;
fn main() {
let x = ml_matrix("1 2 3;4 5 6");
let y = x.row_map(|r| r.fmap(|t| t - r.mean()));
assert_eq!(y, ml_matrix("-1 0 1;-1 0 1"));
}
fn take_row(&self, n: usize) -> Self
fn take_col(&self, n: usize) -> Self
fn skip_row(&self, n: usize) -> Self
fn skip_col(&self, n: usize) -> Self
fn fmap<F>(&self, f: F) -> Matrix
fn col_mut_map<F>(&mut self, f: F)
fn row_mut_map<F>(&mut self, f: F)
fn reduce<F, T>(&self, init: T, f: F) -> f64
fn zip_with<F>(&self, f: F, other: &Matrix) -> Self
fn col_reduce<F>(&self, f: F) -> Vec<f64>
fn row_reduce<F>(&self, f: F) -> Vec<f64>
source§impl Index<(usize, usize)> for Matrix
impl Index<(usize, usize)> for Matrix
Index for Matrix
(usize, usize) -> f64
§Examples
extern crate peroxide;
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a[(0,1)], 2f64);
source§impl IndexMut<(usize, usize)> for Matrix
impl IndexMut<(usize, usize)> for Matrix
IndexMut for Matrix (Assign)
(usize, usize) -> f64
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let mut a = matrix!(1;4;1, 2, 2, Row);
a[(1,1)] = 10.0;
assert_eq!(a, matrix(c!(1,2,3,10), 2, 2, Row));
}
source§impl LinearAlgebra for Matrix
impl LinearAlgebra for Matrix
source§fn lu(&self) -> PQLU
fn lu(&self) -> PQLU
LU Decomposition Implements (Complete Pivot)
§Description
It use complete pivoting LU decomposition. You can get two permutations, and LU matrices.
§Caution
It returns Option<PQLU>
- You should unwrap to obtain real value.
PQLU
has four field - p
, q
, l
, u
.
p
, q
are permutations.
l
, u
are matrices.
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix(vec![1,2,3,4], 2, 2, Row);
let pqlu = a.lu();
let (p,q,l,u) = (pqlu.p, pqlu.q, pqlu.l, pqlu.u);
assert_eq!(p, vec![1]); // swap 0 & 1 (Row)
assert_eq!(q, vec![1]); // swap 0 & 1 (Col)
assert_eq!(l, matrix(c!(1,0,0.5,1),2,2,Row));
assert_eq!(u, matrix(c!(4,3,0,-0.5),2,2,Row));
}
source§fn qr(&self) -> QR
fn qr(&self) -> QR
QR Decomposition
Translation of RosettaCode#Python
§Example
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("12 -51 4;6 167 -68; -4 24 -41");
let qr = a.qr();
let r = ml_matrix("-14 -21 14; 0 -175 70; 0 0 -35");
#[cfg(feature="O3")]
{
assert_eq!(r, qr.r);
}
qr.r.print();
}
source§fn svd(&self) -> SVD
fn svd(&self) -> SVD
Singular Value Decomposition
§Examples
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("3 2 2;2 3 -2");
#[cfg(feature="O3")]
{
let svd = a.svd();
assert!(eq_vec(&vec![5f64, 3f64], &svd.s, 1e-7));
}
a.print();
}
source§fn rref(&self) -> Matrix
fn rref(&self) -> Matrix
Reduced Row Echelon Form
Implementation of RosettaCode
source§fn det(&self) -> f64
fn det(&self) -> f64
Determinant
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(a.det(), -2f64);
}
source§fn block(&self) -> (Self, Self, Self, Self)
fn block(&self) -> (Self, Self, Self, Self)
Block Partition
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;16;1, 4, 4, Row);
let (m1, m2, m3, m4) = a.block();
assert_eq!(m1, matrix(c!(1,2,5,6), 2, 2, Row));
assert_eq!(m2, matrix(c!(3,4,7,8), 2, 2, Row));
assert_eq!(m3, matrix(c!(9,10,13,14), 2, 2, Row));
assert_eq!(m4, matrix(c!(11,12,15,16), 2, 2, Row));
let b = matrix!(1;16;1, 4, 4, Col);
let (m1, m2, m3, m4) = b.block();
assert_eq!(m1, matrix(c!(1,2,5,6), 2, 2, Col));
assert_eq!(m3, matrix(c!(3,4,7,8), 2, 2, Col));
assert_eq!(m2, matrix(c!(9,10,13,14), 2, 2, Col));
assert_eq!(m4, matrix(c!(11,12,15,16), 2, 2, Col));
}
source§fn inv(&self) -> Self
fn inv(&self) -> Self
Inverse of Matrix
§Caution
inv
function returns Option<Matrix>
Thus, you should use pattern matching or unwrap
to obtain inverse.
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
// Non-singular
let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(a.inv(), matrix(c!(-2,1,1.5,-0.5),2,2,Row));
// Singular
//let b = matrix!(1;9;1, 3, 3, Row);
//let c = b.inv(); // Can compile but..
//let d = b.det();
//assert_eq!(d, 0f64);
}
source§fn pseudo_inv(&self) -> Self
fn pseudo_inv(&self) -> Self
source§fn solve(&self, b: &Vec<f64>, sk: SolveKind) -> Vec<f64>
fn solve(&self, b: &Vec<f64>, sk: SolveKind) -> Vec<f64>
Solve with Vector
§Solve options
- LU: Gaussian elimination with Complete pivoting LU (GECP)
- WAZ: Solve with WAZ decomposition
§Reference
- Biswa Nath Datta, Numerical Linear Algebra and Applications, Second Edition
- Ke Chen, Matrix Preconditioning Techniques and Applications, Cambridge Monographs on Applied and Computational Mathematics
fn waz(&self, d_form: Form) -> Option<WAZD>
fn solve_mat(&self, m: &Matrix, sk: SolveKind) -> Matrix
fn is_symmetric(&self) -> bool
source§impl LinearOp<Vec<f64>, Vec<f64>> for Matrix
impl LinearOp<Vec<f64>, Vec<f64>> for Matrix
TODO: Transpose Matrix as Linear operator for Vector
source§impl MatrixProduct for Matrix
impl MatrixProduct for Matrix
source§impl MatrixPtr for Matrix
impl MatrixPtr for Matrix
source§unsafe fn row_ptr(&self, idx: usize) -> Vec<*const f64>
unsafe fn row_ptr(&self, idx: usize) -> Vec<*const f64>
Row pointer
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("1 2;3 4");
unsafe {
let b = a.row_ptr(1);
let b_vec = ptr_to_vec(&b);
assert_eq!(b_vec, vec![3f64, 4f64]);
}
}
unsafe fn col_ptr(&self, idx: usize) -> Vec<*const f64>
source§impl Mul<Matrix> for Vec<f64>
impl Mul<Matrix> for Vec<f64>
Matrix multiplication for Vec<f64>
vs Matrix
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
let v = c!(1,2);
assert_eq!(v * a, c!(7, 10));
}
source§impl Mul for Matrix
impl Mul for Matrix
Matrix Multiplication
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix!(1;4;1, 2, 2, Row);
let b = matrix!(1;4;1, 2, 2, Col);
assert_eq!(a * b, matrix(c!(5, 11, 11, 25), 2, 2, Row));
}
source§impl Neg for Matrix
impl Neg for Matrix
Negation of Matrix
§Examples
extern crate peroxide;
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4],2,2,Row);
println!("{}", -a); // [[-1,-2],[-3,-4]]
source§impl Scalable for Matrix
impl Scalable for Matrix
Modify Matrix
source§fn reshape(&self, (r, c): (usize, usize), shape: Shape) -> Matrix
fn reshape(&self, (r, c): (usize, usize), shape: Shape) -> Matrix
Resize matrix
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("1 2 3;4 5 6"); // ml_matrix has shape `Col`
let b1 = a.reshape((3, 2), Row);
let b2 = a.reshape((3, 2), Col);
assert_eq!(b1, ml_matrix("1 2;3 4;5 6"));
assert_eq!(b2, ml_matrix("1 4;2 5;3 6"));
}
source§fn add_col(&self, v: &Self::Vec) -> Matrix
fn add_col(&self, v: &Self::Vec) -> Matrix
Add column
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("1 2 3;4 5 6");
let b = c!(7,8);
let c = a.add_col(&b);
assert_eq!(c, ml_matrix("1 2 3 7;4 5 6 8"));
}
source§fn add_row(&self, v: &Self::Vec) -> Matrix
fn add_row(&self, v: &Self::Vec) -> Matrix
Add row
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("1 2 3;4 5 6");
let b = c!(7,8,9);
let c = a.add_row(&b);
assert_eq!(c, ml_matrix("1 2 3;4 5 6;7 8 9"));
}
type Vec = Vec<f64>
source§impl ScalableMut for Matrix
impl ScalableMut for Matrix
source§fn reshape_mut(&mut self, (r, c): (usize, usize), shape: Shape)
fn reshape_mut(&mut self, (r, c): (usize, usize), shape: Shape)
Resize matrix (Mutable)
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let mut a = ml_matrix("1 2 3;4 5 6"); // ml_matrix has shape `Row`
a.reshape_mut((3, 2), Row);
assert_eq!(a, ml_matrix("1 2;3 4;5 6"));
a.reshape_mut((3, 2), Col);
assert_eq!(a, ml_matrix("1 4;2 5;3 6"));
}
source§fn add_col_mut(&mut self, v: &Self::Vec)
fn add_col_mut(&mut self, v: &Self::Vec)
Add column (Mutable)
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let mut a = ml_matrix("1 2 3;4 5 6");
let b = c!(7,8);
a.add_col_mut(&b);
assert_eq!(a, ml_matrix("1 2 3 7;4 5 6 8"));
}
source§fn add_row_mut(&mut self, v: &Self::Vec)
fn add_row_mut(&mut self, v: &Self::Vec)
Add row (Mutable)
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let mut a = ml_matrix("1 2 3;4 5 6");
let b = c!(7,8,9);
a.add_row_mut(&b);
assert_eq!(a, ml_matrix("1 2 3;4 5 6;7 8 9"));
}
type Vec = Vec<f64>
source§impl SimpleNorm for Matrix
impl SimpleNorm for Matrix
Simple Frobenius norm
source§impl SimplerLinearAlgebra for Matrix
impl SimplerLinearAlgebra for Matrix
fn back_subs(&self, b: &Vec<f64>) -> Vec<f64>
fn forward_subs(&self, b: &Vec<f64>) -> Vec<f64>
fn lu(&self) -> PQLU
fn waz_diag(&self) -> Option<WAZD>
fn waz(&self) -> Option<WAZD>
fn qr(&self) -> QR
fn rref(&self) -> Matrix
fn det(&self) -> f64
fn block(&self) -> (Matrix, Matrix, Matrix, Matrix)
fn inv(&self) -> Matrix
fn pseudo_inv(&self) -> Matrix
fn solve(&self, b: &Vec<f64>) -> Vec<f64>
fn solve_mat(&self, m: &Matrix) -> Matrix
fn is_symmetric(&self) -> bool
source§impl Statistics for Matrix
impl Statistics for Matrix
source§fn mean(&self) -> Vec<f64>
fn mean(&self) -> Vec<f64>
Column Mean
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let m = matrix(c!(1,3,3,1), 2, 2, Col);
assert_eq!(m.mean(), c!(2,2));
}
source§fn var(&self) -> Vec<f64>
fn var(&self) -> Vec<f64>
Column variance
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let m = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
assert!(nearly_eq(m.var()[0], 1));
}
source§fn sd(&self) -> Vec<f64>
fn sd(&self) -> Vec<f64>
Column Standard Deviation
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let m = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
assert!(nearly_eq(m.sd()[0], 1));
}
source§fn cov(&self) -> Self
fn cov(&self) -> Self
Covariance Matrix (Column based)
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let m = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
println!("{}", m.cov());
// c[0] c[1]
// r[0] 1.0000 -1.0000
// r[1] -1.0000 1.0000
}
type Array = Matrix
type Value = Vec<f64>
fn cor(&self) -> Self
source§impl Sub<Matrix> for f64
impl Sub<Matrix> for f64
Subtraction Matrix with f64
§Examples
#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a - 1f64, matrix!(0;3;1, 2, 2, Row));
}
source§impl Sub for Matrix
impl Sub for Matrix
Subtraction between Matrix
§Examples
extern crate peroxide;
use peroxide::fuga::*;
let a = matrix(vec![1,2,3,4],2,2,Row);
let b = matrix(vec![1,2,3,4],2,2,Col);
println!("{}", a - b); // [[0, -1], [1, 0]]
source§impl TrigOps for Matrix
impl TrigOps for Matrix
fn sin_cos(&self) -> (Self, Self)
fn sin(&self) -> Self
fn cos(&self) -> Self
fn tan(&self) -> Self
fn sinh(&self) -> Self
fn cosh(&self) -> Self
fn tanh(&self) -> Self
fn asin(&self) -> Self
fn acos(&self) -> Self
fn atan(&self) -> Self
fn asinh(&self) -> Self
fn acosh(&self) -> Self
fn atanh(&self) -> Self
fn asin_acos(&self) -> (Self, Self)
fn asinh_acosh(&self) -> (Self, Self)
impl Numeric<f64> for Matrix
Auto Trait Implementations§
impl Freeze for Matrix
impl RefUnwindSafe for Matrix
impl Send for Matrix
impl Sync for Matrix
impl Unpin for Matrix
impl UnwindSafe for Matrix
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)