Bumps a clause and increments it's activity.
@param c the clause
516339
private void bumpClause(final CLClause c) {
        switch (this.config.cbump) {
            case INC:
                c.setActivity(c.activity() + 1);
                break;
            case LRU:
                c.setActivity(this.stats.conflicts);
                break;
            case AVG:
                c.setActivity((this.stats.conflicts + c.activity()) / 2);
                break;
            case NONE:
            default:
                assert this.config.cbump == CleaneLingConfig.ClauseBumping.NONE;
                break;
        }
    }
1207000
protected final void firstMonth(final Calendar c) {
        c.set(Calendar.MONTH, c.getMinimum(Calendar.MONTH));
    }
54152
protected void varBumpActivity(int v, double inc) {
    final MSVariable var = this.vars.get(v);
    var.incrementActivity(inc);
    if (var.activity() > 1e100) {
      for (final MSVariable variable : this.vars)
        variable.rescaleActivity();
      this.varInc *= 1e-100;
    }
    if (this.orderHeap.inHeap(v))
      this.orderHeap.decrease(v);
  }
343938
public void setC(double c)
    {
        if(c <= 0 || Double.isNaN(c) || Double.isInfinite(c))
            throw new IllegalArgumentException("coefficient must be in (0, Inf), not " + c);
        this.c = c;
    }
722609
private void pushExtension(final CLClause c, final int blit) {
        pushExtension(0);
        for (int i = 0; i < c.lits().size(); i++) {
            final int lit = c.lits().get(i);
            if (lit != blit) { pushExtension(lit); }
        }
        pushExtension(blit);
    }
367221
public void addBcc(String bcc) {
        if (this.bcc.length() > 0) {
            this.bcc.append(",");
        }
        this.bcc.append(bcc);
    }
1132989
private static void getCounts(BaseArray T, BaseArray C, int n, int k) {
        for (int i = 0; i < k; ++i) {
            C.set(i, 0);
        }
        for (int i = 0; i < n; ++i) {
            C.update(T.get(i), 1);
        }
    }
1298069
private void backward(final CLClause c, final int ignore) {
        int minlit = 0;
        int minoccs = Integer.MAX_VALUE;
        int litoccs;
        this.stats.steps++;
        for (int i = 0; i < c.lits().size(); i++) {
            final int lit = c.lits().get(i);
            if (lit == ignore) { continue; }
            if (val(lit) < 0) { continue; }
            litoccs = occs(lit).count();
            if (minlit != 0 && minoccs >= litoccs) { continue; }
            minlit = lit;
            minoccs = litoccs;
        }
        if (minoccs >= this.config.bwocclim) { return; }
        assert minlit != 0;
        for (int i = 0; i < c.lits().size(); i++) { mark(c.lits().get(i)); }
        final CLOccs os = occs(minlit);
        for (final CLClause d : os) {
            if (d == c) { continue; }
            int lit;
            int count = this.seen.size();
            int negated = 0;
            this.stats.steps++;
            for (int p = 0; count != 0 && p < d.lits().size(); p++) {
                lit = d.lits().get(p);
                final int m = marked(lit);
                if (m == 0) { continue; }
                assert count > 0;
                count--;
                if (m > 0) { continue; }
                assert m < 0;
                if (negated != 0) {
                    count = Integer.MAX_VALUE;
                    break;
                }
                negated = lit;
            }
            if (count != 0) { continue; }
            if (negated != 0) {
                this.tostrengthen.push(new Pair<>(d, negated));
                this.stats.backwardStrengthened++;
            } else {
                this.stats.backwardSubsumed++;
                dumpClause(d);
            }
        }
        unmark();
    }
1040641
public void increment(String name, int value) {
		Counter counter = get(name, CounterType.Increment);
		counter.setCount(counter.getCount() != null ? counter.getCount() + value : value);
		update();
	}
879789
public static void repeat(char c, int count, StringBuilder sb) {
		for (int i = 0; i < count; i++) {
			sb.append(c);
		}
	}
903060
public void write(int c) {
        if (c != -1) {
            current.append((char)c);
        }
        if (c == '\n') {
            current = new StringBuffer();
            lines.add(current);
        }
    }
24901
public void write(int c) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (nextChar >= nChars)
                flushBuffer();
            cb[nextChar++] = (char) c;
        }
    }
1247445
public void set(double a, double b, double c, double d) {
		this.aProperty.set(a);
		this.bProperty.set(b);
		this.cProperty.set(c);
		this.dProperty.set(d);
		clearBufferedValues();
	}
1234912
public void mutableMultiply(double c, double d)
    {
        double newR = this.real*c-this.imag*d;
        double newI = this.imag*c+this.real*d;
        this.real = newR;
        this.imag = newI;
    }
1224424
public static void mult(DMatrixRBlock A , DMatrixRBlock B , DMatrixRBlock C )
    {
        if( A.numCols != B.numRows )
            throw new IllegalArgumentException("Columns in A are incompatible with rows in B");
        if( A.numRows != C.numRows )
            throw new IllegalArgumentException("Rows in A are incompatible with rows in C");
        if( B.numCols != C.numCols )
            throw new IllegalArgumentException("Columns in B are incompatible with columns in C");
        if( A.blockLength != B.blockLength || A.blockLength != C.blockLength )
            throw new IllegalArgumentException("Block lengths are not all the same.");

        final int blockLength = A.blockLength;

        DSubmatrixD1 Asub = new DSubmatrixD1(A,0, A.numRows, 0, A.numCols);
        DSubmatrixD1 Bsub = new DSubmatrixD1(B,0, B.numRows, 0, B.numCols);
        DSubmatrixD1 Csub = new DSubmatrixD1(C,0, C.numRows, 0, C.numCols);

        MatrixMult_DDRB.mult(blockLength,Asub,Bsub,Csub);
    }
1338085
public void append(final CharBuffer cb) {
        if (cb == null) {
            return;
        }
        provideCapacity(length + cb.length);
        System.arraycopy(cb.c, 0, c, length, cb.length);
        length += cb.length;
    }
1134811
public void setContent(final Content c) {
        final ArrayList<Content> contents = new ArrayList<Content>();
        contents.add(c);
        setContents(contents);
    }