{"Type":"Package","Package":"lazyNumbers","Title":"Exact Floating-Point Arithmetic","Version":"1.2.1","Authors@R":"person(\"Stéphane\", \"Laurent\", , \"laurent_step@outlook.fr\", role = c(\"aut\", \"cre\"))","Maintainer":"Stéphane Laurent ","Description":"Provides a new type of numbers called the lazy numbers.\nArithmetic on lazy numbers is exact, contrary to ordinary\nfloating-point arithmetic. The lazy numbers are implemented in 'C++'\nwith the 'CGAL' library ().","License":"GPL-3","URL":"https://github.com/stla/lazyNumbers","BugReports":"https://github.com/stla/lazyNumbers/issues","Imports":"methods, Rcpp (>= 1.0.9), stats","LinkingTo":"BH, Rcpp, RcppCGAL, RcppEigen","Encoding":"UTF-8","RoxygenNote":"7.2.2","SystemRequirements":"C++ 17, gmp, mpfr","Collate":"'classes.R' 'Arith.R' 'Compare.R' 'Concat.R' 'Extract.R'\n'Math.R' 'RcppExports.R' 'Summary.R' 'Transpose.R' 'aaa.R'\n'lazyMatrices.R' 'lazyNumbers.R'","Suggests":"testthat (>= 3.0.0)","Config/testthat/edition":"3","NeedsCompilation":"yes","Packaged":"2022-11-21 15:29:23 UTC; stla","Author":"Stéphane Laurent [aut, cre]","Repository":"CRAN","Date/Publication":"2022-11-21 21:50:06 UTC","repoType":"cran","tarballUrl":"ftp://cran.r-project.org/pub/R/src/contrib/lazyNumbers_1.2.1.tar.gz","jsonAuthors":[{"name":"Stéphane Laurent","email":"laurent_step@outlook.fr","maintainer":true}],"readme":"lazyNumbers: exact floating-point arithmetic\n================\n\n\n\n[![R-CMD-check](https://github.com/stla/lazyNumbers/actions/workflows/R-CMD-check.yaml/badge.svg)](https://github.com/stla/lazyNumbers/actions/workflows/R-CMD-check.yaml)\n[![R-CMD-check-valgrind](https://github.com/stla/lazyNumbers/actions/workflows/R-CMD-check-valgrind.yaml/badge.svg)](https://github.com/stla/lazyNumbers/actions/workflows/R-CMD-check-valgrind.yaml)\n\n\nIt is well-known that floating-point arithmetic is inexact even with\nsome simple operations. For example:\n\n``` r\n1 - 7*0.1 == 0.3\n## [1] FALSE\n```\n\nThis package provides the *lazy numbers*, which allow exact\nfloating-point arithmetic. These numbers do *not* solve the above issue:\n\n``` r\nlibrary(lazyNumbers)\nx <- lazynb(1) - lazynb(7)*lazynb(0.1)\nas.double(x) == 0.3\n## [1] FALSE\n```\n\nActually one can equivalent define `x` by, shorter, `1 - lazynb(7)*0.1`.\n\nThe above equality does not hold true because `0.1` and `0.3` as double\nnumbers do not exactly represent the true numbers `0.1` and `0.3`:\n\n``` r\nprint(0.3, digits = 17L)\n## [1] 0.29999999999999999\n```\n\nWhole numbers are exactly represented. The following equality is true:\n\n``` r\nx <- 1 - lazynb(7)/10\nas.double(x) == 0.3\n## [1] TRUE\n```\n\nIt is also possible to compare lazy numbers between them:\n\n``` r\ny <- lazynb(3)/lazynb(10)\nx == y\n## [1] TRUE\n```\n\nAnd one can get a thin interval containing the exact value:\n\n``` r\nprint(intervals(x), digits = 17L)\n## $inf\n## [1] 0.29999999999999999\n## \n## $sup\n## [1] 0.30000000000000004\n```\n\nHere is a more concrete example illustrating the benefits of the lazy\nnumbers. Consider the following recursive sequence:\n\n``` r\nu <- function(n) {\n if(n == 1) {\n return(1/7)\n }\n 8 * u(n-1) - 1\n}\n```\n\nIt is clear that all terms of this sequence equal `1/7` (approx.\n`0.1428571`). However this sequence becomes crazy as `n` increases:\n\n``` r\nu(15)\n## [1] 0.1428223\nu(18)\n## [1] 0.125\nu(20)\n## [1] -1\nu(30)\n## [1] -1227133513\n```\n\nThis is not the case of its lazy version:\n\n``` r\nu <- function(n) {\n if(n == 1) {\n return(1/lazynb(7))\n }\n 8 * u(n-1) - 1\n}\nas.double(u(30))\n## [1] 0.1428571\n```\n\nVectors of lazy numbers and matrices of lazy numbers are implemented. It\nis possible to get the determinant and the inverse of a square lazy\nmatrix:\n\n``` r\nset.seed(314159L)\n# non-lazy:\nM <- matrix(rnorm(9L), nrow = 3L, ncol = 3L)\ninvM <- solve(M)\nM %*% invM == diag(3L)\n## [,1] [,2] [,3]\n## [1,] FALSE TRUE FALSE\n## [2,] FALSE TRUE FALSE\n## [3,] FALSE TRUE TRUE\n# lazy:\nM_lazy <- lazymat(M)\ninvM_lazy <- lazyInv(M_lazy)\nas.double(M_lazy %*% invM_lazy) == diag(3L)\n## [,1] [,2] [,3]\n## [1,] TRUE TRUE TRUE\n## [2,] TRUE TRUE TRUE\n## [3,] TRUE TRUE TRUE\n```\n\n### About laziness\n\nThe lazy numbers are called like this because when an operation is\nperformed between numbers, the resulting lazy number is not the result\nof the operation; rather, it is the unevaluated operation. Therefore,\nperforming some operations on lazy numbers is fast, but a call to\n`as.double`, which triggers the exact evaluation, can be slow. A call to\n`intervals` is fast.\n\n## Blog posts\n\n[The lazy numbers in\nR](https://laustep.github.io/stlahblog/posts/lazyNumbers.html).\n\n[The lazy numbers in R:\ncorrection](https://laustep.github.io/stlahblog/posts/lazyNumbers2.html).\n\n## License\n\nThis package is provided under the GPL-3 license but it uses the C++\nlibrary CGAL. If you wish to use CGAL for commercial purposes, you must\nobtain a license from the\n[GeometryFactory](https://geometryfactory.com).","jobInfo":{"package":"lazyNumbers","version":"1.2.1","parsingStatus":"success","parserVersion":2,"parsedAt":"2022-11-21T23:29:54+0000"}}

Description

Usage

Arguments

Format