Adds a unit clause to the given SAT solver.
@param s        the sat solver
@param a        the unit literal
@param blocking the blocking literal
196722
private void addUnitClause(final MiniSatStyleSolver s, int a, int blocking) {
    assert this.clause.size() == 0;
    assert a != LIT_UNDEF;
    assert var(a) < s.nVars();
    this.clause.push(a);
    if (blocking != LIT_UNDEF)
      this.clause.push(blocking);
    s.addClause(this.clause, null);
    this.clause.clear();
  }
759100
private void addToSplitterQueue(Block<S, L> block) {
        ElementReference ref = splitters.referencedAdd(block);
        block.setSplitterQueueReference(ref);
    }
215125
public static void addEquals( DMatrix4x4 a , DMatrix4x4 b ) {
        a.a11 += b.a11;
        a.a12 += b.a12;
        a.a13 += b.a13;
        a.a14 += b.a14;
        a.a21 += b.a21;
        a.a22 += b.a22;
        a.a23 += b.a23;
        a.a24 += b.a24;
        a.a31 += b.a31;
        a.a32 += b.a32;
        a.a33 += b.a33;
        a.a34 += b.a34;
        a.a41 += b.a41;
        a.a42 += b.a42;
        a.a43 += b.a43;
        a.a44 += b.a44;
    }
903353
@Beta
    public static <A, T> Predicate<T> sp(final Object mutex, final A a, final BiPredicate<A, T> biPredicate) {
        N.checkArgNotNull(mutex, "mutex");
        N.checkArgNotNull(biPredicate, "biPredicate");

        return new Predicate<T>() {
            @Override
            public boolean test(T t) {
                synchronized (mutex) {
                    return biPredicate.test(a, t);
                }
            }
        };
    }
740283
def p_blocking_substitution_base(self, p):
        ''
        p[0] = BlockingSubstitution(p[2], p[5], p[1], p[4], lineno=p.lineno(2))
        p.set_lineno(0, p.lineno(2))
851955
public void visitBlockStatement(BlockStatement block) {
        pushState();
        block.setVariableScope(currentScope);
        super.visitBlockStatement(block);
        popState();
    }
1943
@Override
    public Predicate or(Expression<Boolean> arg0, Expression<Boolean> arg1)
    {
        // TODO Auto-generated method stub
        if (arg0 != null && arg1 != null)
        {
            if (arg0.getClass().isAssignableFrom(ComparisonPredicate.class) && arg1.getClass().isAssignableFrom(ComparisonPredicate.class))
            {
                return new DisjunctionPredicate((Predicate)arg0, (Predicate)arg1);
            }
        }
        return null;
    }
342220
private void addPredicates(List<Predicate> newPredicates) {
    for(Predicate newPredicate : newPredicates) {
      if(this.predicates == null) {
        this.predicates = newPredicate;
      } else {
        this.predicates = new And(this.predicates, newPredicate);
      }
    }
  }
383480
@Override
    public boolean setA(DMatrixRMaj A) {
        if( A.numRows > maxRows || A.numCols > maxCols )
            setMaxSize(A.numRows,A.numCols);

        _setA(A);
        if( !decomposer.decompose(A) )
            return false;

        QR = decomposer.getQR();
        return true;
    }
780464
@Override
    public boolean setA(DMatrixRBlock A) {
        if( A.numRows < A.numCols )
            throw new IllegalArgumentException("Number of rows must be more than or equal to the number of columns.  " +
                    "Can't solve an underdetermined system.");

        if( !decomposer.decompose(A))
            return false;

        this.QR = decomposer.getQR();

        return true;
    }
986231
public final void blockStatement() throws RecognitionException {
		int blockStatement_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:697:5: ( localVariableDeclaration | classOrInterfaceDeclaration | statement )
			int alt105=3;
			alt105 = dfa105.predict(input);
			switch (alt105) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:697:7: localVariableDeclaration
					{
					pushFollow(FOLLOW_localVariableDeclaration_in_blockStatement2791);
					localVariableDeclaration();
					state._fsp--;
					if (state.failed) return;
					}
					break;
				case 2 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:698:7: classOrInterfaceDeclaration
					{
					pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement2799);
					classOrInterfaceDeclaration();
					state._fsp--;
					if (state.failed) return;
					}
					break;
				case 3 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:699:11: statement
					{
					pushFollow(FOLLOW_statement_in_blockStatement2811);
					statement();
					state._fsp--;
					if (state.failed) return;
					}
					break;

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 81, blockStatement_StartIndex); }

		}
	}
