
    J-jl                     <   d Z ddlmZmZmZ ddlZddlZddlm	Z
mZ ddlmZ ddlmZ ddlmZ d	 Z[[[d
Z	 dZ	 dZ	 dZdZ ej4                  dd        G d de      Z G d de      Z G d de      ZdZ G d de      Z  G d de      Z!dZ"	  G d de      Z#y)zlstep-size adaptation classes, currently tightly linked to CMA,
because `hsig` is computed in the base class
    )absolute_importdivisionprint_functionN)squaresqrt   )utils)Mh)warnings_and_exceptionsc                 x    t        j                  t        j                  t        j                  |                   S N)npr   sumr   )xs    b/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/sigma_adaptation.py_normr      s!    RWWRVVBIIaL122          
   Toncez!Missing ``path_for_sigma_update.*)messagec                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
CMAAdaptSigmaBasea1  step-size adaptation base class, implement `hsig` (for stalling
    distribution update) functionality via an isotropic evolution path.

    Details: `hsig` or `_update_ps` must be called before the sampling
    distribution is changed. `_update_ps` depends heavily on
    `cma.CMAEvolutionStrategy`.
    c                 .    d| _         d| _        d| _        y )NFr   )is_initialized_base_ps_updated_iterationdelta)selfargskwargss      r   __init__zCMAAdaptSigmaBase.__init__$   s    #( %'"
(r   c                 *   d}d|j                   j                  j                  dz   |z  z  |j                  |z  |j                   j                  j                  dz   |z  z   z  | _        t        j                  |j                        | _        d| _        | S )kset parameters and state variable based on dimension,
        mueff and possibly further options.

              ?r   r   T)	spweightsmueffNcsr   zerospsr   )r    esbs      r   initialize_basez!CMAAdaptSigmaBase.initialize_base)   sy     ,,q0144a255==CVCVYZCZ]^B^8^_((244.#' r   c                    | j                   s| j                  |       | j                  |j                  k(  ry	 |j                  |j                  j
                  k  r&t        j                  ddd|j                  d          |j                  j                  |j                  |j                  z
  |j                  j                  z        }||j                  j                   j"                  dz  |j$                  z  |j                  j&                  z  z  }d| j(                  z
  | j*                  z  | j(                  d	| j(                  z
  z  dz  |z  z   | _        |j                  | _        y# t        $ r Y w xY w)
zupdate the isotropic evolution path.

        Using ``es`` attributes ``mean``, ``mean_old``, ``sigma``,
        ``sigma_vec``, ``sp.weights.mueff``, ``cp.cmean`` and
        ``sm.transform_inverse``.

        :type es: CMAEvolutionStrategy
        NzSdistribution transformation (B and D) have been updated before ps could be computed
_update_psr   verbose)r3         ?r   r   )r   r0   r   	countitersmitereigenupdatedr	   print_warningoptsAttributeErrortransform_inversemeanmean_old	sigma_vecscalingr'   r(   r)   sigmacmeanr+   r-   )r    r.   zs      r   r2   zCMAAdaptSigmaBase._update_ps5   s.    ''  $%%5	||ruu555##$y*,?QZI[] EE##RWWr{{%:bll>R>R$RS 	
RUU]]  #%0255;;>>tww;$'')TWWDGG-Ds,JQ,NN%'\\"  		s   A	E+ +	E76E7c                    | j                  |       |j                  j                  d      r<|j                  j	                  |j
                        }|j                  j                  }n%| j                  y| j                  }| j                  }t        j                  |dz        dd|z
  d|j                  z  z  z
  z  }||j                  z  dz
  dd|j                  dz   z  z   k  S )zreturn "OK-signal" for rank-one update, `True` (OK) or `False`
        (stall rank-one update), based on the length of an evolution path

        CSA_invariant_pathTr   r   g      @)r2   r9   getr6   r;   pcr'   ccr-   r+   r   r   r5   r*   )r    r.   r-   r+   squared_sums        r   hsigzCMAAdaptSigmaBase.hsigO   s    
 	 77;;+,((/BBWW_BBffRUmqAFa",,6F+G'GH RTT!A%B"$$(O(;;;r   c                 P    |xj                    | j                  |fi |z  c_         y)z'change `es.sigma` in place, deprecated?Nr@   update2r    r.   r"   s      r   updatezCMAAdaptSigmaBase.updatef   s     
LDLL.v..r   c                 :    | j                  |       t        d      )a$  return sigma change factor and update self.delta.

        ``self.delta == sigma/sigma0`` accumulates all past changes
        starting from `1.0`.

        Unlike `update`, `update2` is not supposed to change attributes
        in `es`, specifically it should not change `es.sigma`.
        z&must be implemented in a derived class)r2   NotImplementedErrorrM   s      r   rL   zCMAAdaptSigmaBase.update2j   s     	!"JKKr   c                      y)zXmake consistency checks with a `CMAEvolutionStrategy` instance
        as input
        N )r    r.   s     r   check_consistencyz#CMAAdaptSigmaBase.check_consistencyv   s    r   N)__name__
