Code Duplication - NiaOrg/NiaPy - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 34-43 lines in 4 locations

NiaPy/algorithms/modified/jde.py 1 location


        IEEE transactions on evolutionary computation, 10(6), 646-657, 2006.
    """

    def __init__(self, D, NP, nFES, F, CR, Tao, benchmark):
        r"""**__init__(self, D, NP, nFES, F, CR, Tao, benchmark)**.

        Arguments:
            D {integer} -- dimension of problem

            NP {integer} -- population size

            nFES {integer} -- number of function evaluations

            F {decimal} -- scaling factor

            CR {decimal} -- crossover rate

            Tao {decimal}

            benchmark {object} -- benchmark implementation object

        Raises:
            TypeError -- Raised when given benchmark function which does not exists.

        """

        self.benchmark = Utility().get_benchmark(benchmark)
        self.D = D  # dimension of problem
        self.Np = NP  # population size
        self.nFES = nFES  # number of function evaluations
        self.F = F  # scaling factor
        self.CR = CR  # crossover rate
        self.Tao = Tao
        self.Lower = self.benchmark.Lower  # lower bound
        self.Upper = self.benchmark.Upper  # upper bound

        SolutionjDE.FuncEval = staticmethod(self.benchmark.function())
        self.Population = []
        self.FEs = 0
        self.Done = False
        self.bestSolution = SolutionjDE(
            self.D,
            self.Lower,
            self.Upper,
            self.F,
            self.CR)

    def evalPopulation(self):
        """Evaluate population."""

NiaPy/algorithms/basic/ga.py 1 location


    **License:** MIT
    """

    def __init__(self, D, NP, nFES, Ts, Mr, gamma, benchmark):
        r"""**__init__(self, D, NP, nFES, Ts, Mr, gamma, benchmark)**.

        Arguments:
            D {integer} -- dimension of problem

            NP {integer} -- population size

            nFES {integer} -- number of function evaluations

            Ts {integer} -- tournament selection

            Mr {decimal} -- mutation rate

            gamma {decimal} -- minimum frequency

            benchmark {object} -- benchmark implementation object

        Raises:
            TypeError -- Raised when given benchmark function which does not exists.

        """
        self.benchmark = Utility().get_benchmark(benchmark)
        self.NP = NP  # population size; number of search agents
        self.D = D  # dimension of the problem
        self.Ts = Ts  # tournament selection
        self.Mr = Mr  # mutation rate
        self.gamma = gamma  # minimum frequency
        self.Lower = self.benchmark.Lower  # lower bound
        self.Upper = self.benchmark.Upper  # upper bound
        self.Population = []
        self.nFES = nFES  # number of function evaluations
        self.FEs = 0  # function evaluations
        self.Done = False
        Chromosome.FuncEval = staticmethod(self.benchmark.function())

        self.Best = Chromosome(self.D, self.Lower, self.Upper)

    def checkForBest(self, pChromosome):
        """Check best solution."""

NiaPy/algorithms/basic/abc.py 1 location



    """

    def __init__(self, D, NP, nFES, benchmark):
        """**__init__(self, D, NP, nFES, benchmark)**.

        Arguments:
            D {integer} -- dimension of problem

            NP {integer} -- population size

            nFES {integer} -- number of function evaluations

            benchmark {object} -- benchmark implementation object

        Raises:
            TypeError -- Raised when given benchmark function which does not exists.

        """

        self.benchmark = Utility().get_benchmark(benchmark)
        self.D = D  # dimension of the problem
        self.NP = NP  # population size; number of search agents
        self.FoodNumber = int(self.NP / 2)
        self.Limit = 100
        self.Trial = []  # trials
        self.Foods = []  # foods
        self.Probs = []  # probs
        self.nFES = nFES  # number of function evaluations
        self.Lower = self.benchmark.Lower  # lower bound
        self.Upper = self.benchmark.Upper  # upper bound

        self.FEs = 0
        self.Done = False

        SolutionABC.FuncEval = staticmethod(self.benchmark.function())
        self.Best = SolutionABC(self.D, self.Lower, self.Upper)

    def init(self):
        """Initialize positions."""

NiaPy/algorithms/basic/de.py 1 location


        Journal of global optimization 11.4 (1997): 341-359.
    """

    def __init__(self, D, NP, nFES, F, CR, benchmark):
        r"""**__init__(self, D, NP, nFES, F, CR, benchmark)**.

        Arguments:
            D {integer} -- dimension of problem

            NP {integer} -- population size

            nFES {integer} -- number of function evaluations

            F {decimal} -- scaling factor

            CR {decimal} -- crossover rate

            benchmark {object} -- benchmark implementation object

        Raises:
            TypeError -- Raised when given benchmark function which does not exists.

        """

        self.benchmark = Utility().get_benchmark(benchmark)
        self.D = D  # dimension of problem
        self.Np = NP  # population size
        self.nFES = nFES  # number of function evaluations
        self.F = F  # scaling factor
        self.CR = CR  # crossover rate
        self.Lower = self.benchmark.Lower  # lower bound
        self.Upper = self.benchmark.Upper  # upper bound

        SolutionDE.FuncEval = staticmethod(self.benchmark.function())
        self.FEs = 0
        self.Done = False
        self.Population = []
        self.bestSolution = SolutionDE(self.D, self.Lower, self.Upper)

    def evalPopulation(self):
        """Evaluate population."""

		@@ 51-87 (lines=37) @@
