Struct qsym2::target::tensor::axialvector::AxialVector3

pub struct AxialVector3<T>
where
    T: ComplexFloat + Lapack,
{ /* private fields */ }

Structure to manage axial vectors in three dimensions.

Implementations

impl<T> AxialVector3<T>

where T: ComplexFloat + Clone + Lapack,

pub fn builder() -> AxialVector3Builder<T>

Returns a builder to construct a new AxialVector3.

pub fn components(&self) -> &Vector3<T>

Returns a shared reference to the components of the axial vector.

pub fn time_parity(&self) -> &TimeParity

Returns a shared reference to the time parity.

pub fn threshold(&self) -> <T as ComplexFloat>::Real

Returns the threshold with which axial vectors are compared.

Trait Implementations

impl<T> Clone for AxialVector3<T>

where T: ComplexFloat + Lapack + Clone,

fn clone(&self) -> AxialVector3<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> ComplexConjugationTransformable for AxialVector3<T>

where T: ComplexFloat + Lapack,

fn transform_cc_mut(&mut self) -> Result<&mut Self, TransformationError>

Performs a complex conjugation in-place.

fn transform_cc(&self) -> Result<Self, TransformationError>

Performs a complex conjugation and returns the complex-conjugated result.

impl<T> Debug for AxialVector3<T>

where T: Debug + ComplexFloat + Lapack,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Display for AxialVector3<T>

where T: Display + ComplexFloat + Lapack,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> From<AxialVector3<T>> for AxialVector3<Complex<T>>

where T: Float + FloatConst + Lapack, Complex<T>: Lapack,

fn from(value: AxialVector3<T>) -> Self

Converts to this type from the input type.

impl<'a, G, T> Orbit<G, AxialVector3<T>> for AxialVector3SymmetryOrbit<'a, G, T>

where G: SymmetryGroupProperties, T: ComplexFloat + Debug + Lapack, AxialVector3<T>: SymmetryTransformable,

type OrbitIter = OrbitIterator<'a, G, AxialVector3<T>>

Type of the iterator over items in the orbit.

fn group(&self) -> &G

The group generating the orbit.

fn origin(&self) -> &AxialVector3<T>

The origin of the orbit.

fn iter(&self) -> Self::OrbitIter

An iterator over items in the orbit arising from the action of the group on the origin.

impl<T> Overlap<T, Dim<[usize; 2]>> for AxialVector3<T>

where T: Lapack + ComplexFloat<Real = <T as Scalar>::Real> + Debug + Mul<<T as ComplexFloat>::Real, Output = T>, <T as ComplexFloat>::Real: Debug + RelativeEq<<T as ComplexFloat>::Real> + AbsDiffEq<Epsilon = <T as Scalar>::Real>,

fn overlap( &self, other: &Self, metric: Option<&Array2<T>>, _: Option<&Array2<T>>, ) -> Result<T, Error>

Computes the overlap between two axial vectors.

fn overlap_definition(&self) -> String

Returns the mathematical definition of the overlap between two axial vectors.

fn complex_symmetric(&self) -> bool

If true, the inner product is bilinear and $\hat{\iota} = \hat{\kappa}$. If false, the inner product is sesquilinear and $\hat{\iota} = \mathrm{id}$.

impl<T> PartialEq for AxialVector3<T>

where T: ComplexFloat<Real = f64> + Lapack,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, G, T> RepAnalysis<G, AxialVector3<T>, T, Dim<[usize; 2]>> for AxialVector3SymmetryOrbit<'a, G, T>

where G: SymmetryGroupProperties, G::CharTab: SubspaceDecomposable<T>, T: Lapack + ComplexFloat<Real = <T as Scalar>::Real> + Debug + Mul<<T as ComplexFloat>::Real, Output = T>, <T as ComplexFloat>::Real: Debug + Zero + RelativeEq<<T as ComplexFloat>::Real> + AbsDiffEq<Epsilon = <T as Scalar>::Real>, AxialVector3<T>: SymmetryTransformable,

fn analyse_rep( &self, ) -> Result<<<G as CharacterProperties>::CharTab as SubspaceDecomposable<T>>::Decomposition, DecompositionError>

Reduces the representation or corepresentation spanned by the axial vectors in the orbit to a direct sum of the irreducible representations or corepresentations of the generating symmetry group.

Returns

The decomposed result.

Errors

Errors if the decomposition fails, e.g. because one or more calculated multiplicities are non-integral.

fn set_smat(&mut self, smat: Array2<T>)

Sets the overlap matrix between the items in the orbit.

fn smat(&self) -> Option<&Array2<T>>

Returns the overlap matrix between the items in the orbit.

fn xmat(&self) -> &Array2<T>

Returns the transformation matrix $\mathbf{X}$ for the overlap matrix $\mathbf{S}$ between the items in the orbit.