__module____qualname____doc__r#   r0   r2   rI   rN   rL   rS   rR   r   r   r   r      s+    )
24<./
Lr   r   c                       e Zd ZdZd Zy)CMAAdaptSigmaNonezconstant step-size sigmac                      y)z2no update, ``es.sigma`` remains constant.
        NrR   rM   s      r   rN   zCMAAdaptSigmaNone.update|   s     	r   N)rT   rU   rV   rW   rN   rR   r   r   rY   rY   z   s
    "r   rY   c                   0     e Zd ZdZd fd	Zd Zd Z xZS )!CMAAdaptSigmaDistanceProportionala  artificial setting of ``sigma`` proportional to ||m||,

    specifically ``sigma = coefficient * mueff * norm(mean) / n / c_m``.

    The optimal `coefficient` in infinite dimension is ``1.253 = (pi/2)**0.5``,
    the optimal mueff is ``lambda / pi``, hence the optimal phi is ``pi/2 x
    lambda / pi / 2 = lambda / 4`` where exp(-phi/n) is the (log-)expected
    converence rate per iteration.

    This is mainly useful for test purposes, e.g. to simulate optimal progress
    rates.
    c                 T    t         t        |           || _        d| _        d| _        y)z4pass coefficient multiplier for normalized step-sizeTFN)superr\   r#   coefficientis_initialized_direct_mode)r    r_   r"   	__class__s      r   r#   z*CMAAdaptSigmaDistanceProportional.__init__   s,    /?A&"!Rr   c                 L    |xj                   | j                  |      z  c_         y)z2update ``es.sigma`` by calling `update2`.
        NrK   rM   s      r   rN   z(CMAAdaptSigmaDistanceProportional.update   s     	DLL$$r   c                 `   | j                   r/| j                  t        |j                        z  |j                  z  S | j                  |j
                  j                  j                  z  t        |j                        z  |j                  z  |j
                  j                  z  |j                  z  S )zreturn sigma update factor.

        Uses attributes ``.N``, ``.sp.weights.mueff``, ``.mean``, and
        ``.sp.cmean`` of input `es`.
        )
ra   r_   r   r<   r@   r'   r(   r)   r*   rA   rM   s      r   rL   z)CMAAdaptSigmaDistanceProportional.update2   s     ##eBGGn4rxx??##beemm&9&99E"''NJRTTQTVTYTYT_T__bdbjbjjjr   )g333333?)rT   rU   rV   rW   r#   rN   rL   __classcell__rb   s   @r   r\   r\      s    S%	kr   r\   c                   .    e Zd ZdZd Zd Zd Zd Zd Zy)CMAAdaptSigmaCSAzCSA cumulative step-size adaptation AKA path length control.

    As of 2017, CSA is considered as the default step-size control method
    within CMA-ES.
    c                      d| _         d| _        y)z]postpone initialization to a method call where dimension and mueff should be known.

        Fr   N)r`   r   r    r"   s     r   r#   zCMAAdaptSigmaCSA.__init__   s     $
r   c           
      `	   |j                   d   rdnd| _        |j                   d   Z	 t        |j                   d         dk(  r/t        j                   t        j                  g|j                   d<   nt        |j                   d         dk(  r1t        j                   |j                   d   d   g|j                   d<   nVt        |j                   d         dk(  r0t        j
                  |j                   d         |j                   d<   nt        d      t        t        j
                  |j                   d               |j                   d<   |j                   d   d   dkD  s|j                   d   d   dk  rt        d	      d
}d
|j                  j                  j                  dz   |z  z  |j                  |z  |j                  j                  j                  dz   |z  z   z  | _        |j                   d   }||j                   d   rdnd}t        t        }}|dk  r|n"t!        d|dd|j                  |z  z  z
  z  f      }|j                   d   dt#        d|j                  j$                  d|j                  j&                  z  z  dz
  dz  f      dz  dz  z   t(        |dt*        z
  z  z  t!        d|t*        z  |j                  j                  j                  dz
  |j                  dz   z  |z  z  t,        z
  f      z  z   | j                  z   z  | _        t0        dk7  r0|j                   d   dkD  rt3        dj5                  t0                     d| _        | j                  rddg|j                   d<   d}d
|j                  j                  j                  dz   |z  z  |j                  |z  d|j                  j                  j                  |z  z  z   z  | _        |j                   d   dz  | _        |j                   d   dkD  r;t3        d       | j8                  j;                         D ]  \  }}t3        d|d|        t        j<                  |j                        | _        d| _         d| _!        | S # t        $ r1 t        j                   |j                   d   g|j                   d<   Y w xY w)r%   CSA_disregard_lengthTFCSA_clip_length_valuer   r   r   zBoption CSA_clip_length_value should be a number of len(.) in [1,2]zZoption CSA_clip_length_value must be a single positive or a negative and a positive numberr&   r   CSA_damp_mueff_exponentCSA_squaredr4   CSA_dampfacg'1Z?r3   z2CSA damping is asymmetric: dampdown = {0} x dampupzCMAAdaptSigmaCSA Parameters: z  :r   )"r9   disregard_length_settinglenr   infsort
ValueError	TypeErrorlistr'   r(   r)   r*   r+   CSA_dampfac_mueff_inner'CSA_dampfac_mueff_attenuation_dimensionmaxminlam_mirrpopsizeCSA_dampfac_mueff_true_inner_inner_thresholddampscsa_dampdown_facprintformatmax_delta_log_sigma__dict__itemsr,   r-   r   r`   )	r    r.   r/   exponentdamp_inref_dimdamp_in_effkvs	            r   
initializezCMAAdaptSigmaCSA.initialize   s@   
 138N0OUZ%77*+7
