No operators defined on ushort

[Axel Dahmen]

Hi,

I want to start a technical discussion on the fact that C# doesn't define
any mathematical operators on other integral types than int.

Simple things like the following just aren't possible in C#:

ushort a,b,c;

a = b = 0;
c = a - b;

Whatever integral data type you use, you'll always get an error "can't
implicitly convert to int." What's the purpose of this?? If the language
provides types like byte or ushort I want to use them. I want to see
overflow errors whenever routines miscalculate something.

What the compiler does here is technically and mathematically incomplete.
And it should be fixed ASAP.

Anyone?

Axel Dahmen

[Yves Tourchot]

Take a look at these:

http://msdn.microsoft.com/library/de...vclrfshort.asp
http://msdn.microsoft.com/library/de...conversion.asp
"Axel Dahmen" <No****@NoOneKn ows.de> wrote in message
news:ex******** ******@tk2msftn gp13.phx.gbl...

Hi,

I want to start a technical discussion on the fact that C# doesn't define
any mathematical operators on other integral types than int.

Simple things like the following just aren't possible in C#:

ushort a,b,c;

a = b = 0;
c = a - b;

Whatever integral data type you use, you'll always get an error "can't
implicitly convert to int." What's the purpose of this?? If the language
provides types like byte or ushort I want to use them. I want to see
overflow errors whenever routines miscalculate something.

What the compiler does here is technically and mathematically incomplete.
And it should be fixed ASAP.

Anyone?

Axel Dahmen

[Axel Dahmen]

Well, Yves, I know these documents. Though they explain the effect itself
and how to deal with C#'s incomplete data type implementation, they don't
discuss the fact that the missing operators render C# incomplete.

Here is my point of view: Mathematically and in Informatics science, a
native scalar data type establishes a K vector space. - In C#, only the
integer data type fulfills this requirement. All other integral C# data
types are crippled so far.

Regarding this aspect, C# is faulty. To get a truly comprehensive (a
"valid") language, C# needs to add operators to all native scalar data
types.

I might be wrong, but in case I'm not, the arguments in this discussion
should lead to implementing the missing operators into C#.

-----------------------------------
"Yves Tourchot" <de************ ****@sympatico. ca> schrieb im Newsbeitrag
news:ez******** ************@ne ws20.bellglobal .com...

Take a look at these:

http://msdn.microsoft.com/library/de...us/csref/html/
vclrfshort.asp http://msdn.microsoft.com/library/de...us/csref/html/
vclrfimplicitnu mericconversion .asp

"Axel Dahmen" <No****@NoOneKn ows.de> wrote in message
news:ex******** ******@tk2msftn gp13.phx.gbl...

Hi,

I want to start a technical discussion on the fact that C# doesn't define any mathematical operators on other integral types than int.

Simple things like the following just aren't possible in C#:

ushort a,b,c;

a = b = 0;
c = a - b;

Whatever integral data type you use, you'll always get an error "can't
implicitly convert to int." What's the purpose of this?? If the language
provides types like byte or ushort I want to use them. I want to see
overflow errors whenever routines miscalculate something.

What the compiler does here is technically and mathematically incomplete. And it should be fixed ASAP.

Anyone?

Axel Dahmen

[Jon Skeet [C# MVP]]

Axel Dahmen <No****@NoOneKn ows.de> wrote:

Well, Yves, I know these documents. Though they explain the effect itself
and how to deal with C#'s incomplete data type implementation, they don't
discuss the fact that the missing operators render C# incomplete.

Here is my point of view: Mathematically and in Informatics science, a
native scalar data type establishes a K vector space. - In C#, only the
integer data type fulfills this requirement. All other integral C# data
types are crippled so far.

Regarding this aspect, C# is faulty. To get a truly comprehensive (a
"valid") language, C# needs to add operators to all native scalar data
types.

I might be wrong, but in case I'm not, the arguments in this discussion
should lead to implementing the missing operators into C#.

I think the arguments in this discussion would be much better placed if
they were concerned with usefulness rather than academic completeness.

Whether or not C#'s non-int data types are "crippled" doesn't seem to
have stopped people writing C# code which works, does it? The question
shouldn't be whether or not C# is "incomplete ", it's whether it can be
made potentially *more* useful than it already is.

I would certainly be interested to hear from the language authors on
why these choices were made, but if there are some appropriate
practical reasons, I for one have no problem in sacrificing
"completene ss" for "usefulness ".

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[mikeb]

Axel Dahmen wrote:

Well, Yves, I know these documents. Though they explain the effect itself
and how to deal with C#'s incomplete data type implementation, they don't
discuss the fact that the missing operators render C# incomplete.

Here is my point of view: Mathematically and in Informatics science, a
native scalar data type establishes a K vector space. - In C#, only the
integer data type fulfills this requirement. All other integral C# data
types are crippled so far.

Regarding this aspect, C# is faulty. To get a truly comprehensive (a
"valid") language, C# needs to add operators to all native scalar data
types.

