==================

*/

impl Debug for FlagMatrix {

    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {

        for r in 0..self.dims[0] {

            write!(f, "|")?;

            for c in 0..self.dims[1] {

                write!(

                    f,

                    "{}",

                    match self.test([r, c]) {

                        false => '0',

                        true => '1',

                    }

                )?;

            }

            write!(f, "|\n")?;

        }

        Ok(())

    }

}

struct FlagMatrix {

    bytes: *mut u32,

    u32s_total: usize,

    u32s_per_row: usize,

    dims: [usize; 2],

}

#[inline(always)]

fn ceiling_to_mul_32(value: usize) -> usize {

    (value + 31) & !31

}

impl Drop for FlagMatrix {

    fn drop(&mut self) {

        let layout = Self::layout_for(self.u32s_total);

        unsafe {

            // ?

            std::alloc::dealloc(self.bytes as *mut u8, layout);

        }

    }

}

impl FlagMatrix {

    fn get_dims(&self) -> &[usize; 2] {

        &self.dims

    }

    fn reshape(&mut self, new_dims: [usize; 2]) {

        dbg!(self.u32s_total, self.u32s_per_row);

        // 1. calc new u32s_per_row

        let new_u32s_per_row = match ceiling_to_mul_32(new_dims[1]) / 32 {

            min if min > self.u32s_per_row => Some(min * 2),

            _ => None,

        };

        // 2. calc new u32s_total

        let new_u32s_total = match new_u32s_per_row.unwrap_or(self.u32s_per_row) * new_dims[0] {

            min if min > self.u32s_total => Some(min * 2),

            _ => None,

        };

        // 3. set any bits no longer in columns to zero

        let new_last_chunk_zero_prefix = new_dims[1] % 32;

        if new_dims[1] < self.dims[1] {

            let old_min_u32_per_row = ceiling_to_mul_32(new_dims[1]) / 32;

            let new_min_u32_per_row = ceiling_to_mul_32(self.dims[1]) / 32;

            let common_rows = self.dims[0].min(new_dims[0]);

            if old_min_u32_per_row < new_min_u32_per_row {

                // zero chunks made entirely of removed columns

                for row in 0..common_rows {

                    unsafe {

                        self.bytes

                            .add(self.offset_of_chunk_unchecked([row, old_min_u32_per_row]))

                            .write_bytes(0u8, new_min_u32_per_row - old_min_u32_per_row);

                    }

                }

            }

            if new_last_chunk_zero_prefix > 0 {

                // wipe out new_last_chunk_zero_prefix-most significant bits of all new last column chunks

                let mask: u32 = !0u32 >> new_last_chunk_zero_prefix;

                for row in 0..common_rows {

                    let o_of = self.offset_of_chunk_unchecked([row, new_min_u32_per_row - 1]);

                    unsafe { *self.bytes.add(o_of) &= mask };

                }

            }

        }

        dbg!(new_u32s_per_row, new_u32s_total);

        match [new_u32s_per_row, new_u32s_total] {

            [None, None] => { /* do nothing */ }

            [None, Some(new_u32s_total)] => {

                // realloc only! column alignment is still OK

                // assert!(new_u32s_total > self.u32s_total);

                let old_layout = Self::layout_for(self.u32s_total);

                let new_layout = Self::layout_for(new_u32s_total);

                let new_bytes = unsafe {

                    let new_bytes = std::alloc::alloc(new_layout) as *mut u32;

                    // copy the previous total

                    self.bytes.copy_to_nonoverlapping(new_bytes, self.u32s_total);

                    // and zero the remainder

                    new_bytes

                        .add(self.u32s_total)

                        .write_bytes(0u8, new_u32s_total - self.u32s_total);

                    // drop the previous buffer

                    std::alloc::dealloc(self.bytes as *mut u8, old_layout);

                    new_bytes

                };

                self.bytes = new_bytes;

                println!("AFTER {:?}", self.bytes);

                self.u32s_total = new_u32s_total;

        assert!(t_row < self.dims[0]);

        for &f_row in f_rows.iter() {

            assert!(f_row < self.dims[0]);

        }

        // 2. construct an unsafe iterator over chunks

        // column_chunk_range ensures all col_chunk_index values are in range.

        let column_chunk_range = 0..ceiling_to_mul_32(self.dims[1]) / 32;

        let chunk_iter = column_chunk_range.map(move |col_chunk_index| {

            // SAFETY: all rows and columns have already been bounds-checked.

            let t_chunk = unsafe { self.copy_chunk_unchecked(t_row, col_chunk_index) };

            f_rows.iter().fold(t_chunk, |chunk, &f_row| {

                let f_chunk = unsafe { self.copy_chunk_unchecked(f_row, col_chunk_index) };

                chunk & !f_chunk

            })

        });

        // 3. yield columns indices from the chunk iterator

        BitChunkIter::new(chunk_iter)

    }

}

#[test]

fn matrix() {

    for i in 0..5 {

        m.set([0, i]);

        m.set([i, i]);

    }

    println!("{:?}", &m);

    m.reshape([6, 40]);

    let iter = m.col_iter_t1fn(0, &[1, 2, 3]);

    for c in iter {

        println!("{:?}", c);

    }

    println!("{:?}", &m);

}