_rww678A=9;7HBGG34!89:a?9;I`AabcAd7eBGG34!89:a?79wwrwwG^?_7`BGG34$%ijj 04BGGBGGD[<\4]/^BGG+,ww./2Q6"''BY:Z[\:]`a:a !}~~,,q0144a255==CVCVYZCZ]^B^8^_7745GGM2qH24[!(Ag3#q3+@'@A8C 4D
 WW]+q255>>URUU]]-BCaG!KLMqPSTTU#!k/2358!,1D1DQ1F244PQ60RU]/]]`pp:r 6sss
 ''
 q RWWY%7!%;FF+,.#$ ((011vBGG+,ARUU]]0014q88BDD!Ga"%%--J]J]_`J`F`<`aDG/!3DJwwy!A%56 MM//1DAq$3* 2((244.%'""]  _57VVGRWWE\=]3^/0_s   C,Q3 36R-,R-c                    | j                   s| j                  |       | j                  |j                  k(  ry|j                  }|j
                  d   |j
                  d   }t        |       |d   dkD  s|d   dk  r$t        dt        |j
                  d         z        |j                  dz  |d   |j                  z  |j                  dz   z  z   }|j                  dz  |d   |j                  z  |j                  dz   z  z   }t        |      }t        j                  |||      }||k7  r|||z  z  }| xj                   d| j"                  z
  z  c_        | xj                   t%        | j"                  d| j"                  z
  z        |z  z  c_        |j                  | _        y# t        $ r t        j                   |g}Y Uw xY w)a  update path with isotropic delta mean, possibly clipped.

        From input argument `es`, the attributes isotropic_mean_shift,
        opts['CSA_clip_length_value'], and N are used.
        opts['CSA_clip_length_value'] can be a single value, the upper
        bound factor, such that::

            max_len = sqrt(N) + opts['CSA_clip_length_value'] * N / (N+2)

        or a list with a lower and an upper factor.
        Nrm   r   r   zNvalue(s) for option 'CSA_clip_length_value' = %s
                  not allowedr4   r   )r`   r   r   r5   isotropic_mean_shiftr9   rs   rw   r   rt   rv   strr*   r   r
   minmaxr-   r+   _sqrt)r    r.   rB   valsmin_lenmax_lenact_lennew_lens           r   r2   zCMAAdaptSigmaCSA._update_ps   s    ""OOB%%5##77*+77723DTAw{d1gk !#&rww/F'G#HIJ J ddCi$q'BDD.BDD1H"==GddCi$q'BDD.BDD1H"==GAhGii':G'!Ww&& 	AK 5AK01A55%'\\"! 4rvvgt_d4s   "F# #GGc                    | j                  |       | j                  }| j                  }|j                  j	                  d      rX|j                  d   dkD  r$|j
                  dk(  rt        j                  d       |j                  }|j                  j                  }	 |j                  |      }t        |      }|d	k(  ry|j                  d
   rt%        t'        |            |z  dz
  dz  }n$t)        |      t+        j,                  |      z  dz
  }||| j.                  z  z  }t0        dk7  r|d	k  r	|t0        z  }t+        j2                  || j4                   | j4                        }||k7  rzt        j6                  dt9        |      z   dz   t9        t;        j<                  |            z   dz   t9        | j4                        z   dz   dd|j
                  |j                  d          | xj>                  t;        j<                  |      z  c_        t;        j<                  |      S # t        $ rP ddk  rGt        |j                  d         r/dj                  t        |            }t!        j"                  |       Y w xY w)zcall ``self._update_ps(es)`` and update self.delta.

        Return change factor of self.delta.

        From input `es`, either attribute ``N`` or ``const.chiN`` is used and ``path_for_sigma_update``.
        rD   r3   r   z!CSA uses invariant path pc for ps   r   integer_variableszuMissing ``path_for_sigma_update`` attribute in {0}.
 This is usually not a problem unless integer mutations are used.r   ro   r   zsigma change np.exp(z) = z clipped to np.exp(+-)rN   rh   ) r2   r-   r+   r9   rE   r5   r	   print_message_path_for_invariant_updater'   rG   path_for_sigma_updater:   rs   r   type	_warningswarnr   _squarer   r
   chiNr   r   r   r   r8   r   r   expr   )	r    r.   r"   pr+   mr*   s	s_clippeds	            r   rL   zCMAAdaptSigmaCSA.update2  s    	GGWW77;;+,wwy!A%",,!*;##$GH--AB	"((+A F677=!WQZ1$q(A-A a2771:%)A	R$**_q QU!!AIIa$":":!:D<T<TU	> 6Q ?& H3rvvVWy> Y1!2478P8P4Q!RTW!X", "bggi.@	B
 	

bffY''
vvi  7  	"Av#bgg&9:;vd2h'  q!	"s   H" "AI;:I;c           	          |xj                    | j                  |fi |z  c_         ddk  r|d   }t        j                  |j                  |j
                  d|j                  j                  j                      D cg c]  }t        |dz         c}      }|xj                   t        j                  t        j                  |j                  j                  ||j                  z  dz
              d|j                  dz   z  z  z  c_         ddk  r|j                  j                  d|j                  d   r+t        | j                   dz        |j                  z  dz  d	z
  n.t#        | j                         |j$                  j&                  z  dz
  z         |j                  j                  dd
t        | j                   dz        |j                  z  dz  z   t#        | j                         |j$                  j&                  z  z
  z         yyc c}w )zlcall ``self._update_ps(es)`` and update ``es.sigma``.

        Legacy method replaced by `update2`.
        r   r   fitNr   r   r   ro   r4   g      )r@   rL   r   arrayarzidxr'   r(   mur   r   dotr*   more_to_writeappendr9   r-   r   constr   )r    r.   r"   r   rB   slengthss         r   rN   zCMAAdaptSigmaCSA.updateC  s   
 	LDLL.v..6-CxxBFF377CTBEEMMDTDT;U4V W4VqQT4V WXHHHrvvbeemmX_q5HIJQRTRVRVYZRZ^\\H6##BPRPWPWXePf#dggqj/BDD*@1*Du*Llqrvryrylz}  ~F  ~F  ~K  ~K  mK  NO  mO  %Q  R##BDGGQJ"$$0F0J)JUSWSZSZ^^`^f^f^k^kMk)k$lm  !Xs   <HN)	rT   rU   rV   rW   r#   r   r2   rL   rN   rR   r   r   rh   rh      s$    
