# Rust - left shift operator

The Bitwise left shift operator (<<) takes the two numbers and left shift the bits of first operand by number of place specified by second operand. For example: for left shifting the bits of x by y places, the expression (x<<y) can be used. It is equivalent to multiplying x by 2y.

The example below describes how left shift operator works:

```1000 << 2 returns 4000

(In Binary)
1000         ->    1111101000
<< 2                     |  left shift the bits
-----                    V  by 2 places
4000         <-  111110100000
(In Binary)
```

The code of using left shift operator (<<) is given below:

```fn main() {
let x = 1000;

//left shift operation
let z = x << 2;

//Displaying the result
println!("z = {}", z);
}
```

The output of the above code will be:

```z = 4000
```

### Example: Count number of 1 Bits in a positive integer

Consider an integer 1000. In the bit-wise format, it can be written as 1111101000. However, all bits are not written here. A complete representation will be 32 bit representation as given below:

```00000000000000000000001111101000
```

Bitwise AND operation with 1 at any bit results into 1 if the bit is 1 or 0 if the bit is 0. Performing such operation at every bit, and counting the number of 1 gives the count of 1 bits in the given positive integer. To achieve this bitwise left shift operator can be used as shown in the example below:

```fn count_one_bits(n: i32) -> i32{
let mut mask = 1;
let mut count = 0;

//performing bitwise AND operation
//at every bit of the number
for i in 0..31 {
if((mask & n) == mask) {
count += 1;
}
mask = mask << 1;
}
return count;
}

fn main() {
println!("count_one_bits(1000) = {}", count_one_bits(1000));
println!("count_one_bits(1023) = {}", count_one_bits(1023));
}
```

The above code will give the following output:

```count_one_bits(1000) = 6
count_one_bits(1023) = 10
```

❮ Rust - Operators

5