abstract Matrix1x2(Mat1x2)

package geom.matrix

from Mat1x2, to Mat1x2,

@:transitive@:forward

{ x, y }

Static variables

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

staticread onlycounting:Matrix1x2


>>> Matrix1x2.counting == new Matrix1x2({ x: 1., y: 2. })

staticmagnitude:Float


>>> ( new Matrix1x2( { x: 4., y: 3. } ) ).magnitude == 5

staticread onlyminus1:Matrix1x2


>>> Matrix1x2.minus1 == new Matrix1x2({ x: -1., y: -1. })

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

staticread onlyself:Matrix1x2

staticread onlyunit:Matrix1x2


>>> Matrix1x2.unit == new Matrix1x2({ x: 1., y: 1. })

staticread onlyzero:Matrix1x2


>>> Matrix1x2.zero == new Matrix1x2({ x: 0., y: 0. })

Static methods

staticinlineadd(this:Mat1x2, b:Matrix1x2):Matrix1x2

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


>>> Matrix1x2.unit + Matrix1x2.unit == new Matrix1x2( { x: 2., y: 2. } )

staticinlinebottomLeft():Matrix1x2


>>> Matrix1x2.bottomLeft() == new Matrix1x2({ x: -1., y: -1. })

staticinlinebottomRight():Matrix1x2


>>> Matrix1x2.bottomRight() == new Matrix1x2({ x: 1., y: -1. })

staticinlineclone(this:Mat1x2):Matrix1x2


>>> Matrix1x2.counting == Matrix1x2.counting.clone()

@:value({ delta : 0.00001 })staticinlineclose(this:Mat1x2, b:Matrix1x2, delta:Float = 0.00001):Bool


>>> ({ 
... var a = new Matrix1x2( { x: 0.5, y: 0.5 } ); 
... var b = new Matrix1x2( { x: 0.5000001, y: 0.5000001 } ); 
... a.close( b ); }) == true

staticinlineconvex(a:Matrix1x2, b:Matrix1x2, c:Matrix1x2):Bool


>>> ({ 
... var l = new Matrix1x2( { x: 1., y: 0. });
... var t = new Matrix1x2( { x: 2., y: 1. });
... var r = new Matrix1x2( { x: 4., y: 0. });
... var b = new Matrix1x2( { x: 3., y: -1. });
... (!Matrix1x2.convex( l, t, r ) && Matrix1x2.convex( l, b, r )) == true;
... }) == true

staticinlinecross(a:Matrix1x2, b:Matrix1x2):Float


>>> ({ trace('"cross" untested'); true; }) == true

staticinlinedistance(this:Mat1x2):Float


>>> ({ 
... var a = new Matrix1x2( { x: 3., y: 4. } ); 
... a.distance(); }) == 5

staticinlinedistanceBetween(this:Mat1x2, b:Matrix1x2):Float

test with 3,4,5 triangle


>>> ({ 
... var a = new Matrix1x2( { x: 1., y: 1. } ); 
... var b = new Matrix1x2( { x: 1. + 3., y: 1. + 4. } ); 
... a.distanceBetween( b ); }) == 5

staticinlinedistanceBetweenSquare(this:Mat1x2, b:Matrix1x2):Float

test with 3,4,5 triangle


>>> ({ 
... var a = new Matrix1x2( { x: 1., y: 1. } ); 
... var b = new Matrix1x2( { x: 1. + 3., y: 1. + 4. } ); 
... a.distanceBetweenSquare( b ); }) == 25

staticinlinedistanceBetweenSquare_(this:Mat1x2, b:Matrix1x2):Float

staticinlinedivide(this:Mat1x2, v:Float):Matrix1x2

@:op(A / B)staticinlinedividing(a:Matrix1x2, v:Float):Matrix1x2


>>> Matrix1x2.unit / 2 == new Matrix1x2( { x: 0.5, y: 0.5 } )

staticinlinedot(this:Mat1x2, b:Matrix1x2):Matrix1x2

@:op(A * B)staticinlinedotting(a:Matrix1x2, b:Matrix1x2):Matrix1x2

staticinlineeast():Matrix1x2


>>> Matrix1x2.east() == new Matrix1x2({ x: 1., y: 0. })

staticinlinefromArrayPos(arr:Array<Float>, pos:Int):Matrix1x2


>>> Matrix1x2.fromArrayPos( [ 0., 1., 2. ], 1) ==  new Matrix1x2({x:1.,y:2.})

@:fromstaticinlinefromVec3(v:Vector<Float>):Matrix1x2


>>> ({ 
... var a = Matrix1x2.unit;
... var b = haxe.ds.Vector.fromArrayCopy([ 1., 1., 1. ]);
... var c: Matrix1x2 = b;
... a == c; 
... }) == true

