package prbnmcn-dagger-test

You can search for identifiers within the package.

in-package search v0.2.0

prbnmcn-dagger-test
- Dagger_tests
  - Basic_consistency
    
    Dist
    
    Dist_smc
    
    Dists
    
    Gen
    
    Infix
    
    Rational
    
    Lmh
    
    Lmh_incremental
    
    Make
    
    Dists
    
    N
    
    Runner
    
    Smc_stratified
    
    Smc_systematic
  - Biased_coin
  - Diffusions
  - Linear_regression
    
    Smc
    
    FM
    
    Basis
    
    Map
    
    R
    
    Table
    
    Traced
    
    Traced_incremental
  - Map_array
    
    Pure
    
    Infix
  - Poly
    
    Poly
    
    Smc
    
    Array_ops
    
    Infix
    
    List_ops
    
    Seq_ops
    
    Smc_types
  - Random_walks
  - Resampling_test
    
    Dist
    
    R
    
    Rat
  - Sprinkler
    
    Traced
    
    Traced_incremental
  - Yield

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'a t

val return : 'a -> 'a t

val bind : 'a t -> ('a -> 'b t) -> 'b t

val map : 'a t -> ('a -> 'b) -> 'b t

val map2 : 'a t -> 'b t -> ('a -> 'b -> 'c) -> 'c t

val map_array : 'a t array -> ('a array -> 'b) -> 'b t

val if_ : bool t -> (bool -> 'a t) -> 'a t

module Infix : sig ... end

type !'a dist = Stdlib.Random.State.t -> 'a

val sample : 'a dist -> 'a t

val map_score : 'a t -> ('a -> float) -> 'a t

val map_log_score : 'a t -> ('a -> Dagger__.Log_space.t) -> 'a t

val score : float -> unit t

val log_score : Dagger__.Log_space.t -> unit t

module List_ops : sig ... end

module Array_ops : sig ... end

module Seq_ops : sig ... end

type particle_output = Smc_types.particle_output

type resampling_state = Smc_types.resampling_state

val fork : int -> unit t

val get_score : Dagger__.Log_space.t t

val set_score : Dagger__.Log_space.t -> unit t

val yield : particle_output -> resampling_state t

type !'a population = {

terminated : ('a * float) array;
active : (particle_output * float) array;
total_mass : float;

}

exception Invalid_population

val run : 
  ?nthreads:int ->
  (particle_output, float, resampling_state) Dagger__.Resampling.strategy ->
  resampling_state ->
  npart:int ->
  'a t ->
  Dagger__.RNG.t ->
  'a population Stdlib.Seq.t

val run_custom : 
  ?nthreads:int ->
  (particle_output, float, resampling_state) Dagger__.Resampling.strategy ->
  resampling_state ->
  npart:int ->
  (int -> 'a t) ->
  Dagger__.RNG.t ->
  'a population Stdlib.Seq.t