Double non firmato

Ho bisogno di usare un doppio senza segno, ma si scopre che C # non fornisce questo tipo.

Qualcuno sa perché?

I numeri in virgola mobile sono semplicemente l’implementazione della specifica IEEE 754. Non esiste una cosa come un doppio senza firma, per quanto ne so.

http://en.wikipedia.org/wiki/IEEE_754-2008

Perché hai bisogno di un numero in virgola mobile senza segno?

Come sottolineato da Anders Forsgren, non vi è alcun doppio senza segno nella specifica IEEE (e quindi non in C #).

Puoi sempre ottenere il valore positivo chiamando Math.Abs ​​() e potresti racchiudere un double in una struct e applicare il vincolo lì:

public struct PositiveDouble { private double _value; public PositiveDouble() {} public PositiveDouble(double val) { // or truncate/take Abs value automatically? if (val < 0) throw new ArgumentException("Value needs to be positive"); _value = val; } // This conversion is safe, we can make it implicit public static implicit operator double(PositiveDouble d) { return d._value; } // This conversion is not always safe, so we make it explicit public static explicit operator PositiveDouble(double d) { // or truncate/take Abs value automatically? if (d < 0) throw new ArgumentOutOfRangeException("Only positive values allowed"); return new PositiveDouble(d); } // add more cast operators if needed } 

Non esiste un doppio senza segno in nessuna lingua o sistema di cui io abbia mai sentito parlare.

Devo dare la possibilità di passare una variabile che può essere una frazione e deve essere positiva. Volevo usarlo nella mia firma della funzione per applicarlo.

Se si desidera applicare un vincolo in base al quale il parametro è positivo, è necessario farlo con un controllo runtime.

Ho implementato un’implementazione più dettagliata di @ Isak Savo con modifiche qui e là. Non so se è perfetto, ma è un ottimo punto di partenza.

 public struct UDouble { ///  /// Equivalent to . ///  public static UDouble Epsilon = double.Epsilon; ///  /// Represents the smallest possible value of  (0). ///  public static UDouble MinValue = 0d; ///  /// Represents the largest possible value of  (equivalent to ). ///  public static UDouble MaxValue = double.MaxValue; ///  /// Equivalent to . ///  public static UDouble NaN = double.NaN; ///  /// Equivalent to . ///  public static UDouble PositiveInfinity = double.PositiveInfinity; double value; public UDouble(double Value) { if (double.IsNegativeInfinity(Value)) throw new NotSupportedException(); value = Value < 0 ? 0 : Value; } public static implicit operator double(UDouble d) { return d.value; } public static implicit operator UDouble(double d) { return new UDouble(d); } public static bool operator <(UDouble a, UDouble b) { return a.value < b.value; } public static bool operator >(UDouble a, UDouble b) { return a.value > b.value; } public static bool operator ==(UDouble a, UDouble b) { return a.value == b.value; } public static bool operator !=(UDouble a, UDouble b) { return a.value != b.value; } public static bool operator <=(UDouble a, UDouble b) { return a.value <= b.value; } public static bool operator >=(UDouble a, UDouble b) { return a.value >= b.value; } public override bool Equals(object a) { return !(a is UDouble) ? false : this == (UDouble)a; } public override int GetHashCode() { return value.GetHashCode(); } public override string ToString() { return value.ToString(); } } 

Per quanto riguarda il motivo per cui è necessario un double senza segno, considera che le dimensioni di larghezza e altezza degli elementi dell’interfaccia utente non possono essere negative nella maggior parte delle applicazioni in quanto sarebbe illogico; perché, quindi, supportare i numeri negativi dove non sono necessari?

Alcuni valori come PositiveInfinity e NaN potrebbero ancora essere applicabili; pertanto, forniamo riferimenti intuitivi a loro. La grande differenza tra double e UDouble è che UDouble non avrebbe bisogno della costante NegativeInfinity (o almeno presumo così tanto, io non sono un matematico, dopotutto) e la costante MinValue è semplicemente 0 . Inoltre, Epsilon è positivo, tuttavia, non sono sicuro che sia logico utilizzarlo nello stesso contesto dei numeri non firmati.

Nota, questa implementazione tronca automaticamente i numeri negativi e viene generata un’eccezione se si tenta di impostare su NegativeInfinity .