Module: Math

Defined in:
math.c

Defined Under Namespace

Classes: DomainError

Constant Summary

PI =

Definition of the mathematical constant PI as a Float number.

DBL2NUM(atan(1.0)*4.0)
E =

Definition of the mathematical constant E (e) as a Float number.

DBL2NUM(exp(1.0))

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.acos(x) ⇒ Float

Computes the arc cosine of x. Returns 0..PI.

Domain: [-1, 1]

Codomain: [0, PI]

Math.acos(0) == Math::PI/2  #=> true

Returns:



169
170
171
172
173
174
175
176
177
178
# File 'math.c', line 169

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < -1.0 || 1.0 < d) domain_error("acos");
    return DBL2NUM(acos(d));
}

.acosh(x) ⇒ Float

Computes the inverse hyperbolic cosine of x.

Domain: [1, INFINITY)

Codomain: [0, INFINITY)

Math.acosh(1) #=> 0.0

Returns:



321
322
323
324
325
326
327
328
329
330
# File 'math.c', line 321

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < 1.0) domain_error("acosh");
    return DBL2NUM(acosh(d));
}

.asin(x) ⇒ Float

Computes the arc sine of x. Returns -PI/2..PI/2.

Domain: [-1, -1]

Codomain: [-PI/2, PI/2]

Math.asin(1) == Math::PI/2  #=> true

Returns:



193
194
195
196
197
198
199
200
201
202
# File 'math.c', line 193

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < -1.0 || 1.0 < d) domain_error("asin");
    return DBL2NUM(asin(d));
}

.asinh(x) ⇒ Float

Computes the inverse hyperbolic sine of x.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.asinh(1) #=> 0.881373587019543

Returns:



346
347
348
349
350
# File 'math.c', line 346

static VALUE
math_asinh(VALUE obj, VALUE x)
{
    return DBL2NUM(asinh(Get_Double(x)));
}

.atan(x) ⇒ Float

Computes the arc tangent of x. Returns -PI/2..PI/2.

Domain: (-INFINITY, INFINITY)

Codomain: (-PI/2, PI/2)

Math.atan(0) #=> 0.0

Returns:



217
218
219
220
221
# File 'math.c', line 217

static VALUE
math_atan(VALUE obj, VALUE x)
{
    return DBL2NUM(atan(Get_Double(x)));
}

.atan2(y, x) ⇒ Float

Computes the arc tangent given y and x. Returns a Float in the range -PI..PI. Return value is a angle in radians between the positive x-axis of cartesian plane and the point given by the coordinates (x, y) on it.

Domain: (-INFINITY, INFINITY)

Codomain: [-PI, PI]

Math.atan2(-0.0, -1.0) #=> -3.141592653589793
Math.atan2(-1.0, -1.0) #=> -2.356194490192345
Math.atan2(-1.0, 0.0)  #=> -1.5707963267948966
Math.atan2(-1.0, 1.0)  #=> -0.7853981633974483
Math.atan2(-0.0, 1.0)  #=> -0.0
Math.atan2(0.0, 1.0)   #=> 0.0
Math.atan2(1.0, 1.0)   #=> 0.7853981633974483
Math.atan2(1.0, 0.0)   #=> 1.5707963267948966
Math.atan2(1.0, -1.0)  #=> 2.356194490192345
Math.atan2(0.0, -1.0)  #=> 3.141592653589793
Math.atan2(INFINITY, INFINITY)   #=> 0.7853981633974483
Math.atan2(INFINITY, -INFINITY)  #=> 2.356194490192345
Math.atan2(-INFINITY, INFINITY)  #=> -0.7853981633974483
Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345

Returns:



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# File 'math.c', line 62

static VALUE
math_atan2(VALUE obj, VALUE y, VALUE x)
{
    double dx, dy;
    dx = Get_Double(x);
    dy = Get_Double(y);
    if (dx == 0.0 && dy == 0.0) {
	if (!signbit(dx))
	    return DBL2NUM(dy);
        if (!signbit(dy))
	    return DBL2NUM(M_PI);
	return DBL2NUM(-M_PI);
    }
#ifndef ATAN2_INF_C99
    if (isinf(dx) && isinf(dy)) {
	/* optimization for FLONUM */
	if (dx < 0.0) {
	    const double dz = (3.0 * M_PI / 4.0);
	    return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz);
	}
	else {
	    const double dz = (M_PI / 4.0);
	    return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz);
	}
    }
#endif
    return DBL2NUM(atan2(dy, dx));
}

.atanh(x) ⇒ Float

Computes the inverse hyperbolic tangent of x.

Domain: (-1, 1)

Codomain: (-INFINITY, INFINITY)

Math.atanh(1) #=> Infinity

