qfall_math/integer/mat_z/

get.rs

// Copyright © 2023 Marcel Luca Schmidt, Marvin Beckmann
//
// 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 [`MatZ`] matrix.

use super::MatZ;
use crate::{
    integer::Z,
    traits::{MatrixDimensions, MatrixGetEntry, MatrixGetSubmatrix},
};
use flint_sys::{
    fmpz::{fmpz, fmpz_init_set},
    fmpz_mat::{fmpz_mat_entry, fmpz_mat_init_set, fmpz_mat_window_clear, fmpz_mat_window_init},
};
use std::mem::MaybeUninit;

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

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

impl MatrixGetEntry<Z> for MatZ {
    /// 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
    /// ```
    /// use qfall_math::integer::{MatZ, Z};
    /// use qfall_math::traits::MatrixGetEntry;
    /// use std::str::FromStr;
    ///
    /// let matrix = MatZ::from_str("[[1, 2, 3],[4, 5, 6],[7, 8, 9]]").unwrap();
    ///
    /// assert_eq!(unsafe { matrix.get_entry_unchecked(0, 2) }, Z::from(3));
    /// assert_eq!(unsafe { matrix.get_entry_unchecked(2, 1) }, Z::from(8));
    /// assert_eq!(unsafe { matrix.get_entry_unchecked(2, 1) }, Z::from(8));
    /// ```
    unsafe fn get_entry_unchecked(&self, row: i64, column: i64) -> Z {
        let mut copy = fmpz(0);
        let entry = unsafe { fmpz_mat_entry(&self.matrix, row, column) };
        unsafe { fmpz_init_set(&mut copy, entry) };

        Z { value: copy }
    }
}

impl MatrixGetSubmatrix for MatZ {
    /// 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::MatZ, traits::MatrixGetSubmatrix};
    /// use std::str::FromStr;
    ///
    /// let mat = MatZ::identity(3, 3);
    ///
    /// 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 = MatZ::from_str("[[0],[1],[0]]").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_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_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_mat_window_clear(window.as_mut_ptr());
        }
        MatZ {
            matrix: unsafe { window_copy.assume_init() },
        }
    }
}

