Struct feanor_math::rings::float_complex::Complex64

pub struct Complex64;

Implementations

impl Complex64

pub const RING: RingValue<Complex64> = _

pub const I: Complex64El = _

pub fn abs(&self, Complex64El: Complex64El) -> f64

pub fn conjugate(&self, Complex64El: Complex64El) -> Complex64El

pub fn exp(&self, Complex64El: Complex64El) -> Complex64El

pub fn closest_gaussian_int(&self, Complex64El: Complex64El) -> (i64, i64)

pub fn ln_main_branch(&self, Complex64El: Complex64El) -> Complex64El

pub fn is_absolute_approx_eq( &self, lhs: Complex64El, rhs: Complex64El, absolute_threshold: f64 ) -> bool

pub fn is_relative_approx_eq( &self, lhs: Complex64El, rhs: Complex64El, relative_limit: f64 ) -> bool

pub fn is_approx_eq( &self, lhs: Complex64El, rhs: Complex64El, precision: u64 ) -> bool

pub fn from_f64(&self, x: f64) -> Complex64El

pub fn root_of_unity(&self, i: i64, n: i64) -> Complex64El

Trait Implementations

impl CanHomFrom<Complex64> for Complex64

type Homomorphism = ()

fn has_canonical_hom(&self, from: &Self) -> Option<()>

fn map_in( &self, _from: &Self, el: <Self as RingBase>::Element, _: &Self::Homomorphism ) -> <Self as RingBase>::Element

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism ) -> Self::Element

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism )

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism )

impl CanonicalIso<Complex64> for Complex64

type Isomorphism = ()

fn has_canonical_iso(&self, from: &Self) -> Option<()>

fn map_out( &self, _from: &Self, el: <Self as RingBase>::Element, _: &Self::Homomorphism ) -> <Self as RingBase>::Element

impl Clone for Complex64

fn clone(&self) -> Complex64

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DivisibilityRing for Complex64

fn checked_left_div( &self, lhs: &Self::Element, rhs: &Self::Element ) -> Option<Self::Element>

Checks whether there is an element x such that rhs * x = lhs, and returns it if it exists. Note that this does not have to be unique, if rhs is a left zero-divisor. In particular, this function will return any element in the ring if lhs = rhs = 0.

fn is_unit(&self, x: &Self::Element) -> bool

impl EuclideanRing for Complex64

fn euclidean_div_rem( &self, _lhs: Self::Element, _rhs: &Self::Element ) -> (Self::Element, Self::Element)

fn euclidean_deg(&self, _: &Self::Element) -> Option<usize>

fn euclidean_div( &self, lhs: Self::Element, rhs: &Self::Element ) -> Self::Element

fn euclidean_rem( &self, lhs: Self::Element, rhs: &Self::Element ) -> Self::Element

impl Field for Complex64

fn div(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

impl PartialEq for Complex64

fn eq(&self, other: &Complex64) -> 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 PrincipalIdealRing for Complex64

fn ideal_gen( &self, _lhs: &Self::Element, _rhs: &Self::Element ) -> (Self::Element, Self::Element, Self::Element)

Computes a Bezout identity.

impl RingBase for Complex64

type Element = Complex64El

fn clone_el(&self, val: &Self::Element) -> Self::Element

fn add_assign( &self, Complex64El: &mut Self::Element, Complex64El: Self::Element )

fn negate_inplace(&self, Complex64El: &mut Self::Element)

fn mul_assign( &self, Complex64El: &mut Self::Element, Complex64El: Self::Element )

fn from_int(&self, value: i32) -> Self::Element

fn eq_el(&self, _: &Self::Element, _: &Self::Element) -> bool

fn pow_gen<R: IntegerRingStore>( &self, x: Self::Element, power: &El<R>, integers: R ) -> Self::Element

where R::Type: IntegerRing,

Raises x to the power of an arbitrary, nonnegative integer given by a custom integer ring implementation.

fn is_commutative(&self) -> bool

fn is_noetherian(&self) -> bool

fn is_approximate(&self) -> bool

Returns whether this ring computes with approximations to elements. This would usually be the case for rings that are based on f32 or f64, to represent real or complex numbers.

fn dbg<'a>( &self, Complex64El: &Self::Element, out: &mut Formatter<'a> ) -> Result

fn characteristic<I: IntegerRingStore>(&self, ZZ: &I) -> Option<El<I>>

where I::Type: IntegerRing,

Returns the characteristic of this ring as an element of the given implementation of ZZ.

fn add_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn sub_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn mul_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn zero(&self) -> Self::Element

fn one(&self) -> Self::Element

fn neg_one(&self) -> Self::Element

fn is_zero(&self, value: &Self::Element) -> bool

fn is_one(&self, value: &Self::Element) -> bool

fn is_neg_one(&self, value: &Self::Element) -> bool

fn square(&self, value: &mut Self::Element)

fn negate(&self, value: Self::Element) -> Self::Element

fn sub_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn mul_assign_int(&self, lhs: &mut Self::Element, rhs: i32)

fn mul_int(&self, lhs: Self::Element, rhs: i32) -> Self::Element

fn mul_int_ref(&self, lhs: &Self::Element, rhs: i32) -> Self::Element

fn sub_self_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

Computes lhs := rhs - lhs.

fn sub_self_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

Computes lhs := rhs - lhs.

fn add_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn add_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn add_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn add(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn sub_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn sub(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn mul_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn mul(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn sum<I>(&self, els: I) -> Self::Element

where I: Iterator<Item = Self::Element>,

fn prod<I>(&self, els: I) -> Self::Element

where I: Iterator<Item = Self::Element>,

impl Copy for Complex64

impl Domain for Complex64

impl StructuralPartialEq for Complex64