Last updated on 2024-08-03 12:49:05 CEST.

Flavor | Version | T_{install} | T_{check} | T_{total} | Status | Flags |
---|---|---|---|---|---|---|

r-devel-linux-x86_64-debian-clang | 2.6 | 7.45 | 83.19 | 90.64 | ERROR | |

r-devel-linux-x86_64-debian-gcc | 2.6 | 3.92 | 45.87 | 49.79 | ERROR | |

r-devel-linux-x86_64-fedora-clang | 2.6 | 62.31 | ERROR | |||

r-devel-linux-x86_64-fedora-gcc | 2.6 | 63.86 | ERROR | |||

r-devel-windows-x86_64 | 2.6 | 10.00 | 115.00 | 125.00 | OK | |

r-patched-linux-x86_64 | 2.6 | 7.39 | 79.79 | 87.18 | OK | |

r-release-linux-x86_64 | 2.6 | 6.88 | 81.45 | 88.33 | OK | |

r-release-macos-arm64 | 2.6 | 40.00 | OK | |||

r-release-macos-x86_64 | 2.6 | 70.00 | OK | |||

r-release-windows-x86_64 | 2.6 | 10.00 | 114.00 | 124.00 | OK | |

r-oldrel-macos-arm64 | 2.6 | 43.00 | OK | |||

r-oldrel-macos-x86_64 | 2.6 | 129.00 | OK | |||

r-oldrel-windows-x86_64 | 2.6 | 9.00 | 121.00 | 130.00 | OK |

Version: 2.6

Check: tests

