variate

alias

ALIAS method to generate random variate from discrete probability distribution

class AliasMethod(probabilities: array, states: Callable[[list[int]], Any])

Bases: Sampling

Alias Method

__init__(probabilities: array, states: Callable[[list[int]], Any])

Parameters

• probabilities – vector of probabilities (which must sum to 1)

• states – discrete spatial states

cost()

Returns

the computing cost of the algorithm for generating the random variable the cost will usually correspond to the number of generated uniform random variables

reset_sampling_cost()

reset the simulation cost to 0

sample(size: int = 1) → array

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

create_alias(probabilities)

Initialisation of the ALIAS method

binarysearchtree

Binary Search Tree method to generate discrete probability distribution

class BinarySearchTree(probabilities: array, states: Callable[[list[int]], Any])

Bases: Sampling

__init__(probabilities: array, states: Callable[[list[int]], Any])

sample(size: int = 1) → ndarray[Any, dtype[float]]

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

sample_with_u(u)

create_binary_search_tree(probabilities)

binarysearchtreeadapted

Binary Search Tree method. The term adapted means two things: - the probabilities of the tree are computed on the fly, contrary to the usual binary search tree where the probabilities are pre-computed. - it is adapted to our purpose, that is to the simulation CTMC processes, but the code could be made generic to be adapted to other simulation algorithms

class Point(coordinates, value)

Bases: object

Representation of a point in the state grid

__init__(coordinates, value)

Parameters

• coordinates – coordinates (x1, x2, x3,…)

• value – values (y1, y2, y3, …)

coordinates

value

class BinarySearchTreeAdapted1D(model: LevyModel, grid: CTMCGrid, intensity_of_jumps: float)

Bases: Sampling

__init__(model: LevyModel, grid: CTMCGrid, intensity_of_jumps: float)

sample(size: int = 1) → array

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

sample_with_u(u: float)

class BinarySearchTreeAdapted(model: LevyModel, grid: CTMCGrid)

Bases: Sampling

__init__(model: LevyModel, grid: CTMCGrid)

cost() → int

Returns

the computing cost of the algorithm for generating the random variable the cost will usually correspond to the number of generated uniform random variables

reset_sampling_cost() → None

reset the simulation cost to 0

sample(size: int = 1) → array

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

sample_with_us(us: array)

sample_one_bucket(coordinates, probability: float)

huffmantree

Huffman’s Tree method to generate discrete probability distribution

class HuffmanTree(probabilities: array, states: Callable[[list[int]], Any])

Bases: Sampling

__init__(probabilities: array, states: Callable[[list[int]], Any])

sample(size: int = 1) → ndarray[Any, dtype[float]]

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

sample_with_u(u: float, head: Node) → tuple[int, int]

class Node(value: float, is_leaf: bool)

Bases: object

A node in the tree is defined by its value and whether it is a leaf (or has children nodes)

__init__(value: float, is_leaf: bool)

value

is_leaf

class InternalNode(value: float, left_node: Node, right_node: Node)

Bases: Node

An internal node is not a lead, that is it has at least a left node child or a right node child

__init__(value: float, left_node: Node, right_node: Node)

left_node

right_node

class Leaf(value: float, state: int)

Bases: Node

A leaf node has no children

__init__(value: float, state: int)

state

class Heap(nodes: [<class 'distribution.variate.huffmantree.Node'>])

Bases: object

__init__(nodes: [<class 'distribution.variate.huffmantree.Node'>])

pop() → Node

insert(node: Node)

create_huffman_tree(probabilities) → Node

inversion

INVERSION method to generate random variate from discrete probability distribution

class InversionMethod(probability_to_jump_to_state: Callable[[tuple[int, ...]], float], state_manager: StatesManager)

Bases: Sampling

Inversion method

The inversion method might be slower than other methods but one of the benefits is that there is no pre-computation and therefore no (much) impact on memory

__init__(probability_to_jump_to_state: Callable[[tuple[int, ...]], float], state_manager: StatesManager)

cost() → int

Returns

the computing cost of the algorithm for generating the random variable the cost will usually correspond to the number of generated uniform random variables

reset_sampling_cost()

reset the simulation cost to 0

sample(size: int = 1) → list[tuple[int, ...]]

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

sample_with_u(u: float) → tuple[int, ...]

table

TABLE method to generate random variate from discrete probability distribution

class TableMethod(probabilities: array, states: Callable[[list[int]], Any])

Bases: Sampling

Table method - 32bit implementation

__init__(probabilities: array, states: Callable[[list[int]], Any])

sample(size: int = 1) → ndarray[Any, dtype[float]]

sample a random variable corresponding the distribution in scope

Parameters

size – size of the sampling vector

Returns

the array of simulated variables

create_table(probabilities, states)