Struct VectorType 

pub struct VectorType {
    pub inner: TypeHandle,
    pub vectorization: usize,
}

Fields

inner: TypeHandle

vectorization: usize

Implementations

impl VectorType

pub fn get( ctx: &Context, inner: TypeHandle, vectorization: usize, ) -> TypedHandle<Self>

Get or create a new instance.

Trait Implementations

impl AlignedType for VectorType

fn align(&self, ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Clone for VectorType

fn clone(&self) -> VectorType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for VectorType

impl Debug for VectorType

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

Formats the value using the given formatter.

impl DestructurableTypeInterface for VectorType

fn subelement_index_map( &self, _ctx: &Context, ) -> Option<HMap<AttrObj, TypeHandle>>

Destructures the type into subelements into a map of indices to types of subelements. Returns nothing if the type cannot be destructured.

fn type_at_index(&self, _ctx: &Context, _index: &AttrObj) -> TypeHandle

Indicates which type is held at the provided index, returning None if no type could be computed. While this can return information even when the type cannot be completely destructured, it must be coherent with the types returned by subelement_index_map when they exist.

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Eq for VectorType

impl HasElementType for VectorType

fn element_type(&self, ctx: &Context) -> Option<TypeHandle>

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Hash for VectorType

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

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 MaybePackedType for VectorType

fn packing_factor(&self, ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl MaybeVectorizedType for VectorType

fn vector_size(&self, _ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

fn try_vector_size(&self, ctx: &Context) -> Option<usize>

impl OperandNOfType<0, VectorType> for VectorInsertDynamicOp

impl OperandNOfType<0, VectorType> for VectorExtractDynamicOp

impl OperandNOfType<0, VectorType> for MagnitudeOp

impl OperandNOfType<0, VectorType> for NormalizeOp

impl OperandNOfType<0, VectorType> for ISumOp

impl OperandNOfType<0, VectorType> for FSumOp

impl OperandNOfType<0, VectorType> for SDotOp

impl OperandNOfType<0, VectorType> for UDotOp

impl OperandNOfType<0, VectorType> for FDotOp

impl OperandNOfType<1, VectorType> for SDotOp

impl OperandNOfType<1, VectorType> for UDotOp

impl OperandNOfType<1, VectorType> for FDotOp

impl OperandNOfType<4, VectorType> for MmaManualScaledOp

impl OperandNOfType<5, VectorType> for MmaManualScaledOp

impl Parsable for VectorType

type Arg = ()

Type of the argument that must be passed to the parser.

type Parsed = TypedHandle<VectorType>

The type of the parsed entity.

fn parse<'__pliron_parse>( state_stream: &mut StateStream<'__pliron_parse>, arg: Self::Arg, ) -> ParseResult<'__pliron_parse, Self::Parsed>

Define a parser using existing combinators and call into on Parser::parse_stream to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, Output = Self::Parsed, PartialState = ()> + 'a>

where Self::Parsed: 'a,

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for VectorType

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for VectorType

fn fmt(&self, ctx: &Context, state: &State, fmt: &mut Formatter<'_>) -> Result

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl ResultNOfType<0, VectorType> for VectorBroadcastOp

impl ScalarizableType for VectorType

fn scalar_type(&self, _ctx: &Context) -> TypeHandle

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl SizedType for VectorType

fn size(&self, ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

fn size_bits(&self, ctx: &Context) -> usize

impl StructuralPartialEq for VectorType

impl Type for VectorType

fn hash_type(&self) -> TypeValueHash

Compute and get the hash for this instance of Self. Hash collisions can be a possibility.

fn eq_type(&self, other: &dyn Type) -> bool

Is self equal to an other Type?

fn get_type_id(&self) -> TypeId

Get a Type’s static name. This is not per instantiation of the type. It is mostly useful for printing and parsing the type. Uniquing does not use this, but instead uses core::any::TypeId.

fn get_type_id_static() -> TypeId

Same as get_type_id, but without the self reference.

fn get_self_handle(&self, ctx: &Context) -> TypeHandle

Get a copyable handle to this type.

fn instantiate(t: Self, ctx: &Context) -> TypedHandle<Self>

where Self: Sized,

Instantiate a type in the provided Context, returning a TypeHandle to self.

fn register(ctx: &mut Context)

where Self: Sized + Parsable<Arg = (), Parsed = TypedHandle<Self>>,

Register this Type’s TypeId in the dialect it belongs to.

impl Verify for VectorType

fn verify(&self, _ctx: &Context) -> Result<()>