import random, copy, math, time, sys

class Grad(object):     
    def __init__(self, x, y, label):
        self.x = x
        self.y = y
        self.label = label
       
    def rastojanje(self, grad):
        """
        rastojanje ovog grada od grada primljenog kao prarametar
        preko euklidske metrike (odnosno funkcije hypot).
        """
        return math.hypot(self.x - grad.x, self.y - grad.y)
       
    def __str__(self):
        return "%s(%d, %d)" % (self.label, self.x, self.y)
 
           
class Resenje(object):
    def __init__(self, gradovi=[]):
        self.gradovi = [] # gradovi
       
    def get_duzina_puta(self):
        duzina = 0.0
       
        for i in range(len(self.gradovi)):
            tek_grad = self.gradovi[i]
            sledeci_grad = self.gradovi[(i+1) % len(self.gradovi)]
            duzina += tek_grad.rastojanje(sledeci_grad)
           
        return duzina
   
    # duzina_puta je property kao u C#, get metoda je get_duzina_puta
    # set metoda ne postoji (read-only property)
    duzina_puta = property(get_duzina_puta)
   
    # tweak funkcija u simuliranom kaljenju, zamenjuje 2 slucajno odabrana razlicita grada
    def zameni_put(self):
        g1 = random.randrange(len(self.gradovi))
        g2 = random.randrange(len(self.gradovi))
       
        while g2 == g1: # obezbedjivanje da g2 != g1
            g2 = random.randrange(len(self.gradovi))
           
        # zamena elemanata u jednom redu, u ostalim jezicima se to radi u 3 reda preko pomocne promenjive
        self.gradovi[g1], self.gradovi[g2] = self.gradovi[g2], self.gradovi[g1]
   
    # za potrebe crtanja grafova   
    def koordinate(self):
        x, y = [], []
       
        for grad in self.gradovi:
            x.append(grad.x)
            y.append(grad.y)
       
        return x, y
       
       
class SimulatorKaljenja(object):
    def __init__(self, pocetno_resenje):
        self.pocetno_resenje = copy.deepcopy(pocetno_resenje)
        self.najbolje_resenje = None
        self.duzine = []
        self.temperature = []
       
    def stampaj_resenje(self): 
        if self.najbolje_resenje:
            try:
                # ako je instalirana matplot biblioteka koristi je za graficki prikaz
                import matplotlib.pyplot as plt
               
                x1, y1 = self.pocetno_resenje.koordinate()
                x3, y3 = self.najbolje_resenje.koordinate()
               
                # 1. tacku dodajemo ponovo da bi zatvorili konturu od poslednje ka 1. tacki
                x1.append(x1[0])
                y1.append(y1[0])
                x3.append(x3[0])
                y3.append(y3[0])
               
                # prvi grafikon
                plt.figure(1)
                plt.title('prikaz pocetnog i nadjenog resenja')
                plt.plot(x1, y1, 'k--', label='pocetno r.')
                plt.plot(x3, y3, 'g', marker='.', markerfacecolor='r', markersize=20, label='najbolje r.')
                plt.text(2, 95, 'pocetna duzina: %f.2' % self.pocetno_resenje.duzina_puta)
                plt.xlabel('x koordinata')
                plt.ylabel('y koordinata')
                plt.text(2, 87, 'najbolja duzina: %f.2' % self.najbolje_resenje.duzina_puta)
                plt.legend()
               
                for grad in self.najbolje_resenje.gradovi:
                    plt.text(grad.x, grad.y - 2.5, grad.label)
               
                plt.axis([min(x1) -1, max(x1) + 1, min(y1) -1, max(y1) +1])
               
                # drugi grafikon
                plt.figure(2)
               
                # 1. subplot
                plt.subplot(2, 1, 1)
                plt.title('kretanje temperature po iteracijama')
                plt.plot(self.temperature, 'r')
                plt.xlabel('iteracija')
                plt.ylabel('temperatura')
               
                # 2. subplot
                plt.subplot(2, 1, 2)
                plt.title('vrednost f. cilja po iteracijama (duzina puta)')
                plt.plot(self.duzine)
                plt.xlabel('iteracija')
                plt.ylabel('duzina puta')
               
                plt.show()
            except ImportError:
                # nema matplot biblioteke stampaj resenje
                print "Pocetno resenje"
                print self.pocetno_resenje.gradovi
                print "duzina puta je: ", self.pocetno_resenje.duzina_puta
                print "\nResenje"
                print self.najbolje_resenje.gradovi
                print "duzina puta je: ", self.najbolje_resenje.duzina_puta
               
               
    def start(self, pocetna_temperatura=100, alpha=0.999, ponavljanja=10):
        tekuce_resenje = copy.deepcopy(self.pocetno_resenje)
        privremeno_resenje = copy.deepcopy(self.pocetno_resenje)
        najbolje_resenje = copy.deepcopy(self.pocetno_resenje)
        tek_temperatura = pocetna_temperatura
        ZAUSTAVNA_TEMPERATURA = 0.4
       
        while tek_temperatura > ZAUSTAVNA_TEMPERATURA:
           
            # pamtimo kretanje duzine i temperature kroz iteracije
            # da bismo ih kasnije prikazali na grafikonu
            self.duzine.append(tekuce_resenje.duzina_puta)
            self.temperature.append(tek_temperatura)
           
            for i in xrange(ponavljanja):
                privremeno_resenje.zameni_put()
               
                delta_e = privremeno_resenje.duzina_puta - tekuce_resenje.duzina_puta
               
                # ako je privremeno_resenje bolje (delta_e < 0) uzimamo ga
                # a ako nije tada uz odredjenu verovatnocu po formuli:
                # e^(-delta_e / tek_temperatura) odabiramo losije resenje kao tekuce
                # ta verovatnoca je obrnuto srazmerna tek_temperaturi i sto je to novo
                # resenje losije (sto je delta_e vece) ono se teze usvaja
                if delta_e < 0.0 or ( math.exp(-delta_e / tek_temperatura) > random.random() ):
                    tekuce_resenje = copy.deepcopy(privremeno_resenje)
                    if tekuce_resenje.duzina_puta < najbolje_resenje.duzina_puta:
                        najbolje_resenje = copy.deepcopy(tekuce_resenje)
                else:
                    # resetujemo privremeno resenje i probamo dalje
                    privremeno_resenje = copy.deepcopy(tekuce_resenje)
                   
            tek_temperatura *= alpha # ladimo metal
       
        self.najbolje_resenje = najbolje_resenje
       
        return najbolje_resenje
   
   
