Van der Corput sequence: Difference between revisions

<langsyntaxhighlight lang="python">>>> def base10change(n, base):

[1, 0, 1, 1]</langsyntaxhighlight>

<langsyntaxhighlight lang="360asm">* Van der Corput sequence 31/01/2017

END VDCS</langsyntaxhighlight>

<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;

end Main;</langsyntaxhighlight>

<langsyntaxhighlight AutoHotkeylang="autohotkey">SetFormat, FloatFast, 0.5

}</langsyntaxhighlight>

<langsyntaxhighlight lang="bbcbasic"> @% = &20509

= v</langsyntaxhighlight>

<langsyntaxhighlight lang="bc">/*

quit</langsyntaxhighlight>

<langsyntaxhighlight Clang="c">#include <stdio.h>

}</langsyntaxhighlight>

<langsyntaxhighlight lang="cpp">#include <cmath>

}</langsyntaxhighlight>

<langsyntaxhighlight lang="clojure">(defn van-der-corput

[n (van-der-corput n base)]))))</langsyntaxhighlight>

<langsyntaxhighlight lang="lisp">(defun van-der-Corput (n base)

(loop for i to 10 collect (van-der-Corput i base))))</langsyntaxhighlight>

<langsyntaxhighlight lang="d">double vdc(int n, in double base=2.0) pure nothrow @safe @nogc {

}</langsyntaxhighlight>

func vdc sb =n 1.

v s = 01

while n > 0

s *= b

m = n mod b

v += m / s

n = n div b

.

write "base " & b & ":"

for n rangerange0 10

call write " " & vdc b n v

<langsyntaxhighlight lang="ela">open random number list

v' = v + rem / d'</langsyntaxhighlight>

<langsyntaxhighlight lang="ela">take 10 <| map' (vdc 2.0) [1..]</langsyntaxhighlight>

<langsyntaxhighlight lang="elixir">defmodule Van_der_corput do

end)</langsyntaxhighlight>

<langsyntaxhighlight ERRElang="erre">PROGRAM VAN_DER_CORPUT

END PROGRAM</langsyntaxhighlight>

<langsyntaxhighlight lang="euphoria">function vdc(integer n, atom base)

end for</langsyntaxhighlight>

<langsyntaxhighlight lang="fsharp">open System

0</langsyntaxhighlight>

<langsyntaxhighlight lang="factor">USING: formatting fry io kernel math math.functions math.parser

MAIN: vdc-demo</langsyntaxhighlight>

<langsyntaxhighlight lang="forth">: fvdc ( base n -- f )

: test 10 0 do 2 i fvdc cr f. loop ;</langsyntaxhighlight>

This is straightforward once one remembers that the obvious scheme for extracting digits from a number produces them from the low-order end to the high-order end. This reversal is normally annoying, but here a "reflection" ''is'' desired. The source is old-style, except for using F90's ability to have a function (or subroutine) name appear on its END statement with this checked by the compiler. Because the MODULE protocol introduced by F90 is not bothered with, the type of the function has to be declared in all routines invoking it if the default type based on the form of the name does not suffice. Single precision suffices, but the F90 compiler moans that the type of the function itself has not been explicitly declared. Ah well. <langsyntaxhighlight Fortranlang="fortran"> FUNCTION VDC(N,BASE) !Calculates a Van der Corput number...

END</langsyntaxhighlight>

<langsyntaxhighlight lang="freebasic">' version 03-12-2016

End</langsyntaxhighlight>

<langsyntaxhighlight lang="go">package main

}</langsyntaxhighlight>

<langsyntaxhighlight lang="haskell">import Data.ListRatio (Rational(..), (%), numerator, denominator)

import Data.RatioList (unfoldr)

import SystemText.EnvironmentPrintf (printf)

newtype Rat = Rat Rational

show (Rat n) = show (numerator n) ++<> "('/"' ++: show (denominator n))

-- Convert a list of base b digits to its corresponding number. We assume the

-- We assume the digits are valid base b numbers and that their order is from least to most

-- their order is from least to most significant.

-- Convert a number to the list of its base b digits. The order will be from

-- The order will be from least to most significant.

where step 0 = Nothing

step m0 = let (q,r) = m `quotRem` b in Just (r,q)Nothing

| b < | otherwise2 = leterror ds"vdc: =base reversemust $be numToDigits b≥ n2"

<langsyntaxhighlight Uniconlang="unicon">procedure main(A)

end</langsyntaxhighlight>

<langsyntaxhighlight Uniconlang="unicon">procedure vdc(n, base)

end</langsyntaxhighlight>

<langsyntaxhighlight lang="j">vdc=: ([ %~ %@[ #. #.inv)"0 _</langsyntaxhighlight>

<langsyntaxhighlight lang="j"> 2 vdc i.10 NB. 1st 10 nums of Van der Corput sequence in base 2

0 1r5 2r5 3r5 4r5 1r25 6r25 11r25 16r25 21r25</langsyntaxhighlight>

<langsyntaxhighlight lang="java">public class VanDerCorput{

}</langsyntaxhighlight>

<langsyntaxhighlight lang="jq"># vdc(base) converts an input decimal integer to a decimal number based on the van der

end ;</langsyntaxhighlight>

<langsyntaxhighlight lang="jq">def round(n):

range(2;6) | . as $base | "Base \(.): \( [ range(0;11) | vdc($base)|round(1000) ] )"</langsyntaxhighlight>

Base 5: [0,0.2,0.4,0.6,0.8,0.04,0.24,0.44,0.64,0.84,0.08]</langsyntaxhighlight>

<langsyntaxhighlight lang="julia">using Printf

vandercorput(num::Integer, base::Integer) = sum(d * Float64(base) ^ -ex for (ex, d) in enumerate(digits(num, base = base)))

end</langsyntaxhighlight>

<langsyntaxhighlight lang="scala">// version 1.1.2

}</langsyntaxhighlight>

<langsyntaxhighlight lang="lua">function vdc(n, base)

end</langsyntaxhighlight>

->{# [1/42, 1/24, 3/4, 1/168, 5/168, 93/168, 137/168, 1/816, 39/816, 5/8}16]

<langsyntaxhighlight Matlablang="matlab"> function x = corput (n)

end; </langsyntaxhighlight>

<langsyntaxhighlight Maximalang="maxima">/* convert a decimal integer to a list of digits in base `base' */

