src/rational/transcendental/cl_RA_logp.cc

   1 // logp().
   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_I.h"
  13 #include "cl_RA.h"
  14
  15 namespace cln {
  16
  17 cl_boolean logp (const cl_RA& a, const cl_RA& b, cl_RA* pl)
  18 {
  19 // Methode:
  20 // a=1 -> Ergebnis 0
  21 // b Integer:
  22 //   a Integer: log(a,b) rational errechenbar -> liefern
  23 //   a Ratio: a=a1/a2 mit a1>0, a2>1.
  24 //            a1=1 und log(a2,b) rational errechenbar -> -log(a2,b) liefern
  25 // b Ratio: a=a1/a2, b=b1/b2 mit a1>0, a2>0, b1>0, b2>1.
  26 //          log(a2,b2) rational errechenbar ->
  27 //             b1=1 -> bei a1=1 liefern, sonst nicht.
  28 //             b1>1 -> log(a1,b1) rational errechenbar und
  29 //                     log(a1,b1)=log(a2,b2) -> liefern, sonst nicht.
  30 //          sonst a1,a2 vertauschen:
  31 //            log(a2/a1,b1/b2) versuchen (wie oben) ->
  32 //              -log(a2/a1,b1/b2) liefern
  33
  34         if (eq(a,1)) { // a=1 -> Ergebnis 0
  35                 *pl = 0; return cl_true;
  36         }
  37         if (integerp(b)) {
  38                 // b Integer
  39                 DeclareType(cl_I,b);
  40                 if (integerp(a)) {
  41                         // a,b beide Integers
  42                         DeclareType(cl_I,a);
  43                         return logp(a,b,pl);
  44                 } else {
  45                         // a Ratio, b Integer
  46                         DeclareType(cl_RT,a);
  47                         var const cl_I& a1 = numerator(a);
  48                         var const cl_I& a2 = denominator(a);
  49                         if (!eq(a1,1))
  50                                 return cl_false;
  51                         // a1=1
  52                         var cl_RA l;
  53                         if (logp(a2,b,pl)) {
  54                                 *pl = -l; return cl_true;
  55                         } else
  56                                 return cl_false;
  57                 }
  58         } else {
  59                 // a rational, b Ratio
  60                 DeclareType(cl_RT,b);
  61                 var cl_I a1;
  62                 var cl_I a2;
  63                 RA_numden_I_I(a, a1 =, a2 =);
  64                 var const cl_I& b1 = numerator(b);
  65                 var const cl_I& b2 = denominator(b);
  66                 {
  67                         var cl_RA l2;
  68                         // rationalen log(a2,b2) versuchen
  69                         if (logp(a2,b2,&l2)) {
  70                                 if (eq(b1,1)) {
  71                                         if (eq(a1,1))
  72                                                 { *pl = l2; return cl_true; }
  73                                         else
  74                                                 return cl_false;
  75                                 } else {
  76                                         var cl_RA l1;
  77                                         // rationalen log(a1,b1) versuchen
  78                                         if (logp(a1,b1,&l1))
  79                                                 if (l1 == l2)
  80                                                         { *pl = l2; return cl_true; }
  81                                         return cl_false;
  82                                 }
  83                         }
  84                 }
  85                 {
  86                         var cl_RA l2;
  87                         // rationalen log(a1,b2) versuchen
  88                         if (logp(a1,b2,&l2)) {
  89                                 if (eq(b1,1)) {
  90                                         if (eq(a2,1))
  91                                                 { *pl = -l2; return cl_true; }
  92                                         else
  93                                                 return cl_false;
  94                                 } else {
  95                                         var cl_RA l1;
  96                                         // rationalen log(a2,b1) versuchen
  97                                         if (logp(a2,b1,&l1))
  98                                                 if (l1 == l2)
  99                                                         { *pl = -l2; return cl_true; }
 100                                 }
 101                         }
 102                 }
 103                 return cl_false;
 104         }
 105 }
 106
 107 }  // namespace cln