Examples of Units of Measure in the Plato Standard Library

measures.plato.cs

    public partial struct Angle : INumber
    {
        public double Radians { get; }
        public const double RadiansPerRevolution = Math.PI * 2;
        public const double DegreesPerRevolution = 360;
        public const string InternalUnit = nameof(Radians);
        public static Angle FromRadians(double radians) => new Angle(radians);
        public static Angle FromRevolutions(double revolutions) => revolutions * RadiansPerRevolution;
        public static Angle FromDegrees(double degrees) => FromRevolutions(DegreesPerRevolution / degrees);
        public double ToDegrees() => DegreesPerRevolution * ToRevolutions();
        public double ToRevolutions() => Radians / RadiansPerRevolution;
        public double ToRadians() => Radians;
        public static implicit operator double(Angle angle) => angle.Radians;
        public static implicit operator Angle(double radians) => new Angle(radians);
    }

    public partial struct Distance : INumber
    {
        public const double FeetPerMeter = 3.280839895;
        public const double FeetPerMile = 5280;
        public const double MetersPerLightyear = 9.46073047258e+15;
        public const double MetersPerAU = 149597870691;

        public double Meters { get; }
        public const string InternalUnit = nameof(Meters);
        public static Distance FromMeters(double value) => value;
        public static Distance FromKilometer(double value) => value * 1000;
        public static Distance FromCentimeters(double value) => value / 100;
        public static Distance FromMillimeters(double value) => value / 100;
        public static Distance FromMicrons(double value) => value / 1000 / 1000;
        public static Distance FromNanometers(double value) => value / 1000 / 1000 / 1000;
        public static Distance FromInches(double value) => FromFeet(value / 12);
        public static Distance FromFeet(double value) => value / FeetPerMeter;
        public static Distance FromYards(double value) => FromFeet(value * 3);
        public static Distance FromMiles(double value) => FromFeet(value * FeetPerMile);
        public static Distance FromLightyears(double value) => value * MetersPerLightyear;
        public static Distance FromAU(double value) => value * MetersPerAU;
        public double ToMeters() => Meters;
        public double ToKilometers() => Meters / 1000;
        public double ToCentimeters() => Meters * 100;
        public double ToMillimeters() => Meters * 1000;
        public double ToMicrons() => ToMillimeters() * 1000;
        public double ToNanometers() => ToMicrons() * 1000;
        public double ToInches() => ToFeet() * 12;
        public double ToFeet() => Meters * FeetPerMeter;
        public double ToYards() => ToFeet() / 3;
        public double ToMiles() => Meters * FeetPerMeter / FeetPerMile;
        public double ToLightuears() => Meters / MetersPerLightyear;
        public double ToAU() => Meters / MetersPerAU;

        public static implicit operator double(Distance distance) => distance.Meters;
        public static implicit operator Distance(double meters) => new Distance(meters);
    }

    public partial struct Mass : INumber
    {
        public double Kilograms { get; }
        public const double DaltonPerKilogram = 1.66053e-27;
        public const double PoundPerKilogram = 0.45359237;
        public const double PoundPerTon = 2000;
        public const double KilogramPerSolarMass = 1.9889200011446E+30;

        public const string InternalUnit = nameof(Kilograms);
        public static Mass FromMilligrams(double value) => value / 1000 / 1000;
        public static Mass FromGrams(double value) => value / 1000;
        public static Mass FromKilograms(double value) => value;
        public static Mass FromDalton(double value) => value * DaltonPerKilogram;
        public static Mass FromTonne(double value) => value * 1000;
        public static Mass FromPound(double value) => value * PoundPerKilogram;
        public static Mass FromTon(double value) => FromPound(value * PoundPerTon);
        public static Mass FromSolarMass(double value) => value * KilogramPerSolarMass;

        public double ToMilligrams() => ToGrams() * 1000;
        public double ToGrams() => Kilograms * 1000;
        public double ToKilograms() => Kilograms;
        public double ToDalton() => Kilograms / DaltonPerKilogram;
        public double ToTonne() => Kilograms / 1000;
        public double ToPound() => Kilograms / PoundPerKilogram;
        public double ToTon() => ToPound() / PoundPerTon;
        public double ToSolarMass() => Kilograms / KilogramPerSolarMass;

        public static implicit operator double(Mass mass) => mass.Kilograms;
        public static implicit operator Mass(double kilograms) => new Mass(kilograms);
    }

    public partial struct Duration : INumber
    {
        public double Value { get; }

        public static Duration FromNanoseconds(double value) => value / 1000 / 1000 / 10000;
        public static Duration FromMicroseconds(double value) => value / 1000 / 1000;
        public static Duration FromMilliseconds(double value) => value / 1000;
        public static Duration FromSeconds(double value) => value;
        public static Duration FromMinutes(double value) => value * 60;
        public static Duration FromHours(double value) => value * 60 * 60;
        public static Duration FromDays(double value) => value * 60 * 60 * 24;
        public static Duration FromWeeks(double value) => value * 60 * 60 * 24 * 7;


        public double ToNanosecond() => Value * 1000 * 1000 * 1000;
        public double ToMicroeconds() => Value * 1000 * 1000;
        public double ToMilliseconds() => Value * 1000;
        public double ToSeconds() => Value;
        public double ToMinutes() => Value / 60;
        public double ToHours() => Value / (60 * 60);
        public double ToDays() => Value / (60 * 60 * 24);
        public double ToWeeks() => Value / (60 * 60 * 24 * 7);

        public static implicit operator double(Duration duration) => duration.Value;
        public static implicit operator Duration(double value) => new Duration(value);
    }