Simd128Float32, Simd128Mask, and Simd128Float32List additions for dart:scalarlist

sdk/lib/scalarlist/simd128.dart

+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+part of dart.scalarlist;
+
+/**
+ * Interface of Dart Simd128Float32x4 and operations.
+ * Simd128Float32x4 stores 4 32-bit floating point values in "lanes".
+ * The lanes are "x", "y", "z", and "w" respectively.
+ */
+abstract class Simd128Float32x4 {
+  external factory Simd128Float32x4(double x, double y, double z, double w);
+  external factory Simd128Float32x4.zero();
+
+  /// Addition operator.

[kasperl, 2013/02/21 11:28:15]

Are these comments (addition operator, etc.) really helpful?

[Cutch, 2013/02/21 18:45:16]

Probably not. I copied these comments from double.dart....

+  Simd128Float32x4 operator+(Simd128Float32x4 other);
+  /// Negate operator.
+  Simd128Float32x4 operator-();
+  /// Subtraction operator.
+  Simd128Float32x4 operator-(Simd128Float32x4 other);
+  /// Multiplication operator.
+  Simd128Float32x4 operator*(Simd128Float32x4 other);
+  /// Division operator.
+  Simd128Float32x4 operator/(Simd128Float32x4 other);
+
+  /// Relational less than.
+  Simd128Mask lessThan(Simd128Float32x4 other);

[kasperl, 2013/02/21 11:28:15]

Maybe get rid of 'Than' and 'ThanOr' to make these a little bit shorter? Maybe
add a mask prefix or suffix to make it clearer that you're not returning bools?

   x.maskLess(y)
   x.maskGreaterEqual(y)

   x.lessMask(y)
   x.greaterEqualMask(y)

[Cutch, 2013/02/21 18:45:16]

I think maskLess and maskGreaterEqual reads better than lessMask and
greaterEqualMask. What do you think?

+  /// Relational less than or equal.
+  Simd128Mask lessThanOrEqual(Simd128Float32x4 other);
+  /// Relational greater than.
+  Simd128Mask greaterThan(Simd128Float32x4 other);
+  /// Relational greater than or equal.
+  Simd128Mask greaterThanOrEqual(Simd128Float32x4 other);
+  /// Relational equal.
+  Simd128Mask equal(Simd128Float32x4 other);
+  /// Relational not-equal.
+  Simd128Mask notEqual(Simd128Float32x4 other);
+
+  /// Returns a copy of [this] each lane being scaled by [s].
+  Simd128Float32x4 scale(double s);
+  /// Returns the absolute value of this [Simd128Float32].
+  Simd128Float32x4 abs();
+  /// Clamps [this] to be in the range [lowerLimit]-[upperLimit].
+  Simd128Float32x4 clamp(Simd128Float32x4 lowerLimit,
+                         Simd128Float32x4 upperLimit);
+
+  /// Extracted x value.
+  double get x;
+  /// Extracted y value.
+  double get y;
+  /// Extracted z value.
+  double get z;
+  /// Extracted w value.
+  double get w;
+
+  /// Returns a new [Simd128Float32x4] with [this]' x value in all four lanes.
+  Simd128Float32x4 get xxxx;
+  /// Returns a new [Simd128Float32x4] with [this]' y value in all four lanes.
+  Simd128Float32x4 get yyyy;
+  /// Returns a new [Simd128Float32x4] with [this]' z value in all four lanes.
+  Simd128Float32x4 get zzzz;
+  /// Returns a new [Simd128Float32x4] with [this]' w value in all four lanes.
+  Simd128Float32x4 get wwww;
+  // TODO(johnmccutchan): Add all 256 possible combinations.

[kasperl, 2013/02/21 11:28:15]

Is that the plan? Maybe that is the right thing. The tree shaker should remove
all the unused ones pretty easily in dart2js.

[Cutch, 2013/02/21 18:45:16]

Yep.

+
+  /// Returns a new [Simd128Float32x4] copied from [this] with a new x value.
+  Simd128Float32x4 withX(double x);
+  /// Returns a new [Simd128Float32x4] copied from [this] with a new y value.
+  Simd128Float32x4 withY(double y);
+  /// Returns a new [Simd128Float32x4] copied from [this] with a new z value.
+  Simd128Float32x4 withZ(double z);
+  /// Returns a new [Simd128Float32x4] copied from [this] with a new w value.
+  Simd128Float32x4 withW(double w);
+
+  /// Returns the lane-wise minimum value in [this] or [other].
+  Simd128Float32x4 min(Simd128 other);

[kasperl, 2013/02/21 11:28:15]

What's the type of other supposed to be for min and max? Simd128Float32x4?

[Cutch, 2013/02/21 18:45:16]

Typo, it should be Simd128Float32x4 and this is now fixed.

+
+  /// Returns the lane-wise maximum value in [this] or [other].
+  Simd128Float32x4 max(Simd128 other);
+
+  /// Returns the square root of [this].
+  Simd128Float32x4 sqrt();
+
+  /// Returns the reciprocal of [this].
+  Simd128Float32x4 reciprocal();
+
+  /// Returns the square root of the reciprocal of [this].
+  Simd128Float32x4 reciprocalSqrt();
+
+  /// Returns a copy of [this] as a [Simd128Mask].
+  Simd128Mask toSimd128Mask();
+}
+
+/**
+ * Interface of Dart Simd128Mask and operations.
+ * Simd128Mask stores 4 32-bit bit-masks in "lanes".
+ * The lanes are "x", "y", "z", and "w" respectively.
+ */
+abstract class Simd128Mask {
+  external factory Simd128Mask(int x, int y, int z, int w);
+  external factory Simd128Mask.bool(bool x, bool y, bool z, bool w);
+
+  /// The bit-wise or operator.
+  Simd128Mask operator|(Simd128Mask other);
+  /// The bit-wise and operator.
+  Simd128Mask operator&(Simd128Mask other);
+  /// The bit-wise xor operator.
+  Simd128Mask operator^(Simd128Mask other);
+
+  /// Extract 32-bit mask from x lane.
+  int get x;
+  /// Extract 32-bit mask from y lane.
+  int get y;
+  /// Extract 32-bit mask from z lane.
+  int get z;
+  /// Extract 32-bit mask from w lane.
+  int get w;
+
+  /// Returns a new [Simd128Mask] copied from [this] with a new x value.
+  Simd128Mask withX(int x);
+  /// Returns a new [Simd128Mask] copied from [this] with a new y value.
+  Simd128Mask withY(int y);
+  /// Returns a new [Simd128Mask] copied from [this] with a new z value.
+  Simd128Mask withZ(int z);
+  /// Returns a new [Simd128Mask] copied from [this] with a new w value.
+  Simd128Mask withW(int w);
+
+  /// Extracted x value. Returns false for 0, true for any other value.
+  bool get flagX;
+  /// Extracted y value. Returns false for 0, true for any other value.
+  bool get flagY;
+  /// Extracted z value. Returns false for 0, true for any other value.
+  bool get flagZ;
+  /// Extracted w value. Returns false for 0, true for any other value.
+  bool get flagW;
+
+  /// Returns a new [Simd128Mask] copied from [this] with a new x value.
+  Simd128Mask withFlagX(bool x);
+  /// Returns a new [Simd128Mask] copied from [this] with a new y value.
+  Simd128Mask withFlagY(bool y);
+  /// Returns a new [Simd128Mask] copied from [this] with a new z value.
+  Simd128Mask withFlagZ(bool z);
+  /// Returns a new [Simd128Mask] copied from [this] with a new w value.
+  Simd128Mask withFlagW(bool w);
+
+  /// Merge [trueValue] and [falseValue] based on [this]' bit mask:
+  /// Select bit from [trueValue] when bit in [this] is on.
+  /// Select bit from [falseValue] when bit in [this] is off.
+  Simd128Float32x4 select(Simd128Float32x4 trueValue, Simd128Float32x4 falseValue);

[kasperl, 2013/02/21 11:28:15]

Long line.

[Cutch, 2013/02/21 18:45:16]

Done.

+
+  /// Returns a bit-wise of [this] as a [Simd128Float32x4].

[kasperl, 2013/02/21 11:28:15]

bit-wise what? copy?

[Cutch, 2013/02/21 18:45:16]

copy and Done.

+  Simd128Float32x4 toSimd128Float32x4();
+}
+
+/**
+ * A fixed-length list of Simd128Float32x4 numbers that is viewable as a
+ * [ByteArray]. For long lists, this

[kasperl, 2013/02/21 11:28:15]

reflow

[Cutch, 2013/02/21 18:45:16]

Done.

+ * implementation will be considerably more space- and time-efficient than
+ * the default [List] implementation.
+ */
+abstract class Simd128Float32x4List implements List<Simd128Float32x4>,

