devector | Resizable contiguous sequence container with fast appends | Genomics library

So first let me comment how I would write your function if I wanted to use a loop:

Caused by: java.lang.ClassCastException: android.support.v7.widget.GridLayout cannot be cast to android.widget.GridLayout at devector.dom.gridtest.MainActivity.onCreate(MainActivity.java:21)

=> From this line, it's clear that you must be importing and referring to android.widget.GridLayout where as you have taken android.support.v7.widget.GridLayout in XML layout. Use and refer either of any in both layout and class file.

I don't think that what you ask for exists (please proof me wrong if I'm mistaken!).

The best you can do is use @code_lowered, @code_typed, @code_llvm, @code_native macros (in particular @code_lowered) to see what happens to your Julia code snippet. However, as Julia isn't translating all dots to explicit for loops internally, non of these snippets will show you a for-loop version of your code.

Example:

"Vectorization" in R, is a vector processing in R's interpreter's view. Take the function cumsum as an example. On entry, R interpreter sees that a vector x is passed into this function. However, the work is then passed to C language that R interpreter can not analyze / track. While C is doing work, R is just waiting. By the time that R's interpreter comes back to work, a vector has been processed. So in R's view, it has issued a single instruction but processed a vector. This is an analogy to the concept of SIMD - "single instruction, multiple data".

Not just the cumsum function that takes a vector and returns a vector is seen as "vectorization" in R, functions like sum that takes a vector and returns a scalar is also a "vectorization".

Simply put: whenever R calls some compiled code for a loop, it is a "vectorization". If you wonder why this kind of "vectorization" is useful, it is because a loop written by a compiled language is faster than a loop written in an interpreted language. The C loop is translated to machine language that a CPU can understand. However, if a CPU wants to execute an R loop, it needs R's interpreter's help to read it, iteration by iteration. This is like, if you know Chinese (the hardest human language), you can respond to someone speaking Chinese to you faster; otherwise, you need a translator to first translator Chinese to you sentence after sentence in English, then you respond in English, and the translator make it back to Chinese sentence by sentence. The effectiveness of communication is largely reduced.

Firstly, I don't think the performance here is very odd, since you're adding a lot of work to your function.

Secondly, you should actually return x here, otherwise the compiler might decide that you're not using x, and just skip the whole computation, which would thoroughly confuse the timings.

Thirdly, to answer your question 1: You can implement it like this:

If add_vecs seems to be the critical function, writing an explicit for loop could offer more optimization. How does the following benchmark:

This is a curious case. There seems to be a performance problem when accumulating Int8s in an Int64 variable.

Let's try these functions: