Module: CRMF

Defined in:
lib/crmf/version.rb,
ext/crmf/crmf.c

Constant Summary collapse

VERSION =

Returns CRMF gem version.

Returns:

  • (String) —

    CRMF gem version

'0.1.3'.freeze
LOG2_DOWN =

Returns ↓log(2)↓.

Returns:

  • (Float) —

    ↓log(2)↓

DBL2NUM(d)
LOG2_UP =

Returns ↑log(2)↑.

Returns:

  • (Float) —

    ↑log(2)↑

DBL2NUM(d)
PI_DOWN =

Returns ↓𝛑↓.

Returns:

DBL2NUM(d)
PI_UP =

Returns ↑𝛑↑.

Returns:

DBL2NUM(d)
EULER_DOWN =

Returns ↓euler↓.

Returns:

  • (Float) —

    ↓euler↓

DBL2NUM(d)
EULER_UP =

Returns ↑euler↑.

Returns:

  • (Float) —

    ↑euler↑

DBL2NUM(d)

Class Method Summary collapse

Class Method Details

.acos_rd(x) ⇒ Float 



1372
1373
1374
 
# File 'ext/crmf/crmf.c', line 1372

static VALUE crmf_acos_rd(VALUE self, VALUE x) {
	return DBL2NUM(acos_rd(NUM2DBL(x)));
}

.acos_rn(x) ⇒ Float 



1368
1369
1370
 
# File 'ext/crmf/crmf.c', line 1368

static VALUE crmf_acos_rn(VALUE self, VALUE x) {
	return DBL2NUM(acos_rn(NUM2DBL(x)));
}

.acos_ru(x) ⇒ Float 



1376
1377
1378
 
# File 'ext/crmf/crmf.c', line 1376

static VALUE crmf_acos_ru(VALUE self, VALUE x) {
	return DBL2NUM(acos_ru(NUM2DBL(x)));
}

.acos_rz(x) ⇒ Float 



1380
1381
1382
 
# File 'ext/crmf/crmf.c', line 1380

static VALUE crmf_acos_rz(VALUE self, VALUE x) {
	return DBL2NUM(acos_rz(NUM2DBL(x)));
}

.acosh_rd(x) ⇒ Float 



1478
 
# File 'ext/crmf/crmf.c', line 1478

static VALUE crmf_acosh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDD)}

.acosh_rn(x) ⇒ Float 



1480
 
# File 'ext/crmf/crmf.c', line 1480

static VALUE crmf_acosh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDN)}

.acosh_ru(x) ⇒ Float 



1479
 
# File 'ext/crmf/crmf.c', line 1479

static VALUE crmf_acosh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDU)}

.acosh_rz(x) ⇒ Float 



1477
 
# File 'ext/crmf/crmf.c', line 1477

static VALUE crmf_acosh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(acosh, MPFR_RNDZ)}

.add_rd(x, y) ⇒ Float 



1589
1590
1591
1592
1593
1594
1595
1596
1597
 
# File 'ext/crmf/crmf.c', line 1589

static VALUE crmf_add_rd(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_DOWNWARD);
	volatile double dr = dx + dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.add_rn(x, y) ⇒ Float 



1609
1610
1611
1612
1613
1614
1615
1616
 
# File 'ext/crmf/crmf.c', line 1609

static VALUE crmf_add_rn(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TONEAREST);
	volatile double dr = dx + dy;
	return DBL2NUM(dr);
}

.add_ru(x, y) ⇒ Float 



1599
1600
1601
1602
1603
1604
1605
1606
1607
 
# File 'ext/crmf/crmf.c', line 1599

static VALUE crmf_add_ru(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_UPWARD);
	volatile double dr = dx + dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.add_rz(x, y) ⇒ Float 



1579
1580
1581
1582
1583
1584
1585
1586
1587
 
# File 'ext/crmf/crmf.c', line 1579

static VALUE crmf_add_rz(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TOWARDZERO);
	volatile double dr = dx + dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.asin_rd(x) ⇒ Float 



1389
1390
1391
 
# File 'ext/crmf/crmf.c', line 1389

static VALUE crmf_asin_rd(VALUE self, VALUE x) {
	return DBL2NUM(asin_rd(NUM2DBL(x)));
}

