public __type__(__type__ s) { Scale = s.Scale; Euclidean = s.Euclidean; }
public static bool ApproximateEquals(this __type__ t0, __type__ t1, __ftype__ tol) { return(t0.Scale.ApproximateEquals(t1.Scale, tol) && t0.Euclidean.ApproximateEquals(t1.Euclidean, tol)); }
public __type__(__ftype__ scale, __rotnt__ rotation, __vnt__ translation) { Scale = scale; Euclidean = new __euclideannt__(rotation, translation); }
public __type__(__ftype__ scale, __rotnt__ rotation, /*# nfields.ForEach(f => { */ __ftype__ t__f__ /*# }, comma);*/) { Scale = scale; Euclidean = new __euclideannt__(rotation, /*# nfields.ForEach(f => { */ t__f__ /*# }, comma);*/); }
/// <summary> /// Returns if the matrix is orthonormal (i.e. M * M^t == I) /// </summary> public bool IsOrthonormal(__ftype__ epsilon) { var i = this * this.Transposed; return(i.IsIdentity(epsilon)); }
public __type__(__type__ r) { Angle = r.Angle; }
public static bool ApproximateEquals(this __type__ a0, __type__ a1, __ftype__ tolerance) { return(ApproximateEquals(a0.Linear, a1.Linear, tolerance) && ApproximateEquals(a0.Trans, a1.Trans, tolerance)); }
/// <summary> /// Returns if all entries in the matrix a are approximately equal to the respective entries in matrix b. /// </summary> public static bool ApproximatelyEquals(__nmtype__ a, __nmtype__ b, __ftype__ epsilon) { return(DistanceMax(a, b) <= epsilon); //Inefficient implementation, no early exit of comparisons. }
public __type__(__ftype__ w, __ftype__ x, __ftype__ y, __ftype__ z) { W = w; X = x; Y = y; Z = z; __assertNorm__; }
public __type__(__ftype__ w, __v3t__ v) { W = w; X = v.X; Y = v.Y; Z = v.Z; __assertNorm__; }
public __type__(__ftype__[] a, int start) { W = a[start]; X = a[start + 1]; Y = a[start + 2]; Z = a[start + 3]; __assertNorm__; }
public __type__(__ftype__[] a) { W = a[0]; X = a[1]; Y = a[2]; Z = a[3]; __assertNorm__; }
public static bool ApproximateEquals(this __type__ r0, __type__ r1, __ftype__ tolerance) { return(Rot.Distance(r0, r1) <= tolerance); }
public static bool ApproximateEquals(this __type__ t0, __type__ t1, __ftype__ angleTol, __ftype__ posTol, __ftype__ scaleTol) { return(t0.Scale.ApproximateEquals(t1.Scale, scaleTol) && t0.Euclidean.ApproximateEquals(t1.Euclidean, angleTol, posTol)); }
public __type__(__mnnt__ linear, /*# nfields.ForEach(f => { */ __ftype__ t__f__ /*# }, comma); */) { Debug.Assert(linear.Invertible); Linear = linear; Trans = new __vnt__(/*# nfields.ForEach(f => { */ t__f__ /*# }, comma); */); }
public __type__(__ftype__ scale) { Scale = scale; Euclidean = __euclideannt__.Identity; }
public __type__(__euclideannt__ euclideanTransformation) { Scale = 1; Euclidean = euclideanTransformation; }
/// <summary> /// Returns if the matrix is the identity matrix I. /// </summary> public bool IsIdentity(__ftype__ epsilon) { return(ApproximatelyEquals(this, Identity, epsilon)); }
public __type__(__ftype__ scale, __euclideannt__ euclideanTransformation) { Scale = scale; Euclidean = euclideanTransformation; }
public static bool __bopname__(__nmtype__ a, __ftype__ s) { return/*# n.ForEach(i => { m.ForEach(j => { */ (a.M__i____j____bop__s /*# }, andand); }, andand); */); }
public __type__(__ftype__ angleInRadians) { Angle = angleInRadians; }