Add zeroWhere! fused masked zeroing primitive with ComparisonOp

vecxt/src-js/doublearrays.scala

@@ -767,6 +767,35 @@ object doublearrays:
 
     def maxElement: Double = vec.max
     // val t = js.Math.max( vec.toArray: _* )
+
+    inline def `zeroWhere!`(
+        other: Array[Double],
+        threshold: Double,
+        inline op: ComparisonOp
+    ): Unit =
+      assert(vec.length == other.length)
+      var i = 0
+      while i < vec.length do
+        val hit = inline op match
+          case ComparisonOp.LE => other(i) <= threshold
+          case ComparisonOp.LT => other(i) < threshold
+          case ComparisonOp.GE => other(i) >= threshold
+          case ComparisonOp.GT => other(i) > threshold
+          case ComparisonOp.EQ => other(i) == threshold
+          case ComparisonOp.NE => other(i) != threshold
+        if hit then vec(i) = 0.0
+        end if
+        i += 1
+      end while
+    end `zeroWhere!`
+
+    inline def zeroWhere(
+        other: Array[Double],
+        threshold: Double,
+        inline op: ComparisonOp
+    ): Array[Double] =
+      vec.clone().tap(_.`zeroWhere!`(other, threshold, op))
+
   end extension
 
 end doublearrays

vecxt/src-js/floatarrays.scala

@@ -835,6 +835,34 @@ object floatarrays:
       (cv / (vec.length - 1)).toFloat
     end covariance
 
+    inline def `zeroWhere!`(
+        other: Array[Float],
+        threshold: Float,
+        inline op: ComparisonOp
+    ): Unit =
+      assert(vec.length == other.length)
+      var i = 0
+      while i < vec.length do
+        val hit = inline op match
+          case ComparisonOp.LE => other(i) <= threshold
+          case ComparisonOp.LT => other(i) < threshold
+          case ComparisonOp.GE => other(i) >= threshold
+          case ComparisonOp.GT => other(i) > threshold
+          case ComparisonOp.EQ => other(i) == threshold
+          case ComparisonOp.NE => other(i) != threshold
+        if hit then vec(i) = 0.0f
+        end if
+        i += 1
+      end while
+    end `zeroWhere!`
+
+    inline def zeroWhere(
+        other: Array[Float],
+        threshold: Float,
+        inline op: ComparisonOp
+    ): Array[Float] =
+      vec.clone().tap(_.`zeroWhere!`(other, threshold, op))
+
   end extension
 
   extension (vec: Array[Array[Double]])

vecxt/src-jvm/doublearrays.scala

@@ -1239,6 +1239,52 @@ object doublearrays:
 
     // def max: Double =
     //   vec(blas.idamax(vec.length, vec, 1)) // No JS version
+
+    inline def `zeroWhere!`(
+        other: Array[Double],
+        threshold: Double,
+        inline op: ComparisonOp
+    ): Unit =
+      assert(vec.length == other.length)
+      val zero = DoubleVector.zero(spd)
+      val thresh = DoubleVector.broadcast(spd, threshold)
+      var i = 0
+
+      while i < spd.loopBound(vec.length) do
+        val values = DoubleVector.fromArray(spd, vec, i)
+        val cmp = DoubleVector.fromArray(spd, other, i)
+        val mask = inline op match
+          case ComparisonOp.LE => cmp.compare(VectorOperators.LE, thresh)
+          case ComparisonOp.LT => cmp.compare(VectorOperators.LT, thresh)
+          case ComparisonOp.GE => cmp.compare(VectorOperators.GE, thresh)
+          case ComparisonOp.GT => cmp.compare(VectorOperators.GT, thresh)
+          case ComparisonOp.EQ => cmp.compare(VectorOperators.EQ, thresh)
+          case ComparisonOp.NE => cmp.compare(VectorOperators.NE, thresh)
+        values.blend(zero, mask).intoArray(vec, i)
+        i += spdl
+      end while
+
+      while i < vec.length do
+        val hit = inline op match
+          case ComparisonOp.LE => other(i) <= threshold
+          case ComparisonOp.LT => other(i) < threshold
+          case ComparisonOp.GE => other(i) >= threshold
+          case ComparisonOp.GT => other(i) > threshold
+          case ComparisonOp.EQ => other(i) == threshold
+          case ComparisonOp.NE => other(i) != threshold
+        if hit then vec(i) = 0.0
+        end if
+        i += 1
+      end while
+    end `zeroWhere!`
+
+    inline def zeroWhere(
+        other: Array[Double],
+        threshold: Double,
+        inline op: ComparisonOp
+    ): Array[Double] =
+      vec.clone().tap(_.`zeroWhere!`(other, threshold, op))
+
   end extension
 
 end doublearrays

vecxt/src-jvm/floatarrays.scala

@@ -938,5 +938,50 @@ object floatarrays:
       Matrix(out, (n, m))(using BoundsCheck.DoBoundsCheck.no)
     end outer
 