[kasperl, 2013/02/21 11:28:15]

Maybe just get rid of the Float32x4 part? Simd128List seems sufficient to me.

[Cutch, 2013/02/21 18:45:16]

I'm starting to think Float32x4List but I'm not sure what to call Simd128Mask.
Uint32x4?

+    ByteArrayViewable {
+  /**
+   * Creates a [Simd128Float32List] of the specified length (in elements),
+   * all of whose elements are initially zero.
+   */
+  external factory Simd128Float32x4List(int length);
+
+  /**
+   * Creates a [Simd128Float32List] _view_ of the specified region in the
+   * specified byte [array]. Changes in the [Simd128Float32List] will be visible
+   * in the byte array and vice versa. If the [start] index of the region is
+   * not specified,

[kasperl, 2013/02/21 11:28:15]

reflow

[Cutch, 2013/02/21 18:45:16]

Done.

+   * it defaults to zero (the first byte in the byte array). If the length is
+   * not specified, it defaults to null, which indicates that the view extends
+   * to the end of the byte array.
+   *
+   * Throws [ArgumentError] if the length of the specified region
+   * is not divisible by 16 (the size of a "Simd128Float32" in bytes), or if the
+   * [start] of the region is not divisible by 16. If, however, [array]
+   * is a view of another byte array, this constructor will throw
+   * [ArgumentError] if the implicit starting position in the
+   * "ultimately backing" byte array is not divisible by 16. In plain terms,
+   * this constructor throws [ArgumentError] if the specified
+   * region does not contain an integral number of "Simd128Float32s," or if it
+   * is not "Simd128Float32-aligned."
+   */
+  external factory Simd128Float32x4List.view(ByteArray array,
+                                             [int start = 0, int length]);
+}