c# - files - Doble sin firmar

filedownload aspx

Question

Necesito usar un doble sin firmar pero resulta que C # no proporciona tal tipo.

¿Alguien sabe por qué?

Answer 1

Como lo señaló Anders Forsgren, no hay dobles sin firmar en la especificación IEEE (y, por lo tanto, no en C #).

Siempre puede obtener el valor positivo llamando a Math.Abs() y puede ajustar un doble en una estructura y aplicar la restricción allí:

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
}

Answer 2

Desplegué una implementación más detallada de @Isak Savo''s con ajustes aquí y allá. No estoy seguro de si es perfecto, pero es un gran lugar para comenzar.

public struct UDouble
{
    /// <summary>
    /// Equivalent to <see cref="double.Epsilon"/>.
    /// </summary>
    public static UDouble Epsilon = double.Epsilon;

    /// <summary>
    /// Represents the smallest possible value of <see cref="UDouble"/> (0).
    /// </summary>
    public static UDouble MinValue = 0d;

    /// <summary>
    /// Represents the largest possible value of <see cref="UDouble"/> (equivalent to <see cref="double.MaxValue"/>).
    /// </summary>
    public static UDouble MaxValue = double.MaxValue;

    /// <summary>
    /// Equivalent to <see cref="double.NaN"/>.
    /// </summary>
    public static UDouble NaN = double.NaN;

    /// <summary>
    /// Equivalent to <see cref="double.PositiveInfinity"/>.
    /// </summary>
    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();
    }
}

En cuanto a por qué uno necesitaría un double sin firmar, considere que las dimensiones de ancho y alto de los elementos de la interfaz de usuario no pueden ser negativas en la mayoría de las aplicaciones, ya que eso sería ilógico; ¿Por qué, entonces, apoyan números negativos donde no son necesarios?

Algunos valores como PositiveInfinity y NaN todavía pueden ser aplicables; por lo tanto, proporcionamos referencias intuitivas a ellos. La gran diferencia entre double y UDouble es que UDouble no necesitaría el UDouble NegativeInfinity constante (o al menos supongo que esto no es un matemático, y la constante MinValue es simplemente 0 Además, Epsilon es positivo, sin embargo, no estoy seguro de si es lógico usarlo en el mismo contexto que los números sin signo.

Tenga en cuenta que esta implementación trunca automáticamente los números negativos y se lanza una excepción si intenta establecer NegativeInfinity .

Answer 3

Los números de punto flotante son simplemente la implementación de la especificación IEEE 754. No hay tal cosa como un doble sin firmar allí por lo que sé.

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

¿Por qué necesita un número de punto flotante sin firmar?

Answer 4

No existe tal cosa como un doble sin firmar en ningún idioma o sistema del que haya oído hablar.

Necesito dar la capacidad de pasar una variable que puede ser una fracción y debe ser positiva. Quería usarlo en mi firma de función para imponerlo.

Si desea imponer una restricción de que el parámetro es positivo, entonces debe hacer eso con una verificación de tiempo de ejecución.