tests/testthat/test-ilog.R

In poissonconsulting/extras: Helper Functions for Bayesian Analyses

test_that("ilog errors with character input", {
  expect_error(ilog("6"), "non-numeric argument to mathematical function")
})

test_that("ilog errors with NULL input", {
  expect_error(ilog(NULL), "non-numeric argument to mathematical function")
})

test_that("ilog numeric(0) input returns numeric(0)", {
  expect_equal(ilog(numeric(0)), numeric(0))
})

test_that("ilog NA_real_ input returns NA_real_", {
  expect_equal(ilog(NA_real_), NA_real_)
})

test_that("ilog vectorized NA_real_ input returns vector of NA_real_", {
  expect_equal(ilog(rep(NA_real_, 2)), rep(NA_real_, 2))
})

test_that("ilog Inf input returns Inf", {
  expect_equal(ilog(Inf), Inf)
})

test_that("ilog -Inf input returns 0", {
  expect_equal(ilog(-Inf), 0)
})

test_that("ilog logical inputs coerced to numeric", {
  expect_equal(ilog(TRUE), exp(1))
  expect_equal(ilog(FALSE), 1)
  expect_equal(ilog(NA), NA_real_)
})

test_that("ilog integer inputs return expected output", {
  expect_equal(ilog(1L), exp(1))
  expect_equal(ilog(-5L), 0.00673794699908547)
  expect_equal(ilog(100L), 2.68811714181614e+43)
})

test_that("ilog real inputs return expected output", {
  expect_equal(ilog(-0.0231), 0.977164762411049)
  expect_equal(ilog(1.000322), 2.7191572561441)
  expect_equal(ilog(2.491), 12.0733434292139)
})

test_that("ilog vectorized inputs return expected output", {
  expect_equal(ilog(-10:10),
               c(4.53999297624849e-05, 0.00012340980408668, 0.000335462627902512,
                 0.000911881965554516, 0.00247875217666636, 0.00673794699908547,
                 0.0183156388887342, 0.0497870683678639, 0.135335283236613, 0.367879441171442,
                 1, 2.71828182845905, 7.38905609893065, 20.0855369231877, 54.5981500331442,
                 148.413159102577, 403.428793492735, 1096.63315842846, 2980.95798704173,
                 8103.08392757538, 22026.4657948067))
  expect_equal(ilog(seq(-2, 2, length.out = 10)),
               c(0.135335283236613, 0.21107208779109, 0.329192987807906, 0.513417119032592,
                 0.800737402916808, 1.24884886900168, 1.94773404105468, 3.03773177751748,
                 4.73771785964308, 7.38905609893065))
})

test_that("ilog matrix inputs return expected output", {
  expect_equal(ilog(matrix(1:10, ncol = 2, nrow = 5)),
               structure(c(2.71828182845905, 7.38905609893065, 20.0855369231877,
                           54.5981500331442, 148.413159102577, 403.428793492735, 1096.63315842846,
                           2980.95798704173, 8103.08392757538, 22026.4657948067),
                         dim = c(5L, 2L)))
  expect_equal(ilog(matrix(seq(-2, 2, length.out = 10), nrow = 2, ncol = 5)),
               structure(c(0.135335283236613, 0.21107208779109, 0.329192987807906,
                           0.513417119032592, 0.800737402916808, 1.24884886900168, 1.94773404105468,
                           3.03773177751748, 4.73771785964308, 7.38905609893065),
                         dim = c(2L, 5L)))
})

test_that("ilog array inputs return expected output", {
  expect_equal(ilog(array(1:20, dim = c(5, 2, 2))),
               structure(structure(c(2.71828182845905, 7.38905609893065, 20.0855369231877,
                                     54.5981500331442, 148.413159102577, 403.428793492735, 1096.63315842846,
                                     2980.95798704173, 8103.08392757538, 22026.4657948067, 59874.1417151978,
                                     162754.791419004, 442413.39200892, 1202604.28416478, 3269017.37247211,
                                     8886110.52050787, 24154952.7535753, 65659969.1373305, 178482300.963187,
                                     485165195.40979), dim = c(5L, 2L, 2L))))
  expect_equal(ilog(array(seq(-2, 2, length.out = 20), dim = c(2, 5, 2))),
               structure(c(0.135335283236613, 0.167048066569284, 0.206192028251409,
                           0.25450849798849, 0.314146846983714, 0.387760103296325, 0.478622972511232,
                           0.590777513901232, 0.729212952525235, 0.900087626252259, 1.11100294108447,
                           1.37134152175581, 1.69268460032686, 2.08932721042037, 2.57891410565208,
                           3.18322469125988, 3.929141886827, 4.84984802021882, 5.98630095239829,
                           7.38905609893065), dim = c(2L, 5L, 2L)))
})

