...

The bigger the base the fewer numbers fit in the double, not the other
way around.

For a fact, my program will never be invoked with log_k(k), or there is
something fishy with the postcondition of some other function.

Ups :-)

Because, ahem, because, aehm, aehm, well :-)

/Thomas

Andersen wrote On 12/19/05 17:45,:

    static int logBaseK(int n, int k) {
       return (int)Math.round(Math.log(n) / Math.log(k));
    }

Yes, there will be inaccuracies in computing the two logs, and
probably in computing their quotient.  But the inaccuracies
will be small (assuming legitimate n and k), and will be fixed
by the Math.round() call.

   You could do an all-integer (or -long) version using
repeated multiplication: start with 1, multiply by k until
you get n, and return the count.  You'd never need more
than 30 (62) iterations in the worst legitimate case.

   Error-checking (in both versions) is left as an
exercise for the reader.

Sure, nothing in the group's charter prohibits having a bit of fun.

And as a general hint, playing with then numbers and some formulas when
you have a math problem at hand doesn't hurt. It gives you some feel for
the problem.

k being a positive integer? Why didn't you tell us this upfront? You
could e.g. handle that problem with a lookup table. E.g for a base 2 a
table of 31 integers if you really don't trust log():

    final static int logs2[] = {
        0x00000001, 0x00000002, 0x00000004, 0x00000008,
        0x00000010, 0x00000020, 0x00000040, 0x00000080,
        0x00000100, 0x00000200, 0x00000400, 0x00000800,
        0x00001000, 0x00002000, 0x00004000, 0x00008000,
        0x00010000, 0x00020000, 0x00040000, 0x00080000,
        0x00100000, 0x00200000, 0x00400000, 0x00800000,
        0x01000000, 0x02000000, 0x04000000, 0x08000000,
        0x10000000, 0x20000000, 0x40000000
    };

    final static int logs3[] = {
        1, 3, 9, 27,
        ...
    };

   
    private int binSearch(int values[], int e) throws ImpreciseException
    {
        int l = 0;
        int r = values.length - 1;
        int p;
        while(l <= r) {
            p = (l + r) / 2;
            if(e == values[p]) return p;
            if(e < values[p]) {
                r = p - 1;
            } else {
                l = p + 1;
            }
        }
        throw new ImpreciseException();
    }

    public int preciseLog2(int e) throws ImpreciseException
    {
        return binSearch(logs2, e);
    }

    public int preciseLog3(int e) throws ImpreciseException
    {
        return binSearch(logs3, e);
    }

/Thomas