Float32x4 immutable value type and operations.

Float32x4 stores 4 32-bit floating point values in "lanes". The lanes are "x", "y", "z", and "w" respectively.

Constants

int WWWW = 0xFF
const

int WWWX = 0x3F
const

int WWWY = 0x7F
const

int WWWZ = 0xBF
const

int WWXW = 0xCF
const

int WWXX = 0xF
const

int WWXY = 0x4F
const

int WWXZ = 0x8F
const

int WWYW = 0xDF
const

int WWYX = 0x1F
const

int WWYY = 0x5F
const

int WWYZ = 0x9F
const

int WWZW = 0xEF
const

int WWZX = 0x2F
const

int WWZY = 0x6F
const

int WWZZ = 0xAF
const

int WXWW = 0xF3
const

int WXWX = 0x33
const

int WXWY = 0x73
const

int WXWZ = 0xB3
const

int WXXW = 0xC3
const

int WXXX = 0x3
const

int WXXY = 0x43
const

int WXXZ = 0x83
const

int WXYW = 0xD3
const

int WXYX = 0x13
const

int WXYY = 0x53
const

int WXYZ = 0x93
const

int WXZW = 0xE3
const

int WXZX = 0x23
const

int WXZY = 0x63
const

int WXZZ = 0xA3
const

int WYWW = 0xF7
const

int WYWX = 0x37
const

int WYWY = 0x77
const

int WYWZ = 0xB7
const

int WYXW = 0xC7
const

int WYXX = 0x7
const

int WYXY = 0x47
const

int WYXZ = 0x87
const

int WYYW = 0xD7
const

int WYYX = 0x17
const

int WYYY = 0x57
const

int WYYZ = 0x97
const

int WYZW = 0xE7
const

int WYZX = 0x27
const

int WYZY = 0x67
const

int WYZZ = 0xA7
const

int WZWW = 0xFB
const

int WZWX = 0x3B
const

int WZWY = 0x7B
const

int WZWZ = 0xBB
const

int WZXW = 0xCB
const

int WZXX = 0xB
const

int WZXY = 0x4B
const

int WZXZ = 0x8B
const

int WZYW = 0xDB
const

int WZYX = 0x1B
const

int WZYY = 0x5B
const

int WZYZ = 0x9B
const

int WZZW = 0xEB
const

int WZZX = 0x2B
const

int WZZY = 0x6B
const

int WZZZ = 0xAB
const

int XWWW = 0xFC
const

int XWWX = 0x3C
const

int XWWY = 0x7C
const

int XWWZ = 0xBC
const

int XWXW = 0xCC
const

int XWXX = 0xC
const

int XWXY = 0x4C
const

int XWXZ = 0x8C
const

int XWYW = 0xDC
const

int XWYX = 0x1C
const

int XWYY = 0x5C
const

int XWYZ = 0x9C
const

int XWZW = 0xEC
const

int XWZX = 0x2C
const

int XWZY = 0x6C
const

int XWZZ = 0xAC
const

int XXWW = 0xF0
const

int XXWX = 0x30
const

int XXWY = 0x70
const

int XXWZ = 0xB0
const

int XXXW = 0xC0
const

int XXXX = 0x0
const

Mask passed to shuffle or shuffleMix.

int XXXY = 0x40
const

int XXXZ = 0x80
const

int XXYW = 0xD0
const

int XXYX = 0x10
const

int XXYY = 0x50
const

int XXYZ = 0x90
const

int XXZW = 0xE0
const

int XXZX = 0x20
const

int XXZY = 0x60
const

int XXZZ = 0xA0
const

int XYWW = 0xF4
const

int XYWX = 0x34
const

int XYWY = 0x74
const

int XYWZ = 0xB4
const

int XYXW = 0xC4
const

int XYXX = 0x4
const

int XYXY = 0x44
const

int XYXZ = 0x84
const

int XYYW = 0xD4
const

int XYYX = 0x14
const

int XYYY = 0x54
const

int XYYZ = 0x94
const

int XYZW = 0xE4
const

int XYZX = 0x24
const

