qfall-math 0.1.1

// Copyright © 2023 Marcel Luca Schmidt, Sven Moog
//
// This file is part of qFALL-math.
//
// qFALL-math is free software: you can redistribute it and/or modify it under
// the terms of the Mozilla Public License Version 2.0 as published by the
// Mozilla Foundation. See <https://mozilla.org/en-US/MPL/2.0/>.

//! Implementations to get information about a [`MatZq`] matrix.

use super::MatZq;
use crate::{
    integer::{MatZ, Z},
    integer_mod_q::{Modulus, Zq, fmpz_mod_helpers::length},
    traits::{MatrixDimensions, MatrixGetEntry, MatrixGetSubmatrix, MatrixSetEntry},
};
use flint_sys::{
    fmpz::{fmpz, fmpz_init_set},
    fmpz_mat::fmpz_mat_set,
    fmpz_mod_mat::{
        fmpz_mod_mat_entry, fmpz_mod_mat_init_set, fmpz_mod_mat_window_clear,
        fmpz_mod_mat_window_init,
    },
};
use std::mem::MaybeUninit;

impl MatZq {
    /// Creates a [`MatZ`] where each entry is a representative of the
    /// equivalence class of each entry from a [`MatZq`].
    ///
    /// The values in the output matrix are in the range of `[0, modulus)`.
    /// Use [`MatZq::get_representative_least_absolute_residue`] if they should be
    /// in the range `[-modulus/2, modulus/2]`.
    ///
    /// Returns the matrix as a [`MatZ`].
    ///
    /// # Examples
    /// ```
    /// use qfall_math::integer::MatZ;
    /// use qfall_math::integer_mod_q::MatZq;
    /// use std::str::FromStr;
    ///
    /// let mat_zq = MatZq::from_str("[[1, 2],[3, -1]] mod 5").unwrap();
    ///
    /// let mat_z = mat_zq.get_representative_least_nonnegative_residue();
    ///
    /// assert_eq!(mat_z.to_string(), "[[1, 2],[3, 4]]");
    /// ```
    pub fn get_representative_least_nonnegative_residue(&self) -> MatZ {
        let mut out = MatZ::new(self.get_num_rows(), self.get_num_columns());
        unsafe { fmpz_mat_set(&mut out.matrix, &self.matrix.mat[0]) };
        out
    }

    /// Creates a [`MatZ`] where each entry is a representative of the
    /// equivalence class of each entry from a [`MatZq`] with the
    /// representatives close to `0`.
    ///
    /// The values in the output matrix are in the range of `[-modulus/2, modulus/2]`.
    /// For even moduli, the positive representative is chosen for the element `modulus / 2`.
    /// Use [`MatZq::get_representative_least_nonnegative_residue`] if they should be
    /// in the range `[0, modulus)`.
    ///
    /// Returns an [`MatZ`] representation of the given matrix with
    /// representatives chosen close to `0`.
    ///
    /// # Examples
    /// ```
    /// use qfall_math::integer_mod_q::MatZq;
    /// use std::str::FromStr;
    ///
    /// let mat_zq_1 = MatZq::from_str("[[1,2],[3,4]] mod 5").unwrap();
    /// let mat_zq_2 = MatZq::from_str("[[1,2],[3,4]] mod 4").unwrap();
    ///
    /// let mat_z_1 = mat_zq_1.get_representative_least_absolute_residue();
    /// let mat_z_2 = mat_zq_2.get_representative_least_absolute_residue();
    ///
    /// assert_eq!(mat_z_1.to_string(), "[[1, 2],[-2, -1]]");
    /// assert_eq!(mat_z_2.to_string(), "[[1, 2],[-1, 0]]");
    /// ```
    pub fn get_representative_least_absolute_residue(&self) -> MatZ {
        let modulus: Z = Z::from(&self.modulus);
        let modulus_half = modulus.div_floor(2);

        let mut out = MatZ::new(self.get_num_rows(), self.get_num_columns());

        for row in 0..self.get_num_rows() {
            for column in 0..self.get_num_columns() {
                let entry: Z = unsafe { self.get_entry_unchecked(row, column) };

                // Not using Zq::distance for performance reasons.
                if entry > modulus_half {
                    unsafe { out.set_entry_unchecked(row, column, entry - &modulus) };
                } else {
                    unsafe { out.set_entry_unchecked(row, column, entry) };
                }
            }
        }

        out
    }

