Returns a new Tms object obtained by memberwise operation +op+
 of the individual times for this Tms object with those of the other
 Tms object.

 +op+ can be a mathematical operation such as <tt>+</tt>, <tt>-</tt>,
 <tt>*</tt>, <tt>/</tt>
426292
def memberwise(op, x)
      case x
      when Benchmark::Tms
        Benchmark::Tms.new(utime.__send__(op, x.utime),
                           stime.__send__(op, x.stime),
                           cutime.__send__(op, x.cutime),
                           cstime.__send__(op, x.cstime),
                           real.__send__(op, x.real)
                           )
      else
        Benchmark::Tms.new(utime.__send__(op, x),
                           stime.__send__(op, x),
                           cutime.__send__(op, x),
                           cstime.__send__(op, x),
                           real.__send__(op, x)
                           )
      end
    end
740835
def Itax(mt, x, t):
    
    return (Sx(mt, x + 1) - Sx(mt, x + t + 1)) / Dx(mt, x)
897517
def _get_new_block_mem_instance(op_param, mem_map, block_out):
    
    memid, old_mem = op_param
    if old_mem not in mem_map:
        new_mem = old_mem._make_copy(block_out)
        new_mem.id = old_mem.id
        mem_map[old_mem] = new_mem
    return memid, mem_map[old_mem]
119972
def from_symmop(cls, symmop, time_reversal):
        
        magsymmop = cls(symmop.affine_matrix, time_reversal, symmop.tol)
        return magsymmop
485666
public static tmsessionparameter get(nitro_service service) throws Exception{
		tmsessionparameter obj = new tmsessionparameter();
		tmsessionparameter[] response = (tmsessionparameter[])obj.get_resources(service);
		return response[0];
	}
739093
def combine(operator, other)
      if other.respond_to?(:composition) && compatible_with?(other)
        new(value.send(operator, other.convert_to(unit).value), unit)
      end
    end
892533
def _arithmetic_operation(self, other, operation):
        
        if isinstance(other, Trajectory):
            if self.description != other.description:
                raise Exception("Cannot add trajectories with different descriptions")
            if not np.array_equal(self.timepoints, other.timepoints):
                raise Exception("Cannot add trajectories with different time points")
            new_values = operation(self.values, other.values)
        elif isinstance(other, numbers.Real):
            new_values = operation(self.values, float(other))
        else:
            raise Exception("Arithmetic operations is between two `Trajectory` objects or a `Trajectory` and a scalar.")

        return Trajectory(self.timepoints, new_values, self.description)
996181
public Operator createOperator(int op, Selector operand)
  {
	Operator operator = new OperatorImpl(op, operand);

	return operator; 
  }
373124
@Override
    public final <T extends TimePoint<? super U, T>> T addTo(T time) {

        return this.add(time, this, false);

    }
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);
      };
    }
1170890
public Date getTo() {
        Long to = null;
        for (final TimeInterval interval : intervals) {
            if (to == null) {
                to = interval.getTo();
            } else {
                to = Math.max(interval.getTo(), to);
            }
        }
        if (to != null) {
            return new Date(to);
        }
        return null;
    }
923351
def all_operations(self) -> Iterator[ops.Operation]:
        
        return (op for moment in self for op in moment.operations)
1144695
def operate(operator, other)
      exp = operator == '/' ? -1 : 1
      if other.respond_to?(:terms)
        Unit.new(other.terms.map { |t| t ** exp } << self)
      elsif other.respond_to?(:atom)
        Unit.new([self, other ** exp])
      elsif other.is_a?(Numeric)
        self.class.new(to_hash.merge(:factor => factor.send(operator, other)))
      end
    end
677942
public Operation zCombinedAnd(Operation op)
    {
        if (op instanceof IsNotNullOperation)
        {
            return zCombineWithNotNullOperation((IsNotNullOperation) op);
        }
        if (op instanceof IsNullOperation)
        {
            return zCombineWithNullOperation((IsNullOperation) op);
        }
        return op.zCombinedAnd(this);
    }
112805
public SingleOutputStreamOperator<T> sum(int positionToSum) {
		return aggregate(new SumAggregator<>(positionToSum, input.getType(), input.getExecutionConfig()));
	}
723771
def +(other)
      if other.is_a?(Volt::Duration)
        Volt::Duration.new(value + other.value, parts + other.parts)
      else
        Volt::Duration.new(value + other, parts + [[:seconds, other]])
      end
    end
751075
public double totalTime(TimeUnit unit) {
        T obj2 = ref.get();
        if (obj2 != null) {
            double prevLast = lastTime;
            lastTime = Math.max(TimeUtils.convert(totalTimeFunction.applyAsDouble(obj2), totalTimeFunctionUnit, baseTimeUnit()), 0);
            total.getCurrent().add(lastTime - prevLast);
        }
        return TimeUtils.convert(total.poll(), baseTimeUnit(), unit);
    }