Van der Corput sequence

From Rosetta Code
Task
Van der Corput sequence
You are encouraged to solve this task according to the task description, using any language you may know.

When counting integers in binary, if you put a (binary) point to the right of the count then the column immediately to the left denotes a digit with a multiplier of ; the digit in the next column to the left has a multiplier of ; and so on.

So in the following table:

  0.
  1.
 10.
 11.
 ...

the binary number "10" is .

You can also have binary digits to the right of the “point”, just as in the decimal number system. In that case, the digit in the place immediately to the right of the point has a weight of , or . The weight for the second column to the right of the point is or . And so on.

If you take the integer binary count of the first table, and reflect the digits about the binary point, you end up with the van der Corput sequence of numbers in base 2.

  .0
  .1
  .01
  .11
  ...

The third member of the sequence, binary 0.01, is therefore or .


Distribution of 2500 points each: Van der Corput (top) vs pseudorandom
Members of the sequence lie within the interval . Points within the sequence tend to be evenly distributed which is a useful trait to have for Monte Carlo simulations.

This sequence is also a superset of the numbers representable by the "fraction" field of an old IEEE floating point standard. In that standard, the "fraction" field represented the fractional part of a binary number beginning with "1." e.g. 1.101001101.

Hint

A hint at a way to generate members of the sequence is to modify a routine used to change the base of an integer:

>>> def base10change(n, base):
digits = []
while n:
n,remainder = divmod(n, base)
digits.insert(0, remainder)
return digits
 
>>> base10change(11, 2)
[1, 0, 1, 1]

the above showing that 11 in decimal is .
Reflected this would become .1101 or

Task Description

  • Create a function/method/routine that given n, generates the n'th term of the van der Corput sequence in base 2.
  • Use the function to compute and display the first ten members of the sequence. (The first member of the sequence is for n=0).
  • As a stretch goal/extra credit, compute and show members of the sequence for bases other than 2.

See also

ActionScript[edit]

