src/rational/elem/cl_RA_compare.cc

   1 // compare().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cln/rational.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cl_RA.h"
  13 #include "cln/integer.h"
  14
  15 namespace cln {
  16
  17 cl_signean compare (const cl_RA& r, const cl_RA& s)
  18 {
  19 // Methode:
  20 // r,s Integer -> klar
  21 // r<0, s>=0 -> r<s.
  22 // r>=0, s<0 -> r>s.
  23 // r Integer, s Ratio: r=a, s=b/c. Vergleiche a*c und b.
  24 // r Ratio, s Integer: r=a/b, s=c. Vergleiche a und b*c.
  25 // r,s Ratios: r=a/b, s=c/d. Vergleiche a*d und b*c.
  26         // 1. Schritt: Test, ob beides Integers:
  27         if (integerp(r) && integerp(s)) {
  28                 DeclareType(cl_I,r);
  29                 DeclareType(cl_I,s);
  30                 return compare(r,s);
  31         }
  32         // r,s nicht beide Integers.
  33         // 2. Schritt: Test, ob die Vorzeichen bereits das Ergebnis hergeben:
  34         if (minusp(r)) {
  35                 if (!minusp(s))
  36                         return signean_minus; // r<0, s>=0 -> r<s
  37         } else {
  38                 if (minusp(s))
  39                         return signean_plus; // r>=0, s<0 -> r>s
  40         }
  41         // r,s haben gleiches Vorzeichen.
  42         // 3. Schritt: Fallunterscheidung nach Typen
  43         if (integerp(r)) {
  44                 DeclareType(cl_I,r);
  45                 DeclareType(cl_RT,s);
  46                 // r Integer, s Ratio: r=a, s=b/c. Vergleiche a*c und b.
  47                 var const cl_I& a = r;
  48                 var const cl_I& b = numerator(s);
  49                 var const cl_I& c = denominator(s);
  50                 return compare(a*c,b);
  51         }
  52         elif (integerp(s)) {
  53                 DeclareType(cl_I,s);
  54                 DeclareType(cl_RT,r);
  55                 // r Ratio, s Integer: r=a/b, s=c. Vergleiche a und b*c.
  56                 var const cl_I& a = numerator(r);
  57                 var const cl_I& b = denominator(r);
  58                 var const cl_I& c = s;
  59                 return compare(a,b*c);
  60         }
  61         else {
  62                 DeclareType(cl_RT,r);
  63                 DeclareType(cl_RT,s);
  64                 // r,s Ratios: r=a/b, s=c/d. Vergleiche a*d und b*c.
  65                 var const cl_I& a = numerator(r);
  66                 var const cl_I& b = denominator(r);
  67                 var const cl_I& c = numerator(s);
  68                 var const cl_I& d = denominator(s);
  69                 return compare(a*d,b*c);
  70         }
  71 }
  72 // Beschleunigung durch Konversion zu Short-Floats diese zuerst vergleichen??
  73
  74 }  // namespace cln