www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - typing base ^^ exp

reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
I've tested the typing rules for ^^ and they seem wanting. One painful 
example:

     int a2 = 3, b2 = -2;
     writeln(typeof(a2 ^^ b2).stringof);
     writeln(a2 ^^ b2);

The program writes:

int
zsh: floating point exception  ./test.d

Ouch. Here's what I suggest:

====
The type of  the power expression is:  uint  if  both  base  and  exp 
have unsigned  types less  than  ulong ;  int   if  base  is  a signed
integer  less than   long  and   exp  is  an unsigned  type  less than
 ulong ;  ulong  if  both  base  and  exp  have  unsigned types and at
least  one is   ulong ;  long   if  base   is  long   and  exp   is an
unsigned  type; and  double   for all  other combinations  of integral
 base  and  exp . If at least one of the operands has a floating point
type,  the result  type is  the largest  participating  floating point
type.
====

Makes sense?


Andrei
Feb 14 2010
next sibling parent reply BCS <none anon.com> writes:
Hello Andrei,

 The type of  the power expression is:  uint  if  both  base  and  exp 
 have unsigned  types less  than  ulong ;  int   if  base  is  a signed
 integer  less than   long  and   exp  is  an unsigned  type  less than
  ulong ;  ulong  if  both  base  and  exp  have  unsigned types and at
 least  one is   ulong ;  long   if  base   is  long   and  exp   is an
 unsigned  type; and  double   for all  other combinations  of integral
  base  and  exp . If at least one of the operands has a floating point
 type,  the result  type is  the largest  participating  floating point
 type.
 ====
 Makes sense?
 

It might if my brain was willing to parse out the 's :) -- <IXOYE><
Feb 14 2010
next sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
BCS wrote:
 Hello Andrei,
 
 The type of  the power expression is:  uint  if  both  base  and  exp 
 have unsigned  types less  than  ulong ;  int   if  base  is  a signed
 integer  less than   long  and   exp  is  an unsigned  type  less than
  ulong ;  ulong  if  both  base  and  exp  have  unsigned types and at
 least  one is   ulong ;  long   if  base   is  long   and  exp   is an
 unsigned  type; and  double   for all  other combinations  of integral
  base  and  exp . If at least one of the operands has a floating point
 type,  the result  type is  the largest  participating  floating point
 type.
 ====
 Makes sense?

It might if my brain was willing to parse out the 's :)

Word. I'm looking at 460 pages worth of those. Andrei
Feb 14 2010
parent BCS <none anon.com> writes:
Hello Andrei,

 BCS wrote:
 
 It might if my brain was willing to parse out the  's :)
 


How much do you spend on asprin? :) -- <IXOYE><
Feb 14 2010
prev sibling parent Michel Fortin <michel.fortin michelf.com> writes:
On 2010-02-14 18:38:18 -0500, BCS <none anon.com> said:

 Hello Andrei,
 
 The type of  the power expression is:  uint  if  both  base  and  exp 
 have unsigned  types less  than  ulong ;  int   if  base  is  a signed
 integer  less than   long  and   exp  is  an unsigned  type  less than
  ulong ;  ulong  if  both  base  and  exp  have  unsigned types and at
 least  one is   ulong ;  long   if  base   is  long   and  exp   is an
 unsigned  type; and  double   for all  other combinations  of integral
  base  and  exp . If at least one of the operands has a floating point
 type,  the result  type is  the largest  participating  floating point
 type.
 ====
 Makes sense?
 

It might if my brain was willing to parse out the 's :)

It's much more readable this way: === The type of the power expression is: * 'uint' if both 'base' and 'exp' have unsigned types less than 'ulong'; * 'int' if 'base' is a signed integer less than 'long' and 'exp' is an unsigned type less than 'ulong'; * 'ulong' if both 'base' and 'exp' have unsigned types and at least one is 'ulong'; * 'long' if 'base' is 'long' and 'exp' is an unsigned type; and * 'double' for all other combinations of integral 'base' and 'exp'. If at least one of the operands has a floating point type, the result type is the largest participating floating point type. === So "2 ^^ 2" returns a double while "2 ^^ 2u" returns an int... sound strange, but it makes sense in a way, I'm not sure it's a good idea to have signed and unsigned operate in such different ways given how many people tell you to not use unsigned integers unless it's really necessary. You're obviously worried about things like 3 ^^ -2 here, I'd be more tempted to define 3 ^^ -2 as 0, same as (1/3)^^2u. But I don't have a strong opinion about this. -- Michel Fortin michel.fortin michelf.com http://michelf.com/
Feb 14 2010
prev sibling next sibling parent Don <nospam nospam.com> writes:
Andrei Alexandrescu wrote:
 I've tested the typing rules for ^^ and they seem wanting. One painful 
 example:
 
     int a2 = 3, b2 = -2;
     writeln(typeof(a2 ^^ b2).stringof);
     writeln(a2 ^^ b2);
 
 The program writes:
 
 int
 zsh: floating point exception  ./test.d
 
 Ouch. Here's what I suggest:
 
 ====
 The type of  the power expression is:  uint  if  both  base  and  exp 
 have unsigned  types less  than  ulong ;  int   if  base  is  a signed
 integer  less than   long  and   exp  is  an unsigned  type  less than
  ulong ;  ulong  if  both  base  and  exp  have  unsigned types and at
 least  one is   ulong ;  long   if  base   is  long   and  exp   is an
 unsigned  type; and  double   for all  other combinations  of integral
  base  and  exp . If at least one of the operands has a floating point
 type,  the result  type is  the largest  participating  floating point
 type.
 ====
 
 Makes sense?

The problem with this rule is (if I understand correctly) that a2 ^^ 2 has type of double. It's crucial that x ^^ 2 has the same type as x. The annoying thing is that positive literal integers are of type int. The existing behaviour is intentional (it's an intentionally generated divide error), although the error should be moved to compile time. The idea is that int ^^ int should be illegal. Only int ^^ uint should be valid. The code above would therefore generate a compile-time error for any circumstance where it is possible for the exponent to be negative. Range-checking isn't yet fully implemented though. Currently it only gives an error if the value of y is known at compile-time. The intended behaviour is: -1 ^^ exp where exp is an integer is transformed into (exp & 1)? -1 : 1; 1 ^^ exp where exp is an integer is transformed into (exp, 1). Otherwise, if both base and exp are integral types, and exp cannot be implicitly converted to an unsigned, a compile time error occurs. Whenever base ^^ exp is defined, typeof(base ^^ exp) is always the same as typeof(base * exp).
Feb 14 2010
prev sibling parent "Simen kjaeraas" <simen.kjaras gmail.com> writes:
Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> wrote:

 ====
 The type of  the power expression is:  uint  if  both  base  and  exp 
 have unsigned  types less  than  ulong ;  int   if  base  is  a signed
 integer  less than   long  and   exp  is  an unsigned  type  less than
  ulong ;  ulong  if  both  base  and  exp  have  unsigned types and at
 least  one is   ulong ;  long   if  base   is  long   and  exp   is an
 unsigned  type; and  double   for all  other combinations  of integral
  base  and  exp . If at least one of the operands has a floating point
 type,  the result  type is  the largest  participating  floating point
 type.
 ====

 Makes sense?

I believe any and all powExps with integral base and exp should yield an integral result. If you want a double, you ask for it with a cast. Especially, as Don pointed out, when positive integral literals in D are typed as int. "WTF? foo( 2^^2 ) complains about doubles? It don't do that when I do uint x = 2; foo( 2^^x )!" -- Simen
Feb 15 2010