Modern browsers have `Array#includes`

, which does *exactly* that and is widely supported by everyone except IE:

`console.log(['joe', 'jane', 'mary'].includes('jane')); //true`

You can also use `Array#indexOf`

, which is less direct, but doesn't require polyfills for outdated browsers.

`console.log(['joe', 'jane', 'mary'].indexOf('jane') >= 0); //true`

Many frameworks also offer similar methods:

- jQuery:
`$.inArray(value, array, [fromIndex])`

- Underscore.js:
`_.contains(array, value)`

(also aliased as `_.include`

and `_.includes`

)
- Dojo Toolkit:
`dojo.indexOf(array, value, [fromIndex, findLast])`

- Prototype:
`array.indexOf(value)`

- MooTools:
`array.indexOf(value)`

- MochiKit:
`findValue(array, value)`

- MS Ajax:
`array.indexOf(value)`

- Ext:
`Ext.Array.contains(array, value)`

- Lodash:
`_.includes(array, value, [from])`

(is `_.contains`

prior 4.0.0)
- Ramda:
`R.includes(value, array)`

Notice that some frameworks implement this as a function, while others add the function to the array prototype.

There's a simple trick for this problem:

```
bool IsPowerOfTwo(ulong x)
{
return (x & (x - 1)) == 0;
}
```

Note, this function will report `true`

for `0`

, which is not a power of `2`

. If you want to exclude that, here's how:

```
bool IsPowerOfTwo(ulong x)
{
return (x != 0) && ((x & (x - 1)) == 0);
}
```

### Explanation

First and foremost the bitwise binary & operator from MSDN definition:

Binary & operators are predefined for the integral types and bool. For
integral types, & computes the logical bitwise AND of its operands.
For bool operands, & computes the logical AND of its operands; that
is, the result is true if and only if both its operands are true.

Now let's take a look at how this all plays out:

The function returns boolean (true / false) and accepts one incoming parameter of type unsigned long (x, in this case). Let us for the sake of simplicity assume that someone has passed the value 4 and called the function like so:

```
bool b = IsPowerOfTwo(4)
```

Now we replace each occurrence of x with 4:

```
return (4 != 0) && ((4 & (4-1)) == 0);
```

Well we already know that 4 != 0 evals to true, so far so good. But what about:

```
((4 & (4-1)) == 0)
```

This translates to this of course:

```
((4 & 3) == 0)
```

But what exactly is `4&3`

?

The binary representation of 4 is 100 and the binary representation of 3 is 011 (remember the & takes the binary representation of these numbers). So we have:

```
100 = 4
011 = 3
```

Imagine these values being stacked up much like elementary addition. The `&`

operator says that if both values are equal to 1 then the result is 1, otherwise it is 0. So `1 & 1 = 1`

, `1 & 0 = 0`

, `0 & 0 = 0`

, and `0 & 1 = 0`

. So we do the math:

```
100
011
----
000
```

The result is simply 0. So we go back and look at what our return statement now translates to:

```
return (4 != 0) && ((4 & 3) == 0);
```

Which translates now to:

```
return true && (0 == 0);
```

```
return true && true;
```

We all know that `true && true`

is simply `true`

, and this shows that for our example, 4 is a power of 2.

## Best Solution

First, you have to do some sort of range reduction. Trig functions are periodic, so you need to reduce arguments down to a standard interval. For starters, you could reduce angles to be between 0 and 360 degrees. But by using a few identities, you realize you could get by with less. If you calculate sines and cosines for angles between 0 and 45 degrees, you can bootstrap your way to calculating all trig functions for all angles.

Once you've reduced your argument, most chips use a CORDIC algorithm to compute the sines and cosines. You may hear people say that computers use Taylor series. That sounds reasonable, but it's not true. The CORDIC algorithms are much better suited to efficient

hardwareimplementation. (Softwarelibraries may use Taylor series, say on hardware that doesn't support trig functions.) There may be some additional processing, using the CORDIC algorithm to get fairly good answers but then doing something else to improve accuracy.There are some refinements to the above. For example, for very small angles theta (in radians), sin(theta) = theta to all the precision you have, so it's more efficient to simply return theta than to use some other algorithm. So in practice there is a lot of special case logic to squeeze out all the performance and accuracy possible. Chips with smaller markets may not go to as much optimization effort.