/usr/share/perl5/Test/Number/Delta.pm is in libtest-number-delta-perl 1.04-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 | use strict;
use warnings;
package Test::Number::Delta;
# ABSTRACT: Compare the difference between numbers against a given tolerance
our $VERSION = '1.04'; # VERSION
use vars qw (@EXPORT @ISA);
# Required modules
use Carp;
use Test::Builder;
use Exporter;
@ISA = qw( Exporter );
@EXPORT = qw( delta_not_ok delta_ok delta_within delta_not_within );
my $Test = Test::Builder->new;
my $Epsilon = 1e-6;
my $Relative = undef;
sub import {
my $self = shift;
my $pack = caller;
my $found = grep /within|relative/, @_;
croak "Can't specify more than one of 'within' or 'relative'"
if $found > 1;
if ($found) {
my ( $param, $value ) = splice @_, 0, 2;
croak "'$param' parameter must be non-zero"
if $value == 0;
if ( $param eq 'within' ) {
$Epsilon = abs($value);
}
elsif ( $param eq 'relative' ) {
$Relative = abs($value);
}
else {
croak "Test::Number::Delta parameters must come first";
}
}
$Test->exported_to($pack);
$Test->plan(@_);
$self->export_to_level( 1, $self, $_ ) for @EXPORT;
}
#--------------------------------------------------------------------------#
# _check -- recursive function to perform comparison
#--------------------------------------------------------------------------#
sub _check {
my ( $p, $q, $epsilon, $name, @indices ) = @_;
my ( $ok, $diag ) = ( 1, q{} ); # assume true
if ( ref $p eq 'ARRAY' || ref $q eq 'ARRAY' ) {
if ( @$p == @$q ) {
for my $i ( 0 .. $#{$p} ) {
my @new_indices;
( $ok, $diag, @new_indices ) = _check( $p->[$i], $q->[$i], $epsilon, $name,
scalar @indices ? @indices : (), $i, );
if ( not $ok ) {
@indices = @new_indices;
last;
}
}
}
else {
$ok = 0;
$diag =
"Got an array of length "
. scalar(@$p)
. ", but expected an array of length "
. scalar(@$q);
}
}
else {
$ok = abs( $p - $q ) < $epsilon;
if ( !$ok ) {
my ( $ep, $dp ) = _ep_dp($epsilon);
$diag = sprintf( "%.${dp}f and %.${dp}f are not equal" . " to within %.${ep}f",
$p, $q, $epsilon );
}
}
return ( $ok, $diag, scalar(@indices) ? @indices : () );
}
sub _ep_dp {
my $epsilon = shift;
my ($exp) = sprintf( "%e", $epsilon ) =~ m/e(.+)/;
my $ep = $exp < 0 ? -$exp : 1;
my $dp = $ep + 1;
return ( $ep, $dp );
}
#--------------------------------------------------------------------------#
# delta_within()
#--------------------------------------------------------------------------#
sub delta_within($$$;$) { ## no critic
my ( $p, $q, $epsilon, $name ) = @_;
croak "Value of epsilon to delta_within must be non-zero"
if $epsilon == 0;
$epsilon = abs($epsilon);
my ( $ok, $diag, @indices ) = _check( $p, $q, $epsilon, $name );
if (@indices) {
$diag = "At [" . join( "][", @indices ) . "]: $diag";
}
return $Test->ok( $ok, $name ) || $Test->diag($diag);
}
#--------------------------------------------------------------------------#
# delta_ok()
#--------------------------------------------------------------------------#
sub delta_ok($$;$) { ## no critic
my ( $p, $q, $name ) = @_;
{
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $e =
$Relative
? $Relative * ( abs($p) > abs($q) ? abs($p) : abs($q) )
: $Epsilon;
delta_within( $p, $q, $e, $name );
}
}
#--------------------------------------------------------------------------#
# delta_not_ok()
#--------------------------------------------------------------------------#
sub delta_not_within($$$;$) { ## no critic
my ( $p, $q, $epsilon, $name ) = @_;
croak "Value of epsilon to delta_not_within must be non-zero"
if $epsilon == 0;
$epsilon = abs($epsilon);
my ( $ok, undef, @indices ) = _check( $p, $q, $epsilon, $name );
$ok = !$ok;
my ( $ep, $dp ) = _ep_dp($epsilon);
my $diag = sprintf( "Arguments are equal to within %.${ep}f", $epsilon );
return $Test->ok( $ok, $name ) || $Test->diag($diag);
}
sub delta_not_ok($$;$) { ## no critic
my ( $p, $q, $name ) = @_;
{
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $e =
$Relative
? $Relative * ( abs($p) > abs($q) ? abs($p) : abs($q) )
: $Epsilon;
delta_not_within( $p, $q, $e, $name );
}
}
1;
__END__
=pod
=encoding UTF-8
=head1 NAME
Test::Number::Delta - Compare the difference between numbers against a given tolerance
=head1 VERSION
version 1.04
=head1 SYNOPSIS
# Import test functions
use Test::Number::Delta;
# Equality test with default tolerance
delta_ok( 1e-5, 2e-5, 'values within 1e-6');
# Inequality test with default tolerance
delta_not_ok( 1e-5, 2e-5, 'values not within 1e-6');
# Provide specific tolerance
delta_within( 1e-3, 2e-3, 1e-4, 'values within 1e-4');
delta_not_within( 1e-3, 2e-3, 1e-4, 'values not within 1e-4');
# Compare arrays or matrices
@a = ( 3.14, 1.41 );
@b = ( 3.15, 1.41 );
delta_ok( \@a, \@b, 'compare @a and @b' );
# Set a different default tolerance
use Test::Number::Delta within => 1e-5;
delta_ok( 1.1e-5, 2e-5, 'values within 1e-5'); # ok
# Set a relative tolerance
use Test::Number::Delta relative => 1e-3;
delta_ok( 1.01, 1.0099, 'values within 1.01e-3');
=head1 DESCRIPTION
At some point or another, most programmers find they need to compare
floating-point numbers for equality. The typical idiom is to test
if the absolute value of the difference of the numbers is within a desired
tolerance, usually called epsilon. This module provides such a function for use
with L<Test::More>. Usage is similar to other test functions described in
L<Test::More>. Semantically, the C<delta_within> function replaces this kind
of construct:
ok ( abs($p - $q) < $epsilon, '$p is equal to $q' ) or
diag "$p is not equal to $q to within $epsilon";
While there's nothing wrong with that construct, it's painful to type it
repeatedly in a test script. This module does the same thing with a single
function call. The C<delta_ok> function is similar, but either uses a global
default value for epsilon or else calculates a 'relative' epsilon on
the fly so that epsilon is scaled automatically to the size of the arguments to
C<delta_ok>. Both functions are exported automatically.
Because checking floating-point equality is not always reliable, it is not
possible to check the 'equal to' boundary of 'less than or equal to
epsilon'. Therefore, Test::Number::Delta only compares if the absolute value
of the difference is B<less than> epsilon (for equality tests) or
B<greater than> epsilon (for inequality tests).
=head1 USAGE
=head2 use Test::Number::Delta;
With no arguments, epsilon defaults to 1e-6. (An arbitrary choice on the
author's part.)
=head2 use Test::Number::Delta within => 1e-9;
To specify a different default value for epsilon, provide a C<within> parameter
when importing the module. The value must be non-zero.
=head2 use Test::Number::Delta relative => 1e-3;
As an alternative to using a fixed value for epsilon, provide a C<relative>
parameter when importing the module. This signals that C<delta_ok> should
test equality with an epsilon that is scaled to the size of the arguments.
Epsilon is calculated as the relative value times the absolute value
of the argument with the greatest magnitude. Mathematically, for arguments
'x' and 'y':
epsilon = relative * max( abs(x), abs(y) )
For example, a relative value of "0.01" would mean that the arguments are equal
if they differ by less than 1% of the larger of the two values. A relative
value of 1e-6 means that the arguments must differ by less than 1 millionth
of the larger value. The relative value must be non-zero.
=head2 Combining with a test plan
use Test::Number::Delta 'no_plan';
# or
use Test::Number::Delta within => 1e-9, tests => 1;
If a test plan has not already been specified, the optional
parameter for Test::Number::Delta may be followed with a test plan (see
L<Test::More> for details). If a parameter for Test::Number::Delta is
given, it must come first.
=head1 FUNCTIONS
=head2 delta_within
delta_within( $p, $q, $epsilon, '$p and $q are equal within $epsilon' );
delta_within( \@p, \@q, $epsilon, '@p and @q are equal within $epsilon' );
This function tests for equality within a given value of epsilon. The test is
true if the absolute value of the difference between $p and $q is B<less than>
epsilon. If the test is true, it prints an "OK" statement for use in testing.
If the test is not true, this function prints a failure report and diagnostic.
Epsilon must be non-zero.
The values to compare may be scalars or references to arrays. If the values
are references to arrays, the comparison is done pairwise for each index value
of the array. The pairwise comparison is recursive, so matrices may
be compared as well.
For example, this code sample compares two matrices:
my @a = ( [ 3.14, 6.28 ],
[ 1.41, 2.84 ] );
my @b = ( [ 3.14, 6.28 ],
[ 1.42, 2.84 ] );
delta_within( \@a, \@b, 1e-6, 'compare @a and @b' );
The sample prints the following:
not ok 1 - compare @a and @b
# At [1][0]: 1.4100000 and 1.4200000 are not equal to within 0.000001
=head2 delta_ok
delta_ok( $p, $q, '$p and $q are close enough to equal' );
delta_ok( \@p, \@q, '@p and @q are close enough to equal' );
This function tests for equality within a default epsilon value. See L</USAGE>
for details on changing the default. Otherwise, this function works the same
as C<delta_within>.
=head2 delta_not_within
delta_not_within( $p, $q, '$p and $q are different' );
delta_not_within( \@p, \@q, $epsilon, '@p and @q are different' );
This test compares inequality in excess of a given value of epsilon. The test
is true if the absolute value of the difference between $p and $q is B<greater
than> epsilon. For array or matrix comparisons, the test is true if I<any>
pair of values differs by more than epsilon. Otherwise, this function works
the same as C<delta_within>.
=head2 delta_not_ok
delta_not_ok( $p, $q, '$p and $q are different' );
delta_not_ok( \@p, \@q, '@p and @q are different' );
This function tests for inequality in excess of a default epsilon value. See
L</USAGE> for details on changing the default. Otherwise, this function works
the same as C<delta_not_within>.
=for :stopwords cpan testmatrix url annocpan anno bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan
=head1 SUPPORT
=head2 Bugs / Feature Requests
Please report any bugs or feature requests through the issue tracker
at L<https://github.com/dagolden/Test-Number-Delta/issues>.
You will be notified automatically of any progress on your issue.
=head2 Source Code
This is open source software. The code repository is available for
public review and contribution under the terms of the license.
L<https://github.com/dagolden/Test-Number-Delta>
git clone https://github.com/dagolden/Test-Number-Delta.git
=head1 AUTHOR
David Golden <dagolden@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is Copyright (c) 2013 by David Golden.
This is free software, licensed under:
The Apache License, Version 2.0, January 2004
=cut
|