The R Project SVN R

Rev

Rev 85387 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 85387 Rev 85933
Line 1... Line 1...
1 
 
 1 
 
2 
R Under development (unstable) (2023-10-20 r85375) -- "Unsuffered Consequences"
 2 
R Under development (unstable) (2024-02-16 r85931) -- "Unsuffered Consequences"
3 
Copyright (C) 2023 The R Foundation for Statistical Computing
 3 
Copyright (C) 2024 The R Foundation for Statistical Computing
4 
Platform: x86_64-pc-linux-gnu
 4 
Platform: x86_64-pc-linux-gnu
5 
 
 5 
 
6 
R is free software and comes with ABSOLUTELY NO WARRANTY.
 6 
R is free software and comes with ABSOLUTELY NO WARRANTY.
7 
You are welcome to redistribute it under certain conditions.
 7 
You are welcome to redistribute it under certain conditions.
8 
Type 'license()' or 'licence()' for distribution details.
 8 
Type 'license()' or 'licence()' for distribution details.
Line 1017... Line 1017...
1017 
[1] TRUE
 1017 
[1] TRUE
1018 
> res <- try(as.numeric( x ), silent = TRUE)
 1018 
> res <- try(as.numeric( x ), silent = TRUE)
1019 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
 1019 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
1020 
[1] TRUE
 1020 
[1] TRUE
1021 
> res <- try(as.numeric_version( x ), silent = TRUE)
 1021 
> res <- try(as.numeric_version( x ), silent = TRUE)
1022 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
1023 
  invalid non-character version specification 'x' (type: integer)
 - 
 
1024 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
 1022 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
1025 
[1] TRUE
 - 
 
1026 
> res <- try(as.ordered( x ), silent = TRUE)
 1023 
> res <- try(as.ordered( x ), silent = TRUE)
1027 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
 1024 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
1028 
[1] TRUE
 1025 
[1] TRUE
1029 
> res <- try(as.package_version( x ), silent = TRUE)
 1026 
> res <- try(as.package_version( x ), silent = TRUE)
1030 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
1031 
  invalid non-character version specification 'x' (type: integer)
 - 
 
1032 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
 1027 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
1033 
> res <- try(as.pairlist( x ), silent = TRUE)
 1028 
> res <- try(as.pairlist( x ), silent = TRUE)
1034 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
 1029 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
1035 
[1] TRUE
 1030 
[1] TRUE
1036 
> res <- try(as.qr( x ), silent = TRUE)
 1031 
> res <- try(as.qr( x ), silent = TRUE)
Line 1135... Line 1130...
1135 
> if(!inherits(res, 'try-error'))
 1130 
> if(!inherits(res, 'try-error'))
1136 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1131 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1137 
+    } else   !isall.equal(x, res)})
 1132 
+    } else   !isall.equal(x, res)})
1138 
IS: [1] TRUE
 1133 
IS: [1] TRUE
1139 
> res <- try(as.numeric_version( x ), silent = TRUE)
 1134 
> res <- try(as.numeric_version( x ), silent = TRUE)
1140 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
1141 
  invalid non-character version specification 'x' (type: integer)
 - 
 
1142 
> if(!inherits(res, 'try-error'))
 1135 
> if(!inherits(res, 'try-error'))
1143 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1136 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1144 
+    } else   !isall.equal(x, res)})
 1137 
+    } else   !isall.equal(x, res)})
1145 
[1] TRUE
 - 
 
1146 
> res <- try(as.ordered( x ), silent = TRUE)
 1138 
> res <- try(as.ordered( x ), silent = TRUE)
1147 
> if(!inherits(res, 'try-error'))
 1139 
> if(!inherits(res, 'try-error'))
1148 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1140 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1149 
+    } else   !isall.equal(x, res)})
 1141 
+    } else   !isall.equal(x, res)})
1150 
[1] TRUE
 1142 
[1] TRUE
1151 
> res <- try(as.package_version( x ), silent = TRUE)
 1143 
> res <- try(as.package_version( x ), silent = TRUE)
1152 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
1153 
  invalid non-character version specification 'x' (type: integer)
 - 
 
1154 
> if(!inherits(res, 'try-error'))
 1144 
> if(!inherits(res, 'try-error'))
1155 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1145 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1156 
+    } else   !isall.equal(x, res)})
 1146 
