-ve binary literals

[ghost]

0b1111111111111111 is the representation of -1 as
Convert.ToString((short)-1, 2)
shows, but C# refuses this code:
short x = 0b1111111111111111;
It only accepts:
short x = - 0b1;
Why can't we use the exact binary representation?

11111111 is the binary number that can represent 255 for Byte , or -1 for SByte. C# and VB.NET can take this in consederation. Or at least give it a new symbole: 0nb1111_1111.
I don't want to remove the -ve sign. It makes things easy when one knows a +ve no. and want to negate it. But things get ugly when in the opposite situation, when one has the -ve binary no in first place!

[MkazemAkhgary]

Its twos complement representation. And thats also a common way to store signed numbers in hardware level. Because its simpler to implement.

I think the reason it doesnt work for you is because that number magnitude is higher than short range, it then tries to cast value to short but there is arithmetic overflow in evaluating constant number.

You can either go to advanced project settings to disable check for arithmetic overflow (warning: it affects entire project and can change behavior of your program. Make sure there is no unintended arithmetic overflow anywhere hapening in your project)

https://msdn.microsoft.com/en-us/library/s4wcexbc.aspx

Or explicitly write this. Which is better because it doesnt affect rest of your program.

short x = unchecked((short)0b1111111111111111);

[svick]

@MkazemAkhgary

You can either go to advanced project settings to disable check for arithmetic overflow

That doesn't help. That option is disabled by default, but it doesn't apply to constant values.

[ghost]

@MkazemAkhgary
Thanks. I got that this representation comes from 0 - 1 in binary. I was confused with the way we calculate the decimal value of a +ve binary no.
Writing the -ve binary representation as a literal may make testing some values easer. Of course one can use the convert class to do so, but it is a bit verbose.

[gafter]

All numeric literals in C# are nonnegative.

A binary number is a nonnegative value specified in base 2. It is not "two's complement", as it cannot be negative. If you attempt to produce the bitwise representation of a negative number, you end up writing a number larger than can be represented as an int.

[ghost]

@gafter
11111111 is the binary number that can represent 255 for Byte , or -1 for Sbyte. C# and VB.NET can take this in consederation.

[gafter]

11111111 is a number, not a representation. I don’t think we want numbers that are positive as written to magically become negative when run.

[ghost]

This is the binary system. It has no sign beacuase transistors can only be on or off. All of the programming world is represented as 0s and 1s eventually.
We can write numbers as decimals. But if someone tries to test some binary operations on binary numbers, putting -ve signs will not help, beacuase he will have to do more math to convert negative numbers into corresponding +ve ones, suppose he know what are the -ve numbers in first place.
For example: how you write this 11100110?
Thus, c# should guve the full implementation so that the new binary literal has its full potential.

[ghost]

By the way, I don't want to remove the -ve sign. It makes things easy when one knows a +ve no. and want to negate it. But things get ugly when in the opposite situation, when one has the -ve binary no in first place!

[ghost]

If you try:
sbyte n = Convert.ToSByte("11111111", 2);
n will contain -1. But if you try:
sbyte n = Convert.ToSByte("-01111100", 2);
it will raise the exception:

'String cannot contain a minus sign if the base is not 10.'

This is how binary system works.

[tannergooding]

I have an existing proposal for this: #717

The existing concern is the potentially Confusing behavior around overload resolution

[ghost]

I don't see any confusion. If var is used, the number can be assumed to be the shortest positve type, otherwise the programmer should clear his intentions.

[tannergooding]

It cannot, as that is a breaking change. I'm currently on my phone, but can provide better examples later tonight after I get home.

[gafter]

@MohammadHamdyGhanem The C# programming language and the Convert API are not the same thing.

Binary numbers are specified in a C# binary literal using Unicode characters, not bits using two's complement notation. The rightmost digit position is a one, the next position is a two, and so on. There are no negative positions. No matter what base you are specifying your number in (16, 10, 8, or 2), without a negative sign the number isn't negative. That's just the way numbers are specified in different bases. We don't have a notation to let you specify the representation of the number you want.

In any case, we could not change this even if we wanted to. It would cause a breaking change in overload resolution.

[ghost]

@gafter:
The awy you make simplist things comlicated :) !
So, at least give it a new symbole: 0nb1111_1111. Once there is an intention, nothing can't be solved!
thanks.

This ssue is related to the same area:
https://github.com/dotnet/corefx/issues/26826

[gafter]

Yes, a new notation for two's complement number would address this.

[jnm2]

The awy you make simplist things comlicated :) !

He is actually averting a significantly more complicated set of problems in the future which the "simple" (myopic) change would cause.

[DavidArno]

Yes, a new notation for two's complement number would address this.

