docs: def blend_crossover(random, mom, dad, args):
      """Return the offspring of blend crossover on the candidates.
  
      This function performs blend crossover (BLX), which is similar to 
      arithmetic crossover with a bit of mutation. It creates offspring
      whose values are chosen randomly from a range bounded by the
      parent alleles but that is also extended by some amount proportional
      to the *blx_alpha* keyword argument. It is this extension of the
      range that provides the additional exploration. This averaging is 
      only done on the alleles listed in the *blx_points* keyword argument. 
      If this argument is ``None``, then all alleles are used. This function 
      also makes use of the bounder function as specified in the EC's 
      ``evolve`` method.
  
      .. Arguments:
         random -- the random number generator object
         mom -- the first parent candidate
         dad -- the second parent candidate
         args -- a dictionary of keyword arguments
  
      Optional keyword arguments in args:
      
      - *crossover_rate* -- the rate at which crossover is performed 
        (default 1.0)
      - *blx_alpha* -- the blending rate (default 0.1)
      - *blx_points* -- a list of points specifying the alleles to
        recombine (default None)
      
      """
      blx_alpha = args.setdefault('blx_alpha', 0.1)
      blx_points = args.setdefault('blx_points', None)
      crossover_rate = args.setdefault('crossover_rate', 1.0)
      bounder = args['_ec'].bounder
      children = []
      if random.random() < crossover_rate:
          bro = copy.copy(dad)
          sis = copy.copy(mom)
          if blx_points is None:
              blx_points = list(range(min(len(bro), len(sis))))
          for i in blx_points:
              smallest, largest = min(mom[i], dad[i]), max(mom[i], dad[i])
              delta = blx_alpha * (largest - smallest)
              bro[i] = smallest - delta + random.random() * (largest - smallest + 2 * delta)
              sis[i] = smallest - delta + random.random() * (largest - smallest + 2 * delta)
          bro = bounder(bro, args)
          sis = bounder(sis, args)
          children.append(bro)
          children.append(sis)
      else:
          children.append(mom)
          children.append(dad)
      return children