abstract Matrix3x3(Mat3x3)

package geom.matrix

from Mat3x3, to Mat3x3,

@:forward

3x3

Static variables

staticread only_123456789:Matrix3x3

Used for testing 









({


... Matrix3x3._123456789 == new Matrix3x3({ a: 1., b: 2., c: 3.
...                                         , d: 4., e: 5., f: 6.
...                                         , g: 7., h: 8., i: 9. });
... }) == true

@:value(3)staticfinalinlineread onlycolumns:Int = 3

staticread onlycounting:Matrix3x3


>>> ({
... Matrix3x3.counting == new Matrix3x3( { a: 1., b: 2., c: 3.
...                                      , d: 4., e: 5., f: 6.
...                                      , g: 7., h: 8., i: 9. }); 
... }) == true

staticread onlyminus1:Matrix3x3


>>> Matrix3x3.minus1 == new Matrix3x3({ a: -1., b: 0., c: 0.
...                                   , d: 0.,  e: -1., f: 0.
...                                   , g: 0.,  h: 0., i: -1. })

@:value(3)staticfinalinlineread onlyrows:Int = 3

staticread onlyself:Matrix3x3

staticread onlyunit:Matrix3x3


>>> ({ 
... Matrix3x3.unit == new Matrix3x3({ a: 1., b: 0., c: 0.
...                                  , d: 0., e: 1., f: 0.
...                                  , g: 0., h: 0., i: 1. });
... }) == true

staticread onlyzero:Matrix3x3


>>> ({
... Matrix3x3.zero == new Matrix3x3( { a: 0., b: 0., c: 0.
...                                    , d: 0., e: 0., f: 0.
...                                    , g: 0., h: 0., i: 0. }); 
... }) == true

Static methods

staticinlineadd(this:Mat3x3, b:Matrix3x3):Matrix3x3

@:op(A + B)staticinlineadding(a:Matrix3x3, b:Matrix3x3):Matrix3x3


>>> ({ 
... var a = Matrix3x3.unit;
... a + a == new Matrix3x3( { a: 2., b: 0., c: 0.
...                         , d: 0., e: 2., f: 0.
...                         , g: 0., h: 0., i: 2. } ); }) == true

staticinlineclone(this:Mat3x3):Matrix3x3


>>> Matrix3x3.counting == Matrix3x3.counting.clone()

staticinlinecofactor(this:Mat3x3, a:Float, b:Float, c:Float, d:Float):Float

staticinlinedet(this:Mat3x3):Float

@:op(A == B)staticinlineequal(a:Matrix3x3, b:Matrix3x3):Bool


>>> ({ 
... var a = new Matrix3x3({ a: 1., b: 2., c: 3., d: 4., e: 5., f: 6., g: 7., h: 8., i: 9. });
... var b = new Matrix3x3({ a: 1., b: 2., c: 3., d: 4., e: 5., f: 6., g: 7., h: 8., i: 9. });
... a == b; }) == true

staticinlineflipX(this:Mat3x3):Matrix3x3

staticinlineflipXY(this:Mat3x3):Matrix3x3

staticinlineflipY(this:Mat3x3):Matrix3x3

@:fromstaticinlinefrom2x2(m2:Matrix2x2):Matrix3x3

@:fromstaticinlinefrom4x3(m4:Matrix4x3):Matrix3x3

@:fromstaticinlinefromArr(arr:Array<Float>):Matrix3x3

@:fromstaticinlinefromVec(vec:Vector<Float>):Matrix3x3

staticinlinegetXY(this:Mat3x3, x:Int, y:Int):Float

staticinlineget_unit():Matrix3x3

staticinlineinverse(this:Mat3x3):Matrix3x3

staticinlineisEqual(this:Mat3x3, b:Matrix3x3):Bool

staticinlineiterator(this:Mat3x3):ArrayIterator<Float>


>>> ({ 
... var m = Matrix3x3.counting;
... var arr = new Array();
... for( i in m ){
...   arr.push(i); 
... }
... [1.,2.,3.,4.,5.,6.,7.,8.,9.].toString() == arr.toString(); }) == true

@:op(A * B)staticinlinemultiply(p:Matrix3x3, q:Matrix3x3):Matrix3x3

