python-sat 0.1.8.dev10__cp310-cp310-win_amd64.whl → 1.8.dev26__cp310-cp310-win_amd64.whl

pysat/__init__.py

@@ -10,15 +10,15 @@
 
 # current version
 #==============================================================================
-VERSION = (0, 1, 8, "dev", 10)
+VERSION = (1, 8, 'dev', 26)
 
 
 # PEP440 Format
 #==============================================================================
-__version__ = "%d.%d.%d.%s%d" % VERSION if len(VERSION) == 5 else \
-              "%d.%d.%d" % VERSION
+__version__ = '%d.%d.%s%d' % VERSION if len(VERSION) == 4 else \
+              '%d.%d.%d' % VERSION
 
 
 # all submodules
 #==============================================================================
-__all__ = ['card', 'formula', 'pb', 'solvers']
+__all__ = ['card', 'engines', 'formula', 'pb', 'process', 'solvers']

pysat/_fileio.py

@@ -22,11 +22,12 @@
     Module description
     ==================
 
-    This simple module provides a basic interface to input/output operations on
-    files. Its key design feature is the ability to work with both uncompressed
-    and compressed files through a unified interface, thus, making it easier
-    for a user to deal with various types of compressed files. The compression
-    types supported include gzip, bzip2, and lzma (xz).
+    This simple module provides a basic interface to input/output operations
+    on files. Its key design feature is the ability to work with both
+    uncompressed and compressed files through a unified interface, thus,
+    making it easier for a user to deal with various types of compressed
+    files. The compression types supported include gzip, bzip2, lzma (xz), and
+    zstandard (zstd).
 
     The module is supposed to be mainly used by :mod:`pysat.formula`.
 
@@ -66,6 +67,13 @@ except ImportError:
     except ImportError:  # for Python2 without lzma
         lzma_present = False
 
+zstd_present = True
+try:
+    from compression import zstd
+except ImportError:  # zstandard is introduced in Python 3.14
+    zstd_present = False
+
+
 
 #
 #==============================================================================
@@ -75,9 +83,10 @@ class FileObject(object):
         open files creating standard file pointers and closing them. The class
         is used when opening DIMACS files for reading and writing. Supports
         both uncompressed and compressed files. Compression algorithms
-        supported are ``gzip``, ``bzip2``, and ``lzma``. Algorithm ``lzma`` can
-        be used in Python 3 by default and also in Python 2 if the
-        ``backports.lzma`` package is installed.
+        supported are ``gzip``, ``bzip2``, ``lzma``, and ``zstd``. Algorithm
+        ``lzma`` can be used in Python 3 by default and also in Python 2 if
+        the ``backports.lzma`` package is installed. Algorithm ``zstandard``
+        can be used in Python 3.14 and later.
 
         Note that the class opens a file in text mode.
 
@@ -90,8 +99,9 @@ class FileObject(object):
         :type compression: str
 
         Compression type can be ``None``, ``'gzip'``, ``'bzip2'``, ``'lzma'``,
-        as well as ``'use_ext'``. If ``'use_ext'`` is specified, compression
-        algorithm is defined by the extension of the given file name.
+        ``'zstd'``, as well as ``'use_ext'``. If ``'use_ext'`` is specified,
+        compression algorithm is defined by the extension of the given file
+        name.
     """
 
     def __init__(self, name, mode='r', compression=None):
@@ -109,9 +119,9 @@ class FileObject(object):
 
     def open(self, name, mode='r', compression=None):
         """
-            Open a file pointer. Note that a file is *always* opened in text
-            mode. The method inherits its input parameters from the constructor
-            of :class:`FileObject`.
+            Open a file pointer. Note that a file is *always* opened in
+            text mode. The method inherits its input parameters from the
+            constructor of :class:`FileObject`.
         """
 
         if compression == 'use_ext':
@@ -138,11 +148,15 @@ class FileObject(object):
                     self.fp = codecs.getreader('ascii')(self.fp_extra)
                 else:  # mode == 'w'
                     self.fp = codecs.getwriter('ascii')(self.fp_extra)
-        else:  # self.ctype == 'lzma'
+        elif self.ctype == 'lzma':
             # LZMA is available in Python 2 only if backports.lzma is installed
             # Python 3 supports it by default
             assert lzma_present, 'LZMA compression is unavailable.'
             self.fp = lzma.open(name, mode=mode + 't')
+        else:  # self.ctype == 'zstd'
+            # Zstandard is available only in Python 3.14 and later
+            assert zstd_present, 'Zstandard compression is unavailable.'
+            self.fp = zstd.open(name, mode=mode + 't')
 
     def close(self):
         """
