scirs2-linalg 0.4.2

//! Random matrix generation utilities
//!
//! This module provides functions for generating various types of random matrices,
//! which are useful for testing, simulation, and machine learning applications.
//! It leverages the scirs2-core random number generation for enhanced performance
//! and consistency.
//!
//! ## Features
//!
//! * Uniform random matrices
//! * Normal (Gaussian) random matrices
//! * Orthogonal random matrices
//! * Symmetric positive definite random matrices
//! * Structured random matrices (banded, sparse, etc.)
//! * Matrices with specific eigenvalue distributions
//! * Random correlation matrices
//! * Matrices with specific condition numbers
//! * Low-rank matrices
//! * Vandermonde matrices
//! * Permutation matrices
//! * Hilbert matrices
//! * Random polynomials
//! * Sparse random matrices
//! * Special matrix types for machine learning applications
//!
//! ## Examples
//!
//! ```
//! use scirs2_core::ndarray::Array2;
//! use scirs2_linalg::random::{uniform, normal, orthogonal, spd};
//!
//! // Generate 3x3 random uniform matrix with values in [0, 1]
//! let u = uniform::<f64>(3, 3, 0.0, 1.0, None);
//!
//! // Generate 3x3 random normal matrix with mean 0 and std 1
//! let n = normal::<f64>(3, 4, 0.0, 1.0, None);
//!
//! // Generate 4x4 random orthogonal matrix
//! let q = orthogonal::<f64>(4, None);
//!
//! // Generate 3x3 random symmetric positive-definite matrix
//! let s = spd::<f64>(3, 1.0, 10.0, None);
//! ```

use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::numeric::{Float, FromPrimitive, NumAssign, One, Zero};
use scirs2_core::random::{self, ChaCha8Rng, Rng, RngExt, SeedableRng};
use std::iter::Sum;

use crate::decomposition::qr;
use crate::error::LinalgResult;

/// Generate a random matrix with elements from a uniform distribution
///
/// # Arguments
///
/// * `rows` - Number of rows
/// * `cols` - Number of columns
/// * `low` - Lower bound of the uniform distribution
/// * `high` - Upper bound of the uniform distribution
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A matrix of shape (rows, cols) with elements drawn from U(low, high)
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::uniform;
///
/// // Generate a 3x4 matrix with elements from U(0, 1)
/// let rand_mat = uniform::<f64>(3, 4, 0.0, 1.0, None);
/// assert_eq!(rand_mat.shape(), &[3, 4]);
///
/// // Generate a 2x2 matrix with elements from U(-10, 10)
/// let rand_mat = uniform::<f32>(2, 2, -10.0, 10.0, None);
/// assert_eq!(rand_mat.shape(), &[2, 2]);
/// ```
#[allow(dead_code)]
pub fn uniform<F>(rows: usize, cols: usize, low: F, high: F, seed: Option<u64>) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    let range = high - low;
    let mut result = Array2::<F>::zeros((rows, cols));

    for i in 0..rows {
        for j in 0..cols {
            // Generate random value between 0 and 1
            let r: f64 = rng.random_range(0.0..1.0);
            // Scale to range [low..high]
            let val = low + F::from_f64(r).expect("Operation failed") * range;
            result[[i, j]] = val;
        }
    }

    result
}

/// Generate a random matrix with elements from a normal distribution
///
/// # Arguments
///
/// * `rows` - Number of rows
/// * `cols` - Number of columns
/// * `mean` - Mean of the normal distribution
/// * `std` - Standard deviation of the normal distribution
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A matrix of shape (rows, cols) with elements drawn from N(mean, std²)
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::normal;
///
/// // Generate a 3x4 matrix with elements from N(0, 1)
/// let rand_mat = normal::<f64>(3, 4, 0.0, 1.0, None);
/// assert_eq!(rand_mat.shape(), &[3, 4]);
///
/// // Generate a 2x2 matrix with elements from N(5, 2)
/// let rand_mat = normal::<f32>(2, 2, 5.0, 2.0, None);
/// assert_eq!(rand_mat.shape(), &[2, 2]);
/// ```
/// Generate a random matrix with standard normal distribution (mean=0, std=1)
///
/// This is a convenience function equivalent to `normal(shape.0, shape.1, 0.0, 1.0, seed)`
///
/// # Arguments
///
/// * `shape` - Shape of the matrix (rows, cols)
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A rows×cols matrix with standard normal distribution
#[allow(dead_code)]
pub fn random_normalmatrix<F>(shape: (usize, usize), seed: Option<u64>) -> LinalgResult<Array2<F>>
where
    F: Float + Zero + One + Copy + scirs2_core::numeric::FromPrimitive + NumAssign + 'static,
{
    Ok(normal(shape.0, shape.1, F::zero(), F::one(), seed))
}

#[allow(dead_code)]
pub fn normal<F>(rows: usize, cols: usize, mean: F, std: F, seed: Option<u64>) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    let mut result = Array2::<F>::zeros((rows, cols));

    for i in 0..rows {
        for j in 0..cols {
            // Box-Muller transform for generating normal values
            let u1: f64 = rng.random_range(0.00001..0.99999); // Avoid 0
            let u2: f64 = rng.random_range(0.0..1.0);
            let z0 = (-2.0 * u1.ln()).sqrt() * (2.0 * std::f64::consts::PI * u2).cos();

            // Convert to target float type and scale to desired mean/std
            let val = mean + F::from_f64(z0).expect("Operation failed") * std;
            result[[i, j]] = val;
        }
    }

    result
}

