• The update_state() method gains an index argument for setting just some variables in an update.
  • Breaking change, with step (and so on with step_end) changing to time everywhere, in order to smooth the inclusion of continuous time models. This affects quite a few methods:
    • step() and set_step() become time() and set_time()
    • update_state()’s argument changes from step to time
  • Add min_log_likelihood support to $filter() (#361)
  • Allow use of $filter() with deterministic models (that support it)
  • Allow partial running of the filter from the current step up to some step part way through the data (#177)
  • Remove the functionality that allowed a vector of start times to be provided, as we were never using it and it simplifes things to remove it (#310)
  • Remove dust::dust_rng_state_long_jump now that we have proper distributed RNG state support (#343)
  • Removed methods $set_state, $reset and $set_pars which were deprecated in favour of $update_state in 0.9.21 (#273)
  • The names of different generator internal states has been simplified to lose the trailing state, e.g. xoshiro256star_state becomes xoshiro256star (#332)
  • Improved the interface for using dust’s random number support from other packages (#329)
  • New polar algorithm for normally distributed random numbers; faster than Box-Muller but slower than Ziggurat
  • Tweaked algorithm for Ziggurat so now ~10% faster by avoiding drawing a second random number when working with 64 bit integers
  • Added a new vignette describing the internals of the normal sampling algorithms (#325)
  • Added support for drawing normally distributed random numbers using the ziggurat method. Currently this is only efficient on a CPU, though supported on a GPU (#308)
  • Major header reorganisation, the dust::cuda namespace is now dust::gpu, most user-facing uses of cuda and device now replaced with gpu (#298, #317)
  • New (static) method real_size on every dust class for accessing the size of real_type, in bits (#301)
  • Support for the multinomial distribution. This differs from most other random number support because it returns a vector of values not a single number (#307)
  • Rationalised the GPU interface, now once created models can only be used on either the GPU or CPU which simplifies the internal bookkeeping (#292, #302)
  • Improved and generalised RNG interface, with more algorithms and more control
    • Expand set of included generators to 12 with different storage types, period and precision (#281)
    • Faster random number generation with single precision, using xoshiro128plus (#282)
    • Slightly faster real number generation for all generators by avoiding division (#280)
    • The dust_rng object has been refactored with methods changing names, a new behaviour when using multiple generators, and parallelisation (#279)
  • Type names have been standardised and we now avoid _t in favour of _type in line with the POSIX standard; this impacts all existing dust-using code (#278)
  • Density function names have changed from dust::dbinom to dust::density::binomial (and so on, #291)
  • Deprecate the previous state update methods ($reset(), $set_pars() and $set_state()) in favour of a single method that can update any or all of parameters, model state and time, $update_state() (#180)
  • Model determinism is now fixed at creation, rather than being settable via run and simulate, with deterministic now an argument to the constructor (#270)
  • Change to the dust::densities::dnbinom() to offer both of the same parameterisations as R’s dnbinom, explicitly as dust::densities::dnbinom_mu() and dust::densities::dnbinom_prob() (#171)
  • New function dust::dust_generate for creating a mini-package from a dust model for inspection or later loading (#204)
  • New option to dust::dust to skip the model cache, which may be useful when compiling with (say) different GPU options (#248)
  • Add two new vignettes covering model/data comparison and use on GPUs; see vignette("data") and vignette("cuda") (#183, #229)
  • Finer control over GPU settings, with the block size of run() now (optionally) exposed
  • On the GPU integers are kept in shared memory even where reals will no longer fit (#245)
  • Fix infinite loop with rbinom using floats
  • Synchronise possible divergences in the density functions (CUDA only) (#243)
  • Fix a possible issue with dnbinom in float mode with a small mean (#240)
  • Fix a bug when running the systematic resample in the particle filter in float mode (#238)
  • Fix a bug when running the CUDA version of the particle filter without history/trajectories.
  • Change real_t at compilation, and return information about the size of real_t from model objects (#233)
  • Add a CUDA version of the simulate method.
  • Move history and snapshot saving out of VRAM, and make it asynchronous.
  • Added CUDA version of the particle filter, run with model$filter(device = TRUE) (#224)
  • Removed functions dust::dust_simulate and dust::dust_iterate, which were deprecated in 0.7.9 (#215)
  • Invalid inputs in rbinom are converted into exceptions which are safely thrown even from parallel code (#190)
  • The filter method can save snapshots at points along a run (#176)
  • Reduce host and memcpy usage in device reorder by computing scatter index within the kernel (#198)
  • Fix issue with rnorm() running on a GPU (device code).
  • Fix issue with unaligned shared copy in CUDA code.
  • Don’t rewrite files with identical content during generation; this avoids recompilation of code across sessions when the argument workdir is used with dust::dust (#195)
  • Add GPU support (#73)
  • Improved handling of multi-parameter models, allowing parameter sets to be structured and handling of the special case of one particle per parameter set, outlined in vignette("multi") (#169)
  • Deprecate dust::dust_simulate and dust::dust_iterate which are replaced with a new method $simulate on the object which retains state and makes this more powerful (#100, #119, #121)
  • Allow set_pars method to be used with multiparameter dust objects (#125)
  • Enforce rule that once created a dust object may not change state size (i.e., the number of particles, state elements and number of parameter sets may not change). This was already assumed by mcstate
  • Beginnings of particle filter support, with a new $filter() method (only works for models with a compiled “compare” method) (#155)
  • More complete handling of $compare_data() with multiple parameters, with the dust::dust_data function now expanded to support this (#152)
  • Added new method $resample() which implements the resampling algorithm used by the mcstate particle filter (#137)
  • The $compare_data() method is better behaved with multi-parameter dust objects, returning a matrix (#136)
  • Added new methods $n_particles() and $n_state() to every dust model which can be used to query the size of the state (#149)
  • Dust models must now specify two internal types, internal_t and shared_t. The latter is a pointer to constant data shared across all particles within a parameter set (#143)
  • Support for some basic density functions within the header <dust/densities.hpp>. Supported distributions include dbinom, dnbinom, dbetabinom and dpois. These are included for use within comparison functions (#134)
  • Compiled “comparison” functions are supported, designed to compute likelihoods for mcstate; this interface will be expanded and documented in a future release (#129)
  • The data argument (and along with it things like set_data) have moved to become pars as that is how we’re using it, and to make space for a future data element (#130)
  • Add support for rexp from dust model, just using inversion for now (#127)
  • Start of support for running dust objects with multiple data/parameter sets at once (#92)
  • New method set_n_threads() for changing the number of OpenMP threads after initialisation (#122)
  • dust::dust_simulate() can return the entire model end state (#119)
  • New $set_data() method, similar to reset but changing only the data/parameters mid-model run, holding state and everything else identical (#114)
  • Add support for configuring dust generation using C++ pseudo-attributes.
  • Back out the interleaved rng state from 0.5.0, which is causing a performance regression
  • Remove prototype GPU interface, in preparation for a new version (#109)
  • The rng objects (dust_rng) also get a $set_state() method (primarily of debugging interest)
  • New $set_rng_state() method, the inverse to $rng_state() for taking a previously saved state and setting it into a model (#??)
  • dust::dust_iterate now copies names from the index as rownames (#101)
  • The “low n * p” branch of the binomial distribution now uses a slightly faster algorithm (#91)
  • dust::dust_package() validates that the package contains a suitable src/Makevars for use with openmp, or creates one if missing (#95)
  • Some examples are now compiled into the package and available via dust::dust_example(), reducing the need for a compiler for exploration and making examples and testing faster (#89)
  • Change of behaviour for seed, which now seeds from R’s random number if given the default value of NULL (#85, #87)
  • The rng_state method can optionally advance the random number stream, making it more suitable for use with dust::dust_simulate
  • A new utility dust::dust_rng_long_jump which can advance the saved state of a dust RNG, suitable for creating independent streams from one saved state.
  • Helper function dust::dust_simulate is renamed to dust::dust_iterate
  • New function dust::dust_simulate which simulates many parameter sets and starting points at once, possibly in parallel (#84)
  • If $set_index() uses a named index vector, then those names are copied back as rownames on the returned matrix. Similarly, if $state() is used with a named index then those names are used as rownames (#81)
  • Can now generate dust objects that run on the GPU (#69)
  • Overhaul of the RNG interface, where we now pass state and use free functions; this is needed to support future development work (#60)
  • New $rng_state() method for getting the RNG state as a raw vector
  • Use cpp11 as the backend (#22)
  • Simpler RNG interface; we now always use as many RNG streams as there are particles (#51)
  • New function dust::dust_simulate which provides a helper for running a simulation while collecting output (#7)
  • Allow $set_state() to accept an initial state of NULL, in which case only the time is set (#48)
  • Allow $set_state() to accept an initial step too. This can be a vector if particles start at different initial steps, in which case all particles are run up to the latest step (#45)
  • Allow $set_state() to accept a matrix in order to start particles with different starting values (#43)