units

package module
v1.0.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 26, 2023 License: MIT Imports: 2 Imported by: 0

Documentation

Overview

Package units provides a standard way of working with unit for Alaka and Alakans alike. It's automatically generated via a .yaml file with a format that makes it really easy to add new units. Because we use code generation, we can provide functions that are super fast by using explicit values without the work of hand copying hundreds of methods across a bunch of permutations of the same thing.

All the primary UnitTypes and Units of this package are built directly on the float64 construct. This allows go users to treat scalars as the Unit or UnitType that they actually represent, including the ability to use those type definitions as guards in functions that depend on a particular Unit or UnitType. Eg.: 

func AddPressure (p1, p2 PascalsPressure) PascalsPressure {
    returns p1 + p2
}

Index

Constants

This section is empty.

Variables

View Source 
var AlarmMatchList = [...]string{"alarm"}

AlarmMatchList is effectively a constant

View Source 
var AlarmUnitList = [...]string{"Percent"}

AlarmUnitList is effectively a constant

View Source 
var AlarmUnits = [...]Unit{PercentAlarmUnit}

AlarmUnits is effectively a constant

View Source 
var AllTypes = [...]string{
	"Pressure",
	"Temperature",
	"Flow",
	"Volume",
	"Mass",
	"MassFlow",
	"ElectricPotential",
	"ElectricPotentialLoaded",
	"ElectricPotentialUnloaded",
	"Percentage",
	"Fillage",
	"PumpFillage",
	"Humidity",
	"Alarm",
	"Work",
	"Force",
	"Load",
	"MaxLoad",
	"MinLoad",
	"FluidLoad",
	"Length",
	"Stroke",
	"GrossStroke",
	"NetStroke",
	"StrokeRate",
	"Number",
	"Overspeed",
	"Underspeed",
	"Totaliser",
	"WMLFlowRate",
}

AllTypes is a list of all available types below

View Source 
var AllUnitTypes = [...]string{
	"Pressure_Pascals",
	"Pressure_Kilopascals",
	"Pressure_Megapascals",
	"Pressure_PoundsPerSquareInch",
	"Pressure_InchesOfWater",
	"Temperature_DegreesCelsius",
	"Temperature_DegreesFahrenheit",
	"Temperature_Kelvins",
	"Flow_CubicMetersPerSecond",
	"Flow_CubicFeetPerSecond",
	"Flow_ThousandCubicFeetPerDay",
	"Flow_GallonsUSFluidPerSecond",
	"Flow_GallonsUSFluidPerMinute",
	"Flow_BarrelsPerSecond",
	"Flow_BarrelsPerMinute",
	"Volume_CubicMeters",
	"Volume_CubicFeet",
	"Volume_ThousandsOfCubicFeet",
	"Volume_CubicDecimeter",
	"Volume_Liter",
	"Volume_GallonUSFluid",
	"Volume_BarrelsOfOil",
	"Mass_Kilograms",
	"Mass_Pounds",
	"MassFlow_KilogramsPerSecond",
	"MassFlow_PoundsPerSecond",
	"MassFlow_PoundsPerMinute",
	"ElectricPotential_Volts",
	"ElectricPotentialLoaded_Volts",
	"ElectricPotentialUnloaded_Volts",
	"Percentage_Percent",
	"Fillage_Percent",
	"PumpFillage_Percent",
	"Humidity_Percent",
	"Alarm_Percent",
	"Work_Joules",
	"Work_InchPoundsForce",
	"Work_CubicFeetOfNaturalGas",
	"Work_BarrelsOfOilEquivalent",
	"Force_Newtons",
	"Force_PoundsForce",
	"Force_KilogramsForce",
	"Load_Newtons",
	"Load_PoundsForce",
	"Load_KilogramsForce",
	"MaxLoad_Newtons",
	"MaxLoad_PoundsForce",
	"MaxLoad_KilogramsForce",
	"MinLoad_Newtons",
	"MinLoad_PoundsForce",
	"MinLoad_KilogramsForce",
	"FluidLoad_Newtons",
	"FluidLoad_PoundsForce",
	"FluidLoad_KilogramsForce",
	"Length_Meters",
	"Length_Feet",
	"Length_Inches",
	"Stroke_Meters",
	"Stroke_Feet",
	"Stroke_Inches",
	"GrossStroke_Meters",
	"GrossStroke_Feet",
	"GrossStroke_Inches",
	"NetStroke_Meters",
	"NetStroke_Feet",
	"NetStroke_Inches",
	"StrokeRate_StrokesPerSecond",
	"Number_Number",
	"Overspeed_Number",
	"Underspeed_Number",
	"Totaliser_Number",
	"WMLFlowRate_Number",
}

AllUnitTypes is a list of all available Unit and Type combos below AKA the list of all possible output combinations of AlakaTitle

View Source 
var AllUnits = map[string][]string{
	"Pressure":                  {"Pascals", "Kilopascals", "Megapascals", "PoundsPerSquareInch", "InchesOfWater"},
	"Temperature":               {"DegreesCelsius", "DegreesFahrenheit", "Kelvins"},
	"Flow":                      {"CubicMetersPerSecond", "CubicFeetPerSecond", "ThousandCubicFeetPerDay", "GallonsUSFluidPerSecond", "GallonsUSFluidPerMinute", "BarrelsPerSecond", "BarrelsPerMinute"},
	"Volume":                    {"CubicMeters", "CubicFeet", "ThousandsOfCubicFeet", "CubicDecimeter", "Liter", "GallonUSFluid", "BarrelsOfOil"},
	"Mass":                      {"Kilograms", "Pounds"},
	"MassFlow":                  {"KilogramsPerSecond", "PoundsPerSecond", "PoundsPerMinute"},
	"ElectricPotential":         {"Volts"},
	"ElectricPotentialLoaded":   {"Volts"},
	"ElectricPotentialUnloaded": {"Volts"},
	"Percentage":                {"Percent"},
	"Fillage":                   {"Percent"},
	"PumpFillage":               {"Percent"},
	"Humidity":                  {"Percent"},
	"Alarm":                     {"Percent"},
	"Work":                      {"Joules", "InchPoundsForce", "CubicFeetOfNaturalGas", "BarrelsOfOilEquivalent"},
	"Force":                     {"Newtons", "PoundsForce", "KilogramsForce"},
	"Load":                      {"Newtons", "PoundsForce", "KilogramsForce"},
	"MaxLoad":                   {"Newtons", "PoundsForce", "KilogramsForce"},
	"MinLoad":                   {"Newtons", "PoundsForce", "KilogramsForce"},
	"FluidLoad":                 {"Newtons", "PoundsForce", "KilogramsForce"},
	"Length":                    {"Meters", "Feet", "Inches"},
	"Stroke":                    {"Meters", "Feet", "Inches"},
	"GrossStroke":               {"Meters", "Feet", "Inches"},
	"NetStroke":                 {"Meters", "Feet", "Inches"},
	"StrokeRate":                {"StrokesPerSecond"},
	"Number":                    {"Number"},
	"Overspeed":                 {"Number"},
	"Underspeed":                {"Number"},
	"Totaliser":                 {"Number"},
	"WMLFlowRate":               {"Number"},
}

AllUnits is a map of unit type -> units

View Source 
var BarrelsOfOilEquivalentWorkMatchList = [...]string{"bboe", "barrelsofoilequivalent"}

BarrelsOfOilEquivalentWorkMatchList is effectively a constant

View Source 
var BarrelsOfOilVolumeMatchList = [...]string{"bbl", "bbls", "barrelsofoil", "barrelofoil"}

BarrelsOfOilVolumeMatchList is effectively a constant

View Source 
var BarrelsPerMinuteFlowMatchList = [...]string{"bbl/min", "bbl/minute", "bbl/m", "bblm", "barrelspermin", "barrelsperminute", "barrelpermin", "barrelperminute", "barrels/min", "barrels/minute", "barrel/min", "barrel/minute"}

BarrelsPerMinuteFlowMatchList is effectively a constant

View Source 
var BarrelsPerSecondFlowMatchList = [...]string{"bbl/s", "bbl/second", "bbls", "barrelpersecond", "barrelspersecond", "barrels/second", "barrel/second"}

BarrelsPerSecondFlowMatchList is effectively a constant

View Source 
var CubicDecimeterVolumeMatchList = [...]string{"dm³", "dm3", "cubicdecimeter", "cubicdecimeters"}

CubicDecimeterVolumeMatchList is effectively a constant

View Source 
var CubicFeetOfNaturalGasWorkMatchList = [...]string{"btuᵢₜ", "btuit", "btu", "cubicfeetofnaturalgas"}

CubicFeetOfNaturalGasWorkMatchList is effectively a constant

View Source 
var CubicFeetPerSecondFlowMatchList = [...]string{"ft³/s", "ft³s", "ft3/s", "ft3s", "ft^3/s", "ft^3s", "f³/s", "f³s", "f3/s", "f3s", "f^3/s", "f^3s", "cubicfeetpersecond", "cubicfootpersecond", "cubicfeet/second", "cubicfoot/second"}

CubicFeetPerSecondFlowMatchList is effectively a constant

View Source 
var CubicFeetVolumeMatchList = [...]string{"cuft", "ft³", "f³", "cubicfoot", "cubicfeet"}

CubicFeetVolumeMatchList is effectively a constant

View Source 
var CubicMetersPerSecondFlowMatchList = [...]string{"m³/s", "m³s", "m3/s", "m3s", "m^3/s", "m^3s", "cubicmeterspersecond", "cubicmeterpersecond", "cubicmeters/second", "cubicmeter/second"}

CubicMetersPerSecondFlowMatchList is effectively a constant

View Source 
var CubicMetersVolumeMatchList = [...]string{"m³", "m3", "cubicmeter", "cubicmeters"}

CubicMetersVolumeMatchList is effectively a constant

View Source 
var DegreesCelsiusTemperatureMatchList = [...]string{"c", "°c", "celsius", "degreesc", "degreec", "degreescelsius", "degreecelsius"}

DegreesCelsiusTemperatureMatchList is effectively a constant

View Source 
var DegreesFahrenheitTemperatureMatchList = [...]string{"f", "°f", "fahrenheit", "degreesf", "degreef", "degreesfahrenheit", "degreefahrenheit"}

DegreesFahrenheitTemperatureMatchList is effectively a constant

View Source 
var ElectricPotentialLoadedMatchList = [...]string{"electricpotentialloaded", "voltageloaded"}

ElectricPotentialLoadedMatchList is effectively a constant

View Source 
var ElectricPotentialLoadedUnitList = [...]string{"Volts"}

ElectricPotentialLoadedUnitList is effectively a constant

View Source 
var ElectricPotentialLoadedUnits = [...]Unit{VoltsElectricPotentialLoadedUnit}

ElectricPotentialLoadedUnits is effectively a constant

View Source 
var ElectricPotentialMatchList = [...]string{"electricpotential", "voltage"}

ElectricPotentialMatchList is effectively a constant

View Source 
var ElectricPotentialUnitList = [...]string{"Volts"}

ElectricPotentialUnitList is effectively a constant

View Source 
var ElectricPotentialUnits = [...]Unit{VoltsElectricPotentialUnit}

ElectricPotentialUnits is effectively a constant

View Source 
var ElectricPotentialUnloadedMatchList = [...]string{"electricpotentialunloaded", "voltageunloaded"}

ElectricPotentialUnloadedMatchList is effectively a constant

View Source 
var ElectricPotentialUnloadedUnitList = [...]string{"Volts"}

ElectricPotentialUnloadedUnitList is effectively a constant

View Source 
var ElectricPotentialUnloadedUnits = [...]Unit{VoltsElectricPotentialUnloadedUnit}

ElectricPotentialUnloadedUnits is effectively a constant

View Source 
var FeetGrossStrokeMatchList = [...]string{"ft", "foot", "feet"}

FeetGrossStrokeMatchList is effectively a constant

View Source 
var FeetLengthMatchList = [...]string{"ft", "foot", "feet"}

FeetLengthMatchList is effectively a constant

View Source 
var FeetNetStrokeMatchList = [...]string{"ft", "foot", "feet"}

FeetNetStrokeMatchList is effectively a constant

View Source 
var FeetStrokeMatchList = [...]string{"ft", "foot", "feet"}

FeetStrokeMatchList is effectively a constant

View Source 
var FillageMatchList = [...]string{"fillage"}

FillageMatchList is effectively a constant

View Source 
var FillageUnitList = [...]string{"Percent"}

FillageUnitList is effectively a constant

View Source 
var FillageUnits = [...]Unit{PercentFillageUnit}

FillageUnits is effectively a constant

View Source 
var FlowMatchList = [...]string{"flow", "flowrate", "flow_rate", "gasflow", "gasflowrate", "gas_flow", "gas_flow_rate"}

FlowMatchList is effectively a constant

View Source 
var FlowUnitList = [...]string{"Cubic Meters per Second", "Cubic Feet per Second", "Thousand Cubic Feet per Day", "Gallons (U.S. Fluid) per Second", "Gallons (U.S. Fluid) per Minute", "Barrels per Second", "Barrels per Minute"}

FlowUnitList is effectively a constant

View Source 
var FlowUnits = [...]Unit{CubicMetersPerSecondFlowUnit, CubicFeetPerSecondFlowUnit, ThousandCubicFeetPerDayFlowUnit, GallonsUSFluidPerSecondFlowUnit, GallonsUSFluidPerMinuteFlowUnit, BarrelsPerSecondFlowUnit, BarrelsPerMinuteFlowUnit}

FlowUnits is effectively a constant

View Source 
var FluidLoadMatchList = [...]string{"fluidload"}

FluidLoadMatchList is effectively a constant

View Source 
var FluidLoadUnitList = [...]string{"Newtons", "Pounds-force", "Kilograms-force"}

FluidLoadUnitList is effectively a constant

View Source 
var FluidLoadUnits = [...]Unit{NewtonsFluidLoadUnit, PoundsForceFluidLoadUnit, KilogramsForceFluidLoadUnit}

FluidLoadUnits is effectively a constant

View Source 
var ForceMatchList = [...]string{"force"}

ForceMatchList is effectively a constant

View Source 
var ForceUnitList = [...]string{"Newtons", "Pounds-force", "Kilograms-force"}

ForceUnitList is effectively a constant

View Source 
var ForceUnits = [...]Unit{NewtonsForceUnit, PoundsForceForceUnit, KilogramsForceForceUnit}

ForceUnits is effectively a constant

View Source 
var GallonUSFluidVolumeMatchList = [...]string{"gal", "gallon", "gals", "gallons", "gal(us)", "gallon(us)", "gals(us)", "gallons(us)", "gal(u.s.)", "gallon(u.s.)", "gals(u.s.)", "gallons(u.s.)", "gal(usfluid)", "gallon(usfluid)", "gals(usfluid)", "gallons(usfluid)", "gal(u.s.fluid)", "gallon(u.s.fluid)", "gals(u.s.fluid)", "gallons(u.s.fluid)"}

GallonUSFluidVolumeMatchList is effectively a constant

View Source 
var GallonsUSFluidPerMinuteFlowMatchList = [...]string{"gal/m", "gals/m", "galm", "galsm", "gpm", "gallonsperminute", "gallonperminute", "gallonspermin", "gallonpermin", "gallons/minute", "gallons/min", "gallon/minute", "gallon/min"}

GallonsUSFluidPerMinuteFlowMatchList is effectively a constant

View Source 
var GallonsUSFluidPerSecondFlowMatchList = [...]string{"gal/s", "gals/s", "gals", "galss", "gps", "gallonspersecond", "gallonpersecond", "gallons/second", "gallon/second"}

GallonsUSFluidPerSecondFlowMatchList is effectively a constant

View Source 
var GrossStrokeMatchList = [...]string{"grossstroke"}

GrossStrokeMatchList is effectively a constant

View Source 
var GrossStrokeUnitList = [...]string{"Meters", "Feet", "Inches"}

GrossStrokeUnitList is effectively a constant

View Source 
var GrossStrokeUnits = [...]Unit{MetersGrossStrokeUnit, FeetGrossStrokeUnit, InchesGrossStrokeUnit}

GrossStrokeUnits is effectively a constant

View Source 
var HumidityMatchList = [...]string{"humidity"}

HumidityMatchList is effectively a constant

View Source 
var HumidityUnitList = [...]string{"Percent"}

HumidityUnitList is effectively a constant

View Source 
var HumidityUnits = [...]Unit{PercentHumidityUnit}

HumidityUnits is effectively a constant

View Source 
var InchPoundsForceWorkMatchList = [...]string{"inlbf", "inch-poundsforce", "inch-poundforce", "in-lbf"}

InchPoundsForceWorkMatchList is effectively a constant

View Source 
var InchesGrossStrokeMatchList = [...]string{"in", "inch", "inches"}

InchesGrossStrokeMatchList is effectively a constant

View Source 
var InchesLengthMatchList = [...]string{"in", "inch", "inches"}

InchesLengthMatchList is effectively a constant

View Source 
var InchesNetStrokeMatchList = [...]string{"in", "inch", "inches"}

InchesNetStrokeMatchList is effectively a constant

View Source 
var InchesOfWaterPressureMatchList = [...]string{"inh₂o", "inh₂0", "inh2o", "inh20", "incheswater", "inchesofwater", "inchwater", "inchofwater"}

InchesOfWaterPressureMatchList is effectively a constant

View Source 
var InchesStrokeMatchList = [...]string{"in", "inch", "inches"}

InchesStrokeMatchList is effectively a constant

View Source 
var JoulesWorkMatchList = [...]string{"j", "joule", "joules"}

JoulesWorkMatchList is effectively a constant

View Source 
var KelvinsTemperatureMatchList = [...]string{"k", "°k", "kelvin", "kelvins", "degreesk", "degreek", "degreeskelvin", "degreekelvin"}

KelvinsTemperatureMatchList is effectively a constant

View Source 
var KilogramsForceFluidLoadMatchList = [...]string{"kgf", "kilograms-force", "kilogram-force"}

KilogramsForceFluidLoadMatchList is effectively a constant

View Source 
var KilogramsForceForceMatchList = [...]string{"kgf", "kilograms-force", "kilogram-force"}

KilogramsForceForceMatchList is effectively a constant

View Source 
var KilogramsForceLoadMatchList = [...]string{"kgf", "kilograms-force", "kilogram-force"}

KilogramsForceLoadMatchList is effectively a constant

View Source 
var KilogramsForceMaxLoadMatchList = [...]string{"kgf", "kilograms-force", "kilogram-force"}

KilogramsForceMaxLoadMatchList is effectively a constant

View Source 
var KilogramsForceMinLoadMatchList = [...]string{"kgf", "kilograms-force", "kilogram-force"}

KilogramsForceMinLoadMatchList is effectively a constant

View Source 
var KilogramsMassMatchList = [...]string{"kg", "kilogram", "kilo", "kgs", "kilograms", "kilos"}

KilogramsMassMatchList is effectively a constant

View Source 
var KilogramsPerSecondMassFlowMatchList = [...]string{"kg/s", "kgs", "kilogrampersecond", "kilopersecond", "kgpersecond", "kilogramspersecond", "kilospersecond", "kgspersecond", "kilogram/second", "kilo/second", "kg/second", "kilograms/second", "kilos/second", "kgs/second"}

KilogramsPerSecondMassFlowMatchList is effectively a constant

View Source 
var KilopascalsPressureMatchList = [...]string{"kpa", "kilopascal", "kilopascals"}

KilopascalsPressureMatchList is effectively a constant

View Source 
var LengthMatchList = [...]string{"l", "length"}

LengthMatchList is effectively a constant

View Source 
var LengthUnitList = [...]string{"Meters", "Feet", "Inches"}

LengthUnitList is effectively a constant

View Source 
var LengthUnits = [...]Unit{MetersLengthUnit, FeetLengthUnit, InchesLengthUnit}

LengthUnits is effectively a constant

View Source 
var LiterVolumeMatchList = [...]string{"l", "liter", "liters", "litre", "litres"}

LiterVolumeMatchList is effectively a constant

View Source 
var LoadMatchList = [...]string{"load"}

LoadMatchList is effectively a constant

View Source 
var LoadUnitList = [...]string{"Newtons", "Pounds-force", "Kilograms-force"}

LoadUnitList is effectively a constant

View Source 
var LoadUnits = [...]Unit{NewtonsLoadUnit, PoundsForceLoadUnit, KilogramsForceLoadUnit}

LoadUnits is effectively a constant

View Source 
var MassFlowMatchList = [...]string{"massflow", "massflowrate", "flow(mass)", "flowrate(mass)"}

MassFlowMatchList is effectively a constant

View Source 
var MassFlowUnitList = [...]string{"Kilograms per Second", "Pounds per Second", "Pounds per Minute"}

MassFlowUnitList is effectively a constant

View Source 
var MassFlowUnits = [...]Unit{KilogramsPerSecondMassFlowUnit, PoundsPerSecondMassFlowUnit, PoundsPerMinuteMassFlowUnit}

MassFlowUnits is effectively a constant

View Source 
var MassMatchList = [...]string{"mass"}

MassMatchList is effectively a constant

View Source 
var MassUnitList = [...]string{"Kilograms", "Pounds"}

MassUnitList is effectively a constant

View Source 
var MassUnits = [...]Unit{KilogramsMassUnit, PoundsMassUnit}

MassUnits is effectively a constant

View Source 
var MaxLoadMatchList = [...]string{"maxload"}

MaxLoadMatchList is effectively a constant

View Source 
var MaxLoadUnitList = [...]string{"Newtons", "Pounds-force", "Kilograms-force"}

MaxLoadUnitList is effectively a constant

View Source 
var MaxLoadUnits = [...]Unit{NewtonsMaxLoadUnit, PoundsForceMaxLoadUnit, KilogramsForceMaxLoadUnit}

MaxLoadUnits is effectively a constant

View Source 
var MegapascalsPressureMatchList = [...]string{"mpa", "megapascal", "megapascals"}

MegapascalsPressureMatchList is effectively a constant

View Source 
var MetersGrossStrokeMatchList = [...]string{"m", "meter", "meters"}

MetersGrossStrokeMatchList is effectively a constant

View Source 
var MetersLengthMatchList = [...]string{"m", "meter", "meters"}

MetersLengthMatchList is effectively a constant

View Source 
var MetersNetStrokeMatchList = [...]string{"m", "meter", "meters"}

MetersNetStrokeMatchList is effectively a constant

View Source 
var MetersStrokeMatchList = [...]string{"m", "meter", "meters"}

MetersStrokeMatchList is effectively a constant

View Source 
var MinLoadMatchList = [...]string{"minload"}

MinLoadMatchList is effectively a constant

View Source 
var MinLoadUnitList = [...]string{"Newtons", "Pounds-force", "Kilograms-force"}

MinLoadUnitList is effectively a constant

View Source 
var MinLoadUnits = [...]Unit{NewtonsMinLoadUnit, PoundsForceMinLoadUnit, KilogramsForceMinLoadUnit}