/// Generate a random orthogonal matrix
///
/// Creates a random orthogonal matrix using QR decomposition of a random matrix.
/// The result is a matrix Q where Q^T * Q = I (identity).
///
/// # Arguments
///
/// * `n` - Dimension of the square orthogonal matrix
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn orthogonal matrix
///
/// # Examples
///
/// ```
/// use scirs2_core::ndarray::Array2;
/// // Define a helper function for matrix closeness check
/// fn close_l2(a: &Array2<f64>, b: &Array2<f64>, tol: f64) -> bool {
///     let diff = a - b;
///     let norm = diff.iter().map(|&x| x * x).sum::<f64>().sqrt();
///     norm < tol
/// }
/// use scirs2_linalg::random::orthogonal;
///
/// // Generate a 4x4 random orthogonal matrix
/// let q = orthogonal::<f64>(4, None);
/// assert_eq!(q.shape(), &[4, 4]);
///
/// // Verify orthogonality: Q^T * Q should be close to the identity matrix
/// let qt = q.t();
/// let result = qt.dot(&q);
/// let identity = Array2::<f64>::eye(4);
/// assert!(close_l2(&result, &identity, 1e-10));
/// ```
#[allow(dead_code)]
pub fn orthogonal<F>(n: usize, seed: Option<u64>) -> Array2<F>
where
    F: Float
        + NumAssign
        + FromPrimitive
        + Clone
        + std::fmt::Debug
        + Sum
        + Send
        + Sync
        + scirs2_core::ndarray::ScalarOperand
        + 'static,
{
    // Generate a random matrix with standard normal distribution
    let a = normal(n, n, F::zero(), F::one(), seed);

    // Perform QR decomposition
    let (q, _) = qr(&a.view(), None).expect("Operation failed");

    // Return the orthogonal matrix Q
    q
}

/// Generate a random symmetric positive-definite matrix
///
/// Creates a random SPD matrix by generating a random matrix A and computing A^T * A,
/// then adding a multiple of the identity matrix to ensure all eigenvalues are positive.
///
/// # Arguments
///
/// * `n` - Dimension of the square SPD matrix
/// * `min_eigenval` - Minimum eigenvalue (controls the condition number)
/// * `max_eigenval` - Maximum eigenvalue (controls the condition number)
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn symmetric positive-definite matrix
///
/// # Examples
///
/// ```
/// use scirs2_core::ndarray::Array2;
/// use scirs2_linalg::random::spd;
/// use scirs2_linalg::cholesky;
///
/// // Generate a 3x3 random SPD matrix
/// let a = spd::<f64>(3, 1.0, 10.0, None);
/// assert_eq!(a.shape(), &[3, 3]);
///
/// // Verify that it's symmetric
/// let a_t = a.t();
/// assert!(a.iter().zip(a_t.iter()).all(|(x, y)| (x - y).abs() < 1e-10));
///
/// // Verify that it's positive definite (can be Cholesky decomposed)
/// let result = cholesky(&a.view(), None);
/// assert!(result.is_ok());
/// ```
#[allow(dead_code)]
pub fn spd<F>(n: usize, min_eigenval: F, maxeigenval: F, seed: Option<u64>) -> Array2<F>
where
    F: Float
        + NumAssign
        + FromPrimitive
        + Clone
        + std::fmt::Debug
        + Sum
        + Send
        + Sync
        + scirs2_core::ndarray::ScalarOperand
        + 'static,
{
    // Generate a random matrix
    let a = normal(n, n, F::zero(), F::one(), seed);

    // Compute A^T * A which is guaranteed to be symmetric positive semidefinite
    let at = a.t();
    let mut result = at.dot(&a);

    // Generate random eigenvalues in the specified range
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    let mut diag_values = Array1::<F>::zeros(n);
    for i in 0..n {
        let r: f64 = rng.random_range(0.0..1.0);
        let range = maxeigenval - min_eigenval;
        diag_values[i] = min_eigenval + F::from_f64(r).expect("Operation failed") * range;
    }

    // Add a diagonal matrix to ensure the minimum eigenvalue is min_eigenval
    for i in 0..n {
        result[[i, i]] += diag_values[i];
    }

    result
}

/// Generate a random diagonal matrix
///
/// # Arguments
///
/// * `n` - Dimension of the square diagonal matrix
/// * `low` - Lower bound for diagonal elements
/// * `high` - Upper bound for diagonal elements
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn diagonal matrix with random entries on the diagonal
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::diagonal;
///
/// // Generate a 3x3 diagonal matrix with diagonal elements in [1, 10]
/// let d = diagonal::<f64>(3, 1.0, 10.0, None);
/// assert_eq!(d.shape(), &[3, 3]);
///
/// // Check that off-diagonal elements are zero
/// assert_eq!(d[[0, 1]], 0.0);
/// assert_eq!(d[[1, 0]], 0.0);
/// assert_eq!(d[[1, 2]], 0.0);
/// assert_eq!(d[[2, 1]], 0.0);
/// ```
#[allow(dead_code)]
pub fn diagonal<F>(n: usize, low: F, high: F, seed: Option<u64>) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    // Generate random diagonal elements
    let range = high - low;
    let mut diag = Array1::<F>::zeros(n);
    for i in 0..n {
        let r: f64 = rng.random_range(0.0..1.0);
        diag[i] = low + F::from_f64(r).expect("Operation failed") * range;
    }

    // Create a matrix with these diagonal elements
    let mut result = Array2::<F>::zeros((n, n));
    for i in 0..n {
        result[[i, i]] = diag[i];
    }

    result
}

