compiled-knowledge 4.0.0a15__cp312-cp312-win_amd64.whl → 4.0.0a16__cp312-cp312-win_amd64.whl

ck/in_out/parse_ace_nnf.py

@@ -1,11 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Tuple, Optional, Dict, List
+from typing import Tuple, Optional, Dict, List, Sequence
 
 import numpy as np
 
 from ck.circuit import Circuit, CircuitNode, VarNode, ConstValue, ConstNode
 from ck.in_out.parse_ace_lmap import LiteralMap
 from ck.in_out.parser_utils import ParseError, ParserInput
+from ck.pgm import Indicator
 from ck.pgm_circuit.slot_map import SlotKey, SlotMap
 from ck.utils.np_extras import NDArrayFloat64
 
@@ -18,9 +19,9 @@ def read_nnf_with_literal_map(
         input_stream,
         literal_map: LiteralMap,
         *,
+        indicators: Sequence[Indicator] = (),
         const_parameters: bool = True,
         optimise_ops: bool = True,
-        circuit: Optional[Circuit] = None,
         check_header: bool = False,
 ) -> Tuple[CircuitNode, SlotMap, NDArrayFloat64]:
     """
@@ -31,8 +32,8 @@ def read_nnf_with_literal_map(
 
     Args:
         input_stream: to parse, as per `ParserInput` argument.
+        indicators: any indicators to pre allocate to circuit variables.
         literal_map: mapping from literal code to indicators.
-        circuit: an optional circuit to reuse.
         check_header: if true, an exception is raised if the number of nodes or arcs is not as expected.
         const_parameters: if true, the potential function parameters will be circuit
             constants, otherwise they will be circuit variables.
@@ -44,6 +45,7 @@ def read_nnf_with_literal_map(
         slot_map: is a map from indicator to a circuit var index (int).
         params: is a numpy array of parameter values, co-indexed with `circuit.vars[num_indicators:]`
     """
+    circuit = Circuit()
 
     # Set the `const_literals` parameter for `read_nnf`
     const_literals: Optional[Dict[int, ConstValue]]