int XYZY = 0x64
const

int XYZZ = 0xA4
const

int XZWW = 0xF8
const

int XZWX = 0x38
const

int XZWY = 0x78
const

int XZWZ = 0xB8
const

int XZXW = 0xC8
const

int XZXX = 0x8
const

int XZXY = 0x48
const

int XZXZ = 0x88
const

int XZYW = 0xD8
const

int XZYX = 0x18
const

int XZYY = 0x58
const

int XZYZ = 0x98
const

int XZZW = 0xE8
const

int XZZX = 0x28
const

int XZZY = 0x68
const

int XZZZ = 0xA8
const

int YWWW = 0xFD
const

int YWWX = 0x3D
const

int YWWY = 0x7D
const

int YWWZ = 0xBD
const

int YWXW = 0xCD
const

int YWXX = 0xD
const

int YWXY = 0x4D
const

int YWXZ = 0x8D
const

int YWYW = 0xDD
const

int YWYX = 0x1D
const

int YWYY = 0x5D
const

int YWYZ = 0x9D
const

int YWZW = 0xED
const

int YWZX = 0x2D
const

int YWZY = 0x6D
const

int YWZZ = 0xAD
const

int YXWW = 0xF1
const

int YXWX = 0x31
const

int YXWY = 0x71
const

int YXWZ = 0xB1
const

int YXXW = 0xC1
const

int YXXX = 0x1
const

int YXXY = 0x41
const

int YXXZ = 0x81
const

int YXYW = 0xD1
const

int YXYX = 0x11
const

int YXYY = 0x51
const

int YXYZ = 0x91
const

int YXZW = 0xE1
const

int YXZX = 0x21
const

int YXZY = 0x61
const

int YXZZ = 0xA1
const

int YYWW = 0xF5
const

int YYWX = 0x35
const

int YYWY = 0x75
const

int YYWZ = 0xB5
const

int YYXW = 0xC5
const

int YYXX = 0x5
const

int YYXY = 0x45
const

int YYXZ = 0x85
const

int YYYW = 0xD5
const

int YYYX = 0x15
const

int YYYY = 0x55
const

int YYYZ = 0x95
const

int YYZW = 0xE5
const

int YYZX = 0x25
const

int YYZY = 0x65
const

int YYZZ = 0xA5
const

int YZWW = 0xF9
const

int YZWX = 0x39
const

int YZWY = 0x79
const

int YZWZ = 0xB9
const

int YZXW = 0xC9
const

int YZXX = 0x9
const

int YZXY = 0x49
const

int YZXZ = 0x89
const

int YZYW = 0xD9
const

int YZYX = 0x19
const

int YZYY = 0x59
const

int YZYZ = 0x99
const

int YZZW = 0xE9
const

int YZZX = 0x29
const

int YZZY = 0x69
const

int YZZZ = 0xA9
const

int ZWWW = 0xFE
const

int ZWWX = 0x3E
const

int ZWWY = 0x7E
const

int ZWWZ = 0xBE
const

int ZWXW = 0xCE
const

int ZWXX = 0xE
const

int ZWXY = 0x4E
const

int ZWXZ = 0x8E
const

int ZWYW = 0xDE
const

int ZWYX = 0x1E
const

int ZWYY = 0x5E
const

int ZWYZ = 0x9E
const

int ZWZW = 0xEE
const

int ZWZX = 0x2E
const

int ZWZY = 0x6E
const

int ZWZZ = 0xAE
const

int ZXWW = 0xF2
const

int ZXWX = 0x32
const

int ZXWY = 0x72
const

int ZXWZ = 0xB2
const

int ZXXW = 0xC2
const

int ZXXX = 0x2
const

int ZXXY = 0x42
const

int ZXXZ = 0x82
const

int ZXYW = 0xD2
const

int ZXYX = 0x12
const

int ZXYY = 0x52
const

int ZXYZ = 0x92
const

int ZXZW = 0xE2
const

int ZXZX = 0x22
const

int ZXZY = 0x62
const

int ZXZZ = 0xA2
const

int ZYWW = 0xF6
const