def main():
    try:
        import psyco # ako je instalirana biblioteka koristi je (ubrzava izvsenje koda)
        psyco.full()
    except ImportError:
        pass   
   
    gradovi = [Grad(1, 2, 'a'), Grad(29, 21, 'b'),Grad(100, 60, 'c'), Grad(12, 86, 'd'),
            Grad(92, 46, 'e'), Grad(83, 38, 'f'), Grad(55, 36, 'g'), Grad(71, 99, 'h'),
            Grad(12, 41, 'i'), Grad(34, 48, 'j'), Grad(69, 33, 'k'), Grad(78, 10, 'l'),
            Grad(86, 68, 'm'), Grad(79, 27, 'n'), Grad(22, 69, 'o'), Grad(75, 55, 'p'),
            Grad(51, 68, 'r'), Grad(91, 23, 's'), Grad(22, 42, 't'), Grad(47, 80, 'u'),
            Grad(60, 10, 'w'), Grad(91, 79, 'v'), Grad(5, 66, 'x'), Grad(42, 90, 'y'),
            Grad(23, 59, '1'), Grad(46, 83, '2'), Grad(93, 63, '3'), Grad(47, 17, '4'),
            Grad(53, 79, '5'), Grad(76, 23, '6'), Grad(91, 62, '7'), Grad(44, 97, '8'),]
   
    proizvoljno_resenje = Resenje(gradovi)
   
    simulator = SimulatorKaljenja(proizvoljno_resenje)
   
    simulator.start(ponavljanja=10, alpha=0.999, pocetna_temperatura=90)
    simulator.stampaj_resenje()
   

if __name__ == "__main__":
    main()

exp(- razlika_dva_resenja / tekuca_temperatura)

e^(-x) gde je x = razlika_dva_resenja / tekuca_temperatura

75.0764567185   90   0.434229165807
17.3593113928   90   0.824579897332
118.09201759    90   0.269245001197

...

31.4344003928   17.6722502633   0.16885017326
16.566552488    17.6722502633   0.391631822873
140.561224799   17.6722502633   0.000351330940057