Returns:



366
367
368
369
370
371
372
373
374
375
376
377
378
# File 'math.c', line 366

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

    d = Get_Double(x);
    /* check for domain error */
    if (d <  -1.0 || +1.0 <  d) domain_error("atanh");
    /* check for pole error */
    if (d == -1.0) return DBL2NUM(-INFINITY);
    if (d == +1.0) return DBL2NUM(+INFINITY);
    return DBL2NUM(atanh(d));
}

.cbrt(x) ⇒ Float

Returns the cube root of x.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

-9.upto(9) {|x|
  p [x, Math.cbrt(x), Math.cbrt(x)**3]
}
#=> [-9, -2.0800838230519, -9.0]
#   [-8, -2.0, -8.0]
#   [-7, -1.91293118277239, -7.0]
#   [-6, -1.81712059283214, -6.0]
#   [-5, -1.7099759466767, -5.0]
#   [-4, -1.5874010519682, -4.0]
#   [-3, -1.44224957030741, -3.0]
#   [-2, -1.25992104989487, -2.0]
#   [-1, -1.0, -1.0]
#   [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.25992104989487, 2.0]
#   [3, 1.44224957030741, 3.0]
#   [4, 1.5874010519682, 4.0]
#   [5, 1.7099759466767, 5.0]
#   [6, 1.81712059283214, 6.0]
#   [7, 1.91293118277239, 7.0]
#   [8, 2.0, 8.0]
#   [9, 2.0800838230519, 9.0]

Returns:



638
639
640
641
642
# File 'math.c', line 638

static VALUE
math_cbrt(VALUE obj, VALUE x)
{
    return DBL2NUM(cbrt(Get_Double(x)));
}

.cos(x) ⇒ Float

Computes the cosine of x (expressed in radians). Returns a Float in the range -1.0..1.0.

Domain: (-INFINITY, INFINITY)

Codomain: [-1, 1]

Math.cos(Math::PI) #=> -1.0

Returns:



107
108
109
110
111
# File 'math.c', line 107

static VALUE
math_cos(VALUE obj, VALUE x)
{
    return DBL2NUM(cos(Get_Double(x)));
}

.cosh(x) ⇒ Float

Computes the hyperbolic cosine of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: [1, INFINITY)

Math.cosh(0) #=> 1.0

Returns:



245
246
247
248
249
# File 'math.c', line 245

static VALUE
math_cosh(VALUE obj, VALUE x)
{
    return DBL2NUM(cosh(Get_Double(x)));
}

.erf(x) ⇒ Float

Calculates the error function of x.

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

  Math.erf(0) #=> 0.0

Returns:



711
712
713
714
715
# File 'math.c', line 711

static VALUE
math_erf(VALUE obj, VALUE x)
{
    return DBL2NUM(erf(Get_Double(x)));
}

.erfc(x) ⇒ Float

Calculates the complementary error function of x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, 2)

  Math.erfc(0) #=> 1.0

Returns:



731
732
733
734
735
# File 'math.c', line 731

static VALUE
math_erfc(VALUE obj, VALUE x)
{
    return DBL2NUM(erfc(Get_Double(x)));
}

.exp(x) ⇒ Float

Returns e**x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, INFINITY)

Math.exp(0)       #=> 1.0
Math.exp(1)       #=> 2.718281828459045
Math.exp(1.5)     #=> 4.4816890703380645

Returns:



396
397
398
399
400
# File 'math.c', line 396

static VALUE
math_exp(VALUE obj, VALUE x)
{
    return DBL2NUM(exp(Get_Double(x)));
}

.frexp(x) ⇒ Array

Returns a two-element array containing the normalized fraction (a Float) and exponent (a Fixnum) of x.

fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
fraction * 2**exponent                  #=> 1234.0

Returns:



655
656
657
658
659
660
661
662
663
# File 'math.c', line 655

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

    d = frexp(Get_Double(x), &exp);
    return rb_assoc_new(DBL2NUM(d), INT2NUM(exp));
}

.gamma(x) ⇒ Float

Calculates the gamma function of x.

Note that gamma(n) is same as fact(n-1) for integer n > 0.
However gamma(n) returns float and can be an approximation.

 def fact(n) (1..n).inject(1) {|r,i| r*i } end
 1.upto(26) {|i| p [i, Math.gamma(i), fact(i-1)] }
 #=> [1, 1.0, 1]
 #   [2, 1.0, 1]
 #   [3, 2.0, 2]
 #   [4, 6.0, 6]
 #   [5, 24.0, 24]
 #   [6, 120.0, 120]
 #   [7, 720.0, 720]
 #   [8, 5040.0, 5040]
 #   [9, 40320.0, 40320]
 #   [10, 362880.0, 362880]
 #   [11, 3628800.0, 3628800]
 #   [12, 39916800.0, 39916800]
 #   [13, 479001600.0, 479001600]
 #   [14, 6227020800.0, 6227020800]
 #   [15, 87178291200.0, 87178291200]
 #   [16, 1307674368000.0, 1307674368000]
 #   [17, 20922789888000.0, 20922789888000]
 #   [18, 355687428096000.0, 355687428096000]
 #   [19, 6.402373705728e+15, 6402373705728000]
 #   [20, 1.21645100408832e+17, 121645100408832000]
 #   [21, 2.43290200817664e+18, 2432902008176640000]
 #   [22, 5.109094217170944e+19, 51090942171709440000]
 #   [23, 1.1240007277776077e+21, 1124000727777607680000]
 #   [24, 2.5852016738885062e+22, 25852016738884976640000]
 #   [25, 6.204484017332391e+23, 620448401733239439360000]
 #   [26, 1.5511210043330954e+25, 15511210043330985984000000]

Returns:



809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
# File 'math.c', line 809

static VALUE
math_gamma(VALUE obj, VALUE x)
{
    static const double fact_table[] = {
        /* fact(0) */ 1.0,
        /* fact(1) */ 1.0,
        /* fact(2) */ 2.0,
        /* fact(3) */ 6.0,
        /* fact(4) */ 24.0,
        /* fact(5) */ 120.0,
        /* fact(6) */ 720.0,
        /* fact(7) */ 5040.0,
        /* fact(8) */ 40320.0,
        /* fact(9) */ 362880.0,
        /* fact(10) */ 3628800.0,
        /* fact(11) */ 39916800.0,
        /* fact(12) */ 479001600.0,
        /* fact(13) */ 6227020800.0,
        /* fact(14) */ 87178291200.0,
        /* fact(15) */ 1307674368000.0,
        /* fact(16) */ 20922789888000.0,
        /* fact(17) */ 355687428096000.0,
        /* fact(18) */ 6402373705728000.0,
        /* fact(19) */ 121645100408832000.0,
        /* fact(20) */ 2432902008176640000.0,
        /* fact(21) */ 51090942171709440000.0,
        /* fact(22) */ 1124000727777607680000.0,
        /* fact(23)=25852016738884976640000 needs 56bit mantissa which is
         * impossible to represent exactly in IEEE 754 double which have
         * 53bit mantissa. */
    };
    enum {NFACT_TABLE = numberof(fact_table)};
    double d;
    d = Get_Double(x);
    /* check for domain error */
    if (isinf(d) && signbit(d)) domain_error("gamma");
    if (d == floor(d)) {
	if (d < 0.0) domain_error("gamma");
	if (1.0 <= d && d <= (double)NFACT_TABLE) {
	    return DBL2NUM(fact_table[(int)d - 1]);
	}
    }
    return DBL2NUM(tgamma(d));
}

.hypot(x, y) ⇒ Float

Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides x and y.

Math.hypot(3, 4)   #=> 5.0

Returns:



691
692
693
694
695
# File 'math.c', line 691

static VALUE
math_hypot(VALUE obj, VALUE x, VALUE y)
{
    return DBL2NUM(hypot(Get_Double(x), Get_Double(y)));
}

.ldexp(fraction, exponent) ⇒ Float

Returns the value of fraction*(2**exponent).

fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent)   #=> 1234.0

Returns:



675
676
677
678
679
# File 'math.c', line 675

static VALUE
math_ldexp(VALUE obj, VALUE x, VALUE n)
{
    return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n)));
}

.lgamma(x) ⇒ Array, ...

Calculates the logarithmic gamma of x and the sign of gamma of x.

Math.lgamma(x) is same as
 [Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]
but avoid overflow by Math.gamma(x) for large x.

  Math.lgamma(0) #=> [Infinity, 1]

Returns ]

Returns:



868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
# File 'math.c', line 868

static VALUE
math_lgamma(VALUE obj, VALUE x)
{
    double d;
    int sign=1;
    VALUE v;
    d = Get_Double(x);
    /* check for domain error */
    if (isinf(d)) {
	if (signbit(d)) domain_error("lgamma");
	return rb_assoc_new(DBL2NUM(INFINITY), INT2FIX(1));
    }
    v = DBL2NUM(lgamma_r(d, &sign));
    return rb_assoc_new(v, INT2FIX(sign));
}

.log(x) ⇒ Float .log(x, base) ⇒ Float

Returns the logarithm of x. If additional second argument is given, it will be the base of logarithm. Otherwise it is e (for the natural logarithm).

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.log(0)          #=> -Infinity
Math.log(1)          #=> 0.0
Math.log(Math::E)    #=> 1.0
Math.log(Math::E**3) #=> 3.0
Math.log(12, 3)      #=> 2.2618595071429146

