benford-law/build/benford.js

A simple library to check if a dataset follows the Benford's law

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.processBenfordLaw = exports.generateBenfordLawNumbers = exports.generateBenfordLawNumber = void 0;
const benfordProb = {
    '1': 0.301,
    '2': 0.176,
    '3': 0.125,
    '4': 0.097,
    '5': 0.079,
    '6': 0.067,
    '7': 0.058,
    '8': 0.051,
    '9': 0.046,
};
const generateRandomNumber = (minimum, maximum) => Math.random() * (maximum - minimum) + minimum;
const getFirstDigit = (number) => {
    const string = number.toString();
    return parseInt(string[0], 10);
};
const generateBenfordLawNumber = () => Math.exp(generateRandomNumber(Math.log(1), Math.log(1000)));
exports.generateBenfordLawNumber = generateBenfordLawNumber;
const generateBenfordLawNumbers = (length) => {
    const numbers = [];
    for (let i = 0; i < length; i++) {
        numbers.push((0, exports.generateBenfordLawNumber)());
    }
    return numbers;
};
exports.generateBenfordLawNumbers = generateBenfordLawNumbers;
const processBenfordLaw = (numbers, threshold = 0.01, benfordProbabilities = benfordProb) => {
    const firstDigits = numbers.map(getFirstDigit);
    const firstDigitCounts = firstDigits.reduce((acc, digit) => ({
        ...acc,
        [digit]: (acc[digit] || 0) + 1,
    }), {});
    const firstDigitProbabilities = Object.entries(firstDigitCounts).reduce((acc, [digit, count]) => ({
        ...acc,
        [digit]: count / numbers.length,
    }), {});
    const firstDigitAccuracies = Object.entries(firstDigitProbabilities).reduce((acc, [digit, probability]) => {
        const benfordProbability = benfordProbabilities[digit];
        const diff = Math.abs(benfordProbability - probability);
        return {
            ...acc,
            [digit]: diff,
        };
    }, {});
    const isBenford = Object.entries(benfordProbabilities).every(([digit, probability]) => {
        const firstDigitProbability = firstDigitProbabilities[digit];
        return (firstDigitProbability &&
            Math.abs(firstDigitProbability - probability) < threshold);
    });
    return {
        isFollowingBenfordLaw: isBenford,
        firstDigitProbabilities,
        firstDigitCounts,
        firstDigitAccuracies,
    };
};
exports.processBenfordLaw = processBenfordLaw;