/* [1, 0, 0, 0] */</langsyntaxhighlight>

<langsyntaxhighlight Maximalang="maxima">/* convert a list of digits in base `base' to a decimal integer */

/* 8 */</langsyntaxhighlight>

<langsyntaxhighlight Maximalang="maxima">vdc(n, base):= makelist(

*/</langsyntaxhighlight>

*/</langsyntaxhighlight>

<langsyntaxhighlight lang="modula2">MODULE Sequence;

END Sequence.</langsyntaxhighlight>

<langsyntaxhighlight lang="parigp">VdC(n)=n=binary(n);sum(i=1,#n,if(n[i],1.>>(#n+1-i)));

vector(10,n,VdC(n))</langsyntaxhighlight>

<langsyntaxhighlight lang="pascal">Program VanDerCorput;

<langsyntaxhighlight lang="perl">sub vdc {

}</langsyntaxhighlight>

<span num style="color: num*base+digit#008080;">else</span>

<span style="color: printf(1,fmt,v)#008080;">else</span>

<langsyntaxhighlight PicoLisplang="picolisp">(scl 6)

(prinl N ": " (round (vdc N B) 4)) ) )</langsyntaxhighlight>

<syntaxhighlight lang="text">

<langsyntaxhighlight PureBasiclang="purebasic">Procedure.d nBase(n.i,b.i)

Input()</langsyntaxhighlight>

<langsyntaxhighlight lang="python">def vdc(n, base=2):

return vdc</langsyntaxhighlight>

<langsyntaxhighlight lang="python">>>> [vdc(i) for i in range(10)]

>>> </langsyntaxhighlight>

<langsyntaxhighlight lang="python">>>> from fractions import Fraction

[0, 1/2, 1/4, 3/4, 1/8, 5/8, 3/8, 7/8, 1/16, 9/16]</langsyntaxhighlight>

<langsyntaxhighlight lang="python">>>> for b in range(3,6):

