pub fn spacegroup_coperms(
    // Arbitrary superstructure (the thing we want to permute)
    coords: &Coords,

    // Spacegroup operators.
    //
    // * Must be closed under composition.
    // * Must not include pure translations. (this limitation is because the
    //   the method used to equate two operators only considers the rotations)
    ops: &[CartOp],

    tol: f64,
) -> Result<Vec<Perm>, Error>
{
    let dummy_meta = vec![(); coords.num_atoms()];
    spacegroup_coperms_with_meta(coords, &dummy_meta, ops, tol)
}
/// Compute copermutations for all operators in a spacegroup.
///
/// Apologies for the invented terminology; see `conventions.md` about the difference
/// between copermutations and depermutations.
///
/// This method can be called on superstructures so long as pure translations
/// are not included in the list of operators.  Be aware that if the superlattice
/// breaks symmetries of the primitive structure, those symmetries might not have
/// a valid representation as a permutation (and the method will fail).
///
/// `tol = 0` is explicitly supported as long as you only seek the identity.
//
// (NOTE: currently, it actually fails even earlier, when trying to construct IntRot
//        (which fails if and only if the superlattice breaks the symmetry).
//        I don't know / have not yet proven whether there may exist symmetry-broken
//        supercells which DO have a valid permutation representation)
Compute copermutations for all operators in a spacegroup.
Apologies for the invented terminology; see `conventions.md` about the difference
between copermutations and depermutations.

This method can be called on superstructures so long as pure translations
are not included in the list of operators.  Be aware that if the superlattice
breaks symmetries of the primitive structure, those symmetries might not have
a valid representation as a permutation (and the method will fail).

`tol = 0` is explicitly supported as long as you only seek the identity.

currently, it actually fails even earlier, when trying to construct IntRot
(which fails if and only if the superlattice breaks the symmetry).
I don't know / have not yet proven whether there may exist symmetry-broken
supercells which DO have a valid permutation representation)
Compute copermutations for all operators in a spacegroup . Apologies for the invented terminology ; see ` conventions . md ` about the difference between copermutations and depermutations . This method can be called on superstructures so long as pure translations are not included in the list of operators . Be aware that if the superlattice breaks symmetries of the primitive structure those symmetries might not have a valid representation as a permutation ( and the method will fail ) . ` tol = 0 ` is explicitly supported as long as you only seek the identity . currently it actually fails even earlier when trying to construct IntRot ( which fails if and only if the superlattice breaks the symmetry ) . I don ' t know / have not yet proven whether there may exist symmetry - broken supercells which DO have a valid permutation representation )
pub fn spacegroup_coperms(
    // Arbitrary superstructure (the thing we want to permute)
    coords: &Coords,
    // Spacegroup operators.
    //
    // * Must be closed under composition.
    // * Must not include pure translations. (this limitation is because the
    //   the method used to equate two operators only considers the rotations)
    ops: &[CartOp],
    tol: f64,
) -> Result<Vec<Perm>, Error>
{
    let dummy_meta = vec![(); coords.num_atoms()];
    spacegroup_coperms_with_meta(coords, &dummy_meta, ops, tol)
}
pub fn spacegroup_coperms ( // Arbitrary superstructure (the thing we want to permute) coords : & Coords , // Spacegroup operators. // // * Must be closed under composition. // * Must not include pure translations. (this limitation is because the //   the method used to equate two operators only considers the rotations) ops : & [ CartOp ] , tol : f64 , ) -> Result < Vec < Perm > , Error > { let dummy_meta = vec ! [ ( ) coords num_atoms ( ) ] ; spacegroup_coperms_with_meta ( coords , & dummy_meta , ops , tol ) }
Compute copermutations for all operators in a spacegroup.
Compute copermutations for all operators in a spacegroup .
coords
&Coords
ops
&[CartOp]
tol
f64
coords
&Coords
ops
&[CartOp]
tol
f64