Overloads:



434
435
436
437
438
439
440
441
442
443
444
445
446
# File 'math.c', line 434

static VALUE
math_log(int argc, const VALUE *argv, VALUE obj)
{
    VALUE x, base;
    double d;

    rb_scan_args(argc, argv, "11", &x, &base);
    d = math_log1(x);
    if (argc == 2) {
	d /= math_log1(base);
    }
    return DBL2NUM(d);
}

.log10(x) ⇒ Float

Returns the base 10 logarithm of x.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.log10(1)       #=> 0.0
Math.log10(10)      #=> 1.0
Math.log10(10**100) #=> 100.0

Returns:



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
# File 'math.c', line 541

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

    if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) &&
            DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) {
        numbits -= DBL_MANT_DIG;
        x = rb_big_rshift(x, SIZET2NUM(numbits));
    }
    else {
	numbits = 0;
    }

    d = Get_Double(x);
    /* check for domain error */
    if (d < 0.0) domain_error("log10");
    /* check for pole error */
    if (d == 0.0) return DBL2NUM(-INFINITY);

    return DBL2NUM(log10(d) + numbits * log10(2)); /* log10(d * 2 ** numbits) */
}

.log2(x) ⇒ Float

Returns the base 2 logarithm of x.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.log2(1)      #=> 0.0
Math.log2(2)      #=> 1.0
Math.log2(32768)  #=> 15.0
Math.log2(65536)  #=> 16.0

Returns:



501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
# File 'math.c', line 501

static VALUE
math_log2(VALUE obj, VALUE x)
{
    double d;
    size_t numbits;

    if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) &&
            DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) {
        numbits -= DBL_MANT_DIG;
        x = rb_big_rshift(x, SIZET2NUM(numbits));
    }
    else {
	numbits = 0;
    }

    d = Get_Double(x);
    /* check for domain error */
    if (d < 0.0) domain_error("log2");
    /* check for pole error */
    if (d == 0.0) return DBL2NUM(-INFINITY);

    return DBL2NUM(log2(d) + numbits); /* log2(d * 2 ** numbits) */
}

.sin(x) ⇒ Float

Computes the sine of x (expressed in radians). Returns a Float in the range -1.0..1.0.

Domain: (-INFINITY, INFINITY)

Codomain: [-1, 1]

Math.sin(Math::PI/2) #=> 1.0

Returns:



128
129
130
131
132
# File 'math.c', line 128

static VALUE
math_sin(VALUE obj, VALUE x)
{
    return DBL2NUM(sin(Get_Double(x)));
}

.sinh(x) ⇒ Float

Computes the hyperbolic sine of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.sinh(0) #=> 0.0

Returns:



273
274
275
276
277
# File 'math.c', line 273

static VALUE
math_sinh(VALUE obj, VALUE x)
{
    return DBL2NUM(sinh(Get_Double(x)));
}

.sqrt(x) ⇒ Float

Returns the non-negative square root of x.

Domain: [0, INFINITY)

Codomain:[0, INFINITY)

0.upto(10) {|x|
  p [x, Math.sqrt(x), Math.sqrt(x)**2]
}
#=> [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.4142135623731, 2.0]
#   [3, 1.73205080756888, 3.0]
#   [4, 2.0, 4.0]
#   [5, 2.23606797749979, 5.0]
#   [6, 2.44948974278318, 6.0]
#   [7, 2.64575131106459, 7.0]
#   [8, 2.82842712474619, 8.0]
#   [9, 3.0, 9.0]
#   [10, 3.16227766016838, 10.0]

Returns:



591
592
593
594
595
596
597
598
599
600
601
# File 'math.c', line 591

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < 0.0) domain_error("sqrt");
    if (d == 0.0) return DBL2NUM(0.0);
    return DBL2NUM(sqrt(d));
}

.tan(x) ⇒ Float

Computes the tangent of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.tan(0) #=> 0.0

Returns:



149
150
151
152
153
# File 'math.c', line 149

static VALUE
math_tan(VALUE obj, VALUE x)
{
    return DBL2NUM(tan(Get_Double(x)));
}

.tanh(x) ⇒ Float

Computes the hyperbolic tangent of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

Math.tanh(0) #=> 0.0

Returns:



301
302
303
304
305
# File 'math.c', line 301

static VALUE
math_tanh(VALUE obj, VALUE x)
{
    return DBL2NUM(tanh(Get_Double(x)));
}

Instance Method Details

#acos(x) ⇒ Float (private)

Computes the arc cosine of x. Returns 0..PI.

Domain: [-1, 1]