    /// Returns the modulus of the matrix as a [`Modulus`].
    ///
    /// # Examples
    /// ```
    /// use qfall_math::integer_mod_q::MatZq;
    ///
    /// let matrix = MatZq::new(5, 10, 7);
    /// let entry = matrix.get_mod();
    /// ```
    pub fn get_mod(&self) -> Modulus {
        self.modulus.clone()
    }
}

impl MatrixGetSubmatrix for MatZq {
    /// Returns a deep copy of the submatrix defined by the given parameters
    /// and does not check the provided dimensions.
    /// There is also a safe version of this function that checks the input.
    ///
    /// Parameters:
    /// `row_1`: the starting row of the submatrix
    /// `row_2`: the ending row of the submatrix
    /// `col_1`: the starting column of the submatrix
    /// `col_2`: the ending column of the submatrix
    ///
    /// Returns the submatrix from `(row_1, col_1)` to `(row_2, col_2)`(exclusively).
    ///
    /// # Examples
    /// ```
    /// use qfall_math::{integer_mod_q::MatZq, traits::MatrixGetSubmatrix};
    /// use std::str::FromStr;
    ///
    /// let mat = MatZq::identity(3, 3, 17);
    ///
    /// let sub_mat_1 = mat.get_submatrix(0, 2, 1, 1).unwrap();
    /// let sub_mat_2 = mat.get_submatrix(0, -1, 1, -2).unwrap();
    /// let sub_mat_3 = unsafe{mat.get_submatrix_unchecked(0, 3, 1, 2)};
    ///
    /// let e_2 = MatZq::from_str("[[0],[1],[0]] mod 17").unwrap();
    /// assert_eq!(e_2, sub_mat_1);
    /// assert_eq!(e_2, sub_mat_2);
    /// assert_eq!(e_2, sub_mat_3);
    /// ```
    ///
    /// # Safety
    /// To use this function safely, make sure that the selected submatrix is part
    /// of the matrix. If it is not, memory leaks, unexpected panics, etc. might
    /// occur.
    unsafe fn get_submatrix_unchecked(
        &self,
        row_1: i64,
        row_2: i64,
        col_1: i64,
        col_2: i64,
    ) -> Self {
        let mut window = MaybeUninit::uninit();
        // The memory for the elements of window is shared with self.
        unsafe {
            fmpz_mod_mat_window_init(
                window.as_mut_ptr(),
                &self.matrix,
                row_1,
                col_1,
                row_2,
                col_2,
            )
        };
        let mut window_copy = MaybeUninit::uninit();
        unsafe {
            // Deep clone of the content of the window
            fmpz_mod_mat_init_set(window_copy.as_mut_ptr(), window.as_ptr());
            // Clears the matrix window and releases any memory that it uses. Note that
            // the memory to the underlying matrix that window points to is not freed
            fmpz_mod_mat_window_clear(window.as_mut_ptr());
        }
        MatZq {
            matrix: unsafe { window_copy.assume_init() },
            modulus: self.get_mod(),
        }
    }
}

impl MatZq {
    /// Efficiently collects all [`fmpz`]s in a [`MatZq`] without cloning them.
    ///
    /// Hence, the values on the returned [`Vec`] are intended for short-term use
    /// as the access to [`fmpz`] values could lead to memory leaks or modified values
    /// once the [`MatZq`] instance was modified or dropped.
    ///
    /// # Examples
    /// ```compile_fail
    /// use qfall_math::integer_mod_q::MatZq;
    /// use std::str::FromStr;
    ///
    /// let mat = MatZq::from_str("[[1, 2],[3, 4],[5, 6]] mod 3").unwrap();
    ///
    /// let fmpz_entries = mat.collect_entries();
    /// ```
    pub(crate) fn collect_entries(&self) -> Vec<fmpz> {
        let mut entries: Vec<fmpz> =
            Vec::with_capacity((self.get_num_rows() * self.get_num_columns()) as usize);

        for row in 0..self.get_num_rows() {
            for col in 0..self.get_num_columns() {
                // efficiently get entry without cloning the entry itself
                let entry = unsafe { *fmpz_mod_mat_entry(&self.matrix, row, col) };
                entries.push(entry);
            }
        }

        entries
    }

    /// Computes the lengths of a given vector of [`Z`] values
    /// considering the [`Modulus`] of `self`.
    ///
    /// # Examples
    /// ```compile_fail
    /// use qfall_math::integer_mod_q::MatZq;
    /// use std::str::FromStr;
    ///
    /// let mat = MatZq::from_str("[[1, 2],[3, 4]] mod 3").unwrap();
    ///
    /// let lengths = mat.collect_lengths();
    /// ```
    pub(crate) fn collect_lengths(&self) -> Vec<Z> {
        let entries_fmpz = self.collect_entries();

        let modulus_fmpz = self.matrix.mod_[0];
        let mut entry_lengths = Vec::with_capacity(entries_fmpz.len());
        for value in entries_fmpz {
            entry_lengths.push(length(&value, &modulus_fmpz));
        }

        entry_lengths
    }
}

