matrix<T, R:int, C:int, L:int>.init

Description

Initialize a vector from a value of the same type

Signature

matrix<T, R:int, C:int, L:int>.init(T val);

matrix<T, R:int, C:int, L:int>.init(matrix<T, R, C> value);

matrix<T, R, C>.init(int v)
    where T : __BuiltinFloatingPointType;

matrix<T, R, C>.init(float v)
    where T : __BuiltinFloatingPointType;

matrix<T, R, C>.init(int value)
    where T == int16_t;

matrix<T, R, C>.init(vector<T, 4> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(T m00)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(vector<T, 1> row0)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 1, 2> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 1, 3> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 1, 4> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 1> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 2> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 3> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 1> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 2> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 1> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 1
    where C == 1;

matrix<T, R, C>.init(
    T m00,
    T m01)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(vector<T, 2> row0)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 1, 3> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 1, 4> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 2, 2> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 2, 3> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 2> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 1
    where C == 2;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(vector<T, 3> row0)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 1, 4> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 2, 3> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 1
    where C == 3;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m03)
    where R == 1
    where C == 4;

matrix<T, R, C>.init(vector<T, 4> row0)
    where R == 1
    where C == 4;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 1
    where C == 4;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 1
    where C == 4;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 1
    where C == 4;

matrix<T, R, C>.init(
    T m00,
    T m10)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(
    vector<T, 1> row0,
    vector<T, 1> row1)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 2> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 3> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 1> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 2> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 1> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 2
    where C == 1;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m10,
    T m11)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(
    vector<T, 2> row0,
    vector<T, 2> row1)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 2, 3> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 2> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 2
    where C == 2;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m10,
    T m11,
    T m12)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(
    vector<T, 3> row0,
    vector<T, 3> row1)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(matrix<T, 2, 4> value)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 2
    where C == 3;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m03,
    T m10,
    T m11,
    T m12,
    T m13)
    where R == 2
    where C == 4;

matrix<T, R, C>.init(
    vector<T, 4> row0,
    vector<T, 4> row1)
    where R == 2
    where C == 4;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 2
    where C == 4;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 2
    where C == 4;

matrix<T, R, C>.init(
    T m00,
    T m10,
    T m20)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(
    vector<T, 1> row0,
    vector<T, 1> row1,
    vector<T, 1> row2)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 2> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 1> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(
    matrix<T, 2, 1> m,
    vector<T, 1> row2)
    where R == 3
    where C == 1;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m10,
    T m11,
    T m20,
    T m21)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(
    vector<T, 2> row0,
    vector<T, 2> row1,
    vector<T, 2> row2)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 3> value)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(
    matrix<T, 2, 2> m,
    vector<T, 2> row2)
    where R == 3
    where C == 2;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m10,
    T m11,
    T m12,
    T m20,
    T m21,
    T m22)
    where R == 3
    where C == 3;

matrix<T, R, C>.init(
    vector<T, 3> row0,
    vector<T, 3> row1,
    vector<T, 3> row2)
    where R == 3
    where C == 3;

matrix<T, R, C>.init(matrix<T, 3, 4> value)
    where R == 3
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 3
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 3
    where C == 3;

matrix<T, R, C>.init(
    matrix<T, 2, 3> m,
    vector<T, 3> row2)
    where R == 3
    where C == 3;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m03,
    T m10,
    T m11,
    T m12,
    T m13,
    T m20,
    T m21,
    T m22,
    T m23)
    where R == 3
    where C == 4;

matrix<T, R, C>.init(
    vector<T, 4> row0,
    vector<T, 4> row1,
    vector<T, 4> row2)
    where R == 3
    where C == 4;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 3
    where C == 4;

matrix<T, R, C>.init(
    matrix<T, 2, 4> m,
    vector<T, 4> row2)
    where R == 3
    where C == 4;

matrix<T, R, C>.init(
    T m00,
    T m10,
    T m20,
    T m30)
    where R == 4
    where C == 1;

matrix<T, R, C>.init(
    vector<T, 1> row0,
    vector<T, 1> row1,
    vector<T, 1> row2,
    vector<T, 1> row3)
    where R == 4
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 2> value)
    where R == 4
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 4
    where C == 1;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 4
    where C == 1;

matrix<T, R, C>.init(
    matrix<T, 3, 1> m,
    vector<T, 1> row3)
    where R == 4
    where C == 1;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m10,
    T m11,
    T m20,
    T m21,
    T m30,
    T m31)
    where R == 4
    where C == 2;

