Exemple #1
0
    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)))
Exemple #2
0
    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
Exemple #3
0
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))
Exemple #4
0
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
Exemple #5
0
    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
Exemple #6
0
    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
Exemple #7
0
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))
Exemple #8
0
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))
Exemple #9
0
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))