.asin_rn(x) ⇒ Float 



1385
1386
1387
 
# File 'ext/crmf/crmf.c', line 1385

static VALUE crmf_asin_rn(VALUE self, VALUE x) {
	return DBL2NUM(asin_rn(NUM2DBL(x)));
}

.asin_ru(x) ⇒ Float 



1393
1394
1395
 
# File 'ext/crmf/crmf.c', line 1393

static VALUE crmf_asin_ru(VALUE self, VALUE x) {
	return DBL2NUM(asin_ru(NUM2DBL(x)));
}

.asin_rz(x) ⇒ Float 



1397
1398
1399
 
# File 'ext/crmf/crmf.c', line 1397

static VALUE crmf_asin_rz(VALUE self, VALUE x) {
	return DBL2NUM(asin_rz(NUM2DBL(x)));
}

.asinh_rd(x) ⇒ Float 



1483
 
# File 'ext/crmf/crmf.c', line 1483

static VALUE crmf_asinh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDD)}

.asinh_rn(x) ⇒ Float 



1485
 
# File 'ext/crmf/crmf.c', line 1485

static VALUE crmf_asinh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDN)}

.asinh_ru(x) ⇒ Float 



1484
 
# File 'ext/crmf/crmf.c', line 1484

static VALUE crmf_asinh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDU)}

.asinh_rz(x) ⇒ Float 



1482
 
# File 'ext/crmf/crmf.c', line 1482

static VALUE crmf_asinh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(asinh, MPFR_RNDZ)}

.atan2_rd(x, y) ⇒ Float 



1524
 
# File 'ext/crmf/crmf.c', line 1524

static VALUE crmf_atan2_rd(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDD)}

.atan2_rn(x, y) ⇒ Float 



1526
 
# File 'ext/crmf/crmf.c', line 1526

static VALUE crmf_atan2_rn(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDN)}

.atan2_ru(x, y) ⇒ Float 



1525
 
# File 'ext/crmf/crmf.c', line 1525

static VALUE crmf_atan2_ru(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDU)}

.atan2_rz(x, y) ⇒ Float 



1523
 
# File 'ext/crmf/crmf.c', line 1523

static VALUE crmf_atan2_rz(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDZ)}

.atan_rd(x) ⇒ Float 



1406
1407
1408
 
# File 'ext/crmf/crmf.c', line 1406

static VALUE crmf_atan_rd(VALUE self, VALUE x) {
	return DBL2NUM(atan_rd(NUM2DBL(x)));
}

.atan_rn(x) ⇒ Float 



1402
1403
1404
 
# File 'ext/crmf/crmf.c', line 1402

static VALUE crmf_atan_rn(VALUE self, VALUE x) {
	return DBL2NUM(atan_rn(NUM2DBL(x)));
}

.atan_ru(x) ⇒ Float 



1410
1411
1412
 
# File 'ext/crmf/crmf.c', line 1410

static VALUE crmf_atan_ru(VALUE self, VALUE x) {
	return DBL2NUM(atan_ru(NUM2DBL(x)));
}

.atan_rz(x) ⇒ Float 



1414
1415
1416
 
# File 'ext/crmf/crmf.c', line 1414

static VALUE crmf_atan_rz(VALUE self, VALUE x) {
	return DBL2NUM(atan_rz(NUM2DBL(x)));
}

.atanh_rd(x) ⇒ Float 



1488
 
# File 'ext/crmf/crmf.c', line 1488

static VALUE crmf_atanh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDD)}

.atanh_rn(x) ⇒ Float 



1490
 
# File 'ext/crmf/crmf.c', line 1490

static VALUE crmf_atanh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDN)}

.atanh_ru(x) ⇒ Float 



1489
 
# File 'ext/crmf/crmf.c', line 1489

static VALUE crmf_atanh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDU)}

.atanh_rz(x) ⇒ Float 



1487
 
# File 'ext/crmf/crmf.c', line 1487

static VALUE crmf_atanh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(atanh, MPFR_RNDZ)}

.cbrt_rd(x) ⇒ Float

Cubic root, rounded down



1500
 
# File 'ext/crmf/crmf.c', line 1500