matrix<T, R, C>.init(
    vector<T, 2> row0,
    vector<T, 2> row1,
    vector<T, 2> row2,
    vector<T, 2> row3)
    where R == 4
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 3> value)
    where R == 4
    where C == 2;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 4
    where C == 2;

matrix<T, R, C>.init(
    matrix<T, 3, 2> m,
    vector<T, 2> row3)
    where R == 4
    where C == 2;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m10,
    T m11,
    T m12,
    T m20,
    T m21,
    T m22,
    T m30,
    T m31,
    T m32)
    where R == 4
    where C == 3;

matrix<T, R, C>.init(
    vector<T, 3> row0,
    vector<T, 3> row1,
    vector<T, 3> row2,
    vector<T, 3> row3)
    where R == 4
    where C == 3;

matrix<T, R, C>.init(matrix<T, 4, 4> value)
    where R == 4
    where C == 3;

matrix<T, R, C>.init(
    matrix<T, 3, 3> m,
    vector<T, 3> row3)
    where R == 4
    where C == 3;

matrix<T, R, C>.init(
    T m00,
    T m01,
    T m02,
    T m03,
    T m10,
    T m11,
    T m12,
    T m13,
    T m20,
    T m21,
    T m22,
    T m23,
    T m30,
    T m31,
    T m32,
    T m33)
    where R == 4
    where C == 4;

matrix<T, R, C>.init(
    vector<T, 4> row0,
    vector<T, 4> row1,
    vector<T, 4> row2,
    vector<T, 4> row3)
    where R == 4
    where C == 4;

matrix<T, R, C>.init(
    matrix<T, 3, 4> m,
    vector<T, 4> row3)
    where R == 4
    where C == 4;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == bool;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == int8_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == int16_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == int;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == int64_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == intptr_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == half;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == float;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == double;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == uint8_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == uint16_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == uint;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<uintptr_t, R, C> value)
    where T == uint64_t;

matrix<T, R, C>.init(matrix<bool, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<int8_t, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<int16_t, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<int, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<int64_t, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<intptr_t, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<half, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<float, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<double, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<uint8_t, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<uint16_t, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<uint, R, C> value)
    where T == uintptr_t;

matrix<T, R, C>.init(matrix<uint64_t, R, C> value)
    where T == uintptr_t;

Parameters

val : T

value : matrix<T, R, C>

v : int

v : float

value : int

value : vector<T, 4>

m00 : T

row0 : vector<T, 1>

value : matrix<T, 1, 2>

value : matrix<T, 1, 3>

value : matrix<T, 1, 4>

value : matrix<T, 2, 1>

value : matrix<T, 2, 2>

value : matrix<T, 2, 3>

value : matrix<T, 2, 4>

value : matrix<T, 3, 1>

value : matrix<T, 3, 2>

value : matrix<T, 3, 3>

value : matrix<T, 3, 4>

value : matrix<T, 4, 1>

value : matrix<T, 4, 2>

value : matrix<T, 4, 3>

value : matrix<T, 4, 4>

m01 : T

row0 : vector<T, 2>

m02 : T

row0 : vector<T, 3>

m03 : T

row0 : vector<T, 4>

m10 : T

row1 : vector<T, 1>

m11 : T

row1 : vector<T, 2>

m12 : T

row1 : vector<T, 3>

m13 : T

row1 : vector<T, 4>

m20 : T

row2 : vector<T, 1>

m : matrix<T, 2, 1>

m21 : T

row2 : vector<T, 2>

m : matrix<T, 2, 2>

m22 : T

row2 : vector<T, 3>

m : matrix<T, 2, 3>

m23 : T

row2 : vector<T, 4>

m : matrix<T, 2, 4>

m30 : T

row3 : vector<T, 1>

m : matrix<T, 3, 1>

m31 : T

row3 : vector<T, 2>

m : matrix<T, 3, 2>

m32 : T

row3 : vector<T, 3>

m : matrix<T, 3, 3>

m33 : T

row3 : vector<T, 4>

m : matrix<T, 3, 4>

value : matrix<int8_t, R, C>

value : matrix<int16_t, R, C>

value : matrix<int, R, C>

value : matrix<int64_t, R, C>

value : matrix<intptr_t, R, C>

value : matrix<half, R, C>

value : matrix<float, R, C>

value : matrix<double, R, C>

value : matrix<uint8_t, R, C>

value : matrix<uint16_t, R, C>

value : matrix<uint, R, C>

value : matrix<uint64_t, R, C>

value : matrix<uintptr_t, R, C>

value : matrix<bool, R, C>

Availability and Requirements

Defined for the following targets:

hlsl

Available in all stages.