Float32x4 abstract final#

abstract final class Float32x4

Four 32-bit floating point values.

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

Single operations can be performed on the multiple values of one or more Float32x4s, which will perform the corresponding operation for each lane of the operands, and provide a new Float32x4 (or similar multi-value) result with the results from each lane.

The Float32x4 class cannot be extended or implemented.

Constructors#

Float32x4() factory#

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

Creates a Float32x4 containing the 32-bit float values of the arguments.

The created value has Float32x4.x, Float32x4.y, Float32x4.z and Float32x4.w values that are the 32-bit floating point values created from the x, y, z and w arguments by conversion from 64-bit floating point to 32-bit floating point values.

The conversion from 64-bit float to 32-bit float loses significant precision, and may become zero or infinite even if the original 64-bit floating point value was non-zero and finite.

Implementation

external factory Float32x4(double x, double y, double z, double w);

Float32x4.fromFloat64x2() factory#

factory Float32x4.fromFloat64x2(Float64x2 xy)

Creates a Float32x4 with its x and y lanes set to values from xy.

The created value has Float32x4.x and Float32x4.y values which are the conversions of the Float64x2.x and Float64x2.y lanes of xy to 32-bit floating point values. The Float32x4.z and Float32x4.w lanes are set to the zero value.

Implementation

external factory Float32x4.fromFloat64x2(Float64x2 xy);

Float32x4.fromInt32x4Bits() factory#

factory Float32x4.fromInt32x4Bits(Int32x4 bits)

Creates a Float32x4 with 32-bit float values from the provided bits.

The created value has Float32x4.x, Float32x4.y, Float32x4.z and Float32x4.w values, which are the 32-bit floating point values of the bit-representations of the corresponding lanes of bits.

The conversion is performed using the platform endianness for both 32-bit integers and 32-bit floating point numbers.

Implementation

external factory Float32x4.fromInt32x4Bits(Int32x4 bits);

Float32x4.splat() factory#

factory Float32x4.splat(double value)

Creates a Float32x4 with the same 32-bit float value four times.

The created value has the same Float32x4.x, Float32x4.y, Float32x4.z and Float32x4.w value, which is the 32-bit floating point value created by converting the 64-bit floating point value to a 32-bit floating point value.

The conversion from 64-bit float to 32-bit float loses significant precision, and may become zero or infinite even if the original 64-bit floating point value was non-zero and finite.

Implementation

external factory Float32x4.splat(double value);

Float32x4.zero() factory#

factory Float32x4.zero()

Creates a Float32x4 with all values being zero.

The created value has the same Float32x4.x, Float32x4.y, Float32x4.z and Float32x4.w value, which is the 32-bit floating point zero value.

Implementation

external factory Float32x4.zero();

Properties#

hashCode no setter inherited#

int get hashCode

The hash code for this object.

A hash code is a single integer which represents the state of the object that affects operator == comparisons.

All objects have hash codes. The default hash code implemented by Object represents only the identity of the object, the same way as the default operator == implementation only considers objects equal if they are identical (see identityHashCode).

If operator == is overridden to use the object state instead, the hash code must also be changed to represent that state, otherwise the object cannot be used in hash based data structures like the default Set and Map implementations.

Hash codes must be the same for objects that are equal to each other according to operator ==. The hash code of an object should only change if the object changes in a way that affects equality. There are no further requirements for the hash codes. They need not be consistent between executions of the same program and there are no distribution guarantees.

Objects that are not equal are allowed to have the same hash code. It is even technically allowed that all instances have the same hash code, but if clashes happen too often, it may reduce the efficiency of hash-based data structures like HashSet or HashMap.

If a subclass overrides hashCode, it should override the operator == operator as well to maintain consistency.

Inherited from Object.

Implementation

external int get hashCode;

runtimeType no setter inherited#

Type get runtimeType

A representation of the runtime type of the object.

Inherited from Object.

Implementation

external Type get runtimeType;

signMask no setter#

int get signMask

The sign bits of each lane as single bits.

The sign bits of each lane's 32-bit floating point value are stored in the low four bits of this value:

