Ejemplo n.º 1
0
    def sinbad(self, d, wgt):
        w = wgt
        d_cmd = ["-d", str(d)]
        w_cmd = ["-w", str(w)]
        MetaUtils.runtool(self.cmd + d_cmd + w_cmd)

        logp = "%s_-d_%s_-w_%s/log" % (self.logd, d, w)
        f = MetaUtils.fitness(logp)
        w_values = [(w,f)]

        while True:
            sys.stderr.write("\n(d, w, f) => (%s, %s, %s)\n" % \
                            (str(d), str(w), str(f)))
            neighw = self.neighbourw(w_values, w)
            w_cmd = ["-w", str(neighw)]
            MetaUtils.runtool(self.cmd + d_cmd + w_cmd)
            logp = "%s_-d_%s_-w_%s/log" % (self.logd, d, neighw)
            neighf = MetaUtils.fitness(logp)
            w_values.append((neighw,neighf))
            fits = [f for _,f in w_values]

            if MetaUtils.localmax(fits):
                for k,f in w_values:
                    print "(%s,%s)" % (k,f)

                fitw,maxf = self.best_w(w_values)
                msg = "\n%s ambiguities found" % maxf
                msg += "\nd=%s, w=%s\n" % (d, fitw)
                sys.stderr.write(msg)

                return fitw, maxf

            w, f = neighw, neighf
Ejemplo n.º 2
0
    def run(self):
        currval = self.initval
        amberoptcmd = [self.switch, str(currval)]
        MetaUtils.runtool(self.cmd + amberoptcmd)
        currfit = MetaUtils.fitness("%s_%s/log" % (self.logd, currval))
        self.k_values.append((currval,currfit))

        while True:
            sys.stderr.write("\n==> current value: %s, fitness: %s\n" \
                             % (str(currval),str(currfit)))
            neighval = self.neighbour(currval)
            sys.stderr.write("neighval: %s" % (str(neighval)))
            amberoptcmd = [self.switch, str(neighval)]
            MetaUtils.runtool(self.cmd + amberoptcmd)
            neighfit = MetaUtils.fitness("%s_%s/log" % (self.logd, neighval))
            sys.stderr.write("new fitness: %s " % str(neighfit))
            self.k_values.append((neighval,neighfit))

            fitvals = [f for _,f in self.k_values]
            if MetaUtils.localmax(fitvals, 3):
                MetaUtils.report(self.k_values)
                sys.exit(0)

            currval = neighval
            currfit = neighfit
Ejemplo n.º 3
0
    def run(self):
        currlen = self.length
        ambidextoptcmd = ["-k",str(currlen)]
        MetaUtils.runtool(self.cmd + ambidextoptcmd)
        currfit = MetaUtils.fitness("%s_%s/log" % (self.logd, currlen))
        self.k_values.append((currlen,currfit))

        while True:
            sys.stderr.write("\n==> current length: %s, fitness: %s\n" \
                            % (str(currlen),str(currfit)))
            neighlen = self.neighbour(currlen)
            ambidextoptcmd = ["-k",str(neighlen)]
            MetaUtils.runtool(self.cmd + ambidextoptcmd)
            neighfit = MetaUtils.fitness("%s_%s/log" % (self.logd, neighlen))
            sys.stderr.write("new fitness: %s " % str(neighfit))
            self.k_values.append((neighlen,neighfit))

            fitvals = [f for _,f in self.k_values]
            if MetaUtils.localmax(fitvals, NBEST):
                MetaUtils.report(self.k_values)
                sys.exit(0)

            currlen = neighlen
            currfit = neighfit
Ejemplo n.º 4
0
 def sinbad(self, d):
     MetaUtils.runtool(self.cmd + ["-d", str(d)])
     f = MetaUtils.fitness("%s_-d_%s/log" % (self.logd, d))
     return f