@@ -175,6 +189,8 @@ class FileObject(object):
             self.ctype = 'bzip2'
         elif ext in ('.xz', '.lzma'):
             self.ctype = 'lzma'
+        elif ext == '.zst':
+            self.ctype = 'zstd'
         else:
             self.ctype = None
 

pysat/allies/approxmc.py

@@ -22,12 +22,12 @@
     Module description
     ==================
 
-    This module provides interface `ApproxMCv4
+    This module provides interface to `ApproxMCv4
     <https://github.com/meelgroup/approxmc/>`_, a state-of-the-art
     *approximate* model counter utilising an improved version of CryptoMiniSat
-    give approximate model counts to problems of size and complexity that are
-    out of reach for earlier approximate model counters. The original work on
-    ApproxMCv4 has been published in [1]_ and [2]_.
+    to give approximate model counts to problems of size and complexity that
+    are out of reach for earlier approximate model counters. The original work
+    on ApproxMCv4 has been published in [1]_ and [2]_.
 
     .. [1] Mate Soos, Kuldeep S. Meel. *BIRD: Engineering an Efficient CNF-XOR
         SAT Solver and Its Applications to Approximate Model Counting*. AAAI
@@ -47,17 +47,17 @@
     The interface gives access to :class:`Counter`, which expects a formula in
     :class:`.CNF` as input. Given a few additional (optional) arguments,
     including a random seed, *tolerance factor* :math:`\\varepsilon`, and
-    *confidence* :math:`\delta`, the class can be used to get an approximate
+    *confidence* :math:`\\delta`, the class can be used to get an approximate
     number of models of the formula, subject to the given tolerance factor and
     confidence parameter.
 
-    Namely, given a CNF formula :math:`\mathcal{F}` with :math:`\#\mathcal{F}`
-    as the exact number of models, and parameters :math:`\\varepsilon\in(0,1]`
-    and :math:`\delta\in[0,1)`, the counter computes and reports a value
-    :math:`C`, which is an approximate number of models of
-    :math:`\mathcal{F}`, such that
-    :math:`\\textrm{Pr}\left[\\frac{1}{1+\\varepsilon}\#\mathcal{F}\leq C\leq
-    (1+\\varepsilon)\#\mathcal{F}\\right]\geq 1-\delta`.
+    Namely, given a CNF formula :math:`\\mathcal{F}` with
+    :math:`\\#\\mathcal{F}` as the exact number of models, and parameters
+    :math:`\\varepsilon\\in(0,1]` and :math:`\\delta\\in[0,1)`, the counter
+    computes and reports a value :math:`C`, which is an approximate number of
+    models of :math:`\\mathcal{F}`, such that
+    :math:`\\textrm{Pr}\\left[\\frac{1}{1+\\varepsilon}\\#\\mathcal{F}\\leq
+    C\\leq (1+\\varepsilon)\\#\\mathcal{F}\\right]\\geq 1-\\delta`.
 
     The implementation can be used as an executable (the list of available
     command-line options can be shown using ``approxmc.py -h``) in the
@@ -131,13 +131,13 @@ class Counter(object):
         models of the formula, subject to *tolerance factor* ``epsilon`` and
         *confidence parameter* ``delta``.
 
-        Namely, given a CNF formula :math:`\mathcal{F}` and parameters
-        :math:`\\varepsilon\in(0,1]` and :math:`\delta\in[0,1)`, the counter
-        computes and reports a value :math:`C` such that
-        :math:`\\textrm{Pr}\left[\\frac{1}{1+\\varepsilon}\#\mathcal{F}\leq
-        C\leq (1+\\varepsilon)\#\mathcal{F}\\right]\geq 1-\delta`. Here,
-        :math:`\#\mathcal{F}` denotes the exact model count for formula
-        :math:`\mathcal{F}`.
+        Namely, given a CNF formula :math:`\\mathcal{F}` and parameters
+        :math:`\\varepsilon\\in(0,1]` and :math:`\\delta\\in[0,1)`, the
+        counter computes and reports a value :math:`C` such that
+        :math:`\\textrm{Pr}\\left[\\frac{1}{1+\\varepsilon}\\#\\mathcal{F}\\leq
+        C\\leq (1+\\varepsilon)\\#\\mathcal{F}\\right]\\geq 1-\\delta`. Here,
+        :math:`\\#\\mathcal{F}` denotes the exact model count for formula
+        :math:`\\mathcal{F}`.
 
         The ``formula`` argument can be left unspecified at this stage. In
         this case, a user is expected to add all the relevant clauses using