static VALUE crmf_cbrt_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDD)}

.cbrt_rn(x) ⇒ Float

Cubic root, rounded toward nearest



1504
 
# File 'ext/crmf/crmf.c', line 1504

static VALUE crmf_cbrt_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDN)}

.cbrt_ru(x) ⇒ Float

Cubic root, rounded up



1502
 
# File 'ext/crmf/crmf.c', line 1502

static VALUE crmf_cbrt_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDU)}

.cbrt_rz(x) ⇒ Float

Cubic root, rounded toward zero.



1498
 
# File 'ext/crmf/crmf.c', line 1498

static VALUE crmf_cbrt_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(cbrt, MPFR_RNDZ)}

.cos_rd(x) ⇒ Float 



1321
1322
1323
 
# File 'ext/crmf/crmf.c', line 1321

static VALUE crmf_cos_rd(VALUE self, VALUE x) {
	return DBL2NUM(cos_rd(NUM2DBL(x)));
}

.cos_rn(x) ⇒ Float 



1317
1318
1319
 
# File 'ext/crmf/crmf.c', line 1317

static VALUE crmf_cos_rn(VALUE self, VALUE x) {
	return DBL2NUM(cos_rn(NUM2DBL(x)));
}

.cos_ru(x) ⇒ Float 



1325
1326
1327
 
# File 'ext/crmf/crmf.c', line 1325

static VALUE crmf_cos_ru(VALUE self, VALUE x) {
	return DBL2NUM(cos_ru(NUM2DBL(x)));
}

.cos_rz(x) ⇒ Float 



1329
1330
1331
 
# File 'ext/crmf/crmf.c', line 1329

static VALUE crmf_cos_rz(VALUE self, VALUE x) {
	return DBL2NUM(cos_rz(NUM2DBL(x)));
}

.cosh_rd(x) ⇒ Float 



1423
1424
1425
 
# File 'ext/crmf/crmf.c', line 1423

static VALUE crmf_cosh_rd(VALUE self, VALUE x) {
	return DBL2NUM(cosh_rd(NUM2DBL(x)));
}

.cosh_rn(x) ⇒ Float 



1419
1420
1421
 
# File 'ext/crmf/crmf.c', line 1419

static VALUE crmf_cosh_rn(VALUE self, VALUE x) {
	return DBL2NUM(cosh_rn(NUM2DBL(x)));
}

.cosh_ru(x) ⇒ Float 



1427
1428
1429
 
# File 'ext/crmf/crmf.c', line 1427

static VALUE crmf_cosh_ru(VALUE self, VALUE x) {
	return DBL2NUM(cosh_ru(NUM2DBL(x)));
}

.cosh_rz(x) ⇒ Float 



1431
1432
1433
 
# File 'ext/crmf/crmf.c', line 1431

static VALUE crmf_cosh_rz(VALUE self, VALUE x) {
	return DBL2NUM(cosh_rz(NUM2DBL(x)));
}

.div_rd(x, y) ⇒ Float 



1709
1710
1711
1712
1713
1714
1715
1716
1717
 
# File 'ext/crmf/crmf.c', line 1709

static VALUE crmf_div_rd(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_DOWNWARD);
	volatile double dr = dx / dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.div_rn(x, y) ⇒ Float 



1729
1730
1731
1732
1733
1734
1735
1736
 
# File 'ext/crmf/crmf.c', line 1729

static VALUE crmf_div_rn(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TONEAREST);
	volatile double dr = dx / dy;
	return DBL2NUM(dr);
}

.div_ru(x, y) ⇒ Float 



1719
1720
1721
1722
1723
1724
1725
1726
1727
 
# File 'ext/crmf/crmf.c', line 1719

static VALUE crmf_div_ru(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_UPWARD);
	volatile double dr = dx / dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.div_rz(x, y) ⇒ Float 



1699
1700
1701
1702
1703
1704
1705
1706
1707
 
# File 'ext/crmf/crmf.c', line 1699

static VALUE crmf_div_rz(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TOWARDZERO);
	volatile double dr = dx / dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.exp10_rd(x) ⇒ Float 



1468
 
# File 'ext/crmf/crmf.c', line 1468

