abstract Matrix1x4(Mat1x4)

package geom.matrix

from Mat1x4, to Mat1x4,

@:forward

{ x, y, z, w }

Static variables

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

staticread onlycounting:Matrix1x4


>>> Matrix1x4.counting == new Matrix1x4( { x: 1., y: 2., z: 3., w: 4. } )

staticmagnitude:Float


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

staticread onlyminus1:Matrix1x4


>>> Matrix1x4.minus1 == new Matrix1x4( { x: -1., y: -1., z: -1., w: -1. } )

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

staticread onlyself:Matrix1x4

staticread onlyunit:Matrix1x4


>>> Matrix1x4.unit == new Matrix1x4( { x: 1., y: 1., z: 1., w: 1. } )

staticread onlyzero:Matrix1x4


>>> Matrix1x4.zero == new Matrix1x4( { x: 0., y: 0., z: 0., w: 0. } )

Static methods

staticinlineadd(this:Mat1x4, b:Matrix1x4):Matrix1x4

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


>>> ({ 
... var a = Matrix1x4.unit;
... a + a == new Matrix1x4({ x: 2., y: 2., z: 2., w: 2. }); 
... }) == true

staticinlineclone(this:Mat1x4):Matrix1x4


>>> Matrix1x4.counting == Matrix1x4.counting.clone()

@:op(~A)staticinlineconjugate(a:Matrix1x4):Matrix1x4


>>> ({ 
... var a = new Matrix1x4({ x: 1., y: 2., z: 3., w: 1. });
... var b = ~a;
... b == new Matrix1x4({ x: -1., y: -2., z: -3., w: 1. }); }) == true

staticinlineconstrainDistance(this:Mat1x4, anchor:Matrix1x4, distance:Float):Matrix1x4

staticinlinecopy(pin:Matrix1x4, pout:Matrix1x4):Matrix1x4


>>> ({ 
... var a = new Matrix1x4({ x: 1., y: 2., z: 3., w: 1. });
... var b = Matrix1x4.zero;
... var c = Matrix1x4.copy( a, b ); 
... a == c; }) == true

staticinlinecross(this:Mat1x4, v:Matrix1x4):Matrix1x4

@:op(A / B)staticinlinedivide(a:Matrix1x4, v:Float):Matrix1x4

@:op(A / B)staticinlinedivide2(v:Float, a:Matrix1x4):Matrix1x4

staticinlinedotProd(this:Mat1x4, b:Matrix1x4):Float

@:fromstaticinlinefromArray(arr:Array<Float>):Matrix1x4


>>> ({ 
... var a = Matrix1x4.unit;
... var b: Matrix1x4 = [ 1., 1., 1., 1. ];
... Equal.equals( a, b ); }) == true

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


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

staticinlineidentity(out:Matrix1x4):Matrix1x4


>>> Matrix1x4.identity( Matrix1x4.zero ) == new Matrix1x4({ x: 1., y: 1., z: 1., w: 1. })

staticinlineisEqual(this:Mat1x4, b:Matrix1x4):Bool

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


>>> ({ 
... var a = new Matrix1x4({ x: 1., y: 2., z: 3., w: 1. });
... var b = new Matrix1x4({ x: 1., y: 2., z: 3., w: 1. });
... a == b; }) == true

staticinlineiterator(this:Mat1x4):ArrayIterator<Float>


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

staticinlinemagnitudeSquared(this:Mat1x4):Float


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

staticinlinemultiplyQ(q:Matrix1x4, v:Matrix1x4, out:Matrix1x4):Matrix1x4

staticinlinemultiplyV(a:Matrix1x4, b:Matrix1x4, out:Matrix1x4):Matrix1x4

staticinlinenegate(this:Mat1x4):Matrix1x4

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


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

staticinlinenormalize(this:Mat1x4):Matrix1x4

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


>>> ({ 
... var a = new Matrix1x4({ x: 1., y: 2., z: 3., w: 1. });
... var b = new Matrix1x4({ x: 1., y: 2., z: 4., w: 1. });
... a != b; }) == true

staticinlineprojectPoint(this:Mat1x4):Matrix1x4


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

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

staticinlinerotateX(this:Mat1x4, theta:Float):Matrix1x4

staticinlinerotateY(this:Mat1x4, theta:Float):Matrix1x4

staticinlinerotateZ(this:Mat1x4, theta:Float):Matrix1x4

staticinlinescalarProduct(a:Matrix1x4, b:Matrix1x4):Float

staticinlinescaleMultiply(this:Mat1x4, v:Float):Matrix1x4

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

staticinlinesubtract(this:Mat1x4, b:Matrix1x4):Matrix1x4

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


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

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


>>> ({ 
... var a = Matrix1x4.unit;
... var b: Array = a;
... Equal.equals( b, [ 1., 1., 1., 1. ] ); }) == true

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


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

staticinlinetransformPoint(this:Mat1x4, t:Matrix4x3):Matrix1x4

staticinlinetranslateXY(this:Mat1x4, x:Float, y:Float):Matrix1x4

staticinlinetranslateXYZ(this:Mat1x4, x:Float, y:Float, z:Float):Matrix1x4

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