operator*

Description

Signature

/// Requires Capability Set 1:
Ref<T> operator*<T, addrSpace:uint64_t>(Addr<T> value);

int8_t operator*(
    int8_t left,
    int8_t right);

vector<int8_t, N> operator*<N:int>(
    vector<int8_t, N> left,
    vector<int8_t, N> right);

matrix<int8_t, N, M> operator*<N:int, M:int>(
    matrix<int8_t, N, M> left,
    matrix<int8_t, N, M> right);

vector<int8_t, N> operator*<N:int>(
    int8_t left,
    vector<int8_t, N> right);

matrix<int8_t, N, M> operator*<N:int, M:int>(
    int8_t left,
    matrix<int8_t, N, M> right);

vector<int8_t, N> operator*<N:int>(
    vector<int8_t, N> left,
    int8_t right);

matrix<int8_t, N, M> operator*<N:int, M:int>(
    matrix<int8_t, N, M> left,
    int8_t right);

int16_t operator*(
    int16_t left,
    int16_t right);

vector<int16_t, N> operator*<N:int>(
    vector<int16_t, N> left,
    vector<int16_t, N> right);

matrix<int16_t, N, M> operator*<N:int, M:int>(
    matrix<int16_t, N, M> left,
    matrix<int16_t, N, M> right);

vector<int16_t, N> operator*<N:int>(
    int16_t left,
    vector<int16_t, N> right);

matrix<int16_t, N, M> operator*<N:int, M:int>(
    int16_t left,
    matrix<int16_t, N, M> right);

vector<int16_t, N> operator*<N:int>(
    vector<int16_t, N> left,
    int16_t right);

matrix<int16_t, N, M> operator*<N:int, M:int>(
    matrix<int16_t, N, M> left,
    int16_t right);

int operator*(
    int left,
    int right);

vector<int, N> operator*<N:int>(
    vector<int, N> left,
    vector<int, N> right);

matrix<int, N, M> operator*<N:int, M:int>(
    matrix<int, N, M> left,
    matrix<int, N, M> right);

vector<int, N> operator*<N:int>(
    int left,
    vector<int, N> right);

matrix<int, N, M> operator*<N:int, M:int>(
    int left,
    matrix<int, N, M> right);

vector<int, N> operator*<N:int>(
    vector<int, N> left,
    int right);

matrix<int, N, M> operator*<N:int, M:int>(
    matrix<int, N, M> left,
    int right);

int64_t operator*(
    int64_t left,
    int64_t right);

vector<int64_t, N> operator*<N:int>(
    vector<int64_t, N> left,
    vector<int64_t, N> right);

matrix<int64_t, N, M> operator*<N:int, M:int>(
    matrix<int64_t, N, M> left,
    matrix<int64_t, N, M> right);

vector<int64_t, N> operator*<N:int>(
    int64_t left,
    vector<int64_t, N> right);

matrix<int64_t, N, M> operator*<N:int, M:int>(
    int64_t left,
    matrix<int64_t, N, M> right);

vector<int64_t, N> operator*<N:int>(
    vector<int64_t, N> left,
    int64_t right);

matrix<int64_t, N, M> operator*<N:int, M:int>(
    matrix<int64_t, N, M> left,
    int64_t right);

intptr_t operator*(
    intptr_t left,
    intptr_t right);

vector<intptr_t, N> operator*<N:int>(
    vector<intptr_t, N> left,
    vector<intptr_t, N> right);

matrix<intptr_t, N, M> operator*<N:int, M:int>(
    matrix<intptr_t, N, M> left,
    matrix<intptr_t, N, M> right);

vector<intptr_t, N> operator*<N:int>(
    intptr_t left,
    vector<intptr_t, N> right);

matrix<intptr_t, N, M> operator*<N:int, M:int>(
    intptr_t left,
    matrix<intptr_t, N, M> right);

vector<intptr_t, N> operator*<N:int>(
    vector<intptr_t, N> left,
    intptr_t right);

matrix<intptr_t, N, M> operator*<N:int, M:int>(
    matrix<intptr_t, N, M> left,
    intptr_t right);

half operator*(
    half left,
    half right);

vector<half, N> operator*<N:int>(
    vector<half, N> left,
    vector<half, N> right);

matrix<half, N, M> operator*<N:int, M:int>(
    matrix<half, N, M> left,
    matrix<half, N, M> right);

vector<half, N> operator*<N:int>(
    half left,
    vector<half, N> right);

matrix<half, N, M> operator*<N:int, M:int>(
    half left,
    matrix<half, N, M> right);

vector<half, N> operator*<N:int>(
    vector<half, N> left,
    half right);

matrix<half, N, M> operator*<N:int, M:int>(
    matrix<half, N, M> left,
    half right);

float operator*(
    float left,
    float right);

vector<float, N> operator*<N:int>(
    vector<float, N> left,
    vector<float, N> right);

matrix<float, N, M> operator*<N:int, M:int>(
    matrix<float, N, M> left,
    matrix<float, N, M> right);