@@ -147,7 +147,7 @@ class Counter(object):
         used by ApproxMC. The value of ``seed`` is set to ``1`` by default.
 
         :param formula: CNF formula
-        :param seed: do core trimming at most this number of times
+        :param seed: integer seed value
         :param epsilon: tolerance factor
         :param delta: confidence parameter
         :param verbose: verbosity level
@@ -241,7 +241,7 @@ class Counter(object):
             of :class:`Counter` or through a series of calls to
             :meth:`add_clause`, this method runs the ApproxMC counter with the
             specified values of tolerance :math:`\\varepsilon` and confidence
-            :math:`\delta` parameters, as well as the random ``seed`` value,
+            :math:`\\delta` parameters, as well as the random ``seed`` value,
             and returns the number of models estimated.
 
             A user may specify an argument ``projection``, which is a list of
@@ -371,7 +371,7 @@ if __name__ == '__main__':
     delta, epsilon, projection, seed, verbose, files = parse_options()
 
     # parsing the input formula
-    if files and re.search('\.cnf(\.(gz|bz2|lzma|xz))?$', files[0]):
+    if files and re.search(r'\.cnf(\.(gz|bz2|lzma|xz))?$', files[0]):
         formula = CNF(from_file=files[0])
 
         # creating the counter object

pysat/allies/unigen.py

