[typed_data] Add Int32x4.notEqual

TEST=lib/typed_data/int32x4_compare_test

Bug: #64073
Issue: #64170
Change-Id: I1e97afbeca2e637fc0ccdbb3367986539ec4ce5c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/541221
Reviewed-by: Stephen Adams <sra@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Auto-Submit: Modestas Valauskas <valauskasmodestas@gmail.com>
Reviewed-by: Lasse Nielsen <lrn@google.com>
Commit-Queue: Slava Egorov <vegorov@google.com>

Author: modulovalue

CHANGELOG.md

@@ -20,6 +20,8 @@
 - Added `Int32x4.equal`, a lane-wise equality comparison that returns `-1` in
   each lane where the operands are equal and `0` elsewhere, and the
   `Int32x4.anyTrue` getter, which is `true` when any lane is non-zero.
+- Added `Int32x4.notEqual`, a lane-wise inequality comparison that returns `-1`
+  in each lane where the operands differ and `0` elsewhere.
 
 #### `dart:js_interop`
 

sdk/lib/_internal/js_dev_runtime/private/native_typed_data.dart

@@ -1738,6 +1738,15 @@ final class NativeInt32x4 implements Int32x4 {
     );
   }
 
+  Int32x4 notEqual(Int32x4 other) {
+    return NativeInt32x4._truncated(
+      x != other.x ? -1 : 0,
+      y != other.y ? -1 : 0,
+      z != other.z ? -1 : 0,
+      w != other.w ? -1 : 0,
+    );
+  }
+
   bool get anyTrue => (x | y | z | w) != 0;
 
   /// Shuffle the lane values. [mask] must be one of the 256 shuffle constants.

sdk/lib/_internal/js_runtime/lib/native_typed_data.dart

@@ -2026,6 +2026,15 @@ final class NativeInt32x4 implements Int32x4 {
     );
   }
 
+  Int32x4 notEqual(Int32x4 other) {
+    return NativeInt32x4._truncated(
+      x != other.x ? -1 : 0,
+      y != other.y ? -1 : 0,
+      z != other.z ? -1 : 0,
+      w != other.w ? -1 : 0,
+    );
+  }
+
   bool get anyTrue => (x | y | z | w) != 0;
 
   /// Shuffle the lane values. [mask] must be one of the 256 shuffle constants.

sdk/lib/_internal/vm/lib/typed_data_patch.dart

