Trait MechFunctionCompiler 

pub trait MechFunctionCompiler {
    // Required method
    fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>;
}

Required Methods

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

Implementations on Foreign Types

impl MechFunctionCompiler for VariableDefineFxn

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for RecordAccessField

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for RecordAccessSwizzle

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for TableAccessRangeBool

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for TableAccessRangeIndex

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for TableAccessScalarF

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for TableAccessSwizzle

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl MechFunctionCompiler for ExpRational

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<F, T> MechFunctionCompiler for ConvertScalarToScalar<F, T>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<F, T> MechFunctionCompiler for ConvertScalarToScalarBasic<F, T>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<F, T> MechFunctionCompiler for ConvertScalarToMat2<F, T>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for NChooseK<T>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for NChooseKMatrix<T>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for RecordAssign<T>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM1M1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM1S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2x3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2x3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2x3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM2x3V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3x2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3x2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3x2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM3x2V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddM4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddMDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddR4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddRDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddRDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddRDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSM1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSM2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSM2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSM3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSM3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSM4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddSVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV3M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddV4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddVDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddVDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for AddVDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM1M1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM1S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2x3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2x3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2x3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM2x3V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3x2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3x2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3x2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM3x2V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivM4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivMDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivR4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivRDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivRDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivRDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSM1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSM2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSM2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSM3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSM3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSM4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivSVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV3M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivV4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivVDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivVDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DivVDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM1M1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM1S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2x3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2x3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2x3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM2x3V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3x2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3x2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3x2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM3x2V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulM4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulMDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulR4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulRDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulRDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulRDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSM1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSM2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSM2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSM3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSM3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSM4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulSVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV3M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulV4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulVDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulVDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MulVDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM1M1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM1S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2x3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2x3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2x3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM2x3V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3x2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3x2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3x2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM3x2V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubM4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubMDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR3M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubR4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubRDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubRDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubRDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSM1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSM2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSM2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSM3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSM3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSM4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSR2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSR3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSR4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSV2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSV3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSV4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubSVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV2S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV3M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV3S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV4S<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubV4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubVDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubVDS<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for SubVDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotM1M1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotM2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotM3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotM4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotMDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotR2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotR3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotR4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotRDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotScalar<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotV2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotV3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotV4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for DotVDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM1M1<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2x3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2x3M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2x3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM2x3V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3x2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3x2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3x2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM3x2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulM4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulMDM3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulMDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulMDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulMDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR2M2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR2M2x3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR2MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR2V2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR3M3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR3M3x2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR3MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR3V3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR4M4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR4MD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulR4V4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulRDMD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulRDVD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulScalar<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulV2R2<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulV3R3<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulV4R4<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T> MechFunctionCompiler for MatMulVDRD<T>

where T: ConstElem + CompileConst,

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, MatA> MechFunctionCompiler for NotV<T, MatA>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, MatA, MatB> MechFunctionCompiler for AddAssignVV<T, MatA, MatB>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, MatA, MatB> MechFunctionCompiler for DivAssignVV<T, MatA, MatB>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, MatA, MatB> MechFunctionCompiler for MulAssignVV<T, MatA, MatB>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, MatA, MatB> MechFunctionCompiler for SubAssignVV<T, MatA, MatB>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for Set1DRB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for Set1DRS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for Set2DAR<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for Set2DARB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for Set2DRAS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for Set2DRASB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for AddAssign1DRB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for AddAssign1DRS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for AddAssign2DRAS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for AddAssign2DRASB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for DivAssign1DRB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for DivAssign1DRS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for DivAssign2DRAS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for DivAssign2DRASB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for MulAssign1DRB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for MulAssign1DRS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for MulAssign2DRAS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for MulAssign2DRASB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for SubAssign1DRB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for SubAssign1DRS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for SubAssign2DRAS<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, IxVec> MechFunctionCompiler for SubAssign2DRASB<T, Matrix<T, R1, C1, S1>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2> MechFunctionCompiler for Set2DASV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for Set1DRV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for Set1DRVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for Set2DRAV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for Set2DRAVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for AddAssign1DRV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for AddAssign1DRVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for AddAssign2DRAV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for AddAssign2DRAVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for DivAssign1DRV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for DivAssign1DRVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for DivAssign2DRAV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for DivAssign2DRAVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for MulAssign1DRV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for MulAssign1DRVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for MulAssign2DRAV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for MulAssign2DRAVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for SubAssign1DRV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for SubAssign1DRVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for SubAssign2DRAV<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R1, C1, S1, R2, C2, S2, IxVec> MechFunctionCompiler for SubAssign2DRAVB<T, Matrix<T, R1, C1, S1>, Matrix<T, R2, C2, S2>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S> MechFunctionCompiler for Set1DA<T, Matrix<T, R, C, S>>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S> MechFunctionCompiler for Set1DS<T, Matrix<T, R, C, S>>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S> MechFunctionCompiler for Set1DSB<T, Matrix<T, R, C, S>>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S> MechFunctionCompiler for Set2DASS<T, Matrix<T, R, C, S>>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S, IxVec1, IxVec2> MechFunctionCompiler for Set2DRRS<T, Matrix<T, R, C, S>, IxVec1, IxVec2>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S, IxVec1, IxVec2> MechFunctionCompiler for Set2DRRSB<T, Matrix<T, R, C, S>, IxVec1, IxVec2>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S, IxVec> MechFunctionCompiler for Set2DSR<T, Matrix<T, R, C, S>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<T, R, C, S, IxVec> MechFunctionCompiler for Set2DSRB<T, Matrix<T, R, C, S>, IxVec>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

impl<TFrom, TTo, FromMat, ToMat> MechFunctionCompiler for ConvertMatToMat2<TFrom, TTo, FromMat, ToMat>

fn compile(&self, ctx: &mut CompileCtx) -> Result<u32, MechError>

Implementors

impl MechFunctionCompiler for UserFunction