The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.

nhppp 1.1.1

nhppp 1.1.0

New features — two orthogonal truncation option classes - REPORTING (report_first_K, report_last_K; at most one may be set): return only the earliest / latest min(N, K) events of the realization. These are reporting truncations — the count law of the sampled process is unchanged. atmost1 remains as the alias for report_first_K = 1. - GENERATION conditioning (generate_at_least_K, generate_at_most_K; combinable with K1 <= K2): change the sampled law to X | K1 <= N <= K2. generate_at_least_K = 1 alone is the zero-truncated case (atleast1 remains as its alias); generate_at_least_K = generate_at_most_K = K conditions on exactly K events — which is NOT the same object as reporting the first K of an N >= K draw (the reported-first-K times are biased early relative to the exactly-K law). Conditioned sampling uses the exact order-statistics construction with a doubly-truncated Poisson count, drawn by inversion of the CDF restricted to the truncation region (upper-tail parameterization, numerically stable deep in the right tail; primitives rbtpois() in R and rbtpois/rbtpois_vec in C++). Any generation bound routes to the order-statistics kernels; without generation bounds the sequential inversion kernels are used (they cannot condition on the future total). - vdraw_cumulative_intensity() supports the full option set: any generation bound switches from sequential inversion to the exact order-statistics construction on the Lambda scale (doubly-truncated Poisson count; the ascending uniforms on (Lambda(t_min), Lambda(t_max)) are drawn as normalized Exp(1) spacings and mapped through Lambda_inv), and report_last_K is honored on all paths. - The vectorized thinning samplers support both generation bounds by rejection resampling (proposals push only the lower bound into the majorizer; the accepted-count condition is verified per row). The scalar thinning samplers support only generate_at_least_K = 1. - The scalar samplers ppp(), draw_sc_linear(), draw_sc_loglinear(), draw_cumulative_intensity() and draw_intensity() accept the full option set (report_first_K, report_last_K, atleast1, generate_at_least_K, generate_at_most_K), like draw_sc_step() and draw(). Any generation bound routes to the zero-truncated twin (ztppp(), ztdraw_sc_linear(), ztdraw_sc_loglinear(), ztdraw_cumulative_intensity()); draw_intensity() supports only generate_at_least_K = 1. The new arguments follow the existing ones, and calls that do not use them return the same draws as before. - budget_cap replaces atmostB (soft-deprecated alias with a warning): it caps the computational event budget of the vectorized kernels and is an approximation knob (jointly with the 1 - tol quantile bound), not an exact reporting or conditioning contract. It is now honored uniformly by all vectorized sc-step paths (the whole-range regular path used to ignore atmostB silently) and never truncates the conditioned count below generate_at_least_K.

Internals - The eight sc-step C++ kernels (regular/general x plain/zt x whole-range/subinterval) are unified into two template algorithm cores over two grid policies (src/sc_step_core.h); whole-range sampling is the subinterval special case. Net deletion of ~300 lines with no performance loss: the whole-range paths are ~6x faster (the fixed-size blocked Exp(1) draw is replaced by lazy per-event draws), the zero-truncated paths ~1.5x faster, and the subinterval paths ~1.2x faster in the included benchmark (benchmarks/bench_sc_step_unify.R). - The zero-truncated kernels now honor tol instead of a hard-coded .99999 event-count quantile. - Test infrastructure: the sample-validity helper checks matrices with whole-matrix operations instead of per-row testthat expectations (the suite drops from ~15 minutes to ~15 seconds on the 10^4-row distributional fixtures), and the distributional tests (Q-Q agreement, chi-square, and Kolmogorov-Smirnov assertions) are skipped on CRAN. - Copy/allocation fixes: no per-event row materialization in the interval search, fused Lambda construction, no dead matrix pre-allocations, column trimming skips the copy when nothing is trimmed, 1-row range_t/t_min/t_max inputs are shared across rows instead of being replicated at the R level. - New on-demand R-hub v2 workflow (.github/workflows/rhub.yaml) for sanitizer and valgrind checks. The unified kernels are clean under clang-ASan, gcc-ASan, and valgrind (the one valgrind finding is a small leak in the rstream dependency, not in nhppp code).