@@ -0,0 +1,435 @@
+#!/usr/bin/env python
+#-*- coding:utf-8 -*-
+##
+## unigen.py
+##
+##  Created on: Oct 16, 2023
+##      Author: Alexey Ignatiev
+##      E-mail: alexey.ignatiev@monash.edu
+##
+
+"""
+    ===============
+    List of classes
+    ===============
+
+    .. autosummary::
+        :nosignatures:
+
+        Sampler
+
+    ==================
+    Module description
+    ==================
+
+    This module provides interface to `UniGen3
+    <https://github.com/meelgroup/unigen/>`_, a state-of-the-art
+    almost-uniform sampler utilising an improved version of CryptoMiniSat to
+    handle problems of size and complexity that were not possible before. .
+    The original work on UniGen3 has been published in [1]_, [2]_, and [3]_.
+
+    .. [1] Supratik Chakraborty, Kuldeep S. Meel, Moshe Y. Vardi. *Balancing
+        Scalability and Uniformity in SAT Witness Generator*. DAC 2014.
+        pp. 60:1-60:6
+
+    .. [2] Supratik Chakraborty, Daniel J. Fremont, Kuldeep S. Meel, Sanjit A.
+        Seshia, Moshe Y. Vardi. *On Parallel Scalable Uniform SAT Witness
+        Generation*. TACAS 2015. pp. 304-319
+
+    .. [3] Mate Soos, Stephan Gocht, Kuldeep S. Meel. *Tinted, Detached, and
+        Lazy CNF-XOR Solving and Its Applications to Counting and Sampling*.
+        CAV 2020. pp. 463-484
+
+    Note that to be functional, the module requires package ``pyunigen`` to be
+    installed:
+
+    ::
+
+        $ pip install pyunigen
+
+    The interface gives access to :class:`Sampler`, which expects a formula in
+    :class:`.CNF` as input. Given a few additional (optional) arguments,
+    including a random seed, *tolerance factor* :math:`\\varepsilon`,
+    *confidence* :math:`\\delta` (to be used by ApproxMC), and *uniformity
+    parameter* :math:`\\kappa`, the class can be used to get apply
+    almost-uniform sampling and to obtain a requested number of samples as a
+    result, subject to the given tolerance factor and confidence parameter.
+
+    Namely, given a CNF formula :math:`\\mathcal{F}` with the set of
+    satisfying assignments (or models) denoted by :math:`sol(\\mathcal{F})`
+    and parameter :math:`\\varepsilon\\in(0,1]`, a uniform sampler outputs a
+    model :math:`y\\in sol(\\mathcal{F})` such that
+    :math:`\\textrm{Pr}\\left[y \\textrm{ is
+    output}\\right]=\\frac{1}{|sol(\\mathcal{F})|}`. Almost-uniform sampling
+    relaxes the uniformity guarantee and ensures that
+    :math:`\\frac{1}{(1+\\varepsilon)|sol(\\mathcal{F})|} \\leq
+    \\textrm{Pr}\\left[y \\textrm{ is output}\\right] \\leq
+    \\frac{1+\\varepsilon}{|sol(\\mathcal{F})|}`.
+
+    The implementation can be used as an executable (the list of available
+    command-line options can be shown using ``unigen.py -h``) in the
+    following way:
+
+    ::
+
+        $ xzcat formula.cnf.xz
+        p cnf 6 2
+        1 5 0
+        1 6 0
+
+        $ unigen.py -n 4 formula.cnf.xz
+        v +1 -2 +3 -4 -5 -6 0
+        v +1 +2 +3 -4 +5 +6 0
+        v +1 -2 -3 -4 +5 -6 0
+        v -1 -2 -3 -4 +5 +6 0
+
+    Alternatively, the algorithm can be accessed and invoked through the
+    standard ``import`` interface of Python, e.g.
+
+    .. code-block:: python
+
+        >>> from pysat.allies.unigen import Sampler
+        >>> from pysat.formula import CNF
+        >>>
+        >>> cnf = CNF(from_file='formula.cnf.xz')
+        >>>
+        >>> with Sampler(cnf) as sampler:
+        ...     print(sampler.sample(nof_samples=4, sample_over=[1, 2, 3])
+        [[1, 2, 3, 4, 5], [1, -2, -3, -4, -5], [1, -2, -3, -4, 5], [1, 2, -3, 4, 5]]
+
+    As can be seen in the above example, sampling can be done over a
+    user-defined set of variables (rather than the complete set of variables).
+
+    ==============
+    Module details
+    ==============
+"""
+
+#
+#==============================================================================
+from __future__ import print_function
+import getopt
+import os
+from pysat.formula import CNF
+import re
+import sys
+
+# we need pyunigen to be installed:
+pyunigen_present = True
+try:
+    import pyunigen
+except ImportError:
+    pyunigen_present = False
+
+
+#
+#==============================================================================
+class Sampler(object):
+    """
+        A wrapper for UniGen3, a state-of-the-art almost-uniform sampler.
+        Given a formula in :class:`.CNF`, this class can be used to apply
+        almost-uniform sampling of the formula's models, subject to a few
+        input parameters.
+
+        The class initialiser receives a number of input arguments. The
+        ``formula`` argument can be left unspecified at this stage. In this
+        case, a user is expected to add all the relevant clauses using
+        :meth:`add_clause`.
+
+        Additional parameters a user may want to specify include integer
+        ``seed`` (used by ApproxMC), tolerance factor ``epsilon`` (used in the
+        probabilistic guarantees of almost-uniformity), confidence parameter
+        ``delta`` (used by ApproxMC), and uniformity parameter ``kappa`` (see
+        [2]_).
+
+        :param formula: CNF formula
+        :param seed: seed value
+        :param epsilon: tolerance factor
+        :param delta: confidence parameter (used by ApproxMC)
+        :param kappa: uniformity parameter
+        :param verbose: verbosity level
+
+        :type formula: :class:`.CNF`
+        :type seed: int
+        :type epsilon: float
+        :type delta: float
+        :type kappa: float
+        :type verbose: int
+
+        .. code-block:: python
+
+            >>> from pysat.allies.unigen import Sampler
+            >>> from pysat.formula import CNF
+            >>>
+            >>> cnf = CNF(from_file='some-formula.cnf')
+            >>> with Sampler(formula=cnf, epsilon=0.1, delta=0.9) as sampler:
+            ...     for model in sampler.sample(nof_samples=100):
+            ...         print(model)  # printing 100 result samples
+    """
+
+    def __init__(self, formula=None, seed=1, epsilon=0.8, delta=0.2,
+                 kappa=0.638, verbose=0):
+        """
+            Constructor.
+        """
+
+        assert pyunigen_present, 'Package \'pyunigen\' is unavailable. Check your installation.'
+
+        # there are no initial values
+        self.cellc, self.hashc, self.samples = None, None, []
+
+        # creating the Sampler object
+        self.sampler = pyunigen.Sampler(verbosity=verbose, seed=seed,
+                                        delta=delta, epsilon=epsilon,
+                                        kappa=kappa)
+
+        # adding clauses to the sampler
+        if formula:
+            for clause in formula:
+                self.add_clause(clause)
+
+    def __del__(self):
+        """
+            Destructor.
+        """
+
+        self.delete()
+
+    def __enter__(self):
+        """
+            'with' constructor.
+        """
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """
+            'with' destructor.
+        """
+
+        self.delete()
+
+    def add_clause(self, clause):
+        """
+            The method for adding a clause to the problem formula. Although
+            the input formula can be specified as an argument of the
+            constructor of :class:`Sampler`, adding clauses may also be
+            helpful afterwards, *on the fly*.
+
+            The clause to add can be any iterable over integer literals.
+
+            :param clause: a clause to add
+            :type clause: iterable(int)
+
+            .. code-block:: python
+
+                >>> from pysat.allies.unigen import Sampler
+                >>>
+                >>> with Sampler() as sampler:
+                ...     sampler.add_clause(range(1, 4))
+                ...     sampler.add_clause([3, 4])
+                ...
+                ...     print(sampler.sample(nof_samples=4))
+                [[1, 2, -3, 4], [-1, 2, -3, 4], [1, 2, 3, -4], [-1, 2, 3, 4]]
+        """
+
+        self.sampler.add_clause(clause)
+
+    def sample(self, nof_samples, sample_over=None, counts=None):
+        """
+            Given the formula provided by the user either in the constructor
+            of :class:`Sampler` or through a series of calls to
+            :meth:`add_clause`, this method runs the UniGen3 sampler with the
+            specified values of tolerance :math:`\\varepsilon`, confidence
+            :math:`\\delta` parameters, and uniformity parameter :math:`kappa`
+            as well as the random ``seed`` value, and outputs a requested
+            number of samples.
+
+            A user may specify an argument ``sample_over``, which is a list of
+            integers specifying the variables with respect to which sampling
+            should be performed. If ``sample_over`` is left as ``None``,
+            almost-uniform sampling  is done wrt. all the variables of the
+            input formula.
+
+            Finally, argument ``counts`` can be specified as a pair of integer
+            values: *cell count* and *hash count* (in this order) used during
+            sampling. If left undefined (``None``), the values are determined
+            by ApproxMC.
+
+            :param nof_samples: number of samples to output
+            :param sample_over: variables to sample over
+            :param counts: cell count and hash count values
+
+            :type nof_samples: int
+            :type sample_over: list(int)
+            :type counts: [int, int]
+
+            :return: a list of samples
+
+            .. code-block:: python
+
+                >>> from pysat.allies.unigen import Sampler
+                >>> from pysat.card import CardEnc, EncType
+                >>>
+                >>> # cardinality constraint with auxiliary variables
+                >>> # there are exactly 6 models for the constraint
+                >>> # over the 6 original variables
+                >>> cnf = CardEnc.equals(lits=range(1, 5), bound=2, encoding=EncType.totalizer)
+                >>>
+                >>> with Sampler(formula=cnf, epsilon=0.05, delta=0.95) as sampler:
+                ...     for model in sampler.sample(nof_samples=3):
+                ...         print(model)
+                [1, -2, 3, -4, 5, 6, -7, -8, 9, -10, 11, -12, 13, 14, -15, 16, 17, -18, 19, -20]
+                [1, -2, -3, 4, 5, 6, -7, -8, 9, -10, 11, -12, 13, 14, -15, 16, 17, -18, 19, -20]
+                [1, 2, -3, -4, 5, 6, -7, 8, -9, -10, 11, 12, 13, 14, -15, 16, 17, 18, -19, -20]
+                >>>
+                >>> # now, sampling over the original variables
+                >>> with Sampler(formula=cnf, epsilon=0.05, delta=0.95) as sampler:
+                ...     for model in sampler.sample(nof_samples=3, sample_over=range(1, 5)):
+                ...         print(model)
+                [1, 2, -3, -4]
+                [1, -2, 3, -4]
+                [-1, 2, 3, -4]
+        """
+
+        # we cannot pass None as arguments, hence these if-elif branches
+        if sample_over is None and counts is None:
+            self.cellc, self.hashc, self.samples = self.sampler.sample(num=nof_samples)
+        elif counts is None:
+            self.cellc, self.hashc, self.samples = self.sampler.sample(num=nof_samples,
+                                                                       sampling_set=sample_over)
+        elif sample_over is None:
+            self.cellc, self.hashc, self.samples = self.sampler.sample(num=nof_samples,
+                                                                       cell_hash_count=tuple(counts))
+        else:
+            self.cellc, self.hashc, self.samples = self.sampler.sample(num=nof_samples,
+                                                                       sampling_set=sample_over,
+                                                                       cell_hash_count=tuple(counts))
+
+        return self.samples
+
+    def delete(self):
+        """
+            Explicit destructor of the internal Sampler oracle.
+            Delete the actual sampler object and sets it to ``None``.
+        """
+
+        if self.sampler:
+            del self.sampler
+            self.sampler = None
+
+
+#
+#==============================================================================
+def parse_options():
+    """
+        Parses command-line option
+    """
+
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'c:d:e:hk:n:S:s:v:',
+                ['counts=', 'delta=', 'epsilon=', 'help', 'kappa=',
+                 'nof-samples=' 'sample-over=', 'seed=', 'verbose='])
+    except getopt.GetoptError as err:
+        sys.stderr.write(str(err).capitalize())
+        usage()
+        sys.exit(1)
+
+    counts = None
+    delta = 0.2
+    epsilon = 0.8
+    kappa = 0.638
+    nof_samples = 4
+    sample_over = None
+    seed = 1
+    verbose = 0
+
+    for opt, arg in opts:
+        if opt in ('-c', '--counts'):
+            counts = tuple([int(v) for v in str(arg).split(',')])
+        elif opt in ('-d', '--delta'):
+            delta = float(arg)
+        elif opt in ('-e', '--epsilon'):
+            epsilon = float(arg)
+        elif opt in ('-h', '--help'):
+            usage()
+            sys.exit(0)
+        elif opt in ('-k', '--kappa'):
+            kappa = float(arg)
+        elif opt in ('-n', '--nof-samples'):
+            nof_samples = int(arg)
+        elif opt in ('-S', '--sample-over'):
+            # parsing the list of variables
+            sample_over, values = [], str(arg).split(',')
+
+            # checking if there are intervals
+            for value in values:
+                if value.isnumeric():
+                    sample_over.append(int(value))
+                elif '-' in value:
+                    lb, ub = value.split('-')
+                    assert int(lb) < int(ub)
+                    sample_over.extend(list(range(int(lb), int(ub) + 1)))
+
+            # removing duplicates, if any
+            sample_over = sorted(set(sample_over))
+        elif opt in ('-s', '--seed'):
+            seed = int(arg)
+        elif opt in ('-v', '--verbose'):
+            verbose = int(arg)
+        else:
+            assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
+
+    return nof_samples, counts, delta, epsilon, kappa, sample_over, seed, \
+            verbose, args
+
+
+#
+#==============================================================================
+def usage():
+    """
+        Prints usage message.
+        """
+
+    print('Usage:', os.path.basename(sys.argv[0]), '[options] dimacs-file')
+    print('Options:')
+    print('        -c, --counts=<float>        A comma-separated pair of integer values representing cell count and hash count parameters (if any)')
+    print('                                    Note: if omitted, there values are computed by ApproxMC')
+    print('                                    Default: none')
+    print('        -d, --delta=<float>         Confidence parameter as per PAC guarantees')
+    print('                                    Available values: [0, 1) (default = 0.2)')
+    print('        -e, --epsilon=<float>       Tolerance factor as per PAC guarantees')
+    print('                                    Available values: (0 .. 1], all (default = 0.8)')
+    print('        -k, --kappa=<float>         Uniformity parameter')
+    print('                                    Available values: (0 .. 1], all (default = 0.638)')
+    print('        -n, --nof-samples=<int>     Number of required samples')
+    print('                                    Available values: [1 .. INT_MAX] (default = 4)')
+    print('        -S, --sample-over=<list>    If provided, solutions are almost uniformly sampled over this set of variables')
+    print('                                    Available values: comma-separated-list, none (default = none)')
+    print('        -s, --seed=<int>            Random seed')
+    print('                                    Available values: [0 .. INT_MAX] (default = 1)')
+    print('        -v, --verbose=<int>         Verbosity level')
+    print('                                    Available values: [0 .. 15] (default = 0)')
+
+
+#
+#==============================================================================
+if __name__ == '__main__':
+    nof_samples, counts, delta, epsilon, kappa, sample_over, seed, verbose, \
+            files = parse_options()
+
+    # parsing the input formula
+    if files and re.search(r'\.cnf(\.(gz|bz2|lzma|xz))?$', files[0]):
+        formula = CNF(from_file=files[0])
+
+        # creating the sampler object
+        with Sampler(formula, seed=seed, epsilon=epsilon, delta=delta,
+                     kappa=kappa, verbose=verbose) as sampler:
+
+            # almost uniform sampling
+            samples = sampler.sample(nof_samples, sample_over=sample_over,
+                                     counts=counts)
+
+            # printing the result
+            for sample in samples:
+                print('v {0} 0'.format(' '.join(['{0}{1}'.format('+' if v > 0 else '', v) for v in sample])))