[0, 1/5, 2/5, 3/5, 4/5, 1/25, 6/25, 11/25, 16/25, 21/25]</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">#lang racket

base))))</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">#lang racket

(for/sum ([i (digit-length n base)]) (/ (digit n i base) (expt base (+ i 1)))))</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">(for ([base (in-range 2 (add1 5))])

Base 5: 0 1/5 2/5 3/5 4/5 1/25 6/25 11/25 16/25 21/25 |# </langsyntaxhighlight>

<syntaxhighlight lang="raku" perl6line>constant VdC = map { :2("0." ~ .base(2).flip) }, ^Inf;

.say for VdC[^16];</langsyntaxhighlight>

<syntaxhighlight lang="raku" perl6line>sub VdC($base = 2) {

.say for VdC[^10];</langsyntaxhighlight>

<syntaxhighlight lang="raku" perl6line>sub vdc($num, $base = 2) {

}</langsyntaxhighlight>

<syntaxhighlight lang="raku" perl6line>sub vdc($value, $base = 2) {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="rexx">/*REXX program converts an integer (or a range) ──► a Van der Corput number in base 2.*/

return '.'reverse(y) /*heavy lifting is performed by REXX. */</langsyntaxhighlight>

This version handles what the first version does, &nbsp; plus any radix up to (and including) base &nbsp; '''90'''.

<langsyntaxhighlight lang="rexx">/*REXX programpgm converts an integer (or a range) ──► a Van der Corput number, in base 2, or */

/*─────────────── in base 2, or────────────────────────────── optionally, any other base up to and including base 90.*/

if b=='' | b=="," then b=a a /* " " " " " " */

if r=='' | r=="," then r=2 2 /* " " " " " " */

_= VdC( abs(j), abs(r) ) /*convert the ABSolute value of integer*/

_= substr('-', 2 + sign(j) )_ /*if needed, keep the leading - sign.*/

@abcU= @abc; upper @abcU /*go whole hog & extend with uppercase.*/

maxB= length(@@@) /*maximum base (radix) supported here. */

if toB=='' then toB=10 10 /*if omitted, then assume default (10)*/

if inB=='' then inB=10 10 /* " " " " " " */

_= substr(x, j, 1) /*pick off a "digit" (numeral) from X.*/

v= pos(_, @@@) /*get the value of this "digit"/numeral*/

#= # * inB + v - 1 /*construct new number, digit by digit.*/

y= substr(@@@, # // toB + 1, 1)y /* construct the output number, ··· */

#= # % toB /* ··· and also whittle down #. */

<langsyntaxhighlight lang="ring">

<langsyntaxhighlight lang="ruby">def vdc(n, base=2)

end</langsyntaxhighlight>

<langsyntaxhighlight lang="scala">object VanDerCorput extends App {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";

end func;</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">func vdc(value, base=2) {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="stata">mata

end</langsyntaxhighlight>

<langsyntaxhighlight lang="stata">clear

ylabel(, angle(0) format(%3.1f))</langsyntaxhighlight>

<langsyntaxhighlight lang="swift">func vanDerCorput(n: Int, base: Int, num: inout Int, denom: inout Int) {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="tcl">proc digitReverse {n {base 2}} {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="tcl"># Print the first 10 terms of the Van der Corput sequence

}</langsyntaxhighlight>

{{trans|Phix}}Base only.<langsyntaxhighlight lang="vb">Private Function vdc(ByVal n As Integer, BASE As Variant) As Variant

End Sub</langsyntaxhighlight>{{out}}

<langsyntaxhighlight VBScriptlang="vbscript">'http://rosettacode.org/wiki/Van_der_Corput_sequence

End Function</langsyntaxhighlight>

<langsyntaxhighlight lang="vbnet">Module Module1

End Module</langsyntaxhighlight>

<langsyntaxhighlight ecmascriptlang="wren">var v2 = Fn.new { |n|

for (i in 0..9) System.print("%(i) -> %(v3.call(i))")</langsyntaxhighlight>

<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations

[IntOut(0, N); RlOut(0, VdC(N)); CrLf(0)]</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">fcn vdc(n,base=2){

}</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">fcn vdc(n,base=2){

}</langsyntaxhighlight>