int ZYWX = 0x36
const

int ZYWY = 0x76
const

int ZYWZ = 0xB6
const

int ZYXW = 0xC6
const

int ZYXX = 0x6
const

int ZYXY = 0x46
const

int ZYXZ = 0x86
const

int ZYYW = 0xD6
const

int ZYYX = 0x16
const

int ZYYY = 0x56
const

int ZYYZ = 0x96
const

int ZYZW = 0xE6
const

int ZYZX = 0x26
const

int ZYZY = 0x66
const

int ZYZZ = 0xA6
const

int ZZWW = 0xFA
const

int ZZWX = 0x3A
const

int ZZWY = 0x7A
const

int ZZWZ = 0xBA
const

int ZZXW = 0xCA
const

int ZZXX = 0xA
const

int ZZXY = 0x4A
const

int ZZXZ = 0x8A
const

int ZZYW = 0xDA
const

int ZZYX = 0x1A
const

int ZZYY = 0x5A
const

int ZZYZ = 0x9A
const

int ZZZW = 0xEA
const

int ZZZX = 0x2A
const

int ZZZY = 0x6A
const

int ZZZZ = 0xAA
const

Properties

signMask → int
read-only

Extract the sign bits from each lane return them in the first 4 bits. "x" lane is bit 0. "y" lane is bit 1. "z" lane is bit 2. "w" lane is bit 3.

w → double
read-only

Extracted w value.

x → double
read-only

Extracted x value.

y → double
read-only

Extracted y value.

z → double
read-only

Extracted z value.

Constructors

Float32x4(double x, double y, double z, double w)

Float32x4.fromFloat64x2(Float64x2 v)

Sets the x and y lanes to their respective values in v and sets the z and w lanes to 0.0.

Float32x4.fromInt32x4Bits(Int32x4 x)

Float32x4.splat(double v)

Float32x4.zero()

Operators

operator *(Float32x4 other) → Float32x4

Multiplication operator.

operator +(Float32x4 other) → Float32x4

Addition operator.

operator -(Float32x4 other) → Float32x4

Subtraction operator.

operator /(Float32x4 other) → Float32x4

Division operator.

operator unary-() → Float32x4

Negate operator.

Methods

abs() → Float32x4

Returns the lane-wise absolute value of this Float32x4.

clamp(Float32x4 lowerLimit, Float32x4 upperLimit) → Float32x4

Lane-wise clamp this to be in the range lowerLimit-upperLimit.

equal(Float32x4 other) → Int32x4

Relational equal.

greaterThan(Float32x4 other) → Int32x4

Relational greater than.

greaterThanOrEqual(Float32x4 other) → Int32x4

Relational greater than or equal.

lessThan(Float32x4 other) → Int32x4

Relational less than.

lessThanOrEqual(Float32x4 other) → Int32x4

Relational less than or equal.

max(Float32x4 other) → Float32x4

Returns the lane-wise maximum value in this or other.

min(Float32x4 other) → Float32x4

Returns the lane-wise minimum value in this or other.

notEqual(Float32x4 other) → Int32x4

Relational not-equal.

reciprocal() → Float32x4

Returns the reciprocal of this.

reciprocalSqrt() → Float32x4

Returns the square root of the reciprocal of this.

scale(double s) → Float32x4

Returns a copy of this each lane being scaled by s. Equivalent to this * new Float32x4.splat(s)

shuffle(int mask) → Float32x4

Shuffle the lane values. mask must be one of the 256 shuffle constants.

shuffleMix(Float32x4 other, int mask) → Float32x4

Shuffle the lane values in this and other. The returned Float32x4 will have XY lanes from this and ZW lanes from other. Uses the same mask as shuffle.

sqrt() → Float32x4

Returns the square root of this.

withW(double w) → Float32x4

Returns a new Float32x4 copied from this with a new w value.

withX(double x) → Float32x4

Returns a new Float32x4 copied from this with a new x value.

withY(double y) → Float32x4

Returns a new Float32x4 copied from this with a new y value.

withZ(double z) → Float32x4

Returns a new Float32x4 copied from this with a new z value.