units

package module
v1.1.1 Latest Latest
Warning

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

 Go to latest Published: Mar 30, 2022 License: MIT Imports: 9 Imported by: 0

README

godocs.io

go-units

Go library for manipulating and converting between various units of measurement.

Fork

This fork is used to customize the great library bcicen/go-units more according to our needs. We have therefore planned, but not definitely, not to merge the fork back into the base, but rather to maintain an abstraction of it here.

Disclaimer

We, Capstone Labs LLC, do not guarantee functionality of the library, nor correctness of the results. The authors of this library cannot be held responsible for any errors and malfunctions of this library.

See license for more.

Usage

For a full usage documentation of the original library please look here.

Documentation

Overview

Package units is a library for manipulating and converting between various units of measurement

Index

Constants

This section is empty.

Variables

View Source 
var (
	Area = UnitOptionQuantity("area")

	SquareMeter      = NewUnit("square meter", "m2", Area, SI)
	SquareExaMeter   = Exa(SquareMeter, FactorSquare)
	SquarePetaMeter  = Peta(SquareMeter, FactorSquare)
	SquareTeraMeter  = Tera(SquareMeter, FactorSquare)
	SquareGigaMeter  = Giga(SquareMeter, FactorSquare)
	SquareMegaMeter  = Mega(SquareMeter, FactorSquare)
	SquareKiloMeter  = Kilo(SquareMeter, FactorSquare)
	SquareHectoMeter = Hecto(SquareMeter, FactorSquare)
	SquareDecaMeter  = Deca(SquareMeter, FactorSquare)
	SquareDeciMeter  = Deci(SquareMeter, FactorSquare)
	SquareCentiMeter = Centi(SquareMeter, FactorSquare)
	SquareMilliMeter = Milli(SquareMeter, FactorSquare)
	SquareMicroMeter = Micro(SquareMeter, FactorSquare)
	SquareNanoMeter  = Nano(SquareMeter, FactorSquare)
	SquarePicoMeter  = Pico(SquareMeter, FactorSquare)
	SquareFemtoMeter = Femto(SquareMeter, FactorSquare)
	SquareAttoMeter  = Atto(SquareMeter, FactorSquare)

	SquareInch = NewUnit("square inch", "in2", Area, BI)
	SquareFoot = NewUnit("square foot", "ft2", Area, BI)
	SquareYard = NewUnit("square yard", "yd2", Area, BI)
)
View Source 
var (
	Bi   = UnitOptionQuantity("bits")
	Data = UnitOptionQuantity("bytes")

	Byte      = NewUnit("byte", "B", Data)
	KiloByte  = NewUnit("kilobyte", "KB", Data)
	MegaByte  = NewUnit("megabyte", "MB", Data)
	GigaByte  = NewUnit("gigabyte", "GB", Data)
	TeraByte  = NewUnit("terabyte", "TB", Data)
	PetaByte  = NewUnit("petabyte", "PB", Data)
	ExaByte   = NewUnit("exabyte", "", Data)
	ZettaByte = NewUnit("zettabyte", "", Data)
	YottaByte = NewUnit("yottabyte", "", Data)

	Kibibyte = NewUnit("kibibyte", "KiB", Data, IEC)
	Mebibyte = NewUnit("mebibyte", "MiB", Data, IEC)
	Gibibyte = NewUnit("gibibyte", "GiB", Data, IEC)
	Tebibyte = NewUnit("tebibyte", "TiB", Data, IEC)
	Pebibyte = NewUnit("pebibyte", "PiB", Data, IEC)
	Exbibyte = NewUnit("exbibyte", "EiB", Data, IEC)
	Zebibyte = NewUnit("zebibyte", "ZiB", Data, IEC)
	Yobibyte = NewUnit("yobibyte", "YiB", Data, IEC)

	Bit     = NewUnit("bit", "b", Bi)
	KiloBit = Kilo(Bit, FactorLinear)
	MegaBit = Mega(Bit, FactorLinear)
	GigaBit = Giga(Bit, FactorLinear)
	TeraBit = Tera(Bit, FactorLinear)
	PetaBit = Peta(Bit, FactorLinear)
	ExaBit  = Exa(Bit, FactorLinear)

	Nibble = NewUnit("nibble", "", Data)
)
View Source 
var (
	ElectricCurrent = UnitOptionQuantity("e-current")

	Ampere      = NewUnit("ampere", "A", ElectricCurrent)
	ExaAmpere   = Exa(Ampere, FactorLinear)
	PetaAmpere  = Peta(Ampere, FactorLinear)
	TeraAmpere  = Tera(Ampere, FactorLinear)
	GigaAmpere  = Giga(Ampere, FactorLinear)
	MegaAmpere  = Mega(Ampere, FactorLinear)
	KiloAmpere  = Kilo(Ampere, FactorLinear)
	HectoAmpere = Hecto(Ampere, FactorLinear)
	DecaAmpere  = Deca(Ampere, FactorLinear)
	DeciAmpere  = Deci(Ampere, FactorLinear)
	CentiAmpere = Centi(Ampere, FactorLinear)
	MilliAmpere = Milli(Ampere, FactorLinear)
	MicroAmpere = Micro(Ampere, FactorLinear)
	NanoAmpere  = Nano(Ampere, FactorLinear)
	PicoAmpere  = Pico(Ampere, FactorLinear)
	FemtoAmpere = Femto(Ampere, FactorLinear)
	AttoAmpere  = Atto(Ampere, FactorLinear)
)
View Source 
var (
	ElectricPotential = UnitOptionQuantity("e-potential")

	Volt      = NewUnit("volt", "V", ElectricPotential)
	ExaVolt   = Exa(Volt, FactorLinear)
	PetaVolt  = Peta(Volt, FactorLinear)
	TeraVolt  = Tera(Volt, FactorLinear)
	GigaVolt  = Giga(Volt, FactorLinear)
	MegaVolt  = Mega(Volt, FactorLinear)
	KiloVolt  = Kilo(Volt, FactorLinear)
	HectoVolt = Hecto(Volt, FactorLinear)
	DecaVolt  = Deca(Volt, FactorLinear)
	DeciVolt  = Deci(Volt, FactorLinear)
	CentiVolt = Centi(Volt, FactorLinear)
	MilliVolt = Milli(Volt, FactorLinear)
	MicroVolt = Micro(Volt, FactorLinear)
	NanoVolt  = Nano(Volt, FactorLinear)
	PicoVolt  = Pico(Volt, FactorLinear)
	FemtoVolt = Femto(Volt, FactorLinear)
	AttoVolt  = Atto(Volt, FactorLinear)
)
View Source 
var (
	ElectricPower = UnitOptionQuantity("e-power")

	Watt      = NewUnit("watt", "W", ElectricPower)
	ExaWatt   = Exa(Watt, FactorLinear)
	PetaWatt  = Peta(Watt, FactorLinear)
	TeraWatt  = Tera(Watt, FactorLinear)
	GigaWatt  = Giga(Watt, FactorLinear)
	MegaWatt  = Mega(Watt, FactorLinear)
	KiloWatt  = Kilo(Watt, FactorLinear)
	HectoWatt = Hecto(Watt, FactorLinear)
	DecaWatt  = Deca(Watt, FactorLinear)
	DeciWatt  = Deci(Watt, FactorLinear)
	CentiWatt = Centi(Watt, FactorLinear)
	MilliWatt = Milli(Watt, FactorLinear)
	MicroWatt = Micro(Watt, FactorLinear)
	NanoWatt  = Nano(Watt, FactorLinear)
	PicoWatt  = Pico(Watt, FactorLinear)
	FemtoWatt = Femto(Watt, FactorLinear)
	AttoWatt  = Atto(Watt, FactorLinear)
)
View Source 
var (
	Frequency = UnitOptionQuantity("frequency")

	Hertz      = NewUnit("hertz", "Hz", Frequency)
	ExaHertz   = Exa(Hertz, FactorLinear)
	PetaHertz  = Peta(Hertz, FactorLinear)
	TeraHertz  = Tera(Hertz, FactorLinear)
	GigaHertz  = Giga(Hertz, FactorLinear)
	MegaHertz  = Mega(Hertz, FactorLinear)
	KiloHertz  = Kilo(Hertz, FactorLinear)
	HectoHertz = Hecto(Hertz, FactorLinear)
	DecaHertz  = Deca(Hertz, FactorLinear)
	DeciHertz  = Deci(Hertz, FactorLinear)
	CentiHertz = Centi(Hertz, FactorLinear)
	MilliHertz = Milli(Hertz, FactorLinear)
	MicroHertz = Micro(Hertz, FactorLinear)
	NanoHertz  = Nano(Hertz, FactorLinear)
	PicoHertz  = Pico(Hertz, FactorLinear)
	FemtoHertz = Femto(Hertz, FactorLinear)
	AttoHertz  = Atto(Hertz, FactorLinear)
)
View Source 
var (
	Length = UnitOptionQuantity("length")

	Meter      = NewUnit("meter", "m", Length, SI, UnitOptionAliases("metre"))
	ExaMeter   = Exa(Meter, FactorLinear)
	PetaMeter  = Peta(Meter, FactorLinear)
	TeraMeter  = Tera(Meter, FactorLinear)
	GigaMeter  = Giga(Meter, FactorLinear)
	MegaMeter  = Mega(Meter, FactorLinear)
	KiloMeter  = Kilo(Meter, FactorLinear)
	HectoMeter = Hecto(Meter, FactorLinear)
	DecaMeter  = Deca(Meter, FactorLinear)
	DeciMeter  = Deci(Meter, FactorLinear)
	CentiMeter = Centi(Meter, FactorLinear)
	MilliMeter = Milli(Meter, FactorLinear)
	MicroMeter = Micro(Meter, FactorLinear)
	NanoMeter  = Nano(Meter, FactorLinear)
	PicoMeter  = Pico(Meter, FactorLinear)
	FemtoMeter = Femto(Meter, FactorLinear)
	AttoMeter  = Atto(Meter, FactorLinear)

	Angstrom = NewUnit("angstrom", "Å", Length, BI, UnitOptionPlural("angstroms"))
	Inch     = NewUnit("inch", "in", Length, BI, UnitOptionPlural("inches"))
	Foot     = NewUnit("foot", "ft", Length, BI, UnitOptionPlural("feet"))
	Yard     = NewUnit("yard", "yd", Length, BI)
	Mile     = NewUnit("mile", "mi", Length, BI)
	League   = NewUnit("league", "lea", Length, BI)
	Furlong  = NewUnit("furlong", "fur", Length, BI)
)
View Source 
var (
	Mass = UnitOptionQuantity("mass")

	Gram      = NewUnit("gram", "g", Mass)
	ExaGram   = Exa(Gram, FactorLinear)
	PetaGram  = Peta(Gram, FactorLinear)
	TeraGram  = Tera(Gram, FactorLinear)
	GigaGram  = Giga(Gram, FactorLinear)
	MegaGram  = Mega(Gram, FactorLinear)
	KiloGram  = Kilo(Gram, FactorLinear)
	HectoGram = Hecto(Gram, FactorLinear)
	DecaGram  = Deca(Gram, FactorLinear)
	DeciGram  = Deci(Gram, FactorLinear)
	CentiGram = Centi(Gram, FactorLinear)
	MilliGram = Milli(Gram, FactorLinear)
	MicroGram = Micro(Gram, FactorLinear)
	NanoGram  = Nano(Gram, FactorLinear)
	PicoGram  = Pico(Gram, FactorLinear)
	FemtoGram = Femto(Gram, FactorLinear)
	AttoGram  = Atto(Gram, FactorLinear)

	MetricTon = NewUnit("metric ton", "t", Mass, SI)

	Grain  = NewUnit("grain", "gr", Mass, BI)
	Drachm = NewUnit("drachm", "dr", Mass, BI)
	Ounce  = NewUnit("ounce", "oz", Mass, BI)
	Pound  = NewUnit("pound", "lb", Mass, BI)
	Stone  = NewUnit("stone", "st", Mass, BI)
	Ton    = NewUnit("ton", "t", Mass, BI)
	Slug   = NewUnit("slug", "", Mass, BI)
)
View Source 
var (
	Pressure = UnitOptionQuantity("pressure")

	// SI unit metric
	Pascal      = NewUnit("pascal", "Pa", Pressure, SI)
	ExaPascal   = Exa(Pascal, FactorLinear)
	PetaPascal  = Peta(Pascal, FactorLinear)
	TeraPascal  = Tera(Pascal, FactorLinear)
	GigaPascal  = Giga(Pascal, FactorLinear)
	MegaPascal  = Mega(Pascal, FactorLinear)
	KiloPascal  = Kilo(Pascal, FactorLinear)
	HectoPascal = Hecto(Pascal, FactorLinear)
	DecaPascal  = Deca(Pascal, FactorLinear)
	DeciPascal  = Deci(Pascal, FactorLinear)
	CentiPascal = Centi(Pascal, FactorLinear)
	MilliPascal = Milli(Pascal, FactorLinear)
	MicroPascal = Micro(Pascal, FactorLinear)
	NanoPascal  = Nano(Pascal, FactorLinear)
	PicoPascal  = Pico(Pascal, FactorLinear)
	FemtoPascal = Femto(Pascal, FactorLinear)
	AttoPascal  = Atto(Pascal, FactorLinear)

	// Other
	At       = NewUnit("technical atmosphere", "at", Pressure, BI, UnitOptionPlural("technical atmospheres"))
	Atm      = NewUnit("standard atmosphere", "atm", Pressure, BI, UnitOptionPlural("standard atmospheres"))
	Bar      = NewUnit("bar", "bar", Pressure, BI, UnitOptionPlural("bars"))
	CentiBar = Centi(Bar, FactorLinear)
	MilliBar = Milli(Bar, FactorLinear)
	MicroBar = Micro(Bar, FactorLinear)
	Barye    = NewUnit("barye", "Ba", Pressure, BI, UnitOptionPlural("baryes"))
	InH2O    = NewUnit("inch of Water Column", "inH2O", Pressure, BI)
	InHg     = NewUnit("inch of Mercury", "inHg", Pressure, BI)
	MH2O     = NewUnit("meter of Water Column", "mmH2O", Pressure, BI, UnitOptionPlural("meters of Water Column"))
	MmH2O    = Milli(MH2O, FactorLinear)
	CmH2O    = Centi(MH2O, FactorLinear)
	MHg      = NewUnit("meter of Mercury", "mmHg", Pressure, BI, UnitOptionPlural("meters of Mercury"))
	MmHg     = Milli(MHg, FactorLinear)
	CmHg     = Centi(MHg, FactorLinear)
	Newton   = NewUnit("newton per square meter", "N/m²", Pressure, BI)
	Psi      = NewUnit("pound-force per square inch", "psi", Pressure, BI)
	Torr     = NewUnit("torr", "Torr", Pressure, BI)
)
View Source 
var (
	Speed = UnitOptionQuantity("speed")

	MetersPerSecond   = NewUnit("meters per second", "m/s", Speed)
	KilometersPerHour = NewUnit("kilo meters per hour", "kph", Speed)
	FeetPerSecond     = NewUnit("feet per second", "ft/s", Speed)
	MilesPerHour      = NewUnit("miles per hour", "mph", Speed)
	Knot              = NewUnit("knot", "kt", Speed)
)
View Source 
var (
	Temp = UnitOptionQuantity("temperature")

	Celsius    = NewUnit("celsius", "C", Temp, UnitOptionPlural("none"), SI)
	Fahrenheit = NewUnit("fahrenheit", "F", Temp, UnitOptionPlural("none"), US)
	Kelvin     = NewUnit("kelvin", "K", Temp, UnitOptionPlural("none"), SI)
)
View Source 
var (
	Time = UnitOptionQuantity("time")

	Second      = NewUnit("second", "s", Time)
	ExaSecond   = Exa(Second, FactorLinear)
	PetaSecond  = Peta(Second, FactorLinear)
	TeraSecond  = Tera(Second, FactorLinear)
	GigaSecond  = Giga(Second, FactorLinear)
	MegaSecond  = Mega(Second, FactorLinear)
	KiloSecond  = Kilo(Second, FactorLinear)
	HectoSecond = Hecto(Second, FactorLinear)
	DecaSecond  = Deca(Second, FactorLinear)
	DeciSecond  = Deci(Second, FactorLinear)
	CentiSecond = Centi(Second, FactorLinear)
	MilliSecond = Milli(Second, FactorLinear)
	MicroSecond = Micro(Second, FactorLinear)
	NanoSecond  = Nano(Second, FactorLinear)
	PicoSecond  = Pico(Second, FactorLinear)
	FemtoSecond = Femto(Second, FactorLinear)
	AttoSecond  = Atto(Second, FactorLinear)

	Minute = NewUnit("minute", "min", Time)
	Hour   = NewUnit("hour", "hr", Time)
	Day    = NewUnit("day", "d", Time)
	Month  = NewUnit("month", "", Time)
	Year   = NewUnit("year", "yr", Time)

	Decade     = NewUnit("decade", "", Time)
	Century    = NewUnit("century", "", Time)
	Millennium = NewUnit("millennium", "", Time)

	// more esoteric time units
	PlanckTime = NewUnit("planck time", "𝑡ₚ", Time)
	Fortnight  = NewUnit("fortnight", "", Time)
	Score      = NewUnit("score", "", Time)
)
View Source 
var (
	// Shorthand for pre-defined unit systems
	BI  = UnitOptionSystem("imperial")
	SI  = UnitOptionSystem("metric")
	US  = UnitOptionSystem("us")
	IEC = UnitOptionPlural("iec")
)
View Source 
var (
	Volume = UnitOptionQuantity("volume")

	Liter      = NewUnit("liter", "l", Volume, SI, UnitOptionAliases("litre"))
	ExaLiter   = Exa(Liter, FactorLinear)
	PetaLiter  = Peta(Liter, FactorLinear)
	TeraLiter  = Tera(Liter, FactorLinear)
	GigaLiter  = Giga(Liter, FactorLinear)
	MegaLiter  = Mega(Liter, FactorLinear)
	KiloLiter  = Kilo(Liter, FactorLinear)
	HectoLiter = Hecto(Liter, FactorLinear)
	DecaLiter  = Deca(Liter, FactorLinear)
	DeciLiter  = Deci(Liter, FactorLinear)
	CentiLiter = Centi(Liter, FactorLinear)
	MilliLiter = Milli(Liter, FactorLinear)
	MicroLiter = Micro(Liter, FactorLinear)
	NanoLiter  = Nano(Liter, FactorLinear)
	PicoLiter  = Pico(Liter, FactorLinear)
	FemtoLiter = Femto(Liter, FactorLinear)
	AttoLiter  = Atto(Liter, FactorLinear)

	CubicMeter      = NewUnit("cubic meter", "m3", Volume, SI)
	CubicExaMeter   = Exa(CubicMeter, FactorCubic)
	CubicPetaMeter  = Peta(CubicMeter, FactorCubic)
	CubicTeraMeter  = Tera(CubicMeter, FactorCubic)
	CubicGigaMeter  = Giga(CubicMeter, FactorCubic)
	CubicMegaMeter  = Mega(CubicMeter, FactorCubic)
	CubicKiloMeter  = Kilo(CubicMeter, FactorCubic)
	CubicHectoMeter = Hecto(CubicMeter, FactorCubic)
	CubicDecaMeter  = Deca(CubicMeter, FactorCubic)
	CubicDeciMeter  = Deci(CubicMeter, FactorCubic)
	CubicCentiMeter = Centi(CubicMeter, FactorCubic)
	CubicMilliMeter = Milli(CubicMeter, FactorCubic)
	CubicMicroMeter = Micro(CubicMeter, FactorCubic)
	CubicNanoMeter  = Nano(CubicMeter, FactorCubic)
	CubicPicoMeter  = Pico(CubicMeter, FactorCubic)
	CubicFemtoMeter = Femto(CubicMeter, FactorCubic)
	CubicAttoMeter  = Atto(CubicMeter, FactorCubic)

	Quart      = NewUnit("quart", "qt", Volume, BI)
	Pint       = NewUnit("pint", "pt", Volume, BI)
	Gallon     = NewUnit("gallon", "gal", Volume, BI)
	FluidOunce = NewUnit("fluid ounce", "fl oz", Volume, BI, UnitOptionAliases("floz"))

	CubicInch = NewUnit("cubic inch", "in3", Volume, BI)
	CubicFoot = NewUnit("cubic foot", "ft3", Volume, BI)
	CubicYard = NewUnit("cubic yard", "yd3", Volume, BI)

	FluidQuart          = NewUnit("fluid quart", "", Volume, US)
	FluidPint           = NewUnit("fluid pint", "", Volume, US)
	FluidGallon         = NewUnit("fluid gallon", "", Volume, US)
	CustomaryFluidOunce = NewUnit("customary fluid ounce", "", Volume, US)
	Barrel              = NewUnit("barrel", "bbl", Volume, US)
)
View Source 
var DefaultFmtOptions = FmtOptions{true, false, 6}

