Mass struct

public struct Mass : IEquatable<Mass>, IComparable<Mass>
{
    public const long UnitsPerMilligram = 100000;
    public const long UnitsPerGram = UnitsPerMilligram * 1000;
    public const long UnitsPerKilogram = UnitsPerGram * 1000;
    public const long UnitsPerPound = 45359237000;
    public const long UnitsPerGrain = 6479891;

    public static readonly Mass Zero = new Mass(0);
    public static readonly Mass MinValue = new Mass(long.MinValue);
    public static readonly Mass MaxValue = new Mass(long.MaxValue);

    public static readonly Mass OneMilligram = new Mass(UnitsPerMilligram);
    public static readonly Mass OneGram = new Mass(UnitsPerGram);
    public static readonly Mass OneKilogram = new Mass(UnitsPerKilogram);
    public static readonly Mass OnePound = new Mass(UnitsPerPound);
    public static readonly Mass OneGrain = new Mass(UnitsPerGrain);

    private readonly long _units;

    internal Mass(long units)
    {
        _units = units;
    }

    internal Mass(double value, long unitScale)
    {
        _units = (long) checked(value * unitScale);
    }

    public double Milligrams
    {
        get { return _units * (1.0 / UnitsPerMilligram); }
    }

    public double Grams
    {
        get { return _units * (1.0 / UnitsPerGram); }
    }

    public double Kilograms
    {
        get { return _units * (1.0 / UnitsPerKilogram); }
    }

    public double Grains
    {
        get { return _units * (1.0 / UnitsPerGrain); }
    }

    public double Pounds
    {
        get { return _units * (1.0 / UnitsPerPound); }
    }

    public override bool Equals(object obj)
    {
        if (obj is Mass)
            return Equals((Mass) obj);
        return false;
    }

    public bool Equals(Mass other)
    {
        return _units == other._units;
    }

    public bool Equals(Mass other, long tolerance)
    {
        return Math.Abs(_units - other._units) < tolerance;
    }

    public bool EqualsMilligrams(Mass other)
    {
        return Equals(other, UnitsPerMilligram);
    }

    public override int GetHashCode()
    {
        return _units.GetHashCode();
    }

    public override string ToString()
    {
        return Kilograms.ToString();
    }

    public int CompareTo(Mass other)
    {
        return _units.CompareTo(other._units);
    }

    public static Mass FromUnits(long units)
    {
        return new Mass(units);
    }

    public static Mass FromMilligrams(double value)
    {
        return new Mass(value, UnitsPerMilligram);
    }
    public static Mass FromGrams(double value)
    {
        return new Mass(value, UnitsPerGram);
    }

    public static Mass FromKilograms(double value)
    {
        return new Mass(value, UnitsPerKilogram);
    }

    public static Mass FromGrains(double value)
    {
        return new Mass(value, UnitsPerGrain);
    }

    public static Mass FromPounds(double value)
    {
        return new Mass(value, UnitsPerPound);
    }

    public static bool operator ==(Mass left, Mass right)
    {
        return left.Equals(right);
    }

    public static bool operator !=(Mass left, Mass right)
    {
        return !left.Equals(right);
    }

    public static bool operator <(Mass left, Mass right)
    {
        return left._units < right._units;
    }

    public static bool operator >(Mass left, Mass right)
    {
        return left._units > right._units;
    }

    public static bool operator <=(Mass left, Mass right)
    {
        return left._units <= right._units;
    }

    public static bool operator >=(Mass left, Mass right)
    {
        return left._units >= right._units;
    }

    public static Mass operator *(Mass left, Mass right)
    {
        return new Mass(checked(left._units * right._units));
    }

    public static Mass operator *(Mass left, double right)
    {
        return new Mass(checked((long) (left._units * right)));
    }

    public static Mass operator /(Mass left, Mass right)
    {
        return new Mass(checked(left._units / right._units));
    }

    public static Mass operator /(Mass left, double right)
    {
        return new Mass(checked((long) (left._units / right)));
    }
}