>~%2L-!\nr   rh   c                   "    e Zd ZdZd Zd Zd Zy)CMAAdaptSigmaMedianImprovementa{  Compares median fitness to the 27%tile fitness of the
    previous iteration, see Ait ElHara et al, GECCO 2013.

    >>> import cma
    >>> es = cma.CMAEvolutionStrategy(3 * [1], 1,
    ... {'AdaptSigma':cma.sigma_adaptation.CMAAdaptSigmaMedianImprovement,
    ...  'verbose': -9})
    >>> assert es.optimize(cma.ff.elli).result[1] < 1e-9
    >>> assert es.result[2] < 2000

    c                 .    t         j                  |        y r   )r   r#   rj   s     r   r#   z'CMAAdaptSigmaMedianImprovement.__init__`  s    ""4(r   c                 j   |j                   j                  j                  |j                  z  }d|dz  dd|dz  z
  z  t	        j
                  |j                  dz         dz  z  z   z  |j                  z  | _        d|j                  z  | _        dd|j                  z  z
  | _        d| _	        d| _
        | S )z:late initialization using attributes ``N`` and ``popsize``r4          @r   	   r   333333?r   )r'   r(   r)   r~   r   logr*   index_to_comparedampcr   )r    r.   rs      r   r   z)CMAAdaptSigmaMedianImprovement.initializec  s    EEMM"**, #q#vq1c6z0BRVVBDDSTHEUWXEX0X'X Y]_]g]g h $rzz 1BDDL	r   c                     |j                   dk  r.| j                  |       |j                  j                  | _        n| j                  t        | j                           }| j                  t        t        j                  | j                                 }|j                  j                  |j                  dz
  dz     }| j                  t        | j                        z
  }d}ddk  r||t        |j                  j                  | j                  t        t        j                  | j                                 k        z  z  }|d|z
  t        |j                  j                  | j                  t        | j                           k        z  z  }||j                  dz  z  }|d|j                  z  z  }nddk  r_|| j                  t        | j                  |j                  j                  |j                  dz     k        z
  z  }|d|j                  z  z  }n?|d|z
  t        j                  ||z
        z  z  }||t        j                  ||z
        z  z  }d| j                  z
  | j                  z  | j                  |z  z   | _        |xj                  t        j                  | j                  | j                  z        z  c_        ddk  rdd lmc m} |j#                  t%        |j                  j                        t%        | j                        z   t'        |j                  j                        dgz  t'        | j                        dgz  z         d   }	|j(                  j+                  d|	z         |j                  j                  | _        y )Nr   r   r   r   r   r   r   )r5   r   r   intr   r   ceilr~   r   signr   r   r@   r   r   scipy.stats.statsstats
