# Rust - left shift operator assignment

The Bitwise left shift assignment operator (<<=) assigns the first operand a value equal to the result of Bitwise left shift operation of two operands.

(x <<= y) is equivalent to (x = x << y)

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 2^{y}**.

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 mut x = 1000; //left shift assignment operation x <<= 2; //Displaying the result println!("x = {}", x); }

The output of the above code will be:

x = 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 assignment 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 <<= 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