Exemple #1
0
    def run(self):
        self.exportMPS()
        mout = solver(
            self.pathMPS,
            addlazy=True,
            funlazy=self.genLazy(),
            importNeighborhoods=True,
            importedNeighborhoods=self.genNeighborhoods(varCluster=True),
            funTest=self.genTestFunction(),
            alpha=1,
            callback='vmnd',
            verbose=True,
            plotGapsTime=False,
            writeTestLog=True)

        self.resultVars = {
            keyOpTSP(var.varName): var.x
            for var in mout.getVars() if var.x > 0
        }
        return mout
Exemple #2
0
    def run(self,
            outImportNeighborhoods=True,
            outImportedNeighborhoods='function',
            outFunTest=None,
            outAlpha=1,
            outCallback='vmnd',
            outVerbose=True,
            outMinBCTime=0,
            outTimeLimitSeconds=7200,
            writeResult=True,
            outPlotGapsTimes=False,
            outWriteTestLog=False):
        self.exportMPS()

        if outImportedNeighborhoods is 'cluster':
            modelOut = solver(self.pathMPS,
                              verbose=outVerbose,
                              addlazy=False,
                              funlazy=None,
                              importNeighborhoods=outImportNeighborhoods,
                              importedNeighborhoods=self.genNeighborhoods(),
                              funTest=None,
                              callback=outCallback,
                              alpha=outAlpha,
                              minBCTime=outMinBCTime,
                              timeLimitSeconds=outTimeLimitSeconds,
                              plotGapsTime=outPlotGapsTimes,
                              writeTestLog=outWriteTestLog)
        elif outImportedNeighborhoods is 'classic':
            modelOut = solver(
                self.pathMPS,
                verbose=outVerbose,
                addlazy=False,
                funlazy=None,
                importNeighborhoods=outImportNeighborhoods,
                importedNeighborhoods=self.genNeighborhoods(classic=True),
                funTest=None,
                callback=outCallback,
                alpha=outAlpha,
                minBCTime=outMinBCTime,
                timeLimitSeconds=outTimeLimitSeconds,
                plotGapsTime=outPlotGapsTimes,
                writeTestLog=outWriteTestLog)
        else:
            print(
                'Cluster Neighborhoods are the only available in this model.')

        if writeResult:
            file = open(os.path.join(os.path.pardir, 'Results', 'results.txt'),
                        'a')
            line = self.name
            if modelOut.status == GRB.OPTIMAL or modelOut.status == GRB.TIME_LIMIT:
                if outCallback == 'vmnd':
                    line += modelOut._line + '-{}-'.format(
                        outImportedNeighborhoods) + '--MIPGAP: {}--'.format(
                            round(modelOut.MIPGap, 3)) + '\n'
                else:
                    line += modelOut._line + '-{}-'.format(
                        '-pureB&C-') + '--MIPGAP: {}--'.format(
                            round(modelOut.MIPGap, 3)) + '\n'

            else:
                line += ' Feasable solution was not found. ' + '\n'
            file.write(line)
            file.close()

        self.outputvars = {
            var.varName: var.x
            for var in modelOut.getVars() if var.x > 0
        }
        return modelOut
Exemple #3
0
    def run(self,
            outImportNeighborhoods=True,
            outImportedNeighborhoods='function',
            outFunTest=None,
            outAlpha=1,
            outCallback='vmnd',
            outVerbose=True,
            outMinBCTime=0,
            outTimeLimitSeconds=7200,
            writeResult=True,
            outPlotGapsTimes=False,
            outWriteTestLog=False):

        self.exportMPS()

        if outImportedNeighborhoods is 'function':
            modelOut = solver(self.pathMPS,
                              addlazy=True,
                              funlazy=self.genLazy(),
                              importNeighborhoods=True,
                              importedNeighborhoods=self.genNeighborhoods(
                                  funNbhs=True, varCluster=False),
                              funTest=self.genTestFunction(),
                              alpha=outAlpha,
                              callback=outCallback,
                              verbose=outVerbose,
                              minBCTime=outMinBCTime,
                              timeLimitSeconds=outTimeLimitSeconds,
                              plotGapsTime=outPlotGapsTimes,
                              writeTestLog=outWriteTestLog)
        elif outImportedNeighborhoods is 'separated':
            nbhs = self.genNeighborhoods(funNbhs=True)
            nbhs.separateParameterizations()

            modelOut = solver(self.pathMPS,
                              addlazy=True,
                              funlazy=self.genLazy(),
                              importNeighborhoods=True,
                              importedNeighborhoods=nbhs,
                              funTest=self.genTestFunction(),
                              alpha=1,
                              callback=outCallback,
                              verbose=outVerbose,
                              minBCTime=outMinBCTime,
                              timeLimitSeconds=outTimeLimitSeconds,
                              plotGapsTime=outPlotGapsTimes,
                              writeTestLog=outWriteTestLog)
        else:
            modelOut = solver(self.pathMPS,
                              addlazy=True,
                              funlazy=self.genLazy(),
                              importNeighborhoods=True,
                              importedNeighborhoods=self.genNeighborhoods(
                                  funNbhs=False, varCluster=True),
                              funTest=self.genTestFunction(),
                              alpha=outAlpha,
                              callback=outCallback,
                              verbose=outVerbose,
                              minBCTime=outMinBCTime,
                              timeLimitSeconds=outTimeLimitSeconds,
                              plotGapsTime=outPlotGapsTimes,
                              writeTestLog=outWriteTestLog)

        if writeResult:
            file = open(os.path.join(os.path.pardir, 'Results', 'results.txt'),
                        'a')
            line = self.name
            if modelOut.status == GRB.OPTIMAL or modelOut.status == GRB.TIME_LIMIT:
                if outCallback == 'vmnd':
                    line += modelOut._line + '-{}-'.format(
                        outImportedNeighborhoods) + '--MIPGAP: {}--'.format(
                            round(modelOut.MIPGap, 3)) + '\n'
                else:
                    line += modelOut._line + '-{}-'.format(
                        '-pureB&C-') + '--MIPGAP: {}--'.format(
                            round(modelOut.MIPGap, 3)) + '\n'

            else:
                line += ' Feasable solution was not found. ' + '\n'
            file.write(line)
            file.close()

        self.resultVars = {
            keyOpVRP(var.varName): var.x
            for var in modelOut.getVars() if var.x > 0
        }

        return modelOut