...

8.22096986597   0.515936516748   1.20204364492e-07
101.337446793   0.515936516748   4.99157972659e-86
55.2667664311   0.515936516748   3.01073439562e-47
105.114565261   0.515420580231   2.69303981418e-89

import random, copy, math, time

class Resenje(object):
    def __init__(self, br_kraljica):
        self.br_kraljica = br_kraljica
        # resenje: pozicija kraljice u koloni 0 do len - 1
        self.kraljice = range(br_kraljica) 
        # energija: treba da je  0
        self.__broj_sukoba = None
       
        ## postavljamo pocetno resenje
        # generisemo tabelu br_kraljica X br_kraljica popunjenu None elementima
        self.tabla = [[None for i in range(br_kraljica)] for j in range(br_kraljica)]
       
        # postavimo kraljice po dijagonali
        for i in xrange(br_kraljica):
            self.tabla[i][i] = 'K'
       
        # promesamo kolone   
        for i in xrange(br_kraljica):
            self.tvikuj_resenje()
       
    # f-ja cilja, optimalno resenje ima 0 sukoba   
    def get_broj_sukoba(self):
        # Ovo je optimizacija da se broj sukoba racuna samo ako vec nije izrazcunat
        if not self.__broj_sukoba:
            self.__broj_sukoba = self.__racunaj_broj_sukoba()
        return self.__broj_sukoba
   
    # racuna energiju resenja, prakticno funkciju cilja koja se minimizuje
    # a je ovde broj sukoba svih kraljica na tabli
    def __racunaj_broj_sukoba(self):
        # povratna vr.
        # zato sto se sukobljava sam sa sobom i to pri proveri svake od 4
        # dijagonala a to se ne racuna
        br_sukoba = -4 * self.br_kraljica
       
        dx = (-1, 1, -1, 1) # pomeraj koordinate x za kretanje po dijagonalama
        dy = (-1, 1, 1, -1) # pomeraj koordinate y -//-
       
        # provera dijagonala
        for x, y in enumerate(self.kraljice): # (x,y) koord. kraljica
            for i in xrange(4): # za sva 4 kraka dijagonala
                pomx, pomy = x, y # pretraga krece od koordinata kraljice
                # dok se pomeranjem po dijagonali nalazimo na tabli ispitujemo
                # da li smo nabasali na kraljicu. Svaki od 4 ciklusa za 4 dijagonale
                # nailazi na sopstvenu kraljicu pa je zato br_sukoba inicijalizovan
                # na -4 * self.br_kraljica
                while (0 <= pomx < self.br_kraljica) and (0 <= pomy < self.br_kraljica):
                    if self.tabla[pomx][pomy] == 'K':
                        br_sukoba += 1
                    pomx += dx[i]
                    pomy += dy[i]
           
        return br_sukoba
   
    broj_sukoba = property(get_broj_sukoba)
   
    # zamenjuje 2 kolone
    def tvikuj_resenje(self):
        r1 = random.randrange(self.br_kraljica)
        r2 = random.randrange(self.br_kraljica)
       
        # kolone moraju biti razlicite
        while r2 == r1:
            r2 = random.randrange(self.br_kraljica)
           
        # zameni redove r1 i r2
        self.tabla[r1], self.tabla[r2] = self.tabla[r2], self.tabla[r1]
       
        # zameni elemente
        self.kraljice[r1], self.kraljice[r2] = self.kraljice[r2], self.kraljice[r1]
       
        # prethodno izracunata duzina puta vise ne vazi pa se setuje na None
        self.__broj_sukoba = None
   
    def __str__(self):
        rez = ''
        for red in self.tabla:
            s = ''
            for element in red:
                if element: s += element
                else: s += '.'
            rez += s
            rez += '\n'
        return rez
       
   
