Create a new Point operation expression

@param op operator
@param args arguments
@return operation expression
345932
public static JTSPointExpression<Point> pointOperation(Operator op, Expression<?>... args) {
        return new JTSPointOperation<Point>(Point.class, op, args);
    }
564131
function createOperatorNode(operand, nodes = []) {
  return (scope, opts) => {
    const args = nodes.map(node => node(scope, opts));

    if (typeof operand === 'function') {
      return operand(...args);
    }

    const operator = get(opts.functions, operand);

    if (!operator) {
      throw new ReferenceError(`Function '${operand}' isn't declared`);
    }

    return operator(...args);
  };
}
1275602
public static <T extends Comparable<?>> DateTimeOperation<T> dateTimeOperation(Class<? extends T> type,
            Operator operator, Expression<?>... args) {
        return new DateTimeOperation<T>(type, operator, args);
    }
168242
@javax.annotation.Nonnull
  public static double[] op(@javax.annotation.Nonnull final double[] a, @javax.annotation.Nonnull final double[] b, @javax.annotation.Nonnull final DoubleBinaryOperator fn) {
    assert a.length == b.length;
    @javax.annotation.Nonnull final double[] c = new double[a.length];
    for (int j = 0; j < a.length; j++) {
      c[j] = fn.applyAsDouble(a[j], b[j]);
    }
    return c;
  }
1310310
public static <T> Operation<T> operation(Class<? extends T> type, Operator operator,
                                             Expression<?>... args) {
        return operation(type, operator, ImmutableList.copyOf(args));
    }
1320634
public static <X> IteratorFromReaderFactory<X> getFactory(Function<String,X> op) {
    return new LineIteratorFactory<X>(op);
  }
107482
def annotate_op(self, op):
        

        if isinstance(op, Label):
            return op
        else:
            return AnnotatedOp(self, op.name, op.arg)
388035
public static ModelNode createOperation(final String operation) {
        final ModelNode op = new ModelNode();
        op.get(OP).set(operation);
        op.get(OP_ADDR).setEmptyList();
        return op;
    }
727524
public static ModelNode getOperationAddress(final ModelNode op) {
        return op.hasDefined(OP_ADDR) ? op.get(OP_ADDR) : new ModelNode();
    }
429288
public PointExpression<Point> pointN(int idx) {
        return GeometryExpressions.pointOperation(SpatialOps.POINTN, mixin, ConstantImpl.create(idx));
    }
39332
@SuppressWarnings("unchecked")
    public static <T> Operation<T> operation(Class<? extends T> type, Operator operator,
                                             ImmutableList<Expression<?>> args) {
        if (type.equals(Boolean.class)) {
            return (Operation<T>) new PredicateOperation(operator, args);
        } else {
            return new OperationImpl<T>(type, operator, args);
        }
    }
1151339
public Point createPoint(Coordinate coordinate) {
		if (coordinate == null) {
			return new Point(srid, precision);
		}
		return new Point(srid, precision, coordinate.getX(), coordinate.getY());
	}
884920
public SDVariable invoke(Op op, SDVariable x) {
        return invoke(op, x, null);
    }
1291306
function createRelationalOperation(operator) {
      return function(value, other) {
        if (!(typeof value == 'string' && typeof other == 'string')) {
          value = toNumber(value);
          other = toNumber(other);
        }
        return operator(value, other);
      };
    }
346310
public Map<RowColumn, Bytes> getOperationMap(LogEntry.Operation op) {
    Map<RowColumn, Bytes> opMap = new HashMap<>();
    for (LogEntry entry : logEntries) {
      if (entry.getOp().equals(op)) {
        opMap.put(new RowColumn(entry.getRow(), entry.getColumn()), entry.getValue());
      }
    }
    return opMap;
  }
1129748
private void addOp(String op, String path, String value) {
        if (this.operations == null) {
            this.operations = new JsonArray();
        }

        this.operations.add(new JsonObject()
                .add("op", op)
                .add("path", path)
                .add("value", value));
    }
562524
@SuppressWarnings("unchecked")
    private List<String> operations(Map<String, Object> ops) {
        List<String> result = new LinkedList<>();
        for (String operation : ops.keySet()) {
            Object operationOrListOfOperations = ops.get(operation);
            List<Map<String, Object>> toStringify;
            if (operationOrListOfOperations instanceof List) {
                toStringify = (List<Map<String, Object>>) operationOrListOfOperations;
            } else {
                toStringify = Collections.singletonList((Map<String, Object>) operationOrListOfOperations);
            }
            for (Map<String, Object> op : toStringify) {
                List<Map<String, String>> args = (List<Map<String, String>>) op.get("args");
                result.add(operation + "(" + argsToString(args) + ")");
            }
        }

        return result;
    }