Двойной без знака

Question

Мне нужно использовать unsigned double, но оказывается, что C# не предоставляет такого типа.

Кто-нибудь знает почему?

Answer 1

Числа с плавающей точкой являются просто реализацией спецификации IEEE 754. Насколько я знаю, там нет такой вещи как неподписанный двойник.

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

Зачем вам беззнаковое число с плавающей запятой?

Answer 2

Как указывает Андерс Форсгрен, в спецификации IEEE нет двойных без знака (и, следовательно, нет в C#).

Вы всегда можете получить положительное значение, вызвав Math.Abs ​​(), и вы можете заключить двойное число в структуру и применить ограничение там:

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 3

Ни в одном языке или системе, о которых я когда-либо слышал, не существует такого понятия, как двойной знак без знака.

Мне нужно дать возможность передать переменную, которая может быть дробной и должна быть положительной. Я хотел использовать его в своей подписи Function для обеспечения его соблюдения.

Если вы хотите применить ограничение, что параметр является положительным, то вы должны сделать это с проверкой во время выполнения.

Answer 4

Я развернул более детальную реализацию @Isak Savo's с настройками тут и там. Не уверен, что это идеально, но это отличное место для начала.

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();
    }
}

Что касается того, почему нужно без подписи doubleучтите, что размеры ширины и высоты элементов пользовательского интерфейса не могут быть отрицательными в большинстве приложений, поскольку это было бы нелогично; зачем тогда поддерживать отрицательные числа там, где они не нужны?

Некоторые значения, такие как PositiveInfinity а также NaN может все еще быть применимым; поэтому мы предоставляем интуитивно понятные ссылки на них. Большая разница между double а также UDouble является UDouble не нужно постоянное NegativeInfinity (или, по крайней мере, я так предполагаю; в конце концов, я не математик) и MinValue константа просто 0, Также, Epsilon положительно, однако, я не уверен, логично ли использовать в том же контексте, что и числа без знака.

Обратите внимание, что эта реализация автоматически обрезает отрицательные числа, и выдается исключение, если вы пытаетесь установить значение NegativeInfinity,