Trait mori::orientations::OriConv

pub trait OriConv {
    fn to_bunge(&self) -> Bunge;
    fn to_rmat(&self) -> RMat;
    fn to_ang_axis(&self) -> AngAxis;
    fn to_ang_axis_comp(&self) -> AngAxisComp;
    fn to_rod_vec(&self) -> RodVec;
    fn to_rod_vec_comp(&self) -> RodVecComp;
    fn to_quat(&self) -> Quat;
    fn to_homochoric(&self) -> Homochoric;
    fn to_bunge_inplace(&self, bunge: &mut Bunge);
    fn to_rmat_inplace(&self, rmat: &mut RMat);
    fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis);
    fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp);
    fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec);
    fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp);
    fn to_quat_inplace(&self, quat: &mut Quat);
    fn to_homochoric_inplace(&self, homochoric: &mut Homochoric);
}

A set of generic orientation conversions from one to another orientation representation

Required methods

fn to_bunge(&self) -> Bunge

fn to_rmat(&self) -> RMat

fn to_ang_axis(&self) -> AngAxis

fn to_ang_axis_comp(&self) -> AngAxisComp

fn to_rod_vec(&self) -> RodVec

fn to_rod_vec_comp(&self) -> RodVecComp

fn to_quat(&self) -> Quat

fn to_homochoric(&self) -> Homochoric

fn to_bunge_inplace(&self, bunge: &mut Bunge)

fn to_rmat_inplace(&self, rmat: &mut RMat)

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

fn to_quat_inplace(&self, quat: &mut Quat)

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Loading content...

Implementors

impl OriConv for AngAxis

The orientation conversions of a series of axis-angle representation to a number of varying different orientation representations commonly used in material orientation processing.

fn to_bunge(&self) -> Bunge

Converts the axis-angle representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rmat(&self) -> RMat

Converts the axis-angle representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major.

fn to_ang_axis(&self) -> AngAxis

Returns a clone of the axis-angle structure

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the axis-angle representation over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Converts the axis-angle representation over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the axis-angle representation over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

Converts the axis-angle representation over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts the axis-angle representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the axis-angle representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Converts the axis-angle representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Copies the orientation structure in self over to the other AngAxis structure This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the axis-angle representation over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the axis-angle representation over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the axis-angle representation over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

Converts the axis-angle representation over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Converts the axis-angle representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

impl OriConv for AngAxisComp

The orientation conversions of a series of compact axis-angle representation to a number of varying different orientation representations commonly used in material orientation processing.

fn to_rmat(&self) -> RMat

Converts the compact axis-angle representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major.

fn to_bunge(&self) -> Bunge

Converts the compact axis-angle representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_ang_axis(&self) -> AngAxis

Converts the compact axis-angle representation over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Returns a clone of the compact axis-angle structure

fn to_rod_vec(&self) -> RodVec

Converts the compact axis-angle representation over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the compact axis-angle representation over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

Converts the compact axis-angle representation over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts the compact axis-angle representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the compact axis-angle representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Converts the compact axis-angle representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the compact axis-angle representation over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Returns a clone of the compact axis-angle structure This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the compact axis-angle representation over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the compact axis-angle representation over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

Converts the compact axis-angle representation over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Converts the compact axis-angle representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

impl OriConv for Bunge

The orientation conversions of a series of Bunge angles to a number of varying different orientation representations commonly used in material orientation processing.

fn to_bunge(&self) -> Bunge

The conversion from Bunge angles to Bungle angles just returns a copy of the original data structure.

fn to_rmat(&self) -> RMat

Converts the Bunge angles over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major.

fn to_ang_axis(&self) -> AngAxis

Converts the Bunge angles over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the Bunge angles over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Converts the Bunge angles over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the Bunge angles over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

Converts the Bunge angles over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts Bunge angles over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

The conversion from Bunge angles to Bungle angles just returns a copy of the original ori data structure. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Converts the Bunge angles over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the Bunge angles over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the Bunge angles over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the Bunge angles over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the Bunge angles over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

Converts the Bunge angles over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Converts Bunge angles over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