kendalltaurx   rs   r   r   )
r    r.   r"   ft1ft2ftt1pt2r   r   zkendalls
             r   rN   z%CMAAdaptSigmaMedianImprovement.updatel  s   <<!OOBvvzzDH((3t4456C((3rwwt'<'<=>?C66::rzzA~!34D''#d.C.C*DDCA1uS3rvvzzTXXc"''$BWBW:X6Y-ZZ[[[a#gRVVZZ$((3t?T?T;U2V%V!WWWRZZ"_$R"**_$aT**SRVVZZ

VW=X1X-YYYQ^#a#gt!444S2773:...$&&jDFF*TVVaZ7DFHHtvv		122H 6--''RVVZZ(84>(I(+BFFJJ1#(=DHHQRPS@S(SUUVXH##BL166::r   N)rT   rU   rV   rW   r#   r   rN   rR   r   r   r   r   T  s    
)#r   r   c                   8     e Zd ZdZd fd	ZddZd Zd Z xZS )CMAAdaptSigmaTPAa  two point adaptation for step-size sigma.

    Relies on a specific sampling of the first two offspring, whose
    objective function value ranks are used to decide on the step-size
    change, see `update` for the specifics.

    Example
    =======

    >>> import cma
    >>> cma.CMAOptions('adapt').pprint()  # doctest: +ELLIPSIS
     AdaptSigma='True...
    >>> es = cma.CMAEvolutionStrategy(10 * [0.2], 0.1,
    ...     {'AdaptSigma': cma.sigma_adaptation.CMAAdaptSigmaTPA,
    ...      'ftarget': 1e-8})  # doctest: +ELLIPSIS
    (5_w,10)-aCMA-ES (mu_w=3.2,w_1=45%) in dimension 10 (seed=...
    >>> es.optimize(cma.ff.rosen)  # doctest: +ELLIPSIS
    Iter...
    >>> assert 'ftarget' in es.stop()
    >>> assert es.result[1] <= 1e-8  # should coincide with the above
    >>> assert es.result[2] < 6500  # typically < 5500

    References: loosely based on Hansen 2008, CMA-ES with Two-Point
    Step-Size Adaptation, more tightly based on Hansen et al. 2014,
    How to Assess Step-Size Adaptation Mechanisms in Randomized Search.

    c                 T    t         t        |           d| _        || _        || _        y )NF)r^   r   r#   initialized	dimensionr9   )r    r   r9   r"   rb   s       r   r#   zCMAAdaptSigmaTPA.__init__  s'    .0 "	r   c           
      
   | j                   du r| S d| _         |}t        |d      r0||j                  }|j                  j                  }|j
                  }|| j                  }|| j                  }	 |d   }t        j                         | _        	 ddt        j                  |      z  z   | j                  _        | j                  xj                  dt        j                  t        d|z
  f            z  z  c_        | j                  xj                  |z  c_        	 |d   d   | j                  _        t'        d| j                  j                  z         t(        dk7  r5||j+                  dd      dkD  rt'        dj%                  t(                     d| j                  _        d| j                  _        d| j                  _        d| j                  _        d| _        d| _        d| _        | j                   sd| _         | S # t        t        f$ r d}Y w xY w# t        $ rG}t!        j"                  d	j%                  |             d
| j                  _        d| _         Y d}~Id}~ww xY w# t        t        f$ r Y )w xY w)zlate initialization.

        :param N: a `CMAEvolutionStrategy` instance or the dimension for backward compatibility
        :param opts: used for hacking
        TFr*   NTPA_dampfacr   gffffff?r   z-Setting TPA damping failed with exception {0}   r4   vvTPA_dampzdamp set to %dr3   r   z2TPA damping is asymmetric: dampdown = {0} x dampupr   r&   )r   hasattrr9   r'   r~   r*   r   rw   KeyErrorr	   
