Bitwise OR together two numbers.

@param left  a Number
@param right another Number to bitwise OR
@return the bitwise OR of both Numbers
@since 1.0
506839
public static Number or(Number left, Number right) {
        return NumberMath.or(left, right);
    }
1098877
private void processBigram(String left, String right) {
        TokenStats leftStats = getStatsFor(left);
        TokenStats rightStats = getStatsFor(right);
        
        // mark that both appeared
        leftStats.count++;
        rightStats.count++;

        // Mark the respective positions of each
        leftStats.leftCount++;
        rightStats.rightCount++;

        // Increase the number of bigrams seen
        numBigramsInCorpus++;

        // Update the bigram statistics

        // Map the two token's indices into a single long
        long bigram = (((long)leftStats.index) << 32) |  rightStats.index;
        Number curBigramCount = bigramCounts.get(bigram);
        int i = (curBigramCount == null) ? 1 : 1 + curBigramCount.intValue();

        // Compact the count into the smallest numeric type that can represent
        // it.  This hopefully results in some space savings.
        Number val = null;
        if (i < Byte.MAX_VALUE)
            val = Byte.valueOf((byte)i);
        else if (i < Short.MAX_VALUE)
            val = Short.valueOf((short)i);
        else
            val = Integer.valueOf(i);
        
        bigramCounts.put(bigram, val);
    }
938557
public static <L, R> Either<L, R> left(L l) {
        return new Left<>(l);
    }
547905
public static CharSequence concat(CharSequence left, CharSequence right) {
	if (left instanceof Appendable) {
	    try {
		((Appendable) left).append(right);
		return left;
	    }
	    catch (IOException e) {}
	}
	return new StringBuilder(left).append(right);
    }
632151
public static Boolean or(Object left, Object right) {
        return (Boolean) InfixOpNode.or(left, right, null);
    }
442937
public static int compare(Date left, double right) {
	return compare(left.getTime() / 1000, DateTimeUtil.getInstance().toDateTime(right).getTime() / 1000);
    }
774865
@Pure
	@Inline(value="($1 & $2)", constantExpression=true)
	public static int bitwiseAnd(int a, int b) {
		return a & b;
	}
921768
@NonNull
  public static Term subtract(@NonNull Term left, @NonNull Term right) {
    return new BinaryArithmeticTerm(ArithmeticOperator.DIFFERENCE, left, right);
  }
667272
public static boolean isArrayEqual(final Object[] left, final Object[] right) {
        if (left == right) {
            return true;
        }
        if (left == null || right == null) {
            return false;
        }
        if (left.length != right.length) {
            return false;
        }
        for (int i = 0; i < left.length; ++i) {
            if (!isArrayElementEqual(left[i], right[i])) {
                return false;
            }
        }
        return true;
    }
1193598
public <NL, NR> @NonNull Pair<NL, NR> map(final @NonNull Function<? super L, ? extends NL> left, final @NonNull Function<? super R, ? extends NR> right) {
    return new Pair<>(left.apply(this.left), right.apply(this.right));
  }
1286652
static void copyBits(CircularBitSet left, CircularBitSet right) {
    int bitsToCopy = Math.min(left.occupiedBits, right.size);
    int index = left.nextIndex - bitsToCopy;
    if (index < 0)
      index += left.occupiedBits;
    for (int i = 0; i < bitsToCopy; i++, index = left.indexAfter(index))
      right.setNext(left.bitSet.get(index));
  }
1297450
public static String combine(String left, String right, int minOverlap) {
    if (left.length() < minOverlap) return null;
    if (right.length() < minOverlap) return null;
    int bestOffset = Integer.MAX_VALUE;
    for (int offset = minOverlap - left.length(); offset < right.length() - minOverlap; offset++) {
      boolean match = true;
      for (int posLeft = Math.max(0, -offset); posLeft < Math.min(left.length(), right.length() - offset); posLeft++) {
        if (left.charAt(posLeft) != right.charAt(posLeft + offset)) {
          match = false;
          break;
        }
      }
      if (match) {
        if (Math.abs(bestOffset) > Math.abs(offset)) bestOffset = offset;
      }
    }
    if (bestOffset < Integer.MAX_VALUE) {
      String combined = left;
      if (bestOffset > 0) {
        combined = right.substring(0, bestOffset) + combined;
      }
      if (left.length() + bestOffset < right.length()) {
        combined = combined + right.substring(left.length() + bestOffset);
      }
      return combined;
    }
    else {
      return null;
    }
  }
188915
public static Boolean and(Object left, Object right) {
        return (Boolean) InfixOpNode.and(left, right, null);
    }
563134
@Pure
	@Inline(value="($1 ^ $2)", constantExpression=true)
	public static int bitwiseXor(int a, int b) {
		return a ^ b;
	}
753971
public InclusMultiPos<E, L, R> inclus(Boolean left, Boolean right) {
		this.inclusive[0] = checkNotNull(left);
		this.inclusive[1] = checkNotNull(right);
		return this;
	}
1285302
void leftShift(int n) {
        /*
         * If there is enough storage space in this MutableBigInteger already
         * the available space will be used. Space to the right of the used
         * ints in the value array is faster to utilize, so the extra space
         * will be taken from the right if possible.
         */
        if (intLen == 0)
           return;
        int nInts = n >>> 5;
        int nBits = n&0x1F;
        int bitsInHighWord = BigInteger.bitLengthForInt(value[offset]);

        // If shift can be done without moving words, do so
        if (n <= (32-bitsInHighWord)) {
            primitiveLeftShift(nBits);
            return;
        }

        int newLen = intLen + nInts +1;
        if (nBits <= (32-bitsInHighWord))
            newLen--;
        if (value.length < newLen) {
            // The array must grow
            int[] result = new int[newLen];
            for (int i=0; i < intLen; i++)
                result[i] = value[offset+i];
            setValue(result, newLen);
        } else if (value.length - offset >= newLen) {
            // Use space on right
            for(int i=0; i < newLen - intLen; i++)
                value[offset+intLen+i] = 0;
        } else {
            // Must use space on left
            for (int i=0; i < intLen; i++)
                value[i] = value[offset+i];
            for (int i=intLen; i < newLen; i++)
                value[i] = 0;
            offset = 0;
        }
        intLen = newLen;
        if (nBits == 0)
            return;
        if (nBits <= (32-bitsInHighWord))
            primitiveLeftShift(nBits);
        else
            primitiveRightShift(32 -nBits);
    }
990647
function (operator, left, right) {
			var type = (operator === '||' || operator === '&&') ? LOGICAL_EXP : BINARY_EXP;
			return {
				type: type,
				operator: operator,
				left: left,
				right: right
			};
		}