48		License: MIT
49		"""
50
51		def __init__(self, D, NP, nFES, Ts, Mr, gamma, benchmark):
52		r"""__init__(self, D, NP, nFES, Ts, Mr, gamma, benchmark).
53
54		Arguments:
55		D {integer} -- dimension of problem
56
57		NP {integer} -- population size
58
59		nFES {integer} -- number of function evaluations
60
61		Ts {integer} -- tournament selection
62
63		Mr {decimal} -- mutation rate
64
65		gamma {decimal} -- minimum frequency
66
67		benchmark {object} -- benchmark implementation object
68
69		Raises:
70		TypeError -- Raised when given benchmark function which does not exists.
71
72		"""
73		self.benchmark = Utility().get_benchmark(benchmark)
74		self.NP = NP # population size; number of search agents
75		self.D = D # dimension of the problem
76		self.Ts = Ts # tournament selection
77		self.Mr = Mr # mutation rate
78		self.gamma = gamma # minimum frequency
79		self.Lower = self.benchmark.Lower # lower bound
80		self.Upper = self.benchmark.Upper # upper bound
81		self.Population = []
82		self.nFES = nFES # number of function evaluations
83		self.FEs = 0 # function evaluations
84		self.Done = False
85		Chromosome.FuncEval = staticmethod(self.benchmark.function())
86
87		self.Best = Chromosome(self.D, self.Lower, self.Upper)
88
89		def checkForBest(self, pChromosome):
90		"""Check best solution."""

		@@ 55-88 (lines=34) @@
52
53		"""
54
55		def __init__(self, D, NP, nFES, benchmark):
56		"""__init__(self, D, NP, nFES, benchmark).
57
58		Arguments:
59		D {integer} -- dimension of problem
60
61		NP {integer} -- population size
62
63		nFES {integer} -- number of function evaluations
64
65		benchmark {object} -- benchmark implementation object
66
67		Raises:
68		TypeError -- Raised when given benchmark function which does not exists.
69
70		"""
71
72		self.benchmark = Utility().get_benchmark(benchmark)
73		self.D = D # dimension of the problem
74		self.NP = NP # population size; number of search agents
75		self.FoodNumber = int(self.NP / 2)
76		self.Limit = 100
77		self.Trial = [] # trials
78		self.Foods = [] # foods
79		self.Probs = [] # probs
80		self.nFES = nFES # number of function evaluations
81		self.Lower = self.benchmark.Lower # lower bound
82		self.Upper = self.benchmark.Upper # upper bound
83
84		self.FEs = 0
85		self.Done = False
86
87		SolutionABC.FuncEval = staticmethod(self.benchmark.function())
88		self.Best = SolutionABC(self.D, self.Lower, self.Upper)
89
90		def init(self):
91		"""Initialize positions."""

		@@ 54-88 (lines=35) @@
51		Journal of global optimization 11.4 (1997): 341-359.
52		"""
53
54		def __init__(self, D, NP, nFES, F, CR, benchmark):
55		r"""__init__(self, D, NP, nFES, F, CR, benchmark).
56
57		Arguments:
58		D {integer} -- dimension of problem
59
60		NP {integer} -- population size
61
62		nFES {integer} -- number of function evaluations
63
64		F {decimal} -- scaling factor
65
66		CR {decimal} -- crossover rate
67
68		benchmark {object} -- benchmark implementation object
69
70		Raises:
71		TypeError -- Raised when given benchmark function which does not exists.
72
73		"""
74
75		self.benchmark = Utility().get_benchmark(benchmark)
76		self.D = D # dimension of problem
77		self.Np = NP # population size
78		self.nFES = nFES # number of function evaluations
79		self.F = F # scaling factor
80		self.CR = CR # crossover rate
81		self.Lower = self.benchmark.Lower # lower bound
82		self.Upper = self.benchmark.Upper # upper bound
83
84		SolutionDE.FuncEval = staticmethod(self.benchmark.function())
85		self.FEs = 0
86		self.Done = False
87		self.Population = []
88		self.bestSolution = SolutionDE(self.D, self.Lower, self.Upper)
89
90		def evalPopulation(self):
91		"""Evaluate population."""

		@@ 60-102 (lines=43) @@
57		IEEE transactions on evolutionary computation, 10(6), 646-657, 2006.
58		"""
59
60		def __init__(self, D, NP, nFES, F, CR, Tao, benchmark):
61		r"""__init__(self, D, NP, nFES, F, CR, Tao, benchmark).
62
63		Arguments:
64		D {integer} -- dimension of problem
65
66		NP {integer} -- population size
67
68		nFES {integer} -- number of function evaluations
69
70		F {decimal} -- scaling factor
71
72		CR {decimal} -- crossover rate
73
74		Tao {decimal}
75
76		benchmark {object} -- benchmark implementation object
77
78		Raises:
79		TypeError -- Raised when given benchmark function which does not exists.
80
81		"""
82
83		self.benchmark = Utility().get_benchmark(benchmark)
84		self.D = D # dimension of problem
85		self.Np = NP # population size
86		self.nFES = nFES # number of function evaluations
87		self.F = F # scaling factor
88		self.CR = CR # crossover rate
89		self.Tao = Tao
90		self.Lower = self.benchmark.Lower # lower bound
91		self.Upper = self.benchmark.Upper # upper bound
92
93		SolutionjDE.FuncEval = staticmethod(self.benchmark.function())
94		self.Population = []
95		self.FEs = 0
96		self.Done = False
97		self.bestSolution = SolutionjDE(
98		self.D,
99		self.Lower,
100		self.Upper,
101		self.F,
102		self.CR)
103
104		def evalPopulation(self):
105		"""Evaluate population."""

NiaOrg / NiaPy

Code Duplication Length = 34-43 lines in 4 locations

NiaPy/algorithms/modified/jde.py 1 location

NiaPy/algorithms/basic/ga.py 1 location

NiaPy/algorithms/basic/abc.py 1 location

NiaPy/algorithms/basic/de.py 1 location