impl MatrixDimensions for MatZq {
    /// Returns the number of rows of the matrix as a [`i64`].
    ///
    /// # Examples
    /// ```
    /// use qfall_math::integer_mod_q::MatZq;
    /// use qfall_math::traits::*;
    ///
    /// let matrix = MatZq::new(5, 6, 7);
    /// let rows = matrix.get_num_rows();
    /// ```
    fn get_num_rows(&self) -> i64 {
        self.matrix.mat[0].r
    }

    /// Returns the number of columns of the matrix as a [`i64`].
    ///
    /// # Examples
    /// ```
    /// use qfall_math::integer_mod_q::MatZq;
    /// use qfall_math::traits::*;
    ///
    /// let matrix = MatZq::new(5, 6, 7);
    /// let rows = matrix.get_num_columns();
    /// ```
    fn get_num_columns(&self) -> i64 {
        self.matrix.mat[0].c
    }
}

impl MatrixGetEntry<Z> for MatZq {
    /// Outputs the [`Z`] value of a specific matrix entry
    /// without checking whether it's part of the matrix.
    ///
    /// Parameters:
    /// - `row`: specifies the row in which the entry is located
    /// - `column`: specifies the column in which the entry is located
    ///
    /// Returns the [`Z`] value of the matrix at the position of the given
    /// row and column.
    ///
    /// # Safety
    /// To use this function safely, make sure that the selected entry is part
    /// of the matrix. If it is not, memory leaks, unexpected panics, etc. might
    /// occur.
    ///
    /// # Examples
    /// ```rust
    /// use qfall_math::integer_mod_q::MatZq;
    /// use qfall_math::traits::MatrixGetEntry;
    /// use qfall_math::integer::Z;
    /// use std::str::FromStr;
    ///
    /// let matrix = MatZq::from_str("[[1, 2, 3],[4, 5, 6],[7, 8, 9]] mod 10").unwrap();
    ///
    /// let entry_1 :Z = unsafe { matrix.get_entry_unchecked(0, 2) };
    /// let entry_2 :Z = unsafe { matrix.get_entry_unchecked(2, 1) };
    /// let entry_3 :Z = unsafe { matrix.get_entry_unchecked(2, 1) };
    ///
    /// assert_eq!(3, entry_1);
    /// assert_eq!(8, entry_2);
    /// assert_eq!(8, entry_3);
    /// ```
    unsafe fn get_entry_unchecked(&self, row: i64, column: i64) -> Z {
        let mut out = Z::default();
        let entry = unsafe { fmpz_mod_mat_entry(&self.matrix, row, column) };
        unsafe { fmpz_init_set(&mut out.value, entry) };

        out
    }
}

impl MatrixGetEntry<Zq> for MatZq {
    /// Outputs the [`Zq`] value of a specific matrix entry
    /// without checking whether it's part of the matrix.
    ///
    /// Parameters:
    /// - `row`: specifies the row in which the entry is located
    /// - `column`: specifies the column in which the entry is located
    ///
    /// Returns the [`Zq`] value of the matrix at the position of the given
    /// row and column.
    ///
    /// # Safety
    /// To use this function safely, make sure that the selected entry is part
    /// of the matrix. If it is not, memory leaks, unexpected panics, etc. might
    /// occur.
    ///
    /// # Examples
    /// ```rust
    /// use qfall_math::integer_mod_q::{MatZq, Zq};
    /// use qfall_math::traits::MatrixGetEntry;
    /// use std::str::FromStr;
    ///
    /// let matrix = MatZq::from_str("[[1, 2, 3],[4, 5, 6],[7, 8, 9]] mod 10").unwrap();
    ///
    /// assert_eq!(Zq::from((3, 10)), unsafe { matrix.get_entry_unchecked(0, 2) } );
    /// assert_eq!(Zq::from((8, 10)), unsafe { matrix.get_entry_unchecked(2, 1) } );
    /// assert_eq!(Zq::from((8, 10)), unsafe { matrix.get_entry_unchecked(2, 1) } );
    /// ```
    unsafe fn get_entry_unchecked(&self, row: i64, column: i64) -> Zq {
        let mut out = Zq::from((0, &self.modulus));
        let entry = unsafe { fmpz_mod_mat_entry(&self.matrix, row, column) };
        unsafe { fmpz_init_set(&mut out.value.value, entry) };

        out
    }
}