+    } else   !isall.equal(x, res)})
1157 
> res <- try(as.pairlist( x ), silent = TRUE)
 1147 
> res <- try(as.pairlist( x ), silent = TRUE)
1158 
> if(!inherits(res, 'try-error'))
 1148 
> if(!inherits(res, 'try-error'))
Line 1254... Line 1244...
1254 
[1] TRUE
 1244 
[1] TRUE
1255 
> f <- try(as.numeric( x ), silent = TRUE)
 1245 
> f <- try(as.numeric( x ), silent = TRUE)
1256 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
 1246 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
1257 
[1] TRUE
 1247 
[1] TRUE
1258 
> f <- try(as.numeric_version( x ), silent = TRUE)
 1248 
> f <- try(as.numeric_version( x ), silent = TRUE)
1259 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
1260 
  invalid non-character version specification 'x' (type: integer)
 - 
 
1261 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
 1249 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
1262 
[1] TRUE
 - 
 
1263 
> f <- try(as.octmode( x ), silent = TRUE)
 1250 
> f <- try(as.octmode( x ), silent = TRUE)
1264 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
 1251 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
1265 
[1] TRUE
 1252 
[1] TRUE
1266 
> f <- try(as.ordered( x ), silent = TRUE)
 1253 
> f <- try(as.ordered( x ), silent = TRUE)
1267 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
 1254 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
1268 
[1] TRUE
 1255 
[1] TRUE
1269 
> f <- try(as.package_version( x ), silent = TRUE)
 1256 
> f <- try(as.package_version( x ), silent = TRUE)
1270 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
1271 
  invalid non-character version specification 'x' (type: integer)
 - 
 
1272 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
 1257 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
1273 
> f <- try(as.pairlist( x ), silent = TRUE)
 1258 
> f <- try(as.pairlist( x ), silent = TRUE)
1274 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
 1259 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
1275 
[1] TRUE
 1260 
[1] TRUE
1276 
> f <- try(as.qr( x ), silent = TRUE)
 1261 
> f <- try(as.qr( x ), silent = TRUE)
Line 1355... Line 1340...
1355 
[1] TRUE
 1340 
[1] TRUE
1356 
> res <- try(as.numeric( x ), silent = TRUE)
 1341 
> res <- try(as.numeric( x ), silent = TRUE)
1357 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
 1342 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
1358 
[1] TRUE
 1343 
[1] TRUE
1359 
> res <- try(as.numeric_version( x ), silent = TRUE)
 1344 
> res <- try(as.numeric_version( x ), silent = TRUE)
1360 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
1361 
  invalid non-character version specification 'x' (type: double)
 - 
 
1362 
Warning message:
 - 
 
1363 
In lapply(strsplit(x[ok], "[.-]"), as.integer) :
 - 
 
1364 
  NAs introduced by coercion to integer range
 - 
 
1365 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
 1345 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
1366 
[1] TRUE
 - 
 
1367 
> res <- try(as.ordered( x ), silent = TRUE)
 1346 
> res <- try(as.ordered( x ), silent = TRUE)
1368 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
 1347 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
1369 
[1] TRUE
 1348 
[1] TRUE
1370 
> res <- try(as.package_version( x ), silent = TRUE)
 1349 
> res <- try(as.package_version( x ), silent = TRUE)
1371 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
1372 
  invalid non-character version specification 'x' (type: double)
 - 
 
1373 
Warning message:
 - 
 
1374 
In lapply(strsplit(x[ok], "[.-]"), as.integer) :
 - 
 
1375 
  NAs introduced by coercion to integer range
 - 
 
1376 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
 1350 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
1377 
[1] TRUE
 - 
 
1378 
> res <- try(as.pairlist( x ), silent = TRUE)
 1351 
> res <- try(as.pairlist( x ), silent = TRUE)
1379 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
 1352 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
1380 
[1] TRUE
 1353 
[1] TRUE
1381 
> res <- try(as.qr( x ), silent = TRUE)
 1354 
> res <- try(as.qr( x ), silent = TRUE)
1382 
> if(!inherits(res, 'try-error')) report(is.qr(res))
 1355 
> if(!inherits(res, 'try-error')) report(is.qr(res))
Line 1480... Line 1453...
1480 
> if(!inherits(res, 'try-error'))
 1453 
