Inheritance diagram for SystemEx.Numeric.Half16:

Collaboration diagram for SystemEx.Numeric.Half16:

Public Member Functions
	Half16 (ushort value)
	Creates a Half16 from a raw 16‑bit value.
	Half16 (ushort sign, ushort exponent, ushort mantissa)
	Creates a Half16 from explicit sign, exponent, and mantissa fields.
ushort	AsUShort ()
	Returns the raw 16‑bit representation.
byte[]	ToBytes (Endian endian)
	Converts the value into a byte array using the specified endianness.
CompareResult	CompareTo (Half16 b)
	Compares this instance with another Half16 and returns a CompareResult describing the relationship.
override int	GetHashCode ()
	Returns a hash code for this instance.
bool	Equals (Half16 other)
	Determines whether this instance is equal to another Half16 value, using the same semantics as the operator ==(Half16,Half16).
override bool	Equals (object? obj)
	Determines whether this instance is equal to another object.
int	CompareTo (object? obj)
	Compares this instance with another object and returns an integer indicating the relative order, following the standard IComparable contract.
int IComparable< Half16 >.	CompareTo (Half16 other)
	Explicit IComparable<T> implementation that forwards to the extended CompareTo(Half16) method and casts the CompareResult to int.
FixedVector< byte >	ToBytes ()
	Converts this instance into a deterministic byte array suitable for hashing, serialization, or low‑level processing.
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 Half16	Max (Half16 x, Half16 y)
	Returns the larger of two Half16 values.
static Half16	Min (Half16 x, Half16 y)
	Returns the smaller of two Half16 values.
static Half16	Abs (Half16 x)
	Returns the absolute value of the given Half16.
static Half16	FromBytes (byte[] input, int offsets, Endian endian)
	Constructs a Half16 from a byte array.
static bool	IsZero (Half16 value)
	Returns true if the value is +0 or −0.
static bool	IsNegative (Half16 val)
	Returns true if the value is negative.
static bool	IsNaN (Half16 val)
	Returns true if the value is a NaN.
static bool	IsInfinity (Half16 val)
	Returns true if the value is ±infinity.
static Half16	Signum (Half16 x)
	Returns −1, 0, or +1 depending on the sign of the value.
static Half16	Clamp (Half16 x, Half16 min, Half16 max)
	Clamps the value between the specified minimum and maximum.
static bool	IsFinite (Half16 x)
	Returns true if the value is finite (not NaN or infinity).
static bool	IsSubnormal (Half16 x)
	Returns true if the value is a subnormal number.
static bool	IsNormal (Half16 x)
	Returns true if the value is a normal (non‑subnormal, non‑special) number.
static Half16	Floor (Half16 x)
	Computes the floor of the value.
static Half16	Ceil (Half16 x)
	Computes the ceiling of the value.
static Half16	Trunc (Half16 x)
	Truncates the fractional part of the value.
static bool	IsInteger (Half16 x)
	Returns true if the value is an integer.
static bool	operator< (Half16 a, Half16 b)
	Less‑than comparison operator with full IEEE‑754 semantics.
static bool	operator<= (Half16 a, Half16 b)
	Less‑than‑or‑equal comparison operator.
static bool	operator> (Half16 a, Half16 b)
	Greater‑than operator.
static bool	operator>= (Half16 a, Half16 b)
	Greater‑than‑or‑equal operator.
static bool	operator!= (Half16 a, Half16 b)
	Inequality operator.
static Half16	operator+ (Half16 a, Half16 b)
	Addition operator.
static Half16	operator- (Half16 a, Half16 b)
	Subtraction operator.
static Half16	operator* (Half16 a, Half16 b)
	Multiplication operator.
static Half16	operator/ (Half16 a, Half16 b)
	Division operator.
static Half16	operator++ (Half16 a)
	Increment operator.
static Half16	operator-- (Half16 a)
	Decrement operator.
static Half16	Normalize (ushort sign, int exp, uint mant)
	Normalizes a mantissa/exponent pair into a valid Half16 value.
