Set the range of the table.  1 to 1.6 corresponds to the first 12 pages of Babbage's 7 figure logarithms (6000 entries)

minlog  =  1

maxlog  =  1.600

Generate a table at large stepsize over the range.  This can compared to the table as a cross check and will be used to find a polynomial fit

Logtable = 
      Table[{N[x, 40], N[Log[10, x], 40]}, {x, minlog,  maxlog, 
          1/100}]

Fit a 7th order polynomial in x

x =.

polyFit  =  
      N[Fit[Logtable,  Table[x^i, {i, 0, 7}],  x], 40]

Evaluate this polynomial for the same set of points as in the original table used for the fit

calcLogs =  
      polyFit /. x -> 
          Table[N[x, 40], {x, minlog,  maxlog, 1/100}]

Now compute maximum absolute error of the fit over this range

Max[
      Abs[calcLogs - 
          Table[Log[10, x], {x, minlog,  maxlog, 1/100}]]]

This shows we have one to two guard digits to ensure correct rounding

Now compute the first entries of the table, from the fitted polynomial at the desired spacing.

y = 
      Table[N[y, 40], {y,  minlog, minlog + 9/10000, 1/10000}]

Diffs[0]  =  N[polyFit /. x -> y, 40]

Compute the differences

Do[Diffs[i] = 
        Drop[Diffs[i - 1], 1] - Diffs[i - 1][[Range[1, 10 - i]]], {i, 
        7}]

Diffs[1]

Diffs[2]

Diffs[3]

Diffs[4]

Diffs[5]

Diffs[6]

Diffs[7]

Note how the higher order differences become very small.  Hence we need a large number of digits in fixed point to retain adequate precision

Compute integer representations of the initial settings by scaling up by 10^27.  The result column has 5 added to the 8th place so all results are automatically rounded to 7 digits. Negative differences are converted to 10's complement form. Note that because of the pipeline in the difference engine, earlier differences have to be taken from later rows of the table.

NumDigits  =  27

Do[ 
      Col[i] = If[Diffs[i][[4 - IntegerPart[i/2]]] < 0, 
          10^NumDigits - 
            FromDigits[RealDigits[Diffs[i][[4 - IntegerPart[i/2]]], 
                  10, NumDigits, -1] [[1]]], 
          FromDigits[RealDigits[Diffs[i][[4 - IntegerPart[i/2]]], 
                10, NumDigits, -1] [[1]]]] ,  {i,  0,  
        7}]

Col[0]  =  Col[0] + 5*10^(NumDigits - 8)

Col[1]

Col[2]

Col[3]

Col[4]

Col[5]

Col[6]

Col[7]

Now compute an actual table as a final cross check  These numbers should match exactly the beinning of Babbage's 7 figure table. Note that the calculation is pipelined in the same way the physical difference engine is

Do[Print[
        PaddedForm[
          FromDigits[
            Take[Take[IntegerDigits[Col[0] + 10^NumDigits], -NumDigits], 
              7]], 6,  NumberPadding -> "0"]]; 
      Do[Col[i] = Col[i] + Col[i + 1], {i,  0, 6,  2}]; 
      Do[Col[i] = Col[i] + Col[i + 1], {i,  1, 5,  2}], {j, 1, 
        500}]