#[cfg(test)]
mod test_get_entry {
    use super::Zq;
    use crate::{
        integer::Z,
        integer_mod_q::MatZq,
        traits::{MatrixGetEntry, MatrixSetEntry},
    };
    use std::str::FromStr;

    /// Ensure that getting entries works on the edge.
    #[test]
    fn get_edges() {
        let matrix = MatZq::new(5, 10, u64::MAX);

        let entry_1: Z = matrix.get_entry(0, 0).unwrap();
        let entry_2: Z = matrix.get_entry(4, 9).unwrap();

        assert_eq!(0, entry_1);
        assert_eq!(0, entry_2);
    }

    /// Ensure that getting entries works with large numbers.
    #[test]
    fn max_int_positive() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        let value = Z::from(i64::MAX);
        matrix.set_entry(0, 0, value).unwrap();

        let entry: Z = matrix.get_entry(0, 0).unwrap();

        assert_eq!(i64::MAX, entry);
    }

    /// Ensure that getting entries works with large numbers (larger than [`i64`]).
    #[test]
    fn large_positive() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        let value = Z::from(u64::MAX - 1);
        matrix.set_entry(0, 0, value).unwrap();

        let entry: Z = matrix.get_entry(0, 0).unwrap();

        assert_eq!(u64::MAX - 1, entry);
    }

    /// Ensure that getting entries works with large numbers.
    #[test]
    fn max_int_negative() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        let value = Z::from(-i64::MAX);
        matrix.set_entry(0, 0, value).unwrap();

        let entry: Z = matrix.get_entry(0, 0).unwrap();

        assert_eq!((u64::MAX as i128 - i64::MAX as i128) as u64, entry);
    }

    /// Ensure that getting entries works with large numbers (larger than [`i64`]).
    #[test]
    fn large_negative() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        let value = Z::from(-i64::MAX - 1);
        matrix.set_entry(0, 0, value).unwrap();

        let entry: Z = matrix.get_entry(0, 0).unwrap();

        assert_eq!((u64::MAX as i128 - i64::MAX as i128) as u64 - 1, entry);
    }

    /// Ensure that a wrong number of rows yields an Error.
    #[test]
    fn error_wrong_row() {
        let matrix: MatZq = MatZq::new(5, 10, 7);

        assert!(MatrixGetEntry::<Z>::get_entry(&matrix, 5, 1).is_err());
        assert!(MatrixGetEntry::<Z>::get_entry(&matrix, -6, 1).is_err());
        assert!(MatrixGetEntry::<Zq>::get_entry(&matrix, 5, 1).is_err());
        assert!(MatrixGetEntry::<Zq>::get_entry(&matrix, -6, 1).is_err());
    }

    /// Ensure that a wrong number of columns yields an Error.
    #[test]
    fn error_wrong_column() {
        let matrix = MatZq::new(5, 10, 7);

        assert!(MatrixGetEntry::<Z>::get_entry(&matrix, 1, 10).is_err());
        assert!(MatrixGetEntry::<Z>::get_entry(&matrix, 1, -11).is_err());
        assert!(MatrixGetEntry::<Zq>::get_entry(&matrix, 1, 10).is_err());
        assert!(MatrixGetEntry::<Zq>::get_entry(&matrix, 1, -11).is_err());
    }

    /// Ensure that negative indices return the correct values.
    #[test]
    fn negative_indexing() {
        let matrix = MatZq::from_str("[[1, 2, 3],[4, 5, 6],[7, 8, 9]] mod 10").unwrap();

        let entry_1: Z = matrix.get_entry(-1, -1).unwrap();
        let entry_2: Z = matrix.get_entry(-1, -2).unwrap();
        let entry_3: Z = matrix.get_entry(-3, -3).unwrap();
        let entry_4: Zq = matrix.get_entry(-1, -1).unwrap();
        let entry_5: Zq = matrix.get_entry(-1, -2).unwrap();
        let entry_6: Zq = matrix.get_entry(-3, -3).unwrap();

        assert_eq!(9, entry_1);
        assert_eq!(8, entry_2);
        assert_eq!(1, entry_3);
        assert_eq!(Zq::from((9, 10)), entry_4);
        assert_eq!(Zq::from((8, 10)), entry_5);
        assert_eq!(Zq::from((1, 10)), entry_6);
    }

    /// Ensure that the entry is a deep copy and not just a clone of the reference.
    #[test]
    fn memory_test() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        let value = Zq::from((u64::MAX - 1, u64::MAX));
        matrix.set_entry(1, 1, value).unwrap();
        let entry: Z = matrix.get_entry(1, 1).unwrap();
        matrix.set_entry(1, 1, Z::ONE).unwrap();

        assert_eq!(u64::MAX - 1, entry);
    }

    /// Ensure that no memory leak occurs in get_entry with [`Z`](crate::integer::Z).
    #[test]
    fn get_entry_z_memory() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        matrix.set_entry(1, 1, Z::from(u64::MAX - 3)).unwrap();
        let _: Z = matrix.get_entry(1, 1).unwrap();
        matrix.set_entry(2, 2, Z::from(u64::MAX - 10)).unwrap();

        let entry: Z = matrix.get_entry(1, 1).unwrap();
        let _z = Z::from(u64::MAX);

        assert_eq!(entry, Z::from(u64::MAX - 3));
    }

    /// Ensure that no memory leak occurs in get_entry with [`Zq`](crate::integer_mod_q::Zq).
    #[test]
    fn get_entry_zq_memory() {
        let mut matrix = MatZq::new(5, 10, u64::MAX);
        matrix.set_entry(1, 1, Z::from(u64::MAX - 3)).unwrap();
        let _: Zq = matrix.get_entry(1, 1).unwrap();
        matrix.set_entry(2, 2, Z::from(u64::MAX - 10)).unwrap();

        let entry: Z = matrix.get_entry(1, 1).unwrap();
        let _z = Z::from(u64::MAX);

        assert_eq!(entry, Z::from(u64::MAX - 3));
    }

    /// Ensure that getting entries works with different types.
    #[test]
    fn diff_types() {
        let matrix = MatZq::new(5, 10, u64::MAX);

        let _: Z = matrix.get_entry(0, 0).unwrap();
        let _: Zq = matrix.get_entry(0, 0).unwrap();
    }
}

