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

ck/pgm_compiler/named_pgm_compilers.py

@@ -18,32 +18,32 @@ class NamedPGMCompiler(Enum):
     """
     # @formatter:off
 
-    VE_MIN_DEGREE: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_DEGREE')
-    VE_MIN_DEGREE_THEN_FILL: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_DEGREE_THEN_FILL')
-    VE_MIN_FILL: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_FILL')
-    VE_MIN_FILL_THEN_DEGREE: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_FILL_THEN_DEGREE')
-    VE_MIN_WEIGHTED_DEGREE: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_WEIGHTED_DEGREE')
-    VE_MIN_WEIGHTED_FILL: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_WEIGHTED_FILL')
-    VE_MIN_TRADITIONAL_WEIGHTED_FILL: PGMCompiler = _get_compiler_algorithm(variable_elimination, 'MIN_TRADITIONAL_WEIGHTED_FILL')
-
-    FE_MIN_DEGREE: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_DEGREE')
-    FE_MIN_DEGREE_THEN_FILL: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_DEGREE_THEN_FILL')
-    FE_MIN_FILL: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_FILL')
-    FE_MIN_FILL_THEN_DEGREE: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_FILL_THEN_DEGREE')
-    FE_MIN_WEIGHTED_DEGREE: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_WEIGHTED_DEGREE')
-    FE_MIN_WEIGHTED_FILL: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_WEIGHTED_FILL')
-    FE_MIN_TRADITIONAL_WEIGHTED_FILL: PGMCompiler = _get_compiler_algorithm(factor_elimination, 'MIN_TRADITIONAL_WEIGHTED_FILL')
-    FE_BEST_JOINTREE: PGMCompiler = factor_elimination.compile_pgm_best_jointree,
-
-    RC_MIN_DEGREE: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_DEGREE')
-    RC_MIN_DEGREE_THEN_FILL: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_DEGREE_THEN_FILL')
-    RC_MIN_FILL: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_FILL')
-    RC_MIN_FILL_THEN_DEGREE: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_FILL_THEN_DEGREE')
-    RC_MIN_WEIGHTED_DEGREE: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_WEIGHTED_DEGREE')
-    RC_MIN_WEIGHTED_FILL: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_WEIGHTED_FILL')
-    RC_MIN_TRADITIONAL_WEIGHTED_FILL: PGMCompiler = _get_compiler_algorithm(recursive_conditioning, 'MIN_TRADITIONAL_WEIGHTED_FILL')
-
-    ACE: PGMCompiler = _get_compiler(ace)
+    VE_MIN_DEGREE = _get_compiler_algorithm(variable_elimination, 'MIN_DEGREE')
+    VE_MIN_DEGREE_THEN_FILL = _get_compiler_algorithm(variable_elimination, 'MIN_DEGREE_THEN_FILL')
+    VE_MIN_FILL = _get_compiler_algorithm(variable_elimination, 'MIN_FILL')
+    VE_MIN_FILL_THEN_DEGREE = _get_compiler_algorithm(variable_elimination, 'MIN_FILL_THEN_DEGREE')
+    VE_MIN_WEIGHTED_DEGREE = _get_compiler_algorithm(variable_elimination, 'MIN_WEIGHTED_DEGREE')
+    VE_MIN_WEIGHTED_FILL = _get_compiler_algorithm(variable_elimination, 'MIN_WEIGHTED_FILL')
+    VE_MIN_TRADITIONAL_WEIGHTED_FILL = _get_compiler_algorithm(variable_elimination, 'MIN_TRADITIONAL_WEIGHTED_FILL')
+
+    FE_MIN_DEGREE = _get_compiler_algorithm(factor_elimination, 'MIN_DEGREE')
+    FE_MIN_DEGREE_THEN_FILL = _get_compiler_algorithm(factor_elimination, 'MIN_DEGREE_THEN_FILL')
+    FE_MIN_FILL = _get_compiler_algorithm(factor_elimination, 'MIN_FILL')
+    FE_MIN_FILL_THEN_DEGREE = _get_compiler_algorithm(factor_elimination, 'MIN_FILL_THEN_DEGREE')
+    FE_MIN_WEIGHTED_DEGREE = _get_compiler_algorithm(factor_elimination, 'MIN_WEIGHTED_DEGREE')
+    FE_MIN_WEIGHTED_FILL = _get_compiler_algorithm(factor_elimination, 'MIN_WEIGHTED_FILL')
+    FE_MIN_TRADITIONAL_WEIGHTED_FILL = _get_compiler_algorithm(factor_elimination, 'MIN_TRADITIONAL_WEIGHTED_FILL')
+    FE_BEST_JOINTREE = factor_elimination.compile_pgm_best_jointree,
+
+    RC_MIN_DEGREE = _get_compiler_algorithm(recursive_conditioning, 'MIN_DEGREE')
+    RC_MIN_DEGREE_THEN_FILL = _get_compiler_algorithm(recursive_conditioning, 'MIN_DEGREE_THEN_FILL')
+    RC_MIN_FILL = _get_compiler_algorithm(recursive_conditioning, 'MIN_FILL')
+    RC_MIN_FILL_THEN_DEGREE = _get_compiler_algorithm(recursive_conditioning, 'MIN_FILL_THEN_DEGREE')
+    RC_MIN_WEIGHTED_DEGREE = _get_compiler_algorithm(recursive_conditioning, 'MIN_WEIGHTED_DEGREE')
+    RC_MIN_WEIGHTED_FILL = _get_compiler_algorithm(recursive_conditioning, 'MIN_WEIGHTED_FILL')
+    RC_MIN_TRADITIONAL_WEIGHTED_FILL = _get_compiler_algorithm(recursive_conditioning, 'MIN_TRADITIONAL_WEIGHTED_FILL')
+
+    ACE = _get_compiler(ace)
 
     # @formatter:on
 

ck/pgm_compiler/recursive_conditioning.py

@@ -28,7 +28,7 @@ def compile_pgm(
         const_parameters: bool = True,
         *,
         algorithm: ClusterAlgorithm = MIN_FILL_THEN_DEGREE,
-        pre_prune_factor_tables: bool = True,
+        pre_prune_factor_tables: bool = False,
 ) -> PGMCircuit:
     """
     Compile the PGM to an arithmetic circuit, using recursive conditioning.

