vector<T, N:int>.init

Description

Initialize a vector where all elements have the same scalar value.

Signature

vector<T, N:int>.init(T value);

vector<T, N:int>.init(vector<T, N> value);

vector<T, N>.init(int v)
    where T : __BuiltinIntegerType;

vector<T, N>.init(int64_t v)
    where T : __BuiltinIntegerType;

vector<T, N>.init<U>(vector<U, N> other)
    where U : __BuiltinFloatingPointType
    where T : __BuiltinIntegerType;

vector<T, N>.init<U>(vector<U, N> other)
    where U : __BuiltinIntegerType
    where T : __BuiltinIntegerType;

vector<T, N>.init<U>(vector<U, N> other)
    where U : __BuiltinFloatingPointType
    where T : __BuiltinFloatingPointType;

vector<T, N>.init<U>(vector<U, N> other)
    where U : __BuiltinIntegerType
    where T : __BuiltinFloatingPointType;

vector<T, N>.init(int v)
    where T : __BuiltinFloatingPointType;

vector<T, N>.init(float v)
    where T : __BuiltinFloatingPointType;

vector<T, N>.init<L:int>(matrix<T, 2, 2> value)
    where N == 4;

vector<T, N>.init(
    T x,
    T y)
    where N == 2;

vector<T, N>.init(
    T x,
    T y,
    T z)
    where N == 3;

vector<T, N>.init(
    vector<T, 2> xy,
    T z)
    where N == 3;

vector<T, N>.init(
    T x,
    vector<T, 2> yz)
    where N == 3;

vector<T, N>.init(
    T x,
    T y,
    T z,
    T w)
    where N == 4;

vector<T, N>.init(
    vector<T, 2> xy,
    T z,
    T w)
    where N == 4;

vector<T, N>.init(
    T x,
    vector<T, 2> yz,
    T w)
    where N == 4;

vector<T, N>.init(
    T x,
    T y,
    vector<T, 2> zw)
    where N == 4;

vector<T, N>.init(
    vector<T, 2> xy,
    vector<T, 2> zw)
    where N == 4;

vector<T, N>.init(
    vector<T, 3> xyz,
    T w)
    where N == 4;

vector<T, N>.init(
    T x,
    vector<T, 3> yzw)
    where N == 4;

vector<T, N>.init(vector<int8_t, N> value)
    where T == bool;

vector<T, N>.init(int8_t value)
    where T == bool;

vector<T, N>.init(vector<int16_t, N> value)
    where T == bool;

vector<T, N>.init(int16_t value)
    where T == bool;

vector<T, N>.init(vector<int, N> value)
    where T == bool;

vector<T, N>.init(int value)
    where T == bool;

vector<T, N>.init(vector<int64_t, N> value)
    where T == bool;

vector<T, N>.init(int64_t value)
    where T == bool;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == bool;

vector<T, N>.init(intptr_t value)
    where T == bool;

vector<T, N>.init(vector<half, N> value)
    where T == bool;

vector<T, N>.init(half value)
    where T == bool;

vector<T, N>.init(vector<float, N> value)
    where T == bool;

vector<T, N>.init(float value)
    where T == bool;

vector<T, N>.init(vector<double, N> value)
    where T == bool;

vector<T, N>.init(double value)
    where T == bool;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == bool;

vector<T, N>.init(uint8_t value)
    where T == bool;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == bool;

vector<T, N>.init(uint16_t value)
    where T == bool;

vector<T, N>.init(vector<uint, N> value)
    where T == bool;

vector<T, N>.init(uint value)
    where T == bool;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == bool;

vector<T, N>.init(uint64_t value)
    where T == bool;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == bool;

vector<T, N>.init(uintptr_t value)
    where T == bool;

vector<T, N>.init(vector<bool, N> value)
    where T == int8_t;

vector<T, N>.init(bool value)
    where T == int8_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == int8_t;

vector<T, N>.init(int16_t value)
    where T == int8_t;

