WebApps/Observium_CE
1
0
Fork 0
Code Pull Requests Activity

initial commit; version 22.5.12042

Browse Source
This commit is contained in:
Chris Hammer
2022-12-12 23:28:25 -05:00
commit af1b03d79f
17653 changed files with 22692970 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
libs/PhpUnitsOfMeasure/PhysicalQuantity/Acceleration.php Normal file
View File

@ -0,0 +1,38 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
use PhpUnitsOfMeasure\UnitOfMeasure;
class Acceleration extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// meters per second squared
$meterpersecondsquared = UnitOfMeasure::nativeUnitFactory('m/s^2');
$meterpersecondsquared->addAlias('m/s²');
$meterpersecondsquared->addAlias('meter per second squared');
$meterpersecondsquared->addAlias('meters per second squared');
$meterpersecondsquared->addAlias('metre per second squared');
$meterpersecondsquared->addAlias('metres per second squared');
static::addUnit($meterpersecondsquared);
static::addMissingSIPrefixedUnits(
$meterpersecondsquared,
1,
'%pm/s^2',
[
'%pm/s²',
'%Pmeter per second squared',
'%Pmeters per second squared',
'%Pmetre per second squared',
'%Pmetres per second squared',
]
);
}
}

80
libs/PhpUnitsOfMeasure/PhysicalQuantity/Angle.php Normal file
View File

@ -0,0 +1,80 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Angle extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Radians
$radian = UnitOfMeasure::nativeUnitFactory('rad');
$radian->addAlias('radian');
$radian->addAlias('radians');
static::addUnit($radian);
static::addMissingSIPrefixedUnits(
$radian,
1,
'%prad',
[
'%Pradian',
'%Pradians',
]
);
// Degrees
$degree = UnitOfMeasure::linearUnitFactory('deg', M_PI / 180);
$degree->addAlias('°');
$degree->addAlias('degree');
$degree->addAlias('degrees');
static::addUnit($degree);
static::addMissingSIPrefixedUnits(
$degree,
1,
'%pdeg',
[
'%Pdegree',
'%Pdegrees',
]
);
// Arcminute
$arcminute = UnitOfMeasure::linearUnitFactory('arcmin', M_PI / 180 / 60);
$arcminute->addAlias('′');
$arcminute->addAlias('arcminute');
$arcminute->addAlias('arcminutes');
$arcminute->addAlias('amin');
$arcminute->addAlias('am');
$arcminute->addAlias('MOA');
static::addUnit($arcminute);
// Arcsecond
$arcsecond = UnitOfMeasure::linearUnitFactory('arcsec', M_PI / 180 / 3600);
$arcsecond->addAlias('″');
$arcminute->addAlias('arcsecond');
$arcminute->addAlias('arcseconds');
$arcsecond->addAlias('asec');
$arcsecond->addAlias('as');
static::addUnit($arcsecond);
static::addMissingSIPrefixedUnits(
$arcsecond,
1,
'%Parcsec',
[
'%Parcsecond',
'%Parcseconds',
'%pasec',
'%pas',
]
);
}
}

103
libs/PhpUnitsOfMeasure/PhysicalQuantity/Area.php Normal file
View File

@ -0,0 +1,103 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
use PhpUnitsOfMeasure\UnitOfMeasure;
class Area extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Meters squared
$metersquared = UnitOfMeasure::nativeUnitFactory('m^2');
$metersquared->addAlias('m²');
$metersquared->addAlias('meter squared');
$metersquared->addAlias('square meter');
$metersquared->addAlias('square meters');
$metersquared->addAlias('meters squared');
$metersquared->addAlias('metre squared');
$metersquared->addAlias('metres squared');
static::addUnit($metersquared);
static::addMissingSIPrefixedUnits(
$metersquared,
1,
'%pm^2',
[
'%pm²',
'%Pmeter squared',
'square %Pmeter',
'square %Pmeters',
'%Pmeters squared',
'%Pmetre squared',
'%Pmetres squared'
],
2 // square power factor
);
// Foot squared
$newUnit = UnitOfMeasure::linearUnitFactory('ft^2', 9.290304e-2);
$newUnit->addAlias('ft²');
$newUnit->addAlias('foot squared');
$newUnit->addAlias('square foot');
$newUnit->addAlias('square feet');
$newUnit->addAlias('feet squared');
static::addUnit($newUnit);
// Inch squared
$newUnit = UnitOfMeasure::linearUnitFactory('in^2', 6.4516e-4);
$newUnit->addAlias('in²');
$newUnit->addAlias('inch squared');
$newUnit->addAlias('square inch');
$newUnit->addAlias('square inches');
$newUnit->addAlias('inches squared');
static::addUnit($newUnit);
// Mile squared
$newUnit = UnitOfMeasure::linearUnitFactory('mi^2', 2.589988e6);
$newUnit->addAlias('mi²');
$newUnit->addAlias('mile squared');
$newUnit->addAlias('miles squared');
$newUnit->addAlias('square mile');
$newUnit->addAlias('square miles');
static::addUnit($newUnit);
// Yard squared
$newUnit = UnitOfMeasure::linearUnitFactory('yd^2', 8.361274e-1);
$newUnit->addAlias('yd²');
$newUnit->addAlias('yard squared');
$newUnit->addAlias('yards squared');
$newUnit->addAlias('square yard');
$newUnit->addAlias('square yards');
static::addUnit($newUnit);
// Are
$newUnit = UnitOfMeasure::linearUnitFactory('a', 100);
$newUnit->addAlias('are');
$newUnit->addAlias('ares');
static::addUnit($newUnit);
// Decare
$newUnit = UnitOfMeasure::linearUnitFactory('daa', 1000);
$newUnit->addAlias('decare');
$newUnit->addAlias('decares');
static::addUnit($newUnit);
// Hectare
$newUnit = UnitOfMeasure::linearUnitFactory('ha', 10000);
$newUnit->addAlias('hectare');
$newUnit->addAlias('hectares');
static::addUnit($newUnit);
// International Acre
$newUnit = UnitOfMeasure::linearUnitFactory('ac', 4046.8564224);
$newUnit->addAlias('acre');
$newUnit->addAlias('acres');
static::addUnit($newUnit);
}
}