ck/pgm_compiler/support/factor_tables.py

@@ -269,40 +269,48 @@ def _pre_prune_factor_tables(factor_rows: Sequence[_FactorRows]) -> None:
     will be formed, which may eliminate rows. This method identifies and removes
     such rows.
     """
+    # Find all pairs of factors that have at least one common random variable.
     pairs_to_check: List[_FactorPair] = [
         _FactorPair(f1, f2)
         for f1, f2 in pairs(factor_rows)
         if not set(f1.rv_indexes).isdisjoint(f1.rv_indexes)
     ]
 
-    pairs_done: List[_FactorPair] = []
-
-    while len(pairs_to_check) > 0:
-        pair = pairs_to_check.pop()
-        x = pair.x
-        y = pair.y
-
-        x_size = len(x)
-        y_size = len(y)
+    # Simple version.
+    for pair in pairs_to_check:
         pair.prune()
 
-        # See if any pairs need re-checking
-        rvs_affected: Set[int] = set()
-        if x_size != len(x):
-            rvs_affected.update(x.rv_indexes)
-        if y_size != len(y):
-            rvs_affected.update(y.rv_indexes)
-        if len(rvs_affected) > 0:
-            next_pairs_done: List[_FactorPair] = []
-            for pair in pairs_done:
-                if rvs_affected.isdisjoint(pair.all_rv_indexes):
-                    next_pairs_done.append(pair)
-                else:
-                    pairs_to_check.append(pair)
-            pairs_done = next_pairs_done
-
-        # Mark the current pair as done.
-        pairs_done.append(pair)
+    # Earlier version.
+    # This version re-checks processed pairs that may get benefit from a subsequent pruning.
+    # Unfortunately, this is computationally expensive, and provides no practical benefit.
+    #
+    # pairs_done: List[_FactorPair] = []
+    # while len(pairs_to_check) > 0:
+    #     pair: _FactorPair = pairs_to_check.pop()
+    #     x: _FactorRows = pair.x
+    #     y: _FactorRows = pair.y
+    #
+    #     x_size = len(x)
+    #     y_size = len(y)
+    #     pair.prune()
+    #
+    #     # See if any pairs need re-checking
+    #     rvs_affected: Set[int] = set()
+    #     if x_size != len(x):
+    #         rvs_affected.update(x.rv_indexes)
+    #     if y_size != len(y):
+    #         rvs_affected.update(y.rv_indexes)
+    #     if len(rvs_affected) > 0:
+    #         next_pairs_done: List[_FactorPair] = []
+    #         for pair in pairs_done:
+    #             if rvs_affected.isdisjoint(pair.all_rv_indexes):
+    #                 next_pairs_done.append(pair)
+    #             else:
+    #                 pairs_to_check.append(pair)
+    #         pairs_done = next_pairs_done
+    #
+    #     # Mark the current pair as done.
+    #     pairs_done.append(pair)
 
 
 def _make_factor_table(

ck/pgm_compiler/variable_elimination.py

@@ -25,7 +25,7 @@ def compile_pgm(
         const_parameters: bool = True,
         *,
         algorithm: ClusterAlgorithm = MIN_FILL_THEN_DEGREE,
-        pre_prune_factor_tables: bool = True,
+        pre_prune_factor_tables: bool = False,
 ) -> PGMCircuit:
     """
     Compile the PGM to an arithmetic circuit, using variable elimination.

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/ace/demo_ace.py

@@ -17,7 +17,7 @@ def main() -> None:
     # Here is an example showing how to copy Ace to the default
     # location from a source directory.
     #
