convert

Conversion functions.

See the documentation on PyPhi Transition probability matrix conventions for information on the different representations that these functions convert between.

pyphi.convert.reverse_bits(i, n)

Reverse the bits of the n-bit decimal number i.

Examples

>>> reverse_bits(12, 7)
24
>>> reverse_bits(0, 1)
0
>>> reverse_bits(1, 2)
2
pyphi.convert.nodes2indices(nodes)

Convert nodes to a tuple of their indices.

pyphi.convert.nodes2state(nodes)

Convert nodes to a tuple of their states.

pyphi.convert.be2le(i, n)

Convert between big-endian and little-endian for indices in range(n).

pyphi.convert.le2be(i, n)

Convert between big-endian and little-endian for indices in range(n).

pyphi.convert.state2be_index(state)

Convert a PyPhi state-tuple to a decimal index according to the big-endian convention.

Parameters:state (tuple[int]) – A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Returns:A decimal integer corresponding to a network state under the big-endian convention.
Return type:int

Examples

>>> state2be_index((1, 0, 0, 0, 0))
16
>>> state2be_index((1, 1, 1, 0, 0, 0, 0, 0))
224
pyphi.convert.state2le_index(state)

Convert a PyPhi state-tuple to a decimal index according to the little-endian convention.

Parameters:state (tuple[int]) – A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Returns:A decimal integer corresponding to a network state under the little-endian convention.
Return type:int

Examples

>>> state2le_index((1, 0, 0, 0, 0))
1
>>> state2le_index((1, 1, 1, 0, 0, 0, 0, 0))
7
pyphi.convert.le_index2state(i, number_of_nodes)

Convert a decimal integer to a PyPhi state tuple with the little-endian convention.

The output is the reverse of be_index2state().

Parameters:i (int) – A decimal integer corresponding to a network state under the little-endian convention.
Returns:A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Return type:tuple[int]

Examples

>>> number_of_nodes = 5
>>> le_index2state(1, number_of_nodes)
(1, 0, 0, 0, 0)
>>> number_of_nodes = 8
>>> le_index2state(7, number_of_nodes)
(1, 1, 1, 0, 0, 0, 0, 0)
pyphi.convert.be_index2state(i, number_of_nodes)

Convert a decimal integer to a PyPhi state tuple using the big-endian convention that the most-significant bits correspond to low-index nodes.

The output is the reverse of le_index2state().

Parameters:i (int) – A decimal integer corresponding to a network state under the big-endian convention.
Returns:A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Return type:tuple[int]

Examples

>>> number_of_nodes = 5
>>> be_index2state(1, number_of_nodes)
(0, 0, 0, 0, 1)
>>> number_of_nodes = 8
>>> be_index2state(7, number_of_nodes)
(0, 0, 0, 0, 0, 1, 1, 1)
pyphi.convert.be2le_state_by_state(tpm)

Convert a state-by-state TPM from big-endian to little-endian or vice versa.

Parameters:tpm (np.ndarray) – A state-by-state TPM.
Returns:The state-by-state TPM in the other indexing format.
Return type:np.ndarray

Example

>>> tpm = np.arange(16).reshape([4, 4])
>>> be2le_state_by_state(tpm)
array([[ 0.,  1.,  2.,  3.],
       [ 8.,  9., 10., 11.],
       [ 4.,  5.,  6.,  7.],
       [12., 13., 14., 15.]])
pyphi.convert.le2be_state_by_state(tpm)

Convert a state-by-state TPM from big-endian to little-endian or vice versa.

Parameters:tpm (np.ndarray) – A state-by-state TPM.
Returns:The state-by-state TPM in the other indexing format.
Return type:np.ndarray

Example

>>> tpm = np.arange(16).reshape([4, 4])
>>> be2le_state_by_state(tpm)
array([[ 0.,  1.,  2.,  3.],
       [ 8.,  9., 10., 11.],
       [ 4.,  5.,  6.,  7.],
       [12., 13., 14., 15.]])
pyphi.convert.to_multidimensional(tpm)

Reshape a state-by-node TPM to the multidimensional form.

See documentation for the Network object for more information on TPM formats.

pyphi.convert.to_2dimensional(tpm)

Reshape a state-by-node TPM to the 2-dimensional form.

See Transition probability matrix conventions and documentation for the Network object for more information on TPM representations.

pyphi.convert.state_by_state2state_by_node(tpm)

Convert a state-by-state TPM to a state-by-node TPM.

Danger

