src/real/transcendental/cl_R_log.cc

   1 // log().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cln/real.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cl_N.h"
  13 #include "cl_R.h"
  14 #include "cln/rational.h"
  15 #include "cln/float.h"
  16
  17 namespace cln {
  18
  19 const cl_R log (const cl_R& a, const cl_R& b)
  20 {
  21 // Methode:
  22 // a und b rational:
  23 //   b=1 -> Error
  24 //   log(a,b) rational errechenbar -> liefern.
  25 //   Sonst a und b in Floats umwandeln.
  26 // a Float, b rational -> bei b=1 Error, sonst b := (float b a)
  27 // a rational, b Float -> bei a=1 Ergebnis 0, sonst a := (float a b)
  28 // a,b Floats -> log(a,b) = ln(a)/ln(b)
  29  {      Mutable(cl_R,a);
  30         Mutable(cl_R,b);
  31         if (rationalp(b)) {
  32                 // b rational
  33                 if (eq(b,1)) { throw division_by_0_exception(); }
  34                 if (rationalp(a)) {
  35                         // a,b beide rational
  36                         var cl_RA l;
  37                         if (logp(The(cl_RA)(a),The(cl_RA)(b),&l))
  38                                 return l;
  39                         // a,b beide in Floats umwandeln:
  40                         a = cl_float(The(cl_RA)(a)); b = cl_float(The(cl_RA)(b));
  41                 } else
  42                         // a Float
  43                         b = cl_float(The(cl_RA)(b),The(cl_F)(a)); // b := (float b a)
  44         } else {
  45                 // b Float
  46                 if (rationalp(a)) {
  47                         if (eq(a,1)) { return 0; } // a=1 -> Ergebnis 0
  48                         a = cl_float(The(cl_RA)(a),The(cl_F)(b)); // a := (float a b)
  49                 }
  50         }
  51         // Nun a,b beide Floats.
  52         return ln(The(cl_F)(a)) / ln(The(cl_F)(b));
  53 }}
  54
  55 }  // namespace cln