From C to VBA - Error in Conversion

You have the complete VBA code. What problem are you having?

I get it to run but I get a Division by Zero error here

Formula:

            For c = 0 To (x(j + 1) / e) * n

because e has not been assigned a value the first pass through this loop. The C code uses this expression as the iterator, not the exit condition.

It would help to know what you want your code to do. There are no comments and you have not described the specification for this function.

I did a conversion from scratch, but it still does not seem to do much. It is returning 0 for 0-5. I am guessing this is some sort of algorithm for the nth digit of pi.

Your function does have one definite bug. You are passing the argument d to your function, and then changing the value of d inside the function. The default mode for argument passing in VBA is by reference, so you are also changing the caller's version of d. If you are going to change d in your function you should call it by value.

I do not have a C environment to test the C version of this function. Do you know how it works, or did you just copy from someplace?

Public Function NthPi(ByVal d As Long) As Long

'        {
'            int l = (d+=2) * 10 / 3 + 2, j = 0, i = 0;
   Dim L As Long
   Dim j As Long, i As Long, k As Long
   d = d + 2
   L = d * 10 / 3 + 2
   
'
'            long[] x = new long[l], r = new long[l];
   Dim x() As Long, r() As Long
   ReDim x(L)
   ReDim r(L)
      
      
'
'            for (; j < l;)
   Do While j < L
   
'                x[j++] = 20;
      x(j) = 20
      j = j + 1
   Loop
   
'
'            long c, n, e, p = 0;
   Dim c As Long, n As Long, e As Long, p As Long
   
'
'            for (; i < d; ++i)
   Do While i < d

'            {
'                for (j = 0, c = 0; j < l; c = (x[j++] / e) * n)
      j = 0
      c = 0
      Do While j < L
      
'                {
'                    n = l - j - 1;
         n = L - j - 1
'                    e = n * 2 + 1;
         e = n * 2 + 1
'                    r[j] = (x[j] += c) % e;
         c = n * x(j) / e
         j = j + 1
'                }
      Loop
'
'                p = x[--l] / 10;
      L = L - 1
      p = x(L) / 10
'
'                r[l] = x[l++] % 10;
      r(L) = x(L) Mod 10
      L = L + 1
'
'                for (j = 0; j < l;)
         j = 0
         Do While j < L
'                    x[j] = r[j++] * 10;
            x(j) = r(j) * 10
            j = j + 1
         Loop
      i = i + 1
   
'            }
   Loop
'
'            return p % 10;
   NthPi = p Mod 10
   
'        }
End Function

You seem to be asking the same question about a different C class in another place. Strictly speaking this is not exactly the same question, since the code is different, but you are trying to reach the same goal and both are C to VBA conversions. Please post a cross-link here.

Administrative Note:

Welcome to the forum.

We would very much like to help you with your query, however it has been brought to our attention that the same query has been posted on one or more other forums and you have not provided the required cross-post link(s) here.

Please see Forum Rule #3 about cross-posting and adjust accordingly. Read this to understand why we (and other sites like us) consider this to be important.

(Note: this requirement is not optional. No help to be offered until the link is provided.)

Also, I must correct this statement :

Originally Posted by Juggler_IN

@6StringJazzer; The code calculates the n-th digit of pi. So, instead of computing the whole value to the n-th place, it just computes the nth place digit.

The C code is compute not just the n-th place, but all from 0 to n-th place.
For example, if you call NthPi(10), actually NthPi(0), NthPi(1), NthPi(2), NthPi(3), ... until NthPi(10) is calculated, so you are not just compute at exact n-th place.

This means, if you run the loop like this :

    For i = 0 To 5
        Debug.Print NthPi(i)
    Next i

when i = 0, nth(0) is calculated
when i = 1, nth(0) is recalculated, nth(1) is calculated
when i = 2, nth(0) is recalculated, nth(1) is recalculated, nth(2) is calculated
when i = 3, nth(0) is recalculated, nth(1) is recalculated, nth(2) is recalculated, nth(3) is calculated
when i = 4, nth(0) is recalculated, nth(1) is recalculated, nth(2) is recalculated, nth(3) is recalculated, nth(4) is calculated
etc

To show using the code :

Here we "only want the 10th" place (notice no loop, just single item 10) :

Sub Main()
  Dim i As Long
  i = NthPi(10)
End Sub

We insert the Debug line to show what is going on behind the scene :

