pow approximation with 2D lookup table

public class PowLookupTable {

    private final double[] _table;
    private final double _min_a;
    private final double _max_a;
    private final double _min_b;
    private final double _max_b;
    private final int _size;
    private double _diff_a;
    private double _diff_b;

    public PowLookupTable(double min_a, double max_a, double min_b,
            double max_b, int size) {
        _min_a = min_a;
        _max_a = max_a;
        _min_b = min_b;
        _max_b = max_b;
        _diff_a = _max_a - _min_a;
        _diff_b = _max_b - _min_b;
        _size = size;
        _table = new double[size * size];

        // calculate weights
        for (int a = 0; a < size; ++a) {
            for (int b = 0; b < size; ++b) {
                double da = _diff_a * a / (size - 1) + _min_a;
                double db = _diff_b * b / (size - 1) + _min_b;
                _table[a * size + b] = Math.pow(da, db);
            }
        }

    }

    public double pow(double a, double b) {
        // calculate exact position on grid
        double grid_pos_a = (a - _min_a) / _diff_a * (_size - 1);
        double grid_pos_b = (b - _min_b) / _diff_b * (_size - 1);

        // calculate upper left index
        int idx_a = (int) grid_pos_a;
        int idx_b = (int) grid_pos_b;

        // get entries
        double ul = _table[idx_a * _size + idx_b];
        double ur = _table[idx_a * _size + idx_b + 1];
        double ll = _table[idx_a * _size + idx_b + _size];
        double lr = _table[idx_a * _size + idx_b + 1 + _size];

        // first linear interpolation between ul and ur
        double tmp_a = grid_pos_a - idx_a;
        double u = ul * (1 - tmp_a) + tmp_a * ur;
        double l = ll * (1 - tmp_a) + tmp_a * lr;

        // now linear interpolate between these two results
        double tmp_b = grid_pos_b - idx_b;
        double r = u * (1 - tmp_b) + tmp_b * l;

        return r;
    }
}