jclunitconv.pas

East make Tray Icon in delphi

{**************************************************************************************************}
{                                                                                                  }
{ Project JEDI Code Library (JCL)                                                                  }
{                                                                                                  }
{ The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); }
{ you may not use this file except in compliance with the License. You may obtain a copy of the    }
{ License at http://www.mozilla.org/MPL/                                                           }
{                                                                                                  }
{ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF   }
{ ANY KIND, either express or implied. See the License for the specific language governing rights  }
{ and limitations under the License.                                                               }
{                                                                                                  }
{ The Original Code is JclUnitConv.pas.                                                            }
{                                                                                                  }
{ The Initial Developer of the Original Code is Marcel van Brakel.                                 }
{ Portions created by Marcel van Brakel are Copyright Marcel van Brakel. All rights reserved.      }
{                                                                                                  }
{ Contributor(s):                                                                                  }
{   Marcel van Brakel                                                                              }
{   ESB Consultancy                                                                                }
{   Manlio Laschena                                                                                }
{   Allan Lyons                                                                                    }
{   Robert Marquardt (marquardt)                                                                   }
{   Robert Rossmair (rrossmair)                                                                    }
{   Matthias Thoma (mthoma)                                                                        }
{   Petr Vones (pvones)                                                                            }
{   Scott Price (scottprice)                                                                       }
{                                                                                                  }
{**************************************************************************************************}
{                                                                                                  }
{ Contains routines to perform conversion between various units such as length coordinate,         }
{ temperature, angle, mass and pressure conversions.                                               }
{                                                                                                  }
{**************************************************************************************************}

// Last modified: $Data$
// For history see end of file

unit JclUnitConv;

{$I jcl.inc}

interface

uses
  SysUtils,
  JclBase;

const
  { Temperature constants }

  CelsiusFreezingPoint    = 0.0;
  FahrenheitFreezingPoint = 32.0;
  KelvinFreezingPoint     = 273.15;
  CelsiusBoilingPoint     = 100.0 + CelsiusFreezingPoint;
  FahrenheitBoilingPoint  = 180.0 + FahrenheitFreezingPoint;
  KelvinBoilingPoint      = 100.0 + KelvinFreezingPoint;
  CelsiusAbsoluteZero     = -273.15;
  FahrenheitAbsoluteZero  = -459.67;
  KelvinAbsoluteZero      = 0.0;

  { Newly added for Rankine and Reaumur Support by scottprice }
  RankineAbsoluteZero = 0.0;
  RankineAtFahrenheitZero = 459.67;
  RankineFreezingPoint = 491.67;
  RankineBoilingPoint = 180 + RankineFreezingPoint;
  ReaumurAbsoluteZero = -218.52;
  ReaumurFreezingPoint = 0.0;
  ReaumurBoilingPoint = 80.0;


  { Mathematical constants }

  DegPerCycle: Float      = 360.0;
  DegPerGrad: Float       = 0.9;
  DegPerRad: Float        = 57.295779513082320876798154814105;
  GradPerCycle: Float     = 400.0;
  GradPerDeg: Float       = 1.1111111111111111111111111111111;
  GradPerRad: Float       = 63.661977236758134307553505349006;
  RadPerCycle: Float      = 6.283185307179586476925286766559;
  RadPerDeg: Float        = 0.017453292519943295769236907684886;
  RadPerGrad: Float       = 0.015707963267948966192313216916398;
  CyclePerDeg: Float      = 0.0027777777777777777777777777777778;
  CyclePerGrad: Float     = 0.0025;
  CyclePerRad: Float      = 0.15915494309189533576888376337251;
  ArcMinutesPerDeg        = 60.0;
  ArcSecondsPerArcMinute  = 60.0;
  ArcSecondsPerDeg        = ArcSecondsPerArcMinute * ArcMinutesPerDeg;
  DegPerArcMinute         = 1 / ArcMinutesPerDeg;
  DegPerArcSecond         = 1 / ArcSecondsPerDeg;


type
  { Exception classes }
  EUnitConversionError = class(Exception);

  ETemperatureConversionError = class(EUnitConversionError);

  { Temperature type enumeration used for the general routine allowing for
    a more dynamic specification of the source or target temperature types }
  TTemperatureType = (ttCelsius, ttFahrenheit, ttKelvin, ttRankine, ttReaumur);


function HowAOneLinerCanBiteYou(const Step, Max: Longint): Longint;
function MakePercentage(const Step, Max: Longint): Longint;

{ New Temperature routines }
{ Old temperature routines removed and archived incase required again - scottprice }

function CelsiusToFahrenheit(const Temperature: Float): Float;
function CelsiusToKelvin(const Temperature: Float): Float;
function CelsiusToRankine(const Temperature: Float): Float;
function CelsiusToReaumur(const Temperature: Float): Float;
function FahrenheitToCelsius(const Temperature: Float): Float;
function FahrenheitToKelvin(const Temperature: Float): Float;
function FahrenheitToRankine(const Temperature: Float): Float;
function FahrenheitToReaumur(const Temperature: Float): Float;
function KelvinToCelsius(const Temperature: Float): Float;
function KelvinToFahrenheit(const Temperature: Float): Float;
function KelvinToRankine(const Temperature: Float): Float;
function KelvinToReaumur(const Temperature: Float): Float;
function RankineToCelsius(const Temperature: Float): Float;
function RankineToFahrenheit(const Temperature: Float): Float;
function RankineToKelvin(const Temperature: Float): Float;
function RankineToReaumur(const Temperature: Float): Float;
function ReaumurToCelsius(const Temperature: Float): Float;
function ReaumurToFahrenheit(const Temperature: Float): Float;
function ReaumurToKelvin(const Temperature: Float): Float;
function ReaumurToRankine(const Temperature: Float): Float;
function ConvertTemperature(const FromType, ToType: TTemperatureType; const Temperature: Float): Float;
function CelsiusTo(ToType: TTemperatureType; const Temperature: Float): Float;
function FahrenheitTo(ToType: TTemperatureType; const Temperature: Float): Float;
function KelvinTo(ToType: TTemperatureType; const Temperature: Float): Float;
function RankineTo(ToType: TTemperatureType; const Temperature: Float): Float;
function ReaumurTo(ToType: TTemperatureType; const Temperature: Float): Float;

{ Angle conversion }

function CycleToDeg(const Cycles: Float): Float;
function CycleToGrad(const Cycles: Float): Float;
function CycleToRad(const Cycles: Float): Float;
function DegToCycle(const Degrees: Float): Float;
function DegToGrad(const Degrees: Float): Float;
function DegToRad(const Degrees: Float): Float;
function GradToCycle(const Grads: Float): Float;
function GradToDeg(const Grads: Float): Float;
function GradToRad(const Grads: Float): Float;
function RadToCycle(const Radians: Float): Float;
function RadToDeg(const Radians: Float): Float;
function RadToGrad(const Radians: Float): Float;
function DmsToDeg(const D, M: Integer; const S: Float): Float;
function DmsToRad(const D, M: Integer; const S: Float): Float;
procedure DegToDms(const Degrees: Float; out D, M: Integer; out S: Float);
function DegToDmsStr(const Degrees: Float; const SecondPrecision: Cardinal = 3): string;

{ Coordinate conversion }

procedure CartesianToPolar(const X, Y: Float; out R, Phi: Float);
procedure PolarToCartesian(const R, Phi: Float; out X, Y: Float);
procedure CartesianToCylinder(const X, Y, Z: Float; out R, Phi, Zeta: Float);
procedure CartesianToSpheric(const X, Y, Z: Float; out Rho, Phi, Theta: Float);
procedure CylinderToCartesian(const R, Phi, Zeta: Float; out X, Y, Z: Float);
procedure SphericToCartesian(const Rho, Theta, Phi: Float; out X, Y, Z: Float);

{ Length conversion }

function CmToInch(const Cm: Float): Float;
function InchToCm(const Inch: Float): Float;
function FeetToMetre(const Feet: Float): Float;
function MetreToFeet(const Metre: Float): Float;
function YardToMetre(const Yard: Float): Float;
function MetreToYard(const Metre: Float): Float;
function NmToKm(const Nm: Float): Float;
function KmToNm(const Km: Float): Float;
function KmToSm(const Km: Float): Float;
function SmToKm(const Sm: Float): Float;

{ Volume conversion }

function LitreToGalUs(const Litre: Float): Float;
function GalUsToLitre(const GalUs: Float): Float;
function GalUsToGalCan(const GalUs: Float): Float;
function GalCanToGalUs(const GalCan: Float): Float;
function GalUsToGalUk(const GalUs: Float): Float;
function GalUkToGalUs(const GalUk: Float): Float;
function LitreToGalCan(const Litre: Float): Float;
function GalCanToLitre(const GalCan: Float): Float;
function LitreToGalUk(const Litre: Float): Float;
function GalUkToLitre(const GalUk: Float): Float;

{ Mass conversion }

function KgToLb(const Kg: Float): Float;
function LbToKg(const Lb: Float): Float;
function KgToOz(const Kg: Float): Float;
function OzToKg(const Oz: Float): Float;
function CwtUsToKg(const Cwt: Float): Float;
function CwtUkToKg(const Cwt: Float): Float;
function KaratToKg(const Karat: Float): Float;
function KgToCwtUs(const Kg: Float): Float;
function KgToCwtUk(const Kg: Float): Float;
function KgToKarat(const Kg: Float): Float;
function KgToSton(const Kg: Float): Float;
function KgToLton(const Kg: Float): Float;
function StonToKg(const STon: Float): Float;
function LtonToKg(const Lton: Float): Float;
function QrUsToKg(const Qr: Float): Float;
function QrUkToKg(const Qr: Float): Float;
function KgToQrUs(const Kg: Float): Float;
function KgToQrUk(const Kg: Float): Float;

{ Pressure conversion }

function PascalToBar(const Pa: Float): Float;
function PascalToAt(const Pa: Float): Float;
function PascalToTorr(const Pa: Float): Float;
function BarToPascal(const Bar: Float): Float;
function AtToPascal(const At: Float): Float;
function TorrToPascal(const Torr: Float): Float;

{ Other conversions }

function KnotToMs(const Knot: Float): Float;
function HpElectricToWatt(const HpE: Float): Float;
function HpMetricToWatt(const HpM: Float): Float;
function MsToKnot(const Ms: Float): Float;
function WattToHpElectric(const W: Float): Float;
function WattToHpMetric(const W: Float): Float;

implementation

uses
  JclMath, JclResources;

function HowAOneLinerCanBiteYou(const Step, Max: Longint): Longint;
begin
  Result := MakePercentage(Step, Max);
end;

function MakePercentage(const Step, Max: Longint): Longint;
begin
  Assert(Max <> 0);
  Result := Round((Step * 100.0) / Max);
end;

//=== Temperature conversion =================================================

procedure TemperatureBelowAbsoluteError;
begin
  raise ETemperatureConversionError.CreateRes(@RsConvTempBelowAbsoluteZero);
end;

function CelsiusToFahrenheit(const Temperature: Float): Float;
begin
  if Temperature < CelsiusAbsoluteZero then
    TemperatureBelowAbsoluteError;

  Result := (((FahrenheitBoilingPoint-FahrenheitFreezingPoint) /
    CelsiusBoilingPoint) * Temperature) + FahrenheitFreezingPoint;

  // 癋 = 癈