Numeric

Represents a 16‑bit IEEE‑754 binary16 floating‑point value with full bit‑level control over sign, exponent, and mantissa. More...

Collaboration diagram for Numeric:

Topics
	Conversition
	Provides extension methods for converting between different vector types (float, double, int) and dimensions (2D, 3D, 4D).

Classes
struct	SystemEx.Numeric.AxisAngle< TV, T >
	Represents a rotation in 3D space using an axis‑angle pair. More...
struct	SystemEx.Numeric.Half16
interface	SystemEx.Numeric.IHalf< T >
struct	SystemEx.Numeric.Quatd
	Represents a doubleing‑point quaternion used for 3D rotations. More...
struct	SystemEx.Numeric.Quatf
	Represents a floating‑point quaternion used for 3D rotations. More...
struct	SystemEx.Numeric.Vec2d
struct	SystemEx.Numeric.Vec2f
struct	SystemEx.Numeric.Vec2i
struct	SystemEx.Numeric.Vec3d
struct	SystemEx.Numeric.Vec3f
struct	SystemEx.Numeric.Vec3i
struct	SystemEx.Numeric.Vec4d
struct	SystemEx.Numeric.Vec4f
struct	SystemEx.Numeric.Vec4i

Enumerations
enum	SystemEx.Numeric.CompareType { SystemEx.Numeric.CompareType.Skalar , SystemEx.Numeric.CompareType.Norm , SystemEx.Numeric.CompareType.Rotation }
	Defines the comparison mode used by Quatf. More...

Variables
TV	SystemEx.Numeric.AxisAngle< TV, T >.Axis
	The rotation axis. Does not need to be normalized.
T	SystemEx.Numeric.AxisAngle< TV, T >.Angle
	The rotation angle in radians.

Detailed Description

Represents a 16‑bit IEEE‑754 binary16 floating‑point value with full bit‑level control over sign, exponent, and mantissa.

Represents a 2‑component inting‑point vector.

Represents a 2‑component floating‑point vector.

Represents a 2‑component doubleing‑point vector.

Defines the structural layout of a 16‑bit floating format. Implementations specify how many bits are used for sign, exponent and mantissa, including exponent bias and bit positions.

Half16 is a deterministic, platform‑independent implementation of the half‑precision format. Unlike System.Half, this type exposes all internal fields, supports manual construction, and implements full arithmetic without converting to float.

The struct is sequentially laid out and marked with HashAlgorithmAttribute so that hashing can be performed deterministically using SystemEx hashing algorithms.

Half16 also implements IHashable<Half16> so that instances can be converted into a deterministic byte sequence for hashing or serialization.

Vec2d is a lightweight numeric type used throughout SystemEx for geometry, math utilities, device operations, and compute kernels. It stores two double values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec2d implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec2f is a lightweight numeric type used throughout SystemEx for geometry, math utilities, device operations, and compute kernels. It stores two float values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec2f implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec2i is a lightweight numeric type used throughout SystemEx for geometry, math utilities, device operations, and compute kernels. It stores two int values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec2i implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec3d is a lightweight numeric type used throughout SystemEx for geometry, math utilities, device operations, and compute kernels. It stores two double values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec3d implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec3f is a lightweight numeric type used throughout SystemEx for geometry, math utilities, device operations, and compute kernels. It stores two float values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec3f implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec3i is a lightweight numeric type used throughout SystemEx for geometry, math utilities, device operations, and compute kernels. It stores two int values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec3i implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec4d is a lightweight numeric type used throughout SystemEx for geometry, Math utilities, device operations, and compute kernels. It stores two double values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec4d implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec4f is a lightweight numeric type used throughout SystemEx for geometry, MathF utilities, device operations, and compute kernels. It stores two float values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec4f implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

Vec4i is a lightweight numeric type used throughout SystemEx for geometry, Math utilities, device operations, and compute kernels. It stores two int values (X and Y) in a sequential memory layout, making it compatible with native interop and high‑performance compute backends.

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 such as vectors.

Vec4i implements multiple comparison and hashing interfaces:

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

This makes the type suitable for use in dictionaries, sorting, spatial hashing, and compute pipelines.

---

Class Documentation

SystemEx::Numeric::AxisAngle-2-g

struct SystemEx::Numeric::AxisAngle-2-g

Represents a rotation in 3D space using an axis‑angle pair.

Class Members
T	Angle	The rotation angle in radians.
TV	Axis	The rotation axis. Does not need to be normalized.

Enumeration Type Documentation

CompareType

enum SystemEx.Numeric.CompareType

Defines the comparison mode used by Quatf.

Enumerator
Skalar	Compares quaternions by their scalar component w.
Norm	Compares quaternions by their norm (length).
Rotation	Compares quaternions by their rotation angle.

                            {
        Skalar,

        Norm,

        Rotation
    }

Variable Documentation

Angle

T SystemEx.Numeric.AxisAngle< TV, T >.Angle

The rotation angle in radians.

Axis

TV SystemEx.Numeric.AxisAngle< TV, T >.Axis

The rotation axis. Does not need to be normalized.