vector<T, N>.init(vector<int, N> value)
    where T == int8_t;

vector<T, N>.init(int value)
    where T == int8_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == int8_t;

vector<T, N>.init(int64_t value)
    where T == int8_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == int8_t;

vector<T, N>.init(intptr_t value)
    where T == int8_t;

vector<T, N>.init(vector<half, N> value)
    where T == int8_t;

vector<T, N>.init(half value)
    where T == int8_t;

vector<T, N>.init(vector<float, N> value)
    where T == int8_t;

vector<T, N>.init(float value)
    where T == int8_t;

vector<T, N>.init(vector<double, N> value)
    where T == int8_t;

vector<T, N>.init(double value)
    where T == int8_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == int8_t;

vector<T, N>.init(uint8_t value)
    where T == int8_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == int8_t;

vector<T, N>.init(uint16_t value)
    where T == int8_t;

vector<T, N>.init(vector<uint, N> value)
    where T == int8_t;

vector<T, N>.init(uint value)
    where T == int8_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == int8_t;

vector<T, N>.init(uint64_t value)
    where T == int8_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == int8_t;

vector<T, N>.init(uintptr_t value)
    where T == int8_t;

vector<T, N>.init(vector<bool, N> value)
    where T == int16_t;

vector<T, N>.init(bool value)
    where T == int16_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == int16_t;

vector<T, N>.init(int8_t value)
    where T == int16_t;

vector<T, N>.init(vector<int, N> value)
    where T == int16_t;

vector<T, N>.init(int value)
    where T == int16_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == int16_t;

vector<T, N>.init(int64_t value)
    where T == int16_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == int16_t;

vector<T, N>.init(intptr_t value)
    where T == int16_t;

vector<T, N>.init(vector<half, N> value)
    where T == int16_t;

vector<T, N>.init(half value)
    where T == int16_t;

vector<T, N>.init(vector<float, N> value)
    where T == int16_t;

vector<T, N>.init(float value)
    where T == int16_t;

vector<T, N>.init(vector<double, N> value)
    where T == int16_t;

vector<T, N>.init(double value)
    where T == int16_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == int16_t;

vector<T, N>.init(uint8_t value)
    where T == int16_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == int16_t;

vector<T, N>.init(uint16_t value)
    where T == int16_t;

vector<T, N>.init(vector<uint, N> value)
    where T == int16_t;

vector<T, N>.init(uint value)
    where T == int16_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == int16_t;

vector<T, N>.init(uint64_t value)
    where T == int16_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == int16_t;

vector<T, N>.init(uintptr_t value)
    where T == int16_t;

vector<T, N>.init(vector<bool, N> value)
    where T == int;

vector<T, N>.init(bool value)
    where T == int;

vector<T, N>.init(vector<int8_t, N> value)
    where T == int;

vector<T, N>.init(int8_t value)
    where T == int;

vector<T, N>.init(vector<int16_t, N> value)
    where T == int;

vector<T, N>.init(int16_t value)
    where T == int;

vector<T, N>.init(vector<int64_t, N> value)
    where T == int;

vector<T, N>.init(int64_t value)
    where T == int;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == int;

vector<T, N>.init(intptr_t value)
    where T == int;

vector<T, N>.init(vector<half, N> value)
    where T == int;

vector<T, N>.init(half value)
    where T == int;

vector<T, N>.init(vector<float, N> value)
    where T == int;

vector<T, N>.init(float value)
    where T == int;

vector<T, N>.init(vector<double, N> value)
    where T == int;

vector<T, N>.init(double value)
    where T == int;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == int;

vector<T, N>.init(uint8_t value)
    where T == int;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == int;

vector<T, N>.init(uint16_t value)
    where T == int;

vector<T, N>.init(vector<uint, N> value)
    where T == int;

vector<T, N>.init(uint value)
    where T == int;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == int;

vector<T, N>.init(uint64_t value)
    where T == int;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == int;

