Struct feanor_math::rings::float_complex::Complex64Base

pub struct Complex64Base;

Implementations

impl Complex64Base

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

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

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

Trait Implementations

impl CanHomFrom<Complex64Base> for Complex64Base

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 CanIsoFromTo<Complex64Base> for Complex64Base

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 Complex64Base

fn clone(&self) -> Complex64Base

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DivisibilityRing for Complex64Base

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 Complex64Base

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 Complex64Base

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

impl PartialEq for Complex64Base

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

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

Computes a Bezout identity for the generator g of the ideal (lhs, rhs) as g = s * lhs + t * rhs.

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

Computes a generator g of the ideal (lhs, rhs) = (g), also known as greatest common divisor.

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

Computes a generator of the ideal (lhs) ∩ (rhs), also known as least common multiple.

impl RingBase for Complex64Base

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 RingExtension for Complex64Base

type BaseRing = RingValue<Real64Base>

fn base_ring<'a>(&'a self) -> &'a Self::BaseRing

fn from(&self, x: El<Self::BaseRing>) -> Self::Element

fn mul_assign_base(&self, lhs: &mut Self::Element, rhs: &El<Self::BaseRing>)

Computes lhs := lhs * rhs, where rhs is mapped into this ring via RingExtension::from_ref(). Note that this may be faster than self.mul_assign(lhs, self.from_ref(rhs)).

fn from_ref(&self, x: &El<Self::BaseRing>) -> Self::Element

impl Copy for Complex64Base

impl Domain for Complex64Base

impl StructuralPartialEq for Complex64Base