static VALUE crmf_exp10_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDD)}

.exp10_rn(x) ⇒ Float 



1470
 
# File 'ext/crmf/crmf.c', line 1470

static VALUE crmf_exp10_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDN)}

.exp10_ru(x) ⇒ Float 



1469
 
# File 'ext/crmf/crmf.c', line 1469

static VALUE crmf_exp10_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDU)}

.exp10_rz(x) ⇒ Float 



1467
 
# File 'ext/crmf/crmf.c', line 1467

static VALUE crmf_exp10_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp10, MPFR_RNDZ)}

.exp2_rd(x) ⇒ Float 



1463
 
# File 'ext/crmf/crmf.c', line 1463

static VALUE crmf_exp2_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDD)}

.exp2_rn(x) ⇒ Float 



1465
 
# File 'ext/crmf/crmf.c', line 1465

static VALUE crmf_exp2_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDN)}

.exp2_ru(x) ⇒ Float 



1464
 
# File 'ext/crmf/crmf.c', line 1464

static VALUE crmf_exp2_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDU)}

.exp2_rz(x) ⇒ Float 



1462
 
# File 'ext/crmf/crmf.c', line 1462

static VALUE crmf_exp2_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(exp2, MPFR_RNDZ)}

.exp_rd(x) ⇒ Float 



1211
1212
1213
 
# File 'ext/crmf/crmf.c', line 1211

static VALUE crmf_exp_rd(VALUE self, VALUE x) {
	return DBL2NUM(exp_rd(NUM2DBL(x)));
}

.exp_rn(x) ⇒ Float 



1207
1208
1209
 
# File 'ext/crmf/crmf.c', line 1207

static VALUE crmf_exp_rn(VALUE self, VALUE x) {
	return DBL2NUM(exp_rn(NUM2DBL(x)));
}

.exp_ru(x) ⇒ Float 



1215
1216
1217
 
# File 'ext/crmf/crmf.c', line 1215

static VALUE crmf_exp_ru(VALUE self, VALUE x) {
	return DBL2NUM(exp_ru(NUM2DBL(x)));
}

.exp_rz(x) ⇒ Float 



1219
1220
1221
 
# File 'ext/crmf/crmf.c', line 1219

static VALUE crmf_exp_rz(VALUE self, VALUE x) {
	return DBL2NUM(exp_rz(NUM2DBL(x)));
}

.expm1_rd(x) ⇒ Float

Returns exp(x) - 1, rounded down



1281
1282
1283
 
# File 'ext/crmf/crmf.c', line 1281

static VALUE crmf_expm1_rd(VALUE self, VALUE x) {
	return DBL2NUM(expm1_rd(NUM2DBL(x)));
}

.expm1_rn(x) ⇒ Float

Returns exp(x) - 1, rounded to nearest



1276
1277
1278
 
# File 'ext/crmf/crmf.c', line 1276

static VALUE crmf_expm1_rn(VALUE self, VALUE x) {
	return DBL2NUM(expm1_rn(NUM2DBL(x)));
}

.expm1_ru(x) ⇒ Float

Returns exp(x) - 1, rounded up



1286
1287
1288
 
# File 'ext/crmf/crmf.c', line 1286

static VALUE crmf_expm1_ru(VALUE self, VALUE x) {
	return DBL2NUM(expm1_ru(NUM2DBL(x)));
}

.expm1_rz(x) ⇒ Float

Returns exp(x) - 1, rounded toward zero



1291
1292
1293
 
# File 'ext/crmf/crmf.c', line 1291

static VALUE crmf_expm1_rz(VALUE self, VALUE x) {
	return DBL2NUM(expm1_rz(NUM2DBL(x)));
}

.hypot_rd(x, y) ⇒ Float 



1529
 
# File 'ext/crmf/crmf.c', line 1529

static VALUE crmf_hypot_rd(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDD)}

.hypot_rn(x, y) ⇒ Float 



1531
 
# File 'ext/crmf/crmf.c', line 1531

static VALUE crmf_hypot_rn(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDN)}

.hypot_ru(x, y) ⇒ Float 



1530
 
# File 'ext/crmf/crmf.c', line 1530

static VALUE crmf_hypot_ru(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDU)}