Codomain: [0, PI]

Math.acos(0) == Math::PI/2  #=> true

Returns:



169
170
171
172
173
174
175
176
177
178
# File 'math.c', line 169

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < -1.0 || 1.0 < d) domain_error("acos");
    return DBL2NUM(acos(d));
}

#acosh(x) ⇒ Float (private)

Computes the inverse hyperbolic cosine of x.

Domain: [1, INFINITY)

Codomain: [0, INFINITY)

Math.acosh(1) #=> 0.0

Returns:



321
322
323
324
325
326
327
328
329
330
# File 'math.c', line 321

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < 1.0) domain_error("acosh");
    return DBL2NUM(acosh(d));
}

#asin(x) ⇒ Float (private)

Computes the arc sine of x. Returns -PI/2..PI/2.

Domain: [-1, -1]

Codomain: [-PI/2, PI/2]

Math.asin(1) == Math::PI/2  #=> true

Returns:



193
194
195
196
197
198
199
200
201
202
# File 'math.c', line 193

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < -1.0 || 1.0 < d) domain_error("asin");
    return DBL2NUM(asin(d));
}

#asinh(x) ⇒ Float (private)

Computes the inverse hyperbolic sine of x.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.asinh(1) #=> 0.881373587019543

Returns:



346
347
348
349
350
# File 'math.c', line 346

static VALUE
math_asinh(VALUE obj, VALUE x)
{
    return DBL2NUM(asinh(Get_Double(x)));
}

#atan(x) ⇒ Float (private)

Computes the arc tangent of x. Returns -PI/2..PI/2.

Domain: (-INFINITY, INFINITY)

Codomain: (-PI/2, PI/2)

Math.atan(0) #=> 0.0

Returns:



217
218
219
220
221
# File 'math.c', line 217

static VALUE
math_atan(VALUE obj, VALUE x)
{
    return DBL2NUM(atan(Get_Double(x)));
}

#atan2(y, x) ⇒ Float (private)

Computes the arc tangent given y and x. Returns a Float in the range -PI..PI. Return value is a angle in radians between the positive x-axis of cartesian plane and the point given by the coordinates (x, y) on it.

Domain: (-INFINITY, INFINITY)

Codomain: [-PI, PI]

Math.atan2(-0.0, -1.0) #=> -3.141592653589793
Math.atan2(-1.0, -1.0) #=> -2.356194490192345
Math.atan2(-1.0, 0.0)  #=> -1.5707963267948966
Math.atan2(-1.0, 1.0)  #=> -0.7853981633974483
Math.atan2(-0.0, 1.0)  #=> -0.0
Math.atan2(0.0, 1.0)   #=> 0.0
Math.atan2(1.0, 1.0)   #=> 0.7853981633974483
Math.atan2(1.0, 0.0)   #=> 1.5707963267948966
Math.atan2(1.0, -1.0)  #=> 2.356194490192345
Math.atan2(0.0, -1.0)  #=> 3.141592653589793
Math.atan2(INFINITY, INFINITY)   #=> 0.7853981633974483
Math.atan2(INFINITY, -INFINITY)  #=> 2.356194490192345
Math.atan2(-INFINITY, INFINITY)  #=> -0.7853981633974483
Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345

Returns:



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# File 'math.c', line 62

static VALUE
math_atan2(VALUE obj, VALUE y, VALUE x)
{
    double dx, dy;
    dx = Get_Double(x);
    dy = Get_Double(y);
    if (dx == 0.0 && dy == 0.0) {
	if (!signbit(dx))
	    return DBL2NUM(dy);
        if (!signbit(dy))
	    return DBL2NUM(M_PI);
	return DBL2NUM(-M_PI);
    }
#ifndef ATAN2_INF_C99
    if (isinf(dx) && isinf(dy)) {
	/* optimization for FLONUM */
	if (dx < 0.0) {
	    const double dz = (3.0 * M_PI / 4.0);
	    return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz);
	}
	else {
	    const double dz = (M_PI / 4.0);
	    return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz);
	}
    }
#endif
    return DBL2NUM(atan2(dy, dx));
}

#atanh(x) ⇒ Float (private)

Computes the inverse hyperbolic tangent of x.

Domain: (-1, 1)

Codomain: (-INFINITY, INFINITY)

Math.atanh(1) #=> Infinity

Returns:



366
367
368
369
370
371
372
373
374
375
376
377
378
# File 'math.c', line 366

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

    d = Get_Double(x);
    /* check for domain error */
    if (d <  -1.0 || +1.0 <  d) domain_error("atanh");
    /* check for pole error */
    if (d == -1.0) return DBL2NUM(-INFINITY);
    if (d == +1.0) return DBL2NUM(+INFINITY);
    return DBL2NUM(atanh(d));
}