I might be wrong, but in case I'm not, the arguments in this discussion
should lead to implementing the missing operators into C#.

ANSI C and C++ also always perform integer arithmetic using int (or
larger) types. It's just that in these languages you do not get an
error when assigning an int into a smaller integral type (you might get
a warning, though). The C# language designers decided that silently
truncating integral values was the source of enough bugs that they do
not allow implicit conversions if the conversion can potentially lose data.


-----------------------------------
"Yves Tourchot" <de************ ****@sympatico. ca> schrieb im Newsbeitrag
news:ez******** ************@ne ws20.bellglobal .com...

Take a look at these:

http://msdn.microsoft.com/library/de...us/csref/html/
vclrfshort.asp

http://msdn.microsoft.com/library/de...us/csref/html/
vclrfimplicitnu mericconversion .asp

"Axel Dahmen" <No****@NoOneKn ows.de> wrote in message
news:ex****** ********@tk2msf tngp13.phx.gbl. ..

Hi,

I want to start a technical discussion on the fact that C# doesn't
define
any mathematical operators on other integral types than int.

Simple things like the following just aren't possible in C#:

ushort a,b,c;

a = b = 0;
c = a - b;

Whatever integral data type you use, you'll always get an error "can't
implicitly convert to int." What's the purpose of this?? If the language
provides types like byte or ushort I want to use them. I want to see
overflow errors whenever routines miscalculate something.

What the compiler does here is technically and mathematically
incomplete.
And it should be fixed ASAP.

Anyone?

Axel Dahmen

--
mikeb

[Kenneth Baltrinic]

The following works for me. It would seem that the subtraction operator is
defined but returns an int. Go figure.

ushort a,b,c;
a = b = 0;
c = (ushort)(a - b);
--Ken

"Axel Dahmen" <No****@NoOneKn ows.de> wrote in message
news:ex******** ******@tk2msftn gp13.phx.gbl...

Hi,

I want to start a technical discussion on the fact that C# doesn't define
any mathematical operators on other integral types than int.

Simple things like the following just aren't possible in C#:

ushort a,b,c;

a = b = 0;
c = a - b;

Whatever integral data type you use, you'll always get an error "can't
implicitly convert to int." What's the purpose of this?? If the language
provides types like byte or ushort I want to use them. I want to see
overflow errors whenever routines miscalculate something.

What the compiler does here is technically and mathematically incomplete.
And it should be fixed ASAP.

Anyone?

Axel Dahmen

[Axel Dahmen]

Jon,

adding the missing operators has practical impact, of course. First of all
it would make an end to the clumsy spelling. Furthermore, ask yourself: Why
are the smaller integral types implemented into a language anyway?

However, your view regarding practical issues is wrong because this
discussion is not about the semantics of .NET, the syntax of C# or Visual
Studio features but about C#'s completelyness. Just because people write
programs in C# and these programs work doesn't mean everything in the
language is correct. I might say for one, the job simply isn't done yet.

------------------------------------------------------------------
"Jon Skeet [C# MVP]" <sk***@pobox.co m> schrieb im Newsbeitrag
news:MP******** *************** *@msnews.micros oft.com...

Axel Dahmen <No****@NoOneKn ows.de> wrote:

Well, Yves, I know these documents. Though they explain the effect itself and how to deal with C#'s incomplete data type implementation, they don't discuss the fact that the missing operators render C# incomplete.

Here is my point of view: Mathematically and in Informatics science, a
native scalar data type establishes a K vector space. - In C#, only the
integer data type fulfills this requirement. All other integral C# data
types are crippled so far.

Regarding this aspect, C# is faulty. To get a truly comprehensive (a
"valid") language, C# needs to add operators to all native scalar data
types.

I might be wrong, but in case I'm not, the arguments in this discussion
should lead to implementing the missing operators into C#.

I think the arguments in this discussion would be much better placed if
they were concerned with usefulness rather than academic completeness.

Whether or not C#'s non-int data types are "crippled" doesn't seem to
have stopped people writing C# code which works, does it? The question
shouldn't be whether or not C# is "incomplete ", it's whether it can be
made potentially *more* useful than it already is.

I would certainly be interested to hear from the language authors on
why these choices were made, but if there are some appropriate
practical reasons, I for one have no problem in sacrificing
"completene ss" for "usefulness ".

[Axel Dahmen]

No, they both don't perform integer arithmetic using int (if they do, it's a
a compiler peculiarity, not a language feature). And you don't get a warning
either.