Many nondeterministic state-by-state TPMs can be represented by a single a state-by-state TPM. However, the mapping can be made to be one-to-one if we assume the state-by-state TPM is conditionally independent, as this function does. If the given TPM is not conditionally independent, the conditional dependencies will be silently lost.

Note

The indices of the rows and columns of the state-by-state TPM are assumed to follow the little-endian convention. The indices of the rows of the resulting state-by-node TPM also follow the little-endian convention. See the documentation on PyPhi the Transition probability matrix conventions more information.

Parameters:tpm (list[list] or np.ndarray) – A square state-by-state TPM with row and column indices following the little-endian convention.
Returns:A state-by-node TPM, with row indices following the little-endian convention.
Return type:np.ndarray

Example

>>> tpm = np.array([[0.5, 0.5, 0.0, 0.0],
...                 [0.0, 1.0, 0.0, 0.0],
...                 [0.0, 0.2, 0.0, 0.8],
...                 [0.0, 0.3, 0.7, 0.0]])
>>> state_by_state2state_by_node(tpm)
array([[[0.5, 0. ],
        [1. , 0.8]],
<BLANKLINE>
       [[1. , 0. ],
        [0.3, 0.7]]])
pyphi.convert.state_by_node2state_by_state(tpm)

Convert a state-by-node TPM to a state-by-state TPM.

Important

A nondeterministic state-by-node TPM can have more than one representation as a state-by-state TPM. However, the mapping can be made to be one-to-one if we assume the TPMs to be conditionally independent. Therefore, this function returns the corresponding conditionally independent state-by-state TPM.

Note

The indices of the rows of the state-by-node TPM are assumed to follow the little-endian convention, while the indices of the columns follow the big-endian convention. The indices of the rows and columns of the resulting state-by-state TPM both follow the big-endian convention. See the documentation on PyPhi Transition probability matrix conventions for more info.

Parameters:tpm (list[list] or np.ndarray) – A state-by-node TPM with row indices following the little-endian convention and column indices following the big-endian convention.
Returns:A state-by-state TPM, with both row and column indices following the big-endian convention.
Return type:np.ndarray
>>> tpm = np.array([[1, 1, 0],
...                 [0, 0, 1],
...                 [0, 1, 1],
...                 [1, 0, 0],
...                 [0, 0, 1],
...                 [1, 0, 0],
...                 [1, 1, 1],
...                 [1, 0, 1]])
>>> state_by_node2state_by_state(tpm)
array([[0., 0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 1., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 0., 0., 1., 0., 0.]])
pyphi.convert.b2l(i, n)

Convert between big-endian and little-endian for indices in range(n).

pyphi.convert.l2b(i, n)

Convert between big-endian and little-endian for indices in range(n).

pyphi.convert.l2s(i, number_of_nodes)

Convert a decimal integer to a PyPhi state tuple with the little-endian convention.

The output is the reverse of be_index2state().

Parameters:i (int) – A decimal integer corresponding to a network state under the little-endian convention.
Returns:A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Return type:tuple[int]

Examples

>>> number_of_nodes = 5
>>> le_index2state(1, number_of_nodes)
(1, 0, 0, 0, 0)
>>> number_of_nodes = 8
>>> le_index2state(7, number_of_nodes)
(1, 1, 1, 0, 0, 0, 0, 0)
pyphi.convert.b2s(i, number_of_nodes)

Convert a decimal integer to a PyPhi state tuple using the big-endian convention that the most-significant bits correspond to low-index nodes.

The output is the reverse of le_index2state().

Parameters:i (int) – A decimal integer corresponding to a network state under the big-endian convention.
Returns:A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Return type:tuple[int]

Examples

>>> number_of_nodes = 5
>>> be_index2state(1, number_of_nodes)
(0, 0, 0, 0, 1)
>>> number_of_nodes = 8
>>> be_index2state(7, number_of_nodes)
(0, 0, 0, 0, 0, 1, 1, 1)
pyphi.convert.s2l(state)

Convert a PyPhi state-tuple to a decimal index according to the little-endian convention.

Parameters:state (tuple[int]) – A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Returns:A decimal integer corresponding to a network state under the little-endian convention.
Return type:int

Examples

>>> state2le_index((1, 0, 0, 0, 0))
1
>>> state2le_index((1, 1, 1, 0, 0, 0, 0, 0))
7
pyphi.convert.s2b(state)

Convert a PyPhi state-tuple to a decimal index according to the big-endian convention.

