SystemEx.Numeric.Quatd Struct Reference

Represents a doubleing‑point quaternion used for 3D rotations. More...

Inheritance diagram for SystemEx.Numeric.Quatd:

Collaboration diagram for SystemEx.Numeric.Quatd:

Public Member Functions
	Quatd ()
	Initializes the identity quaternion (1,0,0,0).
	Quatd (Vec3d angles)
	Initializes a quaternion from Euler angles (XYZ order).
	Quatd (double fs, double fx, double fy, double fz)
	Initializes a quaternion from explicit components.
	Quatd (double[] pfs)
	Initializes a quaternion from a double array.
	Quatd (AxisAngle< Vec3d, double > axisAngle)
	Initializes a quaternion from an axis‑angle representation.
	Quatd (Quatd other)
	Copy constructor.
double	Get (int index)
	Gets a component by index .
Vec3d	GetRotationAxis ()
	Computes the normalized rotation axis of this quaternion.
double	GetRotationAngle ()
	Returns the rotation angle represented by this quaternion.
CompareResult	CompareTo (Quatd a)
	Compares two quaternions using the configured CompareMode.
int IComparable< Quatd >.	CompareTo (Quatd other)
int	CompareTo (object? obj)
	Compares this quaternion to another object.
bool	Equals (Quatd other)
FixedVector< byte >	ToBytes ()
	Converts the vector into a deterministic byte sequence.
override int	GetHashCode ()
	Computes a hash code for this vector.
override bool	Equals (object? obj)
	Determines whether this instance is equal to another object.
Public Member Functions inherited from SystemEx.IComparableEx< T >
CompareResult	CompareTo (T a)
	Compares this instance with the specified value and returns a CompareResult describing the relationship between them.

Static Public Member Functions
static AxisAngle< Vec3d, double >	ToAxisAngle (Quatd q)
	Converts a quaternion into an axis‑angle representation.
static Quatd	FromAxis (AxisAngle< Vec3d, double > axisAngle)
	Creates a quaternion from an axis‑angle representation.
static bool	IsIdentity (Quatd v)
	Determines whether a quaternion is the identity rotation.
static Quatd	Exponent (Quatd v)
	Computes the quaternion exponential.
static Quatd	Logarithm (Quatd v)
	Computes the quaternion logarithm.
static double	LenghtSqrt (Quatd v)
	Computes the Euclidean length of the quaternion.
static double	Lenght (Quatd v)
	Computes the squared length of the quaternion.
static Quatd	Power (Quatd v, double Exp)
	Raises a quaternion to a scalar power.
static double	DotProduct (Quatd a, Quatd b)
	Computes the DotProduct product of two quaternions.
static Quatd	Invert (Quatd q)
	Computes the inverse of a quaternion.
static Quatd	Normalize (Quatd v)
	Normalizes a quaternion to unit length.
static Quatd	Conjugate (Quatd v)
	Computes the quaternion conjugate.
static Quatd	Slerp (Quatd q0, Quatd q1, double t)
	Performs spherical linear interpolation between two quaternions.
static Quatd	operator* (Quatd a, Quatd b)
	Multiplies two Quatd component‑wise.
static Quatd	operator* (double a, Quatd b)
	Multiplicate a double with a quaternion.
static Quatd	operator* (Quatd a, double b)
	Multiplicate a quaternion with a double.
static Quatd	operator+ (Quatd a, Quatd b)
	Adds two Quatd component‑wise.
static Quatd	operator- (Quatd a, Quatd b)
	Subtracts two Quatd component‑wise.
static Quatd	operator- (Quatd a)
	Invert.
static Quatd	operator/ (Quatd a, Quatd b)
	Divides two Quatd component‑wise.
static Quatd	operator/ (Quatd a, double b)
	Divides both components of the Quatd by a double.

Properties
double	S [get, set]
	Gets or sets the scalar component (w) of the quaternion.
Vec3d	V [get, set]
	Gets or sets the vector component (x,y,z) of the quaternion.
double	X [get, set]
	Gets or sets the X component of the quaternion's vector part.
double	Y [get, set]
	Gets or sets the Y component of the quaternion's vector part.
double	Z [get, set]
	Gets or sets the Z component of the quaternion's vector part.
AxisAngle< Vec3d, double >	AxisAngle [get]
	Gets the axis‑angle representation of this quaternion.
CompareType	CompareMode [get, set]
	Gets or sets the comparison mode used by CompareTo(Quatd).

Detailed Description

