NiaPy.util.utility.Task.__init__() - Code Metrics - Inspection of "Upgrade runner" - NiaOrg/NiaPy - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#206)

by Grega

created 2019-04-24 11:08 UTC

NiaPy.util.utility.Task.init() C

↳ Parent: NiaPy.util.utility

Complexity

Conditions

Size

Total Lines	35
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	14
nop	8
dl	0
loc	35
rs	5.9999
c	0
b	0
f	0

How to fix Complexity Many Parameters

# encoding=utf8

"""Implementation of benchmarks utility function."""

import logging

from numpy import (
    ndarray,
    asarray,
    full,
    empty,
    where,
    random as rand,
    ceil,
    amin,
    amax
)
from NiaPy.benchmarks import (
    Benchmark,
    Rastrigin,
    Rosenbrock,
    Griewank,
    Sphere,
    Ackley,
    Schwefel,
    Schwefel221,
    Schwefel222,
    Whitley,
    Alpine1,
    Alpine2,
    HappyCat,
    Ridge,
    ChungReynolds,
    Csendes,
    Pinter,
    Qing,
    Quintic,
    Salomon,
    SchumerSteiglitz,
    Step,
    Step2,
    Step3,
    Stepint,
    SumSquares,
    StyblinskiTang,
    BentCigar,
    Discus,
    Elliptic,
    ExpandedGriewankPlusRosenbrock,
    HGBat,
    Katsuura,
    ExpandedSchaffer,
    ModifiedSchwefel,
    Weierstrass,
    Michalewichz,
    Levy,
    Sphere2,
    Sphere3,
    Trid,
    Perm,
    Zakharov,
    DixonPrice,
    Powell,
    CosineMixture,
    Infinity,
    SchafferN2,
    SchafferN4
)

logging.basicConfig()
logger = logging.getLogger("NiaPy.util.utility")
logger.setLevel("INFO")

__all__ = [
    "limit_repair",
    "limitInversRepair",
    "objects2array",
    "wangRepair",
    "randRepair",
    "fullArray",
    "reflectRepair"
]


class Utility:
    r"""Base class with string mappings to benchmarks and algorithms.

    Attributes:
        classes (Dict[str, Benchmark]): Mapping from stings to benchmark.

    """

    def __init__(self):
        r"""Initializing the algorithm and benchmark objects."""

        self.benchmark_classes = {
            "ackley": Ackley,
            "alpine1": Alpine1,
            "alpine2": Alpine2,
            "bentcigar": BentCigar,
            "chungReynolds": ChungReynolds,
            "cosinemixture": CosineMixture,
            "csendes": Csendes,
            "discus": Discus,
            "dixonprice": DixonPrice,
            "conditionedellptic": Elliptic,
            "elliptic": Elliptic,
            "expandedgriewankplusrosenbrock": ExpandedGriewankPlusRosenbrock,
            "expandedschaffer": ExpandedSchaffer,
            "griewank": Griewank,
            "happyCat": HappyCat,
            "hgbat": HGBat,
            "infinity": Infinity,
            "katsuura": Katsuura,
            "levy": Levy,
            "michalewicz": Michalewichz,
            "modifiedscwefel": ModifiedSchwefel,
            "perm": Perm,
            "pinter": Pinter,
            "powell": Powell,
            "qing": Qing,
            "quintic": Quintic,
            "rastrigin": Rastrigin,
            "ridge": Ridge,
            "rosenbrock": Rosenbrock,
            "salomon": Salomon,
            "schaffer2": SchafferN2,
            "schaffer4": SchafferN4,
            "schumerSteiglitz": SchumerSteiglitz,
            "schwefel": Schwefel,
            "schwefel221": Schwefel221,
            "schwefel222": Schwefel222,
            "sphere": Sphere,
            "sphere2": Sphere2,
            "sphere3": Sphere3,
            "step": Step,
            "step2": Step2,
            "step3": Step3,
            "stepint": Stepint,
            "styblinskiTang": StyblinskiTang,
            "sumSquares": SumSquares,
            "trid": Trid,
            "weierstrass": Weierstrass,
            "whitley": Whitley,
            "zakharov": Zakharov
        }

        self.algorithm_classes = {}

    def get_benchmark(self, benchmark):
        r"""Get the optimization problem.

        Arguments:
            benchmark (Union[str, Benchmark]): String or class that represents the optimization problem.

        Returns:
            Benchmark: Optimization function with limits.

        """

        if issubclass(type(benchmark), Benchmark):
            return benchmark
        elif benchmark in self.benchmark_classes.keys():
            return self.benchmark_classes[benchmark]()
        else:
            raise TypeError("Passed benchmark is not defined!")

    @classmethod
    def __raiseLowerAndUpperNotDefined(cls):
        r"""Trow exception if lower and upper bounds are not defined in benchmark.

        Raises:
            TypeError: Type error.
        """
        raise TypeError("Upper and Lower value must be defined!")