class SimulatorKaljenja(object):
    def __init__(self, br_kraljica):
        self.br_kraljica = br_kraljica
        self.resenje = None
       
    def start(self, pocetna_temperatura=90.0, alpha=0.997, ponavljanja=None):
        najbolje_resenje = Resenje(self.br_kraljica)
        #privremeno_resenje = copy.deepcopy(najbolje_resenje)
        tekuca_temp = pocetna_temperatura
        if not ponavljanja: ponavljanja = self.br_kraljica / 2
       
       
        while tekuca_temp > 0.10 and najbolje_resenje.broj_sukoba > 0:
            privremeno_resenje = copy.deepcopy(najbolje_resenje)
           
            # Monte Carlo na tekucoj temperaturi
            for i in xrange(ponavljanja):
                privremeno_resenje.tvikuj_resenje()
               
                delta_e = privremeno_resenje.broj_sukoba - najbolje_resenje.broj_sukoba
               
                # ako je resenje bolje uzimamo ga a ako nije tada uz
                # odredjenu verovatnocu odabiramo losije resenje kao tekuce
                if delta_e < 0.0 or (math.exp(-delta_e / tekuca_temp) > random.random()):
                    if  privremeno_resenje.broj_sukoba < najbolje_resenje.broj_sukoba:
                        najbolje_resenje = copy.deepcopy(privremeno_resenje)
                else:
                    privremeno_resenje = copy.deepcopy(najbolje_resenje)
               
            tekuca_temp *= alpha
       
        self.resenje = najbolje_resenje
   
def main():
    try:
        import psyco
        psyco.full()
    except ImportError:
        pass
       
    simulator = SimulatorKaljenja(32)   
   
    t0 = time.time()

    i = 1
    while True:
        print 'ciklus', i
        i += 1
        simulator.start()
        print 'najbolje resenje', simulator.resenje.broj_sukoba
        if simulator.resenje.broj_sukoba == 0:
            break
   
    print simulator.resenje
    print "Izvrsenje trajalo", time.time() - t0, "sekundi"
   

if __name__ == "__main__":
    main()

ciklus 1
najbolje resenje 2
ciklus 2
najbolje resenje 0
.K..............................
....................K...........
..................K.............
............K...................
..K.............................
...........................K....
.................K..............
K...............................
..........K.....................
.....K..........................
...............................K
...................K............
..........................K.....
.............K..................
.....................K..........
............................K...
...............K................
.............................K..
......................K.........
......K.........................
.........................K......
.......K........................
..............K.................
...........K....................
..............................K.
....K...........................
................K...............
........................K.......
.........K......................
.......................K........
...K............................
........K.......................

Izvrsenje trajalo 35.1647040844 sekundi

kolicina_feromona = kolicina_feromona + Q/duzina_Hamiltonove_konture *RO

kolicina_feromona +=  Q/duzina_Hamiltonove_konture *RO

kolicina_feromona = kolicina_feromona * (1 - RO)

kolicina_feromona *= (1 - RO)

P = (Tau**ALFA * Eta**BETA) / SUM(Tau**ALFA * Eta**BETA)

import random, copy, math, time

class Grad(object):     
    def __init__(self, x, y, ime):
        self.x = x
        self.y = y
        self.ime = ime
       
    def rastojanje(self, grad):
        """
        rastojanje ovog grada od grada primljenog kao prarametar
        preko euklidske metrike (odnosno funkcije hypot).
        """
        return math.hypot(self.x - grad.x, self.y - grad.y)
       
    def __str__(self):
        return "%s(%d, %d)" % (self.ime, self.x, self.y)
 
class Ivica(object):
    def __init__(self, feromoni, duzina):
        self.feromoni = feromoni
        self.duzina = duzina