#[cfg(test)]
mod test_get_num {
    use crate::{integer_mod_q::MatZq, traits::MatrixDimensions};

    /// Ensure that the getter for number of rows works correctly.
    #[test]
    fn num_rows() {
        let matrix = MatZq::new(5, 10, 7);

        assert_eq!(matrix.get_num_rows(), 5);
    }

    /// Ensure that the getter for number of columns works correctly.
    #[test]
    fn num_columns() {
        let matrix = MatZq::new(5, 10, 7);

        assert_eq!(matrix.get_num_columns(), 10);
    }
}

#[cfg(test)]
mod test_get_representative_least_nonnegative_residue {
    use crate::{
        integer::Z,
        integer_mod_q::MatZq,
        traits::{MatrixDimensions, MatrixGetEntry, MatrixSetEntry},
    };

    /// Test if the dimensions are taken over correctly
    #[test]
    fn dimensions() {
        let matzq = MatZq::new(15, 17, 13);

        let matz_1 = matzq.get_representative_least_nonnegative_residue();

        assert_eq!(15, matz_1.get_num_rows());
        assert_eq!(17, matz_1.get_num_columns());
    }

    /// Test if entries are taken over correctly
    #[test]
    fn entries_taken_over_correctly() {
        let mut matzq = MatZq::new(2, 2, u64::MAX);
        matzq.set_entry(0, 0, u64::MAX - 58).unwrap();
        matzq.set_entry(0, 1, -1).unwrap();

        let matz_1 = matzq.get_representative_least_nonnegative_residue();

        assert_eq!(Z::from(u64::MAX - 1), matz_1.get_entry(0, 1).unwrap());
        assert_eq!(Z::from(u64::MAX - 58), matz_1.get_entry(0, 0).unwrap());
    }
}

#[cfg(test)]
mod test_mod {
    use crate::integer_mod_q::{MatZq, Modulus};

    /// Ensure that the getter for modulus works correctly.
    #[test]
    fn get_mod() {
        let matrix = MatZq::new(5, 10, 7);

        assert_eq!(matrix.get_mod(), Modulus::from(7));
    }

    /// Ensure that the getter for modulus works with large numbers.
    #[test]
    fn get_mod_large() {
        let matrix = MatZq::new(5, 10, u64::MAX);

        assert_eq!(matrix.get_mod(), Modulus::from(u64::MAX));
    }

    /// Ensure that no memory leak occurs in get_mod.
    #[test]
    fn get_mod_memory() {
        let matrix = MatZq::new(5, 10, u64::MAX);
        let _ = matrix.get_mod();
        let _ = Modulus::from(u64::MAX - 1);

        let modulus = matrix.get_mod();

        assert_eq!(modulus, Modulus::from(u64::MAX));
    }
}