36
libs/PhpUnitsOfMeasure/PhysicalQuantity/ElectricCurrent.php Normal file
View File

@ -0,0 +1,36 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class ElectricCurrent extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Ampere
$ampere = UnitOfMeasure::nativeUnitFactory('A');
$ampere->addAlias('amp');
$ampere->addAlias('amps');
$ampere->addAlias('ampere');
$ampere->addAlias('amperes');
static::addUnit($ampere);
static::addMissingSIPrefixedUnits(
$ampere,
1,
'%pA',
[
'%Pamp',
'%Pamps',
'%Pampere',
'%Pamperes'
]
);
}
}

80
libs/PhpUnitsOfMeasure/PhysicalQuantity/Energy.php Normal file
View File

@ -0,0 +1,80 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Energy extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Joule
$joule = UnitOfMeasure::nativeUnitFactory('J');
$joule->addAlias('joule');
$joule->addAlias('joules');
static::addUnit($joule);
static::addMissingSIPrefixedUnits(
$joule,
1,
'%pJ',
[
'%Pjoule',
'%Pjoules',
]
);
// Electronvolt
$ev = UnitOfMeasure::linearUnitFactory('eV', 1.6021766208e-19);
$ev->addAlias('electronvolt');
$ev->addAlias('electronvolts');
static::addUnit($ev);
static::addMissingSIPrefixedUnits(
$ev,
1,
'%peV',
[
'%Pelectronvolt',
'%Pelectronvolts',
]
);
// Watt hour
$wattHour = UnitOfMeasure::linearUnitFactory('Wh', 3600);
$wattHour->addAlias('watt hour');
$wattHour->addAlias('watt hours');
static::addUnit($wattHour);
static::addMissingSIPrefixedUnits(
$wattHour,
1,
'%pWh',
[
'%Pwatt hour',
'%Pwatt hours',
]
);
// Calorie
$calorie = UnitOfMeasure::linearUnitFactory('cal', 4.184);
$calorie->addAlias('calorie');
$calorie->addAlias('calories');
static::addUnit($calorie);
static::addMissingSIPrefixedUnits(
$calorie,
1,
'%pcal',
[
'%Pcalorie',
'%Pcalories',
]
);
}
}

102
libs/PhpUnitsOfMeasure/PhysicalQuantity/Length.php Normal file
View File

@ -0,0 +1,102 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Length extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Meter
$meter = UnitOfMeasure::nativeUnitFactory('m');
$meter->addAlias('meter');
$meter->addAlias('meters');
$meter->addAlias('metre');
$meter->addAlias('metres');
static::addUnit($meter);
static::addMissingSIPrefixedUnits(
$meter,
1,
'%pm',
[
'%Pmeter',
'%Pmeters',
'%Pmetre',
'%Pmetres'
]
);
// Foot
$newUnit = UnitOfMeasure::linearUnitFactory('ft', 0.3048);
$newUnit->addAlias('foot');
$newUnit->addAlias('feet');
static::addUnit($newUnit);
// Inch
$newUnit = UnitOfMeasure::linearUnitFactory('in', 0.0254);
$newUnit->addAlias('inch');
$newUnit->addAlias('inches');
static::addUnit($newUnit);
// Mile
$newUnit = UnitOfMeasure::linearUnitFactory('mi', 1609.344);
$newUnit->addAlias('mile');
$newUnit->addAlias('miles');
static::addUnit($newUnit);
// Yard
$newUnit = UnitOfMeasure::linearUnitFactory('yd', 0.9144);
$newUnit->addAlias('yard');
$newUnit->addAlias('yards');
static::addUnit($newUnit);
// Nautical mile
$newUnit = UnitOfMeasure::linearUnitFactory('M', 1852);
$newUnit->addAlias('nautical mile');
$newUnit->addAlias('nautical miles');
$newUnit->addAlias('nmi');
$newUnit->addAlias('NM');
static::addUnit($newUnit);
// Scandinavian mil
$newUnit = UnitOfMeasure::linearUnitFactory('mil', 10000);
static::addUnit($newUnit);
// Astronomical Unit
$newUnit = UnitOfMeasure::linearUnitFactory('AU', 149597870700);
$newUnit->addAlias('au');
$newUnit->addAlias('astronomical unit');
$newUnit->addAlias('astronomical units');
static::addUnit($newUnit);
// Light Year
$newUnit = UnitOfMeasure::linearUnitFactory('ly', 9460730472580800);
$newUnit->addAlias('LY');
$newUnit->addAlias('light year');
$newUnit->addAlias('light years');
static::addUnit($newUnit);
// Light Year
$parsec = UnitOfMeasure::linearUnitFactory('pc', 3.085677581491367279E+16); // parsec == au * 648000 / pi (30856775814913672.789139379577965)
$parsec->addAlias('parsec');
$parsec->addAlias('parsecs');
static::addUnit($parsec);
static::addMissingSIPrefixedUnits(
$parsec,
1,
'%ppc',
[
'%Pparsec',
'%Pparsecs'
]
);
}
}