def limit_repair(x, Lower, Upper, **kwargs):
    r"""Repair solution and put the solution in the random position inside of the bounds of problem.

    Arguments:
            x (numpy.ndarray): Solution to check and repair if needed.
            Lower (numpy.ndarray): Lower bounds of search space.
            Upper (numpy.ndarray): Upper bounds of search space.
            kwargs (Dict[str, Any]): Additional arguments.

    Returns:
            numpy.ndarray: Solution in search space.
    """
    ir = where(x < Lower)
    x[ir] = Lower[ir]
    ir = where(x > Upper)
    x[ir] = Upper[ir]
    return x


def limitInversRepair(x, Lower, Upper, **kwargs):
    r"""Repair solution and put the solution in the random position inside of the bounds of problem.

    Arguments:
            x (numpy.ndarray): Solution to check and repair if needed.
            Lower (numpy.ndarray): Lower bounds of search space.
            Upper (numpy.ndarray): Upper bounds of search space.
            kwargs (Dict[str, Any]): Additional arguments.

    Returns:
            numpy.ndarray: Solution in search space.
    """
    ir = where(x < Lower)
    x[ir] = Upper[ir]
    ir = where(x > Upper)
    x[ir] = Lower[ir]
    return x


def wangRepair(x, Lower, Upper, **kwargs):
    r"""Repair solution and put the solution in the random position inside of the bounds of problem.

    Arguments:
            x (numpy.ndarray): Solution to check and repair if needed.
            Lower (numpy.ndarray): Lower bounds of search space.
            Upper (numpy.ndarray): Upper bounds of search space.
            kwargs (Dict[str, Any]): Additional arguments.

    Returns:
            numpy.ndarray: Solution in search space.
    """
    ir = where(x < Lower)
    x[ir] = amin([Upper[ir], 2 * Lower[ir] - x[ir]], axis=0)
    ir = where(x > Upper)
    x[ir] = amax([Lower[ir], 2 * Upper[ir] - x[ir]], axis=0)
    return x


def randRepair(x, Lower, Upper, rnd=rand, **kwargs):
    r"""Repair solution and put the solution in the random position inside of the bounds of problem.

    Arguments:
            x (numpy.ndarray): Solution to check and repair if needed.
            Lower (numpy.ndarray): Lower bounds of search space.
            Upper (numpy.ndarray): Upper bounds of search space.
            rnd (mtrand.RandomState): Random generator.
            kwargs (Dict[str, Any]): Additional arguments.

    Returns:
            numpy.ndarray: Fixed solution.
    """
    ir = where(x < Lower)
    x[ir] = rnd.uniform(Lower[ir], Upper[ir])
    ir = where(x > Upper)
    x[ir] = rnd.uniform(Lower[ir], Upper[ir])
    return x