Represents a doubleing‑point quaternion used for 3D rotations.

Quatd stores a scalar component w and a vector component (x,y,z) in a sequential memory layout, making it suitable for native interop, compute kernels, and deterministic hashing.

The struct is annotated with HashAlgorithmAttribute to enable attribute‑driven hashing via HashFactory.
BernsteinHash is used because it is fast, byte‑linear, and ideal for small fixed‑size numeric types.

Quatd implements multiple comparison and hashing interfaces:

• IComparable and IComparable<T> for ordering
• IEquatable<T> for equality checks
• IHashable<T> for deterministic byte‑level hashing

Constructor & Destructor Documentation

Quatd() [1/6]

SystemEx.Numeric.Quatd.Quatd

(

)

Initializes the identity quaternion (1,0,0,0).

                        {
            m_v = new Vec3d(0);
            m_s = 1.0;
            m_comparebleMode = CompareType.Skalar;
        }

Here is the caller graph for this function:

Quatd() [2/6]

SystemEx.Numeric.Quatd.Quatd

(

Vec3d

angles

)

Initializes a quaternion from Euler angles (XYZ order).

                                      {
            double cos_z_2 = System.Math.Cos(0.5*angles.Z);
            double cos_y_2 = System.Math.Cos(0.5*angles.Y);
            double cos_x_2 = System.Math.Cos(0.5*angles.X);
 
            double sin_z_2 = System.Math.Sin(0.5*angles.Z);
            double sin_y_2 = System.Math.Sin(0.5*angles.Y);
            double sin_x_2 = System.Math.Sin(0.5*angles.X);
 
            // and now compute quaternion
            m_s = cos_z_2 * cos_y_2 * cos_x_2 + sin_z_2 * sin_y_2 * sin_x_2;
            m_v = new Vec3d
            (
                cos_z_2 * cos_y_2 * sin_x_2 - sin_z_2 * sin_y_2 * cos_x_2,
                cos_z_2 * sin_y_2 * cos_x_2 + sin_z_2 * cos_y_2 * sin_x_2,
                sin_z_2 * cos_y_2 * cos_x_2 - cos_z_2 * sin_y_2 * sin_x_2
            );
            m_comparebleMode = CompareType.Skalar;
        }

Quatd() [3/6]

SystemEx.Numeric.Quatd.Quatd	(	double	fs,
		double	fx,
		double	fy,
		double	fz )

Initializes a quaternion from explicit components.

                                                                    {
            m_s = fs;
            m_v = new Vec3d(fx, fy, fz);
            m_comparebleMode = CompareType.Skalar;
        }

Quatd() [4/6]

SystemEx.Numeric.Quatd.Quatd

(

double[]

pfs

)

Initializes a quaternion from a double array.

                                      {
            m_s = pfs[0];
            m_v = new Vec3d(pfs[1], pfs[2], pfs[3]);
            m_comparebleMode = CompareType.Skalar;
        }

Quatd() [5/6]

SystemEx.Numeric.Quatd.Quatd

(

AxisAngle< Vec3d, double >

axisAngle

)

Initializes a quaternion from an axis‑angle representation.

                                                            {
            var tmp = FromAxis(axisAngle);
            m_s = tmp.m_s;
            m_v = tmp.m_v;
            m_comparebleMode = CompareType.Skalar;
        }

Here is the call graph for this function:

Quatd() [6/6]

SystemEx.Numeric.Quatd.Quatd

(

Quatd

other

)

Copy constructor.

                                     {
            m_s = other.m_s;
            m_v = other.m_v;
            m_comparebleMode = CompareType.Skalar;
        }

Here is the call graph for this function:

Member Function Documentation

CompareTo() [1/3]

int SystemEx.Numeric.Quatd.CompareTo

(

object?

obj

)

Compares this quaternion to another object.

                                             {
            if ( (obj is Quatd) ) {
                return (int)CompareTo((Quatd)(obj));
            }
            throw new ArgumentException("Object is not a Quatd object");
        }

Here is the call graph for this function:

CompareTo() [2/3]

CompareResult SystemEx.Numeric.Quatd.CompareTo

(

Quatd

a

)

