Beispiel #1
0
    def areItemsSwitchable(self, chromosome, periodGene, altPeriod,
                           periodGeneLowerLimit, periodGeneUpperLimit):
        """
        """

        if chromosome.stringIdentifier[altPeriod] > 0:
            altPeriodGene = chromosome.genesByPeriod[altPeriod]
            altPeriodGeneLowerLimit, altPeriodGeneUpperLimit = Chromosome.geneLowerUpperLimit(
                chromosome, altPeriodGene)

            if (periodGeneLowerLimit <= altPeriod
                    and altPeriod < periodGeneUpperLimit) and (
                        altPeriodGeneLowerLimit <= periodGene.period
                        and periodGene.period < altPeriodGeneUpperLimit):
                return True
        else:
            if (periodGeneLowerLimit <= altPeriod
                    and altPeriod < periodGeneUpperLimit):
                return True

        return False
Beispiel #2
0
    def searchIndividu(self, chromosome, strategy):
        """
        """

        results = []

        if strategy == "absolute_mutation":
            if self._visitedNodes[chromosome.stringIdentifier] is not None:
                return None
            print("chrom : ", chromosome, self.searchDepth)

        # shuffledPeriods = [(period, item) for period, item in enumerate(chromosome.stringIdentifier)]

        # print("shuffledPeriods : ", shuffledPeriods, chromosome.stringIdentifier)
        # random.shuffle(shuffledPeriods)

        orderedGenes = [
            gene for itemGenes in chromosome.dnaArray for gene in itemGenes
            if gene.cost > 0
        ]
        # orderedGenes.sort(key=lambda gene: gene.cost, reverse= True)

        random.shuffle(orderedGenes)

        # print("ordered : ", orderedGenes)
        for periodGene in orderedGenes:

            print("gene : ", periodGene)
            periodGeneLowerLimit, periodGeneUpperLimit = Chromosome.geneLowerUpperLimit(
                chromosome, periodGene)

            i = 1
            backwardPeriod, forwardPeriod = periodGene.period, periodGene.period
            while True:
                if forwardPeriod is not None:
                    forwardPeriod = periodGene.period + i
                if backwardPeriod is not None:
                    backwardPeriod = periodGene.period - i

                if backwardPeriod is not None and backwardPeriod < 0:
                    backwardPeriod = None

                if forwardPeriod is not None and forwardPeriod > InputDataInstance.instance.nPeriods - 1:
                    forwardPeriod = None

                # print(backwardPeriod, forwardPeriod)
                if backwardPeriod is not None:
                    if self.areItemsSwitchable(chromosome, periodGene,
                                               backwardPeriod,
                                               periodGeneLowerLimit,
                                               periodGeneUpperLimit):
                        evaluationData = self.evaluateItemsSwitch(
                            chromosome, periodGene, backwardPeriod)
                        if strategy == "random_mutation":
                            self.result = self.switchItems(
                                chromosome, periodGene, backwardPeriod,
                                evaluationData)
                            return None

                        if strategy == "population":
                            results.append(
                                self.switchItems(chromosome, periodGene,
                                                 backwardPeriod,
                                                 evaluationData))

                        if strategy == "positive_mutation":
                            if evaluationData["variance"] > 0:
                                self.result = self.switchItems(
                                    chromosome, periodGene, backwardPeriod,
                                    evaluationData)
                                return None

                        if strategy == "simple_mutation":
                            if evaluationData["variance"] > 0:
                                self.result = self.switchItems(
                                    chromosome, periodGene, backwardPeriod,
                                    evaluationData)
                                return None
                            results.append(evaluationData)

                        if strategy == "absolute_mutation":
                            if evaluationData["variance"] > 0:
                                results.append(evaluationData)
                    else:
                        backwardPeriod = None

                if forwardPeriod is not None:
                    if self.areItemsSwitchable(chromosome, periodGene,
                                               forwardPeriod,
                                               periodGeneLowerLimit,
                                               periodGeneUpperLimit):
                        evaluationData = self.evaluateItemsSwitch(
                            chromosome, periodGene, forwardPeriod)
                        if strategy == "random_mutation":
                            self.result = self.switchItems(
                                chromosome, periodGene, forwardPeriod,
                                evaluationData)
                            return None

                        if strategy == "population":
                            results.append(
                                self.switchItems(chromosome, periodGene,
                                                 forwardPeriod,
                                                 evaluationData))

                        if strategy == "positive_mutation":
                            if evaluationData["variance"] > 0:
                                self.result = self.switchItems(
                                    chromosome, periodGene, forwardPeriod,
                                    evaluationData)
                                return None

                        if strategy == "simple_mutation":
                            if evaluationData["variance"] > 0:
                                self.result = self.switchItems(
                                    chromosome, periodGene, forwardPeriod,
                                    evaluationData)
                                return None
                            results.append(evaluationData)

                        if strategy == "absolute_mutation":
                            if evaluationData["variance"] > 0:
                                results.append(evaluationData)
                    else:
                        forwardPeriod = None

                if backwardPeriod is None and forwardPeriod is None:
                    break

                i += 1

                if strategy == "absolute_mutation":
                    if len(results) > 0:
                        self.searchDepth += 1
                        self._visitedNodes[chromosome.stringIdentifier] = 1
                        self.searchIndividu(results[-1], strategy)

                        if self._stopSearchEvent.is_set():
                            return None

        if strategy == "absolute_mutation":
            if len(results) == 0:
                self.result = chromosome
                self._stopSearchEvent.set()
                return None
        elif strategy == "simple_mutation":
            # self.result = np.random.choice(results)
            return None
        elif strategy == "population":
            self.result = results
            return None