#[cfg(test)]
mod test_get_vec {
    use crate::{integer_mod_q::MatZq, traits::MatrixGetSubmatrix};
    use std::str::FromStr;

    /// Ensure that getting a row works
    #[test]
    fn get_row_works() {
        let matrix = MatZq::from_str(&format!(
            "[[0, 0, 0],[4, {}, {}]] mod {}",
            i64::MAX,
            i64::MIN,
            u64::MAX
        ))
        .unwrap();
        let row_1 = matrix.get_row(0).unwrap();
        let row_2 = matrix.get_row(1).unwrap();

        let cmp_1 = MatZq::from_str(&format!("[[0, 0, 0]] mod {}", u64::MAX)).unwrap();
        let cmp_2 = MatZq::from_str(&format!(
            "[[4, {}, {}]] mod {}",
            i64::MAX,
            i64::MIN,
            u64::MAX
        ))
        .unwrap();

        assert_eq!(cmp_1, row_1);
        assert_eq!(cmp_2, row_2);
    }

    /// Ensure that getting a row with a negative index works
    #[test]
    fn get_row_negative_indexing_works() {
        let matrix = MatZq::from_str(&format!(
            "[[0, 0, 0],[42, {}, {}]] mod {}",
            i64::MAX,
            u64::MAX - 1,
            u64::MAX
        ))
        .unwrap();
        let row_1 = matrix.get_row(-2).unwrap();
        let row_2 = matrix.get_row(-1).unwrap();

        let cmp_1 = MatZq::from_str(&format!("[[0, 0, 0]] mod {}", u64::MAX)).unwrap();
        let cmp_2 = MatZq::from_str(&format!(
            "[[42, {}, {}]] mod {}",
            i64::MAX,
            u64::MAX - 1,
            u64::MAX
        ))
        .unwrap();

        assert_eq!(cmp_1, row_1);
        assert_eq!(cmp_2, row_2);
    }

    /// Ensure that getting a column works
    #[test]
    fn get_column_works() {
        let matrix = MatZq::from_str(&format!(
            "[[1, 0, 3],[{}, 0, 5],[{}, 0, 7]] mod {}",
            i64::MAX,
            i64::MIN,
            u64::MAX
        ))
        .unwrap();
        let column_1 = matrix.get_column(0).unwrap();
        let column_2 = matrix.get_column(1).unwrap();
        let column_3 = matrix.get_column(2).unwrap();

        let cmp_1 = MatZq::from_str(&format!(
            "[[1],[{}],[{}]] mod {}",
            i64::MAX,
            i64::MIN,
            u64::MAX
        ))
        .unwrap();
        let cmp_2 = MatZq::from_str(&format!("[[0],[0],[0]] mod {}", u64::MAX)).unwrap();
        let cmp_3 = MatZq::from_str(&format!("[[3],[5],[7]] mod {}", u64::MAX)).unwrap();

        assert_eq!(cmp_1, column_1);
        assert_eq!(cmp_2, column_2);
        assert_eq!(cmp_3, column_3);
    }

    /// Ensure that getting a column with a negative index works
    #[test]
    fn get_column_negative_indexing_works() {
        let matrix = MatZq::from_str(&format!(
            "[[42, 0, 42],[{}, 0, 17],[{}, 0, 42]] mod {}",
            i64::MAX,
            u64::MAX - 1,
            u64::MAX
        ))
        .unwrap();
        let column_1 = matrix.get_column(-3).unwrap();
        let column_2 = matrix.get_column(-2).unwrap();
        let column_3 = matrix.get_column(-1).unwrap();

        let cmp_1 = MatZq::from_str(&format!(
            "[[42],[{}],[{}]] mod {}",
            i64::MAX,
            u64::MAX - 1,
            u64::MAX
        ))
        .unwrap();
        let cmp_2 = MatZq::from_str(&format!("[[0],[0],[0]] mod {}", u64::MAX)).unwrap();
        let cmp_3 = MatZq::from_str(&format!("[[42],[17],[42]] mod {}", u64::MAX)).unwrap();

        assert_eq!(cmp_1, column_1);
        assert_eq!(cmp_2, column_2);
        assert_eq!(cmp_3, column_3);
    }

    /// Ensure that wrong row and column dimensions yields an error
    #[test]
    fn wrong_dim_error() {
        let matrix = MatZq::from_str(&format!(
            "[[1, 2, 3],[{}, 4, 5],[{}, 6, 7]] mod {}",
            i64::MAX,
            i64::MIN,
            u64::MAX
        ))
        .unwrap();
        let row_1 = matrix.get_row(-4);
        let row_2 = matrix.get_row(4);
        let column_1 = matrix.get_column(-4);
        let column_2 = matrix.get_column(4);

        assert!(row_1.is_err());
        assert!(row_2.is_err());
        assert!(column_1.is_err());
        assert!(column_2.is_err());
    }
}