.hypot_rz(x, y) ⇒ Float 



1528
 
# File 'ext/crmf/crmf.c', line 1528

static VALUE crmf_hypot_rz(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(y, x, atan2, MPFR_RNDZ)}

.log10_rd(x) ⇒ Float 



1262
1263
1264
 
# File 'ext/crmf/crmf.c', line 1262

static VALUE crmf_log10_rd(VALUE self, VALUE x) {
	return DBL2NUM(log10_rd(NUM2DBL(x)));
}

.log10_rn(x) ⇒ Float 



1258
1259
1260
 
# File 'ext/crmf/crmf.c', line 1258

static VALUE crmf_log10_rn(VALUE self, VALUE x) {
	return DBL2NUM(log10_rn(NUM2DBL(x)));
}

.log10_ru(x) ⇒ Float 



1266
1267
1268
 
# File 'ext/crmf/crmf.c', line 1266

static VALUE crmf_log10_ru(VALUE self, VALUE x) {
	return DBL2NUM(log10_ru(NUM2DBL(x)));
}

.log10_rz(x) ⇒ Float 



1270
1271
1272
 
# File 'ext/crmf/crmf.c', line 1270

static VALUE crmf_log10_rz(VALUE self, VALUE x) {
	return DBL2NUM(log10_rz(NUM2DBL(x)));
}

.log1p_rd(x) ⇒ Float

Returns log(x + 1), rounded down



1302
1303
1304
 
# File 'ext/crmf/crmf.c', line 1302

static VALUE crmf_log1p_rd(VALUE self, VALUE x) {
	return DBL2NUM(log1p_rd(NUM2DBL(x)));
}

.log1p_rn(x) ⇒ Float

Returns log(x + 1), rounded to nearest



1297
1298
1299
 
# File 'ext/crmf/crmf.c', line 1297

static VALUE crmf_log1p_rn(VALUE self, VALUE x) {
	return DBL2NUM(log1p_rn(NUM2DBL(x)));
}

.log1p_ru(x) ⇒ Float

Returns log(x + 1), rounded up



1307
1308
1309
 
# File 'ext/crmf/crmf.c', line 1307

static VALUE crmf_log1p_ru(VALUE self, VALUE x) {
	return DBL2NUM(log1p_ru(NUM2DBL(x)));
}

.log1p_rz(x) ⇒ Float

Returns log(x + 1), rounded toward zero



1312
1313
1314
 
# File 'ext/crmf/crmf.c', line 1312

static VALUE crmf_log1p_rz(VALUE self, VALUE x) {
	return DBL2NUM(log1p_rz(NUM2DBL(x)));
}

.log2_rd(x) ⇒ Float 



1245
1246
1247
 
# File 'ext/crmf/crmf.c', line 1245

static VALUE crmf_log2_rd(VALUE self, VALUE x) {
	return DBL2NUM(log2_rd(NUM2DBL(x)));
}

.log2_rn(x) ⇒ Float 



1241
1242
1243
 
# File 'ext/crmf/crmf.c', line 1241

static VALUE crmf_log2_rn(VALUE self, VALUE x) {
	return DBL2NUM(log2_rn(NUM2DBL(x)));
}

.log2_ru(x) ⇒ Float 



1249
1250
1251
 
# File 'ext/crmf/crmf.c', line 1249

static VALUE crmf_log2_ru(VALUE self, VALUE x) {
	return DBL2NUM(log2_ru(NUM2DBL(x)));
}

.log2_rz(x) ⇒ Float 



1253
1254
1255
 
# File 'ext/crmf/crmf.c', line 1253

static VALUE crmf_log2_rz(VALUE self, VALUE x) {
	return DBL2NUM(log2_rz(NUM2DBL(x)));
}

.log_rd(x) ⇒ Float 



1228
1229
1230
 
# File 'ext/crmf/crmf.c', line 1228

static VALUE crmf_log_rd(VALUE self, VALUE x) {
	return DBL2NUM(log_rd(NUM2DBL(x)));
}

.log_rn(x) ⇒ Float 



1224
1225
1226
 
# File 'ext/crmf/crmf.c', line 1224

