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.

## No comments:

## Post a Comment