Simplifying a short code

[schniefen]

I'm working on simplifying a part of a function. d_n actually represents a double sequence, call it d_ki, where both indices k and i begin at 0 and terminate at n. Evaluating the sequence for any n yields a "matrix" where the xth first columns in the xth row fall away (noting that the first row is row zero, second is first and so on). Every d_n thus represents the nth, ever-decreasing row in the "matrix". a is a previously defined list and x a constant. Is there a way to simplify the code so that when evaluating the function for all n, one mustn't change the code every time?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

def ln(x,n):      ...      d_0 =[]      for k in range(n+1):      d_0.append(a[k])      d_1=[]      for k in range (1,n+1):      d_1.append((d_0[k]-4**(-1)*d_0[k-1])/(1-4**(-1)))      d_2=[]      for k in range(2,n+1):      d_2.append((d_1[k-1]-4**(-2)*d_1[k-2])/(1-4**(-2)))      d_3=[]      for k in range(3,n+1):      d_3.append((d_2[k-2]-4**(-3)*d_2[k-3])/(1-4**(-3)))      ...      d_n=[]      for k in range(n,n+1):      d_n.append((d_n-1[k-(n-1)]-4**(-n)*d_n-1[k-n])/(1-4**(-n)))      return (x-1)/d_n[0]

[ichabod801]

It's not clear to me what you mean. Can you give an example matrix for small k and i, and repost your code with proper indentation.

I expect this can be done with nested lists and a nested for loop, but I'd want a better understanding of the problem before proposing a solution.

[schniefen]

I'm approximating the natural logarithm according to the formulas given in this paper https://www.ams.org/journals/mcom/1972-2...7438-2.pdf (see second page, under 'Algorithm for logarithm'). When evaluating dki one attains a matrix of the form

1 2 3 4 5

([[d_00,d_01,d_02,...,d_nn],   [     d_11,d_12,...,d_nn],   [               ...,d_nn],   [          d_n-1n-1,d_nn],   [                   d_nn]])

Here is the full code.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

def ln(x,n):     a =[(1+x)/2]     g =[x**(1/2)]     for i in range(n):         a.append((a[i]+g[i])/2)         g.append((a[i+1]*g[i])**(1/2))     d_0 =[]     for k in range(n+1):         d_0.append(a[k])     d_1=[]     for k in range (1,n+1):         d_1.append((d_0[k]-4**(-1)*d_0[k-1])/(1-4**(-1)))     d_2=[]     for k in range(2,n+1):         d_2.append((d_1[k-1]-4**(-2)*d_1[k-2])/(1-4**(-2)))     d_3=[]     for k in range(3,n+1):         d_3.append((d_2[k-2]-4**(-3)*d_2[k-3])/(1-4**(-3)))     ...     d_n=[]     for k in range(n,n+1):         d_n.append((d_n-1[k-(n-1)]-4**(-n)*d_n-1[k-n])/(1-4**(-n)))     return (x-1)/d_n[0]

[ichabod801]

As I said, nested for loops and nested lists. I think this will work:

1 2 3 4 5 6 7 8 9 10 11 12

def ln(x, n):     a =[(1 + x) / 2]     g =[x ** (1 / 2)]     for i in range(n):         a.append((a[i] + g[i]) / 2)         g.append((a[i+1] * g[i]) ** (1 / 2))     d = [a[:]]     for i in range(1, n + 1):         d.append([])         for k in range(i, n + 1):             d.append(d[-2][k - i - 1] - 4 ** (-1) * d[-2][k - i] / (1 - 4 ** (-i)))     return (x - 1) / d[-1][0]

[schniefen]

Nice! I made some minor adjustments, and the code below should work. Thanks!

1 2 3 4 5 6 7 8 9 10 11 12

def ln(x, n):     a =[(1 + x) / 2]     g =[x ** (1 / 2)]     for i in range(n):         a.append((a[i] + g[i]) / 2)         g.append((a[i+1] * g[i]) ** (1 / 2))     d = [a[:]]     for i in range(1, n + 1):         d.append([])         for k in range(i, n + 1):             d[i].append((d[-2][k - i +1] - 4 ** (-i) * d[-2][k - i])/(1 - 4 ** (-i)))     return (x - 1)/d[-1][0]