#[cfg(test)]
mod test_get_submatrix {
    use crate::{
        integer::Z,
        integer_mod_q::MatZq,
        traits::{MatrixDimensions, MatrixGetSubmatrix},
    };
    use std::str::FromStr;

    /// Ensures that getting the entire matrix as a submatrix works.
    #[test]
    fn entire_matrix() {
        let mat = MatZq::identity(5, 5, i64::MAX);

        let sub_mat = mat.get_submatrix(0, 4, 0, 4).unwrap();

        assert_eq!(mat, sub_mat);
    }

    /// Ensures that a single matrix entry can be retrieved.
    #[test]
    fn matrix_single_entry() {
        let mat = MatZq::identity(5, 5, i64::MAX);

        let sub_mat = mat.get_submatrix(0, 0, 0, 0).unwrap();

        let cmp_mat = MatZq::identity(1, 1, i64::MAX);
        assert_eq!(cmp_mat, sub_mat);
    }

    /// Ensures that the dimensions of the submatrix are correct.
    #[test]
    fn correct_dimensions() {
        let mat = MatZq::identity(100, 100, i64::MAX);

        let sub_mat = mat.get_submatrix(1, 37, 0, 29).unwrap();

        assert_eq!(37, sub_mat.get_num_rows());
        assert_eq!(30, sub_mat.get_num_columns());
    }

    /// Ensures that a submatrix can be correctly retrieved for a matrix with large
    /// entries.
    #[test]
    fn large_entries() {
        let mat = MatZq::from_str(&format!(
            "[[{}, 2, 3],[1, {}, 3]] mod {}",
            u64::MAX,
            i64::MIN,
            u128::MAX
        ))
        .unwrap();

        let sub_mat = mat.get_submatrix(0, 1, 0, 1).unwrap();

        let cmp_mat = MatZq::from_str(&format!(
            "[[{}, 2],[1, {}]] mod {}",
            u64::MAX,
            i64::MIN,
            u128::MAX
        ))
        .unwrap();
        assert_eq!(cmp_mat, sub_mat);
    }

    /// Ensures that an error is returned if coordinates are addressed that are not
    /// within the matrix.
    #[test]
    fn invalid_coordinates() {
        let mat = MatZq::identity(10, 10, u64::MAX);

        assert!(mat.get_submatrix(0, 0, 0, 10).is_err());
        assert!(mat.get_submatrix(0, 10, 0, 0).is_err());
        assert!(mat.get_submatrix(0, 0, -11, 0).is_err());
        assert!(mat.get_submatrix(-11, 0, 0, 0).is_err());
    }

    /// Ensure that negative indices return the correct submatrix.
    #[test]
    fn negative_indexing() {
        let matrix = MatZq::identity(3, 3, u64::MAX);

        assert_eq!(matrix, matrix.get_submatrix(0, -1, 0, -1).unwrap());
        assert_eq!(matrix, matrix.get_submatrix(-3, -1, -3, -1).unwrap());
        assert_eq!(
            matrix.get_row(0).unwrap(),
            matrix.get_submatrix(0, -3, -3, -1).unwrap()
        );
    }

    /// Ensures that the function panics if no columns of the matrix are addressed.
    #[test]
    #[should_panic]
    fn no_columns() {
        let mat = MatZq::identity(10, 10, u64::MAX);

        let _ = mat.get_submatrix(0, 0, 6, 5);
    }

    /// Ensures that the function panics if no rows of the matrix are addressed.
    #[test]
    #[should_panic]
    fn no_rows() {
        let mat = MatZq::identity(10, 10, u64::MAX);

        let _ = mat.get_submatrix(5, 4, 0, 0);
    }

    /// Ensure that the submatrix function can be called with several types.
    #[test]
    fn availability() {
        let mat = MatZq::identity(10, 10, u64::MAX);

        let _ = mat.get_submatrix(0_i8, 0_i8, 0_i8, 0_i8);
        let _ = mat.get_submatrix(0_i16, 0_i16, 0_i16, 0_i16);
        let _ = mat.get_submatrix(0_i32, 0_i32, 0_i32, 0_i32);
        let _ = mat.get_submatrix(0_i64, 0_i64, 0_i64, 0_i64);
        let _ = mat.get_submatrix(0_u8, 0_u8, 0_u8, 0_u8);
        let _ = mat.get_submatrix(0_u16, 0_i16, 0_u16, 0_u16);
        let _ = mat.get_submatrix(0_u32, 0_i32, 0_u32, 0_u32);
        let _ = mat.get_submatrix(0_u64, 0_i64, 0_u64, 0_u64);
        let _ = mat.get_submatrix(&Z::ZERO, &Z::ZERO, &Z::ZERO, &Z::ZERO);
    }
}