static uint	RoundToNearestEven (uint mant)
	Rounds a mantissa using round‑to‑nearest‑even.
static Half16	Negate (Half16 h)
	Returns the negated value.
static bool	operator== (Half16 a, Half16 b)
	Equality operator with IEEE‑754 zero handling.
static Half16	Mul (Half16 a, Half16 b)
	Multiplies two Half16 values using full bit‑level arithmetic.
static Half16	Add (Half16 a, Half16 b)
	Adds two Half16 values using full IEEE‑754 style mantissa/exponent arithmetic, including handling of special values such as NaN, infinities, and signed zero.
static Half16	Div (Half16 a, Half16 b)
	Divides one Half16 value by another using full mantissa/exponent arithmetic.

Properties
ushort	SignBits `[get]`
	Number of bits used for the sign field (always 1).
ushort	ExponentBits `[get]`
	Number of bits used for the exponent field (IEEE‑754 binary16 uses 5).
ushort	MantissaBits `[get]`
	Number of bits used for the mantissa (fraction) field (10 bits).
ushort	ExponentBias `[get]`
	Exponent bias used by the binary16 format (15).
ushort	TotalBits `[get]`
	Total number of bits in the representation (16).
bool	Sign `[get]`
	Gets the sign bit (true = negative).
ushort	Exponent `[get]`
	Gets the exponent field (5 bits).
ushort	Mantissa `[get]`
	Gets the mantissa (fraction) field (10 bits).
static Half16	Zero `[get]`
	Represents +0.
static Half16	One `[get]`
	Represents +1.
static Half16	NegativeOne `[get]`
	Represents −1.
static Half16	PositiveInfinity `[get]`
	Represents positive infinity.
static Half16	NegativeInfinity `[get]`
	Represents negative infinity.
static Half16	Epsilon `[get]`
	Smallest representable positive increment.
static Half16	NaN `[get]`
	Quiet NaN value.
static Half16	NaN2 `[get]`
	Alternative NaN encoding.
static Half16	MinValue `[get]`
	Smallest representable negative value.
static Half16	MaxValue `[get]`
	Largest representable positive value.
static Half16	E `[get]`
	Euler's number (approximation).
static Half16	Pi `[get]`
	π (approximation).
static Half16	Tau `[get]`
	τ = 2π (approximation).

Constructor & Destructor Documentation

◆ Half16() [1/2]

SystemEx.Numeric.Half16.Half16 ( ushort value )

Creates a Half16 from a raw 16‑bit value.

                                       {
            m_value = value;
        }

Here is the caller graph for this function:

◆ Half16() [2/2]

SystemEx.Numeric.Half16.Half16	(	ushort	sign,
		ushort	exponent,
		ushort	mantissa )

Creates a Half16 from explicit sign, exponent, and mantissa fields.

                                                                        {
            m_value = (ushort)((sign << 15) | (exponent << 10) | mantissa);
        }

Member Function Documentation

◆ Abs()

Half16 SystemEx.Numeric.Half16.Abs ( Half16 x )

static

Returns the absolute value of the given Half16.

159 =>

160 new Half16(0, x.Exponent, x.Mantissa);

Here is the call graph for this function:

◆ Add()

Half16 SystemEx.Numeric.Half16.Add	(	Half16	a,
		Half16	b )

static

Adds two Half16 values using full IEEE‑754 style mantissa/exponent arithmetic, including handling of special values such as NaN, infinities, and signed zero.

The operation is performed entirely in the half‑precision domain without converting to float or double.

Parameters

a	The left operand.
b	The right operand.

