import numpy as np                                                               
from time import time                                                            
import sysconfig                                                                 
import psutil                                                                    
import re                                                                        

mkl = True                                                                                  
# Print numpy see whether mkl/blas is available                                  
np.show_config()                                                                 
print("python compile flags")                                                    
print(sysconfig.get_config_var('CFLAGS'))                                        
                                                                                 
re_cpu = re.compile("^model name        : (.*)")                                 
with open('/proc/cpuinfo') as f:                                                 
    for line in f:                                                               
        model = re_cpu.match(line)                                               
        if model:                                                                
            print(model.group(1))                                                
            break                                                                
                                                                                 
print("mkl: %s" % mkl)                                                           
print("physical cores: %s" % psutil.cpu_count())                                 
print("logical cores: %s" % psutil.cpu_count(logical=True))                      
print("cpu min freq: %s" % psutil.cpu_freq().min)                                
print("cpu current freq: %s" % psutil.cpu_freq().current)                        
print("cpu max freq: %s" % psutil.cpu_freq().max)                                
print("load average: %s %s %s" % psutil.getloadavg())                            
print("Total memory: %s GB" % round(psutil.virtual_memory().total/1000000000, 2))                                                                                
print("Available memory: %s GB" % round(psutil.virtual_memory().available/1000000000, 2))                                                                        

np.random.seed(0)                                                                
                                                                                 
size = 4096                                                                      
A, B = np.random.random((size, size)), np.random.random((size, size))            
C, D = np.random.random((size * 128,)), np.random.random((size * 128,))          
E = np.random.random((int(size / 2), int(size / 4)))                             
F = np.random.random((int(size / 2), int(size / 2)))                             
F = np.dot(F, F.T)                                                               
G = np.random.random((int(size / 2), int(size / 2)))                             
                                                                                 
# Matrix multiplication                                                          
N = 10                                                                           
t = time()                                                                       
for i in range(N):                                                               
    np.dot(A, B)                                                                 
delta = time() - t                                                               
print('Dotted two %dx%d matrices in %0.2f s.' % (size, size, delta / N))         
del A, B                                                                         
# Vector multiplication                                                          
N = 10                                                                           
t = time()                                                                       
for i in range(N):                                                               
    np.dot(C, D)                                                                 
delta = time() - t                                                               
print('Dotted two vectors of length %d in %0.2f ms.' % (size * 128, 1e3 * delta / N))                                                                            
del C, D                                                                         
                                                                                 
# Singular Value Decomposition (SVD)                                             
N = 3                                                                            
t = time()                                                                       
for i in range(N):                                                               
    np.linalg.svd(E, full_matrices = False)                                      
delta = time() - t                                                               
print("SVD of a %dx%d matrix in %0.2f s." % (size / 2, size / 4, delta / N))     
del E

# Cholesky Decomposition                                                         
N = 3                                                                            
t = time()                                                                       
for i in range(N):                                                               
    np.linalg.cholesky(F)                                                        
delta = time() - t                                                               
print("Cholesky decomposition of a %dx%d matrix in %0.2f s." % (size / 2, size /\
 2, delta / N))

"""tests continue, but segfault on i9-10900K, numpy 1.26 at "Cholesky Decomposition""""