-    # ace.copy_ace_to_default_location(r'E:\Dropbox\Research\Ace\all')
+    # ace.copy_ace_to_default_location(r'C:\Research\Ace\ace_v3.0_windows')
 
     pgm_cct: PGMCircuit = ace.compile_pgm(pgm, print_output=True)
 

ck_demos/pgm_compiler/compare_pgm_compilers.py

@@ -9,6 +9,15 @@ from ck_demos.utils.compare import compare
 
 # @formatter:off
 
+# =========================================
+#  Experiment configuration
+# =========================================
+
+CACHE_CIRCUITS: bool = True
+BREAK_BETWEEN_PGMS: bool = True
+COMMA_NUMBERS: bool = True
+PRINT_HEADER: bool = True
+
 PGMS: Sequence[PGM] = [
     example.Rain(),
     example.Cancer(),
@@ -25,14 +34,14 @@ PGMS: Sequence[PGM] = [
     # example.Mildew(),
 ]
 
-CCT_COMPILERS: Sequence[NamedCircuitCompiler] = [DEFAULT_CIRCUIT_COMPILER]
-
 PGM_COMPILERS: Sequence[NamedPGMCompiler] = [
     named_compiler
     for named_compiler in NamedPGMCompiler
     if named_compiler.name.startswith('FE_') and 'WEIGHTED' not in named_compiler.name
 ] + [NamedPGMCompiler.ACE]
 
+CCT_COMPILERS: Sequence[NamedCircuitCompiler] = [DEFAULT_CIRCUIT_COMPILER]
+
 # @formatter:on
 
 
@@ -41,6 +50,10 @@ def main() -> None:
         pgms=PGMS,
         pgm_compilers=PGM_COMPILERS,
         cct_compilers=CCT_COMPILERS,
+        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

@@ -7,13 +7,17 @@ from ck.pgm_circuit.wmc_program import WMCProgram
 from ck.pgm_compiler import NamedPGMCompiler
 from ck_demos.utils.stop_watch import StopWatch
 
-CACHE_CIRCUIT: bool = True
-
 
 def compare(
         pgms: Sequence[PGM],
         pgm_compilers: Sequence[NamedPGMCompiler],
         cct_compilers: Sequence[NamedCircuitCompiler],
+        *,
+        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
@@ -35,54 +39,78 @@ def compare(
         pgms: a sequence of PGM objects.
         pgm_compilers: a sequence of named PGM compilers.
         cct_compilers: a sequence of named circuit compilers.
+        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.
-    max_pgm_name: int = max(len(pgm.name) for pgm in pgms)
-    max_pgm_compiler_name: int = max(len(pgm_compiler.name) for pgm_compiler in pgm_compilers)
-    max_cct_compiler_name: int = max(len(cct_compiler.name) for cct_compiler in cct_compilers)
+    # Work out column widths for names.
+    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 = 16
+    col_cct_compile_time: int = 16
+    col_execute_time: int = 10
+
+    # Print formatting
+    comma: str = ',' if comma_numbers else ''
 
-    # variables for when CACHE_CIRCUIT is true
+    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
 
     for pgm in pgms:
-        pgm_name: str = pgm.name.ljust(max_pgm_name)
+        pgm_name: str = pgm.name.ljust(col_pgm_name)
         for pgm_compiler in pgm_compilers:
-            pgm_compiler_name: str = pgm_compiler.name.ljust(max_pgm_compiler_name)
+            pgm_compiler_name: str = pgm_compiler.name.ljust(col_pgm_compiler_name)
             for cct_compiler in cct_compilers:
-                cct_compiler_name: str = cct_compiler.name.ljust(max_cct_compiler_name)
+                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_CIRCUIT and pgm is prev_pgm and pgm_compiler is prev_pgm_compiler:
-                        print(f'{"":10} ', end='')
-                        print(f'{"":10}  ', end='')
+                    if cache_circuits and pgm is prev_pgm and pgm_compiler is prev_pgm_compiler:
+                        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()
-                        print(f'{pgm_cct.circuit_top.circuit.number_of_operations:10,} ', end='')
-                        print(f'{time.seconds():10.3f}s ', end='')
+                        num_ops: int = pgm_cct.circuit_top.circuit.number_of_operations
+                        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
 
                     time.start()
+                    # `pgm_cct` will always be set but the IDE can't work that out.
+                    # noinspection PyUnboundLocalVariable
                     wmc = WMCProgram(pgm_cct, compiler=cct_compiler.compiler)
                     time.stop()
-                    print(f'{time.seconds():10.3f}s ', 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:10.3f}μs ', end='')
+                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end=sep)
                 except Exception as err:
                     print(repr(err), end='')
-
                 print()
-        print()
+        if break_between_pgms:
+            print()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a12
+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
@@ -43,7 +43,7 @@ Refer to the project online documentation at
 The primary repository for the project is 
 [github.com/ropeless/compiled_knowledge](https://github.com/ropeless/compiled_knowledge). 
 
-The Python package is available on PyPi, see
+The Python package is available on PyPI, see
 [pypi.org/project/compiled-knowledge](https://pypi.org/project/compiled-knowledge/).
 
 For more information email