Exclusive-or

@param aLeft
lhs
@param aRight
rhs
@return operator
494000
@Nonnull
  public static JSOpBinary xor (@Nonnull final IJSExpression aLeft, @Nonnull final IJSExpression aRight)
  {
    return new JSOpBinary (aLeft, "^", aRight);
  }
671671
private boolean voltConvertBinaryIntegerLiteral(Session session, Expression lhs, Expression rhs) {
        Expression nonIntegralExpr;
        int whichChild;
        if (lhs.dataType.isIntegralType()) {
            nonIntegralExpr = rhs;
            whichChild = RIGHT;
        }
        else if (rhs.dataType.isIntegralType()) {
            nonIntegralExpr = lhs;
            whichChild = LEFT;
        } else {
            return false;
        }

        return ExpressionValue.voltMutateToBigintType(nonIntegralExpr, this, whichChild);
    }
541385
public void apairs_from_idxlst(JointFragments jf) {
		List<int[]> il = jf.getIdxlist();
		//System.out.println("Alt Alig apairs_from_idxlst");

		aligpath = new IndexPair[il.size()];
		idx1 = new int[il.size()];
		idx2 = new int[il.size()];
		for (int i =0 ; i < il.size();i++) {
			int[] p = il.get(i);
			//System.out.print(" idx1 " + p[0] + " idx2 " + p[1]);
			idx1[i] = p[0];
			idx2[i] = p[1];
			aligpath[i] = new IndexPair((short)p[0],(short)p[1]);

		}
		eqr0  = idx1.length;
		//System.out.println("eqr " + eqr0);
		gaps0 = count_gaps(idx1,idx2);

	}
1118805
@Nonnull
  public IMPLTYPE arg (@Nonnegative final int nIndex, @Nonnull final IJSExpression aArgument)
  {
    ValueEnforcer.notNull (aArgument, "Argument");
    m_aArgs.add (nIndex, aArgument);
    return _thisAsT ();
  }
8082
public static Boolean or(Boolean a,Boolean b) 
  {
  	return orTable[ttIndex(a)][ttIndex(b)];
  }
456990
final public void Or() throws ParseException {
    And();
    label_7:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OR0:
      case OR1:
        ;
        break;
      default:
        jj_la1[10] = jj_gen;
        break label_7;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OR0:
        jj_consume_token(OR0);
        break;
      case OR1:
        jj_consume_token(OR1);
        break;
      default:
        jj_la1[11] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
                           AstOr jjtn001 = new AstOr(JJTOR);
                           boolean jjtc001 = true;
                           jjtree.openNodeScope(jjtn001);
      try {
        And();
      } catch (Throwable jjte001) {
                           if (jjtc001) {
                             jjtree.clearNodeScope(jjtn001);
                             jjtc001 = false;
                           } else {
                             jjtree.popNode();
                           }
                           if (jjte001 instanceof RuntimeException) {
                             {if (true) throw (RuntimeException)jjte001;}
                           }
                           if (jjte001 instanceof ParseException) {
                             {if (true) throw (ParseException)jjte001;}
                           }
                           {if (true) throw (Error)jjte001;}
      } finally {
                           if (jjtc001) {
                             jjtree.closeNodeScope(jjtn001,  2);
                           }
      }
    }
  }