30
libs/PhpUnitsOfMeasure/PhysicalQuantity/LuminousIntensity.php Normal file
View File

@ -0,0 +1,30 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class LuminousIntensity extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Candela
$candela = UnitOfMeasure::nativeUnitFactory('cd');
$candela->addAlias('candela');
static::addUnit($candela);
static::addMissingSIPrefixedUnits(
$candela,
1,
'%pcd',
[
'%Pcandela',
]
);
}
}

102
libs/PhpUnitsOfMeasure/PhysicalQuantity/Mass.php Normal file
View File

@ -0,0 +1,102 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Mass extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Gram
$gram = UnitOfMeasure::nativeUnitFactory('g');
$gram->addAlias('gram');
$gram->addAlias('grams');
static::addUnit($gram);
static::addMissingSIPrefixedUnits(
$gram,
1,
'%pg',
[
'%Pgram',
'%Pgrams',
]
);
// Tonne (metric)
$tonne = UnitOfMeasure::linearUnitFactory('t', 1e6);
$tonne->addAlias('T');
$tonne->addAlias('ton');
$tonne->addAlias('tons');
$tonne->addAlias('tonne');
$tonne->addAlias('tonnes');
static::addUnit($tonne);
static::addMissingSIPrefixedUnits(
$tonne,
1,
'%pt',
[
'%pT',
'%Pton',
'%Ptons',
'%Ptonne',
'%Ptonnes',
]
);
// Grain
$newUnit = UnitOfMeasure::linearUnitFactory('gr', 453.59237 / (16 * 437.5));
$newUnit->addAlias('grain');
$newUnit->addAlias('grains');
static::addUnit($newUnit);
// Pound
$newUnit = UnitOfMeasure::linearUnitFactory('lb', 453.59237);
$newUnit->addAlias('lbs');
$newUnit->addAlias('pound');
$newUnit->addAlias('pounds');
static::addUnit($newUnit);
// Ounce
$newUnit = UnitOfMeasure::linearUnitFactory('oz', 453.59237 / 16);
$newUnit->addAlias('ounce');
$newUnit->addAlias('ounces');
static::addUnit($newUnit);
// Stone
$newUnit = UnitOfMeasure::linearUnitFactory('st', 453.59237 * 14);
$newUnit->addAlias('stone');
$newUnit->addAlias('stones');
static::addUnit($newUnit);
// Hundredweight
$newUnit = UnitOfMeasure::linearUnitFactory('cwt', 453.59237 * 112);
$newUnit->addAlias('hundredweight');
$newUnit->addAlias('hundredweights');
static::addUnit($newUnit);
// US short Ton
$newUnit = UnitOfMeasure::linearUnitFactory('ust', 453.59237 * 2000);
$newUnit->addAlias('us short ton');
$newUnit->addAlias('us short tons');
static::addUnit($newUnit);
// US long Ton
$newUnit = UnitOfMeasure::linearUnitFactory('ukt', 453.59237 * 2240);
$newUnit->addAlias('uk long ton');
$newUnit->addAlias('uk long tons');
static::addUnit($newUnit);
// Asian picul
$newUnit = UnitOfMeasure::linearUnitFactory('picul', 60478.982);
$newUnit->addAlias('tam');
static::addUnit($newUnit);
}
}

46
libs/PhpUnitsOfMeasure/PhysicalQuantity/Power.php Normal file
View File

@ -0,0 +1,46 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Power extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Watt
$watt = UnitOfMeasure::nativeUnitFactory('W');
$watt->addAlias('watt');
$watt->addAlias('watts');
static::addUnit($watt);
static::addMissingSIPrefixedUnits(
$watt,
1,
'%pW',
[
'%Pwatt',
'%Pwatts',
]
);
// decibels-milliwatt
$newUnit = new UnitOfMeasure(
'dBm',
function ($x) {
return 10 * log10($x) + 30;
},
function ($x) {
return pow(10, ($x / 10)) / 1000;
}
);
$newUnit->addAlias('dbm');
$newUnit->addAlias('decibels-milliwatt');
static::addUnit($newUnit);
}
}

87
libs/PhpUnitsOfMeasure/PhysicalQuantity/Pressure.php Normal file
View File

