Hadamard product for real matrices

Author: stefan-zobel

pom.xml

@@ -4,7 +4,7 @@
     <groupId>net.sourceforge.streamsupport</groupId>
     <artifactId>jamu</artifactId>
     <packaging>jar</packaging>
-    <version>1.3.1-SNAPSHOT-1</version>
+    <version>1.3.1-SNAPSHOT-2</version>
     <name>JAMU</name>
     <description>Java Matrix Utilities built on top of Intel MKL</description>
     <url>https://github.com/stefan-zobel/JAMU/</url>
@@ -63,7 +63,7 @@
                             <goal>jar</goal>
                         </goals>
                         <configuration>
-                            <!--doclint>none</doclint-->
+                            <doclint>none</doclint>
                         </configuration>
                     </execution>
                 </executions>

src/main/java/net/jamu/matrix/MatrixD.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019, 2021 Stefan Zobel
+ * Copyright 2019, 2023 Stefan Zobel
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -603,6 +603,19 @@ public interface MatrixD extends Dimensions, MatrixDConduct {
      */
     MatrixD expm();
 
+    /**
+     * Hadamard product {@code C = A} ∘ {@code B} (also known as
+     * element-wise product) of this matrix (A) and B.
+     * 
+     * @param B
+     *            the matrix this matrix is multiplied with
+     * @param out
+     *            output matrix for the result of the multiplication
+     * @return {@code out}
+     * @since 1.3.1
+     */
+    MatrixD hadamard(MatrixD B, MatrixD out);
+
     /**
      * Copy into a jagged array.
      * 

src/main/java/net/jamu/matrix/MatrixDBase.java

@@ -535,6 +535,22 @@ public MatrixD expm() {
         return Expm.expmD(this, normMaxAbs());
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public MatrixD hadamard(MatrixD B, MatrixD out) {
+        Checks.checkEqualDimension(this, B);
+        Checks.checkEqualDimension(this, out);
+        double[] _a = a;
+        double[] _b = B.getArrayUnsafe();
+        double[] _c = out.getArrayUnsafe();
+        for (int i = 0; i < _a.length; ++i) {
+            _c[i] = _a[i] * _b[i];
+        }
+        return out;
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -859,6 +875,14 @@ public MatrixD transposedTimes(MatrixD B) {
         return transAmult(B, create(cols, B.numColumns()));
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public MatrixD hadamard(MatrixD B) {
+        return hadamard(B, create(rows, cols));
+    }
+
     /**
      * {@inheritDoc}
      */

src/main/java/net/jamu/matrix/MatrixDConduct.java

@@ -329,6 +329,17 @@ public interface MatrixDConduct {
      */
     MatrixD inverse();
 
+    /**
+     * Hadamard product {@code A} ∘ {@code B} (also known as
+     * element-wise product) of this matrix (A) and B.
+     * 
+     * @param B
+     *            the matrix this matrix is multiplied with
+     * @return the result of the Hadamard multiplication
+     * @since 1.3.1
+     */
+    MatrixD hadamard(MatrixD B);
+
     /**
      * Reshapes this matrix into a new matrix of dimension {@code rows x cols}
      * where the elements in this matrix are read in Fortran-style column-major

src/main/java/net/jamu/matrix/MatrixF.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019, 2021 Stefan Zobel
+ * Copyright 2019, 2023 Stefan Zobel
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -603,6 +603,19 @@ public interface MatrixF extends Dimensions, MatrixFConduct {
      */
     MatrixF expm();
 
+    /**
+     * Hadamard product {@code C = A} ∘ {@code B} (also known as
+     * element-wise product) of this matrix (A) and B.
+     * 
+     * @param B
+     *            the matrix this matrix is multiplied with
+     * @param out
+     *            output matrix for the result of the multiplication
+     * @return {@code out}
+     * @since 1.3.1
+     */
+    MatrixF hadamard(MatrixF B, MatrixF out);
+
     /**
      * Copy into a jagged array.
      * 

src/main/java/net/jamu/matrix/MatrixFBase.java

@@ -535,6 +535,22 @@ public MatrixF expm() {
         return Expm.expmF(this, normMaxAbs());
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public MatrixF hadamard(MatrixF B, MatrixF out) {
+        Checks.checkEqualDimension(this, B);
+        Checks.checkEqualDimension(this, out);
+        float[] _a = a;
+        float[] _b = B.getArrayUnsafe();
+        float[] _c = out.getArrayUnsafe();
+        for (int i = 0; i < _a.length; ++i) {
+            _c[i] = _a[i] * _b[i];
+        }
+        return out;
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -859,6 +875,14 @@ public MatrixF transposedTimes(MatrixF B) {
         return transAmult(B, create(cols, B.numColumns()));
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public MatrixF hadamard(MatrixF B) {
+        return hadamard(B, create(rows, cols));
+    }
+
     /**
      * {@inheritDoc}
      */

src/main/java/net/jamu/matrix/MatrixFConduct.java

@@ -329,6 +329,17 @@ public interface MatrixFConduct {
      */
     MatrixF inverse();
 
+    /**
+     * Hadamard product {@code A} ∘ {@code B} (also known as
+     * element-wise product) of this matrix (A) and B.
+     * 
+     * @param B
+     *            the matrix this matrix is multiplied with
+     * @return the result of the Hadamard multiplication
+     * @since 1.3.1
+     */
+    MatrixF hadamard(MatrixF B);
+
     /**
      * Reshapes this matrix into a new matrix of dimension {@code rows x cols}
      * where the elements in this matrix are read in Fortran-style column-major