staticinlineinRect(this:Mat1x2, b:Matrix1x2, c:Matrix1x2):Bool


>>> ({ 
... var a = Matrix1x2.topRight()/2; 
... var b = Matrix1x2.zero; 
... var c = Matrix1x2.topRight(); 
... a.inRect( b, c ); }) == true
>>> ({ 
... var a = Matrix1x2.bottomLeft()/2; 
... var b = Matrix1x2.zero; 
... var c = Matrix1x2.topRight(); 
... a.inRect( b, c ); }) == false
>>> ({ 
... var a = Matrix1x2.bottomLeft()/2; 
... var b = Matrix1x2.bottomRight(); 
... var c = Matrix1x2.zero; 
... a.inRect( b, c ); }) == false
>>> ({ 
... var a = Matrix1x2.bottomRight()/2; 
... var b = Matrix1x2.bottomRight(); 
... var c = Matrix1x2.zero; 
... a.inRect( b, c ); }) == true

staticinlineinTri(this:Mat1x2, a:Matrix1x2, b:Matrix1x2, c:Matrix1x2):Bool


>>> ({ trace('"inTri" untested'); true; }) == true

staticinlineinTri2(this:Mat1x2, a:Matrix1x2, b:Matrix1x2, c:Matrix1x2):Bool


>>> ({ trace('"inTri2" untested'); true; }) == true

staticinlineisEqual(this:Mat1x2, b:Matrix1x2):Bool

@:op(A == B)staticinlineisEqualling(a:Matrix1x2, b:Matrix1x2):Bool


>>> ({ 
... var a = new Matrix1x2( { x: 7., y: 6. } ); 
... var b = new Matrix1x2( { x: 7., y: 6. } ); 
... a == b; 
... }) == true

staticinlineisLeft(this:Mat1x2, a:Matrix1x2, b:Matrix1x2):Float


>>> ({ trace('"isLeft" untested'); true; }) == true

staticinlineiterator(this:Mat1x2):Iterator<Float>


>>> ({ 
... var m = Matrix1x2.counting;
... var arr = new Array();
... for( i in m ){
...   arr.push(i); 
... }
... [1.,2.].toString() == arr.toString(); }) == true

staticinlinelenSquare(this:Mat1x2):Float


>>> ({ 
... var a = new Matrix1x2( { x: 3., y: 3. } ); 
... a.lenSquare(); }) == 18

staticinlinelerp(this:Mat1x2, p:Matrix1x2, t:Float):Matrix1x2

staticinlinelerpClampT(this:Mat1x2, p:Matrix1x2, t:Float):Matrix1x2

staticinlinemid(a:Matrix1x2, b:Matrix1x2):Matrix1x2


>>> ({ 
... var a = new Matrix1x2( { x: 3.,  y: 1. } ); 
... var b = new Matrix1x2( { x: 4.,  y: 2. } ); 
... var c = new Matrix1x2( { x: 3.5, y: 1.5 } );
... var mid = Matrix1x2.mid( a, b ); 
... mid == c;
... }) == true

staticinlinenegate(this:Mat1x2):Matrix1x2

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


>>> ({ 
... var a = new Matrix1x2({ x: 1., y: 2. });
... var b = -a;
... b == new Matrix1x2({ x: -1., y: -2. }); }) == true

staticinlinenormalize(this:Mat1x2):Float


>>> ({ trace('"normalize" untested'); true; }) == true

staticinlinenorth():Matrix1x2


>>> Matrix1x2.north() == new Matrix1x2({ x: 0., y: 1. })

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


>>> ({ 
... var a = new Matrix1x2( { x: 7., y: 5. } ); 
... var b = new Matrix1x2( { x: 7., y: 6. } ); 
... a != b; 
... }) == true

staticinlineperp(this:Mat1x2, b:Matrix1x2):Float


>>> ({ trace('"perp" untested still to consider'); true; }) == true

staticinlinepivotAround(this:Mat1x2, omega:Float, pivot:Matrix1x2):Matrix1x2


>>> ({ 
... var a = Matrix1x2.topRight(); 
... var b = a.pivotAround( Math.PI/2, Matrix1x2.topRight()/2 ); 
... b.close( Matrix1x2.north() ); }) == true

@:op([])staticinlinereadItem(this:Mat1x2, k:Int):Float

staticinlinescaleMultiply(this:Mat1x2, v:Float):Matrix1x2

@:op(A * B)@:commutativestaticinlinescaleMultiplying(a:Matrix1x2, v:Float):Matrix1x2


>>> Matrix1x2.unit * 2 == new Matrix1x2( { x: 2., y: 2. } )
>>> 2 * Matrix1x2.unit == new Matrix1x2( { x: 2., y: 2. } )