impl OriConv for Quat

The orientation conversions of a series of unit quaternions to a number of varying different orientation representations commonly used in material orientation processing.

fn to_bunge(&self) -> Bunge

Converts the unit quaternion representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rmat(&self) -> RMat

Converts the unit quaternion representation over to rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major.

fn to_ang_axis(&self) -> AngAxis

Converts the unit quaternion representation over to angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the unit quaternion over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Converts the unit quaternion over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the unit quaternion over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

This returns a clone of the original unit quaternion structure

fn to_homochoric(&self) -> Homochoric

Converts the quaternion representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the unit quaternion representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Converts the unit quaternion representation over to rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the unit quaternion over to a angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the unit quaternion over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the unit quaternion over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the unit quaternion over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

This returns a clone of the original unit quaternion structure This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Converts the quaternion representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

impl OriConv for RMat

The orientation conversions of a series of rotation matrices to a number of varying different orientation representations commonly used in material orientation processing.

fn to_bunge(&self) -> Bunge

Converts the rotation matrices to the equivalent bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rmat(&self) -> RMat

Returns a copy of the initial rotation matrix data structure

fn to_ang_axis(&self) -> AngAxis

Converts the rotation matrix over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the rotation matrix over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Converts the rotation matrix over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the rotation matrix over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

Converts the rotation matrix over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts the rotation matrix representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the rotation matrices to the equivalent bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Returns a copy of the initial rotation matrix data structure This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the rotation matrix over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the rotation matrix over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the rotation matrix over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the rotation matrix over to a compact Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

This operation is done inplace and does not create a new structure

impl OriConv for RodVec

The orientation conversions of a series of Rodrigues vectors to a number of varying different orientation representations commonly used in material orientation processing.

fn to_bunge(&self) -> Bunge

Converts the Rodrigues vector representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rmat(&self) -> RMat

Converts the Rodrigues vector representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major.

fn to_ang_axis(&self) -> AngAxis

Converts the Rodrigues vector representation over to axis-angle representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the Rodrigues vector representation over to a compact axial vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Returns a clone of the Rodrigues vector.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the Rodrigues vector representation over to a compact Rodrigues which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

Converts the Rodrigues vector representation over to a unit quaternion which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts the Rodrigues vector representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the Rodrigues vector representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Converts the Rodrigues vector representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the Rodrigues vector representation over to an axial vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the Rodrigues vector representation over to a compact axial vector representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Returns a clone of the Rodrigues vector. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the Rodrigues vector representation over to a compact Rodrigues which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

Converts the Rodrigues vector representation over to a unit quaternion which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Converts the Rodrigues vector representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

impl OriConv for RodVecComp

The orientation conversions of a series of compact Rodrigues vectors to a number of varying different orientation representations commonly used in material orientation processing. It should be noted that the compact Rodrigues vector is much more likely to be numerically unstable compared to the other orientation representations. This is due to the fact that the tan(phi\2) term is included into the compacted vector.

fn to_bunge(&self) -> Bunge

Converts the compact Rodrigues vector representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rmat(&self) -> RMat

Converts the compact Rodrigues vector representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major.

fn to_ang_axis(&self) -> AngAxis

Converts the compact Rodrigues vector representation over to axis-angle representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the compact Rodrigues vector representation over to a compact axial vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Converts the compact Rodrigues vector representation over to a Rodrigues which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Returns a clone of the compact Rodrigues vector structure

fn to_quat(&self) -> Quat

Converts the compact Rodrigues vector representation over to a unit quaternion which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts the compact Rodrigues vector representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the compact Rodrigues vector representation over to Bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Converts the compact Rodrigues vector representation over to a rotation matrix which has the following properties shape (3, 3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the compact Rodrigues vector representation over to axis-angle representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the compact Rodrigues vector representation over to compact axis-angle representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the compact Rodrigues vector representation over to a Rodrigues which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Returns a clone of the compact Rodrigues vector structure This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

Converts the compact Rodrigues vector representation over to a unit quaternion which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

Converts the compact Rodrigues vector representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

Loading content...