Increase coefficients the same value so one of them reaches 1

@param double $coef0
@param double $coef1
341500
private static function rectifyReliabilityCoefs(&$coef0, &$coef1)
    {
        $reliabilityRectification = 1 - max($coef0, $coef1);
        
        $coef0 += $reliabilityRectification;
        $coef1 += $reliabilityRectification;
    }
796055
def increment(d, key, val=1):
    
    if key in d:
        d[key] += val
    else:
        d[key] = val
466140
public function increase($fields, $where, float $diff = 1): int
    {
        return intval(self::crease('+', $fields, $where, $diff));
    }
1371040
public static void fe_add(int[] h,int[] f,int[] g)
{
  int f0 = f[0];
  int f1 = f[1];
  int f2 = f[2];
  int f3 = f[3];
  int f4 = f[4];
  int f5 = f[5];
  int f6 = f[6];
  int f7 = f[7];
  int f8 = f[8];
  int f9 = f[9];
  int g0 = g[0];
  int g1 = g[1];
  int g2 = g[2];
  int g3 = g[3];
  int g4 = g[4];
  int g5 = g[5];
  int g6 = g[6];
  int g7 = g[7];
  int g8 = g[8];
  int g9 = g[9];
  int h0 = f0 + g0;
  int h1 = f1 + g1;
  int h2 = f2 + g2;
  int h3 = f3 + g3;
  int h4 = f4 + g4;
  int h5 = f5 + g5;
  int h6 = f6 + g6;
  int h7 = f7 + g7;
  int h8 = f8 + g8;
  int h9 = f9 + g9;
  h[0] = (int)h0;
  h[1] = (int)h1;
  h[2] = (int)h2;
  h[3] = (int)h3;
  h[4] = (int)h4;
  h[5] = (int)h5;
  h[6] = (int)h6;
  h[7] = (int)h7;
  h[8] = (int)h8;
  h[9] = (int)h9;
}
548058
public void set(List<Double> coefficients, Engine engine) {
        setCoefficients(coefficients);
        setEngine(engine);
    }
205656
def increase_last(self, k):
        
        idx = self._last_idx
        if idx is not None:
            self.results[idx] += k
1112539
def load_coef(filename):
    """"""
    
    with open(filename) as f: 
        lines = f.readlines()

        lst = lines[0].split(',')

        nmax = int(lst[0])
        mmax = int(lst[1])

        L = (nmax + 1) + mmax * (2 * nmax - mmax + 1);

        vec = np.zeros(L, dtype=np.complex128)
   
        lines.pop(0)

        for n, line in enumerate(lines):
            lst = line.split(',')
            re = float(lst[0])
            im = float(lst[1])
            vec[n] = re + 1j * im

    return sp.ScalarCoefs(vec, nmax, mmax)
436499
def increase_i(self):
        """"""
        self.i += 1
        if self.i > self.bracket_id:
            self.no_more_trial = True
945164
public function increment($key, $value = 1)
    {
        $val = (int) $this->get($key) + $value;
        return $this->put($key, $val) ? $val : false;
    }
762807
@javax.annotation.Nonnull
  public final synchronized com.simiacryptus.util.data.ScalarStatistics add(@javax.annotation.Nonnull final com.simiacryptus.util.data.ScalarStatistics right) {
    @javax.annotation.Nonnull final com.simiacryptus.util.data.ScalarStatistics sum = new com.simiacryptus.util.data.ScalarStatistics();
    sum.sum0 += sum0;
    sum.sum0 += right.sum0;
    sum.sum1 += sum1;
    sum.sum1 += right.sum1;
    sum.sum2 += sum2;
    sum.sum2 += right.sum2;
    return sum;
  }
226416
@Nullable
  public com.simiacryptus.util.data.ScalarStatistics add(@javax.annotation.Nonnull final double... values) {
    double v1 = 0;
    double v2 = 0;
    double vmax = max;
    double vmin = max;
    int z = 0;
    double vlog = 0;
    int n = 0;
    int p = 0;
    for (final double v : values) {
      v1 += v;
      v2 += v * v;
      vmin = Math.min(min, v);
      vmax = Math.max(max, v);
      if (Math.abs(v) < com.simiacryptus.util.data.ScalarStatistics.zeroTol) {
        z++;
      }
      else {
        if (v < 0) {
          n++;
        }
        else {
          p++;
        }
        vlog += Math.log10(Math.abs(v));
      }
    }
    synchronized (this) {
      sum0 += values.length;
      sum1 += v1;
      sum2 += v2;
      min = Math.min(min, vmin);
      max = Math.max(max, vmax);
      negatives += n;
      positives += p;
      sumLog += vlog;
      zeros += z;
    }
    return this;
  }
948450
def update_coefs(self):
        """"""
        coefs = []
        sum_coefs = 0.
        moment1 = self.iuh.moment1
        for t in itertools.count(0., 1.):
            points = (moment1 % 1,) if t <= moment1 <= (t+2.) else ()
            try:
                coef = integrate.quad(
                    self._quad, 0., 1., args=(t,), points=points)[0]
            except integrate.IntegrationWarning:
                idx = int(moment1)
                coefs = numpy.zeros(idx+2, dtype=float)
                weight = (moment1-idx)
                coefs[idx] = (1.-weight)
                coefs[idx+1] = weight
                self.coefs = coefs
                warnings.warn(
                    'During the determination of the MA coefficients '
                    'corresponding to the instantaneous unit hydrograph '
                    '`%s` a numerical integration problem occurred.  '
                    'Please check the calculated coefficients: %s.'
                    % (repr(self.iuh), objecttools.repr_values(coefs)))
                break   # pragma: no cover
            sum_coefs += coef
            if (sum_coefs > .9) and (coef < self.smallest_coeff):
                coefs = numpy.array(coefs)
                coefs /= numpy.sum(coefs)
                self.coefs = coefs
                break
            else:
                coefs.append(coef)
433094
public void increment(PairCountAccumulator<A,B> other) {
    for (A key1 : other.counts.keySet()) {
      for (B key2 : other.counts.get(key1).keySet()) {
        double value = other.getCount(key1, key2);
        incrementOutcome(key1, key2, value);
      }
    }
  }
713855
public function increment($increment = 1) {
		$this->_current = min($this->_total, $this->_current + $increment);
	}
299374
public function increment($key, $value = 1)
    {
        $this->store->increment($this->taggedItemKey($key), $value);
    }
1037009
public function increment($column, $value = null, $where = [], $operator = "+")
    {
        return self::getInstance()->makeIncreDecrement($column, $value, $where, $operator);
    }
16030
def update_ar_coefs(self):
        
        del self.ar_coefs
        for ar_order in range(1, self.effective_max_ar_order+1):
            self.calc_all_ar_coefs(ar_order, self.ma)
            if self._rel_rmse < self.max_rel_rmse:
                break
        else:
            with hydpy.pub.options.reprdigits(12):
                raise RuntimeError(
                    f'Method `update_ar_coefs` is not able to determine '
                    f'the AR coefficients of the ARMA model with the desired '
                    f'accuracy.  You can either set the tolerance value '
                    f'`max_rel_rmse` to a higher value or increase the '
                    f'allowed `max_ar_order`.  An accuracy of `'
                    f'{objecttools.repr_(self._rel_rmse)}` has been reached '
                    f'using `{self.effective_max_ar_order}` coefficients.')