Struct DiagonalMatrix 

pub struct DiagonalMatrix<const N: usize> {
    pub elements: [f64; N],
}

A square, diagonal matrix with N rows and N columns.

matrix.elements[i] is the matrix element $A_{ii}$. All off-diagonal elements are 0.

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;
let a = DiagonalMatrix {
    elements: [-2.0, 3.0],
};

assert_eq!(a[(0, 0)], -2.0);
assert_eq!(a[(0, 1)], 0.0);
assert_eq!(a[(1, 0)], 0.0);
assert_eq!(a[(1, 1)], 3.0);

Fields

elements: [f64; N]

The members of the diagonal of the matrix

Implementations

impl<const N: usize> DiagonalMatrix<N>

pub fn to_dense(self) -> Matrix<N, N>

Construct a dense matrix with the given diagonal.

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;

let a = DiagonalMatrix {
    elements: [-2.0, 3.0],
};
let b = a.to_dense();
assert_eq!(b.rows, [[-2.0, 0.0], [0.0, 3.0]]);

Trait Implementations

impl<const N: usize> Add for DiagonalMatrix<N>

fn add(self, rhs: Self) -> Self

Add two diagonal matrices.

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;
let a = DiagonalMatrix {
    elements: [-3.0, 2.0, -8.0],
};
let b = DiagonalMatrix {
    elements: [4.0, -4.0, 12.0],
};

let c = a + b;
assert_eq!(c[0], 1.0);
assert_eq!(c[1], -2.0);
assert_eq!(c[2], 4.0);

type Output = DiagonalMatrix<N>

The resulting type after applying the + operator.

impl<const N: usize> AddAssign for DiagonalMatrix<N>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const N: usize> Clone for DiagonalMatrix<N>

fn clone(&self) -> DiagonalMatrix<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for DiagonalMatrix<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for DiagonalMatrix<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> GeneralMatrix for DiagonalMatrix<N>

fn zeros() -> Self

Fill a matrix with zeros.

fn shape(&self) -> (usize, usize)

Get the shape of a matrix (n_rows,n_columns).

impl<const N: usize> Index<(usize, usize)> for DiagonalMatrix<N>

fn index(&self, index: (usize, usize)) -> &f64

Index matrix elements by (row, column).

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;
let a = DiagonalMatrix {
    elements: [1.0, 2.0, 3.0],
};
assert_eq!(a[(0, 0)], 1.0);
assert_eq!(a[(1, 1)], 2.0);
assert_eq!(a[(0, 2)], 0.0);
assert_eq!(a[(2, 2)], 3.0);

type Output = f64

The returned type after indexing.

impl<const N: usize> Index<usize> for DiagonalMatrix<N>

fn index(&self, index: usize) -> &f64

Index the diagonal components.

Example

use hoomd_linear_algebra::{SquareMatrix, matrix::DiagonalMatrix};
let a = DiagonalMatrix {
    elements: [1.0, 2.0, 3.0],
};
assert_eq!(a[0], 1.0);
assert_eq!(a[1], 2.0);
assert_eq!(a[2], 3.0);

type Output = f64

The returned type after indexing.

impl<const N: usize> IndexMut<usize> for DiagonalMatrix<N>

fn index_mut(&mut self, index: usize) -> &mut f64

Performs the mutable indexing (container[index]) operation.

impl<const N: usize, const M: usize> MatMul<DiagonalMatrix<M>> for Matrix<N, M>

fn matmul(&self, rhs: &DiagonalMatrix<M>) -> Self::Output

Matrix-diagonal matrix multiplication.

This is equivalent to scaling each column of a Matrix by the corresponding element in a DiagonalMatrix.

Examples

use hoomd_linear_algebra::{
    Full, GeneralMatrix, MatMul,
    matrix::{DiagonalMatrix, Matrix22},
};

let diag = DiagonalMatrix {
    elements: [3.0, 4.0],
};
let a = Matrix22::full(1.0).matmul(&diag);
assert_eq!(a[(0, 1)], 4.0);
assert_eq!(a[(1, 0)], 3.0);

type Output = Matrix<N, M>

The type of the output matrix.

impl<const N: usize> Mul<f64> for DiagonalMatrix<N>

fn mul(self, rhs: f64) -> Self

Multiply a diagonal matrix by a scalar.

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;
let a = DiagonalMatrix {
    elements: [-3.0, 2.0, -8.0],
};

let b = a * 3.0;
assert_eq!(b[0], -9.0);
assert_eq!(b[1], 6.0);
assert_eq!(b[2], -24.0);

type Output = DiagonalMatrix<N>

The resulting type after applying the * operator.

impl<const N: usize> MulAssign<f64> for DiagonalMatrix<N>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<const N: usize> Neg for DiagonalMatrix<N>

fn neg(self) -> Self

Negate a diagonal matrix.

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;
let a = DiagonalMatrix {
    elements: [-3.0, 2.0, -8.0],
};

let b = -a;
assert_eq!(b[0], 3.0);
assert_eq!(b[1], -2.0);
assert_eq!(b[2], 8.0);

type Output = DiagonalMatrix<N>

The resulting type after applying the - operator.

impl<const N: usize> PartialEq for DiagonalMatrix<N>

fn eq(&self, other: &DiagonalMatrix<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Serialize for DiagonalMatrix<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> Sub for DiagonalMatrix<N>

fn sub(self, rhs: Self) -> Self

Subtract two diagonal matrices.

Example

use hoomd_linear_algebra::matrix::DiagonalMatrix;
let a = DiagonalMatrix {
    elements: [-3.0, 2.0, -8.0],
};
let b = DiagonalMatrix {
    elements: [4.0, -4.0, 12.0],
};

let c = a - b;
assert_eq!(c[0], -7.0);
assert_eq!(c[1], 6.0);
assert_eq!(c[2], -20.0);

type Output = DiagonalMatrix<N>

The resulting type after applying the - operator.

impl<const N: usize> SubAssign for DiagonalMatrix<N>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const N: usize> Copy for DiagonalMatrix<N>

impl<const N: usize> StructuralPartialEq for DiagonalMatrix<N>