Enum DType 

pub enum DType {
    Boolean,
    Integer(Width),
    Float(FloatWidth),
    Complex(ComplexWidth),
    Character,
}

The element type of a compact buffer. Numbers widen from Boolean through the integer widths to the float widths to the complex widths.

Variants

Boolean

Integer(Width)

Float(FloatWidth)

Complex(ComplexWidth)

Character

Implementations

impl DType

pub fn is_integral(self) -> bool

Whether items of this dtype are whole numbers: Booleans and integers.

pub fn mathish(self) -> bool

Whether Mathish forms (tolerant::MathishFloorDivide and the rest) apply to a call that computes at this dtype: 64-bit floats and complex numbers with 64-bit parts.

pub fn is_real(self) -> bool

Whether items of this dtype are real numbers: Booleans, integers and floats.

pub fn kind(self) -> u8

This dtype’s kind, in the order that NEP 50 promotes kinds: 0 for Booleans, 1 for integers, 2 for floats, 3 for complex numbers and 4 for characters, which don’t mix with numbers.

pub fn name(self) -> &'static str

The dtype’s name, as NumPy names its dtypes: "bool", "uint8", "int16", "int32", "int64", "float16", "float32", "float64", "complex64" and "complex128". NumPy has no dtype for characters, which are "character". Rustymath’s Python API and BPL’s •storage both use these names.

pub fn named(name: &str) -> Option<DType>

The dtype that DType::name calls name, or None for any other name.

pub fn widens_to(self, to: DType) -> bool

Whether this dtype widens to to: whether DType::common promotes this dtype and to to to. An integer widens to every float and complex dtype.

pub fn inexact(self, limit: FloatWidth) -> Option<(DType, DType)>

The dtypes that a function of floats or complex numbers computes in and gives, for arguments of this dtype. A Boolean or an integer takes the float that Width::float gives under limit, but at least f32, which computes faster than f16. Under NumPy’s limit, f64, that’s f32 for Booleans, u8 and i16, and f64 for i32 and i64. f16 computes in f32, and its results round back. Other floats and complex numbers stay as they are. None for characters.

pub fn numpy_float(self) -> FloatWidth

The float width that a Boolean or integer computes in under rustymath’s own policy, NumPy’s: the float that DType::inexact gives it under f64. f64 for any other dtype.

pub fn computes_in( self, int: Width, float: FloatWidth, has: impl Fn(DType) -> bool, ) -> Option<DType>

The dtype that an argument of this dtype computes in, for a function with a kernel at each dtype where has holds. That’s this dtype where it has a kernel. Otherwise it’s the first with a kernel of these: for a Boolean or an integer, integers of int or of this dtype’s width, whichever is wider, then floats of float; for a float or a complex number, the dtype that DType::inexact gives it; then each wider float, and each complex dtype whose parts are at least as wide; and last, for a float, integers of int, which compute it as the whole number it holds (operation::whole_numbers). int and float are the caller’s policy for exact numbers. NumPy’s is i64 and the float that inexact gives under f64. None where no dtype on the way has a kernel.

pub fn common(self, other: DType) -> Option<DType>

The dtype that arguments of this dtype and other promote to: the higher kind, wide enough for both. A Boolean takes the other dtype. An integer beside a float or complex dtype takes that dtype, as in JAX, where NumPy widens the float to hold every integer exactly. A float beside a complex dtype takes parts at least as wide. None for characters beside numbers.

pub fn common_weak(self, weak: DType) -> Option<DType>

The dtype that NEP 50 promotes an array of this dtype and a weak value of dtype weak to. A weak value is a Python scalar, which has no dtype of its own. BPL’s weak numbers follow the same rule. The caller gives the weak value’s dtype at the default width of its kind. Where its kind is no higher, the array’s dtype wins. A weak complex value beside floats takes their width. Otherwise the weak dtype wins. None for characters beside numbers.

pub fn real(self) -> DType

The real dtype of a complex dtype’s parts. Other dtypes are their own.

pub fn complex(self) -> DType

The complex dtype that numbers of this dtype take: complex64 for f16, f32 and complex64, and complex128 for everything else.

impl DType

pub const ALL: [DType; 11]

Every dtype, in the order that numbers widen, with characters last.

pub const fn index(self) -> usize

This dtype’s position in DType::ALL.

impl DType

pub fn bytes(self) -> usize

The bytes that one item of this dtype takes.

Trait Implementations

impl Clone for DType

fn clone(&self) -> DType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DType

impl Debug for DType

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

Formats the value using the given formatter.

impl Eq for DType

impl Hash for DType

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DType

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DType