Result: ERROR
Running ‘testthat.R’ [8s/9s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
> if(require("testthat")) {
+ library(testthat)
+ library(Rdpack)
+ test_check("Rdpack")
+ } else
+ warning("package 'testthat' required for 'Rdpack\'s' tests")
Loading required package: testthat
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/RtmptaIecI/file2b4d079fbdd3c.Rd
Parsing the Rd documentation in file /tmp/RtmptaIecI/file2b4d079fbdd3c.Rd ...
The Rd content was written to file /tmp/RtmptaIecI/file2b4d0723208f35.Rd
Parsing the Rd documentation in file /home/hornik/tmp/R.check/r-devel-clang/Work/build/Packages/Rdpack/examples/reprompt.Rd ...
The Rd content was written to file /tmp/RtmptaIecI/file2b4d0723208f35.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file deparse_usage.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
newargs is: data nrow ncol byrow dimnames dim start end frequency deltat ts.eps class names .Data ...
The Rd content was written to file StructureClasses.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file show.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file initialize-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file classRepresentation-class.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/RtmptaIecI/file2b4d0723208f35.Rd
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file myshow-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file seq.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq()
\\method{seq}{default}()
seq.int()
seq_along()
seq_len()
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file tmp.Rd
Processing the Rd object...
The Rd content was written to file seqB.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
myseq(from, to, by = 1)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Parsing the Rd documentation in file seq.Rd ...
The Rd content was written to file seq2.Rd
Parsing the Rd documentation in file seq2.Rd ...
The Rd content was written to file seq3.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
══ Skipped tests (1) ═══════════════════════════════════════════════════════════
• empty test (1): 'test-char2Rdpiece.R:32:1'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test-bib.R:90:5'): bib works fine ───────────────────────────────────
<subscriptOutOfBoundsError/error/condition>
Error in `s[[i]]`: subscript out of bounds
Backtrace:
▆
1. ├─testthat::expect_warning(insert_ref("xxx", package = "rbibutils")) at test-bib.R:90:5
2. │ └─testthat:::quasi_capture(...)
3. │ ├─testthat (local) .capture(...)
4. │ │ └─base::withCallingHandlers(...)
5. │ └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
6. └─Rdpack::insert_ref("xxx", package = "rbibutils")
7. ├─base::tryCatch(...)
8. │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
9. │ └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
10. │ └─base (local) doTryCatch(return(expr), name, parentenv, handler)
11. ├─bibs[[key]]
12. └─utils:::`[[.bibentry`(bibs, key)
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
Error: Test failures
Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 2.6

Check: tests

Result: ERROR
Running ‘testthat.R’ [4s/5s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
> if(require("testthat")) {
+ library(testthat)
+ library(Rdpack)
+ test_check("Rdpack")
+ } else
+ warning("package 'testthat' required for 'Rdpack\'s' tests")
Loading required package: testthat
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/RtmpNlSK5d/file2e675e6cb204f3.Rd
Parsing the Rd documentation in file /tmp/RtmpNlSK5d/file2e675e6cb204f3.Rd ...
The Rd content was written to file /tmp/RtmpNlSK5d/file2e675e57df2455.Rd
Parsing the Rd documentation in file /home/hornik/tmp/R.check/r-devel-gcc/Work/build/Packages/Rdpack/examples/reprompt.Rd ...
The Rd content was written to file /tmp/RtmpNlSK5d/file2e675e57df2455.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file deparse_usage.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
newargs is: data nrow ncol byrow dimnames dim start end frequency deltat ts.eps class names .Data ...
The Rd content was written to file StructureClasses.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file show.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file initialize-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file classRepresentation-class.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/RtmpNlSK5d/file2e675e57df2455.Rd
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file myshow-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file seq.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq()
\\method{seq}{default}()
seq.int()
seq_along()
seq_len()
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file tmp.Rd
Processing the Rd object...
The Rd content was written to file seqB.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
myseq(from, to, by = 1)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Parsing the Rd documentation in file seq.Rd ...
The Rd content was written to file seq2.Rd
Parsing the Rd documentation in file seq2.Rd ...
The Rd content was written to file seq3.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
══ Skipped tests (1) ═══════════════════════════════════════════════════════════
• empty test (1): 'test-char2Rdpiece.R:32:1'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test-bib.R:90:5'): bib works fine ───────────────────────────────────
<subscriptOutOfBoundsError/error/condition>
Error in `s[[i]]`: subscript out of bounds
Backtrace:
▆
1. ├─testthat::expect_warning(insert_ref("xxx", package = "rbibutils")) at test-bib.R:90:5
2. │ └─testthat:::quasi_capture(...)
3. │ ├─testthat (local) .capture(...)
4. │ │ └─base::withCallingHandlers(...)
5. │ └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
6. └─Rdpack::insert_ref("xxx", package = "rbibutils")
7. ├─base::tryCatch(...)
8. │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
9. │ └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
10. │ └─base (local) doTryCatch(return(expr), name, parentenv, handler)
11. ├─bibs[[key]]
12. └─utils:::`[[.bibentry`(bibs, key)
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
Error: Test failures
Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 2.6

Check: tests

Result: ERROR
Running ‘testthat.R’
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
> if(require("testthat")) {
+ library(testthat)
+ library(Rdpack)
+ test_check("Rdpack")
+ } else
+ warning("package 'testthat' required for 'Rdpack\'s' tests")
Loading required package: testthat
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/Rtmp5iZgl9/working_dir/Rtmp9e0cUK/file3cd3dc2bc8f4c9.Rd
Parsing the Rd documentation in file /tmp/Rtmp5iZgl9/working_dir/Rtmp9e0cUK/file3cd3dc2bc8f4c9.Rd ...
The Rd content was written to file /tmp/Rtmp5iZgl9/working_dir/Rtmp9e0cUK/file3cd3dcad8c473.Rd
Parsing the Rd documentation in file /data/gannet/ripley/R/packages/tests-clang/Rdpack.Rcheck/Rdpack/examples/reprompt.Rd ...
The Rd content was written to file /tmp/Rtmp5iZgl9/working_dir/Rtmp9e0cUK/file3cd3dcad8c473.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file deparse_usage.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
newargs is: data nrow ncol byrow dimnames dim start end frequency deltat ts.eps class names .Data ...
The Rd content was written to file StructureClasses.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file show.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file initialize-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file classRepresentation-class.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/Rtmp5iZgl9/working_dir/Rtmp9e0cUK/file3cd3dcad8c473.Rd
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file myshow-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file seq.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq()
\\method{seq}{default}()
seq.int()
seq_along()
seq_len()
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file tmp.Rd
Processing the Rd object...
The Rd content was written to file seqB.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
myseq(from, to, by = 1)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Parsing the Rd documentation in file seq.Rd ...
The Rd content was written to file seq2.Rd
Parsing the Rd documentation in file seq2.Rd ...
The Rd content was written to file seq3.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
══ Skipped tests (1) ═══════════════════════════════════════════════════════════
• empty test (1): 'test-char2Rdpiece.R:32:1'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test-bib.R:90:5'): bib works fine ───────────────────────────────────
<subscriptOutOfBoundsError/error/condition>
Error in `s[[i]]`: subscript out of bounds
Backtrace:
▆
1. ├─testthat::expect_warning(insert_ref("xxx", package = "rbibutils")) at test-bib.R:90:5
2. │ └─testthat:::quasi_capture(...)
3. │ ├─testthat (local) .capture(...)
4. │ │ └─base::withCallingHandlers(...)
5. │ └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
6. └─Rdpack::insert_ref("xxx", package = "rbibutils")
7. ├─base::tryCatch(...)
8. │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
9. │ └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
10. │ └─base (local) doTryCatch(return(expr), name, parentenv, handler)
11. ├─bibs[[key]]
12. └─utils:::`[[.bibentry`(bibs, key)
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
Error: Test failures
Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 2.6

Check: tests

Result: ERROR
Running ‘testthat.R’
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
> if(require("testthat")) {
+ library(testthat)
+ library(Rdpack)
+ test_check("Rdpack")
+ } else
+ warning("package 'testthat' required for 'Rdpack\'s' tests")
Loading required package: testthat
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/Rtmp5Z2Nzo/working_dir/RtmpCgxlay/file3ca9545e936f9c.Rd
Parsing the Rd documentation in file /tmp/Rtmp5Z2Nzo/working_dir/RtmpCgxlay/file3ca9545e936f9c.Rd ...
The Rd content was written to file /tmp/Rtmp5Z2Nzo/working_dir/RtmpCgxlay/file3ca954114c1558.Rd
Parsing the Rd documentation in file /data/gannet/ripley/R/packages/tests-devel/Rdpack.Rcheck/Rdpack/examples/reprompt.Rd ...
The Rd content was written to file /tmp/Rtmp5Z2Nzo/working_dir/RtmpCgxlay/file3ca954114c1558.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file deparse_usage.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
newargs is: data nrow ncol byrow dimnames dim start end frequency deltat ts.eps class names .Data ...
The Rd content was written to file StructureClasses.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file show.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file initialize-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file classRepresentation-class.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file /tmp/Rtmp5Z2Nzo/working_dir/RtmpCgxlay/file3ca954114c1558.Rd
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file myshow-methods.Rd
Rd source not supplied, looking for installed documentation.
Installed documentation found, processing it...
The Rd content was written to file seq.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq()
\\method{seq}{default}()
seq.int()
seq_along()
seq_len()
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Rd source not supplied, looking for installed documentation.
Rd source not supplied and installed documentation not found.
Trying a 'prompt' function to generate documentation for the object.
success: documentation generated using a 'prompt' function.
The Rd content was written to file tmp.Rd
Processing the Rd object...
The Rd content was written to file seqB.Rd
_<08>S_<08>e_<08>q_<08>u_<08>e_<08>n_<08>c_<08>e _<08>G_<08>e_<08>n_<08>e_<08>r_<08>a_<08>t_<08>i_<08>o_<08>n
_<08>D_<08>e_<08>s_<08>c_<08>r_<08>i_<08>p_<08>t_<08>i_<08>o_<08>n:
Generate regular sequences. 'seq' is a standard generic with a
default method. 'seq.int' is a primitive which can be much faster
but has a few restrictions. 'seq_along' and 'seq_len' are very
fast primitives for two common cases.
_<08>U_<08>s_<08>a_<08>g_<08>e:
seq(...)
## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
seq.int(from, to, by, length.out, along.with, ...)
seq_along(along.with)
seq_len(length.out)
myseq(from, to, by = 1)
_<08>A_<08>r_<08>g_<08>u_<08>m_<08>e_<08>n_<08>t_<08>s:
...: arguments passed to or from methods.
from, to: the starting and (maximal) end values of the sequence. Of
length '1' unless just 'from' is supplied as an unnamed
argument.
by: number: increment of the sequence.
length.out: desired length of the sequence. A non-negative number,
which for 'seq' and 'seq.int' will be rounded up if
fractional.
along.with: take the length from the length of this argument.
_<08>D_<08>e_<08>t_<08>a_<08>i_<08>l_<08>s:
Numerical inputs should all be finite (that is, not infinite,
'NaN' or 'NA').
The interpretation of the unnamed arguments of 'seq' and 'seq.int'
is _not_ standard, and it is recommended always to name the
arguments when programming.
'seq' is generic, and only the default method is described here.
Note that it dispatches on the class of the *first* argument
irrespective of argument names. This can have unintended
consequences if it is called with just one argument intending this
to be taken as 'along.with': it is much better to use 'seq_along'
in that case.
'seq.int' is an internal generic which dispatches on methods for
'"seq"' based on the class of the first supplied argument (before
argument matching).
Typical usages are
seq(from, to)
seq(from, to, by= )
seq(from, to, length.out= )
seq(along.with= )
seq(from)
seq(length.out= )
The first form generates the sequence 'from, from+/-1, ..., to'
(identical to 'from:to').
The second form generates 'from, from+by', ..., up to the sequence
value less than or equal to 'to'. Specifying 'to - from' and 'by'
of opposite signs is an error. Note that the computed final value
can go just beyond 'to' to allow for rounding error, but is
truncated to 'to'. ('Just beyond' is by up to 1e-10 times
'abs(from - to)'.)
The third generates a sequence of 'length.out' equally spaced
values from 'from' to 'to'. ('length.out' is usually abbreviated
to 'length' or 'len', and 'seq_len' is much faster.)
The fourth form generates the integer sequence '1, 2, ...,
length(along.with)'. ('along.with' is usually abbreviated to
'along', and 'seq_along' is much faster.)
The fifth form generates the sequence '1, 2, ..., length(from)'
(as if argument 'along.with' had been specified), _unless_ the
argument is numeric of length 1 when it is interpreted as '1:from'
(even for 'seq(0)' for compatibility with S). Using either
'seq_along' or 'seq_len' is much preferred (unless strict S
compatibility is essential).
The final form generates the integer sequence '1, 2, ...,
length.out' unless 'length.out = 0', when it generates
'integer(0)'.
Very small sequences (with 'from - to' of the order of 10^{-14}
times the larger of the ends) will return 'from'.
For 'seq' (only), up to two of 'from', 'to' and 'by' can be
supplied as complex values provided 'length.out' or 'along.with'
is specified. More generally, the default method of 'seq' will
handle classed objects with methods for the 'Math', 'Ops' and
'Summary' group generics.
'seq.int', 'seq_along' and 'seq_len' are primitive.
_<08>V_<08>a_<08>l_<08>u_<08>e:
'seq.int' and the default method of 'seq' for numeric arguments
return a vector of type '"integer"' or '"double"': programmers
should not rely on which.
'seq_along' and 'seq_len' return an integer vector, unless it is a
_long vector_ when it will be double.
_<08>R_<08>e_<08>f_<08>e_<08>r_<08>e_<08>n_<08>c_<08>e_<08>s:
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
Language_. Wadsworth & Brooks/Cole.
_<08>S_<08>e_<08>e _<08>A_<08>l_<08>s_<08>o:
The methods 'seq.Date' and 'seq.POSIXt'.
':', 'rep', 'sequence', 'row', 'col'.
_<08>E_<08>x_<08>a_<08>m_<08>p_<08>l_<08>e_<08>s:
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2) # matches 'end'
seq(1, 9, by = pi) # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
Parsing the Rd documentation in file seq.Rd ...
The Rd content was written to file seq2.Rd
Parsing the Rd documentation in file seq2.Rd ...
The Rd content was written to file seq3.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
Processing the Rd object...
The Rd content was written to file seq.Rd
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
══ Skipped tests (1) ═══════════════════════════════════════════════════════════
• empty test (1): 'test-char2Rdpiece.R:32:1'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test-bib.R:90:5'): bib works fine ───────────────────────────────────
<subscriptOutOfBoundsError/error/condition>
Error in `s[[i]]`: subscript out of bounds
Backtrace:
▆
1. ├─testthat::expect_warning(insert_ref("xxx", package = "rbibutils")) at test-bib.R:90:5
2. │ └─testthat:::quasi_capture(...)
3. │ ├─testthat (local) .capture(...)
4. │ │ └─base::withCallingHandlers(...)
5. │ └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
6. └─Rdpack::insert_ref("xxx", package = "rbibutils")
7. ├─base::tryCatch(...)
8. │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
9. │ └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
10. │ └─base (local) doTryCatch(return(expr), name, parentenv, handler)
11. ├─bibs[[key]]
12. └─utils:::`[[.bibentry`(bibs, key)
[ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
Error: Test failures
Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc