On Monday, 4 July 2022 at 10:19:36 UTC, Bastiaan Veelo wrote:

immutable decimalRanks = iota(10).map!(p => 10.pow(p)).array;

This advantage becomes much more clear in, let's say:

immutable long powersOfThree = iota(27).map!(p => 3.pow(p)).array;

Handwritten this is a very long chain of arbitrary numbers and you have to put a very close look, that those are indeed the powers of three.

On Monday, 4 July 2022 at 09:40:45 UTC, Bastiaan Veelo wrote:

immutable decimalRanks = iota(10).map!(p => 10.pow(p)).array;

Your example requires

import std.range; // for iota
import std.algorithm; // for map
import std.math; // for pow of int

Then your example is prone to errors:

immutable decimalRanks = iota(13).map!(p => 10.pow(p)).array; // silent wrap around

(unit)test to the rescue:

auto make_decimal_rank ()
{
   import std.range;
   import std.algorithm;
   import std.math;
   return iota (13).map!(p => 10.pow (p)).array;
}

void main ()
{
   import std.stdio;
   immutable decimalRank = make_decimal_rank;
   decimalRank.writeln;
   typeof (decimalRank).stringof.writeln;
}

unittest {
   enum ar13 = [
         1,
         10,
         100,
         1000,
         10000,
         100000,
         1000000,
         10000000,
         100000000,
         1000000000,
         10000000000,
         100000000000,
         1000000000000
      ];
   pragma (msg, typeof (ar13));
   assert (make_decimal_rank == ar13);
}

Running:

dmd -checkaction=context -unittest -run decrank
long[]
decrank.d(35): [unittest] [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 1410065408, 1215752192, -727379968] != [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000]
1/1 modules FAILED unittests

On Monday, 4 July 2022 at 23:19:27 UTC, kdevel wrote:

immutable decimalRanks = iota(13).map!(p => 10.pow(p)).array; // silent wrap around

To be fair, original example also requires some testing.

On Tuesday, 5 July 2022 at 07:37:35 UTC, Alexandru Ermicioi wrote:
[...]

Sure, but user1234 was never in favor of it. It is prone to the same wrap around which have been avoided by using strings in the first place:

auto sgenDecimalRanks()
{
    auto r = "1";
    auto result = "[";
    foreach (i; 1 .. 13)
    {
        result ~= r;
        if (i < 12)
            result ~= ", ";
        r ~= '0';
    }
    result ~= "]";
    return result;
}

On Monday, 4 July 2022 at 13:03:55 UTC, Dom Disc wrote:
[...]

immutable long powersOfThree = iota(27).map!(p => 3.pow(p)).array;

Really?

immutable long [] powersOfThree = [
      1,
      3,
      3 * 3,
      3 * 3 * 3,
      3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
   ];

On Wednesday, 6 July 2022 at 00:11:58 UTC, kdevel wrote:

immutable long powersOfThree = iota(27).map!(p => 3.pow(p)).array;

immutable long [] powersOfThree = [
      1,
      3,
      3 * 3,
      3 * 3 * 3,
      3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
   ];

Ok, but with this, you can't see where the overflow will occur. So you have the same problem as with the one-liner (and it is indeed very much longer).

On Monday, 4 July 2022 at 23:19:27 UTC, kdevel wrote:

immutable decimalRanks = iota(10).map!(p => 10.pow(p)).array;

import std.range; // for iota
import std.algorithm; // for map
import std.math; // for pow of int

immutable decimalRanks = iota(13).map!(p => 10.pow(p)).array; // silent wrap around

Sorry for the late reply, but I just stumbled over this old thread.
I now have a function

ubyte maxpow(const ulong base) { }

That returns the maximum power of the given base that fits in a ucent (for smaller target types, shift down the result by one for each halfing of the size).

With this you can create the function

```d
ulong[] powersOf(byte n)
{
   import std.range : iota;
   import std.algorithm : map;
   return iota(maxpow(n)>>1).map!(p => ulong(n)^^p).array;
}
```