/// Generate a random banded matrix
///
/// # Arguments
///
/// * `rows` - Number of rows
/// * `cols` - Number of columns
/// * `lower_bandwidth` - Number of subdiagonals
/// * `upper_bandwidth` - Number of superdiagonals
/// * `low` - Lower bound for elements
/// * `high` - Upper bound for elements
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A rows×cols banded matrix with the specified bandwidths
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::banded;
///
/// // Generate a 5x5 tridiagonal matrix (1 subdiagonal, 1 superdiagonal)
/// let tri = banded::<f64>(5, 5, 1, 1, -1.0, 1.0, None);
/// assert_eq!(tri.shape(), &[5, 5]);
///
/// // Elements outside the band should be zero
/// assert_eq!(tri[[0, 2]], 0.0); // Outside upper bandwidth
/// assert_eq!(tri[[2, 0]], 0.0); // Outside lower bandwidth
/// ```
#[allow(dead_code)]
pub fn banded<F>(
    rows: usize,
    cols: usize,
    lower_bandwidth: usize,
    upper_bandwidth: usize,
    low: F,
    high: F,
    seed: Option<u64>,
) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut result = Array2::<F>::zeros((rows, cols));
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    let range = high - low;

    for i in 0..rows {
        // Calculate the column range for this row
        let j_start = i.saturating_sub(lower_bandwidth);
        let j_end = (i + upper_bandwidth + 1).min(cols);

        for j in j_start..j_end {
            let r: f64 = rng.random_range(0.0..1.0);
            result[[i, j]] = low + F::from_f64(r).expect("Operation failed") * range;
        }
    }

    result
}

/// Generate a random sparse matrix with specified density
///
/// # Arguments
///
/// * `rows` - Number of rows
/// * `cols` - Number of columns
/// * `density` - Fraction of non-zero elements (between 0 and 1)
/// * `low` - Lower bound for non-zero elements
/// * `high` - Upper bound for non-zero elements
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A rows×cols sparse matrix with the specified density
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::sparse;
///
/// // Generate a 100x100 sparse matrix with 10% non-zero elements
/// let s = sparse::<f64>(100, 100, 0.1, -1.0, 1.0, Some(42));
/// assert_eq!(s.shape(), &[100, 100]);
///
/// // Check that approximately 10% of elements are non-zero
/// let non_zero_count = s.iter().filter(|&&x| x != 0.0).count();
/// let expected_count = (100.0 * 100.0 * 0.1) as usize;
/// // With a larger matrix, we expect the density to be closer to the target
/// assert!((non_zero_count as f64 - expected_count as f64).abs() < expected_count as f64 * 0.2);
/// ```
#[allow(dead_code)]
pub fn sparse<F>(
    rows: usize,
    cols: usize,
    density: f64,
    low: F,
    high: F,
    seed: Option<u64>,
) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    // Validate density
    if !(0.0..=1.0).contains(&density) {
        panic!("Density must be between 0 and 1");
    }

    let mut result = Array2::<F>::zeros((rows, cols));
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    let range = high - low;

    for i in 0..rows {
        for j in 0..cols {
            // Decide whether this element should be non-zero
            let p: f64 = rng.random_range(0.0..1.0);
            if p < density {
                let r: f64 = rng.random_range(0.0..1.0);
                result[[i, j]] = low + F::from_f64(r).expect("Operation failed") * range;
            }
        }
    }

    result
}

/// Generate a random Toeplitz matrix
///
/// A Toeplitz matrix has constant values along all diagonals.
///
/// # Arguments
///
/// * `n` - Dimension of the square Toeplitz matrix
/// * `low` - Lower bound for elements
/// * `high` - Upper bound for elements
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn Toeplitz matrix
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::toeplitz;
///
/// // Generate a 5x5 Toeplitz matrix
/// let t = toeplitz::<f64>(5, -1.0, 1.0, None);
/// assert_eq!(t.shape(), &[5, 5]);
///
/// // Check that values along diagonals are constant
/// assert_eq!(t[[0, 1]], t[[1, 2]]);
/// assert_eq!(t[[1, 0]], t[[2, 1]]);
/// ```
#[allow(dead_code)]
pub fn toeplitz<F>(n: usize, low: F, high: F, seed: Option<u64>) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    let range = high - low;

    // Generate the first row and column
    let mut first_row = Array1::<F>::zeros(n);
    let mut first_col = Array1::<F>::zeros(n);

    for i in 0..n {
        let r: f64 = rng.random_range(0.0..1.0);
        first_row[i] = low + F::from_f64(r).expect("Operation failed") * range;
    }

    // First element of first column is same as first element of first row
    first_col[0] = first_row[0];

    for i in 1..n {
        let r: f64 = rng.random_range(0.0..1.0);
        first_col[i] = low + F::from_f64(r).expect("Operation failed") * range;
    }

    // Construct Toeplitz matrix
    let mut result = Array2::<F>::zeros((n, n));

    for i in 0..n {
        for j in 0..n {
            if i <= j {
                result[[i, j]] = first_row[j - i];
            } else {
                result[[i, j]] = first_col[i - j];
            }
        }
    }

    result
}