@ -0,0 +1,87 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Pressure extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Pascal
$pascal = UnitOfMeasure::nativeUnitFactory('Pa');
$pascal->addAlias('pascal');
$pascal->addAlias('pascals');
static::addUnit($pascal);
static::addMissingSIPrefixedUnits(
$pascal,
1,
'%pPa',
[
'%Ppascal',
'%Ppascals',
]
);
// Standard atmosphere
$newUnit = UnitOfMeasure::linearUnitFactory('atm', 101325);
$newUnit->addAlias('atmosphere');
$newUnit->addAlias('atmospheres');
static::addUnit($newUnit);
// Technical atmosphere
$newUnit = UnitOfMeasure::linearUnitFactory('at', 98066.5);
$newUnit->addAlias('technical atmosphere');
$newUnit->addAlias('technical atmospheres');
static::addUnit($newUnit);
// Torr
$newUnit = UnitOfMeasure::linearUnitFactory('torr', 101325 / 760);
static::addUnit($newUnit);
// Bar
$bar = UnitOfMeasure::linearUnitFactory('bar', 1e5);
static::addUnit($bar);
static::addMissingSIPrefixedUnits(
$bar,
1,
'%pbar'
);
// Inch of Mercury
$newUnit = UnitOfMeasure::linearUnitFactory('inHg', 1 / 0.00029530);
//$newUnit->addAlias('inhg');
$newUnit->addAlias('inches of mercury');
static::addUnit($newUnit);
// Millimeter of Mercury
$newUnit = UnitOfMeasure::linearUnitFactory('mmHg', 133.322387415);
//$newUnit->addAlias('mmhg');
$newUnit->addAlias('millimeters of mercury');
$newUnit->addAlias('millimetres of mercury');
static::addUnit($newUnit);
// Pound per Square Inch
$newUnit = UnitOfMeasure::linearUnitFactory('psi', 6894.757293168);
$newUnit->addAlias('pounds per square inch');
static::addUnit($newUnit);
// Kilo-pound per Square Inch
$newUnit = UnitOfMeasure::linearUnitFactory('ksi', 6894757.293168);
$newUnit->addAlias('kilopounds per square inch');
static::addUnit($newUnit);
// Kilo-pound per Square Inch
$newUnit = UnitOfMeasure::linearUnitFactory('Mpsi', 6894757293.168);
//$newUnit->addAlias('mpsi');
$newUnit->addAlias('megapounds per square inch');
static::addUnit($newUnit);
}
}

32
libs/PhpUnitsOfMeasure/PhysicalQuantity/Quantity.php Normal file
View File

@ -0,0 +1,32 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Quantity extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Moles
$mole = UnitOfMeasure::nativeUnitFactory('mol');
$mole->addAlias('mole');
$mole->addAlias('moles');
static::addUnit($mole);
static::addMissingSIPrefixedUnits(
$mole,
1,
'%pmol',
[
'%Pmole',
'%Pmoles',
]
);
}
}

32
libs/PhpUnitsOfMeasure/PhysicalQuantity/SolidAngle.php Normal file
View File

@ -0,0 +1,32 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class SolidAngle extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Steradians
$steradian = UnitOfMeasure::nativeUnitFactory('sr');
$steradian->addAlias('steradian');
$steradian->addAlias('steradians');
static::addUnit($steradian);
static::addMissingSIPrefixedUnits(
$steradian,
1,
'%psr',
[
'%Psteradian',
'%Psteradians',
]
);
}
}

141
libs/PhpUnitsOfMeasure/PhysicalQuantity/Temperature.php Normal file
View File

@ -0,0 +1,141 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Temperature extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Kelvin
$kelvin = UnitOfMeasure::nativeUnitFactory('K');
$kelvin->addAlias('k');
$kelvin->addAlias('°K');
$kelvin->addAlias('kelvin');
static::addUnit($kelvin);
static::addMissingSIPrefixedUnits(
$kelvin,
1,
'%pK',
[
'%pk',
'%Pkelvin',
]
);
// Degree Celsius
$newUnit = new UnitOfMeasure(
'°C',
function ($x) {
return $x - 273.15;
},
function ($x) {
return $x + 273.15;
}
);
$newUnit->addAlias('c');
$newUnit->addAlias('C');
$newUnit->addAlias('celsius');
static::addUnit($newUnit);
// Degree Fahrenheit
$newUnit = new UnitOfMeasure(
'°F',
function ($x) {
return ($x * 9 / 5) - 459.67;
},
function ($x) {
return ($x + 459.67) * 5/9;
}
);
$newUnit->addAlias('f');
$newUnit->addAlias('F');
$newUnit->addAlias('fahrenheit');
static::addUnit($newUnit);
// Degree Rankine
$newUnit = UnitOfMeasure::linearUnitFactory('°Ra', 5/9);
$newUnit->addAlias('°R');
$newUnit->addAlias('r');
$newUnit->addAlias('R');
$newUnit->addAlias('ra');
$newUnit->addAlias('Ra');
$newUnit->addAlias('rankine');
static::addUnit($newUnit);
// Degree Delisle
$newUnit = new UnitOfMeasure(
'°De',
function ($x) {
return (373.15 - $x) * 3/2;
},
function ($x) {
return 373.15 - $x * 2/3;
}
);
$newUnit->addAlias('°D');
$newUnit->addAlias('D');
$newUnit->addAlias('d');
$newUnit->addAlias('de');
$newUnit->addAlias('De');
$newUnit->addAlias('delisle');
static::addUnit($newUnit);
// Degree Newton
$newUnit = new UnitOfMeasure(
'°N',
function ($x) {
return ($x - 273.15) * 33/100;
},
function ($x) {
return $x * 100/33 + 273.15;
}
);
$newUnit->addAlias('N');
$newUnit->addAlias('newton');
static::addUnit($newUnit);
// Degree Réaumur
$newUnit = new UnitOfMeasure(
'°Ré',
function ($x) {
return ($x - 273.15) * 4/5;
},
function ($x) {
return $x * 5/4 + 273.15;
}
);
$newUnit->addAlias('°Re');
$newUnit->addAlias('Ré');
$newUnit->addAlias('re');
$newUnit->addAlias('Re');
$newUnit->addAlias('réaumur');
$newUnit->addAlias('reaumur');
static::addUnit($newUnit);
// Degree Rømer
$newUnit = new UnitOfMeasure(
'°Rø',
function ($x) {
return ($x - 273.15) * 21/40 + 7.5;
},
function ($x) {
return ($x - 7.5) * 40/21 + 273.15;
}
);
$newUnit->addAlias('°Ro');
$newUnit->addAlias('Rø');
$newUnit->addAlias('ro');
$newUnit->addAlias('Ro');
$newUnit->addAlias('rømer');
$newUnit->addAlias('romer');
static::addUnit($newUnit);
}
}