> if(!inherits(res, 'try-error'))
1481 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1454 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1482 
+    } else   !isall.equal(x, res)})
 1455 
+    } else   !isall.equal(x, res)})
1483 
IS: [1] TRUE
 1456 
IS: [1] TRUE
1484 
> res <- try(as.numeric_version( x ), silent = TRUE)
 1457 
> res <- try(as.numeric_version( x ), silent = TRUE)
1485 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
1486 
  invalid non-character version specification 'x' (type: double)
 - 
 
1487 
Warning message:
 - 
 
1488 
In lapply(strsplit(x[ok], "[.-]"), as.integer) :
 - 
 
1489 
  NAs introduced by coercion to integer range
 - 
 
1490 
> if(!inherits(res, 'try-error'))
 1458 
> if(!inherits(res, 'try-error'))
1491 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1459 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1492 
+    } else   !isall.equal(x, res)})
 1460 
+    } else   !isall.equal(x, res)})
1493 
[1] TRUE
 - 
 
1494 
> res <- try(as.ordered( x ), silent = TRUE)
 1461 
> res <- try(as.ordered( x ), silent = TRUE)
1495 
> if(!inherits(res, 'try-error'))
 1462 
> if(!inherits(res, 'try-error'))
1496 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1463 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1497 
+    } else   !isall.equal(x, res)})
 1464 
+    } else   !isall.equal(x, res)})
1498 
[1] TRUE
 1465 
[1] TRUE
1499 
> res <- try(as.package_version( x ), silent = TRUE)
 1466 
> res <- try(as.package_version( x ), silent = TRUE)
1500 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
1501 
  invalid non-character version specification 'x' (type: double)
 - 
 
1502 
Warning message:
 - 
 
1503 
In lapply(strsplit(x[ok], "[.-]"), as.integer) :
 - 
 
1504 
  NAs introduced by coercion to integer range
 - 
 
1505 
> if(!inherits(res, 'try-error'))
 1467 
> if(!inherits(res, 'try-error'))
1506 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1468 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1507 
+    } else   !isall.equal(x, res)})
 1469 
+    } else   !isall.equal(x, res)})
1508 
[1] TRUE
 - 
 
1509 
> res <- try(as.pairlist( x ), silent = TRUE)
 1470 
> res <- try(as.pairlist( x ), silent = TRUE)
1510 
> if(!inherits(res, 'try-error'))
 1471 