@@ -57,38 +59,42 @@ def read_nnf_with_literal_map(
     else:
         const_literals = {}
 
-    top_node, literal_slot_map = read_nnf(
+    # Make a slot map to map from an indicator to a circuit variable index.
+    # Preload `var_literals` to map literal codes to circuit vars.
+    # We allocate the circuit variables here to ensure that indicators
+    # come before parameters in the circuit variables.
+    slot_map: Dict[SlotKey, int] = {
+        indicator: i
+        for i, indicator in enumerate(indicators)
+    }
+    circuit.new_vars(len(slot_map))
+    var_literals: Dict[int, int] = {}
+    for literal_code, indicator in literal_map.indicators.items():
+        slot = slot_map.get(indicator)
+        if slot is None:
+            slot = circuit.new_var().idx
+            slot_map[indicator] = slot
+        var_literals[literal_code] = slot
+    num_indicators: int = len(slot_map)
+
+    # Parse the nnf file
+    top_node, vars_literals = read_nnf(
         input_stream,
+        var_literals=var_literals,
         const_literals=const_literals,
         circuit=circuit,
         check_header=check_header,
         optimise_ops=optimise_ops,
     )
-    circuit = top_node.circuit
-
-    # Build the slot map from indicator to slot.
-    # Some indicators may not be in `literal_slot_map` because they were not needed
-    # for the arithmetic circuit in the NNF file. For those indicators, we create
-    # dummy circuit vars.
-    def _get_slot(_literal_code: int) -> int:
-        _slot: Optional[int] = literal_slot_map.get(_literal_code)
-        if _slot is None:
-            _slot: int = circuit.new_var().idx
-        return _slot
 
-    slot_map: Dict[SlotKey, int] = {
-        indicator: _get_slot(literal_code)
-        for literal_code, indicator in literal_map.indicators.items()
-    }
-
-    # Get the parameter values
-    num_indicators: int = len(literal_map.indicators)
+    # Get the parameter values.
+    # Any new circuit vars added to the circuit are parameters.
+    # Parameter IDs are not added to the slot map as we don't know them.
     num_parameters: int = top_node.circuit.number_of_vars - num_indicators
     assert num_parameters == 0 or not const_parameters, 'const_parameters -> num_parameters == 0'
-
     params: NDArrayFloat64 = np.zeros(num_parameters, dtype=np.float64)
     for literal_code, value in literal_map.params.items():
-        literal_slot: Optional[int] = literal_slot_map.get(literal_code)
+        literal_slot: Optional[int] = var_literals.get(literal_code)
         if literal_slot is not None and literal_slot >= num_indicators:
             params[literal_slot - num_indicators] = value
 
@@ -98,6 +104,7 @@ def read_nnf_with_literal_map(
 def read_nnf(
         input_stream,
         *,
+        var_literals: Optional[Dict[int, int]] = None,
         const_literals: Optional[Dict[int, ConstValue]] = None,
         circuit: Optional[Circuit] = None,
         check_header: bool = False,
@@ -109,44 +116,51 @@ def read_nnf(
     The input consists of propositional logical sentences in negative normal form (NNF).
     This covers both ".ac" and ".nnf" files produced by the software ACE.
 
-    The returned slot map will have entries to get circuit vars for literal codes.
-    E.g., given a literal code (int), use `circuit.vars[slot_map[literal_code]]` to get its var node.
+    This function returns the last node parsed (or the constant zero node if no nodes passed).
+    It also returns a mapping from literal code (int) to circuit variable index.
 
-    Software may simplify an NNF file by removing arcs, but it may not update the header.
-    Although the resulting file is not conformant, it is still parsable.
-    Parameter `check_header` can be set to false, which prevents an exception being raised.
+    Two optional dictionaries may be supplied. Dictionary `var_literals` maps a literal
+    code to a pre-existing circuit variable index. Dictionary `const_literals` maps a literal
+    code to a constant value. A literal code should not appear in both dictionaries.
+
+    Any literal code that is parsed but does not appear in `var_literals` or `const_literals`
+    results in a new circuit variable being created and a corresponding entry added to
+    `var_literals`.
+
+    External software may modify an NNF file by removing arcs, but it may not update the header.
+    Although the resulting file is not conformant, it is still parsable (by ignoring the header).
+    Parameter `check_header` can be set to true, which causes an exception being raised if the
+    header disagrees with the rest of the file.
 
     Args:
         input_stream: to parse, as per `ParserInput` argument.
+        var_literals: an optional mapping from literal code to existing circuit variable index.
         const_literals: an optional mapping from literal code to constant value.
         circuit: an optional empty circuit to reuse.
         check_header: if true, an exception is raised if the number of nodes or arcs is not as expected.
         optimise_ops: if true then circuit optimised operations will be used.
 
     Returns:
-        (circuit_top, literal_slot_map)
+        (circuit_top, var_literals)
         circuit_top: is the resulting top node from parsing the input.
-        literal_slot_map: is a mapping from literal code (int) to a circuit var index (int).
-
-    Assumes:
-        If a circuit is provided, it is empty.
+        var_literals: is a mapping from literal code (int) to a circuit variable index (int).
     """
     if circuit is None:
         circuit: Circuit = Circuit()
 
-    if circuit.number_of_vars != 0:
-        raise ValueError('the given circuit must be empty')
+    if var_literals is None:
+        var_literals: Dict[int, int] = {}
 
     if const_literals is None:
         const_literals: Dict[int, ConstValue] = {}
 
-    parser = CircuitParser(circuit, check_header, const_literals, optimise_ops)
+    parser = CircuitParser(circuit, check_header, var_literals, const_literals, optimise_ops)
     parser.parse(input_stream)
 
     nodes = parser.nodes
     cct_top = circuit.zero if len(nodes) == 0 else nodes[-1]
 
-    return cct_top, parser.literal_slot_map
+    return cct_top, var_literals
 
 
 class Parser(ABC):
@@ -198,6 +212,8 @@ class Parser(ABC):
                                     self.add_node(raise_f, args)
                                 else:
                                     self.mul_node(raise_f, args)
+                    else:
+                        raise_f(f'unexpected parser state: {state}')
                 line = input_stream.readline()
             self.done(raise_f)
         except ParseError as e:
@@ -236,17 +252,18 @@ class CircuitParser(Parser):
             self,
             circuit: Circuit,
             check_header: bool,
+            var_literals: Dict[int, int],
             const_literals: Dict[int, ConstValue],
             optimise_ops: bool,
     ):
         self.check_header: bool = check_header
-        self.literal_slot_map: Dict[SlotKey, int] = {}
-        self.optimise_ops = optimise_ops
-        self.circuit = circuit
+        self.var_literals: Dict[int, int] = var_literals
         self.const_literals: Dict[int, ConstValue] = const_literals
+        self.optimise_ops: bool = optimise_ops
+        self.circuit: Circuit = circuit
         self.nodes: List[CircuitNode] = []
-        self.num_nodes = None
-        self.num_edges = None
+        self.num_nodes = None  # read from the file header for checking
+        self.num_edges = None  # read from the file header for checking
 
     def comment(self, raise_f, message: str) -> None:
         pass
@@ -257,13 +274,20 @@ class CircuitParser(Parser):
         """
         const_value: Optional[ConstValue] = self.const_literals.get(literal_code)
         if const_value is not None:
+            # Literal code maps to a constant value
+            if literal_code in self.var_literals:
+                raise_f('literal code both constant and variable: {literal_code}')
             node: ConstNode = self.circuit.const(const_value)
-        elif literal_code in self.literal_slot_map.keys():
-            raise_f(f'duplicated literal code: {literal_code}')
-            return
+
+        elif (var_idx := self.var_literals.get(literal_code)) is not None:
+            # Literal code maps to an existing circuit variable
+            node: VarNode = self.circuit.vars[var_idx]
+
         else:
+            # Literal code maps to a new circuit variable
             node: VarNode = self.circuit.new_var()
-            self.literal_slot_map[literal_code] = node.idx
+            self.var_literals[literal_code] = node.idx
+
         self.nodes.append(node)
 
     def add_node(self, raise_f, args: List[int]) -> None:

ck/in_out/parser_utils.py

@@ -32,7 +32,7 @@ class ParserInput:
     def __init__(self, input_stream):
         self._input = _check_input(input_stream)
         self._prev_line_len = 0
-        self._cur_line = 1
+        self._cur_line = 0
         self._cur_char = 1
         self._lookahead = []
 

ck/pgm_compiler/ace/ace.py

@@ -14,6 +14,7 @@ from ck.in_out.render_net import render_bayesian_network
 from ck.pgm import PGM
 from ck.pgm_circuit import PGMCircuit
 from ck.pgm_circuit.slot_map import SlotMap
+from ck.utils.local_config import config
 from ck.utils.np_extras import NDArrayFloat64
 from ck.utils.tmp_dir import tmp_dir
 
@@ -121,8 +122,9 @@ def compile_pgm(
             parameter_values: NDArrayFloat64
             circuit_top, slot_map, parameter_values = read_nnf_with_literal_map(
                 file,
+                indicators=pgm.indicators,
                 literal_map=literal_map,
-                const_parameters=const_parameters
+                const_parameters=const_parameters,
             )
 
     # Consistency checking
@@ -198,8 +200,12 @@ def copy_ace_to_default_location(
 def default_ace_location() -> Path:
     """
     Get the default location for Ace files.
+
+    This function checks the local config for the variable
+    CK_ACE_LOCATION. If that is not available, then the
+    directory that this Python module is in will be used.
     """
-    return Path(__file__).parent
+    return Path(config.get('CK_ACE_LOCATION', Path(__file__).parent))
 
 
 @dataclass

ck/utils/local_config.py

@@ -0,0 +1,270 @@
+"""
+This module provides access to local configuration variables.
+
+Local configuration variables are {variable} = {value} pairs that
+are defined externally to CK for the purposes of adapting
+to the local environment that CK is installed in. Local
+configuration variables are not expected to modify the
+behaviour of algorithms implemented in CK.
+
+The primary method to access local configuration is `get`. Various
+other getter methods wrap `get`.
+
+The `get` method will search for a value for a requested variable
+using the following steps.
+1) Check the `programmatic config` which is a dictionary that
+   can be directly updated.
+2) Check the PYTHONPATH for a module called `config` (i.e., a
+   `config.py` file) for global variables defined in that module.
+3) Check the system environment variables (`os.environ`).
+
+Variable names must be a valid Python identifier. Only valid
+value types are supported, as per the function `valid_value`.
+
+Usage:
+    from ck.utils.local_config import config
+
+    # assume `config.py` is in the PYTHONPATH and contains:
+    #    ABC = 123
+    #    DEF = 456
+
+    val = config.ABC                  # val = 123
+    val = config.XYZ                  # will raise an exception
+    val = config.get('ABC')           # val = 123
+    val = config['DEF']               # val = 456
+    val = config['XYZ']               # will raise an exception
+    val = config.get('XYZ')           # val = None
+    val = config.get('XYZ', 999)      # val = 999
+
+    from ck.utils.local_config import get_params
+
+    val = get_params('ABC')                  # val = ('ABC', 123)
+    val = get_params('ABC', 'DEF')           # val = (('ABC', 123), ('DEF', 456))
+    val = get_params('ABC', 'DEF', sep='=')  # val = ('ABC=123', 'DEF=456')
+    val = get_params('ABC;DEF', delim=';')   # val = 'ABC=123;DEF=456'
+
+"""
+
+import inspect
+import os
+from ast import literal_eval
+from itertools import chain
+from typing import Optional, Dict, Any, Sequence, Iterable
+
+from ck.utils.iter_extras import flatten
+
+try:
+    # Try to import the user's `config.py`
+    import config as _user_config
+except ImportError:
+    _user_config = None
+
+# Sentinel object
+_NIL = object()
+
+
+class Config:
+
+    def __init__(self):
+        self._programmatic_config: Dict[str, Any] = {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get the value of the given local configuration variable.
+        If the configuration variable is not available, return the given default value.
+        """
+        if not key.isidentifier():
+            raise KeyError(f'invalid local configuration parameter: {key!r}')
+
+        # Check the programmatic config
+        value = self._programmatic_config.get(key, _NIL)
+        if value is not _NIL:
+            return value
+
+        # Check config.py
+        if _user_config is not None:
+            value = vars(_user_config).get(key, _NIL)
+            if value is not _NIL:
+                if not valid_value(value):
+                    raise KeyError(f'user configuration file contains an invalid value for variable: {key!r}')
+                return value
+
+        # Check the OS environment
+        value = os.environ.get(key, _NIL)
+        if value is not _NIL:
+            return value
+
+        # Not found - return the default value
+        return default
+
+    def __contains__(self, key: str) -> bool:
+        return self.get(key, _NIL) is not _NIL
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """
+        Programmatically overwrite a local configuration variable.
+        """
+        if not key.isidentifier():
+            raise KeyError(f'invalid local configuration parameter: {key!r}')
+        if not valid_value(value):
+            raise ValueError(f'invalid local configuration parameter value: {value!r}')
+        self._programmatic_config[key] = value
+
+    def __getitem__(self, key: str):
+        """
+        Get the value of the given configuration variable.
+        If the configuration variable is not available, raise a KeyError.
+        """
+        value = self.get(key, _NIL)
+        if value is _NIL:
+            raise KeyError(f'undefined local configuration parameter: {key}')
+        return value
+
+    def __getattr__(self, key: str):
+        """
+        Get the value of the given configuration variable.
+        If the configuration variable is not available, raise a KeyError.
+        """
+        value = self.get(key, _NIL)
+        if value is _NIL:
+            raise KeyError(f'undefined local configuration parameter: {key}')
+        return value
+
+
+# The global local config object.
+config = Config()
+
+
+def valid_value(value: Any) -> bool:
+    """
+    Does the given value have an acceptable type for
+    a configuration variable?
+    """
+    if isinstance(value, (list, tuple, set)):
+        return all(valid_value(elem) for elem in value)
+    if isinstance(value, dict):
+        return all(valid_value(elem) for elem in chain(value.keys(), value.values()))
+    if callable(value) or inspect.isfunction(value) or inspect.ismodule(value):
+        return False
+    # All tests pass
+    return True
+
+
+# noinspection PyShadowingNames
+def get_params(
+        *keys: str,
+        sep: Optional[str] = None,
+        delim: Optional[str] = None,
+        config: Config = config,
+):
+    """
+    Return one or more configuration parameter as key-value pairs.
+
+    If `sep` is None then each key-value pair is returned as a tuple, otherwise
+    each key-value pair is returned as a string with `sep` as the separator.
+
+    If `delim` is None then each key is treated as is. If one key is provided then
+    its value is returned. If multiple keys are provided, then multiple values
+    are returned in a tuple.
+
+    If `delim` is not None, then keys are split using `delim`, and results
+    are returned as a single string with `delim` as the delimiter. If
+    `delim` is not None then the default value for `sep` is '='.
+
+    For example, assume config.py contains: ABC = 123 and DEF = 456,
+    then:
+        get_params('ABC') -> ('ABC', 123)
+        get_params('ABC', 'DEF') -> ('ABC', 123), ('DEF', 456)
+        get_params('ABC', sep='=') = 'ABC=123'
+        get_params('ABC', 'DEF', sep='=') = 'ABC=123', 'DEF=456'
+        get_params('ABC;DEF', delim=';') = 'ABC=123;DEF=456'
+        get_params('ABC;DEF', sep='==', delim=';') = 'ABC==123;DEF==456'
+
+    :param keys: the names of variables to access.
+    :param sep: the separator character between {variable} and {value}.
+    :param delim: the delimiter character between key-value pairs.
+    :param config: a Config instance to update. Default is the global config.
+    """
+    if delim is not None:
+        keys = flatten(key.split(delim) for key in keys)
+        if sep is None:
+            sep = '='
+
+    if sep is None:
+        items = ((key, config[key]) for key in keys)
+    else:
+        items = (f'{key}{sep}{config[key]!r}' for key in keys)
+
+    if delim is None:
+        result = tuple(items)
+        if len(result) == 1:
+            result = result[0]
+    else:
+        result = delim.join(str(item) for item in items)
+
+    return result
+
+
+# noinspection PyShadowingNames
+def update_config(
+        argv: Sequence[str],
+        valid_keys: Optional[Iterable[str]] = None,
+        *,
+        sep: str = '=',
+        strip_whitespace: bool = True,
+        config: Config = config,
+) -> None:
+    """
+    Programmatically overwrite a local configuration variable from a command line `argv`.
+
+    Variable values are interpreted as per a Python literal.
+
+    Example usage:
+        import sys
+        from ck.utils.local_config import update_config
+
+        def main():
+            ...
+
+        if __name__ == '__main__':
+            update_config(sys.argv, ['in_name', 'out_name'])
+            main()
+
+    :param argv: a collection of strings in the form '{variable}={value}'.
+        Variables not in `valid_keys` will raise a ValueError.
+    :param valid_keys: an optional collection of strings that are valid variables to
+        process from argv, or None to accept all variables.
+    :param sep: the separator character between {variable} and {value}.
+        Defaults is '='.
+    :param strip_whitespace: If True, then whitespace is stripped from
+        the value before updating the config. Whitespace is always stripped
+        from the variable name.
+    :param config: a Config instance to update. Default is the global config.
+    """
+    if valid_keys is not None:
+        valid_keys = set(valid_keys)
+
+    for arg in argv:
+        var_val = str(arg).split(sep, maxsplit=1)
+        if len(var_val) != 2:
+            raise ValueError(f'cannot split argument: {arg!r} using separator {sep!r}')
+
+        var, val = var_val
+        var = var.strip()
+        if strip_whitespace:
+            val = val.strip()
+
+        if valid_keys is not None and var not in valid_keys:
+            raise KeyError(f'invalid key: {arg!r}')
+
+        try:
+            interpreted = literal_eval(val)
+        except (ValueError, SyntaxError) as err:
+            # Some operating systems strip quotes off
+            # strings, so we try to recover.
+            if '"' in val or "'" in val:
+                # Too hard... forget it.
+                raise err
+            interpreted = str(val)
+
+        config[var] = interpreted

ck_demos/pgm_compiler/compare_pgm_compilers.py

@@ -16,6 +16,7 @@ from ck_demos.utils.compare import compare
 CACHE_CIRCUITS: bool = True
 BREAK_BETWEEN_PGMS: bool = True
 COMMA_NUMBERS: bool = True
+PRINT_HEADER: bool = True
 
 PGMS: Sequence[PGM] = [
     example.Rain(),
@@ -52,6 +53,7 @@ def main() -> None:
         cache_circuits=CACHE_CIRCUITS,
         break_between_pgms=BREAK_BETWEEN_PGMS,
         comma_numbers=COMMA_NUMBERS,
+        print_header=PRINT_HEADER,
     )
     print()
     print('Done.')

ck_demos/utils/compare.py

@@ -16,6 +16,8 @@ def compare(
         cache_circuits: bool = True,
         break_between_pgms: bool = True,
         comma_numbers: bool = True,
+        print_header: bool = True,
+        sep: str = '  ',
 ) -> None:
     """
     For each combination of the given arguments, construct a PGMCircuit (using a
@@ -40,25 +42,34 @@ def compare(
         cache_circuits: if true, then circuits are reused across different circuit compilers.
         break_between_pgms: if true, print a blank line  between different workload PGMs.
         comma_numbers: if true, commas are used in large numbers.
+        print_header: if true, a header line is printed.
+        sep: column separator.
     """
     # Work out column widths for names.
-    col_pgm_name: int = max(len(pgm.name) for pgm in pgms)
-    col_pgm_compiler_name: int = max(len(pgm_compiler.name) for pgm_compiler in pgm_compilers)
-    col_cct_compiler_name: int = max(len(cct_compiler.name) for cct_compiler in cct_compilers)
+    col_pgm_name: int = max(3, max(len(pgm.name) for pgm in pgms))
+    col_pgm_compiler_name: int = max(12, max(len(pgm_compiler.name) for pgm_compiler in pgm_compilers))
+    col_cct_compiler_name: int = max(12, max(len(cct_compiler.name) for cct_compiler in cct_compilers))
     col_cct_ops: int = 10
-    col_pgm_compile_time: int = 10
-    col_cct_compile_time: int = 10
+    col_pgm_compile_time: int = 16
+    col_cct_compile_time: int = 16
     col_execute_time: int = 10
 
+    # Print formatting
+    comma: str = ',' if comma_numbers else ''
+
+    if print_header:
+        print('PGM'.ljust(col_pgm_name), end=sep)
+        print('PGM-compiler'.ljust(col_pgm_compiler_name), end=sep)
+        print('CCT-compiler'.ljust(col_cct_compiler_name), end=sep)
+        print('CCT-ops'.rjust(col_cct_ops), end=sep)
+        print('PGM-compile-time'.rjust(col_pgm_compile_time), end=sep)
+        print('CCT-compile-time'.rjust(col_cct_compile_time), end=sep)
+        print('Run-time'.rjust(col_execute_time))
+
     # Variables for when cache_circuits is true
     prev_pgm = None
     prev_pgm_compiler = None
 
-    if comma_numbers:
-        comma = ','
-    else:
-        comma = ''
-
     for pgm in pgms:
         pgm_name: str = pgm.name.ljust(col_pgm_name)
         for pgm_compiler in pgm_compilers:
@@ -66,23 +77,23 @@ def compare(
             for cct_compiler in cct_compilers:
                 cct_compiler_name: str = cct_compiler.name.ljust(col_cct_compiler_name)
 
-                print(f'{pgm_name}  ', end='')
-                print(f'{pgm_compiler_name}  ', end='')
-                print(f'{cct_compiler_name}  ', end='')
+                print(pgm_name, end=sep)
+                print(pgm_compiler_name, end=sep)
+                print(cct_compiler_name, end=sep)
 
                 try:
                     time = StopWatch()
 
                     if cache_circuits and pgm is prev_pgm and pgm_compiler is prev_pgm_compiler:
-                        print(f'{"":{col_cct_ops}} ', end='')
-                        print(f'{"":{col_pgm_compile_time}}  ', end='')
+                        print(f'{"":{col_cct_ops}}', end=sep)
+                        print(f'{"":{col_pgm_compile_time}}', end=sep)
                     else:
                         time.start()
                         pgm_cct: PGMCircuit = pgm_compiler(pgm)
                         time.stop()
                         num_ops: int = pgm_cct.circuit_top.circuit.number_of_operations
-                        print(f'{num_ops:{col_cct_ops}{comma}} ', end='')
-                        print(f'{time.seconds():{col_pgm_compile_time}{comma}.3f} ', end='')
+                        print(f'{num_ops:{col_cct_ops}{comma}}', end=sep)
+                        print(f'{time.seconds():{col_pgm_compile_time}{comma}.3f}', end=sep)
                         prev_pgm = pgm
                         prev_pgm_compiler = pgm_compiler
 
@@ -91,16 +102,15 @@ def compare(
                     # noinspection PyUnboundLocalVariable
                     wmc = WMCProgram(pgm_cct, compiler=cct_compiler.compiler)
                     time.stop()
-                    print(f'{time.seconds():{col_cct_compile_time}{comma}.3f} ', end='')
+                    print(f'{time.seconds():{col_cct_compile_time}{comma}.3f}', end=sep)
 
                     time.start()
                     for _ in range(1000):
                         wmc.compute()
                     time.stop()
-                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f} ', end='')
+                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end=sep)
                 except Exception as err:
                     print(repr(err), end='')
-
                 print()
         if break_between_pgms:
             print()

{compiled_knowledge-4.0.0a15.dist-info → compiled_knowledge-4.0.0a16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a15
+Version: 4.0.0a16
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT

{compiled_knowledge-4.0.0a15.dist-info → compiled_knowledge-4.0.0a16.dist-info}/RECORD

@@ -2,7 +2,7 @@ ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm.py,sha256=rbqgP-clfSvgpzUXxVjk_6SdM9neHmpChku6qpyeidk,120700
 ck/circuit/__init__.py,sha256=tozFNNVzsgQDwFrtGzrgcFS4XTszhgyFmbMGfV5pimc,212
 ck/circuit/circuit.c,sha256=_DN78mWLcGdXOKoZv6Eq-m50KLpOP0SY_GjFrhLJoj0,1773051
-ck/circuit/circuit.cp312-win_amd64.pyd,sha256=TCkj4oiRcRFb0av5YyizlygbYKtFJn8LAqjT7nO8Zjw,252416
+ck/circuit/circuit.cp312-win_amd64.pyd,sha256=T0hYyLn7cjYZ54ki85-HaKltQZcuO6oSWBtx3DNe4iI,252416
 ck/circuit/circuit.pyx,sha256=Y35CZMalySX8_uhNH6wIaZzS6ACn3rh3L99bog1lQx8,28060
 ck/circuit/circuit_node.pyx,sha256=8RuEC1ngYxnsGryzQ1lOEPc4ewTxvKwc56sOxWLB9zs,4103
 ck/circuit/circuit_py.py,sha256=_k8H1yZsfp2vERkX_CIo8VxxOf1ICw2zL8i2ckoaSlE,28127
@@ -15,7 +15,7 @@ ck/circuit_compiler/llvm_vm_compiler.py,sha256=I46_XV5FrClDKO06zIjn8T3ME5XQ9RYJ_
 ck/circuit_compiler/named_circuit_compilers.py,sha256=gKhRvYLflSCkk6CBI-CBQ2UwR-bhEhMxLvnefPm8288,2282
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=pEAwTleuZgdYhTAQMea2f9YsFK54eoNbZSbrWkW8aeE,49
 ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=xpYybtj-aRcMJV1oKkB-p0kciZVW3gLRd0OJBfDg3sc,757006
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=hq07LvGfpD8VsssyCmmbecF38YCIws2efly317jvPug,92160
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=XSQU7oikafjfsOaiBfI70kS2cLn69kn2CJjKgs2i5cw,92160
 ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=hHuNo99TbodNpWgQwQ8qzW1cTwGXZj5SW0tKAo9u6cw,7718
 ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=yUkBNr5HnoVXyWjJdXHp8lyAXFiIDYapvMvHtzKuhI8,3140
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,9 +55,9 @@ ck/example/triangle_square.py,sha256=D-ADGOSxCffsgukLTySsb6HVQpUnOJ-ZyMGBz_qGna4
 ck/example/truss.py,sha256=5ud1qvPZMSKqSx0Sq1ZKcEeD_ZVUdKbEBfk5eyqhpm4,1974
 ck/in_out/__init__.py,sha256=PKhy5qeUrmmUaECSQIkoLQ2McAfQFSwB06vQZk3vpmo,112
 ck/in_out/parse_ace_lmap.py,sha256=EZnSLhsZwdPnk2Fbe2El0YXYqvjd_cBh7PZro7ZeR04,7891
-ck/in_out/parse_ace_nnf.py,sha256=Hkc24qn4ziA4-VunBEinURDGsnmCWICj73w3bopecR0,11843
+ck/in_out/parse_ace_nnf.py,sha256=zO3smkKKiUy_g0S7WeNyhEaZu5x65wuSNIDWlA3YU_g,13350
 ck/in_out/parse_net.py,sha256=cBY7X4k5U8v9x_dtFZWdOpSPh-q-U47gdImNo2Tf9dY,14302
-ck/in_out/parser_utils.py,sha256=Js_BaOmNji4mM7UYDm6pGd56wYcQoere7TuB0tkztko,5440
+ck/in_out/parser_utils.py,sha256=IKwgXBrIhHdL85n92RzB5yau_ja7DB3iAV-FHMgWsnI,5440
 ck/in_out/pgm_pickle.py,sha256=i5LYxez356we7MzHwsQBmFdOvBJOLVKBp4u4lSwBOjU,1004
 ck/in_out/pgm_python.py,sha256=c2-yxXxJ4fF00gUD5Lvt_CSE07EgwYeHW3nSNXunEvc,10092
 ck/in_out/render_bugs.py,sha256=6YBhMIq3VRKFS0XqHbaWj6iz1io7O9icW23kukF_Cic,3383
@@ -80,7 +80,7 @@ ck/pgm_compiler/pgm_compiler.py,sha256=F44PtlwqMG0FS6KzOYKZuyZT6olWAVtBH-QXZPzz4
 ck/pgm_compiler/recursive_conditioning.py,sha256=U0NdIns8yLQtYR_MOf1w__CChpOMDlgRCL2nFRhtnzU,7936
 ck/pgm_compiler/variable_elimination.py,sha256=YNBurWTz8_BoaZgRZFj-T9gRVGek7ZutGkvjegyLkCM,3460
 ck/pgm_compiler/ace/__init__.py,sha256=BkZXAF32Pk8QU7jhkuKvHqtsFasPjf8gxiZbyrGDDbQ,82
-ck/pgm_compiler/ace/ace.py,sha256=Q3d76rwAMsNFQeRXdxycy_KUJeE29g7bURryKAdq-aI,10095
+ck/pgm_compiler/ace/ace.py,sha256=iyDacqArXW1cVP6tBabxRmmLWIHabuPkCoq2tWBm2ww,10397
 ck/pgm_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm_compiler/support/clusters.py,sha256=96Up5XUgERh-t6KzSIOF2gtP5T4Ul83JK_aPtIR72Ic,20821
 ck/pgm_compiler/support/factor_tables.py,sha256=N7BNBBA-BX6RN-eiDwENtMLczW3JAkV-qW0i0k8OZEM,15558
@@ -88,7 +88,7 @@ ck/pgm_compiler/support/join_tree.py,sha256=tRHev655cwRsOSyLK9HYwfX8EEkubmlg1fw7
 ck/pgm_compiler/support/named_compiler_maker.py,sha256=tQ79JOI8MknAziUiFhFGV9n4y6PPKrnbq3-quMmnrwY,974
 ck/pgm_compiler/support/circuit_table/__init__.py,sha256=eWMP5ywgd51RJexKkhcpKJb_8iEluL0C4_hyOpzlAvQ,167
 ck/pgm_compiler/support/circuit_table/circuit_table.c,sha256=aO3bq3V-FwbmJDzWVYwigOFeQUC6gFz-nAq091XQp2E,702527
-ck/pgm_compiler/support/circuit_table/circuit_table.cp312-win_amd64.pyd,sha256=eVXmnKKG8k-V0v_RfhH9_n8nHfB6zZtC5LPDAvHitY0,94720
+ck/pgm_compiler/support/circuit_table/circuit_table.cp312-win_amd64.pyd,sha256=D8n3mBrIXbSPyFVOWJUwKb7F3h1O1SXmdGq7igfQFpA,94720
 ck/pgm_compiler/support/circuit_table/circuit_table.pyx,sha256=jhzstay-3EUgu0CIbWKd0eNDNToX1tmm9IQxk0ZgpYM,11904
 ck/pgm_compiler/support/circuit_table/circuit_table_py.py,sha256=1WFCxgBFu4oaYRCdk_1uXeufFQu6PqMOsYIQ_SkXDS4,10156
 ck/probability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,6 +111,7 @@ ck/sampling/wmc_metropolis_sampler.py,sha256=PRv7wtPZz7BcwN8iArsykVwqgY77v5km7rX
 ck/sampling/wmc_rejection_sampler.py,sha256=cd0VONZf-oa491RRKfwT2LakQs0o_slgPCes8AOvSNc,4897
 ck/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/utils/iter_extras.py,sha256=DDml5Jprmun2RovJxkwXx1uJkWacYhZEnX1ARSX2TB4,4310
+ck/utils/local_config.py,sha256=-oTKvKCpm29JeHEhV1_qLC5fMS523unDzXr0VYE3M0U,9535
 ck/utils/map_list.py,sha256=T2OpjI7eDgC4geCtW_FsEr6ryiePOnKZwfDahB63zfA,3847
 ck/utils/map_set.py,sha256=BLu9BO3FCtzZlZ9MfP9STtIdQ4Me8-QKdwB7o15y7f8,3809
 ck/utils/np_extras.py,sha256=J5KIQJX3C79ltAfKKYc0B0HI43iyuUQxLI9HZ9FiORI,1734
@@ -133,7 +134,7 @@ ck_demos/pgm/demo_pgm_dump_stress.py,sha256=L9S3yp0EQM56kWztV4A6XzEqITOGbThImZIU
 ck_demos/pgm/demo_pgm_string_rendering.py,sha256=JTf_M6pPwl9RtOLlpJFQIgNgGuHnsddJbxhgbZOChos,285
 ck_demos/pgm/show_examples.py,sha256=KxK37hKqWD9w9k9RoMCdJgkBIMePf8udQbqaFs-s91c,461
 ck_demos/pgm_compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck_demos/pgm_compiler/compare_pgm_compilers.py,sha256=0dm77DygI9E4WMOAD-M8Kzrf4xlPmZuZX6zUdy5fZ4Y,1548
+ck_demos/pgm_compiler/compare_pgm_compilers.py,sha256=pG0OQBl2wjdCIUU0RM70j8TfCjYUxRU0i13OWpfXUHc,1611
 ck_demos/pgm_compiler/demo_compiler_dump.py,sha256=OlLJi1wwdFQxave5lpceyVx0-ihHEn2-d-0XFFTjowY,1370
 ck_demos/pgm_compiler/demo_factor_elimination.py,sha256=KDzYwNZJ9HTcPoNxg6lxFoaXJ26QW-nnBI-0Ux_yWoM,1320
 ck_demos/pgm_compiler/demo_join_tree.py,sha256=E7ZqFrRuAmnSRmBTDqNGxD-KFlHOtd_jIju8UJssUfM,574
@@ -161,12 +162,12 @@ ck_demos/sampling/demo_marginal_direct_sampler.py,sha256=RhNunuIUnYI_GXp9m8wzadM
 ck_demos/sampling/demo_uniform_sampler.py,sha256=Z6tX_OYKGLc_w3-kEPK4KEZlJo7F5HOq_tUVppB_VQE,962
 ck_demos/sampling/demo_wmc_direct_sampler.py,sha256=c7maxTmZyIijaVdFs2h_KQbK30LvI-oCm2BXSUXVoD8,1113
 ck_demos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck_demos/utils/compare.py,sha256=WGCYv6rbT_vU1ldndnIoflmF2EDAQ2ckCw2i2QVVPng,4357
+ck_demos/utils/compare.py,sha256=MwigxgMqeV7slrzdIJYVJ340QBCCXOeUzUKOJkkd98w,4972
 ck_demos/utils/convert_network.py,sha256=TSKj8q7L7J5rhrvwjaDkdYZ0Sg8vV5FRL_vCanX1CQw,1363
 ck_demos/utils/sample_model.py,sha256=in-Nlv-iuNIu6y9fDuMyo7nzgimBuTAnCWcpnVqvqDQ,8839
 ck_demos/utils/stop_watch.py,sha256=VzXHRWx0V8vPSD-bLgLlEYkCkR2FA0-KmM_pfKx-Pxo,13205
-compiled_knowledge-4.0.0a15.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.0.0a15.dist-info/METADATA,sha256=2pLUAaU9vrC3iWkLGsj6SPKfKQDSZ8UL2eBh9xdkF4k,1838
-compiled_knowledge-4.0.0a15.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
-compiled_knowledge-4.0.0a15.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.0.0a15.dist-info/RECORD,,
+compiled_knowledge-4.0.0a16.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.0.0a16.dist-info/METADATA,sha256=5y-1ZXcu9vGc2PE6lccfgtWTwjOstq_vY0Uk6OT9AQc,1838
+compiled_knowledge-4.0.0a16.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
+compiled_knowledge-4.0.0a16.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.0.0a16.dist-info/RECORD,,