Functions

func NewConversion 

func NewConversion(from, to Unit, formula string)

NewConversion registers a new conversion formula from one Unit to another

func NewConversionFromFn 

func NewConversionFromFn(from, to Unit, f ConversionFn, formula string)

NewConversion registers a new conversion formula from one Unit to another

func NewRatioConversion 

func NewRatioConversion(from, to Unit, ratio float64)

Register a conversion formula and the inverse, given a ratio of from Unit in to Unit

Types

type Conversion 

type Conversion struct {
	Fn      ConversionFn
	Formula string
	// contains filtered or unexported fields
}

func ResolveConversion 

func ResolveConversion(from, to Unit) (cpath []Conversion, err error)

ResolveConversion resolves a path of one or more Conversions between two units

func (Conversion) From 

func (c Conversion) From() string

func (Conversion) String 

func (c Conversion) String() string

String representation of conversion formula

func (Conversion) To 

func (c Conversion) To() string

Conversion implements bfstree.Edge interface

type ConversionFn 

type ConversionFn func(float64) float64

type FmtOptions 

type FmtOptions struct {
	Label     bool // if false, unit label/symbol will be omitted
	Short     bool // if true, use unit shortname or symbol
	Precision int  // maximum meaningful precision to truncate value
}

type MagnitudeFactor 