vector<float, N> operator*<N:int>(
    float left,
    vector<float, N> right);

matrix<float, N, M> operator*<N:int, M:int>(
    float left,
    matrix<float, N, M> right);

vector<float, N> operator*<N:int>(
    vector<float, N> left,
    float right);

matrix<float, N, M> operator*<N:int, M:int>(
    matrix<float, N, M> left,
    float right);

double operator*(
    double left,
    double right);

vector<double, N> operator*<N:int>(
    vector<double, N> left,
    vector<double, N> right);

matrix<double, N, M> operator*<N:int, M:int>(
    matrix<double, N, M> left,
    matrix<double, N, M> right);

vector<double, N> operator*<N:int>(
    double left,
    vector<double, N> right);

matrix<double, N, M> operator*<N:int, M:int>(
    double left,
    matrix<double, N, M> right);

vector<double, N> operator*<N:int>(
    vector<double, N> left,
    double right);

matrix<double, N, M> operator*<N:int, M:int>(
    matrix<double, N, M> left,
    double right);

uint8_t operator*(
    uint8_t left,
    uint8_t right);

vector<uint8_t, N> operator*<N:int>(
    vector<uint8_t, N> left,
    vector<uint8_t, N> right);

matrix<uint8_t, N, M> operator*<N:int, M:int>(
    matrix<uint8_t, N, M> left,
    matrix<uint8_t, N, M> right);

vector<uint8_t, N> operator*<N:int>(
    uint8_t left,
    vector<uint8_t, N> right);

matrix<uint8_t, N, M> operator*<N:int, M:int>(
    uint8_t left,
    matrix<uint8_t, N, M> right);

vector<uint8_t, N> operator*<N:int>(
    vector<uint8_t, N> left,
    uint8_t right);

matrix<uint8_t, N, M> operator*<N:int, M:int>(
    matrix<uint8_t, N, M> left,
    uint8_t right);

uint16_t operator*(
    uint16_t left,
    uint16_t right);

vector<uint16_t, N> operator*<N:int>(
    vector<uint16_t, N> left,
    vector<uint16_t, N> right);

matrix<uint16_t, N, M> operator*<N:int, M:int>(
    matrix<uint16_t, N, M> left,
    matrix<uint16_t, N, M> right);

vector<uint16_t, N> operator*<N:int>(
    uint16_t left,
    vector<uint16_t, N> right);

matrix<uint16_t, N, M> operator*<N:int, M:int>(
    uint16_t left,
    matrix<uint16_t, N, M> right);

vector<uint16_t, N> operator*<N:int>(
    vector<uint16_t, N> left,
    uint16_t right);

matrix<uint16_t, N, M> operator*<N:int, M:int>(
    matrix<uint16_t, N, M> left,
    uint16_t right);

uint operator*(
    uint left,
    uint right);

vector<uint, N> operator*<N:int>(
    vector<uint, N> left,
    vector<uint, N> right);

matrix<uint, N, M> operator*<N:int, M:int>(
    matrix<uint, N, M> left,
    matrix<uint, N, M> right);

vector<uint, N> operator*<N:int>(
    uint left,
    vector<uint, N> right);

matrix<uint, N, M> operator*<N:int, M:int>(
    uint left,
    matrix<uint, N, M> right);

vector<uint, N> operator*<N:int>(
    vector<uint, N> left,
    uint right);

matrix<uint, N, M> operator*<N:int, M:int>(
    matrix<uint, N, M> left,
    uint right);

uint64_t operator*(
    uint64_t left,
    uint64_t right);

vector<uint64_t, N> operator*<N:int>(
    vector<uint64_t, N> left,
    vector<uint64_t, N> right);

matrix<uint64_t, N, M> operator*<N:int, M:int>(
    matrix<uint64_t, N, M> left,
    matrix<uint64_t, N, M> right);

vector<uint64_t, N> operator*<N:int>(
    uint64_t left,
    vector<uint64_t, N> right);

matrix<uint64_t, N, M> operator*<N:int, M:int>(
    uint64_t left,
    matrix<uint64_t, N, M> right);

vector<uint64_t, N> operator*<N:int>(
    vector<uint64_t, N> left,
    uint64_t right);

matrix<uint64_t, N, M> operator*<N:int, M:int>(
    matrix<uint64_t, N, M> left,
    uint64_t right);

uintptr_t operator*(
    uintptr_t left,
    uintptr_t right);

vector<uintptr_t, N> operator*<N:int>(
    vector<uintptr_t, N> left,
    vector<uintptr_t, N> right);

matrix<uintptr_t, N, M> operator*<N:int, M:int>(
    matrix<uintptr_t, N, M> left,
    matrix<uintptr_t, N, M> right);

vector<uintptr_t, N> operator*<N:int>(
    uintptr_t left,
    vector<uintptr_t, N> right);

matrix<uintptr_t, N, M> operator*<N:int, M:int>(
    uintptr_t left,
    matrix<uintptr_t, N, M> right);