vector<T, N>.init(uintptr_t value)
    where T == int;

vector<T, N>.init(vector<bool, N> value)
    where T == int64_t;

vector<T, N>.init(bool value)
    where T == int64_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == int64_t;

vector<T, N>.init(int8_t value)
    where T == int64_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == int64_t;

vector<T, N>.init(int16_t value)
    where T == int64_t;

vector<T, N>.init(vector<int, N> value)
    where T == int64_t;

vector<T, N>.init(int value)
    where T == int64_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == int64_t;

vector<T, N>.init(intptr_t value)
    where T == int64_t;

vector<T, N>.init(vector<half, N> value)
    where T == int64_t;

vector<T, N>.init(half value)
    where T == int64_t;

vector<T, N>.init(vector<float, N> value)
    where T == int64_t;

vector<T, N>.init(float value)
    where T == int64_t;

vector<T, N>.init(vector<double, N> value)
    where T == int64_t;

vector<T, N>.init(double value)
    where T == int64_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == int64_t;

vector<T, N>.init(uint8_t value)
    where T == int64_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == int64_t;

vector<T, N>.init(uint16_t value)
    where T == int64_t;

vector<T, N>.init(vector<uint, N> value)
    where T == int64_t;

vector<T, N>.init(uint value)
    where T == int64_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == int64_t;

vector<T, N>.init(uint64_t value)
    where T == int64_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == int64_t;

vector<T, N>.init(uintptr_t value)
    where T == int64_t;

vector<T, N>.init(vector<bool, N> value)
    where T == intptr_t;

vector<T, N>.init(bool value)
    where T == intptr_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == intptr_t;

vector<T, N>.init(int8_t value)
    where T == intptr_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == intptr_t;

vector<T, N>.init(int16_t value)
    where T == intptr_t;

vector<T, N>.init(vector<int, N> value)
    where T == intptr_t;

vector<T, N>.init(int value)
    where T == intptr_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == intptr_t;

vector<T, N>.init(int64_t value)
    where T == intptr_t;

vector<T, N>.init(vector<half, N> value)
    where T == intptr_t;

vector<T, N>.init(half value)
    where T == intptr_t;

vector<T, N>.init(vector<float, N> value)
    where T == intptr_t;

vector<T, N>.init(float value)
    where T == intptr_t;

vector<T, N>.init(vector<double, N> value)
    where T == intptr_t;

vector<T, N>.init(double value)
    where T == intptr_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == intptr_t;

vector<T, N>.init(uint8_t value)
    where T == intptr_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == intptr_t;

vector<T, N>.init(uint16_t value)
    where T == intptr_t;

vector<T, N>.init(vector<uint, N> value)
    where T == intptr_t;

vector<T, N>.init(uint value)
    where T == intptr_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == intptr_t;

vector<T, N>.init(uint64_t value)
    where T == intptr_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == intptr_t;

vector<T, N>.init(uintptr_t value)
    where T == intptr_t;

vector<T, N>.init(vector<bool, N> value)
    where T == half;

vector<T, N>.init(bool value)
    where T == half;

vector<T, N>.init(vector<int8_t, N> value)
    where T == half;

vector<T, N>.init(int8_t value)
    where T == half;

vector<T, N>.init(vector<int16_t, N> value)
    where T == half;

vector<T, N>.init(int16_t value)
    where T == half;

vector<T, N>.init(vector<int, N> value)
    where T == half;

vector<T, N>.init(int value)
    where T == half;

vector<T, N>.init(vector<int64_t, N> value)
    where T == half;

vector<T, N>.init(int64_t value)
    where T == half;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == half;

vector<T, N>.init(intptr_t value)
    where T == half;

vector<T, N>.init(vector<float, N> value)
    where T == half;

vector<T, N>.init(float value)
    where T == half;

vector<T, N>.init(vector<double, N> value)
    where T == half;

vector<T, N>.init(double value)
    where T == half;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == half;

vector<T, N>.init(uint8_t value)
    where T == half;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == half;