Structured argument containers for user functions - The args containers (lambda_args, Lambda_args) now have two explicit channels: shared (a named list of row-invariant arguments of any type, stored once and never replicated across point processes) and row_args (a data.frame or data.table with one row per point process, validated for row count and automatically row-subset by the rejection loops). The container is passed as the user function’s SECOND POSITIONAL argument, exactly as given except that row_args is already subset; the name of the second formal is the user’s choice. - Deprecations and compatibility: a flat list with neither recognized element keeps its released all-shared behavior with no warning (thinning family); the nested vector_arguments data.table convention is deprecated (mapped onto row_args semantics, warning once per call); Lambda_inv_args is deprecated — one Lambda_args container is delivered to both Lambda and Lambda_inv. For vdraw_cumulative_intensity(), flat/legacy containers keep the released named-argument call (Lambda(t, Lambda_args = ...)) with a deprecation warning; structured containers get the positional call. When no arguments are supplied at all, user functions are now called with a single argument (Lambda(t) instead of Lambda(t, Lambda_args = NULL)), so plain one-argument closures work everywhere. - row_args/vector_arguments accept plain data.frames (the data.table requirement is dropped; data.tables are still accepted as-is, read-only, never coerced or copied). - New vignette “How to write an intensity or cumulative intensity function for vectorized models”: the calling contract, the structured container and its alignment idiom, majorizer construction, a worked thinning-vs-inversion example, and the anti-patterns. - get_step_majorizer() gains fun_args, taking the same container with the same delivery convention, so the sampler’s lambda can be used for majorizer construction without hand-wrapping.

Thinning (intensity) family - New vdraw_intensity_step(): vectorized thinning sampler with piecewise constant majorizers over arbitrary interval bounds (time_breaks, as in vdraw_sc_step()); the target intensity remains an arbitrary vectorized R function. Generalizes vdraw_intensity(), which assumes equal-length intervals. Both share one C++ template core (src/intensity_step_core.h). - Count conditioning on the vectorized thinning samplers (vdraw_intensity(), vdraw_intensity_step()): conditioning is by rejection — candidate realizations are proposed from the majorizer conditioned on at least K1 majorizer events (exact: only the lower bound may be pushed into the proposal), thinned, and rows whose accepted count falls outside [K1, K2] are resampled. The per-round acceptance probability degrades in the strictness of the bounds and in the looseness of the majorizer; there is no iteration cap. Special case K1 = K2 = K (exactly K events): only under-counts are rejected — rows with more than K survivors are salvaged exactly by keeping a uniformly random size-K subset of the events (conditionally-iid times make the subset an exact exactly-K draw regardless of the surviving count, with no knowledge of the integrated target intensity), avoiding the near-zero two-sided acceptance probability when the target integrated intensity is large relative to K. The scalar thinning samplers support only generate_at_least_K = 1. - The thinning kernels now error when lambda exceeds the majorizer also on the conditioned path (the old R-only zero-truncated path silently capped acceptance probabilities above 1, sampling from the wrong process when the majorizer was invalid). The internal vdraw_intensity_step_regular_forcezt() is removed, superseded by the conditioned C++ kernel.

Long-format output for the vectorized samplers - New output = c("matrix", "long") argument on the sc-step samplers (vdraw_sc_step(), vztdraw_sc_step(), vdraw_sc_step_regular() and the _cpp kernels) and on vdraw_cumulative_intensity() / vdraw(). "long" returns list(id, time, n_draws) with one entry per event: id is the 1-based point-process index (ascending, times ascending within id). A point process with zero events contributes no entries — its id is absent, and n_draws distinguishes “no events” from “not sampled”; no NA is used. The C++ paths build the long format directly (no dense intermediate; accumulator reserve()d from the expected Lambda mass), so it is preferred when event counts vary widely across point processes: in the included benchmark (10^6 processes, mean ~1 event, max ~40), 404 MB dense vs 11.5 MB long, and ~30% faster. RNG consumption is identical across the two outputs, so a same-seed dense and long draw hold the same event values. On the conditioned vdraw_cumulative_intensity() path, Lambda_inv is called on the event vector with row_args subset to one row per event (aligned by id). The thinning samplers do not take output yet. - New vignette “Long event output for large simulations” showing the two formats side by side, the no-event semantics, and the memory/time comparison as event-count heterogeneity grows.