fn norm_preserving_scalar_map(&self, i: usize) -> Result<fn(_: T) -> T, Error>

Returns the norm-preserving scalar map $f$ for every element of the generating group defined by

fn integrality_threshold(&self) -> <T as ComplexFloat>::Real

Returns the threshold for integrality checks of irreducible representation or corepresentation multiplicities.

fn eigenvalue_comparison_mode(&self) -> &EigenvalueComparisonMode

Returns the enumerated type specifying the comparison mode for filtering out orbit overlap eigenvalues.

fn calc_smat( &mut self, metric: Option<&Array<T, D>>, metric_h: Option<&Array<T, D>>, use_cayley_table: bool, ) -> Result<&mut Self, Error>

Calculates and stores the overlap matrix between items in the orbit, with respect to a metric of the basis in which these items are expressed.

fn normalise_smat(&mut self) -> Result<&mut Self, Error>

Normalises overlap matrix between items in the orbit such that its diagonal entries are unity.

fn calc_tmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>

Computes the $\mathbf{T}(g)$ matrix for a particular element $g$ of the generating group.

fn calc_dmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>

Computes the representation or corepresentation matrix $\mathbf{D}(g)$ for a particular element $g$ in the generating group in the basis of the orbit.

fn calc_character(&self, op: &G::GroupElement) -> Result<T, Error>

Computes the character of a particular element $g$ in the generating group in the basis of the orbit.

fn calc_characters( &self, ) -> Result<Vec<(<G as ClassProperties>::ClassSymbol, T)>, Error>

Computes the characters of the elements in a conjugacy-class transversal of the generating group in the basis of the orbit.

impl<T> SpatialUnitaryTransformable for AxialVector3<T>

where T: ComplexFloat + LinalgScalar + ScalarOperand + Copy + Lapack, f64: Into<T>,

fn transform_spatial_mut( &mut self, rmat: &Array2<f64>, _perm: Option<&Permutation<usize>>, ) -> Result<&mut Self, TransformationError>

Performs a spatial transformation in-place.

fn transform_spatial( &self, rmat: &Array2<f64>, perm: Option<&Permutation<usize>>, ) -> Result<Self, TransformationError>

Performs a spatial transformation and returns the transformed result.

impl<T> SpinUnitaryTransformable for AxialVector3<T>

where T: ComplexFloat + Lapack,

fn transform_spin_mut( &mut self, _dmat: &Array2<Complex<f64>>, ) -> Result<&mut Self, TransformationError>

Axial vectors are spatial quantities, therefore spin transformations have no effects on them.

fn transform_spin( &self, dmat: &Array2<Complex<f64>>, ) -> Result<Self, TransformationError>

Performs a spin transformation and returns the transformed result.

impl<T> SymmetryTransformable for AxialVector3<T>

where T: ComplexFloat + Lapack, AxialVector3<T>: SpatialUnitaryTransformable + TimeReversalTransformable,

fn sym_permute_sites_spatial( &self, _symop: &SymmetryOperation, ) -> Result<Permutation<usize>, TransformationError>

Determines the permutation of sites (e.g. atoms in molecules) due to the action of a symmetry operation.

fn sym_transform_spatial_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation in-place.

fn sym_transform_spatial( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation and returns the transformed result.

fn sym_transform_spatial_with_spintimerev_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation in-place, but with spin-including time reversal.

fn sym_transform_spatial_with_spintimerev( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a spatial transformation according to a specified symmetry operation but with spin-including time reversal and returns the transformed result.

fn sym_transform_spin_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a spin transformation according to a specified symmetry operation in-place.

fn sym_transform_spin( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a spin transformation according to a specified symmetry operation and returns the transformed result.

fn sym_transform_spin_spatial_mut( &mut self, symop: &SymmetryOperation, ) -> Result<&mut Self, TransformationError>

Performs a coupled spin-spatial transformation according to a specified symmetry operation in-place.

fn sym_transform_spin_spatial( &self, symop: &SymmetryOperation, ) -> Result<Self, TransformationError>

Performs a coupled spin-spatial transformation according to a specified symmetry operation and returns the transformed result.

impl<T> TimeReversalTransformable for AxialVector3<T>

where T: ComplexFloat + Lapack,

fn transform_timerev_mut(&mut self) -> Result<&mut Self, TransformationError>

Provides a custom implementation of time reversal where the axial vector is kept invariant or inverted based on its time-parity. The components of the vector are also complex-conjugated to respect the antiunitarity of time reversal.

fn transform_timerev(&self) -> Result<Self, TransformationError>

Performs a time-reversal transformation and returns the time-reversed result.

impl<T> Eq for AxialVector3<T>

where T: ComplexFloat<Real = f64> + Lapack,