test_that("ilog dataframe inputs return expected output", {
  expect_equal(ilog(data.frame(y = -5:5)),
               structure(list(y = c(0.00673794699908547, 0.0183156388887342,
                                    0.0497870683678639, 0.135335283236613, 0.367879441171442, 1,
                                    2.71828182845905, 7.38905609893065, 20.0855369231877, 54.5981500331442,
                                    148.413159102577)), row.names = c(NA, -11L), class = "data.frame"))
})

test_that("ilog2 errors with character input", {
  expect_error(ilog2("6"), "non-numeric argument to binary operator")
})

test_that("ilog2 NULL input returns numeric(0)", {
  expect_equal(ilog2(NULL), numeric(0))
})

test_that("ilog2 numeric(0) input returns numeric(0)", {
  expect_equal(ilog2(numeric(0)), numeric(0))
})

test_that("ilog2 NA_real_ input returns NA_real_", {
  expect_equal(ilog2(NA_real_), NA_real_)
})

test_that("ilog2 vectorized NA_real_ input returns vector of NA_real_", {
  expect_equal(ilog2(rep(NA_real_, 2)), rep(NA_real_, 2))
})

test_that("ilog2 Inf input returns Inf", {
  expect_equal(ilog2(Inf), Inf)
})

test_that("ilog2 -Inf input returns 0", {
  expect_equal(ilog2(-Inf), 0)
})

test_that("ilog2 logical inputs coerced to numeric", {
  expect_equal(ilog2(TRUE), 2)
  expect_equal(ilog2(FALSE), 1)
  expect_equal(ilog2(NA), NA_real_)
})

test_that("ilog2 integer inputs return expected output", {
  expect_equal(ilog2(1L), 2)
  expect_equal(ilog2(-5L), 0.03125)
  expect_equal(ilog2(100L), 1.26765060022823e+30)
})

test_that("ilog2 real inputs return expected output", {
  expect_equal(ilog2(-0.0231), 0.984115805960014)
  expect_equal(ilog2(1.000322), 2.00044643660328)
  expect_equal(ilog2(2.491), 5.62167480082688)
})

test_that("ilog2 vectorized inputs return expected output", {
  expect_equal(ilog2(-10:10),
               c(0.0009765625, 0.001953125, 0.00390625, 0.0078125, 0.015625,
                 0.03125, 0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16, 32, 64, 128,
                 256, 512, 1024))
  expect_equal(ilog2(seq(-2, 2, length.out = 10)),
               c(0.25, 0.340197500043594, 0.462937356143645, 0.629960524947437,
                 0.857243982853073, 1.16652903957612, 1.5874010519682, 2.16011947778461,
                 2.9394689845512, 4))
})

test_that("ilog2 matrix inputs return expected output", {
  expect_equal(ilog2(matrix(1:10, ncol = 2, nrow = 5)),
               structure(c(2, 4, 8, 16, 32, 64, 128, 256, 512, 1024), dim = c(5L, 2L)))
  expect_equal(ilog2(matrix(seq(-2, 2, length.out = 10), nrow = 2, ncol = 5)),
               structure(c(0.25, 0.340197500043594, 0.462937356143645, 0.629960524947437,
                           0.857243982853073, 1.16652903957612, 1.5874010519682, 2.16011947778461,
                           2.9394689845512, 4), dim = c(2L, 5L)))
})

test_that("ilog2 array inputs return expected output", {
  expect_equal(ilog2(array(1:20, dim = c(5, 2, 2))),
               structure(c(2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096,
                           8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576),
                         dim = c(5L, 2L, 2L)))
  expect_equal(ilog2(array(seq(-2, 2, length.out = 20), dim = c(2, 5, 2))),
               structure(c(0.25, 0.28927755932068, 0.334726025306118, 0.387314910566664,
                           0.448166048068928, 0.518577522223096, 0.600051359789051, 0.694325571307328,
                           0.803411226566882, 0.929635355008406, 1.07569058622018, 1.24469258946402,
                           1.44024653753876, 1.66652401279709, 1.92835199588499, 2.23131583552309,
                           2.58187839589481, 2.98751792330897, 3.45688757312642, 4), dim = c(2L, 5L, 2L)))
})

test_that("ilog2 dataframe inputs return expected output", {
  expect_equal(ilog2(data.frame(y = -5:5)),
               structure(list(y = c(0.03125, 0.0625, 0.125, 0.25, 0.5, 1, 2,
                                    4, 8, 16, 32)), class = "data.frame", row.names = c(NA, -11L)))
})