MinLoadUnits is effectively a constant

View Source 
var NetStrokeMatchList = [...]string{"netstroke"}

NetStrokeMatchList is effectively a constant

View Source 
var NetStrokeUnitList = [...]string{"Meters", "Feet", "Inches"}

NetStrokeUnitList is effectively a constant

View Source 
var NetStrokeUnits = [...]Unit{MetersNetStrokeUnit, FeetNetStrokeUnit, InchesNetStrokeUnit}

NetStrokeUnits is effectively a constant

View Source 
var NewtonsFluidLoadMatchList = [...]string{"n", "newton", "newtons"}

NewtonsFluidLoadMatchList is effectively a constant

View Source 
var NewtonsForceMatchList = [...]string{"n", "newton", "newtons"}

NewtonsForceMatchList is effectively a constant

View Source 
var NewtonsLoadMatchList = [...]string{"n", "newton", "newtons"}

NewtonsLoadMatchList is effectively a constant

View Source 
var NewtonsMaxLoadMatchList = [...]string{"n", "newton", "newtons"}

NewtonsMaxLoadMatchList is effectively a constant

View Source 
var NewtonsMinLoadMatchList = [...]string{"n", "newton", "newtons"}

NewtonsMinLoadMatchList is effectively a constant

View Source 
var NumberMatchList = [...]string{"*"}

NumberMatchList is effectively a constant

View Source 
var NumberNumberMatchList = [...]string{"number", "*"}

NumberNumberMatchList is effectively a constant

View Source 
var NumberOverspeedMatchList = [...]string{"number", "*"}

NumberOverspeedMatchList is effectively a constant

View Source 
var NumberTotaliserMatchList = [...]string{"number", "*"}

NumberTotaliserMatchList is effectively a constant

View Source 
var NumberUnderspeedMatchList = [...]string{"number", "*"}

NumberUnderspeedMatchList is effectively a constant

View Source 
var NumberUnitList = [...]string{"Number"}

NumberUnitList is effectively a constant

View Source 
var NumberUnits = [...]Unit{NumberNumberUnit}

NumberUnits is effectively a constant

View Source 
var NumberWMLFlowRateMatchList = [...]string{"number", "*"}

NumberWMLFlowRateMatchList is effectively a constant

View Source 
var OverspeedMatchList = [...]string{"overspeed"}

OverspeedMatchList is effectively a constant

View Source 
var OverspeedUnitList = [...]string{"Number"}

OverspeedUnitList is effectively a constant

View Source 
var OverspeedUnits = [...]Unit{NumberOverspeedUnit}

OverspeedUnits is effectively a constant

View Source 
var PascalsPressureMatchList = [...]string{"pa", "pascal", "pascals"}

PascalsPressureMatchList is effectively a constant

View Source 
var PercentAlarmMatchList = [...]string{"%", "percent", "percentage"}

PercentAlarmMatchList is effectively a constant

View Source 
var PercentFillageMatchList = [...]string{"%", "percent", "percentage"}

PercentFillageMatchList is effectively a constant

View Source 
var PercentHumidityMatchList = [...]string{"%", "percent", "percentage"}

PercentHumidityMatchList is effectively a constant

View Source 
var PercentPercentageMatchList = [...]string{"%", "percent", "percentage"}

PercentPercentageMatchList is effectively a constant

View Source 
var PercentPumpFillageMatchList = [...]string{"%", "percent", "percentage"}

PercentPumpFillageMatchList is effectively a constant

View Source 
var PercentageMatchList = [...]string{"percentage"}

PercentageMatchList is effectively a constant

View Source 
var PercentageUnitList = [...]string{"Percent"}

PercentageUnitList is effectively a constant

View Source 
var PercentageUnits = [...]Unit{PercentPercentageUnit}

PercentageUnits is effectively a constant

View Source 
var PoundsForceFluidLoadMatchList = [...]string{"lbf", "pounds-force", "poundsforce", "pound-force", "poundforce"}

PoundsForceFluidLoadMatchList is effectively a constant

View Source 
var PoundsForceForceMatchList = [...]string{"lbf", "pounds-force", "poundsforce", "pound-force", "poundforce"}

PoundsForceForceMatchList is effectively a constant

View Source 
var PoundsForceLoadMatchList = [...]string{"lbf", "pounds-force", "poundsforce", "pound-force", "poundforce"}

PoundsForceLoadMatchList is effectively a constant

View Source 
var PoundsForceMaxLoadMatchList = [...]string{"lbf", "pounds-force", "poundsforce", "pound-force", "poundforce"}

PoundsForceMaxLoadMatchList is effectively a constant

View Source 
var PoundsForceMinLoadMatchList = [...]string{"lbf", "pounds-force", "poundsforce", "pound-force", "poundforce"}

PoundsForceMinLoadMatchList is effectively a constant

View Source 
var PoundsMassMatchList = [...]string{"lb", "lbs", "pound", "pounds"}

PoundsMassMatchList is effectively a constant

View Source 
var PoundsPerMinuteMassFlowMatchList = [...]string{"lb/min", "lbs/min", "lbmin", "lbsmin", "lb/m", "lbs/m", "lbm", "lbsm", "poundperminute", "poundsperminute", "pound/minute", "pounds/minute", "poundpermin", "poundspermin", "pound/min", "pounds/min"}

PoundsPerMinuteMassFlowMatchList is effectively a constant

View Source 
var PoundsPerSecondMassFlowMatchList = [...]string{"lb/s", "lbs/s", "lbs", "lbss", "poundpersecond", "poundspersecond", "pound/second", "pounds/second"}

PoundsPerSecondMassFlowMatchList is effectively a constant

View Source 
var PoundsPerSquareInchPressureMatchList = [...]string{"psi", "poundspersquareinch", "poundpersquareinch"}

PoundsPerSquareInchPressureMatchList is effectively a constant

View Source 
var PressureMatchList = [...]string{"pressure"}

PressureMatchList is effectively a constant

View Source 
var PressureUnitList = [...]string{"Pascals", "Kilopascals", "Megapascals", "Pounds per Square Inch", "Inches of Water"}

PressureUnitList is effectively a constant

View Source 
var PressureUnits = [...]Unit{PascalsPressureUnit, KilopascalsPressureUnit, MegapascalsPressureUnit, PoundsPerSquareInchPressureUnit, InchesOfWaterPressureUnit}

PressureUnits is effectively a constant

View Source 
var PumpFillageMatchList = [...]string{"pumpfillage"}

PumpFillageMatchList is effectively a constant

View Source 
var PumpFillageUnitList = [...]string{"Percent"}

PumpFillageUnitList is effectively a constant

View Source 
var PumpFillageUnits = [...]Unit{PercentPumpFillageUnit}

PumpFillageUnits is effectively a constant

View Source 
var StrokeMatchList = [...]string{"stroke"}

StrokeMatchList is effectively a constant

View Source 
var StrokeRateMatchList = [...]string{"strokerate", "stroke-rate"}

StrokeRateMatchList is effectively a constant

View Source 
var StrokeRateUnitList = [...]string{"Strokes per Second"}

StrokeRateUnitList is effectively a constant

View Source 
var StrokeRateUnits = [...]Unit{StrokesPerSecondStrokeRateUnit}

StrokeRateUnits is effectively a constant

View Source 
var StrokeUnitList = [...]string{"Meters", "Feet", "Inches"}

StrokeUnitList is effectively a constant

View Source 
var StrokeUnits = [...]Unit{MetersStrokeUnit, FeetStrokeUnit, InchesStrokeUnit}

StrokeUnits is effectively a constant

View Source 
var StrokesPerSecondStrokeRateMatchList = [...]string{"strokes/s", "strokespersecond", "s/s"}

StrokesPerSecondStrokeRateMatchList is effectively a constant

View Source 
var TemperatureMatchList = [...]string{"temperature", "temp"}

TemperatureMatchList is effectively a constant

View Source 
var TemperatureUnitList = [...]string{"Degrees Celsius", "Degrees Fahrenheit", "Kelvins"}

TemperatureUnitList is effectively a constant

View Source 
var TemperatureUnits = [...]Unit{DegreesCelsiusTemperatureUnit, DegreesFahrenheitTemperatureUnit, KelvinsTemperatureUnit}

TemperatureUnits is effectively a constant

View Source 
var ThousandCubicFeetPerDayFlowMatchList = [...]string{"mcfd", "mcf/d", "mcftd", "mcft/d", "mft³/d", "mft³d", "mft3/d", "mft3d", "mft^3/d", "mft^3d", "mf³/d", "mf³d", "mf3/d", "mf3d", "mf^3/d", "mf^3d", "thousandcubicfeetperday", "thousandcubicfeet/day"}

ThousandCubicFeetPerDayFlowMatchList is effectively a constant

View Source 
var ThousandsOfCubicFeetVolumeMatchList = [...]string{"mcf", "mft³", "mf³", "thousandcubicfeet", "thousandsofcubicfeet", "thousandscubicfeet"}

ThousandsOfCubicFeetVolumeMatchList is effectively a constant

View Source 
var TotaliserMatchList = [...]string{"totaliser"}

TotaliserMatchList is effectively a constant

View Source 
var TotaliserUnitList = [...]string{"Number"}

TotaliserUnitList is effectively a constant

View Source 
var TotaliserUnits = [...]Unit{NumberTotaliserUnit}

TotaliserUnits is effectively a constant

View Source 
var UnderspeedMatchList = [...]string{"underspeed"}

UnderspeedMatchList is effectively a constant

View Source 
var UnderspeedUnitList = [...]string{"Number"}

UnderspeedUnitList is effectively a constant

View Source 
var UnderspeedUnits = [...]Unit{NumberUnderspeedUnit}

UnderspeedUnits is effectively a constant

View Source 
var VoltsElectricPotentialLoadedMatchList = [...]string{"volt", "volts", "v"}

VoltsElectricPotentialLoadedMatchList is effectively a constant

View Source 
var VoltsElectricPotentialMatchList = [...]string{"volt", "volts", "v"}

VoltsElectricPotentialMatchList is effectively a constant

View Source 
var VoltsElectricPotentialUnloadedMatchList = [...]string{"volt", "volts", "v"}

VoltsElectricPotentialUnloadedMatchList is effectively a constant

View Source 
var VolumeMatchList = [...]string{"volume"}

VolumeMatchList is effectively a constant

View Source 
var VolumeUnitList = [...]string{"Cubic Meters", "Cubic Feet", "Thousands of Cubic Feet", "Cubic Decimeter", "Liter", "Gallon (U.S. Fluid)", "Barrels of Oil"}

VolumeUnitList is effectively a constant

View Source 
var VolumeUnits = [...]Unit{CubicMetersVolumeUnit, CubicFeetVolumeUnit, ThousandsOfCubicFeetVolumeUnit, CubicDecimeterVolumeUnit, LiterVolumeUnit, GallonUSFluidVolumeUnit, BarrelsOfOilVolumeUnit}

VolumeUnits is effectively a constant

View Source 
var WMLFlowRateMatchList = [...]string{"wmlflowrate"}

WMLFlowRateMatchList is effectively a constant

View Source 
var WMLFlowRateUnitList = [...]string{"Number"}

WMLFlowRateUnitList is effectively a constant

View Source 
var WMLFlowRateUnits = [...]Unit{NumberWMLFlowRateUnit}

WMLFlowRateUnits is effectively a constant

View Source 
var WhitespaceRegex = regexp.MustCompile(`\s`)
View Source 
var WorkMatchList = [...]string{"work"}

WorkMatchList is effectively a constant

View Source 
var WorkUnitList = [...]string{"Joules", "Inch-pounds Force", "Cubic Feet of Natural Gas", "Barrels of Oil Equivalent"}

WorkUnitList is effectively a constant

View Source 
var WorkUnits = [...]Unit{JoulesWorkUnit, InchPoundsForceWorkUnit, CubicFeetOfNaturalGasWorkUnit, BarrelsOfOilEquivalentWorkUnit}

WorkUnits is effectively a constant

Functions

func AlakaTitle 

func AlakaTitle(ut UnitType, u Unit) string

AlakaTitle returns the Alaka string representing this particular unit and unit type combo

func GetTypeUnit 

func GetTypeUnit(input string) (UnitType, Unit)

GetTypeUnit returns the unit type and unit which matches input or (NumberUnitType, NumberNumberUnit). Opposite of AlakaTitle

func SanitizeString 

func SanitizeString(input string) string

SanitizeString removes whitespace and lower cases the string

Types

type Alarm 

type Alarm float64

Alarm (UnitType) Contains 1 units:

  • PercentAlarm p => p = %

Base: PercentAlarm 

var AlarmUnitType Alarm = 0.0

func (Alarm) Base 

func (x Alarm) Base() Unit

Base always returns PercentAlarmUnit

func (Alarm) MatchList 

func (x Alarm) MatchList() []string

MatchList always returns AlarmMatchList[:]

func (Alarm) Matches 

func (x Alarm) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Alarm) Name 

func (x Alarm) Name() string

Name always returns "Alarm"

func (Alarm) Title 

func (x Alarm) Title() string

Title always returns "Alarm"

func (Alarm) UnitList 

func (x Alarm) UnitList() []string

UnitList always returns AlarmUnitList[:]

func (Alarm) Units 

func (x Alarm) Units() []Unit

Units always returns AlarmUnits[:]

type BarrelsOfOilEquivalentWork 

type BarrelsOfOilEquivalentWork Work

BarrelsOfOilEquivalentWork (Unit) UnitType : Work UnitType.Base: JoulesWork Unit.FromBase: J => J * 0.000,000,000,163,399 = bboe Unit.ToBase : bboe => bboe * 6,120,000,000 = J 

var BarrelsOfOilEquivalentWorkUnit BarrelsOfOilEquivalentWork = 0.0

func (BarrelsOfOilEquivalentWork) Base 

func (x BarrelsOfOilEquivalentWork) Base() Unit

Base always returns JoulesWorkUnit

func (BarrelsOfOilEquivalentWork) FromBase 

func (x BarrelsOfOilEquivalentWork) FromBase(J float64) float64

FromBase converts J to bboe

func (BarrelsOfOilEquivalentWork) MatchList 

func (x BarrelsOfOilEquivalentWork) MatchList() []string

MatchList always returns BarrelsOfOilEquivalentWorkMatchList[:]

func (BarrelsOfOilEquivalentWork) Matches 

func (x BarrelsOfOilEquivalentWork) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (BarrelsOfOilEquivalentWork) Name 

func (x BarrelsOfOilEquivalentWork) Name() string

Name always returns "Barrels of Oil Equivalent"

func (BarrelsOfOilEquivalentWork) Symbol 

func (x BarrelsOfOilEquivalentWork) Symbol() string

Symbol always returns "bboe"

func (BarrelsOfOilEquivalentWork) Title 

func (x BarrelsOfOilEquivalentWork) Title() string

Title always returns "BarrelsOfOilEquivalent"

func (BarrelsOfOilEquivalentWork) ToBase 

func (x BarrelsOfOilEquivalentWork) ToBase(bboe float64) float64

ToBase converts bboe to J

func (BarrelsOfOilEquivalentWork) TypeOf 

func (x BarrelsOfOilEquivalentWork) TypeOf() UnitType

TypeOf always returns WorkUnitType

type BarrelsOfOilVolume 

type BarrelsOfOilVolume Volume

BarrelsOfOilVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 * 6.289,81 = bbl Unit.ToBase : bbl => bbl * 0.158,987 = m³ 

var BarrelsOfOilVolumeUnit BarrelsOfOilVolume = 0.0

func (BarrelsOfOilVolume) Base 