#[cfg(test)]
mod test_collect_entries {
    use super::MatZq;
    use std::str::FromStr;

    /// Ensures that all entries from the matrices are actually collected in the vector.
    #[test]
    fn all_entries_collected() {
        let mat_1 = MatZq::from_str(&format!(
            "[[1, 2],[{}, {}],[3, 4]] mod {}",
            i64::MAX,
            i64::MIN,
            u64::MAX
        ))
        .unwrap();
        let mat_2 = MatZq::from_str("[[-1, 2]] mod 2").unwrap();

        let entries_1 = mat_1.collect_entries();
        let entries_2 = mat_2.collect_entries();

        assert_eq!(entries_1.len(), 6);
        assert_eq!(entries_1[0].0, 1);
        assert_eq!(entries_1[1].0, 2);
        assert!(entries_1[2].0 >= 2_i64.pow(62));
        assert!(entries_1[3].0 >= 2_i64.pow(62));
        assert_eq!(entries_1[4].0, 3);
        assert_eq!(entries_1[5].0, 4);

        assert_eq!(entries_2.len(), 2);
        assert_eq!(entries_2[0].0, 1);
        assert_eq!(entries_2[1].0, 0);
    }
}

#[cfg(test)]
mod test_collect_lengths {
    use super::{MatZq, Z};
    use std::str::FromStr;

    /// Ensures that the lengths of the matrices are collected correctly.
    #[test]
    fn lengths_correctly_computed() {
        let mat_1 = MatZq::from_str(&format!(
            "[[1, 2],[{}, {}],[3, 4]] mod {}",
            i64::MAX - 2,
            i64::MIN,
            i64::MAX - 1
        ))
        .unwrap();
        let mat_2 = MatZq::from_str("[[-1, 2]] mod 2").unwrap();

        let lengths_1 = mat_1.collect_lengths();
        let lengths_2 = mat_2.collect_lengths();

        assert_eq!(lengths_1.len(), 6);
        assert_eq!(lengths_1[0], Z::ONE);
        assert_eq!(lengths_1[1], Z::from(2));
        assert_eq!(lengths_1[2], Z::ONE);
        assert_eq!(lengths_1[3], Z::from(2));
        assert_eq!(lengths_1[4], Z::from(3));
        assert_eq!(lengths_1[5], Z::from(4));

        assert_eq!(lengths_2.len(), 2);
        assert_eq!(lengths_2[0], Z::ONE);
        assert_eq!(lengths_2[1], Z::ZERO);
    }
}

#[cfg(test)]
mod test_get_representative_least_absolute_residue {
    use super::*;
    use std::str::FromStr;

    /// Test with a large modulus.
    #[test]
    fn large_modulus() {
        let mat_zq = MatZq::from_str(&format!("[[1,2],[-1,-2]] mod {}", u64::MAX)).unwrap();

        let mat_z = mat_zq.get_representative_least_absolute_residue();

        let mat_cmp = MatZ::from_str("[[1,2],[-1,-2]]").unwrap();
        assert_eq!(mat_z.to_string(), mat_cmp.to_string());
    }

    /// Test with even modulus.
    #[test]
    fn even_modulus() {
        let mat_zq = MatZq::from_str("[[0,1,2,3,4,5,6,7,8,9,10]] mod 10").unwrap();

        let mat_z = mat_zq.get_representative_least_absolute_residue();

        let mat_cmp = MatZ::from_str("[[0,1,2,3,4,5,-4,-3,-2,-1,0]]").unwrap();
        assert_eq!(mat_z.to_string(), mat_cmp.to_string());
    }

    /// Test with uneven modulus.
    #[test]
    fn uneven_modulus() {
        let mat_zq = MatZq::from_str("[[0,1,2,3,4,5,6,7,8,9,10,11]] mod 11").unwrap();

        let mat_z = mat_zq.get_representative_least_absolute_residue();

        let mat_cmp = MatZ::from_str("[[0,1,2,3,4,5,-5,-4,-3,-2,-1,0]]").unwrap();
        assert_eq!(mat_z.to_string(), mat_cmp.to_string());
    }
}