pub fn use_equivalent_cell(&mut self, tol: f64, target_lattice: &Lattice) -> Result<(), NonEquivalentLattice>
    {
        Ok({
            warn!("Untested code path: 1650857f-42df-47e4-8ff0-cdd9dcb85020");
            let unimodular = &self.lattice * target_lattice.inverse_matrix();
            let unimodular = match crate::util::Tol(tol).unfloat_m33(unimodular.matrix()) {
                Ok(m) => m,
                Err(_) => {
                    throw!(NonEquivalentLattice {
                        backtrace: failure::Backtrace::new(),
                        a_binv: unimodular.matrix().into_array(),
                    })
                },
            };
            self.apply_unimodular(&unimodular);
        })
    }
/// Produce an identical structure (up to precision loss) represented
/// in terms of a different unit cell.
///
/// The new cell is required to be equivalent to the original cell.
/// Otherwise, it fails with `NonEquivalentLattice.`
///
/// Numerically speaking, the input cell will not be used exactly;
/// instead, the new lattice is recomputed as a linear combination of
/// the original lattice vectors. The expectation is that this
/// causes less of a disturbance to the positions of sites which
/// are distant to the origin, in the case where one wishes to reduce
/// the sites into the new unit cell afterwards.
Produce an identical structure (up to precision loss) represented
in terms of a different unit cell.

The new cell is required to be equivalent to the original cell.
Otherwise, it fails with `NonEquivalentLattice.`

Numerically speaking, the input cell will not be used exactly;
instead, the new lattice is recomputed as a linear combination of
the original lattice vectors. The expectation is that this
causes less of a disturbance to the positions of sites which
are distant to the origin, in the case where one wishes to reduce
the sites into the new unit cell afterwards.
Produce an identical structure ( up to precision loss ) represented in terms of a different unit cell . The new cell is required to be equivalent to the original cell . Otherwise it fails with ` NonEquivalentLattice . ` Numerically speaking the input cell will not be used exactly ; instead the new lattice is recomputed as a linear combination of the original lattice vectors . The expectation is that this causes less of a disturbance to the positions of sites which are distant to the origin in the case where one wishes to reduce the sites into the new unit cell afterwards .
pub fn use_equivalent_cell(&mut self, tol: f64, target_lattice: &Lattice) -> Result<(), NonEquivalentLattice>
    {
        Ok({
            warn!("Untested code path: 1650857f-42df-47e4-8ff0-cdd9dcb85020");
            let unimodular = &self.lattice * target_lattice.inverse_matrix();
            let unimodular = match crate::util::Tol(tol).unfloat_m33(unimodular.matrix()) {
                Ok(m) => m,
                Err(_) => {
                    throw!(NonEquivalentLattice {
                        backtrace: failure::Backtrace::new(),
                        a_binv: unimodular.matrix().into_array(),
                    })
                },
            };
            self.apply_unimodular(&unimodular);
        })
    }
pub fn use_equivalent_cell ( & mut self , tol : f64 , target_lattice : & Lattice ) -> Result < ( ) , NonEquivalentLattice > { Ok ( { warn ! ( " " ) ; let unimodular = & self . lattice * target_lattice . inverse_matrix ( ) ; let unimodular = match crate :: util :: Tol ( tol ) . unfloat_m33 ( unimodular . matrix ( ) ) { Ok ( m ) => m , Err ( _ ) => { throw ! ( NonEquivalentLattice { backtrace failure Backtrace new ( ) a_binv unimodular matrix ( ) into_array ( ) } ) } , } ; self . apply_unimodular ( & unimodular ) ; } ) }
Produce an identical structure (up to precision loss) represented
in terms of a different unit cell.
Produce an identical structure ( up to precision loss ) represented in terms of a different unit cell .
&mut self
tol
f64
target_lattice
&Lattice
&mut self
tol
f64
target_lattice
&Lattice