Documentation - Reference examples modernized to the current API: draw(), vdraw(), and vdraw_cumulative_intensity() gain examples (they had none); the structured args containers, the generation bounds (including exactly-K), the reporting truncations, and get_step_majorizer(fun_args = ) are now demonstrated on the reference pages. Vignette code uses budget_cap and the reporting/generation vocabulary throughout.

Breaking change (random streams only) - Same-seed results differ from 1.0.5.x for the vectorized sc-step, zero-truncated, and thinning samplers: the package guarantees the sampled process distribution, not the number or order of RNG calls. Users relying on common random numbers should block RNG streams themselves.

New features - Add vdraw_sc_step() and vztdraw_sc_step(): vectorized sampling from piecewise constant intensities where intervals need not be equally spaced. The time_breaks argument accepts a vector of K+1 bounds shared by all point processes, or an n x (K+1) matrix with one row of bounds per point process (a 1-row matrix is treated as shared and is not replicated in memory; the C++ kernels index row 0 directly). - Both lambda_matrix (per-interval rates) and Lambda_matrix (cumulative at interval ends) forms are supported, as are t_min/t_max subintervals, atmost1, atmostB, and atleast1 (which routes to the zero-truncated sampler), matching the vdraw_sc_step_regular() interface. - New vignette “Step intensities over arbitrary intervals” showcasing vdraw_sc_step() / vztdraw_sc_step() on standard demographic age bands, with a timing study against vdraw_sc_step_regular(). - Implementation: new C++ kernels (vdraw_sc_step_general[2], vztdraw_sc_step_general[2], step_general_inverse, find_break_interval) that mirror the *_regular kernels with the three regularity operations replaced: per-interval widths in the rate-to-cumulative conversion, binary search over breaks for time-to-interval lookup, and breaks-based index+fraction-to-time reconstruction. Existing *_regular kernels are untouched, so previously drawn seeds reproduce exactly.

Bug fixes (each with a regression test) - vdraw_intensity_step_regular_cpp() / vdraw_intensity() / vdraw(): the thinning step looked up the majorizer in the wrong interval whenever the interval length differed from 1 (misplaced parenthesis in the index arithmetic), distorting the acceptance ratio or throwing “Majorizer error”. Draws from these functions change (are now correct) when the interval length is not 1. - vdraw_sc_step_regular_cpp() / vztdraw_sc_step_regular_cpp(): a subinterval bound equal to rate_matrix_t_max read past the end of the cumulative-intensity row (out-of-bounds read). Indices and fractions are now clamped; results on previously-correct inputs are unchanged. - vdraw(): supplying only Lambda_maj_matrix now routes to the thinning sampler as documented instead of erroring (dispatch condition tested lambda_maj_matrix twice). - vztdraw_intensity() (internal): range_t was not passed through to vztdraw_intensity_step_regular() and every call errored.

Tests and validation - New test files cover shared and per-row breaks, subintervals, argument validation, seed reproducibility, rlecuyer streams, and cross-validation: same-seed agreement with the *_regular kernels on equal-spaced breaks, bitwise shared-vs-replicated-breaks equality, and distributional agreement with scalar draw_sc_step(). - Full suite: 36,367 assertions, 0 failures; R CMD check: 0 errors, 0 warnings, 0 notes.

nhppp 1.0.5

nhppp 1.0.4

nhppp 1.0.3

nhppp 1.0.2

nhppp 1.0.1

nhppp 1.0.0

nhppp 0.2.1

nhppp 0.2.0

nhppp 0.1.4

nhppp 0.1.3

nhppp 0.1.2

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.