This implementation uses logarithms to computes the nth term of the sequence at any base. Numbers in the output are rounded to 6 decimal places to hide any floating point inaccuracies.

 
package {
 
import flash.display.Sprite;
import flash.events.Event;
 
public class VanDerCorput extends Sprite {
 
public function VanDerCorput():void {
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
 
private function init(e:Event = null):void {
 
removeEventListener(Event.ADDED_TO_STAGE, init);
 
var base2:Vector.<Number> = new Vector.<Number>(10, true);
var base3:Vector.<Number> = new Vector.<Number>(10, true);
var base4:Vector.<Number> = new Vector.<Number>(10, true);
var base5:Vector.<Number> = new Vector.<Number>(10, true);
var base6:Vector.<Number> = new Vector.<Number>(10, true);
var base7:Vector.<Number> = new Vector.<Number>(10, true);
var base8:Vector.<Number> = new Vector.<Number>(10, true);
 
var i:uint;
 
for ( i = 0; i < 10; i++ ) {
base2[i] = Math.round( _getTerm(i, 2) * 1000000 ) / 1000000;
base3[i] = Math.round( _getTerm(i, 3) * 1000000 ) / 1000000;
base4[i] = Math.round( _getTerm(i, 4) * 1000000 ) / 1000000;
base5[i] = Math.round( _getTerm(i, 5) * 1000000 ) / 1000000;
base6[i] = Math.round( _getTerm(i, 6) * 1000000 ) / 1000000;
base7[i] = Math.round( _getTerm(i, 7) * 1000000 ) / 1000000;
base8[i] = Math.round( _getTerm(i, 8) * 1000000 ) / 1000000;
}
 
trace("Base 2: " + base2.join(', '));
trace("Base 3: " + base3.join(', '));
trace("Base 4: " + base4.join(', '));
trace("Base 5: " + base5.join(', '));
trace("Base 6: " + base6.join(', '));
trace("Base 7: " + base7.join(', '));
trace("Base 8: " + base8.join(', '));
 
}
 
private function _getTerm(n:uint, base:uint = 2):Number {
 
var r:Number = 0, p:uint, digit:uint;
var baseLog:Number = Math.log(base);
 
while ( n > 0 ) {
p = Math.pow( base, uint(Math.log(n) / baseLog) );
 
digit = n / p;
n %= p;
r += digit / (p * base);
}
 
return r;
 
}
 
}
 
}
 
Output:
Base 2: 0, 0.5, 0.25, 0.75, 0.125, 0.625, 0.375, 0.875, 0.0625, 0.5625
Base 3: 0, 0.333333, 0.666667, 0.111111, 0.444444, 0.777778, 0.222222, 0.555556, 0.888889, 0.037037
Base 4: 0, 0.25, 0.5, 0.75, 0.0625, 0.3125, 0.5625, 0.8125, 0.125, 0.375
Base 5: 0, 0.2, 0.4, 0.6, 0.8, 0.04, 0.24, 0.44, 0.64, 0.84
Base 6: 0, 0.166667, 0.333333, 0.5, 0.666667, 0.833333, 0.027778, 0.194444, 0.361111, 0.527778
Base 7: 0, 0.142857, 0.285714, 0.428571, 0.571429, 0.714286, 0.857143, 0.020408, 0.163265, 0.306122
Base 8: 0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 0.015625, 0.140625

Ada[edit]

with Ada.Text_IO;
 
procedure Main is
package Float_IO is new Ada.Text_IO.Float_IO (Float);
function Van_Der_Corput (N : Natural; Base : Positive := 2) return Float is
Value  : Natural  := N;
Result  : Float  := 0.0;
Exponent : Positive := 1;
begin
while Value > 0 loop
Result  := Result +
Float (Value mod Base) / Float (Base ** Exponent);
Value  := Value / Base;
Exponent := Exponent + 1;
end loop;
return Result;
end Van_Der_Corput;
begin
for Base in 2 .. 5 loop
Ada.Text_IO.Put ("Base" & Integer'Image (Base) & ":");
for N in 1 .. 10 loop
Ada.Text_IO.Put (' ');
Float_IO.Put (Item => Van_Der_Corput (N, Base), Exp => 0);
end loop;
Ada.Text_IO.New_Line;
end loop;
end Main;
Output:
Base 2:  0.50000  0.25000  0.75000  0.12500  0.62500  0.37500  0.87500  0.06250  0.56250  0.31250
Base 3:  0.33333  0.66667  0.11111  0.44444  0.77778  0.22222  0.55556  0.88889  0.03704  0.37037
Base 4:  0.25000  0.50000  0.75000  0.06250  0.31250  0.56250  0.81250  0.12500  0.37500  0.62500
Base 5:  0.20000  0.40000  0.60000  0.80000  0.04000  0.24000  0.44000  0.64000  0.84000  0.08000

AutoHotkey[edit]

Works with: AutoHotkey_L
SetFormat, FloatFast, 0.5
for i, v in [2, 3, 4, 5, 6] {
seq .= "Base " v ": "
Loop, 10
seq .= VanDerCorput(A_Index - 1, v) (A_Index = 10 ? "`n" : ", ")
}
MsgBox, % seq
 
VanDerCorput(n, b, r=0) {
while n
r += Mod(n, b) * b ** -A_Index, n := n // b
return, r
}
Output:
Base 2: 0, 0.50000, 0.25000, 0.75000, 0.12500, 0.62500, 0.37500, 0.87500, 0.06250, 0.56250
Base 3: 0, 0.33333, 0.66667, 0.11111, 0.44444, 0.77778, 0.22222, 0.55555, 0.88889, 0.03704
Base 4: 0, 0.25000, 0.50000, 0.75000, 0.06250, 0.31250, 0.56250, 0.81250, 0.12500, 0.37500
Base 5: 0, 0.20000, 0.40000, 0.60000, 0.80000, 0.04000, 0.24000, 0.44000, 0.64000, 0.84000
Base 6: 0, 0.16667, 0.33333, 0.50000, 0.66667, 0.83333, 0.02778, 0.19445, 0.36111, 0.52778

AWK[edit]

 
# syntax: GAWK -f VAN_DER_CORPUT_SEQUENCE.AWK
# converted from BBC BASIC
BEGIN {
printf("base")
for (i=0; i<=9; i++) {
printf(" %7d",i)
}
printf("\n")
for (base=2; base<=5; base++) {
printf("%-4s",base)
for (i=0; i<=9; i++) {
printf(" %7.5f",vdc(i,base))
}
printf("\n")
}
exit(0)
}
function vdc(n,b, s,v) {
s = 1
while (n) {
s *= b
v += (n % b) / s
n /= b
n = int(n)
}
return(v)
}
 

Output:

base       0       1       2       3       4       5       6       7       8       9
2    0.00000 0.50000 0.25000 0.75000 0.12500 0.62500 0.37500 0.87500 0.06250 0.56250
3    0.00000 0.33333 0.66667 0.11111 0.44444 0.77778 0.22222 0.55556 0.88889 0.03704
4    0.00000 0.25000 0.50000 0.75000 0.06250 0.31250 0.56250 0.81250 0.12500 0.37500
5    0.00000 0.20000 0.40000 0.60000 0.80000 0.04000 0.24000 0.44000 0.64000 0.84000

BBC BASIC[edit]

      @% = &20509
FOR base% = 2 TO 5
PRINT "Base " ; STR$(base%) ":"
FOR number% = 0 TO 9
PRINT FNvdc(number%, base%);
NEXT
PRINT
NEXT
END
 
DEF FNvdc(n%, b%)
LOCAL v, s%
s% = 1
WHILE n%
s% *= b%
v += (n% MOD b%) / s%
n% DIV= b%
ENDWHILE
= v
Output:
Base 2:
  0.00000  0.50000  0.25000  0.75000  0.12500  0.62500  0.37500  0.87500  0.06250  0.56250
Base 3:
  0.00000  0.33333  0.66667  0.11111  0.44444  0.77778  0.22222  0.55556  0.88889  0.03704
Base 4:
  0.00000  0.25000  0.50000  0.75000  0.06250  0.31250  0.56250  0.81250  0.12500  0.37500
Base 5:
  0.00000  0.20000  0.40000  0.60000  0.80000  0.04000  0.24000  0.44000  0.64000  0.84000

bc[edit]

This solution hardcodes the literal 10 because numeric literals in bc can use any base from 2 to 16. This solution only works with integer bases from 2 to 16.

/*
* Return the _n_th term of the van der Corput sequence.
* Uses the current _ibase_.
*/
define v(n) {
auto c, r, s
 
s = scale
scale = 0 /* to use integer division */
 
/*
* c = count digits of n
* r = reverse the digits of n
*/
for (0; n != 0; n /= 10) {
c += 1
r = (10 * r) + (n % 10)
}
 
/* move radix point to left of digits */
scale = length(r) + 6
r /= 10 ^ c
 
scale = s
return r
}
 
t = 10
for (b = 2; b <= 4; b++) {
"base "; b
obase = b
for (i = 0; i < 10; i++) {
ibase = b
" "; v(i)
ibase = t
}
obase = t
}
quit

Some of the calculations are not exact, because bc performs calculations using base 10. So the program prints a result like .202222221 (base 3) when the exact result would be .21 (base 3).

Output:
base 2
  0.00000000000000
  .10000000000000
  .01000000000000
  .11000000000000
  .00100000000000
  .10100000000000
  .01100000000000
  .11100000000000
  .00010000000000
  .10010000000000
base 3
  0.000000000
  .022222222
  .122222221
  .002222222
  .102222222
  .202222221
  .012222222
  .112222221
  .212222221
  .000222222
base 4
  0.0000000
  .1000000
  .2000000
  .3000000
  .0100000
  .1100000
  .2100000
  .310000000
  .0200000
  .1200000

C[edit]

#include <stdio.h>
 
void vc(int n, int base, int *num, int *denom)
{
int p = 0, q = 1;
 
while (n) {
p = p * base + (n % base);
q *= base;
n /= base;
}
 
*num = p;
*denom = q;
 
while (p) { n = p; p = q % p; q = n; }
*num /= q;
*denom /= q;
}
 
int main()
{
int d, n, i, b;
for (b = 2; b < 6; b++) {
printf("base %d:", b);
for (i = 0; i < 10; i++) {
vc(i, b, &n, &d);
if (n) printf("  %d/%d", n, d);
else printf(" 0");
}
printf("\n");
}
 
return 0;
}
Output:
base 2:  0  1/2  1/4  3/4  1/8  5/8  3/8  7/8  1/16  9/16
base 3:  0  1/3  2/3  1/9  4/9  7/9  2/9  5/9  8/9  1/27
base 4:  0  1/4  1/2  3/4  1/16  5/16  9/16  13/16  1/8  3/8
base 5:  0  1/5  2/5  3/5  4/5  1/25  6/25  11/25  16/25  21/25

C++[edit]

Translation of: Perl 6
#include <cmath>
#include <iostream>
 
double vdc(int n, double base = 2)
{
double vdc = 0, denom = 1;
while (n)
{
vdc += fmod(n, base) / (denom *= base);
n /= base; // note: conversion from 'double' to 'int'
}
return vdc;
}
 
int main()
{
for (double base = 2; base < 6; ++base)
{
std::cout << "Base " << base << "\n";
for (int n = 0; n < 10; ++n)
{
std::cout << vdc(n, base) << " ";
}
std::cout << "\n\n";
}
}
Output:
Base 2
0 0.5 0.25 0.75 0.125 0.625 0.375 0.875 0.0625 0.5625 

Base 3
0 0.333333 0.666667 0.111111 0.444444 0.777778 0.222222 0.555556 0.888889 0.037037 

Base 4
0 0.25 0.5 0.75 0.0625 0.3125 0.5625 0.8125 0.125 0.375 

Base 5
0 0.2 0.4 0.6 0.8 0.04 0.24 0.44 0.64 0.84 

C#[edit]

This is based on the C version.
It uses LINQ and enumeration over a collection to package the sequence and make it easy to use. Note that the iterator returns a generic Tuple whose items are the numerator and denominator for the item.

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace VanDerCorput
{
/// <summary>
/// Computes the Van der Corput sequence for any number base.
/// The numbers in the sequence vary from zero to one, including zero but excluding one.
/// The sequence possesses low discrepancy.
/// Here are the first ten terms for bases 2 to 5:
///
/// base 2: 0 1/2 1/4 3/4 1/8 5/8 3/8 7/8 1/16 9/16
/// base 3: 0 1/3 2/3 1/9 4/9 7/9 2/9 5/9 8/9 1/27
/// base 4: 0 1/4 1/2 3/4 1/16 5/16 9/16 13/16 1/8 3/8
/// base 5: 0 1/5 2/5 3/5 4/5 1/25 6/25 11/25 16/25 21/25
/// </summary>
/// <see cref="http://rosettacode.org/wiki/Van_der_Corput_sequence"/>
public class VanDerCorputSequence: IEnumerable<Tuple<long,long>>
{
/// <summary>
/// Number base for the sequence, which must bwe two or more.
/// </summary>
public int Base { get; private set; }
 
/// <summary>
/// Maximum number of terms to be returned by iterator.
/// </summary>
public long Count { get; private set; }
 
/// <summary>
/// Construct a sequence for the given base.
/// </summary>
/// <param name="iBase">Number base for the sequence.</param>
/// <param name="count">Maximum number of items to be returned by the iterator.</param>
public VanDerCorputSequence(int iBase, long count = long.MaxValue) {
if (iBase < 2)
throw new ArgumentOutOfRangeException("iBase", "must be two or greater, not the given value of " + iBase);
Base = iBase;
Count = count;
}
 
/// <summary>
/// Compute nth term in the Van der Corput sequence for the base specified in the constructor.
/// </summary>
/// <param name="n">The position in the sequence, which may be zero or any positive number.</param>
/// This number is always an integral power of the base.</param>
/// <returns>The Van der Corput sequence value expressed as a Tuple containing a numerator and a denominator.</returns>
public Tuple<long,long> Compute(long n)
{
long p = 0, q = 1;
long numerator, denominator;
while (n != 0)
{
p = p * Base + (n % Base);
q *= Base;
n /= Base;
}
numerator = p;
denominator = q;
while (p != 0)
{
n = p;
p = q % p;
q = n;
}
numerator /= q;
denominator /= q;
return new Tuple<long,long>(numerator, denominator);
}
 
/// <summary>
/// Compute nth term in the Van der Corput sequence for the given base.
/// </summary>
/// <param name="iBase">Base to use for the sequence.</param>
/// <param name="n">The position in the sequence, which may be zero or any positive number.</param>
/// <returns>The Van der Corput sequence value expressed as a Tuple containing a numerator and a denominator.</returns>
public static Tuple<long, long> Compute(int iBase, long n)
{
var seq = new VanDerCorputSequence(iBase);
return seq.Compute(n);
}
 
/// <summary>
/// Iterate over the Van Der Corput sequence.
/// The first value in the sequence is always zero, regardless of the base.
/// </summary>
/// <returns>A tuple whose items are the Van der Corput value given as a numerator and denominator.</returns>
public IEnumerator<Tuple<long, long>> GetEnumerator()
{
long iSequenceIndex = 0L;
while (iSequenceIndex < Count)
{
yield return Compute(iSequenceIndex);
iSequenceIndex++;
}
}
 
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
 
class Program
{
static void Main(string[] args)
{
TestBasesTwoThroughFive();
 
Console.WriteLine("Type return to continue...");
Console.ReadLine();
}
 
static void TestBasesTwoThroughFive()
{
foreach (var seq in Enumerable.Range(2, 5).Select(x => new VanDerCorputSequence(x, 10))) // Just the first 10 elements of the each sequence
{
Console.Write("base " + seq.Base + ":");
foreach(var vc in seq)
Console.Write(" " + vc.Item1 + "/" + vc.Item2);
Console.WriteLine();
}
}
}
}
 
 
Output:
base 2: 0/1 1/2 1/4 3/4 1/8 5/8 3/8 7/8 1/16 9/16
base 3: 0/1 1/3 2/3 1/9 4/9 7/9 2/9 5/9 8/9 1/27
base 4: 0/1 1/4 1/2 3/4 1/16 5/16 9/16 13/16 1/8 3/8
base 5: 0/1 1/5 2/5 3/5 4/5 1/25 6/25 11/25 16/25 21/25
base 6: 0/1 1/6 1/3 1/2 2/3 5/6 1/36 7/36 13/36 19/36
Type return to continue...

Clojure[edit]

(defn van-der-corput
"Get the nth element of the van der Corput sequence."
([n]
;; Default base = 2
(van-der-corput n 2))
([n base]
(let [s (/ 1 base)] ;; A multiplicand to shift to the right of the decimal.
;; We essentially want to reverse the digits of n and put them after the
;; decimal point. So, we repeatedly pull off the lowest digit of n, scale
;; it to the right of the decimal point, and accumulate that.
(loop [sum 0
n n
scale s]
(if (zero? n)
sum ;; Base case: no digits left, so we're done.
(recur (+ sum (* (rem n base) scale)) ;; Accumulate the least digit
(quot n base) ;; Drop a digit of n
(* scale s))))))) ;; Move farther past the decimal
 
(clojure.pprint/print-table
(cons :base (range 10)) ;; column headings
(for [base (range 2 6)] ;; rows
(into {:base base}
(for [n (range 10)] ;; table entries
[n (van-der-corput n base)]))))
Output:
| :base | 0 |   1 |   2 |   3 |    4 |    5 |    6 |     7 |     8 |     9 |
|-------+---+-----+-----+-----+------+------+------+-------+-------+-------|
|     2 | 0 | 1/2 | 1/4 | 3/4 |  1/8 |  5/8 |  3/8 |   7/8 |  1/16 |  9/16 |
|     3 | 0 | 1/3 | 2/3 | 1/9 |  4/9 |  7/9 |  2/9 |   5/9 |   8/9 |  1/27 |
|     4 | 0 | 1/4 | 1/2 | 3/4 | 1/16 | 5/16 | 9/16 | 13/16 |   1/8 |   3/8 |
|     5 | 0 | 1/5 | 2/5 | 3/5 |  4/5 | 1/25 | 6/25 | 11/25 | 16/25 | 21/25 |


Common Lisp[edit]

(defun van-der-Corput (n base)
(loop for d = 1 then (* d base) while (<= d n)
finally
(return (/ (parse-integer
(reverse (write-to-string n :base base))
:radix base)
d))))
 
(loop for base from 2 to 5 do
(format t "Base ~a: ~{~6a~^~}~%" base
(loop for i to 10 collect (van-der-Corput i base))))
Output:
Base 2: 0     1/2   1/4   3/4   1/8   5/8   3/8   7/8   1/16  9/16  5/16  
Base 3: 0     1/3   2/3   1/9   4/9   7/9   2/9   5/9   8/9   1/27  10/27 
Base 4: 0     1/4   1/2   3/4   1/16  5/16  9/16  13/16 1/8   3/8   5/8   
Base 5: 0     1/5   2/5   3/5   4/5   1/25  6/25  11/25 16/25 21/25 2/25

D[edit]

double vdc(int n, in double base=2.0) pure nothrow @safe @nogc {
double vdc = 0.0, denom = 1.0;
while (n) {
denom *= base;
vdc += (n % base) / denom;
n /= base;
}
return vdc;
}
 
void main() {
import std.stdio, std.algorithm, std.range;
 
foreach (immutable b; 2 .. 6)
writeln("\nBase ", b, ": ", 10.iota.map!(n => vdc(n, b)));
}
Output:
Base 2: [0, 0.5, 0.25, 0.75, 0.125, 0.625, 0.375, 0.875, 0.0625, 0.5625]

Base 3: [0, 0.333333, 0.666667, 0.111111, 0.444444, 0.777778, 0.222222, 0.555556, 0.888889, 0.037037]

Base 4: [0, 0.25, 0.5, 0.75, 0.0625, 0.3125, 0.5625, 0.8125, 0.125, 0.375]

Base 5: [0, 0.2, 0.4, 0.6, 0.8, 0.04, 0.24, 0.44, 0.64, 0.84]

Ela[edit]

open random number list
 
vdc bs n = vdc' 0.0 1.0 n
where vdc' v d n
| n > 0 = vdc' v' d' n'
| else = v
where
d' = d * bs
rem = n % bs
n' = truncate (n / bs)
v' = v + rem / d'

Test (with base 2.0, using non-strict map function on infinite list):

take 10 <| map' (vdc 2.0) [1..]
Output:
[0.5,0.25,0.75,0.125,0.625,0.375,0.875,0.0625,0.5625,0.3125]

Elixir[edit]

Works with: Elixir version 1.1
defmodule Van_der_corput do
def sequence( n, base \\ 2 ) do
"0." <> (Integer.to_string(n, base) |> String.reverse )
end
 
def float( n, base \\ 2 ) do
Integer.digits(n, base) |> Enum.reduce(0, fn i,acc -> (i + acc) / base end)
end
 
def fraction( n, base \\ 2 ) do
str = Integer.to_string(n, base) |> String.reverse
denominator = Enum.reduce(1..String.length(str), 1, fn _,acc -> acc*base end)
reduction(String.to_integer(str, base), denominator, 2)
end
 
defp reduction( 0, _, _ ), do: "0"
defp reduction( numerator, denominator, i ) when numerator < i, do: "#{numerator}/#{denominator}"
defp reduction( numerator, denominator, i ) when rem(numerator, i)==0 and rem(denominator, i)==0 do
reduction( div(numerator, i), div(denominator, i), i )
end
defp reduction( numerator, denominator, i ), do: reduction( numerator, denominator, i+1 )
end
 
funs = [ {"Float(Base):", &Van_der_corput.sequence/2},
{"Float(Decimal):", &Van_der_corput.float/2},
{"Fraction:", &Van_der_corput.fraction/2} ]
Enum.each(funs, fn {title, fun} ->
IO.puts title
Enum.each(2..5, fn base ->
IO.puts " Base #{ base }: #{ Enum.map_join(0..9, ", ", &fun.(&1, base)) }"
end)
end)
Output:
Float(Base):
  Base 2: 0.0, 0.1, 0.01, 0.11, 0.001, 0.101, 0.011, 0.111, 0.0001, 0.1001
  Base 3: 0.0, 0.1, 0.2, 0.01, 0.11, 0.21, 0.02, 0.12, 0.22, 0.001
  Base 4: 0.0, 0.1, 0.2, 0.3, 0.01, 0.11, 0.21, 0.31, 0.02, 0.12
  Base 5: 0.0, 0.1, 0.2, 0.3, 0.4, 0.01, 0.11, 0.21, 0.31, 0.41
Float(Decimal):
  Base 2: 0.0, 0.5, 0.25, 0.75, 0.125, 0.625, 0.375, 0.875, 0.0625, 0.5625
  Base 3: 0.0, 0.3333333333333333, 0.6666666666666666, 0.1111111111111111, 0.4444444444444444, 0.7777777777777778, 0.2222222222222222, 0.5555555555555555, 0.8888888888888888, 0.037037037037037035
  Base 4: 0.0, 0.25, 0.5, 0.75, 0.0625, 0.3125, 0.5625, 0.8125, 0.125, 0.375
  Base 5: 0.0, 0.2, 0.4, 0.6, 0.8, 0.04, 0.24, 0.44000000000000006, 0.64, 0.8400000000000001
Fraction:
  Base 2: 0, 1/2, 1/4, 3/4, 1/8, 5/8, 3/8, 7/8, 1/16, 9/16
  Base 3: 0, 1/3, 2/3, 1/9, 4/9, 7/9, 2/9, 5/9, 8/9, 1/27
  Base 4: 0, 1/4, 1/2, 3/4, 1/16, 5/16, 9/16, 13/16, 1/8, 3/8
  Base 5: 0, 1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25

Erlang[edit]

I liked the bc output-in-same-base, but think this is the way it should look.

 
-module( van_der_corput ).
 
-export( [sequence/1, sequence/2, task/0] ).
 
sequence( N ) -> sequence( N, 2 ).
 
sequence( 0, _Base ) -> 0.0;
sequence( N, Base ) -> erlang:list_to_float( "0." ++ lists:flatten([erlang:integer_to_list(X) || X <- sequence_loop(N, Base)]) ).
 
task() -> [task(X) || X <- lists:seq(2, 5)].
 
 
 
sequence_loop( 0, _Base ) -> [];
sequence_loop( N, Base ) ->
New_n = N div Base,
Digit = N rem Base,
[Digit | sequence_loop( New_n, Base )].
 
task( Base ) ->
io:fwrite( "Base ~p:", [Base] ),
[io:fwrite( " ~p", [sequence(X, Base)] ) || X <- lists:seq(0, 9)],
io:fwrite( "~n" ).
 
Output:
34> van_der_corput:task().
Base 2: 0.0 0.1 0.01 0.11 0.001 0.101 0.011 0.111 0.0001 0.1001
Base 3: 0.0 0.1 0.2 0.01 0.11 0.21 0.02 0.12 0.22 0.001
Base 4: 0.0 0.1 0.2 0.3 0.01 0.11 0.21 0.31 0.02 0.12
Base 5: 0.0 0.1 0.2 0.3 0.4 0.01 0.11 0.21 0.31 0.41

ERRE[edit]

PROGRAM VAN_DER_CORPUT
 
!
! for rosettacode.org
!
 
PROCEDURE VDC(N%,B%->RES)
LOCAL V,S%
S%=1
WHILE N%>0 DO
S%*=B%
V+=(N% MOD B%)/S%
N%=N% DIV B%
END WHILE
RES=V
END PROCEDURE
 
BEGIN
FOR BASE%=2 TO 5 DO
PRINT("Base";STR$(BASE%);":")
FOR NUMBER%=0 TO 9 DO
VDC(NUMBER%,BASE%->RES)
WRITE("#.##### ";RES;)
END FOR
PRINT
END FOR
END PROGRAM
Output:
Base 2:
 0.00000 0.50000 0.25000 0.75000 0.12500 0.62500 0.37500 0.87500 0.06250 0.56250
Base 3:
 0.00000 0.33333 0.66667 0.11111 0.44444 0.77778 0.22222 0.55556 0.88889 0.03704
Base 4:
 0.00000 0.25000 0.50000 0.75000 0.06250 0.31250 0.56250 0.81250 0.12500 0.37500
Base 5:
 0.00000 0.20000 0.40000 0.60000 0.80000 0.04000 0.24000 0.44000 0.64000 0.84000

Euphoria[edit]

Translation of: D
function vdc(integer n, atom base)
atom vdc, denom, rem
vdc = 0
denom = 1
while n do
denom *= base
rem = remainder(n,base)
n = floor(n/base)
vdc += rem / denom
end while
return vdc
end function
 
for i = 2 to 5 do
printf(1,"Base %d\n",i)
for j = 0 to 9 do
printf(1,"%g ",vdc(j,i))
end for
puts(1,"\n\n")
end for
Output:
Base 2
0 0.5 0.25 0.75 0.125 0.625 0.375 0.875 0.0625 0.5625

Base 3
0 0.333333 0.666667 0.111111 0.444444 0.777778 0.222222 0.555556 0.888889 0.037037

Base 4
0 0.25 0.5 0.75 0.0625 0.3125 0.5625 0.8125 0.125 0.375

Base 5
0 0.2 0.4 0.6 0.8 0.04 0.24 0.44 0.64 0.84

F#[edit]

open System
 
let vdc n b =
let rec loop n denom acc =
if n > 0l then
let m, remainder = Math.DivRem(n, b)
loop m (denom * b) (acc + (float remainder) / (float (denom * b)))
else acc
loop n 1 0.0
 
 
[<EntryPoint>]
let main argv =
printfn "%A" [ for n in 0 .. 9 -> (vdc n 2) ]
printfn "%A" [ for n in 0 .. 9 -> (vdc n 5) ]
0
Output:
[0.0; 0.5; 0.25; 0.75; 0.125; 0.625; 0.375; 0.875; 0.0625; 0.5625]
[0.0; 0.2; 0.4; 0.6; 0.8; 0.04; 0.24; 0.44; 0.64; 0.84]

Forth[edit]

: fvdc ( base n -- f )
0e 1e ( F: vdc denominator )
begin dup while
over s>d d>f f*
over /mod ( base rem n )
swap s>d d>f fover f/
frot f+ fswap
repeat 2drop fdrop ;
 
: test 10 0 do 2 i fvdc cr f. loop ;
Output:
test
0.
0.5
0.25
0.75
0.125
0.625
0.375
0.875
0.0625
0.5625  ok

Go[edit]

package main
 
import "fmt"
 
func v2(n uint) (r float64) {
p := .5
for n > 0 {
if n&1 == 1 {
r += p
}
p *= .5
n >>= 1
}
return
}
 
func newV(base uint) func(uint) float64 {
invb := 1 / float64(base)
return func(n uint) (r float64) {
p := invb
for n > 0 {
r += p * float64(n%base)
p *= invb
n /= base
}
return
}
}
 
func main() {
fmt.Println("Base 2:")
for i := uint(0); i < 10; i++ {
fmt.Println(i, v2(i))
}
fmt.Println("Base 3:")
v3 := newV(3)
for i := uint(0); i < 10; i++ {
fmt.Println(i, v3(i))
}
}
Output:
Base 2:
0 0
1 0.5
2 0.25
3 0.75
4 0.125
5 0.625
6 0.375
7 0.875
8 0.0625
9 0.5625
Base 3:
0 0
1 0.3333333333333333
2 0.6666666666666666
3 0.1111111111111111
4 0.4444444444444444
5 0.7777777777777777
6 0.2222222222222222
7 0.5555555555555556
8 0.8888888888888888
9 0.037037037037037035

Haskell[edit]

The function vdc returns the nth exact, arbitrary precision van der Corput number for any base ≥ 2 and any n. (A reasonable value is returned for negative values of n.)

import Data.List
import Data.Ratio
import System.Environment
import Text.Printf
 
-- A wrapper type for Rationals to make them look nicer when we print them.
newtype Rat = Rat Rational
instance Show Rat where
show (Rat n) = show (numerator n) ++ "/" ++ show (denominator n)
 
-- Convert a list of base b digits to its corresponding number. We assume the
-- digits are valid base b numbers and that their order is from least to most
-- significant.
digitsToNum :: Integer -> [Integer] -> Integer
digitsToNum b = foldr1 (\d acc -> b * acc + d)
 
-- Convert a number to the list of its base b digits. The order will be from
-- least to most significant.
numToDigits :: Integer -> Integer -> [Integer]
numToDigits _ 0 = [0]
numToDigits b n = unfoldr step n
where step 0 = Nothing
step m = let (q,r) = m `quotRem` b in Just (r,q)
 
-- Return the n'th element in the base b van der Corput sequence. The base
-- must be ≥ 2.
vdc :: Integer -> Integer -> Rat
vdc b n | b < 2 = error "vdc: base must be ≥ 2"
| otherwise = let ds = reverse $ numToDigits b n
in Rat (digitsToNum b ds % b ^ length ds)
 
-- Print the base followed by a sequence of van der Corput numbers.
printVdc :: (Integer,[Rat]) -> IO ()
printVdc (b,ns) = putStrLn $ printf "Base %d:" b
++ concatMap (printf " %5s" . show) ns
 
-- To print the n'th van der Corput numbers for n in [2,3,4,5] call the program
-- with no arguments. Otherwise, passing the base b, first n, next n and
-- maximum n will print the base b numbers for n in [firstN, nextN, ..., maxN].
main :: IO ()
main = do
args <- getArgs
let (bases, nums) = case args of
[b, f, s, m] -> ([read b], [read f, read s..read m])
_ -> ([2,3,4,5], [0..9])
mapM_ printVdc [(b,rs) | b <- bases, let rs = map (vdc b) nums]
Output:
for small bases:
$ ./vandercorput 
Base 2:   0/1   1/2   1/4   3/4   1/8   5/8   3/8   7/8  1/16  9/16
Base 3:   0/1   1/3   2/3   1/9   4/9   7/9   2/9   5/9   8/9  1/27
Base 4:   0/1   1/4   1/2   3/4  1/16  5/16  9/16 13/16   1/8   3/8
Base 5:   0/1   1/5   2/5   3/5   4/5  1/25  6/25 11/25 16/25 21/25
Output:
for a larger base. (Base 123 for n ∈ [50, 100, …, 300].)
$ ./vandercorput 123 50 100 300
Base 123: 50/123 100/123 3322/15129 9472/15129 494/15129 6644/15129

Icon and Unicon[edit]

The following solution works in both Icon and Unicon:

procedure main(A)
base := integer(get(A)) | 2
every writes(round(vdc(0 to 9,base),10)," ")
write()
end
 
procedure vdc(n, base)
e := 1.0
x := 0.0
while x +:= 1(((0 < n) % base) / (e *:= base), n /:= base)
return x
end
 
procedure round(n,d)
places := 10 ^ d
return real(integer(n*places + 0.5)) / places
end

and a sample run is:

->vdc
0.0 0.5 0.25 0.75 0.125 0.625 0.375 0.875 0.0625 0.5625 
->vdc 3
0.0 0.3333333333 0.6666666667 0.1111111111 0.4444444444 0.7777777778 0.2222222222 0.5555555556 0.8888888889 0.037037037 
->vdc 5
0.0 0.2 0.4 0.6 0.8 0.04 0.24 0.44 0.64 0.84 
->vdc 123
0.0 0.0081300813 0.0162601626 0.0243902439 0.0325203252 0.0406504065 0.0487804878 0.0569105691 0.0650406504 0.07317073170000001 
->

An alternate, Unicon-specific implementation of vdc patterned after the functional Perl 6 solution is:

procedure vdc(n, base)
s1 := create |((0 < 1(.n, n /:= base)) % base)
s2 := create 2(e := 1.0, |(e *:= base))
every (result := 0) +:= |s1() / s2()
return result
end

It produces the same output as shown above.

J[edit]

Solution:

vdc=: ([ %~ %@[ #. #.inv)"0 _

Examples:

   2 vdc i.10                NB. 1st 10 nums of Van der Corput sequence in base 2
0 0.5 0.25 0.75 0.125 0.625 0.375 0.875 0.0625 0.5625
2x vdc i.10 NB. as above but using rational nums
0 1r2 1r4 3r4 1r8 5r8 3r8 7r8 1r16 9r16
2 3 4 5x vdc i.10 NB. 1st 10 nums of Van der Corput sequence in bases 2 3 4 5
0 1r2 1r4 3r4 1r8 5r8 3r8 7r8 1r16 9r16
0 1r3 2r3 1r9 4r9 7r9 2r9 5r9 8r9 1r27
0 1r4 1r2 3r4 1r16 5r16 9r16 13r16 1r8 3r8
0 1r5 2r5 3r5 4r5 1r25 6r25 11r25 16r25 21r25

In other words: use the left argument as the "base" to structure the sequence numbers into digits ("base 2", etc.). Then use the reciprocal of the left argument as the "base" to re-represent this sequence and divide that result by the left argument to get the Van der Corput sequence number.

Java[edit]

Translation of: Perl 6

Using (denom *= 2) as the denominator is not a recommended way of doing things since it is not clear when the multiplication and assignment happen. Comparing this to the "++" operator, it looks like it should do the doubling and assignment second. Comparing it to the "++" operator used as a preincrement operator, it looks like it should do the doubling and assignment first. Comparing it to the behavior of parentheses, it looks like it should do the doubling and assignment first. Luckily for us, it works the same in Java as in Perl 6 (doubling and assignment first). It was kept the Perl 6 way to help with the comparison. Normally, we would initialize denom to 2 (since that is the denominator of the leftmost digit), use it alone in the vdc sum, and then double it after.

public class VanDerCorput{
public static double vdc(int n){
double vdc = 0;
int denom = 1;
while(n != 0){
vdc += n % 2.0 / (denom *= 2);
n /= 2;
}
return vdc;
}
 
public static void main(String[] args){
for(int i = 0; i <= 10; i++){
System.out.println(vdc(i));
}
}
}
Output:
0.0
0.5
0.25
0.75
0.125
0.625
0.375
0.875
0.0625
0.5625
0.3125

jq[edit]

Works with: jq version 1.4

The neat thing about the following implementation of vdc(base) is that it shows how the task can be accomplished in two separate steps without the need to construct an intermediate array.

# vdc(base) converts an input decimal integer to a decimal number based on the van der
# Corput sequence using base 'base', e.g. (4 | vdc(2)) is 0.125.
#
def vdc(base):
 
# The helper function converts a stream of residuals to a decimal,
# e.g. if base is 2, then decimalize( (0,0,1) ) yields 0.125
def decimalize(stream):
reduce stream as $d # state: [accumulator, power]
( [0, 1/base];
.[1] as $power | [ .[0] + ($d * $power), $power / base] )
| .[0];
 
if . == 0 then 0
else decimalize(recurse( if . == 0 then empty else ./base | floor end ) % base)
end ;

Example:

def round(n):
(if . < 0 then -1 else 1 end) as $s
| $s*10*.*n | if (floor%10)>4 then (.+5) else . end | ./10 | floor/n | .*$s;
 
range(2;6) | . as $base | "Base \(.): \( [ range(0;11) | vdc($base)|round(1000) ] )"
Output:
 
$ jq -n -f -c -r van_der_corput_sequence.jq
Base 2: [0,0.5,0.25,0.75,0.125,0.625,0.375,0.875,0.063,0.563,0.313]
Base 3: [0,0.333,0.667,0.111,0.444,0.778,0.222,0.556,0.889,0.037,0.37]
Base 4: [0,0.25,0.5,0.75,0.063,0.313,0.563,0.813,0.125,0.375,0.625]
Base 5: [0,0.2,0.4,0.6,0.8,0.04,0.24,0.44,0.64,0.84,0.08]

Julia[edit]

 
function vdc{T<:Integer}(n::T, b::T)
sum([d*float(b)^-i for (i, d) in enumerate(digits(n, b))])
end
 
for i in 2:9
print(" Base ", i)
for j in 0:9
print(@sprintf(" %8.6f", vdc(j, i)))
end
println()
end
 
Output:
   Base 2 0.000000 0.500000 0.250000 0.750000 0.125000 0.625000 0.375000 0.875000 0.062500 0.562500
   Base 3 0.000000 0.333333 0.666667 0.111111 0.444444 0.777778 0.222222 0.555556 0.888889 0.037037
   Base 4 0.000000 0.250000 0.500000 0.750000 0.062500 0.312500 0.562500 0.812500 0.125000 0.375000
   Base 5 0.000000 0.200000 0.400000 0.600000 0.800000 0.040000 0.240000 0.440000 0.640000 0.840000
   Base 6 0.000000 0.166667 0.333333 0.500000 0.666667 0.833333 0.027778 0.194444 0.361111 0.527778
   Base 7 0.000000 0.142857 0.285714 0.428571 0.571429 0.714286 0.857143 0.020408 0.163265 0.306122
   Base 8 0.000000 0.125000 0.250000 0.375000 0.500000 0.625000 0.750000 0.875000 0.015625 0.140625
   Base 9 0.000000 0.111111 0.222222 0.333333 0.444444 0.555556 0.666667 0.777778 0.888889 0.012346

Lua[edit]

function vdc(n, base)
local digits = {}
while n ~= 0 do
local m = math.floor(n / base)
table.insert(digits, n - m * base)
n = m
end
m = 0
for p, d in pairs(digits) do
m = m + math.pow(base, -p) * d
end
return m
end

Mathematica[edit]

VanDerCorput[n_,base_:2]:=Table[
FromDigits[{Reverse[IntegerDigits[k,base]],0},base],
{k,n}]


VanDerCorput[10,2]
->{1/2,1/4,3/4,1/8,5/8,3/8,7/8,1/16,9/16,5/16}

VanDerCorput[10,3]
->{1/3, 2/3, 1/9, 4/9, 7/9, 2/9, 5/9, 8/9, 1/27, 10/27}

VanDerCorput[10,4]
->{1/4, 1/2, 3/4, 1/16, 5/16, 9/16, 13/16, 1/8, 3/8, 5/8}

VanDerCorput[10,5]
->{1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25, 2/25}

MATLAB / Octave[edit]

    function x = corput (n)
b = dec2bin(1:n)-'0'; % generate sequence of binary numbers from 1 to n
l = size(b,2); % get number of binary digits
w = (1:l)-l-1; % 2.^w are the weights
x = b * ( 2.^w'); % matrix times vector multiplication for
end;
Output:
 corput(10)
 ans =

   0.500000
   0.250000
   0.750000
   0.125000
   0.625000
   0.375000
   0.875000
   0.062500
   0.562500
   0.312500

Maxima[edit]

Define two helper functions

/* convert a decimal integer to a list of digits in base `base' */
dec2digits(d, base):= block([digits: []],
while (d>0) do block([newdi: mod(d, base)],
digits: cons(newdi, digits),
d: round( (d - newdi) / base)),
digits)$
 
dec2digits(123, 10);
/* [1, 2, 3] */
dec2digits( 8, 2);
/* [1, 0, 0, 0] */
/* convert a list of digits in base `base' to a decimal integer */
digits2dec(l, base):= block([s: 0, po: 1],
for di in reverse(l) do (s: di*po + s, po: po*base),
s)$
 
digits2dec([1, 2, 3], 10);
/* 123 */
digits2dec([1, 0, 0, 0], 2);
/* 8 */

The main function

vdc(n, base):= makelist(
digits2dec(
dec2digits(k, base),
1/base) / base,
k, n);
 
vdc(10, 2);
/*
1 1 3 1 5 3 7 1 9 5
(%o123) [-, -, -, -, -, -, -, --, --, --]
2 4 4 8 8 8 8 16 16 16
*/
 
vdc(10, 5);
/*
1 2 3 4 1 6 11 16 21 2
(%o124) [-, -, -, -, --, --, --, --, --, --]
5 5 5 5 25 25 25 25 25 25
*/

digits2dec can by used with symbols to produce the same example as in the task description

 
/* 11 in decimal is */
digits: digits2dec([box(1), box(0), box(1), box(1)], box(2));
aux: expand(digits2dec(digits, 1/base) / base)$
simp: false$
/* reflected this would become ... */
subst(box(2), base, aux);
simp: true$
 
/*
 
3 2
""" """ """ """ """ """ """
(%o126) "2" "1" + "2" "0" + "2" "1" + "1"
""" """ """ """ """ """ """
 
- 4 - 3 - 2 - 1
""" """ """ """ """ """ """ """
(%o129) "1" "2" + "0" "2" + "1" "2" + "1" "2"
""" """ """ """ """ """ """ """
 
*/

PARI/GP[edit]

VdC(n)=n=binary(n);sum(i=1,#n,if(n[i],1.>>(#n+1-i)));
VdC(n)=sum(i=1,#binary(n),if(bittest(n,i-1),1.>>i)); \\ Alternate approach
vector(10,n,VdC(n))
Output:
[0.500000000, 0.250000000, 0.750000000, 0.125000000, 0.625000000, 0.375000000, 0.875000000, 0.0625000000, 0.562500000, 0.312500000]

Pascal[edit]

Tested with Free Pascal

Program VanDerCorput;
{$IFDEF FPC}
{$MODE DELPHI}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
 
type
tvdrCallback = procedure (nom,denom: NativeInt);
 
{ Base=2
function rev2(n,Pot:NativeUint):NativeUint;
var
r : Nativeint;
begin
r := 0;
while Pot > 0 do
Begin
r := r shl 1 OR (n AND 1);
n := n shr 1;
dec(Pot);
end;
rev2 := r;
end;
}

 
function reverse(n,base,Pot:NativeUint):NativeUint;
var
r,c : Nativeint;
begin
r := 0;
//No need to test n> 0 in this special case, n starting in upper half
while Pot > 0 do
Begin
c := n div base;
r := n+(r-c)*base;
n := c;
dec(Pot);
end;
reverse := r;
end;
 
procedure VanDerCorput(base,count:NativeUint;f:tvdrCallback);
//calculates count nominater and denominater of Van der Corput sequence
// to base
var
Pot,
denom,nom,
i : NativeUint;
Begin
denom := 1;
Pot := 0;
while count > 0 do
Begin
IF Pot = 0 then
f(0,1);
//start in upper half
i := denom;
inc(Pot);
denom := denom *base;
 
repeat
nom := reverse(i,base,Pot);
IF count > 0 then
f(nom,denom)
else
break;
inc(i);
dec(count);
until i >= denom;
end;
end;
 
procedure vdrOutPut(nom,denom: NativeInt);
Begin
write(nom,'/',denom,' ');
end;
 
var
i : NativeUint;
Begin
For i := 2 to 5 do
Begin
write(' Base ',i:2,' :');
VanDerCorput(i,9,@vdrOutPut);
writeln;
end;
end.
 
output
 Base  2 :0/1  1/2  1/4  3/4  1/8  5/8  3/8  7/8  1/16  9/16  
 Base  3 :0/1  1/3  2/3  1/9  4/9  7/9  2/9  5/9  8/9  1/27  
 Base  4 :0/1  1/4  2/4  3/4  1/16  5/16  9/16  13/16  2/16  6/16  
 Base  5 :0/1  1/5  2/5  3/5  4/5  1/25  6/25  11/25  16/25  21/25

Perl[edit]

Translation of: Perl6
sub vdc {
my @value = shift;
my $base = shift // 2;
use integer;
push @value, $value[-1] / $base while $value[-1] > 0;
my ($x, $sum) = (1, 0);
no integer;
$sum += ($_ % $base) / ($x *= $base) for @value;
return $sum;
}
 
for my $base ( 2 .. 5 ) {
print "base $base: ", join ' ', map { vdc($_, $base) } 0 .. 10;
print "\n";
}

Perl 6[edit]

First a cheap implementation in base 2, using string operations.

constant VdC = map { :2("0." ~ .base(2).flip) }, ^Inf;
.say for VdC[^16];

Here is a more elaborate version using the polymod built-in integer method:

sub VdC($base = 2) {
map {
[+] $_ && .polymod($base xx *) Z/ [\*] $base xx *
}, ^Inf
}
 
.say for VdC[^10];
Output:
0
0.5
0.25
0.75
0.125
0.625
0.375
0.875
0.0625
0.5625

Here is a fairly standard imperative version in which we mutate three variables in parallel:

sub vdc($num, $base = 2) {
my $n = $num;
my $vdc = 0;
my $denom = 1;
while $n {
$vdc += $n mod $base / ($denom *= $base);
$n div= $base;
}
$vdc;
}
 
for 2..5 -> $b {
say "Base $b";
say (vdc($_,$b) for ^10).perl;
say '';
}
Output:
Base 2
(0, 1/2, 1/4, 3/4, 1/8, 5/8, 3/8, 7/8, 1/16, 9/16)

Base 3
(0, 1/3, 2/3, 1/9, 4/9, 7/9, 2/9, 5/9, 8/9, 1/27)

Base 4
(0, 1/4, 1/2, 3/4, 1/16, 5/16, 9/16, 13/16, 1/8, 3/8)

Base 5
(0, 1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25)

Here is a functional version that produces the same output:

sub vdc($value, $base = 2) {
my @values := $value, { $_ div $base } ... 0;
my @denoms := $base, { $_ * $base } ... *;
[+] do for @values Z @denoms -> $v, $d {
$v mod $base / $d;
}
}

We first define two sequences, one finite, one infinite. When we zip those sequences together, the finite sequence terminates the loop (which, since a Perl 6 loop returns all its values, is merely another way of writing a map). We then sum with [+], a reduction of the + operator. (We could have in-lined the sequences or used a traditional map operator, but this way seems more readable than the typical FP solution.) The do is necessary to introduce a statement where a term is expected, since Perl 6 distinguishes "sentences" from "noun phrases" as a natural language might.

Phix[edit]

Not entirely sure what to print, so decided to print in three different ways.
It struck me straightaway that the VdC of say 123 is 321/1000, which seems trivial in any base or desired format.

enum BASE, FRAC, DECIMAL
constant DESC = {"Base","Fraction","Decimal"}
 
function vdc(integer n, atom base, integer flag)
object res = ""
atom num = 0, denom = 1, digit, g
while n do
denom *= base
digit = remainder(n,base)
n = floor(n/base)
if flag=BASE then
res &= digit+'0'
else
num = num*base+digit
end if
end while
if flag=FRAC then
g = gcd(num,denom)
return {num/g,denom/g}
elsif flag=DECIMAL then
return num/denom
end if
return {iff(length(res)=0?"0":"0."&res)}
end function
 
procedure show_vdc(integer flag, string fmt)
object v
for i=2 to 5 do
printf(1,"%s %d: ",{DESC[flag],i})
for j=0 to 9 do
v = vdc(j,i,flag)
if flag=FRAC and v[1]=0 then
printf(1,"0 ")
else
printf(1,fmt,v)
end if
end for
puts(1,"\n")
end for
end procedure
 
show_vdc(BASE,"%s ")
show_vdc(FRAC,"%d/%d ")
show_vdc(DECIMAL,"%g ")
Output:
Base 2: 0 0.1 0.01 0.11 0.001 0.101 0.011 0.111 0.0001 0.1001
Base 3: 0 0.1 0.2 0.01 0.11 0.21 0.02 0.12 0.22 0.001
Base 4: 0 0.1 0.2 0.3 0.01 0.11 0.21 0.31 0.02 0.12
Base 5: 0 0.1 0.2 0.3 0.4 0.01 0.11 0.21 0.31 0.41
Fraction 2: 0 1/2 1/4 3/4 1/8 5/8 3/8 7/8 1/16 9/16
Fraction 3: 0 1/3 2/3 1/9 4/9 7/9 2/9 5/9 8/9 1/27
Fraction 4: 0 1/4 1/2 3/4 1/16 5/16 9/16 13/16 1/8 3/8
Fraction 5: 0 1/5 2/5 3/5 4/5 1/25 6/25 11/25 16/25 21/25
Decimal 2: 0 0.5 0.25 0.75 0.125 0.625 0.375 0.875 0.0625 0.5625
Decimal 3: 0 0.333333 0.666667 0.111111 0.444444 0.777778 0.222222 0.555556 0.888889 0.037037
Decimal 4: 0 0.25 0.5 0.75 0.0625 0.3125 0.5625 0.8125 0.125 0.375
Decimal 5: 0 0.2 0.4 0.6 0.8 0.04 0.24 0.44 0.64 0.84

PicoLisp[edit]

(scl 6)
 
(de vdc (N B)
(default B 2)
(let (R 0 A 1.0)
(until (=0 N)
(inc 'R (* (setq A (/ A B)) (% N B)))
(setq N (/ N B)) )
R ) )
 
(for B (2 3 4)
(prinl "Base: " B)
(for N (range 0 9)
(prinl N ": " (round (vdc N B) 4)) ) )
Output:
Base: 2
0: 0.0000
1: 0.5000
2: 0.2500
3: 0.7500
4: 0.1250
5: 0.6250
6: 0.3750
7: 0.8750
8: 0.0625
9: 0.5625
Base: 3
0: 0.0000
1: 0.3333
2: 0.6667
3: 0.1111
4: 0.4444
5: 0.7778
6: 0.2222
7: 0.5556
8: 0.8889
9: 0.0370
Base: 4
0: 0.0000
1: 0.2500
2: 0.5000
3: 0.7500
4: 0.0625
5: 0.3125
6: 0.5625
7: 0.8125
8: 0.1250
9: 0.3750

PL/I[edit]

 
vdcb: procedure (an) returns (bit (31)); /* 6 July 2012 */
declare an fixed binary (31);
declare (n, i) fixed binary (31);
declare v bit (31) varying;
 
n = an; v = ''b;
do i = 1 by 1 while (n > 0);
if iand(n, 1) = 1 then v = v || '1'b; else v = v || '0'b;
n = isrl(n, 1);
end;
return (v);
end vdcb;
 
declare i fixed binary (31);
 
do i = 0 to 10;
put skip list ('0.' || vdcb(i));
end;
 
Output:
0.0000000000000000000000000000000 
0.1000000000000000000000000000000 
0.0100000000000000000000000000000 
0.1100000000000000000000000000000 
0.0010000000000000000000000000000 
0.1010000000000000000000000000000 
0.0110000000000000000000000000000 
0.1110000000000000000000000000000 
0.0001000000000000000000000000000 
0.1001000000000000000000000000000 
0.0101000000000000000000000000000 

Prolog[edit]

% vdc( N, Base, Out )
% Out = the Van der Corput representation of N in given Base
vdc( 0, _, [] ).
vdc( N, Base, Out ) :-
Nr is mod(N, Base),
Nq is N // Base,
vdc( Nq, Base, Tmp ),
Out = [Nr|Tmp].
 
% Writes every element of a list to stdout; no newlines
write_list( [] ).
write_list( [H|T] ) :-
write( H ),
write_list( T ).
 
% Writes the Nth Van der Corput item.
print_vdc( N, Base ) :-
vdc( N, Base, Lst ),
write('0.'),
write_list( Lst ).
print_vdc( N ) :-
print_vdc( N, 2 ).
 
% Prints the first N+1 elements of the Van der Corput
% sequence, each to its own line
print_some( 0, _ ) :-
write( '0.0' ).
print_some( N, Base ) :-
M is N - 1,
print_some( M, Base ),
nl,
print_vdc( N, Base ).
print_some( N ) :-
print_some( N, 2 ).
 
test :-
writeln('First 10 members in base 2:'),
print_some( 9 ),
nl,
write('7th member in base 4 (stretch goal) => '),
print_vdc( 7, 4 ).
 
Output:
(result of test):
First 10 members in base 2:
0.0
0.1
0.01
0.11
0.001
0.101
0.011
0.111
0.0001
0.1001
7th member in base 4 (stretch goal) => 0.31
true .

Python[edit]

(Python3.x)

The multi-base sequence generator

def vdc(n, base=2):
vdc, denom = 0,1
while n:
denom *= base
n, remainder = divmod(n, base)
vdc += remainder / denom
return vdc

Sample output

Base 2 and then 3:

>>> [vdc(i) for i in range(10)]
[0, 0.5, 0.25, 0.75, 0.125, 0.625, 0.375, 0.875, 0.0625, 0.5625]
>>> [vdc(i, 3) for i in range(10)]
[0, 0.3333333333333333, 0.6666666666666666, 0.1111111111111111, 0.4444444444444444, 0.7777777777777777, 0.2222222222222222, 0.5555555555555556, 0.8888888888888888, 0.037037037037037035]
>>>

As fractions[edit]

We can get the output as rational numbers if we use the fraction module (and change its string representation to look like a fraction):

>>> from fractions import Fraction
>>> Fraction.__repr__ = lambda x: '%i/%i' % (x.numerator, x.denominator)
>>> [vdc(i, base=Fraction(2)) for i in range(10)]
[0, 1/2, 1/4, 3/4, 1/8, 5/8, 3/8, 7/8, 1/16, 9/16]

Stretch goal[edit]

Sequences for different bases:

>>> for b in range(3,6):
print('\nBase', b)
print([vdc(i, base=Fraction(b)) for i in range(10)])
 
Base 3
[0, 1/3, 2/3, 1/9, 4/9, 7/9, 2/9, 5/9, 8/9, 1/27]
 
Base 4
[0, 1/4, 1/2, 3/4, 1/16, 5/16, 9/16, 13/16, 1/8, 3/8]
 
Base 5
[0, 1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25]

Racket[edit]

Following the suggestion.

#lang racket
(define (van-der-Corput n base)
(if (zero? n)
0
(let-values ([(q r) (quotient/remainder n base)])
(/ (+ r (van-der-Corput q base))
base))))

By digits, extracted arithmetically.

#lang racket
(define (digit-length n base)
(if (< n base) 1 (add1 (digit-length (quotient n base) base))))
(define (digit n i base)
(remainder (quotient n (expt base i)) base))
(define (van-der-Corput n base)
(for/sum ([i (digit-length n base)]) (/ (digit n i base) (expt base (+ i 1)))))

Output.

(for ([base (in-range 2 (add1 5))])
(printf "Base ~a: " base)
(for ([n (in-range 0 10)])
(printf "~a " (van-der-Corput n base)))
(newline))
 
#| Base 2: 0 1/2 1/4 3/4 1/8 5/8 3/8 7/8 1/16 9/16
Base 3: 0 1/3 2/3 1/9 4/9 7/9 2/9 5/9 8/9 1/27
Base 4: 0 1/4 1/2 3/4 1/16 5/16 9/16 13/16 1/8 3/8
Base 5: 0 1/5 2/5 3/5 4/5 1/25 6/25 11/25 16/25 21/25 |#

REXX[edit]

binary version[edit]

This version only handles binary (base 2).

Virtually any integer (including negative) is allowed and is accurate (no rounding).

A range of integers is also supported.

/*REXX program converts an integer (or a range)  ──►  a Van der Corput number in base 2.*/
numeric digits 1000 /*handle almost anything the user wants*/
parse arg a b . /*obtain the optional arguments from CL*/
if a=='' then parse value 0 10 with a b /*Not specified? Then use the defaults*/
if b=='' then b=a /*assume a range for a single number.*/
 
do j=a to b /*traipse through the range of numbers.*/
_=VdC( abs(j) ) /*convert absolute value of an integer.*/
leading=substr('-', 2 + sign(j) ) /*if needed, elide the leading sign. */
say leading || _ /*show number, with leading minus sign?*/
end /*j*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
VdC: procedure; y=x2b( d2x( arg(1) ) ) + 0 /*convert to hexadecimal, then binary.*/
if y==0 then return 0 /*handle the special case of zero. */
else return '.'reverse(y) /*heavy lifting is performed by REXX. */

output when using the default input of:   0   10

0
.1
.01
.11
.001
.101
.011
.111
.0001
.1001
.0101

any radix up to 90[edit]

This version handles what the first version does, plus any radix up to (and including) base 90.
It can also support a list (enabled when the base is negative).

/*REXX program converts an  integer  (or a range)  ──►  a Van der Corput number,        */
/*─────────────── in base 2, or optionally, any other base up to and including base 90.*/
numeric digits 1000 /*handle almost anything the user wants*/
parse arg a b r . /*obtain optional arguments from the CL*/
if a=='' | a=="," then parse value 0 10 with a b /*Not specified? Then use the defaults*/
if b=='' | b=="," then b=a /* " " " " " " */
if r=='' | r=="," then r=2 /* " " " " " " */
z= /*a placeholder for a list of numbers. */
do j=a to b /*traipse through the range of integers*/
_=VdC( abs(j), abs(r) ) /*convert the ABSolute value of integer*/
_=substr('-', 2+sign(j) )_ /*if needed, keep the leading - sign.*/
if r>0 then say _ /*if positive base, then just show it. */
else z=z _ /* ··· else append (build) a list. */
end /*j*/
 
if z\=='' then say strip(z) /*if a list is wanted, then display it.*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
base: procedure; parse arg x, toB, inB /*get a number, toBase, and inBase. */
/*┌───────────────────────────────────────────────────────────────────┐
┌─┘ Input to this function: x (is required & must be an integer).└─┐
│ toBase the base to convert X to. │
│ inBase the base X is expressed in. │
│ │
│ toBase or inBase can be omitted which causes the default of 10 │
└─┐ to be used. Both have a limit of: 2 ──► 90.┌─┘
└───────────────────────────────────────────────────────────────────┘*/

@abc= 'abcdefghijklmnopqrstuvwxyz' /*the Latin lowercase alphabet chars. */
@[email protected]; upper @abcU /*go whole hog and extend characters. */
@@@= 0123456789 || @abc || @abcU /*prefix them with some numeric digits.*/
@@@= @@@'<>[]{}()?~!@#$%^&*_+-=|\/;:`' /*add some special characters as well, */
/*special characters should be viewable*/
numeric digits 1000 /*what the hey, support biggy numbers.*/
maxB=length(@@@) /*maximum base (radix) supported here. */
if toB=='' then toB=10 /*if skipped, then assume default (10)*/
if inB=='' then inB=10 /* " " " " " " */
#=0 /* [↓] convert base inB X ──► base 10*/
do j=1 for length(x)
_=substr(x, j, 1) /*pick off a "digit" (numeral) from X.*/
v=pos(_, @@@) /*get the value of this "digit"/numeral*/
if v==0|v>inB then call erd x,j,inB /*is it an illegal "digit" (numeral) ? */
#=#*inB + v - 1 /*construct new number, digit by digit.*/
end /*j*/
y= /* [↓] convert base 10 # ──► base toB.*/
do while #>=toB /*deconstruct the new number (#). */
y=substr(@@@, #//toB + 1, 1)y /* construct the output number, ··· */
#=# % toB /* ··· and also whittle down #. */
end /*while*/
 
return substr(@@@, #+1, 1)y
/*──────────────────────────────────────────────────────────────────────────────────────*/
VdC: return '.'reverse(base(arg(1), arg(2))) /*convert the #, reverse the #, append.*/

output   when using the multiple inputs of (where a negative base indicates to show numbers as a list):

0 30 -2
1 30 -3
1 30 -4
1 30 -5
55582777 55582804 -80

(All outputs are a single line list.)

.0 .1 .01 .11 .001 .101 .011 .111 .0001 .1001 .0101 .1101 .0011 .1011 .0111 .1111 .00001 .10001 .01001 .11001 .00101 .10101 .01101 .11101 .00011 .10011 .01011 .11011 .00111 .10111 .01111
.1 .2 .01 .11 .21 .02 .12 .22 .001 .101 .201 .011 .111 .211 .021 .121 .221 .002 .102 .202 .012 .112 .212 .022 .122 .222 .0001 .1001 .2001 .0101
.1 .2 .3 .01 .11 .21 .31 .02 .12 .22 .32 .03 .13 .23 .33 .001 .101 .201 .301 .011 .111 .211 .311 .021 .121 .221 .321 .031 .131 .231
.1 .2 .3 .4 .01 .11 .21 .31 .41 .02 .12 .22 .32 .42 .03 .13 .23 .33 .43 .04 .14 .24 .34 .44 .001 .101 .201 .301 .401 .011
.V[Is1 .W[Is1 .X[Is1 .Y[Is1 .Z[Is1 .<[Is1 .>[Is1 .[[Is1 .][Is1 .{[Is1 .}[Is1 .([Is1 .)[Is1 .?[Is1 .~[Is1 .![Is1 .@[Is1 .#[Is1 .$[Is1 .%[Is1 .^[Is1 .&[Is1 .*[Is1 .0]Is1 .1]Is1 .2]Is1 .3]Is1 .4]Is1

Ring[edit]

 
decimals(4)
for base = 2 to 5
see "base " + string(base) + " : "
for number = 0 to 9
see "" + corput(number, base) + " "
next
see nl
next
 
func corput n, b
vdc = 0
denom = 1
while n
denom *= b
rem = n % b
n = floor(n/b)
vdc += rem / denom
end
return vdc
 

Output:

base 2 : 0 0.5000 0.2500 0.7500 0.1250 0.6250 0.3750 0.8750 0.0625 0.5625
base 3 : 0 0.3333 0.6667 0.1111 0.4444 0.7778 0.2222 0.5556 0.8889 0.0370
base 4 : 0 0.2500 0.5000 0.7500 0.0625 0.3125 0.5625 0.8125 0.1250 0.3750
base 5 : 0 0.2000 0.4000 0.6000 0.8000 0.0400 0.2400 0.4400 0.6400 0.8400

Ruby[edit]

The multi-base sequence generator

def vdc(n, base=2)
str = n.to_s(base).reverse
str.to_i(base).quo(base ** str.length)
end
 
(2..5).each do |base|
puts "Base #{base}: " + Array.new(10){|i| vdc(i,base)}.join(", ")
end

Sample output

Base 2: 0/1, 1/2, 1/4, 3/4, 1/8, 5/8, 3/8, 7/8, 1/16, 9/16
Base 3: 0/1, 1/3, 2/3, 1/9, 4/9, 7/9, 2/9, 5/9, 8/9, 1/27
Base 4: 0/1, 1/4, 1/2, 3/4, 1/16, 5/16, 9/16, 13/16, 1/8, 3/8
Base 5: 0/1, 1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25

Seed7[edit]

Translation of: D
$ include "seed7_05.s7i";
include "float.s7i";
 
const func float: vdc (in var integer: number, in integer: base) is func
result
var float: vdc is 0.0;
local
var integer: denom is 1;
var integer: remainder is 0;
begin
while number <> 0 do
denom *:= base;
remainder := number rem base;
number := number div base;
vdc +:= flt(remainder) / flt(denom);
end while;
end func;
 
const proc: main is func
local
var integer: base is 0;
var integer: number is 0;
begin
for base range 2 to 5 do
writeln;
writeln("Base " <& base);
for number range 0 to 9 do
write(vdc(number, base) digits 6 <& " ");
end for;
writeln;
end for;
end func;
Output:

Base 2
0.000000 0.500000 0.250000 0.750000 0.125000 0.625000 0.375000 0.875000 0.062500 0.562500 

Base 3
0.000000 0.333333 0.666667 0.111111 0.444444 0.777778 0.222222 0.555556 0.888889 0.037037 

Base 4
0.000000 0.250000 0.500000 0.750000 0.062500 0.312500 0.562500 0.812500 0.125000 0.375000 

Base 5
0.000000 0.200000 0.400000 0.600000 0.800000 0.040000 0.240000 0.440000 0.640000 0.840000 

Sidef[edit]

Translation of: Perl
func vdc(value, base=2) {
while (value[-1] > 0) {
value.append(value[-1] / base -> int);
}
var (x, sum) = (1, 0);
value.each { |i|
sum += ((i % base) / (x *= base));
}
return sum;
}
 
2.to(5).each { |base|
var seq = (10.range.map {|i| vdc([i], base) });
"base %d: %s\n".printf(base, seq.map{|n| "%.4f" % n}.join(', '));
}
Output:
base 2: 0.0000, 0.5000, 0.2500, 0.7500, 0.1250, 0.6250, 0.3750, 0.8750, 0.0625, 0.5625
base 3: 0.0000, 0.3333, 0.6667, 0.1111, 0.4444, 0.7778, 0.2222, 0.5556, 0.8889, 0.0370
base 4: 0.0000, 0.2500, 0.5000, 0.7500, 0.0625, 0.3125, 0.5625, 0.8125, 0.1250, 0.3750
base 5: 0.0000, 0.2000, 0.4000, 0.6000, 0.8000, 0.0400, 0.2400, 0.4400, 0.6400, 0.8400

Tcl[edit]

The core of this is code to handle digit reversing. Note that this also tackles negative numbers (by preserving the sign independently).

proc digitReverse {n {base 2}} {
set n [expr {[set neg [expr {$n < 0}]] ? -$n : $n}]
set result 0.0
set bit [expr {1.0 / $base}]
for {} {$n > 0} {set n [expr {$n / $base}]} {
set result [expr {$result + $bit * ($n % $base)}]
set bit [expr {$bit / $base}]
}
return [expr {$neg ? -$result : $result}]
}

Note that the above procedure will produce terms of the Van der Corput sequence by default.

# Print the first 10 terms of the Van der Corput sequence
for {set i 1} {$i <= 10} {incr i} {
puts "vanDerCorput($i) = [digitReverse $i]"
}
 
# In other bases
foreach base {3 4 5} {
set seq {}
for {set i 1} {$i <= 10} {incr i} {
lappend seq [format %.5f [digitReverse $i $base]]
}
puts "${base}: [join $seq {, }]"
}
Output:
vanDerCorput(1) = 0.5
vanDerCorput(2) = 0.25
vanDerCorput(3) = 0.75
vanDerCorput(4) = 0.125
vanDerCorput(5) = 0.625
vanDerCorput(6) = 0.375
vanDerCorput(7) = 0.875
vanDerCorput(8) = 0.0625
vanDerCorput(9) = 0.5625
vanDerCorput(10) = 0.3125
3: 0.33333, 0.66667, 0.11111, 0.44444, 0.77778, 0.22222, 0.55556, 0.88889, 0.03704, 0.37037
4: 0.25000, 0.50000, 0.75000, 0.06250, 0.31250, 0.56250, 0.81250, 0.12500, 0.37500, 0.62500
5: 0.20000, 0.40000, 0.60000, 0.80000, 0.04000, 0.24000, 0.44000, 0.64000, 0.84000, 0.08000

VBScript[edit]

'http://rosettacode.org/wiki/Van_der_Corput_sequence
'Van der Corput Sequence fucntion call = VanVanDerCorput(number,base)
 
Base2 = "0" : Base3 = "0" : Base4 = "0" : Base5 = "0"
Base6 = "0" : Base7 = "0" : Base8 = "0" : Base9 = "0"
 
l = 1
h = 1
Do Until l = 9
'Set h to the value of l after each function call
'as it sets it to 0 - see lines 37 to 40.
Base2 = Base2 & ", " & VanDerCorput(h,2) : h = l
Base3 = Base3 & ", " & VanDerCorput(h,3) : h = l
Base4 = Base4 & ", " & VanDerCorput(h,4) : h = l
Base5 = Base5 & ", " & VanDerCorput(h,5) : h = l
Base6 = Base6 & ", " & VanDerCorput(h,6) : h = l
l = l + 1
Loop
 
WScript.Echo "Base 2: " & Base2
WScript.Echo "Base 3: " & Base3
WScript.Echo "Base 4: " & Base4
WScript.Echo "Base 5: " & Base5
WScript.Echo "Base 6: " & Base6
 
'Van der Corput Sequence
Function VanDerCorput(n,b)
k = RevString(Dec2BaseN(n,b))
For i = 1 To Len(k)
VanDerCorput = VanDerCorput + (CLng(Mid(k,i,1)) * b^-i)
Next
End Function
 
'Decimal to Base N Conversion
Function Dec2BaseN(q,c)
Dec2BaseN = ""
Do Until q = 0
Dec2BaseN = CStr(q Mod c) & Dec2BaseN
q = Int(q / c)
Loop
End Function
 
'Reverse String
Function RevString(s)
For j = Len(s) To 1 Step -1
RevString = RevString & Mid(s,j,1)
Next
End Function
Output:
Base 2: 0, 0.5, 0.5, 0.25, 0.75, 0.125, 0.625, 0.375, 0.875
Base 3: 0, 0.333333333333333, 0.666666666666667, 0.111111111111111, 0.444444444444444, 0.777777777777778, 0.222222222222222, 0.555555555555556, 0.888888888888889
Base 4: 0, 0.25, 0.5, 0.75, 0.0625, 0.3125, 0.5625, 0.8125, 0.125
Base 5: 0, 0.2, 0.4, 0.6, 0.8, 0.04, 0.24, 0.44, 0.64
Base 6: 0, 0.166666666666667, 0.333333333333333, 0.5, 0.666666666666667, 0.833333333333333, 2.77777777777778E-02, 0.194444444444444, 0.361111111111111

XPL0[edit]

include c:\cxpl\codes;  \intrinsic 'code' declarations
 
func real VdC(N); \Return Nth term of van der Corput sequence in base 2
int N;
real V, U;
[V:= 0.0; U:= 0.5;
repeat N:= N/2;
if rem(0) then V:= V+U;
U:= U/2.0;
until N=0;
return V;
];
 
int N;
for N:= 0 to 10-1 do
[IntOut(0, N); RlOut(0, VdC(N)); CrLf(0)]
Output:
0    0.00000
1    0.50000
2    0.25000
3    0.75000
4    0.12500
5    0.62500
6    0.37500
7    0.87500
8    0.06250
9    0.56250

zkl[edit]

Translation of: Python
fcn vdc(n,base=2){
vdc:=0.0; denom:=1;
while(n){ reg remainder;
denom *= base;
n, remainder = n.divr(base);
vdc += (remainder.toFloat() / denom);
}
vdc
}
Translation of: Ruby
fcn vdc(n,base=2){
str:=n.toString(base).reverse();
str.toInt(base).toFloat()/(base.toFloat().pow(str.len()))
}
Output:
[0..10].apply(vdcR).println("base 2");
L(0,0.5,0.25,0.75,0.125,0.625,0.375,0.875,0.0625,0.5625,0.3125)base 2

[0..10].apply(vdc.fp1(3)).println("base 3");
L(0,0.333333,0.666667,0.111111,0.444444,0.777778,0.222222,0.555556,0.888889,0.037037,0.37037)base 3