I can reproduce your results on my machine with those options you write in your post. However, if I also enable link time optimization (I also pass the -flto flag to gcc 4.7.2), the results are identical: (I am compiling your original code, with container.push_back(Item());) $ g++ -std=c++11 -O3 -flto regr.cpp && perf stat -r … Read more
Using the following: g++ -O3 Time.cpp -I <MyBoost> ./a.out UseArray completed in 2.196 seconds UseVector completed in 4.412 seconds UseVectorPushBack completed in 8.017 seconds The whole thing completed in 14.626 seconds So array is twice as quick as vector. But after looking at the code in more detail this is expected; as you run across … Read more
Using C++ arrays with new (that is, using dynamic arrays) should be avoided. There is the problem you have to keep track of the size, and you need to delete them manually and do all sort of housekeeping. Using arrays on the stack is also discouraged because you don’t have range checking, and passing the … Read more
Simplest solution Use numpy.dot or a.dot(b). See the documentation here. >>> a = np.array([[ 5, 1 ,3], [ 1, 1 ,1], [ 1, 2 ,1]]) >>> b = np.array([1, 2, 3]) >>> print a.dot(b) array([16, 6, 8]) This occurs because numpy arrays are not matrices, and the standard operations *, +, -, / work element-wise … Read more
A one-liner splitting d into chunks of size 20: split(d, ceiling(seq_along(d)/20)) More details: I think all you need is seq_along(), split() and ceiling(): > d <- rpois(73,5) > d [1] 3 1 11 4 1 2 3 2 4 10 10 2 7 4 6 6 2 1 1 2 3 8 3 10 7 … Read more
vector: Contiguous memory. Pre-allocates space for future elements, so extra space required beyond what’s necessary for the elements themselves. Each element only requires the space for the element type itself (no extra pointers). Can re-allocate memory for the entire vector any time that you add an element. Insertions at the end are constant, amortized time, … Read more
How about std::remove() instead: #include <algorithm> … vec.erase(std::remove(vec.begin(), vec.end(), 8), vec.end()); This combination is also known as the erase-remove idiom.
Actually there are quite a few methods. int sum_of_elems = 0; C++03 Classic for loop: for(std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it) sum_of_elems += *it; Using a standard algorithm: #include <numeric> sum_of_elems = std::accumulate(vector.begin(), vector.end(), 0); Important Note: The last argument’s type is used not just for the initial value, but for the type … Read more
I agree with R. Pate and Todd Gardner; a std::set might be a good idea here. Even if you’re stuck using vectors, if you have enough duplicates, you might be better off creating a set to do the dirty work. Let’s compare three approaches: Just using vector, sort + unique sort( vec.begin(), vec.end() ); vec.erase( … Read more
I use the tail function: tail(vector, n=1) The nice thing with tail is that it works on dataframes too, unlike the x[length(x)] idiom.