docs: def set(self, opts, popsize=None, ccovfac=1, verbose=True):
          """Compute strategy parameters as a function
          of dimension and population size """
  
          alpha_cc = 1.0  # cc-correction for mueff, was zero before
  
          def conedf(df, mu, N):
              """used for computing separable learning rate"""
              return 1. / (df + 2.*sqrt(df) + float(mu) / N)
  
          def cmudf(df, mu, alphamu):
              """used for computing separable learning rate"""
              return (alphamu + mu - 2. + 1. / mu) / (df + 4.*sqrt(df) + mu / 2.)
  
          sp = self
          N = sp.N
          if popsize:
              opts.evalall({'N':N, 'popsize':popsize})
          else:
              popsize = opts.evalall({'N':N})['popsize']  # the default popsize is computed in CMAOptions()
          ## meta_parameters.lambda_exponent == 0.0
          popsize = int(popsize + N** 0.0 - 1)
          sp.popsize = popsize
          if opts['CMA_mirrors'] < 0.5:
              sp.lam_mirr = int(0.5 + opts['CMA_mirrors'] * popsize)
          elif opts['CMA_mirrors'] > 1:
              sp.lam_mirr = int(0.5 + opts['CMA_mirrors'])
          else:
              sp.lam_mirr = int(0.5 + 0.16 * min((popsize, 2 * N + 2)) + 0.29)  # 0.158650... * popsize is optimal
              # lam = arange(2,22)
              # mirr = 0.16 + 0.29/lam
              # print(lam); print([int(0.5 + l) for l in mirr*lam])
              # [ 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21]
              # [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4]
          ## meta_parameters.parent_fraction == 0.5
          sp.mu_f = 0.5 * sp.popsize  # float value of mu
          if opts['CMA_mu'] is not None:
              sp.mu_f = opts['CMA_mu']
          sp.mu = int(sp.mu_f + 0.499999)  # round down for x.5
          sp.mu = max((sp.mu, 1))
          # in principle we have mu_opt = popsize/2 + lam_mirr/2,
          # which means in particular weights should only be negative for q > 0.5+mirr_frac/2
          if sp.mu > sp.popsize - 2 * sp.lam_mirr + 1:
              _print_warning("pairwise selection is not implemented, therefore " +
                    " mu = %d > %d = %d - 2*%d + 1 = popsize - 2*mirr + 1 can produce a bias" % (
                      sp.mu, sp.popsize - 2 * sp.lam_mirr + 1, sp.popsize, sp.lam_mirr))
          if sp.lam_mirr > sp.popsize // 2:
              raise _Error("fraction of mirrors in the population as read from option CMA_mirrors cannot be larger 0.5, " +
                           "theoretically optimal is 0.159")
          sp.weights = log(max([sp.mu, sp.popsize / 2.0]) + 0.5) - log(1 + np.arange(sp.mu))
          sp.weights /= sum(sp.weights)
          sp.mueff = 1 / sum(sp.weights**2)
          # TODO: this will disappear, as it is done in class CMAAdaptSigmaCSA
          ## meta_parameters.cs_exponent == 1.0
          b = 1.0
          ## meta_parameters.cs_multiplier == 1.0
          sp.cs = 1.0 * (sp.mueff + 2)**b / (N + (sp.mueff + 3)**b)  # TODO: this doesn't change dependency of dimension
          # sp.cs = (sp.mueff + 2) / (N + 1.5*sp.mueff + 1)
          ## meta_parameters.cc_exponent == 1.0
          b = 1.0
          ## meta_parameters.cc_multiplier == 1.0
          sp.cc = 1.0 * \
                  (4 + alpha_cc * sp.mueff / N)**b / \
                  (N**b + (4 + alpha_cc * 2 * sp.mueff / N)**b)
          sp.cc_sep = (1 + 1 / N + alpha_cc * sp.mueff / N) / (N**0.5 + 1 / N + alpha_cc * 2 * sp.mueff / N)  # \not\gg\cc
          if hasattr(opts['vv'], '__getitem__') and opts['vv'][0] == 'sweep_ccov1':
              ## meta_parameters.cc_multiplier == 1.0
              sp.cc = 1.0 * (4 + sp.mueff / N)**0.5 / ((N + 4)**0.5 + (2 * sp.mueff / N)**0.5)
          sp.rankmualpha = opts['CMA_rankmualpha']
          # sp.rankmualpha = _evalOption(opts['CMA_rankmualpha'], 0.3)
          ## meta_parameters.c1_multiplier == 1.0
          sp.c1 = ( 1.0 * ccovfac * min(1, sp.popsize / 6) *
                   ## meta_parameters.c1_exponent == 2.0
                   2 / ((N + 1.3)** 2.0 + sp.mueff))
          # 1/0
          sp.c1_sep = ccovfac * conedf(N, sp.mueff, N)
          if opts['CMA_rankmu'] != 0:  # also empty
              ## meta_parameters.cmu_multiplier == 2.0
              alphacov, mu = 2.0 , sp.mueff
              sp.cmu = min(1 - sp.c1, ccovfac * alphacov *
                           ## meta_parameters.cmu_exponent == 2.0
                           (sp.rankmualpha + mu - 2 + 1 / mu) / ((N + 2)** 2.0 + alphacov * mu / 2))
              if hasattr(opts['vv'], '__getitem__') and opts['vv'][0] == 'sweep_ccov':
                  sp.cmu = opts['vv'][1]
              sp.cmu_sep = min(1 - sp.c1_sep, ccovfac * cmudf(N, sp.mueff, sp.rankmualpha))
          else:
              sp.cmu = sp.cmu_sep = 0
          if hasattr(opts['vv'], '__getitem__') and opts['vv'][0] == 'sweep_ccov1':
              sp.c1 = opts['vv'][1]
  
          sp.neg = _BlancClass()
          if opts['CMA_active'] and opts['CMA_on']:
              # in principle we have mu_opt = popsize/2 + lam_mirr/2,
              # which means in particular weights should only be negative for q > 0.5+mirr_frac/2
              if 1 < 3: # seems most natural: continuation of log(lambda/2) - log(k) qqqqqqqqqqqqqqqqqqqqqqqqqq
                  sp.neg.mu_f = popsize // 2  # not sure anymore what this is good for
                  sp.neg.weights = array([log(k) - log(popsize/2 + 1/2) for k in np.arange(np.ceil(popsize/2 + 1.1/2), popsize + .1)])
              sp.neg.mu = len(sp.neg.weights)
              sp.neg.weights /= sum(sp.neg.weights)
              sp.neg.mueff = 1 / sum(sp.neg.weights**2)
              ## meta_parameters.cact_exponent == 1.5
              sp.neg.cmuexp = opts['CMA_active'] * 0.3 * sp.neg.mueff / ((N + 2)** 1.5 + 1.0 * sp.neg.mueff)
              if hasattr(opts['vv'], '__getitem__') and opts['vv'][0] == 'sweep_ccov_neg':
                  sp.neg.cmuexp = opts['vv'][1]
              # reasoning on learning rate cmuexp: with sum |w| == 1 and
              #   length-normalized vectors in the update, the residual
              #   variance in any direction exceeds exp(-N*cmuexp)
              assert sp.neg.mu >= sp.lam_mirr  # not really necessary
              # sp.neg.minresidualvariance = 0.66  # not it use, keep at least 0.66 in all directions, small popsize is most critical
          else:
              sp.neg.cmuexp = 0
  
          sp.CMA_on = sp.c1 + sp.cmu > 0
          # print(sp.c1_sep / sp.cc_sep)
  
          if not opts['CMA_on'] and opts['CMA_on'] not in (None, [], (), ''):
              sp.CMA_on = False
              # sp.c1 = sp.cmu = sp.c1_sep = sp.cmu_sep = 0
          mueff_exponent = 0.5
          if 1 < 3:
              mueff_exponent = opts['CSA_damp_mueff_exponent']
          # TODO: this will disappear, as it is done in class CMAAdaptSigmaCSA
          sp.damps = opts['CSA_dampfac'] * (0.5 +
                                            0.5 * min([1, (sp.lam_mirr / (0.159 * sp.popsize) - 1)**2])**1 +
                                            2 * max([0, ((sp.mueff - 1) / (N + 1))**mueff_exponent - 1]) + sp.cs
                                            )
          sp.cmean = float(opts['CMA_cmean'])
          # sp.kappa = 1  # 4-D, lam=16, rank1, kappa < 4 does not influence convergence rate
                          # in larger dim it does, 15-D with defaults, kappa=8 factor 2
          if verbose:
              if not sp.CMA_on:
                  print('covariance matrix adaptation turned off')
              if opts['CMA_mu'] != None:
                  print('mu = %f' % (sp.mu_f))