)
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
1 22.250 22.250 22.250 22.250 {method 'dot' of 'numpy.ndarray' objects}
```
```julia
julia> n = 10000;
julia> x = rand(n,n);
julia> y = rand(n,n);
julia> x .* y;
julia> @time x .* y;
0.365343 seconds (30 allocations: 762.941 MiB, 10.40% gc time)
julia> @time x * y;
23.990639 seconds (6 allocations: 762.940 MiB, 0.12% gc time)
```
EDIT: I committed crimes by not doing a proper benchmark and by timing in the top-level. But, in this case it doesn’t make much difference.
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [May 19, 2018, 7:14pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/9 "2018-05-19T19:14:07Z")
Are you still comparing elementwise multiplication in Python with matrix multiplication in Julia? Because a 10x increase in `n` is expected to be a 100x slowdown in elementwise multiply, which matches the time you’re reporting for NumPy—about 0.6 seconds. Matrix multiply is super-linear in the size of the matrix, so you would expect a much bigger slowdown for that, which is exactly what you’re seeing in Julia.
---
### Author:  [@davidbp](https://discourse.julialang.org/u/davidbp)
#### Post date: [May 19, 2018, 7:47pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/10 "2018-05-19T19:47:31Z")
> [@lucagessi](#):
>
> ```julia
> @time a*a;
>
> ```
That is indeed elementwise product in Python.
Matrix multiply in python should be ` a @ a` or `np.matmul(a,a)`.
---
### Author:  [@lucagessi](https://discourse.julialang.org/u/lucagessi)
#### Post date: [May 19, 2018, 8:45pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/11 "2018-05-19T20:45:00Z")
Are you sure a\*a is element wise?
From documentation:
[https://docs.julialang.org/en/release-0.6/stdlib/linalg/](https://docs.julialang.org/en/release-0.6/stdlib/linalg/)
---
### Author:  [@lucagessi](https://discourse.julialang.org/u/lucagessi)
#### Post date: [May 19, 2018, 8:48pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/12 "2018-05-19T20:48:03Z")
I want to understand why is so slow. At the moment I haven’t a precise application
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [May 19, 2018, 8:48pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/13 "2018-05-19T20:48:52Z")
No, `a*a` is matrix multiply in Julia but it’s elementwise multiply in Python, which is what you’re timing: `cProfile.run("x*y")`. That is why Python is faster and scales linearly with the size of the matrix.
---
### Author:  [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)
#### Post date: [May 19, 2018, 8:51pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/14 "2018-05-19T20:51:37Z")
Python elementwise.
Julia matrix multiplication.
---
### Author:  [@lucagessi](https://discourse.julialang.org/u/lucagessi)
#### Post date: [May 19, 2018, 8:54pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/15 "2018-05-19T20:54:07Z")
Are you sure?
I tried:
```julia
import numpy as np
x=np.matrix('1 2 3');
y=np.matrix('1;2;3');
x*y
```
And it results 14.
I think is matrix multiplication.
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [May 19, 2018, 9:02pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/16 "2018-05-19T21:02:15Z")
That’s a different type than `numpy.random.random` gives you and they do not behave the same way when you operate on them with `*`:
```python
>>> type(numpy.random.random((3,3)))
>>> a = numpy.ones((3, 3))
>>> type(a)
>>> a * a
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
>>> a.dot(a)
array([[3., 3., 3.],
[3., 3., 3.],
[3., 3., 3.]])
>>> m = numpy.matrix(a)
>>> type(m)
>>> m * m
matrix([[3., 3., 3.],
[3., 3., 3.],
[3., 3., 3.]])
>>> m.dot(m)
matrix([[3., 3., 3.],
[3., 3., 3.],
[3., 3., 3.]])
```
If you find it immensely confusing that `*` does completely different and incompatible things in Python/NumPy for subtly different array types, I can sympathize.
---
### Author:  [@lucagessi](https://discourse.julialang.org/u/lucagessi)
#### Post date: [May 19, 2018, 9:12pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/17 "2018-05-19T21:12:33Z")
Ok. I understand now 😃
Thank you a lot.
So I’ll wait for version 1 of Julia while using 0.6 😛
Good work!
---
### Author:  [@Seif\_Shebl](https://discourse.julialang.org/u/Seif_Shebl)
#### Post date: [May 19, 2018, 9:28pm UTC](https://discourse.julialang.org/t/slow-matrix-multiplication-in-julia-compared-to-python-numpy/11015/18 "2018-05-19T21:28:19Z")
The fastest Python on the planet (Intel Python):
```julia
import numpy as np
import cProfile
import time
n = 10000;
x = np.random.random((n,n))
y = np.random.random((n,n))
t0 = time.clock()
z = np.matrix(x) * np.matrix(y)
t1 = time.clock()
total = t1-t0
print("Total (sec) =", total)
```
Which times:
```julia
Total (sec) = 10.513941910715321
[Finished in 12.4s]
```
And Julia (Julia Pro 0.6.0 for fair comparison):
```julia
julia> x = rand(10000,10000);
julia> y = rand(10000,10000);
julia> @time x*y;
9.327905 seconds (6 allocations: 762.940 MiB, 0.12% gc time)
```
Hope the comparison is clear now! Happy Julia-ing, BTW.