Method get_transform_steps

bitvm/src/bigint/std.rs:397–461

Generates a vector of TransformStep struct that encodes all the information needed to convert BigInt form one limbsize represention (source) to another (target). used as a helper function for `transform_limbsize`

(source_limb_size: u32, target_limb_size: u32)

    /// convert BigInt form one limbsize represention (source) to another (target).
    /// used as a helper function for `transform_limbsize`
    fn get_transform_steps(source_limb_size: u32, target_limb_size: u32) -> Vec<TransformStep> {
        //define an empty vector to store Transform steps
        let mut transform_steps: Vec<TransformStep> = Vec::new();

        // compute the number of limbs for target and source
        let target_n_limbs = N_BITS.div_ceil(target_limb_size);
        let mut target_limb_remaining_bits = Self::N_BITS - (target_n_limbs - 1) * target_limb_size;
        let source_n_limbs = N_BITS.div_ceil(source_limb_size);
        let source_head = Self::N_BITS - (source_n_limbs - 1) * source_limb_size;

        // define a vector of limbsizes of source
        let mut limb_sizes: Vec<u32> = Vec::with_capacity(source_n_limbs as usize);
        let mut first_iter_flag = true;
        for _ in 0..(source_n_limbs - 1) {
            limb_sizes.push(source_limb_size);
        }
        limb_sizes.push(source_head);

        //iterate until all limbs of source are processed
        while !limb_sizes.is_empty() {
            //iterate until the target limb is filled completely
            while target_limb_remaining_bits > 0 {
                let source_limb_last_idx = limb_sizes.len() - 1;
                let source_limb_remaining_bits = limb_sizes[source_limb_last_idx];

                match source_limb_remaining_bits.cmp(&target_limb_remaining_bits) {
                    Ordering::Less => {
                        transform_steps.push(TransformStep {
                            current_limb_remaining_bits: source_limb_remaining_bits,
                            extract_window: source_limb_remaining_bits,
                            drop_currentlimb: true,
                            initiate_targetlimb: first_iter_flag,
                        });
                        target_limb_remaining_bits -= source_limb_remaining_bits;
                        limb_sizes.pop();
                    }
                    Ordering::Equal => {
                        transform_steps.push(TransformStep {
                            current_limb_remaining_bits: source_limb_remaining_bits,
                            extract_window: target_limb_remaining_bits,
                            drop_currentlimb: true,
                            initiate_targetlimb: first_iter_flag,
                        });
                        target_limb_remaining_bits = 0;
                        limb_sizes.pop();
                    }
                    Ordering::Greater => {
                        transform_steps.push(TransformStep {
                            current_limb_remaining_bits: source_limb_remaining_bits,
                            extract_window: target_limb_remaining_bits,
                            drop_currentlimb: false,
                            initiate_targetlimb: first_iter_flag,
                        });
                        limb_sizes[source_limb_last_idx] =
                            source_limb_remaining_bits - target_limb_remaining_bits;
                        target_limb_remaining_bits = 0;
                    }
                }