#cbrt(x) ⇒ Float (private)

Returns the cube root of x.

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

-9.upto(9) {|x|
  p [x, Math.cbrt(x), Math.cbrt(x)**3]
}
#=> [-9, -2.0800838230519, -9.0]
#   [-8, -2.0, -8.0]
#   [-7, -1.91293118277239, -7.0]
#   [-6, -1.81712059283214, -6.0]
#   [-5, -1.7099759466767, -5.0]
#   [-4, -1.5874010519682, -4.0]
#   [-3, -1.44224957030741, -3.0]
#   [-2, -1.25992104989487, -2.0]
#   [-1, -1.0, -1.0]
#   [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.25992104989487, 2.0]
#   [3, 1.44224957030741, 3.0]
#   [4, 1.5874010519682, 4.0]
#   [5, 1.7099759466767, 5.0]
#   [6, 1.81712059283214, 6.0]
#   [7, 1.91293118277239, 7.0]
#   [8, 2.0, 8.0]
#   [9, 2.0800838230519, 9.0]

Returns:



638
639
640
641
642
# File 'math.c', line 638

static VALUE
math_cbrt(VALUE obj, VALUE x)
{
    return DBL2NUM(cbrt(Get_Double(x)));
}

#cos(x) ⇒ Float (private)

Computes the cosine of x (expressed in radians). Returns a Float in the range -1.0..1.0.

Domain: (-INFINITY, INFINITY)

Codomain: [-1, 1]

Math.cos(Math::PI) #=> -1.0

Returns:



107
108
109
110
111
# File 'math.c', line 107

static VALUE
math_cos(VALUE obj, VALUE x)
{
    return DBL2NUM(cos(Get_Double(x)));
}

#cosh(x) ⇒ Float (private)

Computes the hyperbolic cosine of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: [1, INFINITY)

Math.cosh(0) #=> 1.0

Returns:



245
246
247
248
249
# File 'math.c', line 245

static VALUE
math_cosh(VALUE obj, VALUE x)
{
    return DBL2NUM(cosh(Get_Double(x)));
}

#erf(x) ⇒ Float (private)

Calculates the error function of x.

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

  Math.erf(0) #=> 0.0

Returns:



711
712
713
714
715
# File 'math.c', line 711

static VALUE
math_erf(VALUE obj, VALUE x)
{
    return DBL2NUM(erf(Get_Double(x)));
}

#erfc(x) ⇒ Float (private)

Calculates the complementary error function of x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, 2)

  Math.erfc(0) #=> 1.0

Returns:



731
732
733
734
735
# File 'math.c', line 731

static VALUE
math_erfc(VALUE obj, VALUE x)
{
    return DBL2NUM(erfc(Get_Double(x)));
}

#exp(x) ⇒ Float (private)

Returns e**x.

Domain: (-INFINITY, INFINITY)

Codomain: (0, INFINITY)

Math.exp(0)       #=> 1.0
Math.exp(1)       #=> 2.718281828459045
Math.exp(1.5)     #=> 4.4816890703380645

Returns:



396
397
398
399
400
# File 'math.c', line 396

static VALUE
math_exp(VALUE obj, VALUE x)
{
    return DBL2NUM(exp(Get_Double(x)));
}

#frexp(x) ⇒ Array (private)

Returns a two-element array containing the normalized fraction (a Float) and exponent (a Fixnum) of x.

fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
fraction * 2**exponent                  #=> 1234.0

Returns:



655
656
657
658
659
660
661
662
663
# File 'math.c', line 655

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

    d = frexp(Get_Double(x), &exp);
    return rb_assoc_new(DBL2NUM(d), INT2NUM(exp));
}

#gamma(x) ⇒ Float (private)

Calculates the gamma function of x.

Note that gamma(n) is same as fact(n-1) for integer n > 0.
However gamma(n) returns float and can be an approximation.

 def fact(n) (1..n).inject(1) {|r,i| r*i } end
 1.upto(26) {|i| p [i, Math.gamma(i), fact(i-1)] }
 #=> [1, 1.0, 1]
 #   [2, 1.0, 1]
 #   [3, 2.0, 2]
 #   [4, 6.0, 6]
 #   [5, 24.0, 24]
 #   [6, 120.0, 120]
 #   [7, 720.0, 720]
 #   [8, 5040.0, 5040]
 #   [9, 40320.0, 40320]
 #   [10, 362880.0, 362880]
 #   [11, 3628800.0, 3628800]
 #   [12, 39916800.0, 39916800]
 #   [13, 479001600.0, 479001600]
 #   [14, 6227020800.0, 6227020800]
 #   [15, 87178291200.0, 87178291200]
 #   [16, 1307674368000.0, 1307674368000]
 #   [17, 20922789888000.0, 20922789888000]
 #   [18, 355687428096000.0, 355687428096000]
 #   [19, 6.402373705728e+15, 6402373705728000]
 #   [20, 1.21645100408832e+17, 121645100408832000]
 #   [21, 2.43290200817664e+18, 2432902008176640000]
 #   [22, 5.109094217170944e+19, 51090942171709440000]
 #   [23, 1.1240007277776077e+21, 1124000727777607680000]
 #   [24, 2.5852016738885062e+22, 25852016738884976640000]
 #   [25, 6.204484017332391e+23, 620448401733239439360000]
 #   [26, 1.5511210043330954e+25, 15511210043330985984000000]

