1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  23  */
  24 /*
  25  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  26  * Use is subject to license terms.
  27  */
  28 
  29 #pragma weak clog = __clog
  30 
  31 /* INDENT OFF */
  32 /*
  33  * dcomplex clog(dcomplex z);
  34  *
  35  *                    _________
  36  *                   / 2    2            -1   y
  37  * log(x+iy) = log(\/ x  + y    ) + i tan   (---)
  38  *                                            x
  39  *
  40  *              1       2    2         -1   y
  41  *           = --- log(x  + y ) + i tan   (---)
  42  *              2                           x
  43  *
  44  * Note that the arctangent ranges from -PI to +PI, thus the imaginary
  45  * part of clog is atan2(y,x).
  46  *
  47  * EXCEPTION CASES (conform to ISO/IEC 9899:1999(E)):
  48  *    clog(-0 + i 0   ) =  -inf + i pi
  49  *    clog( 0 + i 0   ) =  -inf + i 0
  50  *    clog( x + i inf ) =  -inf + i pi/2, for finite x
  51  *    clog( x + i NaN ) =  NaN  + i NaN with invalid for finite x
  52  *    clog(-inf + iy   )=  +inf + i pi, for finite positive-signed y
  53  *    clog(+inf + iy   )=  +inf + i 0 , for finite positive-signed y
  54  *    clog(-inf + i inf)=  inf  + i 3pi/4
  55  *    clog(+inf + i inf)=  inf  + i pi/4
  56  *    clog(+-inf+ i NaN)=  inf  + i NaN
  57  *    clog(NaN  + i y  )=  NaN  + i NaN for finite y
  58  *    clog(NaN  + i inf)=  inf  + i NaN
  59  *    clog(NaN  + i NaN)=  NaN  + i NaN
  60  */
  61 /* INDENT ON */
  62 
  63 #include "libm_synonyms.h"
  64 #include <math.h>         /* atan2/fabs/log/log1p */
  65 #include "complex_wrapper.h"
  66 #include "libm_protos.h"        /* __k_clog_r */
  67 
  68 
  69 static const double half = 0.5, one = 1.0;
  70 
  71 dcomplex
  72 clog(dcomplex z) {
  73         dcomplex        ans;
  74         double          x, y, t, ax, ay, w;
  75         int             n, ix, iy, hx, hy;
  76         unsigned        lx, ly;
  77 
  78         x = D_RE(z);
  79         y = D_IM(z);
  80         hx = HI_WORD(x);
  81         lx = LO_WORD(x);
  82         hy = HI_WORD(y);
  83         ly = LO_WORD(y);
  84         ix = hx & 0x7fffffff;
  85         iy = hy & 0x7fffffff;
  86         ay = fabs(y);
  87         ax = fabs(x);
  88         D_IM(ans) = carg(z);
  89         if (ix < iy || (ix == iy && lx < ly)) {
  90                 /* swap x and y to force ax >= ay */
  91                 t = ax;
  92                 ax = ay;
  93                 ay = t;
  94                 n = ix, ix = iy;
  95                 iy = n;
  96                 n = lx, lx = ly;
  97                 ly = n;
  98         }
  99         n = (ix - iy) >> 20;
 100         if (ix >= 0x7ff00000) {      /* x or y is Inf or NaN */
 101                 if (ISINF(ix, lx))
 102                         D_RE(ans) = ax;
 103                 else if (ISINF(iy, ly))
 104                         D_RE(ans) = ay;
 105                 else
 106                         D_RE(ans) = ax * ay;
 107         } else if ((iy | ly) == 0) {
 108                 D_RE(ans) = ((ix | lx) == 0)? -one / ax : log(ax);
 109         } else if (((0x3fffffff - ix) ^ (ix - 0x3fe00000)) >= 0) {
 110                 /* 0.5 <= x < 2 */
 111                 if (ix >= 0x3ff00000) {
 112                         if (((ix - 0x3ff00000) | lx) == 0)
 113                                 D_RE(ans) = half * log1p(ay * ay);
 114                         else if (n >= 60)
 115                                 D_RE(ans) = log(ax);
 116                         else
 117                                 D_RE(ans) = half * (log1p(ay * ay + (ax -
 118                                     one) * (ax + one)));
 119                 } else if (n >= 60) {
 120                         D_RE(ans) = log(ax);
 121                 } else {
 122                         D_RE(ans) = __k_clog_r(ax, ay, &w);
 123                 }
 124         } else if (n >= 30) {
 125                 D_RE(ans) = log(ax);
 126         } else if (ix < 0x5f300000 && iy >= 0x20b00000) {
 127                 /* 2**-500< y < x < 2**500 */
 128                 D_RE(ans) = half * log(ax * ax + ay * ay);
 129         } else {
 130                 t = ay / ax;
 131                 D_RE(ans) = log(ax) + half * log1p(t * t);
 132         }
 133         return (ans);
 134 }