I'm not sure I like this idea. Whilst 2's complement is near-ubiquitous these days, it's still an CPU-implementation detail and, as such, should not be of concern except in real edge cases. Do such edge cases really justify a new language feature?

[ghost]

@DavidArno
What is the goal of adding the binary literal in first place?.. Programmers have lived years without it. If it is away to simplify dealing with binary system instead of using the Convert class, so it's not a complete feature, and we still have to use the convert class in some cases. This is practically what happend to me. I was testing the Vector.ConditionalSelect function, so I needed to check some results by using binary numbers. I couldn't represent negative binaries directly, and discoverd also that the Convert.ToString method can't convert a binary number to sbyte. So, practicaly, I didn't find it easy and fast to work with existing tools, and had to work around.
Please remember that not all programing is for business. There are students and others who can use progrsmming languages to test results, solve problems, buildind calculators, or simulate some systems. In Eygpt, 9th grade and high school students stududy Vb.net, and some collage students study vb.net, c# or c++. I think this is rhe case in many countries all over the world.
The popularity of vb.net and c# is beyound professional programmers. Millions are using them in small tasks that aid there work and don't even require building applications.
C# and vb.net are general purpose languages, so, if you add a feature it is better be complete and easy to use.
Thanks

[MkazemAkhgary]

I'm not sure what do you mean by -ve and +ve. what does it stand for❓ I don't understand.

and what is stopping you from doing simple - 0b1?

If you have difficulties solving your problem it maybe better to directly address that instead of requesting a feature and hoping for it to be released. even if you convince the team to make this happen, its going to take some time. I guess you want to solve your problem sooner than this.

[DavidArno]

@MohammadHamdyGhanem,

What is the goal of adding the binary literal in first place?

For handling bit-mapped values. In every case I can think of, those values are unsigned numbers. And there is already very good support for bitmapped operations in the language.

It's trying to mix bit-mapped values and negative numbers that I see as the extreme edge case and that therefore doesn't justify language support.

Regarding your use-case of Vector.ConditionalSelect, I do not know how the method works, but "integral mask vector" sounds like a bit pattern. As such, int is a poor choice of type; the designer of the method should have used uint. But you can cast from an unsigned int to a signed one, allowing you to use such bit patterns in such situations:

uint value = 0b11111111111111111111111111111111;
var value2 = (int)value;
Console.WriteLine(value2); // prints -1

Or you can just use unchecked to convert them directly:

unchecked
{
    var value = (int)0b11111111111111111111111111111111u;
    Console.WriteLine(value); // prints -1
}

[DavidArno]

@MkazemAkhgary,

I'm not sure what do you mean by -ve and +ve. what does it stand for❓ I don't understand.

They are just abbreviations for negative and positive, respectively.

[jnm2]

Apparently - means negati and + means positi. Looks weird for sure.

[DavidArno]

@jnm2,

It's good old RAS Syndrome in action.

[jnm2]

Ha! Never knew the term for that!

[ghost]

@MkazemAkhgary
I always find a way to solve my problems. If I've waited for Microsoft to solve everything I wouldn't write any code!
For example, I had to use in-memory file to concatenate large arrays before vb6 introduces the Join function!
A few years ago, I customized an open source help viewer for my usage, becuase I hate the small font used in helpviwer. It worked fine on 32 bit win but failed on 64 bit. After some debugging using reflection, I discovered a bug in one internal class in the framework and reported it, showing the lines of code that have the bug and how to fix it. The person who replayed asked me: Is there anyone uses this class?
Yes, obviously me and the Microsoft team who wrote the open source project in first place!.
I'm not sure if the bug is fixed, but I solved my problem by writing a few wrapper classes that replace some of the internal framework classes and do nothing but invoking the original methods via reflection, exept for only one method that contains the bug, which I copied its original code and fixed the bug. This was before entering the open source era. So, I don't really rely on. Net team to solve my problems. I only seek perfecion for my favorite programming languages. And it will be nice to save my time writing strange wrappers to fix forgotten bugs!
Worest, I suggested a general solution to such these bugs. The problem came becuase the registry returns a file path containing system variables on win 64 which is not the case on win 32 (something related to wow64). This can produce problems in old methods that deal with file and directory pathes stored in the registery. I suggested to make any method that opens files and directories in SYSTEM.IO Namespace resolve system varisbles first before trying to open any path. No one caired as usual!

[ghost]

+ve and -ve are famous betwwen engineers.
https://www.quora.com/What-do-ve-and-+ve-mean

[jveselka]

@MohammadHamdyGhanem

+ve and -ve are famous betwwen engineers.

Is that so? Still, I see no reason to use them in issue title especialy short as this one.

[MkazemAkhgary]

I think software engineers are far different than hardware engineers. 😄