You can use NumPy broadcasting for pairwise elementwise multiplication between x and y and then flatten with .ravel(), like so -

(x[:,None]*y).ravel()

Or use outer product and then flatten -

np.outer(x,y).ravel()

You can use np.multiply to multiply element-wise with broadcasting:

A = np.array([[1,1,1],
              [1,1,1]])

B = np.array([2, 3])

res = np.multiply(A, B[:, None])

print(res)

array([[2, 2, 2],
       [3, 3, 3]])

When doing an element-wise operation between two arrays, which are not of the same dimensionality, NumPy will perform broadcasting. In your case Numpy will broadcast b along the rows of a:

import numpy as np
a = np.array([[1],
              [2]])
b = [3, 4]
print(a * b)

Gives:

[[3 4]
 [6 8]]

To prevent this, you need to make a and b of the same dimensionality. You can add dimensions to an array by using np.newaxis or None in your indexing, like this:

print(a * b[:, np.newaxis]) 

Gives:

[[3]
 [8]]

Use numpy broadcast.

Try this

from numpy.random import rand
a = rand(4,5)
b = rand(6)
c = a[...,None] * b
print (c.shape)

Or equivelently

c = a.reshape(4,5,1)*b

Broadcasting involves 2 steps

• give all arrays the same number of dimensions

• expand the 1 dimensions to match the other arrays

With your inputs

(41,6) (41,)

one is 2d, the other 1d; broadcasting can change the 1d to (1, 41), but it does not automatically expand in the other direction (41,1).

(41,6) (1,41) 

Neither (41,41) or (6,41) matches the other.

So you need to change your y to (41,1) or the x to (6,41)

x.T*y
x*y[:,None]

I'm assuming, of course, that you want element by element multiplication, not the np.dot matrix product.

Numpy broadcasts automatically, so you should be able to just do

a * b

Example:

In [1]: import numpy as np

In [2]: a = np.ones((20,37,2,121,240))

In [3]: b = np.ones(((121,240)))

In [4]: (a * b).shape
Out[4]: (20, 37, 2, 121, 240)

The * operator for numpy arrays is element wise multiplication (similar to the Hadamard product for arrays of the same dimension), not matrix multiply.

For example:

>>> a
array([[0],
       [1],
       [2]])
>>> b
array([0, 1, 2])
>>> a*b
array([[0, 0, 0],
       [0, 1, 2],
       [0, 2, 4]])

For matrix multiply with numpy arrays:

>>> a = np.ones((3,2))
>>> b = np.ones((2,4))
>>> np.dot(a,b)
array([[ 2.,  2.,  2.,  2.],
       [ 2.,  2.,  2.,  2.],
       [ 2.,  2.,  2.,  2.]])

In addition you can use the matrix class:

>>> a=np.matrix(np.ones((3,2)))
>>> b=np.matrix(np.ones((2,4)))
>>> a*b
matrix([[ 2.,  2.,  2.,  2.],
        [ 2.,  2.,  2.,  2.],
        [ 2.,  2.,  2.,  2.]])

More information on broadcasting numpy arrays can be found here, and more information on the matrix class can be found here.

Are you using arrays? If yes, you're in luck because the '*' is element by element multiplication and not matrix multiplication. Therefore:

import numpy as np

A = np.array([5, 4, 3, 2, 1])
B = np.array([[ 123.,    4.,    0.,    0.,    0.],
                    [   0.,    0.,    0.,   45.,    0.],
                    [   0.,    0.,  100.,   -5.,    0.]])

C = np.tile(A, (M, 1)) * B

D = A * B

And as result you get:

>>> C
array([[ 615.,   16.,    0.,    0.,    0.],
       [   0.,    0.,    0.,   90.,    0.],
       [   0.,    0.,  300.,  -10.,    0.]])
>>> D
array([[ 615.,   16.,    0.,    0.,    0.],
       [   0.,    0.,    0.,   90.,    0.],
       [   0.,    0.,  300.,  -10.,    0.]])

And if you're working with matrices, use multiply() to have element-wise multiplication (which is what you're trying to do)

https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html#array-or-matrix-which-should-i-use