Returns the string name for this operator.
@param op the token type, e.g. {@link Token#ADD} or {@link Token#TYPEOF}
@return the source operator string, such as "+" or "typeof"
420695
public static String operatorToString(int op) {
        String result = operatorNames.get(op);
        if (result == null)
            throw new IllegalArgumentException("Invalid operator: " + op);
        return result;
    }
938417
public static String getModuleNameFor(Op op) {
        //String functionName = op instanceof TransformOp || op instanceof ReduceOp || op instanceof IndexAccumulation ? op.opName() + "_strided" : op.opName();
        String moduleName = null;
        if (op instanceof ReduceOp) {

            moduleName = "reduce";

            // FIXME: special case for reduce3
            if (op.opName().equals("cosinesimilarity")) {
                moduleName = "reduce3";
            } else if (op.opName().equals("euclidean")) {
                moduleName = "reduce3";
            } else if (op.opName().equals("manhattan")) {
                moduleName = "reduce3";
            }

        } else if (op instanceof TransformOp) {
            // FIXME: we need special case for pairwise transforms for now. Later we should make them separate kernel call
            if (op.opName().equals("add")) {
                moduleName = "pairWiseTransform";
            } else if (op.opName().equals("copy")) {
                moduleName = "pairWiseTransform";
            } else if (op.opName().equals("div")) {
                moduleName = "pairWiseTransform";
            } else if (op.opName().equals("mul")) {
                moduleName = "pairWiseTransform";
            } else if (op.opName().equals("rdiv")) {
                moduleName = "pairWiseTransform";
            } else if (op.opName().equals("rsub")) {
                moduleName = "pairWiseTransform";
            } else if (op.opName().equals("sub")) {
                moduleName = "pairWiseTransform";

            } else {
                moduleName = "transform";
            }
        } else if (op instanceof ScalarOp) {
            moduleName = "scalar";
        } else if (op instanceof BroadcastOp) {
            moduleName = "broadcast";
        } else if (op instanceof IndexAccumulation) {
            moduleName = "indexReduce";
        }
        return moduleName;
    }
452424
public com.google.protobuf.ByteString
      getOpBytes() {
    java.lang.Object ref = op_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      op_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
610973
static String opToStrNoFail(Token operator) {
    String res = opToStr(operator);
    if (res == null) {
      throw new Error("Unknown op " + operator);
    }
    return res;
  }
22655
public static String prettyType(BtrpOperand o) {
        if (o == IgnorableOperand.getInstance()) {
            return "??";
        }
        return prettyType(o.degree(), o.type());
    }
645101
public String getExpressionString() {
        StringBuffer buf = new StringBuffer();
        buf.append("(");
        if (mOperator != null) {
            buf.append(mOperator.getOperatorSymbol());
            buf.append(" ");
        } else {
            for (int i = 0; i < mOperators.size(); i++) {
                UnaryOperator operator = (UnaryOperator) mOperators.get(i);
                buf.append(operator.getOperatorSymbol());
                buf.append(" ");
            }
        }
        buf.append(mExpression.getExpressionString());
        buf.append(")");
        return buf.toString();
    }
1058343
private static String validateOperator(final String operator) {
        if (!OPERATORS.contains(operator) && !BOOLEAN_OPERATORS.contains(operator)) {
            throw new CitrusRuntimeException("Unknown operator '" + operator + "'");
        }
        return operator;
    }
897986
def operatorLabel( self, operator ):
        
        for key, value in self._operatorMap.items():
            if ( value == operator ):
                return key
        return operator
1007104
function xop_operation_to_assembly_opcode_string(opcode) {
  for (let instr of Object.keys(OP_ADDR_MODE_TO_XOP)) {
    let allowed_addressing_modes = OP_ADDR_MODE_TO_XOP[instr];
    for (let addressing_mode of Object.keys(allowed_addressing_modes)) {
      let this_xop_operation = allowed_addressing_modes[addressing_mode];

      if (XOP[opcode] === this_xop_operation) {
        return instr;
      }
    }
  }
  return undefined;
}
847839
public String findStringValue(JvmAnnotationTarget op, Class<? extends Annotation> annotationType) {
		final JvmAnnotationReference reference = this.lookup.findAnnotation(op, annotationType);
		if (reference != null) {
			return findStringValue(reference);
		}
		return null;
	}
598288
private static Double getOperandAsNumeric(String op) {
        Double d = null;
        try {
            d = Double.valueOf(op);
        } catch (Exception e) {
            // Null is returned if not numeric.
        }
        return d;
    }
327546
@Pure /* not guaranteed pure , since toString() is invoked on the argument a*/
	@Inline("($1 + $2)")
	public static String operator_plus(Object a, String b) {
		return a + b;
	}
651079
private String consJobName(String opName, String... args) {
		StringBuilder b = new StringBuilder();
		b.append(opName + "(");
		for(int i = 0; i < args.length; i++) {
			if(i > 0) b.append(", ");
			b.append(args[i]);
		}
		b.append(")");
		return b.toString();
	}
1252992
public List<Integer> findIntValues(JvmAnnotationTarget op, Class<? extends Annotation> annotationType) {
		final JvmAnnotationReference reference = this.lookup.findAnnotation(op, annotationType);
		if (reference != null) {
			return findIntValues(reference);
		}
		return null;
	}
1038060
protected String naryOperator(final NAryOperator operator, final String opString) {
        final StringBuilder sb = new StringBuilder();
        int count = 0;
        final int size = operator.numberOfOperands();
        Formula last = null;
        for (final Formula op : operator) {
            if (++count == size) {
                last = op;
            } else {
                sb.append(operator.type().precedence() < op.type().precedence() ? this.toString(op) : this.bracket(op));
                sb.append(opString);
            }
        }
        if (last != null) {
            sb.append(operator.type().precedence() < last.type().precedence() ? this.toString(last) : this.bracket(last));
        }
        return sb.toString();
    }
181940
public ExpressionBuilder operator(Operator operator) {
        this.checkOperatorSymbol(operator);
        this.userOperators.put(operator.getSymbol(), operator);
        return this;
    }
468978
SimpleProxyId<BaseProxy> getId(final IdMessage op) {
    if (Strength.SYNTHETIC.equals(op.getStrength())) {
      return this.allocateSyntheticId(op.getTypeToken(), op.getSyntheticId());
    }
    return this.state.requestFactory.getId(op.getTypeToken(), op.getServerId(), op.getClientId());
  }