Struct rgsl::types::matrix_complex::MatrixComplexF64

pub struct MatrixComplexF64 { /* private fields */ }

Implementations

impl MatrixComplexF64

pub fn new(n1: usize, n2: usize) -> Option<Self>

Creates a new MatrixF64.

pub fn new_with_init(n1: usize, n2: usize) -> Option<Self>

Creates a new MatrixF64 with all elements set to zero.

pub fn get(&self, y: usize, x: usize) -> ComplexF64

This function returns the (i,j)-th element of the matrix. If y or x lie outside the allowed range of 0 to n1-1 and 0 to n2-1 then the error handler is invoked and 0 is returned.

pub fn set(&mut self, y: usize, x: usize, value: &ComplexF64) -> &Self

This function sets the value of the (i,j)-th element of the matrix to value. If y or x lies outside the allowed range of 0 to n1-1 and 0 to n2-1 then the error handler is invoked.

pub fn set_all(&mut self, x: &ComplexF64) -> &Self

This function sets all the elements of the matrix to the value x.

pub fn set_zero(&mut self) -> &Self

This function sets all the elements of the matrix to zero.

pub fn set_identity(&mut self) -> &Self

This function sets the elements of the matrix to the corresponding elements of the identity matrix, m(i,j) = \delta(i,j), i.e. a unit diagonal with all off-diagonal elements zero. This applies to both square and rectangular matrices.

pub fn copy_from(&mut self, other: &MatrixComplexF64) -> Value

This function copies the elements of the other matrix into the self matrix. The two matrices must have the same size.

pub fn copy_to(&self, other: &mut MatrixComplexF64) -> Value

This function copies the elements of the self matrix into the other matrix. The two matrices must have the same size.

pub fn swap(&mut self, other: &mut MatrixComplexF64) -> Value

This function exchanges the elements of the matrices self and other by copying. The two matrices must have the same size.

pub fn get_row(&self, y: usize) -> Option<(Value, VectorComplexF64)>

This function copies the elements of the y-th row of the matrix into the returned vector.

pub fn get_col(&self, x: usize) -> Option<(Value, VectorComplexF64)>

This function copies the elements of the x-th column of the matrix into the returned vector.

pub fn set_row(&mut self, y: usize, v: &VectorComplexF64) -> Value

This function copies the elements of the vector v into the y-th row of the matrix. The length of the vector must be the same as the length of the row.

pub fn set_col(&mut self, x: usize, v: &VectorComplexF64) -> Value

This function copies the elements of the vector v into the x-th column of the matrix. The length of the vector must be the same as the length of the column.

pub fn swap_rows(&mut self, y1: usize, y2: usize) -> Value

This function exchanges the y1-th and y2-th rows of the matrix in-place.

pub fn swap_columns(&mut self, x1: usize, x2: usize) -> Value

This function exchanges the x1-th and x2-th columns of the matrix in-place.

pub fn swap_row_col(&mut self, i: usize, j: usize) -> Value

This function exchanges the i-th row and j-th column of the matrix in-place. The matrix must be square for this operation to be possible.

pub fn transpose_memcpy(&self) -> Option<(Value, MatrixComplexF64)>

This function returns the transpose of the matrix by copying the elements into it. This function works for all matrices provided that the dimensions of the matrix dest match the transposed dimensions of the matrix.

pub fn transpose(&mut self) -> Value

This function replaces the matrix m by its transpose by copying the elements of the matrix in-place. The matrix must be square for this operation to be possible.

pub fn add(&mut self, other: &MatrixComplexF64) -> Value

This function adds the elements of the other matrix to the elements of the self matrix. The result self(i,j) <- self(i,j) + other(i,j) is stored in self and other remains unchanged. The two matrices must have the same dimensions.

pub fn sub(&mut self, other: &MatrixComplexF64) -> Value

This function subtracts the elements of the other matrix from the elements of the self matrix. The result self(i,j) <- self(i,j) - other(i,j) is stored in self and other remains unchanged. The two matrices must have the same dimensions.

pub fn mul_elements(&mut self, other: &MatrixComplexF64) -> Value

This function multiplies the elements of the self matrix by the elements of the other matrix. The result self(i,j) <- self(i,j) * other(i,j) is stored in self and other remains unchanged. The two matrices must have the same dimensions.

pub fn div_elements(&mut self, other: &MatrixComplexF64) -> Value

This function divides the elements of the self matrix by the elements of the other matrix. The result self(i,j) <- self(i,j) / other(i,j) is stored in self and other remains unchanged. The two matrices must have the same dimensions.

pub fn scale(&mut self, x: &ComplexF64) -> Value

This function multiplies the elements of the self matrix by the constant factor x. The result self(i,j) <- x self(i,j) is stored in self.

pub fn add_constant(&mut self, x: &ComplexF64) -> Value

This function adds the constant value x to the elements of the self matrix. The result self(i,j) <- self(i,j) + x is stored in self.

pub fn is_null(&self) -> bool

This function returns true if all the elements of the self matrix are stricly zero.

pub fn is_pos(&self) -> bool

This function returns true if all the elements of the self matrix are stricly positive.

pub fn is_neg(&self) -> bool

This function returns true if all the elements of the self matrix are stricly negative.

pub fn is_non_neg(&self) -> bool

This function returns true if all the elements of the self matrix are stricly non-negative.

pub fn equal(&self, other: &MatrixComplexF64) -> bool

This function returns true if all elements of the two matrix are equal.

pub fn row<F: FnOnce(Option<VectorComplexF64View<'_>>)>(
    &mut self,
    i: usize,
    f: F
)

pub fn column<F: FnOnce(Option<VectorComplexF64View<'_>>)>(
    &mut self,
    j: usize,
    f: F
)

pub fn diagonal<F: FnOnce(Option<VectorComplexF64View<'_>>)>(&mut self, f: F)

pub fn subdiagonal<F: FnOnce(Option<VectorComplexF64View<'_>>)>(
    &mut self,
    k: usize,
    f: F
)

pub fn superdiagonal<F: FnOnce(Option<VectorComplexF64View<'_>>)>(
    &mut self,
    k: usize,
    f: F
)

pub fn subrow<F: FnOnce(Option<VectorComplexF64View<'_>>)>(
    &mut self,
    i: usize,
    offset: usize,
    n: usize,
    f: F
)

pub fn subcolumn<F: FnOnce(Option<VectorComplexF64View<'_>>)>(
    &mut self,
    i: usize,
    offset: usize,
    n: usize,
    f: F
)

pub fn size1(&self) -> usize

pub fn size2(&self) -> usize

pub fn clone(&self) -> Option<Self>

Trait Implementations

impl Debug for MatrixComplexF64

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

Formats the value using the given formatter.

impl Drop for MatrixComplexF64

fn drop(&mut self)

Executes the destructor for this type.