Demonstration of transfering to another number
972079
def TransferDemo(handler, t):
    
    t.say ("One moment please.")
    t.transfer(MY_PHONE)
    t.say("Hi. I am a robot")
    json = t.RenderJson()
    logging.info ("TransferDemo json: %s" % json)
    handler.response.out.write(json)
1077982
def increment(self, member, amount=1):
        """"""
        return self.client.zincrby(self.name, member, amount)
182930
function MeetmeUnmute(meetme, usernum) {
  MeetmeUnmute.super_.call(this, 'MeetmeUnmute');
  this.set('Meetme', meetme);
  this.set('Usernum', usernum);
}
301788
def swap(self):
        """"""
        self.xmin, self.ymin = self.ymin, self.xmin
        self.xmax, self.ymax = self.ymax, self.xmax
571265
function createOutTransfer (dappId, transactionId, recipientId, amount, secret, secondSecret, timeOffset) {
	var now = new Date().getTime();
	var time = timeOffset ? now - timeOffset : now;
	var keys = crypto.getKeys(secret);

	var transaction = {
		type: 7,
		amount: amount,
		fee: constants.fees.send,
		recipientId: recipientId,
		senderPublicKey: keys.publicKey,
		timestamp: slots.getTime(time),
		asset: {
			outTransfer: {
				dappId: dappId,
				transactionId: transactionId,
			},
		},
	};

	crypto.sign(transaction, keys);

	if (secondSecret) {
		var secondKeys = crypto.getKeys(secondSecret);
		crypto.secondSign(transaction, secondKeys);
	}

	return transaction;
}
937718
def increment(self, amount=1):
        
        self.__lock.acquire()
        self.__count += amount
        v = self.value()
        self.__lock.release()
        return v
1038855
function convertOnes(num) {
  if (str(num).length > 1) {
    throw new Error("Must have at most 1 digit");
  }

  num = int(num);
  return mapOnes[num];
}
771113
@Override
	public void transferTo(Decoder newDecoder) {
		super.transferTo(newDecoder);
		if (remainingBytesLength > 0) {
			if (currentBuffer == null || !currentBuffer.hasRemaining())
				currentBuffer = ByteBuffer.wrap(remainingBytes, 0, remainingBytesLength);
			else {
				byte[] b = new byte[remainingBytesLength + currentBuffer.remaining()];
				System.arraycopy(remainingBytes, 0, b, 0, remainingBytesLength);
				currentBuffer.get(b, remainingBytesLength, currentBuffer.remaining());
				currentBuffer = ByteBuffer.wrap(b);
			}
		}
	}
452374
def advance_by(self, amount):
        
        if amount < 0:
            raise ValueError("cannot retreat time reference: amount {} < 0"
                             .format(amount))
        self.__delta += amount
347079
function(amount) {
      for (var sI = 0; sI < this.slices.length; sI++)
        this.slices[sI].start = (this.slices[sI].start + amount);
      for (var id in this.counters)
        this.counters[id].shiftTimestampsForward(amount);
    }
997086
function fromNumber(num){
    return Lam(Lam((function go(n){return n===0?Var(0):App(Var(1),go(n-1))})(num)));
  }
1079726
def _expand_for_carryover(max_vol, plan, **kwargs):
    
    max_vol = float(max_vol)
    carryover = kwargs.get('carryover', True)
    if not carryover:
        return plan
    new_transfer_plan = []
    for p in plan:
        source = p['aspirate']['location']
        target = p['dispense']['location']
        volume = float(p['aspirate']['volume'])
        while volume > max_vol * 2:
            new_transfer_plan.append({
                'aspirate': {'location': source, 'volume': max_vol},
                'dispense': {'location': target, 'volume': max_vol}
            })
            volume -= max_vol

        if volume > max_vol:
            volume /= 2
            new_transfer_plan.append({
                'aspirate': {'location': source, 'volume': float(volume)},
                'dispense': {'location': target, 'volume': float(volume)}
            })
        new_transfer_plan.append({
            'aspirate': {'location': source, 'volume': float(volume)},
            'dispense': {'location': target, 'volume': float(volume)}
        })
    return new_transfer_plan
