pub fn multiply_inverse_into(&self, rhs: &impl Transposition, into: &mut Change) {
        if self.stage() != rhs.stage() {
            panic!("Can't use transpositions of different stages!");
        }

        let stage = self.stage().as_usize();

        while into.stage().as_usize() < stage {
            into.seq.push(Bell::from(0));
        }

        if into.stage().as_usize() > stage {
            into.seq.truncate(stage);
        }

        for i in 0..stage {
            into.seq[rhs.bell_at(Place::from(i)).as_usize()] = self.seq[i];
        }
    }
/// Multiplies this `Change` by the inversion of a [Transposition], and copies the result into
/// another `Change` to without any heap allocations.  Same as [multiply](Change::multiply), except
/// that it will avoid allocating a new `Change` on the heap if an old one can be reused.
///
/// # Panics
/// Panics if `rhs` doesn't have the same [Stage] as this `Change`.
///
/// # Example
/// ```
/// use bellmetal::{Bell, Change};
///
/// let part_head = Change::from("34567812");
/// let some_change = Change::from("23456187");
/// let mut output_change = Change::empty();
///
/// part_head.multiply_inverse_into(&some_change, &mut output_change);
///
/// assert_eq!(output_change, Change::from("83456721"));
/// ```
Multiplies this `Change` by the inversion of a [Transposition], and copies the result into
another `Change` to without any heap allocations.  Same as [multiply](Change::multiply), except
that it will avoid allocating a new `Change` on the heap if an old one can be reused.
Multiplies this ` Change ` by the inversion of a [ Transposition ] and copies the result into another ` Change ` to without any heap allocations . Same as [ multiply ] ( Change :: multiply ) except that it will avoid allocating a new ` Change ` on the heap if an old one can be reused .
pub fn multiply_inverse_into(&self, rhs: &impl Transposition, into: &mut Change) {
        if self.stage() != rhs.stage() {
            panic!("Can't use transpositions of different stages!");
        }
        let stage = self.stage().as_usize();
        while into.stage().as_usize() < stage {
            into.seq.push(Bell::from(0));
        }
        if into.stage().as_usize() > stage {
            into.seq.truncate(stage);
        }
        for i in 0..stage {
            into.seq[rhs.bell_at(Place::from(i)).as_usize()] = self.seq[i];
        }
    }
pub fn multiply_inverse_into ( & self , rhs : & impl Transposition , into : & mut Change ) { if self . stage ( ) != rhs . stage ( ) { panic ! ( " " ) ; } let stage = self . stage ( ) . as_usize ( ) ; while into . stage ( ) . as_usize ( ) < stage { into . seq . push ( Bell :: from ( 0 ) ) ; } if into . stage ( ) . as_usize ( ) > stage { into . seq . truncate ( stage ) ; } for i in 0 .. stage { into . seq [ rhs . bell_at ( Place :: from ( i ) ) . as_usize ( ) ] = self . seq [ i ] ; } }
Multiplies this `Change` by the inversion of a [Transposition], and copies the result into
another `Change` to without any heap allocations.
Multiplies this ` Change ` by the inversion of a [ Transposition ] and copies the result into another ` Change ` to without any heap allocations .
&self
rhs
&impl Transposition
into
&mut Change
&self
rhs
&impl Transposition
into
&mut Change
panics
Panics if `rhs` doesn't have the same [Stage] as this `Change`.
Panics if ` rhs ` doesn ' t have the same [ Stage ] as this ` Change ` .
example
```
use bellmetal::{Bell, Change}.



part_head.multiply_inverse_into(&some_change, &mut output_change).


` ` ` use bellmetal :: { Bell Change } . part_head . multiply_inverse_into ( &some_change &mut output_change ) .