Function NthPi(ByVal d As Long) As Long
  'int l = (d+=2) * 10 / 3 + 2, j = 0, i = 0;
  Dim L As Long, j As Long, i As Long
  d = d + 2
  L = d * 10 \ 3 + 2


  'long[] x = new long[l], r = new long[l];
  Dim x() As Long, r() As Long
  ReDim x(L), r(L)


  'for (; j < l;)
  '    x[j++] = 20;
  For j = 0 To L - 1
      x(j) = 20
  Next j


  'long c, n, e, p = 0;
  Dim c As Long, n As Long, e As Long, p As Long


  'for (; i < d; ++i)
  '{
  For i = 0 To d - 1


      'for (j = 0, c = 0; j < l; c = (x[j++] / e) * n)
      '{
      c = 0
      For j = 0 To L - 1


          'n = l - j - 1;
          n = L - j - 1


          'e = n * 2 + 1;
          e = n * 2 + 1


          'r[j] = (x[j] += c) % e;
          x(j) = x(j) + c
          r(j) = x(j) Mod e


      '}
          c = (x(j) \ e) * n
      Next j


      'p = x[--l] / 10;
      L = L - 1
      p = x(L) \ 10
Debug.Print "The " & i; " digit = " & p


      'r[l] = x[l++] % 10;
      r(L) = x(L) Mod 10
      L = L + 1


      'for (j = 0; j < l;)
      For j = 0 To L - 1


          'x[j] = r[j++] * 10;
          x(j) = r(j) * 10


      '}
      Next j


  '}
  Next i


  'return p % 10;
  NthPi = p Mod 10
End Function

The result of macro is :
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
The 7 digit = 6
The 8 digit = 5
The 9 digit = 3
The 10 digit = 5
The 11 digit = 8

Which means, even though we input the 10 as n-th place, but actually all the digit between 0 to 10 is calculated, it's only not shown up to user (hidden).

Thus the statement "it just computes the nth place digit" is wrong.


Now, if put it back again into loop, the result will be very clear:

Sub Main()
  Dim i As Long, j As Long
  For i = 0 To 10
      j = NthPi(i)
      Debug.Print "================="
  Next i
End Sub

The 0 digit = 3
The 1 digit = 1
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
The 7 digit = 6
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
The 7 digit = 6
The 8 digit = 5
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
The 7 digit = 6
The 8 digit = 5
The 9 digit = 3
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
The 7 digit = 6
The 8 digit = 5
The 9 digit = 3
The 10 digit = 5
=================
The 0 digit = 3
The 1 digit = 1
The 2 digit = 4
The 3 digit = 1
The 4 digit = 5
The 5 digit = 9
The 6 digit = 2
The 7 digit = 6
The 8 digit = 5
The 9 digit = 3
The 10 digit = 5
The 11 digit = 8
=================

Maybe :

'https://tio.run/##jVFNU4MwFLzzK/bSGRDoB44nysmrOh09eGA4MBA1nTTUgFrH4bfjC8QPCljfBZL3drO7Lyv9XSGLppHpjpX7NGO4ey8rtptfcflsfVigykRalti0/92NrrJKK57hteA5rlMubee79TOk66FQsLmswBFhGdJnHeGCflyXO73JPk7XZSHLQrD5veIVs2@qpw23ueOEvcHasiYxZIPZR/NfA7cszY/7v7iMQVHIR5iXyUQ@ZVM3BTm0czcKHJxhtcQC53AReNhq655JoC9X88cJDtSS7K07isSD6l8codpQQ@JdQ4TOILdDvHXdhBiCseeQeZAemIf9iCBDTWtC/q8ltQDjMOt23OlqT7bRsgDTqcih2CGjLklYAZ@ofKzC0RGmIyLOgEKeGBm9VPE2McoSuBEyBzOwIUFtnaTTAR5i3xfa4GoZnkYoWmYLEjqVWQv6I9LpHZs9azLVRXw2UNB30DsoVr0oSQZmPVSHqK26aT4B
'141592653589793238462643383279402884197169399375105

Sub Main()
  Dim i As Long
  For i = 0 To 50
      Debug.Print Trim$(NthPi(i));
  Next i
End Sub

Function NthPi(ByVal d As Long) As Long
  'int l = (d+=2) * 10 / 3 + 2, j = 0, i = 0;
  Dim l As Long, j As Long, i As Long
  d = d + 2
  l = d * 10 \ 3 + 2


  'long[] x = new long[l], r = new long[l];
  Dim x() As Long, r() As Long
  ReDim x(l), r(l)


  'for (; j < l;)
  '    x[j++] = 20;
  For j = 0 To l - 1
      x(j) = 20
  Next j


  'long c, n, e, p = 0;
  Dim c As Long, n As Long, e As Long, p As Long


  'for (; i < d; ++i)
  '{
  For i = 0 To d - 1
  
  
      'for (j = 0, c = 0; j < l; c = (x[j++] / e) * n)
      '{
      c = 0
      For j = 0 To l - 1


          'n = l - j - 1;
          n = l - j - 1


          'e = n * 2 + 1;
          e = n * 2 + 1


          'r[j] = (x[j] += c) % e;
          x(j) = x(j) + c
          r(j) = x(j) Mod e

      
      '}
          c = (x(j) \ e) * n
      Next j


      'p = x[--l] / 10;
      l = l - 1
      p = x(l) \ 10


      'r[l] = x[l++] % 10;
      r(l) = x(l) Mod 10
      l = l + 1


      'for (j = 0; j < l;)
      For j = 0 To l - 1


          'x[j] = r[j++] * 10;
          x(j) = r(j) * 10


      '}
      Next j


  '}
  Next i


  'return p % 10;
  NthPi = p Mod 10