def reflectRepair(x, Lower, Upper, **kwargs):
    r"""Repair solution and put the solution in search space with reflection of how much the solution violates a bound.

    Args:
            x (numpy.ndarray): Solution to be fixed.
            Lower (numpy.ndarray): Lower bounds of search space.
            Upper (numpy.ndarray): Upper bounds of search space.
            kwargs (Dict[str, Any]): Additional arguments.

    Returns:
            numpy.ndarray: Fix solution.
    """
    ir = where(x > Upper)
    x[ir] = Lower[ir] + x[ir] % (Upper[ir] - Lower[ir])
    ir = where(x < Lower)
    x[ir] = Lower[ir] + x[ir] % (Upper[ir] - Lower[ir])
    return x


def fullArray(a, D):
    r"""Fill or create array of length D, from value or value form a.

    Arguments:
        a (Union[int, float, numpy.ndarray], Iterable[Any]): Input values for fill.
        D (int): Length of new array.

    Returns:
        numpy.ndarray: Array filled with passed values or value.

    """

    A = []

    if isinstance(a, (int, float)):
        A = full(D, a)
    elif isinstance(a, (ndarray, list, tuple)):
        if len(a) == D:
            A = a if isinstance(a, ndarray) else asarray(a)
        elif len(a) > D:
            A = a[:D] if isinstance(a, ndarray) else asarray(a[:D])
        else:
            for i in range(int(ceil(float(D) / len(a)))):
                A.extend(a[:D if (D - i * len(a)) >= len(a) else D - i * len(a)])
            A = asarray(A)
    return A


def objects2array(objs):
    r"""Convert `Iterable` array or list to `NumPy` array.

    Args:
        objs (Iterable[Any]): Array or list to convert.

    Returns:
        numpy.ndarray: Array of objects.

    """

    a = empty(len(objs), dtype=object)
    for i, e in enumerate(objs):
        a[i] = e
    return a


