abstract Matrix1x3(Mat1x3)

package geom.matrix

from Mat1x3, to Mat1x3,

@:forward

{ x, y, z } try to use 1x4 for 3D vectors.

Static variables

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

staticread onlycounting:Matrix1x3


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

staticmagnitude:Float


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

staticread onlyminus1:Matrix1x3


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

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

staticread onlyself:Matrix1x3

staticread onlyunit:Matrix1x3


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

staticread onlyzero:Matrix1x3


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

Static methods

staticinlineadd(this:Mat1x3, b:Matrix1x3):Matrix1x3

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


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

staticinlineclone(this:Mat1x3):Matrix1x3


>>> Matrix1x3.counting == Matrix1x3.counting.clone()

staticinlinecopy(pin:Matrix1x3, pout:Matrix1x3):Matrix1x3


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

staticinlinecross(this:Mat1x3, v:Matrix1x3):Matrix1x3

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

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

staticinlinedotProd(this:Mat1x3, b:Matrix1x3):Float

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


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

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


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

staticinlineget_unit():Matrix1x3

staticinlineidentity(out:Matrix1x3):Matrix1x3


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

staticinlineisEqual(this:Mat1x3, b:Matrix1x3):Bool

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


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

staticinlineiterator(this:Mat1x3):ArrayIterator<Float>


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

staticinlinemagnitudeSquared(this:Mat1x3):Float


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

staticinlinenegate(this:Mat1x3):Matrix1x3

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


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

staticinlinenormalize(this:Mat1x3):Matrix1x3

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


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

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

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

staticinlinescaleMultiply(this:Mat1x3, v:Float):Matrix1x3

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


>>> ({ 
... var a = new Matrix1x3({ x: 1., y: 2., z: 3. });
... var b = a * 2;
... b == new Matrix1x3({ x: 2., y: 4., z: 6. }); }) == true

staticinlinestaticFromArray(this:Mat1x3, arr:Array<Float>):Matrix1x3

staticinlinestaticFromVec(this:Mat1x3, vec:Vector<Float>):Matrix1x3

staticinlinesubtract(this:Mat1x3, b:Matrix1x3):Matrix1x3

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


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

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


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

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


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

staticinlinetransformPoint(this:Mat1x3, t:Matrix4x3):Matrix1x3

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