vector<T, N>.init(uint16_t value)
    where T == half;

vector<T, N>.init(vector<uint, N> value)
    where T == half;

vector<T, N>.init(uint value)
    where T == half;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == half;

vector<T, N>.init(uint64_t value)
    where T == half;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == half;

vector<T, N>.init(uintptr_t value)
    where T == half;

vector<T, N>.init(vector<bool, N> value)
    where T == float;

vector<T, N>.init(bool value)
    where T == float;

vector<T, N>.init(vector<int8_t, N> value)
    where T == float;

vector<T, N>.init(int8_t value)
    where T == float;

vector<T, N>.init(vector<int16_t, N> value)
    where T == float;

vector<T, N>.init(int16_t value)
    where T == float;

vector<T, N>.init(vector<int, N> value)
    where T == float;

vector<T, N>.init(int value)
    where T == float;

vector<T, N>.init(vector<int64_t, N> value)
    where T == float;

vector<T, N>.init(int64_t value)
    where T == float;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == float;

vector<T, N>.init(intptr_t value)
    where T == float;

vector<T, N>.init(vector<half, N> value)
    where T == float;

vector<T, N>.init(half value)
    where T == float;

vector<T, N>.init(vector<double, N> value)
    where T == float;

vector<T, N>.init(double value)
    where T == float;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == float;

vector<T, N>.init(uint8_t value)
    where T == float;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == float;

vector<T, N>.init(uint16_t value)
    where T == float;

vector<T, N>.init(vector<uint, N> value)
    where T == float;

vector<T, N>.init(uint value)
    where T == float;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == float;

vector<T, N>.init(uint64_t value)
    where T == float;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == float;

vector<T, N>.init(uintptr_t value)
    where T == float;

vector<T, N>.init(vector<bool, N> value)
    where T == double;

vector<T, N>.init(bool value)
    where T == double;

vector<T, N>.init(vector<int8_t, N> value)
    where T == double;

vector<T, N>.init(int8_t value)
    where T == double;

vector<T, N>.init(vector<int16_t, N> value)
    where T == double;

vector<T, N>.init(int16_t value)
    where T == double;

vector<T, N>.init(vector<int, N> value)
    where T == double;

vector<T, N>.init(int value)
    where T == double;

vector<T, N>.init(vector<int64_t, N> value)
    where T == double;

vector<T, N>.init(int64_t value)
    where T == double;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == double;

vector<T, N>.init(intptr_t value)
    where T == double;

vector<T, N>.init(vector<half, N> value)
    where T == double;

vector<T, N>.init(half value)
    where T == double;

vector<T, N>.init(vector<float, N> value)
    where T == double;

vector<T, N>.init(float value)
    where T == double;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == double;

vector<T, N>.init(uint8_t value)
    where T == double;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == double;

vector<T, N>.init(uint16_t value)
    where T == double;

vector<T, N>.init(vector<uint, N> value)
    where T == double;

vector<T, N>.init(uint value)
    where T == double;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == double;

vector<T, N>.init(uint64_t value)
    where T == double;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == double;

vector<T, N>.init(uintptr_t value)
    where T == double;

vector<T, N>.init(vector<bool, N> value)
    where T == uint8_t;

vector<T, N>.init(bool value)
    where T == uint8_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == uint8_t;

vector<T, N>.init(int8_t value)
    where T == uint8_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == uint8_t;

vector<T, N>.init(int16_t value)
    where T == uint8_t;

vector<T, N>.init(vector<int, N> value)
    where T == uint8_t;

vector<T, N>.init(int value)
    where T == uint8_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == uint8_t;

vector<T, N>.init(int64_t value)
    where T == uint8_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == uint8_t;

vector<T, N>.init(intptr_t value)
    where T == uint8_t;

vector<T, N>.init(vector<half, N> value)
    where T == uint8_t;

vector<T, N>.init(half value)
    where T == uint8_t;