The x lane in bit 0.
The y lane in bit 1.
The z lane in bit 2.
The w lane in bit 3.

Implementation

int get signMask;

w no setter#

double get w

The value of the "w" lane.

Implementation

double get w;

x no setter#

double get x

The value of the "x" lane.

Implementation

double get x;

y no setter#

double get y

The value of the "y" lane.

Implementation

double get y;

z no setter#

double get z

The value of the "z" lane.

Implementation

double get z;

Methods#

abs()#

Float32x4 abs()

Lane-wise conversion to absolute value.

Converts each lane's value to a non-negative value by negating the value if it is negative, and keeping the original value if it is not negative.

Returns the result for each lane.

Implementation

Float32x4 abs();

clamp()#

Float32x4 clamp(Float32x4 lowerLimit, Float32x4 upperLimit)

Lane-wise clamp to a range.

Clamps the value of each lane to a minimum value of the corresponding lane of lowerLimit and a maximum value of the corresponding lane of upperLimit. If the original value is lower than the minimum value, the result is the minimum value, and if original value is greater than the maximum value, the result is the maximum value. The result is unspecified if the maximum value is lower than the minimum value, or if any of the three values is a NaN value, other than that the result will be one of those three values, or possibly a different NaN value if any value is a NaN value.

Returns the result for each lane.

Implementation

Float32x4 clamp(Float32x4 lowerLimit, Float32x4 upperLimit);

equal()#

Int32x4 equal(Float32x4 other)

Lane-wise equals comparison.

Compares the 32-bit floating point value of each lane of this to the value of the corresponding lane of other, using 32-bit floating point comparison. For floating point comparisons, a comparison with a NaN value is always false, and -0.0 (negative zero) is considered equal to 0.0 (positive zero), and not less strictly than it. The result for a lane is a 32-bit signed integer which is -1 (all bits set) if the value from this object is equal to the value from other, and the result is 0 (all bits cleared) if not, including if either value is a NaN value.

Returns four values that are always either 0 or -1.

Implementation

Int32x4 equal(Float32x4 other);

greaterThan()#

Int32x4 greaterThan(Float32x4 other)

Lane-wise greater-than comparison.

Compares the 32-bit floating point value of each lane of this to the value of the corresponding lane of other, using 32-bit floating point comparison. For floating point comparisons, a comparison with a NaN value is always false, and -0.0 (negative zero) is considered equal to 0.0 (positive zero), and not less strictly than it. The result for a lane is a 32-bit signed integer which is -1 (all bits set) if the value from this object is greater than the value from other, and the result is 0 (all bits cleared) if not, including if either value is a NaN value.

Returns four values that are always either 0 or -1.

Implementation

Int32x4 greaterThan(Float32x4 other);

greaterThanOrEqual()#

Int32x4 greaterThanOrEqual(Float32x4 other)

Lane-wise greater-than-or-equal comparison.

Compares the 32-bit floating point value of each lane of this to the value of the corresponding lane of other, using 32-bit floating point comparison. For floating point comparisons, a comparison with a NaN value is always false, and -0.0 (negative zero) is considered equal to 0.0 (positive zero), and not less strictly than it. The result for a lane is a 32-bit signed integer which is -1 (all bits set) if the value from this object is greater than or equal to the value from other, and the result is 0 (all bits cleared) if not, including if either value is a NaN value.

Returns four values that are always either 0 or -1.

Implementation

Int32x4 greaterThanOrEqual(Float32x4 other);

lessThan()#

Int32x4 lessThan(Float32x4 other)

Lane-wise less-than comparison.

Compares the 32-bit floating point value of each lane of this to the value of the corresponding lane of other, using 32-bit floating point comparison. For floating point comparisons, a comparison with a NaN value is always false, and -0.0 (negative zero) is considered equal to 0.0 (positive zero), and not less strictly than it. The result for a lane is a 32-bit signed integer which is -1 (all bits set) if the value from this object is less than the value from other, and the result is 0 (all bits cleared) if not, including if either value is a NaN value.

Returns four values that are always either 0 or -1.

Implementation

Int32x4 lessThan(Float32x4 other);

