Exponential operator

[Don]

Bill Baxter wrote:
> On Fri, Aug 7, 2009 at 3:50 AM, Lars T.
> Kyllingstad<public at kyllingen.nospamnet> wrote:
>> In the 'proposed syntax change' thread, Don mentioned that an exponentiation
>> operator is sorely missing from D. I couldn't agree more.
>>
>> Daniel Keep has proposed the syntax
>>
>>  a*^b
>>
>> while my suggestion was
>>
>>  a^^b
>>
>> Neither of the natural candidates, a^b and a**b, are an option, as they are,
>> respectively, already taken and ambiguous.
>>
>> "Why do we need this?" you say. "Isn't pow(a,b) good enough?" And yes,
>> pow(a,b) is just as good as mul(a,b) or div(a,b), but we don't use those, do
>> we? Exponentiation is a very common mathematical operation that deserves its
>> own symbol. Besides, bearophile has pointed out several optimisations that
>> the compiler can/must perform on exponential expressions.
>>
>> He also proposed that the overload be called opPower.
>>
>> What do you think?
> 
> I'm all for it.
> But if we can't get that, then it might be nice to have at least
> squaring and cubing template functions in std.math.  Squaring numbers
> is so common it deserves a direct way.  It always annoys me when I
> have to write
>    float x = (some expression);
>    float x2 = x*x;
> When I'd like to be able to just write (some expression)^^2.
> sqr(some expression) would be ok, too.  It's odd that sqrt and cbrt
> exist in the std C math library but not their inverses.

Yes, it's powers of 2 and 3 that are 90% of the use cases.
Squaring is a really common operation (more common than xor). An 
optimising compiler always needs to recognize it.

> I found this list of languages with an exponentiation operator:
> # x ↑ y:  Algol,  Commodore BASIC
> # x ^ y: BASIC, J, Matlab, R, Microsoft Excel, TeX (and its
> derivatives), Haskell (for integer exponents), and most computer
> algebra systems
> # x ** y: Ada, Bash, Fortran, FoxPro, Perl, Python, Ruby, SAS, ABAP,
> Haskell (for floating-point exponents), Turing
> # x * y: APL
> 
> --bb

I personally don't understand why anyone would like ** as an 
exponentiation operator. The only thing in its favour is that that's 
what Fortran did. And Fortran only used it because it had almost no 
characters to choose from.  ↑ is the best (yup, I had a C64).
^ is the next best, but unfortunately C grabbed it for xor. I think ^^ 
is the best available option.

Aside from the fact that x**y is ambiguous (eg, x***y could be x ** (*y) 
or x * (*(*y)) ), I just think ^^ looks better:

assert( 3**3 + 4**3  + 5**3 == 6**3 );

assert( 3^^3 + 4^^3  + 5^^3 == 6^^3 );


Found an old discussion, pragma proposed ^^ and opPower:
http://www.digitalmars.com/d/archives/digitalmars/D/18742.html#N18742
The fact that exactly the same proposal came up again is encouraging -- 
it's moderately intuitive.

For overloading, by analogy to opAdd(), opSub(), opMul(), opDiv() it 
should probably be opPow().