1  /* Complex sine hyperbole function for float types.
       2     Copyright (C) 1997-2018 Free Software Foundation, Inc.
       3     This file is part of the GNU C Library.
       4     Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
       5  
       6     The GNU C Library is free software; you can redistribute it and/or
       7     modify it under the terms of the GNU Lesser General Public
       8     License as published by the Free Software Foundation; either
       9     version 2.1 of the License, or (at your option) any later version.
      10  
      11     The GNU C Library is distributed in the hope that it will be useful,
      12     but WITHOUT ANY WARRANTY; without even the implied warranty of
      13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14     Lesser General Public License for more details.
      15  
      16     You should have received a copy of the GNU Lesser General Public
      17     License along with the GNU C Library; if not, see
      18     <http://www.gnu.org/licenses/>.  */
      19  
      20  #include "quadmath-imp.h"
      21  
      22  __complex128
      23  csinhq (__complex128 x)
      24  {
      25    __complex128 retval;
      26    int negate = signbitq (__real__ x);
      27    int rcls = fpclassifyq (__real__ x);
      28    int icls = fpclassifyq (__imag__ x);
      29  
      30    __real__ x = fabsq (__real__ x);
      31  
      32    if (__glibc_likely (rcls >= QUADFP_ZERO))
      33      {
      34        /* Real part is finite.  */
      35        if (__glibc_likely (icls >= QUADFP_ZERO))
      36  	{
      37  	  /* Imaginary part is finite.  */
      38  	  const int t = (int) ((FLT128_MAX_EXP - 1) * M_LN2q);
      39  	  __float128 sinix, cosix;
      40  
      41  	  if (__glibc_likely (fabsq (__imag__ x) > FLT128_MIN))
      42  	    {
      43  	      sincosq (__imag__ x, &sinix, &cosix);
      44  	    }
      45  	  else
      46  	    {
      47  	      sinix = __imag__ x;
      48  	      cosix = 1;
      49  	    }
      50  
      51  	  if (negate)
      52  	    cosix = -cosix;
      53  
      54  	  if (fabsq (__real__ x) > t)
      55  	    {
      56  	      __float128 exp_t = expq (t);
      57  	      __float128 rx = fabsq (__real__ x);
      58  	      if (signbitq (__real__ x))
      59  		cosix = -cosix;
      60  	      rx -= t;
      61  	      sinix *= exp_t / 2;
      62  	      cosix *= exp_t / 2;
      63  	      if (rx > t)
      64  		{
      65  		  rx -= t;
      66  		  sinix *= exp_t;
      67  		  cosix *= exp_t;
      68  		}
      69  	      if (rx > t)
      70  		{
      71  		  /* Overflow (original real part of x > 3t).  */
      72  		  __real__ retval = FLT128_MAX * cosix;
      73  		  __imag__ retval = FLT128_MAX * sinix;
      74  		}
      75  	      else
      76  		{
      77  		  __float128 exp_val = expq (rx);
      78  		  __real__ retval = exp_val * cosix;
      79  		  __imag__ retval = exp_val * sinix;
      80  		}
      81  	    }
      82  	  else
      83  	    {
      84  	      __real__ retval = sinhq (__real__ x) * cosix;
      85  	      __imag__ retval = coshq (__real__ x) * sinix;
      86  	    }
      87  
      88  	  math_check_force_underflow_complex (retval);
      89  	}
      90        else
      91  	{
      92  	  if (rcls == QUADFP_ZERO)
      93  	    {
      94  	      /* Real part is 0.0.  */
      95  	      __real__ retval = copysignq (0, negate ? -1 : 1);
      96  	      __imag__ retval = __imag__ x - __imag__ x;
      97  	    }
      98  	  else
      99  	    {
     100  	      __real__ retval = nanq ("");
     101  	      __imag__ retval = nanq ("");
     102  
     103  	      feraiseexcept (FE_INVALID);
     104  	    }
     105  	}
     106      }
     107    else if (rcls == QUADFP_INFINITE)
     108      {
     109        /* Real part is infinite.  */
     110        if (__glibc_likely (icls > QUADFP_ZERO))
     111  	{
     112  	  /* Imaginary part is finite.  */
     113  	  __float128 sinix, cosix;
     114  
     115  	  if (__glibc_likely (fabsq (__imag__ x) > FLT128_MIN))
     116  	    {
     117  	      sincosq (__imag__ x, &sinix, &cosix);
     118  	    }
     119  	  else
     120  	    {
     121  	      sinix = __imag__ x;
     122  	      cosix = 1;
     123  	    }
     124  
     125  	  __real__ retval = copysignq (HUGE_VALQ, cosix);
     126  	  __imag__ retval = copysignq (HUGE_VALQ, sinix);
     127  
     128  	  if (negate)
     129  	    __real__ retval = -__real__ retval;
     130  	}
     131        else if (icls == QUADFP_ZERO)
     132  	{
     133  	  /* Imaginary part is 0.0.  */
     134  	  __real__ retval = negate ? -HUGE_VALQ : HUGE_VALQ;
     135  	  __imag__ retval = __imag__ x;
     136  	}
     137        else
     138  	{
     139  	  __real__ retval = HUGE_VALQ;
     140  	  __imag__ retval = __imag__ x - __imag__ x;
     141  	}
     142      }
     143    else
     144      {
     145        __real__ retval = nanq ("");
     146        __imag__ retval = __imag__ x == 0 ? __imag__ x : nanq ("");
     147      }
     148  
     149    return retval;
     150  }