It&#39;s quite annoying to test all my strings for `null` before I can safely apply methods like `ToUpper()`, `StartWith()` etc...

If the default value of `string` were the empty string, I would not have to test, and I would feel it to be more consistent with the other value types like `int` or `double` for example.
Additionally `Nullable&lt;String&gt;` would make sense.

So why did the designers of C# choose to use `null` as the default value of strings?

Note: This relates to [this question][1], but is more focused on the why instead of what to do with it.


  [1]: https://stackoverflow.com/questions/265875/default-string-initialization-null-or-empty

Why is the default value of the string type null instead of an empty string?

I have been using Knitr via R-Studio, and think it is pretty neat. I have a minor issue though. When I source a file in an R-Chunk, the knitr output includes external comments as follows: 


    + FALSE Loading required package: ggplot2
    + FALSE Loading required package: gridExtra
    + FALSE Loading required package: grid
    + FALSE Loading required package: VGAM
    + FALSE Loading required package: splines
    + FALSE Loading required package: stats4
    + FALSE Attaching package: &#39;VGAM&#39;
    + FALSE The following object(s) are masked from &#39;package:stats4&#39;:

I have tried to set R-chunk options in various ways but still didn&#39;t seem to avoid the problem: 

    ```{r echo=FALSE, cache=FALSE, results=FALSE, warning=FALSE, comment=FALSE, warning=FALSE} 
    source(&quot;C:/Rscripts/source.R&quot;);
    
    ```

Is there any way to comment out these messages?



R - Markdown avoiding package loading messages

