Calculate inverse bounds correctly

[inverse-tax] / tax.js

"use strict";

function parse_table(as_text) {
  function parse_line(line) {
    return line.trim().split(' ').filter(x => x !== '').map(x => parseFloat(x));
  }
  return as_text.trim().split('\n').map(parse_line);
}

function tax_table_from_table(table) {
  return table.map(([start, rate], i, table) =>
    [start, i < table.length - 1 ? table[i+1][0] : Infinity, rate / 100.0]);
}

function parse_tax_table(as_text) {
  return tax_table_from_table(parse_table(as_text));
}

function sum(nums) {
  return nums.reduce((total, num) => total + num, 0);
}

function tax(table, income) {
  return sum(table.map(([start, end, rate]) =>
    Math.max(0, Math.min(income, end) - start) * rate));
}

function apply_deductible(table, deductible) {
  return table.map(([start, end, rate]) => [start + deductible, end + deductible, rate]);
}

function merge_tax_tables(t1, t2) {
  if (t1.length == 0) return t2;
  if (t2.length == 0) return t1;
  const [start1, end1, rate1] = t1[0];
  const [start2, end2, rate2] = t2[0];
  if (start1 == start2) {
    if (end1 == end2) {
      return [[start1, end1, rate1 + rate2]].concat(merge_tax_tables(t1.slice(1), t2.slice(1)));
    }
    if (end1 < end2) {
      return [[start1, end1, rate1 + rate2]].concat(merge_tax_tables(t1.slice(1), [[end1, end2, rate2]].concat(t2.slice(1))));
    }
    return merge_tax_tables(t2, t1);
  }
  if (start1 < start2) {
    if (end1 <= start2) {
      return [t1[0]].concat(merge_tax_tables(t1.slice(1), t2));
    }
    return [[start1, start2, rate1]].concat(merge_tax_tables([[start2, end1, rate1]].concat(t1.slice(1)), t2));
  }
  return merge_tax_tables(t2, t1);
}

function invert(table) {
  // Here we solve
  //   net = m * gross + b
  // for gross:
  //   net - b = m * gross
  //   (net - b) / m = gross
  // and the calculate the inverse's bounds

  const ms = table.map(([start, end, rate]) => 1 - rate);
  const full_brackets = [0].concat(table.map(([start, end, rate]) => (end - start) * rate)).slice(0, table.length);
  function sum_lower_brackets(remaining_brackets, acc = 0) {
    if (remaining_brackets.length == 0) return [];
    return [acc + remaining_brackets[0]].concat(sum_lower_brackets(remaining_brackets.slice(1), acc + remaining_brackets[0]));
  }
  const bs = sum_lower_brackets(full_brackets).map((lower_brackets, i) => {
    const [start, end, rate] = table[i];
    // Finding b:
    //   net = gross - lower_brackets - rate * (gross - start)
    //   net = gross - lower_brackets - rate * gross + rate * start
    //   net = gross - rate * gross - lower_brackets + rate * start
    //   net = (1 - rate) * gross - lower_brackets + rate * start
    //   net = m * gross - lower_brackets + rate * start
    //                   \_____________________________/  - here is b
    return rate * start - lower_brackets;
  });
  const inverse_table = table.map(([start, end, rate], i) => {
    const m = ms[i];
    const b = bs[i];
    return [m * start + b, m * end + b, m, b];
  });
  return function(net) {
    for (const [start, end, m, b] of inverse_table) {
      if (start < net && net < end) {
        return (net - b) / m;
      }
    }
    return net;
  };
}