Returns:



809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
# File 'math.c', line 809

static VALUE
math_gamma(VALUE obj, VALUE x)
{
    static const double fact_table[] = {
        /* fact(0) */ 1.0,
        /* fact(1) */ 1.0,
        /* fact(2) */ 2.0,
        /* fact(3) */ 6.0,
        /* fact(4) */ 24.0,
        /* fact(5) */ 120.0,
        /* fact(6) */ 720.0,
        /* fact(7) */ 5040.0,
        /* fact(8) */ 40320.0,
        /* fact(9) */ 362880.0,
        /* fact(10) */ 3628800.0,
        /* fact(11) */ 39916800.0,
        /* fact(12) */ 479001600.0,
        /* fact(13) */ 6227020800.0,
        /* fact(14) */ 87178291200.0,
        /* fact(15) */ 1307674368000.0,
        /* fact(16) */ 20922789888000.0,
        /* fact(17) */ 355687428096000.0,
        /* fact(18) */ 6402373705728000.0,
        /* fact(19) */ 121645100408832000.0,
        /* fact(20) */ 2432902008176640000.0,
        /* fact(21) */ 51090942171709440000.0,
        /* fact(22) */ 1124000727777607680000.0,
        /* fact(23)=25852016738884976640000 needs 56bit mantissa which is
         * impossible to represent exactly in IEEE 754 double which have
         * 53bit mantissa. */
    };
    enum {NFACT_TABLE = numberof(fact_table)};
    double d;
    d = Get_Double(x);
    /* check for domain error */
    if (isinf(d) && signbit(d)) domain_error("gamma");
    if (d == floor(d)) {
	if (d < 0.0) domain_error("gamma");
	if (1.0 <= d && d <= (double)NFACT_TABLE) {
	    return DBL2NUM(fact_table[(int)d - 1]);
	}
    }
    return DBL2NUM(tgamma(d));
}

#hypot(x, y) ⇒ Float (private)

Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides x and y.

Math.hypot(3, 4)   #=> 5.0

Returns:



691
692
693
694
695
# File 'math.c', line 691

static VALUE
math_hypot(VALUE obj, VALUE x, VALUE y)
{
    return DBL2NUM(hypot(Get_Double(x), Get_Double(y)));
}

#ldexp(fraction, exponent) ⇒ Float (private)

Returns the value of fraction*(2**exponent).

fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent)   #=> 1234.0

Returns:



675
676
677
678
679
# File 'math.c', line 675

static VALUE
math_ldexp(VALUE obj, VALUE x, VALUE n)
{
    return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n)));
}

#lgamma(x) ⇒ Array, ... (private)

Calculates the logarithmic gamma of x and the sign of gamma of x.

Math.lgamma(x) is same as
 [Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]
but avoid overflow by Math.gamma(x) for large x.

  Math.lgamma(0) #=> [Infinity, 1]

Returns ]

Returns:



868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
# File 'math.c', line 868

static VALUE
math_lgamma(VALUE obj, VALUE x)
{
    double d;
    int sign=1;
    VALUE v;
    d = Get_Double(x);
    /* check for domain error */
    if (isinf(d)) {
	if (signbit(d)) domain_error("lgamma");
	return rb_assoc_new(DBL2NUM(INFINITY), INT2FIX(1));
    }
    v = DBL2NUM(lgamma_r(d, &sign));
    return rb_assoc_new(v, INT2FIX(sign));
}

#log(x) ⇒ Float (private) #log(x, base) ⇒ Float (private)

Returns the logarithm of x. If additional second argument is given, it will be the base of logarithm. Otherwise it is e (for the natural logarithm).

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.log(0)          #=> -Infinity
Math.log(1)          #=> 0.0
Math.log(Math::E)    #=> 1.0
Math.log(Math::E**3) #=> 3.0
Math.log(12, 3)      #=> 2.2618595071429146

Overloads:



434
435
436
437
438
439
440
441
442
443
444
445
446
# File 'math.c', line 434