> if(!inherits(res, 'try-error'))
1511 
+    report({if(is.pairlist(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 1472 
+    report({if(is.pairlist(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
1512 
+    } else   !isall.equal(x, res)})
 1473 
+    } else   !isall.equal(x, res)})
1513 
[1] TRUE
 1474 
[1] TRUE
Line 1605... Line 1566...
1605 
[1] TRUE
 1566 
[1] TRUE
1606 
> f <- try(as.numeric( x ), silent = TRUE)
 1567 
> f <- try(as.numeric( x ), silent = TRUE)
1607 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
 1568 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
1608 
[1] TRUE
 1569 
[1] TRUE
1609 
> f <- try(as.numeric_version( x ), silent = TRUE)
 1570 
> f <- try(as.numeric_version( x ), silent = TRUE)
1610 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
1611 
  invalid non-character version specification 'x' (type: double)
 - 
 
1612 
Warning message:
 - 
 
1613 
In lapply(strsplit(x[ok], "[.-]"), as.integer) :
 - 
 
1614 
  NAs introduced by coercion to integer range
 - 
 
1615 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
 1571 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
1616 
[1] TRUE
 - 
 
1617 
> f <- try(as.octmode( x ), silent = TRUE)
 1572 
> f <- try(as.octmode( x ), silent = TRUE)
1618 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
 1573 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
1619 
> f <- try(as.ordered( x ), silent = TRUE)
 1574 
> f <- try(as.ordered( x ), silent = TRUE)
1620 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
 1575 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
1621 
[1] TRUE
 1576 
[1] TRUE
1622 
> f <- try(as.package_version( x ), silent = TRUE)
 1577 
> f <- try(as.package_version( x ), silent = TRUE)
1623 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
1624 
  invalid non-character version specification 'x' (type: double)
 - 
 
1625 
Warning message:
 - 
 
1626 
In lapply(strsplit(x[ok], "[.-]"), as.integer) :
 - 
 
1627 
  NAs introduced by coercion to integer range
 - 
 
1628 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
 1578 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
1629 
[1] TRUE
 - 
 
1630 
> f <- try(as.pairlist( x ), silent = TRUE)
 1579 
> f <- try(as.pairlist( x ), silent = TRUE)
1631 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
 1580 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
1632 
[1] TRUE
 1581 
[1] TRUE
1633 
> f <- try(as.qr( x ), silent = TRUE)
 1582 
> f <- try(as.qr( x ), silent = TRUE)
1634 
>   if(!inherits(f, 'try-error')) report(identical(f, as.qr( f )))
 1583 
>   if(!inherits(f, 'try-error')) report(identical(f, as.qr( f )))
Line 2032... Line 1981...
2032 
[1] TRUE
 1981 
[1] TRUE
2033 
> res <- try(as.numeric( x ), silent = TRUE)
 1982 
> res <- try(as.numeric( x ), silent = TRUE)
2034 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
 1983 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
2035 
[1] TRUE
 1984 
[1] TRUE
2036 
> res <- try(as.numeric_version( x ), silent = TRUE)
 1985 
> res <- try(as.numeric_version( x ), silent = TRUE)
2037 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
2038 
  invalid non-character version specification 'x' (type: list)
 - 
 
2039 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
 1986 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
2040 
[1] TRUE
 - 
 
2041 
> res <- try(as.ordered( x ), silent = TRUE)
 1987 
> res <- try(as.ordered( x ), silent = TRUE)
2042 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
 1988 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
2043 
[1] TRUE
 1989 
[1] TRUE
2044 
> res <- try(as.package_version( x ), silent = TRUE)
 1990 
> res <- try(as.package_version( x ), silent = TRUE)
2045 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
2046 
  invalid non-character version specification 'x' (type: list)
 - 
 
2047 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
 1991 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
2048 
> res <- try(as.pairlist( x ), silent = TRUE)
 1992 
> res <- try(as.pairlist( x ), silent = TRUE)
2049 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
 1993 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
2050 
[1] TRUE
 1994 
[1] TRUE
2051 
> res <- try(as.qr( x ), silent = TRUE)
 1995 
> res <- try(as.qr( x ), silent = TRUE)
Line 2149... Line 2093...
2149 
> if(!inherits(res, 'try-error'))
 2093 
> if(!inherits(res, 'try-error'))
2150 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2094 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2151 
+    } else   !isall.equal(x, res)})
 2095 
+    } else   !isall.equal(x, res)})
2152 
[1] TRUE
 2096 
[1] TRUE
2153 
> res <- try(as.numeric_version( x ), silent = TRUE)
 2097 
> res <- try(as.numeric_version( x ), silent = TRUE)
2154 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
2155 
  invalid non-character version specification 'x' (type: list)
 - 
 
2156 
> if(!inherits(res, 'try-error'))
 2098 
> if(!inherits(res, 'try-error'))
2157 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2099 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2158 
+    } else   !isall.equal(x, res)})
 2100 
+    } else   !isall.equal(x, res)})
2159 
[1] TRUE
 - 
 
2160 
> res <- try(as.ordered( x ), silent = TRUE)
 2101 
> res <- try(as.ordered( x ), silent = TRUE)
2161 
> if(!inherits(res, 'try-error'))
 2102 
> if(!inherits(res, 'try-error'))
2162 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2103 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2163 
+    } else   !isall.equal(x, res)})
 2104 
+    } else   !isall.equal(x, res)})
2164 
[1] TRUE
 2105 
[1] TRUE
2165 
> res <- try(as.package_version( x ), silent = TRUE)
 2106 
> res <- try(as.package_version( x ), silent = TRUE)
2166 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
2167 
  invalid non-character version specification 'x' (type: list)
 - 
 
2168 
> if(!inherits(res, 'try-error'))
 2107 
> if(!inherits(res, 'try-error'))
2169 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2108 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2170 
+    } else   !isall.equal(x, res)})
 2109 
+    } else   !isall.equal(x, res)})
2171 
> res <- try(as.pairlist( x ), silent = TRUE)
 2110 
> res <- try(as.pairlist( x ), silent = TRUE)
2172 
> if(!inherits(res, 'try-error'))
 2111 
> if(!inherits(res, 'try-error'))
Line 2263... Line 2202...
2263 
[1] TRUE
 2202 