+    inline def `zeroWhere!`(
+        other: Array[Float],
+        threshold: Float,
+        inline op: ComparisonOp
+    ): Unit =
+      assert(vec.length == other.length)
+      val zero = FloatVector.zero(spf)
+      val thresh = FloatVector.broadcast(spf, threshold)
+      var i = 0
+
+      while i < spf.loopBound(vec.length) do
+        val values = FloatVector.fromArray(spf, vec, i)
+        val cmp = FloatVector.fromArray(spf, other, i)
+        val mask = inline op match
+          case ComparisonOp.LE => cmp.compare(VectorOperators.LE, thresh)
+          case ComparisonOp.LT => cmp.compare(VectorOperators.LT, thresh)
+          case ComparisonOp.GE => cmp.compare(VectorOperators.GE, thresh)
+          case ComparisonOp.GT => cmp.compare(VectorOperators.GT, thresh)
+          case ComparisonOp.EQ => cmp.compare(VectorOperators.EQ, thresh)
+          case ComparisonOp.NE => cmp.compare(VectorOperators.NE, thresh)
+        values.blend(zero, mask).intoArray(vec, i)
+        i += spfl
+      end while
+
+      while i < vec.length do
+        val hit = inline op match
+          case ComparisonOp.LE => other(i) <= threshold
+          case ComparisonOp.LT => other(i) < threshold
+          case ComparisonOp.GE => other(i) >= threshold
+          case ComparisonOp.GT => other(i) > threshold
+          case ComparisonOp.EQ => other(i) == threshold
+          case ComparisonOp.NE => other(i) != threshold
+        if hit then vec(i) = 0.0f
+        end if
+        i += 1
+      end while
+    end `zeroWhere!`
+
+    inline def zeroWhere(
+        other: Array[Float],
+        threshold: Float,
+        inline op: ComparisonOp
+    ): Array[Float] =
+      vec.clone().tap(_.`zeroWhere!`(other, threshold, op))
+
   end extension
 end floatarrays

vecxt/src-native/doublearrays.scala

@@ -751,6 +751,35 @@ object doublearrays:
     end covariance
 
     // def max: Double = vec(blas.cblas_idamax(vec.length, vec.at(0), 1)) // No JS version
+
+    inline def `zeroWhere!`(
+        other: Array[Double],
+        threshold: Double,
+        inline op: ComparisonOp
+    ): Unit =
+      assert(vec.length == other.length)
+      var i = 0
+      while i < vec.length do
+        val hit = inline op match
+          case ComparisonOp.LE => other(i) <= threshold
+          case ComparisonOp.LT => other(i) < threshold
+          case ComparisonOp.GE => other(i) >= threshold
+          case ComparisonOp.GT => other(i) > threshold
+          case ComparisonOp.EQ => other(i) == threshold
+          case ComparisonOp.NE => other(i) != threshold
+        if hit then vec(i) = 0.0
+        end if
+        i += 1
+      end while
+    end `zeroWhere!`
+
+    inline def zeroWhere(
+        other: Array[Double],
+        threshold: Double,
+        inline op: ComparisonOp
+    ): Array[Double] =
+      vec.clone().tap(_.`zeroWhere!`(other, threshold, op))
+
   end extension
 
 end doublearrays

vecxt/src-native/floatarrays.scala

@@ -818,6 +818,34 @@ object floatarrays:
       (cv / (vec.length - 1)).toFloat
     end covariance
 
+    inline def `zeroWhere!`(
+        other: Array[Float],
+        threshold: Float,
+        inline op: ComparisonOp
+    ): Unit =
+      assert(vec.length == other.length)
+      var i = 0
+      while i < vec.length do
+        val hit = inline op match
+          case ComparisonOp.LE => other(i) <= threshold
+          case ComparisonOp.LT => other(i) < threshold
+          case ComparisonOp.GE => other(i) >= threshold
+          case ComparisonOp.GT => other(i) > threshold
+          case ComparisonOp.EQ => other(i) == threshold
+          case ComparisonOp.NE => other(i) != threshold
+        if hit then vec(i) = 0.0f
+        end if
+        i += 1
+      end while
+    end `zeroWhere!`
+
+    inline def zeroWhere(
+        other: Array[Float],
+        threshold: Float,
+        inline op: ComparisonOp
+    ): Array[Float] =
+      vec.clone().tap(_.`zeroWhere!`(other, threshold, op))
+
   end extension
 
   extension (vec: Array[Array[Double]])

vecxt/src/ComparisonOp.scala

@@ -0,0 +1,5 @@
+package vecxt
+
+enum ComparisonOp:
+  case LT, LE, GT, GE, EQ, NE
+end ComparisonOp

vecxt/src/all.scala

@@ -18,6 +18,7 @@ object all:
   export vecxt.IntArraysX.*
 
   export vecxt.VarianceMode
+  export vecxt.ComparisonOp
 
   // matricies
   export vecxt.OneAndZero.given_OneAndZero_Boolean