Parameters:state (tuple[int]) – A state-tuple where the \(i^{\textrm{th}}\) element of the tuple gives the state of the \(i^{\textrm{th}}\) node.
Returns:A decimal integer corresponding to a network state under the big-endian convention.
Return type:int

Examples

>>> state2be_index((1, 0, 0, 0, 0))
16
>>> state2be_index((1, 1, 1, 0, 0, 0, 0, 0))
224
pyphi.convert.b2l_sbs(tpm)

Convert a state-by-state TPM from big-endian to little-endian or vice versa.

Parameters:tpm (np.ndarray) – A state-by-state TPM.
Returns:The state-by-state TPM in the other indexing format.
Return type:np.ndarray

Example

>>> tpm = np.arange(16).reshape([4, 4])
>>> be2le_state_by_state(tpm)
array([[ 0.,  1.,  2.,  3.],
       [ 8.,  9., 10., 11.],
       [ 4.,  5.,  6.,  7.],
       [12., 13., 14., 15.]])
pyphi.convert.l2b_sbs(tpm)

Convert a state-by-state TPM from big-endian to little-endian or vice versa.

Parameters:tpm (np.ndarray) – A state-by-state TPM.
Returns:The state-by-state TPM in the other indexing format.
Return type:np.ndarray

Example

>>> tpm = np.arange(16).reshape([4, 4])
>>> be2le_state_by_state(tpm)
array([[ 0.,  1.,  2.,  3.],
       [ 8.,  9., 10., 11.],
       [ 4.,  5.,  6.,  7.],
       [12., 13., 14., 15.]])
pyphi.convert.to_md(tpm)

Reshape a state-by-node TPM to the multidimensional form.

See documentation for the Network object for more information on TPM formats.

pyphi.convert.to_2d(tpm)

Reshape a state-by-node TPM to the 2-dimensional form.

See Transition probability matrix conventions and documentation for the Network object for more information on TPM representations.

pyphi.convert.sbn2sbs(tpm)

Convert a state-by-node TPM to a state-by-state TPM.

Important

A nondeterministic state-by-node TPM can have more than one representation as a state-by-state TPM. However, the mapping can be made to be one-to-one if we assume the TPMs to be conditionally independent. Therefore, this function returns the corresponding conditionally independent state-by-state TPM.

Note

The indices of the rows of the state-by-node TPM are assumed to follow the little-endian convention, while the indices of the columns follow the big-endian convention. The indices of the rows and columns of the resulting state-by-state TPM both follow the big-endian convention. See the documentation on PyPhi Transition probability matrix conventions for more info.

Parameters:tpm (list[list] or np.ndarray) – A state-by-node TPM with row indices following the little-endian convention and column indices following the big-endian convention.
Returns:A state-by-state TPM, with both row and column indices following the big-endian convention.
Return type:np.ndarray
>>> tpm = np.array([[1, 1, 0],
...                 [0, 0, 1],
...                 [0, 1, 1],
...                 [1, 0, 0],
...                 [0, 0, 1],
...                 [1, 0, 0],
...                 [1, 1, 1],
...                 [1, 0, 1]])
>>> state_by_node2state_by_state(tpm)
array([[0., 0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 1., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 0., 0., 1., 0., 0.]])
pyphi.convert.sbs2sbn(tpm)

Convert a state-by-state TPM to a state-by-node TPM.

Danger

Many nondeterministic state-by-state TPMs can be represented by a single a state-by-state TPM. However, the mapping can be made to be one-to-one if we assume the state-by-state TPM is conditionally independent, as this function does. If the given TPM is not conditionally independent, the conditional dependencies will be silently lost.

Note

The indices of the rows and columns of the state-by-state TPM are assumed to follow the little-endian convention. The indices of the rows of the resulting state-by-node TPM also follow the little-endian convention. See the documentation on PyPhi the Transition probability matrix conventions more information.

Parameters:tpm (list[list] or np.ndarray) – A square state-by-state TPM with row and column indices following the little-endian convention.
Returns:A state-by-node TPM, with row indices following the little-endian convention.
Return type:np.ndarray

Example

>>> tpm = np.array([[0.5, 0.5, 0.0, 0.0],
...                 [0.0, 1.0, 0.0, 0.0],
...                 [0.0, 0.2, 0.0, 0.8],
...                 [0.0, 0.3, 0.7, 0.0]])
>>> state_by_state2state_by_node(tpm)
array([[[0.5, 0. ],
        [1. , 0.8]],
<BLANKLINE>
       [[1. , 0. ],
        [0.3, 0.7]]])