Lines Matching defs:accuracy
14 # accuracy : accuracy (scalar)
222 our $accuracy = undef;
407 sub accuracy {
418 croak "accuracy must be a number, not '$a'"
420 croak "accuracy must be an integer, not '$a'"
427 $x -> {accuracy} = $a; # set instance A
431 ${"${class}::accuracy"} = $a; # set class A
439 return $x -> {accuracy};
442 return ${"${class}::accuracy"};
466 $x -> {accuracy} = undef; # clear instance A
470 ${"${class}::accuracy"} = undef; # clear class A
560 # We use this special handling of accuracy and precision because
561 # accuracy() always sets precision to undef and precision() always sets
562 # accuracy to undef. With out this special treatment, the following
563 # would result in both accuracy and precision being undef.
565 # $x -> config(accuracy => 3, precision => undef)
567 croak "config(): both accuracy and precision are defined"
568 if defined($args -> {accuracy}) && defined ($args -> {precision});
570 if (defined $args -> {accuracy}) {
571 $class -> accuracy($args -> {accuracy});
575 $class -> accuracy(undef); # also sets precision to undef
578 delete $args->{accuracy};
612 accuracy precision
633 # select accuracy parameter based on precedence,
637 $scale = $x->{accuracy} unless defined $scale;
641 $scale = $class -> accuracy() unless defined $scale;
722 # Don't copy the accuracy and precision, because a new object should get
1171 carp "can't specify both accuracy and precision";
1174 $self->{accuracy} = $_[0];
1177 $self->{accuracy} = $class -> accuracy();
1232 carp "can't specify both accuracy and precision";
1235 $self->{accuracy} = $_[0];
1238 $self->{accuracy} = $class -> accuracy();
1301 carp "can't specify both accuracy and precision";
1304 $self->{accuracy} = $_[0];
1307 $self->{accuracy} = $class -> accuracy();
1360 carp "can't specify both accuracy and precision";
1363 $self->{accuracy} = $_[0];
1366 $self->{accuracy} = $class -> accuracy();
1442 $copy->{accuracy} = $x->{accuracy} if exists $x->{accuracy};
1467 ($y->{accuracy}, $y->{precision}) = ($x->{accuracy}, $x->{precision});
1495 ($y->{accuracy}, $y->{precision}) = ($x->{accuracy}, $x->{precision});
1521 ($y->{accuracy}, $y->{precision}) = ($x->{accuracy}, $x->{precision});
2398 $rem -> {accuracy} = $x -> {accuracy};
2542 $rem -> {accuracy} = $x -> {accuracy};
4239 $self->{accuracy} = undef;
4246 # $a accuracy, if given by caller
4252 croak "accuracy must be a number, not '$a'"
4265 $a = $_->{accuracy}
4266 if (defined $_->{accuracy}) && (!defined $a || $_->{accuracy} < $a);
4281 $a = $class -> accuracy();
4302 if !defined $self->{accuracy} || $self->{accuracy} >= $a;
4313 # accuracy: +$n preserve $n digits from left,
4325 $x->{accuracy} = $scale if !defined $x->{accuracy} || $x->{accuracy} > $scale; # 3 > 2
4339 $x->{accuracy} = $scale if !defined $x->{accuracy} || $x->{accuracy} > $scale; # 3 > 2
4407 $x->{accuracy} = $scale if $scale >= 0;
4409 $x->{accuracy} = $len+$scale;
4410 $x->{accuracy} = 0 if $scale < -$len;
4428 $x->{accuracy} = undef;
4666 $m -> accuracy(undef);
5552 if ($param eq 'accuracy') {
5553 $class -> accuracy(shift);
5571 # Fall-back accuracy.
5737 # $a accuracy, if given by caller
5752 $a = $_->{accuracy}
5753 if (defined $_->{accuracy}) && (!defined $a || $_->{accuracy} < $a);
5767 $a = $class -> accuracy() unless defined $a;
6520 Math::BigInt->accuracy(); # get class accuracy
6521 Math::BigInt->accuracy($n); # set class accuracy
6528 Math::BigInt->div_scale($n); # set fallback accuracy
6648 $x->round($A,$P,$mode); # round to accuracy or precision using
6650 $x->bround($n); # accuracy: preserve $n digits
6820 Each of the methods below (except config(), accuracy() and precision()) accepts
6822 C<accuracy>, C<precision> and C<round_mode>. Please see the section about
6830 =item accuracy()
6832 Math::BigInt->accuracy(5); # set class accuracy
6833 $x->accuracy(5); # set instance accuracy
6835 $A = Math::BigInt->accuracy(); # get class accuracy
6836 $A = $x->accuracy(); # get instance accuracy
6838 Set or get the accuracy, i.e., the number of significant digits. The accuracy
6839 must be an integer. If the accuracy is set to C<undef>, no rounding is done.
6842 L</bround()> or L</bfround()> or by passing the desired accuracy to the method
6853 Math::BigInt->accuracy(4); # set class accuracy to 4
6857 print $x->accuracy(); # prints "4"
6858 print $y->accuracy(); # also prints "4", since
6859 # class accuracy is 4
6861 Math::BigInt->accuracy(5); # set class accuracy to 5
6862 print $x->accuracy(); # prints "4", since instance
6863 # accuracy is 4
6864 print $y->accuracy(); # prints "5", since no instance
6865 # accuracy, and class accuracy is 5
6885 You might want to use L</accuracy()> instead. With L</accuracy()> you set the
6902 Set/get the fallback accuracy. This is the accuracy used when neither accuracy
6955 $accu = Math::BigInt->config("accuracy"); # get
6977 accuracy RW Global accuracy
6981 div_scale RW Fallback accuracy for division etc.
7548 $x->blog($base, $accuracy); # logarithm of x to the base $base
7556 $x->bexp($accuracy); # calculate e ** X
7928 Round $x to accuracy C<$A> or precision C<$P> using the round mode
7933 $x->bround($N); # accuracy: preserve $N digits
7935 Rounds $x to an accuracy of $N digits.
8127 Math::BigFloat, the output is zero padded according to the current accuracy or
8376 Math::BigInt and Math::BigFloat have full support for accuracy and precision
8379 This section describes the accuracy/precision handling in Math::BigInt and
8389 During the rest of this document, the shortcuts A (for accuracy), P (for
8419 an accuracy greater than the non-zero digits when there are zeros in it or
8435 When both A and P are undefined, this is used as a fallback accuracy when
8525 * bsqrt() simply hands its accuracy argument over to bdiv.
8560 * You can set the A global via Math::BigInt->accuracy() or
8561 Math::BigFloat->accuracy() or whatever class you are using.
8565 * to undefine A, use Math::SomeClass->accuracy(undef);
8567 * Setting Math::SomeClass->accuracy() clears automatically
8573 * to find out the current global A, use Math::SomeClass->accuracy()
8575 * use $x->accuracy() respective $x->precision() for the local
8577 * Please note that $x->accuracy() respective $x->precision()
8599 Math::BigInt->accuracy(2);
8600 Math::BigInt::SomeSubclass->accuracy(3);
8686 * You can set A or P locally by using $x->accuracy() or
8690 * $x->accuracy() clears $x->precision(), and vice versa.
8695 bround() is for accuracy rounding, while bfround() is for precision
8710 $x->accuracy(5);
8713 Here 4 takes precedence over 5, so 123.5 is the result and $x->accuracy()
8880 Math::BigFloat->accuracy(4); # no more A than 4
8886 Math::BigFloat->accuracy(5); # no more A than 5
8890 print "$y, ",$y->accuracy(),"\n"; # 123.4, 4
8892 Math::BigFloat->accuracy(undef); # A not important now
9043 our $accuracy = 2; # round to 2 decimal places
9093 well es preserve accuracy (as in sqrt(3)).