BlancClassr   r   r   r{   	Exceptionr   r   r   r   tpa_dampdown_facrE   r   
z_exponent	sigma_facrelative_to_delta_meanr   s2last)r    r*   r9   _Nr~   damp_faces          r   r   zCMAAdaptSigmaTPA.initialize  s$    t#K 1c?|vvddllGA9A<99D	M*H ""$	#
 RVVAY.DGGLGGLLAsAw{+;'< ===LGGLLH$L	:j1DGGL"TWW\\12 q dldhhy!6Lq6PFF+,.	 )-&	#DK 8$ 	H	  	#NNJQQRSTUDGGL"D	# )$ 		s=   3H BH 9I/ HH	I,%<I''I,/JJc                 $   | j                   dur| j                  |       | j                   durt        j                  ddd       d| _         ddk  r^t	        j
                  |      }t	        j                  ||d   k        t	        j                  ||d   k        z
  }|t        |      dz
  z  }n|ddk  rwt	        j                  |j                  j                  dk(        d   d   t	        j                  |j                  j                  dk(        d   d   z
  }||j                  dz
  z  }d| j                  j                  z
  | j                  z  | j                  j                  t	        j                        z  t	        j                   |      | j                  j"                  z  z  z   | _        |xj$                  t	        j&                  | j                  | j                  j(                  z  | j                  dk  rt*        ndz        z  c_        y)	zthe first and second value in ``function_values``
        must reflect two mirrored solutions.

        Mirrored solutions must have been sampled
        in direction / in opposite direction of
        the previous mean shift, respectively.
        Tz%dimension not known, damping set to 4rN   r   r   r   r   N)r   r   r	   r8   r   asarrayr   rs   nonzeror   r   r~   r'   r   r   r   absr   r@   r   r   r   )r    r.   function_valuesr"   f_valsrB   s         r   rN   zCMAAdaptSigmaTPA.update  s    4'OOB4' G,.#Dq5ZZ0Fvq	)*RVVFVAY4F-GGAVq AU 