vector<uintptr_t, N> operator*<N:int>(
    vector<uintptr_t, N> left,
    uintptr_t right);

matrix<uintptr_t, N, M> operator*<N:int, M:int>(
    matrix<uintptr_t, N, M> left,
    uintptr_t right);

T operator*<T>(
    T left,
    T right)
    where T : __BuiltinArithmeticType;

vector<T, N> operator*<T, N:int>(
    vector<T, N> left,
    vector<T, N> right)
    where T : __BuiltinArithmeticType;

matrix<T, N, M> operator*<T, N:int, M:int>(
    matrix<T, N, M> left,
    matrix<T, N, M> right)
    where T : __BuiltinArithmeticType;

vector<T, N> operator*<T, N:int>(
    T left,
    vector<T, N> right)
    where T : __BuiltinArithmeticType;

matrix<T, N, M> operator*<T, N:int, M:int>(
    T left,
    matrix<T, N, M> right)
    where T : __BuiltinArithmeticType;

vector<T, N> operator*<T, N:int>(
    vector<T, N> left,
    T right)
    where T : __BuiltinArithmeticType;

matrix<T, N, M> operator*<T, N:int, M:int>(
    matrix<T, N, M> left,
    T right)
    where T : __BuiltinArithmeticType;

T operator*<T>(
    T v0,
    T v1)
    where T : IArithmetic;

T operator*<T>(
    T v0,
    T v1)
    where T : IFloat;

T operator*<T>(DescriptorHandle<T> value)
    where T : IOpaqueDescriptor;

/// Requires Capability Set 2:
CoopVec<T, N> operator*<T, N:int>(
    CoopVec<T, N> lhs,
    const T rhs)
    where T : __BuiltinArithmeticType;

/// Requires Capability Set 2:
CoopVec<T, N> operator*<T, N:int>(
    const T lhs,
    CoopVec<T, N> rhs)
    where T : __BuiltinArithmeticType;

Generic Parameters

T

addrSpace : uint64_t

N : int

M : int

T: __BuiltinArithmeticType

T: IArithmetic

T: IFloat

T: IOpaqueDescriptor

Parameters

value : Addr<T>

left : int8_t

right : int8_t

left : vector<int8_t, N>

right : vector<int8_t, N>

left : matrix<int8_t, N, M>

right : matrix<int8_t, N, M>

left : int16_t

right : int16_t

left : vector<int16_t, N>

right : vector<int16_t, N>

left : matrix<int16_t, N, M>

right : matrix<int16_t, N, M>

left : int

right : int

left : vector<int, N>

right : vector<int, N>

left : matrix<int, N, M>

right : matrix<int, N, M>

left : int64_t

right : int64_t

left : vector<int64_t, N>

right : vector<int64_t, N>

left : matrix<int64_t, N, M>

right : matrix<int64_t, N, M>

left : intptr_t

right : intptr_t

left : vector<intptr_t, N>

right : vector<intptr_t, N>

left : matrix<intptr_t, N, M>

right : matrix<intptr_t, N, M>

left : half

right : half

left : vector<half, N>

right : vector<half, N>

left : matrix<half, N, M>

right : matrix<half, N, M>

left : float

right : float

left : vector<float, N>

right : vector<float, N>

left : matrix<float, N, M>

right : matrix<float, N, M>

left : double

right : double

left : vector<double, N>

right : vector<double, N>

left : matrix<double, N, M>

right : matrix<double, N, M>

left : uint8_t

right : uint8_t

left : vector<uint8_t, N>

right : vector<uint8_t, N>

left : matrix<uint8_t, N, M>

right : matrix<uint8_t, N, M>

left : uint16_t

right : uint16_t

left : vector<uint16_t, N>

right : vector<uint16_t, N>

left : matrix<uint16_t, N, M>

right : matrix<uint16_t, N, M>

left : uint

right : uint

left : vector<uint, N>

right : vector<uint, N>

left : matrix<uint, N, M>

right : matrix<uint, N, M>

left : uint64_t

right : uint64_t

left : vector<uint64_t, N>

right : vector<uint64_t, N>

left : matrix<uint64_t, N, M>

right : matrix<uint64_t, N, M>

left : uintptr_t

right : uintptr_t

left : vector<uintptr_t, N>

right : vector<uintptr_t, N>

left : matrix<uintptr_t, N, M>

right : matrix<uintptr_t, N, M>

left : T

right : T

left : vector<T, N>

right : vector<T, N>

left : matrix<T, N, M>

right : matrix<T, N, M>

v0 : T

v1 : T

value : DescriptorHandle<T>

lhs : CoopVec<T, N>

rhs : T

lhs : T

rhs : CoopVec<T, N>

Availability and Requirements

Capability Set 1

Defined for the following targets:

cpp

Available in all stages.

cuda

Available in all stages.

spirv

Available in all stages.

Capability Set 2

Defined for the following targets:

hlsl

Available in all stages.

cpp

Available in all stages.

cuda

Available in all stages.

spirv

Available in all stages.

Requires capability: spvCooperativeVectorNV.