95
libs/PhpUnitsOfMeasure/PhysicalQuantity/Time.php Normal file
View File

@ -0,0 +1,95 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\UnitOfMeasure;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
class Time extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Second
$second = UnitOfMeasure::nativeUnitFactory('s');
$second->addAlias('sec');
$second->addAlias('secs');
$second->addAlias('second');
$second->addAlias('seconds');
static::addUnit($second);
static::addMissingSIPrefixedUnits(
$second,
1,
'%ps',
[
'%Psec',
'%Psecs',
'%Psecond',
'%Pseconds'
]
);
// Minutes
$newUnit = UnitOfMeasure::linearUnitFactory('m', 60);
$newUnit->addAlias('min');
$newUnit->addAlias('mins');
$newUnit->addAlias('minute');
$newUnit->addAlias('minutes');
static::addUnit($newUnit);
// Hours
$newUnit = UnitOfMeasure::linearUnitFactory('h', 3600);
$newUnit->addAlias('hr');
$newUnit->addAlias('hrs');
$newUnit->addAlias('hour');
$newUnit->addAlias('hours');
static::addUnit($newUnit);
// Days
$newUnit = UnitOfMeasure::linearUnitFactory('d', 86400);
$newUnit->addAlias('day');
$newUnit->addAlias('days');
static::addUnit($newUnit);
// Weeks, understood as 7 days
$newUnit = UnitOfMeasure::linearUnitFactory('w', 604800);
$newUnit->addAlias('wk');
$newUnit->addAlias('wks');
$newUnit->addAlias('week');
$newUnit->addAlias('weeks');
static::addUnit($newUnit);
// Gregorian year, understood as 365.2425 days
$newUnit = UnitOfMeasure::linearUnitFactory('yr', 31556952);
$newUnit->addAlias('year');
$newUnit->addAlias('years');
$newUnit->addAlias('gregorian year');
$newUnit->addAlias('gregorian years');
static::addUnit($newUnit);
// Decade
$newUnit = UnitOfMeasure::linearUnitFactory('decade', 315569520);
$newUnit->addAlias('decades');
static::addUnit($newUnit);
// Century
$newUnit = UnitOfMeasure::linearUnitFactory('century', 3155695200);
$newUnit->addAlias('centuries');
static::addUnit($newUnit);
// Millennium
$newUnit = UnitOfMeasure::linearUnitFactory('millennium', 31556952000);
$newUnit->addAlias('millennia');
static::addUnit($newUnit);
// Julian year, understood as 365.25 days
$newUnit = UnitOfMeasure::linearUnitFactory('jyr', 31557600);
$newUnit->addAlias('julian year');
$newUnit->addAlias('julian years');
static::addUnit($newUnit);
}
}

127
libs/PhpUnitsOfMeasure/PhysicalQuantity/Velocity.php Normal file
View File