class Mrav(object):
    # atribut klase u kojem se cuva broj svih stvorenih mrava
    brojac = -1
    gradovi = None
    ivice = None
   
    def inicijalizuj_atribute(self):
        self.tek_grad = self.pocetni_grad
        self.putanja = [self.tek_grad] 
        self.duzina_putanje = 0.0
       
    def __init__(self, gradovi, alfa, beta, ro, q):
        Mrav.ALFA = alfa
        Mrav.BETA = beta
        Mrav.RO = ro
        Mrav.Q = q
       
        if not Mrav.gradovi:
            Mrav.gradovi = gradovi
           
        if not Mrav.ivice:
            Mrav.ivice = {}
            init_feromoni = 1.0 / len(Mrav.gradovi)
            for i in Mrav.gradovi:
                for j in Mrav.gradovi:
                    if i != j :
                        rastojanje = i.rastojanje(j)
                        Mrav.ivice[i, j] = Ivica(init_feromoni, rastojanje)
                       
        Mrav.brojac += 1
        self.pocetni_grad = Mrav.gradovi[Mrav.brojac % len(Mrav.gradovi)]
       
        self.inicijalizuj_atribute()
       
    def _tau_x_eta(self, do_grad):
        # izracunava vrednost pozeljnosti ivice od tekuceg grada do grada
        # primljenog kao parametar. Pozeljnost ivice je direktno proporcionalna
        # kolicini feromona na njoj (sto se oznacava sa tau), a obratni proporcionalna
        # njenoj duzini (eta). Stepenovanjem tau i eta sa parametrima ALFA i BETA
        # omogucava nam da dajemo prednost jednom ili drugom kriterijumu pozeljnosti
        # i to tako sto BETA oznacava koliko umanjujemo znacaj blizine a ALFA
        # koliko umanjujemo znacaj feromona. Npr. za ALFA: 1 i BETA: 5 znaci da
        # nam je vaznija kolicina feromona od blizine
        ivica = Mrav.ivice[self.tek_grad, do_grad]
        tau = ivica.feromoni
        eta = 1.0 / ivica.duzina
       
        return tau**Mrav.ALFA * eta**Mrav.BETA
       
    def _odaberi_sledeci_grad(self):
        imenilac = 0.0
       
        # svi gradovi razlika poseceni = neposeceni, skupovna operacija
        neposeceni_gradovi = set(Mrav.gradovi).difference(self.putanja)
       
        # ako nema neposecenih vrati None
        if not neposeceni_gradovi:       
            return None
       
        # za svaki neposeceni grad izracunaj _tau_x_eta i saberi
        # tj. racunamo zbir svih pozeljnosti posete neposecenim gradovima
        for grad in neposeceni_gradovi:
            imenilac += self._tau_x_eta(grad)
       
        # za svaki neposecen grad izracunaj verovatnocu posete p
        # i pokusaj da je ostvaris, ako je ne ostvaris probaj
        # ponovo sve iz pocetka dok konacno ne uspes u tome.
        # Verovatnoca posete se izravunava tako sto podelimo pozeljnost posete
        # neposecenog grada sa zbirom svih pozeljnosti posete neposecenim gradovima
        while True:
            for grad in neposeceni_gradovi:
                p = self._tau_x_eta(grad) / imenilac
               
                if random.random() < p:
                    return grad

    def pusti_mrava(self):
        sled_grad = self._odaberi_sledeci_grad()
       
        # dok postoji sledeci grad za obilazak stavi ga u putanju obishenih
        # azuriraj duzinu putanje mrava i tekuci grad a zatim nadji sledeci grad
        while sled_grad:
            self.putanja.append(sled_grad)
            self.duzina_putanje += Mrav.ivice[self.tek_grad, sled_grad].duzina
            self.tek_grad = sled_grad
            sled_grad = self._odaberi_sledeci_grad()
       
        # sad je sled_grad None znaci da smo prosli sve gradove
        # a Hamiltonovu konturu zatvaramo vezujuci 1. i poslednji
        # poseceni grad koji se cuvaju u self.putanja (0. i -1. poziciju)
        self.duzina_putanje += Mrav.ivice[self.putanja[0], self.putanja[-1]].duzina
       
    def pospi_feromone(self):
        br_gradova = len(self.putanja)
       
        # svakoj ivici putanje mrava (Hamiltonove konture) u oba smera dodaj
        # odgovarajucu kolicinu feromona po formuli Q / duzina_putanje * RO
        for i in xrange(br_gradova):
            od_grada = self.putanja[i]
            do_grada = self.putanja[(i + 1) % br_gradova]
           
            Mrav.ivice[od_grada, do_grada].feromoni += Mrav.Q / self.duzina_putanje * Mrav.RO
            Mrav.ivice[do_grada, od_grada].feromoni = Mrav.ivice[od_grada, do_grada].feromoni
           
    @staticmethod
    def ispari_feromone():
        # smanji kolicinu feromona na svakoj ivici po rekurentnoj formuli feromoni *= 1 / RO
        for ivica in Mrav.ivice.itervalues():
            ivica.feromoni *= (1.0 - Mrav.RO)
           
    def koordinate(self):
        x, y = [], []
       
        for grad in self.putanja:
            x.append(grad.x)
            y.append(grad.y)
       
        return x, y
   
    # toString u javi       
    def __str__(self):
        return "duzina puta: %f" % self.duzina_putanje
   
    # compare u javi
    def __cmp__(self, drugi):
        return cmp(self.duzina_putanje, drugi.duzina_putanje)
           
           
