WeightedRandom.Backend behaviour (weighted_random v1.0.0-rc.1)

Copy Markdown View Source

WeightedRandom.Backend offers a contract to all who implement it:

  1. The main WeightedRandom package presents a novel interface for generating a list of probabilities (floats that can be summed to equal exactly 1.0).
  2. The custom Backend module decides what to do with those probabilities once they are generated.

To create your own backend, copy the module WeightedRandom.Backend.Linear and make changes to the functions.

To use a different backend, you can either pass it in as an opt (see function docs), or you can put it in your config file:

config :weighted_random,
  backend: Your.Backend.Module

Summary

Types

backend_opts()
index()
indices()
opts()
percentage()
probability_type()
t()
table()
weight()
weights()

Callbacks

options()

Optionally provide the opts kwli

preprocess(input, opts)

weights is a list of floats which, if summed, would equal exactly 1.0. Each float represents the probability of being selected in the random sample.

take(table, count)

Given the struct returned by preprocess/2, return a list of random indices equal to count.

Functions

list_probability_types()
preprocess(backend, input, opts)
take(map, count)

Types

backend_opts()

@type backend_opts() :: [{:probability_type, probability_type()}]

index()

@type index() :: integer()

indices()

@type indices() :: [index()]

opts()

@type opts() :: keyword()

percentage()

@type percentage() :: float()

probability_type()

@type probability_type() :: :weights | :probabilities

t()

@type t() :: %WeightedRandom.Backend{
  backend: atom(),
  outcomes: list(),
  table: struct()
}

table()

@type table() :: struct()

weight()

@type weight() :: WeightedRandom.Input.Weight.t()

weights()

@type weights() :: [weight()]

Callbacks

options()

(optional) 
@callback options() :: keyword()

Optionally provide the opts kwli

preprocess(input, opts)

@callback preprocess(input :: WeightedRandom.Input.t(), opts :: opts()) :: table()

weights is a list of floats which, if summed, would equal exactly 1.0. Each float represents the probability of being selected in the random sample.

So if given [0.25, 0.25, 0.5], then index 2 is twice as likely to be sampled as index 1.

This function must return some kind of struct that will later be passed into take/2.

take(table, count)

@callback take(table :: struct(), count :: integer()) :: indices :: [index :: integer()]

Given the struct returned by preprocess/2, return a list of random indices equal to count.

Functions

list_probability_types()

preprocess(backend, input, opts)

take(map, count)