Adds a ternary clause to the given SAT solver.
@param s the sat solver
@param a the first literal
@param b the second literal
@param c the third literal
542875
void addTernaryClause(final MiniSatStyleSolver s, int a, int b, int c) {
    this.addTernaryClause(s, a, b, c, LIT_UNDEF);
  }
437481
@Override
    public boolean setA(DMatrixRMaj A) {
        if( A.numRows < A.numCols )
            throw new IllegalArgumentException("Can't solve for wide systems.  More variables than equations.");
        if( A.numRows > maxRows || A.numCols > maxCols )
            setMaxSize(A.numRows,A.numCols);

        R.reshape(A.numCols,A.numCols);
        a.reshape(A.numRows,1);
        temp.reshape(A.numRows,1);

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

        gammas = decomposer.getGammas();
        QR = decomposer.getQR();
        decomposer.getR(R,true);
        return true;
    }
342483
public static void parseConditionToJunction(Condition condition,
			Junction junction, Class<?> persistentClass) {
		// 子条件
		List<Condition> subConditions = condition.getSubConditions();

		// 有子条件则进行遍历获取最终的条件
		if (null != subConditions && !subConditions.isEmpty()) {
			// 子条件当中的and条件集合
			List<Condition> andConditions = condition.getAndConditions();
			if (null != andConditions && !andConditions.isEmpty()) {
				// 创建一个and条件集合
				Conjunction conj = Restrictions.conjunction();
				// 添加到父条件中
				junction.add(conj);
				for (Condition andCondition : andConditions) {
					/*
					 * 把每个条件看做是一个大的条件(包含 and 和 or 2个部分),
					 * 然后使用disjunction连接条件集合来组合这个大条件的(and项 和 or项);
					 * 因为and项和or项都已经被分为2个部分
					 * ,而且又是用disjunction来组合,所以可以保证一个大条件只会被or连接符分隔成2个部分
					 */
					Disjunction dj = Restrictions.disjunction();
					conj.add(dj);
					parseConditionToJunction(andCondition, dj, persistentClass);
				}
			}

			// 子条件当中的or条件集合
			List<Condition> orConditions = condition.getOrConditions();
			if (null != orConditions && !orConditions.isEmpty()) {
				// 创建一个or条件集合
				Disjunction disj = Restrictions.disjunction();
				// 添加到父条件中
				junction.add(disj);
				for (Condition orCondition : orConditions) {
					// 这里的实现原理与上面的andCondition的处理相同
					Disjunction dj = Restrictions.disjunction();
					disj.add(dj);
					parseConditionToJunction(orCondition, dj, persistentClass);
				}
			}
		} else {
			// 条件为最终条件，转换为符合Hibernate的条件，然后条件到条件集合中
			junction.add(condition.getCriterion(persistentClass));
		}
	}
368065
public void addConstraint(Constraint c) {

        int index = c.getConstraintType() == Constraint.PRIMARY_KEY ? 0
                                                                    : constraintList
                                                                        .length;

        constraintList =
            (Constraint[]) ArrayUtil.toAdjustedArray(constraintList, c, index,
                1);

        updateConstraintLists();
    }
837757
public static long max(long a, final long b, final long c) {
        if (b > a) {
            a = b;
        }
        if (c > a) {
            a = c;
        }
        return a;
    }
1189131
function add (a, b, c) {
		binary_arithmetic.call(this, a, b, c, '__add', add_internal);
	}
1142662
public void applyQ( ZMatrixRMaj A ) {
        if( A.numRows != numRows )
            throw new IllegalArgumentException("A must have at least "+numRows+" rows.");

        for( int j = minLength-1; j >= 0; j-- ) {
            int diagIndex = (j*numRows+j)*2;
            double realBefore = QR.data[diagIndex];
            double imagBefore = QR.data[diagIndex+1];

            QR.data[diagIndex] = 1;
            QR.data[diagIndex+1] = 0;

            QrHelperFunctions_ZDRM.rank1UpdateMultR(A, QR.data, j * numRows, gammas[j], 0, j, numRows, v);

            QR.data[diagIndex] = realBefore;
            QR.data[diagIndex+1] = imagBefore;
        }
    }
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();
	}
1098868
public static <T> int compare(T a, T b, Comparator<? super T> c) {
        if (a == b) {
            return 0;
        }
        return c.compare(a, b);
    }
184818
public static void addEquals( DMatrix2x2 a , DMatrix2x2 b ) {
        a.a11 += b.a11;
        a.a12 += b.a12;
        a.a21 += b.a21;
        a.a22 += b.a22;
    }
74113
public Predicate<T> or( final Predicate<T> other ) {
        if (other == null || other == this) return this;
        return new Predicate<T>() {
            @Override
            public boolean test( T input ) {
                return Predicate.this.test(input) || other.test(input);
            }
        };
    }
1179665
public static void subtractEquals( DMatrix4 a , DMatrix4 b ) {
        a.a1 -= b.a1;
        a.a2 -= b.a2;
        a.a3 -= b.a3;
        a.a4 -= b.a4;
    }
1014441
public static void subtractEquals( DMatrix3 a , DMatrix3 b ) {
        a.a1 -= b.a1;
        a.a2 -= b.a2;
        a.a3 -= b.a3;
    }
446524
public static Tristate searchSATSolver(final MiniSatStyleSolver s, final SATHandler handler, final LNGIntVector assumptions) {
    return s.solve(handler, assumptions);
  }
804787
public void addBasicSentence(MtasCQLParserBasicSentenceCondition s)
      throws ParseException {
    if (!simplified) {
      List<MtasCQLParserBasicSentencePartCondition> newWordList = s
          .getPartList();
      partList.addAll(newWordList);
    } else {
      throw new ParseException("already simplified");
    }
  }
848604
@Nonnull
	public <V1 extends T1, V2 extends T2> LObjIntObjPredicateBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC3, LObjIntObjPredicate<V1, V2> function) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
290851
@Beta
    public static <A, B, T> Predicate<T> sp(final Object mutex, final A a, final B b, final TriPredicate<A, B, T> triPredicate) {
        N.checkArgNotNull(mutex, "mutex");
        N.checkArgNotNull(triPredicate, "triPredicate");

        return new Predicate<T>() {
            @Override
            public boolean test(T t) {
                synchronized (mutex) {
                    return triPredicate.test(a, b, t);
                }
            }
        };
    }