matrix.as

package ASUtil.Math
{
    import flash.geom.Matrix;
    import flash.geom.Matrix3D;

    public class matrix extends Object
    {

        public static const opMul:String = "Multiplication";
        public static const opAdd:String = "Addition";
        public static const opSub:String = "Subtract";
        public static const opInv:String = "Inverse";
        public static const opFMX:String = "ToFlashMatrix";
        public static const opFM3:String = "ToFlashMatrix3D";

        private var data:Vector.<Number>;
        private var W:uint;
        private var H:uint;

        public var newLine:Boolean = true;

        public function matrix ( width:uint, height:uint, ... dat )
        {

            data = new Vector.<Number> ( width * height, true );

            W = width;
            H = height;

            if ( dat.length > W * H )
                throw new Error ( "More data provided than fits in matrix.", 0 );

            for ( var n:uint = 0; n < dat.length; n ++ )
                data [ n ] = dat [ n ];

        };

        public function setElement ( x:uint, y:uint, value:Number ) : void
        {

            if ( x >= W || y >= H )
                throw new Error ( "The coordinance ( " + x + ", " + y + " ) is out of the matrix bounds.", 1 );

            data [ x + y * W ] = value;

        };

        public function add ( mat:matrix ) : matrix
        {

            if ( mat.width != W || mat.height != H )
                throw new Error ( "Mismatched dimensions for adding.", 2 );

            var ret:matrix = new matrix ( W, H );

            for ( var x:uint = 0; x < W; x ++ )
            {

                for ( var y:uint = 0; y < H; y ++ )
                {

                    ret.setElement ( x, y, data [ x + y * H ] + mat.getElement ( x, y ) );

                }

            }

            return ret;

        };

        public function sub ( mat:matrix ) : matrix
        {

            if ( mat.width != W || mat.height != H )
                throw new Error ( "Mismatched dimensions for adding.", 3 );

            var ret:matrix = new matrix ( W, H );

            for ( var x:uint = 0; x < W; x ++ )
            {

                for ( var y:uint = 0; y < H; y ++ )
                {

                    ret.setElement ( x, y, data [ x + y * H ] - mat.getElement ( x, y ) );

                }

            }

            return ret;

        };

        public function mulUniform ( val:Number ):matrix
        {

            var ret:matrix = new matrix ( W, H );

            for ( var n:uint = 0; n < W * H; n ++ )
            {

                ret.setElement ( n % W, ( n - n % W ) / W, val * data [ n ] );

            }

            return ret;

        };

        public function mulMatrix ( mat:matrix ) : matrix
        {

            if ( W != mat.height )
                throw new Error ( "Mismatched dimensions for multiplication.", 4 );

            var ret:matrix = new matrix ( mat.width, H );
            var curr:Number;

            for ( var x:uint = 0; x < mat.width; x ++ )
                for ( var y:uint = 0; y < H; y ++ )
                {

                    curr = 0;

                    for ( var n:uint = 0; n < W; n ++ )
                        curr += mat.getElement ( x, n ) * data [ n * W + y ];

                    ret.setElement ( x, y, curr );

                }

            return ret;

        };

        public function inverse () : matrix
        {

            if ( !operationSupported ( opInv ) )
                throw new Error ( "inversion is not possible on this matrix.", 5 );

            var ret:matrix = new matrix ( W, H );
            var mul:Number;

            if ( W == 1 )
                ret.setElement ( 0, 0, 1 / data [ 0 ] );

            if ( W == 2 )
            {

                mul = 1 / ( data [ 0 ] * data [ 3 ] - data [ 1 ] * data [ 2 ] );

                ret.setElement ( 0, 0, data [ 3 ] * mul );
                ret.setElement ( 1, 0, -data [ 1 ] * mul );

                ret.setElement ( 0, 1, -data [ 2 ] * mul );
                ret.setElement ( 1, 1, data [ 0 ] * mul );

            }

            if ( W == 3 )
            {

                mul = 1 / ( data [ 0 ] * ( ( data [ 4 ] * data [ 8 ] ) - ( data [ 5 ] * data [ 7 ] ) ) + data [ 1 ] * ( ( data [ 5 ] * data [ 6 ] ) - ( data [ 8 ] * data [ 3 ] ) ) + data [ 2 ] * ( ( data [ 3 ] * data [ 7 ] ) - ( data [ 4 ] * data [ 6 ] ) ) );

                ret.setElement ( 0, 0, ( data [ 4 ] * data [ 8 ] - data [ 5 ] * data [ 7 ] ) );
                ret.setElement ( 0, 1, ( data [ 2 ] * data [ 7 ] - data [ 1 ] * data [ 8 ] ) );
                ret.setElement ( 0, 2, ( data [ 1 ] * data [ 5 ] - data [ 2 ] * data [ 4 ] ) );

                ret.setElement ( 1, 0, ( data [ 5 ] * data [ 6 ] - data [ 3 ] * data [ 8 ] ) );
                ret.setElement ( 1, 1, ( data [ 0 ] * data [ 8 ] - data [ 2 ] * data [ 6 ] ) );
                ret.setElement ( 1, 2, ( data [ 2 ] * data [ 3 ] - data [ 0 ] * data [ 5 ] ) );

                ret.setElement ( 2, 0, ( data [ 3 ] * data [ 7 ] - data [ 4 ] * data [ 6 ] ) );
                ret.setElement ( 2, 1, ( data [ 6 ] * data [ 1 ] - data [ 0 ] * data [ 7 ] ) );
                ret.setElement ( 2, 2, ( data [ 0 ] * data [ 4 ] - data [ 1 ] * data [ 3 ] ) );

                ret = ret.mulUniform ( mul );

            }

            return ret;

        }

        public function getElement ( x:uint, y:uint ) : Number
        {

            return data [ x + y * W ];

        };

        public function get width () : uint
        {

            return W;

        };

        public function get height () : uint
        {

            return H;

        };

        public function getRawData () : Vector.<Number>
        {

            return data;

        };

        public function operationSupported ( operation:String, second:matrix = null ) : Boolean
        {

            if ( !( operation == opFMX || operation == opFM3 || operation == opInv || second != null ) )
                throw new Error ( "Second matrix not provided to test for operability.", 6 );

            switch ( operation )
            {

                case opInv:
                    if ( ( W == 3 && H == 3 ) || ( W == 2 && H == 2 ) || ( W == 1 && H == 1 ) )
                        return true;
                    else
                        return false;
                    break;

                case opAdd:
                    if ( W == second.width && H == second.height )
                        return true;
                    else
                        return false;
                    break;

                case opSub:
                    if ( W == second.width && H == second.height )
                        return true;
                    else
                        return false;
                    break;

                case opMul:

                    if ( W == second.height )
                        return true;
                    else
                        return false;

                case opFMX:

                    if ( W == 3 && H == 3 || W == 3 && H == 2 )
                        return true;
                    else
                        return false;
                    break;

                case opFM3:

                    if ( W == 4 && H == 4 )
                        return true;
                    else
                        return false;

                    break;

                default:

                    throw new Error ( operation + " is not an operation you can test for.", 7 );

                    break;

            }

            return false;

        };

        public function toString () : String
        {

            var out:String = ( newLine ) ? '' : '[ ';
            var maxL:Vector.<uint> = new Vector.<uint> ( W, true );

            var qx:uint;
            var sp:String;
            var sa:String;

            for ( var n:uint = 0; n < W * H; n ++ )
            {

                qx = n % W;
                maxL [ qx ] = Math.max ( maxL [ qx ], data [ n ].toString ().length );

            }

            for ( var y:uint = 0; y < H; y ++ )
            for ( var x:uint = 0; x < W; x ++ )
            {

                sp = '';
                sa = data [ x + y * W ].toString ( 10 );

                while ( sa.length < maxL [ x ] && newLine )
                    sa = ' ' + sa;

                if ( x == 0 )
                    out += '[ ';

                out += sa;

                if ( x < W - 1 )
                    out += ', ';
                else
                {

                    out += ' ]';
                        if ( y < H - 1 )
                            out += ( newLine ) ? '\n' : ' ';

                }

            }

            out += ( newLine ) ? '' : ' ]';

            var t:String = '';

            if ( out.indexOf ( "\n" ) != 0 )
            {

                var u:uint = 0;
                while ( u ++ < out.indexOf ( "\n" ) )
                    t += '-';

            }
            else
            {

                var g:uint = 0;
                while ( g ++ < out.length )
                    t += '-';

            }

            if ( newLine )
                out = "Matrix:\n" + t + '\n' + out + '\n' + t;

            return out;

        };

        public function toFlashMatrix () : flash.geom.Matrix
        {

            if ( ! operationSupported ( opFMX ) )
                throw new Error ( "Cannot convert to flash matrix. ( wrond dimentions )", 8 );

            var ret:flash.geom.Matrix = new flash.geom.Matrix ( data [ 0 ], data [ 1 ], data [ 3 ], data [ 4 ], data [ 2 ], data [ 5 ] );
            return ret;

        }

        public function toFlashMatrix3D () : flash.geom.Matrix3D
        {

            if ( ! operationSupported ( opFM3 ) )
                throw new Error ( "Cannot convert to flash matrix. ( wrond dimentions )", 9 );

            var ret:flash.geom.Matrix3D = new flash.geom.Matrix3D ( data );
            return ret;

        }

        public static function generateIdentity ( size:uint ) : matrix
        {

            var ret:matrix = new matrix ( size, size );
            var i:uint = 0;

            while ( i ++ < size )
                ret.setElement ( i - 1, i - 1, 1 );

            return ret;

        };

        public static function fromFlashMatrix ( mat:flash.geom.Matrix ) : matrix
        {

            return new matrix ( 3, 3, mat.a, mat.b, mat.tx, mat.c, mat.d, mat.ty, 0, 0, 1 );

        }

        public static function fromFlashMatrix3D ( mat:flash.geom.Matrix3D ) : matrix
        {

            return new matrix ( 4, 4, mat.rawData );

        }

    };

};