The `LL` makes the integer literal of type `long long`.

So `2LL`, is a 2 of type `long long`.

Without the `LL`, the literal would only be of type `int`.

This matters when you&#39;re doing stuff like this:

    1   &lt;&lt; 40
    1LL &lt;&lt; 40

With just the literal `1`, (assuming `int` to be 32-bits, you shift beyond the size of the integer type -&gt; undefined behavior).
With `1LL`, you set the type to `long long` before hand and now it will properly return 2^40.


Does `ifelse` really calculate both the `yes` and `no` vectors -- as in, the entirety of each vector?
Or does it just calculate some values from each vector? 

Also, is `ifelse` really that slow?  



Does ifelse really calculate both of its vectors every time? Is it slow?

I&#39;m writing a simple edit text in Java. When the user opens it, a file will be opened in `JTabbedPane`. I did the following to save the files opened:

`HashMap&lt;String, Tab&gt; hash = new HashMap&lt;String, Tab&gt;(); `

Where `Tab` will receive the values, such as: `File file, JTextArea container, JTabbedPane tab`.

I have a class called `Tab`:

   	public Tab(File file, JTextArea container, JTabbedPane tab)
	{
		this.file = file;
		this.container = container;
		this.tab = tab;
		tab.add(file.getName(), container);
		readFile();
	}


Now, in this `SaveFile` class, I need get the `Tab` values stored in the `HashMap`. How can I do that?

How to get values and keys from HashMap?

I was looking at some of the solutions in Google Code Jam and some people used this things that I had never seen before. For example,

    2LL*r+1LL

What does 2LL and 1LL mean?

Their includes look like this:

    #include &lt;math.h&gt;
    #include &lt;algorithm&gt;
    #define _USE_MATH_DEFINES

or 

    #include &lt;cmath&gt;



What is 1LL or 2LL in C and C++?

I was looking at some of the solutions in Google Code Jam and some people used this things that I had never seen before. For example,
<pre><code class="hljs">2LL*r+1LL
</code></pre>
What does 2LL and 1LL mean?
Their includes look like this:
<pre><code class="hljs language-arduino">#include &#x3C;math.h>
#include &#x3C;algorithm>
#define _USE_MATH_DEFINES
</code></pre>
or
<pre><code class="hljs language-arduino">#include &#x3C;cmath>
</code></pre>

Now we all sometimes have to work with binary data. In C++ we work with sequences of bytes, and since the beginning `char` was the our building block. Defined to have `sizeof` of 1, it is the byte. And all library I/O functions use `char` by default. All is good but there was always a little concern, a little oddity that bugged some people - the number of bits in a byte is implementation-defined.

So in C99, it was decided to introduce several typedefs to let the developers easily express themselves, the fixed-width integer types. Optional, of course, since we never want to hurt portability. Among them, `uint8_t`, migrated into C++11 as `std::uint8_t`, a fixed width 8-bit unsigned integer type, was the perfect choice for people who really wanted to work with 8 bit bytes.

And so, developers embraced the new tools and started building libraries that expressively state that they accept 8-bit byte sequences, as `std::uint8_t*`, `std::vector&lt;std::uint8_t&gt;` or otherwise.

But, perhaps with a very deep thought, the standardization committee decided not to require implementation of `std::char_traits&lt;std::uint8_t&gt;` therefore prohibiting developers from easily and portably instantiating, say, `std::basic_fstream&lt;std::uint8_t&gt;` and easily reading `std::uint8_t`s as a binary data. Or maybe, some of us don&#39;t care about the number of bits in a byte and are happy with it.

But unfortunately, two worlds collide and sometimes you have to take a data as `char*` and pass it to a library that expects `std::uint8_t*`. But wait, you say, isn&#39;t `char` variable bit and `std::uint8_t` is fixed to 8? Will it result into a loss of data? 

Well, there is an interesting Standardese on this. The `char` defined to hold exactly one byte and byte is the lowest addressable chunk of memory, so there can&#39;t be a type with bit width lesser than that of `char`. Next, it is defined to be able to hold UTF-8 code units. This gives us the minimum - 8 bits. So now we have a typedef which is required to be 8 bits wide and a type that is at least 8 bits wide. But are there alternatives? Yes, `unsigned char`. Remember that signedness of `char` is implementation-defined. Any other type? Thankfully, no. All other integral types have required ranges which fall outside of 8 bits.

