The actual infinite loop for this transformation.
548678
def loop(self):
        
        logger.debug("Node loop starts for {!r}.".format(self))

        while self.should_loop:
            try:
                self.step()
            except InactiveReadableError:
                break

        logger.debug("Node loop ends for {!r}.".format(self))
955928
public static void transform(Atom[] ca, Matrix4d t) {
		for (Atom atom : ca)
			Calc.transform(atom, t);
	}
800998
def _iter(self, with_final=True):
        
        # MUST have called fit first
        stop = len(self.steps_)
        if not with_final:
            stop -= 1

        for idx, (name, trans) in enumerate(islice(self.steps_, 0, stop)):
            yield idx, name, trans
1019302
private void performTransformation(MutableRenderingContext renderingContext, Transformation transformation,
        TransformationContext context, Block block) throws MacroExecutionException
    {
        try {
            renderingContext.transformInContext(transformation, context, block);
        } catch (Exception e) {
            throw new MacroExecutionException("Failed to perform transformation", e);
        }
    }
978048
public static void multiplyRealComplex( GrayF realA ,
											ImageInterleaved complexB , ImageInterleaved complexC ) {
		if( complexB instanceof InterleavedF32 ) {
			DiscreteFourierTransformOps.multiplyRealComplex((GrayF32) realA, (InterleavedF32) complexB, (InterleavedF32) complexC);
		} else if( complexB instanceof InterleavedF64 ) {
			DiscreteFourierTransformOps.multiplyRealComplex((GrayF64) realA, (InterleavedF64) complexB, (InterleavedF64) complexC);
		} else {
			throw new IllegalArgumentException("Unknown image type");
		}
	}
1355111
public void exceptionShift() {
        numExceptional++;
        double mag = 0.05 * numExceptional;
        if (mag > 1.0) mag = 1.0;

        double angle = 2.0 * UtilEjml.PI * (rand.nextDouble() - 0.5) * mag;
        performImplicitSingleStep(0, angle, true);

        // allow more convergence time
        nextExceptional = steps + exceptionalThresh;  // (numExceptional+1)*
    }
1139288
function() {
			var context = this.loopContext;

			this.loopContext = context.upper;

			var forkContext = this.forkContext;
			var brokenForkContext = this.popBreakContext().brokenForkContext;
			var choiceContext;

			// Creates a looped path.
			switch (context.type) {
				case "WhileStatement":
				case "ForStatement":
					choiceContext = this.popChoiceContext();
					makeLooped(
						this,
						forkContext.head,
						context.continueDestSegments);
					break;

				case "DoWhileStatement":
					choiceContext = this.popChoiceContext();

					if (!choiceContext.processed) {
						choiceContext.trueForkContext.add(forkContext.head);
						choiceContext.falseForkContext.add(forkContext.head);
					}
					if (context.test !== true) {
						brokenForkContext.addAll(choiceContext.falseForkContext);
					}

					// `true` paths go to looping.
					var segmentsList = choiceContext.trueForkContext.segmentsList;

					for (var i = 0; i < segmentsList.length; ++i) {
						makeLooped(
							this,
							segmentsList[i],
							context.entrySegments);
					}
					break;

				case "ForInStatement":
				case "ForOfStatement":
					brokenForkContext.add(forkContext.head);
					makeLooped(
						this,
						forkContext.head,
						context.leftSegments);
					break;

					/* istanbul ignore next */
				default:
					throw new Error("unreachable");
			}

			// Go next.
			if (brokenForkContext.empty) {
				forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
			} else {
				forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
			}
		}
130706
def run_loop(self):
		""
		self.running = True
		event = SDL_Event()
		try:
			while self.running:
				while SDL_PollEvent(ctypes.byref(event)) != 0:
					f = self._sdl_event_handlers.get(event.type)
					if f is not None:
						f ( event )
				self.render_scene()
		except SdlAppQuit as e:
			pass
380349
@Override
	protected void doTransform(ITransformable.Scale transformable, float comp)
	{
		float fromX = reversed ? this.toX : this.fromX;
		float toX = reversed ? this.fromX : this.toX;
		float fromY = reversed ? this.toY : this.fromY;
		float toY = reversed ? this.fromY : this.toY;
		float fromZ = reversed ? this.toZ : this.fromZ;
		float toZ = reversed ? this.fromZ : this.toZ;

		transformable.scale(fromX + (toX - fromX) * comp, fromY + (toY - fromY) * comp, fromZ + (toZ - fromZ) * comp, offsetX, offsetY,
				offsetZ);
	}
787858
public static void loopFor(int start , int endExclusive , int step , IntConsumer consumer ) {
		try {
			int range = endExclusive-start;
			pool.submit(() ->IntStream.range(0, range/step).parallel().forEach(i-> consumer.accept(start+i*step))).get();
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}
1156252
def continuation(self, body=None, final=True):
        ''''''
        return self.encode(body, opcode=0, final=final)
608383
def _loop(self):
        
        self.stop_flag.value = False
        self.time_started.value = time()
        self.time_elapsed.value = 0

        while True:
            if self.stop_flag.value:
                break
            self.update_text()
            with self.time_started.get_lock():
                start = self.time_started.value
                with self.time_elapsed.get_lock():
                    self.time_elapsed.value = time() - start
                    if (
                            self.timeout.value and
                            (self.time_elapsed.value > self.timeout.value)):
                        self.stop()
                        raise ProgressTimedOut(
                            self.name,
                            self.time_elapsed.value,
                        )
89186
function applyTransforms(transforms, t, callback) {
  log.debug('applying', transforms.length, 'transforms');
  for (var i = 0; i < transforms.length; i++) {
    var transform = transforms[i];
    log.debug('next transform', transform);
    if (transform.isAsync) {
      // asynchronous case
      return transform(t, function(t) {
        // this is only called when the async transform was successful,
        // otherwise t.callback has already been called with an error.
        applyTransforms(transforms.slice(i + 1), t, callback);
      });
    } else {
      // synchronous case
      var result = transform(t);
      if (!result) {
        log.debug('transform has failed or was a final transform');
        // stop processing t.callback has already been called
        return;
      }
    }
  }
  log.debug('all transformations done, starting next step');
  if (nextTickAvailable) {
    return process.nextTick(function() {
      callback(t);
    });
  }
  return callback(t);
}
246856
def increment(self):
        ''''''

        for i in xrange(len(self._counter) - 1, -1, -1):
            self._counter[i] += 1

            if self._counter[i] < 256: break

            # Carry the one
            self._counter[i] = 0

        # Overflow
        else:
            self._counter = [ 0 ] * len(self._counter)
1299974
def _transform(self, data, transform, step_size):
    '''
    
    '''
    if callable(transform):
      data = transform(data, step_size)
    return data
1058597
function () {
        while (this.head !== null) {
            var temp = this.head;
            this.head = this.head.next();   // use next() the instead of "_next", otherwise it will loop forever
            temp._list = null;
            temp._next = null;
            temp._prev = null;
        }

        this.head = null;
        this.size = 0;
    }
571432
private function loop()
    {
        $c = $this->controller;

        if (is_callable([$c, 'throttle'])) {
            $throttle = function () use ($c) {
                return $c->throttle();
            };
        } else {
            $throttle = function () {
                return $this->throttle();
            };
        }

        // The entire runtime loop
        while ($c->signal()) {

            $c->process();
            
            time_nanosleep(0, $throttle());
        }
    }