             return INFINITE; // the two shall never meet
         } else {
             var r :Number = rray / rplane;
-            return s.add(this.multiply(r));
+            return s.add(this.scale(r));
         }
     }
     

     * Returns a new vector that is the result of multiplying the current vector
     * by the specified scalar.
     */
    public function multiply (value :Number) :Vector3
    {
        return new Vector3(x * value, y * value, z * value);
    }
        
    /**

    /** Duplicates a vector. */
    public function clone() :Vector3
    {
        return new Vector3(this.x, this.y, this.z);
    }

    /** Returns this vector's length. */
    public function get length () :Number
    {
        return Math.sqrt(x * x + y * y + z * z);
    }

    /** Returns the dot product of this vector with vector v. */
    public function dot (v :Vector3) :Number
    {
        return x * v.x + y * v.y + z * v.z;
    }

    /** Returns a new vector that is a normalized version of this vector. */
    public function normalize () :Vector3
    {
        return this.clone().normalizeLocal();
    }

    /** Destructively normalizes this vector. Returns a reference to the modified self. */
    public function normalizeLocal () :Vector3
    {
        var len :Number = this.length;
        set(x / len, y / len, z / len);
        return this;
    }
    
    /**
     * Returns a new vector that is the cross product of this vector with vector v,
     * such that <code>result = this &#8855; v</code>.
     */
    public function cross (v :Vector3) :Vector3
    {
        return this.clone().crossLocal(v);
    }

    /**
     * Sets this vector to the result of a cross product with vector v, such that
     * <code>this = this &#8855; v</code>. Returns a reference to the modified self.
     */
    public function crossLocal (v :Vector3) :Vector3
    {
        var xx :Number = y * v.z - z * v.y;
        var yy :Number = z * v.x - x * v.z;
        var zz :Number = x * v.y - y * v.x;
        set(xx, yy, zz);

        return this;
    }

    /** Returns a new vector that is the summation of this vector with vector v. */
    public function add (v :Vector3) :Vector3
    {
        return this.clone().addLocal(v);
    }

    /**
     * Sets this vector to the result of summation with v, such that <code>this = this + v</code>.
     * Returns a reference to the modified self.
     */
    public function addLocal (v :Vector3) :Vector3
    {
        set(x + v.x, y + v.y, z + v.z);
        return this;
    }

    /** Returns a new vector that is the subtraction of vector v from this vector.*/
    public function subtract (v :Vector3) :Vector3
    {
        return this.clone().subtractLocal(v);
    }

    /**
     * Sets the vector to the result of subtraction of v, such that <code>this = this - v</code>.
     * Returns a reference to the modified self.
     */
    public function subtractLocal (v :Vector3) :Vector3
    {
        set(x - v.x, y - v.y, z - v.z);
        return this;
    }

    /**