@ -0,0 +1,127 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
use PhpUnitsOfMeasure\UnitOfMeasure;
class Velocity extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// meter per second
$meterpersecond = UnitOfMeasure::nativeUnitFactory('m/s');
$meterpersecond->addAlias('meters/sec');
$meterpersecond->addAlias('meters per second');
$meterpersecond->addAlias('meter per second');
$meterpersecond->addAlias('metres per second');
$meterpersecond->addAlias('metre per second');
static::addUnit($meterpersecond);
static::addMissingSIPrefixedUnits(
$meterpersecond,
1,
'%pm/s',
[
'%Pmeters/sec',
'%Pmeter per second',
'%Pmeters per second',
'%Pmetre per second',
'%Pmetres per second'
]
);
// meter per minute
$meterperminute = UnitOfMeasure::linearUnitFactory('m/min', 1 / 60);
$meterperminute->addAlias('meters/min');
$meterperminute->addAlias('meters per minute');
$meterperminute->addAlias('meter per minute');
$meterperminute->addAlias('metres per minute');
$meterperminute->addAlias('metre per minute');
static::addUnit($meterperminute);
static::addMissingSIPrefixedUnits(
$meterperminute,
1,
'%pm/min',
[
'%Pmeters/min',
'%Pmeter per minute',
'%Pmeters per minute',
'%Pmetre per minute',
'%Pmetres per minute'
]
);
// meters per hour
$meterperhour = UnitOfMeasure::linearUnitFactory('m/h', 1 / 3600);
$meterperhour->addAlias('m/hr');
$meterperhour->addAlias('m/hour');
$meterperhour->addAlias('meters/hour');
$meterperhour->addAlias('meter per hour');
$meterperhour->addAlias('meters per hour');
$meterperhour->addAlias('metre per hour');
$meterperhour->addAlias('metres per hour');
static::addUnit($meterperhour);
static::addMissingSIPrefixedUnits(
$meterperhour,
1,
'%pm/h',
[
'%pm/hr',
'%pm/hour',
'%Pmeters/hour',
'%Pmeter per hour',
'%Pmeters per hour',
'%Pmetre per hour',
'%Pmetres per hour'
]
);
// feet per second
$newUnit = UnitOfMeasure::linearUnitFactory('ft/s', 0.3048);
$newUnit->addAlias('fps');
$newUnit->addAlias('FPS');
$newUnit->addAlias('feet/sec');
$newUnit->addAlias('feet per second');
static::addUnit($newUnit);
// feet per minute
$newUnit = UnitOfMeasure::linearUnitFactory('ft/min', 0.3048 / 60);
$newUnit->addAlias('fpm');
$newUnit->addAlias('FPM');
$newUnit->addAlias('feet/min');
$newUnit->addAlias('feet per minute');
static::addUnit($newUnit);
// miles per second
$newUnit = UnitOfMeasure::linearUnitFactory('mps', 1609.344);
$newUnit->addAlias('MPS');
$newUnit->addAlias('miles/sec');
$newUnit->addAlias('miles per second');
static::addUnit($newUnit);
// miles per hour
$newUnit = UnitOfMeasure::linearUnitFactory('mph', 1609.344 / 3600);
$newUnit->addAlias('MPH');
$newUnit->addAlias('miles/hour');
$newUnit->addAlias('miles per hour');
static::addUnit($newUnit);
// knot
$newUnit = UnitOfMeasure::linearUnitFactory('kn', 0.514444);
$newUnit->addAlias('knot');
$newUnit->addAlias('knots');
static::addUnit($newUnit);
// Supersonic speed
$newUnit = UnitOfMeasure::linearUnitFactory('mach', 344);
$newUnit->addAlias('speed of sound');
static::addUnit($newUnit);
}
}

131
libs/PhpUnitsOfMeasure/PhysicalQuantity/Volume.php Normal file
View File

@ -0,0 +1,131 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
use PhpUnitsOfMeasure\UnitOfMeasure;
class Volume extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Cubic meter
$cubicmeter = UnitOfMeasure::nativeUnitFactory('m^3');
$cubicmeter->addAlias('m³');
$cubicmeter->addAlias('cubic meter');
$cubicmeter->addAlias('cubic meters');
$cubicmeter->addAlias('cubic metre');
$cubicmeter->addAlias('cubic metres');
static::addUnit($cubicmeter);
static::addMissingSIPrefixedUnits(
$cubicmeter,
1,
'%pm^3',
[
'%pm³',
'cubic %Pmeter',
'cubic %Pmeters',
'cubic %Pmetre',
'cubic %Pmetres'
],
3 // cubic power factor
);
// Cubic foot
$newUnit = UnitOfMeasure::linearUnitFactory('ft^3', pow(0.3048, 3));
$newUnit->addAlias('ft³');
$newUnit->addAlias('cubic foot');
$newUnit->addAlias('cubic feet');
static::addUnit($newUnit);
// Cubic inch
$newUnit = UnitOfMeasure::linearUnitFactory('in^3', pow(0.0254, 3));
$newUnit->addAlias('in³');
$newUnit->addAlias('cubic inch');
$newUnit->addAlias('cubic inches');
static::addUnit($newUnit);
// Cubic yard
$newUnit = UnitOfMeasure::linearUnitFactory('yd^3', pow(0.9144, 3));
$newUnit->addAlias('yd³');
$newUnit->addAlias('cubic yard');
$newUnit->addAlias('cubic yards');
static::addUnit($newUnit);
// Liter
$liter = UnitOfMeasure::linearUnitFactory('l', 1e-3);
$liter->addAlias('L');
$liter->addAlias('liter');
$liter->addAlias('liters');
$liter->addAlias('litre');
$liter->addAlias('litres');
static::addUnit($liter);
static::addMissingSIPrefixedUnits(
$liter,
1,
'%pl',
[
'%pL',
'%Pliter',
'%Pliters',
'%Plitre',
'%Plitres'
]
);
// Cup
$newUnit = UnitOfMeasure::linearUnitFactory('cup', 2.365882e-4);
$newUnit->addAlias('cup');
$newUnit->addAlias('cups');
static::addUnit($newUnit);
// teaspoon
$newUnit = UnitOfMeasure::linearUnitFactory('tsp', 0.00000492892);
$newUnit->addAlias('teaspoon');
$newUnit->addAlias('teaspoons');
static::addUnit($newUnit);
// tablespoon
$newUnit = UnitOfMeasure::linearUnitFactory('tbsp', 0.00001478676);
$newUnit->addAlias('tablespoon');
$newUnit->addAlias('tablespoons');
static::addUnit($newUnit);
// Gallon
$newUnit = UnitOfMeasure::linearUnitFactory('gal', 3.7854118e-3);
$newUnit->addAlias('gallon');
$newUnit->addAlias('gallons');
$newUnit->addAlias('us gal');
static::addUnit($newUnit);
// Quart
$newUnit = UnitOfMeasure::linearUnitFactory('qt', 9.4635295e-4);
$newUnit->addAlias('quart');
$newUnit->addAlias('quarts');
$newUnit->addAlias('qts');
$newUnit->addAlias('liq qt');
static::addUnit($newUnit);
// Fluid Ounce
$newUnit = UnitOfMeasure::linearUnitFactory('fl oz', 2.957353e-5);
$newUnit->addAlias('fluid ounce');
$newUnit->addAlias('fluid ounces');
$newUnit->addAlias('fluid oz');
$newUnit->addAlias('fl. oz.');
$newUnit->addAlias('oz. fl.');
static::addUnit($newUnit);
// Pint
$newUnit = UnitOfMeasure::linearUnitFactory('pt', 4.73176475e-4);
$newUnit->addAlias('pint');
$newUnit->addAlias('pints');
$newUnit->addAlias('liq pt');
static::addUnit($newUnit);
}
}

