Lines Matching full:class
17 my $class = ref $_[0];
18 my $x = $class -> _copy($_[0]);
19 my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
20 return $class -> _add($x, $y);
24 my $class = ref $_[0];
28 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
30 $x = $class -> _copy($_[0]);
31 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
33 return $class -> _sub($x, $y);
37 my $class = ref $_[0];
38 my $x = $class -> _copy($_[0]);
39 my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
40 return $class -> _mul($x, $y);
44 my $class = ref $_[0];
48 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
50 $x = $class -> _copy($_[0]);
51 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
53 return $class -> _div($x, $y);
57 my $class = ref $_[0];
61 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
63 $x = $class -> _copy($_[0]);
64 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
66 return $class -> _mod($x, $y);
70 my $class = ref $_[0];
74 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
76 $x = $class -> _copy($_[0]);
77 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
79 return $class -> _pow($x, $y);
83 my $class = ref $_[0];
86 $y = $class -> _num($_[0]);
87 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
90 $y = ref($_[1]) ? $class -> _num($_[1]) : $_[1];
92 return $class -> _lsft($x, $y);
96 my $class = ref $_[0];
100 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
102 $x = $class -> _copy($_[0]);
103 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
105 return $class -> _rsft($x, $y);
111 my $class = ref $_[0];
115 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
117 $x = $class -> _copy($_[0]);
118 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
120 return $class -> _acmp($x, $y) < 0;
124 my $class = ref $_[0];
128 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
130 $x = $class -> _copy($_[0]);
131 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
133 return $class -> _acmp($x, $y) <= 0;
137 my $class = ref $_[0];
141 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
143 $x = $class -> _copy($_[0]);
144 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
146 return $class -> _acmp($x, $y) > 0;
150 my $class = ref $_[0];
154 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
156 $x = $class -> _copy($_[0]);
157 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
159 return $class -> _acmp($x, $y) >= 0;
163 my $class = ref $_[0];
164 my $x = $class -> _copy($_[0]);
165 my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
166 return $class -> _acmp($x, $y) == 0;
170 my $class = ref $_[0];
171 my $x = $class -> _copy($_[0]);
172 my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
173 return $class -> _acmp($x, $y) != 0;
179 my $class = ref $_[0];
183 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
185 $x = $class -> _copy($_[0]);
186 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
188 return $class -> _acmp($x, $y);
194 my $class = ref $_[0];
198 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
200 $x = $class -> _copy($_[0]);
201 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
203 return $class -> _and($x, $y);
207 my $class = ref $_[0];
211 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
213 $x = $class -> _copy($_[0]);
214 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
216 return $class -> _or($x, $y);
220 my $class = ref $_[0];
224 $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
226 $x = $class -> _copy($_[0]);
227 $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
229 return $class -> _xor($x, $y);
237 my $class = ref $_[0];
238 return $class -> _sqrt($class -> _copy($_[0]));
260 my $class = shift;
261 return $class -> _new("0");
265 my $class = shift;
266 return $class -> _new("1");
270 my $class = shift;
271 return $class -> _new("2");
275 my $class = shift;
276 return $class -> _new("10");
280 my ($class, $exp) = @_;
281 $exp = $class -> _num($exp) if ref($exp);
282 return $class -> _new("1" . ("0" x $exp));
286 my ($class, $x) = @_;
287 return $class -> _new($class -> _str($x));
303 my ($class, $x) = @_;
304 0 + $class -> _str($x);
319 my ($class, $x, $y) = @_;
320 my $sum = $class -> _zero();
321 my $i = $class -> _zero();
322 while ($class -> _acmp($i, $y) < 0) {
323 $sum = $class -> _add($sum, $x);
324 $i = $class -> _inc($i);
330 my ($class, $x, $y) = @_;
333 if $class -> _is_zero($y);
335 my $r = $class -> _copy($x);
336 my $q = $class -> _zero();
337 while ($class -> _acmp($r, $y) >= 0) {
338 $q = $class -> _inc($q);
339 $r = $class -> _sub($r, $y);
347 my ($class, $x) = @_;
348 $class -> _add($x, $class -> _one());
352 my ($class, $x) = @_;
353 $class -> _sub($x, $class -> _one());
360 my $class = shift;
368 $za = $class -> _add($ya, $xa);
370 $za = $class -> _add($xa, $ya);
372 $zs = $class -> _is_zero($za) ? '+' : $xs;
376 my $acmp = $class -> _acmp($xa, $ya); # abs(x) = abs(y)
379 $za = $class -> _zero();
385 $za = $class -> _sub($xa, $ya, $flag);
388 $za = $class -> _sub($ya, $xa, !$flag);
398 my $class = shift;
403 $class -> _sadd($xa, $xs, $ya, $ys, $flag);
411 my ($class, $x, $y) = @_;
412 my $xstr = $class -> _str($x);
413 my $ystr = $class -> _str($y);
419 my ($class, $x) = @_;
420 CORE::length($class -> _str($x));
424 my ($class, $x) = @_;
425 $class -> _len($x);
429 my ($class, $x, $n) = @_;
430 substr($class ->_str($x), -($n+1), 1);
434 my ($class, $x) = @_;
436 my $len = $class -> _len($x);
437 my $sum = $class -> _zero();
439 my $digit = $class -> _digit($x, $i);
440 $digit = $class -> _new($digit);
441 $sum = $class -> _add($sum, $digit);
448 my ($class, $x) = @_;
449 my $str = $class -> _str($x);
458 my ($class, $x) = @_;
459 $class -> _str($x) == 0;
464 my ($class, $x) = @_;
465 substr($class -> _str($x), -1, 1) % 2 == 0;
470 my ($class, $x) = @_;
471 substr($class -> _str($x), -1, 1) % 2 != 0;
476 my ($class, $x) = @_;
477 $class -> _str($x) == 1;
482 my ($class, $x) = @_;
483 $class -> _str($x) == 2;
488 my ($class, $x) = @_;
489 $class -> _str($x) == 10;
497 my ($class, $x) = @_;
507 my ($class, $x, $y) = @_;
510 if $class -> _is_zero($y);
512 if ($class -> can('_div')) {
513 $x = $class -> _copy($x);
514 my ($q, $r) = $class -> _div($x, $y);
517 my $r = $class -> _copy($x);
518 while ($class -> _acmp($r, $y) >= 0) {
519 $r = $class -> _sub($r, $y);
529 my ($class, $x, $n, $b) = @_;
530 $b = $class -> _new($b) unless ref $b;
531 return scalar $class -> _div($x, $class -> _pow($class -> _copy($b), $n));
535 my ($class, $x, $n, $b) = @_;
536 $b = $class -> _new($b) unless ref $b;
537 return $class -> _mul($x, $class -> _pow($class -> _copy($b), $n));
542 my ($class, $x, $y) = @_;
544 if ($class -> _is_zero($y)) {
545 return $class -> _one(); # y == 0 => x => 1
548 if (($class -> _is_one($x)) || # x == 1
549 ($class -> _is_one($y))) # or y == 1
554 if ($class -> _is_zero($x)) {
555 return $class -> _zero(); # 0 ** y => 0 (if not y <= 0)
558 my $pow2 = $class -> _one();
560 my $y_bin = $class -> _as_bin($y);
565 $pow2 = $class -> _mul($pow2, $x) if substr($y_bin, $len, 1) eq '1';
566 $x = $class -> _mul($x, $x);
569 $x = $class -> _mul($x, $pow2);
575 my ($class, $n, $k) = @_;
581 my $twok = $class -> _mul($class -> _two(), $class -> _copy($k));
582 if ($class -> _acmp($twok, $n) > 0) {
583 $k = $class -> _sub($class -> _copy($n), $k);
597 if ($class -> _is_zero($k)) {
598 return $class -> _one();
603 my $n_orig = $class -> _copy($n);
607 $n = $class -> _sub($n, $k);
608 $n = $class -> _inc($n);
610 my $f = $class -> _copy($n);
611 $f = $class -> _inc($f);
613 my $d = $class -> _two();
617 while ($class -> _acmp($f, $n_orig) <= 0) {
618 $n = $class -> _mul($n, $f);
619 $n = $class -> _div($n, $d);
620 $f = $class -> _inc($f);
621 $d = $class -> _inc($d);
629 # my ($class, $x) = @_;
631 # my $two = $class -> _two();
633 # if ($class -> _acmp($x, $two) < 0) {
634 # return $class -> _one();
637 # my $i = $class -> _copy($x);
638 # while ($class -> _acmp($i, $two) > 0) {
639 # $i = $class -> _dec($i);
640 # $x = $class -> _mul($x, $i);
648 my ($class, $x) = @_;
653 my $p = $class -> _one();
654 my $r = $class -> _one();
655 my $two = $class -> _two();
657 my ($log2n) = $class -> _log_int($class -> _copy($x), $two);
658 my $h = $class -> _zero();
659 my $shift = $class -> _zero();
660 my $k = $class -> _one();
662 while ($class -> _acmp($h, $x)) {
663 $shift = $class -> _add($shift, $h);
664 $h = $class -> _rsft($class -> _copy($x), $log2n, $two);
665 $log2n = $class -> _dec($log2n) if !$class -> _is_zero($log2n);
666 my $high = $class -> _copy($h);
667 $high = $class -> _dec($high) if $class -> _is_even($h);
668 while ($class -> _acmp($k, $high)) {
669 $k = $class -> _add($k, $two);
670 $p = $class -> _mul($p, $k);
672 $r = $class -> _mul($r, $p);
674 return $class -> _lsft($r, $shift, $two);
679 my ($class, $x) = @_;
681 my $two = $class -> _two();
683 if ($class -> _acmp($x, $two) < 0) {
684 return $class -> _one();
687 my $i = $class -> _copy($x);
688 while ($class -> _acmp($i, $two) > 0) {
689 $i = $class -> _sub($i, $two);
690 $x = $class -> _mul($x, $i);
700 my ($class, $x, $base) = @_;
703 return if $class -> _is_zero($x);
705 $base = $class -> _new(2) unless defined($base);
706 $base = $class -> _new($base) unless ref($base);
709 return if $class -> _is_zero($base) || $class -> _is_one($base);
712 if ($class -> _is_one($x)) {
713 return $class -> _zero(), 1 if wantarray;
714 return $class -> _zero();
717 my $cmp = $class -> _acmp($x, $base);
721 return $class -> _one(), 1 if wantarray;
722 return $class -> _one();
727 return $class -> _zero(), 0 if wantarray;
728 return $class -> _zero();
737 my $x_str = $class -> _str($x);
738 my $b_str = $class -> _str($base);
745 $y = $class -> _new($guess);
748 my $trial = $class -> _pow($class -> _copy($base), $y);
749 my $acmp = $class -> _acmp($trial, $x);
754 $trial = $class -> _mul($trial, $base);
755 $y = $class -> _inc($y);
756 $acmp = $class -> _acmp($trial, $x);
762 $trial = $class -> _div($trial, $base);
763 $y = $class -> _dec($y);
764 $acmp = $class -> _acmp($trial, $x);
772 my ($class, $x) = @_;
774 return if $class -> _is_zero($x);
776 my $str = $class -> _to_hex($x);
780 my $y = $class -> _new(length($str) - 1);
781 $y = $class -> _mul($y, $class -> _new(4));
786 $y = $class -> _add($y, $class -> _new($n));
789 my $pow2 = $class -> _lsft($class -> _one(), $y, 2);
790 my $is_exact = $class -> _acmp($x, $pow2) == 0 ? 1 : 0;
795 my ($class, $x) = @_;
797 return if $class -> _is_zero($x);
799 my $str = $class -> _str($x);
801 my $y = $class -> _new($len - 1);
804 #my $pow10 = $class -> _1ex($y);
805 #my $is_exact = $class -> _acmp($x, $pow10) ? 1 : 0;
812 my ($class, $x) = @_;
814 return if $class -> _is_zero($x);
816 my $str = $class -> _to_hex($x);
820 my $y = $class -> _new(length($str) - 1);
821 $y = $class -> _mul($y, $class -> _new(4));
826 $y = $class -> _add($y, $class -> _new($n));
830 my $pow2 = $class -> _lsft($class -> _one(), $y, 2);
831 my $is_exact = $class -> _acmp($x, $pow2) == 0 ? 1 : 0;
832 $y = $class -> _inc($y) if $is_exact == 0;
838 my ($class, $x) = @_;
840 return if $class -> _is_zero($x);
842 my $str = $class -> _str($x);
846 my $y = $class -> _new($len - 1);
851 my $y = $class -> _new($len);
858 my ($class, $y) = @_;
860 return $y if $class -> _is_zero($y);
862 my $y_str = $class -> _str($y);
888 $x = $class -> _new($x);
898 my $xsq = $class -> _mul($class -> _copy($x), $x); # x(i)^2
899 my $acmp = $class -> _acmp($xsq, $y); # x(i)^2 <=> y
904 $two = $class -> _two() if $acmp != 0;
914 my $numer = $class -> _sub($class -> _copy($y), $xsq); # y - x(i)^2
915 my $denom = $class -> _mul($class -> _copy($two), $x); # 2 * x(i)
916 my $delta = $class -> _div($numer, $denom);
918 unless ($class -> _is_zero($delta)) {
919 $x = $class -> _add($x, $delta);
920 $xsq = $class -> _mul($class -> _copy($x), $x); # x(i)^2
921 $acmp = $class -> _acmp($xsq, $y); # x(i)^2 <=> y
932 my $numer = $class -> _sub($xsq, $y); # x(i)^2 - y
933 my $denom = $class -> _mul($class -> _copy($two), $x); # 2 * x(i)
934 my $delta = $class -> _div($numer, $denom);
935 last if $class -> _is_zero($delta);
937 $x = $class -> _sub($x, $delta);
938 $xsq = $class -> _mul($class -> _copy($x), $x); # x(i)^2
939 $acmp = $class -> _acmp($xsq, $y); # x(i)^2 <=> y
947 $x = $class -> _dec($x);
948 $xsq = $class -> _mul($class -> _copy($x), $x); # x(i)^2
949 $acmp = $class -> _acmp($xsq, $y); # x(i)^2 <=> y
956 my ($class, $y, $n) = @_;
958 return $y if $class -> _is_zero($y) || $class -> _is_one($y) ||
959 $class -> _is_one($n);
963 return $class -> _one() if $class -> _acmp($y, $n) <= 0;
976 my $y_str = $class -> _str($y);
992 my $log10x = $log10y / $class -> _num($n);
1038 my $x = $class -> _new($x_str);
1058 my $nm1 = $class -> _dec($class -> _copy($n)); # n-1
1059 my $xpownm1 = $class -> _pow($class -> _copy($x), $nm1); # x(i)^(n-1)
1060 my $xpown = $class -> _mul($class -> _copy($xpownm1), $x); # x(i)^n
1061 my $acmp = $class -> _acmp($xpown, $y); # x(i)^n <=> y
1065 print "x = ", $class -> _str($x), "\n";
1066 print "x^n = ", $class -> _str($xpown), "\n";
1067 print "y = ", $class -> _str($y), "\n";
1079 my $numer = $class -> _sub($class -> _copy($y), $xpown); # y - x(i)^n
1080 my $denom = $class -> _mul($class -> _copy($n), $xpownm1); # n * x(i)^(n-1)
1081 my $delta = $class -> _div($numer, $denom);
1085 print "numer = ", $class -> _str($numer), "\n";
1086 print "denom = ", $class -> _str($denom), "\n";
1087 print "delta = ", $class -> _str($delta), "\n";
1090 unless ($class -> _is_zero($delta)) {
1091 $x = $class -> _add($x, $delta);
1092 $xpownm1 = $class -> _pow($class -> _copy($x), $nm1); # x(i)^(n-1)
1093 $xpown = $class -> _mul($class -> _copy($xpownm1), $x); # x(i)^n
1094 $acmp = $class -> _acmp($xpown, $y); # x(i)^n <=> y
1098 print "x = ", $class -> _str($x), "\n";
1099 print "x^n = ", $class -> _str($xpown), "\n";
1100 print "y = ", $class -> _str($y), "\n";
1113 my $numer = $class -> _sub($class -> _copy($xpown), $y); # x(i)^n - y
1114 my $denom = $class -> _mul($class -> _copy($n), $xpownm1); # n * x(i)^(n-1)
1117 print "numer = ", $class -> _str($numer), "\n";
1118 print "denom = ", $class -> _str($denom), "\n";
1121 my $delta = $class -> _div($numer, $denom);
1124 print "delta = ", $class -> _str($delta), "\n";
1127 last if $class -> _is_zero($delta);
1129 $x = $class -> _sub($x, $delta);
1130 $xpownm1 = $class -> _pow($class -> _copy($x), $nm1); # x(i)^(n-1)
1131 $xpown = $class -> _mul($class -> _copy($xpownm1), $x); # x(i)^n
1132 $acmp = $class -> _acmp($xpown, $y); # x(i)^n <=> y
1136 print "x = ", $class -> _str($x), "\n";
1137 print "x^n = ", $class -> _str($xpown), "\n";
1138 print "y = ", $class -> _str($y), "\n";
1148 $x = $class -> _dec($x);
1149 $xpown = $class -> _pow($class -> _copy($x), $n); # x(i)^n
1150 $acmp = $class -> _acmp($xpown, $y); # x(i)^n <=> y
1160 my ($class, $x, $y) = @_;
1162 return $x if $class -> _acmp($x, $y) == 0;
1164 my $m = $class -> _one();
1165 my $mask = $class -> _new("32768");
1169 my $xc = $class -> _copy($x);
1170 my $yc = $class -> _copy($y);
1171 my $z = $class -> _zero();
1173 until ($class -> _is_zero($xc) || $class -> _is_zero($yc)) {
1174 ($xc, $xr) = $class -> _div($xc, $mask);
1175 ($yc, $yr) = $class -> _div($yc, $mask);
1176 my $bits = $class -> _new($class -> _num($xr) & $class -> _num($yr));
1177 $z = $class -> _add($z, $class -> _mul($bits, $m));
1178 $m = $class -> _mul($m, $mask);
1185 my ($class, $x, $y) = @_;
1187 return $class -> _zero() if $class -> _acmp($x, $y) == 0;
1189 my $m = $class -> _one();
1190 my $mask = $class -> _new("32768");
1194 my $xc = $class -> _copy($x);
1195 my $yc = $class -> _copy($y);
1196 my $z = $class -> _zero();
1198 until ($class -> _is_zero($xc) || $class -> _is_zero($yc)) {
1199 ($xc, $xr) = $class -> _div($xc, $mask);
1200 ($yc, $yr) = $class -> _div($yc, $mask);
1201 my $bits = $class -> _new($class -> _num($xr) ^ $class -> _num($yr));
1202 $z = $class -> _add($z, $class -> _mul($bits, $m));
1203 $m = $class -> _mul($m, $mask);
1210 $z = $class -> _add($z, $class -> _mul($xc, $m))
1211 unless $class -> _is_zero($xc);
1212 $z = $class -> _add($z, $class -> _mul($yc, $m))
1213 unless $class -> _is_zero($yc);
1219 my ($class, $x, $y) = @_;
1221 return $x if $class -> _acmp($x, $y) == 0; # shortcut (see _and)
1223 my $m = $class -> _one();
1224 my $mask = $class -> _new("32768");
1228 my $xc = $class -> _copy($x);
1229 my $yc = $class -> _copy($y);
1230 my $z = $class -> _zero();
1232 until ($class -> _is_zero($xc) || $class -> _is_zero($yc)) {
1233 ($xc, $xr) = $class -> _div($xc, $mask);
1234 ($yc, $yr) = $class -> _div($yc, $mask);
1235 my $bits = $class -> _new($class -> _num($xr) | $class -> _num($yr));
1236 $z = $class -> _add($z, $class -> _mul($bits, $m));
1237 $m = $class -> _mul($m, $mask);
1244 $z = $class -> _add($z, $class -> _mul($xc, $m))
1245 unless $class -> _is_zero($xc);
1246 $z = $class -> _add($z, $class -> _mul($yc, $m))
1247 unless $class -> _is_zero($yc);
1253 my ($class, $x, $sx, $y, $sy) = @_;
1255 return ($class -> _zero(), '+')
1256 if $class -> _is_zero($x) || $class -> _is_zero($y);
1264 $bx = $class -> _copy($x);
1265 $bx = $class -> _dec($bx);
1266 $bx = $class -> _as_hex($bx);
1271 $bx = $class -> _as_hex($x); # get binary representation
1279 $by = $class -> _copy($y);
1280 $by = $class -> _dec($by);
1281 $by = $class -> _as_hex($by);
1286 $by = $class -> _as_hex($y); # get binary representation
1327 $bx = $class -> _from_hex($bx);
1329 $bx = $class -> _inc($bx) if $sign eq '-';
1332 $sign = '+' if $class -> _is_zero($bx);
1338 my ($class, $x, $sx, $y, $sy) = @_;
1340 return ($class -> _zero(), '+')
1341 if $class -> _is_zero($x) && $class -> _is_zero($y);
1349 $bx = $class -> _copy($x);
1350 $bx = $class -> _dec($bx);
1351 $bx = $class -> _as_hex($bx);
1356 $bx = $class -> _as_hex($x); # get binary representation
1364 $by = $class -> _copy($y);
1365 $by = $class -> _dec($by);
1366 $by = $class -> _as_hex($by);
1371 $by = $class -> _as_hex($y); # get binary representation
1412 $bx = $class -> _from_hex($bx);
1414 $bx = $class -> _inc($bx) if $sign eq '-';
1417 $sign = '+' if $class -> _is_zero($bx);
1423 my ($class, $x, $sx, $y, $sy) = @_;
1425 return ($class -> _zero(), '+')
1426 if $class -> _is_zero($x) && $class -> _is_zero($y);
1434 $bx = $class -> _copy($x);
1435 $bx = $class -> _dec($bx);
1436 $bx = $class -> _as_hex($bx);
1441 $bx = $class -> _as_hex($x); # get binary representation
1449 $by = $class -> _copy($y);
1450 $by = $class -> _dec($by);
1451 $by = $class -> _as_hex($by);
1456 $by = $class -> _as_hex($y); # get binary representation
1497 $bx = $class -> _from_hex($bx);
1499 $bx = $class -> _inc($bx) if $sign eq '-';
1502 $sign = '+' if $class -> _is_zero($bx);
1509 my ($class, $x) = @_;
1511 my $tmp = $class -> _copy($x);
1512 my $chunk = $class -> _new("16777216"); # 2^24 = 24 binary digits
1514 until ($class -> _acmp($tmp, $chunk) < 0) {
1515 ($tmp, $rem) = $class -> _div($tmp, $chunk);
1516 $str = sprintf("%024b", $class -> _num($rem)) . $str;
1518 unless ($class -> _is_zero($tmp)) {
1519 $str = sprintf("%b", $class -> _num($tmp)) . $str;
1526 my ($class, $x) = @_;
1528 my $tmp = $class -> _copy($x);
1529 my $chunk = $class -> _new("16777216"); # 2^24 = 8 octal digits
1531 until ($class -> _acmp($tmp, $chunk) < 0) {
1532 ($tmp, $rem) = $class -> _div($tmp, $chunk);
1533 $str = sprintf("%08o", $class -> _num($rem)) . $str;
1535 unless ($class -> _is_zero($tmp)) {
1536 $str = sprintf("%o", $class -> _num($tmp)) . $str;
1543 my ($class, $x) = @_;
1545 my $tmp = $class -> _copy($x);
1546 my $chunk = $class -> _new("16777216"); # 2^24 = 6 hexadecimal digits
1548 until ($class -> _acmp($tmp, $chunk) < 0) {
1549 ($tmp, $rem) = $class -> _div($tmp, $chunk);
1550 $str = sprintf("%06x", $class -> _num($rem)) . $str;
1552 unless ($class -> _is_zero($tmp)) {
1553 $str = sprintf("%x", $class -> _num($tmp)) . $str;
1560 my ($class, $x) = @_;
1561 return '0b' . $class -> _to_bin($x);
1566 my ($class, $x) = @_;
1567 return '0' . $class -> _to_oct($x); # yes, 0 becomes "00"
1572 my ($class, $x) = @_;
1573 return '0x' . $class -> _to_hex($x);
1578 my ($class, $x) = @_;
1580 my $tmp = $class -> _copy($x);
1581 my $chunk = $class -> _new("65536");
1583 until ($class -> _is_zero($tmp)) {
1584 ($tmp, $rem) = $class -> _div($tmp, $chunk);
1585 $str = pack('n', $class -> _num($rem)) . $str;
1595 my $class = shift;
1598 $base = $class -> _new($base) unless ref($base);
1606 if ($class -> _acmp($base, $class -> _new("94")) <= 0) {
1622 my $tmp = $class -> _copy($x);
1624 until ($class -> _is_zero($tmp)) {
1625 ($tmp, $rem) = $class -> _div($tmp, $base);
1626 my $num = $class -> _num($rem);
1638 my ($class, $x, $base) = @_;
1641 $base = $class -> _new($base) unless ref($base);
1642 my $two = $class -> _two();
1643 croak "base must be >= 2" unless $class -> _acmp($base, $two) >= 0;
1646 my $xcopy = $class -> _copy($x);
1650 until ($class -> _acmp($xcopy, $base) < 0) {
1651 ($xcopy, $rem) = $class -> _div($xcopy, $base);
1656 unless ($class -> _is_zero($xcopy)) {
1661 unshift @$out, $class -> _zero() unless @$out;
1669 my ($class, $hex) = @_;
1681 my $ret = $class -> _new(int hex substr $hex, 0, $rem);
1686 my $shift = $class -> _new(1 << (4 * 7));
1689 $ret = $class -> _mul($ret, $shift);
1690 $ret = $class -> _add($ret, $class -> _new($part));
1699 my ($class, $oct) = @_;
1710 my $ret = $class -> _new(int oct substr $oct, 0, $rem);
1715 my $shift = $class -> _new(1 << (3 * 10));
1718 $ret = $class -> _mul($ret, $shift);
1719 $ret = $class -> _add($ret, $class -> _new($part));
1728 my ($class, $bin) = @_;
1739 my $ret = $class -> _new(int oct '0b' . substr $bin, 0, $rem);
1744 my $shift = $class -> _new(1 << 31);
1747 $ret = $class -> _mul($ret, $shift);
1748 $ret = $class -> _add($ret, $class -> _new($part));
1756 my ($class, $str) = @_;
1757 my $x = $class -> _zero();
1758 my $base = $class -> _new("256");
1761 $x = $class -> _mul($x, $base);
1762 my $byteval = $class -> _new(unpack 'C', substr($str, $i, 1));
1763 $x = $class -> _add($x, $byteval);
1770 my $class = shift;
1773 $base = $class -> _new($base) unless ref($base);
1776 my $x = $class -> _zero();
1782 if ($class -> _acmp($base, $class -> _new("36")) <= 0) {
1785 } elsif ($class -> _acmp($base, $class -> _new("94")) <= 0) {
1796 $collseq = substr $collseq, 0, $class -> _num($base);
1815 $x = $class -> _mul($x, $base);
1816 my $num = $class -> _new($collseq{$chr});
1817 $x = $class -> _add($x, $num);
1825 my ($class, $in, $base) = @_;
1828 $base = $class -> _new($base) unless ref($base);
1829 my $two = $class -> _two();
1830 croak "base must be >= 2" unless $class -> _acmp($base, $two) >= 0;
1832 # @$in = map { ref($_) ? $_ : $class -> _new($_) } @$in;
1836 $ele = $class -> _new($ele) unless ref($ele);
1837 my $x = $class -> _copy($ele);
1840 $x = $class -> _mul($x, $base);
1842 $ele = $class -> _new($ele) unless ref($ele);
1843 $x = $class -> _add($x, $ele);
1854 my ($class, $x, $y) = @_;
1857 if ($class -> _is_zero($y)) {
1862 if ($class -> _is_one($y)) {
1863 return ($class -> _zero(), '+');
1866 my $u = $class -> _zero();
1867 my $v = $class -> _one();
1868 my $a = $class -> _copy($y);
1869 my $b = $class -> _copy($x);
1876 ($a, $q, $b) = ($b, $class -> _div($a, $b));
1877 last if $class -> _is_zero($b);
1879 my $vq = $class -> _mul($class -> _copy($v), $q);
1880 my $t = $class -> _add($vq, $u);
1888 return unless $class -> _is_one($a);
1895 my ($class, $num, $exp, $mod) = @_;
1898 if ($class -> _is_one($mod)) {
1899 return $class -> _zero();
1904 if ($class -> _is_zero($num)) {
1905 return $class -> _is_zero($exp) ? $class -> _one()
1906 : $class -> _zero();
1909 # $num = $class -> _mod($num, $mod); # this does not make it faster
1911 my $acc = $class -> _copy($num);
1912 my $t = $class -> _one();
1914 my $expbin = $class -> _as_bin($exp);
1920 $t = $class -> _mul($t, $acc);
1921 $t = $class -> _mod($t, $mod);
1923 $acc = $class -> _mul($acc, $acc);
1924 $acc = $class -> _mod($acc, $mod);
1932 my ($class, $x, $y) = @_;
1937 if ($class -> _acmp($x, $y) == 0) {
1938 return $class -> _copy($x);
1941 if ($class -> _is_zero($x)) {
1942 if ($class -> _is_zero($y)) {
1943 return $class -> _zero();
1945 return $class -> _copy($y);
1948 if ($class -> _is_zero($y)) {
1949 return $class -> _copy($x);
1954 $x = $class -> _copy($x);
1955 until ($class -> _is_zero($y)) {
1959 $x = $class -> _mod($x, $y);
1964 $x = $class -> _copy($y);
1976 my ($class, $x, $y) = @_;
1980 return $class -> _zero()
1981 if ($class -> _is_zero($x) ||
1982 $class -> _is_zero($y));
1984 my $gcd = $class -> _gcd($class -> _copy($x), $y);
1985 $x = $class -> _div($x, $gcd);
1986 $x = $class -> _mul($x, $y);
1991 my ($class, $n) = @_;
1993 $n = $class -> _num($n) if ref $n;
2000 push @y, $class -> _two();
2003 push @y, $class -> _one();
2007 $y[$i] = $class -> _add($class -> _copy($y[$i - 1]), $y[$i - 2]);
2018 return $class -> _two() if $n == 0;
2020 return $class -> _add(scalar($class -> _fib($n - 1)),
2021 scalar($class -> _fib($n + 1)));
2025 my ($class, $n) = @_;
2027 $n = $class -> _num($n) if ref $n;
2034 push @y, $class -> _zero();
2037 push @y, $class -> _one();
2041 $y[$i] = $class -> _add($class -> _copy($y[$i - 1]), $y[$i - 2]);
2051 my $two = $class -> _two();
2056 return $class -> _zero() if $n <= 0;
2057 return $class -> _one() if $n <= 2;
2067 $y = $class -> _add($class -> _mul($class -> _copy($a), $a),
2068 $class -> _mul($class -> _copy($b), $b));
2071 $y = $class -> _mul($class -> _sub($class -> _mul(
2072 $class -> _copy($two), $a), $b), $b);
2093 Math::BigInt::Lib - virtual parent class for Math::BigInt libraries
2117 to be used directly, but rather as a parent class for backend libraries used by
2141 liberary methods are always called as class methods, not instance methods:
2143 $x = Class -> method($x, $y); # like this
2149 $bool = Class -> method($x, $y); # like this
2159 =item CLASS-E<gt>api_version()
2162 implemented by a subclass will be inherited from this class.
2173 =item CLASS-E<gt>_new(STR)
2179 =item CLASS-E<gt>_zero()
2183 =item CLASS-E<gt>_one()
2187 =item CLASS-E<gt>_two()
2191 =item CLASS-E<gt>_ten()
2195 =item CLASS-E<gt>_from_bin(STR)
2200 =item CLASS-E<gt>_from_oct(STR)
2205 =item CLASS-E<gt>_from_hex(STR)
2211 =item CLASS-E<gt>_from_bytes(STR)
2217 =item CLASS-E<gt>_from_base(STR, BASE, COLLSEQ)
2246 $x = $class -> _from_base("11111010", 2)
2247 $x = $class -> _from_base("372", 8)
2248 $x = $class -> _from_base("250", 10)
2249 $x = $class -> _from_base("FA", 16)
2253 $x = $class -> _from_base("100021", 3)
2254 $x = $class -> _from_base("3322", 4)
2255 $x = $class -> _from_base("2000", 5)
2256 $x = $class -> _from_base("caaa", 5, "abcde")
2257 $x = $class -> _from_base("42", 62)
2258 $x = $class -> _from_base("2!", 94)
2260 =item CLASS-E<gt>_from_base_num(ARRAY, BASE)
2267 $x = $class -> _from_base_num([1, 1, 0, 1], 2) # $x is 13
2268 $x = $class -> _from_base_num([3, 125, 39], 128) # $x is 65191
2276 =item CLASS-E<gt>_add(OBJ1, OBJ2)
2280 =item CLASS-E<gt>_mul(OBJ1, OBJ2)
2284 =item CLASS-E<gt>_div(OBJ1, OBJ2)
2290 =item CLASS-E<gt>_sub(OBJ1, OBJ2, FLAG)
2292 =item CLASS-E<gt>_sub(OBJ1, OBJ2)
2297 =item CLASS-E<gt>_sadd(OBJ1, SIGN1, OBJ2, SIGN2)
2302 ($obj3, $sign3) = $class -> _sadd($obj1, $sign1, $obj2, $sign2);
2304 =item CLASS-E<gt>_ssub(OBJ1, SIGN1, OBJ2, SIGN2)
2309 ($obj3, $sign3) = $class -> _sadd($obj1, $sign1, $obj2, $sign2);
2311 =item CLASS-E<gt>_dec(OBJ)
2315 =item CLASS-E<gt>_inc(OBJ)
2319 =item CLASS-E<gt>_mod(OBJ1, OBJ2)
2323 =item CLASS-E<gt>_sqrt(OBJ)
2327 =item CLASS-E<gt>_root(OBJ, N)
2331 =item CLASS-E<gt>_fac(OBJ)
2336 =item CLASS-E<gt>_dfac(OBJ)
2343 =item CLASS-E<gt>_pow(OBJ1, OBJ2)
2347 =item CLASS-E<gt>_modinv(OBJ1, OBJ2)
2364 =item CLASS-E<gt>_modpow(OBJ1, OBJ2, OBJ3)
2368 =item CLASS-E<gt>_rsft(OBJ, N, B)
2378 =item CLASS-E<gt>_lsft(OBJ, N, B)
2383 =item CLASS-E<gt>_log_int(OBJ, B)
2390 =item CLASS-E<gt>_ilog2(OBJ)
2401 =item CLASS-E<gt>_ilog10(OBJ)
2415 =item CLASS-E<gt>_clog2(OBJ)
2423 =item CLASS-E<gt>_clog10(OBJ)
2431 =item CLASS-E<gt>_gcd(OBJ1, OBJ2)
2435 =item CLASS-E<gt>_lcm(OBJ1, OBJ2)
2439 =item CLASS-E<gt>_fib(OBJ)
2445 =item CLASS-E<gt>_lucas(OBJ)
2457 =item CLASS-E<gt>_and(OBJ1, OBJ2)
2461 =item CLASS-E<gt>_or(OBJ1, OBJ2)
2465 =item CLASS-E<gt>_xor(OBJ1, OBJ2)
2469 =item CLASS-E<gt>_sand(OBJ1, OBJ2, SIGN1, SIGN2)
2473 =item CLASS-E<gt>_sor(OBJ1, OBJ2, SIGN1, SIGN2)
2477 =item CLASS-E<gt>_sxor(OBJ1, OBJ2, SIGN1, SIGN2)
2487 =item CLASS-E<gt>_is_zero(OBJ)
2491 =item CLASS-E<gt>_is_one(OBJ)
2495 =item CLASS-E<gt>_is_two(OBJ)
2499 =item CLASS-E<gt>_is_ten(OBJ)
2503 =item CLASS-E<gt>_is_even(OBJ)
2507 =item CLASS-E<gt>_is_odd(OBJ)
2511 =item CLASS-E<gt>_acmp(OBJ1, OBJ2)
2522 =item CLASS-E<gt>_str(OBJ)
2527 =item CLASS-E<gt>_to_bin(OBJ)
2531 =item CLASS-E<gt>_to_oct(OBJ)
2535 =item CLASS-E<gt>_to_hex(OBJ)
2539 =item CLASS-E<gt>_to_bytes(OBJ)
2545 =item CLASS-E<gt>_to_base(OBJ, BASE, COLLSEQ)
2550 $val = $class -> _new("210");
2551 $str = $class -> _to_base($val, 10, "xyz") # $str is "zyx"
2553 $val = $class -> _new("32");
2554 $str = $class -> _to_base($val, 2, "-|") # $str is "|-----"
2558 =item CLASS-E<gt>_to_base_num(OBJ, BASE)
2565 $x = $class -> _to_base_num(13, 2) # $x is [1, 1, 0, 1]
2566 $x = $class -> _to_base_num(65191, 128) # $x is [3, 125, 39]
2568 =item CLASS-E<gt>_as_bin(OBJ)
2572 =item CLASS-E<gt>_as_oct(OBJ)
2576 =item CLASS-E<gt>_as_hex(OBJ)
2580 =item CLASS-E<gt>_as_bytes(OBJ)
2590 =item CLASS-E<gt>_num(OBJ)
2602 =item CLASS-E<gt>_copy(OBJ)
2606 =item CLASS-E<gt>_len(OBJ)
2610 =item CLASS-E<gt>_zeros(OBJ)
2615 =item CLASS-E<gt>_digit(OBJ, N)
2621 CLASS->_digit($obj, 0) # returns 3
2622 CLASS->_digit($obj, 1) # returns 2
2623 CLASS->_digit($obj, 2) # returns 1
2624 CLASS->_digit($obj, -1) # returns 1
2626 =item CLASS-E<gt>_digitsum(OBJ)
2630 =item CLASS-E<gt>_check(OBJ)
2636 =item CLASS-E<gt>_set(OBJ)
2650 =item CLASS-E<gt>_1ex(N)
2661 =item CLASS-E<gt>_nok(OBJ1, OBJ2)
2671 =item CLASS-E<gt>_alen(OBJ)