&gt; **Possible Duplicate:**  
&gt; [JavaScript - Are loops really faster in reverse…?](https://stackoverflow.com/questions/1340589/javascript-are-loops-really-faster-in-reverse)  

&lt;!-- End of automatically inserted text --&gt;

I don&#39;t know if this question is valid in other languages or not, but I&#39;m asking this specifically for `JavaScript`.

I see in some articles and questions that the fastest loop in JavaScript is something like:

    for(var i = array.length; i--; )

Also in Sublime Text 2, when you try to write a loop, it suggests:

    for (var i = Things.length - 1; i &gt;= 0; i--) {
    	Things[i]
    };

I want to know, why is `i--` faster than `i++` in loops?

Why is i-- faster than i++ in loops?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/1340589/javascript-are-loops-really-faster-in-reverse" target="_blank" rel="noopener noreferrer">JavaScript - Are loops really faster in reverse…?</a>

I don't know if this question is valid in other languages or not, but I'm asking this specifically for <code>JavaScript</code>.
I see in some articles and questions that the fastest loop in JavaScript is something like:
<pre><code class="hljs language-css">for(var i = array.length; i--; )
</code></pre>
Also in Sublime Text 2, when you try to write a loop, it suggests:
<pre><code class="hljs language-css">for (var i = Things.length - 1; i >= 0; i--) {
	Things[i]
};
</code></pre>
I want to know, why is <code>i--</code> faster than <code>i++</code> in loops?

&gt; **Possible Duplicate:**  
&gt; [Usage of toString in JavaScript](https://stackoverflow.com/questions/6853865/usage-of-tostring-in-javascript)  

&lt;!-- End of automatically inserted text --&gt;

    152..toString(2)

correctly creates the binary string &quot;10011000&quot;, but

    152.toString(2)

throws an exception

&gt; &quot;SyntaxError: identifier starts immediately after numeric literal&quot;

Why? The latter syntax actually sounds more correct while the former looks very odd!


Why does 10..toString() work, but 10.toString() does not?

I only know one js library and that is [jQuery](http://jquery.com/).  
But my other coders in the group are changing [AngularJS](http://angularjs.org/) as their default library in new project.

I don&#39;t know anything about it. How is it different from jQuery?  
I already have a set of functions done for similar tasks in jQuery. Can I still use jQuery stuff with AngularJS?

How is AngularJS different from jQuery

I am setting a cookie with JavaScript and it is working fine but it is not taking the expire time I am giving. It keeps on taking session value regardless of what I give, below is the code which I took from [here][1]

    var now = new Date();
	var time = now.getTime();
	var expireTime = time + 1000*60;
	now.setTime(expireTime);
	var tempExp = &#39;Wed, 31 Oct 2012 08:50:17 GMT&#39;;
	document.cookie = aaa+&#39;=&#39;+sStr+&#39;;expires=&#39;+now.toGMTString()+&#39;;path=/&#39;;

I tried giving hard-coded value but still it is showing expire as session in chrome dev tool

    var tempExp = &#39;Wed, 31 Oct 2012 08:50:17 GMT&#39;;
    document.cookie = aaa+&#39;=&#39;+sStr+&#39;;expires=&#39;+tempExp+&#39;;path=/&#39;;


Any idea what I am doing wrong?

  [1]: https://stackoverflow.com/questions/3794989/how-to-set-a-cookie-to-expire-in-1-hour-in-javascript

How can I set a cookie with expire time?

How do I set a data attribute without adding a value in jQuery? I want this:

    &lt;body data-body&gt;

I tried:

    $(&#39;body&#39;).attr(&#39;data-body&#39;); // this is a getter, not working
    $(&#39;body&#39;).attr(&#39;data-body&#39;, null); // not adding anything

Everything else seems to add the second arguments as a string. Is it possible to just set an attribute without value?



Set attribute without value

Is there a way of debugging the angularjs application when it is loaded in the browser?

ie. I wish to get the `$rootScope` of my current application. How would I do that?

how to debug the $rootScope object of angularjs in the browser

I have a list of length 130,000 where each element is a character vector of length 110. I would like to convert this list to a matrix with dimension 1,430,000*10. How can I do it more efficiently?\
My code is :
 
    output=NULL
    for(i in 1:length(z)) {
     output=rbind(output,
                  matrix(z[[i]],ncol=10,byrow=TRUE))
    }



How to convert a huge list-of-vector to a matrix more efficiently?

I have come across the following script which checks whether an element has class `a`, and if not, adds it:

    if (!$(&quot;div&quot;).hasClass(&quot;a&quot;)){
       $(&quot;div&quot;).addClass(&quot;a&quot;);
    }

As jQuery won&#39;t add the class if it already exists, this could be changed to:

    $(&quot;div&quot;).addClass(&quot;a&quot;);

However, is there any performance improvements by using `hasClass` first, or is this using the same method which `addClass` does anyway, and therefore duplicating the logic?

Should I use &quot;hasClass&quot; before &quot;addClass&quot;?

**Background**

My question is motivated by simple observations, which somewhat undermine the beliefs/assumptions often held/made by experienced MATLAB users:

 - MATLAB is very well optimized when it comes to the built-in functions and the fundamental language features, such as indexing vectors and matrices.
 - Loops in MATLAB are slow (despite the JIT) and should generally be avoided if the algorithm can be expressed in a native, &#39;vectorized&#39; manner. 

The bottom line: core MATLAB functionality is efficient and trying to outperform it using MATLAB code is hard, if not impossible.


**Investigating performance of vector indexing**

The example codes shown below are as fundamental as it gets: I assign a scalar value to all vector entries. First, I allocate an empty vector `x`:

    tic; x = zeros(1e8,1); toc
    Elapsed time is 0.260525 seconds.

Having `x` I would like to set all its entries to the same value. In practice you would do it differently, e.g., `x = value*ones(1e8,1)`, but the point here is to investigate the performance of vector indexing. The simplest way is to write:

    tic; x(:) = 1; toc
    Elapsed time is 0.094316 seconds.

Let&#39;s call it method 1 (from the value assigned to `x`). It seems to be very fast (faster at least than memory allocation). Because the only thing I do here is operate on memory, I can estimate the efficiency of this code by calculating the obtained *effective memory bandwidth* and comparing it to the *hardware memory bandwidth* of my computer:

    eff_bandwidth = numel(x) * 8 bytes per double * 2 / time

In the above, I multiply by `2` because unless SSE streaming is used, setting values in memory requires that the vector is both read from and written to the memory. In the above example:

    eff_bandwidth(1) = 1e8*8*2/0.094316 = 17 Gb/s

[STREAM-benchmarked memory bandwidth](https://www.cs.virginia.edu/stream/) of my computer is around 17.9 Gb/s, so indeed - MATLAB delivers close to peak performance in this case! So far, so good.

Method 1 is suitable if you want to set *all* vector elements to some value. But if you want to access elements every `step` entries, you need to substitute the `:` with e.g., `1:step:end`. Below is a direct speed comparison with method 1:

    tic; x(1:end) = 2; toc
    Elapsed time is 0.496476 seconds.

While you would not expect it to perform any different, method 2 is clearly big trouble: factor 5 slowdown for no reason. My suspicion is that in this case MATLAB explicitly allocates the index vector (`1:end`). This is somewhat confirmed by using explicit vector size instead of `end`:

    tic; x(1:1e8) = 3; toc
    Elapsed time is 0.482083 seconds.

Methods 2 and 3 perform equally bad.

Another possibility is to explicitly create an index vector `id` and use it to index `x`. This gives you the most flexible indexing capabilities. In our case:

    tic;
    id = 1:1e8; % colon(1,1e8);
    x(id) = 4;
    toc
    Elapsed time is 1.208419 seconds.

Now that is really something - 12 times slowdown compared to method 1! I understand it should perform worse than method 1 because of the additional memory used for `id`, but why is it so much worse than methods 2 and 3?

Let&#39;s try to give the loops a try - as hopeless as it may sound.

    tic;
    for i=1:numel(x)
        x(i) = 5;
    end
    toc
    Elapsed time is 0.788944 seconds.

A big surprise - a loop beats a `vectorized` method 4, but is still slower than methods 1, 2 and 3. It turns out that in this particular case you can do it better:

    tic;
    for i=1:1e8
        x(i) = 6;
    end
    toc
    Elapsed time is 0.321246 seconds.

And that is the probably the most bizarre outcome of this study - **a MATLAB-written loop significantly outperforms native vector indexing**. That should certainly not be so. Note that the JIT&#39;ed loop is still 3 times slower than the theoretical peak almost obtained by method 1. So there is still plenty of room for improvement. It is just surprising (a stronger word would be more suitable) that usual &#39;vectorized&#39; indexing (`1:end`) is even slower.

**Questions**

 - is simple indexing in MATLAB **very** inefficient (methods 2, 3, and 4 are slower than method 1), or did I miss something?
 - why is method 4 **(so much) slower** than methods 2 and 3?
 - why does using `1e8` instead of `numel(x)` as a loop bound speed up the code by factor 2?

**Edit**
After reading Jonas&#39;s comment, here is another way to do that using logical indices:

    tic;
    id = logical(ones(1, 1e8));
    x(id) = 7;
    toc
    Elapsed time is 0.613363 seconds.

Much better than method 4.

For convenience:

    function test

    tic; x = zeros(1,1e8); toc

    tic; x(:) = 1; toc
    tic; x(1:end) = 2; toc
    tic; x(1:1e8) = 3; toc

    tic;
    id = 1:1e8; % colon(1,1e8);
    x(id) = 4;
    toc

    tic;
    for i=1:numel(x)
        x(i) = 5;
    end
    toc

    tic;
    for i=1:1e8
        x(i) = 6;
    end
    toc

    end

Is indexing vectors in MATLAB inefficient?

I aim to start opencv little by little but first I need to decide which API of OpenCV is more useful. I predict that Python implementation is shorter but running time will be more dense and slow compared to the native C++ implementations. Is there any know can comment about performance and coding differences between these two perspectives?

Does performance differ between Python or C++ coding of OpenCV?

This question is merely for me as I always like to write optimized code that can run also on cheap slow servers (or servers with A LOT of traffic)

I looked around and I was not able to find an answer.  I was wondering what is faster between those two examples keeping in mind that the array&#39;s keys in my case are not important (pseudo-code naturally):

    &lt;?php
    $a = array();
    while($new_val = &#39;get over 100k email addresses already lowercased&#39;){
        if(!in_array($new_val, $a){
            $a[] = $new_val;
            //do other stuff
        }
    }
    ?&gt;
    
    &lt;?php
    $a = array();
    while($new_val = &#39;get over 100k email addresses already lowercased&#39;){
        if(!isset($a[$new_val]){
            $a[$new_val] = true;
            //do other stuff
        }
    }
    ?&gt;

As the point of the question is not the array collision, I would like to add that if you are afraid of colliding inserts for `$a[$new_value]`, you can use `$a[md5($new_value)]`.  it can still cause collisions, but would take away from a possible DoS attack when reading from an user provided file (http://nikic.github.com/2011/12/28/Supercolliding-a-PHP-array.html)

what is faster: in_array or isset?

Can somebody tell me why Dijkstra&#39;s algorithm for single source shortest path assumes that the edges must be non-negative. 

I am talking about only edges not the negative weight cycles.

Why doesn&#39;t Dijkstra&#39;s algorithm work for negative weight edges?

I faced this problem many times during various situations. It is generic to all programming languages although I am comfortable with C or Java.

Let us consider two arrays (or collections):

    char[] A = {&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;};
    char[] B = {&#39;c&#39;, &#39;d&#39;, &#39;e&#39;, &#39;f&#39;};

How do I get the common elements between the two arrays as a new array?
In this case, the intersection of array A and B is `char[] c = {&#39;c&#39;, &#39;d&#39;}`.

I want to avoid the repeated iteration of one array inside the other array which will
increase the execution time by (length of A times length of B) which is too much in the case of huge arrays.

Is there any way we could do a single pass in each array to get the common elements?


How do I get the intersection between two arrays as a new array?

I have two rectangles characterized by 4 values each : 

Left position `X`, top position `Y`, width `W` and height `H`:

    X1, Y1, H1, W1
    X2, Y2, H2, W2

Rectangles are not rotated, like so:

    +--------------------&gt; X axis
    |
    |    (X,Y)      (X+W, Y)
    |    +--------------+
    |    |              |
    |    |              |
    |    |              |
    |    +--------------+
    v    (X, Y+H)     (X+W,Y+H)
    
    Y axis

What is the best solution to determine whether the intersection of the two rectangles is empty or not?

Two Rectangles intersection

Consider the four percentages below, represented as `float` numbers:

        13.626332%
        47.989636%
         9.596008%
        28.788024%
       -----------
       100.000000%

I need to represent these percentages as whole numbers. If I simply use `Math.round()`, I end up with a total of 101%. 


    14 + 48 + 10 + 29 = 101

If I use `parseInt()`, I end up with a total of 97%. 


    13 + 47 + 9 + 28 = 97

What&#39;s a good algorithm to represent any number of  percentages as whole numbers while still maintaining a total of 100%?

---
**Edit**: After reading some of the comments and answers, there are clearly many ways to go about solving this.

In my mind, to remain true to the numbers, the &quot;right&quot; result is the one that minimizes the overall error, defined by how much error rounding would introduce relative to the actual value:

            value  rounded     error               decision
       ----------------------------------------------------
        13.626332       14      2.7%          round up (14)
        47.989636       48      0.0%          round up (48)
         9.596008       10      4.0%    don&#39;t round up  (9)
        28.788024       29      2.7%          round up (29)

In case of a tie (3.33, 3.33, 3.33) an arbitrary decision can be made (e.g. 3, 4, 3).

How to make rounded percentages add up to 100%

I&#39;ve to detect if two time periods are overlapping.&lt;br/&gt;
Every period has a start date and an end date.&lt;br/&gt;
I need to detect if my first time period (A) is overlapping with another one(B/C). &lt;br/&gt;
In my case, if the start of B is equal to the end of A, they are not overlapping(the inverse too) &lt;br/&gt;
I found the following cases:

![enter image description here][1]


So actually I&#39;m doing this like this:

    tStartA &lt; tStartB &amp;&amp; tStartB &lt; tEndA //For case 1
    OR
    tStartA &lt; tEndB &amp;&amp; tEndB &lt;= tEndA //For case 2
    OR
    tStartB &lt; tStartA  &amp;&amp; tEndB &gt; tEndA //For case 3


(The case 4 is taken in the account either in case 1 or in case 2)

It **works**, but it seems not very efficient.

So, first is there an existing class in c# that can modelize this(a time period), something like a timespan, but with a fixed start date.

Secondly: Is there already a c# code(like in the `DateTime` class) which can handle this?

Third: if no, what would be your approach to make this comparison the most fast?


  [1]: http://i.stack.imgur.com/AIBUV.png

Algorithm to detect overlapping periods

I have a collection in MongoDB where there are around (~3 million records). My sample record would look like,

     { &quot;_id&quot; = ObjectId(&quot;50731xxxxxxxxxxxxxxxxxxxx&quot;),
       &quot;source_references&quot; : [
                               &quot;_id&quot; : ObjectId(&quot;5045xxxxxxxxxxxxxx&quot;),
                               &quot;name&quot; : &quot;xxx&quot;,
                               &quot;key&quot; : 123
                              ]
     }


I am having a lot of duplicate records in the collection having same `source_references.key`. (By Duplicate I mean, `source_references.key` not the `_id`).

I want to remove duplicate records based on `source_references.key`, I&#39;m thinking of writing some PHP code to traverse each record and remove the record if exists.

Is there a way to remove the duplicates in Mongo Internal command line?

How to remove duplicates based on a key in Mongodb?

I&#39;m working on a event tracking system which uses a handful of lookup tables as well as the primary logging table.   In a report I&#39;m writing, an object can be selected to view statistics against.  The interface shows all objects in order of decreasing importance (ie, hits).

The schema for the two tables (slightly trimmed down, but you get the gist): 

    CREATE TABLE IF NOT EXISTS `event_log` (
      `event_id` int(11) NOT NULL AUTO_INCREMENT,
      `user_id` int(5) DEFAULT NULL,
      `object_id` int(5) DEFAULT NULL,
      `event_date` datetime DEFAULT NULL,
      PRIMARY KEY (`event_id`),
      KEY `user_id` (`user_id`),
      KEY `object_id` (`object_id`)
    );
    
    CREATE TABLE IF NOT EXISTS `lookup_event_objects` (
      `object_id` int(11) NOT NULL AUTO_INCREMENT,
      `object_desc` varchar(255) NOT NULL,
      PRIMARY KEY (`object_id`)
    );

The query I&#39;m having trouble with is below.  It works fine with my table of ~100 entries, but the EXPLAIN worries me a little.

		explain	SELECT 
				el.object_id, 
				leo.object_desc, 
				COUNT(el.object_id) as count_rows
			FROM 
				event_log el 
				LEFT JOIN lookup_event_objects leo ON leo.object_id = el.object_id
			GROUP BY 
				el.object_id
			ORDER BY 
				count_rows DESC,
				leo.object_desc ASC

Returns: 
`Using index; Using temporary; Using filesort`

So -- what&#39;s wrong with my schema and/or query for MySQL to fall back on `temporary` and `filesort`?  Or is it as optimized as it can get using ORDER BY? 

Using index, using temporary, using filesort - how to fix this?

In his book `The C++ Standard Library (Second Edition)` Nicolai Josuttis states that lambdas can be better optimized by the compiler than plain functions.

&gt; In addition, C++ compilers optimize lambdas better than they do
&gt; ordinary functions.
(Page 213)

Why is that? 

I thought when it comes to inlining there shouldn&#39;t be any difference any more. The only reason I could think of is that compilers might have a better local context with lambdas and such can make more assumptions and perform more optimizations. 

Why can lambdas be better optimized by the compiler than plain functions?

Suppose I have a std::vector of structs. What happens to the memory if the vector is clear()&#39;d?

    std::vector&lt;myStruct&gt; vecs;
    vecs.resize(10000);
    vecs.clear();

Will the memory be freed, or still attached to the vecs variable as a reusable buffer?


 


Is std::vector memory freed upon a clear?

So, I had this code:

    constexpr unsigned N = 1000;
    void f1(char* sum, char* a, char* b) {
        for(int i = 0; i &lt; N; ++i) {
            sum[i] = a[i] + b[i];
        }
    }
    
    void f2(char* sum, char* a, char* b) {
        char* end = sum + N;
        while(sum != end) {
            *sum++ = *a++ + *b++;
        }
    }

I wanted to see the code that GCC 4.7.2 would generate. So I ran `g++ -march=native -O3 -masm=intel -S a.c++ -std=c++11` And got the following output:

            .file   &quot;a.c++&quot;
            .intel_syntax noprefix
            .text
            .p2align 4,,15
            .globl  _Z2f1PcS_S_
            .type   _Z2f1PcS_S_, @function
    _Z2f1PcS_S_:
    .LFB0:
            .cfi_startproc
            lea     rcx, [rdx+16]
            lea     rax, [rdi+16]
            cmp     rdi, rcx
            setae   r8b
            cmp     rdx, rax
            setae   cl
            or      cl, r8b
            je      .L5
            lea     rcx, [rsi+16]
            cmp     rdi, rcx
            setae   cl
            cmp     rsi, rax
            setae   al
            or      cl, al
            je      .L5
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L3:
            movdqu  xmm0, XMMWORD PTR [rdx+rax]
            movdqu  xmm1, XMMWORD PTR [rsi+rax]
            paddb   xmm0, xmm1
            movdqu  XMMWORD PTR [rdi+rax], xmm0
            add     rax, 16
            cmp     rax, 992
            jne     .L3
            mov     ax, 8
            mov     r9d, 992
    .L2:
            sub     eax, 1
            lea     rcx, [rdx+r9]
            add     rdi, r9
            lea     r8, [rax+1]
            add     rsi, r9
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L4:
            movzx   edx, BYTE PTR [rcx+rax]
            add     dl, BYTE PTR [rsi+rax]
            mov     BYTE PTR [rdi+rax], dl
            add     rax, 1
            cmp     rax, r8
            jne     .L4
            rep
            ret
    .L5:
            mov     eax, 1000
            xor     r9d, r9d
            jmp     .L2
            .cfi_endproc
    .LFE0:
            .size   _Z2f1PcS_S_, .-_Z2f1PcS_S_
            .p2align 4,,15
            .globl  _Z2f2PcS_S_
            .type   _Z2f2PcS_S_, @function
    _Z2f2PcS_S_:
    .LFB1:
            .cfi_startproc
            lea     rcx, [rdx+16]
            lea     rax, [rdi+16]
            cmp     rdi, rcx
            setae   r8b
            cmp     rdx, rax
            setae   cl
            or      cl, r8b
            je      .L19
            lea     rcx, [rsi+16]
            cmp     rdi, rcx
            setae   cl
            cmp     rsi, rax
            setae   al
            or      cl, al
            je      .L19
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L17:
            movdqu  xmm0, XMMWORD PTR [rdx+rax]
            movdqu  xmm1, XMMWORD PTR [rsi+rax]
            paddb   xmm0, xmm1
            movdqu  XMMWORD PTR [rdi+rax], xmm0
            add     rax, 16
            cmp     rax, 992
            jne     .L17
            add     rdi, 992
            add     rsi, 992
            add     rdx, 992
            mov     r8d, 8
    .L16:
            xor     eax, eax
            .p2align 4,,10
            .p2align 3
    .L18:
            movzx   ecx, BYTE PTR [rdx+rax]
            add     cl, BYTE PTR [rsi+rax]
            mov     BYTE PTR [rdi+rax], cl
            add     rax, 1
            cmp     rax, r8
            jne     .L18
            rep
            ret
    .L19:
            mov     r8d, 1000
            jmp     .L16
            .cfi_endproc
    .LFE1:
            .size   _Z2f2PcS_S_, .-_Z2f2PcS_S_
            .ident  &quot;GCC: (GNU) 4.7.2&quot;
            .section        .note.GNU-stack,&quot;&quot;,@progbits

I suck at reading assembly, so I decided to add some markers to know where the bodies of the loops went:

    constexpr unsigned N = 1000;
    void f1(char* sum, char* a, char* b) {
        for(int i = 0; i &lt; N; ++i) {
            asm(&quot;# im in ur loop&quot;);
            sum[i] = a[i] + b[i];
        }
    }
    
    void f2(char* sum, char* a, char* b) {
        char* end = sum + N;
        while(sum != end) {
            asm(&quot;# im in ur loop&quot;);
            *sum++ = *a++ + *b++;
        }
    }

And GCC spat this out:

        .file   &quot;a.c++&quot;
        .intel_syntax noprefix
        .text
        .p2align 4,,15
        .globl  _Z2f1PcS_S_
        .type   _Z2f1PcS_S_, @function
    _Z2f1PcS_S_:
    .LFB0:
        .cfi_startproc
        xor eax, eax
        .p2align 4,,10
        .p2align 3
    .L2:
    #APP
    # 4 &quot;a.c++&quot; 1
        # im in ur loop
    # 0 &quot;&quot; 2
    #NO_APP
        movzx   ecx, BYTE PTR [rdx+rax]
        add cl, BYTE PTR [rsi+rax]
        mov BYTE PTR [rdi+rax], cl
        add rax, 1
        cmp rax, 1000
        jne .L2
        rep
        ret
        .cfi_endproc
    .LFE0:
        .size   _Z2f1PcS_S_, .-_Z2f1PcS_S_
        .p2align 4,,15
        .globl  _Z2f2PcS_S_
        .type   _Z2f2PcS_S_, @function
    _Z2f2PcS_S_:
    .LFB1:
        .cfi_startproc
        xor eax, eax
        .p2align 4,,10
        .p2align 3
    .L6:
    #APP
    # 12 &quot;a.c++&quot; 1
        # im in ur loop
    # 0 &quot;&quot; 2
    #NO_APP
        movzx   ecx, BYTE PTR [rdx+rax]
        add cl, BYTE PTR [rsi+rax]
        mov BYTE PTR [rdi+rax], cl
        add rax, 1
        cmp rax, 1000
        jne .L6
        rep
        ret
        .cfi_endproc
    .LFE1:
        .size   _Z2f2PcS_S_, .-_Z2f2PcS_S_
        .ident  &quot;GCC: (GNU) 4.7.2&quot;
        .section    .note.GNU-stack,&quot;&quot;,@progbits

This is considerably shorter, and has some significant differences like the lack of SIMD instructions. I was expecting the same output, with some comments somewhere in the middle of it. Am I making some wrong assumption here? Is GCC&#39;s optimizer hindered by asm comments?

Why is i-- faster than i++ in loops?

Javascript Problem Overview

Javascript Solutions

R - Markdown avoiding package loading messages

Why is the default value of the string type null instead of an empty string?

Attributions