static VALUE crmf_log_rn(VALUE self, VALUE x) {
	return DBL2NUM(log_rn(NUM2DBL(x)));
}

.log_ru(x) ⇒ Float 



1232
1233
1234
 
# File 'ext/crmf/crmf.c', line 1232

static VALUE crmf_log_ru(VALUE self, VALUE x) {
	return DBL2NUM(log_ru(NUM2DBL(x)));
}

.log_rz(x) ⇒ Float 



1236
1237
1238
 
# File 'ext/crmf/crmf.c', line 1236

static VALUE crmf_log_rz(VALUE self, VALUE x) {
	return DBL2NUM(log_rz(NUM2DBL(x)));
}

.mul_rd(x, y) ⇒ Float 



1669
1670
1671
1672
1673
1674
1675
1676
1677
 
# File 'ext/crmf/crmf.c', line 1669

static VALUE crmf_mul_rd(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_DOWNWARD);
	volatile double dr = dx * dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.mul_rn(x, y) ⇒ Float 



1689
1690
1691
1692
1693
1694
1695
1696
 
# File 'ext/crmf/crmf.c', line 1689

static VALUE crmf_mul_rn(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TONEAREST);
	volatile double dr = dx * dy;
	return DBL2NUM(dr);
}

.mul_ru(x, y) ⇒ Float 



1679
1680
1681
1682
1683
1684
1685
1686
1687
 
# File 'ext/crmf/crmf.c', line 1679

static VALUE crmf_mul_ru(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_UPWARD);
	volatile double dr = dx * dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.mul_rz(x, y) ⇒ Float 



1659
1660
1661
1662
1663
1664
1665
1666
1667
 
# File 'ext/crmf/crmf.c', line 1659

static VALUE crmf_mul_rz(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TOWARDZERO);
	volatile double dr = dx * dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.pow_rd(x, y) ⇒ Float 



1519
 
# File 'ext/crmf/crmf.c', line 1519

static VALUE crmf_pow_rd(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDD)}

.pow_rn(x, y) ⇒ Float 



1521
 
# File 'ext/crmf/crmf.c', line 1521

static VALUE crmf_pow_rn(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDN)}

.pow_ru(x, y) ⇒ Float 



1520
 
# File 'ext/crmf/crmf.c', line 1520

static VALUE crmf_pow_ru(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDU)}

.pow_rz(x, y) ⇒ Float 



1518
 
# File 'ext/crmf/crmf.c', line 1518

static VALUE crmf_pow_rz(VALUE self, VALUE x, VALUE y) {CRMF_MPFR_DYADIC(x, y, pow, MPFR_RNDZ)}

.pown_rd(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℤ



1550
 
# File 'ext/crmf/crmf.c', line 1550

static VALUE crmf_pown_rd(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDD)}

.pown_rn(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℤ



1558
 
# File 'ext/crmf/crmf.c', line 1558

static VALUE crmf_pown_rn(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDN)}

.pown_ru(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℤ



1554
 
# File 'ext/crmf/crmf.c', line 1554

static VALUE crmf_pown_ru(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDU)}

.pown_rz(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℤ



1546
 
# File 'ext/crmf/crmf.c', line 1546

static VALUE crmf_pown_rz(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2LONG(n), pow_si, MPFR_RNDZ)}

.rootn_rd(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℕ



1568
 
# File 'ext/crmf/crmf.c', line 1568

static VALUE crmf_rootn_rd(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDD)}

.rootn_rn(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℕ



1576
 
# File 'ext/crmf/crmf.c', line 1576

static VALUE crmf_rootn_rn(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDN)}

.rootn_ru(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℕ



1572
 
# File 'ext/crmf/crmf.c', line 1572

static VALUE crmf_rootn_ru(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDU)}

.rootn_rz(x, n) ⇒ Float

Parameters:

  • x (Float)
  • n (Integer) —

    n ∈ ℕ



1564
 
# File 'ext/crmf/crmf.c', line 1564

static VALUE crmf_rootn_rz(VALUE self, VALUE x, VALUE n) {CRMF_MPFR_DYADIC_INTEGER(x, NUM2ULONG(n), pow_si, MPFR_RNDZ)}