Finally, `std::uint8_t` is optional, that means that the library which uses this type will not compile if it&#39;s not defined. But what if it compiles? I can say with a great degree of confidence that this means that we are on a platform with 8 bit bytes and `CHAR_BIT == 8`.

Once we have this knowledge, that we have 8-bit bytes, that `std::uint8_t` is implemented as either `char` or `unsigned char`, can we assume that we can do `reinterpret_cast` from `char*` to `std::uint8_t*` and vice versa? Is it portable?

This is where my Standardese reading skills fail me. I read about safely derived pointers (`[basic.stc.dynamic.safety]`) and, as far as I understand, the following:

    std::uint8_t* buffer = /* ... */ ;
    char* buffer2 = reinterpret_cast&lt;char*&gt;(buffer);
    std::uint8_t buffer3 = reinterpret_cast&lt;std::uint8_t*&gt;(buffer2);

is safe if we don&#39;t touch `buffer2`. Correct me if I&#39;m wrong.

So, given the following preconditions:

- `CHAR_BIT == 8`
- `std::uint8_t` is defined.

Is it portable and safe to cast `char*` and `std::uint8_t*` back and forth, assuming that we&#39;re working with binary data and the potential lack of sign of `char` doesn&#39;t matter?

I would appreciate references to the Standard with explanations.

EDIT: Thanks, Jerry Coffin. I&#39;m going to add the quote from the Standard ([basic.lval], &#167;3.10/10):

&gt; If a program attempts to access the stored value of an object through a glvalue of other than one of the
following types the behavior is undefined:

&gt; ...

&gt; — a char or unsigned char type.

EDIT2: Ok, going deeper. `std::uint8_t` is not guaranteed to be a typedef of `unsigned char`. It can be implemented as *extended unsigned integer type* and extended unsigned integer types are not included in &#167;3.10/10. What now?

reinterpret_cast between char* and std::uint8_t* - safe?

The compiler book(The dragon book) explains that value types are created on the stack, and reference types are created on the heap. 


For Java, JVM also contains heap and stack in runtime data area.  Objects and arrays are created on heap, method frames are pushed to stack. One heap is shared by all threads, while each thread has its own stack. The following diagram shows this: 

![enter image description here][1]

More about [Java run-time data areas][2].

What I don&#39;t understand is that since JVM is essentially a software, how are those JVM heap, stack and threads mapped to physical machine? 

I would appreciate it if someone can compare those concept between Java and C++. Because Java runs on JVM, but C++ does not. 

To make this question more precise, I want to know the following: 

 1. Comparing with Java, What does C++ run-time data area look like? A picture would be helpful, I can&#39;t find a good picture like the JVM one above. 
 2. How the JVM heap, stack, registers and threads are mapped to operating system? or I should ask how they are mapped to physical machine? 
 3. Is it true that each JVM threads is simply a user thread and gets mapped to kernal in some way? (user thread vs kernel thread)

**Update**: 
I draw a picture for runtime physical memory of a process.  
![enter image description here][3]


  [1]: http://i.stack.imgur.com/cFTf6.jpg
  [2]: http://www.programcreek.com/2013/04/jvm-run-time-data-areas/
  [3]: http://i.stack.imgur.com/xAPl5.jpg

How JVM stack, heap and threads are mapped to physical memory or operation system

Hi i am getting undefined reference error in the following code:

    class Helloworld{
      public:
         static int x;
         void foo();
    };
    void Helloworld::foo(){
         Helloworld::x = 10;
    };

I don&#39;t want a `static` `foo()` function. How can I access `static` variable of a class in non-`static` method of a class?

Undefined reference to static variable c++

Is there a difference between declaring floating point constant as a `static constexpr` variable and a function as in example below, or is it just a matter of style?

    class MY_PI
    {
    public:
        static constexpr float MY_PI_VAR = 3.14f;
        static constexpr float MY_PI_FUN() { return 3.14f; }
    }

