def uporaba(self):
self.lab.destroy()
primer_1 = Ali(a,b)
primer_2 = Ali(In(a,Neg(b),c),a)
primer_3 = Ali(e,In(a,Ali(a,Neg(b),d),c))
primer_4 = In(F(),a)
self.obvestilo.set('''- Klic sat(izraz) nam vrne slovar spremenljivk in njihovih boolovih vrednosti, ki zadostijo temu,
da je izraz rešljiv.
- izraz.cnf() nam vrne izraz v CNF obliki. \n
primer_1 = {0}
primer_1.cnf() = {1}
sat(primer_1) = {2}
primer_2 = {3}
primer_2.cnf() = {4}
sat(primer_2) = {5}
primer_3 = {6}
primer_3.cnf() = {7}
sat(primer_3) = {8}
Če spremenljivkam v izrazu ne moremo določiti takšne vrednosti, da bi bil izraz resničen, nam
funkcija vrne niz 'Izraz ni rešljiv.'
primer_4 = {9}
primer_4.cnf() = {10}
sat(primer_4) = {11}'''.format(primer_1, primer_1.cnf(), sat(primer_1), primer_2, primer_2.cnf(), sat(primer_2), primer_3, primer_3.cnf(),
sat(primer_3), primer_4, primer_4.cnf(), sat(primer_4)))
def elaborate(self, platform):
m = Module()
# pipe the enable
ena_pipe = Signal(2)
m.d.sync += ena_pipe.eq(Cat(self.ena, ena_pipe[0]))
m.d.comb += self.valid.eq(ena_pipe[1])
# shift inputs up
shf_i = Signal(signed(self.isz + 7))
shf_q = Signal(signed(self.isz + 7))
m.d.sync += [
shf_i.eq(self.input_i << self.shift),
shf_q.eq(self.input_q << self.shift)
]
# truncate and saturate to output
m.submodules.sat_i = sat(isz=self.osz + 7, osz=self.osz)
m.submodules.sat_q = sat(isz=self.osz + 7, osz=self.osz)
m.d.comb += [
m.submodules.sat_i.input.eq(shf_i[self.isz - self.osz:]),
m.submodules.sat_q.input.eq(shf_q[self.isz - self.osz:])
]
m.d.sync += [
self.output_i.eq(m.submodules.sat_i.output),
self.output_q.eq(m.submodules.sat_q.output)
]
# count up saturation events
satval = Signal(8)
satcnt = Signal(8)
with m.If(ena_pipe[0]):
m.d.sync += satcnt.eq(satcnt + 1)
with m.If(satcnt == 0):
m.d.sync += [
satval.eq(m.submodules.sat_i.flag
| m.submodules.sat_i.flag),
self.sathld.eq(satval)
]
with m.Else():
m.d.sync += [
satval.eq(satval + (m.submodules.sat_i.flag
| m.submodules.sat_i.flag))
]
return m
def test(n,k,s, izpisuj = False, cas = True):
'''Funkcija testira pravilnost SAT solverja s pomočjo generatorja primerov.
n in k označujeta maksimalno število različnih spr. v izrazu in dolžino
izraza (t.j. število spr. v izrazu). s označuje, koliko primerov želimo
generirati. Če ne želimo izpisovati časa, ki ga SAT solver porabi za
reševanje, nastavimo cas na False. Če ne želimo izpisovati rezultatov testiranja,
nastavimo izpisuj na False.'''
a = time.clock()
for i in range(s):
izraz = generiraj(n,k)
test = majhen_test(izraz, sat(izraz, cas))
if test == False: print('Napaka: SAT solver ne vrne prave rešitve.')
if izpisuj: print(test,'\n')
print('Porabljen čas za {} primerov: {} s.'.format(s,time.clock()-a))
def solve(sudoku, expr):
SIZE = 3
sudoku = clean(sudoku)
rows = sudoku.split('\n')
for i in range(len(rows)):
rows[i] = list(rows[i])
vardict = {}
for i in range(SIZE**2):
for j in range(SIZE**2):
if rows[i][j] != '.':
for n in range(1, SIZE**2 + 1):
vardict[(i + 1) * 100 + (j + 1) * 10 +
n] = str(rows[i][j] == str(n)).lower()
t = time()
solution, vardict, count = sat(expr, vardict)
t = time() - t
solved = [['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '0', '0', '0', '0', '0', '0', '0', '0']]
for k in vardict:
if vardict[k] == 'true':
solved[int(str(k)[0]) - 1][int(str(k)[1]) - 1] = str(k)[2]
for i in range(len(solved)):
solved[i] = ''.join(solved[i])
solved = '\n'.join(solved)
return solved, t, count
def elaborate(self, platform):
m = Module()
# accumulate DC and subtract
dcb_acc = Signal(signed(self.dsz + 1 + self.dc_coeff))
dcb_out = Signal(signed(self.dsz + 1))
valid_pipe = Signal(2)
m.d.sync += valid_pipe.eq(Cat(self.ena, valid_pipe[0]))
with m.If(self.ena):
m.d.sync += [
dcb_acc.eq(dcb_acc + dcb_out),
dcb_out.eq(self.input - (dcb_acc >> self.dc_coeff))
]
# saturate DC block output
m.submodules.dcb_sat = sat(isz=self.dsz + 1, osz=self.dsz)
m.d.comb += m.submodules.dcb_sat.input.eq(dcb_out)
with m.If(valid_pipe[0]):
m.d.sync += self.output.eq(m.submodules.dcb_sat.output)
m.d.comb += self.valid.eq(valid_pipe[1])
return m
def elaborate(self, platform):
m = Module()
# multiplier
mult = Signal(signed(self.csz+self.isz))
m.d.sync += mult.eq(self.input * self.coeff)
# accumulator
acc = Signal(signed(self.csz+self.isz+self.agrw))
rnd_const = Const(1<<(self.csz+1), signed(self.csz+self.isz+self.agrw))
with m.If(self.mac_ena):
m.d.sync += acc.eq(acc + mult)
with m.Else():
m.d.sync += acc.eq(rnd_const)
# truncate, saturate and hold output
m.submodules.sat = sat(isz = self.agrw+self.osz-2, osz = self.osz)
m.d.comb += m.submodules.sat.input.eq(acc[self.csz+2:])
with m.If(self.dump):
m.d.sync += self.output.eq(m.submodules.sat.output)
return m
def barvanje(g,k, cas = True):
'''Sprejme slovar g, ki podaja graf in število barv, s katerimi želimo pobarvati naš graf.
Funkcija vrne slovar vozlišč z njihovimi barvami.'''
return barvanje_sat_to_barve(sat(barvanje_pretvori(g,k),cas))
def hadamard(n, cas = True):
'''Funkcija sprejme število n in vrne Hadamardovo matriko dimenzije n x n (če ta obstaja).'''
return hadamard_sat_to_matrika(sat(hadamard_pretvori(n),cas))
def sudoku(zacetni, cas=True):
"""Sprejme začetne pogoje, podane s seznamom trojic [(i1,j1,k1),(i2,j2,k2),...]. Trojica (i,j,k)
predstavlja polje (i,j), ter vrednost k na tem polju. Funkcija vrne rešitev sudokuja v obliki matrike."""
return sudoku_sat_to_matrika(sat(sudoku_pretvori(zacetni), cas))