lessThanOrEqual()#

Int32x4 lessThanOrEqual(Float32x4 other)

Lane-wise less-than-or-equal comparison.

Compares the 32-bit floating point value of each lane of this to the value of the corresponding lane of other, using 32-bit floating point comparison. For floating point comparisons, a comparison with a NaN value is always false, and -0.0 (negative zero) is considered equal to 0.0 (positive zero), and not less strictly than it. The result for a lane is a 32-bit signed integer which is -1 (all bits set) if the value from this object is less than or equal to the value from other, and the result is 0 (all bits cleared) if not, including if either value is a NaN value.

Returns four values that are always either 0 or -1.

Implementation

Int32x4 lessThanOrEqual(Float32x4 other);

max()#

Float32x4 max(Float32x4 other)

Lane-wise maximum.

For each lane select the greater of the lane value of this and other.

The result is the greater of the two lane values if either is greater. The result is unspecified if either lane contains a NaN value or if the values are -0.0 and 0.0, so that neither value is smaller or greater than the other. Different platforms may give different results in those cases, but always one of the lane values.

Returns the result for each lane.

Implementation

Float32x4 max(Float32x4 other);

min()#

Float32x4 min(Float32x4 other)

Lane-wise minimum.

For each lane select the lesser of the lane value of this and other.

The result is the lesser of the two lane values if either is lesser. The result is unspecified if either lane contains a NaN value or if the values are -0.0 and 0.0, so that neither value is smaller or greater than the other. Different platforms may give different results in those cases, but always one of the lane values.

Returns the result for each lane.

Implementation

Float32x4 min(Float32x4 other);

noSuchMethod() inherited#

dynamic noSuchMethod(Invocation invocation)

Invoked when a nonexistent method or property is accessed.

A dynamic member invocation can attempt to call a member which doesn't exist on the receiving object. Example:

dynamic object = 1;
object.add(42); // Statically allowed, run-time error

This invalid code will invoke the noSuchMethod method of the integer 1 with an Invocation representing the .add(42) call and arguments (which then throws).

Classes can override noSuchMethod to provide custom behavior for such invalid dynamic invocations.

A class with a non-default noSuchMethod invocation can also omit implementations for members of its interface. Example:

class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}