vector<T, N>.init(vector<float, N> value)
    where T == uint8_t;

vector<T, N>.init(float value)
    where T == uint8_t;

vector<T, N>.init(vector<double, N> value)
    where T == uint8_t;

vector<T, N>.init(double value)
    where T == uint8_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == uint8_t;

vector<T, N>.init(uint16_t value)
    where T == uint8_t;

vector<T, N>.init(vector<uint, N> value)
    where T == uint8_t;

vector<T, N>.init(uint value)
    where T == uint8_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == uint8_t;

vector<T, N>.init(uint64_t value)
    where T == uint8_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == uint8_t;

vector<T, N>.init(uintptr_t value)
    where T == uint8_t;

vector<T, N>.init(vector<bool, N> value)
    where T == uint16_t;

vector<T, N>.init(bool value)
    where T == uint16_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == uint16_t;

vector<T, N>.init(int8_t value)
    where T == uint16_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == uint16_t;

vector<T, N>.init(int16_t value)
    where T == uint16_t;

vector<T, N>.init(vector<int, N> value)
    where T == uint16_t;

vector<T, N>.init(int value)
    where T == uint16_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == uint16_t;

vector<T, N>.init(int64_t value)
    where T == uint16_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == uint16_t;

vector<T, N>.init(intptr_t value)
    where T == uint16_t;

vector<T, N>.init(vector<half, N> value)
    where T == uint16_t;

vector<T, N>.init(half value)
    where T == uint16_t;

vector<T, N>.init(vector<float, N> value)
    where T == uint16_t;

vector<T, N>.init(float value)
    where T == uint16_t;

vector<T, N>.init(vector<double, N> value)
    where T == uint16_t;

vector<T, N>.init(double value)
    where T == uint16_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == uint16_t;

vector<T, N>.init(uint8_t value)
    where T == uint16_t;

vector<T, N>.init(vector<uint, N> value)
    where T == uint16_t;

vector<T, N>.init(uint value)
    where T == uint16_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == uint16_t;

vector<T, N>.init(uint64_t value)
    where T == uint16_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == uint16_t;

vector<T, N>.init(uintptr_t value)
    where T == uint16_t;

vector<T, N>.init(vector<bool, N> value)
    where T == uint;

vector<T, N>.init(bool value)
    where T == uint;

vector<T, N>.init(vector<int8_t, N> value)
    where T == uint;

vector<T, N>.init(int8_t value)
    where T == uint;

vector<T, N>.init(vector<int16_t, N> value)
    where T == uint;

vector<T, N>.init(int16_t value)
    where T == uint;

vector<T, N>.init(vector<int, N> value)
    where T == uint;

vector<T, N>.init(int value)
    where T == uint;

vector<T, N>.init(vector<int64_t, N> value)
    where T == uint;

vector<T, N>.init(int64_t value)
    where T == uint;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == uint;

vector<T, N>.init(intptr_t value)
    where T == uint;

vector<T, N>.init(vector<half, N> value)
    where T == uint;

vector<T, N>.init(half value)
    where T == uint;

vector<T, N>.init(vector<float, N> value)
    where T == uint;

vector<T, N>.init(float value)
    where T == uint;

vector<T, N>.init(vector<double, N> value)
    where T == uint;

vector<T, N>.init(double value)
    where T == uint;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == uint;

vector<T, N>.init(uint8_t value)
    where T == uint;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == uint;

vector<T, N>.init(uint16_t value)
    where T == uint;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == uint;

vector<T, N>.init(uint64_t value)
    where T == uint;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == uint;

vector<T, N>.init(uintptr_t value)
    where T == uint;

vector<T, N>.init(vector<bool, N> value)
    where T == uint64_t;

vector<T, N>.init(bool value)
    where T == uint64_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == uint64_t;

vector<T, N>.init(int8_t value)
    where T == uint64_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == uint64_t;

vector<T, N>.init(int16_t value)
    where T == uint64_t;

