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

        into.seq.clear();

        for i in 0..self.stage().as_usize() {
            into.seq
                .push(lhs.bell_at(Place::from(self.seq[i].as_number())));
        }
    }
/// Multiplies this `Change` on to the end of the argument, and copies the result into another
/// `Change` to avoid heap allocations.  Note that the argument is used on the **left** hand side
/// of the multiplication.
///
/// # Panics
/// Panics if `lhs` is doesn't have the same [Stage] as this `Change`.
///
/// # Example
/// ```
/// use bellmetal::Change;
///
/// let part_head = Change::from("34567812");
/// let example_change = Change::from("43215786");
/// let mut output_change = Change::empty();
///
/// example_change.pre_multiply_into(&part_head, &mut output_change);
///
/// assert_eq!(output_change, Change::from("65437128"));
/// ```
Multiplies this `Change` on to the end of the argument, and copies the result into another
`Change` to avoid heap allocations.  Note that the argument is used on the **left** hand side
of the multiplication.
Multiplies this ` Change ` on to the end of the argument and copies the result into another ` Change ` to avoid heap allocations . Note that the argument is used on the ** left ** hand side of the multiplication .
pub fn pre_multiply_into(&self, lhs: &impl Transposition, into: &mut Change) {
        if self.stage() != lhs.stage() {
            panic!("Can't use transpositions of different stages!");
        }
        into.seq.clear();
        for i in 0..self.stage().as_usize() {
            into.seq
                .push(lhs.bell_at(Place::from(self.seq[i].as_number())));
        }
    }
pub fn pre_multiply_into ( & self , lhs : & impl Transposition , into : & mut Change ) { if self . stage ( ) != lhs . stage ( ) { panic ! ( " " ) ; } into . seq . clear ( ) ; for i in 0 .. self . stage ( ) . as_usize ( ) { into . seq . push ( lhs . bell_at ( Place :: from ( self . seq [ i ] . as_number ( ) ) ) ) ; } }
Multiplies this `Change` on to the end of the argument, and copies the result into another
`Change` to avoid heap allocations.
Multiplies this ` Change ` on to the end of the argument and copies the result into another ` Change ` to avoid heap allocations .
&self
lhs
&impl Transposition
into
&mut Change
&self
lhs
&impl Transposition
into
&mut Change
panics
Panics if `lhs` is doesn't have the same [Stage] as this `Change`.
Panics if ` lhs ` is doesn ' t have the same [ Stage ] as this ` Change ` .
example
```
use bellmetal::Change.



example_change.pre_multiply_into(∂_head, &mut output_change).


` ` ` use bellmetal :: Change . example_change . pre_multiply_into ( ∂_head &mut output_change ) .