test_that("ilog10 errors with character input", {
  expect_error(ilog10("6"), "non-numeric argument to binary operator")
})

test_that("ilog10 NULL input returns numeric(0)", {
  expect_equal(ilog10(NULL), numeric(0))
})

test_that("ilog10 numeric(0) input returns numeric(0)", {
  expect_equal(ilog10(numeric(0)), numeric(0))
})

test_that("ilog10 NA_real_ input returns NA_real_", {
  expect_equal(ilog10(NA_real_), NA_real_)
})

test_that("ilog10 vectorized NA_real_ input returns vector of NA_real_", {
  expect_equal(ilog10(rep(NA_real_, 2)), rep(NA_real_, 2))
})

test_that("ilog10 Inf input returns Inf", {
  expect_equal(ilog10(Inf), Inf)
})

test_that("ilog10 -Inf input returns 0", {
  expect_equal(ilog10(-Inf), 0)
})

test_that("ilog10 logical inputs coerced to numeric", {
  expect_equal(ilog10(TRUE), 10)
  expect_equal(ilog10(FALSE), 1)
  expect_equal(ilog10(NA), NA_real_)
})

test_that("ilog10 integer inputs return expected output", {
  expect_equal(ilog10(1L), 10)
  expect_equal(ilog10(-5L), 1e-05)
  expect_equal(ilog10(100L), 1e+100)
})

test_that("ilog10 real inputs return expected output", {
  expect_equal(ilog10(-0.0231), 0.948200107019506)
  expect_equal(ilog10(1.000322), 10.0074170732889)
  expect_equal(ilog10(2.491), 309.741929921658)
})

test_that("ilog10 vectorized numeric inputs return expected outputs", {
  expect_equal(ilog10(-10:10),
               c(1e-10, 1e-09, 1e-08, 1e-07, 1e-06, 1e-05, 1e-04, 0.001, 0.01,
                 0.1, 1, 10, 100, 1000, 10000, 1e+05, 1e+06, 1e+07, 1e+08, 1e+09,
                 1e+10))
  expect_equal(ilog10(seq(-2, 2, length.out = 10)),
               c(0.01, 0.0278255940220712, 0.0774263682681127, 0.215443469003188,
                 0.599484250318941, 1.66810053720006, 4.64158883361278, 12.9154966501488,
                 35.9381366380463, 100))
})

test_that("ilog10 matrix numeric inputs return expected output", {
  expect_equal(ilog10(matrix(1:10, ncol = 2, nrow = 5)),
               structure(c(10, 100, 1000, 10000, 1e+05, 1e+06, 1e+07, 1e+08,
                           1e+09, 1e+10), dim = c(5L, 2L)))
  expect_equal(ilog10(matrix(seq(-2, 2, length.out = 10), nrow = 2, ncol = 5)),
               structure(c(0.01, 0.0278255940220712, 0.0774263682681127, 0.215443469003188,
                           0.599484250318941, 1.66810053720006, 4.64158883361278, 12.9154966501488,
                           35.9381366380463, 100), dim = c(2L, 5L)))
})

test_that("ilog10 array numeric inputs return expected output", {
  expect_equal(ilog10(array(1:20, dim = c(5, 2, 2))),
               structure(c(10, 100, 1000, 10000, 1e+05, 1e+06, 1e+07, 1e+08,
                           1e+09, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17,
                           1e+18, 1e+19, 1e+20), dim = c(5L, 2L, 2L)))
  expect_equal(ilog10(array(seq(-2, 2, length.out = 20), dim = c(2, 5, 2))),
               structure(c(0.01, 0.0162377673918872, 0.0263665089873036, 0.0428133239871939,
                           0.0695192796177561, 0.112883789168469, 0.183298071083244, 0.297635144163132,
                           0.483293023857175, 0.784759970351461, 1.27427498570313, 2.06913808111479,
                           3.35981828628378, 5.45559478116851, 8.85866790410082, 14.3844988828766,
                           23.3572146909012, 37.9269019073225, 61.5848211066026, 100), dim = c(2L, 5L, 2L)))
})

test_that("ilog10 dataframe numeric inputs return expected output", {
  expect_equal(ilog10(data.frame(y = -5:5)),
               structure(list(y = c(1e-05, 1e-04, 0.001, 0.01, 0.1, 1, 10, 100,
                                    1000, 10000, 1e+05)), class = "data.frame", row.names = c(NA, -11L)))
})