.sin_rd(x) ⇒ Float 



1338
1339
1340
 
# File 'ext/crmf/crmf.c', line 1338

static VALUE crmf_sin_rd(VALUE self, VALUE x) {
	return DBL2NUM(sin_rd(NUM2DBL(x)));
}

.sin_rn(x) ⇒ Float 



1334
1335
1336
 
# File 'ext/crmf/crmf.c', line 1334

static VALUE crmf_sin_rn(VALUE self, VALUE x) {
	return DBL2NUM(sin_rn(NUM2DBL(x)));
}

.sin_ru(x) ⇒ Float 



1342
1343
1344
 
# File 'ext/crmf/crmf.c', line 1342

static VALUE crmf_sin_ru(VALUE self, VALUE x) {
	return DBL2NUM(sin_ru(NUM2DBL(x)));
}

.sin_rz(x) ⇒ Float 



1346
1347
1348
 
# File 'ext/crmf/crmf.c', line 1346

static VALUE crmf_sin_rz(VALUE self, VALUE x) {
	return DBL2NUM(sin_rz(NUM2DBL(x)));
}

.sinh_rd(x) ⇒ Float 



1440
1441
1442
 
# File 'ext/crmf/crmf.c', line 1440

static VALUE crmf_sinh_rd(VALUE self, VALUE x) {
	return DBL2NUM(sinh_rd(NUM2DBL(x)));
}

.sinh_rn(x) ⇒ Float 



1436
1437
1438
 
# File 'ext/crmf/crmf.c', line 1436

static VALUE crmf_sinh_rn(VALUE self, VALUE x) {
	return DBL2NUM(sinh_rn(NUM2DBL(x)));
}

.sinh_ru(x) ⇒ Float 



1444
1445
1446
 
# File 'ext/crmf/crmf.c', line 1444

static VALUE crmf_sinh_ru(VALUE self, VALUE x) {
	return DBL2NUM(sinh_ru(NUM2DBL(x)));
}

.sinh_rz(x) ⇒ Float 



1448
1449
1450
 
# File 'ext/crmf/crmf.c', line 1448

static VALUE crmf_sinh_rz(VALUE self, VALUE x) {
	return DBL2NUM(sinh_rz(NUM2DBL(x)));
}

.sqrt_rd(x) ⇒ Float 



1493
 
# File 'ext/crmf/crmf.c', line 1493

static VALUE crmf_sqrt_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDD)}

.sqrt_rn(x) ⇒ Float 



1495
 
# File 'ext/crmf/crmf.c', line 1495

static VALUE crmf_sqrt_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDN)}

.sqrt_ru(x) ⇒ Float 



1494
 
# File 'ext/crmf/crmf.c', line 1494

static VALUE crmf_sqrt_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDU)}

.sqrt_rz(x) ⇒ Float 



1492
 
# File 'ext/crmf/crmf.c', line 1492

static VALUE crmf_sqrt_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(sqrt, MPFR_RNDZ)}

.sub_rd(x, y) ⇒ Float 



1629
1630
1631
1632
1633
1634
1635
1636
1637
 
# File 'ext/crmf/crmf.c', line 1629

static VALUE crmf_sub_rd(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_DOWNWARD);
	volatile double dr = dx - dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.sub_rn(x, y) ⇒ Float 



1649
1650
1651
1652
1653
1654
1655
1656
 
# File 'ext/crmf/crmf.c', line 1649

static VALUE crmf_sub_rn(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TONEAREST);
	volatile double dr = dx - dy;
	return DBL2NUM(dr);
}

.sub_ru(x, y) ⇒ Float 



1639
1640
1641
1642
1643
1644
1645
1646
1647
 
# File 'ext/crmf/crmf.c', line 1639

static VALUE crmf_sub_ru(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_UPWARD);
	volatile double dr = dx - dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.sub_rz(x, y) ⇒ Float 



1619
1620
1621
1622
1623
1624
1625
1626
1627
 
# File 'ext/crmf/crmf.c', line 1619

static VALUE crmf_sub_rz(VALUE self, VALUE x, VALUE y)
{
	double dx = NUM2DBL(x);
	double dy = NUM2DBL(y);
	fesetround(FE_TOWARDZERO);
	volatile double dr = dx - dy;
	fesetround(FE_TONEAREST);
	return DBL2NUM(dr);
}

