perl: нахождение среднего значения и дисперсии больших чисел без переполнения

Ни один из ваших входных данных не является достаточно большим, чтобы требовать JSON::PP для создания объектов Math::BigInt в системе с 64-битными целыми числами, поэтому это не так.

Вы можете сделать что-то вроде следующего в начале вашего sub.

@_ = map { Math::BigInt->new($_) } @_;   # Or ::BigFloat?

Альтернативно,

my $zero_B = Math::BigInt->new(0);

sub stats {
    my $n      = @_;
    my $sum_B  = sum($zero_B, @_);
    my $mean_B = $sum_B / $n;
    my $var_B  = sum( map { Math::BigInt->new($_) ** 2 } @_ ) / $n - $mean_B ** 2;
    my ($min, $max) = minmax(@_);
    return {
        n        => $n,
        sum      => $sum_B,
        max      => $max,
        min      => $min,
        mean     => $mean_B,
        variance => $var_B,
    };
}

Все вместе:

use strict;
use warnings;

use Data::Dumper    qw( Dumper );
use JSON::PP        qw( );
use List::MoreUtils qw( minmax );
use List::Util      qw( sum );
use Math::BigInt    qw( );

my $zero_B = Math::BigInt->new(0);
my $JSON = JSON::PP->new->allow_bignum->utf8->pretty->canonical;

sub stats {
    my $n      = @_;
    my $sum_B  = sum($zero_B, @_);
    my $mean_B = $sum_B / $n;
    my $var_B  = sum( map { Math::BigInt->new($_) ** 2 } @_ ) / $n - $mean_B ** 2;
    my ($min, $max) = minmax(@_);
    return {
        n        => $n,
        sum      => $sum_B,
        max      => $max,
        min      => $min,
        mean     => $mean_B,
        variance => $var_B,
    };
}

my @test = (
    [qw( 919300112739897344 919305709216464896 919305709216464896 985592115567603712 959299136196456448 )],
    [qw( 479655558 429035600 3281034608 3281034608 2606592908 3490045576 )],
    [ qw( 914426431563644928 ) x 3142 ]
);

for (@test) {
    print "---\n";
    my $s = stats( map { $JSON->decode($_) } @$_ );

    if (
           $JSON->encode($s->{variance}) =~ /"/  # MEAN ENCODED AS STRING
        || $JSON->encode($s->{mean}) =~ /"/      # VARIANCE ENCODED AS STRING
        || $s->{variance} < 0                    # VARIANCE IS NEGATIVE!
    ) {
        local $Data::Dumper::Varname = "DUMPED_RAWDATA";
        print Dumper($_);
        print $JSON->encode({
            json_encoded_rawdata => $_,
            json_encoded_stats => $s,
        });
    } else {
        print "ok\n";
    }
}

Примечания:

• Оба подхода будут работать, даже если объекты уже являются объектами Math::*.
• Я определил, что переменные гарантированно содержат объект Math:Big*, используя _B для ясности.
• Я переместил тестовый код в тестовую обвязку.
• Я использовал minmax, потому что это более эффективно, чем отдельные вызовы min и max.
• Я импортировал сабвуферы из модулей, чтобы не использовать их полное имя.
• Не нужно принудительно помещать что-то в скалярном контексте в скалярный контекст.

Ответ @ikegami работает правильно, но для меня он слишком медленный, так как эта подпрограмма вызывается много раз во внутреннем цикле моей программы. Я думаю, что это стоимость обеспечения того, чтобы все числа были преобразованы в числа произвольной точности. В итоге я использовал следующую реализацию, которая позволяет избежать преобразования всех чисел в произвольный тип точности.

sub stats {

    my $n = scalar @_;
    my $sum    = List::Util::sum0(@_);
    my $mean   = $sum / $n;
    my $var = List::Util::sum0( map { ( $_ - $mean )**2 } @_ ) / $n;
    $mean   += 0;
    $variance += 0;    # TO ENSURE THAT THEY ARE ENCODED AS NUMBERS IN JSON
    {
        n      => $n,
        sum    => $sum,
        max    => List::Util::max(@_),
        min    => List::Util::min(@_),
        mean   => $mean,
        variance => $var,
    };
}

Я изменил метод расчета дисперсии, чтобы избежать отрицательных результатов (как предложил @Robert). Это может пожертвовать точностью в $sum (и во всем, что зависит от $sum) из-за добавления больших целых чисел с плавающей запятой. Однако он завершает работу за приемлемое время выполнения.

Непреднамеренное кодирование чисел JSON в виде строк объясняется в https://metacpan.org/pod/JSON::PP#simple-scalars. Эта проблема решается с помощью предложенного там метода принудительного кодирования в виде чисел.

JSON::PP будет кодировать неопределенные скаляры как нулевые значения JSON, скаляры, которые в последний раз использовались в строковом контексте перед кодированием как строки JSON, и все остальное как числовое значение.

Вы можете заставить тип быть номером JSON, нумеровав его:

my $x = "3"; # some variable containing a string
$x += 0;     # numify it, ensuring it will be dumped as a number
$x *= 1;     # same thing, the choice is yours. in to force