def setUp(self): random.seed() self.sample_size = 10 self.test_num = random.randrange(0, 2**6) self.pool_dir = f'TEST_EXPERIMENT_{self.test_num:04X}' self.n = 64 self.db = f'db_{self.test_num:04X}.db' Formula.generate_formula_pool(self.pool_dir, self.sample_size, self.n, 4.2, poolsize=3) self.pool = list( map(partial(os.path.join, self.pool_dir), os.listdir(self.pool_dir)))
def setUp(self): random.seed() dirname = 'test_files' num_vars = random.randrange(10,512) samples = 5 Formula.generate_formula_pool( dirname, samples, num_vars, 4.2, poolsize=3, ) self.formulae = [ Formula.generate_satisfiable_formula(num_vars, 4.2) for _ in range(samples) ]
def setUp(self): random.seed() self.sample_size = 3 self.pool_dir = 'test_files' number_formulae = 10 self.formulae = [ Formula.generate_satisfiable_formula(20, 4.2) for _ in range(number_formulae) ]
def test_hardness(self): n = 500 for i in range(0,self.cases): f = Formula.generate_satisfiable_formula(n, 4.2) atoms = 0 for var in range(1,n+1): if len(f.get_occurrences(var)) > len(f.get_occurrences(-var)): atoms += 1 atoms *= 2 a = Assignment(atoms, n) self.assertFalse(f.is_satisfied_by(a))
def test_occurrences(self): for i in range(0,self.cases): f = Formula.generate_satisfiable_formula(500,4.2) for i in range(1,501): pos_occs = f.get_occurrences(i) neg_occs = f.get_occurrences(-i) # validate positive occurrences for clause_idx in pos_occs: self.assertTrue(i in f.clauses[clause_idx]) # validate negative occurrences for clause_idx in neg_occs: self.assertTrue(-i in f.clauses[clause_idx])
def test_occurrence_counting(self): for i in range(0,self.cases): f = Formula.generate_satisfiable_formula(500, 4.2) occ_count = {} for clause in f.clauses: for lit in clause: if lit in occ_count: occ_count[lit] += 1 else: occ_count[lit] = 1 for k,v in occ_count.items(): self.assertEqual( len(f.get_occurrences(k)), v ) self.assertLessEqual(v, f.max_occs)
def setUp(self): random.seed() cases = 10 self.eps = 2**(-30) self.n = 128 self.r = 4.2 self.significance_level = 0.01 if __debug__ else 0.05 self.sample_size = 1000 self.repeat = 100 self.max_failure = self.repeat * 0.2 self.jump_range = self.n // 10 self.formulae = [ Formula.generate_satisfiable_formula(self.n, self.r) for _ in range(0, cases) ]
def setUp(self): random.seed() cases = 1 if __debug__ else 100 n = 64 r = 4.2 formulae = [ Formula.generate_satisfiable_formula(n, r) for _ in range(0, cases) ] self.solver_setup = dict( max_flips=n * 5, max_tries=100, formulae=formulae, cases=cases, min_successes=cases // 100, )
def test_random_creation_and_reading(self): for i in range(0,self.cases): f = Formula.generate_satisfiable_formula(500, 4.2) self.assertEqual(f, Formula(dimacs = str(f)))
def test_satisfiable_assignment(self): for i in range(0,self.cases): n = random.randrange(10,1001) r = random.randrange(20,42)/10 f = Formula.generate_satisfiable_formula(n,r) self.assertTrue(f.is_satisfied_by(f.satisfying_assignment))
def test_random_creation(self): for i in range(0,self.cases): n = random.randrange(10,1001) r = random.randrange(20,42)/10 f = Formula.generate_satisfiable_formula(n, r) self.assertLess(f.num_clauses - n * r, 2)
def __init__(self, input_files, solver, solver_params, is_static, repetition_of, *init_database, poolsize=1, database='experiments.db'): assert all([os.path.isfile(input_file) for input_file in input_files]),\ "input_files = {} is no List[str]".format(input_files) assert isinstance(solver, str),\ "solver = {} :: {} is no str".format(solver, type(solver)) assert solver in SOLVERS,\ "solver = {} not in {}".format(solver, SOLVERS.keys()) assert isinstance(solver_params, dict),\ "solver_params = {} :: {} is no dict".format(solver_params, type(solver_params)) assert isinstance(poolsize, int),\ "poolsize = {} :: {} is no int".format(poolsize, type(poolsize)) assert poolsize > 0,\ "poolsize = {} <= 0".format(poolsize) assert isinstance(database, str),\ "database = {} :: {} is no str" assert all(isinstance(query, str) for query in init_database),\ "init_database = {} is not a list of str" # get solver functions self.solver = solver self.solver_params = solver_params self.repetition_of = repetition_of # save poolsize self.poolsize = poolsize # save database file self.database = database # no results yet self.results = None with sqlite3.connect(self.database, timeout=60) as conn: # init database, if not already done c = conn.cursor() c.execute(CREATE_EXPERIMENT) c.execute(CREATE_FORMULA) for statement in init_database: c.execute(statement) self.formulae = [] for file in input_files: with open(file, 'r') as f: formula = Formula(dimacs=f.read()) res = c.execute( 'SELECT formula_id FROM formula WHERE formula_file like ?', (file, )) res = list(res) if not res: c.execute(SAVE_FORMULA, (file, formula.num_vars, formula.num_clauses, str(formula.satisfying_assignment))) formula_id = c.lastrowid elif res: formula_id, = res[0] self.formulae.append((formula_id, formula)) c.execute( SAVE_EXPERIMENT, (self.repetition_of, solver, solver_params['noise_param'], solver_params['max_tries'], solver_params['max_flips'], len(input_files), is_static)) self.experiment_id = c.lastrowid conn.commit()
die('SEED is not an integer') elif flag == '--poolsize': try: poolsize = int(flags[flag_idx + 1]) flag_idx += 1 except ValueError: die('POOLSIZE is not an integer') if poolsize <= 0: die('POOLSIZE must be greater than 0') elif flag == '--verbose': verbose = True else: die('What is this shit? {}'.format(flag)) flag_idx += 1 try: Formula.generate_formula_pool(dir, num, num_vars, ratio, poolsize=poolsize, verbose=verbose) except Exception as e: die('{}'.format(str(e)), system_error=True)
from src.solver.probsat import probsat_distribution parser = argparse.ArgumentParser() grp = parser.add_mutually_exclusive_group(required=True) grp.add_argument('--gsat', action='store_true') grp.add_argument('--walksat', action='store_true') grp.add_argument('--probsat', action='store_true') args = parser.parse_args() PATH = [1,2,1,3,1,2,1,0] FORMULA = Formula( clauses=[[1, -2], [-1, 3], [2, 3], [1, 2]], num_vars=3, sat_assignment=Assignment( atoms=[True, True, True], num_vars=3, ), ) ASSGNS = [0, 4, 6, 2, 3, 7, 5, 1] def generate_probs(distribution, context): assgn = Assignment([False, False, False], 3) ctx = context(FORMULA, assgn) probs = [] for i, a in zip(PATH, ASSGNS): probs.append((a, distribution(ctx))) if i > 0: ctx.update(i)