This code has no compile-time warnings or errors even though the MockList class has no concrete implementation of any of the List interface methods. Calls to List methods are forwarded to noSuchMethod, so this code will log an invocation similar to Invocation.method(#add, [42]) and then throw.

If a value is returned from noSuchMethod, it becomes the result of the original invocation. If the value is not of a type that can be returned by the original invocation, a type error occurs at the invocation.

The default behavior is to throw a NoSuchMethodError.

Inherited from Object.

Implementation

@pragma("vm:entry-point")
@pragma("wasm:entry-point")
external dynamic noSuchMethod(Invocation invocation);

notEqual()#

Int32x4 notEqual(Float32x4 other)

Lane-wise not-equals comparison.

Compares the 32-bit floating point value of each lane of this to the value of the corresponding lane of other, using 32-bit floating point comparison. For floating point comparisons, a comparison with a NaN value is always false, and -0.0 (negative zero) is considered equal to 0.0 (positive zero), and not less strictly than it. The result for a lane is a 32-bit signed integer which is -1 (all bits set) if the value from this object is not equal to the value from other, and the result is 0 (all bits cleared) if not, including if either value is a NaN value.

Returns four values that are always either 0 or -1.

Implementation

Int32x4 notEqual(Float32x4 other);

reciprocal()#

Float32x4 reciprocal()

Lane-wise reciprocal.

For each lane compute the result of dividing 1.0 by the lane's value.

If the value is a NaN value, so is the result. If the value is infinite, the result is a zero value with the same sign. If the value is zero, the result is infinite with the same sign. Otherwise the result is an approximation of the mathematical result of dividing 1 by the (finite, non-zero) value of the lane.

Returns the result for each lane.

Implementation

Float32x4 reciprocal();

reciprocalSqrt()#

Float32x4 reciprocalSqrt()

Lane-wise approximation of reciprocal square root.

Approximates the same result as reciprocal followed by sqrt, or sqrt followed by reciprocal, but may be more precise and/or efficient due to computing the result directly, rather than not creating a an intermediate result, and possibly by working entirely at a reduced precision.

The result can differ between platforms due to differences in approximation and precision, and for values where the order of sqrt and reciprocal makes a difference. The latter applies specifically to -0.0 where sqrt(-0.0) is defined to be -0.0, and reciprocal of that is -Infinity. In the opposite order it computes sqrt of -Infinity which is NaN.

Implementation

Float32x4 reciprocalSqrt();

scale()#

Float32x4 scale(double scale)

Lane-wise multiplication by scale.

Returns a result where each lane is the result of multiplying the corresponding lane of this value with scale. This can happen either by converting the lane value to a 64-bit floating point value, multiplying it with scale and converting the result back to a 32-bit floating point value, or by converting scale to a 32-bit floating point value and performing a 32-bit floating point multiplication.

In the latter case it is equivalent to thisValue * Float32x4.splat(s).

Implementation

Float32x4 scale(double scale);

shuffle()#

Float32x4 shuffle(int mask)

Shuffle the lane values based on the mask.

The mask must be one of the 256 shuffle masks from xxxx to wwww.

Creates a new Float32x4 whose lane values are taken from the lanes of this value based on the lanes of the shuffle mask, with the result's x lane being taken from the lane of the first letter of the shuffle mask's name, the y lane from the second letter, z lane from the third letter and w lane from the fourth letter.

For example, the shuffle mask wxyz creates a new Float32x4 whose x lane is the w lane of this value, because the first letter of the shuffle mask's name, wxyz is "w". Then the y, z and w lanes of the result are the values of the x, y and z lanes of this value.

The xyzw "identity shuffle" mask gives a result with the same lanes as the original.

Some masks preserve the values of all lanes, but may permute them. Other masks duplicates some lanes and discards the values of others.

For example, doing v1.shuffle(yyyy) is equivalent to Float32x4.splat(v1.y).

Implementation

Float32x4 shuffle(int mask);

shuffleMix()#

Float32x4 shuffleMix(Float32x4 other, int mask)

Mixes lanes chosen from two Float32x4 values using a mask.

Creates a new Float32x4 where the x and y lanes are chosen from the lanes of this value selected by the first two letters of the mask's name, and the z and w lanes are the lanes of other selected by the last two letters of the mask's name.

For example, v1.shuffleMix(v2, Float32x4.xyzw) is equivalent to Float32x4(v1.x, v1.y, v2.z, v2.w).

If other is the same value as this Float32x4, this function is the same as shuffle. That is, doing v1.shuffleMix(v1, mask) is equivalent to v1.shuffle(mask).

Implementation

Float32x4 shuffleMix(Float32x4 other, int mask);

sqrt()#

Float32x4 sqrt()

Lane-wise square root.

For each lane compute the 32-bit floating point square root of the lane's value.

The result for a lane is a NaN value if the original value is less than zero or if it is a NaN value. The result for a negative zero, -0.0, is the same value again. The result for positive infinity is positive infinity. Otherwise the result is a positive value which approximates the mathematical square root of the original value.

Returns the result for each lane.

Implementation

Float32x4 sqrt();

toString() inherited#

String toString()

A string representation of this object.

Some classes have a default textual representation, often paired with a static parse function (like int.parse). These classes will provide the textual representation as their string representation.

Other classes have no meaningful textual representation that a program will care about. Such classes will typically override toString to provide useful information when inspecting the object, mainly for debugging or logging.

Inherited from Object.

Implementation

external String toString();

withW()#

Float32x4 withW(double w)

This value, but with the value of the Float32x4.w lane set to w.

Returns a new Float32x4 with the same values for the x, y and z lanes as this value, and with a Float32x4.w lane having the value w converted to a 32-bit floating point number.

Implementation

Float32x4 withW(double w);

withX()#

Float32x4 withX(double x)

This value, but with the value of the Float32x4.x lane set to x.

Returns a new Float32x4 with the same values for the y, z and w lanes as this value, and with a Float32x4.x lane having the value x converted to a 32-bit floating point number.

Implementation

Float32x4 withX(double x);

withY()#

Float32x4 withY(double y)

This value, but with the value of the Float32x4.y lane set to y.

Returns a new Float32x4 with the same values for the x, z and w lanes as this value, and with a Float32x4.y lane having the value y converted to a 32-bit floating point number.

Implementation

Float32x4 withY(double y);

withZ()#

Float32x4 withZ(double z)

This value, but with the value of the Float32x4.z lane set to z.

Returns a new Float32x4 with the same values for the x, y and w lanes as this value, and with a Float32x4.z lane having the value z converted to a 32-bit floating point number.

Implementation

Float32x4 withZ(double z);

Operators#

operator *()#

Float32x4 operator *(Float32x4 other)

Lane-wise multiplication.

Multiplies the value of each lane of this value with the value of the corresponding lane of other.

Returns the result for each lane.

Implementation

Float32x4 operator *(Float32x4 other);

operator +()#

Float32x4 operator +(Float32x4 other)

Lane-wise addition.

Adds the value of each lane of this value to the value of the corresponding lane of other.

Returns the result for each lane.

Implementation

Float32x4 operator +(Float32x4 other);

operator -()#

Float32x4 operator -(Float32x4 other)

Lane-wise subtraction.

Subtracts the value of each lane of other from the value of the corresponding lane of this value.

Returns the result for each lane.

Implementation

Float32x4 operator -(Float32x4 other);

operator /()#

Float32x4 operator /(Float32x4 other)

Lane-wise division.

Divides the value of each lane of this value with the value of the corresponding lane of other.

Returns the result for each lane.

Implementation

Float32x4 operator &#47;(Float32x4 other);

operator ==() inherited#

bool operator ==(Object other)

The equality operator.

The default behavior for all Objects is to return true if and only if this object and other are the same object.

Override this method to specify a different equality relation on a class. The overriding method must still be an equivalence relation. That is, it must be:

Total: It must return a boolean for all arguments. It should never throw.
Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and o2 == o3 are true, then o1 == o3 must be true.

The method should also be consistent over time, so whether two objects are equal should only change if at least one of the objects was modified.

If a subclass overrides the equality operator, it should override the hashCode method as well to maintain consistency.

Inherited from Object.

Implementation

external bool operator ==(Object other);

operator unary-()#

Float32x4 operator unary-()

Lane-wise negation.

Returns a result where each lane is the negation of the corresponding lane of this value.

Implementation

Float32x4 operator -();

Constants#

wwww#

const int wwww

Shuffle mask "wwww".

Float32x4 abstract final#

Constructors#

Float32x4() factory#

Float32x4.fromFloat64x2() factory#

Float32x4.fromInt32x4Bits() factory#

Float32x4.splat() factory#

Float32x4.zero() factory#

Properties#

hashCode no setter inherited#

runtimeType no setter inherited#

signMask no setter#

w no setter#

x no setter#

y no setter#

z no setter#

Methods#

abs()#

clamp()#

equal()#

greaterThan()#

greaterThanOrEqual()#

lessThan()#

lessThanOrEqual()#

max()#

min()#

noSuchMethod() inherited#

notEqual()#

reciprocal()#

reciprocalSqrt()#

scale()#

shuffle()#

shuffleMix()#

sqrt()#

toString() inherited#

withW()#

withX()#

withY()#

withZ()#

Operators#

operator *()#

operator +()#

operator -()#

operator /()#

operator ==() inherited#

operator unary-()#

Constants#

wwww#

wwwx#

wwwy#

wwwz#

wwxw#

wwxx#

wwxy#

wwxz#

wwyw#

wwyx#

wwyy#

wwyz#

wwzw#

wwzx#

wwzy#

wwzz#

wxww#

wxwx#

wxwy#

wxwz#

wxxw#

wxxx#

wxxy#

wxxz#

wxyw#

wxyx#

wxyy#

wxyz#

wxzw#

wxzx#

wxzy#

wxzz#

wyww#

wywx#