@:op(A * B)staticinlinemultiplyV(v:Float, m:Matrix3x3):Matrix3x3

staticinlinenegate(this:Mat3x3):Matrix3x3

@:op(-A)staticinlinenegating(a:Matrix3x3):Matrix3x3


>>> ({ 
... var a = Matrix3x3.counting;
... var b = -a;
... b == new Matrix3x3({ a: -1., b: -2., c: -3., d: -4., e: -5., f: -6., g: -7., h: -8., i: -9. }); }) == true

@:op(A != B)staticinlinenotEqual(a:Matrix3x3, b:Matrix3x3):Bool


>>> ({ 
... var a = new Matrix3x3({ a: 1., b: 2., c: 3., d: 4., e: 5., f: 6., g: 7., h: 8., i: 9. });
... var b = new Matrix3x3({ a: 1., b: 2., c: 3., d: 4., e: 5., f: 6., g: 7., h: 8., i: 8. });
... a != b; }) == true

staticinlineradianX(theta:Float):Matrix3x3

staticinlineradianY(theta:Float):Matrix3x3

staticinlineradianZ(theta:Float):Matrix3x3

staticinlinerotate(this:Mat3x3, theta:Float):Matrix3x3

staticinlinerotateX(this:Mat3x3, theta:Float):Matrix3x3

staticinlinerotateY(this:Mat3x3, theta:Float):Matrix3x3

staticinlinerotateZ(this:Mat3x3, theta:Float):Matrix3x3

staticinlinescale(this:Mat3x3, s:Float):Matrix3x3

staticinlinescale2D(this:Mat3x3, s:Float):Matrix3x3

staticinlinescaleVector2(this:Mat3x3, p:Matrix1x2):Matrix3x3

staticinlinescaleVector4(this:Mat3x3, p:Matrix1x4):Matrix3x3

staticinlinescaleVectorT3(this:Mat3x3, p:Tmatrix1x3):Matrix3x3

staticinlinescaleX(this:Mat3x3, x:Float):Matrix3x3

staticinlinescaleXYZ(this:Mat3x3, x:Float, y:Float, z:Float):Matrix3x3

staticinlinescaleY(this:Mat3x3, y:Float):Matrix3x3

staticinlinescaleZ(this:Mat3x3, z:Float):Matrix3x3

staticinlinesetXY(this:Mat3x3, x:Int, y:Int, v:Float):Float

staticinlineshearX(this:Mat3x3, theta:Float):Matrix3x3

staticinlineshearY(this:Mat3x3, theta:Float):Matrix3x3

staticinlinesubtract(this:Mat3x3, b:Matrix3x3):Matrix3x3

@:op(A - B)staticinlinesubtracting(a:Matrix3x3, b:Matrix3x3):Matrix3x3


>>> ({ 
... var a = Matrix3x3.unit;
... a - a == Matrix3x3.zero; }) == true

staticinlinesx(x:Float):Matrix3x3

staticinlinesxyz(x:Float, y:Float, z:Float):Matrix3x3

staticinlinesy(y:Float):Matrix3x3

staticinlinesz(z:Float):Matrix3x3

@:tostaticinlineto2x2(this:Mat3x3):Matrix2x2

staticinlineto3D(m2:Matrix2x2):Matrix3x3

@:tostaticinlineto4x3(this:Mat3x3):Matrix4x3

@:tostaticinlinetoArray(this:Mat3x3):Array<Float>

@:tostaticinlinetoVector(this:Mat3x3):Vector<Float>

staticinlinetranslateX(this:Mat3x3, x:Float):Matrix3x3

staticinlinetranslateXY(this:Mat3x3, x:Float, y:Float):Matrix3x3

staticinlinetranspose(this:Mat3x3):Matrix3x3

staticinlinetx(x:Float):Matrix3x3

staticinlinetxy(x:Float, y:Float):Matrix3x3

staticinlinety(y:Float):Matrix3x3

staticinlinexFlip():Matrix3x3

staticinlinexShear(theta:Float):Matrix3x3

staticinlinexyFlip():Matrix3x3

staticinlineyFlip():Matrix3x3

staticinlineyShear(theta:Float):Matrix3x3