A starting point/position and a vector, i.e. vector applied on a point/position.
190917
function BoundingBox2D( xMin , yMin , xMax , yMax ) {
	this.min = new Vector2D( xMin , yMin ) ;
	this.max = new Vector2D( xMax , yMax ) ;
}
1250173
function(obj) {
                if (obj.start && obj.end) { return this.contains(obj.start) && this.contains(obj.end); }
                var P = (obj.elements || obj).slice();
                if (P.length == 2) { P.push(0); }
                if (this.start.eql(P)) { return true; }
                var S = this.start.elements;
                var V = vector.create([S[0] - P[0], S[1] - P[1], S[2] - (P[2] || 0)]);
                var vect = this.toVector();
                return V.isAntiparallelTo(vect) && V.modulus() <= vect.modulus();
              }
821111
function Vector(x, y) {
    this.x = x != null ? x : 0.0;
    this.y = y != null ? y : 0.0;
  }
1186267
private void computeRenderingPoint(int width, int height)
    {
        rx = (int) Math.floor(origin.getX(x, width));
        ry = (int) Math.floor(origin.getY(y, height));
    }
1072283
def project(vec1, vec2):
    """"""
    if isinstance(vec1, Vector3) and isinstance(vec2, Vector3) \
            or isinstance(vec1, Vector4) and isinstance(vec2, Vector4):
        return dot(vec1, vec2) / vec2.length() * vec2.normalize_copy()
    else:
        raise ValueError("vec1 and vec2 must be Vector3 or Vector4 objects.")
337126
function MultiPoint(multiPoint) {
        crs(multiPoint);
        bbox(multiPoint);
        if (!requiredProperty(multiPoint, 'coordinates', 'array')) {
            positionArray(multiPoint.coordinates, '', 1);
        }
    }
1201969
function BoundVector2D( px , py , vx , vy ) {
	this.position = new Vector2D( px , py ) ;
	this.vector = new Vector2D( vx , vy ) ;
}
573553
function( geometry, pos, angle ){

            this._aabb = null;
            this.children.push({
                g: geometry
                ,pos: new Physics.vector( pos )
                ,angle: angle
            });

            return this;
        }
86493
function add(v1, v2) {
    if (!isAVector(v1)) throw new Error("v1 must be a vector.");
    if (!isAVector(v2)) throw new Error("v2 must be a vector.");
    return Vector.zip(v1,v2,(e1, e2) => e1 + e2);
}
720057
public void setPosition(Vector3D v) {
		this.x = v.getX();
		this.y = v.getY();
		this.z = v.getZ();
	}
987317
public final void setStartEndPoints(final Point3D start, final Point3D end) {
        final Point3D direction = start.subtract(end);
        final Point3D position = start.midpoint(end);
        setLength(direction.magnitude());
        final Point3D axis = UP.crossProduct(direction.normalize());
        super.setVisible(true);
        super.setTranslateX(position.getX());
        super.setTranslateY(position.getY());
        super.setTranslateZ(position.getZ());
        super.setRotationAxis(axis);
        super.setRotate(UP.angle(direction.normalize()));
    }
149156
def apply(self, data, data_type='point', reference=None, **kwargs):
        
        if data_type == 'point':
            return self.apply_to_point(data)
        elif data_type == 'vector':
            return self.apply_to_vector(data)
        elif data_type == 'image':
            return self.apply_to_image(data, reference, **kwargs)
960641
def pointing_vector(self, s, time):
        
        t = time - self._t0
        longitude = self._longitude + self._dlongdt * t

        # define the basis vectors in the spin (primed) coordinates in terms of
        # the Roche coordinates.
        # ez' = s
        # ex' =  (ex - s(s.ex)) /|i - s(s.ex)|
        # ey' = s x ex'
        ex = np.array([1., 0., 0.])
        ezp = s
        exp = (ex - s*np.dot(s,ex))
        eyp = np.cross(s, exp)

        return np.sin(self._colat)*np.cos(longitude)*exp +\
                  np.sin(self._colat)*np.sin(longitude)*eyp +\
                  np.cos(self._colat)*ezp
527934
def point(u, v)
      Util3D.check_arg_type(::Numeric, u)
      Util3D.check_arg_type(::Numeric, v)
      return base_point + u_vector*u + v_vector*v
    end
35333
function(vector) {
    var V = vector.elements || vector;
    return Line.create([
      this.anchor.elements[0] + V[0],
      this.anchor.elements[1] + V[1],
      this.anchor.elements[2] + (V[2] || 0)
    ], this.direction);
  }
465075
def point(self, pos):
        """"""
        return ((1 - pos) ** 3 * self.start) + \
               (3 * (1 - pos) ** 2 * pos * self.control1) + \
               (3 * (1 - pos) * pos ** 2 * self.control2) + \
               (pos ** 3 * self.end)
1113202
def addFeatureStartLocation(
            self, coordinate, reference_id, strand=None, position_types=None):
        

        # make an object for the start, which has:
        # {coordinate : integer, reference : reference_id, types = []}
        self.start = self._getLocation(coordinate, reference_id, strand, position_types)

        return