J-jtdZddlmZmZmZddlZddlmZddlZ ddl Z ddl m Z ddl mZddlmZmZdd lmZdd lmZdd lmZ[[[eZGd d eZGddeeZGddeZGddeZGddeZ GddeZ!GddeZ"GddeZ#GddeZ$GddeZ%Gd d!eZ&Gd"d#eZ'Gd$d%eZ(Gd&d'eZ)y)(zBWrapper for objective functions like noise, rotation, gluing args )absolute_importdivisionprint_functionN)partial)utils)Mh)ConstRandnShiftRotation)BoundTransform) EvalParallel2)rangec:eZdZdZdgZedZddZdZdZ y) Functionaa declarative base class, indicating that a derived class instance "is" a (fitness/objective) function. A `callable` passed to `__init__` is called as the fitness `Function`, otherwise the `_eval` method is called, if defined in the derived class, when the `Function` instance is called. If the input argument is a matrix or a list of vectors, the method is called for each vector individually like ``_eval(numpy.asarray(vector)) for vector in matrix``. >>> import cma >>> from cma.fitness_transformations import Function >>> f = Function(cma.ff.rosen) >>> assert f.evaluations == 0 >>> assert f([2, 3]) == cma.ff.rosen([2, 3]) >>> assert f.evaluations == 1 >>> assert f([[1], [2]]) == [cma.ff.rosen([1]), cma.ff.rosen([2])] >>> assert f.evaluations == 3 >>> class Fsphere(Function): ... def _eval(self, x): ... return sum(x**2) >>> fsphere = Fsphere() >>> assert fsphere.evaluations == 0 >>> assert fsphere([2, 3]) == 4 + 9 and fsphere([[2], [3]]) == [4, 9] >>> assert fsphere.evaluations == 3 >>> Fsphere.__init__ = lambda self: None # overwrites Function.__init__ >>> assert Fsphere()([2]) == 4 # which is perfectly fine to do Details: - When called, a class instance calls either the function passed to `__init__` or, if none was given, tries to call any of the `function_names_to_evaluate_first_found`, first come first serve. By default, ``function_names_to_evaluate_first_found == ["_eval"]``. - This class cannot move to module `fitness_functions`, because the latter uses `fitness_transformations.rotate`. _evalc"tjS)zattributes which are searched for to be called if no function was given to `__init__`. The first present match is used. )r'_function_names_to_evaluate_first_found)selfs i/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/fitness_transformations.py&function_names_to_evaluate_first_foundz/Function.function_names_to_evaluate_first_found;s???Nc0tj||y)zcallows to define the fitness_function to be called, doesn't need to be ever called N)r initializerfitness_functions r__init__zFunction.__init__Ds D"23rch||_d|_tj |_d|_d|_y)z%initialization of `Function` rTN)_Function__callable evaluationsnpinfftarget target_hit_at_Function__initializedrs rrzFunction.initializeIs0+w !rc 0 |jst |j}||j D]} t ||}n|tj|d\}}|xjt|z c_ |Dcgc]$}|tj|g|ddi|&}}|jsttj||jkr[|jt|z dzt!tj||jkj#dz|_ ||S|xjdz c_ y#t$rtj|dYjwxYw#t$rY`wxYwcc}w)NrrT)r$AttributeErrorrrrrgetattrras_vector_listrlenr asarrayr#anyr"listindex) rargskwargs callable_nameX list_revertxFs r__call__zFunction.__call__Rss ,%%$$& OO  CC 'd 3ID  "11$q':NA{   A & HIJ12::a=>48>v>AJ%%#bjjmt||.K*L%)%5%5A%>%BT"**UV-[_[g[gJgEhEnEnosEt%t"q> !    ! ) ,   d + ,& Ks(E F)FF?F FFN) __name__ __module__ __qualname____doc__rpropertyrrrr6rrrrs5&N07i+ @@4 ""rrc$eZdZdZddZdZdZy)ComposedFunctionacompose an arbitrary number of functions. A class instance is a list of functions. Calling the instance executes the composition of these functions (evaluating from right to left as in math notation). Functions can be added to or removed from the list at any time with the obvious effect. To remain consistent (if needed), the ``list_of_inverses`` attribute must be updated respectively. >>> import numpy as np >>> from cma.fitness_transformations import ComposedFunction >>> f1, f2, f3, f4 = lambda x: 2*x, lambda x: x**2, lambda x: 3*x, lambda x: x**3 >>> f = ComposedFunction([f1, f2, f3, f4]) >>> assert isinstance(f, list) and isinstance(f, ComposedFunction) >>> assert f[0] == f1 # how I love Python indexing >>> assert all(f(x) == f1(f2(f3(f4(x)))) for x in np.random.rand(10)) >>> assert f4 == f.pop() >>> assert len(f) == 3 >>> f.insert(1, f4) >>> f.append(f4) >>> assert all(f(x) == f1(f4(f2(f3(f4(x))))) for x in range(5)) A more specific example: >>> from cma.fitness_transformations import ComposedFunction >>> from cma.boundary_handler import BoundTransform >>> from cma import ff >>> f = ComposedFunction([ff.elli, ... BoundTransform([[0], [1]]).transform]) >>> assert max(f([2, 3]), f([1, 1])) <= ff.elli([1, 1]) Details: - This class can serve as basis for a more transparent alternative to a ``scaling_of_variables`` CMA option or for any necessary transformation of the fitness/objective function (genotype-phenotype transformation). - The parallelizing call with a list of solutions of the `Function` class is not inherited. The inheritence from `Function` is rather declarative than funtional and could be omitted. Nchtj||tj|||_y)zCaveat: to remain consistent, the ``list_of_inverses`` must be updated explicitly, if the list of function was updated after initialization. N)r,rrlist_of_inverses)rlist_of_functionsrAs rrzComposedFunction.__init__s) d-.$ 0rctj||g|i|tdt| dz dD]}|||g|i|}|S)Nr)rr6rr)rr4r.r/is rr6zComposedFunction.__call__sX$3D3F3rCI:>2.AQ+D+F+A/rc|jtjdytt |jD]}|j||g|i|}|S)zhevaluate the composition of inverses on ``x``. Return `None`, if no list was provided. Nzinverses were not given)rAr print_warningrr)rEs rinversezComposedFunction.inversesb  (    9 : s40012A(%%a(>> import functools >>> import numpy as np >>> import cma >>> def elli48(x): ... return 1e-4 * functools.partial(cma.ff.elli, cond=1e8)(x) >>> fcigtab = cma.fitness_transformations.StackFunction( ... elli48, cma.ff.sphere, 2) >>> x = [1, 2, 3, 4] >>> assert np.isclose(fcigtab(x), cma.ff.cigtab(np.asarray(x))) c.||_||_||_yr7)f1f2n1)rrMrNrOs rrzStackFunction.__init__src6|jdk(r|j|g|i|St||jk(r|j|g|i|S|j|d|jg|i||j||jdg|i|zS)Nr)rOrNr)rM)rr4r.r/s rrzStackFunction._evals 77a<4771.t.v. . q6TWW 4771.t.v. .twwq$''{4T4V4wtwwq{7\T7\U[7\\\rN)r8r9r:r;rrr=rrrKrKs ]rrKceZdZdZdZdZy) GlueArgumentsa&deprecated, use `functools.partial` or `cma.fitness_transformations.partial` instead, which has the same functionality and interface. from a `callable` return a `callable` with arguments attached. An ellipsoid function with condition number ``1e4`` is created by ``felli1e4 = cma.s.ft.GlueArguments(cma.ff.elli, cond=1e4)``. >>> import cma >>> f = cma.fitness_transformations.GlueArguments(cma.ff.elli, ... cond=1e1) >>> assert f([1, 2]) == 1**2 + 1e1 * 2**2 ctjdttj ||||_||_||_y)zdefine function, ``args``, and ``kwargs``. ``args`` are appended to arguments passed in the call, ``kwargs`` are updated with keyword arguments passed in the call. zeGlueArguments is deprecated. Use `functools.partial` (`cma.fitness_transformations.partial`) instead.N)warningswarnDeprecationWarningrrrr.r/)rrr.r/s rrzGlueArguments.__init__sB  a( * $ 01 0  rct|j}|j|tj|}t j ||g||jzi|S)zbcall function with at least one additional argument and attached args and kwargs. )dictr/updater r*rr6r.)rr4r.r/ joined_kwargss rr6zGlueArguments.__call__s\T[[) V$ JJqM  q2D499,<2#02 2rNr8r9r:r;rr6r=rrrRrRs 2rrRceZdZdZdZy)FBoundTransforma^shortcut for ``ComposedFunction([f, BoundTransform(bounds).transform])``, see also below. Maps the argument into bounded or half-bounded (feasible) domain before evaluating ``f``. Example with lower bound at 0, which becomes the image of -0.05 in `BoundTransform.transform`: >>> import cma, numpy as np >>> f = cma.fitness_transformations.FBoundTransform(cma.ff.elli, ... [[0], None]) >>> assert all(f[1](np.random.randn(200)) >= 0) >>> assert all(f[1]([-0.05, -0.05]) == 0) >>> assert f([-0.05, -0.05]) == 0 A slightly more verbose version to implement the lower bound at zero in the very same way: >>> import cma >>> felli_in_bound = cma.s.ft.ComposedFunction( ... [cma.ff.elli, cma.BoundTransform([[0], None]).transform]) c|t||_tj|||jjgy)zC`bounds[0]` are lower bounds, `bounds[1]` are upper bounds N)r bound_tfr?r transform)rrboundss rrzFBoundTransform.__init__ s3'v. !!$%t}}'>'>? ArNr8r9r:r;rr=rrr]r]s 0Arr]ceZdZdZddZy)Rotatedareturn a rotated version of a function for testing purpose. This class is a convenience shortcut for the litte more verbose composition of a function with a rotation: >>> import cma >>> from cma import fitness_transformations as ft >>> f1 = ft.Rotated(cma.ff.elli) >>> f2 = ft.ComposedFunction([cma.ff.elli, ft.Rotation()]) >>> assert f1([2]) == f2([2]) # same rotation only in 1-D >>> assert f1([1, 2]) != f2([1, 2]) NcP| t|}tj|||gy)zZoptional argument ``rotate(x)`` must return a (stable) rotation of ``x``. N)seed)r r?r)rfrotaterfs rrzRotated.__init__"s' >4(F!!$F 4r)NNrbr=rrrdrds  5rrdceZdZdZddZy)Shiftedakcompose a function with a shift in x-space. >>> import cma >>> f = cma.s.ft.Shifted(cma.ff.elli) Details: this class solely provides as default second argument to `ComposedFunction`, namely a random shift in search space. ``shift=lambda x: x`` would provide "no shift", ``None`` expands to ``cma.transformations.ConstRandnShift()``. NcL| t}tj|||gy)z.``shift(x)`` must return a (stable) shift of xN)r r?r)rrgshifts rrzShifted.__init__5s# =#%E!!$E 3rr7rbr=rrrjrj*s  4rrjc(eZdZdZ ddZdZdZy)ScaleCoordinatesa compose a (fitness) function with a preceding scaling and offset. Scaling interface ----------------- After ``fun2 = cma.ScaleCoordinates(fun, multipliers, zero)``, we have ``fun2(x) == fun(multipliers * (x - zero))``, where the vector size of `multipliers` and `zero` is adapated to the size of `x`, in case by recycling their last entry. This awkwardly asks to pass the `zero` argument of the preimage space where it has little meaning. Hence more conveniently, ``fun2 = cma.ScaleCoordinates(fun, multipliers, lower=lower)`` gets ``fun2(x) == fun(multipliers * x + lower)``. Domain interface (lower and upper variable values) -------------------------------------------------- Let ``u`` and ``l`` be vectors (or a scalar) of (approximate) lower and upper variable values, respectively. After ``fun2 = cma.ScaleCoordinates(fun, upper=u, lower=l)`` we have ``fun2(x) == fun(l + (u - l) * x)``. Now, passing 0 as ``x[i]`` to ``fun2`` evaluates ``fun`` at ``l[i]`` while passing 1 evaluates ``fun`` at ``u[i]``. To match the size of ``x``, the sizes of ``u`` and ``l`` are shortened or their last entry is recycled if necessary. The default value for `lower` is zero in which case `upper` just becomes a scaling multiplier. Bounding the search domain of ``fun2`` to ``[0, 1]`` now bounds ``fun`` to the domain ``[l, u]``. The ``'bounds'`` option of `CMAOptions` allows to set these bounds. More general, the affine transformation is defined such that ``x[i]==from_lower_upper[0]`` evaluates ``fun`` at ``l[i]`` and ``x[i]==from_lower_upper[1]`` evaluates ``fun`` at ``u[i]`` where ``from_lower_upper == [0, 1]`` by default. Examples and Doctest -------------------- >>> import numpy as np >>> import cma >>> fun = cma.ScaleCoordinates(cma.ff.sphere, upper=[30, 1]) >>> bool(fun([1, 1]) == 30**2 + 1**2) True >>> fun.transform([1, 1]).tolist(), fun.transform([0.2, 0.2]).tolist() ([30.0, 1.0], [6.0, 0.2]) >>> fun.inverse(fun.transform([0.1, 0.3])).tolist() [0.1, 0.3] >>> fun = cma.ScaleCoordinates(cma.ff.sphere, upper=[31, 3], lower=[1, 2]) >>> bool(-1e-9 < fun([1, -1]) - (31**2 + 1**2) < 1e-9) True >>> f = cma.ScaleCoordinates(cma.ff.sphere, [100, 1]) >>> assert f[0] == cma.ff.sphere # first element of f-composition >>> assert f(range(1, 6)) == 100**2 + sum([x**2 for x in range(2, 6)]) >>> assert f([2.1]) == 210**2 == f(2.1) >>> assert f(20 * [1]) == 100**2 + 19 >>> assert np.all(f.inverse(f.scale_and_offset([1, 2, 3, 4])) == ... np.asarray([1, 2, 3, 4])) >>> f = cma.ScaleCoordinates(f, [-2, 7], [2, 3, 4]) # last is recycled >>> bool(f([5, 6]) == sum(x**2 for x in [100 * -2 * (5 - 2), 7 * (6 - 3)])) True See also these [Practical Hints](https://cma-es.github.io/cmaes_sourcecode_page.html#practical) for encoding variables. Nc <tj|||jg|j|_||_||_||_||_||_d}|| td|dvr%tjdj||tj|jt|_|l|i||j|j \|_|_tj|j  |jz |_n || | td|d|_|d |_|'tj|j d z|_tj tj|jt|j z d kd }t#|r9td j|j|j t%|||j |j\|_|_|jd |jd z } tj|jt|j z | z |_|jd |jd z|j zz |_|jd |jd z|jzz } t'j(|j | s/tjd j| |j |ptj|t|_|%tjdj|||&tjdj||yyy)a= :param fitness_function: a `callable` object :param multipliers: coordinate-wise multipliers. :param zero: defines a new zero in preimage space, that is, calling the `ScaleCoordinates` instance returns ``fitness_function(multipliers * (x - zero))``. :param upper: variable value to which from_lower_upper[1] maps. :param lower: variable value to which from_lower_upper[0] maps. Only either `multipliers` or 'upper` can be passed. If `zero` is passed then `upper` and `lower` are ignored. The arguments ``multipliers``, ``zero``, ``upper`` and ``lower`` can be vectors or scalars, superfluous trailing elements are ignored and the last element is recycled if needed to fit the length of the later given input. `from_lower_upper` is `(0, 1)` by default and defines the preimage values which are mapped to `lower` and `upper`, respectively (unless `multipliers` or `zero` are given). These two preimage values are always the same for all coordinates. Details ------- The `upper` and `lower` and `from_lower_upper` parameters are used to assign `multipliers` and `zero` such that the transformation is then always computed from the latter two only. c t|t|}}||krtj||}||fS||krtj||}||fS#Y||fSxYw)z:align shorter to longer array such that a1*a2 doesn't bailas_)r)rrecycled)a1a2l1l2s ralignz(ScaleCoordinates.__init__..alignsr 4R#b'B73Br6M"W3Br6M D r6Ms AANz5Either `multipliers` or `upper` argument must be None)Nrrz?from_lower_upper={0} ignored because multipliers={1} were given)dtypezLEither `multipliers` or `zero` or `upper` or `lower` argument must be given.ryrrzz`upper` value(s) must be stricly larger than `lower` value(s); values were: upper={0} lower={1} offending indices = {2}rDzzero computed from upper and lower differ from upper={0} from lower={1} This may be a bug or due to small numerical deviationsz/lower={0} is ignored because zero={1} was givenz/upper={0} is ignored because zero={1} was given)r?rscale_and_offsetr` multiplierzerolowerupperfrom_lower_upper ValueErrorrTrUformatr r*floatwherer)r,_Mhvequals_approximately) rr multipliersr}rr~rrxidxdxzero_from_uppers rrzScaleCoordinates.__init__~s: !!$!4#8#89 ;..%   0   "  !XYY~5 _%v&6 DF jjFDO| 1.3DOOTZZ.P+ jj44tF \} "<=='(.%} }ZZ 3a7 ((2::djj>KqPQRSTC3x "> #)&TZZc"K MM &+4::tzz%B "DJ &&q)D,A,A!,DDB!zz$**EBTZZOSUUDO--a04??B3F3SSDI"33A6"9Ltzz9YYO,,TYYH Z &votyyA C   4u5DI  O%veT24  O%veT24! rcHtjfd}|j6|j*||j||jz zS|j||jz S|j||jzS)Nc2tj|SNrqrrsvecr4s rrz,ScaleCoordinates.scale_and_offset..r>>#1- -rr r*r}r|rr4rs ` rr{z!ScaleCoordinates.scale_and_offsets JJqM . 99 T__%@$//"a!DII,&67A  YY "AdiiL A__ ($//"Q&ArcHtjfd}|j6|j*||jz ||jzS|j||jzS|j||jz S)z\inverse of coordinate-wise affine transformation ``y / multipliers + zero`` c2tj|Srrrs rrz#ScaleCoordinates.inverse..rrrrrs ` rrIzScaleCoordinates.inverses JJqM . 99 T__%@Adoo&&4995A  YY "AdiiL A__ (Adoo&&Ar)NNNNry)r8r9r:r;rr{rIr=rrrnrn;s$ADAE:@b4H  rrnc"eZdZdZdZdZdZy) FixVariablesa9Insert variables with given values, thereby reducing the dimensionality of the resulting composed function. The constructor takes ``index_value_pairs``, a `dict` or `list` of pairs, as input and returns a function with smaller preimage space than input function ``f``. Fixing variable 3 and 5 works like >>> from cma.fitness_transformations import FixVariables >>> index_value_pairs = [[2, 0.2], [4, 0.4]] >>> fun = FixVariables(cma.ff.elli, index_value_pairs) >>> fun[1](4 * [1]) == [ 1., 1., 0.2, 1., 0.4, 1.] True Or starting from a given current solution in the larger space from which we pick the fixed values: >>> from cma.fitness_transformations import FixVariables >>> current_solution = [0.1 * i for i in range(5)] >>> fixed_indices = [2, 4] >>> index_value_pairs = [[i, current_solution[i]] # fix these ... for i in fixed_indices] >>> fun = FixVariables(cma.ff.elli, index_value_pairs) >>> fun[1](4 * [1]) == [ 1., 1., 0.2, 1., 0.4, 1.] True >>> assert (current_solution == # list with same values ... fun.transform(fun.insert_variables(current_solution))) >>> assert (current_solution == # list with same values ... fun.insert_variables(fun.transform(current_solution))) Details: this might replace the ``fixed_variables`` option in `CMAOptions` in future, but hasn't been thoroughly tested yet. Supersedes `ExpandSolution`. chtj|||jgt||_y)zfreturn `f` with reduced dimensionality. ``index_value_pairs``: variables N)r?rinsert_variablesrXindex_value_pairs)rrgrs rrzFixVariables.__init__#s- !!$D,A,A(BC!%&7!8rctt|Dcgc]}||jvr||}}t|tr|St j |Scc}w)a;transform `x` such that it could be used as argument to `self`. Return a list or array, usually dismissing some elements of `x`. ``fun.transform`` is the inverse of ``fun.insert_variables == fun[1]``, that is ``np.all(x == fun.transform(fun.insert_variables(x))) is True``. )rr)r isinstancer,r r*)rr4rFress rr`zFixVariables.transform,sZ#3q6]4]D222t]4 D)s>rzz#>4sAc t|jdk(r|St|}t|jD]!}|j ||j|#t |tst j|}|S)z%return `x` with inserted fixed valuesr)r)rr,sortedinsertrr r*)rr4yrFs rrzFixVariables.insert_variables7sm t%% &! +H G../A HHQ..q1 20!T" 1 ArN)r8r9r:r;rr`rr=rrrrs$J9 ? rrceZdZdZddZdZy) ExpensifyzIAdd waiting time to each evaluation, to simulate "expensive" behaviorcJtj|||_||_y)zadd time in secondsN)rrtimecallable)rr0rs rrzExpensify.__init__Es$ ! rctj|jtj|g|i||j|i|Sr7)rsleeprr6r)rr.r/s rr6zExpensify.__call__Js@ 499$000t}}d-f--rN)rr[r=rrrrBs" .rrceZdZdZddZdZy)SomeNaNFitnessz:transform ``fitness_function`` to return sometimes ``NaN``cJtj|||_||_yr7)rrrp)rrprobability_of_nans rrzSomeNaNFitness.__init__Qs$ 0#rctj||g|tjj d|j krtj S|j|g|S)Nr)rr6r randomrandrnanr)rr4r.s rr6zSomeNaNFitness.__call__UsQ$)D) 99>>!  &66M(4((2T2 2rN)g?r[r=rrrrOsD$3rrc&eZdZdZddfdZdZy) NoisyFitnesszzNoisyFitness._ssRYY__->'>'DrcDdtjjzSrrrs rrzNoisyFitness.`ssRYY__->'>rcLtj||||_||_y)aattach relative and absolution noise to ``fitness_function``. Relative noise is by default computed using the length of the input argument to ``fitness_function``. Both noise functions take ``dimension`` as input. >>> import cma >>> from cma.fitness_transformations import NoisyFitness >>> fn = NoisyFitness(cma.ff.elli) >>> assert fn([1, 2]) != cma.ff.elli([1, 2]) >>> assert fn.evaluations == 1 N)rr rel_noise abs_noise)rrrrs rrzNoisyFitness.__init__^s# $ 01""rc tj||g|}|jr7|||jt|zz }t j |sJ|j r||j t|z }|Sr7)rr6rr)r isscalarr)rr4r.rgs rr6zNoisyFitness.__call__rso   dA - - >> T^^CF++ +A;;q> !> >> A' 'ArNr[r=rrrr\sFD>#(rrc<eZdZdZej dfdZdZdZy)IntegerMixedFunction2aucompose fitness function with some integer variables using `np.round` by default. >>> import numpy as np >>> import cma >>> f = cma.s.ft.IntegerMixedFunction2(cma.ff.elli, [0, 3, 5]) >>> assert f([-0.2, 2]) == f([0.4, 2]) != f([0.8, 2]) >>> f = cma.s.ft.IntegerMixedFunction2(cma.ff.elli, [0]) >>> assert f([-0.2, 2]) == f(np.array([0.4, 2])) != f(np.array([0.8, 2])) Related: Option ``'integer_variables'`` of `cma.CMAOptions` sets ``'minstd'`` of integer variables, see `cma.options_parameters.integer_std_lower_bound` and rounds the better solutions, see `cma.integer_centering`. Tcrtj|||jg||_||_||_y)zapply operator(x[i]) for i in integer_variable_indices before to call function(x). If `copy`, return a copy iff a value is changed. N)r?r_flatteninteger_variable_indicesoperatorcopy)rfunctionrrrs rrzIntegerMixedFunction2.__init__s3 !!$4==(AB(@%   rc||j}tj|}tj||k(s2|jrtj |d}|||j<|SNTr)rr roundallrarray)rr4values new_valuess r _flatten2zIntegerMixedFunction2._flatten2s]4001XXf% vvjF*+yyHHQT*/9Ad++ ,rcht|tjr|j|Sd}t |j D]l}|t | kr|t |k\r|S|j||}|||k7sA|s%|jrtj|d}d}|||<n|S)NFTr) rr ndarrayrrrr)rrr)rr4copiedrFms rrzIntegerMixedFunction2._flattens a $>>!$ $556ACF7{CF{  ad#Atqy$)).A!F!7rN) r8r9r:r;r rrrrr=rrrr{s$ EGHHSWrrc6eZdZdZej dfdZdZy)IntegerMixedFunctionafDEPRECATED compose fitness function with some integer variables using `np.floor` by default. >>> import cma >>> f = cma.s.ft.IntegerMixedFunction(cma.ff.elli, [0, 3, 6]) >>> assert f([0.2, 2]) == f([0.4, 2]) != f([1.2, 2]) It is advisable to set minstd of integer variables to ``1 / (2 * len(integer_variable_indices) + 1)``, in which case in an independent model at least 33% (1 integer variable) -> 39% (many integer variables) of the solutions should have an integer mutation on average. Option ``integer_variables`` of `cma.CMAOptions` implements this simple measure. Tcrtj|||jg||_||_||_y)zQapply operator(x[i]) for i in integer_variable_indices before to call function(x)N)r?rrrrcopy_arg)rrrrrs rrzIntegerMixedFunction.__init__s1!!$4==(AB(@%    rc|jrtj|d}ntj|}t |j D]:}|t | kr|t |k\r|S|j||||<<|Sr)rr rr*rrr)r)rr4rFs rrzIntegerMixedFunction._flattens} ==&A 1 A556ACF7{CF{==1&AaD 7 rN)r8r9r:r;r floorrrr=rrrrs EGHHW[! rr)*r; __future__rrrrT functoolsrnumpyr r utilitiesrutilities.mathr rtransformationsr r boundary_handlerr optimization_toolsr utilities.python3for2rrhobjectrr,r?rKrRr]rdrjrnrrrrrrr=rrrs@@ %6,-(X~ Y"vY"vDxDL]H]2&2H&2PA&A@55,44"@'@DC#CJ . . 3X 38>/,/b+r