Support row-major deepCopy and use array *= for hadamard

Co-authored-by: Quafadas <24899792+Quafadas@users.noreply.github.com>

Author: Copilot

vecxt/src-js/array_native.scala

@@ -456,6 +456,17 @@ object JsNativeDoubleArrays:
       res
     end *
 
+    inline def *=(d: NArray[Double])(using inline boundsCheck: BoundsCheck): Unit =
+      dimCheck(vec, d)
+      val n = vec.length
+
+      var i = 0
+      while i < n do
+        vec(i) = vec(i) * d(i)
+        i += 1
+      end while
+    end *=
+
     inline def outer(other: NArray[Double])(using ClassTag[Double]): Matrix[Double] =
       val n = vec.length
       val m = other.length

vecxt/src-jvm/arrays.scala

@@ -1176,6 +1176,23 @@ object arrays:
       out
     end *
 
+    inline def *=(d: Array[Double])(using inline boundsCheck: BoundsCheck): Unit =
+      dimCheck(vec, d)
+      var i = 0
+      while i < spd.loopBound(vec.length) do
+        DoubleVector
+          .fromArray(spd, vec, i)
+          .mul(DoubleVector.fromArray(spd, d, i))
+          .intoArray(vec, i)
+        i += spdl
+      end while
+
+      while i < vec.length do
+        vec(i) = vec(i) * d(i)
+        i = i + 1
+      end while
+    end *=
+
     inline def /(d: Array[Double])(using inline boundsCheck: BoundsCheck): Array[Double] =
       dimCheck(vec, d)
       val out = new Array[Double](vec.length)

vecxt/src-native/array_js_native.scala

@@ -456,6 +456,17 @@ object JsNativeDoubleArrays:
       res
     end *
 
+    inline def *=(d: NArray[Double])(using inline boundsCheck: BoundsCheck): Unit =
+      dimCheck(vec, d)
+      val n = vec.length
+
+      var i = 0
+      while i < n do
+        vec(i) = vec(i) * d(i)
+        i += 1
+      end while
+    end *=
+
     inline def outer(other: NArray[Double])(using ClassTag[Double]): Matrix[Double] =
       val n = vec.length
       val m = other.length

vecxt/src/MatrixInstance.scala

@@ -127,10 +127,23 @@ object MatrixInstance:
       * @return
       */
     def deepCopy(using ct: ClassTag[A]): Matrix[A] =
+      deepCopy(asRowMajor = false)
+    end deepCopy
+
+    /** Returns a deep copy of the matrix with specified layout. Copies elements one by one.
+      *
+      * @param asRowMajor
+      *   If true, returns row-major layout; if false, returns column-major layout
+      * @param ct
+      * @return
+      */
+    def deepCopy(asRowMajor: Boolean)(using ct: ClassTag[A]): Matrix[A] =
       // println(s"Deep copying matrix with shape ${m.shape} and offset ${m.offset}")
       import BoundsCheck.DoBoundsCheck.no
       val newRaw = NArray.ofSize[A](m.numel)
-      val newMat = Matrix(newRaw, m.rows, m.cols, 1, m.rows, 0)
+      val newMat =
+        if asRowMajor then Matrix(newRaw, m.rows, m.cols, m.cols, 1, 0) // row-major: rowStride = cols, colStride = 1
+        else Matrix(newRaw, m.rows, m.cols, 1, m.rows, 0) // column-major: rowStride = 1, colStride = rows
       var i = 0
       for row <- 0 until m.rows do
         for col <- 0 until m.cols do

vecxt/src/doublematrix.scala

@@ -146,44 +146,31 @@ object DoubleMatrix:
         val newArr = vecxt.arrays.*(m.raw)(m2.raw)
         Matrix[Double](newArr, m.rows, m.cols, m.rowStride, m.colStride, m.offset)(using BoundsCheck.DoBoundsCheck.no)
       else
-        // Different memory layouts: materialize only one matrix and multiply in-place
-        // Choose which matrix to materialize based on which is already dense column-major
+        // Different memory layouts: materialize one matrix to match the other's layout
         if m.isDenseColMajor then
-          // m is already dense, materialize m2 and multiply in-place
-          val m2Dense = m2.deepCopy
-          // Multiply m2Dense in-place with m
-          var idx = 0
-          var j = 0
-          while j < m.cols do
-            var i = 0
-            while i < m.rows do
-              m2Dense.raw(idx) = m2Dense.raw(idx) * m(i, j)
-              i += 1
-              idx += 1
-            end while
-            j += 1
-          end while
+          // m is dense column-major, materialize m2 to column-major and multiply in-place
+          val m2Dense = m2.deepCopy(asRowMajor = false)
+          vecxt.arrays.*=(m2Dense.raw)(m.raw)
+          m2Dense
+        else if m.isDenseRowMajor then
+          // m is dense row-major, materialize m2 to row-major and multiply in-place
+          val m2Dense = m2.deepCopy(asRowMajor = true)
+          vecxt.arrays.*=(m2Dense.raw)(m.raw)
           m2Dense
         else if m2.isDenseColMajor then
-          // m2 is already dense, materialize m and multiply in-place
-          val mDense = m.deepCopy
-          // Multiply mDense in-place with m2
-          var idx = 0
-          var j = 0
-          while j < m.cols do
-            var i = 0
-            while i < m.rows do
-              mDense.raw(idx) = mDense.raw(idx) * m2(i, j)
-              i += 1
-              idx += 1
-            end while
-            j += 1
-          end while
+          // m2 is dense column-major, materialize m to column-major and multiply in-place
+          val mDense = m.deepCopy(asRowMajor = false)
+          vecxt.arrays.*=(mDense.raw)(m2.raw)
+          mDense
+        else if m2.isDenseRowMajor then
+          // m2 is dense row-major, materialize m to row-major and multiply in-place
+          val mDense = m.deepCopy(asRowMajor = true)
+          vecxt.arrays.*=(mDense.raw)(m2.raw)
           mDense
         else
-          // Neither is dense column-major, materialize m and use SIMD multiplication
-          val mDense = m.deepCopy
-          val m2Dense = m2.deepCopy
+          // Neither is dense, materialize both to column-major and use SIMD multiplication
+          val mDense = m.deepCopy(asRowMajor = false)
+          val m2Dense = m2.deepCopy(asRowMajor = false)
           val newArr = vecxt.arrays.*(mDense.raw)(m2Dense.raw)
           Matrix[Double](newArr, m.rows, m.cols)(using BoundsCheck.DoBoundsCheck.no)
         end if