.tan_rd(x) ⇒ Float 



1355
1356
1357
 
# File 'ext/crmf/crmf.c', line 1355

static VALUE crmf_tan_rd(VALUE self, VALUE x) {
	return DBL2NUM(tan_rd(NUM2DBL(x)));
}

.tan_rn(x) ⇒ Float 



1351
1352
1353
 
# File 'ext/crmf/crmf.c', line 1351

static VALUE crmf_tan_rn(VALUE self, VALUE x) {
	return DBL2NUM(tan_rn(NUM2DBL(x)));
}

.tan_ru(x) ⇒ Float 



1359
1360
1361
 
# File 'ext/crmf/crmf.c', line 1359

static VALUE crmf_tan_ru(VALUE self, VALUE x) {
	return DBL2NUM(tan_ru(NUM2DBL(x)));
}

.tan_rz(x) ⇒ Float 



1363
1364
1365
 
# File 'ext/crmf/crmf.c', line 1363

static VALUE crmf_tan_rz(VALUE self, VALUE x) {
	return DBL2NUM(tan_rz(NUM2DBL(x)));
}

.tanh_rd(x) ⇒ Float 



1473
 
# File 'ext/crmf/crmf.c', line 1473

static VALUE crmf_tanh_rd(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDD)}

.tanh_rn(x) ⇒ Float 



1475
 
# File 'ext/crmf/crmf.c', line 1475

static VALUE crmf_tanh_rn(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDN)}

.tanh_ru(x) ⇒ Float 



1474
 
# File 'ext/crmf/crmf.c', line 1474

static VALUE crmf_tanh_ru(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDU)}

.tanh_rz(x) ⇒ Float 



1472
 
# File 'ext/crmf/crmf.c', line 1472

static VALUE crmf_tanh_rz(VALUE self, VALUE x) {CRMF_MPFR_MONADIC(tanh, MPFR_RNDZ)}

.to_float(obj, rnd = :nearest) ⇒ Float

Convert obj to a Float, rounding according to rnd.

Parameters:

  • obj (Float, Integer, String, #to_f) —

    object to convert

  • rnd (Symbol) (defaults to: :nearest) —

    :nearest, :down, :up, :zero or :away

Returns:



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'ext/crmf/crmf.c', line 214

static VALUE crmf_object_to_float(int argc, VALUE *argv, VALUE self)
{
	VALUE obj = Qnil, rnd = Qnil;
	mpfr_rnd_t rndt = MPFR_RNDN;
	rb_scan_args(argc, argv, "11", &obj, &rnd);
	if (rnd != Qnil)
		rndt = crmf_sym_to_rnd(rnd);
	MPFR_DECL_INIT(mpfra, 53);
	int type = rb_type(obj);
	int t = 0;
	if (type == RUBY_T_FLOAT) {
		printf("RUBY_T_FLOAT\n");
		double d = NUM2DBL(obj);
		t = mpfr_set_d(mpfra, d, rndt);
	}
	else if (type == RUBY_T_FIXNUM) {
		printf("RUBY_T_FIXNUM\n");
		long int li = NUM2LL(obj);
		t = mpfr_set_si(mpfra, li, rndt);
	}
	else if (type == RUBY_T_BIGNUM) {
		printf("RUBY_T_BIGNUM\n");
		obj = rb_funcallv(obj, id_to_s, 0, NULL);
		const char *strptr = StringValuePtr(obj);
		t = mpfr_set_str(mpfra, strptr, 10, rndt);
	}
	else if (type == RUBY_T_STRING) {
		printf("RUBY_T_STRING\n");
		const char *strptr = StringValuePtr(obj);
		t = mpfr_set_str(mpfra, strptr, 10, rndt);
	}
	else {
		obj = rb_funcallv(obj, id_to_f, 0, NULL);
		double d = NUM2DBL(obj);
		t = mpfr_set_d(mpfra, d, rndt);
	}
	mpfr_subnormalize(mpfra, t, rndt);
	double d = mpfr_get_d(mpfra, rndt);
	return DBL2NUM(d);
}