staticinlinesign(n:Float):Int


>>> Matrix1x2.sign( -7. ) == -1
>>> Matrix1x2.sign( 7. ) == 1

staticinlinesouth():Matrix1x2


>>> Matrix1x2.south() == new Matrix1x2({ x: 0., y: -1. })

staticinlinespan(this:Mat1x2, b:Matrix1x2):Matrix1x2


>>> ({ trace('"span" untested still to consider'); true; }) == true

staticinlinesubtract(this:Mat1x2, b:Matrix1x2):Matrix1x2

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


>>> Matrix1x2.unit - Matrix1x2.unit == new Matrix1x2( { x: 0., y: 0. } )

staticinlinesumXY(this:Mat1x2):Float

staticinlinetheta(this:Mat1x2):Float


>>> Matrix1x2.east().theta()        == 0.
>>> Matrix1x2.bottomRight().theta() == -Math.PI/4
>>> Matrix1x2.south().theta()       == -Math.PI/2
>>> Matrix1x2.bottomLeft().theta()  == -3*Math.PI/4
>>> Matrix1x2.west().theta()        == Math.PI
>>> Matrix1x2.topLeft().theta()     == 3*Math.PI/4
>>> Matrix1x2.north().theta()       == Math.PI/2
>>> Matrix1x2.topRight().theta()    == Math.PI/4

staticinlinethetaDifference(a:Matrix1x2, b:Matrix1x2):Float


>>> Matrix1x2.thetaDifference( Matrix1x2.east(),        Matrix1x2.zero ) == 0
>>> Matrix1x2.thetaDifference( Matrix1x2.bottomRight(), Matrix1x2.zero ) == -Math.PI/4
>>> Matrix1x2.thetaDifference( Matrix1x2.south(),       Matrix1x2.zero ) == -Math.PI/2
>>> Matrix1x2.thetaDifference( Matrix1x2.bottomLeft(),  Matrix1x2.zero ) == -3*Math.PI/4
>>> Matrix1x2.thetaDifference( Matrix1x2.west(),        Matrix1x2.zero ) == Math.PI
>>> Matrix1x2.thetaDifference( Matrix1x2.topLeft(),     Matrix1x2.zero ) == 3*Math.PI/4
>>> Matrix1x2.thetaDifference( Matrix1x2.north(),       Matrix1x2.zero ) == Math.PI/2
>>> Matrix1x2.thetaDifference( Matrix1x2.topRight(),    Matrix1x2.zero ) == Math.PI/4

staticinlinetoArrayPos(this:Mat1x2, arr:Array<Float>, pos:Int):Array<Float>


>>> ({ 
... var a = new Matrix1x2( { x: 5., y: 6. } ); 
... var arr = [ 0., 1., 2. ]; 
... a.toArrayPos( arr, 1 ); }) == [ 0., 5., 6. ]

@:tostaticinlinetoTpoint(this:Mat1x2):Tpoint


>>> ({ trace('"toTPoint" untested'); true; }) == true

@:tostaticinlinetoVec3(this:Mat1x2):Vector<Float>


>>> ({ 
... var a = Matrix1x2.unit;
... var b: haxe.ds.Vector = a;
... var c = haxe.ds.Vector.fromArrayCopy([ 1., 1., 1. ]);
... Equal.equals( b, c ); }) == true

staticinlinetopLeft():Matrix1x2


>>> Matrix1x2.topLeft() == new Matrix1x2({ x: -1., y: 1. })

staticinlinetopRight():Matrix1x2


>>> Matrix1x2.topRight() == new Matrix1x2({ x: 1., y: 1. })

staticinlinetriangleArea(a:Matrix1x2, b:Matrix1x2, c:Matrix1x2):Float


>>> ({ trace('"triangleArea" untested'); true; }) == true

staticinlinewest():Matrix1x2


>>> Matrix1x2.west() == new Matrix1x2({ x: -1., y: 0. })

@:op([])staticinlinewriteItem(this:Mat1x2, k:Int, v:Float):Float

@:value({ delta : 0.00001 })staticinlinexClose(this:Mat1x2, b:Matrix1x2, delta:Float = 0.00001):Bool


>>> ({
... var a = new Matrix1x2( { x: 0.5, y: 1. } ); 
... var b = new Matrix1x2( { x: 0.5000001, y: 0.5000001 } ); 
... a.close( b ); }) == true

@:value({ delta : 0.00001 })staticinlineyClose(this:Mat1x2, b:Matrix1x2, delta:Float = 0.00001):Bool


>>> ({ 
... var a = new Matrix1x2( { x: 1., y: 0.5 } ); 
... var b = new Matrix1x2( { x: 0.5000001, y: 0.5000001 } ); 
... a.close( b ); }) == true