Python vs C++ Performance

Just for curiosity, I wanted to see how fast is C++ compared with regular Python and Python using the numpy library. Below the results:

A bit of Python code with regular python, same loop using numpy, and numpy vectorial (like in MatLab):

'''
Created on Nov 19, 2012

@author: leal
'''

import numpy as np
from datetime import datetime

nSpectra = 12 * 32 * 256
nBinsTotal = nSpectra * 512;
    
def testSpectraIN5():    
    total = []
    for i in range(nBinsTotal):
        res = 500 * 500 + i
        total.append(res)
    
def testSpectraIN5np():
    total = np.empty(nBinsTotal, dtype=float)
    for i in range(nBinsTotal):
        res = 500 * 500 + i
        total[i]=res
        
def testSpectraIN5npOpt():
    # res = [0..nBinsTotal-1]
    res = np.arange(nBinsTotal, dtype=float)
    total = 500 * 500 + res  
    


if __name__ == '__main__':
    print "Main has started!"
    print "* testSpectraIN5"
    t_start = datetime.now()
    testSpectraIN5()
    t_end = datetime.now()
    t_total = t_end - t_start
    print "Total time: ", t_total, " seconds"
    print "* testSpectraIN5np"
    t_start = datetime.now()
    testSpectraIN5np()
    t_end = datetime.now()
    t_total = t_end - t_start
    print "Total time: ", t_total, " seconds"
    print "* testSpectraIN5npOpt"
    t_start = datetime.now()
    testSpectraIN5npOpt()
    t_end = datetime.now()
    t_total = t_end - t_start
    print "Total time: ", t_total, " seconds"
    print "Main has finished!"

Python v 2.7.3 results:

Main has started!
* testSpectraIN5
Total time:  0:00:12.781883  seconds
* testSpectraIN5np
Total time:  0:00:09.553932  seconds
* testSpectraIN5npOpt
Total time:  0:00:00.823714  seconds
Main has finished!

For C++, I just did two cycles, one without initialising the vector with its size, and other one with it. Code is below:

// constructing vectors
#include <iostream>
#include <vector>
#include <valarray>

// C++11
#include <chrono>
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::milliseconds milliseconds;

int main() {

    std::cout << "Main has started!" << std::endl;

    Clock::time_point t0 = Clock::now();

    int nSpectra = 12 * 32 * 256;
    int nBinsTotal = nSpectra * 512;

    std::vector<double> total; //(nBinsTotal);

    for (int i = 0; i < nBinsTotal; i++) {
        double res = 500 * 500 + i;
        total.push_back(res);
    }

    Clock::time_point t1 = Clock::now();
    milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);

    std::cout.precision(2);
    std::cout << "Total time: " << std::fixed << ms.count() * 1e-3 << " seconds"<< std::endl;

    std::cout << "Vector with known size:"<< std::endl;
    t0 = Clock::now();
    std::vector<double> total2(nBinsTotal);

    for (int i = 0; i < nBinsTotal; i++) {
        double res = 500 * 500 + i;
        total2[i] = res;
    }

    t1 = Clock::now();
    ms = std::chrono::duration_cast<milliseconds>(t1 - t0);

    std::cout.precision(2);
    std::cout << "Total time: " << std::fixed << ms.count() * 1e-3 << " seconds"<< std::endl;


    std::cout << "Main has finished!" << std::endl;
    return 0;
}

The result is:

Main has started!
Total time: 1.70 seconds
Vector with known size:
Total time: 0.74 seconds
Main has finished!

It's interesting to see how the programming approach changes the results!
Surprisingly, Python, using a vectorial numpy approach, can be as fast as C++. It's not a surprise however, that an initlised array in C++ can be twice faster!

EDIT:

What about java???
So I tried first with ArrayList and Vector but they were so slow (more than 30 seconds), that I didn't even dare to add them below... I came up with this code, but doesn't really compare to what I did in C++.

import java.util.Vector;

public class VectorTest {

    public static void main(String[] args) {

        int nSpectra = 12 * 32 * 256;
        int nBinsTotal = nSpectra * 512;

        double[] total2 = new double[nBinsTotal];
        
        long startTime = System.nanoTime();

        // <E> Element type of Vector e.g. String, Integer, Object ...
        for (int i = 0; i < nBinsTotal; i++) {
            double res = 500 * 500 + i;
            total2[i] = res;
        }
        long endTime = System.nanoTime();

        long duration = endTime - startTime;

        System.out.println("Total time: " + duration * 1e-9);

    }
}

Start calculation with arrays and initilisation.
Total time: 0.073217508

Using regular arrays, Java can be as fast as C++ Vectors with predefined length.