{*******************************************************}
{                                                       }
{       Borland Delphi Runtime Library                  }
{       StdConvs Unit                                   }
{       Standard conversions types                      }
{                                                       }
{       Copyright (C) 1995,2000 Inprise Corporation     }
{                                                       }
{*******************************************************}

{ The metric units and prefixes in this unit follow the various
  SI/NIST standards (http://physics.nist.gov/cuu/Units/index.html)

  References:
  [1] NIST: Mendenhall Order of 1893
  [2] ds.dial.pipex.com/nib/metric.htm
  [3] www.omnis.demon.co.uk/conversn/oldenguk.htm
  [4] NIST (physics.nist.gov/cuu/Units/outside.html)
  [5] NIST (physics.nist.gov/cuu/Units/meter.html)
  [6] Accepted best guess, but nobody really knows
  [7] www.ex.ac.uk/cimt/dictunit/dictunit.htm   !! GREAT SITE !!

  Other great sites
  www.unc.edu/~rowlett/units/index.html !! GREAT SITE !!
  www.omnis.demon.co.uk/indexfrm.htm !! GREAT SITE !!
  www.sciencemadesimple.com/conversions.html
  www.numberexchange.net/Convert/Weight.html
  students.washington.edu/kyle/temp.html
  www.convertit.com
}

unit StdConvs;

interface

uses
  SysUtils, ConvUtils;

var
  //############################################################################
  // Distance Conversion Units
  // basic unit of measurement is meters
  cbDistance: TConvFamily;

  duMicromicrons: TConvType;
  duAngstroms: TConvType;
  duMillimicrons: TConvType;
  duMicrons: TConvType;
  duMillimeters: TConvType;
  duCentimeters: TConvType;
  duDecimeters: TConvType;
  duMeters: TConvType;
  duDekameters: TConvType;
  duHectometers: TConvType;
  duKilometers: TConvType;
  duMegameters: TConvType;
  duGigameters: TConvType;
  duInches: TConvType;
  duFeet: TConvType;
  duYards: TConvType;
  duMiles: TConvType;
  duNauticalMiles: TConvType;
  duAstronomicalUnits: TConvType;
  duLightYears: TConvType;
  duParsecs: TConvType;
  duCubits: TConvType;
  duFathoms: TConvType;
  duFurlongs: TConvType;
  duHands: TConvType;
  duPaces: TConvType;
  duRods: TConvType;
  duChains: TConvType;
  duLinks: TConvType;
  duPicas: TConvType;
  duPoints: TConvType;

  //############################################################################
  // Area Conversion Units
  // basic unit of measurement is square meters
  cbArea: TConvFamily;

  auSquareMillimeters: TConvType;
  auSquareCentimeters: TConvType;
  auSquareDecimeters: TConvType;
  auSquareMeters: TConvType;
  auSquareDekameters: TConvType;
  auSquareHectometers: TConvType;
  auSquareKilometers: TConvType;
  auSquareInches: TConvType;
  auSquareFeet: TConvType;
  auSquareYards: TConvType;
  auSquareMiles: TConvType;
  auAcres: TConvType;
  auCentares: TConvType;
  auAres: TConvType;
  auHectares: TConvType;
  auSquareRods: TConvType;

  //############################################################################
  // Volume Conversion Units
  // basic unit of measurement is cubic meters
  cbVolume: TConvFamily;

  vuCubicMillimeters: TConvType;
  vuCubicCentimeters: TConvType;
  vuCubicDecimeters: TConvType;
  vuCubicMeters: TConvType;
  vuCubicDekameters: TConvType;
  vuCubicHectometers: TConvType;
  vuCubicKilometers: TConvType;
  vuCubicInches: TConvType;
  vuCubicFeet: TConvType;
  vuCubicYards: TConvType;
  vuCubicMiles: TConvType;
  vuMilliLiters: TConvType;
  vuCentiLiters: TConvType;
  vuDeciLiters: TConvType;
  vuLiters: TConvType;
  vuDekaLiters: TConvType;
  vuHectoLiters: TConvType;
  vuKiloLiters: TConvType;
  vuAcreFeet: TConvType;
  vuAcreInches: TConvType;
  vuCords: TConvType;
  vuCordFeet: TConvType;
  vuDecisteres: TConvType;
  vuSteres: TConvType;
  vuDekasteres: TConvType;

  vuGallons: TConvType; // American Fluid Units
  vuQuarts: TConvType;
  vuPints: TConvType;
  vuCups: TConvType;
  vuGills: TConvType;
  vuOunces: TConvType;
  vuTablespoons: TConvType;
  vuTeaspoons: TConvType;

  vuDryGallons: TConvType; // American Dry Units
  vuDryQuarts: TConvType;
  vuDryPints: TConvType;
  vuPecks: TConvType;
  vuBuckets: TConvType;
  vuBushels: TConvType;

  vuUKGallons: TConvType; // English Imperial Fluid/Dry Units
  vuUKPottles: TConvType;
  vuUKQuarts: TConvType;
  vuUKPints: TConvType;
  vuUKGills: TConvType;
  vuUKOunces: TConvType;
  vuUKPecks: TConvType;
  vuUKBuckets: TConvType;
  vuUKBushels: TConvType;

  //############################################################################
  // Mass Conversion Units
  // basic unit of measurement is grams
  cbMass: TConvFamily;

  muNanograms: TConvType;
  muMicrograms: TConvType;
  muMilligrams: TConvType;
  muCentigrams: TConvType;
  muDecigrams: TConvType;
  muGrams: TConvType;
  muDekagrams: TConvType;
  muHectograms: TConvType;
  muKilograms: TConvType;
  muMetricTons: TConvType;
  muDrams: TConvType; // Avoirdupois Units
  muGrains: TConvType;
  muLongTons: TConvType;
  muTons: TConvType;
  muOunces: TConvType;
  muPounds: TConvType;
  muStones: TConvType;

  //############################################################################
  // Temperature Conversion Units
  // basic unit of measurement is celsius
  cbTemperature: TConvFamily;

  tuCelsius: TConvType;
  tuKelvin: TConvType;
  tuFahrenheit: TConvType;
  tuRankine: TConvType;
  tuReaumur: TConvType;

  //############################################################################
  // Time Conversion Units
  // basic unit of measurement is days (which is also the same as TDateTime)
  cbTime: TConvFamily;

  tuMilliSeconds: TConvType;
  tuSeconds: TConvType;
  tuMinutes: TConvType;
  tuHours: TConvType;
  tuDays: TConvType;
  tuWeeks: TConvType;
  tuFortnights: TConvType;
  tuMonths: TConvType;
  tuYears: TConvType;
  tuDecades: TConvType;
  tuCenturies: TConvType;
  tuMillennia: TConvType;
  tuDateTime: TConvType;

{ Constants (and their derivatives) used in this unit }
const
  MetersPerInch = 0.0254; // [1]
  MetersPerFoot = MetersPerInch * 12;
  MetersPerYard = MetersPerFoot * 3;
  MetersPerMile = MetersPerFoot * 5280;
  MetersPerNauticalMiles = 1852;
  MetersPerAstronomicalUnit = 1.49598E11; // [4]
  MetersPerLightSecond = 2.99792458E8; // [5]
  MetersPerLightYear = MetersPerLightSecond * 31556925.9747; // [7]
  MetersPerParsec = MetersPerAstronomicalUnit * 206264.806247096; // 60 * 60 * (180 / Pi)
  MetersPerCubit = 0.4572; // [6][7]
  MetersPerFathom = MetersPerFoot * 6;
  MetersPerFurlong = MetersPerYard * 220;
  MetersPerHand = MetersPerInch * 4;
  MetersPerPace = MetersPerInch * 30;
  MetersPerRod = MetersPerFoot * 16.5;
  MetersPerChain = MetersPerRod * 4;
  MetersPerLink = MetersPerChain / 100;
  MetersPerPoint = MetersPerInch * 0.01384;
  MetersPerPica = MetersPerPoint * 12;

  SquareMetersPerSquareInch = MetersPerInch * MetersPerInch;
  SquareMetersPerSquareFoot = MetersPerFoot * MetersPerFoot;
  SquareMetersPerSquareYard = MetersPerYard * MetersPerYard;
  SquareMetersPerSquareMile = MetersPerMile * MetersPerMile;
  SquareMetersPerAcre = SquareMetersPerSquareYard * 4840;
  SquareMetersPerSquareRod = MetersPerRod * MetersPerRod;

  CubicMetersPerCubicInch = MetersPerInch * MetersPerInch * MetersPerInch;
  CubicMetersPerCubicFoot = MetersPerFoot * MetersPerFoot * MetersPerFoot;
  CubicMetersPerCubicYard = MetersPerYard * MetersPerYard * MetersPerYard;
  CubicMetersPerCubicMile = MetersPerMile * MetersPerMile * MetersPerMile;
  CubicMetersPerAcreFoot = SquareMetersPerAcre * MetersPerFoot;
  CubicMetersPerAcreInch = SquareMetersPerAcre * MetersPerInch;
  CubicMetersPerCord = CubicMetersPerCubicFoot * 128;
  CubicMetersPerCordFoot = CubicMetersPerCubicFoot * 16;

  CubicMetersPerUSGallon = CubicMetersPerCubicInch * 231; // [2][3][7]
  CubicMetersPerUSQuart = CubicMetersPerUSGallon / 4;
  CubicMetersPerUSPint = CubicMetersPerUSQuart / 2;
  CubicMetersPerUSCup = CubicMetersPerUSPint / 2;
  CubicMetersPerUSGill = CubicMetersPerUSCup / 2;
  CubicMetersPerUSOunce = CubicMetersPerUSCup / 8;
  CubicMetersPerUSTablespoon = CubicMetersPerUSOunce / 2;
  CubicMetersPerUSTeaspoon = CubicMetersPerUSOunce / 6;

  CubicMetersPerUSDryGallon = CubicMetersPerCubicInch * 268.8025; // [7]
  CubicMetersPerUSDryQuart = CubicMetersPerUSDryGallon / 4;
  CubicMetersPerUSDryPint = CubicMetersPerUSDryQuart / 2;
  CubicMetersPerUSPeck = CubicMetersPerUSDryGallon * 2;
  CubicMetersPerUSBucket = CubicMetersPerUSPeck * 2;
  CubicMetersPerUSBushel = CubicMetersPerUSBucket * 2;

  CubicMetersPerUKGallon = 0.00454609; // [2][7]
  CubicMetersPerUKPottle = CubicMetersPerUKGallon / 2;
  CubicMetersPerUKQuart = CubicMetersPerUKPottle / 2;
  CubicMetersPerUKPint = CubicMetersPerUKQuart / 2;
  CubicMetersPerUKGill = CubicMetersPerUKPint / 4;
  CubicMetersPerUKOunce = CubicMetersPerUKPint / 20;
  CubicMetersPerUKPeck = CubicMetersPerUKGallon * 2;
  CubicMetersPerUKBucket = CubicMetersPerUKPeck * 2;
  CubicMetersPerUKBushel = CubicMetersPerUKBucket * 2;

  GramsPerPound = 453.59237; // [1][7]
  GramsPerDrams = GramsPerPound / 256;
  GramsPerGrains = GramsPerPound / 7000;
  GramsPerTons = GramsPerPound * 2000;
  GramsPerLongTons = GramsPerPound * 2240;
  GramsPerOunces = GramsPerPound / 16;

// simple temperature conversion
function FahrenheitToCelsius(const AValue: Double): Double;
function CelsiusToFahrenheit(const AValue: Double): Double;

implementation

uses
  DateUtils;

function FahrenheitToCelsius(const AValue: Double): Double;
begin
  Result := ((AValue - 32) * 5) / 9;
end;

function CelsiusToFahrenheit(const AValue: Double): Double;
begin
  Result := ((AValue * 9) / 5) + 32;
end;

function KelvinToCelsius(const AValue: Double): Double;
begin
  Result := AValue - 273.15;
end;

function CelsiusToKelvin(const AValue: Double): Double;
begin
  Result := AValue + 273.15;
end;

function RankineToCelsius(const AValue: Double): Double;
begin
  Result := FahrenheitToCelsius(AValue - 459.67);
end;

function CelsiusToRankine(const AValue: Double): Double;
begin
  Result := CelsiusToFahrenheit(AValue) + 459.67;
end;

function ReaumurToCelsius(const AValue: Double): Double;
begin
  Result := ((CelsiusToFahrenheit(AValue) - 32) * 4) / 9;
end;

function CelsiusToReaumur(const AValue: Double): Double;
begin
  Result := FahrenheitToCelsius(((AValue * 9) / 4) + 32);
end;

initialization

  //############################################################################
  // Distance's family type
  cbDistance := RegisterConversionFamily('Distance');

  // Distance's various conversion types
  duMicromicrons := RegisterConversionType(cbDistance, 'Micromicrons', 1E-12);
  duAngstroms := RegisterConversionType(cbDistance, 'Angstroms', 1E-10);
  duMillimicrons := RegisterConversionType(cbDistance, 'Millimicrons', 1E-9);
  duMicrons := RegisterConversionType(cbDistance, 'Microns', 1E-6);
  duMillimeters := RegisterConversionType(cbDistance, 'Millimeters', 0.001);
  duCentimeters := RegisterConversionType(cbDistance, 'Centimeters', 0.01);
  duDecimeters := RegisterConversionType(cbDistance, 'Decimeters', 0.1);
  duMeters := RegisterConversionType(cbDistance, 'Meters', 1);
  duDekameters := RegisterConversionType(cbDistance, 'Dekameters', 10);
  duHectometers := RegisterConversionType(cbDistance, 'Hectometers', 100);
  duKilometers := RegisterConversionType(cbDistance, 'Kilometers', 1000);
  duMegameters := RegisterConversionType(cbDistance, 'Megameters', 1E+6);
  duGigameters := RegisterConversionType(cbDistance, 'Gigameters', 1E+9);
  duInches := RegisterConversionType(cbDistance, 'Inches', MetersPerInch);
  duFeet := RegisterConversionType(cbDistance, 'Feet', MetersPerFoot);
  duYards := RegisterConversionType(cbDistance, 'Yards', MetersPerYard);
  duMiles := RegisterConversionType(cbDistance, 'Miles', MetersPerMile);
  duNauticalMiles := RegisterConversionType(cbDistance, 'NauticalMiles', MetersPerNauticalMiles);
  duAstronomicalUnits := RegisterConversionType(cbDistance, 'AstronomicalUnits', MetersPerAstronomicalUnit);
  duLightYears := RegisterConversionType(cbDistance, 'LightYears', MetersPerLightYear);
  duParsecs := RegisterConversionType(cbDistance, 'Parsecs', MetersPerParsec);
  duCubits := RegisterConversionType(cbDistance, 'Cubits', MetersPerCubit);
  duFathoms := RegisterConversionType(cbDistance, 'Fathoms', MetersPerFathom);
  duFurlongs := RegisterConversionType(cbDistance, 'Furlongs', MetersPerFurlong);
  duHands := RegisterConversionType(cbDistance, 'Hands', MetersPerHand);
  duPaces := RegisterConversionType(cbDistance, 'Paces', MetersPerPace);
  duRods := RegisterConversionType(cbDistance, 'Rods', MetersPerRod);
  duChains := RegisterConversionType(cbDistance, 'Chains', MetersPerChain);
  duLinks := RegisterConversionType(cbDistance, 'Links', MetersPerLink);
  duPicas := RegisterConversionType(cbDistance, 'Picas', MetersPerPica);
  duPoints := RegisterConversionType(cbDistance, 'Points', MetersPerPoint);

  //############################################################################
  // Area's family type
  cbArea := RegisterConversionFamily('Area');

  // Area's various conversion types
  auSquareMillimeters := RegisterConversionType(cbArea, 'SquareMillimeters', 1E-6);
  auSquareCentimeters := RegisterConversionType(cbArea, 'SquareCentimeters', 0.0001);
  auSquareDecimeters := RegisterConversionType(cbArea, 'SquareDecimeters', 0.01);
  auSquareMeters := RegisterConversionType(cbArea, 'SquareMeters', 1);
  auSquareDekameters := RegisterConversionType(cbArea, 'SquareDekameters', 100);
  auSquareHectometers := RegisterConversionType(cbArea, 'SquareHectometers', 10000);
  auSquareKilometers := RegisterConversionType(cbArea, 'SquareKilometers', 1E+6);
  auSquareInches := RegisterConversionType(cbArea, 'SquareInches', SquareMetersPerSquareInch);
  auSquareFeet := RegisterConversionType(cbArea, 'SquareFeet', SquareMetersPerSquareFoot);
  auSquareYards := RegisterConversionType(cbArea, 'SquareYards', SquareMetersPerSquareYard);
  auSquareMiles := RegisterConversionType(cbArea, 'SquareMiles', SquareMetersPerSquareMile);
  auAcres := RegisterConversionType(cbArea, 'Acres', SquareMetersPerAcre);
  auCentares := RegisterConversionType(cbArea, 'Centares', 1);
  auAres := RegisterConversionType(cbArea, 'Ares', 100);
  auHectares := RegisterConversionType(cbArea, 'Hectares', 10000);
  auSquareRods := RegisterConversionType(cbArea, 'SquareRods', SquareMetersPerSquareRod);

  //############################################################################
  // Volume's family type
  cbVolume := RegisterConversionFamily('Volume');

  // Volume's various conversion types
  vuCubicMillimeters := RegisterConversionType(cbVolume, 'CubicMillimeters', 1E-9);
  vuCubicCentimeters := RegisterConversionType(cbVolume, 'CubicCentimeters', 1E-6);
  vuCubicDecimeters := RegisterConversionType(cbVolume, 'CubicDecimeters', 0.001);
  vuCubicMeters := RegisterConversionType(cbVolume, 'CubicMeters', 1);
  vuCubicDekameters := RegisterConversionType(cbVolume, 'CubicDekameters', 1000);
  vuCubicHectometers := RegisterConversionType(cbVolume, 'CubicHectometers', 1E+6);
  vuCubicKilometers := RegisterConversionType(cbVolume, 'CubicKilometers', 1E+9);
  vuCubicInches := RegisterConversionType(cbVolume, 'CubicInches', CubicMetersPerCubicInch);
  vuCubicFeet := RegisterConversionType(cbVolume, 'CubicFeet', CubicMetersPerCubicFoot);
  vuCubicYards := RegisterConversionType(cbVolume, 'CubicYards', CubicMetersPerCubicYard);
  vuCubicMiles := RegisterConversionType(cbVolume, 'CubicMiles', CubicMetersPerCubicMile);
  vuMilliLiters := RegisterConversionType(cbVolume, 'MilliLiters', 1E-6);
  vuCentiLiters := RegisterConversionType(cbVolume, 'CentiLiters', 1E-5);
  vuDeciLiters := RegisterConversionType(cbVolume, 'DeciLiters', 1E-4);
  vuLiters := RegisterConversionType(cbVolume, 'Liters', 0.001);
  vuDekaLiters := RegisterConversionType(cbVolume, 'DekaLiters', 0.01);
  vuHectoLiters := RegisterConversionType(cbVolume, 'HectoLiters', 0.1);
  vuKiloLiters := RegisterConversionType(cbVolume, 'KiloLiters', 1);
  vuAcreFeet := RegisterConversionType(cbVolume, 'AcreFeet', CubicMetersPerAcreFoot);
  vuAcreInches := RegisterConversionType(cbVolume, 'AcreInches', CubicMetersPerAcreInch);
  vuCords := RegisterConversionType(cbVolume, 'Cords', CubicMetersPerCord);
  vuCordFeet := RegisterConversionType(cbVolume, 'CordFeet', CubicMetersPerCordFoot);
  vuDecisteres := RegisterConversionType(cbVolume, 'Decisteres', 0.1);
  vuSteres := RegisterConversionType(cbVolume, 'Steres', 1);
  vuDekasteres := RegisterConversionType(cbVolume, 'Dekasteres', 10);

  // American Fluid Units
  vuGallons := RegisterConversionType(cbVolume, 'Gallons', CubicMetersPerUSGallon);
  vuQuarts := RegisterConversionType(cbVolume, 'Quarts', CubicMetersPerUSQuart);
  vuPints := RegisterConversionType(cbVolume, 'Pints', CubicMetersPerUSPint);
  vuCups := RegisterConversionType(cbVolume, 'Cups', CubicMetersPerUSCup);
  vuGills := RegisterConversionType(cbVolume, 'Gills', CubicMetersPerUSGill);
  vuOunces := RegisterConversionType(cbVolume, 'Ounces', CubicMetersPerUSOunce);
  vuTablespoons := RegisterConversionType(cbVolume, 'Tablespoons', CubicMetersPerUSTablespoon);
  vuTeaspoons := RegisterConversionType(cbVolume, 'Teaspoons', CubicMetersPerUSTeaspoon);

  // American Dry Units
  vuDryGallons := RegisterConversionType(cbVolume, 'DryGallons', CubicMetersPerUSDryGallon);
  vuDryQuarts := RegisterConversionType(cbVolume, 'DryQuarts', CubicMetersPerUSDryQuart);
  vuDryPints := RegisterConversionType(cbVolume, 'DryPints', CubicMetersPerUSDryPint);
  vuPecks := RegisterConversionType(cbVolume, 'Pecks', CubicMetersPerUSPeck);
  vuBuckets := RegisterConversionType(cbVolume, 'Buckets', CubicMetersPerUSBucket);
  vuBushels := RegisterConversionType(cbVolume, 'Bushels', CubicMetersPerUSBushel);

  // English Imperial Fluid/Dry Units
  vuUKGallons := RegisterConversionType(cbVolume, 'UKGallons', CubicMetersPerUKGallon);
  vuUKPottles := RegisterConversionType(cbVolume, 'UKPottle', CubicMetersPerUKPottle);
  vuUKQuarts := RegisterConversionType(cbVolume, 'UKQuarts', CubicMetersPerUKQuart);
  vuUKPints := RegisterConversionType(cbVolume, 'UKPints', CubicMetersPerUKPint);
  vuUKGills := RegisterConversionType(cbVolume, 'UKGill', CubicMetersPerUKGill);
  vuUKOunces := RegisterConversionType(cbVolume, 'UKOunces', CubicMetersPerUKOunce);
  vuUKPecks := RegisterConversionType(cbVolume, 'UKPecks', CubicMetersPerUKPeck);
  vuUKBuckets := RegisterConversionType(cbVolume, 'UKBuckets', CubicMetersPerUKBucket);
  vuUKBushels := RegisterConversionType(cbVolume, 'UKBushels', CubicMetersPerUKBushel);

  //############################################################################
  // Mass's family type
  cbMass := RegisterConversionFamily('Mass');

  // Mass's various conversion types
  muNanograms := RegisterConversionType(cbMass, 'Nanograms', 1E-9);
  muMicrograms := RegisterConversionType(cbMass, 'Micrograms', 1E-6);
  muMilligrams := RegisterConversionType(cbMass, 'Milligrams', 0.001);
  muCentigrams := RegisterConversionType(cbMass, 'Centigrams', 0.01);
  muDecigrams := RegisterConversionType(cbMass, 'Decigrams', 0.1);
  muGrams := RegisterConversionType(cbMass, 'Grams', 1);
  muDekagrams := RegisterConversionType(cbMass, 'Dekagrams', 10);
  muHectograms := RegisterConversionType(cbMass, 'Hectograms', 100);
  muKilograms := RegisterConversionType(cbMass, 'Kilograms', 1000);
  muMetricTons := RegisterConversionType(cbMass, 'MetricTons', 1E+6);
  muDrams := RegisterConversionType(cbMass, 'Drams', GramsPerDrams);
  muGrains := RegisterConversionType(cbMass, 'Grains', GramsPerGrains);
  muTons := RegisterConversionType(cbMass, 'Tons', GramsPerTons);
  muLongTons := RegisterConversionType(cbMass, 'LongTons', GramsPerLongTons);
  muOunces := RegisterConversionType(cbMass, 'Ounces', GramsPerOunces);
  muPounds := RegisterConversionType(cbMass, 'Pounds', GramsPerPound);

  //############################################################################
  // Temperature's family type
  cbTemperature := RegisterConversionFamily('Temperature');

  // Temperature's various conversion types
  tuCelsius := RegisterConversionType(cbTemperature, 'Celsius', 1);
  tuKelvin := RegisterConversionType(cbTemperature, 'Kelvin',
    KelvinToCelsius, CelsiusToKelvin);
  tuFahrenheit := RegisterConversionType(cbTemperature, 'Fahrenheit',
    FahrenheitToCelsius, CelsiusToFahrenheit);
  tuRankine := RegisterConversionType(cbTemperature, 'Rankine',
    RankineToCelsius, CelsiusToRankine);
  tuReaumur := RegisterConversionType(cbTemperature, 'Reaumur',
    ReaumurToCelsius, CelsiusToReaumur);

  //############################################################################
  // Time's family type
  cbTime := RegisterConversionFamily('Time');

  // Time's various conversion types
  tuMilliSeconds := RegisterConversionType(cbTime, 'MilliSeconds', 1 / MSecsPerDay);
  tuSeconds := RegisterConversionType(cbTime, 'Seconds', 1 / SecsPerDay);
  tuMinutes := RegisterConversionType(cbTime, 'Minutes', 1 / MinsPerDay);
  tuHours := RegisterConversionType(cbTime, 'Hours', 1 / HoursPerDay);
  tuDays := RegisterConversionType(cbTime, 'Days', 1);
  tuWeeks := RegisterConversionType(cbTime, 'Weeks', DaysPerWeek);
  tuFortnights := RegisterConversionType(cbTime, 'Fortnights', WeeksPerFortnight * DaysPerWeek);
  tuMonths := RegisterConversionType(cbTime, 'Months', ApproxDaysPerMonth);
  tuYears := RegisterConversionType(cbTime, 'Years', ApproxDaysPerYear);
  tuDecades := RegisterConversionType(cbTime, 'Decades', ApproxDaysPerDecade);
  tuCenturies := RegisterConversionType(cbTime, 'Centuries', ApproxDaysPerCentury);
  tuMillennia := RegisterConversionType(cbTime, 'Millennia', ApproxDaysPerMillennium);
  tuDateTime := RegisterConversionType(cbTime, 'DateTime', 1);

finalization

  // we only neeed to unregister the ones that do callbacks
  UnregisterConversionType(tuKelvin);
  UnregisterConversionType(tuFahrenheit);
  UnregisterConversionType(tuRankine);
  UnregisterConversionType(tuReaumur);
end.