Vector2D

Vector2D.as

package com.foed
{
    import flash.display.Graphics;

    /**
     * 基本的な2次元ベクトルクラス
     */
    public class Vector2D
    {
        private var _x:Number;
        private var _y:Number;

        /**
         * コンストラクタ
         */
        public function Vector2D(x:Number = 0, y:Number = 0)
        {
            _x = x;
            _y = y;
        }

        /**
         * ベクトルを可視化するのに用いる。
         * 一般にデバッグ目的で用いる。
         * @param graphics ベクトルを描画するGraphicsのインスタンス
         * @param color ベクトルを描画するのに用いる線の色
         */
        public function draw(graphics:Graphics, color:uint = 0):void
        {
            graphics.lineStyle(0, color);
            graphics.moveTo(0, 0);
            graphics.lineTo(_x, _y);
        }

        /**
         * ベクトルのコピーを生成する。
         * @return Vector2D このベクトルのコピー
         */
        public function clone():Vector2D
        {
            return new Vector2D(x, y);
        }

        /**
         * このベクトルのx,yの値をゼロに設定する
         * @return Vector2D このベクトルの参照
         */
        public function zero():Vector2D
        {
            _x = 0;
            _y = 0;
            return this;
        }

        /**
         * このベクトルがゼロかどうか判別する
         * i.e. x,yがゼロである
         * @return Boolean ベクトルがゼロなら真、それ以外は偽
         */
        public function isZero():Boolean
        {
            return _x == 0 && _y == 0;
        }

        /**
         * ベクトルの大きさを設定/取得する。
         * 大きさの設定により、ベクトルのxとyが変わるが、
         * 角度は変わらない。
         */
        public function set length(value:Number):void
        {
            var a:Number = angle;   // 下記 get angle()参照

            _x = Math.cos(a) * value;
            _y = Math.sin(a) * value;
        }
        public function get length():Number
        {
            return Math.sqrt(lengthSQ); // 下記 get lengthSQ()参照
        }

        /**
         * ベクトルの大きさの2乗を求める。
         */
        public function get lengthSQ():Number
        {
            return _x * _x + _y * _y;
        }

        /**
         * ベクトルの角度を設定/取得する。
         * 角度の設定により、xとyは変わるが、
         * 大きさは維持される。
         */
        public function set angle(value:Number):void
        {
            var len:Number = length; // 上記 get length()参照
            _x = Math.cos(value) * len;
            _y = Math.sin(value) * len;
        }
        public function get angle():Number
        {
            return Math.atan2(_y, _x);
        }

        /**
         * ベクトルを正規化（大きさを1）にする。
         * v.length = 1と同じだが、こちらの方が効率が良い。
         * @return Vector2D このベクトルの参照
         */
        public function normalize():Vector2D
        {
            if (length == 0)
            {
                _x = 1; // ゼロベクトルのときは(1,0)とする
                return this;
            }
            var len:Number = length;
            _x /= len;
            _y /= len;
            return this;
        }

        /**
         * ベクトルの大きさを指定した値以下にする。
         * @param max ベクトルの最大の大きさ
         * ベクトルの大きさがmaxを超える場合には、この値に
         * 縮められる。
         * @return Vector2D このベクトルの参照
         */
        public function truncate(max:Number):Vector2D
        {
            length = Math.min(max, length);
            return this;
        }

        /**
         * ベクトルの方向を反転する。
         * @return Vector2D このベクトルの参照
         */
        public function reverse():Vector2D
        {
            _x = -_x;
            _y = -_y;
            return this;
        }

        /**
         * このベクトルが正規化されているかどうか
         * （すなわち、大きさが1かどうか）を判別する。
         * @return Boolean 大きさが1なら真、そうでなければ偽
         */
        public function isNormalized():Boolean
        {
            return length == 1.0;
        }

        /**
         * このベクトルと与えられたベクトルの内積を計算する。
         * @param v2 内積をとるVector2Dのインスタンス
         * @return Number このベクトルと、引数に渡された
         * インスタンスとの内積
         */
        public function dotProd(v2:Vector2D):Number
        {
            return _x * v2.x + _y * v2.y;
        }

        /**
         * 2つのベクトルの角度を計算する
         * @param v1 第1のVector2Dインスタンス
         * @param v2 第2のVector2Dインスタンス
         * @return 2つのベクトルの間の角度
         */
        public static function angleBetween(v1:Vector2D,
                                            v2:Vector2D):Number
        {
            if (!v1.isNormalized()) v1 = v1.clone().normalize();
            if (!v2.isNormalized()) v2 = v2.clone().normalize();
            return Math.acos(v1.dotProd(v2));
        }

        /**
         * 与えられたベクトルが、このベクトルの右側にあるか
         * 左側にあるかを判別する。
         * @return int 左側なら-1、右側なら+1
         */
        public function sign(v2:Vector2D):int
        {
            return perp.dotProd(v2) < 0 ? -1 : 1; // 下記 get perp()参照
        }

        /**
         * このベクトルに垂直なベクトルを返す。
         * @return Vector2D このベクトルに垂直なベクトル
         */
        public function get perp():Vector2D
        {
            return new Vector2D(-y, x);
        }

        /**
         * このベクトルと与えられたベクトルの間の距離を計算する。
         * @param v2 Vector2D インスタンス
         * @return Number このベクトルと、引数で渡されたベクトルとの
         * 間の距離
         */
        public function dist(v2:Vector2D):Number
        {
            return Math.sqrt(distSQ(v2)); // 下記 get distSQ()参照
        }

        /**
         * このベクトルと与えられたベクトルの間の距離の2乗を計算する。
         * @param v2 Vector2Dインスタンス
         * @return Number このベクトルと与えられたベクトルの間の距離の2乗
         */
        public function distSQ(v2:Vector2D):Number
        {
            var dx:Number = v2.x - x;
            var dy:Number = v2.y - y;
            return dx * dx + dy * dy;
        }

        /**
         * このベクトルに、あるベクトルを足して、その結果を
         * 格納した新しいVector2Dインスタンスを生成する。
         * @param v2 Vector2D インスタンス
         * @return Vector2D ベクトルの和を格納した新しいベクトル
         *のインスタンス
         */
        public function add(v2:Vector2D):Vector2D
        {
            return new Vector2D(_x + v2.x, _y + v2.y);
        }

        /**
         * このベクトルから、あるベクトルを引いて、その結果を
         * 格納した新しいVector2Dインスタンスを生成する。
         * @param v2 Vector2D インスタンス
         * @return Vector2D ベクトルの差を格納した新しいベクトル
         *のインスタンス
         */
        public function subtract(v2:Vector2D):Vector2D
        {
            return new Vector2D(_x - v2.x, _y - v2.y);
        }

        /**
         * このベクトルに、ある値を掛けて、その結果を
         * 格納した新しいVector2Dインスタンスを生成する。
         * @param v2 Vector2D インスタンス
         * @return Vector2D 掛け算の結果を格納した新しいベクトル
         *のインスタンス
         */
        public function multiply(value:Number):Vector2D
        {
            return new Vector2D(_x * value, _y * value);
        }

        /**
         * このベクトルを、ある値で割って、その結果を
         * 格納した新しいVector2Dインスタンスを生成する。
         * @param v2 Vector2D インスタンス
         * @return Vector2D 割り算の結果を格納した新しいベクトル
         *のインスタンス
         */
        public function divide(value:Number):Vector2D
        {
            return new Vector2D(_x / value, _y / value);
        }

        /**
         * このベクトルと、与えられたベクトルが等しいか
         * どうか判別する。
         * @param v2 Vector2D インスタンス
         * @return Boolean 等しければ真、そうでなければ偽
         */
        public function equals(v2:Vector2D):Boolean
        {
            return _x == v2.x && _y == v2.y;
        }

        /**
         * ベクトルのx成分の値を設定/取得する。
         */
        public function set x(value:Number):void
        {
            _x = value;
        }
        public function get x():Number
        {
            return _x;
        }

        /**
         * ベクトルのy成分の値を設定/取得する。
         */
        public function set y(value:Number):void
        {
            _y = value;
        }
        public function get y():Number
        {
            return _y;
        }

        /**
         * このベクトルの文字列表現を生成する。
         * @return String このベクトルの文字列表現
         */
        public function toString():String
        {
            return "[Vector2D (x:" + _x + ", y:" + _y + ")]";
        }
    }
}