type MagnitudeFactor = float64
const (
	FactorLinear MagnitudeFactor = iota + 1.0
	FactorSquare
	FactorCubic
)

type Unit 

type Unit struct {
	Name     string
	Symbol   string
	Quantity string
	// contains filtered or unexported fields
}

func All 

func All() []Unit

Return all registered Units, sorted by name and quantity

func Atto 

func Atto(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Centi 

func Centi(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Deca 

func Deca(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Deci 

func Deci(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Exa 

func Exa(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Femto 

func Femto(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Find 

func Find(s string) (Unit, error)

Find Unit matching name or symbol provided

func Giga 

func Giga(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Hecto 

func Hecto(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Kilo 

func Kilo(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Mega 

func Mega(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Micro 

func Micro(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Milli 

func Milli(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Nano 

func Nano(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func NewUnit 

func NewUnit(name, symbol string, opts ...UnitOption) Unit

NewUnit registers a new Unit within the package, returning the newly created Unit

func Peta 

func Peta(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Pico 

func Pico(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func Tera 

func Tera(base Unit, factor MagnitudeFactor, opts ...UnitOption) Unit

func (Unit) Names 

func (u Unit) Names() []string

Returns all names and symbols this unit may be referred to

func (Unit) PluralName 

func (u Unit) PluralName() string

Return the plural name for this unit

func (Unit) System 

func (u Unit) System() string

Return the system of units this Unit belongs to, if any

type UnitList 

type UnitList []Unit

func (UnitList) Len 

func (a UnitList) Len() int

UnitList implements sort.Interface

func (UnitList) Less 

func (a UnitList) Less(i, j int) bool

func (UnitList) Swap 

func (a UnitList) Swap(i, j int)

type UnitOption 

type UnitOption func(Unit) Unit

Option that may be passed to NewUnit

func UnitOptionAliases 

func UnitOptionAliases(a ...string) UnitOption

Additional names, spellings, or symbols that this unit may be referred to as

func UnitOptionPlural 

func UnitOptionPlural(s string) UnitOption

Either "none", "auto", or a custom plural unit name "none" - labels will use the unmodified unit name in a plural context "auto" - labels for this unit will be created with a plural suffix when appropriate (default)

func UnitOptionQuantity 

func UnitOptionQuantity(s string) UnitOption

Set a quantity label for which this Unit belongs

func UnitOptionSystem 

func UnitOptionSystem(s string) UnitOption

Set a system of units for which this Unit belongs

type Value 

type Value struct {
	// contains filtered or unexported fields
}

func ConvertFloat 

func ConvertFloat(x float64, from, to Unit) (Value, error)

ConvertFloat converts a provided float from one Unit to another

func MustConvertFloat 

func MustConvertFloat(x float64, from, to Unit) Value

MustConvertFloat converts a provided float from one Unit to another, panicking on error

func NewValue 

func NewValue(v float64, u Unit) Value

NewValue creates a new Value instance

func (Value) Convert 

func (v Value) Convert(to Unit) (Value, error)

Convert converts this Value to another Unit

func (Value) Float 

func (v Value) Float() float64

func (Value) Fmt 

func (v Value) Fmt(opts FmtOptions) string

func (Value) MustConvert 

func (v Value) MustConvert(to Unit) Value

MustConvert converts this Value to another Unit, panicking on error

func (Value) String 

func (v Value) String() string

func (Value) Unit 

func (v Value) Unit() Unit

Source Files

View all Source files

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.