If this function is used to create lookup-tables, it will be called only during compile-time, so the imports are not in the resulting executable (therefore it doesn't matter that I replaced pow by the buildin ^^).

static immutable ulong[maxpow(17)>>1] ranksOf17 = powersOf(17);

I think this is much more readable as a list of obscure number literals, it is safe to use, doesn't increase linker time and doesn't blow up the binary.
Hurray to the meta-programming! Hurray! Hurray!

On Wednesday, 28 December 2022 at 13:57:13 UTC, Dom Disc wrote:

ubyte maxpow(const ulong base) { }

Code?

ucent? Cannot use cent/ucent or core.int128's types here.

What do you mean by "shift down"? "Shift right" aka "divide by two"?

```d
ulong[] powersOf(byte n)
{
   import std.range : iota;
   import std.algorithm : map;
   return iota(maxpow(n)>>1).map!(p => ulong(n)^^p).array;
}
```

This generates too few elements.

import std.stdio;
import mod_maxpow;

auto powersOf (T) (ulong n)
{
   import std.range : iota;
   import std.algorithm : map;
   import std.array : array;
   return iota(maxpow!T (n) + 1).map!(p => n^^p).array;
}

int main (string [] args)
{
   static immutable ranksOf17 = powersOf!ulong (17);
   writeln (ranksOf17);
   return 0;
}

prints

[1, 17, 289, 4913, 83521, 1419857, 24137569, 410338673, 6975757441, 118587876497, 2015993900449, 34271896307633, 582622237229761, 9904578032905937, 168377826559400929, 2862423051509815793]

maxpow!ulong(17) is 15. Counting starts with 0 so we must add one.

static immutable ulong[maxpow(17)>>1] ranksOf17 = powersOf(17);

Unnecessary code duplication.

Unit tests?

On Sunday, 1 January 2023 at 23:05:46 UTC, kdevel wrote:

ubyte maxpow(const ulong base) { }

Yeah, I implemented this long time ago, when I still had hope that ucent will be available soon :-/

Yes. Divide by two to find out what power fits in uint, divide by four for ushort and divide by 8 for ubyte.

Ok, but I tend to omit n^^0 and n^^1 - so I would say it even generates too many elements :-)

static immutable ulong[maxpow(17)>>1] ranksOf17 = powersOf(17);

Yes, I hate that too. But

ulong[] ranksOf17 = powersOf(17);

will generate a dynamic array, and unfortunately an inherited length for static arrays (e.g. something like uint[$] x = [1,2,3]; or whatever syntax we could agree upon) is still not available :-(

Of course. Nothing that you can do will ever make those obsolete.
Mine are rather exhaustive:

/// exponentiation without overflow
/// return invalid if overflow would occur.
T safePow(T)(const(T) base, const int exp) if(isIntegral!T)
{
   if(exp < 2) return !exp ? 1 : (exp < 0 && base.abs != 1) ? 0 : odd(exp) ? base : 1;
   static if(isUnsigned!T)
   {
      if(base < 2) return base;
      if(base >= 1<<(T.sizeof<<2)) return invalid!T; // base too large to fit any powers of it into the same type
      if(exp > (maxpow(base)>>(5-bitlen(T.sizeof)))) return invalid!T;
      return T(base^^exp); // calc only if no overflow for sure (very efficient)
   }
   else
   {
      auto r = safePow(abs(base), exp); // max power may not fit in the signed type
      if(r > T.max) return invalid!T; // but at least we can detect it
      return (base < 0 && odd(exp)) ? -T(r) : T(r);
   }
}

unittest
{
   import std.conv;
   void test(T)()
   {
      T r;
      foreach(T base; (-128 * isSigned!T)..128)
      {
         foreach(uint exp; 0..256)
         {
            r = safePow(base, exp);
            if(exp==1) assert(r == base);
            else if(r == invalid!T)
            {
               assert(T.max / safePow(base, exp-1).abs < base.abs,
                      "max wrong: ",base,"^^",exp," <= "~T.stringof~".max");
               break;
            }
            assert(r == base^^exp, "calc wrong: ",base,"^^",exp," != ",r);
         }
      }
   }
   test!byte;
   test!ubyte;
   test!short;
   test!ushort;
   test!int;
   test!uint;
   test!long;
   test!ulong;
}