Adds a binary clause to the given SAT solver.
@param s the sat solver
@param a the first literal
@param b the second literal
7841
void addBinaryClause(final MiniSatStyleSolver s, int a, int b) {
    this.addBinaryClause(s, a, b, LIT_UNDEF);
  }
1118619
public static <T1, T2> BiPredicate<T1, T2> or(BiPredicate<T1, T2> first, BiPredicate<T1, T2> second, BiPredicate<T1, T2> third) {
        dbc.precondition(first != null, "first predicate is null");
        dbc.precondition(second != null, "second predicate is null");
        dbc.precondition(third != null, "third predicate is null");
        return Logic.Binary.or(Iterations.iterable(first, second, third));
    }
480943
@Override
    public boolean setA(DMatrixRBlock A) {
        // Extract a lower triangular solution
        if( !decomposer.decompose(A) )
            return false;

        blockLength = A.blockLength;

        return true;
    }
664465
public static boolean equal(byte[] a, byte[] b) {
       if (a == b)
          return (true);
       if ((a == null) || (b == null))
          return (false);
       if (a.length != b.length)
          return (false);
       for (int i = 0; i < a.length; i++)
          if (a[i] != b[i])
             return (false);
       return (true);
    }
488927
void addQuaternaryClause(final MiniSatStyleSolver s, int a, int b, int c, int d) {
    this.addQuaternaryClause(s, a, b, c, d, LIT_UNDEF);
  }
1265343
private static int mod(int a, final int B) {
        final int N = a / B;

        a -= N * B;
        if (a < 0) {
            return a + B;
        }
        return a;
    }
577882
@Inline(value="$1.add($2)")
	@Pure
	public static BigInteger operator_plus(BigInteger a, BigInteger b) {
		return a.add(b);
	}
1237030
public void set(byte b, Collection c) {
		if ((c != null) && (c.size() > 0)) {
			StringBuilder sb = new StringBuilder();
			Iterator it = c.iterator();
			while (it.hasNext()) {
				String s = (String) it.next();
				sb.append(s);
				if (it.hasNext())
					sb.append(lineSeparator);
			}
			set(b, sb.toString());
		} else
			remove(b);
	}
482079
public static boolean overlap(@Nullable String[] as, @Nullable String[] bs)
  {
    if (as == null || bs == null) {
      // They only have overlap if both are null.
      return as == null && bs == null;
    }
    if (as.length == 0 && bs.length == 0) {
      return true;
    }

    for (String a : as) {
      for (String b : bs) {
        if (Objects.equals(a, b)) {
          return true;
        }
      }
    }

    return false;
  }
1027163
public void add(byte b, Collection c) {
		if ((c != null) && (c.size() > 0)) {
			String s2 = get(b);
            for (Object aC : c) {
                String s = (String) aC;
                if (s2 == null)
                    s2 = s;
                else
                    s2 += lineSeparator + s;
            }
			set(b, s2);
		}
	}
1292949
private void writeULong(int s) {
        byte b1 = (byte)((s >> 24) & 0xff);
        byte b2 = (byte)((s >> 16) & 0xff);
        byte b3 = (byte)((s >> 8) & 0xff);
        byte b4 = (byte)(s & 0xff);
        writeByte(b1);
        writeByte(b2);
        writeByte(b3);
        writeByte(b4);
    }
1217606
public static final Atom add(Atom a, Atom b){

		Atom c = new AtomImpl();
		c.setX( a.getX() + b.getX() );
		c.setY( a.getY() + b.getY() );
		c.setZ( a.getZ() + b.getZ() );

		return c ;
	}
542875
void addTernaryClause(final MiniSatStyleSolver s, int a, int b, int c) {
    this.addTernaryClause(s, a, b, c, LIT_UNDEF);
  }
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;
    }
379157
function (q, a, b, x, s, t) {
        return safe_add(bit_rol(safe_add(safe_add(a, q),safe_add(x, t)), s),b);
    }
1269769
public static DoubleMatrix solveSymmetric(DoubleMatrix A, DoubleMatrix B) {
		A.assertSquare();
		DoubleMatrix X = B.dup();
		int[] ipiv = new int[B.rows];
		SimpleBlas.sysv('U', A.dup(), ipiv, X);
		return X;
	}
617040
public static int hamming(TupleDesc_B a, TupleDesc_B b ) {
		int score = 0;
		final int N = a.data.length;
		for( int i = 0; i < N; i++ ) {
			score += hamming(a.data[i] ^ b.data[i]);
		}
		return score;
	}