126998
private Formula constructCNF(final LinkedHashSet<? extends Formula> clauses) {
    if (clauses.isEmpty())
      return this.verum();
    if (clauses.size() == 1)
      return clauses.iterator().next();
    Map<LinkedHashSet<? extends Formula>, And> opAndMap = this.andsN;
    switch (clauses.size()) {
      case 2:
        opAndMap = this.ands2;
        break;
      case 3:
        opAndMap = this.ands3;
        break;
      case 4:
        opAndMap = this.ands4;
        break;
      default:
        break;
    }
    And tempAnd = opAndMap.get(clauses);
    if (tempAnd != null)
      return tempAnd;
    tempAnd = new And(clauses, this, true);
    opAndMap.put(clauses, tempAnd);
    return tempAnd;
  }
779257
private void processBlock(List<GenericCriteria> list, byte[] block)
   {
      if (block != null)
      {
         if (MPPUtility.getShort(block, 0) > 0x3E6)
         {
            addCriteria(list, block);
         }
         else
         {
            switch (block[0])
            {
               case (byte) 0x0B:
               {
                  processBlock(list, getChildBlock(block));
                  break;
               }

               case (byte) 0x06:
               {
                  processBlock(list, getListNextBlock(block));
                  break;
               }

               case (byte) 0xED: // EQUALS
               {
                  addCriteria(list, block);
                  break;
               }

               case (byte) 0x19: // AND
               case (byte) 0x1B:
               {
                  addBlock(list, block, TestOperator.AND);
                  break;
               }

               case (byte) 0x1A: // OR
               case (byte) 0x1C:
               {
                  addBlock(list, block, TestOperator.OR);
                  break;
               }
            }
         }
      }
   }
925988
public static void addStmt(BlockStmt block, Statement stmt) {
        List<Statement> stmts = block.getStmts();
        if (stmts == null) {
            stmts = new ArrayList<Statement>();
            block.setStmts(stmts);
        }
        stmts.add(stmt);
    }
652950
public static void setBlocking(FileDescriptor fd, boolean blocking) throws IOException {
        try {
            int flags = Libcore.os.fcntlVoid(fd, F_GETFL);
            if (!blocking) {
                flags |= O_NONBLOCK;
            } else {
                flags &= ~O_NONBLOCK;
            }
            Libcore.os.fcntlLong(fd, F_SETFL, flags);
        } catch (ErrnoException errnoException) {
            throw errnoException.rethrowAsIOException();
        }
    }
944422
protected static void multTransBBlockMinus_L( double[] dataA, double []dataC,
                                                  int indexA, int indexB, int indexC,
                                                  final int widthA, final int heightA, final int widthC ) {
//        for( int i = 0; i < heightA; i++ ) {
//            for( int j = 0; j <= i; j++ ) {
//                double sum = 0;
//                for( int k = 0; k < widthA; k++ ) {
//                    sum += dataA[i*widthA + k + indexA] * dataA[j*widthA + k + indexB];
//                }
//                dataC[ i*widthC + j + indexC ] -= sum;
//            }
//        }

        for( int i = 0; i < heightA; i++ ) {
            int rowA = i*widthA+indexA;
            int endA = rowA + widthA;
            int rowB = indexB;
            int rowC = i*widthC + indexC;
            for( int j = 0; j <= i; j++ , rowB += widthA) {
                double sum = 0;

                int a = rowA;
                int b = rowB;

                while( a != endA ) {
                    sum += dataA[a++] * dataA[b++];
                }
                dataC[ rowC + j ] -= sum;
            }
        }

    }
1012503
public static void set(
        MutableIntArrayND a0, IntSupplier s)
    {
        a0.coordinates().parallel().forEach(t ->
        {
            a0.set(t, s.getAsInt());
        });
    }