/// Generate a random matrix with a specific condition number
///
/// Creates a matrix with a specified condition number by generating
/// a random orthogonal matrix Q and a diagonal matrix D with eigenvalues
/// spaced to achieve the target condition number.
///
/// # Arguments
///
/// * `n` - Dimension of the square matrix
/// * `condition_number` - Target condition number (must be >= 1.0)
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn matrix with the specified condition number
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::with_condition_number;
/// use scirs2_linalg::cond;
///
/// // Generate a 4x4 matrix with condition number 100
/// let a = with_condition_number::<f64>(4, 100.0, None);
/// assert_eq!(a.shape(), &[4, 4]);
///
/// // Verify the matrix has the correct shape
/// // (we don't compute the condition number in the doctest because
/// // it might not be implemented for all configurations)
/// assert_eq!(a.shape(), &[4, 4]);
/// ```
#[allow(dead_code)]
pub fn with_condition_number<F>(n: usize, conditionnumber: F, seed: Option<u64>) -> Array2<F>
where
    F: Float
        + NumAssign
        + FromPrimitive
        + Clone
        + std::fmt::Debug
        + Sum
        + Send
        + Sync
        + scirs2_core::ndarray::ScalarOperand
        + 'static,
{
    // Validate condition _number
    if conditionnumber < F::one() {
        panic!("Condition _number must be >= 1.0");
    }

    // Generate random orthogonal matrix Q1
    let q1 = orthogonal::<F>(n, seed);

    // Generate another random orthogonal matrix Q2
    let seed2 = seed.map(|s| s.wrapping_add(1));
    let q2 = orthogonal::<F>(n, seed2);

    // Create diagonal matrix with eigenvalues
    let mut d = Array2::<F>::zeros((n, n));

    // First eigenvalue is 1, last eigenvalue is 1/condition_number
    // Intermediate eigenvalues are logarithmically spaced
    let min_eigenval = F::one() / conditionnumber;

    let log_min = min_eigenval.ln();
    let log_max = F::one().ln();

    for i in 0..n {
        let t = F::from_f64((i as f64) / ((n - 1) as f64)).expect("Operation failed");
        let log_val = log_min * t + log_max * (F::one() - t);
        d[[i, i]] = log_val.exp();
    }

    // Form result = Q1 * D * Q2^T
    let temp = q1.dot(&d);
    let q2t = q2.t();

    temp.dot(&q2t)
}

/// Generate a random matrix with specified eigenvalues
///
/// Creates a matrix with the given eigenvalues by generating
/// a random orthogonal matrix Q and computing Q * D * Q^T,
/// where D is a diagonal matrix with the specified eigenvalues.
///
/// # Arguments
///
/// * `eigenvalues` - Array of eigenvalues for the matrix
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A square matrix with the specified eigenvalues
///
/// # Examples
///
/// ```
/// use scirs2_core::ndarray::array;
/// use scirs2_linalg::random::with_eigenvalues;
/// use scirs2_linalg::eigvals;
///
/// // Generate a 3x3 matrix with eigenvalues [1.0, 2.0, 3.0]
/// let evals = array![1.0, 2.0, 3.0];
/// let a = with_eigenvalues(&evals, None);
/// assert_eq!(a.shape(), &[3, 3]);
///
/// // Verify that the eigenvalues are close to the expected values
/// // Note: For simplicity, we just check if the matrix has appropriate size
/// assert_eq!(a.shape(), &[3, 3]);
///
/// // In practice, we would compute eigenvalues and verify correctness:
/// // let computed_evals = eigvals(&a.view()).expect("Operation failed");
/// // But eigenvalues could be complex and sorting may be challenging in doctests
/// // So we just verify the matrix size here
/// ```
#[allow(dead_code)]
pub fn with_eigenvalues<F>(eigenvalues: &Array1<F>, seed: Option<u64>) -> Array2<F>
where
    F: Float
        + NumAssign
        + FromPrimitive
        + Clone
        + std::fmt::Debug
        + Sum
        + Send
        + Sync
        + scirs2_core::ndarray::ScalarOperand
        + 'static,
{
    let n = eigenvalues.len();

    // Generate random orthogonal matrix Q
    let q = orthogonal::<F>(n, seed);

    // Create diagonal matrix with specified _eigenvalues
    let mut d = Array2::<F>::zeros((n, n));
    for i in 0..n {
        d[[i, i]] = eigenvalues[i];
    }

    // Form result = Q * D * Q^T for symmetric matrix with given _eigenvalues
    let temp = q.dot(&d);
    let qt = q.t();

    temp.dot(&qt)
}

/// Generate a Hilbert matrix, which is famously ill-conditioned
///
/// The Hilbert matrix is defined as `H[i,j] = 1/(i+j+1)`.
/// These matrices are symmetric positive definite but become increasingly
/// ill-conditioned as the size increases, making them useful for testing
/// numerical stability of algorithms.
///
/// # Arguments
///
/// * `n` - Dimension of the square Hilbert matrix
///
/// # Returns
///
/// An nxn Hilbert matrix
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::hilbert;
///
/// // Generate a 3x3 Hilbert matrix
/// let h = hilbert::<f64>(3);
/// assert_eq!(h.shape(), &[3, 3]);
///
/// // Check a few entries against the definition
/// assert!((h[[0, 0]] - 1.0).abs() < 1e-10);
/// assert!((h[[0, 1]] - 0.5).abs() < 1e-10);
/// assert!((h[[1, 1]] - 1.0/3.0).abs() < 1e-10);
/// ```
#[allow(dead_code)]
pub fn hilbert<F>(n: usize) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut result = Array2::<F>::zeros((n, n));

    for i in 0..n {
        for j in 0..n {
            let value = F::one() / F::from_f64((i + j + 1) as f64).expect("Operation failed");
            result[[i, j]] = value;
        }
    }

    result
}

/// Generate a Vandermonde matrix from a set of points
///
/// A Vandermonde matrix is defined as `V[i,j] = x_i^j`, where x_i is the
/// i-th point. These matrices are commonly used in polynomial interpolation
/// and fitting.
///
/// # Arguments
///
/// * `points` - Array of points to use for the Vandermonde matrix
///
/// # Returns
///
/// A Vandermonde matrix with shape (points.len(), points.len())
///
/// # Examples
///
/// ```
/// use scirs2_core::ndarray::array;
/// use scirs2_linalg::random::vandermonde;
///
/// // Generate a Vandermonde matrix from points [1, 2, 3]
/// let points = array![1.0, 2.0, 3.0];
/// let v = vandermonde(&points);
/// assert_eq!(v.shape(), &[3, 3]);
///
/// // Check values: for point x_i, column j should be x_i^j
/// assert_eq!(v[[0, 0]], 1.0);  // 1^0
/// assert_eq!(v[[0, 1]], 1.0);  // 1^1
/// assert_eq!(v[[0, 2]], 1.0);  // 1^2
/// assert_eq!(v[[1, 0]], 1.0);  // 2^0
/// assert_eq!(v[[1, 1]], 2.0);  // 2^1
/// assert_eq!(v[[1, 2]], 4.0);  // 2^2
/// ```
#[allow(dead_code)]
pub fn vandermonde<F>(points: &Array1<F>) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let n = points.len();
    let mut result = Array2::<F>::zeros((n, n));

    for i in 0..n {
        let x = points[i];

        // First column is always x^0 = 1
        result[[i, 0]] = F::one();

        // Fill remaining columns: V[i,j] = points[i]^j
        for j in 1..n {
            result[[i, j]] = result[[i, j - 1]] * x;
        }
    }

    result
}