266::?+A.q1BJJrvvzzQ4OPQ4RST4UUAaAdggii-466)DGGII
,BRVVAYPTPWPWPbPbEb,bb
BFF466DGGLL09=!%5L M 	Mr   c                 6   t        |j                  t              sJ |j                  dkD  rt        j
                  j                  d|j                        }|j                  |   |j                  |   z
  }|j                  d   |   |j                  |   z
  }|j                  d   |   |j                  |   z
  }t        j
                  j                  d|j                  d      D ]0  }||k(  r||dkD  rdndz  }||z  |j                  d   |   |j                  |   z
  z  |j                  d   |   |j                  |   z
  z  r|j                  |   |j                  |   z
  |j                  d   |   |j                  |   z
  z  }|j                  |   |j                  |   z
  |j                  d   |   |j                  |   z
  z  }dt        dt	        j                  |j                  |         |j                  |   z  t	        j                  |j                  |         |j                  |   z  f      z  }	t        j                   |||z  |	      rt        j                   |||z  |	      rt#        j$                  d|||z  |||z  ||	|j                  |   fz  dd|j                        }
|
xr t'        j(                  |
       t#        j$                  d	d
|j*                  z  z   dd|j                        }
|
xr t'        j(                  |
       3 y y )Nr   r   r   r   gdy=zTPA: apparent inconsistency with mirrored samples, where dmi_div_dx0i, dm/dx0=%f, %f and dmi_div_dx1i, dm/dx1=%f, %f 
 i=%d expected precision=%f mean[i]=%frS   r   zKzero delta encountered in TPA which 
should be very rare and might be a bugz (sigma=%f))
isinstanceadapt_sigmar   r5   r   randomrandintr*   mean_after_tellr=   popr<   r{   r   stdsr
   equals_approximatelyr	   format_warningr   r   r@   )r    r.   jdmdx0dx1idmi_div_dx0idmi_div_dx1iexpected_precisionr   s              r   rS   z"CMAAdaptSigmaTPA.check_consistency  s   "..*:;;;<<!		!!!RTT*A##A&Q7B&&)A,+C&&)A,+CYY&&q"$$26a!e+A9q	!rwwqz 9:FF1IaL2771:-/$&$6$6q$9BKKN$J')vvay|bggaj'@$BL$&$6$6q$9BKKN$J+-66!9Q<"''!*+D$FL).a
9KbggVWj9X9;
9KbggVWj9X6Z 2[ *[& 22("s(4FH " 7 7$0"s(<N!P!00H !-bflBsF !#5rwwqzKCC 0.> @A?VY^^TUEV,, .T(5(@.A )<=O(*	6A 897NY^^A=N= 3 r   )NN)	rT   rU   rV   rW   r#   r   rN   rS   re   rf   s   @r   r   r     s     6:vMD%Or   r   )$rW   
__future__r   r   r   warningsr   numpyr   r   r   r   r   	utilitiesr	   utilities.mathr
    r   _cma_warningsr   r   ry   rz   r   r   filterwarningsobjectr   rY   r\   r   rh   r   r   r   rR   r   r   <module>r     s    A @   2   6 2X~  T  0*, '"   	  )L M] ]|) !k(9 !kF  mn( mn`;%6 ;z  8dO( dOr   