class MravljiSimulator(object):
    def __init__(self, gradovi, ALFA = 1.0, BETA = 5.0, RO = 0.5, Q = 100.0):
        self.mravi = []
        for i in xrange(len(gradovi)):
            self.mravi.append(Mrav(gradovi, ALFA, BETA, RO, Q))
        self.najbolji_mrav = self.mravi[0] # proizvoljnog mrava proglasimo najboljim
       
    def start(self, ponavljanja=20):
        # za svako ponavljanje
        for i in xrange(ponavljanja):
            # pusti svakog mrava da napravi Hamiltonovu konturu
            for mrav in self.mravi:
                mrav.pusti_mrava()
               
            Mrav.ispari_feromone()
               
            # svaki mrav nek pospe feromone na svojoj konturi
            for mrav in self.mravi:
                mrav.pospi_feromone()
               
            najuspesniji_mrav_generacije = min(self.mravi)
           
            # pamtimo sveukupno najuspesnijeg mrava
            self.najbolji_mrav = copy.deepcopy(
                    min(self.najbolji_mrav, najuspesniji_mrav_generacije))
           
            # pripremamo mrave za ponavljanje tako sto ih resetujemo
            for mrav in self.mravi:
                mrav.inicijalizuj_atribute()
               
    def stampaj_resenje(self): 
        if self.najbolji_mrav:
            try:
                # ako je instalirana matplot biblioteka koristi je za graficki prikaz
                import matplotlib.pyplot as plt
               
                x, y = self.najbolji_mrav.koordinate()
                               
                # 1. tacku dodajemo ponovo da bi zatvorili konturu od poslednje ka 1. tacki
                x.append(x[0])
                y.append(y[0])
               
                plt.title('prikaz nadjenog resenja')
                plt.plot(x, y, 'g', marker='.', markerfacecolor='r', markersize=20, label='najbolje r.')
                plt.xlabel('x koordinata')
                plt.ylabel('y koordinata')
                plt.text(2, 95, 'najbolja duzina: %f.2' % self.najbolji_mrav.duzina_putanje)
                plt.legend()
               
                for grad in self.najbolji_mrav.putanja:
                    plt.text(grad.x, grad.y - 2.5, grad.ime)
               
                plt.axis([min(x) -1, max(x) + 1, min(y) -1, max(y) +1])             
             
                plt.show()
            except ImportError:
                # nema matplot biblioteke stampaj resenje rucno
                print "Resenje"
                print self.najbolji_mrav.putanja
                print "duzina puta je: ", self.najbolji_mrav.duzina_putanje
               
       
def main():
    try:
        import psyco # ako je instalirana biblioteka koristi je (ubrzava izvsenje koda)
        psyco.full()
    except ImportError:
        pass   
   
    gradovi = [Grad(1, 2, 'a'), Grad(29, 21, 'b'),Grad(100, 60, 'c'), Grad(12, 86, 'd'),
            Grad(92, 46, 'e'), Grad(83, 38, 'f'), Grad(55, 36, 'g'), Grad(71, 99, 'h'),
            Grad(12, 41, 'i'), Grad(34, 48, 'j'), Grad(69, 33, 'k'), Grad(78, 10, 'l'),
            Grad(86, 68, 'm'), Grad(79, 27, 'n'), Grad(22, 69, 'o'), Grad(75, 55, 'p'),
            Grad(51, 68, 'r'), Grad(91, 23, 's'), Grad(22, 42, 't'), Grad(47, 80, 'u'),
            Grad(60, 10, 'w'), Grad(91, 79, 'v'), Grad(5, 66, 'x'), Grad(42, 90, 'y'),
            Grad(23, 59, '1'), Grad(46, 83, '2'), Grad(93, 63, '3'), Grad(47, 17, '4'),
            Grad(53, 79, '5'), Grad(76, 23, '6'), Grad(91, 62, '7'), Grad(44, 97, '8'),
            ]
           
    simulator = MravljiSimulator(gradovi, ALFA=1.0, BETA = 2.0, RO=0.5)
   
    t0 = time.time()
    simulator.start(ponavljanja=50)
    print "Izvrsenje trajalo", time.time() - t0, "sekundi"
   
    simulator.stampaj_resenje()

if __name__ == "__main__":
    main()