Difference Between ≫≫≫ and ≫≫

Difference between and in Scala

The >> operator preserves the sign (sign-extends), while >>> zeroes the leftmost bits (zero-extends).

-10>>2
res0: Int = -3
-10>>>2
res1: Int = 1073741821

Try it out yourself.

This is not necessary in languages like C which has signed and unsigned types, unlike Java, which also has >>> (because it has no unsigned integers).

What is the difference between operator in Java and JavaScript?

Both are the logical right shift, but JavaScript has some weirdness in how it handles numbers. Normally numbers in JavaScript are floats, but the bitwise operations convert them to unsigned 32 bit integers. So even though the value looks like it shouldn't change, it converts the number to a 32 bit unsigned integer.

The value that you see 4294843840 is just the same bits as -123456, but interpreted as unsigned instead of signed.

what does mean in java?

The >>> operator is the unsigned right bit-shift operator in Java. It effectively divides the operand by 2 to the power of the right operand, or just 2 here.

The difference between >> and >>> would only show up when shifting negative numbers. The >> operator shifts a 1 bit into the most significant bit if it was a 1, and the >>> shifts in a 0 regardless.

UPDATE:

Let's average 1 and 2147483647 (Integer.MAX_VALUE). We can do the math easily:

(1 + 2147483647) / 2 = 2147483648 / 2 = 1073741824

Now, with the code (low + high) / 2, these are the bits involved:

          1: 00000000 00000000 00000000 00000001
+2147483647: 01111111 11111111 11111111 11111111
================================================
-2147483648: 10000000 00000000 00000000 00000000  // Overflow
/2
================================================
-1073741824: 11000000 00000000 00000000 00000000  // Signed divide, same as >> 1.

Let's make the "shift" to >>>:

          1: 00000000 00000000 00000000 00000001
+2147483647: 01111111 11111111 11111111 11111111
================================================
-2147483648: 10000000 00000000 00000000 00000000  // Overflow
>>> 1
================================================
+1073741824: 01000000 00000000 00000000 00000000  // Unsigned shift right.

What is the difference between ' ' and ' / ' , shifting and division in java

No, absolutely not the same.

You can use >> to divide, yes, but just by 2, because >> shift all the bits to the right with the consequence of dividing by 2 the number.

This is just because of how binary base operations work. And works for unsigned numbers, for signed ones it depends on which codification are you using and what kind of shift it is.

eg.

122 = 01111010 >> 1 = 00111101 = 61

The difference between logical shift right, arithmetic shift right, and rotate right

First remember that machine words are of fixed size. Say 4, and that your input is:

+---+---+---+---+
| a | b | c | d |
+---+---+---+---+

Then pushing everything one position to the left gives:

+---+---+---+---+
| b | c | d | X |
+---+---+---+---+

Question what to put as X?

with a shift put 0
with rotate put a

Now push everything one position to the right gives:

+---+---+---+---+
| X | a | b | c |
+---+---+---+---+

Question what to put as X?

with a logical shift put 0
with an arithmetic shift put a
with rotate put d

Roughly.

Logical shift correspond to (left-shift) multiplication by 2, (right-shift) integer division by 2.

Arithmetic shift is something related to 2's-complement representation of signed numbers. In this representation, the sign is the leftmost bit, then arithmetic shift preserves the sign (this is called sign extension).

Rotate has no ordinary mathematical meaning, and is almost an obsolete operation even in computers.

Using echo; What is difference between and

When echoing something to a file, >> appends to the file and > overwrites the file.

$ echo foobar > test
$ cat test
foobar
$ echo baz >> test
$ cat test
foobar
baz
$ echo foobar > test
$ cat test
foobar

From the example you posted, a log directory is created and then *.log is put into log/.gitignore so that no log files are committed to git. Since > was used, if a .gitignore file had existed, it would be overwritten with only *.log.

The log directory itself is then added to your local git stage.

On the next line, >> is added so that tmp is appended to the end of the .gitignore file instead of overwriting it. It is then added to the staging area.

what's the difference between bitwise shift with 2 arrows and 3 arrows?

Double Arrows ">>" and Triple Arrows ">>>" are defined on 32-bit integers, so performing these on a variable will "convert" them so-to-speak from non-numbers, to numbers. Additionally, javascript numbers are stored as double precision floats, so these operations will also cause you to lose any precision bits higher than 32 . ">>" maintains the sign bit (result is a signed integer), while ">>>" does not (result is an unsigned integer).

http://msdn.microsoft.com/en-us/library/342xfs5s%28v=vs.94%29.aspx

For a much better explanation: https://stackoverflow.com/a/1822769/780399

Are the shift operators ( , ) arithmetic or logical in C?

According to K&R 2nd edition the results are implementation-dependent for right shifts of signed values.

Wikipedia says that C/C++ 'usually' implements an arithmetic shift on signed values.

Basically you need to either test your compiler or not rely on it. My VS2008 help for the current MS C++ compiler says that their compiler does an arithmetic shift.

Difference Between ≫≫≫ and ≫≫