impl MatZ {
    /// Efficiently collects all [`fmpz`]s in a [`MatZ`] 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 [`MatZ`] instance was modified or dropped.
    ///
    /// # Examples
    /// ```compile_fail
    /// use qfall_math::integer::MatZ;
    /// use std::str::FromStr;
    ///
    /// let mat = MatZ::from_str("[[1, 2],[3, 4],[5, 6]]").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_mat_entry(&self.matrix, row, col) };
                entries.push(entry);
            }
        }

        entries
    }
}

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

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

        let entry = matrix.get_entry(1, 1).unwrap();

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

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

        let entry = matrix.get_entry(1, 1).unwrap();

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

    /// Ensure that getting entries works with large negative numbers.
    #[test]
    fn max_int_negative() {
        let mut matrix = MatZ::new(5, 10);
        let value = Z::from(i64::MIN);
        matrix.set_entry(1, 1, value).unwrap();

        let entry = matrix.get_entry(1, 1).unwrap();

        assert_eq!(Z::from(i64::MIN), entry);
    }

    /// Ensure that getting entries works with large negative numbers (larger than i64).
    #[test]
    fn large_negative() {
        let mut matrix = MatZ::new(5, 10);
        let value_str = &format!("-{}", u64::MAX);
        matrix
            .set_entry(1, 1, Z::from_str(value_str).unwrap())
            .unwrap();

        let entry = matrix.get_entry(1, 1).unwrap();

        assert_eq!(Z::from_str(value_str).unwrap(), entry);
    }

    /// Ensure that getting entries at (0, 0) works.
    #[test]
    fn getting_at_zero() {
        let mut matrix = MatZ::new(5, 10);
        let value = Z::from(i64::MIN);
        matrix.set_entry(0, 0, value).unwrap();

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

        assert_eq!(entry, Z::from(i64::MIN));
    }

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

        assert!(matrix.get_entry(5, 1).is_err());
        assert!(matrix.get_entry(-6, 1).is_err());
    }

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

        assert!(matrix.get_entry(1, 100).is_err());
        assert!(matrix.get_entry(1, -11).is_err());
    }

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

        assert_eq!(matrix.get_entry(-1, -1).unwrap(), Z::from(9));
        assert_eq!(matrix.get_entry(-1, -2).unwrap(), Z::from(8));
        assert_eq!(matrix.get_entry(-3, -3).unwrap(), Z::from(1));
    }

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

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

    // *** Doc-tests of automatically implemented functions by `MatrixGetEntry`

    /// Ensures that the doc-test of [`MatZ::get_entries`] works.
    #[test]
    fn get_entries() {
        let matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let entries = matrix.get_entries();
        let mut added_entries = Z::default();
        for row in entries {
            for entry in row {
                added_entries += entry;
            }
        }
    }

    /// Ensures that [`MatZ::get_entries`] returns all entries in the correct order.
    #[test]
    fn get_entries_correct() {
        let matrix = MatZ::from_str("[[2, 3, 4],[5, 6, 7]]").unwrap();

        let entries = matrix.get_entries();

        assert_eq!(2, entries[0][0]);
        assert_eq!(3, entries[0][1]);
        assert_eq!(4, entries[0][2]);
        assert_eq!(5, entries[1][0]);
        assert_eq!(6, entries[1][1]);
        assert_eq!(7, entries[1][2]);

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

    /// Ensures that the doc-test of [`MatZ::get_entries_rowwise`] works.
    #[test]
    fn get_entries_rowwise() {
        let matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let entries = matrix.get_entries_rowwise();
        let mut added_entries = Z::default();
        for entry in entries {
            added_entries += entry;
        }
    }

    /// Ensures that [`MatZ::get_entries_rowwise`] returns all entries in the correct order.
    #[test]
    fn get_entries_rowwise_correct() {
        let matrix = MatZ::from_str("[[2, 3, 4],[5, 6, 7]]").unwrap();

        let entries = matrix.get_entries_rowwise();

        assert_eq!(2, entries[0]);
        assert_eq!(3, entries[1]);
        assert_eq!(4, entries[2]);
        assert_eq!(5, entries[3]);
        assert_eq!(6, entries[4]);
        assert_eq!(7, entries[5]);
        assert_eq!(6, entries.len());
    }

    /// Ensures that the doc-test of [`MatZ::get_entries_columnwise`] works.
    #[test]
    fn get_entries_columnwise() {
        let matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let entries = matrix.get_entries_columnwise();
        let mut added_entries = Z::default();
        for entry in entries {
            added_entries += entry;
        }
    }

    /// Ensures that [`MatZ::get_entries_columnwise`] returns all entries in the correct order.
    #[test]
    fn get_entries_columnwise_correct() {
        let matrix = MatZ::from_str("[[2, 3, 4],[5, 6, 7]]").unwrap();

        let entries = matrix.get_entries_columnwise();

        assert_eq!(2, entries[0]);
        assert_eq!(5, entries[1]);
        assert_eq!(3, entries[2]);
        assert_eq!(6, entries[3]);
        assert_eq!(4, entries[4]);
        assert_eq!(7, entries[5]);
        assert_eq!(6, entries.len());
    }
}

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

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

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

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

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

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

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

        let cmp_1 = MatZ::from_str("[[0, 0, 0]]").unwrap();
        let cmp_2 = MatZ::from_str(&format!("[[4, {}, {}]]", i64::MAX, i64::MIN)).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 =
            MatZ::from_str(&format!("[[0, 0, 0],[42, {}, {}]]", i64::MAX, i64::MIN)).unwrap();
        let row_1 = matrix.get_row(-2).unwrap();
        let row_2 = matrix.get_row(-1).unwrap();

        let cmp_1 = MatZ::from_str("[[0, 0, 0]]").unwrap();
        let cmp_2 = MatZ::from_str(&format!("[[42, {}, {}]]", i64::MAX, i64::MIN)).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 = MatZ::from_str(&format!(
            "[[1, 0, 3],[{}, 0, 5],[{}, 0, 7]]",
            i64::MAX,
            i64::MIN
        ))
        .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 = MatZ::from_str(&format!("[[1],[{}],[{}]]", i64::MAX, i64::MIN)).unwrap();
        let cmp_2 = MatZ::from_str("[[0],[0],[0]]").unwrap();
        let cmp_3 = MatZ::from_str("[[3],[5],[7]]").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 = MatZ::from_str(&format!(
            "[[42, 0, 42],[{}, 0, 17],[{}, 0, 42]]",
            i64::MAX,
            i64::MIN
        ))
        .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 = MatZ::from_str(&format!("[[42],[{}],[{}]]", i64::MAX, i64::MIN)).unwrap();
        let cmp_2 = MatZ::from_str("[[0],[0],[0]]").unwrap();
        let cmp_3 = MatZ::from_str("[[42],[17],[42]]").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 = MatZ::from_str(&format!(
            "[[1, 2, 3],[{}, 4, 5],[{}, 6, 7]]",
            i64::MAX,
            i64::MIN
        ))
        .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::{MatZ, Z},
        traits::{MatrixDimensions, MatrixGetSubmatrix, MatrixSetSubmatrix},
    };
    use std::str::FromStr;

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

        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 = MatZ::identity(5, 5);

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

        let cmp_mat = MatZ::identity(1, 1);
        assert_eq!(cmp_mat, sub_mat);
    }

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

        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 = MatZ::from_str(&format!("[[{}, 2, 3],[1, {}, 3]]", u64::MAX, i64::MIN)).unwrap();

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

        let cmp_mat = MatZ::from_str(&format!("[[{}, 2],[1, {}]]", u64::MAX, i64::MIN)).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 = MatZ::identity(10, 10);

        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 = MatZ::from_str("[[1, 2, 3],[4, 5, 6],[7, 8, 9]]").unwrap();

        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 = MatZ::identity(10, 10);

        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 = MatZ::identity(10, 10);

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

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

        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);
    }

    // *** Doc-tests of automatically implemented functions by `MatrixGetSubmatrix`

    /// Ensures that the first doc-test of [`MatZ::get_rows`] works.
    #[test]
    fn get_rows_1() {
        let matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let mut added_rows = MatZ::new(1, 3);
        for row in matrix.get_rows() {
            added_rows += row;
        }
    }

    /// Ensures that the second doc-test of [`MatZ::get_rows`] works.
    #[test]
    fn get_rows_2() {
        let mut matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let mut added_rows = MatZ::new(1, 3);
        for (i, row) in matrix.get_rows().iter().enumerate() {
            added_rows += row;
            matrix.set_row(i, &added_rows, 0).unwrap();
        }
    }

    /// Ensures that the first doc-test of [`MatZ::get_columns`] works.
    #[test]
    fn get_columns_1() {
        let matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let mut added_columns = MatZ::new(3, 1);
        for column in matrix.get_columns() {
            added_columns += column;
        }
    }

    /// Ensures that the second doc-test of [`MatZ::get_columns`] works.
    #[test]
    fn get_columns_2() {
        let mut matrix = MatZ::sample_uniform(3, 3, 0, 16).unwrap();

        let mut added_columns = MatZ::new(3, 1);
        for (i, column) in matrix.get_columns().iter().enumerate() {
            added_columns += column;
            matrix.set_column(i, &added_columns, 0).unwrap();
        }
    }
}

#[cfg(test)]
mod test_collect_entries {
    use super::MatZ;
    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 =
            MatZ::from_str(&format!("[[1, 2],[{}, {}],[3, 4]]", i64::MAX, i64::MIN)).unwrap();
        let mat_2 = MatZ::from_str("[[-1, 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, 2);
    }
}