End Function

Juggler_IN,

After examining the expected result compared to output of C program, I conclude that the correction cannot be made by keep using original code.
I propose a new macro (modified), but it will not produce individual digit of PI (looping from x to y), but the value of the biggest expected digit is set first (for example 50), then the macro will calculate all the digits between 0 to 50.
Using this macro, not only the digit number is corrected, but also it is blazing fast.

Shall we do it ?

Well, do you want my modified macro as proposed above, or will you wait someone fixing from the C code side and then re-translate it to VBA ?

Originally Posted by Juggler_IN

This was base-10 equivalent to base-16 bailey-borwein-plouffe-formula.

Well, not really. The C# you posted is (poorly) based on the spigot algorithm (warning, pdf) by Rabinowitz and Wagon.
Unfortunately, it has some drawbacks, since we must track remainders.
A faster algorithm can be used up to 50k digits, changing base. You can find it, for instance, in "Pi Unleashed" (yes, still coded in C).

On page 6 of the spigot algorithm (pdf shared by Hydraulics) by Rabinowitz and Wagon... "At the 32nd iteration, a 102 shows up, yielding a predigit of 10." I think this fact can be used to trap the error in C code. This occurrence of 102, is happening across all "x" marked values. If we add Debug p, x(l) after the line p = x(l) \ 10, we get to see the instances of 102 against x(l).

Here is a modified function that returns Pi correctly up to 1000 digits. Awfully slow if used in a for loop, it needs 78 seconds. For the single 10000th digit it requires 23 seconds.

Option Explicit

Sub Main()

Dim i As Long

For i = 0 To 1000
    Debug.Print Trim$(NthPi(i));
Next i

End Sub

Function NthPi(ByVal d As Long) As Long

d = d + 4
Dim n As Long
n = d * 10 \ 3 + 2
Dim x() As Long
Dim r() As Long
Dim p() As Long
ReDim x(n)
ReDim r(n)
ReDim p(d)
Dim i As Long
Dim c As Long
Dim j As Long
Dim k As Long
Dim num As Long
Dim den As Long
Dim q As Long
Dim result As String

For j = 0 To n - 1
    x(j) = 20
Next j

Do While i < d
    c = 0
    For j = 0 To n - 1
        num = n - j - 1
        den = num * 2 + 1
        x(j) = x(j) + c
        q = x(j) \ den
        r(j) = x(j) Mod den
        c = q * num
    Next j
    p(i) = x(n - 1) \ 10
    r(n - 1) = x(n - 1) Mod 10
    For k = 0 To n - 1
        x(k) = r(k) * 10
    Next k
    i = i + 1
Loop

result = ""
c = 0

For i = d To 0 Step -1
    p(i) = p(i) + c
    c = p(i) \ 10
    result = CStr(p(i) Mod 10) + result
Next i

NthPi = Right(p(d - 4), 1)

End Function

HTH,

Francesco

This is one order of magnitude faster: 2.3s for the 10000th digit alone.

Function NthPiBest(ByVal digit As Long) As Long

digit = digit + 3

Dim length As Long
length = (digit \ 4 + 2) * 14
Dim a() As Long
ReDim a(length)
Dim b As Long
Dim c As Long
c = length
Dim d As Long
Dim e As Long
e = 0
Dim f As Long
f = 10000
Dim g As Long
Dim h As Long
h = 0
Dim result As String

result = ""
c = c - 14
b = c
Do While b > 1
    Do While b > 1
        b = b - 1
        d = d * b
        If h = 0 Then
            d = d + 2000 * f
        Else
            d = d + a(b) * f
        End If
        g = b + b - 1
        a(b) = d Mod g
        d = d \ g
    Loop
    result = result & Format((e + d \ f), "0000")
    h = 4
    e = d Mod f
    d = e
    c = c - 14
    b = c
Loop

NthPiBest = Mid(result, digit - 3, 1)

End Function

As karedog noted, these algorithms calculate Pi up to the desired digit.

HTH,

Francesco