static constexpr variable vs function

    class A {};
    
    int main() {
     A() = A();
     return 0; 
    }

Why does this code compile? Shouldn&#39;t be there some error that on the left side of assignment operator should be placed lvalue? Is A() lvalue? g++ 4.7 version

A() = A() - why does it compile?

I am new to competitive programming, and I noticed frequently, many of the great coders have these four lines in their code (particularly in those involving arrays):

    int di[] = { 1, -1, 0, 0, 1, -1, 1, -1 };
    int dj[] = { 0, 0, 1, -1, 1, -1, -1, 1 };
    int diK[] = { -2, -2, -1, 1, 2, 2, 1, -1 };
    int djK[] = { -1, 1, 2, 2, 1, -1, -2, -2 };

What does this really signify and what is technique used for?


What is the significance of initializing direction arrays below with given values when developing chess program?

Does a program that writes to &quot;stdout&quot; write to a file?  the screen?  I don&#39;t understand what it means to write to stdout.

What does it mean to write to stdout in C?

I am trying to use Curl in C.

I visited Curl official page, and copied sample source code.

below is the link:
http://curl.haxx.se/libcurl/c/sepheaders.html

when I run this code with command &quot;gcc test.c&quot;, 

the console shows message like below.

    /tmp/cc1vsivQ.o: In function `main&#39;:
    test.c:(.text+0xe1): undefined reference to `curl_global_init&#39;
    test.c:(.text+0xe6): undefined reference to `curl_easy_init&#39;
    test.c:(.text+0x10c): undefined reference to `curl_easy_setopt&#39;
    test.c:(.text+0x12e): undefined reference to `curl_easy_setopt&#39;
    test.c:(.text+0x150): undefined reference to `curl_easy_setopt&#39;
    test.c:(.text+0x17e): undefined reference to `curl_easy_cleanup&#39;
    test.c:(.text+0x1b3): undefined reference to `curl_easy_cleanup&#39;
    test.c:(.text+0x1db): undefined reference to `curl_easy_setopt&#39;
    test.c:(.text+0x1e7): undefined reference to `curl_easy_perform&#39;
    test.c:(.text+0x1ff): undefined reference to `curl_easy_cleanup&#39;

I do not know how to solve this.

undefined reference to curl_global_init, curl_easy_init and other function(C)

This [question][1] demonstrates a very interesting phenomenon: [denormalized][2] floats slow down the code more than an order of magnitude.

The behavior is well explained in the [accepted answer][3]. However, there is one comment, with currently 153 upvotes, that I cannot find satisfactory answer to:

&gt; Why isn&#39;t the compiler just dropping the +/- 0 in this case?!? –
&gt; **Michael Dorgan**

&lt;sub&gt;Side note: I have the impression that 0f is/must be exactly representable (furthermore - it&#39;s binary representation must be all zeroes), but can&#39;t find such a claim in the c11 standard. A quote proving this, or argument disproving this claim, would be most welcome. Regardless, *Michael*&#39;s question is the main question here.&lt;/sub&gt;

---
[&#167;5.2.4.2.2][4]

&gt; An implementation may give zero and values that are not floating-point
&gt; numbers (such as infinities and NaNs) a sign or may leave them
&gt; unsigned.

  [1]: https://stackoverflow.com/questions/9314534/why-does-changing-0-1f-to-0-slow-down-performance-by-10x
  [2]: http://en.wikipedia.org/wiki/Denormal_number
  [3]: https://stackoverflow.com/a/9314926/1145760
  [4]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

Why does MSVS not optimize away +0?

I am trying to program some sockets and so, on the server side, I use `htonl(INADDR_ANY)`. To the extent I understood, it seems to me that this function generates a random IP (am I correct ?). In fact, I want to bind my socket with my `localhost`. But if I run this 

    printf(&quot;%d&quot;,htonl(INADDR_ANY));

I get 0 as a return value. Could someone bring some explanation ?

Understanding INADDR_ANY for socket programming

Let a, b and c be non-large positive integers. Does a/b/c always equal a/(b * c) with C# integer arithmetic?  For me, in C# it looks like:

    int a = 5126, b = 76, c = 14;
    int x1 = a / b / c;
    int x2 = a / (b * c);

So my question is: does `x1 == x2` for all a, b and c?

In C# integer arithmetic, does a/b/c always equal a/(b*c)?

I have been working on an area lighting implementation in WebGL similar to this demo:

http://threejs.org/examples/webgldeferred_arealights.html

The above implementation in three.js was ported from the work of ArKano22 over on gamedev.net:

http://www.gamedev.net/topic/552315-glsl-area-light-implementation/

Though these solutions are very impressive, they both have a few limitations. The primary issue with ArKano22&#39;s original implementation is that the calculation of the diffuse term does not account for surface normals.

I have been augmenting this solution for some weeks now, working with the improvements by redPlant to address this problem. Currently I have normal calculations incorporated into the solution, BUT the result is also flawed.

Here is a sneak preview of my current implementation:

![area lighting teaser][1]

## Introduction

The steps for calculating the diffuse term for each fragment is as follows:

1. Project the vertex onto the plane that the area light sits on, so that the projected vector is coincident with the light&#39;s normal/direction.
2. Check that the vertex is on the correct side of the area light plane by comparing the projection vector with the light&#39;s normal.
3. Calculate the 2D offset of this projected point on the plane from the light&#39;s center/position.
4. Clamp this 2D offset vector so that it sits inside the light&#39;s area (defined by its width and height).
5. Derive the 3D world position of the projected and clamped 2D point. This is the **nearest point** on the area light to the vertex.
6. Perform the usual diffuse calculations that you would for a point light by taking the dot product between the the vertex-to-nearest-point vector (normalised) and the vertex normal.

## Problem

The issue with this solution is that the lighting calculations are done from the **nearest point** and do not account for other points on the lights surface that could be illuminating the fragment even more so. Let me try and explain why…

Consider the following diagram:

![problematic area lighting situation][2]

The area light is both perpendicular to the surface and intersects it. Each of the fragments on the surface will always return a **nearest point** on the area light where the surface and the light intersect. Since the surface normal and the vertex-to-light vectors are always perpendicular, the dot product between them is zero. Subsequently, the calculation of the diffuse contribution is zero despite there being a large area of light looming over the surface.

## Potential Solution

I propose that rather than calculate the light from the **nearest point** on the area light, we calculate it from a point on the area light that yields the greatest dot product between the vertex-to-light vector (normalised) and the vertex normal. In the diagram above, this would be the purple dot, rather than the blue dot.

## Help!

And so, this is where I need your help. In my head, I have a pretty good idea of how this point can be derived, but don&#39;t have the mathematical competence to arrive at the solution.

Currently I have the following information available in my fragment shader:

* vertex position
* vertex normal (unit vector)
* light position, width and height
* light normal (unit vector)
* light right (unit vector)
* light up (unit vector)
* projected point from the vertex onto the lights plane (3D)
* projected point offset from the lights center (2D)
* clamped offset (2D)
* world position of this clamped offset – the **nearest point** (3D)

To put all this information into a visual context, I created this diagram (hope it helps):

![available lighting information][3]

To test my proposal, I need the **casting point** on the area light – represented by the red dots, so that I can perform the dot product between the vertex-to-casting-point (normalised) and the vertex normal. Again, this should yield the maximum possible contribution value.

# UPDATE!!!

I have created an interactive sketch over on CodePen that visualises the mathematics that I currently have implemented:

## http://codepen.io/wagerfield/pen/ywqCp

![codepen][4]

The relavent code that you should focus on is line **318**.

`castingPoint.location` is an instance of `THREE.Vector3` and is the missing piece of the puzzle. You should also notice that there are 2 values at the lower left of the sketch – these are dynamically updated to display the dot product between the relevant vectors.

I imagine that the solution would require another pseudo plane that aligns with the direction of the vertex normal AND is perpendicular to the light&#39;s plane, but I could be wrong!


  [1]: http://i.stack.imgur.com/4V5c0.png
  [2]: http://i.stack.imgur.com/ubZ4v.png
  [3]: http://i.stack.imgur.com/pZUEf.png
  [4]: http://i.stack.imgur.com/USld4.png

Improved Area Lighting in WebGL &amp; ThreeJS

Is there a faster way than `x &gt;= start &amp;&amp; x &lt;= end` in C or C++ to test if an integer is between two integers?

*UPDATE*: My specific platform is iOS. This is part of a box blur function that restricts pixels to a circle in a given square.

*UPDATE*: After trying the [accepted answer](https://stackoverflow.com/a/17095534/1165522), I got an order of magnitude speedup on the one line of code over doing it the normal `x &gt;= start &amp;&amp; x &lt;= end` way.

*UPDATE*: Here is the after and before code with assembler from XCode:

**NEW WAY**

    // diff = (end - start) + 1
    #define POINT_IN_RANGE_AND_INCREMENT(p, range) ((p++ - range.start) &lt; range.diff)
    
    Ltmp1313:
     ldr    r0, [sp, #176] @ 4-byte Reload
     ldr    r1, [sp, #164] @ 4-byte Reload
     ldr    r0, [r0]
     ldr    r1, [r1]
     sub.w  r0, r9, r0
     cmp    r0, r1
     blo    LBB44_30
        

**OLD WAY**

    #define POINT_IN_RANGE_AND_INCREMENT(p, range) (p &lt;= range.end &amp;&amp; p++ &gt;= range.start)

    Ltmp1301:
     ldr    r1, [sp, #172] @ 4-byte Reload
     ldr    r1, [r1]
     cmp    r0, r1
     bls    LBB44_32
     mov    r6, r0
     b      LBB44_33
    LBB44_32:
     ldr    r1, [sp, #188] @ 4-byte Reload
     adds   r6, r0, #1
    Ltmp1302:
     ldr    r1, [r1]
     cmp    r0, r1
     bhs    LBB44_36

Pretty amazing how reducing or eliminating branching can provide such a dramatic speed up.

Fastest way to determine if an integer is between two integers (inclusive) with known sets of values

In the output layer of a neural network, it is typical to use the softmax function to approximate a probability distribution:

![enter image description here][1]

This is expensive to compute because of the exponents. Why not simply perform a Z transform so that all outputs are positive, and then normalise just by dividing all outputs by the sum of all outputs?


  [1]: http://i.stack.imgur.com/r1MZm.png

Why use softmax as opposed to standard normalization?

In a small application written in C/C++, I am facing a problem with the `rand` function and maybe the seed :

I want to produce a sequence of random numbers that are of different orders, i.e. with different logarithm values (base 2). But it seems that all the numbers produced are of the same order, fluctuating just between 2^25 and 2^30.

Is it because `rand()` is seeded with Unix time which is by now a relatively big number? What am I forgetting ? 
I am seeding `rand()` only once at the beginning of the `main()`.

Why does C++ rand() seem to generate only numbers of the same order of magnitude?

How can I get a long number bigger than Long.MAX_VALUE?

I want this method to return `true`:

    boolean isBiggerThanMaxLong(long val) {
        return (val &gt; Long.MAX_VALUE);
    }

A long bigger than Long.MAX_VALUE

I am transitioning from Java to C++ and have some questions about the `long` data type. In Java, to hold an integer greater than 2&lt;sup&gt;32&lt;/sup&gt;, you would simply write `long x;`. However, in C++, it seems that `long` is both a data type and a modifier. 

There seems to be several ways to use `long`:

    long x;
    long long x;
    long int x;
    long long int x;

Also, it seems there are things such as:

    long double x;

and so on.

What is the difference between all of these various data types, and do they all have the same purpose?

What is the difference between &quot;long&quot;, &quot;long long&quot;, &quot;long int&quot;, and &quot;long long int&quot; in C++?

I&#39;m running Windows 8.1 x64 with Java 7 update 45 x64 (no 32 bit Java installed) on a Surface Pro 2 tablet.

The code below takes 1688ms when the type of i is a long and 109ms when i is an int. Why is long (a 64 bit type) an order of magnitude slower than int on a 64 bit platform with a 64 bit JVM?

My only speculation is that the CPU takes longer to add a 64 bit integer than a 32 bit one, but that seems unlikely. I suspect Haswell doesn&#39;t use ripple-carry adders.

I&#39;m running this in Eclipse Kepler SR1, btw.


    public class Main {
    
        private static long i = Integer.MAX_VALUE;
    
        public static void main(String[] args) {	
            System.out.println(&quot;Starting the loop&quot;);
            long startTime = System.currentTimeMillis();
            while(!decrementAndCheck()){
            }
            long endTime = System.currentTimeMillis();
            System.out.println(&quot;Finished the loop in &quot; + (endTime - startTime) + &quot;ms&quot;);
        }

        private static boolean decrementAndCheck() {
            return --i &lt; 0;
        }

    }


Edit: Here are the results from equivalent C++ code compiled by VS 2013 (below), same system. &lt;del&gt;long: 72265ms int: 74656ms&lt;/del&gt;  Those results were in debug 32 bit mode.

In 64 bit release mode: &lt;del&gt;long: 875ms&lt;/del&gt; long long:  906ms int: 1047ms


This suggests that the result I observed is JVM optimization weirdness rather than CPU limitations.




    #include &quot;stdafx.h&quot;
    #include &quot;iostream&quot;
    #include &quot;windows.h&quot;
    #include &quot;limits.h&quot;

    long long i = INT_MAX;

    using namespace std;


    boolean decrementAndCheck() {
	return --i &lt; 0;
    }


    int _tmain(int argc, _TCHAR* argv[])
    {


	cout &lt;&lt; &quot;Starting the loop&quot; &lt;&lt; endl;

	unsigned long startTime = GetTickCount64();
	while (!decrementAndCheck()){
	}
	unsigned long endTime = GetTickCount64();

	cout &lt;&lt; &quot;Finished the loop in &quot; &lt;&lt; (endTime - startTime) &lt;&lt; &quot;ms&quot; &lt;&lt; endl;



    }


Edit: Just tried this again in Java 8 RTM, no significant change.

Why is long slower than int in x64 Java?

I have 3 very large signed integers.

    long x = long.MaxValue;
    long y = long.MaxValue - 1;
    long z = long.MaxValue - 2;

I want to calculate their truncated average. Expected average value is `long.MaxValue - 1`, which is `9223372036854775806`.

It is impossible to calculate it as:

    long avg = (x + y + z) / 3; // 3074457345618258600

Note: I read all those questions about average of 2 numbers, but I don&#39;t see how that technique can be applied to average of 3 numbers.

It would be very easy with the usage of `BigInteger`, but let&#39;s assume I cannot use it.

    BigInteger bx = new BigInteger(x);
    BigInteger by = new BigInteger(y);
    BigInteger bz = new BigInteger(z);
    BigInteger bavg = (bx + by + bz) / 3; // 9223372036854775806


If I convert to `double`, then, of course, I lose precision:

    double dx = x;
    double dy = y;
    double dz = z;
    double davg = (dx + dy + dz) / 3; // 9223372036854780000

If I convert to `decimal`, it works, but also let&#39;s assume that I cannot use it.

    decimal mx = x;
    decimal my = y;
    decimal mz = z;
    decimal mavg = (mx + my + mz) / 3; // 9223372036854775806

**Question:** Is there a way to calculate the truncated average of 3 very large integers only with the usage of `long` type? Don&#39;t consider that question as C#-specific, just it is easier for me to provide samples in C#.

Average of 3 long integers

I often see questions relating to `Overflow` errors with [tag:VBA].

My question is why use the `integer` variable declaration instead of just defining all numerical variables (excluding `double` etc.) as `long`?

Unless you&#39;re performing an operation like in a for loop where you can guarantee that the value won&#39;t exceed the 32,767 limit, is there an impact on performance or something else that would dictate not using `long`?

Why Use Integer Instead of Long?

So noticed from this [page](http://en.cppreference.com/w/cpp/numeric/math) that none of the math functions in c++11 seems to make use of constexpr, whereas I believe all of them could be. So that leaves me with two questions, one is why did they choose not to make the functions constexpr. And two for a function like `sqrt` I could probably write my own constexpr, but something like sin or cos would be trickier so is there a way around it.

Constexpr Math Functions

Many algorithms require to compute `(-1)^n` (both integer), usually as a factor in a series. That is, a factor that is `-1` for odd n and `1` for even n. In a C++ environment, one often sees:

    #include&lt;iostream&gt;
    #include&lt;cmath&gt;
    int main(){
       int n = 13;
       std::cout &lt;&lt; std::pow(-1, n) &lt;&lt; std::endl;
    }

**What is better or the usual convention?** (or something else),

    std::pow(-1, n)
    std::pow(-1, n%2)
    (n%2?-1:1)
    (1-2*(n%2))  // (gives incorrect value for negative n)

#EDIT:

In addition, user @SeverinPappadeux proposed another alternative based on (a global?) array lookups. My version of it is:

    const int res[] {-1, 1, -1}; // three elements are needed for negative modulo results
    const int* const m1pow = res + 1; 
    ...
    m1pow[n%2]


----------
This is not probably not going to settle the question but, by using the emitted code we can discard some options.

### First without optimization, the final contenders are:

       1 - ((n &amp; 1) &lt;&lt; 1);

(7 operation, no memory access)

      mov eax, DWORD PTR [rbp-20]
      add eax, eax
      and eax, 2
      mov edx, 1
      sub edx, eax
      mov eax, edx
      mov DWORD PTR [rbp-16], eax

and 

       retvals[n&amp;1];

(5 operations, memory --registers?-- access)

      mov eax, DWORD PTR [rbp-20]
      and eax, 1
      cdqe
      mov eax, DWORD PTR main::retvals[0+rax*4]
      mov DWORD PTR [rbp-8], eax

### Now with optimization (-O3)

       1 - ((n &amp; 1) &lt;&lt; 1);

(4 operation, no memory access)

      add edx, edx
      mov ebp, 1
      and edx, 2
      sub ebp, edx
.

      retvals[n&amp;1];

(4 operations, memory --registers?-- access)

      mov eax, edx
      and eax, 1
      movsx rcx, eax
      mov r12d, DWORD PTR main::retvals[0+rcx*4]
.

       n%2?-1:1;

(4 operations, no memory access)

      cmp eax, 1
      sbb ebx, ebx
      and ebx, 2
      sub ebx, 1

The test are [here](https://godbolt.org/g/dD391u). I had to some some acrobatics to have meaningful code that doesn&#39;t elide operations all together. 

## Conclusion (for now)

So at the end it depends on the level optimization and expressiveness:

- `1 - ((n &amp; 1) &lt;&lt; 1);` is **always** good but not very expressive.
- `retvals[n&amp;1];` pays a price for memory access.
- `n%2?-1:1;` is expressive and good but only with optimization.


What is the correct way to obtain (-1)^n?

I&#39;ve been working on a few project Euler exercises to improve my knowledge of C++.

I&#39;ve written the following function:

    int a = 0,b = 0,c = 0;

    for (a = 1; a &lt;= SUMTOTAL; a++)
    {
        for (b = a+1; b &lt;= SUMTOTAL-a; b++)
        {
            c = SUMTOTAL-(a+b);

            if (c == sqrt(pow(a,2)+pow(b,2)) &amp;&amp; b &lt; c)
            {
                std::cout &lt;&lt; &quot;a: &quot; &lt;&lt; a &lt;&lt; &quot; b: &quot; &lt;&lt; b &lt;&lt; &quot; c: &quot;&lt;&lt; c &lt;&lt; std::endl;
                std::cout &lt;&lt; a * b * c &lt;&lt; std::endl;
            }
        }
    }

This computes in 17 milliseconds.

However, if I change the line

    if (c == sqrt(pow(a,2)+pow(b,2)) &amp;&amp; b &lt; c)

to 

    if (c == sqrt((a*a)+(b*b)) &amp;&amp; b &lt; c)

the computation takes place in 2 milliseconds. Is there some obvious implementation detail of `pow(int, int)` that I&#39;m missing which makes the first expression compute so much slower?

Content Type	Original Author	Original Content on Stackoverflow
Question	fersarr	View Question on Stackoverflow
Solution 1 - C++	Kyurem	View Answer on Stackoverflow

What is 1LL or 2LL in C and C++?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

How to get values and keys from HashMap?

Does ifelse really calculate both of its vectors every time? Is it slow?

Attributions