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!"

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.