Benford's law: Difference between revisions

{{Wikipedia|Benford's_law}}

 

This result has been found to apply to a wide variety of data sets, including electricity bills, street addresses, stock prices, population numbers, death rates, lengths of rivers, physical and mathematical constants, and processes described by power laws (which are very common in nature). It tends to be most accurate when values are distributed across multiple orders of magnitude.

 

 

 

For this task, write (a) routine(s) to calculate the distribution of first significant (non-zero) digits in a collection of numbers, then display the actual vs. expected distribution in the way most convenient for your language (table / graph / histogram / whatever).

 

 

''For extra credit:'' Show the distribution for one other set of numbers from a page on Wikipedia. State which Wikipedia page it can be obtained from and what the set enumerates. Again, no need to display the actual list of numbers or the code to load them.

 

;<nowiki>See also:</nowiki>

* [http://www.numberphile.com/videos/benfords_law.html numberphile.com].

 

=={{header|C++}}==

#include <cln/integer.h>

#include <cln/integer_io.h>

#include <cstdlib>

#include <cmath>

using namespace cln ;

 

} ;

 

std::ostringstream os ;

}

}

 

std::generate_n( fibonaccis.begin( ) + 2 , 998 , NextNum( a , b ) ) ;

std::cout << std::endl ;

std::cout << " found expected\n" ;

for ( int i = 1 ; i < 10 ; i++ ) {

double expected = std::log10( 1 + 1 / static_cast<double>( i )) ;

std::cout << i << " :" << std::setw( 16 ) << std::right << found * 100 << " %" ;

}

return 0 ;

{{out}}

<pre> found expected

</pre>

 

=={{header|D}}==

{{trans|Scala}}

 

double[2][9] benford(R)(R seq) if (isForwardRange!R && !isInfinite!R) {

writefln("%d: %5.2f%% | %5.2f%% | %5.4f%%",

i+1, p[1] * 100, p[0] * 100, abs(p[1] - p[0]) * 100);

{{out}}

<pre> Actual Expected Deviation

===Alternative Version===

The output is the same.

std.algorithm, std.array;

 

writefln("%d: %5.2f%% | %5.2f%% | %5.4f%%", i + 1,

f * 100.0 / N, expected[i] * 100,

 

=={{header|Erlang}}==

-module( benfords_law ).

-export( [actual_distribution/1, distribution/1, task/0] ).

Keys = lists:sort( dict:fetch_keys( Actual_dict) ),

io:fwrite( "Digit Actual Benfords expected~n" ),

 

 

[Key | _] = erlang:integer_to_list( N ),

dict:update_counter( Key - 48, 1, Dict ).

{{out}}

<pre>

9 0.045 0.04575749056067514

</pre>

 

=={{header|Fortran}}==

FORTRAN 90. Compilation and output of this program using emacs compile command and a fairly obvious Makefile entry:

Compilation started at Sat May 18 01:13:00

 

0.300999999 0.177000001 0.125000000 9.60000008E-02 7.99999982E-02 6.70000017E-02 5.70000000E-02 5.29999994E-02 4.50000018E-02 LEADING FIBONACCI DIGIT

 

 

! compute most significant digits, Fibonacci like.

implicit none

write(6,*) (benfordsLaw(i),i=1,9),'THE LAW'

write(6,*) (count(i)/1000.0 ,i=1,9),'LEADING FIBONACCI DIGIT'

 

=={{header|Haskell}}==

import Data.Char (digitToInt)

 

fstdigit = digitToInt . head . show

 

fibdata = map fstdigit $ take n fibs

freqs = M.fromListWith (+) $ zip fibdata (repeat 1)

 

 

{{out}}

<pre>[(1,0.301,0.301029995663981),

(9,0.045,0.0457574905606751)]

</pre>

 

=={{header|J}}==

We show the correlation coefficient of Benford's law with the leading digits of the first 1000 Fibonacci numbers is almost unity.

benford =: log10@:(1+%)

assert '0.30 0.18 0.12 0.10 0.08 0.07 0.06 0.05 0.05' -: 5j2 ": benford >: i. 9

assert '0.9999' -: 6j4 ": (normalize TALLY_BY_KEY) r benford >: i.9

 

 

Table[{d, N@Count[fibdata, d]/Length@fibdata, Log10[1. + 1/d]}, {d, 1,

{{out}}

<pre>1 0.301 0.30103

9 0.045 0.0457575</pre>

 

=={{header|Perl}}==

use strict ;

use warnings ;

$result = sprintf ( "%.2f" , 100 * $expected[ $i - 1 ] ) ;

printf "%15s %%\n" , $result ;

{{Out}}

<pre>

9 : 4.50 % 4.58 %

</pre>

 

 

 

 

 

 

=={{header|PL/pgSQL}}==

WITH recursive

constant(val) AS

(select cast(corr(probability_theoretical,probability_real) as numeric(5,4)) correlation

from benford) c

 

=={{header|Prolog}}==

{{works with|SWI Prolog|6.2.6 by Jan Wielemaker, University of Amsterdam}}

Note: SWI Prolog implements arbitrary precision integer arithmetic through use of the GNU MP library

% Does the Fibonacci sequence follow Benford's law?

%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

findall(B, (between(1,9,N), benford(N,B)), Benford),

findall(C, firstchar(C), Fc), freq(Fc, Freq),

{{out}}

<pre>?- go.

5.12% - 5.30%

4.58% - 4.50%</pre>

 

=={{header|Python}}==

Works with Python 3.X & 2.7

from itertools import islice, count

from collections import Counter

 

# just to show that not all kind-of-random sets behave like that

{{out}}

<pre>fibbed Benfords deviation

11.0% 5.1% 5.9%

10.9% 4.6% 6.3%</pre>

 

=={{header|Racket}}==

 

(define (log10 n) (/ (log n) (log 10)))

;; 7: 5.8% 5.8%

;; 8: 5.1% 5.1%

 

 

 

 

end /*k*/

 

 

</pre>

<pre>

</pre>

 

=={{header|Scala}}==

val fibs : Stream[BigInt] = { def series(i:BigInt,j:BigInt):Stream[BigInt] = i #:: series(j, i+j); series(1,0).tail.tail }

 

case (k, v) => println( "%d: %5.2f%% | %5.2f%% | %5.4f%%".format(k,v._2*100,v._1*100,math.abs(v._2-v._1)*100) )

}

{{out}}

<pre>

9: 4.50% | 4.58% | 0.0757%

</pre>