[1] TRUE
2264 
> f <- try(as.numeric( x ), silent = TRUE)
 2203 
> f <- try(as.numeric( x ), silent = TRUE)
2265 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
 2204 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
2266 
[1] TRUE
 2205 
[1] TRUE
2267 
> f <- try(as.numeric_version( x ), silent = TRUE)
 2206 
> f <- try(as.numeric_version( x ), silent = TRUE)
2268 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
2269 
  invalid non-character version specification 'x' (type: list)
 - 
 
2270 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
 2207 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
2271 
[1] TRUE
 - 
 
2272 
> f <- try(as.octmode( x ), silent = TRUE)
 2208 
> f <- try(as.octmode( x ), silent = TRUE)
2273 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
 2209 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
2274 
> f <- try(as.ordered( x ), silent = TRUE)
 2210 
> f <- try(as.ordered( x ), silent = TRUE)
2275 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
 2211 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
2276 
[1] TRUE
 2212 
[1] TRUE
2277 
> f <- try(as.package_version( x ), silent = TRUE)
 2213 
> f <- try(as.package_version( x ), silent = TRUE)
2278 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
2279 
  invalid non-character version specification 'x' (type: list)
 - 
 
2280 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
 2214 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
2281 
> f <- try(as.pairlist( x ), silent = TRUE)
 2215 
> f <- try(as.pairlist( x ), silent = TRUE)
2282 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
 2216 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
2283 
[1] TRUE
 2217 
[1] TRUE
2284 
> f <- try(as.qr( x ), silent = TRUE)
 2218 
> f <- try(as.qr( x ), silent = TRUE)
Line 2360... Line 2294...
2360 
[1] TRUE
 2294 
[1] TRUE
2361 
> res <- try(as.numeric( x ), silent = TRUE)
 2295 
> res <- try(as.numeric( x ), silent = TRUE)
2362 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
 2296 
> if(!inherits(res, 'try-error')) report(is.numeric(res))
2363 
[1] TRUE
 2297 
[1] TRUE
2364 
> res <- try(as.numeric_version( x ), silent = TRUE)
 2298 
> res <- try(as.numeric_version( x ), silent = TRUE)
2365 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
2366 
  invalid non-character version specification 'x' (type: list)
 - 
 
2367 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
 2299 
> if(!inherits(res, 'try-error')) report(is.numeric_version(res))
2368 
> res <- try(as.ordered( x ), silent = TRUE)
 2300 
> res <- try(as.ordered( x ), silent = TRUE)
2369 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
 2301 
> if(!inherits(res, 'try-error')) report(is.ordered(res))
2370 
> res <- try(as.package_version( x ), silent = TRUE)
 2302 
> res <- try(as.package_version( x ), silent = TRUE)
2371 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
2372 
  invalid non-character version specification 'x' (type: list)
 - 
 
2373 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
 2303 
> if(!inherits(res, 'try-error')) report(is.package_version(res))
2374 
> res <- try(as.pairlist( x ), silent = TRUE)
 2304 
> res <- try(as.pairlist( x ), silent = TRUE)
2375 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
 2305 
> if(!inherits(res, 'try-error')) report(is.pairlist(res))
2376 
[1] TRUE
 2306 
[1] TRUE
2377 
> res <- try(as.qr( x ), silent = TRUE)
 2307 
> res <- try(as.qr( x ), silent = TRUE)
Line 2478... Line 2408...
2478 
> if(!inherits(res, 'try-error'))
 2408 
> if(!inherits(res, 'try-error'))
2479 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2409 
+    report({if(is.numeric(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2480 
+    } else   !isall.equal(x, res)})
 2410 
+    } else   !isall.equal(x, res)})
2481 
[1] TRUE
 2411 
[1] TRUE
2482 
> res <- try(as.numeric_version( x ), silent = TRUE)
 2412 
> res <- try(as.numeric_version( x ), silent = TRUE)
2483 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
2484 
  invalid non-character version specification 'x' (type: list)
 - 
 
2485 
> if(!inherits(res, 'try-error'))
 2413 
> if(!inherits(res, 'try-error'))
2486 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2414 
+    report({if(is.numeric_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2487 
+    } else   !isall.equal(x, res)})
 2415 
+    } else   !isall.equal(x, res)})
2488 
> res <- try(as.ordered( x ), silent = TRUE)
 2416 