Returns: The sum a + b as a Half16 value. If the operation is undefined (e.g. +∞ + −∞), NaN is returned.

                                                        {
            if ( IsNaN(a) || IsNaN(b) ) return Half16.NaN;
            if ( IsInfinity(a) && IsInfinity(b) && a.Sign != b.Sign ) return Half16.NaN;
 
            // Sonderfälle
            if ( IsInfinity(a) ) return a;
            if ( IsInfinity(b) ) return b;
 
            if ( IsZero(a) ) return b;
            if ( IsZero(b) ) return a;
 
            ushort expA = a.Exponent;
            ushort expB = b.Exponent;
 
            uint mantA = (expA == 0) ? a.Mantissa : (uint)(a.Mantissa | 0x400);
            uint mantB = (expB == 0) ? b.Mantissa: (uint)(b.Mantissa | 0x400);
 
            int exp = expA;
 
            int diff = expA - expB;
 
            if ( diff > 0 ) {
                mantB >>= diff;
            } else if ( diff < 0 ) {
                mantA >>= -diff;
                exp = expB;
            }
 
            uint mant;
            ushort sign;
 
            if ( a.Sign == b.Sign ) {
                mant = mantA + mantB;
                sign = (ushort)(a.Sign ? 1 : 0);
            } else {
                if ( mantA >= mantB ) {
                    mant = mantA - mantB;
                    sign = (ushort)(a.Sign ? 1 : 0);
                } else {
                    mant = mantB - mantA;
                    sign = (ushort)(b.Sign ? 1 : 0);
                }
            }
 
            if ( mant == 0 ) return new Half16(0, 0, 0);
 
            while ( (mant & 0x400) == 0 ) {
                mant <<= 1;
                exp--;
            }
 
            return Normalize(sign, exp, mant);
        }

Here is the call graph for this function:

◆ AsUShort()

ushort SystemEx.Numeric.Half16.AsUShort ( )

Returns the raw 16‑bit representation.

Implements SystemEx.Numeric.IHalf< T >.

180=> m_value;

◆ Ceil()

Half16 SystemEx.Numeric.Half16.Ceil ( Half16 x )

static

Computes the ceiling of the value.

                                               {
            if ( IsNaN(x) || IsInfinity(x) ) return x;
 
            ushort e = x.Exponent;
 
            if ( e >= 15 ) {
                int shift = e - 15;
                uint mant = (uint)(x.Mantissa | 0x400);
                mant >>= shift;
                mant <<= shift;
                return new Half16((ushort)(x.Sign ? 1 : 0), e, (ushort)(mant & 0x3FF));
            }
 
            if ( IsZero(x) ) return x;
 
            return x.Sign ? Zero : One;
        }

Here is the call graph for this function:

◆ Clamp()

Half16 SystemEx.Numeric.Half16.Clamp	(	Half16	x,
		Half16	min,
		Half16	max )

static

Clamps the value between the specified minimum and maximum.

                                                                        {
            if ( x < min ) return min;
            if ( x > max ) return max;
            return x;
        }

Here is the call graph for this function:

◆ CompareTo() [1/3]

CompareResult SystemEx.Numeric.Half16.CompareTo ( Half16 b )

Compares this instance with another Half16 and returns a CompareResult describing the relationship.

NaN is treated as unordered: if this instance is NaN and the other is not, the result is CompareResult.AIsSmallerB to provide a deterministic ordering for sorting and data structures.

Parameters

b	The value to compare with this instance.