555111
public EqualsBuilder append(final Object lhs, final Object rhs) {
        if (isEquals == false) {
            return this;
        }
        if (lhs == rhs) {
            return this;
        }
        if (lhs == null || rhs == null) {
            this.setEquals(false);
            return this;
        }
        final Class<?> lhsClass = lhs.getClass();
        if (!lhsClass.isArray()) {
            // The simple case, not an array, just test the element
            isEquals = lhs.equals(rhs);
        } else if (lhs.getClass() != rhs.getClass()) {
            // Here when we compare different dimensions, for example: a boolean[][] to a boolean[]
            this.setEquals(false);
        }
        // 'Switch' on type of array, to dispatch to the correct handler
        // This handles multi dimensional arrays of the same depth
        else if (lhs instanceof long[]) {
            append((long[]) lhs, (long[]) rhs);
        }
157801
Expr or() {
		Expr expr = and();
		for (Tok tok=peek(); tok.sym==Sym.OR; tok=peek()) {
			move();
			expr = new Logic(Sym.OR, expr, and(), location);
		}
		return expr;
	}
1250456
def _has_exclusive_option(cls, options):
        """"""
        return any([getattr(options, opt) is not None for opt in
                    cls.BASE_ERROR_SELECTION_OPTIONS])
784139
public ExpressionBuilder or() {
		GroupExpression lastGroupExpression = stack.isEmpty() ? null : stack.peek();

		if (lhsExpression == null) {
			throw new SyntaxException("Syntax exception: OR missing LHS operand");
		} else if (lastGroupExpression == null) {
			GroupExpression or = new GroupExpression(GroupExpression.Type.OR);
			or.add(lhsExpression);
			stack.push(or);
			expression.setExpression(or);
			lhsExpression = null;
		} else if (lastGroupExpression.getType().equals(GroupExpression.Type.OR)) {
			// Keep using the existing OR
			lhsExpression = null;
			return this;
		} else if (lastGroupExpression.getType().equals(GroupExpression.Type.AND)) {
			// AND takes precedence over OR, so we wrap the AND
			// by removing it from any parent expressions and inserting the OR in its place

			GroupExpression and = stack.pop();
			GroupExpression or = new GroupExpression(GroupExpression.Type.OR);

			if (stack.isEmpty()) {
				expression.setExpression(or);
				or.add(and);
			} else {
				// need to get at the parent
				GroupExpression parent = stack.pop();
				parent.remove(and);
				parent.add(or);
				or.add(and);
			}

			stack.push(and);
			stack.push(or);
			lhsExpression = null;
		}

		return this;
	}
1143611
public static void oddEvenSort( double arrayToBeSorted[], double[] arrayThatFollowsTheSort ) {
        for( int i = 0; i < arrayToBeSorted.length / 2; i++ ) {
            for( int j = 0; j + 1 < arrayToBeSorted.length; j += 2 )
                if (arrayToBeSorted[j] > arrayToBeSorted[j + 1]) {
                    double tmpa = arrayToBeSorted[j];
                    arrayToBeSorted[j] = arrayToBeSorted[j + 1];
                    arrayToBeSorted[j + 1] = tmpa;
                    if (arrayThatFollowsTheSort != null) {
                        double tmpb = arrayThatFollowsTheSort[j];
                        arrayThatFollowsTheSort[j] = arrayThatFollowsTheSort[j + 1];
                        arrayThatFollowsTheSort[j + 1] = tmpb;
                    }
                }
            for( int j = 1; j + 1 < arrayToBeSorted.length; j += 2 )
                if (arrayToBeSorted[j] > arrayToBeSorted[j + 1]) {
                    double tmpa = arrayToBeSorted[j];
                    arrayToBeSorted[j] = arrayToBeSorted[j + 1];
                    arrayToBeSorted[j + 1] = tmpa;
                    if (arrayThatFollowsTheSort != null) {
                        double tmpb = arrayThatFollowsTheSort[j];
                        arrayThatFollowsTheSort[j] = arrayThatFollowsTheSort[j + 1];
                        arrayThatFollowsTheSort[j + 1] = tmpb;
                    }
                }
        }
    }
75290
public static <T extends Comparable<T>> T max(T lhs, T rhs) {
        return BinaryOperator.maxBy(new ComparableComparator<T>()).apply(lhs, rhs);
    }
836996
private void alk(final EncodingResult result, final Variable[] vars, int rhs) {
    if (rhs < 0)
      throw new IllegalArgumentException("Invalid right hand side of cardinality constraint: " + rhs);
    if (rhs > vars.length) {
      result.addClause();
      return;
    }
    if (rhs == 0)
      return;
    if (rhs == 1) {
      result.addClause((Literal[]) vars);
      return;
    }
    if (rhs == vars.length) {
      for (final Variable var : vars)
        result.addClause(var);
      return;
    }
    switch (this.config().alkEncoder) {
      case TOTALIZER:
        if (this.alkTotalizer == null)
          this.alkTotalizer = new CCALKTotalizer();
        this.alkTotalizer.build(result, vars, rhs);
        break;
      case MODULAR_TOTALIZER:
        if (this.alkModularTotalizer == null)
          this.alkModularTotalizer = new CCALKModularTotalizer(this.f);
        this.alkModularTotalizer.build(result, vars, rhs);
        break;
      case CARDINALITY_NETWORK:
        if (this.alkCardinalityNetwork == null)
          this.alkCardinalityNetwork = new CCALKCardinalityNetwork();
        this.alkCardinalityNetwork.build(result, vars, rhs);
        break;
      case BEST:
        this.bestALK(vars.length).build(result, vars, rhs);
        break;
      default:
        throw new IllegalStateException("Unknown at-least-k encoder: " + this.config().alkEncoder);
    }
  }
1244331
public static DepIoChart insideOutsideSingleRoot(double[] fracRoot, double[][] fracChild) {
        final boolean singleRoot = true;        
        return insideOutside(fracRoot, fracChild, singleRoot);
    }
109293
public static BooleanExpression anyOf(BooleanExpression... exprs) {
        BooleanExpression rv = null;
        for (BooleanExpression b : exprs) {
            rv = rv == null ? b : rv.or(b);
        }
        return rv;
    }
1107876
final public Selector BooleanExpr() throws ParseException {
                           Selector left, right=null;
    left = BooleanTerm();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case OR:
      jj_consume_token(OR);
      right = BooleanExpr();
      break;
    default:
      jj_la1[0] = jj_gen;
      ;
    }
    if (right == null) {if (true) return left;}
    else {if (true) return new OperatorImpl(Operator.OR, left, right);}
    throw new Error("Missing return statement in function");
  }
413563
public static void or(byte[] map, int pos, byte source, int count) {

        int shift = pos & 0x07;
        int mask  = (source & 0xff) >>> shift;
        int index = pos / 8;

        if (index >= map.length) {
            return;
        }

        byte b = (byte) (map[index] | mask);

        map[index] = b;

        if (shift == 0) {
            return;
        }

        shift = 8 - shift;

        if (count > shift) {
            mask           = ((source & 0xff) << 8) >>> shift;
            b              = (byte) (map[index + 1] | mask);
            map[index + 1] = b;
        }
    }