I guess if someone's choosing a particular data type, he's aware of its
peculiarities. In fact, he might be using it *because* of its peculiarities.
If he doesn't, he might simply use int anyway.

The .NET runtime may perform its integral calculations internally by using
int on PC platforms; however, I don't mind. I want to discuss about C# as a
platform independant language and some lack therein.
--------------------------------
"mikeb" <ma************ @mailnull.com> schrieb im Newsbeitrag
news:#W******** ******@TK2MSFTN GP09.phx.gbl...

Axel Dahmen wrote:

Well, Yves, I know these documents. Though they explain the effect itself and how to deal with C#'s incomplete data type implementation, they don't discuss the fact that the missing operators render C# incomplete.

Here is my point of view: Mathematically and in Informatics science, a
native scalar data type establishes a K vector space. - In C#, only the
integer data type fulfills this requirement. All other integral C# data
types are crippled so far.

Regarding this aspect, C# is faulty. To get a truly comprehensive (a
"valid") language, C# needs to add operators to all native scalar data
types.

I might be wrong, but in case I'm not, the arguments in this discussion
should lead to implementing the missing operators into C#.

ANSI C and C++ also always perform integer arithmetic using int (or
larger) types. It's just that in these languages you do not get an
error when assigning an int into a smaller integral type (you might get
a warning, though). The C# language designers decided that silently
truncating integral values was the source of enough bugs that they do
not allow implicit conversions if the conversion can potentially lose

data.

[Jon Skeet [C# MVP]]

Axel Dahmen <No****@NoOneKn ows.de> wrote:

adding the missing operators has practical impact, of course. First of all
it would make an end to the clumsy spelling.
Do you mean casting?
Furthermore, ask yourself: Why
are the smaller integral types implemented into a language anyway?
I'm not trying to defend the lack of operators on those types - as I
said, I don't know the reasons myself, and would be interested to hear
them. I was suggesting that you were coming at the issue from an
unhelpful angle.
However, your view regarding practical issues is wrong because this
discussion is not about the semantics of .NET, the syntax of C# or Visual
Studio features but about C#'s completelyness. Just because people write
programs in C# and these programs work doesn't mean everything in the
language is correct. I might say for one, the job simply isn't done yet.

It doesn't mean everything in the language is as good as it could be,
but that's a long way from your view that the language is "crippled"
and that it's not "valid" which makes it sound completely unusable.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Eric Gunnerson [MS]]

The runtime only defines operations for number of 4 or 8 byte length. I'm
not one of the CLR architects, but my understanding is that this was done
for a couple of reasons. First, operations on 4 or 8 byte numbers are more
efficient than smaller sizes on many processors. Also, adding in additional
support for smaller types would require more work and complexity both in the
runtime and the JIT.

--
Eric Gunnerson

Visit the C# product team at http://www.csharp.net
Eric's blog is at http://blogs.gotdotnet.com/ericgu/

This posting is provided "AS IS" with no warranties, and confers no rights.
"Axel Dahmen" <No****@NoOneKn ows.de> wrote in message
news:OA******** ******@tk2msftn gp13.phx.gbl...

Well, Yves, I know these documents. Though they explain the effect itself
and how to deal with C#'s incomplete data type implementation, they don't
discuss the fact that the missing operators render C# incomplete.

Here is my point of view: Mathematically and in Informatics science, a
native scalar data type establishes a K vector space. - In C#, only the
integer data type fulfills this requirement. All other integral C# data
types are crippled so far.

Regarding this aspect, C# is faulty. To get a truly comprehensive (a
"valid") language, C# needs to add operators to all native scalar data
types.

I might be wrong, but in case I'm not, the arguments in this discussion
should lead to implementing the missing operators into C#.

-----------------------------------
"Yves Tourchot" <de************ ****@sympatico. ca> schrieb im Newsbeitrag
news:ez******** ************@ne ws20.bellglobal .com...

Take a look at these:

http://msdn.microsoft.com/library/de...us/csref/html/ vclrfshort.asp

http://msdn.microsoft.com/library/de...us/csref/html/ vclrfimplicitnu mericconversion .asp

"Axel Dahmen" <No****@NoOneKn ows.de> wrote in message
news:ex******** ******@tk2msftn gp13.phx.gbl...

Hi,

I want to start a technical discussion on the fact that C# doesn't define any mathematical operators on other integral types than int.

Simple things like the following just aren't possible in C#:

ushort a,b,c;

a = b = 0;
c = a - b;

Whatever integral data type you use, you'll always get an error "can't
implicitly convert to int." What's the purpose of this?? If the language provides types like byte or ushort I want to use them. I want to see
overflow errors whenever routines miscalculate something.

What the compiler does here is technically and mathematically incomplete. And it should be fixed ASAP.

Anyone?

Axel Dahmen