Returns: A CompareResult indicating whether this instance is smaller than, equal to, or larger than b .

                                                    {
            CompareResult _ret = CompareResult.Equal;
 
            if ( IsNaN(this) && !IsNaN(b) ) _ret = CompareResult.AIsSmallerB;
 
            else {
                if ( this < b ) _ret = CompareResult.AIsSmallerB;
                else if ( this > b ) _ret = CompareResult.AIsLargerB;
            }
 
            return _ret;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CompareTo() [2/3]

int IComparable< Half16 >. SystemEx.Numeric.Half16.CompareTo ( Half16 other )

Explicit IComparable<T> implementation that forwards to the extended CompareTo(Half16) method and casts the CompareResult to int.

This keeps the standard .NET comparison API compatible while still exposing a strongly typed comparison result via IComparableEx<Half16>.

Parameters

other The value to compare with.

Returns: A signed integer indicating the relative order.

                                                           {
            return (int)CompareTo(other);
        }

Here is the call graph for this function:

◆ CompareTo() [3/3]

int SystemEx.Numeric.Half16.CompareTo ( object? obj )

Compares this instance with another object and returns an integer indicating the relative order, following the standard IComparable contract.

If obj is a Half16, the comparison is delegated to CompareTo(Half16) and the resulting CompareResult is cast to int.

Parameters

obj	The object to compare with.

Returns: A signed integer indicating the relative order: negative if this instance is smaller, zero if equal, positive if larger.

Exceptions

ArgumentException Thrown if obj is not a Half16.

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

Here is the call graph for this function:

◆ Div()

Half16 SystemEx.Numeric.Half16.Div	(	Half16	a,
		Half16	b )

static

Divides one Half16 value by another using full mantissa/exponent arithmetic.

The operation is performed entirely in half‑precision and handles special values (NaN, infinities, signed zero) according to IEEE‑754‑like rules.

Parameters

a	The dividend.
b	The divisor.

Returns: The quotient a / b as a Half16 value. If the operation is undefined (e.g. division by zero, ∞ / ∞), NaN is returned.

                                                     {
            if ( IsNaN(a) || IsNaN(b) ) return Half16.NaN;
            if ( IsZero(b) ) return Half16.NaN;
            if ( IsZero(a) ) return Half16.Zero;
 
            if ( IsInfinity(a) && IsInfinity(b) ) return Half16.NaN;
 
            ushort sign = (ushort)((a.Sign ? 1 : 0) ^ (b.Sign ? 1 : 0) );
 
            if ( IsInfinity(a) ) {
                return new Half16(sign, 0x1F, 0);
            }
            if ( IsInfinity(b) ) return Half16.Zero;
 
            ushort expA = a.Exponent;
            ushort expB = b.Exponent;
 
            uint mantA = (expA == 0) ? a.Mantissa : (uint)(a.Mantissa | 0x400);
            uint mantB = (expB == 0) ? b.Mantissa: (uint)(b.Mantissa | 0x400);
 
            int exp = expA - expB + 15;
 
            uint mant = (mantA << 13) / mantB;
 
            while ( (mant & 0x400) == 0 ) {
                mant <<= 1;
                exp--;
            }
 
            return Normalize(sign, exp, mant);
        }

Here is the call graph for this function:

◆ Equals() [1/2]

bool SystemEx.Numeric.Half16.Equals ( Half16 other )

Determines whether this instance is equal to another Half16 value, using the same semantics as the operator ==(Half16,Half16).

Parameters

other The value to compare with.

Returns: true if the values are equal; otherwise false.

                                            {
            return this == other;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Equals() [2/2]

override bool SystemEx.Numeric.Half16.Equals ( object? obj )

Determines whether this instance is equal to another object.

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

Parameters

obj	The object to compare with.

Returns: true if obj is a Half16 and equal to this instance; otherwise false.

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

Here is the call graph for this function:

◆ Floor()

Half16 SystemEx.Numeric.Half16.Floor ( Half16 x )

static

Computes the floor of the value.

                                                {
            if ( IsNaN(x) || IsInfinity(x) ) return x;
 
            ushort e = x.Exponent;
 
            if ( e >= 15 ) {
                int shift = e - 15;
                uint mant = (uint)(x.Mantissa | 0x400);
                mant >>= shift;
                mant <<= shift;
                return new Half16((ushort)(x.Sign ? 1 : 0), e, (ushort)(mant & 0x3FF));
            }
 
            if ( IsZero(x) ) return x;
 
            return x.Sign ? NegativeOne : Zero;
        }

Here is the call graph for this function:

◆ FromBytes()

Half16 SystemEx.Numeric.Half16.FromBytes	(	byte[]	input,
		int	offsets,
		Endian	endian )

static

Constructs a Half16 from a byte array.

                                                                                    {
            ushort value = input.ToUShort(offsets, endian);
            return new Half16(value);
        }

Here is the call graph for this function:

◆ GetHashCode()

override int SystemEx.Numeric.Half16.GetHashCode ( )

Returns a hash code for this instance.

The hash is computed using HashFactory.Hash32<T>(T,uint) with a fixed seed. If the computed hash is non‑zero, it is used; otherwise the raw ushort value is hashed.

This ensures a deterministic, stable hash suitable for use in dictionaries, sets, and other hash‑based containers.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsFinite()

bool SystemEx.Numeric.Half16.IsFinite ( Half16 x )

static

Returns true if the value is finite (not NaN or infinity).

239 =>

240 x.Exponent != 0x1F;

Here is the call graph for this function:

◆ IsInfinity()

bool SystemEx.Numeric.Half16.IsInfinity ( Half16 val )

static

Returns true if the value is ±infinity.

216 =>

217 (val.Exponent == 0x1F) && (val.Mantissa == 0);

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsInteger()

bool SystemEx.Numeric.Half16.IsInteger ( Half16 x )

static

Returns true if the value is an integer.

                                                  {
            if ( IsNaN(x) || IsInfinity(x) ) return false;
 
            ushort e = x.Exponent;
 
            if ( e < 15 ) return IsZero(x);
 
            int shift = e - 15;
            uint mant = (uint)(x.Mantissa | 0x400);
 
            return (mant & ((1u << shift) - 1)) == 0;
        }

Here is the call graph for this function:

◆ IsNaN()

bool SystemEx.Numeric.Half16.IsNaN ( Half16 val )

static

Returns true if the value is a NaN.

210 =>

211 (val.Exponent == 0x1F) && (val.Mantissa != 0);

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsNegative()

bool SystemEx.Numeric.Half16.IsNegative ( Half16 val )

static

Returns true if the value is negative.

204 =>

205 (val.m_value & 0x8000) != 0;

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsNormal()

bool SystemEx.Numeric.Half16.IsNormal ( Half16 x )

static

Returns true if the value is a normal (non‑subnormal, non‑special) number.

                                                 {
            ushort e = x.Exponent;
            return e != 0 && e != 0x1F;
        }

Here is the call graph for this function:

◆ IsSubnormal()

bool SystemEx.Numeric.Half16.IsSubnormal ( Half16 x )

static

Returns true if the value is a subnormal number.

245 =>

246 x.Exponent == 0 && x.Mantissa != 0;

Here is the call graph for this function:

◆ IsZero()

bool SystemEx.Numeric.Half16.IsZero ( Half16 value )

static

Returns true if the value is +0 or −0.

198 =>

199 (value.m_value & ~0x8000) == 0;

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Max()

Half16 SystemEx.Numeric.Half16.Max	(	Half16	x,
		Half16	y )

static

Returns the larger of two Half16 values.

149=> (x > y) ? x : y;

Here is the call graph for this function:

◆ Min()

Half16 SystemEx.Numeric.Half16.Min	(	Half16	x,
		Half16	y )

static

Returns the smaller of two Half16 values.

154=> (x < y) ? x : y;

Here is the call graph for this function:

◆ Mul()

Half16 SystemEx.Numeric.Half16.Mul	(	Half16	a,
		Half16	b )

static

Multiplies two Half16 values using full bit‑level arithmetic.

                                                        {
            if ( IsNaN(a) || IsNaN(b) ) return Half16.NaN;
            if ( IsZero(a) || IsZero(b) ) return Half16.Zero;
 
            ushort sign = (ushort)((a.Sign ? 1 : 0) ^ (b.Sign ? 1 : 0) );
 
            if ( IsInfinity(a) || IsInfinity(b) ) {
                return new Half16(sign, 0x1F, 0);
            }
 
            ushort expA = a.Exponent;
            ushort expB = b.Exponent;
 
            uint mantA = (expA == 0) ? a.Mantissa : (uint)(a.Mantissa | 0x400);
            uint mantB = (expB == 0) ? b.Mantissa: (uint)(b.Mantissa | 0x400);
 
            int exp = expA + expB - 15;
 
            uint mant = mantA * mantB; // bis zu 20 Bits
 
            // Normalisieren
            while ( (mant & 0x80000) != 0 ) {
                mant >>= 1;
                exp++;
            }
 
            mant >>= 10; // zurück auf 11 Bits (leading + 10 mantissa)
 
            return Normalize(sign, exp, mant);
        }

Here is the call graph for this function:

◆ Negate()

Half16 SystemEx.Numeric.Half16.Negate ( Half16 h )

static

Returns the negated value.

                                          {
            ushort sign = (ushort)(h.Sign ? 1 : 0);
            return new Half16((ushort)(sign ^ 1), h.Exponent, h.Mantissa);
        }

Here is the call graph for this function:

◆ Normalize()

Half16 SystemEx.Numeric.Half16.Normalize	(	ushort	sign,
		int	exp,
		uint	mant )

static

Normalizes a mantissa/exponent pair into a valid Half16 value.

                                                                    {
            if ( mant == 0 ) return new Half16(sign, 0, 0);
 
            while ( (mant & 0x400) == 0 ) {
                mant <<= 1;
                exp--;
            }
 
            if ( exp <= 0 )
                return new Half16(sign, 0, (ushort)(mant >> (1 - exp)));
 
            if ( exp >= 31 )
                return new Half16(sign, 0x1F, 0);
 
            ushort finalMant = (ushort)(mant & 0x3FF);
 
            return new Half16(sign, (ushort)exp, finalMant);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator!=()

bool SystemEx.Numeric.Half16.operator!=	(	Half16	a,
		Half16	b )

static

Inequality operator.

381=> !(a == b);

Here is the call graph for this function:

◆ operator*()

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

static

Multiplication operator.

396=> Mul(a, b);

Here is the call graph for this function:

◆ operator+()

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

static

Addition operator.

386=> Add(a, b);

SystemEx.Drawing.BlendMode.Add

@ Add

Adds the layer’s color value to the underlying color. Useful for additive accumulation or brightness‑...

Definition ICanvasList.cs:37

Here is the call graph for this function:

◆ operator++()

Half16 SystemEx.Numeric.Half16.operator++ ( Half16 a )

static

Increment operator.

406=> a + One;

Here is the call graph for this function:

◆ operator-()

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

static

Subtraction operator.

391=> a + Negate(b);

Here is the call graph for this function:

◆ operator--()

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

static

Decrement operator.

411=> a - One;

Here is the call graph for this function:

◆ operator/()

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

static

Division operator.

401=> Div(a, b);

Here is the call graph for this function:

◆ operator<()

bool SystemEx.Numeric.Half16.operator<	(	Half16	a,
		Half16	b )

static

Less‑than comparison operator with full IEEE‑754 semantics.

                                                             {
            if ( IsNaN(a) || IsNaN(b) ) return false;
 
            bool _neg = IsNegative(a);
 
            if ( _neg != IsNegative(b) ) {
                if ( IsZero(a) && IsZero(b) )
                    return false;
                return _neg;
            }
 
            return (a.m_value != b.m_value) && ((a.m_value < b.m_value) ^ _neg);
        }

Here is the call graph for this function:

◆ operator<=()

bool SystemEx.Numeric.Half16.operator<=	(	Half16	a,
		Half16	b )

static

Less‑than‑or‑equal comparison operator.

                                                            {
            if ( IsNaN(a) || IsNaN(b) ) return false;
 
            bool _neg = IsNegative(a);
 
            if ( _neg != IsNegative(b) ) {
                if ( IsZero(a) && IsZero(b) )
                    return true;
                return _neg;
            }
 
            return (a.m_value == b.m_value) || ((a.m_value < b.m_value) ^ _neg);
        }

Here is the call graph for this function:

◆ operator==()

bool SystemEx.Numeric.Half16.operator==	(	Half16	a,
		Half16	b )

static

Equality operator with IEEE‑754 zero handling.

                                                            {
            if ( IsNaN(a) || IsNaN(b) ) return false;
            return (a.m_value == b.m_value) || (IsZero(a) && IsZero(b));
        }

Here is the call graph for this function:

◆ operator>()

bool SystemEx.Numeric.Half16.operator>	(	Half16	a,
		Half16	b )

static

Greater‑than operator.

371=> b < a;

Here is the call graph for this function:

◆ operator>=()

bool SystemEx.Numeric.Half16.operator>=	(	Half16	a,
		Half16	b )

static

Greater‑than‑or‑equal operator.

376=> b <= a;

Here is the call graph for this function:

◆ RoundToNearestEven()

uint SystemEx.Numeric.Half16.RoundToNearestEven ( uint mant )

static

Rounds a mantissa using round‑to‑nearest‑even.

                                                     {
            uint guard = (mant >> 2) & 1;
            uint round = (mant >> 1) & 1;
            uint sticky = mant & 1;
 
            uint add = 0;
 
            if ( round != 0 ) {
                if ( guard != 0 || sticky != 0 )
                    add = 1;
            }
 
            return (mant >> 3) + add;
        }

◆ Signum()

Half16 SystemEx.Numeric.Half16.Signum ( Half16 x )

static

Returns −1, 0, or +1 depending on the sign of the value.

                                                 {
            if ( IsNaN(x) ) return Half16.NaN;
            if ( IsZero(x) ) return Half16.Zero;
            return x.Sign ? Half16.NegativeOne : Half16.One;
        }

Here is the call graph for this function:

◆ ToBytes() [1/2]

FixedVector< byte > SystemEx.Numeric.Half16.ToBytes ( )

Converts this instance into a deterministic byte array suitable for hashing, serialization, or low‑level processing.

The returned array contains the raw 16‑bit representation of the value in the system's native endianness, wrapped in a SystemEx FixedVector<T>.

Returns: A new FixedVector<T> containing the raw bytes of this Half16 value.

Implements SystemEx.Hash.IHashable< T >.

                                            {
            return new FixedVector<byte>(m_value.ToBytes());
        }

◆ ToBytes() [2/2]

byte[] SystemEx.Numeric.Half16.ToBytes ( Endian endian )

Converts the value into a byte array using the specified endianness.

Implements SystemEx.Numeric.IHalf< T >.

185 =>

186 m_value.ToBytes(endian);

◆ Trunc()

Half16 SystemEx.Numeric.Half16.Trunc ( Half16 x )

static

Truncates the fractional part of the value.

                                                {
            if ( IsNaN(x) || IsInfinity(x) ) return x;
 
            ushort e = x.Exponent;
 
            if ( e >= 15 ) {
                int shift = e - 15;
                uint mant = (uint)(x.Mantissa | 0x400);
                mant >>= shift;
                mant <<= shift;
                return new Half16((ushort)(x.Sign ? 1 : 0), e, (ushort)(mant & 0x3FF));
            }
 
            return Zero;
        }

Here is the call graph for this function:

Property Documentation

◆ E

Half16 SystemEx.Numeric.Half16.E

staticget

Euler's number (approximation).

◆ Epsilon

Half16 SystemEx.Numeric.Half16.Epsilon

staticget

Smallest representable positive increment.

◆ Exponent

ushort SystemEx.Numeric.Half16.Exponent

get

Gets the exponent field (5 bits).

Implements SystemEx.Numeric.IHalf< T >.

◆ ExponentBias

ushort SystemEx.Numeric.Half16.ExponentBias

get

Exponent bias used by the binary16 format (15).

Implements SystemEx.Numeric.IHalf< T >.

◆ ExponentBits

ushort SystemEx.Numeric.Half16.ExponentBits

get

Number of bits used for the exponent field (IEEE‑754 binary16 uses 5).

Implements SystemEx.Numeric.IHalf< T >.

◆ Mantissa

ushort SystemEx.Numeric.Half16.Mantissa

get

Gets the mantissa (fraction) field (10 bits).

Implements SystemEx.Numeric.IHalf< T >.

◆ MantissaBits

ushort SystemEx.Numeric.Half16.MantissaBits

get

Number of bits used for the mantissa (fraction) field (10 bits).

Implements SystemEx.Numeric.IHalf< T >.

◆ MaxValue

Half16 SystemEx.Numeric.Half16.MaxValue

staticget

Largest representable positive value.

◆ MinValue

Half16 SystemEx.Numeric.Half16.MinValue

staticget

Smallest representable negative value.

◆ NaN

Half16 SystemEx.Numeric.Half16.NaN

staticget

Quiet NaN value.

◆ NaN2

Half16 SystemEx.Numeric.Half16.NaN2

staticget

Alternative NaN encoding.

◆ NegativeInfinity

Half16 SystemEx.Numeric.Half16.NegativeInfinity

staticget

Represents negative infinity.

◆ NegativeOne

Half16 SystemEx.Numeric.Half16.NegativeOne

staticget

Represents −1.

◆ One

Half16 SystemEx.Numeric.Half16.One

staticget

Represents +1.

◆ Pi

Half16 SystemEx.Numeric.Half16.Pi

staticget

π (approximation).

◆ PositiveInfinity

Half16 SystemEx.Numeric.Half16.PositiveInfinity

staticget

Represents positive infinity.

◆ Sign

bool SystemEx.Numeric.Half16.Sign

get

Gets the sign bit (true = negative).

Implements SystemEx.Numeric.IHalf< T >.

◆ SignBits

ushort SystemEx.Numeric.Half16.SignBits

get

Number of bits used for the sign field (always 1).

Implements SystemEx.Numeric.IHalf< T >.

◆ Tau

Half16 SystemEx.Numeric.Half16.Tau

staticget

τ = 2π (approximation).

◆ TotalBits

ushort SystemEx.Numeric.Half16.TotalBits

get

Total number of bits in the representation (16).

Implements SystemEx.Numeric.IHalf< T >.

◆ Zero

Half16 SystemEx.Numeric.Half16.Zero

staticget

Represents +0.

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

Half16.cs

Public Member Functions

Static Public Member Functions

Properties

Constructor & Destructor Documentation

◆ Half16() [1/2]

◆ Half16() [2/2]

Member Function Documentation

◆ Abs()

◆ Add()

◆ AsUShort()

◆ Ceil()

◆ Clamp()

◆ CompareTo() [1/3]

◆ CompareTo() [2/3]

◆ CompareTo() [3/3]

◆ Div()

◆ Equals() [1/2]

◆ Equals() [2/2]

◆ Floor()

◆ FromBytes()

◆ GetHashCode()

◆ IsFinite()

◆ IsInfinity()

◆ IsInteger()

◆ IsNaN()

◆ IsNegative()

◆ IsNormal()

◆ IsSubnormal()

◆ IsZero()

◆ Max()

◆ Min()

◆ Mul()

◆ Negate()

◆ Normalize()

◆ operator!=()

◆ operator*()

◆ operator+()

◆ operator++()

◆ operator-()

◆ operator--()

◆ operator/()

◆ operator<()

◆ operator<=()

◆ operator==()

◆ operator>()

◆ operator>=()

◆ RoundToNearestEven()

◆ Signum()

◆ ToBytes() [1/2]

◆ ToBytes() [2/2]

◆ Trunc()

Property Documentation

◆ E

◆ Epsilon

◆ Exponent

◆ ExponentBias

◆ ExponentBits

◆ Mantissa

◆ MantissaBits

◆ MaxValue

◆ MinValue

◆ NaN

◆ NaN2

◆ NegativeInfinity

◆ NegativeOne

◆ One

◆ Pi

◆ PositiveInfinity

◆ Sign

◆ SignBits

◆ Tau

◆ TotalBits

◆ Zero