Slow point product in R

I am trying to take a dot product from a 331x23152 and 23152x23152 matrix.

In Python and Octave this is a trivial operation, but in R it seems incredibly slow.

N <- 331
M <- 23152

mat_1 = matrix( rnorm(N*M,mean=0,sd=1), N, M) 
mat_2 = matrix( rnorm(N*M,mean=0,sd=1), M, M) 
tm3 <- system.time({
    mat_3 = mat_1%*%mat_2
})
print(tm3)

      

        
        
        
      

    

Output signal

user  system elapsed 
101.95    0.04  101.99 

      

        
        
        
      

    

In other words, this dot product takes over 100 seconds.

I am running R-3.4.0 64-bit, with RStudio v1.0.143 on an i7-4790 with 16GB of RAM. Thus, I did not expect this operation to take that long.

Am I missing something? I started looking into the bigmemory and bigalgebra packages, but I can't help but think that there is a solution without resorting to packages.

EDIT

To give you an idea of ​​the time difference, here's a script for Octave:

n = 331;
m = 23152;

mat_1 = rand(n,m);
mat_2 = rand(m,m);
tic
mat_3 = mat_1*mat_2;
toc

      

        
        
        
      

    

Output signal

Elapsed time is 3.81038 seconds.

      

        
        
        
      

    

And in Python:

import numpy as np
import time

n = 331
m = 23152

mat_1 = np.random.random((n,m))
mat_2 = np.random.random((m,m))
tm_1 = time.time()
mat_3 = np.dot(mat_1,mat_2)
tm_2 = time.time()
tm_3 = tm_2 - tm_1
print(tm_3)

      

        
        
        
      

    

Output signal

2.781277894973755

      

        
        
        
      

    

As you can see, these numbers are not in the same ball.

EDIT 2

In Zheyuan Li's request, here are examples of point product toys.

In R:

mat_1 = matrix(c(1,2,1,2,1,2), nrow = 2, ncol = 3)
mat_2 = matrix(c(1,1,1,2,2,2,3,3,3), nrow = 3, ncol = 3)
mat_3 = mat_1 %*% mat_2
print(mat_3)

      

        
        
        
      

    

Output:

     [,1] [,2] [,3]
[1,]    3    6    9
[2,]    6   12   18

      

        
        
        
      

    

In an octave:

mat_1 = [1,1,1;2,2,2];
mat_2 = [1,2,3;1,2,3;1,2,3];
mat_3 = mat_1*mat_2

      

        
        
        
      

    

Output:

mat_3 =

    3    6    9
    6   12   18

      

        
        
        
      

    

In Python:

import numpy as np

mat_1 = np.array([[1,1,1],[2,2,2]])
mat_2 = np.array([[1,2,3],[1,2,3],[1,2,3]])
mat_3 = np.dot(mat_1, mat_2)
print(mat_3)

      

        
        
        
      

    

Output:

[[ 3  6  9]
 [ 6 12 18]]

      

        
        
        
      

    

For more information on matrix dot products: https://en.wikipedia.org/wiki/Matrix_multiplication

EDIT 3

Output for sessionInfo()

:

> sessionInfo()
R version 3.4.0 (2017-04-21)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 7 x64 (build 7601) Service Pack 1

Matrix products: default

locale:
[1] LC_COLLATE=Dutch_Netherlands.1252  LC_CTYPE=Dutch_Netherlands.1252    LC_MONETARY=Dutch_Netherlands.1252
[4] LC_NUMERIC=C                       LC_TIME=Dutch_Netherlands.1252    

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

loaded via a namespace (and not attached):
[1] compiler_3.4.0 tools_3.4.0 

      

        
        
        
      

    

EDIT 4

I tried the package bigalgebra

but that didn't seem to speed up:

library('bigalgebra')

N <- 331
M <- 23152

mat_1 = matrix( rnorm(N*M,mean=0,sd=1), N, M)
mat_1 <- as.big.matrix(mat_1)
mat_2 = matrix( rnorm(N*M,mean=0,sd=1), M, M)
tm3 <- system.time({
    mat_3 = mat_1%*%mat_2
})
print(tm3)

      

        
        
        
      

    

Output:

   user  system elapsed 
 101.79    0.00  101.81

      

        
        
        
      

    

EDIT 5

N <- 331
M <- 23152

mat_1 = matrix( runif(N*M), N, M)
mat_2 = matrix( runif(M*M), M, M)
tm3 <- system.time({
    mat_3 = mat_1%*%mat_2
})
print(tm3)

      

        
        
        
      

    

Output:

   user  system elapsed 
 102.46    0.05  103.00