Translation verticale / Renvoie la translation verticale (appel sans argument).
@param y translation verticale
@returns {Matrix} nouvelle instance
542038
function(y) {
            
            if (y == null) return this.decompose(this.mtx).translateY;
            
            return new Matrix(this.mtx && this.mtx.translate(0,y));
        }
475261
def translate(line, ascent, offs=0):
    
    # TODO: why do I have thuis factor here?
    ascent *= -2
    offs *= -2

    l0 = length(line)

    # change relative to line:
    t0 = offs  # -h+offs
    t1 = l0 * ascent + offs
    return translate2P(line, t0, t1)
293067
function getTranslateValue(direction, node) {
  const rect = node.getBoundingClientRect();

  let transform;

  if (node.fakeTransform) {
    transform = node.fakeTransform;
  } else {
    const computedStyle = window.getComputedStyle(node);
    transform =
      computedStyle.getPropertyValue('-webkit-transform') ||
      computedStyle.getPropertyValue('transform');
  }

  let offsetX = 0;
  let offsetY = 0;

  if (transform && transform !== 'none' && typeof transform === 'string') {
    const transformValues = transform
      .split('(')[1]
      .split(')')[0]
      .split(',');
    offsetX = parseInt(transformValues[4], 10);
    offsetY = parseInt(transformValues[5], 10);
  }

  if (direction === 'left') {
    return `translateX(100vw) translateX(-${rect.left - offsetX}px)`;
  }

  if (direction === 'right') {
    return `translateX(-${rect.left + rect.width + GUTTER - offsetX}px)`;
  }

  if (direction === 'up') {
    return `translateY(100vh) translateY(-${rect.top - offsetY}px)`;
  }

  // direction === 'down'
  return `translateY(-${rect.top + rect.height + GUTTER - offsetY}px)`;
}
202575
public Matrix4d translation(Vector3dc offset) {
        return translation(offset.x(), offset.y(), offset.z());
    }
807906
public void translate(float x, float y, float z) {
        NativeTransform.translate(getNative(), x, y, z);
    }
412544
public function translate($x, $y)
    {
        if(!$x && !$y)
        {
            return $this;
        }
        
        for($i=0; $i<$this->numberOfPoints; $i++)
        {
            $this->points[$i] = $this->points[$i]->translate($x, $y);
        }

        return $this;
    }
1359190
def _translate(self, x, y):
        """"""
        # we add our position relative to our parent and then call then next parent up
        return self.parent._translate((x + self.x), (y + self.y))
1297912
public void translate(float x, float y, float z) {
        getTransform().translate(x, y, z);
        if (mTransformCache.translate(x, y, z)) {
            onTransformChanged();
        }
    }
1297356
def translate(translationAmt):
        """"""
        if not isinstance(translationAmt, Vector3):
            raise ValueError("translationAmt must be a Vector3")

        ma4 = Matrix4((1, 0, 0, translationAmt.x),
                      (0, 1, 0, translationAmt.y),
                      (0, 0, 1, translationAmt.z),
                      (0, 0, 0, 1))
        return ma4
768869
public static <X, Y> List<LocalProperty<Y>> translate(List<? extends LocalProperty<X>> properties, Function<X, Optional<Y>> translator)
    {
        properties = normalizeAndPrune(properties);

        ImmutableList.Builder<LocalProperty<Y>> builder = ImmutableList.builder();
        for (LocalProperty<X> property : properties) {
            Optional<LocalProperty<Y>> translated = property.translate(translator);
            if (translated.isPresent()) {
                builder.add(translated.get());
            }
            else if (!(property instanceof ConstantProperty)) {
                break; // Only break if we fail to translate non-constants
            }
        }

        return builder.build();
    }
1356977
private void combineWithTranslation(Matrix4d rotation) {
		rotation.setTranslation(centroid);
		rotation.mul(rotation, centroidInverse);
	}
1254549
public <NEW> Graph<K, NEW, EV> translateVertexValues(TranslateFunction<VV, NEW> translator) throws Exception {
		return run(new TranslateVertexValues<>(translator));
	}
644577
public void translate(Vector2D<?, ?> translation) {
		assert translation != null : AssertMessages.notNullParameter();
		translate(translation.getX(), translation.getY());
	}
545327
public static final void translate (Atom atom, Vector3d v) {

		atom.setX(atom.getX()+v.x);
		atom.setY(atom.getY()+v.y);
		atom.setZ(atom.getZ()+v.z);
	}
1110765
@Override
    public <T extends JCTree> T translate(T tree) {
        TranslationContext<?> newContext = contextMap.get(tree);
        return translate(tree, newContext != null ? newContext : context);
    }
1110404
function (level, x, y) {
            var context = null;
            if (level >= this.minLevel && level <= this.maxLevel) {
                context = this.levels[level].context2D;
            }
            return context;
        }
510679
public static void translateM(
            float[] m, int mOffset,
            float x, float y, float z) {
        for (int i=0 ; i<4 ; i++) {
            int mi = mOffset + i;
            m[12 + mi] += m[mi] * x + m[4 + mi] * y + m[8 + mi] * z;
        }
    }