vector<T, N>.init(vector<int, N> value)
    where T == uint64_t;

vector<T, N>.init(int value)
    where T == uint64_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == uint64_t;

vector<T, N>.init(int64_t value)
    where T == uint64_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == uint64_t;

vector<T, N>.init(intptr_t value)
    where T == uint64_t;

vector<T, N>.init(vector<half, N> value)
    where T == uint64_t;

vector<T, N>.init(half value)
    where T == uint64_t;

vector<T, N>.init(vector<float, N> value)
    where T == uint64_t;

vector<T, N>.init(float value)
    where T == uint64_t;

vector<T, N>.init(vector<double, N> value)
    where T == uint64_t;

vector<T, N>.init(double value)
    where T == uint64_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == uint64_t;

vector<T, N>.init(uint8_t value)
    where T == uint64_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == uint64_t;

vector<T, N>.init(uint16_t value)
    where T == uint64_t;

vector<T, N>.init(vector<uint, N> value)
    where T == uint64_t;

vector<T, N>.init(uint value)
    where T == uint64_t;

vector<T, N>.init(vector<uintptr_t, N> value)
    where T == uint64_t;

vector<T, N>.init(uintptr_t value)
    where T == uint64_t;

vector<T, N>.init(vector<bool, N> value)
    where T == uintptr_t;

vector<T, N>.init(bool value)
    where T == uintptr_t;

vector<T, N>.init(vector<int8_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(int8_t value)
    where T == uintptr_t;

vector<T, N>.init(vector<int16_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(int16_t value)
    where T == uintptr_t;

vector<T, N>.init(vector<int, N> value)
    where T == uintptr_t;

vector<T, N>.init(int value)
    where T == uintptr_t;

vector<T, N>.init(vector<int64_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(int64_t value)
    where T == uintptr_t;

vector<T, N>.init(vector<intptr_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(intptr_t value)
    where T == uintptr_t;

vector<T, N>.init(vector<half, N> value)
    where T == uintptr_t;

vector<T, N>.init(half value)
    where T == uintptr_t;

vector<T, N>.init(vector<float, N> value)
    where T == uintptr_t;

vector<T, N>.init(float value)
    where T == uintptr_t;

vector<T, N>.init(vector<double, N> value)
    where T == uintptr_t;

vector<T, N>.init(double value)
    where T == uintptr_t;

vector<T, N>.init(vector<uint8_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(uint8_t value)
    where T == uintptr_t;

vector<T, N>.init(vector<uint16_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(uint16_t value)
    where T == uintptr_t;

vector<T, N>.init(vector<uint, N> value)
    where T == uintptr_t;

vector<T, N>.init(uint value)
    where T == uintptr_t;

vector<T, N>.init(vector<uint64_t, N> value)
    where T == uintptr_t;

vector<T, N>.init(uint64_t value)
    where T == uintptr_t;

Generic Parameters

U: __BuiltinFloatingPointType

U: __BuiltinIntegerType

L : int

Parameters

value : T

value : vector<T, N>

v : int

v : int64_t

other : vector<U, N>

v : float

value : matrix<T, 2, 2>

x : T

y : T

z : T

xy : vector<T, 2>

yz : vector<T, 2>

w : T

zw : vector<T, 2>

xyz : vector<T, 3>

yzw : vector<T, 3>

value : vector<int8_t, N>

value : int8_t

value : vector<int16_t, N>

value : int16_t

value : vector<int, N>

value : int

value : vector<int64_t, N>

value : int64_t

value : vector<intptr_t, N>

value : intptr_t

value : vector<half, N>

value : half

value : vector<float, N>

value : float

value : vector<double, N>

value : double

value : vector<uint8_t, N>

value : uint8_t

value : vector<uint16_t, N>

value : uint16_t

value : vector<uint, N>

value : uint

value : vector<uint64_t, N>

value : uint64_t

value : vector<uintptr_t, N>

value : uintptr_t

value : vector<bool, N>

value : bool