src/rational/transcendental/cl_RA_logp.cc

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