/*
 *  call-seq:
 *     Math.acos(x)    => float
 *  
 *  Computes the arc cosine of <i>x</i>. Returns 0..PI.
 */

static VALUE
math_acos(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = acos(RFLOAT(x)->value);
    domain_check(d, "acos");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.acosh(x)    => float
 *  
 *  Computes the inverse hyperbolic cosine of <i>x</i>.
 */

static VALUE
math_acosh(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = acosh(RFLOAT(x)->value);
    domain_check(d, "acosh");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.asin(x)    => float
 *  
 *  Computes the arc sine of <i>x</i>. Returns 0..PI.
 */

static VALUE
math_asin(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = asin(RFLOAT(x)->value);
    domain_check(d, "asin");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.asinh(x)    => float
 *  
 *  Computes the inverse hyperbolic sine of <i>x</i>.
 */

static VALUE
math_asinh(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(asinh(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.atan(x)    => float
 *  
 *  Computes the arc tangent of <i>x</i>. Returns -{PI/2} .. {PI/2}.
 */

static VALUE
math_atan(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(atan(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.atan2(y, x)  => float
 *  
 *  Computes the arc tangent given <i>y</i> and <i>x</i>. Returns
 *  -PI..PI.
 *     
 */

static VALUE
math_atan2(obj, y, x)
    VALUE obj, x, y;
{
    Need_Float2(y, x);
    return rb_float_new(atan2(RFLOAT(y)->value, RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.atanh(x)    => float
 *  
 *  Computes the inverse hyperbolic tangent of <i>x</i>.
 */

static VALUE
math_atanh(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = atanh(RFLOAT(x)->value);
    domain_check(d, "atanh");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.cos(x)    => float
 *  
 *  Computes the cosine of <i>x</i> (expressed in radians). Returns
 *  -1..1.
 */

static VALUE
math_cos(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(cos(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.cosh(x)    => float
 *  
 *  Computes the hyperbolic cosine of <i>x</i> (expressed in radians).
 */

static VALUE
math_cosh(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    
    return rb_float_new(cosh(RFLOAT(x)->value));
}

/*
 * call-seq:
 *    Math.erf(x)  => float
 *
 *  Calculates the error function of x.
 */

static VALUE
math_erf(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(erf(RFLOAT(x)->value));
}

/*
 * call-seq:
 *    Math.erfc(x)  => float
 *
 *  Calculates the complementary error function of x.
 */

static VALUE
math_erfc(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(erfc(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.exp(x)    => float
 *  
 *  Returns e**x.
 */

static VALUE
math_exp(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(exp(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.frexp(numeric)    => [ fraction, exponent ]
 *  
 *  Returns a two-element array containing the normalized fraction (a
 *  <code>Float</code>) and exponent (a <code>Fixnum</code>) of
 *  <i>numeric</i>.
 *     
 *     fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
 *     fraction * 2**exponent                  #=> 1234.0
 */

static VALUE
math_frexp(obj, x)
    VALUE obj, x;
{
    double d;
    int exp;

    Need_Float(x);
    
    d = frexp(RFLOAT(x)->value, &exp);
    return rb_assoc_new(rb_float_new(d), INT2NUM(exp));
}

/*
 *  call-seq:
 *     Math.hypot(x, y)    => float
 *  
 *  Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle
 *  with sides <i>x</i> and <i>y</i>.
 *     
 *     Math.hypot(3, 4)   #=> 5.0
 */

static VALUE
math_hypot(obj, x, y)
    VALUE obj, x, y;
{
    Need_Float2(x, y);
    return rb_float_new(hypot(RFLOAT(x)->value, RFLOAT(y)->value));
}

/*
 *  call-seq:
 *     Math.ldexp(flt, int) -> float
 *  
 *  Returns the value of <i>flt</i>*(2**<i>int</i>).
 *     
 *     fraction, exponent = Math.frexp(1234)
 *     Math.ldexp(fraction, exponent)   #=> 1234.0
 */

static VALUE
math_ldexp(obj, x, n)
    VALUE obj, x, n;
{
    Need_Float(x);
    return rb_float_new(ldexp(RFLOAT(x)->value, NUM2INT(n)));
}

/*
 *  call-seq:
 *     Math.log(numeric)    => float
 *  
 *  Returns the natural logarithm of <i>numeric</i>.
 */

static VALUE
math_log(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = log(RFLOAT(x)->value);
    domain_check(d, "log");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.log10(numeric)    => float
 *  
 *  Returns the base 10 logarithm of <i>numeric</i>.
 */

static VALUE
math_log10(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = log10(RFLOAT(x)->value);
    domain_check(d, "log10");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.sin(x)    => float
 *  
 *  Computes the sine of <i>x</i> (expressed in radians). Returns
 *  -1..1.
 */

static VALUE
math_sin(obj, x)
    VALUE obj, x;
{
    Need_Float(x);

    return rb_float_new(sin(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.sinh(x)    => float
 *  
 *  Computes the hyperbolic sine of <i>x</i> (expressed in
 *  radians).
 */

static VALUE
math_sinh(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(sinh(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.sqrt(numeric)    => float
 *  
 *  Returns the non-negative square root of <i>numeric</i>.
 */

static VALUE
math_sqrt(obj, x)
    VALUE obj, x;
{
    double d;

    Need_Float(x);
    errno = 0;
    d = sqrt(RFLOAT(x)->value);
    domain_check(d, "sqrt");
    return rb_float_new(d);
}

/*
 *  call-seq:
 *     Math.tan(x)    => float
 *  
 *  Returns the tangent of <i>x</i> (expressed in radians).
 */

static VALUE
math_tan(obj, x)
    VALUE obj, x;
{
    Need_Float(x);

    return rb_float_new(tan(RFLOAT(x)->value));
}

/*
 *  call-seq:
 *     Math.tanh()    => float
 *  
 *  Computes the hyperbolic tangent of <i>x</i> (expressed in
 *  radians).
 */

static VALUE
math_tanh(obj, x)
    VALUE obj, x;
{
    Need_Float(x);
    return rb_float_new(tanh(RFLOAT(x)->value));
}

     # File lib/complex.rb, line 534
534:   def acos(z)
535:     if Complex.generic?(z) and z >= -1 and z <= 1
536:       acos!(z)
537:     else
538:       -1.0.im * log( z + 1.0.im * sqrt(1.0-z*z) )
539:     end
540:   end

     # File lib/complex.rb, line 566
566:   def acosh(z)
567:     if Complex.generic?(z) and z >= 1
568:       acosh!(z)
569:     else
570:       log( z + sqrt(z*z-1.0) )
571:     end
572:   end

     # File lib/complex.rb, line 542
542:   def asin(z)
543:     if Complex.generic?(z) and z >= -1 and z <= 1
544:       asin!(z)
545:     else
546:       -1.0.im * log( 1.0.im * z + sqrt(1.0-z*z) )
547:     end
548:   end

     # File lib/complex.rb, line 574
574:   def asinh(z)
575:     if Complex.generic?(z)
576:       asinh!(z)
577:     else
578:       log( z + sqrt(1.0+z*z) )
579:     end
580:   end

     # File lib/complex.rb, line 550
550:   def atan(z)
551:     if Complex.generic?(z)
552:       atan!(z)
553:     else
554:       1.0.im * log( (1.0.im+z) / (1.0.im-z) ) / 2.0
555:     end
556:   end

     # File lib/complex.rb, line 558
558:   def atan2(y,x)
559:     if Complex.generic?(y) and Complex.generic?(x)
560:       atan2!(y,x)
561:     else
562:       -1.0.im * log( (x+1.0.im*y) / sqrt(x*x+y*y) )
563:     end
564:   end

     # File lib/complex.rb, line 582
582:   def atanh(z)
583:     if Complex.generic?(z) and z >= -1 and z <= 1
584:       atanh!(z)
585:     else
586:       log( (1.0+z) / (1.0-z) ) / 2.0
587:     end
588:   end

     # File lib/complex.rb, line 463
463:   def cos(z)
464:     if Complex.generic?(z)
465:       cos!(z)
466:     else
467:       Complex(cos!(z.real)*cosh!(z.image),
468:               -sin!(z.real)*sinh!(z.image))
469:     end
470:   end

     # File lib/complex.rb, line 499
499:   def cosh(z)
500:     if Complex.generic?(z)
501:       cosh!(z)
502:     else
503:       Complex( cosh!(z.real)*cos!(z.image), sinh!(z.real)*sin!(z.image) )
504:     end
505:   end

     # File lib/complex.rb, line 454
454:   def exp(z)
455:     if Complex.generic?(z)
456:       exp!(z)
457:     else
458:       Complex(exp!(z.real) * cos!(z.image), exp!(z.real) * sin!(z.image))
459:     end
460:   end

     # File lib/complex.rb, line 516
516:   def log(z)
517:     if Complex.generic?(z) and z >= 0
518:       log!(z)
519:     else
520:       r, theta = z.polar
521:       Complex(log!(r.abs), theta)
522:     end
523:   end

     # File lib/complex.rb, line 526
526:   def log10(z)
527:     if Complex.generic?(z)
528:       log10!(z)
529:     else
530:       log(z)/log!(10)
531:     end
532:   end

     # File lib/mathn.rb, line 256
256:   def rsqrt(a)
257:     if a.kind_of?(Float)
258:       sqrt!(a)
259:     elsif a.kind_of?(Rational)
260:       rsqrt(a.numerator)/rsqrt(a.denominator)
261:     else
262:       src = a
263:       max = 2 ** 32
264:       byte_a = [src & 0xffffffff]
265:       # ruby's bug
266:       while (src >= max) and (src >>= 32)
267:         byte_a.unshift src & 0xffffffff
268:       end
269:       
270:       answer = 0
271:       main = 0
272:       side = 0
273:       for elm in byte_a
274:         main = (main << 32) + elm
275:         side <<= 16
276:         if answer != 0
277:           if main * 4  < side * side
278:             applo = main.div(side)
279:           else 
280:             applo = ((sqrt!(side * side + 4 * main) - side)/2.0).to_i + 1
281:           end
282:         else
283:           applo = sqrt!(main).to_i + 1
284:         end
285:         
286:         while (x = (side + applo) * applo) > main
287:           applo -= 1
288:         end
289:         main -= x
290:         answer = (answer << 16) + applo
291:         side += applo * 2
292:       end
293:       if main == 0
294:         answer
295:       else
296:         sqrt!(a)
297:       end
298:     end
299:   end

     # File lib/complex.rb, line 473
473:   def sin(z)
474:     if Complex.generic?(z)
475:       sin!(z)
476:     else
477:       Complex(sin!(z.real)*cosh!(z.image),
478:               cos!(z.real)*sinh!(z.image))
479:     end
480:   end

     # File lib/complex.rb, line 491
491:   def sinh(z)
492:     if Complex.generic?(z)
493:       sinh!(z)
494:     else
495:       Complex( sinh!(z.real)*cos!(z.image), cosh!(z.real)*sin!(z.image) )
496:     end
497:   end

     # File lib/complex.rb, line 435
435:   def sqrt(z)
436:     if Complex.generic?(z)
437:       if z >= 0
438:         sqrt!(z)
439:       else
440:         Complex(0,sqrt!(-z))
441:       end
442:     else
443:       if z.image < 0
444:         sqrt(z.conjugate).conjugate
445:       else
446:         r = z.abs
447:         x = z.real
448:         Complex( sqrt!((r+x)/2), sqrt!((r-x)/2) )
449:       end
450:     end
451:   end

     # File lib/mathn.rb, line 233
233:   def sqrt(a)
234:     if a.kind_of?(Complex)
235:       abs = sqrt(a.real*a.real + a.image*a.image)
236: #      if not abs.kind_of?(Rational)
237: #       return a**Rational(1,2)
238: #      end
239:       x = sqrt((a.real + abs)/Rational(2))
240:       y = sqrt((-a.real + abs)/Rational(2))
241: #      if !(x.kind_of?(Rational) and y.kind_of?(Rational))
242: #       return a**Rational(1,2)
243: #      end
244:       if a.image >= 0 
245:         Complex(x, y)
246:       else
247:         Complex(x, -y)
248:       end
249:     elsif a >= 0
250:       rsqrt(a)
251:     else
252:       Complex(0,rsqrt(-a))
253:     end
254:   end

     # File lib/complex.rb, line 483
483:   def tan(z)
484:     if Complex.generic?(z)
485:       tan!(z)
486:     else
487:       sin(z)/cos(z)
488:     end
489:   end

     # File lib/complex.rb, line 507
507:   def tanh(z)
508:     if Complex.generic?(z)
509:       tanh!(z)
510:     else
511:       sinh(z)/cosh(z)
512:     end
513:   end