> res <- try(as.ordered( x ), silent = TRUE)
2489 
> if(!inherits(res, 'try-error'))
 2417 
> if(!inherits(res, 'try-error'))
2490 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2418 
+    report({if(is.ordered(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2491 
+    } else   !isall.equal(x, res)})
 2419 
+    } else   !isall.equal(x, res)})
2492 
> res <- try(as.package_version( x ), silent = TRUE)
 2420 
> res <- try(as.package_version( x ), silent = TRUE)
2493 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
2494 
  invalid non-character version specification 'x' (type: list)
 - 
 
2495 
> if(!inherits(res, 'try-error'))
 2421 
> if(!inherits(res, 'try-error'))
2496 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
 2422 
+    report({if(is.package_version(x)) { cat('IS: ');all.equal(x, res, tolerance=0)
2497 
+    } else   !isall.equal(x, res)})
 2423 
+    } else   !isall.equal(x, res)})
2498 
> res <- try(as.pairlist( x ), silent = TRUE)
 2424 
> res <- try(as.pairlist( x ), silent = TRUE)
2499 
> if(!inherits(res, 'try-error'))
 2425 
> if(!inherits(res, 'try-error'))
Line 2590... Line 2516...
2590 
[1] TRUE
 2516 
[1] TRUE
2591 
> f <- try(as.numeric( x ), silent = TRUE)
 2517 
> f <- try(as.numeric( x ), silent = TRUE)
2592 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
 2518 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric( f )))
2593 
[1] TRUE
 2519 
[1] TRUE
2594 
> f <- try(as.numeric_version( x ), silent = TRUE)
 2520 
> f <- try(as.numeric_version( x ), silent = TRUE)
2595 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version) :
 - 
 
2596 
  invalid non-character version specification 'x' (type: list)
 - 
 
2597 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
 2521 
>   if(!inherits(f, 'try-error')) report(identical(f, as.numeric_version( f )))
2598 
> f <- try(as.octmode( x ), silent = TRUE)
 2522 
> f <- try(as.octmode( x ), silent = TRUE)
2599 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
 2523 
>   if(!inherits(f, 'try-error')) report(identical(f, as.octmode( f )))
2600 
> f <- try(as.ordered( x ), silent = TRUE)
 2524 
> f <- try(as.ordered( x ), silent = TRUE)
2601 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
 2525 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ordered( f )))
2602 
> f <- try(as.package_version( x ), silent = TRUE)
 2526 
> f <- try(as.package_version( x ), silent = TRUE)
2603 
Warning in .make_numeric_version(x, strict, .standard_regexps()$valid_package_version,  :
 - 
 
2604 
  invalid non-character version specification 'x' (type: list)
 - 
 
2605 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
 2527 
>   if(!inherits(f, 'try-error')) report(identical(f, as.package_version( f )))
2606 
> f <- try(as.pairlist( x ), silent = TRUE)
 2528 
> f <- try(as.pairlist( x ), silent = TRUE)
2607 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
 2529 
>   if(!inherits(f, 'try-error')) report(identical(f, as.pairlist( f )))
2608 
[1] TRUE
 2530 
[1] TRUE
2609 
> f <- try(as.qr( x ), silent = TRUE)
 2531 
> f <- try(as.qr( x ), silent = TRUE)
Line 2639... Line 2561...
2639 
> f <- try(as.stepfun( x ), silent = TRUE)
 2561 
> f <- try(as.stepfun( x ), silent = TRUE)
2640 
>   if(!inherits(f, 'try-error')) report(identical(f, as.stepfun( f )))
 2562 
>   if(!inherits(f, 'try-error')) report(identical(f, as.stepfun( f )))
2641 
> f <- try(as.ts( x ), silent = TRUE)
 2563 
> f <- try(as.ts( x ), silent = TRUE)
2642 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ts( f )))
 2564 
>   if(!inherits(f, 'try-error')) report(identical(f, as.ts( f )))
2643 
> cat('Time elapsed: ', proc.time() - .proctime00,'\n')
 2565 
> cat('Time elapsed: ', proc.time() - .proctime00,'\n')
2644 
Time elapsed:  0.102 0.017 0.118 0 0
2566 
Time elapsed:  0.093 0.02 0.114 0 0
2645 
>
2567 
>
2646 
>
2568 
>