Compares two quaternions using the configured CompareMode.

                                                   {
 
            CompareResult _ret = CompareResult.Equal;
 
            double _a = 0;
            double _b = 0;
 
            switch ( m_comparebleMode ) {
            case CompareType.Skalar:
            _ret = (CompareResult)m_s.CompareTo(a.m_s);
            break;
            case CompareType.Norm:
            _a = m_s * m_s + Vec3d.Lenght(m_v);
            _b = a.m_s * a.m_s + Vec3d.Lenght(a.m_v);
            _ret = (CompareResult)_a.CompareTo(_b);
            break;
            case CompareType.Rotation:
            _a = GetRotationAngle();
            _b = a.GetRotationAngle();
            _ret = (CompareResult)_a.CompareTo(_b);
            break;
            }
            return _ret;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

CompareTo() [3/3]

int IComparable< Quatd >. SystemEx.Numeric.Quatd.CompareTo

(

Quatd

other

)

                                                         {
            return (int)CompareTo(other);
        }

Conjugate()

Quatd SystemEx.Numeric.Quatd.Conjugate ( Quatd v )

static

Computes the quaternion conjugate.

                                                  {
            Quatd temp = new Quatd( v);
 
            temp.m_v.X = -temp.m_v.X;
            temp.m_v.Y = -temp.m_v.Y;
            temp.m_v.Z = -temp.m_v.Z;
 
            return temp;
        }

Here is the call graph for this function:

DotProduct()

double SystemEx.Numeric.Quatd.DotProduct ( Quatd a, Quatd b )

static

Computes the DotProduct product of two quaternions.

                                                             {
            return a.m_s * b.m_s +
                   a.m_v.X * b.m_v.X +
                   a.m_v.Y * b.m_v.Y +
                   a.m_v.Z * b.m_v.Z;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Equals() [1/2]

override bool SystemEx.Numeric.Quatd.Equals

(

object?

obj

)

Determines whether this instance is equal to another object.

The object is considered equal if it is a Quatd and compares equal using Equals(Quatd).

Parameters

obj	The object to compare with.

Returns

true if obj is a Quatd and equal to this instance; otherwise false.

                                                    {
            if ( obj == null ) return false;
            return (obj is Quatd) && Equals((Quatd)obj);
        }

Here is the call graph for this function:

Equals() [2/2]

bool SystemEx.Numeric.Quatd.Equals

(

Quatd

other

)

                                           {
            return m_s == other.m_s && m_v == other.m_v;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Exponent()

Quatd SystemEx.Numeric.Quatd.Exponent ( Quatd v )

static

Computes the quaternion exponential.

                                                 {
            double Mul;
 
            Quatd temp = new Quatd( v);
            double Length = Vec3d.LenghtSqrt(temp.m_v);
 
            if ( Length > 1.0e-4f )
                Mul = System.Math.Sin(Length) / Length;
            else
                Mul = 1.0;
 
            temp.m_s = System.Math.Cos(Length);
 
            temp.m_v.X *= Mul;
            temp.m_v.Y *= Mul;
            temp.m_v.Z *= Mul;
 
            return temp;
        }

Here is the call graph for this function:

FromAxis()

Quatd SystemEx.Numeric.Quatd.FromAxis ( AxisAngle< Vec3d, double > axisAngle )

static

Creates a quaternion from an axis‑angle representation.

                                                                            {
 
            double len = Vec3d.LenghtSqrt(axisAngle.Axis);
            Quatd temp = new Quatd();
 
            if ( len > 1e-12 ) {
                double inv = 1.0 / len;
 
                // Achse normalisieren
                double nx = axisAngle.Axis.X * inv;
                double ny = axisAngle.Axis.Y * inv;
                double nz = axisAngle.Axis.Z * inv;
 
                double omega = 0.5f * axisAngle.Angle;
                double s = System.Math.Sin(omega);
 
                temp.m_v = new Vec3d(s * nx, s * ny, s * nz);
                temp.m_s = System.Math.Cos(omega);
            } else {
                // Ungültige Achse → Identity
                temp.m_s = 1.0;
                temp.m_v = Vec3d.Zero;
            }
 
            return Normalize(temp);
 
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Get()

double SystemEx.Numeric.Quatd.Get

(

int

index

)

Gets a component by index .

                                        {
            return index switch
            {
                0 => S,
                1 => X,
                2 => Y,
                3 => Z,
                _ => throw new ArgumentOutOfRangeException(nameof(index))
            };
        }

Here is the caller graph for this function:

GetHashCode()

override int SystemEx.Numeric.Quatd.GetHashCode

(

)

Computes a hash code for this vector.

The primary hash is generated using HashFactory and the HashAlgorithmAttribute applied to this struct.
If hashing fails (rare), a fallback XOR‑based hash is used.

                                           {
            var x =  HashFactory.Hash32(this, 674545);
            if ( x.Value != 0 ) return (int)x.Value;
 
            return m_v.GetHashCode() ^ m_s.GetHashCode();
 
        }

GetRotationAngle()

double SystemEx.Numeric.Quatd.GetRotationAngle

(

)

Returns the rotation angle represented by this quaternion.

                                          {
            double s = System.Math.Clamp(m_s, -1.0, 1.0);
            double thetaOver2 = System.Math.Acos(s);
            return thetaOver2 * 2.0;
        }

Here is the caller graph for this function:

GetRotationAxis()

Vec3d SystemEx.Numeric.Quatd.GetRotationAxis

(

)

Computes the normalized rotation axis of this quaternion.

                                        {
            double sinThetaOver2Sq = 1.0 - m_s * m_s;
 
            if ( sinThetaOver2Sq <= 0.0 ) {
                return new Vec3d(1.0, 0.0, 0.0);
            }
            double   oneOverSinThetaOver2 = 1.0 / System.Math.Sqrt(sinThetaOver2Sq);
 
            return Vec3d.Normalize(new Vec3d(
                m_v.X * oneOverSinThetaOver2,
                m_v.Y * oneOverSinThetaOver2,
                m_v.Z * oneOverSinThetaOver2
             ));
 
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Invert()

Quatd SystemEx.Numeric.Quatd.Invert ( Quatd q )

static

Computes the inverse of a quaternion.

                                               {
            double temp = Lenght(q);
            Quatd tq = new Quatd(q);
 
            tq.m_s /= temp;
            tq.m_v.X /= -temp;
            tq.m_v.Y /= -temp;
            tq.m_v.Z /= -temp;
            return tq;       // Okay, same norm.
        }

Here is the call graph for this function:

Here is the caller graph for this function:

IsIdentity()

bool SystemEx.Numeric.Quatd.IsIdentity ( Quatd v )

static

Determines whether a quaternion is the identity rotation.

                                                  {
            return v.m_v == Vec3d.Zero && System.Math.Abs(v.m_s - 1.0) <= 0.00001f;
        }

Here is the call graph for this function:

Lenght()

double SystemEx.Numeric.Quatd.Lenght ( Quatd v )

static

Computes the squared length of the quaternion.

                                                {
            return (v.m_s * v.m_s +
                v.m_v.X * v.m_v.X +
                v.m_v.Y * v.m_v.Y +
                v.m_v.Z * v.m_v.Z);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

LenghtSqrt()

double SystemEx.Numeric.Quatd.LenghtSqrt ( Quatd v )

static

Computes the Euclidean length of the quaternion.

                                                    {
            return System.Math.Sqrt(v.m_s *
                                    v.m_s + v.m_v.X *
                                    v.m_v.X + v.m_v.Y *
                                    v.m_v.Y + v.m_v.Z *
                                    v.m_v.Z);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Logarithm()

Quatd SystemEx.Numeric.Quatd.Logarithm ( Quatd v )

static

Computes the quaternion logarithm.

                                                  {
 
            Quatd temp = new Quatd( v);
 
            double vLen = Vec3d.LenghtSqrt(temp.m_v);
            double angle = System.Math.Atan2(vLen, temp.m_s);
 
            temp.m_s = 0.0;
 
            if ( vLen > 1e-6 ) {
                double scale = angle / vLen;
                temp.m_v.X *= scale;
                temp.m_v.Y *= scale;
                temp.m_v.Z *= scale;
            } else {
                temp.m_v = Vec3d.Zero;
            }
 
            return temp;
        }

Here is the call graph for this function:

Normalize()

Quatd SystemEx.Numeric.Quatd.Normalize ( Quatd v )

static

Normalizes a quaternion to unit length.

                                                  {
            double norme = LenghtSqrt(v);
            Quatd temp = new Quatd(v);
 
            if ( norme < 1e-12f ) {
                temp.m_s = 1.0;
                temp.m_v = new Vec3d(0, 0, 0);
            } else {
                double recip = 1.0/norme;
 
                temp.m_s *= recip;
                temp.m_v.X *= recip;
                temp.m_v.Y *= recip;
                temp.m_v.Z *= recip;
            }
            return temp;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

operator*() [1/3]

Quatd SystemEx.Numeric.Quatd.operator* ( double a, Quatd b )

static

Multiplicate a double with a quaternion.

                                                             {
            Quatd _ret = new Quatd();
 
            _ret.m_s = a * b.m_s;
            _ret.m_v = a * b.m_v;
 
            return _ret;
        }

Here is the call graph for this function:

operator*() [2/3]

Quatd SystemEx.Numeric.Quatd.operator* ( Quatd a, double b )

static

Multiplicate a quaternion with a double.

                                                             {
            Quatd _ret = new Quatd();
 
            _ret.m_s = a.m_s * b;
            _ret.m_v = a.m_v * b;
 
            return _ret;
        }

Here is the call graph for this function:

operator*() [3/3]

Quatd SystemEx.Numeric.Quatd.operator* ( Quatd a, Quatd b )

static

Multiplies two Quatd component‑wise.

                                                            {
            Quatd qtmp = new Quatd();
 
            double ax = a.m_v.X;
            double ay = a.m_v.Y;
            double az = a.m_v.Z;
 
            double bx = b.m_v.X;
            double by = b.m_v.Y;
            double bz = b.m_v.Z;
 
            double as_ = a.m_s;
            double bs_ = b.m_s;
 
            // Skalarteil
            qtmp.m_s = as_ * bs_ - ax * bx - ay * by - az * bz;
 
            // Vektorteil
            qtmp.m_v = new Vec3d(
                as_ * bx + bs_ * ax + ay * bz - az * by,
                as_ * by + bs_ * ay + az * bx - ax * bz,
                as_ * bz + bs_ * az + ax * by - ay * bx
            );
 
            return qtmp;
        }

Here is the call graph for this function:

operator+()

Quatd SystemEx.Numeric.Quatd.operator+ ( Quatd a, Quatd b )

static

Adds two Quatd component‑wise.

                                                            {
            return new Quatd(
                a.m_s + b.m_s,
                a.m_v.X + b.m_v.X,
                a.m_v.Y + b.m_v.Y,
                a.m_v.Z + b.m_v.Z
            );
        }

Here is the call graph for this function:

operator-() [1/2]

Quatd SystemEx.Numeric.Quatd.operator- ( Quatd a )

static

Invert.

                                                   {
            return new Quatd(
                -a.m_s,
                -a.m_v.X,
                -a.m_v.Y,
                -a.m_v.Z
            );
        }

Here is the call graph for this function:

operator-() [2/2]

Quatd SystemEx.Numeric.Quatd.operator- ( Quatd a, Quatd b )

static

Subtracts two Quatd component‑wise.

                                                            {
            return new Quatd(
                a.m_s - b.m_s,
                a.m_v.X - b.m_v.X,
                a.m_v.Y - b.m_v.Y,
                a.m_v.Z - b.m_v.Z
            );
        }

Here is the call graph for this function:

operator/() [1/2]

Quatd SystemEx.Numeric.Quatd.operator/ ( Quatd a, double b )

static

Divides both components of the Quatd by a double.

                                                             {
            Quatd _ret = new Quatd();
 
            _ret.m_s = a.m_s / b;
            _ret.m_v = a.m_v / b;
 
            return _ret;
        }

Here is the call graph for this function:

operator/() [2/2]

Quatd SystemEx.Numeric.Quatd.operator/ ( Quatd a, Quatd b )

static

Divides two Quatd component‑wise.

                                                            {
            return a * Invert(b);
        }

Here is the call graph for this function:

Power()

Quatd SystemEx.Numeric.Quatd.Power ( Quatd v, double Exp )

static

Raises a quaternion to a scalar power.

                                                          {
            if ( System.Math.Abs(v.m_s) > .9999f ) {
                return v;
            }
 
            // Erhalte halbe angle alpha (alpha = theta/2)
            double   alpha = System.Math.Acos(v.m_s);
 
            // Berechne neuen alpha Wert
            double   newAlpha = alpha * Exp;
 
            // Berechne neuen s wert
            Quatd result = new Quatd();
            result.m_s = System.Math.Cos(newAlpha);
 
            // Berechne neue xyz Werte
 
            double   mult = System.Math.Sin(newAlpha) / System.Math.Sin(alpha);
            result.m_v.X = v.m_v.X * mult;
            result.m_v.Y = v.m_v.Y * mult;
            result.m_v.Z = v.m_v.Z * mult;
 
            return Normalize(result);
        }

Here is the call graph for this function:

Slerp()

Quatd SystemEx.Numeric.Quatd.Slerp ( Quatd q0, Quatd q1, double t )

static

Performs spherical linear interpolation between two quaternions.

                                                                   { // Spherical linear interpolation. 
            if ( t <= 0.0 ) return q0;
            if ( t >= 1.0 ) return q1;
 
            double cosOmega = DotProduct(q0, q1);
 
            double q1w = q1.m_s;
            double q1x = q1.m_v.X;
            double q1y = q1.m_v.Y;
            double q1z = q1.m_v.Z;
 
            if ( cosOmega < 0.0 ) {
                q1w = -q1w;
                q1x = -q1x;
                q1y = -q1y;
                q1z = -q1z;
                cosOmega = -cosOmega;
            }
 
            Debug.Assert(cosOmega < 1.0);
 
            // Compute interpolation fraction, checking for quaternions
            // almost exactly the same
 
            double k0, k1;
            if ( cosOmega > 0.9999 ) {
                k0 = 1.0 - t;
                k1 = t;
            } else {
                // Compute the sin of the angle using the
                // trig identity sin^2(omega) + cos^2(omega) = 1
 
                double sinOmega = System.Math.Sqrt(1.0 - cosOmega*cosOmega);
 
                // Compute the angle from its sin and cosine
 
                double omega = System.Math.Atan2(sinOmega, cosOmega);
 
                // Compute inverse of denominator, so we only have
                // to divide once
 
                double oneOverSinOmega = 1.0 / sinOmega;
 
                // Compute interpolation parameters
 
                k0 = System.Math.Sin((1.0 - t) * omega) * oneOverSinOmega;
                k1 = System.Math.Sin(t * omega) * oneOverSinOmega;
            }
 
            // Interpolate
 
            Quatd result = new Quatd();
 
            result.m_v.X = k0 * q0.m_v.X + k1 * q1x;
            result.m_v.Y = k0 * q0.m_v.Y + k1 * q1y;
            result.m_v.Z = k0 * q0.m_v.Z + k1 * q1z;
            result.m_s = k0 * q0.m_s + k1 * q1w;
 
            // Return it
 
            return result;
        }

Here is the call graph for this function:

ToAxisAngle()

AxisAngle< Vec3d, double > SystemEx.Numeric.Quatd.ToAxisAngle ( Quatd q )

static

Converts a quaternion into an axis‑angle representation.

                                                                       {
            AxisAngle<Vec3d, double> _ret = new AxisAngle<Vec3d, double>();
 
            _ret.Angle = q.GetRotationAngle();
            _ret.Axis = q.GetRotationAxis();
 
            return _ret;
        }

Here is the call graph for this function:

ToBytes()

FixedVector< byte > SystemEx.Numeric.Quatd.ToBytes

(

)

Converts the vector into a deterministic byte sequence.

This method is used by HashFactory to compute attribute‑driven hashes. The byte layout is stable and platform‑safe, ensuring consistent hashing across devices and backends.

Implements SystemEx.Hash.IHashable< T >.

                                            {
            Cache m = new Cache(sizeof(double) * 4);
 
            for ( byte i = 0 ; i < 4 ; i++ )
                m.WriteRange((ulong)(sizeof(double) * i), Get(i).ToBytes());
 
            return m.ToArrayEx();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Property Documentation

AxisAngle

AxisAngle<Vec3d, double> SystemEx.Numeric.Quatd.AxisAngle

get

Gets the axis‑angle representation of this quaternion.

CompareMode

CompareType SystemEx.Numeric.Quatd.CompareMode

getset

Gets or sets the comparison mode used by CompareTo(Quatd).

{ get => m_comparebleMode; set => m_comparebleMode = value; }

S

double SystemEx.Numeric.Quatd.S

getset

Gets or sets the scalar component (w) of the quaternion.

{ get => m_s; set => m_s = value; }

V

Vec3d SystemEx.Numeric.Quatd.V

getset

Gets or sets the vector component (x,y,z) of the quaternion.

{ get => m_v; set => m_v = value; }

X

double SystemEx.Numeric.Quatd.X

getset

Gets or sets the X component of the quaternion's vector part.

{ get => m_v.X; set => m_v.X = value; }

Y

double SystemEx.Numeric.Quatd.Y

getset

Gets or sets the Y component of the quaternion's vector part.

{ get => m_v.Y; set => m_v.Y = value; }

Z

double SystemEx.Numeric.Quatd.Z

getset

Gets or sets the Z component of the quaternion's vector part.

{ get => m_v.Z; set => m_v.Z = value; }

---

The documentation for this struct was generated from the following file:

• Quatd.cs