Scipy Lecture Notes – Learn numerics, science, and data with Python

By default, numpy.ndarray multiply element-wise. There is a separate type called numpy.matrix which does matrix math. Alternatively, as of Python 3.5, `a @ b` will do matrix multiplication on NDArrays.

The first is just a misunderstanding of the `*` operator. I don't believe there is any context for which this would yield anything other than the element-wise product between `x` and `y` (provided these are `ndarray`s).

The second, (the matrix product between `x` and `y`) works provided that the dimensions of `x` and `y` make sense to perform matrix multiplication, i.e., `x` is 1xN and `y` is Nx1.

While I agree there are some idiosyncrasies, I think it is hyperbole to call it a disaster. I will say that one idiosyncrasy that annoyed me up when moving from octave / matlab, was that NumPy's `zeros` and `ones` functions require the dimensions as a tuple, while others, like `rand` or `randn` take multiple arguments as the dimensions.

Does x.T.dot(y) work?

It's not historical. It's conceptual and deliberate (and far less confusing than the alternative, i.m.o.).

What's likely happening is that you're using a 1D array and a 2D array. If they were both actually vectors, `x.dot(y)` would work fine.

For example:

    import numpy as np
    x = y = np.arange(10)
    x.dot(y) # Yields 285

However, your problem is likely that one's a vector and one's a 2D array. Matlab doesn't actually have vectors at all, so this distinction confuses a lot of people. A row vector and a column vector are both 2D and aren't actually vectors at all. You can transpose them and swap the dimensions. When you transpose a vector in numpy, you still get a 1D vector. Transposing doesn't change the number of dimensions (To me it would be _incredibly_ confusing if it did...).

So, in your case, you probably had something like:

    import numpy as np
    x = np.arange(10)
    y = x[np.newaxis, :]
    x.dot(y) # Raises a ValueError

Note that the opposite (`y.dot(x)`) would have worked fine in this case, as well as `np.inner`.

`np.dot` uses the last dimension of the first array (10) and the second-to-last dimension of the other array (1). They don't match. It's that simple.

You might have also been trying to take the dot product of two 2D arrays with the same dimension. In that case, the same thing happens. The last dimension of one doesn't match the second-to-last dimension of the other.

If you're coming from a MATLAB background, you might find this helpful [0].

When I switched from MATLAB to Python/numpy/scipy, I had to deal with these syntactic annoyances. But now I feel comfortable after using it for many years.

Don't forget the biggest edge Python has over MATLAB for numeric simulation, i.e., you can prototype your work as quickly, and for the same program, convert the slow portions into C or Fortran without the need to rewrite the whole thing. Not to mention, a proper programming language underlying the numeric system.

[0] https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-u...

Is Python 2 going to be kept alive forever and ever? Is there any other language on the planet that keeps a previous version supported years after a major release came out?