static VALUE
math_log(int argc, const VALUE *argv, VALUE obj)
{
    VALUE x, base;
    double d;

    rb_scan_args(argc, argv, "11", &x, &base);
    d = math_log1(x);
    if (argc == 2) {
	d /= math_log1(base);
    }
    return DBL2NUM(d);
}

#log10(x) ⇒ Float (private)

Returns the base 10 logarithm of x.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.log10(1)       #=> 0.0
Math.log10(10)      #=> 1.0
Math.log10(10**100) #=> 100.0

Returns:



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
# File 'math.c', line 541

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

    if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) &&
            DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) {
        numbits -= DBL_MANT_DIG;
        x = rb_big_rshift(x, SIZET2NUM(numbits));
    }
    else {
	numbits = 0;
    }

    d = Get_Double(x);
    /* check for domain error */
    if (d < 0.0) domain_error("log10");
    /* check for pole error */
    if (d == 0.0) return DBL2NUM(-INFINITY);

    return DBL2NUM(log10(d) + numbits * log10(2)); /* log10(d * 2 ** numbits) */
}

#log2(x) ⇒ Float (private)

Returns the base 2 logarithm of x.

Domain: (0, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.log2(1)      #=> 0.0
Math.log2(2)      #=> 1.0
Math.log2(32768)  #=> 15.0
Math.log2(65536)  #=> 16.0

Returns:



501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
# File 'math.c', line 501

static VALUE
math_log2(VALUE obj, VALUE x)
{
    double d;
    size_t numbits;

    if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) &&
            DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) {
        numbits -= DBL_MANT_DIG;
        x = rb_big_rshift(x, SIZET2NUM(numbits));
    }
    else {
	numbits = 0;
    }

    d = Get_Double(x);
    /* check for domain error */
    if (d < 0.0) domain_error("log2");
    /* check for pole error */
    if (d == 0.0) return DBL2NUM(-INFINITY);

    return DBL2NUM(log2(d) + numbits); /* log2(d * 2 ** numbits) */
}

#sin(x) ⇒ Float (private)

Computes the sine of x (expressed in radians). Returns a Float in the range -1.0..1.0.

Domain: (-INFINITY, INFINITY)

Codomain: [-1, 1]

Math.sin(Math::PI/2) #=> 1.0

Returns:



128
129
130
131
132
# File 'math.c', line 128

static VALUE
math_sin(VALUE obj, VALUE x)
{
    return DBL2NUM(sin(Get_Double(x)));
}

#sinh(x) ⇒ Float (private)

Computes the hyperbolic sine of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.sinh(0) #=> 0.0

Returns:



273
274
275
276
277
# File 'math.c', line 273

static VALUE
math_sinh(VALUE obj, VALUE x)
{
    return DBL2NUM(sinh(Get_Double(x)));
}

#sqrt(x) ⇒ Float (private)

Returns the non-negative square root of x.

Domain: [0, INFINITY)

Codomain:[0, INFINITY)

0.upto(10) {|x|
  p [x, Math.sqrt(x), Math.sqrt(x)**2]
}
#=> [0, 0.0, 0.0]
#   [1, 1.0, 1.0]
#   [2, 1.4142135623731, 2.0]
#   [3, 1.73205080756888, 3.0]
#   [4, 2.0, 4.0]
#   [5, 2.23606797749979, 5.0]
#   [6, 2.44948974278318, 6.0]
#   [7, 2.64575131106459, 7.0]
#   [8, 2.82842712474619, 8.0]
#   [9, 3.0, 9.0]
#   [10, 3.16227766016838, 10.0]

Returns:



591
592
593
594
595
596
597
598
599
600
601
# File 'math.c', line 591

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

    d = Get_Double(x);
    /* check for domain error */
    if (d < 0.0) domain_error("sqrt");
    if (d == 0.0) return DBL2NUM(0.0);
    return DBL2NUM(sqrt(d));
}

#tan(x) ⇒ Float (private)

Computes the tangent of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-INFINITY, INFINITY)

Math.tan(0) #=> 0.0

Returns:



149
150
151
152
153
# File 'math.c', line 149

static VALUE
math_tan(VALUE obj, VALUE x)
{
    return DBL2NUM(tan(Get_Double(x)));
}

#tanh(x) ⇒ Float (private)

Computes the hyperbolic tangent of x (expressed in radians).

Domain: (-INFINITY, INFINITY)

Codomain: (-1, 1)

Math.tanh(0) #=> 0.0

Returns:



301
302
303
304
305
# File 'math.c', line 301

static VALUE
math_tanh(VALUE obj, VALUE x)
{
    return DBL2NUM(tanh(Get_Double(x)));
}