operator*

Description

Multiplies a cooperative matrix by a scalar value: CoopMat * scalar Performs element-wise multiplication of each element in the matrix by the scalar.

Signature

Ref<T, AddressSpace.Generic> operator*<T, Access access, AddressSpace addrSpace>(
    Ptr<T, AddressSpace.Generic> value);

int8_t operator*(
    int8_t left,
    int8_t right);

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

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

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

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

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

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

int16_t operator*(
    int16_t left,
    int16_t right);

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

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

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

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

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

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

int operator*(
    int left,
    int right);

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

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

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

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

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

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

int64_t operator*(
    int64_t left,
    int64_t right);

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

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

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

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

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

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

intptr_t operator*(
    intptr_t left,
    intptr_t right);

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

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

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

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

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

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

half operator*(
    half left,
    half right);

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

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

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

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

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

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

float operator*(
    float left,
    float right);

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

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

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

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

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

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

double operator*(
    double left,
    double right);

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

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

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

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

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

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

uint8_t operator*(
    uint8_t left,
    uint8_t right);

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

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

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

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

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

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

uint16_t operator*(
    uint16_t left,
    uint16_t right);

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

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

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

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

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

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

uint operator*(
    uint left,
    uint right);

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

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

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

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

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

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

uint64_t operator*(
    uint64_t left,
    uint64_t right);

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

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

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

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

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

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

uintptr_t operator*(
    uintptr_t left,
    uintptr_t right);

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

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

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

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

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

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

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

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

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

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

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

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

matrix<T, N, M> operator*<T, int N, int M>(
    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 1:
linalg.CoopMat<T, S, M, N, R> operator*<T, MemoryScope S, int M, int N, linalg.CoopMatMatrixUseR>(
    linalg.CoopMat<T, S, M, N, R> lhs,
    const T rhs)
    where T : __BuiltinArithmeticType;

/// Requires Capability Set 1:
linalg.CoopMat<T, S, M, N, R> operator*<T, MemoryScope S, int M, int N, linalg.CoopMatMatrixUseR>(
    const T lhs,
    linalg.CoopMat<T, S, M, N, R> rhs)
    where T : __BuiltinArithmeticType;

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

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

Generic Parameters

T

The element type of the cooperative matrix.

access : Access

addrSpace : AddressSpace

N : int

The number of columns in the matrix fragment.

M : int

The number of rows in the matrix fragment.

T: __BuiltinArithmeticType

The element type of the cooperative matrix.

T: IArithmetic

The element type of the cooperative matrix.

T: IFloat

The element type of the cooperative matrix.

T: IOpaqueDescriptor

The element type of the cooperative matrix.

S : MemoryScope

The memory scope defining the cooperative group.

R : linalg.CoopMatMatrixUse

The matrix use specifier (MatrixA, MatrixB, or MatrixAccumulator).

Parameters

value : Ptr<T, AddressSpace.Generic>

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 : linalg.CoopMat<T, S, M, N, R>

The cooperative matrix to multiply.

rhs : T

The scalar value to multiply each element by.

lhs : T

The cooperative matrix to multiply.

rhs : linalg.CoopMat<T, S, M, N, R>

The scalar value to multiply each element by.

lhs : CoopVec<T, N>

The cooperative matrix to multiply.

rhs : CoopVec<T, N>

The scalar value to multiply each element by.

Return value

A new cooperative matrix with all elements multiplied by the scalar.

Availability and Requirements

Capability Set 1

Defined for the following targets:

cuda

Available in all stages.

spirv

Available in all stages.

Requires capability: spvCooperativeMatrixKHR.

Capability Set 2

Defined for the following targets:

hlsl

Available in all stages.

glsl

Available in all stages.

cpp

Available in all stages.

cuda

Available in all stages.

spirv

Available in all stages.

Requires capability: spvCooperativeVectorNV.