222
libs/PhpUnitsOfMeasure/PhysicalQuantity/VolumeFlow.php Normal file
View File

@ -0,0 +1,222 @@
<?php
namespace PhpUnitsOfMeasure\PhysicalQuantity;
use PhpUnitsOfMeasure\AbstractPhysicalQuantity;
use PhpUnitsOfMeasure\HasSIUnitsTrait;
use PhpUnitsOfMeasure\UnitOfMeasure;
class VolumeFlow extends AbstractPhysicalQuantity
{
use HasSIUnitsTrait;
protected static $unitDefinitions;
protected static function initialize()
{
// Cubic meter per second
$cubicmeterpersecond = UnitOfMeasure::nativeUnitFactory('m^3/s');
$cubicmeterpersecond->addAlias('m³/s');
$cubicmeterpersecond->addAlias('cubic meter per second');
$cubicmeterpersecond->addAlias('cubic meters per second');
$cubicmeterpersecond->addAlias('cubic metre per second');
$cubicmeterpersecond->addAlias('cubic metres per second');
static::addUnit($cubicmeterpersecond);
static::addMissingSIPrefixedUnits(
$cubicmeterpersecond,
1,
'%pm^3/s',
[
'%pm³/s',
'cubic %Pmeter per second',
'cubic %Pmeters per second',
'cubic %Pmetre per second',
'cubic %Pmetres per second'
],
3 // cubic power factor
);
// Cubic meter per minute
$newUnit = UnitOfMeasure::linearUnitFactory('m^3/min', 1 / 60);
$newUnit->addAlias('m³/min');
$newUnit->addAlias('cmm');
$newUnit->addAlias('CMM');
$newUnit->addAlias('cubic meter per minute');
$newUnit->addAlias('cubic meters per minute');
static::addUnit($newUnit);
// Cubic meter per hour
$newUnit = UnitOfMeasure::linearUnitFactory('m^3/h', 1 / 3600);
$newUnit->addAlias('m³/h');
$newUnit->addAlias('cmh');
$newUnit->addAlias('CMH');
$newUnit->addAlias('cubic meter per hour');
$newUnit->addAlias('cubic meters per hour');
static::addUnit($newUnit);
// Liter per second
$literpersecond = UnitOfMeasure::linearUnitFactory('l/s', 1e-3);
$literpersecond->addAlias('L/s');
$literpersecond->addAlias('liter per second');
$literpersecond->addAlias('liters per second');
$literpersecond->addAlias('litre per second');
$literpersecond->addAlias('litres per second');
static::addUnit($literpersecond);
static::addMissingSIPrefixedUnits(
$literpersecond,
1,
'%pl/s',
[
'%pL/s',
'%Pliter per second',
'%Pliters per second',
'%Plitre per second',
'%Plitres per second'
]
);
// Liter per minute
$newUnit = UnitOfMeasure::linearUnitFactory('l/min', 1e-3 / 60);
$newUnit->addAlias('L/min');
$newUnit->addAlias('lpm');
$newUnit->addAlias('LPM');
$newUnit->addAlias('liter per minute');
$newUnit->addAlias('liters per minute');
$newUnit->addAlias('litre per minute');
$newUnit->addAlias('litres per minute');
static::addUnit($newUnit);
// Liter per hour
$newUnit = UnitOfMeasure::linearUnitFactory('l/h', 1e-3 / 3600);
$newUnit->addAlias('L/h');
$newUnit->addAlias('lph');
$newUnit->addAlias('LPH');
$newUnit->addAlias('liter per hour');
$newUnit->addAlias('liters per hour');
$newUnit->addAlias('litre per hour');
$newUnit->addAlias('litres per hour');
static::addUnit($newUnit);
// Cubic foot per second
$newUnit = UnitOfMeasure::linearUnitFactory('ft^3/s', pow(0.3048, 3));
$newUnit->addAlias('cfs');
$newUnit->addAlias('CFS');
$newUnit->addAlias('ft³/s');
$newUnit->addAlias('cubic foot per second');
$newUnit->addAlias('cubic feet per second');
static::addUnit($newUnit);
// Cubic foot per minute
$newUnit = UnitOfMeasure::linearUnitFactory('ft^3/min', pow(0.3048, 3) / 60);
$newUnit->addAlias('cfm');
$newUnit->addAlias('CFM');
$newUnit->addAlias('ft³/min');
$newUnit->addAlias('cubic foot per minute');
$newUnit->addAlias('cubic feet per minute');
static::addUnit($newUnit);
// Cubic foot per hour
$newUnit = UnitOfMeasure::linearUnitFactory('ft^3/h', pow(0.3048, 3) / 3600);
$newUnit->addAlias('cfh');
$newUnit->addAlias('CFH');
$newUnit->addAlias('ft³/h');
$newUnit->addAlias('cubic foot per hour');
$newUnit->addAlias('cubic feet per hour');
static::addUnit($newUnit);
// Gallon per second
$newUnit = UnitOfMeasure::linearUnitFactory('gal/s', 3.7854118e-3);
$newUnit->addAlias('gps');
$newUnit->addAlias('GPS');
$newUnit->addAlias('gallon per second');
$newUnit->addAlias('gallons per second');
$newUnit->addAlias('us gal/s');
static::addUnit($newUnit);
// Gallon per minute
$newUnit = UnitOfMeasure::linearUnitFactory('gal/min', 3.7854118e-3 / 60);
$newUnit->addAlias('gpm');
$newUnit->addAlias('GPM');
$newUnit->addAlias('gallon per minute');
$newUnit->addAlias('gallons per minute');
$newUnit->addAlias('us gal/min');
static::addUnit($newUnit);
// Gallon per hour
$newUnit = UnitOfMeasure::linearUnitFactory('gal/h', 3.7854118e-3 / 3600);
$newUnit->addAlias('gph');
$newUnit->addAlias('GPH');
$newUnit->addAlias('gallon per hour');
$newUnit->addAlias('gallons per hour');
$newUnit->addAlias('us gal/h');
static::addUnit($newUnit);
// Gallon per day
$newUnit = UnitOfMeasure::linearUnitFactory('gal/d', 3.7854118e-3 / 86400);
$newUnit->addAlias('gpd');
$newUnit->addAlias('GPD');
$newUnit->addAlias('gallon per day');
$newUnit->addAlias('gallons per day');
$newUnit->addAlias('us gal/d');
static::addUnit($newUnit);
/*
// Cubic inch per second
$newUnit = UnitOfMeasure::linearUnitFactory('in^3', pow(0.0254, 3));
$newUnit->addAlias('in³');
$newUnit->addAlias('cubic inch per second');
$newUnit->addAlias('cubic inches per second');
static::addUnit($newUnit);
// Cubic yard per second
$newUnit = UnitOfMeasure::linearUnitFactory('yd^3', pow(0.9144, 3));
$newUnit->addAlias('yd³');
$newUnit->addAlias('cubic yard per second');
$newUnit->addAlias('cubic yards per second');
static::addUnit($newUnit);
// Cup
$newUnit = UnitOfMeasure::linearUnitFactory('cup', 2.365882e-4);
$newUnit->addAlias('cup');
$newUnit->addAlias('cups');
static::addUnit($newUnit);
// teaspoon
$newUnit = UnitOfMeasure::linearUnitFactory('tsp', 0.00000492892);
$newUnit->addAlias('teaspoon');
$newUnit->addAlias('teaspoons');
static::addUnit($newUnit);
// tablespoon
$newUnit = UnitOfMeasure::linearUnitFactory('tbsp', 0.00001478676);
$newUnit->addAlias('tablespoon');
$newUnit->addAlias('tablespoons');
static::addUnit($newUnit);
// Quart
$newUnit = UnitOfMeasure::linearUnitFactory('qt', 9.4635295e-4);
$newUnit->addAlias('quart');
$newUnit->addAlias('quarts');
$newUnit->addAlias('qts');
$newUnit->addAlias('liq qt');
static::addUnit($newUnit);
// Fluid Ounce
$newUnit = UnitOfMeasure::linearUnitFactory('fl oz', 2.957353e-5);
$newUnit->addAlias('fluid ounce');
$newUnit->addAlias('fluid ounces');
$newUnit->addAlias('fluid oz');
$newUnit->addAlias('fl. oz.');
$newUnit->addAlias('oz. fl.');
static::addUnit($newUnit);
// Pint
$newUnit = UnitOfMeasure::linearUnitFactory('pt', 4.73176475e-4);
$newUnit->addAlias('pint');
$newUnit->addAlias('pints');
$newUnit->addAlias('liq pt');
static::addUnit($newUnit);
*/
}
}