/// Generate a random correlation matrix
///
/// A correlation matrix is symmetric positive semi-definite with
/// ones on the diagonal. These matrices are commonly used in statistics,
/// finance, and machine learning.
///
/// The method generates a random matrix, computes A^T * A, and then
/// normalizes the result to have ones on the diagonal.
///
/// # Arguments
///
/// * `n` - Dimension of the square correlation matrix
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn correlation matrix
///
/// # Examples
///
/// ```
/// use scirs2_linalg::random::random_correlation;
///
/// // Generate a 4x4 random correlation matrix
/// let c = random_correlation::<f64>(4, None);
/// assert_eq!(c.shape(), &[4, 4]);
///
/// // Check that diagonal elements are 1
/// for i in 0..4 {
///     assert!((c[[i, i]] - 1.0).abs() < 1e-10);
/// }
///
/// // Check that off-diagonal elements are in [-1, 1]
/// for i in 0..4 {
///     for j in (i+1)..4 {
///         assert!(c[[i, j]] >= -1.0 && c[[i, j]] <= 1.0);
///         // Also verify symmetry
///         assert!((c[[i, j]] - c[[j, i]]).abs() < 1e-10);
///     }
/// }
/// ```
#[allow(dead_code)]
pub fn random_correlation<F>(n: usize, seed: Option<u64>) -> Array2<F>
where
    F: Float
        + NumAssign
        + FromPrimitive
        + Clone
        + std::fmt::Debug
        + Sum
        + Send
        + Sync
        + scirs2_core::ndarray::ScalarOperand
        + 'static,
{
    // Generate a random matrix with n rows and n/2 + 1 columns
    // (ensures that the resulting matrix is full rank)
    let k = (n / 2) + 1;
    let a = normal(n, k, F::zero(), F::one(), seed);

    // Compute A * A^T (this gives a positive semi-definite matrix)
    let at = a.t();
    let result = a.dot(&at);

    // Create an intermediate correlation matrix with proper normalization
    let mut corr = Array2::<F>::zeros((n, n));

    for i in 0..n {
        for j in 0..n {
            corr[[i, j]] = result[[i, j]] / (result[[i, i]] * result[[j, j]]).sqrt();
        }
    }

    // This ensures that the diagonal elements are exactly 1
    for i in 0..n {
        corr[[i, i]] = F::one();
    }

    corr
}

/// Generate a random low-rank matrix
///
/// Creates a matrix with a specified rank that is less than min(rows, cols).
/// This is useful for testing algorithms that exploit low-rank structure.
///
/// # Arguments
///
/// * `rows` - Number of rows
/// * `cols` - Number of columns
/// * `rank` - Target rank (must be <= min(rows, cols))
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// A matrix of shape (rows, cols) with rank equal to the specified rank
///
/// # Examples
///
/// ```ignore
/// use scirs2_linalg::random::low_rank;
/// use scirs2_linalg::svd;
///
/// // Generate a 4x4 matrix with rank 2
/// let a = low_rank::<f64>(4, 4, 2, None);
/// assert_eq!(a.shape(), &[4, 4]);
///
/// // Basic smoke test - just ensure the function completes without panicking
/// // Detailed verification of rank properties is done in unit tests
///
/// // For a more comprehensive test, we'd check the ratio between singular values
/// // but this can be unstable in different test environments, so we omit it here.
/// ```
#[allow(dead_code)]
pub fn low_rank<F>(rows: usize, cols: usize, rank: usize, seed: Option<u64>) -> Array2<F>
where
    F: Float
        + NumAssign
        + FromPrimitive
        + Clone
        + std::fmt::Debug
        + Sum
        + Send
        + Sync
        + scirs2_core::ndarray::ScalarOperand
        + 'static,
{
    if rank > rows.min(cols) {
        panic!("Rank must be less than or equal to min(rows, cols)");
    }

    if rank == 0 {
        return Array2::<F>::zeros((rows, cols));
    }

    // Create orthogonal left and right factor matrices
    let mut left = Array2::<F>::zeros((rows, rank));
    let mut right = Array2::<F>::zeros((rank, cols));

    // For the left factor, create orthogonal columns
    if rows >= rank {
        // If rows >= rank, we can use the orthogonal function directly
        let temp = orthogonal::<F>(rows, seed);
        for i in 0..rows {
            for j in 0..rank {
                left[[i, j]] = temp[[i, j]];
            }
        }
    } else {
        // If rows < rank, fill with random normal values
        left = normal(rows, rank, F::zero(), F::one(), seed);
    }

    // For the right factor, create orthogonal rows
    if cols >= rank {
        // If cols >= rank, we can use the orthogonal function and transpose
        let temp = orthogonal::<F>(cols, seed.map(|s| s.wrapping_add(1)));
        // Take the first rank rows of the transpose
        let temp_t = temp.t();
        for i in 0..rank {
            for j in 0..cols {
                right[[i, j]] = temp_t[[i, j]];
            }
        }
    } else {
        // If cols < rank, fill with random normal values
        right = normal(
            rank,
            cols,
            F::zero(),
            F::one(),
            seed.map(|s| s.wrapping_add(1)),
        );
    }

    // We'll directly build the low-rank matrix as a sum of rank-1 outer products
    let mut result = Array2::<F>::zeros((rows, cols));

    // Extract column vectors from left and row vectors from right
    for r in 0..rank {
        let scaling = F::from_f64(1.0).expect("Operation failed"); // All singular values are 1.0

        // Get column r from left
        let u_col = left.column(r).to_owned();

        // Get row r from right
        let v_row = right.row(r).to_owned();

        // Add scaled outer product u * v^T to result
        for i in 0..rows {
            for j in 0..cols {
                result[[i, j]] += scaling * u_col[i] * v_row[j];
            }
        }
    }

    result
}

