/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Degrees
$new_unit = new UnitOfMeasure('°', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('deg');
$new_unit->addAlias('degs');
$new_unit->addAlias('degree');
$new_unit->addAlias('degrees');
$this->registerUnitOfMeasure($new_unit);
// Radians
$new_unit = new UnitOfMeasure('rad', function ($x) {
return $x * M_PI / 180;
}, function ($x) {
return $x / M_PI * 180;
});
$new_unit->addAlias('rads');
$new_unit->addAlias('radian');
$new_unit->addAlias('radians');
$this->registerUnitOfMeasure($new_unit);
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Degree Kelvin
$new_unit = new UnitOfMeasure('°K', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('K');
$new_unit->addAlias('kelvin');
$this->registerUnitOfMeasure($new_unit);
// Degree Celsius
$new_unit = new UnitOfMeasure('°C', function ($x) {
return $x - 273.15;
}, function ($x) {
return $x + 273.15;
});
$new_unit->addAlias('C');
$new_unit->addAlias('celsius');
$this->registerUnitOfMeasure($new_unit);
// Degree Fahrenheit
$new_unit = new UnitOfMeasure('°F', function ($x) {
return $x * 9 / 5 - 459.67;
}, function ($x) {
return ($x + 459.67) * 5 / 9;
});
$new_unit->addAlias('F');
$new_unit->addAlias('fahrenheit');
$this->registerUnitOfMeasure($new_unit);
}
/**
* @covers \PhpUnitsOfMeasure\UnitOfMeasure::convertValueToNativeUnitOfMeasure
*/
public function testConvertValueToNativeUnitOfMeasure()
{
$uom = new UnitOfMeasure('quatloos', function ($x) {
return false;
}, function ($x) {
return $x * 1.1234;
});
$this->assertSame(11.234, $uom->convertValueToNativeUnitOfMeasure(10));
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Pascal
$new_unit = new UnitOfMeasure('Pa', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('pascal');
$this->registerUnitOfMeasure($new_unit);
// Atmosphere
$new_unit = new UnitOfMeasure('atm', function ($x) {
return $x / 101325;
}, function ($x) {
return $x * 101325;
});
$new_unit->addAlias('atmosphere');
$new_unit->addAlias('atmospheres');
$this->registerUnitOfMeasure($new_unit);
// Bar
$new_unit = new UnitOfMeasure('bar', function ($x) {
return $x / 100000.0;
}, function ($x) {
return $x * 100000.0;
});
$new_unit->addAlias('bar');
$this->registerUnitOfMeasure($new_unit);
// Inch of Mercury
$new_unit = new UnitOfMeasure('inHg', function ($x) {
return $x / 3386.389;
}, function ($x) {
return $x * 3386.389;
});
$new_unit->addAlias('inches of mercury');
$this->registerUnitOfMeasure($new_unit);
// Milimeter of Mercury
$new_unit = new UnitOfMeasure('mmHg', function ($x) {
return $x / 133.3224;
}, function ($x) {
return $x * 133.3224;
});
$new_unit->addAlias('milimeters of mercury');
$new_unit->addAlias('torr');
$this->registerUnitOfMeasure($new_unit);
// Pound per Square Inch
$new_unit = new UnitOfMeasure('psi', function ($x) {
return $x / 6894.757;
}, function ($x) {
return $x * 6894.757;
});
$new_unit->addAlias('pounds per square inch');
$this->registerUnitOfMeasure($new_unit);
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Candela
$new_unit = new UnitOfMeasure('cd', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('candela');
$this->registerUnitOfMeasure($new_unit);
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// meter per second
$new_unit = new UnitOfMeasure('m/s', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('meters per second');
$new_unit->addAlias('meter per second');
$this->registerUnitOfMeasure($new_unit);
}
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);
// kilometers per hour
$newUnit = UnitOfMeasure::linearUnitFactory('km/h', 0.277778);
$newUnit->addAlias('km/hour');
$newUnit->addAlias('kilometer per hour');
$newUnit->addAlias('kilometers per hour');
$newUnit->addAlias('kilometre per hour');
$newUnit->addAlias('kilometres per hour');
static::addUnit($newUnit);
// feet per second
$newUnit = UnitOfMeasure::linearUnitFactory('ft/s', 0.3048);
$newUnit->addAlias('feet/sec');
$newUnit->addAlias('feet per second');
static::addUnit($newUnit);
// miles per hour
$newUnit = UnitOfMeasure::linearUnitFactory('mph', 0.44704);
$newUnit->addAlias('miles/hour');
$newUnit->addAlias('miles per hour');
static::addUnit($newUnit);
// knot
$newUnit = UnitOfMeasure::linearUnitFactory('knot', 0.514444);
$newUnit->addAlias('knots');
static::addUnit($newUnit);
}
protected static function initialize()
{
// Kilogram
$kilogram = UnitOfMeasure::nativeUnitFactory('kg');
$kilogram->addAlias('kilogram');
$kilogram->addAlias('kilograms');
static::addUnit($kilogram);
static::addMissingSIPrefixedUnits($kilogram, 0.001, '%pg', ['%Pgram', '%Pgrams']);
// Tonne (metric)
$newUnit = UnitOfMeasure::linearUnitFactory('t', 1000.0);
$newUnit->addAlias('ton');
$newUnit->addAlias('tons');
$newUnit->addAlias('tonne');
$newUnit->addAlias('tonnes');
static::addUnit($newUnit);
// Pound
$newUnit = UnitOfMeasure::linearUnitFactory('lb', 0.45359237);
$newUnit->addAlias('lbs');
$newUnit->addAlias('pound');
$newUnit->addAlias('pounds');
static::addUnit($newUnit);
// Ounce
$newUnit = UnitOfMeasure::linearUnitFactory('oz', 0.45359237 / 16);
$newUnit->addAlias('ounce');
$newUnit->addAlias('ounces');
static::addUnit($newUnit);
// Stone
$newUnit = UnitOfMeasure::linearUnitFactory('st', 0.45359237 * 14);
$newUnit->addAlias('stone');
$newUnit->addAlias('stones');
static::addUnit($newUnit);
}
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);
}
protected static function initialize()
{
// Pascal
$pascal = UnitOfMeasure::nativeUnitFactory('Pa');
$pascal->addAlias('pascal');
static::addUnit($pascal);
static::addMissingSIPrefixedUnits($pascal, 1, '%pPa', ['%Ppascal']);
// Atmosphere
$newUnit = UnitOfMeasure::linearUnitFactory('atm', 101325);
$newUnit->addAlias('atmosphere');
$newUnit->addAlias('atmospheres');
static::addUnit($newUnit);
// Bar
$bar = UnitOfMeasure::linearUnitFactory('bar', 100000.0);
static::addUnit($bar);
static::addMissingSIPrefixedUnits($bar, 1, '%pbar');
// Inch of Mercury
$newUnit = UnitOfMeasure::linearUnitFactory('inHg', 3386.389);
$newUnit->addAlias('inches of mercury');
static::addUnit($newUnit);
// Millimeter of Mercury
$newUnit = UnitOfMeasure::linearUnitFactory('mmHg', 133.3224);
$newUnit->addAlias('millimeters of mercury');
$newUnit->addAlias('millimetres of mercury');
$newUnit->addAlias('torr');
static::addUnit($newUnit);
// Pound per Square Inch
$newUnit = UnitOfMeasure::linearUnitFactory('psi', 6894.757);
$newUnit->addAlias('pounds per square inch');
static::addUnit($newUnit);
}
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']);
}
protected static function initialize()
{
// Candela
$candela = UnitOfMeasure::nativeUnitFactory('cd');
$candela->addAlias('candela');
static::addUnit($candela);
static::addMissingSIPrefixedUnits($candela, 1, '%pcd', ['%Pcandela']);
}
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']);
}
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']);
}
protected static function initialize()
{
// meter per second
$meterpersecond = UnitOfMeasure::nativeUnitFactory('m/s');
$meterpersecond->addAlias('meters per second');
$meterpersecond->addAlias('meter per second');
$meterpersecond->addAlias('metres per second');
$meterpersecond->addAlias('metre per second');
static::addUnit($meterpersecond);
}
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']);
}
protected static function initialize()
{
$native = UnitOfMeasure::nativeUnitFactory('s');
$native->addAlias('sopee');
$native->addAlias('sopees');
static::addUnit($native);
$unit = UnitOfMeasure::linearUnitFactory('t', 2.5);
$unit->addAlias('tumpet');
$unit->addAlias('tumpets');
static::addUnit($unit);
}
protected static function initialize()
{
$native = UnitOfMeasure::nativeUnitFactory('u');
$native->addAlias('uvee');
$native->addAlias('uvees');
static::addUnit($native);
$unit = UnitOfMeasure::linearUnitFactory('v', 3.5);
$unit->addAlias('vorp');
$unit->addAlias('vorps');
static::addUnit($unit);
}
protected static function initialize()
{
$native = UnitOfMeasure::nativeUnitFactory('l');
$native->addAlias('lupee');
$native->addAlias('lupees');
static::addUnit($native);
static::addMissingSIPrefixedUnits($native, 1, '%pl', ['%Plupee', '%Plupees']);
$unit = UnitOfMeasure::linearUnitFactory('p', 4.5);
$unit->addAlias('plurp');
$unit->addAlias('plurps');
static::addUnit($unit);
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Second
$new_unit = new UnitOfMeasure('s', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('sec');
$new_unit->addAlias('secs');
$new_unit->addAlias('second');
$new_unit->addAlias('seconds');
$this->registerUnitOfMeasure($new_unit);
// Minutes
$new_unit = new UnitOfMeasure('m', function ($x) {
return $x / 60;
}, function ($x) {
return $x * 60;
});
$new_unit->addAlias('min');
$new_unit->addAlias('mins');
$new_unit->addAlias('minute');
$new_unit->addAlias('minutes');
$this->registerUnitOfMeasure($new_unit);
// Hours
$new_unit = new UnitOfMeasure('h', function ($x) {
return $x / 3600;
}, function ($x) {
return $x * 3600;
});
$new_unit->addAlias('hr');
$new_unit->addAlias('hrs');
$new_unit->addAlias('hour');
$new_unit->addAlias('hours');
$this->registerUnitOfMeasure($new_unit);
// Days
$new_unit = new UnitOfMeasure('d', function ($x) {
return $x / 86400;
}, function ($x) {
return $x * 86400;
});
$new_unit->addAlias('day');
$new_unit->addAlias('days');
$this->registerUnitOfMeasure($new_unit);
// Weeks, understood as 7 days
$new_unit = new UnitOfMeasure('w', function ($x) {
return $x / 604800;
}, function ($x) {
return $x * 604800;
});
$new_unit->addAlias('wk');
$new_unit->addAlias('wks');
$new_unit->addAlias('week');
$new_unit->addAlias('weeks');
$this->registerUnitOfMeasure($new_unit);
}
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);
// Julian year, understood as 365.25 days
$newUnit = UnitOfMeasure::linearUnitFactory('jyr', 31557600);
$newUnit->addAlias('julian year');
$newUnit->addAlias('julian years');
static::addUnit($newUnit);
}
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']);
// 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']);
}
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);
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Ampere
$new_unit = new UnitOfMeasure('A', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('amp');
$new_unit->addAlias('amps');
$new_unit->addAlias('ampere');
$new_unit->addAlias('amperes');
$this->registerUnitOfMeasure($new_unit);
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Meter
$new_unit = new UnitOfMeasure('m', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('meter');
$new_unit->addAlias('meters');
$this->registerUnitOfMeasure($new_unit);
// Millimeter
$new_unit = new UnitOfMeasure('mm', function ($x) {
return $x / 0.001;
}, function ($x) {
return $x * 0.001;
});
$new_unit->addAlias('millimeter');
$new_unit->addAlias('millimeters');
$this->registerUnitOfMeasure($new_unit);
// Centimeter
$new_unit = new UnitOfMeasure('cm', function ($x) {
return $x / 0.01;
}, function ($x) {
return $x * 0.01;
});
$new_unit->addAlias('centimeter');
$new_unit->addAlias('centimeters');
$this->registerUnitOfMeasure($new_unit);
// Decimeter
$new_unit = new UnitOfMeasure('dm', function ($x) {
return $x / 0.1;
}, function ($x) {
return $x * 0.1;
});
$new_unit->addAlias('decimeter');
$new_unit->addAlias('decimeters');
$this->registerUnitOfMeasure($new_unit);
// Kilometer
$new_unit = new UnitOfMeasure('km', function ($x) {
return $x / 1000;
}, function ($x) {
return $x * 1000;
});
$new_unit->addAlias('kilometer');
$new_unit->addAlias('kilometers');
$this->registerUnitOfMeasure($new_unit);
// Foot
$new_unit = new UnitOfMeasure('ft', function ($x) {
return $x / 0.3048;
}, function ($x) {
return $x * 0.3048;
});
$new_unit->addAlias('foot');
$new_unit->addAlias('feet');
$this->registerUnitOfMeasure($new_unit);
// Inch
$new_unit = new UnitOfMeasure('in', function ($x) {
return $x / 0.0254;
}, function ($x) {
return $x * 0.0254;
});
$new_unit->addAlias('inch');
$new_unit->addAlias('inches');
$this->registerUnitOfMeasure($new_unit);
// Mile
$new_unit = new UnitOfMeasure('mi', function ($x) {
return $x / 1609.344;
}, function ($x) {
return $x * 1609.344;
});
$new_unit->addAlias('mile');
$new_unit->addAlias('miles');
$this->registerUnitOfMeasure($new_unit);
// Yard
$new_unit = new UnitOfMeasure('yd', function ($x) {
return $x / 0.9144;
}, function ($x) {
return $x * 0.9144;
});
$new_unit->addAlias('yard');
$new_unit->addAlias('yards');
$this->registerUnitOfMeasure($new_unit);
}
/**
* @covers \PhpUnitsOfMeasure\UnitOfMeasure::isNativeUnit
*/
public function testIsNotNativeUnit()
{
$uom = new UnitOfMeasure('quatloos', function ($valueInNativeUnit) {
return $valueInNativeUnit;
}, function ($valueInThisUnit) {
return $valueInThisUnit;
});
$this->assertSame(false, $uom->isNativeUnit());
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Cubic meter
$new_unit = new UnitOfMeasure('m^3', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('m³');
$new_unit->addAlias('cubic meter');
$new_unit->addAlias('cubic meters');
$this->registerUnitOfMeasure($new_unit);
// Cubic millimeter
$new_unit = new UnitOfMeasure('mm^3', function ($x) {
return $x / 1.0E-9;
}, function ($x) {
return $x * 1.0E-9;
});
$new_unit->addAlias('mm³');
$new_unit->addAlias('cubic millimeter');
$new_unit->addAlias('cubic millimeters');
$this->registerUnitOfMeasure($new_unit);
// Cubic centimeter
$new_unit = new UnitOfMeasure('cm^3', function ($x) {
return $x / 1.0E-6;
}, function ($x) {
return $x * 1.0E-6;
});
$new_unit->addAlias('cm³');
$new_unit->addAlias('cubic centimeter');
$new_unit->addAlias('cubic centimeters');
$this->registerUnitOfMeasure($new_unit);
// Cubic decimeter
$new_unit = new UnitOfMeasure('dm^3', function ($x) {
return $x / 0.001;
}, function ($x) {
return $x * 0.001;
});
$new_unit->addAlias('dm³');
$new_unit->addAlias('cubic decimeter');
$new_unit->addAlias('cubic decimeters');
$this->registerUnitOfMeasure($new_unit);
// Cubic kilometer
$new_unit = new UnitOfMeasure('km^3', function ($x) {
return $x / 1000000000.0;
}, function ($x) {
return $x * 1000000000.0;
});
$new_unit->addAlias('km³');
$new_unit->addAlias('cubic kilometer');
$new_unit->addAlias('cubic kilometers');
$this->registerUnitOfMeasure($new_unit);
// Cubic foot
$new_unit = new UnitOfMeasure('ft^3', function ($x) {
return $x / 0.02831685;
}, function ($x) {
return $x * 0.02831685;
});
$new_unit->addAlias('ft³');
$new_unit->addAlias('cubic foot');
$new_unit->addAlias('cubic feet');
$this->registerUnitOfMeasure($new_unit);
// Cubic inch
$new_unit = new UnitOfMeasure('in^3', function ($x) {
return $x / 1.638706E-5;
}, function ($x) {
return $x * 1.638706E-5;
});
$new_unit->addAlias('in³');
$new_unit->addAlias('cubic inch');
$new_unit->addAlias('cubic inches');
$this->registerUnitOfMeasure($new_unit);
// Cubic yard
$new_unit = new UnitOfMeasure('yd^3', function ($x) {
return $x / 0.7645549;
}, function ($x) {
return $x * 0.7645549;
});
$new_unit->addAlias('yd³');
$new_unit->addAlias('cubic yard');
$new_unit->addAlias('cubic yards');
$this->registerUnitOfMeasure($new_unit);
// Milliliters
$new_unit = new UnitOfMeasure('ml', function ($x) {
return $x / 1.0E-6;
}, function ($x) {
return $x * 1.0E-6;
});
$new_unit->addAlias('milliliter');
$new_unit->addAlias('milliliters');
$this->registerUnitOfMeasure($new_unit);
// Centiliters
$new_unit = new UnitOfMeasure('cl', function ($x) {
return $x / 1.0E-5;
}, function ($x) {
return $x * 1.0E-5;
});
$new_unit->addAlias('centiliter');
$new_unit->addAlias('centiliters');
$this->registerUnitOfMeasure($new_unit);
// Deciliter
$new_unit = new UnitOfMeasure('dl', function ($x) {
return $x / 0.0001;
}, function ($x) {
return $x * 0.0001;
});
$new_unit->addAlias('deciliter');
$new_unit->addAlias('deciliters');
$this->registerUnitOfMeasure($new_unit);
// Liter
$new_unit = new UnitOfMeasure('l', function ($x) {
return $x / 0.001;
}, function ($x) {
return $x * 0.001;
});
$new_unit->addAlias('liter');
$new_unit->addAlias('liters');
$this->registerUnitOfMeasure($new_unit);
// Decaliter
$new_unit = new UnitOfMeasure('dal', function ($x) {
return $x / 0.01;
}, function ($x) {
return $x * 0.01;
});
$new_unit->addAlias('decaliter');
$new_unit->addAlias('decaliters');
$this->registerUnitOfMeasure($new_unit);
// Hectoliter
$new_unit = new UnitOfMeasure('hl', function ($x) {
return $x / 0.1;
}, function ($x) {
return $x * 0.1;
});
$new_unit->addAlias('hectoliter');
$new_unit->addAlias('hectoliters');
$this->registerUnitOfMeasure($new_unit);
// Cup
$new_unit = new UnitOfMeasure('cup', function ($x) {
return $x / 0.0002365882;
}, function ($x) {
return $x * 0.0002365882;
});
$new_unit->addAlias('cup');
$new_unit->addAlias('cups');
$this->registerUnitOfMeasure($new_unit);
}
public function testCreatingNewUnitsForQuantities()
{
// New units of measure can be defined and registered
// with physical quantities on the fly.
// Here, we create three new units, demonstrating the 3
// different methods for instantiating them. These units
// will exist in addition to the units that come 'out of
// the box' for the given quantity, once they're registered
// with the static addUnit().
// The linear unit factory is useful for defining new
// units that are a simple scaling factor conversion
// to the quantity's native unit of measure.
// In this case there are 4.5 bbbb's in the native unit of measure.
$unitA = UnitOfMeasure::linearUnitFactory('bbbb', 4.5);
Wigginess::addUnit($unitA);
// Using the native unit factory method is equivalent to a
// linear unit with a factor of 1. It's convenient for creating
// a unit to represent the native unit of measure.
$unitB = UnitOfMeasure::nativeUnitFactory('aaaa');
Wigginess::addUnit($unitB);
// The long form constructor is necessary for units
// that don't have simple scaling factor functions for
// their conversions. For this unit we'll also add 2 more
// aliases (dddd and eeee) that serve as equivalent names
// for the unit's real name (cccc).
$unitC = new UnitOfMeasure('cccc', function ($valueInNativeUnit) {
return $valueInNativeUnit - 100;
}, function ($valueInThisUnit) {
return $valueInThisUnit + 100;
});
$unitC->addAlias('dddd');
$unitC->addAlias('eeee');
Wigginess::addUnit($unitC);
// Here we can see that the units defined above
// convert as expected with the built-in units.
$a = new Wigginess(21, 'sopees');
$this->assertSame(21, $a->toUnit('aaaa'));
$this->assertSame(21 / 4.5, $a->toUnit('bbbb'));
$this->assertSame(21 - 100, $a->toUnit('cccc'));
$this->assertSame(21 - 100, $a->toUnit('dddd'));
$this->assertSame(21 - 100, $a->toUnit('eeee'));
$b = new Wigginess(21, 'tumpets');
$this->assertSame(21 * 2.5, $b->toUnit('aaaa'));
$this->assertSame(21 / 4.5 * 2.5, $b->toUnit('bbbb'));
$this->assertSame(21 * 2.5 - 100, $b->toUnit('cccc'));
$this->assertSame(21 * 2.5 - 100, $b->toUnit('dddd'));
$this->assertSame(21 * 2.5 - 100, $b->toUnit('eeee'));
}
/**
* Configure all the standard units of measure
* to which this quantity can be converted.
*
* @return void
*/
public function __construct($value, $unit)
{
parent::__construct($value, $unit);
// Kilogram
$new_unit = new UnitOfMeasure('kg', function ($x) {
return $x;
}, function ($x) {
return $x;
});
$new_unit->addAlias('kilogram');
$new_unit->addAlias('kilograms');
$this->registerUnitOfMeasure($new_unit);
// Milligram
$new_unit = new UnitOfMeasure('mg', function ($x) {
return $x / 1.0E-6;
}, function ($x) {
return $x * 1.0E-6;
});
$new_unit->addAlias('milligram');
$new_unit->addAlias('milligrams');
$this->registerUnitOfMeasure($new_unit);
// Centigram
$new_unit = new UnitOfMeasure('cg', function ($x) {
return $x / 1.0E-5;
}, function ($x) {
return $x * 1.0E-5;
});
$new_unit->addAlias('centigram');
$new_unit->addAlias('centigrams');
$this->registerUnitOfMeasure($new_unit);
// Gram
$new_unit = new UnitOfMeasure('g', function ($x) {
return $x / 0.001;
}, function ($x) {
return $x * 0.001;
});
$new_unit->addAlias('gram');
$new_unit->addAlias('grams');
$this->registerUnitOfMeasure($new_unit);
// Tonne (metric)
$new_unit = new UnitOfMeasure('t', function ($x) {
return $x / 1000.0;
}, function ($x) {
return $x * 1000.0;
});
$new_unit->addAlias('ton');
$new_unit->addAlias('tons');
$new_unit->addAlias('tonne');
$new_unit->addAlias('tonnes');
$this->registerUnitOfMeasure($new_unit);
// Pound
$new_unit = new UnitOfMeasure('lb', function ($x) {
return $x / 0.4535924;
}, function ($x) {
return $x * 0.4535924;
});
$new_unit->addAlias('lbs');
$new_unit->addAlias('pound');
$new_unit->addAlias('pounds');
$this->registerUnitOfMeasure($new_unit);
// Ounce
$new_unit = new UnitOfMeasure('oz', function ($x) {
return $x / 0.02834952;
}, function ($x) {
return $x * 0.02834952;
});
$new_unit->addAlias('ounce');
$new_unit->addAlias('ounces');
$this->registerUnitOfMeasure($new_unit);
}
protected static function initialize()
{
// Meters squared
$metersquared = UnitOfMeasure::nativeUnitFactory('m^2');
$metersquared->addAlias('m²');
$metersquared->addAlias('meter squared');
$metersquared->addAlias('meters squared');
$metersquared->addAlias('metre squared');
$metersquared->addAlias('metres squared');
static::addUnit($metersquared);
// Millimeter squared
$newUnit = UnitOfMeasure::linearUnitFactory('mm^2', 1.0E-6);
$newUnit->addAlias('mm²');
$newUnit->addAlias('millimeter squared');
$newUnit->addAlias('millimeters squared');
$newUnit->addAlias('millimetre squared');
$newUnit->addAlias('millimetres squared');
static::addUnit($newUnit);
// Centimeter squared
$newUnit = UnitOfMeasure::linearUnitFactory('cm^2', 0.0001);
$newUnit->addAlias('cm²');
$newUnit->addAlias('centimeter squared');
$newUnit->addAlias('centimeters squared');
$newUnit->addAlias('centimetre squared');
$newUnit->addAlias('centimetres squared');
static::addUnit($newUnit);
// Decimeter squared
$newUnit = UnitOfMeasure::linearUnitFactory('dm^2', 0.01);
$newUnit->addAlias('dm²');
$newUnit->addAlias('decimeter squared');
$newUnit->addAlias('decimeters squared');
$newUnit->addAlias('decimetre squared');
$newUnit->addAlias('decimetres squared');
static::addUnit($newUnit);
// Kilometer squared
$newUnit = UnitOfMeasure::linearUnitFactory('km^2', 1000000.0);
$newUnit->addAlias('km²');
$newUnit->addAlias('kilometer squared');
$newUnit->addAlias('kilometers squared');
$newUnit->addAlias('kilometre squared');
$newUnit->addAlias('kilometres squared');
static::addUnit($newUnit);
// Foot squared
$newUnit = UnitOfMeasure::linearUnitFactory('ft^2', 0.09290304000000001);
$newUnit->addAlias('ft²');
$newUnit->addAlias('foot squared');
$newUnit->addAlias('feet squared');
static::addUnit($newUnit);
// Inch squared
$newUnit = UnitOfMeasure::linearUnitFactory('in^2', 0.00064516);
$newUnit->addAlias('in²');
$newUnit->addAlias('inch squared');
$newUnit->addAlias('inches squared');
static::addUnit($newUnit);
// Mile squared
$newUnit = UnitOfMeasure::linearUnitFactory('mi^2', 2589988.0);
$newUnit->addAlias('mi²');
$newUnit->addAlias('mile squared');
$newUnit->addAlias('miles squared');
static::addUnit($newUnit);
// Yard squared
$newUnit = UnitOfMeasure::linearUnitFactory('yd^2', 0.8361274);
$newUnit->addAlias('yd²');
$newUnit->addAlias('yard squared');
$newUnit->addAlias('yards squared');
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);
}
