Description Usage Arguments Details Value Author(s) References See Also Examples

View source: R/as.R View source: R/as.R

Create multiple (i.e. typically *high*) precision numbers, to be
used in arithmetic and mathematical computations with **R**.

1 2 3 4 5 6 7 |

`x` |
a |

`precBits, prec` |
a number, the maximal precision to be used, in
`53` corresponds to double precision.
Must be at least 2. If `missing` ,
`getPrec(x)` determines a default precision. |

`base` |
(only when |

`rnd.mode` |
a 1-letter string specifying how |

`scientific` |
(used only when |

`name` |
a string specifying the mpfrlib - internal constant
computation. |

`...` |
potentially further arguments passed to and from methods. |

The `"mpfr"`

method of `mpfr()`

is a simple
wrapper around `roundMpfr()`

.

MPFR supports the following rounding modes,

- GMP_RND
**N**: round to

**n**earest (roundTiesToEven in IEEE 754-2008).- GMP_RND
**Z**: round toward

**z**ero (roundTowardZero in IEEE 754-2008).- GMP_RND
**U**: round toward plus infinity (“Up”, roundTowardPositive in IEEE 754-2008).

- GMP_RND
**D**: round toward minus infinity (“Down”, roundTowardNegative in IEEE 754-2008).

- GMP_RND
**A**: round

**a**way from zero (new since MPFR 3.0.0).

The ‘round to nearest’ (`"N"`

) mode, the default here,
works as in the IEEE 754 standard: in case the number to be rounded
lies exactly in the middle of two representable numbers, it is rounded
to the one with the least significant bit set to zero. For example,
the number 5/2, which is represented by (10.1) in binary, is rounded
to (10.0)=2 with a precision of two bits, and not to (11.0)=3. This
rule avoids the "drift" phenomenon mentioned by Knuth in volume 2 of
The Art of Computer Programming (Section 4.2.2).

When `x`

is `character`

, `mpfr()`

will detect the precision of the input object.

an object of (S4) class `mpfr`

, or for
`mpfr(x)`

when `x`

is an array,
`mpfrMatrix`

, or `mpfrArray`

which the user should just as a normal numeric vector or array.

Martin Maechler

The MPFR team. (201x).
*GNU MPFR – The Multiple Precision Floating-Point Reliable
Library*; see http://www.mpfr.org/mpfr-current/#doc or directly
http://www.mpfr.org/mpfr-current/mpfr.pdf.

The class documentation `mpfr`

contains more
details. Use `asNumeric`

to transform back to double
precision ("`numeric`

").

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | ```
mpfr(pi, 120) ## the double-precision pi "translated" to 120-bit precision
pi. <- Const("pi", prec = 260) # pi "computed" to correct 260-bit precision
pi. # nicely prints 80 digits [260 * log10(2) ~= 78.3 ~ 80]
Const("gamma", 128L) # 0.5772...
Const("catalan", 128L) # 0.9159...
x <- mpfr(0:7, 100)/7 # a more precise version of k/7, k=0,..,7
x
1 / x
## character input :
mpfr("2.718281828459045235360287471352662497757") - exp(mpfr(1, 150))
## ~= -4 * 10^-40
## Also works for NA, NaN, ... :
cx <- c("1234567890123456", 345, "NA", "NaN", "Inf", "-Inf")
mpfr(cx)
## with some 'base' choices :
print(mpfr("111.1111", base=2)) * 2^4
mpfr("af21.01020300a0b0c", base=16)
## 68 bit prec. 44833.00393694653820642
mpfr("ugi0", base = 32) == 10^6 ## TRUE
## --- Large integers from package 'gmp':
Z <- as.bigz(7)^(1:200)
head(Z, 40)
## mfpr(Z) by default chooses the correct *maximal* default precision:
mZ. <- mpfr(Z)
## more efficiently chooses precision individually
m.Z <- mpfr(Z, precBits = frexpZ(Z)$exp)
## the precBits chosen are large enough to keep full precision:
stopifnot(identical(cZ <- as.character(Z),
as(mZ.,"character")),
identical(cZ, as(m.Z,"character")))
## compare mpfr-arithmetic with exact rational one:
stopifnot(all.equal(mpfr(as.bigq(355,113), 99),
mpfr(355, 99) / 113, tol = 2^-98))
## look at different "rounding modes":
sapply(c("N", "D","U","Z","A"), function(RND)
mpfr(c(-1,1)/5, 20, rnd.mode = RND), simplify=FALSE)
symnum(sapply(c("N", "D","U","Z","A"),
function(RND) mpfr(0.2, prec = 5:15, rnd.mode = RND) < 0.2 ))
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.