[proposal] :Allow divde by zero

[Xyncgas]

There's meaning dividing things by zero in mathmatics (for one, I am dividing 0 in my research), but it's so hard for me to do this because it's undefined in c#, so instead I had to write hacks to do it.

the way you can do it is, instead of undefined, make it a special type when you divide numbers to zero, then when you multiply that number by zero it casts back. so this would be a good starting point. Ideally if a double was divided by zero the result should be pi_double which has the same length as zero and can perform other arithmetic normally in this type.

The essential part is to remember that this number has been divided by zero, and what number it was divided from. it should be representable in literal too like 12345P which means 12345/0

[Xyncgas]

For those that says this division has no meaning, why would you ever divide by 0, well why would you ever cast your type to object, but regardless it has a meaning in mathematics, and having this as an undefine behavior is like having a hole in value types after 'null' in our references which we know how many dollars it cost us. if people try to cast anything divided by zero back to its original type it should be seen as multiplying it by zero but compiler should say (warn/error) that you should be multiplying it by zero instead of casting it.

[LupusInferni315]

@Xyncgas except that even in mathematics division by 0 is undefined, it is both simultaneously positive and negative infinity as well as every value in between, and multiplying this unknown and undefined value by 0 is still unknown and undefined, something adequately handled by float/double.NaN

[tannergooding]

Also noting, since this thread was revived, that integer divide by zero is a hardware fault. That is, it forces an "exception" at the hardware level. It isn't something that a language or runtime can trivially support.

[Xyncgas]

We can simply convert x/0 to an union case of 'undefined', and multiplying this case (type) to 0 converts the value back to its original form much like putting x in an imaginary domain when divided by 0

[CyrusNajmabadi]

We can simply

how would you 'simply' do that @Xyncgas ?

It certainly can't simply be done with hardware intrinsic types.

and multiplying this case (type) to 0 converts the value back to its original form

I know of no branch of mathematics that works this way. Dividing by zero and then multiplying back out again would never result in the original value.

If you want math to work this way, multiple people have told you how. Define your own type with these semantics. Done. We're not going to do anything in the language to support this. Especially with absolutely no community support, and just a single person claiming they want this because in the math they do, this makes sense to them and them alone.

[HaloFour]

For floating point math dividing by zero produces infinity which is already represented in the language and runtime as double.Infinity, following the IEEE-754 standard behavior.

[YairHalberstadt]

but regardless it has a meaning in mathematics

I think this is a grave misunderstanding of how mathematics works. Certainly one can define axiomatic systems under which division by 0 has a meaning, but there are an infinity of such axiomatic systems and none of them are special.

In the vast majority of commonly used axiomatic systems which are close enough to our intuition for the concept number to be considered to define number systems, division by 0 does not have a meaning. If your research uses a rarer number system where it does, well good for you, but that does not change the fact that for the vast majority of number theories it does not.

Computing tends to use number systems which are very different to those of mathematics. They match our intuitions about how numbers behave far less, but are much more efficiently implementable on physical machines. In these systems which are highly performance optimized allowing for special divided by 0 values is definitely a no go.

[CyrusNajmabadi]

The essential part is to remember that this number has been divided by zero, and what number it was divided from. it should be representable in literal too like 12345P which means 12345/0

This seems very sensible. And it feels like semantics you could have by defining your own numeric type which would then know what this means and how to properly propagate it through all the operations you support.

[CyrusNajmabadi]

Note: the language will definitely not at support for this unless the runtime adds a first class type for this and we feel there will be widespread use of this type.

As an example, we have no current interest in adding language support for System.Half.

[Neme12]

As an example, we have no current interest in adding language support for System.Half.

Why not? :(

[CyrusNajmabadi]

Too niche.

[Neme12]

I don't think it's too niche. It's really common in certain domains (especially machine learning). It's not any more niche than something like sbyte.

[Neme12]

If it was that niche, why would they have added it?

[CyrusNajmabadi]

We'll take that feedback into account. Thanks!

[CyrusNajmabadi]

It seems like I will need to write a formal letter to the dotnet foundation explaining patiently the significance of dividing by 0 in programming and mathematics,

@Xyncgas as I said, this seems like a sensible abstraction. It would, however, likely be very niche. As such, it would be better served by a math library written for this purpose.

so to remind you that programming language and computers serve mathematics, and scientists are the first class citizens they are why these things exist in the first place

Yes. Scientists are first class citizens. However, so are many other groups. And, as mentioned above, this is a very niche feature. We are not likely to do such a feature that has such a small audience, and which can be solved through the use of a library. Thanks

[mburbea]

As already stated, if you are using float or double division by zero already compiles and has a meaning. (1f / 0f = ∞f, 1d / 0d = ∞d). For the non floating point types division by zero is an error CS0020, and changing it would be a breaking change.