mirascript-vm 0.1.87

Native Rust virtual machine for MiraScript
Documentation
use crate::standard_library::required;
use crate::{MiraAny, MiraCallContext, MiraError, Result};

use super::helpers::{as_matrix, numeric, shape};
use super::map_nested;

pub(super) fn invert(_call: &mut MiraCallContext<'_>, args: &[MiraAny]) -> Result<MiraAny> {
    let value = required(args, 0, "a")?;
    let dimensions = shape(value)?;
    if dimensions.is_empty() {
        return Ok(MiraAny::Number(1.0 / numeric(value)?));
    }
    if dimensions.len() == 1 {
        return map_nested(value, &mut |value| {
            Ok(MiraAny::Number(1.0 / numeric(&value)?))
        });
    }
    if dimensions[0] != dimensions[1] {
        return Err(MiraError::runtime("Matrix must be square"));
    }
    let size = dimensions[0];
    let matrix = as_matrix(value)?;
    if size == 1 {
        return Ok(MiraAny::Array(vec![MiraAny::Array(vec![MiraAny::Number(
            1.0 / numeric(
                matrix
                    .first()
                    .and_then(|row| row.first())
                    .unwrap_or(&MiraAny::Nil),
            )?,
        )])]));
    }
    if size == 2 {
        let a = numeric(&matrix[0][0])?;
        let b = numeric(&matrix[0][1])?;
        let c = numeric(&matrix[1][0])?;
        let d = numeric(&matrix[1][1])?;
        let determinant = a * d - b * c;
        return Ok(MiraAny::Array(vec![
            MiraAny::Array(vec![
                MiraAny::Number(d / determinant),
                MiraAny::Number(-b / determinant),
            ]),
            MiraAny::Array(vec![
                MiraAny::Number(-c / determinant),
                MiraAny::Number(a / determinant),
            ]),
        ]));
    }
    let mut left = vec![vec![0.0; size]; size];
    let mut right = vec![vec![0.0; size]; size];
    for row in 0..size {
        for column in 0..size {
            left[row][column] = numeric(
                matrix
                    .get(row)
                    .and_then(|row| row.get(column))
                    .unwrap_or(&MiraAny::Nil),
            )?;
            right[row][column] = if row == column { 1.0 } else { 0.0 };
        }
    }
    for column in 0..size {
        let mut pivot = column;
        let mut largest = left[column][column].abs();
        for (row, values) in left.iter().enumerate().skip(column + 1) {
            if values[column].abs() > largest {
                largest = values[column].abs();
                pivot = row;
            }
        }
        left.swap(column, pivot);
        right.swap(column, pivot);
        let pivot_left = left[column].clone();
        let pivot_right = right[column].clone();
        let pivot_value = pivot_left[column];
        for (row, (left_row, right_row)) in left.iter_mut().zip(right.iter_mut()).enumerate() {
            if row != column {
                if left_row[column] != 0.0 {
                    let factor = -left_row[column] / pivot_value;
                    for (value, pivot) in left_row[column..].iter_mut().zip(&pivot_left[column..]) {
                        *value += factor * pivot;
                    }
                    for (value, pivot) in right_row.iter_mut().zip(&pivot_right) {
                        *value += factor * pivot;
                    }
                }
            } else {
                for value in &mut left_row[column..] {
                    *value /= pivot_value;
                }
                for value in right_row {
                    *value /= pivot_value;
                }
            }
        }
    }
    Ok(MiraAny::Array(
        right
            .into_iter()
            .map(|row| MiraAny::Array(row.into_iter().map(MiraAny::Number).collect()))
            .collect(),
    ))
}