func (x BarrelsOfOilVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (BarrelsOfOilVolume) FromBase 

func (x BarrelsOfOilVolume) FromBase(m3 float64) float64

FromBase converts m³ to bbl

func (BarrelsOfOilVolume) MatchList 

func (x BarrelsOfOilVolume) MatchList() []string

MatchList always returns BarrelsOfOilVolumeMatchList[:]

func (BarrelsOfOilVolume) Matches 

func (x BarrelsOfOilVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (BarrelsOfOilVolume) Name 

func (x BarrelsOfOilVolume) Name() string

Name always returns "Barrels of Oil"

func (BarrelsOfOilVolume) Symbol 

func (x BarrelsOfOilVolume) Symbol() string

Symbol always returns "bbl"

func (BarrelsOfOilVolume) Title 

func (x BarrelsOfOilVolume) Title() string

Title always returns "BarrelsOfOil"

func (BarrelsOfOilVolume) ToBase 

func (x BarrelsOfOilVolume) ToBase(bbl float64) float64

ToBase converts bbl to m³

func (BarrelsOfOilVolume) TypeOf 

func (x BarrelsOfOilVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type BarrelsPerMinuteFlow 

type BarrelsPerMinuteFlow Flow

BarrelsPerMinuteFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s * 377.389 = bbl/min Unit.ToBase : bblm => bblm * 0.002,649,79 = m³/s 

var BarrelsPerMinuteFlowUnit BarrelsPerMinuteFlow = 0.0

func (BarrelsPerMinuteFlow) Base 

func (x BarrelsPerMinuteFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (BarrelsPerMinuteFlow) FromBase 

func (x BarrelsPerMinuteFlow) FromBase(m3s float64) float64

FromBase converts m³/s to bbl/min

func (BarrelsPerMinuteFlow) MatchList 

func (x BarrelsPerMinuteFlow) MatchList() []string

MatchList always returns BarrelsPerMinuteFlowMatchList[:]

func (BarrelsPerMinuteFlow) Matches 

func (x BarrelsPerMinuteFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (BarrelsPerMinuteFlow) Name 

func (x BarrelsPerMinuteFlow) Name() string

Name always returns "Barrels per Minute"

func (BarrelsPerMinuteFlow) Symbol 

func (x BarrelsPerMinuteFlow) Symbol() string

Symbol always returns "bbl/min"

func (BarrelsPerMinuteFlow) Title 

func (x BarrelsPerMinuteFlow) Title() string

Title always returns "BarrelsPerMinute"

func (BarrelsPerMinuteFlow) ToBase 

func (x BarrelsPerMinuteFlow) ToBase(bblm float64) float64

ToBase converts bbl/min to m³/s

func (BarrelsPerMinuteFlow) TypeOf 

func (x BarrelsPerMinuteFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type BarrelsPerSecondFlow 

type BarrelsPerSecondFlow Flow

BarrelsPerSecondFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s * 6.289,81 = bbl/s Unit.ToBase : bbls => bbls * 0.158,987 = m³/s 

var BarrelsPerSecondFlowUnit BarrelsPerSecondFlow = 0.0

func (BarrelsPerSecondFlow) Base 

func (x BarrelsPerSecondFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (BarrelsPerSecondFlow) FromBase 

func (x BarrelsPerSecondFlow) FromBase(m3s float64) float64

FromBase converts m³/s to bbl/s

func (BarrelsPerSecondFlow) MatchList 

func (x BarrelsPerSecondFlow) MatchList() []string

MatchList always returns BarrelsPerSecondFlowMatchList[:]

func (BarrelsPerSecondFlow) Matches 

func (x BarrelsPerSecondFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (BarrelsPerSecondFlow) Name 

func (x BarrelsPerSecondFlow) Name() string

Name always returns "Barrels per Second"

func (BarrelsPerSecondFlow) Symbol 

func (x BarrelsPerSecondFlow) Symbol() string

Symbol always returns "bbl/s"

func (BarrelsPerSecondFlow) Title 

func (x BarrelsPerSecondFlow) Title() string

Title always returns "BarrelsPerSecond"

func (BarrelsPerSecondFlow) ToBase 

func (x BarrelsPerSecondFlow) ToBase(bbls float64) float64

ToBase converts bbl/s to m³/s

func (BarrelsPerSecondFlow) TypeOf 

func (x BarrelsPerSecondFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type CubicDecimeterVolume 

type CubicDecimeterVolume Volume

CubicDecimeterVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 * 1,000 = dm³ Unit.ToBase : dm3 => dm3 * 0.001 = m³ 

var CubicDecimeterVolumeUnit CubicDecimeterVolume = 0.0

func (CubicDecimeterVolume) Base 

func (x CubicDecimeterVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (CubicDecimeterVolume) FromBase 

func (x CubicDecimeterVolume) FromBase(m3 float64) float64

FromBase converts m³ to dm³

func (CubicDecimeterVolume) MatchList 

func (x CubicDecimeterVolume) MatchList() []string

MatchList always returns CubicDecimeterVolumeMatchList[:]

func (CubicDecimeterVolume) Matches 

func (x CubicDecimeterVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (CubicDecimeterVolume) Name 

func (x CubicDecimeterVolume) Name() string

Name always returns "Cubic Decimeter"

func (CubicDecimeterVolume) Symbol 

func (x CubicDecimeterVolume) Symbol() string

Symbol always returns "dm³"

func (CubicDecimeterVolume) Title 

func (x CubicDecimeterVolume) Title() string

Title always returns "CubicDecimeter"

func (CubicDecimeterVolume) ToBase 

func (x CubicDecimeterVolume) ToBase(dm3 float64) float64

ToBase converts dm³ to m³

func (CubicDecimeterVolume) TypeOf 

func (x CubicDecimeterVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type CubicFeetOfNaturalGasWork 

type CubicFeetOfNaturalGasWork Work

CubicFeetOfNaturalGasWork (Unit) UnitType : Work UnitType.Base: JoulesWork Unit.FromBase: J => J * 0.000,000,947,817 = BTUᵢₜ Unit.ToBase : btu => btu * 1,055,060 = J 

var CubicFeetOfNaturalGasWorkUnit CubicFeetOfNaturalGasWork = 0.0

func (CubicFeetOfNaturalGasWork) Base 

func (x CubicFeetOfNaturalGasWork) Base() Unit

Base always returns JoulesWorkUnit

func (CubicFeetOfNaturalGasWork) FromBase 

func (x CubicFeetOfNaturalGasWork) FromBase(J float64) float64

FromBase converts J to BTUᵢₜ

func (CubicFeetOfNaturalGasWork) MatchList 

func (x CubicFeetOfNaturalGasWork) MatchList() []string

MatchList always returns CubicFeetOfNaturalGasWorkMatchList[:]

func (CubicFeetOfNaturalGasWork) Matches 

func (x CubicFeetOfNaturalGasWork) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (CubicFeetOfNaturalGasWork) Name 

func (x CubicFeetOfNaturalGasWork) Name() string

Name always returns "Cubic Feet of Natural Gas"

func (CubicFeetOfNaturalGasWork) Symbol 

func (x CubicFeetOfNaturalGasWork) Symbol() string

Symbol always returns "BTUᵢₜ"

func (CubicFeetOfNaturalGasWork) Title 

func (x CubicFeetOfNaturalGasWork) Title() string

Title always returns "CubicFeetOfNaturalGas"

func (CubicFeetOfNaturalGasWork) ToBase 

func (x CubicFeetOfNaturalGasWork) ToBase(btu float64) float64

ToBase converts BTUᵢₜ to J

func (CubicFeetOfNaturalGasWork) TypeOf 

func (x CubicFeetOfNaturalGasWork) TypeOf() UnitType

TypeOf always returns WorkUnitType

type CubicFeetPerSecondFlow 

type CubicFeetPerSecondFlow Flow

CubicFeetPerSecondFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s * 35.314,7 = ft³/s Unit.ToBase : ft3s => ft3s * 0.028,316,8 = m³/s 

var CubicFeetPerSecondFlowUnit CubicFeetPerSecondFlow = 0.0

func (CubicFeetPerSecondFlow) Base 

func (x CubicFeetPerSecondFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (CubicFeetPerSecondFlow) FromBase 

func (x CubicFeetPerSecondFlow) FromBase(m3s float64) float64

FromBase converts m³/s to ft³/s

func (CubicFeetPerSecondFlow) MatchList 

func (x CubicFeetPerSecondFlow) MatchList() []string

MatchList always returns CubicFeetPerSecondFlowMatchList[:]

func (CubicFeetPerSecondFlow) Matches 

func (x CubicFeetPerSecondFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (CubicFeetPerSecondFlow) Name 

func (x CubicFeetPerSecondFlow) Name() string

Name always returns "Cubic Feet per Second"

func (CubicFeetPerSecondFlow) Symbol 

func (x CubicFeetPerSecondFlow) Symbol() string

Symbol always returns "ft³/s"

func (CubicFeetPerSecondFlow) Title 

func (x CubicFeetPerSecondFlow) Title() string

Title always returns "CubicFeetPerSecond"

func (CubicFeetPerSecondFlow) ToBase 

func (x CubicFeetPerSecondFlow) ToBase(ft3s float64) float64

ToBase converts ft³/s to m³/s

func (CubicFeetPerSecondFlow) TypeOf 

func (x CubicFeetPerSecondFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type CubicFeetVolume 

type CubicFeetVolume Volume

CubicFeetVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 * 35.314,7 = cu ft Unit.ToBase : cuft => cuft * 0.028,316,8 = m³ 

var CubicFeetVolumeUnit CubicFeetVolume = 0.0

func (CubicFeetVolume) Base 

func (x CubicFeetVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (CubicFeetVolume) FromBase 

func (x CubicFeetVolume) FromBase(m3 float64) float64

FromBase converts m³ to cu ft

func (CubicFeetVolume) MatchList 

func (x CubicFeetVolume) MatchList() []string

MatchList always returns CubicFeetVolumeMatchList[:]

func (CubicFeetVolume) Matches 

func (x CubicFeetVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (CubicFeetVolume) Name 

func (x CubicFeetVolume) Name() string

Name always returns "Cubic Feet"

func (CubicFeetVolume) Symbol 

func (x CubicFeetVolume) Symbol() string

Symbol always returns "cu ft"

func (CubicFeetVolume) Title 

func (x CubicFeetVolume) Title() string

Title always returns "CubicFeet"

func (CubicFeetVolume) ToBase 

func (x CubicFeetVolume) ToBase(cuft float64) float64

ToBase converts cu ft to m³

func (CubicFeetVolume) TypeOf 

func (x CubicFeetVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type CubicMetersPerSecondFlow 

type CubicMetersPerSecondFlow Flow

CubicMetersPerSecondFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s = m³/s Unit.ToBase : m3s => m3s = m³/s 

var CubicMetersPerSecondFlowUnit CubicMetersPerSecondFlow = 0.0

func (CubicMetersPerSecondFlow) Base 

func (x CubicMetersPerSecondFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (CubicMetersPerSecondFlow) FromBase 

func (x CubicMetersPerSecondFlow) FromBase(m3s float64) float64

FromBase converts m³/s to m³/s

func (CubicMetersPerSecondFlow) MatchList 

func (x CubicMetersPerSecondFlow) MatchList() []string

MatchList always returns CubicMetersPerSecondFlowMatchList[:]

func (CubicMetersPerSecondFlow) Matches 

func (x CubicMetersPerSecondFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (CubicMetersPerSecondFlow) Name 

func (x CubicMetersPerSecondFlow) Name() string

Name always returns "Cubic Meters per Second"

func (CubicMetersPerSecondFlow) Symbol 

func (x CubicMetersPerSecondFlow) Symbol() string

Symbol always returns "m³/s"

func (CubicMetersPerSecondFlow) Title 

func (x CubicMetersPerSecondFlow) Title() string

Title always returns "CubicMetersPerSecond"

func (CubicMetersPerSecondFlow) ToBase 

func (x CubicMetersPerSecondFlow) ToBase(m3s float64) float64

ToBase converts m³/s to m³/s

func (CubicMetersPerSecondFlow) TypeOf 

func (x CubicMetersPerSecondFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type CubicMetersVolume 

type CubicMetersVolume Volume

CubicMetersVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 = m³ Unit.ToBase : m3 => m3 = m³ 

var CubicMetersVolumeUnit CubicMetersVolume = 0.0

func (CubicMetersVolume) Base 

func (x CubicMetersVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (CubicMetersVolume) FromBase 

func (x CubicMetersVolume) FromBase(m3 float64) float64

FromBase converts m³ to m³

func (CubicMetersVolume) MatchList 

func (x CubicMetersVolume) MatchList() []string

MatchList always returns CubicMetersVolumeMatchList[:]

func (CubicMetersVolume) Matches 

func (x CubicMetersVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (CubicMetersVolume) Name 

func (x CubicMetersVolume) Name() string

Name always returns "Cubic Meters"

func (CubicMetersVolume) Symbol 

func (x CubicMetersVolume) Symbol() string

Symbol always returns "m³"

func (CubicMetersVolume) Title 

func (x CubicMetersVolume) Title() string

Title always returns "CubicMeters"

func (CubicMetersVolume) ToBase 

func (x CubicMetersVolume) ToBase(m3 float64) float64

ToBase converts m³ to m³

func (CubicMetersVolume) TypeOf 

func (x CubicMetersVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type DegreesCelsiusTemperature 

type DegreesCelsiusTemperature Temperature

DegreesCelsiusTemperature (Unit) UnitType : Temperature UnitType.Base: DegreesCelsiusTemperature Unit.FromBase: C => C = °C Unit.ToBase : C => C = °C 

var DegreesCelsiusTemperatureUnit DegreesCelsiusTemperature = 0.0

func (DegreesCelsiusTemperature) Base 

func (x DegreesCelsiusTemperature) Base() Unit

Base always returns DegreesCelsiusTemperatureUnit

func (DegreesCelsiusTemperature) FromBase 

func (x DegreesCelsiusTemperature) FromBase(C float64) float64

FromBase converts °C to °C

func (DegreesCelsiusTemperature) MatchList 

func (x DegreesCelsiusTemperature) MatchList() []string

MatchList always returns DegreesCelsiusTemperatureMatchList[:]

func (DegreesCelsiusTemperature) Matches 

func (x DegreesCelsiusTemperature) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (DegreesCelsiusTemperature) Name 

func (x DegreesCelsiusTemperature) Name() string

Name always returns "Degrees Celsius"

func (DegreesCelsiusTemperature) Symbol 

func (x DegreesCelsiusTemperature) Symbol() string

Symbol always returns "°C"

func (DegreesCelsiusTemperature) Title 

func (x DegreesCelsiusTemperature) Title() string

Title always returns "DegreesCelsius"

func (DegreesCelsiusTemperature) ToBase 

func (x DegreesCelsiusTemperature) ToBase(C float64) float64

ToBase converts °C to °C

func (DegreesCelsiusTemperature) TypeOf 

func (x DegreesCelsiusTemperature) TypeOf() UnitType

TypeOf always returns TemperatureUnitType

type DegreesFahrenheitTemperature 

type DegreesFahrenheitTemperature Temperature

DegreesFahrenheitTemperature (Unit) UnitType : Temperature UnitType.Base: DegreesCelsiusTemperature Unit.FromBase: C => (C * (9.0 / 5.0)) + 32.0 = °F Unit.ToBase : F => (F - 32.0) * (5.0 / 9.0) = °C 

var DegreesFahrenheitTemperatureUnit DegreesFahrenheitTemperature = 0.0

func (DegreesFahrenheitTemperature) Base 

func (x DegreesFahrenheitTemperature) Base() Unit

Base always returns DegreesCelsiusTemperatureUnit

func (DegreesFahrenheitTemperature) FromBase 

func (x DegreesFahrenheitTemperature) FromBase(C float64) float64

FromBase converts °C to °F

func (DegreesFahrenheitTemperature) MatchList 

func (x DegreesFahrenheitTemperature) MatchList() []string

MatchList always returns DegreesFahrenheitTemperatureMatchList[:]

func (DegreesFahrenheitTemperature) Matches 

func (x DegreesFahrenheitTemperature) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (DegreesFahrenheitTemperature) Name 

func (x DegreesFahrenheitTemperature) Name() string

Name always returns "Degrees Fahrenheit"

func (DegreesFahrenheitTemperature) Symbol 

func (x DegreesFahrenheitTemperature) Symbol() string

Symbol always returns "°F"

func (DegreesFahrenheitTemperature) Title 

func (x DegreesFahrenheitTemperature) Title() string

Title always returns "DegreesFahrenheit"

func (DegreesFahrenheitTemperature) ToBase 

func (x DegreesFahrenheitTemperature) ToBase(F float64) float64

ToBase converts °F to °C

func (DegreesFahrenheitTemperature) TypeOf 

func (x DegreesFahrenheitTemperature) TypeOf() UnitType

TypeOf always returns TemperatureUnitType

type ElectricPotential 

type ElectricPotential float64

ElectricPotential (UnitType) Contains 1 units:

  • VoltsElectricPotential V => V = V

Base: VoltsElectricPotential 

var ElectricPotentialUnitType ElectricPotential = 0.0

func (ElectricPotential) Base 

func (x ElectricPotential) Base() Unit

Base always returns VoltsElectricPotentialUnit

func (ElectricPotential) MatchList 

func (x ElectricPotential) MatchList() []string

MatchList always returns ElectricPotentialMatchList[:]

func (ElectricPotential) Matches 

func (x ElectricPotential) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (ElectricPotential) Name 

func (x ElectricPotential) Name() string

Name always returns "Electric Potential"

func (ElectricPotential) Title 

func (x ElectricPotential) Title() string

Title always returns "ElectricPotential"

func (ElectricPotential) UnitList 

func (x ElectricPotential) UnitList() []string

UnitList always returns ElectricPotentialUnitList[:]

func (ElectricPotential) Units 

func (x ElectricPotential) Units() []Unit

Units always returns ElectricPotentialUnits[:]

type ElectricPotentialLoaded 

type ElectricPotentialLoaded float64

ElectricPotentialLoaded (UnitType) Contains 1 units:

  • VoltsElectricPotentialLoaded V => V = V

Base: VoltsElectricPotentialLoaded 

var ElectricPotentialLoadedUnitType ElectricPotentialLoaded = 0.0

func (ElectricPotentialLoaded) Base 

func (x ElectricPotentialLoaded) Base() Unit

Base always returns VoltsElectricPotentialLoadedUnit

func (ElectricPotentialLoaded) MatchList 

func (x ElectricPotentialLoaded) MatchList() []string

MatchList always returns ElectricPotentialLoadedMatchList[:]

func (ElectricPotentialLoaded) Matches 

func (x ElectricPotentialLoaded) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (ElectricPotentialLoaded) Name 

func (x ElectricPotentialLoaded) Name() string

Name always returns "Electric Potential Loaded"

func (ElectricPotentialLoaded) Title 

func (x ElectricPotentialLoaded) Title() string

Title always returns "ElectricPotentialLoaded"

func (ElectricPotentialLoaded) UnitList 

func (x ElectricPotentialLoaded) UnitList() []string

UnitList always returns ElectricPotentialLoadedUnitList[:]

func (ElectricPotentialLoaded) Units 

func (x ElectricPotentialLoaded) Units() []Unit

Units always returns ElectricPotentialLoadedUnits[:]

type ElectricPotentialUnloaded 

type ElectricPotentialUnloaded float64

ElectricPotentialUnloaded (UnitType) Contains 1 units:

  • VoltsElectricPotentialUnloaded V => V = V

Base: VoltsElectricPotentialUnloaded 

var ElectricPotentialUnloadedUnitType ElectricPotentialUnloaded = 0.0

func (ElectricPotentialUnloaded) Base 

func (x ElectricPotentialUnloaded) Base() Unit

Base always returns VoltsElectricPotentialUnloadedUnit

func (ElectricPotentialUnloaded) MatchList 

func (x ElectricPotentialUnloaded) MatchList() []string

MatchList always returns ElectricPotentialUnloadedMatchList[:]

func (ElectricPotentialUnloaded) Matches 

func (x ElectricPotentialUnloaded) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (ElectricPotentialUnloaded) Name 

func (x ElectricPotentialUnloaded) Name() string

Name always returns "Electric Potential Unloaded"

func (ElectricPotentialUnloaded) Title 

func (x ElectricPotentialUnloaded) Title() string

Title always returns "ElectricPotentialUnloaded"

func (ElectricPotentialUnloaded) UnitList 

func (x ElectricPotentialUnloaded) UnitList() []string

UnitList always returns ElectricPotentialUnloadedUnitList[:]

func (ElectricPotentialUnloaded) Units 

func (x ElectricPotentialUnloaded) Units() []Unit

Units always returns ElectricPotentialUnloadedUnits[:]

type FeetGrossStroke added in v1.0.5 

type FeetGrossStroke GrossStroke

FeetGrossStroke (Unit) UnitType : GrossStroke UnitType.Base: MetersGrossStroke Unit.FromBase: m => m * 3.280,84 = ft Unit.ToBase : ft => ft * 0.304,800 = m 

var FeetGrossStrokeUnit FeetGrossStroke = 0.0

func (FeetGrossStroke) Base added in v1.0.5 

func (x FeetGrossStroke) Base() Unit

Base always returns MetersGrossStrokeUnit

func (FeetGrossStroke) FromBase added in v1.0.5 

func (x FeetGrossStroke) FromBase(m float64) float64

FromBase converts m to ft

func (FeetGrossStroke) MatchList added in v1.0.5 

func (x FeetGrossStroke) MatchList() []string

MatchList always returns FeetGrossStrokeMatchList[:]

func (FeetGrossStroke) Matches added in v1.0.5 

func (x FeetGrossStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (FeetGrossStroke) Name added in v1.0.5 

func (x FeetGrossStroke) Name() string

Name always returns "Feet"

func (FeetGrossStroke) Symbol added in v1.0.5 

func (x FeetGrossStroke) Symbol() string

Symbol always returns "ft"

func (FeetGrossStroke) Title added in v1.0.5 

func (x FeetGrossStroke) Title() string

Title always returns "Feet"

func (FeetGrossStroke) ToBase added in v1.0.5 

func (x FeetGrossStroke) ToBase(ft float64) float64

ToBase converts ft to m

func (FeetGrossStroke) TypeOf added in v1.0.5 

func (x FeetGrossStroke) TypeOf() UnitType

TypeOf always returns GrossStrokeUnitType

type FeetLength 

type FeetLength Length

FeetLength (Unit) UnitType : Length UnitType.Base: MetersLength Unit.FromBase: m => m * 3.280,84 = ft Unit.ToBase : ft => ft * 0.304,800 = m 

var FeetLengthUnit FeetLength = 0.0

func (FeetLength) Base 

func (x FeetLength) Base() Unit

Base always returns MetersLengthUnit

func (FeetLength) FromBase 

func (x FeetLength) FromBase(m float64) float64

FromBase converts m to ft

func (FeetLength) MatchList 

func (x FeetLength) MatchList() []string

MatchList always returns FeetLengthMatchList[:]

func (FeetLength) Matches 

func (x FeetLength) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (FeetLength) Name 

func (x FeetLength) Name() string

Name always returns "Feet"

func (FeetLength) Symbol 

func (x FeetLength) Symbol() string

Symbol always returns "ft"

func (FeetLength) Title 

func (x FeetLength) Title() string

Title always returns "Feet"

func (FeetLength) ToBase 

func (x FeetLength) ToBase(ft float64) float64

ToBase converts ft to m

func (FeetLength) TypeOf 

func (x FeetLength) TypeOf() UnitType

TypeOf always returns LengthUnitType

type FeetNetStroke added in v1.0.5 

type FeetNetStroke NetStroke

FeetNetStroke (Unit) UnitType : NetStroke UnitType.Base: MetersNetStroke Unit.FromBase: m => m * 3.280,84 = ft Unit.ToBase : ft => ft * 0.304,800 = m 

var FeetNetStrokeUnit FeetNetStroke = 0.0

func (FeetNetStroke) Base added in v1.0.5 

func (x FeetNetStroke) Base() Unit

Base always returns MetersNetStrokeUnit

func (FeetNetStroke) FromBase added in v1.0.5 

func (x FeetNetStroke) FromBase(m float64) float64

FromBase converts m to ft

func (FeetNetStroke) MatchList added in v1.0.5 

func (x FeetNetStroke) MatchList() []string

MatchList always returns FeetNetStrokeMatchList[:]

func (FeetNetStroke) Matches added in v1.0.5 

func (x FeetNetStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (FeetNetStroke) Name added in v1.0.5 

func (x FeetNetStroke) Name() string

Name always returns "Feet"

func (FeetNetStroke) Symbol added in v1.0.5 

func (x FeetNetStroke) Symbol() string

Symbol always returns "ft"

func (FeetNetStroke) Title added in v1.0.5 

func (x FeetNetStroke) Title() string

Title always returns "Feet"

func (FeetNetStroke) ToBase added in v1.0.5 

func (x FeetNetStroke) ToBase(ft float64) float64

ToBase converts ft to m

func (FeetNetStroke) TypeOf added in v1.0.5 

func (x FeetNetStroke) TypeOf() UnitType

TypeOf always returns NetStrokeUnitType

type FeetStroke added in v1.0.5 

type FeetStroke Stroke

FeetStroke (Unit) UnitType : Stroke UnitType.Base: MetersStroke Unit.FromBase: m => m * 3.280,84 = ft Unit.ToBase : ft => ft * 0.304,800 = m 

var FeetStrokeUnit FeetStroke = 0.0

func (FeetStroke) Base added in v1.0.5 

func (x FeetStroke) Base() Unit

Base always returns MetersStrokeUnit

func (FeetStroke) FromBase added in v1.0.5 

func (x FeetStroke) FromBase(m float64) float64

FromBase converts m to ft

func (FeetStroke) MatchList added in v1.0.5 

func (x FeetStroke) MatchList() []string

MatchList always returns FeetStrokeMatchList[:]

func (FeetStroke) Matches added in v1.0.5 

func (x FeetStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (FeetStroke) Name added in v1.0.5 

func (x FeetStroke) Name() string

Name always returns "Feet"

func (FeetStroke) Symbol added in v1.0.5 

func (x FeetStroke) Symbol() string

Symbol always returns "ft"

func (FeetStroke) Title added in v1.0.5 

func (x FeetStroke) Title() string

Title always returns "Feet"

func (FeetStroke) ToBase added in v1.0.5 

func (x FeetStroke) ToBase(ft float64) float64

ToBase converts ft to m

func (FeetStroke) TypeOf added in v1.0.5 

func (x FeetStroke) TypeOf() UnitType

TypeOf always returns StrokeUnitType

type Fillage added in v1.0.5 

type Fillage float64

Fillage (UnitType) Contains 1 units:

  • PercentFillage p => p = %

Base: PercentFillage 

var FillageUnitType Fillage = 0.0

func (Fillage) Base added in v1.0.5 

func (x Fillage) Base() Unit

Base always returns PercentFillageUnit

func (Fillage) MatchList added in v1.0.5 

func (x Fillage) MatchList() []string

MatchList always returns FillageMatchList[:]

func (Fillage) Matches added in v1.0.5 

func (x Fillage) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Fillage) Name added in v1.0.5 

func (x Fillage) Name() string

Name always returns "Fillage"

func (Fillage) Title added in v1.0.5 

func (x Fillage) Title() string

Title always returns "Fillage"

func (Fillage) UnitList added in v1.0.5 

func (x Fillage) UnitList() []string

UnitList always returns FillageUnitList[:]

func (Fillage) Units added in v1.0.5 

func (x Fillage) Units() []Unit

Units always returns FillageUnits[:]

type Flow 

type Flow float64

Flow (UnitType) Contains 7 units:

  • CubicMetersPerSecondFlow m3s => m3s = m³/s
  • CubicFeetPerSecondFlow m3s => m3s * 35.314,7 = ft³/s
  • ThousandCubicFeetPerDayFlow m3s => m3s * 3,051.19 = MCFD
  • GallonsUSFluidPerSecondFlow m3s => m3s * 264.172 = gal/s
  • GallonsUSFluidPerMinuteFlow m3s => m3s * 15850.3 = gal/min
  • BarrelsPerSecondFlow m3s => m3s * 6.289,81 = bbl/s
  • BarrelsPerMinuteFlow m3s => m3s * 377.389 = bbl/min

Base: CubicMetersPerSecondFlow 

var FlowUnitType Flow = 0.0

func (Flow) Base 

func (x Flow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (Flow) MatchList 

func (x Flow) MatchList() []string

MatchList always returns FlowMatchList[:]

func (Flow) Matches 

func (x Flow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Flow) Name 

func (x Flow) Name() string

Name always returns "Flow"

func (Flow) Title 

func (x Flow) Title() string

Title always returns "Flow"

func (Flow) UnitList 

func (x Flow) UnitList() []string

UnitList always returns FlowUnitList[:]

func (Flow) Units 

func (x Flow) Units() []Unit

Units always returns FlowUnits[:]

type FluidLoad added in v1.0.5 

type FluidLoad float64

FluidLoad (UnitType) Contains 3 units:

  • NewtonsFluidLoad N => N = N
  • PoundsForceFluidLoad N => N * 0.224,809 = lbf
  • KilogramsForceFluidLoad N => N * 0.101,972 = kgf

Base: NewtonsFluidLoad 

var FluidLoadUnitType FluidLoad = 0.0

func (FluidLoad) Base added in v1.0.5 

func (x FluidLoad) Base() Unit

Base always returns NewtonsFluidLoadUnit

func (FluidLoad) MatchList added in v1.0.5 

func (x FluidLoad) MatchList() []string

MatchList always returns FluidLoadMatchList[:]

func (FluidLoad) Matches added in v1.0.5 

func (x FluidLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (FluidLoad) Name added in v1.0.5 

func (x FluidLoad) Name() string

Name always returns "Fluid Load"

func (FluidLoad) Title added in v1.0.5 

func (x FluidLoad) Title() string

Title always returns "FluidLoad"

func (FluidLoad) UnitList added in v1.0.5 

func (x FluidLoad) UnitList() []string

UnitList always returns FluidLoadUnitList[:]

func (FluidLoad) Units added in v1.0.5 

func (x FluidLoad) Units() []Unit

Units always returns FluidLoadUnits[:]

type Force 

type Force float64

Force (UnitType) Contains 3 units:

  • NewtonsForce N => N = N
  • PoundsForceForce N => N * 0.224,809 = lbf
  • KilogramsForceForce N => N * 0.101,972 = kgf

Base: NewtonsForce 

var ForceUnitType Force = 0.0

func (Force) Base 

func (x Force) Base() Unit

Base always returns NewtonsForceUnit

func (Force) MatchList 

func (x Force) MatchList() []string

MatchList always returns ForceMatchList[:]

func (Force) Matches 

func (x Force) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Force) Name 

func (x Force) Name() string

Name always returns "Force"

func (Force) Title 

func (x Force) Title() string

Title always returns "Force"

func (Force) UnitList 

func (x Force) UnitList() []string

UnitList always returns ForceUnitList[:]

func (Force) Units 

func (x Force) Units() []Unit

Units always returns ForceUnits[:]

type GallonUSFluidVolume 

type GallonUSFluidVolume Volume

GallonUSFluidVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 * 264.172 = gal (US) Unit.ToBase : gal => gal * 0.003,785,41 = m³ 

var GallonUSFluidVolumeUnit GallonUSFluidVolume = 0.0

func (GallonUSFluidVolume) Base 

func (x GallonUSFluidVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (GallonUSFluidVolume) FromBase 

func (x GallonUSFluidVolume) FromBase(m3 float64) float64

FromBase converts m³ to gal (US)

func (GallonUSFluidVolume) MatchList 

func (x GallonUSFluidVolume) MatchList() []string

MatchList always returns GallonUSFluidVolumeMatchList[:]

func (GallonUSFluidVolume) Matches 

func (x GallonUSFluidVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (GallonUSFluidVolume) Name 

func (x GallonUSFluidVolume) Name() string

Name always returns "Gallon (U.S. Fluid)"

func (GallonUSFluidVolume) Symbol 

func (x GallonUSFluidVolume) Symbol() string

Symbol always returns "gal (US)"

func (GallonUSFluidVolume) Title 

func (x GallonUSFluidVolume) Title() string

Title always returns "GallonUSFluid"

func (GallonUSFluidVolume) ToBase 

func (x GallonUSFluidVolume) ToBase(gal float64) float64

ToBase converts gal (US) to m³

func (GallonUSFluidVolume) TypeOf 

func (x GallonUSFluidVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type GallonsUSFluidPerMinuteFlow 

type GallonsUSFluidPerMinuteFlow Flow

GallonsUSFluidPerMinuteFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s * 15850.3 = gal/min Unit.ToBase : galm => galm * 0.000,063,090,2 = m³/s 

var GallonsUSFluidPerMinuteFlowUnit GallonsUSFluidPerMinuteFlow = 0.0

func (GallonsUSFluidPerMinuteFlow) Base 

func (x GallonsUSFluidPerMinuteFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (GallonsUSFluidPerMinuteFlow) FromBase 

func (x GallonsUSFluidPerMinuteFlow) FromBase(m3s float64) float64

FromBase converts m³/s to gal/min

func (GallonsUSFluidPerMinuteFlow) MatchList 

func (x GallonsUSFluidPerMinuteFlow) MatchList() []string

MatchList always returns GallonsUSFluidPerMinuteFlowMatchList[:]

func (GallonsUSFluidPerMinuteFlow) Matches 

func (x GallonsUSFluidPerMinuteFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (GallonsUSFluidPerMinuteFlow) Name 

func (x GallonsUSFluidPerMinuteFlow) Name() string

Name always returns "Gallons (U.S. Fluid) per Minute"

func (GallonsUSFluidPerMinuteFlow) Symbol 

func (x GallonsUSFluidPerMinuteFlow) Symbol() string

Symbol always returns "gal/min"

func (GallonsUSFluidPerMinuteFlow) Title 

func (x GallonsUSFluidPerMinuteFlow) Title() string

Title always returns "GallonsUSFluidPerMinute"

func (GallonsUSFluidPerMinuteFlow) ToBase 

func (x GallonsUSFluidPerMinuteFlow) ToBase(galm float64) float64

ToBase converts gal/min to m³/s

func (GallonsUSFluidPerMinuteFlow) TypeOf 

func (x GallonsUSFluidPerMinuteFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type GallonsUSFluidPerSecondFlow 

type GallonsUSFluidPerSecondFlow Flow

GallonsUSFluidPerSecondFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s * 264.172 = gal/s Unit.ToBase : gals => gals * 0.003,785,41 = m³/s 

var GallonsUSFluidPerSecondFlowUnit GallonsUSFluidPerSecondFlow = 0.0

func (GallonsUSFluidPerSecondFlow) Base 

func (x GallonsUSFluidPerSecondFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (GallonsUSFluidPerSecondFlow) FromBase 

func (x GallonsUSFluidPerSecondFlow) FromBase(m3s float64) float64

FromBase converts m³/s to gal/s

func (GallonsUSFluidPerSecondFlow) MatchList 

func (x GallonsUSFluidPerSecondFlow) MatchList() []string

MatchList always returns GallonsUSFluidPerSecondFlowMatchList[:]

func (GallonsUSFluidPerSecondFlow) Matches 

func (x GallonsUSFluidPerSecondFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (GallonsUSFluidPerSecondFlow) Name 

func (x GallonsUSFluidPerSecondFlow) Name() string

Name always returns "Gallons (U.S. Fluid) per Second"

func (GallonsUSFluidPerSecondFlow) Symbol 

func (x GallonsUSFluidPerSecondFlow) Symbol() string

Symbol always returns "gal/s"

func (GallonsUSFluidPerSecondFlow) Title 

func (x GallonsUSFluidPerSecondFlow) Title() string

Title always returns "GallonsUSFluidPerSecond"

func (GallonsUSFluidPerSecondFlow) ToBase 

func (x GallonsUSFluidPerSecondFlow) ToBase(gals float64) float64

ToBase converts gal/s to m³/s

func (GallonsUSFluidPerSecondFlow) TypeOf 

func (x GallonsUSFluidPerSecondFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type GrossStroke added in v1.0.5 

type GrossStroke float64

GrossStroke (UnitType) Contains 3 units:

  • MetersGrossStroke m => m = m
  • FeetGrossStroke m => m * 3.280,84 = ft
  • InchesGrossStroke m => m * 39.370,1 = in

Base: MetersGrossStroke 

var GrossStrokeUnitType GrossStroke = 0.0

func (GrossStroke) Base added in v1.0.5 

func (x GrossStroke) Base() Unit

Base always returns MetersGrossStrokeUnit

func (GrossStroke) MatchList added in v1.0.5 

func (x GrossStroke) MatchList() []string

MatchList always returns GrossStrokeMatchList[:]

func (GrossStroke) Matches added in v1.0.5 

func (x GrossStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (GrossStroke) Name added in v1.0.5 

func (x GrossStroke) Name() string

Name always returns "Gross Stroke"

func (GrossStroke) Title added in v1.0.5 

func (x GrossStroke) Title() string

Title always returns "GrossStroke"

func (GrossStroke) UnitList added in v1.0.5 

func (x GrossStroke) UnitList() []string

UnitList always returns GrossStrokeUnitList[:]

func (GrossStroke) Units added in v1.0.5 

func (x GrossStroke) Units() []Unit

Units always returns GrossStrokeUnits[:]

type Humidity 

type Humidity float64

Humidity (UnitType) Contains 1 units:

  • PercentHumidity p => p = %

Base: PercentHumidity 

var HumidityUnitType Humidity = 0.0

func (Humidity) Base 

func (x Humidity) Base() Unit

Base always returns PercentHumidityUnit

func (Humidity) MatchList 

func (x Humidity) MatchList() []string

MatchList always returns HumidityMatchList[:]

func (Humidity) Matches 

func (x Humidity) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Humidity) Name 

func (x Humidity) Name() string

Name always returns "Humidity"

func (Humidity) Title 

func (x Humidity) Title() string

Title always returns "Humidity"

func (Humidity) UnitList 

func (x Humidity) UnitList() []string

UnitList always returns HumidityUnitList[:]

func (Humidity) Units 

func (x Humidity) Units() []Unit

Units always returns HumidityUnits[:]

type InchPoundsForceWork 

type InchPoundsForceWork Work

InchPoundsForceWork (Unit) UnitType : Work UnitType.Base: JoulesWork Unit.FromBase: J => J * 8.850,74 = in lbf Unit.ToBase : inlbf => inlbf * 0.112,985 = J 

var InchPoundsForceWorkUnit InchPoundsForceWork = 0.0

func (InchPoundsForceWork) Base 

func (x InchPoundsForceWork) Base() Unit

Base always returns JoulesWorkUnit

func (InchPoundsForceWork) FromBase 

func (x InchPoundsForceWork) FromBase(J float64) float64

FromBase converts J to in lbf

func (InchPoundsForceWork) MatchList 

func (x InchPoundsForceWork) MatchList() []string

MatchList always returns InchPoundsForceWorkMatchList[:]

func (InchPoundsForceWork) Matches 

func (x InchPoundsForceWork) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (InchPoundsForceWork) Name 

func (x InchPoundsForceWork) Name() string

Name always returns "Inch-pounds Force"

func (InchPoundsForceWork) Symbol 

func (x InchPoundsForceWork) Symbol() string

Symbol always returns "in lbf"

func (InchPoundsForceWork) Title 

func (x InchPoundsForceWork) Title() string

Title always returns "InchPoundsForce"

func (InchPoundsForceWork) ToBase 

func (x InchPoundsForceWork) ToBase(inlbf float64) float64

ToBase converts in lbf to J

func (InchPoundsForceWork) TypeOf 

func (x InchPoundsForceWork) TypeOf() UnitType

TypeOf always returns WorkUnitType

type InchesGrossStroke added in v1.0.5 

type InchesGrossStroke GrossStroke

InchesGrossStroke (Unit) UnitType : GrossStroke UnitType.Base: MetersGrossStroke Unit.FromBase: m => m * 39.370,1 = in Unit.ToBase : in => in * 0.0254,000 = m 

var InchesGrossStrokeUnit InchesGrossStroke = 0.0

func (InchesGrossStroke) Base added in v1.0.5 

func (x InchesGrossStroke) Base() Unit

Base always returns MetersGrossStrokeUnit

func (InchesGrossStroke) FromBase added in v1.0.5 

func (x InchesGrossStroke) FromBase(m float64) float64

FromBase converts m to in

func (InchesGrossStroke) MatchList added in v1.0.5 

func (x InchesGrossStroke) MatchList() []string

MatchList always returns InchesGrossStrokeMatchList[:]

func (InchesGrossStroke) Matches added in v1.0.5 

func (x InchesGrossStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (InchesGrossStroke) Name added in v1.0.5 

func (x InchesGrossStroke) Name() string

Name always returns "Inches"

func (InchesGrossStroke) Symbol added in v1.0.5 

func (x InchesGrossStroke) Symbol() string

Symbol always returns "in"

func (InchesGrossStroke) Title added in v1.0.5 

func (x InchesGrossStroke) Title() string

Title always returns "Inches"

func (InchesGrossStroke) ToBase added in v1.0.5 

func (x InchesGrossStroke) ToBase(in float64) float64

ToBase converts in to m

func (InchesGrossStroke) TypeOf added in v1.0.5 

func (x InchesGrossStroke) TypeOf() UnitType

TypeOf always returns GrossStrokeUnitType

type InchesLength 

type InchesLength Length

InchesLength (Unit) UnitType : Length UnitType.Base: MetersLength Unit.FromBase: m => m * 39.370,1 = in Unit.ToBase : in => in * 0.0254,000 = m 

var InchesLengthUnit InchesLength = 0.0

func (InchesLength) Base 

func (x InchesLength) Base() Unit

Base always returns MetersLengthUnit

func (InchesLength) FromBase 

func (x InchesLength) FromBase(m float64) float64

FromBase converts m to in

func (InchesLength) MatchList 

func (x InchesLength) MatchList() []string

MatchList always returns InchesLengthMatchList[:]

func (InchesLength) Matches 

func (x InchesLength) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (InchesLength) Name 

func (x InchesLength) Name() string

Name always returns "Inches"

func (InchesLength) Symbol 

func (x InchesLength) Symbol() string

Symbol always returns "in"

func (InchesLength) Title 

func (x InchesLength) Title() string

Title always returns "Inches"

func (InchesLength) ToBase 

func (x InchesLength) ToBase(in float64) float64

ToBase converts in to m

func (InchesLength) TypeOf 

func (x InchesLength) TypeOf() UnitType

TypeOf always returns LengthUnitType

type InchesNetStroke added in v1.0.5 

type InchesNetStroke NetStroke

InchesNetStroke (Unit) UnitType : NetStroke UnitType.Base: MetersNetStroke Unit.FromBase: m => m * 39.370,1 = in Unit.ToBase : in => in * 0.0254,000 = m 

var InchesNetStrokeUnit InchesNetStroke = 0.0

func (InchesNetStroke) Base added in v1.0.5 

func (x InchesNetStroke) Base() Unit

Base always returns MetersNetStrokeUnit

func (InchesNetStroke) FromBase added in v1.0.5 

func (x InchesNetStroke) FromBase(m float64) float64

FromBase converts m to in

func (InchesNetStroke) MatchList added in v1.0.5 

func (x InchesNetStroke) MatchList() []string

MatchList always returns InchesNetStrokeMatchList[:]

func (InchesNetStroke) Matches added in v1.0.5 

func (x InchesNetStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (InchesNetStroke) Name added in v1.0.5 

func (x InchesNetStroke) Name() string

Name always returns "Inches"

func (InchesNetStroke) Symbol added in v1.0.5 

func (x InchesNetStroke) Symbol() string

Symbol always returns "in"

func (InchesNetStroke) Title added in v1.0.5 

func (x InchesNetStroke) Title() string

Title always returns "Inches"

func (InchesNetStroke) ToBase added in v1.0.5 

func (x InchesNetStroke) ToBase(in float64) float64

ToBase converts in to m

func (InchesNetStroke) TypeOf added in v1.0.5 

func (x InchesNetStroke) TypeOf() UnitType

TypeOf always returns NetStrokeUnitType

type InchesOfWaterPressure 

type InchesOfWaterPressure Pressure

InchesOfWaterPressure (Unit) UnitType : Pressure UnitType.Base: PascalsPressure Unit.FromBase: Pa => Pa * 0.004,014,74 = inH₂O Unit.ToBase : inH2O => inH2O * 249.082 = Pa 

var InchesOfWaterPressureUnit InchesOfWaterPressure = 0.0

func (InchesOfWaterPressure) Base 

func (x InchesOfWaterPressure) Base() Unit

Base always returns PascalsPressureUnit

func (InchesOfWaterPressure) FromBase 

func (x InchesOfWaterPressure) FromBase(Pa float64) float64

FromBase converts Pa to inH₂O

func (InchesOfWaterPressure) MatchList 

func (x InchesOfWaterPressure) MatchList() []string

MatchList always returns InchesOfWaterPressureMatchList[:]

func (InchesOfWaterPressure) Matches 

func (x InchesOfWaterPressure) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (InchesOfWaterPressure) Name 

func (x InchesOfWaterPressure) Name() string

Name always returns "Inches of Water"

func (InchesOfWaterPressure) Symbol 

func (x InchesOfWaterPressure) Symbol() string

Symbol always returns "inH₂O"

func (InchesOfWaterPressure) Title 

func (x InchesOfWaterPressure) Title() string

Title always returns "InchesOfWater"

func (InchesOfWaterPressure) ToBase 

func (x InchesOfWaterPressure) ToBase(inH2O float64) float64

ToBase converts inH₂O to Pa

func (InchesOfWaterPressure) TypeOf 

func (x InchesOfWaterPressure) TypeOf() UnitType

TypeOf always returns PressureUnitType

type InchesStroke added in v1.0.5 

type InchesStroke Stroke

InchesStroke (Unit) UnitType : Stroke UnitType.Base: MetersStroke Unit.FromBase: m => m * 39.370,1 = in Unit.ToBase : in => in * 0.0254,000 = m 

var InchesStrokeUnit InchesStroke = 0.0

func (InchesStroke) Base added in v1.0.5 

func (x InchesStroke) Base() Unit

Base always returns MetersStrokeUnit

func (InchesStroke) FromBase added in v1.0.5 

func (x InchesStroke) FromBase(m float64) float64

FromBase converts m to in

func (InchesStroke) MatchList added in v1.0.5 

func (x InchesStroke) MatchList() []string

MatchList always returns InchesStrokeMatchList[:]

func (InchesStroke) Matches added in v1.0.5 

func (x InchesStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (InchesStroke) Name added in v1.0.5 

func (x InchesStroke) Name() string

Name always returns "Inches"

func (InchesStroke) Symbol added in v1.0.5 

func (x InchesStroke) Symbol() string

Symbol always returns "in"

func (InchesStroke) Title added in v1.0.5 

func (x InchesStroke) Title() string

Title always returns "Inches"

func (InchesStroke) ToBase added in v1.0.5 

func (x InchesStroke) ToBase(in float64) float64

ToBase converts in to m

func (InchesStroke) TypeOf added in v1.0.5 

func (x InchesStroke) TypeOf() UnitType

TypeOf always returns StrokeUnitType

type JoulesWork 

type JoulesWork Work

JoulesWork (Unit) UnitType : Work UnitType.Base: JoulesWork Unit.FromBase: J => J = J Unit.ToBase : J => J = J 

var JoulesWorkUnit JoulesWork = 0.0

func (JoulesWork) Base 

func (x JoulesWork) Base() Unit

Base always returns JoulesWorkUnit

func (JoulesWork) FromBase 

func (x JoulesWork) FromBase(J float64) float64

FromBase converts J to J

func (JoulesWork) MatchList 

func (x JoulesWork) MatchList() []string

MatchList always returns JoulesWorkMatchList[:]

func (JoulesWork) Matches 

func (x JoulesWork) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (JoulesWork) Name 

func (x JoulesWork) Name() string

Name always returns "Joules"

func (JoulesWork) Symbol 

func (x JoulesWork) Symbol() string

Symbol always returns "J"

func (JoulesWork) Title 

func (x JoulesWork) Title() string

Title always returns "Joules"

func (JoulesWork) ToBase 

func (x JoulesWork) ToBase(J float64) float64

ToBase converts J to J

func (JoulesWork) TypeOf 

func (x JoulesWork) TypeOf() UnitType

TypeOf always returns WorkUnitType

type KelvinsTemperature 

type KelvinsTemperature Temperature

KelvinsTemperature (Unit) UnitType : Temperature UnitType.Base: DegreesCelsiusTemperature Unit.FromBase: C => C + 273.15 = K Unit.ToBase : K => K - 273.15 = °C 

var KelvinsTemperatureUnit KelvinsTemperature = 0.0

func (KelvinsTemperature) Base 

func (x KelvinsTemperature) Base() Unit

Base always returns DegreesCelsiusTemperatureUnit

func (KelvinsTemperature) FromBase 

func (x KelvinsTemperature) FromBase(C float64) float64

FromBase converts °C to K

func (KelvinsTemperature) MatchList 

func (x KelvinsTemperature) MatchList() []string

MatchList always returns KelvinsTemperatureMatchList[:]

func (KelvinsTemperature) Matches 

func (x KelvinsTemperature) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KelvinsTemperature) Name 

func (x KelvinsTemperature) Name() string

Name always returns "Kelvins"

func (KelvinsTemperature) Symbol 

func (x KelvinsTemperature) Symbol() string

Symbol always returns "K"

func (KelvinsTemperature) Title 

func (x KelvinsTemperature) Title() string

Title always returns "Kelvins"

func (KelvinsTemperature) ToBase 

func (x KelvinsTemperature) ToBase(K float64) float64

ToBase converts K to °C

func (KelvinsTemperature) TypeOf 

func (x KelvinsTemperature) TypeOf() UnitType

TypeOf always returns TemperatureUnitType

type KilogramsForceFluidLoad added in v1.0.5 

type KilogramsForceFluidLoad FluidLoad

KilogramsForceFluidLoad (Unit) UnitType : FluidLoad UnitType.Base: NewtonsFluidLoad Unit.FromBase: N => N * 0.101,972 = kgf Unit.ToBase : kgf => kgf * 9.806,65 = N 

var KilogramsForceFluidLoadUnit KilogramsForceFluidLoad = 0.0

func (KilogramsForceFluidLoad) Base added in v1.0.5 

func (x KilogramsForceFluidLoad) Base() Unit

Base always returns NewtonsFluidLoadUnit

func (KilogramsForceFluidLoad) FromBase added in v1.0.5 

func (x KilogramsForceFluidLoad) FromBase(N float64) float64

FromBase converts N to kgf

func (KilogramsForceFluidLoad) MatchList added in v1.0.5 

func (x KilogramsForceFluidLoad) MatchList() []string

MatchList always returns KilogramsForceFluidLoadMatchList[:]

func (KilogramsForceFluidLoad) Matches added in v1.0.5 

func (x KilogramsForceFluidLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsForceFluidLoad) Name added in v1.0.5 

func (x KilogramsForceFluidLoad) Name() string

Name always returns "Kilograms-force"

func (KilogramsForceFluidLoad) Symbol added in v1.0.5 

func (x KilogramsForceFluidLoad) Symbol() string

Symbol always returns "kgf"

func (KilogramsForceFluidLoad) Title added in v1.0.5 

func (x KilogramsForceFluidLoad) Title() string

Title always returns "KilogramsForce"

func (KilogramsForceFluidLoad) ToBase added in v1.0.5 

func (x KilogramsForceFluidLoad) ToBase(kgf float64) float64

ToBase converts kgf to N

func (KilogramsForceFluidLoad) TypeOf added in v1.0.5 

func (x KilogramsForceFluidLoad) TypeOf() UnitType

TypeOf always returns FluidLoadUnitType

type KilogramsForceForce 

type KilogramsForceForce Force

KilogramsForceForce (Unit) UnitType : Force UnitType.Base: NewtonsForce Unit.FromBase: N => N * 0.101,972 = kgf Unit.ToBase : kgf => kgf * 9.806,65 = N 

var KilogramsForceForceUnit KilogramsForceForce = 0.0

func (KilogramsForceForce) Base 

func (x KilogramsForceForce) Base() Unit

Base always returns NewtonsForceUnit

func (KilogramsForceForce) FromBase 

func (x KilogramsForceForce) FromBase(N float64) float64

FromBase converts N to kgf

func (KilogramsForceForce) MatchList 

func (x KilogramsForceForce) MatchList() []string

MatchList always returns KilogramsForceForceMatchList[:]

func (KilogramsForceForce) Matches 

func (x KilogramsForceForce) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsForceForce) Name 

func (x KilogramsForceForce) Name() string

Name always returns "Kilograms-force"

func (KilogramsForceForce) Symbol 

func (x KilogramsForceForce) Symbol() string

Symbol always returns "kgf"

func (KilogramsForceForce) Title 

func (x KilogramsForceForce) Title() string

Title always returns "KilogramsForce"

func (KilogramsForceForce) ToBase 

func (x KilogramsForceForce) ToBase(kgf float64) float64

ToBase converts kgf to N

func (KilogramsForceForce) TypeOf 

func (x KilogramsForceForce) TypeOf() UnitType

TypeOf always returns ForceUnitType

type KilogramsForceLoad added in v1.0.5 

type KilogramsForceLoad Load

KilogramsForceLoad (Unit) UnitType : Load UnitType.Base: NewtonsLoad Unit.FromBase: N => N * 0.101,972 = kgf Unit.ToBase : kgf => kgf * 9.806,65 = N 

var KilogramsForceLoadUnit KilogramsForceLoad = 0.0

func (KilogramsForceLoad) Base added in v1.0.5 

func (x KilogramsForceLoad) Base() Unit

Base always returns NewtonsLoadUnit

func (KilogramsForceLoad) FromBase added in v1.0.5 

func (x KilogramsForceLoad) FromBase(N float64) float64

FromBase converts N to kgf

func (KilogramsForceLoad) MatchList added in v1.0.5 

func (x KilogramsForceLoad) MatchList() []string

MatchList always returns KilogramsForceLoadMatchList[:]

func (KilogramsForceLoad) Matches added in v1.0.5 

func (x KilogramsForceLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsForceLoad) Name added in v1.0.5 

func (x KilogramsForceLoad) Name() string

Name always returns "Kilograms-force"

func (KilogramsForceLoad) Symbol added in v1.0.5 

func (x KilogramsForceLoad) Symbol() string

Symbol always returns "kgf"

func (KilogramsForceLoad) Title added in v1.0.5 

func (x KilogramsForceLoad) Title() string

Title always returns "KilogramsForce"

func (KilogramsForceLoad) ToBase added in v1.0.5 

func (x KilogramsForceLoad) ToBase(kgf float64) float64

ToBase converts kgf to N

func (KilogramsForceLoad) TypeOf added in v1.0.5 

func (x KilogramsForceLoad) TypeOf() UnitType

TypeOf always returns LoadUnitType

type KilogramsForceMaxLoad added in v1.0.5 

type KilogramsForceMaxLoad MaxLoad

KilogramsForceMaxLoad (Unit) UnitType : MaxLoad UnitType.Base: NewtonsMaxLoad Unit.FromBase: N => N * 0.101,972 = kgf Unit.ToBase : kgf => kgf * 9.806,65 = N 

var KilogramsForceMaxLoadUnit KilogramsForceMaxLoad = 0.0

func (KilogramsForceMaxLoad) Base added in v1.0.5 

func (x KilogramsForceMaxLoad) Base() Unit

Base always returns NewtonsMaxLoadUnit

func (KilogramsForceMaxLoad) FromBase added in v1.0.5 

func (x KilogramsForceMaxLoad) FromBase(N float64) float64

FromBase converts N to kgf

func (KilogramsForceMaxLoad) MatchList added in v1.0.5 

func (x KilogramsForceMaxLoad) MatchList() []string

MatchList always returns KilogramsForceMaxLoadMatchList[:]

func (KilogramsForceMaxLoad) Matches added in v1.0.5 

func (x KilogramsForceMaxLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsForceMaxLoad) Name added in v1.0.5 

func (x KilogramsForceMaxLoad) Name() string

Name always returns "Kilograms-force"

func (KilogramsForceMaxLoad) Symbol added in v1.0.5 

func (x KilogramsForceMaxLoad) Symbol() string

Symbol always returns "kgf"

func (KilogramsForceMaxLoad) Title added in v1.0.5 

func (x KilogramsForceMaxLoad) Title() string

Title always returns "KilogramsForce"

func (KilogramsForceMaxLoad) ToBase added in v1.0.5 

func (x KilogramsForceMaxLoad) ToBase(kgf float64) float64

ToBase converts kgf to N

func (KilogramsForceMaxLoad) TypeOf added in v1.0.5 

func (x KilogramsForceMaxLoad) TypeOf() UnitType

TypeOf always returns MaxLoadUnitType

type KilogramsForceMinLoad added in v1.0.5 

type KilogramsForceMinLoad MinLoad

KilogramsForceMinLoad (Unit) UnitType : MinLoad UnitType.Base: NewtonsMinLoad Unit.FromBase: N => N * 0.101,972 = kgf Unit.ToBase : kgf => kgf * 9.806,65 = N 

var KilogramsForceMinLoadUnit KilogramsForceMinLoad = 0.0

func (KilogramsForceMinLoad) Base added in v1.0.5 

func (x KilogramsForceMinLoad) Base() Unit

Base always returns NewtonsMinLoadUnit

func (KilogramsForceMinLoad) FromBase added in v1.0.5 

func (x KilogramsForceMinLoad) FromBase(N float64) float64

FromBase converts N to kgf

func (KilogramsForceMinLoad) MatchList added in v1.0.5 

func (x KilogramsForceMinLoad) MatchList() []string

MatchList always returns KilogramsForceMinLoadMatchList[:]

func (KilogramsForceMinLoad) Matches added in v1.0.5 

func (x KilogramsForceMinLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsForceMinLoad) Name added in v1.0.5 

func (x KilogramsForceMinLoad) Name() string

Name always returns "Kilograms-force"

func (KilogramsForceMinLoad) Symbol added in v1.0.5 

func (x KilogramsForceMinLoad) Symbol() string

Symbol always returns "kgf"

func (KilogramsForceMinLoad) Title added in v1.0.5 

func (x KilogramsForceMinLoad) Title() string

Title always returns "KilogramsForce"

func (KilogramsForceMinLoad) ToBase added in v1.0.5 

func (x KilogramsForceMinLoad) ToBase(kgf float64) float64

ToBase converts kgf to N

func (KilogramsForceMinLoad) TypeOf added in v1.0.5 

func (x KilogramsForceMinLoad) TypeOf() UnitType

TypeOf always returns MinLoadUnitType

type KilogramsMass 

type KilogramsMass Mass

KilogramsMass (Unit) UnitType : Mass UnitType.Base: KilogramsMass Unit.FromBase: kg => kg = kg Unit.ToBase : kg => kg = kg 

var KilogramsMassUnit KilogramsMass = 0.0

func (KilogramsMass) Base 

func (x KilogramsMass) Base() Unit

Base always returns KilogramsMassUnit

func (KilogramsMass) FromBase 

func (x KilogramsMass) FromBase(kg float64) float64

FromBase converts kg to kg

func (KilogramsMass) MatchList 

func (x KilogramsMass) MatchList() []string

MatchList always returns KilogramsMassMatchList[:]

func (KilogramsMass) Matches 

func (x KilogramsMass) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsMass) Name 

func (x KilogramsMass) Name() string

Name always returns "Kilograms"

func (KilogramsMass) Symbol 

func (x KilogramsMass) Symbol() string

Symbol always returns "kg"

func (KilogramsMass) Title 

func (x KilogramsMass) Title() string

Title always returns "Kilograms"

func (KilogramsMass) ToBase 

func (x KilogramsMass) ToBase(kg float64) float64

ToBase converts kg to kg

func (KilogramsMass) TypeOf 

func (x KilogramsMass) TypeOf() UnitType

TypeOf always returns MassUnitType

type KilogramsPerSecondMassFlow 

type KilogramsPerSecondMassFlow MassFlow

KilogramsPerSecondMassFlow (Unit) UnitType : MassFlow UnitType.Base: KilogramsPerSecondMassFlow Unit.FromBase: kgs => kgs = kg/s Unit.ToBase : kgs => kgs = kg/s 

var KilogramsPerSecondMassFlowUnit KilogramsPerSecondMassFlow = 0.0

func (KilogramsPerSecondMassFlow) Base 

func (x KilogramsPerSecondMassFlow) Base() Unit

Base always returns KilogramsPerSecondMassFlowUnit

func (KilogramsPerSecondMassFlow) FromBase 

func (x KilogramsPerSecondMassFlow) FromBase(kgs float64) float64

FromBase converts kg/s to kg/s

func (KilogramsPerSecondMassFlow) MatchList 

func (x KilogramsPerSecondMassFlow) MatchList() []string

MatchList always returns KilogramsPerSecondMassFlowMatchList[:]

func (KilogramsPerSecondMassFlow) Matches 

func (x KilogramsPerSecondMassFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilogramsPerSecondMassFlow) Name 

func (x KilogramsPerSecondMassFlow) Name() string

Name always returns "Kilograms per Second"

func (KilogramsPerSecondMassFlow) Symbol 

func (x KilogramsPerSecondMassFlow) Symbol() string

Symbol always returns "kg/s"

func (KilogramsPerSecondMassFlow) Title 

func (x KilogramsPerSecondMassFlow) Title() string

Title always returns "KilogramsPerSecond"

func (KilogramsPerSecondMassFlow) ToBase 

func (x KilogramsPerSecondMassFlow) ToBase(kgs float64) float64

ToBase converts kg/s to kg/s

func (KilogramsPerSecondMassFlow) TypeOf 

func (x KilogramsPerSecondMassFlow) TypeOf() UnitType

TypeOf always returns MassFlowUnitType

type KilopascalsPressure 

type KilopascalsPressure Pressure

KilopascalsPressure (Unit) UnitType : Pressure UnitType.Base: PascalsPressure Unit.FromBase: Pa => Pa * 0.001 = kPa Unit.ToBase : kPa => kPa * 1,000 = Pa 

var KilopascalsPressureUnit KilopascalsPressure = 0.0

func (KilopascalsPressure) Base 

func (x KilopascalsPressure) Base() Unit

Base always returns PascalsPressureUnit

func (KilopascalsPressure) FromBase 

func (x KilopascalsPressure) FromBase(Pa float64) float64

FromBase converts Pa to kPa

func (KilopascalsPressure) MatchList 

func (x KilopascalsPressure) MatchList() []string

MatchList always returns KilopascalsPressureMatchList[:]

func (KilopascalsPressure) Matches 

func (x KilopascalsPressure) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (KilopascalsPressure) Name 

func (x KilopascalsPressure) Name() string

Name always returns "Kilopascals"

func (KilopascalsPressure) Symbol 

func (x KilopascalsPressure) Symbol() string

Symbol always returns "kPa"

func (KilopascalsPressure) Title 

func (x KilopascalsPressure) Title() string

Title always returns "Kilopascals"

func (KilopascalsPressure) ToBase 

func (x KilopascalsPressure) ToBase(kPa float64) float64

ToBase converts kPa to Pa

func (KilopascalsPressure) TypeOf 

func (x KilopascalsPressure) TypeOf() UnitType

TypeOf always returns PressureUnitType

type Length 

type Length float64

Length (UnitType) Contains 3 units:

  • MetersLength m => m = m
  • FeetLength m => m * 3.280,84 = ft
  • InchesLength m => m * 39.370,1 = in

Base: MetersLength 

var LengthUnitType Length = 0.0

func (Length) Base 

func (x Length) Base() Unit

Base always returns MetersLengthUnit

func (Length) MatchList 

func (x Length) MatchList() []string

MatchList always returns LengthMatchList[:]

func (Length) Matches 

func (x Length) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Length) Name 

func (x Length) Name() string

Name always returns "Length"

func (Length) Title 

func (x Length) Title() string

Title always returns "Length"

func (Length) UnitList 

func (x Length) UnitList() []string

UnitList always returns LengthUnitList[:]

func (Length) Units 

func (x Length) Units() []Unit

Units always returns LengthUnits[:]

type LiterVolume 

type LiterVolume Volume

LiterVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 * 1,000 = L Unit.ToBase : L => L * 0.001 = m³ 

var LiterVolumeUnit LiterVolume = 0.0

func (LiterVolume) Base 

func (x LiterVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (LiterVolume) FromBase 

func (x LiterVolume) FromBase(m3 float64) float64

FromBase converts m³ to L

func (LiterVolume) MatchList 

func (x LiterVolume) MatchList() []string

MatchList always returns LiterVolumeMatchList[:]

func (LiterVolume) Matches 

func (x LiterVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (LiterVolume) Name 

func (x LiterVolume) Name() string

Name always returns "Liter"

func (LiterVolume) Symbol 

func (x LiterVolume) Symbol() string

Symbol always returns "L"

func (LiterVolume) Title 

func (x LiterVolume) Title() string

Title always returns "Liter"

func (LiterVolume) ToBase 

func (x LiterVolume) ToBase(L float64) float64

ToBase converts L to m³

func (LiterVolume) TypeOf 

func (x LiterVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type Load added in v1.0.5 

type Load float64

Load (UnitType) Contains 3 units:

  • NewtonsLoad N => N = N
  • PoundsForceLoad N => N * 0.224,809 = lbf
  • KilogramsForceLoad N => N * 0.101,972 = kgf

Base: NewtonsLoad 

var LoadUnitType Load = 0.0

func (Load) Base added in v1.0.5 

func (x Load) Base() Unit

Base always returns NewtonsLoadUnit

func (Load) MatchList added in v1.0.5 

func (x Load) MatchList() []string

MatchList always returns LoadMatchList[:]

func (Load) Matches added in v1.0.5 

func (x Load) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Load) Name added in v1.0.5 

func (x Load) Name() string

Name always returns "Load"

func (Load) Title added in v1.0.5 

func (x Load) Title() string

Title always returns "Load"

func (Load) UnitList added in v1.0.5 

func (x Load) UnitList() []string

UnitList always returns LoadUnitList[:]

func (Load) Units added in v1.0.5 

func (x Load) Units() []Unit

Units always returns LoadUnits[:]

type Mass 

type Mass float64

Mass (UnitType) Contains 2 units:

  • KilogramsMass kg => kg = kg
  • PoundsMass kg => kg * 2.204,62 = lb

Base: KilogramsMass 

var MassUnitType Mass = 0.0

func (Mass) Base 

func (x Mass) Base() Unit

Base always returns KilogramsMassUnit

func (Mass) MatchList 

func (x Mass) MatchList() []string

MatchList always returns MassMatchList[:]

func (Mass) Matches 

func (x Mass) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Mass) Name 

func (x Mass) Name() string

Name always returns "Mass"

func (Mass) Title 

func (x Mass) Title() string

Title always returns "Mass"

func (Mass) UnitList 

func (x Mass) UnitList() []string

UnitList always returns MassUnitList[:]

func (Mass) Units 

func (x Mass) Units() []Unit

Units always returns MassUnits[:]

type MassFlow 

type MassFlow float64

MassFlow (UnitType) Contains 3 units:

  • KilogramsPerSecondMassFlow kgs => kgs = kg/s
  • PoundsPerSecondMassFlow kgs => kgs * 2.204,62 = lb/s
  • PoundsPerMinuteMassFlow kgs => kgs * 132.277 = lb/min

Base: KilogramsPerSecondMassFlow 

var MassFlowUnitType MassFlow = 0.0

func (MassFlow) Base 

func (x MassFlow) Base() Unit

Base always returns KilogramsPerSecondMassFlowUnit

func (MassFlow) MatchList 

func (x MassFlow) MatchList() []string

MatchList always returns MassFlowMatchList[:]

func (MassFlow) Matches 

func (x MassFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MassFlow) Name 

func (x MassFlow) Name() string

Name always returns "Mass Flow"

func (MassFlow) Title 

func (x MassFlow) Title() string

Title always returns "MassFlow"

func (MassFlow) UnitList 

func (x MassFlow) UnitList() []string

UnitList always returns MassFlowUnitList[:]

func (MassFlow) Units 

func (x MassFlow) Units() []Unit

Units always returns MassFlowUnits[:]

type MaxLoad added in v1.0.5 

type MaxLoad float64

MaxLoad (UnitType) Contains 3 units:

  • NewtonsMaxLoad N => N = N
  • PoundsForceMaxLoad N => N * 0.224,809 = lbf
  • KilogramsForceMaxLoad N => N * 0.101,972 = kgf

Base: NewtonsMaxLoad 

var MaxLoadUnitType MaxLoad = 0.0

func (MaxLoad) Base added in v1.0.5 

func (x MaxLoad) Base() Unit

Base always returns NewtonsMaxLoadUnit

func (MaxLoad) MatchList added in v1.0.5 

func (x MaxLoad) MatchList() []string

MatchList always returns MaxLoadMatchList[:]

func (MaxLoad) Matches added in v1.0.5 

func (x MaxLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MaxLoad) Name added in v1.0.5 

func (x MaxLoad) Name() string

Name always returns "Max Load"

func (MaxLoad) Title added in v1.0.5 

func (x MaxLoad) Title() string

Title always returns "MaxLoad"

func (MaxLoad) UnitList added in v1.0.5 

func (x MaxLoad) UnitList() []string

UnitList always returns MaxLoadUnitList[:]

func (MaxLoad) Units added in v1.0.5 

func (x MaxLoad) Units() []Unit

Units always returns MaxLoadUnits[:]

type MegapascalsPressure 

type MegapascalsPressure Pressure

MegapascalsPressure (Unit) UnitType : Pressure UnitType.Base: PascalsPressure Unit.FromBase: Pa => Pa * 0.000,001 = MPa Unit.ToBase : MPa => MPa * 1,000,000 = Pa 

var MegapascalsPressureUnit MegapascalsPressure = 0.0

func (MegapascalsPressure) Base 

func (x MegapascalsPressure) Base() Unit

Base always returns PascalsPressureUnit

func (MegapascalsPressure) FromBase 

func (x MegapascalsPressure) FromBase(Pa float64) float64

FromBase converts Pa to MPa

func (MegapascalsPressure) MatchList 

func (x MegapascalsPressure) MatchList() []string

MatchList always returns MegapascalsPressureMatchList[:]

func (MegapascalsPressure) Matches 

func (x MegapascalsPressure) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MegapascalsPressure) Name 

func (x MegapascalsPressure) Name() string

Name always returns "Megapascals"

func (MegapascalsPressure) Symbol 

func (x MegapascalsPressure) Symbol() string

Symbol always returns "MPa"

func (MegapascalsPressure) Title 

func (x MegapascalsPressure) Title() string

Title always returns "Megapascals"

func (MegapascalsPressure) ToBase 

func (x MegapascalsPressure) ToBase(MPa float64) float64

ToBase converts MPa to Pa

func (MegapascalsPressure) TypeOf 

func (x MegapascalsPressure) TypeOf() UnitType

TypeOf always returns PressureUnitType

type MetersGrossStroke added in v1.0.5 

type MetersGrossStroke GrossStroke

MetersGrossStroke (Unit) UnitType : GrossStroke UnitType.Base: MetersGrossStroke Unit.FromBase: m => m = m Unit.ToBase : m => m = m 

var MetersGrossStrokeUnit MetersGrossStroke = 0.0

func (MetersGrossStroke) Base added in v1.0.5 

func (x MetersGrossStroke) Base() Unit

Base always returns MetersGrossStrokeUnit

func (MetersGrossStroke) FromBase added in v1.0.5 

func (x MetersGrossStroke) FromBase(m float64) float64

FromBase converts m to m

func (MetersGrossStroke) MatchList added in v1.0.5 

func (x MetersGrossStroke) MatchList() []string

MatchList always returns MetersGrossStrokeMatchList[:]

func (MetersGrossStroke) Matches added in v1.0.5 

func (x MetersGrossStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MetersGrossStroke) Name added in v1.0.5 

func (x MetersGrossStroke) Name() string

Name always returns "Meters"

func (MetersGrossStroke) Symbol added in v1.0.5 

func (x MetersGrossStroke) Symbol() string

Symbol always returns "m"

func (MetersGrossStroke) Title added in v1.0.5 

func (x MetersGrossStroke) Title() string

Title always returns "Meters"

func (MetersGrossStroke) ToBase added in v1.0.5 

func (x MetersGrossStroke) ToBase(m float64) float64

ToBase converts m to m

func (MetersGrossStroke) TypeOf added in v1.0.5 

func (x MetersGrossStroke) TypeOf() UnitType

TypeOf always returns GrossStrokeUnitType

type MetersLength 

type MetersLength Length

MetersLength (Unit) UnitType : Length UnitType.Base: MetersLength Unit.FromBase: m => m = m Unit.ToBase : m => m = m 

var MetersLengthUnit MetersLength = 0.0

func (MetersLength) Base 

func (x MetersLength) Base() Unit

Base always returns MetersLengthUnit

func (MetersLength) FromBase 

func (x MetersLength) FromBase(m float64) float64

FromBase converts m to m

func (MetersLength) MatchList 

func (x MetersLength) MatchList() []string

MatchList always returns MetersLengthMatchList[:]

func (MetersLength) Matches 

func (x MetersLength) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MetersLength) Name 

func (x MetersLength) Name() string

Name always returns "Meters"

func (MetersLength) Symbol 

func (x MetersLength) Symbol() string

Symbol always returns "m"

func (MetersLength) Title 

func (x MetersLength) Title() string

Title always returns "Meters"

func (MetersLength) ToBase 

func (x MetersLength) ToBase(m float64) float64

ToBase converts m to m

func (MetersLength) TypeOf 

func (x MetersLength) TypeOf() UnitType

TypeOf always returns LengthUnitType

type MetersNetStroke added in v1.0.5 

type MetersNetStroke NetStroke

MetersNetStroke (Unit) UnitType : NetStroke UnitType.Base: MetersNetStroke Unit.FromBase: m => m = m Unit.ToBase : m => m = m 

var MetersNetStrokeUnit MetersNetStroke = 0.0

func (MetersNetStroke) Base added in v1.0.5 

func (x MetersNetStroke) Base() Unit

Base always returns MetersNetStrokeUnit

func (MetersNetStroke) FromBase added in v1.0.5 

func (x MetersNetStroke) FromBase(m float64) float64

FromBase converts m to m

func (MetersNetStroke) MatchList added in v1.0.5 

func (x MetersNetStroke) MatchList() []string

MatchList always returns MetersNetStrokeMatchList[:]

func (MetersNetStroke) Matches added in v1.0.5 

func (x MetersNetStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MetersNetStroke) Name added in v1.0.5 

func (x MetersNetStroke) Name() string

Name always returns "Meters"

func (MetersNetStroke) Symbol added in v1.0.5 

func (x MetersNetStroke) Symbol() string

Symbol always returns "m"

func (MetersNetStroke) Title added in v1.0.5 

func (x MetersNetStroke) Title() string

Title always returns "Meters"

func (MetersNetStroke) ToBase added in v1.0.5 

func (x MetersNetStroke) ToBase(m float64) float64

ToBase converts m to m

func (MetersNetStroke) TypeOf added in v1.0.5 

func (x MetersNetStroke) TypeOf() UnitType

TypeOf always returns NetStrokeUnitType

type MetersStroke added in v1.0.5 

type MetersStroke Stroke

MetersStroke (Unit) UnitType : Stroke UnitType.Base: MetersStroke Unit.FromBase: m => m = m Unit.ToBase : m => m = m 

var MetersStrokeUnit MetersStroke = 0.0

func (MetersStroke) Base added in v1.0.5 

func (x MetersStroke) Base() Unit

Base always returns MetersStrokeUnit

func (MetersStroke) FromBase added in v1.0.5 

func (x MetersStroke) FromBase(m float64) float64

FromBase converts m to m

func (MetersStroke) MatchList added in v1.0.5 

func (x MetersStroke) MatchList() []string

MatchList always returns MetersStrokeMatchList[:]

func (MetersStroke) Matches added in v1.0.5 

func (x MetersStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MetersStroke) Name added in v1.0.5 

func (x MetersStroke) Name() string

Name always returns "Meters"

func (MetersStroke) Symbol added in v1.0.5 

func (x MetersStroke) Symbol() string

Symbol always returns "m"

func (MetersStroke) Title added in v1.0.5 

func (x MetersStroke) Title() string

Title always returns "Meters"

func (MetersStroke) ToBase added in v1.0.5 

func (x MetersStroke) ToBase(m float64) float64

ToBase converts m to m

func (MetersStroke) TypeOf added in v1.0.5 

func (x MetersStroke) TypeOf() UnitType

TypeOf always returns StrokeUnitType

type MinLoad added in v1.0.5 

type MinLoad float64

MinLoad (UnitType) Contains 3 units:

  • NewtonsMinLoad N => N = N
  • PoundsForceMinLoad N => N * 0.224,809 = lbf
  • KilogramsForceMinLoad N => N * 0.101,972 = kgf

Base: NewtonsMinLoad 

var MinLoadUnitType MinLoad = 0.0

func (MinLoad) Base added in v1.0.5 

func (x MinLoad) Base() Unit

Base always returns NewtonsMinLoadUnit

func (MinLoad) MatchList added in v1.0.5 

func (x MinLoad) MatchList() []string

MatchList always returns MinLoadMatchList[:]

func (MinLoad) Matches added in v1.0.5 

func (x MinLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (MinLoad) Name added in v1.0.5 

func (x MinLoad) Name() string

Name always returns "Min Load"

func (MinLoad) Title added in v1.0.5 

func (x MinLoad) Title() string

Title always returns "MinLoad"

func (MinLoad) UnitList added in v1.0.5 

func (x MinLoad) UnitList() []string

UnitList always returns MinLoadUnitList[:]

func (MinLoad) Units added in v1.0.5 

func (x MinLoad) Units() []Unit

Units always returns MinLoadUnits[:]

type NetStroke added in v1.0.5 

type NetStroke float64

NetStroke (UnitType) Contains 3 units:

  • MetersNetStroke m => m = m
  • FeetNetStroke m => m * 3.280,84 = ft
  • InchesNetStroke m => m * 39.370,1 = in

Base: MetersNetStroke 

var NetStrokeUnitType NetStroke = 0.0

func (NetStroke) Base added in v1.0.5 

func (x NetStroke) Base() Unit

Base always returns MetersNetStrokeUnit

func (NetStroke) MatchList added in v1.0.5 

func (x NetStroke) MatchList() []string

MatchList always returns NetStrokeMatchList[:]

func (NetStroke) Matches added in v1.0.5 

func (x NetStroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NetStroke) Name added in v1.0.5 

func (x NetStroke) Name() string

Name always returns "Net Stroke"

func (NetStroke) Title added in v1.0.5 

func (x NetStroke) Title() string

Title always returns "NetStroke"

func (NetStroke) UnitList added in v1.0.5 

func (x NetStroke) UnitList() []string

UnitList always returns NetStrokeUnitList[:]

func (NetStroke) Units added in v1.0.5 

func (x NetStroke) Units() []Unit

Units always returns NetStrokeUnits[:]

type NewtonsFluidLoad added in v1.0.5 

type NewtonsFluidLoad FluidLoad

NewtonsFluidLoad (Unit) UnitType : FluidLoad UnitType.Base: NewtonsFluidLoad Unit.FromBase: N => N = N Unit.ToBase : N => N = N 

var NewtonsFluidLoadUnit NewtonsFluidLoad = 0.0

func (NewtonsFluidLoad) Base added in v1.0.5 

func (x NewtonsFluidLoad) Base() Unit

Base always returns NewtonsFluidLoadUnit

func (NewtonsFluidLoad) FromBase added in v1.0.5 

func (x NewtonsFluidLoad) FromBase(N float64) float64

FromBase converts N to N

func (NewtonsFluidLoad) MatchList added in v1.0.5 

func (x NewtonsFluidLoad) MatchList() []string

MatchList always returns NewtonsFluidLoadMatchList[:]

func (NewtonsFluidLoad) Matches added in v1.0.5 

func (x NewtonsFluidLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NewtonsFluidLoad) Name added in v1.0.5 

func (x NewtonsFluidLoad) Name() string

Name always returns "Newtons"

func (NewtonsFluidLoad) Symbol added in v1.0.5 

func (x NewtonsFluidLoad) Symbol() string

Symbol always returns "N"

func (NewtonsFluidLoad) Title added in v1.0.5 

func (x NewtonsFluidLoad) Title() string

Title always returns "Newtons"

func (NewtonsFluidLoad) ToBase added in v1.0.5 

func (x NewtonsFluidLoad) ToBase(N float64) float64

ToBase converts N to N

func (NewtonsFluidLoad) TypeOf added in v1.0.5 

func (x NewtonsFluidLoad) TypeOf() UnitType

TypeOf always returns FluidLoadUnitType

type NewtonsForce 

type NewtonsForce Force

NewtonsForce (Unit) UnitType : Force UnitType.Base: NewtonsForce Unit.FromBase: N => N = N Unit.ToBase : N => N = N 

var NewtonsForceUnit NewtonsForce = 0.0

func (NewtonsForce) Base 

func (x NewtonsForce) Base() Unit

Base always returns NewtonsForceUnit

func (NewtonsForce) FromBase 

func (x NewtonsForce) FromBase(N float64) float64

FromBase converts N to N

func (NewtonsForce) MatchList 

func (x NewtonsForce) MatchList() []string

MatchList always returns NewtonsForceMatchList[:]

func (NewtonsForce) Matches 

func (x NewtonsForce) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NewtonsForce) Name 

func (x NewtonsForce) Name() string

Name always returns "Newtons"

func (NewtonsForce) Symbol 

func (x NewtonsForce) Symbol() string

Symbol always returns "N"

func (NewtonsForce) Title 

func (x NewtonsForce) Title() string

Title always returns "Newtons"

func (NewtonsForce) ToBase 

func (x NewtonsForce) ToBase(N float64) float64

ToBase converts N to N

func (NewtonsForce) TypeOf 

func (x NewtonsForce) TypeOf() UnitType

TypeOf always returns ForceUnitType

type NewtonsLoad added in v1.0.5 

type NewtonsLoad Load

NewtonsLoad (Unit) UnitType : Load UnitType.Base: NewtonsLoad Unit.FromBase: N => N = N Unit.ToBase : N => N = N 

var NewtonsLoadUnit NewtonsLoad = 0.0

func (NewtonsLoad) Base added in v1.0.5 

func (x NewtonsLoad) Base() Unit

Base always returns NewtonsLoadUnit

func (NewtonsLoad) FromBase added in v1.0.5 

func (x NewtonsLoad) FromBase(N float64) float64

FromBase converts N to N

func (NewtonsLoad) MatchList added in v1.0.5 

func (x NewtonsLoad) MatchList() []string

MatchList always returns NewtonsLoadMatchList[:]

func (NewtonsLoad) Matches added in v1.0.5 

func (x NewtonsLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NewtonsLoad) Name added in v1.0.5 

func (x NewtonsLoad) Name() string

Name always returns "Newtons"

func (NewtonsLoad) Symbol added in v1.0.5 

func (x NewtonsLoad) Symbol() string

Symbol always returns "N"

func (NewtonsLoad) Title added in v1.0.5 

func (x NewtonsLoad) Title() string

Title always returns "Newtons"

func (NewtonsLoad) ToBase added in v1.0.5 

func (x NewtonsLoad) ToBase(N float64) float64

ToBase converts N to N

func (NewtonsLoad) TypeOf added in v1.0.5 

func (x NewtonsLoad) TypeOf() UnitType

TypeOf always returns LoadUnitType

type NewtonsMaxLoad added in v1.0.5 

type NewtonsMaxLoad MaxLoad

NewtonsMaxLoad (Unit) UnitType : MaxLoad UnitType.Base: NewtonsMaxLoad Unit.FromBase: N => N = N Unit.ToBase : N => N = N 

var NewtonsMaxLoadUnit NewtonsMaxLoad = 0.0

func (NewtonsMaxLoad) Base added in v1.0.5 

func (x NewtonsMaxLoad) Base() Unit

Base always returns NewtonsMaxLoadUnit

func (NewtonsMaxLoad) FromBase added in v1.0.5 

func (x NewtonsMaxLoad) FromBase(N float64) float64

FromBase converts N to N

func (NewtonsMaxLoad) MatchList added in v1.0.5 

func (x NewtonsMaxLoad) MatchList() []string

MatchList always returns NewtonsMaxLoadMatchList[:]

func (NewtonsMaxLoad) Matches added in v1.0.5 

func (x NewtonsMaxLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NewtonsMaxLoad) Name added in v1.0.5 

func (x NewtonsMaxLoad) Name() string

Name always returns "Newtons"

func (NewtonsMaxLoad) Symbol added in v1.0.5 

func (x NewtonsMaxLoad) Symbol() string

Symbol always returns "N"

func (NewtonsMaxLoad) Title added in v1.0.5 

func (x NewtonsMaxLoad) Title() string

Title always returns "Newtons"

func (NewtonsMaxLoad) ToBase added in v1.0.5 

func (x NewtonsMaxLoad) ToBase(N float64) float64

ToBase converts N to N

func (NewtonsMaxLoad) TypeOf added in v1.0.5 

func (x NewtonsMaxLoad) TypeOf() UnitType

TypeOf always returns MaxLoadUnitType

type NewtonsMinLoad added in v1.0.5 

type NewtonsMinLoad MinLoad

NewtonsMinLoad (Unit) UnitType : MinLoad UnitType.Base: NewtonsMinLoad Unit.FromBase: N => N = N Unit.ToBase : N => N = N 

var NewtonsMinLoadUnit NewtonsMinLoad = 0.0

func (NewtonsMinLoad) Base added in v1.0.5 

func (x NewtonsMinLoad) Base() Unit

Base always returns NewtonsMinLoadUnit

func (NewtonsMinLoad) FromBase added in v1.0.5 

func (x NewtonsMinLoad) FromBase(N float64) float64

FromBase converts N to N

func (NewtonsMinLoad) MatchList added in v1.0.5 

func (x NewtonsMinLoad) MatchList() []string

MatchList always returns NewtonsMinLoadMatchList[:]

func (NewtonsMinLoad) Matches added in v1.0.5 

func (x NewtonsMinLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NewtonsMinLoad) Name added in v1.0.5 

func (x NewtonsMinLoad) Name() string

Name always returns "Newtons"

func (NewtonsMinLoad) Symbol added in v1.0.5 

func (x NewtonsMinLoad) Symbol() string

Symbol always returns "N"

func (NewtonsMinLoad) Title added in v1.0.5 

func (x NewtonsMinLoad) Title() string

Title always returns "Newtons"

func (NewtonsMinLoad) ToBase added in v1.0.5 

func (x NewtonsMinLoad) ToBase(N float64) float64

ToBase converts N to N

func (NewtonsMinLoad) TypeOf added in v1.0.5 

func (x NewtonsMinLoad) TypeOf() UnitType

TypeOf always returns MinLoadUnitType

type Number 

type Number float64

Number (UnitType) Contains 1 units:

  • NumberNumber n => n =

Base: NumberNumber 

var NumberUnitType Number = 0.0

func (Number) Base 

func (x Number) Base() Unit

Base always returns NumberNumberUnit

func (Number) MatchList 

func (x Number) MatchList() []string

MatchList always returns NumberMatchList[:]

func (Number) Matches 

func (x Number) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Number) Name 

func (x Number) Name() string

Name always returns "Number"

func (Number) Title 

func (x Number) Title() string

Title always returns "Number"

func (Number) UnitList 

func (x Number) UnitList() []string

UnitList always returns NumberUnitList[:]

func (Number) Units 

func (x Number) Units() []Unit

Units always returns NumberUnits[:]

type NumberNumber 

type NumberNumber Number

NumberNumber (Unit) UnitType : Number UnitType.Base: NumberNumber Unit.FromBase: n => n = Unit.ToBase : n => n = 

var NumberNumberUnit NumberNumber = 0.0

func (NumberNumber) Base 

func (x NumberNumber) Base() Unit

Base always returns NumberNumberUnit

func (NumberNumber) FromBase 

func (x NumberNumber) FromBase(n float64) float64

FromBase converts to

func (NumberNumber) MatchList 

func (x NumberNumber) MatchList() []string

MatchList always returns NumberNumberMatchList[:]

func (NumberNumber) Matches 

func (x NumberNumber) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NumberNumber) Name 

func (x NumberNumber) Name() string

Name always returns "Number"

func (NumberNumber) Symbol 

func (x NumberNumber) Symbol() string

Symbol always returns ""

func (NumberNumber) Title 

func (x NumberNumber) Title() string

Title always returns "Number"

func (NumberNumber) ToBase 

func (x NumberNumber) ToBase(n float64) float64

ToBase converts to

func (NumberNumber) TypeOf 

func (x NumberNumber) TypeOf() UnitType

TypeOf always returns NumberUnitType

type NumberOverspeed 

type NumberOverspeed Overspeed

NumberOverspeed (Unit) UnitType : Overspeed UnitType.Base: NumberOverspeed Unit.FromBase: n => n = Unit.ToBase : n => n = 

var NumberOverspeedUnit NumberOverspeed = 0.0

func (NumberOverspeed) Base 

func (x NumberOverspeed) Base() Unit

Base always returns NumberOverspeedUnit

func (NumberOverspeed) FromBase 

func (x NumberOverspeed) FromBase(n float64) float64

FromBase converts to

func (NumberOverspeed) MatchList 

func (x NumberOverspeed) MatchList() []string

MatchList always returns NumberOverspeedMatchList[:]

func (NumberOverspeed) Matches 

func (x NumberOverspeed) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NumberOverspeed) Name 

func (x NumberOverspeed) Name() string

Name always returns "Number"

func (NumberOverspeed) Symbol 

func (x NumberOverspeed) Symbol() string

Symbol always returns ""

func (NumberOverspeed) Title 

func (x NumberOverspeed) Title() string

Title always returns "Number"

func (NumberOverspeed) ToBase 

func (x NumberOverspeed) ToBase(n float64) float64

ToBase converts to

func (NumberOverspeed) TypeOf 

func (x NumberOverspeed) TypeOf() UnitType

TypeOf always returns OverspeedUnitType

type NumberTotaliser 

type NumberTotaliser Totaliser

NumberTotaliser (Unit) UnitType : Totaliser UnitType.Base: NumberTotaliser Unit.FromBase: n => n = Unit.ToBase : n => n = 

var NumberTotaliserUnit NumberTotaliser = 0.0

func (NumberTotaliser) Base 

func (x NumberTotaliser) Base() Unit

Base always returns NumberTotaliserUnit

func (NumberTotaliser) FromBase 

func (x NumberTotaliser) FromBase(n float64) float64

FromBase converts to

func (NumberTotaliser) MatchList 

func (x NumberTotaliser) MatchList() []string

MatchList always returns NumberTotaliserMatchList[:]

func (NumberTotaliser) Matches 

func (x NumberTotaliser) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NumberTotaliser) Name 

func (x NumberTotaliser) Name() string

Name always returns "Number"

func (NumberTotaliser) Symbol 

func (x NumberTotaliser) Symbol() string

Symbol always returns ""

func (NumberTotaliser) Title 

func (x NumberTotaliser) Title() string

Title always returns "Number"

func (NumberTotaliser) ToBase 

func (x NumberTotaliser) ToBase(n float64) float64

ToBase converts to

func (NumberTotaliser) TypeOf 

func (x NumberTotaliser) TypeOf() UnitType

TypeOf always returns TotaliserUnitType

type NumberUnderspeed 

type NumberUnderspeed Underspeed

NumberUnderspeed (Unit) UnitType : Underspeed UnitType.Base: NumberUnderspeed Unit.FromBase: n => n = Unit.ToBase : n => n = 

var NumberUnderspeedUnit NumberUnderspeed = 0.0

func (NumberUnderspeed) Base 

func (x NumberUnderspeed) Base() Unit

Base always returns NumberUnderspeedUnit

func (NumberUnderspeed) FromBase 

func (x NumberUnderspeed) FromBase(n float64) float64

FromBase converts to

func (NumberUnderspeed) MatchList 

func (x NumberUnderspeed) MatchList() []string

MatchList always returns NumberUnderspeedMatchList[:]

func (NumberUnderspeed) Matches 

func (x NumberUnderspeed) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NumberUnderspeed) Name 

func (x NumberUnderspeed) Name() string

Name always returns "Number"

func (NumberUnderspeed) Symbol 

func (x NumberUnderspeed) Symbol() string

Symbol always returns ""

func (NumberUnderspeed) Title 

func (x NumberUnderspeed) Title() string

Title always returns "Number"

func (NumberUnderspeed) ToBase 

func (x NumberUnderspeed) ToBase(n float64) float64

ToBase converts to

func (NumberUnderspeed) TypeOf 

func (x NumberUnderspeed) TypeOf() UnitType

TypeOf always returns UnderspeedUnitType

type NumberWMLFlowRate 

type NumberWMLFlowRate WMLFlowRate

NumberWMLFlowRate (Unit) UnitType : WMLFlowRate UnitType.Base: NumberWMLFlowRate Unit.FromBase: n => n = Unit.ToBase : n => n = 

var NumberWMLFlowRateUnit NumberWMLFlowRate = 0.0

func (NumberWMLFlowRate) Base 

func (x NumberWMLFlowRate) Base() Unit

Base always returns NumberWMLFlowRateUnit

func (NumberWMLFlowRate) FromBase 

func (x NumberWMLFlowRate) FromBase(n float64) float64

FromBase converts to

func (NumberWMLFlowRate) MatchList 

func (x NumberWMLFlowRate) MatchList() []string

MatchList always returns NumberWMLFlowRateMatchList[:]

func (NumberWMLFlowRate) Matches 

func (x NumberWMLFlowRate) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (NumberWMLFlowRate) Name 

func (x NumberWMLFlowRate) Name() string

Name always returns "Number"

func (NumberWMLFlowRate) Symbol 

func (x NumberWMLFlowRate) Symbol() string

Symbol always returns ""

func (NumberWMLFlowRate) Title 

func (x NumberWMLFlowRate) Title() string

Title always returns "Number"

func (NumberWMLFlowRate) ToBase 

func (x NumberWMLFlowRate) ToBase(n float64) float64

ToBase converts to

func (NumberWMLFlowRate) TypeOf 

func (x NumberWMLFlowRate) TypeOf() UnitType

TypeOf always returns WMLFlowRateUnitType

type Overspeed 

type Overspeed float64

Overspeed (UnitType) Contains 1 units:

  • NumberOverspeed n => n =

Base: NumberOverspeed 

var OverspeedUnitType Overspeed = 0.0

func (Overspeed) Base 

func (x Overspeed) Base() Unit

Base always returns NumberOverspeedUnit

func (Overspeed) MatchList 

func (x Overspeed) MatchList() []string

MatchList always returns OverspeedMatchList[:]

func (Overspeed) Matches 

func (x Overspeed) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Overspeed) Name 

func (x Overspeed) Name() string

Name always returns "Overspeed"

func (Overspeed) Title 

func (x Overspeed) Title() string

Title always returns "Overspeed"

func (Overspeed) UnitList 

func (x Overspeed) UnitList() []string

UnitList always returns OverspeedUnitList[:]

func (Overspeed) Units 

func (x Overspeed) Units() []Unit

Units always returns OverspeedUnits[:]

type PascalsPressure 

type PascalsPressure Pressure

PascalsPressure (Unit) UnitType : Pressure UnitType.Base: PascalsPressure Unit.FromBase: Pa => Pa = Pa Unit.ToBase : Pa => Pa = Pa 

var PascalsPressureUnit PascalsPressure = 0.0

func (PascalsPressure) Base 

func (x PascalsPressure) Base() Unit

Base always returns PascalsPressureUnit

func (PascalsPressure) FromBase 

func (x PascalsPressure) FromBase(Pa float64) float64

FromBase converts Pa to Pa

func (PascalsPressure) MatchList 

func (x PascalsPressure) MatchList() []string

MatchList always returns PascalsPressureMatchList[:]

func (PascalsPressure) Matches 

func (x PascalsPressure) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PascalsPressure) Name 

func (x PascalsPressure) Name() string

Name always returns "Pascals"

func (PascalsPressure) Symbol 

func (x PascalsPressure) Symbol() string

Symbol always returns "Pa"

func (PascalsPressure) Title 

func (x PascalsPressure) Title() string

Title always returns "Pascals"

func (PascalsPressure) ToBase 

func (x PascalsPressure) ToBase(Pa float64) float64

ToBase converts Pa to Pa

func (PascalsPressure) TypeOf 

func (x PascalsPressure) TypeOf() UnitType

TypeOf always returns PressureUnitType

type PercentAlarm 

type PercentAlarm Alarm

PercentAlarm (Unit) UnitType : Alarm UnitType.Base: PercentAlarm Unit.FromBase: p => p = % Unit.ToBase : p => p = % 

var PercentAlarmUnit PercentAlarm = 0.0

func (PercentAlarm) Base 

func (x PercentAlarm) Base() Unit

Base always returns PercentAlarmUnit

func (PercentAlarm) FromBase 

func (x PercentAlarm) FromBase(p float64) float64

FromBase converts % to %

func (PercentAlarm) MatchList 

func (x PercentAlarm) MatchList() []string

MatchList always returns PercentAlarmMatchList[:]

func (PercentAlarm) Matches 

func (x PercentAlarm) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PercentAlarm) Name 

func (x PercentAlarm) Name() string

Name always returns "Percent"

func (PercentAlarm) Symbol 

func (x PercentAlarm) Symbol() string

Symbol always returns "%"

func (PercentAlarm) Title 

func (x PercentAlarm) Title() string

Title always returns "Percent"

func (PercentAlarm) ToBase 

func (x PercentAlarm) ToBase(p float64) float64

ToBase converts % to %

func (PercentAlarm) TypeOf 

func (x PercentAlarm) TypeOf() UnitType

TypeOf always returns AlarmUnitType

type PercentFillage added in v1.0.5 

type PercentFillage Fillage

PercentFillage (Unit) UnitType : Fillage UnitType.Base: PercentFillage Unit.FromBase: p => p = % Unit.ToBase : p => p = % 

var PercentFillageUnit PercentFillage = 0.0

func (PercentFillage) Base added in v1.0.5 

func (x PercentFillage) Base() Unit

Base always returns PercentFillageUnit

func (PercentFillage) FromBase added in v1.0.5 

func (x PercentFillage) FromBase(p float64) float64

FromBase converts % to %

func (PercentFillage) MatchList added in v1.0.5 

func (x PercentFillage) MatchList() []string

MatchList always returns PercentFillageMatchList[:]

func (PercentFillage) Matches added in v1.0.5 

func (x PercentFillage) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PercentFillage) Name added in v1.0.5 

func (x PercentFillage) Name() string

Name always returns "Percent"

func (PercentFillage) Symbol added in v1.0.5 

func (x PercentFillage) Symbol() string

Symbol always returns "%"

func (PercentFillage) Title added in v1.0.5 

func (x PercentFillage) Title() string

Title always returns "Percent"

func (PercentFillage) ToBase added in v1.0.5 

func (x PercentFillage) ToBase(p float64) float64

ToBase converts % to %

func (PercentFillage) TypeOf added in v1.0.5 

func (x PercentFillage) TypeOf() UnitType

TypeOf always returns FillageUnitType

type PercentHumidity 

type PercentHumidity Humidity

PercentHumidity (Unit) UnitType : Humidity UnitType.Base: PercentHumidity Unit.FromBase: p => p = % Unit.ToBase : p => p = % 

var PercentHumidityUnit PercentHumidity = 0.0

func (PercentHumidity) Base 

func (x PercentHumidity) Base() Unit

Base always returns PercentHumidityUnit

func (PercentHumidity) FromBase 

func (x PercentHumidity) FromBase(p float64) float64

FromBase converts % to %

func (PercentHumidity) MatchList 

func (x PercentHumidity) MatchList() []string

MatchList always returns PercentHumidityMatchList[:]

func (PercentHumidity) Matches 

func (x PercentHumidity) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PercentHumidity) Name 

func (x PercentHumidity) Name() string

Name always returns "Percent"

func (PercentHumidity) Symbol 

func (x PercentHumidity) Symbol() string

Symbol always returns "%"

func (PercentHumidity) Title 

func (x PercentHumidity) Title() string

Title always returns "Percent"

func (PercentHumidity) ToBase 

func (x PercentHumidity) ToBase(p float64) float64

ToBase converts % to %

func (PercentHumidity) TypeOf 

func (x PercentHumidity) TypeOf() UnitType

TypeOf always returns HumidityUnitType

type PercentPercentage 

type PercentPercentage Percentage

PercentPercentage (Unit) UnitType : Percentage UnitType.Base: PercentPercentage Unit.FromBase: p => p = % Unit.ToBase : p => p = % 

var PercentPercentageUnit PercentPercentage = 0.0

func (PercentPercentage) Base 

func (x PercentPercentage) Base() Unit

Base always returns PercentPercentageUnit

func (PercentPercentage) FromBase 

func (x PercentPercentage) FromBase(p float64) float64

FromBase converts % to %

func (PercentPercentage) MatchList 

func (x PercentPercentage) MatchList() []string

MatchList always returns PercentPercentageMatchList[:]

func (PercentPercentage) Matches 

func (x PercentPercentage) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PercentPercentage) Name 

func (x PercentPercentage) Name() string

Name always returns "Percent"

func (PercentPercentage) Symbol 

func (x PercentPercentage) Symbol() string

Symbol always returns "%"

func (PercentPercentage) Title 

func (x PercentPercentage) Title() string

Title always returns "Percent"

func (PercentPercentage) ToBase 

func (x PercentPercentage) ToBase(p float64) float64

ToBase converts % to %

func (PercentPercentage) TypeOf 

func (x PercentPercentage) TypeOf() UnitType

TypeOf always returns PercentageUnitType

type PercentPumpFillage added in v1.0.5 

type PercentPumpFillage PumpFillage

PercentPumpFillage (Unit) UnitType : PumpFillage UnitType.Base: PercentPumpFillage Unit.FromBase: p => p = % Unit.ToBase : p => p = % 

var PercentPumpFillageUnit PercentPumpFillage = 0.0

func (PercentPumpFillage) Base added in v1.0.5 

func (x PercentPumpFillage) Base() Unit

Base always returns PercentPumpFillageUnit

func (PercentPumpFillage) FromBase added in v1.0.5 

func (x PercentPumpFillage) FromBase(p float64) float64

FromBase converts % to %

func (PercentPumpFillage) MatchList added in v1.0.5 

func (x PercentPumpFillage) MatchList() []string

MatchList always returns PercentPumpFillageMatchList[:]

func (PercentPumpFillage) Matches added in v1.0.5 

func (x PercentPumpFillage) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PercentPumpFillage) Name added in v1.0.5 

func (x PercentPumpFillage) Name() string

Name always returns "Percent"

func (PercentPumpFillage) Symbol added in v1.0.5 

func (x PercentPumpFillage) Symbol() string

Symbol always returns "%"

func (PercentPumpFillage) Title added in v1.0.5 

func (x PercentPumpFillage) Title() string

Title always returns "Percent"

func (PercentPumpFillage) ToBase added in v1.0.5 

func (x PercentPumpFillage) ToBase(p float64) float64

ToBase converts % to %

func (PercentPumpFillage) TypeOf added in v1.0.5 

func (x PercentPumpFillage) TypeOf() UnitType

TypeOf always returns PumpFillageUnitType

type Percentage 

type Percentage float64

Percentage (UnitType) Contains 1 units:

  • PercentPercentage p => p = %

Base: PercentPercentage 

var PercentageUnitType Percentage = 0.0

func (Percentage) Base 

func (x Percentage) Base() Unit

Base always returns PercentPercentageUnit

func (Percentage) MatchList 

func (x Percentage) MatchList() []string

MatchList always returns PercentageMatchList[:]

func (Percentage) Matches 

func (x Percentage) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Percentage) Name 

func (x Percentage) Name() string

Name always returns "Percentage"

func (Percentage) Title 

func (x Percentage) Title() string

Title always returns "Percentage"

func (Percentage) UnitList 

func (x Percentage) UnitList() []string

UnitList always returns PercentageUnitList[:]

func (Percentage) Units 

func (x Percentage) Units() []Unit

Units always returns PercentageUnits[:]

type PoundsForceFluidLoad added in v1.0.5 

type PoundsForceFluidLoad FluidLoad

PoundsForceFluidLoad (Unit) UnitType : FluidLoad UnitType.Base: NewtonsFluidLoad Unit.FromBase: N => N * 0.224,809 = lbf Unit.ToBase : lbf => lbf * 4.448,22 = N 

var PoundsForceFluidLoadUnit PoundsForceFluidLoad = 0.0

func (PoundsForceFluidLoad) Base added in v1.0.5 

func (x PoundsForceFluidLoad) Base() Unit

Base always returns NewtonsFluidLoadUnit

func (PoundsForceFluidLoad) FromBase added in v1.0.5 

func (x PoundsForceFluidLoad) FromBase(N float64) float64

FromBase converts N to lbf

func (PoundsForceFluidLoad) MatchList added in v1.0.5 

func (x PoundsForceFluidLoad) MatchList() []string

MatchList always returns PoundsForceFluidLoadMatchList[:]

func (PoundsForceFluidLoad) Matches added in v1.0.5 

func (x PoundsForceFluidLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsForceFluidLoad) Name added in v1.0.5 

func (x PoundsForceFluidLoad) Name() string

Name always returns "Pounds-force"

func (PoundsForceFluidLoad) Symbol added in v1.0.5 

func (x PoundsForceFluidLoad) Symbol() string

Symbol always returns "lbf"

func (PoundsForceFluidLoad) Title added in v1.0.5 

func (x PoundsForceFluidLoad) Title() string

Title always returns "PoundsForce"

func (PoundsForceFluidLoad) ToBase added in v1.0.5 

func (x PoundsForceFluidLoad) ToBase(lbf float64) float64

ToBase converts lbf to N

func (PoundsForceFluidLoad) TypeOf added in v1.0.5 

func (x PoundsForceFluidLoad) TypeOf() UnitType

TypeOf always returns FluidLoadUnitType

type PoundsForceForce 

type PoundsForceForce Force

PoundsForceForce (Unit) UnitType : Force UnitType.Base: NewtonsForce Unit.FromBase: N => N * 0.224,809 = lbf Unit.ToBase : lbf => lbf * 4.448,22 = N 

var PoundsForceForceUnit PoundsForceForce = 0.0

func (PoundsForceForce) Base 

func (x PoundsForceForce) Base() Unit

Base always returns NewtonsForceUnit

func (PoundsForceForce) FromBase 

func (x PoundsForceForce) FromBase(N float64) float64

FromBase converts N to lbf

func (PoundsForceForce) MatchList 

func (x PoundsForceForce) MatchList() []string

MatchList always returns PoundsForceForceMatchList[:]

func (PoundsForceForce) Matches 

func (x PoundsForceForce) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsForceForce) Name 

func (x PoundsForceForce) Name() string

Name always returns "Pounds-force"

func (PoundsForceForce) Symbol 

func (x PoundsForceForce) Symbol() string

Symbol always returns "lbf"

func (PoundsForceForce) Title 

func (x PoundsForceForce) Title() string

Title always returns "PoundsForce"

func (PoundsForceForce) ToBase 

func (x PoundsForceForce) ToBase(lbf float64) float64

ToBase converts lbf to N

func (PoundsForceForce) TypeOf 

func (x PoundsForceForce) TypeOf() UnitType

TypeOf always returns ForceUnitType

type PoundsForceLoad added in v1.0.5 

type PoundsForceLoad Load

PoundsForceLoad (Unit) UnitType : Load UnitType.Base: NewtonsLoad Unit.FromBase: N => N * 0.224,809 = lbf Unit.ToBase : lbf => lbf * 4.448,22 = N 

var PoundsForceLoadUnit PoundsForceLoad = 0.0

func (PoundsForceLoad) Base added in v1.0.5 

func (x PoundsForceLoad) Base() Unit

Base always returns NewtonsLoadUnit

func (PoundsForceLoad) FromBase added in v1.0.5 

func (x PoundsForceLoad) FromBase(N float64) float64

FromBase converts N to lbf

func (PoundsForceLoad) MatchList added in v1.0.5 

func (x PoundsForceLoad) MatchList() []string

MatchList always returns PoundsForceLoadMatchList[:]

func (PoundsForceLoad) Matches added in v1.0.5 

func (x PoundsForceLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsForceLoad) Name added in v1.0.5 

func (x PoundsForceLoad) Name() string

Name always returns "Pounds-force"

func (PoundsForceLoad) Symbol added in v1.0.5 

func (x PoundsForceLoad) Symbol() string

Symbol always returns "lbf"

func (PoundsForceLoad) Title added in v1.0.5 

func (x PoundsForceLoad) Title() string

Title always returns "PoundsForce"

func (PoundsForceLoad) ToBase added in v1.0.5 

func (x PoundsForceLoad) ToBase(lbf float64) float64

ToBase converts lbf to N

func (PoundsForceLoad) TypeOf added in v1.0.5 

func (x PoundsForceLoad) TypeOf() UnitType

TypeOf always returns LoadUnitType

type PoundsForceMaxLoad added in v1.0.5 

type PoundsForceMaxLoad MaxLoad

PoundsForceMaxLoad (Unit) UnitType : MaxLoad UnitType.Base: NewtonsMaxLoad Unit.FromBase: N => N * 0.224,809 = lbf Unit.ToBase : lbf => lbf * 4.448,22 = N 

var PoundsForceMaxLoadUnit PoundsForceMaxLoad = 0.0

func (PoundsForceMaxLoad) Base added in v1.0.5 

func (x PoundsForceMaxLoad) Base() Unit

Base always returns NewtonsMaxLoadUnit

func (PoundsForceMaxLoad) FromBase added in v1.0.5 

func (x PoundsForceMaxLoad) FromBase(N float64) float64

FromBase converts N to lbf

func (PoundsForceMaxLoad) MatchList added in v1.0.5 

func (x PoundsForceMaxLoad) MatchList() []string

MatchList always returns PoundsForceMaxLoadMatchList[:]

func (PoundsForceMaxLoad) Matches added in v1.0.5 

func (x PoundsForceMaxLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsForceMaxLoad) Name added in v1.0.5 

func (x PoundsForceMaxLoad) Name() string

Name always returns "Pounds-force"

func (PoundsForceMaxLoad) Symbol added in v1.0.5 

func (x PoundsForceMaxLoad) Symbol() string

Symbol always returns "lbf"

func (PoundsForceMaxLoad) Title added in v1.0.5 

func (x PoundsForceMaxLoad) Title() string

Title always returns "PoundsForce"

func (PoundsForceMaxLoad) ToBase added in v1.0.5 

func (x PoundsForceMaxLoad) ToBase(lbf float64) float64

ToBase converts lbf to N

func (PoundsForceMaxLoad) TypeOf added in v1.0.5 

func (x PoundsForceMaxLoad) TypeOf() UnitType

TypeOf always returns MaxLoadUnitType

type PoundsForceMinLoad added in v1.0.5 

type PoundsForceMinLoad MinLoad

PoundsForceMinLoad (Unit) UnitType : MinLoad UnitType.Base: NewtonsMinLoad Unit.FromBase: N => N * 0.224,809 = lbf Unit.ToBase : lbf => lbf * 4.448,22 = N 

var PoundsForceMinLoadUnit PoundsForceMinLoad = 0.0

func (PoundsForceMinLoad) Base added in v1.0.5 

func (x PoundsForceMinLoad) Base() Unit

Base always returns NewtonsMinLoadUnit

func (PoundsForceMinLoad) FromBase added in v1.0.5 

func (x PoundsForceMinLoad) FromBase(N float64) float64

FromBase converts N to lbf

func (PoundsForceMinLoad) MatchList added in v1.0.5 

func (x PoundsForceMinLoad) MatchList() []string

MatchList always returns PoundsForceMinLoadMatchList[:]

func (PoundsForceMinLoad) Matches added in v1.0.5 

func (x PoundsForceMinLoad) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsForceMinLoad) Name added in v1.0.5 

func (x PoundsForceMinLoad) Name() string

Name always returns "Pounds-force"

func (PoundsForceMinLoad) Symbol added in v1.0.5 

func (x PoundsForceMinLoad) Symbol() string

Symbol always returns "lbf"

func (PoundsForceMinLoad) Title added in v1.0.5 

func (x PoundsForceMinLoad) Title() string

Title always returns "PoundsForce"

func (PoundsForceMinLoad) ToBase added in v1.0.5 

func (x PoundsForceMinLoad) ToBase(lbf float64) float64

ToBase converts lbf to N

func (PoundsForceMinLoad) TypeOf added in v1.0.5 

func (x PoundsForceMinLoad) TypeOf() UnitType

TypeOf always returns MinLoadUnitType

type PoundsMass 

type PoundsMass Mass

PoundsMass (Unit) UnitType : Mass UnitType.Base: KilogramsMass Unit.FromBase: kg => kg * 2.204,62 = lb Unit.ToBase : lb => lb * 0.453,592 = kg 

var PoundsMassUnit PoundsMass = 0.0

func (PoundsMass) Base 

func (x PoundsMass) Base() Unit

Base always returns KilogramsMassUnit

func (PoundsMass) FromBase 

func (x PoundsMass) FromBase(kg float64) float64

FromBase converts kg to lb

func (PoundsMass) MatchList 

func (x PoundsMass) MatchList() []string

MatchList always returns PoundsMassMatchList[:]

func (PoundsMass) Matches 

func (x PoundsMass) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsMass) Name 

func (x PoundsMass) Name() string

Name always returns "Pounds"

func (PoundsMass) Symbol 

func (x PoundsMass) Symbol() string

Symbol always returns "lb"

func (PoundsMass) Title 

func (x PoundsMass) Title() string

Title always returns "Pounds"

func (PoundsMass) ToBase 

func (x PoundsMass) ToBase(lb float64) float64

ToBase converts lb to kg

func (PoundsMass) TypeOf 

func (x PoundsMass) TypeOf() UnitType

TypeOf always returns MassUnitType

type PoundsPerMinuteMassFlow 

type PoundsPerMinuteMassFlow MassFlow

PoundsPerMinuteMassFlow (Unit) UnitType : MassFlow UnitType.Base: KilogramsPerSecondMassFlow Unit.FromBase: kgs => kgs * 132.277 = lb/min Unit.ToBase : lbmin => lbmin * 0.007,559,87 = kg/s 

var PoundsPerMinuteMassFlowUnit PoundsPerMinuteMassFlow = 0.0

func (PoundsPerMinuteMassFlow) Base 

func (x PoundsPerMinuteMassFlow) Base() Unit

Base always returns KilogramsPerSecondMassFlowUnit

func (PoundsPerMinuteMassFlow) FromBase 

func (x PoundsPerMinuteMassFlow) FromBase(kgs float64) float64

FromBase converts kg/s to lb/min

func (PoundsPerMinuteMassFlow) MatchList 

func (x PoundsPerMinuteMassFlow) MatchList() []string

MatchList always returns PoundsPerMinuteMassFlowMatchList[:]

func (PoundsPerMinuteMassFlow) Matches 

func (x PoundsPerMinuteMassFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsPerMinuteMassFlow) Name 

func (x PoundsPerMinuteMassFlow) Name() string

Name always returns "Pounds per Minute"

func (PoundsPerMinuteMassFlow) Symbol 

func (x PoundsPerMinuteMassFlow) Symbol() string

Symbol always returns "lb/min"

func (PoundsPerMinuteMassFlow) Title 

func (x PoundsPerMinuteMassFlow) Title() string

Title always returns "PoundsPerMinute"

func (PoundsPerMinuteMassFlow) ToBase 

func (x PoundsPerMinuteMassFlow) ToBase(lbmin float64) float64

ToBase converts lb/min to kg/s

func (PoundsPerMinuteMassFlow) TypeOf 

func (x PoundsPerMinuteMassFlow) TypeOf() UnitType

TypeOf always returns MassFlowUnitType

type PoundsPerSecondMassFlow 

type PoundsPerSecondMassFlow MassFlow

PoundsPerSecondMassFlow (Unit) UnitType : MassFlow UnitType.Base: KilogramsPerSecondMassFlow Unit.FromBase: kgs => kgs * 2.204,62 = lb/s Unit.ToBase : lbs => lbs * 0.453,592 = kg/s 

var PoundsPerSecondMassFlowUnit PoundsPerSecondMassFlow = 0.0

func (PoundsPerSecondMassFlow) Base 

func (x PoundsPerSecondMassFlow) Base() Unit

Base always returns KilogramsPerSecondMassFlowUnit

func (PoundsPerSecondMassFlow) FromBase 

func (x PoundsPerSecondMassFlow) FromBase(kgs float64) float64

FromBase converts kg/s to lb/s

func (PoundsPerSecondMassFlow) MatchList 

func (x PoundsPerSecondMassFlow) MatchList() []string

MatchList always returns PoundsPerSecondMassFlowMatchList[:]

func (PoundsPerSecondMassFlow) Matches 

func (x PoundsPerSecondMassFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsPerSecondMassFlow) Name 

func (x PoundsPerSecondMassFlow) Name() string

Name always returns "Pounds per Second"

func (PoundsPerSecondMassFlow) Symbol 

func (x PoundsPerSecondMassFlow) Symbol() string

Symbol always returns "lb/s"

func (PoundsPerSecondMassFlow) Title 

func (x PoundsPerSecondMassFlow) Title() string

Title always returns "PoundsPerSecond"

func (PoundsPerSecondMassFlow) ToBase 

func (x PoundsPerSecondMassFlow) ToBase(lbs float64) float64

ToBase converts lb/s to kg/s

func (PoundsPerSecondMassFlow) TypeOf 

func (x PoundsPerSecondMassFlow) TypeOf() UnitType

TypeOf always returns MassFlowUnitType

type PoundsPerSquareInchPressure 

type PoundsPerSquareInchPressure Pressure

PoundsPerSquareInchPressure (Unit) UnitType : Pressure UnitType.Base: PascalsPressure Unit.FromBase: Pa => Pa * 0.000,145,038 = psi Unit.ToBase : psi => psi * 6,894.76 = Pa 

var PoundsPerSquareInchPressureUnit PoundsPerSquareInchPressure = 0.0

func (PoundsPerSquareInchPressure) Base 

func (x PoundsPerSquareInchPressure) Base() Unit

Base always returns PascalsPressureUnit

func (PoundsPerSquareInchPressure) FromBase 

func (x PoundsPerSquareInchPressure) FromBase(Pa float64) float64

FromBase converts Pa to psi

func (PoundsPerSquareInchPressure) MatchList 

func (x PoundsPerSquareInchPressure) MatchList() []string

MatchList always returns PoundsPerSquareInchPressureMatchList[:]

func (PoundsPerSquareInchPressure) Matches 

func (x PoundsPerSquareInchPressure) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PoundsPerSquareInchPressure) Name 

func (x PoundsPerSquareInchPressure) Name() string

Name always returns "Pounds per Square Inch"

func (PoundsPerSquareInchPressure) Symbol 

func (x PoundsPerSquareInchPressure) Symbol() string

Symbol always returns "psi"

func (PoundsPerSquareInchPressure) Title 

func (x PoundsPerSquareInchPressure) Title() string

Title always returns "PoundsPerSquareInch"

func (PoundsPerSquareInchPressure) ToBase 

func (x PoundsPerSquareInchPressure) ToBase(psi float64) float64

ToBase converts psi to Pa

func (PoundsPerSquareInchPressure) TypeOf 

func (x PoundsPerSquareInchPressure) TypeOf() UnitType

TypeOf always returns PressureUnitType

type Pressure 

type Pressure float64

Pressure (UnitType) Contains 5 units:

  • PascalsPressure Pa => Pa = Pa
  • KilopascalsPressure Pa => Pa * 0.001 = kPa
  • MegapascalsPressure Pa => Pa * 0.000,001 = MPa
  • PoundsPerSquareInchPressure Pa => Pa * 0.000,145,038 = psi
  • InchesOfWaterPressure Pa => Pa * 0.004,014,74 = inH₂O

Base: PascalsPressure 

var PressureUnitType Pressure = 0.0

func (Pressure) Base 

func (x Pressure) Base() Unit

Base always returns PascalsPressureUnit

func (Pressure) MatchList 

func (x Pressure) MatchList() []string

MatchList always returns PressureMatchList[:]

func (Pressure) Matches 

func (x Pressure) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Pressure) Name 

func (x Pressure) Name() string

Name always returns "Pressure"

func (Pressure) Title 

func (x Pressure) Title() string

Title always returns "Pressure"

func (Pressure) UnitList 

func (x Pressure) UnitList() []string

UnitList always returns PressureUnitList[:]

func (Pressure) Units 

func (x Pressure) Units() []Unit

Units always returns PressureUnits[:]

type PumpFillage added in v1.0.5 

type PumpFillage float64

PumpFillage (UnitType) Contains 1 units:

  • PercentPumpFillage p => p = %

Base: PercentPumpFillage 

var PumpFillageUnitType PumpFillage = 0.0

func (PumpFillage) Base added in v1.0.5 

func (x PumpFillage) Base() Unit

Base always returns PercentPumpFillageUnit

func (PumpFillage) MatchList added in v1.0.5 

func (x PumpFillage) MatchList() []string

MatchList always returns PumpFillageMatchList[:]

func (PumpFillage) Matches added in v1.0.5 

func (x PumpFillage) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (PumpFillage) Name added in v1.0.5 

func (x PumpFillage) Name() string

Name always returns "Pump Fillage"

func (PumpFillage) Title added in v1.0.5 

func (x PumpFillage) Title() string

Title always returns "PumpFillage"

func (PumpFillage) UnitList added in v1.0.5 

func (x PumpFillage) UnitList() []string

UnitList always returns PumpFillageUnitList[:]

func (PumpFillage) Units added in v1.0.5 

func (x PumpFillage) Units() []Unit

Units always returns PumpFillageUnits[:]

type Stroke added in v1.0.5 

type Stroke float64

Stroke (UnitType) Contains 3 units:

  • MetersStroke m => m = m
  • FeetStroke m => m * 3.280,84 = ft
  • InchesStroke m => m * 39.370,1 = in

Base: MetersStroke 

var StrokeUnitType Stroke = 0.0

func (Stroke) Base added in v1.0.5 

func (x Stroke) Base() Unit

Base always returns MetersStrokeUnit

func (Stroke) MatchList added in v1.0.5 

func (x Stroke) MatchList() []string

MatchList always returns StrokeMatchList[:]

func (Stroke) Matches added in v1.0.5 

func (x Stroke) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Stroke) Name added in v1.0.5 

func (x Stroke) Name() string

Name always returns "Stroke"

func (Stroke) Title added in v1.0.5 

func (x Stroke) Title() string

Title always returns "Stroke"

func (Stroke) UnitList added in v1.0.5 

func (x Stroke) UnitList() []string

UnitList always returns StrokeUnitList[:]

func (Stroke) Units added in v1.0.5 

func (x Stroke) Units() []Unit

Units always returns StrokeUnits[:]

type StrokeRate 

type StrokeRate float64

StrokeRate (UnitType) Contains 1 units:

  • StrokesPerSecondStrokeRate ss => ss = strokes/s

Base: StrokesPerSecondStrokeRate 

var StrokeRateUnitType StrokeRate = 0.0

func (StrokeRate) Base 

func (x StrokeRate) Base() Unit

Base always returns StrokesPerSecondStrokeRateUnit

func (StrokeRate) MatchList 

func (x StrokeRate) MatchList() []string

MatchList always returns StrokeRateMatchList[:]

func (StrokeRate) Matches 

func (x StrokeRate) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (StrokeRate) Name 

func (x StrokeRate) Name() string

Name always returns "Stroke Rate"

func (StrokeRate) Title 

func (x StrokeRate) Title() string

Title always returns "StrokeRate"

func (StrokeRate) UnitList 

func (x StrokeRate) UnitList() []string

UnitList always returns StrokeRateUnitList[:]

func (StrokeRate) Units 

func (x StrokeRate) Units() []Unit

Units always returns StrokeRateUnits[:]

type StrokesPerSecondStrokeRate 

type StrokesPerSecondStrokeRate StrokeRate

StrokesPerSecondStrokeRate (Unit) UnitType : StrokeRate UnitType.Base: StrokesPerSecondStrokeRate Unit.FromBase: ss => ss = strokes/s Unit.ToBase : ss => ss = strokes/s 

var StrokesPerSecondStrokeRateUnit StrokesPerSecondStrokeRate = 0.0

func (StrokesPerSecondStrokeRate) Base 

func (x StrokesPerSecondStrokeRate) Base() Unit

Base always returns StrokesPerSecondStrokeRateUnit

func (StrokesPerSecondStrokeRate) FromBase 

func (x StrokesPerSecondStrokeRate) FromBase(ss float64) float64

FromBase converts strokes/s to strokes/s

func (StrokesPerSecondStrokeRate) MatchList 

func (x StrokesPerSecondStrokeRate) MatchList() []string

MatchList always returns StrokesPerSecondStrokeRateMatchList[:]

func (StrokesPerSecondStrokeRate) Matches 

func (x StrokesPerSecondStrokeRate) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (StrokesPerSecondStrokeRate) Name 

func (x StrokesPerSecondStrokeRate) Name() string

Name always returns "Strokes per Second"

func (StrokesPerSecondStrokeRate) Symbol 

func (x StrokesPerSecondStrokeRate) Symbol() string

Symbol always returns "strokes/s"

func (StrokesPerSecondStrokeRate) Title 

func (x StrokesPerSecondStrokeRate) Title() string

Title always returns "StrokesPerSecond"

func (StrokesPerSecondStrokeRate) ToBase 

func (x StrokesPerSecondStrokeRate) ToBase(ss float64) float64

ToBase converts strokes/s to strokes/s

func (StrokesPerSecondStrokeRate) TypeOf 

func (x StrokesPerSecondStrokeRate) TypeOf() UnitType

TypeOf always returns StrokeRateUnitType

type Temperature 

type Temperature float64

Temperature (UnitType) Contains 3 units:

  • DegreesCelsiusTemperature C => C = °C
  • DegreesFahrenheitTemperature C => (C * (9.0 / 5.0)) + 32.0 = °F
  • KelvinsTemperature C => C + 273.15 = K

Base: DegreesCelsiusTemperature 

var TemperatureUnitType Temperature = 0.0

func (Temperature) Base 

func (x Temperature) Base() Unit

Base always returns DegreesCelsiusTemperatureUnit

func (Temperature) MatchList 

func (x Temperature) MatchList() []string

MatchList always returns TemperatureMatchList[:]

func (Temperature) Matches 

func (x Temperature) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Temperature) Name 

func (x Temperature) Name() string

Name always returns "Temperature"

func (Temperature) Title 

func (x Temperature) Title() string

Title always returns "Temperature"

func (Temperature) UnitList 

func (x Temperature) UnitList() []string

UnitList always returns TemperatureUnitList[:]

func (Temperature) Units 

func (x Temperature) Units() []Unit

Units always returns TemperatureUnits[:]

type ThousandCubicFeetPerDayFlow 

type ThousandCubicFeetPerDayFlow Flow

ThousandCubicFeetPerDayFlow (Unit) UnitType : Flow UnitType.Base: CubicMetersPerSecondFlow Unit.FromBase: m3s => m3s * 3,051.19 = MCFD Unit.ToBase : MCFD => MCFD * 0.000,327,741 = m³/s 

var ThousandCubicFeetPerDayFlowUnit ThousandCubicFeetPerDayFlow = 0.0

func (ThousandCubicFeetPerDayFlow) Base 

func (x ThousandCubicFeetPerDayFlow) Base() Unit

Base always returns CubicMetersPerSecondFlowUnit

func (ThousandCubicFeetPerDayFlow) FromBase 

func (x ThousandCubicFeetPerDayFlow) FromBase(m3s float64) float64

FromBase converts m³/s to MCFD

func (ThousandCubicFeetPerDayFlow) MatchList 

func (x ThousandCubicFeetPerDayFlow) MatchList() []string

MatchList always returns ThousandCubicFeetPerDayFlowMatchList[:]

func (ThousandCubicFeetPerDayFlow) Matches 

func (x ThousandCubicFeetPerDayFlow) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (ThousandCubicFeetPerDayFlow) Name 

func (x ThousandCubicFeetPerDayFlow) Name() string

Name always returns "Thousand Cubic Feet per Day"

func (ThousandCubicFeetPerDayFlow) Symbol 

func (x ThousandCubicFeetPerDayFlow) Symbol() string

Symbol always returns "MCFD"

func (ThousandCubicFeetPerDayFlow) Title 

func (x ThousandCubicFeetPerDayFlow) Title() string

Title always returns "ThousandCubicFeetPerDay"

func (ThousandCubicFeetPerDayFlow) ToBase 

func (x ThousandCubicFeetPerDayFlow) ToBase(MCFD float64) float64

ToBase converts MCFD to m³/s

func (ThousandCubicFeetPerDayFlow) TypeOf 

func (x ThousandCubicFeetPerDayFlow) TypeOf() UnitType

TypeOf always returns FlowUnitType

type ThousandsOfCubicFeetVolume 

type ThousandsOfCubicFeetVolume Volume

ThousandsOfCubicFeetVolume (Unit) UnitType : Volume UnitType.Base: CubicMetersVolume Unit.FromBase: m3 => m3 * 0.035,314,7 = MCF Unit.ToBase : MCF => MCF * 28.316,8 = m³ 

var ThousandsOfCubicFeetVolumeUnit ThousandsOfCubicFeetVolume = 0.0

func (ThousandsOfCubicFeetVolume) Base 

func (x ThousandsOfCubicFeetVolume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (ThousandsOfCubicFeetVolume) FromBase 

func (x ThousandsOfCubicFeetVolume) FromBase(m3 float64) float64

FromBase converts m³ to MCF

func (ThousandsOfCubicFeetVolume) MatchList 

func (x ThousandsOfCubicFeetVolume) MatchList() []string

MatchList always returns ThousandsOfCubicFeetVolumeMatchList[:]

func (ThousandsOfCubicFeetVolume) Matches 

func (x ThousandsOfCubicFeetVolume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (ThousandsOfCubicFeetVolume) Name 

func (x ThousandsOfCubicFeetVolume) Name() string

Name always returns "Thousands of Cubic Feet"

func (ThousandsOfCubicFeetVolume) Symbol 

func (x ThousandsOfCubicFeetVolume) Symbol() string

Symbol always returns "MCF"

func (ThousandsOfCubicFeetVolume) Title 

func (x ThousandsOfCubicFeetVolume) Title() string

Title always returns "ThousandsOfCubicFeet"

func (ThousandsOfCubicFeetVolume) ToBase 

func (x ThousandsOfCubicFeetVolume) ToBase(MCF float64) float64

ToBase converts MCF to m³

func (ThousandsOfCubicFeetVolume) TypeOf 

func (x ThousandsOfCubicFeetVolume) TypeOf() UnitType

TypeOf always returns VolumeUnitType

type Totaliser 

type Totaliser float64

Totaliser (UnitType) Contains 1 units:

  • NumberTotaliser n => n =

Base: NumberTotaliser 

var TotaliserUnitType Totaliser = 0.0

func (Totaliser) Base 

func (x Totaliser) Base() Unit

Base always returns NumberTotaliserUnit

func (Totaliser) MatchList 

func (x Totaliser) MatchList() []string

MatchList always returns TotaliserMatchList[:]

func (Totaliser) Matches 

func (x Totaliser) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Totaliser) Name 

func (x Totaliser) Name() string

Name always returns "Totaliser"

func (Totaliser) Title 

func (x Totaliser) Title() string

Title always returns "Totaliser"

func (Totaliser) UnitList 

func (x Totaliser) UnitList() []string

UnitList always returns TotaliserUnitList[:]

func (Totaliser) Units 

func (x Totaliser) Units() []Unit

Units always returns TotaliserUnits[:]

type Underspeed 

type Underspeed float64

Underspeed (UnitType) Contains 1 units:

  • NumberUnderspeed n => n =

Base: NumberUnderspeed 

var UnderspeedUnitType Underspeed = 0.0

func (Underspeed) Base 

func (x Underspeed) Base() Unit

Base always returns NumberUnderspeedUnit

func (Underspeed) MatchList 

func (x Underspeed) MatchList() []string

MatchList always returns UnderspeedMatchList[:]

func (Underspeed) Matches 

func (x Underspeed) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Underspeed) Name 

func (x Underspeed) Name() string

Name always returns "Underspeed"

func (Underspeed) Title 

func (x Underspeed) Title() string

Title always returns "Underspeed"

func (Underspeed) UnitList 

func (x Underspeed) UnitList() []string

UnitList always returns UnderspeedUnitList[:]

func (Underspeed) Units 

func (x Underspeed) Units() []Unit

Units always returns UnderspeedUnits[:]

type Unit 

type Unit interface {
	// Title is used for code interfaces
	Title() string
	// Name is used for displays
	Name() string
	// Symbol is the symbol of the unit and can be displayed beside scalars
	Symbol() string
	// FromBase converts the given number of the unit type base to this unit
	FromBase(float64) float64
	// ToBase converts the given number of this unit type to the base unit
	ToBase(float64) float64
	// MatchList is a list of matching strings which should represent this unit in userland
	MatchList() []string
	// Matches compares a string to a switch of all possible matches
	Matches(string) bool
	// TypeOf returns the UnitType of this unit. You can access the BaseUnit from there
	TypeOf() UnitType
	// Base returns the base Unit of this UnitType directly
	Base() Unit
}

Unit represents a scalar type of unit which can be converted to and from a base

func GetUnit 

func GetUnit(input string, typeOf UnitType) Unit

GetUnit returns the unit which matches input or NumberNumberUnit

type UnitType 

type UnitType interface {
	// Title is used for code interfaces
	Title() string
	// Name is used for displays
	Name() string
	// Base returns the primary unit of this unit type that is stored in Alaka.
	// Most of the time this is an SI unit, but not always (temperature is C,
	// not K, for example)
	Base() Unit
	// Units returns all the supported units of this unit type
	Units() []Unit
	// UnitList returns all the supported units of this unit type as strings
	UnitList() []string
	// MatchList is a list of matching strings which should represent this unit type in userland
	MatchList() []string
	// Matches compares a string to a switch of all possible matches
	Matches(string) bool
}

UnitType represents a collection of related units

func GetType 

func GetType(input string) UnitType

GetType returns the unit type which matches input or NumberUnitType

type VoltsElectricPotential 

type VoltsElectricPotential ElectricPotential

VoltsElectricPotential (Unit) UnitType : ElectricPotential UnitType.Base: VoltsElectricPotential Unit.FromBase: V => V = V Unit.ToBase : V => V = V 

var VoltsElectricPotentialUnit VoltsElectricPotential = 0.0

func (VoltsElectricPotential) Base 

func (x VoltsElectricPotential) Base() Unit

Base always returns VoltsElectricPotentialUnit

func (VoltsElectricPotential) FromBase 

func (x VoltsElectricPotential) FromBase(V float64) float64

FromBase converts V to V

func (VoltsElectricPotential) MatchList 

func (x VoltsElectricPotential) MatchList() []string

MatchList always returns VoltsElectricPotentialMatchList[:]

func (VoltsElectricPotential) Matches 

func (x VoltsElectricPotential) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (VoltsElectricPotential) Name 

func (x VoltsElectricPotential) Name() string

Name always returns "Volts"

func (VoltsElectricPotential) Symbol 

func (x VoltsElectricPotential) Symbol() string

Symbol always returns "V"

func (VoltsElectricPotential) Title 

func (x VoltsElectricPotential) Title() string

Title always returns "Volts"

func (VoltsElectricPotential) ToBase 

func (x VoltsElectricPotential) ToBase(V float64) float64

ToBase converts V to V

func (VoltsElectricPotential) TypeOf 

func (x VoltsElectricPotential) TypeOf() UnitType

TypeOf always returns ElectricPotentialUnitType

type VoltsElectricPotentialLoaded 

type VoltsElectricPotentialLoaded ElectricPotentialLoaded

VoltsElectricPotentialLoaded (Unit) UnitType : ElectricPotentialLoaded UnitType.Base: VoltsElectricPotentialLoaded Unit.FromBase: V => V = V Unit.ToBase : V => V = V 

var VoltsElectricPotentialLoadedUnit VoltsElectricPotentialLoaded = 0.0

func (VoltsElectricPotentialLoaded) Base 

func (x VoltsElectricPotentialLoaded) Base() Unit

Base always returns VoltsElectricPotentialLoadedUnit

func (VoltsElectricPotentialLoaded) FromBase 

func (x VoltsElectricPotentialLoaded) FromBase(V float64) float64

FromBase converts V to V

func (VoltsElectricPotentialLoaded) MatchList 

func (x VoltsElectricPotentialLoaded) MatchList() []string

MatchList always returns VoltsElectricPotentialLoadedMatchList[:]

func (VoltsElectricPotentialLoaded) Matches 

func (x VoltsElectricPotentialLoaded) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (VoltsElectricPotentialLoaded) Name 

func (x VoltsElectricPotentialLoaded) Name() string

Name always returns "Volts"

func (VoltsElectricPotentialLoaded) Symbol 

func (x VoltsElectricPotentialLoaded) Symbol() string

Symbol always returns "V"

func (VoltsElectricPotentialLoaded) Title 

func (x VoltsElectricPotentialLoaded) Title() string

Title always returns "Volts"

func (VoltsElectricPotentialLoaded) ToBase 

func (x VoltsElectricPotentialLoaded) ToBase(V float64) float64

ToBase converts V to V

func (VoltsElectricPotentialLoaded) TypeOf 

func (x VoltsElectricPotentialLoaded) TypeOf() UnitType

TypeOf always returns ElectricPotentialLoadedUnitType

type VoltsElectricPotentialUnloaded 

type VoltsElectricPotentialUnloaded ElectricPotentialUnloaded

VoltsElectricPotentialUnloaded (Unit) UnitType : ElectricPotentialUnloaded UnitType.Base: VoltsElectricPotentialUnloaded Unit.FromBase: V => V = V Unit.ToBase : V => V = V 

var VoltsElectricPotentialUnloadedUnit VoltsElectricPotentialUnloaded = 0.0

func (VoltsElectricPotentialUnloaded) Base 

func (x VoltsElectricPotentialUnloaded) Base() Unit

Base always returns VoltsElectricPotentialUnloadedUnit

func (VoltsElectricPotentialUnloaded) FromBase 

func (x VoltsElectricPotentialUnloaded) FromBase(V float64) float64

FromBase converts V to V

func (VoltsElectricPotentialUnloaded) MatchList 

func (x VoltsElectricPotentialUnloaded) MatchList() []string

MatchList always returns VoltsElectricPotentialUnloadedMatchList[:]

func (VoltsElectricPotentialUnloaded) Matches 

func (x VoltsElectricPotentialUnloaded) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (VoltsElectricPotentialUnloaded) Name 

func (x VoltsElectricPotentialUnloaded) Name() string

Name always returns "Volts"

func (VoltsElectricPotentialUnloaded) Symbol 

func (x VoltsElectricPotentialUnloaded) Symbol() string

Symbol always returns "V"

func (VoltsElectricPotentialUnloaded) Title 

func (x VoltsElectricPotentialUnloaded) Title() string

Title always returns "Volts"

func (VoltsElectricPotentialUnloaded) ToBase 

func (x VoltsElectricPotentialUnloaded) ToBase(V float64) float64

ToBase converts V to V

func (VoltsElectricPotentialUnloaded) TypeOf 

func (x VoltsElectricPotentialUnloaded) TypeOf() UnitType

TypeOf always returns ElectricPotentialUnloadedUnitType

type Volume 

type Volume float64

Volume (UnitType) Contains 7 units:

  • CubicMetersVolume m3 => m3 = m³
  • CubicFeetVolume m3 => m3 * 35.314,7 = cu ft
  • ThousandsOfCubicFeetVolume m3 => m3 * 0.035,314,7 = MCF
  • CubicDecimeterVolume m3 => m3 * 1,000 = dm³
  • LiterVolume m3 => m3 * 1,000 = L
  • GallonUSFluidVolume m3 => m3 * 264.172 = gal (US)
  • BarrelsOfOilVolume m3 => m3 * 6.289,81 = bbl

Base: CubicMetersVolume 

var VolumeUnitType Volume = 0.0

func (Volume) Base 

func (x Volume) Base() Unit

Base always returns CubicMetersVolumeUnit

func (Volume) MatchList 

func (x Volume) MatchList() []string

MatchList always returns VolumeMatchList[:]

func (Volume) Matches 

func (x Volume) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Volume) Name 

func (x Volume) Name() string

Name always returns "Volume"

func (Volume) Title 

func (x Volume) Title() string

Title always returns "Volume"

func (Volume) UnitList 

func (x Volume) UnitList() []string

UnitList always returns VolumeUnitList[:]

func (Volume) Units 

func (x Volume) Units() []Unit

Units always returns VolumeUnits[:]

type WMLFlowRate 

type WMLFlowRate float64

WMLFlowRate (UnitType) Contains 1 units:

  • NumberWMLFlowRate n => n =

Base: NumberWMLFlowRate 

var WMLFlowRateUnitType WMLFlowRate = 0.0

func (WMLFlowRate) Base 

func (x WMLFlowRate) Base() Unit

Base always returns NumberWMLFlowRateUnit

func (WMLFlowRate) MatchList 

func (x WMLFlowRate) MatchList() []string

MatchList always returns WMLFlowRateMatchList[:]

func (WMLFlowRate) Matches 

func (x WMLFlowRate) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (WMLFlowRate) Name 

func (x WMLFlowRate) Name() string

Name always returns "WML Flow Rate"

func (WMLFlowRate) Title 

func (x WMLFlowRate) Title() string

Title always returns "WMLFlowRate"

func (WMLFlowRate) UnitList 

func (x WMLFlowRate) UnitList() []string

UnitList always returns WMLFlowRateUnitList[:]

func (WMLFlowRate) Units 

func (x WMLFlowRate) Units() []Unit

Units always returns WMLFlowRateUnits[:]

type Work 

type Work float64

Work (UnitType) Contains 4 units:

  • JoulesWork J => J = J
  • InchPoundsForceWork J => J * 8.850,74 = in lbf
  • CubicFeetOfNaturalGasWork J => J * 0.000,000,947,817 = BTUᵢₜ
  • BarrelsOfOilEquivalentWork J => J * 0.000,000,000,163,399 = bboe

Base: JoulesWork 

var WorkUnitType Work = 0.0

func (Work) Base 

func (x Work) Base() Unit

Base always returns JoulesWorkUnit

func (Work) MatchList 

func (x Work) MatchList() []string

MatchList always returns WorkMatchList[:]

func (Work) Matches 

func (x Work) Matches(check string) bool

Matches returns true if check matches our possible names. Helpful when a user is allowed to enter in unit types freehand, for example.

func (Work) Name 

func (x Work) Name() string

Name always returns "Work"

func (Work) Title 

func (x Work) Title() string

Title always returns "Work"

func (Work) UnitList 

func (x Work) UnitList() []string

UnitList always returns WorkUnitList[:]

func (Work) Units 

func (x Work) Units() []Unit

Units always returns WorkUnits[:]

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.