/// Generate a random permutation matrix
///
/// A permutation matrix is a binary matrix that has exactly one entry of 1
/// in each row and column, with all other entries 0. Multiplying by a permutation
/// matrix permutes the rows or columns of the original matrix.
///
/// # Arguments
///
/// * `n` - Dimension of the square permutation matrix
/// * `seed` - Optional seed for the random number generator
///
/// # Returns
///
/// An nxn permutation matrix
///
/// # Examples
///
/// ```
/// use scirs2_core::ndarray::Array2;
/// use scirs2_linalg::random::permutation;
///
/// // Generate a 4x4 random permutation matrix
/// let p = permutation::<f64>(4, None);
/// assert_eq!(p.shape(), &[4, 4]);
///
/// // Check that each row and column has exactly one 1
/// let one = 1.0;
/// let zero = 0.0;
///
/// for i in 0..4 {
///     let mut row_sum = 0.0;
///     let mut col_sum = 0.0;
///     for j in 0..4 {
///         row_sum += p[[i, j]];
///         col_sum += p[[j, i]];
///         // Check binary property: all entries are either 0 or 1
///         assert!(p[[i, j]] == zero || p[[i, j]] == one);
///     }
///     assert!((row_sum - 1.0).abs() < 1e-10);
///     assert!((col_sum - 1.0).abs() < 1e-10);
/// }
/// ```
#[allow(dead_code)]
pub fn permutation<F>(n: usize, seed: Option<u64>) -> Array2<F>
where
    F: Float + NumAssign + FromPrimitive + Clone + 'static,
{
    let mut rng = match seed {
        Some(s) => ChaCha8Rng::seed_from_u64(s),
        None => {
            let mut seedarr = [0u8; 32];
            scirs2_core::random::rng().fill(&mut seedarr);
            ChaCha8Rng::from_seed(seedarr)
        }
    };

    // Initialize result as zeros
    let mut result = Array2::<F>::zeros((n, n));

    // Create a permutation of 0..n
    let mut indices: Vec<usize> = (0..n).collect();

    // Shuffle the indices using Fisher-Yates algorithm
    for i in (1..n).rev() {
        let j = rng.random_range(0..=i);
        indices.swap(i, j);
    }

    // Set the 1s in the permutation matrix
    for (i, &j) in indices.iter().enumerate() {
        result[[i, j]] = F::one();
    }

    result
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::decomposition::{cholesky, svd};
    use crate::eigen::eigvals;
    use approx::assert_relative_eq;
    use scirs2_core::ndarray::{array, Array2};
    // cond is used in the examples but not directly in the tests

    #[test]
    fn test_uniform() {
        let rows = 3;
        let cols = 4;
        let low = -1.0;
        let high = 1.0;

        // Test with and without seed
        let a = uniform::<f64>(rows, cols, low, high, None);
        let b = uniform::<f64>(rows, cols, low, high, Some(42));
        let c = uniform::<f64>(rows, cols, low, high, Some(42)); // Same seed

        // Check dimensions
        assert_eq!(a.shape(), &[rows, cols]);
        assert_eq!(b.shape(), &[rows, cols]);

        // Check that values are in the correct range
        assert!(a.iter().all(|&x| x >= low && x <= high));
        assert!(b.iter().all(|&x| x >= low && x <= high));

        // Check that same seed gives same result
        assert_eq!(b, c);

        // Check that different seeds (or no seed) give different results
        assert_ne!(a, b);
    }

    #[test]
    fn test_normal() {
        let rows = 3;
        let cols = 4;
        let mean = 0.0;
        let std = 1.0;

        // Test with and without seed
        let a = normal::<f64>(rows, cols, mean, std, None);
        let b = normal::<f64>(rows, cols, mean, std, Some(42));
        let c = normal::<f64>(rows, cols, mean, std, Some(42)); // Same seed

        // Check dimensions
        assert_eq!(a.shape(), &[rows, cols]);
        assert_eq!(b.shape(), &[rows, cols]);

        // Check that same seed gives same result
        assert_eq!(b, c);

        // Check that different seeds (or no seed) give different results
        assert_ne!(a, b);
    }

    #[test]
    fn test_orthogonal() {
        let n = 4;

        // Test with and without seed
        let a = orthogonal::<f64>(n, None);
        let b = orthogonal::<f64>(n, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[n, n]);
        assert_eq!(b.shape(), &[n, n]);

        // Check orthogonality: Q^T * Q ≈ I
        let at = a.t();
        let result_a = at.dot(&a);
        let _identity = Array2::<f64>::eye(n);

        for i in 0..n {
            for j in 0..n {
                if i == j {
                    assert_relative_eq!(result_a[[i, j]], 1.0, epsilon = 1e-10);
                } else {
                    assert_relative_eq!(result_a[[i, j]], 0.0, epsilon = 1e-10);
                }
            }
        }

        // Same for b
        let bt = b.t();
        let result_b = bt.dot(&b);

        for i in 0..n {
            for j in 0..n {
                if i == j {
                    assert_relative_eq!(result_b[[i, j]], 1.0, epsilon = 1e-10);
                } else {
                    assert_relative_eq!(result_b[[i, j]], 0.0, epsilon = 1e-10);
                }
            }
        }
    }

    #[test]
    fn test_spd() {
        let n = 3;
        let min_eigenval = 1.0;
        let max_eigenval = 10.0;

        // Test with and without seed
        let a = spd::<f64>(n, min_eigenval, max_eigenval, None);
        let b = spd::<f64>(n, min_eigenval, max_eigenval, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[n, n]);
        assert_eq!(b.shape(), &[n, n]);

        // Check symmetry
        let at = a.t();
        for i in 0..n {
            for j in 0..n {
                assert_relative_eq!(a[[i, j]], at[[i, j]], epsilon = 1e-10);
            }
        }

        // Check positive definiteness (via Cholesky decomposition)
        let chol_a = cholesky(&a.view(), None);
        assert!(chol_a.is_ok());

        let chol_b = cholesky(&b.view(), None);
        assert!(chol_b.is_ok());
    }

    #[test]
    fn test_diagonal() {
        let n = 3;
        let low = 1.0;
        let high = 10.0;

        // Test with and without seed
        let a = diagonal::<f64>(n, low, high, None);
        let b = diagonal::<f64>(n, low, high, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[n, n]);
        assert_eq!(b.shape(), &[n, n]);

        // Check diagonal structure
        for i in 0..n {
            for j in 0..n {
                if i == j {
                    // Diagonal elements should be in [low, high]
                    assert!(a[[i, j]] >= low && a[[i, j]] <= high);
                    assert!(b[[i, j]] >= low && b[[i, j]] <= high);
                } else {
                    // Off-diagonal elements should be zero
                    assert_eq!(a[[i, j]], 0.0);
                    assert_eq!(b[[i, j]], 0.0);
                }
            }
        }
    }

    #[test]
    fn test_banded() {
        let rows = 5;
        let cols = 5;
        let lower = 1; // Subdiagonal
        let upper = 1; // Superdiagonal
        let low = -1.0;
        let high = 1.0;

        // Generate tridiagonal matrix
        let a = banded::<f64>(rows, cols, lower, upper, low, high, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[rows, cols]);

        // Check band structure
        for i in 0..rows {
            for j in 0..cols {
                if (i as isize - j as isize).abs() <= (lower as isize).max(upper as isize) {
                    // Elements within band should be in [low, high]
                    assert!(a[[i, j]] >= low && a[[i, j]] <= high);
                } else {
                    // Elements outside band should be zero
                    assert_eq!(a[[i, j]], 0.0);
                }
            }
        }
    }

    #[test]
    fn test_sparse() {
        let rows = 10;
        let cols = 10;
        let density = 0.2; // 20% non-zero
        let low = -1.0;
        let high = 1.0;

        // Generate sparse matrix
        let a = sparse::<f64>(rows, cols, density, low, high, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[rows, cols]);

        // Count non-zero elements
        let non_zero_count = a.iter().filter(|&&x| x != 0.0).count();
        let total_elements = rows * cols;
        let expected_count = (total_elements as f64 * density) as usize;

        // Allow some deviation due to randomness
        let tolerance = (total_elements as f64 * 0.1) as usize; // 10% tolerance
        assert!(
            non_zero_count >= expected_count - tolerance
                && non_zero_count <= expected_count + tolerance,
            "Expected {} non-zero elements (±{}), but got {}",
            expected_count,
            tolerance,
            non_zero_count
        );

        // Check that non-zero values are in [low, high]
        assert!(a
            .iter()
            .filter(|&&x| x != 0.0)
            .all(|&x| x >= low && x <= high));
    }

    #[test]
    fn test_toeplitz() {
        let n = 5;
        let low = -1.0;
        let high = 1.0;

        // Generate Toeplitz matrix
        let a = toeplitz::<f64>(n, low, high, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[n, n]);

        // Check Toeplitz property: elements on each diagonal are constant
        for k in -(n as isize - 1)..n as isize {
            let mut diagonal_values = Vec::new();

            for i in 0..n {
                for j in 0..n {
                    if (j as isize) - (i as isize) == k {
                        diagonal_values.push(a[[i, j]]);
                    }
                }
            }

            // Check that all values on this diagonal are equal
            if !diagonal_values.is_empty() {
                let first_val = diagonal_values[0];
                for val in &diagonal_values {
                    assert_relative_eq!(*val, first_val, epsilon = 1e-10);
                }
            }
        }
    }

    #[test]
    fn test_with_condition_number() {
        // This test is primarily to check that the function doesn't panic
        // Precise condition number verification is difficult due to numerical stability issues

        let n = 4;
        let condition = 5.0; // Very modest condition number for testing

        // Generate matrix with specified condition number
        let a = with_condition_number::<f64>(n, condition, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[n, n]);

        // Compute SVD to get singular values (if possible)
        if let Ok((_, s, _)) = svd(&a.view(), false, None) {
            // Verify we have the expected number of singular values
            assert_eq!(s.len(), n);

            // Verify all singular values are positive
            for i in 0..n {
                assert!(s[i] > 0.0);
            }
        } else {
            // If SVD fails due to numerical issues, just verify basic properties
            println!("SVD failed for condition number matrix, skipping detailed verification");
        }
    }

    #[test]
    fn test_with_eigenvalues() {
        let eigenvalues = array![1.0, 2.0, 3.0];
        let n = eigenvalues.len();

        // Generate matrix with specified eigenvalues
        let a = with_eigenvalues(&eigenvalues, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[n, n]);

        // Compute eigenvalues
        let computed_eigenvalues = eigvals(&a.view(), None).expect("Operation failed");

        // Check that the real parts of the eigenvalues match (ignoring order)
        // Convert complex eigenvalues to real magnitudes
        let mut real_computed = Vec::new();
        for ev in computed_eigenvalues.iter() {
            // For symmetric matrices constructed with our method, eigenvalues should be real
            // (imaginary part should be very small due to numerical precision)
            real_computed.push(ev.re);
        }

        real_computed.sort_by(|a, b| a.partial_cmp(b).expect("Operation failed"));

        let mut sorted_expected = eigenvalues.to_vec();
        sorted_expected.sort_by(|a, b| a.partial_cmp(b).expect("Operation failed"));

        // Check that eigenvalues match
        for (expected, computed) in sorted_expected.iter().zip(real_computed.iter()) {
            assert!((expected - computed).abs() < 1e-10);
        }
    }

    #[test]
    fn test_hilbert() {
        let n = 4;

        // Generate Hilbert matrix
        let h = hilbert::<f64>(n);

        // Check dimensions
        assert_eq!(h.shape(), &[n, n]);

        // Check Hilbert matrix properties
        for i in 0..n {
            for j in 0..n {
                let expected = 1.0 / (i + j + 1) as f64;
                assert_relative_eq!(h[[i, j]], expected, epsilon = 1e-10);
            }
        }

        // Check symmetry
        let ht = h.t();
        for i in 0..n {
            for j in 0..n {
                assert_relative_eq!(h[[i, j]], ht[[i, j]], epsilon = 1e-10);
            }
        }

        // Check positive definiteness
        let chol = cholesky(&h.view(), None);
        assert!(chol.is_ok());
    }

    #[test]
    fn test_vandermonde() {
        let points = array![1.0, 2.0, 3.0, 4.0];
        let n = points.len();

        // Generate Vandermonde matrix
        let v = vandermonde(&points);

        // Check dimensions
        assert_eq!(v.shape(), &[n, n]);

        // Check Vandermonde matrix properties
        for i in 0..n {
            for j in 0..n {
                let expected = points[i].powi(j as i32);
                assert_relative_eq!(v[[i, j]], expected, epsilon = 1e-10);
            }
        }
    }

    #[test]
    fn test_random_correlation() {
        let n = 5;

        // Generate correlation matrix
        let c = random_correlation::<f64>(n, Some(42));

        // Check dimensions
        assert_eq!(c.shape(), &[n, n]);

        // Check diagonal elements are 1
        for i in 0..n {
            assert_relative_eq!(c[[i, i]], 1.0, epsilon = 1e-10);
        }

        // Check off-diagonal elements are in [-1, 1]
        for i in 0..n {
            for j in 0..n {
                if i != j {
                    assert!(c[[i, j]] >= -1.0 && c[[i, j]] <= 1.0);
                }
            }
        }

        // Check symmetry
        let ct = c.t();
        for i in 0..n {
            for j in 0..n {
                assert_relative_eq!(c[[i, j]], ct[[i, j]], epsilon = 1e-10);
            }
        }

        // Check positive semi-definiteness
        // Eigenvalues of a correlation matrix should be non-negative
        let eigenvalues = eigvals(&c.view(), None).expect("Operation failed");
        for ev in eigenvalues.iter() {
            assert!(ev.re >= -1e-10); // Allow for small numerical errors
        }
    }

    #[test]
    fn test_low_rank() {
        let rows = 6;
        let cols = 5;
        let rank = 3;

        // Generate low-rank matrix
        let a = low_rank::<f64>(rows, cols, rank, Some(42));

        // Check dimensions
        assert_eq!(a.shape(), &[rows, cols]);

        // Check rank by computing SVD (if possible)
        if let Ok((_, s, _)) = svd(&a.view(), false, None) {
            // First 'rank' singular values should be significantly larger than the rest
            for i in 0..rank {
                assert!(s[i] > 1e-10);
            }

            // The non-zero singular values are not guaranteed to have a specific pattern
            // but the matrix should have numerical rank close to the requested rank
            // Count "significant" singular values (those larger than a small threshold)
            let significant_count = s.iter().filter(|&&sv| sv > 1e-10).count();
            assert!(
                significant_count >= rank,
                "Matrix has fewer significant singular values ({}) than requested rank ({})",
                significant_count,
                rank
            );
        } else {
            // If SVD fails due to numerical issues, just verify basic properties
            println!("SVD failed for low-rank matrix, skipping detailed rank verification");
        }

        // Test a special case (zero rank)
        let zero_rank = low_rank::<f64>(3, 3, 0, None);
        assert_eq!(zero_rank.shape(), &[3, 3]);
        for i in 0..3 {
            for j in 0..3 {
                assert_eq!(zero_rank[[i, j]], 0.0);
            }
        }
    }

    #[test]
    fn test_permutation() {
        let n = 5;

        // Generate permutation matrix
        let p = permutation::<f64>(n, Some(42));

        // Check dimensions
        assert_eq!(p.shape(), &[n, n]);

        // Check that each row and column has exactly one 1
        for i in 0..n {
            let row_sum: f64 = p.row(i).sum();
            let col_sum: f64 = p.column(i).sum();

            assert_relative_eq!(row_sum, 1.0, epsilon = 1e-10);
            assert_relative_eq!(col_sum, 1.0, epsilon = 1e-10);
        }

        // Check that all entries are either 0 or 1
        for i in 0..n {
            for j in 0..n {
                assert!(p[[i, j]] == 0.0 || p[[i, j]] == 1.0);
            }
        }

        // Check orthogonality (permutation matrices are orthogonal)
        let pt = p.t();
        let result = p.dot(&pt);

        // Result should be the identity matrix
        for i in 0..n {
            for j in 0..n {
                if i == j {
                    assert_relative_eq!(result[[i, j]], 1.0, epsilon = 1e-10);
                } else {
                    assert_relative_eq!(result[[i, j]], 0.0, epsilon = 1e-10);
                }
            }
        }
    }
}