Calculates the transformation

@param transformable the transformable
@param comp the comp
778722
@Override
	protected void doTransform(Size<T> transformable, float comp)
	{
		int fromWidth = reversed ? this.toWidth : this.fromWidth;
		int toWidth = reversed ? this.fromWidth : this.toWidth;
		int fromHeight = reversed ? this.toHeight : this.fromHeight;
		int toHeight = reversed ? this.fromHeight : this.toHeight;

		transformable.setSize((int) (fromWidth + (toWidth - fromWidth) * comp), (int) (fromHeight + (toHeight - fromHeight) * comp));
	}
257227
@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	protected void doTransform(ITransformable transformable, float comp)
	{
		if (listTransformations.size() == 0)
			return;

		if (reversed)
			elapsedTimeCurrentLoop = Math.max(0, duration - elapsedTimeCurrentLoop);
		for (Transformation transformation : listTransformations)
		{
			transformation.transform(transformable, elapsedTimeCurrentLoop);
			elapsedTimeCurrentLoop -= transformation.totalDuration();
		}
	}
635589
@Override
	protected void doTransform(ITransformable.Translate 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.translate(fromX + (toX - fromX) * comp, fromY + (toY - fromY) * comp, fromZ + (toZ - fromZ) * comp);
	}
604419
function transform(path) {
    if (shouldProcess(path)) {
        const renderer = Renderer.forPath(path);
        transformer(path.node, renderer, buildErrorHandler(path));
        // replace the render call if present, else replace the JSX
        if (Renderer.isParent(path)) {
            path.parentPath.replaceWith(renderer.toFunctionCall());
        } else {
            path.replaceWith(renderer.toFunctionCall());
        }
    }
}
407120
def apply(self, transformation, node):
        '''
        
        '''
        assert issubclass(transformation, (Transformation, Analysis))
        a = transformation()
        a.attach(self)
        res = a.apply(node)

        # the transformation updated the AST, so analyse may need to be rerun
        # we could use a finer-grain caching system, and provide a way to flag
        # some analyses as `unmodified' by the transformation, as done in LLVM
        # (and PIPS ;-)
        if a.update:
            self._cache.clear()
        return res
256864
private void add(Transform transform, MethodType target) {
        types.add(0, target);
        transforms.add(0, transform);
    }
410984
public static <T> void sort (List<T> a, Comparator<? super T> comp)
    {
        sort(a, 0, a.size() - 1, comp);
    }
388806
@Override
	protected void doTransform(ITransformable.Rotate transformable, float comp)
	{
		float from = reversed ? toAngle : fromAngle;
		float to = reversed ? fromAngle : toAngle;
		transformable.rotate(from + (to - from) * comp, axisX, axisY, axisZ, offsetX, offsetY, offsetZ);
	}
890333
public static <T> Comparator<T> inverse(final Comparator<T> baseComp)
  {
    return new Comparator<T>()
    {
      @Override
      public int compare(T t, T t1)
      {
        return baseComp.compare(t1, t);
      }
    };
  }
787514
def _transformBy(self, matrix, **kwargs):
        
        t = transform.Transform(*matrix)
        transformation = t.transform(self.transformation)
        self.transformation = tuple(transformation)
537450
public void transform(Tuple2D<?> tuple) {
		assert tuple != null : AssertMessages.notNullParameter();
		final double x = this.m00 * tuple.getX() + this.m01 * tuple.getY() + this.m02;
		final double y = this.m10 * tuple.getX() + this.m11 * tuple.getY() + this.m12;
		tuple.set(x, y);
	}
773679
public void transform(Source xmlSource, Result outputTarget, boolean shouldRelease)
          throws TransformerException
  {

    synchronized (m_reentryGuard)
    {
      SerializationHandler xoh = createSerializationHandler(outputTarget);
      this.setSerializationHandler(xoh);        

      m_outputTarget = outputTarget;

      transform(xmlSource, shouldRelease);
    }
  }
509244
public void registerTransform(String pattern, AbstractTransform transform) {
        transforms.add(new Transform(new WildcardFileFilter(pattern.split("\\,")), transform));
    }
1111053
function _transform() {
	var codeIn = $('#codeIn').val();
	try {
		var codeOut = Streamline.transform(codeIn, {
			runtime: _generators ? "generators" : "callbacks",
		});
		$('#codeOut').val(codeOut);
		info("ready");
	} catch (ex) {
		console.error(ex);
		error(ex.message);
	}
}
1074473
function transform(data, encoding, callback) {
    /* jshint validthis:true */

    // Ignore if killed
    /* istanbul ignore if */
    if (this._swiftTransform.killed) {
        return;
    }

    // Push the task
    this._swiftTransform.queue.push({ data: data, encoding: encoding }, transformDone.bind(this));

    // If we are not saturated, simply call more right away
    if (this._swiftTransform.queue.running() + this._swiftTransform.queue.length() < this._swiftTransform.queue.concurrency) {
        setImmediate(callback);
    // Otherwise store the callback because we will need it later
    } else {
        this._swiftTransform.callback = callback;
    }
}
143485
@Override
    protected Double transformToValue(DBObject dbObject) {
        DBObject valueObject = (DBObject) dbObject.get("value");
        Number t = (Number) valueObject.get("total");

        return t.doubleValue();
    }
684506
public static <K,V> MapFactory<K,V> tree(Comparator<K> comp) {
	return new TreeMapFactory<K,V>(comp);
    }