1			# encoding=utf8
2
3			"""Implementation of benchmarks utility function."""
4
5			import logging
6
7			from numpy import (
8			ndarray,
9			asarray,
10			full,
11			empty,
12			where,
13			random as rand,
14			ceil,
15			amin,
16			amax
17			)
18			from NiaPy.benchmarks import (
19			Benchmark,
20			Rastrigin,
21			Rosenbrock,
22			Griewank,
23			Sphere,
24			Ackley,
25			Schwefel,
26			Schwefel221,
27			Schwefel222,
28			Whitley,
29			Alpine1,
30			Alpine2,
31			HappyCat,
32			Ridge,
33			ChungReynolds,
34			Csendes,
35			Pinter,
36			Qing,
37			Quintic,
38			Salomon,
39			SchumerSteiglitz,
40			Step,
41			Step2,
42			Step3,
43			Stepint,
44			SumSquares,
45			StyblinskiTang,
46			BentCigar,
47			Discus,
48			Elliptic,
49			ExpandedGriewankPlusRosenbrock,
50			HGBat,
51			Katsuura,
52			ExpandedSchaffer,
53			ModifiedSchwefel,
54			Weierstrass,
55			Michalewichz,
56			Levy,
57			Sphere2,
58			Sphere3,
59			Trid,
60			Perm,
61			Zakharov,
62			DixonPrice,
63			Powell,
64			CosineMixture,
65			Infinity,
66			SchafferN2,
67			SchafferN4
68			)
69
70			logging.basicConfig()
71			logger = logging.getLogger("NiaPy.util.utility")
72			logger.setLevel("INFO")
73
74			__all__ = [
75			"limit_repair",
76			"limitInversRepair",
77			"objects2array",
78			"wangRepair",
79			"randRepair",
80			"fullArray",
81			"reflectRepair"
82			]
83
84
85			class Utility:
86			r"""Base class with string mappings to benchmarks and algorithms.
87
88			Attributes:
89			classes (Dict[str, Benchmark]): Mapping from stings to benchmark.
90
91			"""
92
93			def __init__(self):
94			r"""Initializing the algorithm and benchmark objects."""
95
96			self.benchmark_classes = {
97			"ackley": Ackley,
98			"alpine1": Alpine1,
99			"alpine2": Alpine2,
100			"bentcigar": BentCigar,
101			"chungReynolds": ChungReynolds,
102			"cosinemixture": CosineMixture,
103			"csendes": Csendes,
104			"discus": Discus,
105			"dixonprice": DixonPrice,
106			"conditionedellptic": Elliptic,
107			"elliptic": Elliptic,
108			"expandedgriewankplusrosenbrock": ExpandedGriewankPlusRosenbrock,
109			"expandedschaffer": ExpandedSchaffer,
110			"griewank": Griewank,
111			"happyCat": HappyCat,
112			"hgbat": HGBat,
113			"infinity": Infinity,
114			"katsuura": Katsuura,
115			"levy": Levy,
116			"michalewicz": Michalewichz,
117			"modifiedscwefel": ModifiedSchwefel,
118			"perm": Perm,
119			"pinter": Pinter,
120			"powell": Powell,
121			"qing": Qing,
122			"quintic": Quintic,
123			"rastrigin": Rastrigin,
124			"ridge": Ridge,
125			"rosenbrock": Rosenbrock,
126			"salomon": Salomon,
127			"schaffer2": SchafferN2,
128			"schaffer4": SchafferN4,
129			"schumerSteiglitz": SchumerSteiglitz,
130			"schwefel": Schwefel,
131			"schwefel221": Schwefel221,
132			"schwefel222": Schwefel222,
133			"sphere": Sphere,
134			"sphere2": Sphere2,
135			"sphere3": Sphere3,
136			"step": Step,
137			"step2": Step2,
138			"step3": Step3,
139			"stepint": Stepint,
140			"styblinskiTang": StyblinskiTang,
141			"sumSquares": SumSquares,
142			"trid": Trid,
143			"weierstrass": Weierstrass,
144			"whitley": Whitley,
145			"zakharov": Zakharov
146			}
147
148			self.algorithm_classes = {}
149
150			def get_benchmark(self, benchmark):
151			r"""Get the optimization problem.
152
153			Arguments:
154			benchmark (Union[str, Benchmark]): String or class that represents the optimization problem.
155
156			Returns:
157			Benchmark: Optimization function with limits.
158
159			"""
160
161			if issubclass(type(benchmark), Benchmark):
162			return benchmark
163			elif benchmark in self.benchmark_classes.keys():
164			return self.benchmark_classes[benchmark]()
165			else:
166			raise TypeError("Passed benchmark is not defined!")
167
168			@classmethod
169			def __raiseLowerAndUpperNotDefined(cls):
170			r"""Trow exception if lower and upper bounds are not defined in benchmark.
171
172			Raises:
173			TypeError: Type error.
174			"""
175			raise TypeError("Upper and Lower value must be defined!")
176
177
178			def limit_repair(x, Lower, Upper, **kwargs):
179			r"""Repair solution and put the solution in the random position inside of the bounds of problem.
180
181			Arguments:
182			x (numpy.ndarray): Solution to check and repair if needed.
183			Lower (numpy.ndarray): Lower bounds of search space.
184			Upper (numpy.ndarray): Upper bounds of search space.
185			kwargs (Dict[str, Any]): Additional arguments.
186
187			Returns:
188			numpy.ndarray: Solution in search space.
189			"""
190			ir = where(x < Lower)
191			x[ir] = Lower[ir]
192			ir = where(x > Upper)
193			x[ir] = Upper[ir]
194			return x
195
196
197			def limitInversRepair(x, Lower, Upper, **kwargs):
198			r"""Repair solution and put the solution in the random position inside of the bounds of problem.
199
200			Arguments:
201			x (numpy.ndarray): Solution to check and repair if needed.
202			Lower (numpy.ndarray): Lower bounds of search space.
203			Upper (numpy.ndarray): Upper bounds of search space.
204			kwargs (Dict[str, Any]): Additional arguments.
205
206			Returns:
207			numpy.ndarray: Solution in search space.
208			"""
209			ir = where(x < Lower)
210			x[ir] = Upper[ir]
211			ir = where(x > Upper)
212			x[ir] = Lower[ir]
213			return x
214
215
216			def wangRepair(x, Lower, Upper, **kwargs):
217			r"""Repair solution and put the solution in the random position inside of the bounds of problem.
218
219			Arguments:
220			x (numpy.ndarray): Solution to check and repair if needed.
221			Lower (numpy.ndarray): Lower bounds of search space.
222			Upper (numpy.ndarray): Upper bounds of search space.
223			kwargs (Dict[str, Any]): Additional arguments.
224
225			Returns:
226			numpy.ndarray: Solution in search space.
227			"""
228			ir = where(x < Lower)
229			x[ir] = amin([Upper[ir], 2 * Lower[ir] - x[ir]], axis=0)
230			ir = where(x > Upper)
231			x[ir] = amax([Lower[ir], 2 * Upper[ir] - x[ir]], axis=0)
232			return x
233
234
235			def randRepair(x, Lower, Upper, rnd=rand, **kwargs):
236			r"""Repair solution and put the solution in the random position inside of the bounds of problem.
237
238			Arguments:
239			x (numpy.ndarray): Solution to check and repair if needed.
240			Lower (numpy.ndarray): Lower bounds of search space.
241			Upper (numpy.ndarray): Upper bounds of search space.
242			rnd (mtrand.RandomState): Random generator.
243			kwargs (Dict[str, Any]): Additional arguments.
244
245			Returns:
246			numpy.ndarray: Fixed solution.
247			"""
248			ir = where(x < Lower)
249			x[ir] = rnd.uniform(Lower[ir], Upper[ir])
250			ir = where(x > Upper)
251			x[ir] = rnd.uniform(Lower[ir], Upper[ir])
252			return x
253
254
255			def reflectRepair(x, Lower, Upper, **kwargs):
256			r"""Repair solution and put the solution in search space with reflection of how much the solution violates a bound.
257
258			Args:
259			x (numpy.ndarray): Solution to be fixed.
260			Lower (numpy.ndarray): Lower bounds of search space.
261			Upper (numpy.ndarray): Upper bounds of search space.
262			kwargs (Dict[str, Any]): Additional arguments.
263
264			Returns:
265			numpy.ndarray: Fix solution.
266			"""
267			ir = where(x > Upper)
268			x[ir] = Lower[ir] + x[ir] % (Upper[ir] - Lower[ir])
269			ir = where(x < Lower)
270			x[ir] = Lower[ir] + x[ir] % (Upper[ir] - Lower[ir])
271			return x
272
273
274			def fullArray(a, D):
275			r"""Fill or create array of length D, from value or value form a.
276
277			Arguments:
278			a (Union[int, float, numpy.ndarray], Iterable[Any]): Input values for fill.
279			D (int): Length of new array.
280
281			Returns:
282			numpy.ndarray: Array filled with passed values or value.
283
284			"""
285
286			A = []
287
288			if isinstance(a, (int, float)):
289			A = full(D, a)
290			elif isinstance(a, (ndarray, list, tuple)):
291			if len(a) == D:
292			A = a if isinstance(a, ndarray) else asarray(a)
293			elif len(a) > D:
294			A = a[:D] if isinstance(a, ndarray) else asarray(a[:D])
295			else:
296			for i in range(int(ceil(float(D) / len(a)))):
297			A.extend(a[:D if (D - i * len(a)) >= len(a) else D - i * len(a)])
298			A = asarray(A)
299			return A
300
301
302			def objects2array(objs):
303			r"""Convert `Iterable` array or list to `NumPy` array.
304
305			Args:
306			objs (Iterable[Any]): Array or list to convert.
307
308			Returns:
309			numpy.ndarray: Array of objects.
310
311			"""
312
313			a = empty(len(objs), dtype=object)
314			for i, e in enumerate(objs):
315			a[i] = e
316			return a
317

NiaOrg / NiaPy

Pull Request — master (#206)

NiaPy.util.utility.Task.__init__() C

Complexity

Size

Duplication

Importance

How to fix Complexity Many Parameters

Complexity

Many Parameters

Duplication Side-by-Side

Filter issues like

NiaPy.util.utility.Task.init() C