621599
private <IN1, IN2, OUT> Collection<Integer> transformTwoInputTransform(TwoInputTransformation<IN1, IN2, OUT> transform) {

		Collection<Integer> inputIds1 = transform(transform.getInput1());
		Collection<Integer> inputIds2 = transform(transform.getInput2());

		// the recursive call might have already transformed this
		if (alreadyTransformed.containsKey(transform)) {
			return alreadyTransformed.get(transform);
		}

		List<Integer> allInputIds = new ArrayList<>();
		allInputIds.addAll(inputIds1);
		allInputIds.addAll(inputIds2);

		String slotSharingGroup = determineSlotSharingGroup(transform.getSlotSharingGroup(), allInputIds);

		streamGraph.addCoOperator(
				transform.getId(),
				slotSharingGroup,
				transform.getCoLocationGroupKey(),
				transform.getOperator(),
				transform.getInputType1(),
				transform.getInputType2(),
				transform.getOutputType(),
				transform.getName());

		if (transform.getStateKeySelector1() != null || transform.getStateKeySelector2() != null) {
			TypeSerializer<?> keySerializer = transform.getStateKeyType().createSerializer(env.getConfig());
			streamGraph.setTwoInputStateKey(transform.getId(), transform.getStateKeySelector1(), transform.getStateKeySelector2(), keySerializer);
		}

		streamGraph.setParallelism(transform.getId(), transform.getParallelism());
		streamGraph.setMaxParallelism(transform.getId(), transform.getMaxParallelism());

		for (Integer inputId: inputIds1) {
			streamGraph.addEdge(inputId,
					transform.getId(),
					1
			);
		}

		for (Integer inputId: inputIds2) {
			streamGraph.addEdge(inputId,
					transform.getId(),
					2
			);
		}

		return Collections.singleton(transform.getId());
	}
601217
void pass_2(int fi, 
	      float in[],  int in0, int istride,
	      float out[], int out0, int ostride,
	      int sign, int product) {
    int k, k1;

    int factor = 2;
    int m = n / factor;
    int q = n / product;
    int product_1 = product / factor;

    int di = istride * m;
    int dj = ostride * product_1;
    int i = in0, j = out0;
    float x_real, x_imag;
    for (k = 0; k < q; k++) {
      float twids[] = twiddle[fi][k];
      float w_real =       twids[0];
      float w_imag = -sign*twids[1];

      for (k1 = 0; k1 < product_1; k1++) {
	float z0_real = in[i];
	float z0_imag = in[i+1];
	float z1_real = in[i+di];
	float z1_imag = in[i+di+1];
	i += istride;

	/* compute x = W(2) z */

	/* apply twiddle factors */
	  
	/* out0 = 1 * (z0 + z1) */
	out[j]   = z0_real + z1_real;
	out[j+1] = z0_imag + z1_imag;
	  
	/* out1 = w * (z0 - z1) */
	x_real = z0_real - z1_real;
	x_imag = z0_imag - z1_imag;
	out[j+dj]   = w_real * x_real - w_imag * x_imag;
	out[j+dj+1] = w_real * x_imag + w_imag * x_real;
	  
	j += ostride;
      }
      j += (factor-1)*dj;
    }}
554342
public TimestampInterval move(
        long amount,
        IsoUnit unit
    ) {

        if (amount == 0) {
            return this;
        }

        Boundary<PlainTimestamp> s;
        Boundary<PlainTimestamp> e;

        if (this.getStart().isInfinite()) {
            s = Boundary.infinitePast();
        } else {
            s =
                Boundary.of(
                    this.getStart().getEdge(),
                    this.getStart().getTemporal().plus(amount, unit));
        }

        if (this.getEnd().isInfinite()) {
            e = Boundary.infiniteFuture();
        } else {
            e =
                Boundary.of(
                    this.getEnd().getEdge(),
                    this.getEnd().getTemporal().plus(amount, unit));
        }

        return new TimestampInterval(s, e);

    }
388732
private int transfer(int state, int[] ids)
    {
        for (int c : ids)
        {
            if ((getBase(state) + c < getBaseArraySize())
                && (getCheck(getBase(state) + c) == state))
            {
                state = getBase(state) + c;
            }
            else
            {
                return -1;
            }
        }
        return state;
    }
305978
@Override
    void transfer(HashMapPro.Entry[] newTable) {
	int newCapacity = newTable.length;
	for (Entry<K, V> e = header.after; e != header; e = e.after) {
	    // if (rehash)
	    // e.hash = (e.key == null) ? 0 : hash(e.key);
	    int index = indexFor(e.hash, newCapacity);
	    e.next = newTable[index];
	    newTable[index] = e;
	}
    }