Hadamard product without using a library?

For the non mathematicians like me, here’s the wikipedia definition

In mathematics, the Hadamard product (also known as the element-wise product , entrywise product [1]: ch. 5 or Schur product [2]) is a binary operation that takes two matrices of the same dimensions and produces another matrix of the same dimension as the operands, where each element i, j is the product of elements i, j of the original two matrices.

I’d start with how to represent the input matrices and make sure they have equal dimensions ..

That’s a one-liner comprehension

Enum.zip_with(a, b, &*/2), but this will work only on 1D lists.

a very long and indecipherable one I fear (but I have issues with comprehensions’ comprehension)

I was joking of course But was pointing towards some sort of multiplying two 1D lists

yup! I just had a kind of Lovecraftian vision for that multi-dimensional one-liner ..

What is the data structure for your matrices?

Thank you for asking.
Here are some test cases:

Test.test([1, 2], [3, 4]) => [3, 8]
Test.test([[1, [[2]]]], [[3, [[4]]]]) => [[3, [[8]]]]
Test.text([[1, 2]], [3, 4]) => raise custom error

I don’t know much about math but it looks like your matrices can have any level of “nesting”, and are “irregular” (some are row>col>sub, other cols are just numbers, some rows are numbers without cols) but your valid cases always imply that the two matrices have the same shape, they are symmetrical.

So the answer would be a function that when given two lists, will recursively call itself with each pair of items, and when given two numbers, return the product.

Here is my proposal but before reading it, try to find a solution yourself, it is actually straightforward.

defmodule H do
  def hadamard(a, b) when is_integer(a) and is_integer(b), do: a * b
  def hadamard([a | tail_a], [b | tail_b]), do: [hadamard(a, b) | hadamard(tail_a, tail_b)]
  def hadamard([], []), do: []
  def hadamard(_, _), do: raise ArgumentError, "or a custom error"
end


a = H.hadamard([1, 2], [3, 4])
IO.inspect(a, label: "a")

b = H.hadamard([[1, [[2]]]], [[3, [[4]]]])
IO.inspect(b, label: "b", charlists: :as_lists)

_ = H.hadamard([[1, 2]], [3, 4])

I would suggest using functions. A 2D matrix is a function of two arguments.

You could define the Hadamard product of A, B as:

H(i, j) = A(i, j) * B(i, j)

That is readable. Representing matrices as arrays is done for efficiency of computation. If you need efficiency then use the Nx library.

A product is a binary operation. Therefore, it corresponds to a function of two arguments.

You could also define the Hadamard product as a higher-order function that returns an anonymous function of the indexes:

H(A, B)(i,j) = A(i, j) * B(i, j)