@@ -4030,6 +4030,13 @@ final class _Int32x4 implements Int32x4 {
   @pragma("vm:external-name", "Int32x4_equal")
   external Int32x4 equal(Int32x4 other);
 
+  Int32x4 notEqual(Int32x4 other) => Int32x4(
+    x != other.x ? -1 : 0,
+    y != other.y ? -1 : 0,
+    z != other.z ? -1 : 0,
+    w != other.w ? -1 : 0,
+  );
+
   @pragma("vm:recognized", "other")
   @pragma("vm:external-name", "Int32x4_getX")
   external int get x;

sdk/lib/_internal/wasm/common/simd.dart

@@ -653,6 +653,15 @@ final class I32x4 extends WasmTypedDataBase implements Int32x4 {
   Int32x4 equal(Int32x4 other) =>
       I32x4.fromV128(WasmI32x4(_bits).eq(WasmI32x4((other as I32x4)._bits)));
 
+  Int32x4 notEqual(Int32x4 other) {
+    return I32x4._truncated(
+      x != other.x ? -1 : 0,
+      y != other.y ? -1 : 0,
+      z != other.z ? -1 : 0,
+      w != other.w ? -1 : 0,
+    );
+  }
+
   bool get anyTrue => _bits.anyTrue;
 
   Int32x4 shuffle(int mask) {

sdk/lib/typed_data/typed_data.dart

@@ -4376,6 +4376,15 @@ abstract final class Int32x4 {
   /// Returns four values that are always either 0 or -1.
   Int32x4 equal(Int32x4 other);
 
+  /// Lane-wise integer inequality comparison.
+  ///
+  /// 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 it is.
+  ///
+  /// Returns four values that are always either 0 or -1.
+  Int32x4 notEqual(Int32x4 other);
+
   /// Extract 32-bit mask from x lane.
   int get x;
 

tests/lib/typed_data/int32x4_compare_test.dart

@@ -11,32 +11,92 @@ import 'dart:typed_data';
 
 import 'package:expect/expect.dart';
 
-void testEqual() {
-  final a = Int32x4(1, 2, 3, 4);
+// Int32 min and max.
+const _min = -2147483648;
+const _max = 2147483647;
+
+/// Tests Int32x4 equality comparisons.
+///
+/// If [testingEqual] is true, tests [Int32x4.equal].
+/// If [testingEqual] is false, tests [Int32x4.notEqual].
+void testEquality(bool testingEqual) {
+  Int32x4 compare(Int32x4 a, Int32x4 b) =>
+      testingEqual ? a.equal(b) : a.notEqual(b);
+
+  // Checks that:
+  // - compare produces the expected mask
+  // - compare is symmetric
+  // - each operand is reflexive (equals itself in every lane)
+  // - equal and notEqual are inverses, i.e. never equal to each other
+  void check(Int32x4 a, Int32x4 b) {
+    void expectSameLanes(Int32x4 expected, Int32x4 actual) {
+      Expect.equals(expected.x, actual.x);
+      Expect.equals(expected.y, actual.y);
+      Expect.equals(expected.z, actual.z);
+      Expect.equals(expected.w, actual.w);
+    }
+
+    // -1 where the operator is true for the lane, else 0.
+    int compareLane(int a, int b) => (a == b) == testingEqual ? -1 : 0;
+    final r = compare(a, b);
+    Expect.equals(compareLane(a.x, b.x), r.x);
+    Expect.equals(compareLane(a.y, b.y), r.y);
+    Expect.equals(compareLane(a.z, b.z), r.z);
+    Expect.equals(compareLane(a.w, b.w), r.w);
+    var sign = 0;
+    if (r.x == -1) sign |= 1;
+    if (r.y == -1) sign |= 2;
+    if (r.z == -1) sign |= 4;
+    if (r.w == -1) sign |= 8;
+    Expect.equals(sign, r.signMask);
+
+    // Symmetry: swapping the operands gives the same mask.
+    expectSameLanes(r, compare(b, a));
+
+    // Reflexivity: each operand compares equal to itself in every lane.
+    void reflexive(Int32x4 v) {
+      final selfMask = compare(v, v);
+      final expected = testingEqual ? -1 : 0;
+      Expect.equals(expected, selfMask.x);
+      Expect.equals(expected, selfMask.y);
+      Expect.equals(expected, selfMask.z);
+      Expect.equals(expected, selfMask.w);
+    }
+
+    reflexive(a);
+    reflexive(b);
+
+    // equal and notEqual are inverses: ~ turns one into the other, and they
+    // disagree in every lane (eq.notEqual(neq) all true, eq.equal(neq) all
+    // false).
+    final eq = a.equal(b);
+    final neq = a.notEqual(b);
+    expectSameLanes(neq, ~eq);
+    expectSameLanes(eq, ~neq);
+    final eqNeq = eq.notEqual(neq);
+    Expect.equals(-1, eqNeq.x);
+    Expect.equals(-1, eqNeq.y);
+    Expect.equals(-1, eqNeq.z);
+    Expect.equals(-1, eqNeq.w);
+    final eqEq = eq.equal(neq);
+    Expect.equals(0, eqEq.x);
+    Expect.equals(0, eqEq.y);
+    Expect.equals(0, eqEq.z);
+    Expect.equals(0, eqEq.w);
+  }
 
-  // All lanes equal -> every lane is -1.
-  final all = a.equal(Int32x4(1, 2, 3, 4));
-  Expect.equals(-1, all.x);
-  Expect.equals(-1, all.y);
-  Expect.equals(-1, all.z);
-  Expect.equals(-1, all.w);
-  Expect.equals(0xf, all.signMask);
-
-  // No lanes equal -> every lane is 0.
-  final none = a.equal(Int32x4(5, 6, 7, 8));
-  Expect.equals(0, none.x);
-  Expect.equals(0, none.y);
-  Expect.equals(0, none.z);
-  Expect.equals(0, none.w);
-  Expect.equals(0x0, none.signMask);
-
-  // Per-lane result: only y and w match.
-  final some = a.equal(Int32x4(0, 2, 0, 4));
-  Expect.equals(0, some.x);
-  Expect.equals(-1, some.y);
-  Expect.equals(0, some.z);
-  Expect.equals(-1, some.w);
-  Expect.equals(0xa, some.signMask); // bits 1 and 3.
+  // All lanes equal.
+  check(Int32x4(1, 2, 3, 4), Int32x4(1, 2, 3, 4));
+  check(Int32x4(-3, -2, -1, 0), Int32x4(-3, -2, -1, 0));
+  check(Int32x4(_min, _max, 0, -1), Int32x4(_min, _max, 0, -1));
+  // No lanes equal.
+  check(Int32x4(1, 2, 3, 4), Int32x4(5, 6, 7, 8));
+  check(Int32x4(-3, -2, -1, 0), Int32x4(-7, -6, -5, -4));
+  check(Int32x4(_min, _max, 0, -1), Int32x4(_max, _min, -1, 0));
+  // Only y and w match.
+  check(Int32x4(1, 2, 3, 4), Int32x4(0, 2, 0, 4));
+  check(Int32x4(-3, -2, -1, 0), Int32x4(0, -2, 0, 0));
+  check(Int32x4(_min, 2, _max, 4), Int32x4(0, 2, 0, 4));
 }
 
 void testAnyTrue() {
@@ -75,7 +135,8 @@ void testAnyTrue() {
 
 void main() {
   for (int i = 0; i < 20; i++) {
-    testEqual();
+    testEquality(true); // equal
+    testEquality(false); // notEqual
     testAnyTrue();
   }
 }