Upgrade to Pod-Simple-3.08
[perl.git] / lib / bigrat.pl
1 package bigrat;
2 require "bigint.pl";
3 #
4 # This library is no longer being maintained, and is included for backward
5 # compatibility with Perl 4 programs which may require it.
6 # This legacy library is deprecated and will be removed in a future
7 # release of perl.
8 #
9 # In particular, this should not be used as an example of modern Perl
10 # programming techniques.
11 #
12 # Arbitrary size rational math package
13
14 warn( "The 'bigrat.pl' legacy library is deprecated and will be"
15       . " removed in the next major release of perl. Please use the"
16       . " bigrat module instead." );
17
18 # by Mark Biggar
19 #
20 # Input values to these routines consist of strings of the form 
21 #   m|^\s*[+-]?[\d\s]+(/[\d\s]+)?$|.
22 # Examples:
23 #   "+0/1"                          canonical zero value
24 #   "3"                             canonical value "+3/1"
25 #   "   -123/123 123"               canonical value "-1/1001"
26 #   "123 456/7890"                  canonical value "+20576/1315"
27 # Output values always include a sign and no leading zeros or
28 #   white space.
29 # This package makes use of the bigint package.
30 # The string 'NaN' is used to represent the result when input arguments 
31 #   that are not numbers, as well as the result of dividing by zero and
32 #       the sqrt of a negative number.
33 # Extreamly naive algorthims are used.
34 #
35 # Routines provided are:
36 #
37 #   rneg(RAT) return RAT                negation
38 #   rabs(RAT) return RAT                absolute value
39 #   rcmp(RAT,RAT) return CODE           compare numbers (undef,<0,=0,>0)
40 #   radd(RAT,RAT) return RAT            addition
41 #   rsub(RAT,RAT) return RAT            subtraction
42 #   rmul(RAT,RAT) return RAT            multiplication
43 #   rdiv(RAT,RAT) return RAT            division
44 #   rmod(RAT) return (RAT,RAT)          integer and fractional parts
45 #   rnorm(RAT) return RAT               normalization
46 #   rsqrt(RAT, cycles) return RAT       square root
47 \f
48 # Convert a number to the canonical string form m|^[+-]\d+/\d+|.
49 sub main'rnorm { #(string) return rat_num
50     local($_) = @_;
51     s/\s+//g;
52     if (m#^([+-]?\d+)(/(\d*[1-9]0*))?$#) {
53         &norm($1, $3 ? $3 : '+1');
54     } else {
55         'NaN';
56     }
57 }
58
59 # Normalize by reducing to lowest terms
60 sub norm { #(bint, bint) return rat_num
61     local($num,$dom) = @_;
62     if ($num eq 'NaN') {
63         'NaN';
64     } elsif ($dom eq 'NaN') {
65         'NaN';
66     } elsif ($dom =~ /^[+-]?0+$/) {
67         'NaN';
68     } else {
69         local($gcd) = &'bgcd($num,$dom);
70         $gcd =~ s/^-/+/;
71         if ($gcd ne '+1') { 
72             $num = &'bdiv($num,$gcd);
73             $dom = &'bdiv($dom,$gcd);
74         } else {
75             $num = &'bnorm($num);
76             $dom = &'bnorm($dom);
77         }
78         substr($dom,$[,1) = '';
79         "$num/$dom";
80     }
81 }
82
83 # negation
84 sub main'rneg { #(rat_num) return rat_num
85     local($_) = &'rnorm(@_);
86     tr/-+/+-/ if ($_ ne '+0/1');
87     $_;
88 }
89
90 # absolute value
91 sub main'rabs { #(rat_num) return $rat_num
92     local($_) = &'rnorm(@_);
93     substr($_,$[,1) = '+' unless $_ eq 'NaN';
94     $_;
95 }
96
97 # multipication
98 sub main'rmul { #(rat_num, rat_num) return rat_num
99     local($xn,$xd) = split('/',&'rnorm($_[$[]));
100     local($yn,$yd) = split('/',&'rnorm($_[$[+1]));
101     &norm(&'bmul($xn,$yn),&'bmul($xd,$yd));
102 }
103
104 # division
105 sub main'rdiv { #(rat_num, rat_num) return rat_num
106     local($xn,$xd) = split('/',&'rnorm($_[$[]));
107     local($yn,$yd) = split('/',&'rnorm($_[$[+1]));
108     &norm(&'bmul($xn,$yd),&'bmul($xd,$yn));
109 }
110 \f
111 # addition
112 sub main'radd { #(rat_num, rat_num) return rat_num
113     local($xn,$xd) = split('/',&'rnorm($_[$[]));
114     local($yn,$yd) = split('/',&'rnorm($_[$[+1]));
115     &norm(&'badd(&'bmul($xn,$yd),&'bmul($yn,$xd)),&'bmul($xd,$yd));
116 }
117
118 # subtraction
119 sub main'rsub { #(rat_num, rat_num) return rat_num
120     local($xn,$xd) = split('/',&'rnorm($_[$[]));
121     local($yn,$yd) = split('/',&'rnorm($_[$[+1]));
122     &norm(&'bsub(&'bmul($xn,$yd),&'bmul($yn,$xd)),&'bmul($xd,$yd));
123 }
124
125 # comparison
126 sub main'rcmp { #(rat_num, rat_num) return cond_code
127     local($xn,$xd) = split('/',&'rnorm($_[$[]));
128     local($yn,$yd) = split('/',&'rnorm($_[$[+1]));
129     &bigint'cmp(&'bmul($xn,$yd),&'bmul($yn,$xd));
130 }
131
132 # int and frac parts
133 sub main'rmod { #(rat_num) return (rat_num,rat_num)
134     local($xn,$xd) = split('/',&'rnorm(@_));
135     local($i,$f) = &'bdiv($xn,$xd);
136     if (wantarray) {
137         ("$i/1", "$f/$xd");
138     } else {
139         "$i/1";
140     }   
141 }
142
143 # square root by Newtons method.
144 #   cycles specifies the number of iterations default: 5
145 sub main'rsqrt { #(fnum_str[, cycles]) return fnum_str
146     local($x, $scale) = (&'rnorm($_[$[]), $_[$[+1]);
147     if ($x eq 'NaN') {
148         'NaN';
149     } elsif ($x =~ /^-/) {
150         'NaN';
151     } else {
152         local($gscale, $guess) = (0, '+1/1');
153         $scale = 5 if (!$scale);
154         while ($gscale++ < $scale) {
155             $guess = &'rmul(&'radd($guess,&'rdiv($x,$guess)),"+1/2");
156         }
157         "$guess";          # quotes necessary due to perl bug
158     }
159 }
160
161 1;