view release on metacpan or  search on metacpan

t/7026-nvec-quadmath-safety.t  view on Meta::CPAN

    my $sum = $v->sum();
    ok($sum > 0, 'sum of tiny values is positive');
    ok(approx_eq($sum, $tiny * 13, $tol), 'sum of tiny values correct');
};

subtest 'edge cases: very large values' => sub {
    my $large = 1e300;
    my $v = nvec::new([$large, $large, $large]);

    my $sum = $v->sum();
    ok($sum > $large, 'sum of large values is larger');
    # For very large values, use relative tolerance
    my $mean = $v->mean();
    my $rel_error = abs($mean - $large) / $large;
    ok($rel_error < 1e-10, "mean of large values correct (rel error: $rel_error)");
};

subtest 'edge cases: mixed scales' => sub {
    my $v = nvec::new([1e-100, 1.0, 1e100]);

    # Use approximate comparison for very small/large values
    my $min = $v->min();
    my $max = $v->max();
    ok($min > 0 && $min < 1e-99, 'min finds smallest (order of 1e-100)');
    ok($max > 1e99, 'max finds largest (order of 1e100)');

    # Mean is dominated by the large value
    my $mean = $v->mean();
    ok($mean > 1e99, 'mean dominated by large value');
};

subtest 'edge cases: zeros' => sub {
    my $zeros = nvec::zeros(10);

    is($zeros->sum(), 0, 'sum of zeros');
    is($zeros->mean(), 0, 'mean of zeros');
    is($zeros->min(), 0, 'min of zeros');
    is($zeros->max(), 0, 'max of zeros');
    is($zeros->variance(), 0, 'variance of zeros');
    is($zeros->std(), 0, 'std of zeros');
};

subtest 'edge cases: single element' => sub {
    my $single = nvec::new([42.5]);

    is($single->len(), 1, 'length is 1');
    is($single->sum(), 42.5, 'sum of single');
    is($single->mean(), 42.5, 'mean of single');
    is($single->min(), 42.5, 'min of single');
    is($single->max(), 42.5, 'max of single');
    is($single->median(), 42.5, 'median of single');
};

# ============================================
# Quadmath-specific precision tests
# ============================================

if ($is_quad) {
    subtest 'quadmath: precision characteristics' => sub {
        # Note: nvec may use double-precision internally even on quadmath perl
        # These tests verify basic functionality works correctly

        # Test that very small values are preserved
        my $small = 1e-15;
        my $v = nvec::new([$small]);
        my $got = $v->get(0);
        ok($got > 0, 'very small value preserved');
        ok(approx_eq($got, $small, 1e-20), 'small value accurate');

        # Test arithmetic with small values
        my $a = nvec::new([1.0]);
        my $result = $a->add_scalar(-1.0);
        is($result->get(0), 0, 'subtraction gives zero');
    };

    subtest 'quadmath: large value handling' => sub {
        my $large = 1e100;
        my $v = nvec::new([$large, $large * 2, $large * 3]);

        ok($v->min() > 0, 'large min is positive');
        ok($v->max() > $v->min(), 'max > min for distinct values');
        ok($v->mean() > $large, 'mean is in expected range');
    };

    subtest 'quadmath: accumulation test' => sub {
        my $n = 100;
        my $v = nvec::zeros(1);

        for (1..$n) {
            $v = $v->add_scalar(1.0);
        }

        my $result = $v->get(0);
        ok(approx_eq($result, $n, $tol), "accumulated sum of $n ones");
    };
}

done_testing();