[{"name":"Acceleration","comment":" An `Acceleration` represents an acceleration in meters per second squared,\r\nfeet per second squared or [gees][1]. It is stored as a number of meters per\r\nsecond squared.\r\n\r\nNote that since `MetersPerSecondSquared` is defined as `Rate MetersPerSecond\r\nSeconds` (change in speed per unit time), you can construct an `Acceleration`\r\nvalue using `Quantity.per`:\r\n\r\n    acceleration =\r\n        changeInSpeed |> Quantity.per duration\r\n\r\nYou can also do rate-related calculations with `Acceleration` values to compute\r\n`Speed` or `Duration`:\r\n\r\n    changeInSpeed =\r\n        acceleration |> Quantity.for duration\r\n\r\n    alsoChangeInSpeed =\r\n        duration |> Quantity.at acceleration\r\n\r\n    duration =\r\n        changeInSpeed |> Quantity.at_ acceleration\r\n\r\n[1]: https://en.wikipedia.org/wiki/G-force#Unit_and_measurement\r\n\r\n@docs Acceleration, MetersPerSecondSquared\r\n\r\n@docs metersPerSecondSquared, inMetersPerSecondSquared, feetPerSecondSquared, inFeetPerSecondSquared, gees, inGees\r\n\r\n","unions":[],"aliases":[{"name":"Acceleration","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Acceleration.MetersPerSecondSquared"},{"name":"MetersPerSecondSquared","comment":" ","args":[],"type":"Quantity.Rate Speed.MetersPerSecond Duration.Seconds"}],"values":[{"name":"feetPerSecondSquared","comment":" Construct an acceleration from a number of feet per second squared.\r\n","type":"Basics.Float -> Acceleration.Acceleration"},{"name":"gees","comment":" Construct an acceleration from a number of [gees][1]. One gee is equal to\r\n9.80665 meters per second squared (the standard acceleration due to gravity).\r\n\r\n    Acceleration.gees 1\r\n    --> Acceleration.metersPerSecondSquared 9.80665\r\n\r\n[1]: https://en.wikipedia.org/wiki/G-force#Unit_and_measurement\r\n\r\n","type":"Basics.Float -> Acceleration.Acceleration"},{"name":"inFeetPerSecondSquared","comment":" Convert an acceleration to a number of feet per second squared.\r\n","type":"Acceleration.Acceleration -> Basics.Float"},{"name":"inGees","comment":" Convert an acceleration to a number of gees.\r\n","type":"Acceleration.Acceleration -> Basics.Float"},{"name":"inMetersPerSecondSquared","comment":" Convert an acceleration to a number of meters per second squared.\r\n","type":"Acceleration.Acceleration -> Basics.Float"},{"name":"metersPerSecondSquared","comment":" Construct an acceleration from a number of meters per second squared.\r\n","type":"Basics.Float -> Acceleration.Acceleration"}],"binops":[]},{"name":"Angle","comment":" An `Angle` represents an angle in degrees, radians, or turns. It is stored\r\nas a number of radians.\r\n\r\n@docs Angle, Radians\r\n\r\n\r\n## Conversions\r\n\r\n@docs radians, inRadians, degrees, inDegrees, turns, inTurns\r\n\r\n\r\n## Trigonometry\r\n\r\nIf you're using `Angle` values instead of plain `Float`s, you'll need to use\r\nthese functions instead of [the corresponding ones in core][1].\r\n\r\n[1]: https://package.elm-lang.org/packages/elm/core/latest/Basics#trigonometry\r\n\r\n@docs sin, cos, tan, asin, acos, atan, atan2\r\n\r\n","unions":[{"name":"Radians","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"Angle","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Angle.Radians"}],"values":[{"name":"acos","comment":" ","type":"Basics.Float -> Angle.Angle"},{"name":"asin","comment":" ","type":"Basics.Float -> Angle.Angle"},{"name":"atan","comment":" ","type":"Basics.Float -> Angle.Angle"},{"name":"atan2","comment":" ","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Angle.Angle"},{"name":"cos","comment":" ","type":"Angle.Angle -> Basics.Float"},{"name":"degrees","comment":" Construct an angle from a number of degrees.\r\n\r\n    Angle.degrees 180\r\n    --> Angle.radians pi\r\n\r\n","type":"Basics.Float -> Angle.Angle"},{"name":"inDegrees","comment":" Convert an angle to a number of degrees.\r\n\r\n    Angle.turns 2 |> Angle.inDegrees\r\n    --> 720\r\n\r\n","type":"Angle.Angle -> Basics.Float"},{"name":"inRadians","comment":" Convert an angle to a number of radians.\r\n","type":"Angle.Angle -> Basics.Float"},{"name":"inTurns","comment":" Convert an angle to a number of turns.\r\n\r\n    Angle.radians pi |> Angle.inTurns\r\n    --> 0.5\r\n\r\n","type":"Angle.Angle -> Basics.Float"},{"name":"radians","comment":" Construct an angle from a number of radians.\r\n","type":"Basics.Float -> Angle.Angle"},{"name":"sin","comment":" ","type":"Angle.Angle -> Basics.Float"},{"name":"tan","comment":" ","type":"Angle.Angle -> Basics.Float"},{"name":"turns","comment":" Construct an angle from a number of turns.\r\n\r\n    Angle.turns -0.25\r\n    --> Angle.degrees -90\r\n\r\n","type":"Basics.Float -> Angle.Angle"}],"binops":[]},{"name":"AngularAcceleration","comment":" An `AngularAcceleration` represents an angular acceleration in radians per\r\nsecond squared, degrees per second squared, and turns per second squared. It is\r\nstored as a number of radians per second squared.\r\n\r\nNote that since `RadiansPerSecondSquared` is defined as `Rate RadiansPerSecond\r\nSeconds` (change in angular speed per unit time), you can construct an\r\n`AngularAcceleration` value using `Quantity.per`:\r\n\r\n    angularAcceleration =\r\n        changeInAngularSpeed |> Quantity.per duration\r\n\r\nYou can also do rate-related calculations with `AngularAcceleration` values to\r\ncompute `AngularSpeed` or `Duration`:\r\n\r\n    changeInAngularSpeed =\r\n        angularAcceleration |> Quantity.for duration\r\n\r\n    alsoChangeInAngularSpeed =\r\n        duration |> Quantity.at angularAcceleration\r\n\r\n    duration =\r\n        changeInAngularSpeed |> Quantity.at_ angularAcceleration\r\n\r\n@docs AngularAcceleration, RadiansPerSecondSquared\r\n\r\n@docs radiansPerSecondSquared, inRadiansPerSecondSquared, degreesPerSecondSquared, inDegreesPerSecondSquared\r\n@docs turnsPerSecondSquared, inTurnsPerSecondSquared\r\n\r\n","unions":[],"aliases":[{"name":"AngularAcceleration","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float AngularAcceleration.RadiansPerSecondSquared"},{"name":"RadiansPerSecondSquared","comment":" ","args":[],"type":"Quantity.Rate AngularSpeed.RadiansPerSecond Duration.Seconds"}],"values":[{"name":"degreesPerSecondSquared","comment":" Construct an angular acceleration from a number of degrees per second squared.\r\n","type":"Basics.Float -> AngularAcceleration.AngularAcceleration"},{"name":"inDegreesPerSecondSquared","comment":" Convert an angular acceleration to a number of degrees per second squared.\r\n","type":"AngularAcceleration.AngularAcceleration -> Basics.Float"},{"name":"inRadiansPerSecondSquared","comment":" Convert an angular acceleration to a number of radians per second squared.\r\n","type":"AngularAcceleration.AngularAcceleration -> Basics.Float"},{"name":"inTurnsPerSecondSquared","comment":" Convert an angular acceleration to a number of turns per second squared.\r\n","type":"AngularAcceleration.AngularAcceleration -> Basics.Float"},{"name":"radiansPerSecondSquared","comment":" Construct an angular acceleration from a number of radians per second squared.\r\n","type":"Basics.Float -> AngularAcceleration.AngularAcceleration"},{"name":"turnsPerSecondSquared","comment":" Construct an angular acceleration from a number of turns per second squared.\r\n","type":"Basics.Float -> AngularAcceleration.AngularAcceleration"}],"binops":[]},{"name":"AngularSpeed","comment":" An `AngularSpeed` represents an acceleration in radians per second, degrees\r\nper second, turns (revolutions) per second and turns (revolutions) per minute.\r\nIt is stored as a number of radians per second.\r\n\r\nNote that since `RadiansPerSecond` is defined as `Rate Radians Seconds` (angle\r\nper unit time), you can construct an `AngularSpeed` value using `Quantity.per`:\r\n\r\n    angularSpeed =\r\n        angle |> Quantity.per duration\r\n\r\nYou can also do rate-related calculations with `AngularSpeed` values to compute\r\n`Angle` or `Duration`:\r\n\r\n    angle =\r\n        angularSpeed |> Quantity.for duration\r\n\r\n    alsoAngle =\r\n        duration |> Quantity.at angularSpeed\r\n\r\n    duration =\r\n        angle |> Quantity.at_ angularSpeed\r\n\r\n@docs AngularSpeed, RadiansPerSecond\r\n\r\n@docs radiansPerSecond, inRadiansPerSecond, degreesPerSecond, inDegreesPerSecond\r\n@docs turnsPerSecond, inTurnsPerSecond, turnsPerMinute, inTurnsPerMinute\r\n\r\n\r\n## Aliases for `turns` as `revolutions`\r\n\r\nThe Elm core `Basics` module uses `turns` in its [Angle Conversions](https://package.elm-lang.org/packages/elm-lang/core/latest/Basics#angle-conversions).\r\nTo be consistent, this module also uses `turns`, however since 'revolutions per\r\nminute' (RPM) is in common usage, several aliases are provided.\r\n\r\n@docs revolutionsPerSecond, inRevolutionsPerSecond, revolutionsPerMinute, inRevolutionsPerMinute\r\n\r\n","unions":[],"aliases":[{"name":"AngularSpeed","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float AngularSpeed.RadiansPerSecond"},{"name":"RadiansPerSecond","comment":" ","args":[],"type":"Quantity.Rate Angle.Radians Duration.Seconds"}],"values":[{"name":"degreesPerSecond","comment":" Construct an angular speed from a number of degrees per second.\r\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"inDegreesPerSecond","comment":" Convert an angular speed to a number of degrees per second.\r\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inRadiansPerSecond","comment":" Convert an angular speed to a number of radians per second.\r\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inRevolutionsPerMinute","comment":" Alias for `inTurnsPerMinute`.\r\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inRevolutionsPerSecond","comment":" Alias for `inTurnsPerSecond`.\r\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inTurnsPerMinute","comment":" Convert an angular speed to a number of turns per minute.\r\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inTurnsPerSecond","comment":" Convert an angular speed to a number of turns per second.\r\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"radiansPerSecond","comment":" Construct an angular speed from a number of radians per second.\r\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"revolutionsPerMinute","comment":" Alias for `turnsPerMinute`.\r\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"revolutionsPerSecond","comment":" Alias for `turnsPerSecond`.\r\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"turnsPerMinute","comment":" Construct an angular speed from a number of turns per minute.\r\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"turnsPerSecond","comment":" Construct an angular speed from a number of turns per second.\r\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"}],"binops":[]},{"name":"Area","comment":" An `Area` represents an area in square meters, square feet, acres, hectares\r\netc. It is stored as a number of square meters.\r\n\r\nNote that you can construct an `Area` value directly using the functions in this\r\nmodule, but it also works to call [`Quantity.squared`](Quantity#squared) on a\r\n`Length` or [`Quantity.times`](Quantity#times) on a pair of `Length`s. The\r\nfollowing are all equivalent:\r\n\r\n    Area.squareFeet 100\r\n\r\n    Quantity.squared (Length.feet 10)\r\n\r\n    Length.feet 25 |> Quantity.times (Length.feet 4)\r\n\r\n@docs Area, SquareMeters\r\n\r\n\r\n## Metric\r\n\r\n@docs squareMeters, inSquareMeters\r\n@docs squareMillimeters, inSquareMillimeters, squareCentimeters, inSquareCentimeters, hectares, inHectares, squareKilometers, inSquareKilometers\r\n\r\n\r\n## Imperial\r\n\r\n@docs squareInches, inSquareInches, squareFeet, inSquareFeet, squareYards, inSquareYards, acres, inAcres, squareMiles, inSquareMiles\r\n\r\n","unions":[],"aliases":[{"name":"Area","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Area.SquareMeters"},{"name":"SquareMeters","comment":" ","args":[],"type":"Quantity.Squared Length.Meters"}],"values":[{"name":"acres","comment":" Construct an area from a number of acres.\r\n","type":"Basics.Float -> Area.Area"},{"name":"hectares","comment":" Construct an area from a number of hectares.\r\n","type":"Basics.Float -> Area.Area"},{"name":"inAcres","comment":" Convert an area to a number of acres.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inHectares","comment":" Convert an area to a number of hectares.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareCentimeters","comment":" Convert an area to a number of square centimeters.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareFeet","comment":" Convert an area to a number of square feet.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareInches","comment":" Convert an area to a number of square inches.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareKilometers","comment":" Convert an area to a number of square kilometers.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareMeters","comment":" Convert an area to a number of square meters.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareMiles","comment":" Convert an area to a number of square miles.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareMillimeters","comment":" Convert an area to a number of square millimeters.\r\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareYards","comment":" Convert an area to a number of square yards.\r\n","type":"Area.Area -> Basics.Float"},{"name":"squareCentimeters","comment":" Construct an area from a number of square centimeters.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareFeet","comment":" Construct an area from a number of square feet.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareInches","comment":" Construct an area from a number of square inches.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareKilometers","comment":" Construct an area from a number of square kilometers.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareMeters","comment":" Construct an area from a number of square meters.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareMiles","comment":" Construct an area from a number of square miles.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareMillimeters","comment":" Construct an area from a number of square millimeters.\r\n","type":"Basics.Float -> Area.Area"},{"name":"squareYards","comment":" Construct an area from a number of square yards.\r\n","type":"Basics.Float -> Area.Area"}],"binops":[]},{"name":"Capacitance","comment":" A `Capacitance` value represents an electrical capacitance in farads.\r\n\r\nNote that since `Capacitance` is defined as `Rate Coulombs Volts` (charge per\r\nvoltage), you can construct a `Capacitance` value using `Quantity.per`:\r\n\r\n    capacitance =\r\n        charge |> Quantity.per voltage\r\n\r\nYou can also compute `Charge` and `Voltage` using `Capacitance`:\r\n\r\n    charge =\r\n        voltage |> Quantity.at capacitance\r\n\r\n    voltage =\r\n        charge |> Quantity.at_ capacitance\r\n\r\n@docs Capacitance, Farads\r\n\r\n@docs farads, inFarads\r\n@docs picofarads, inPicofarads, nanofarads, inNanofarads, microfarads, inMicrofarads\r\n\r\n","unions":[{"name":"Farads","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"Capacitance","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Capacitance.Farads"}],"values":[{"name":"farads","comment":" Construct capacitance from a number of farads.\r\n","type":"Basics.Float -> Capacitance.Capacitance"},{"name":"inFarads","comment":" Convert capacitance to a number of farads.\r\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"inMicrofarads","comment":" Convert a capacitance to a number of microfarads\r\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"inNanofarads","comment":" Convert a capacitance to a number of nanofarads\r\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"inPicofarads","comment":" Convert a capacitance to a number of picofarads.\r\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"microfarads","comment":" Construct a capacitance from a number of microfarads.\r\n","type":"Basics.Float -> Capacitance.Capacitance"},{"name":"nanofarads","comment":" Construct a capacitance from a number of nanofarads\r\n","type":"Basics.Float -> Capacitance.Capacitance"},{"name":"picofarads","comment":" Construct capacitance from a number of picofarads.\r\n","type":"Basics.Float -> Capacitance.Capacitance"}],"binops":[]},{"name":"Charge","comment":" A `Charge` value represents an electrical charge in coulombs or ampere\r\nhours. It is stored as a number of coulombs.\r\n\r\n@docs Charge, Coulombs\r\n\r\n@docs coulombs, inCoulombs, ampereHours, inAmpereHours, milliampereHours, inMilliampereHours\r\n\r\n","unions":[{"name":"Coulombs","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"Charge","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Charge.Coulombs"}],"values":[{"name":"ampereHours","comment":" Construct a charge from a number of ampere hours.\r\n","type":"Basics.Float -> Charge.Charge"},{"name":"coulombs","comment":" Construct a charge from a number of coulombs.\r\n","type":"Basics.Float -> Charge.Charge"},{"name":"inAmpereHours","comment":" Convert a charge to a number of ampere hours.\r\n","type":"Charge.Charge -> Basics.Float"},{"name":"inCoulombs","comment":" Convert a charge to a number of coulombs.\r\n","type":"Charge.Charge -> Basics.Float"},{"name":"inMilliampereHours","comment":" Convert a charge to a number of milliampere hours.\r\n","type":"Charge.Charge -> Basics.Float"},{"name":"milliampereHours","comment":" Construct a charge from a number of milliampere hours.\r\n","type":"Basics.Float -> Charge.Charge"}],"binops":[]},{"name":"Current","comment":" A `Current` value represents an electrical current in amperes.\r\n\r\nNote that since `Amperes` is defined as `Rate Coulombs Seconds` (charge\r\nper unit time), you can construct a `Current` value using `Quantity.per`:\r\n\r\n    current =\r\n        charge |> Quantity.per duration\r\n\r\nYou can also do rate-related calculations with `Current` values to compute\r\n`Charge` or `Duration`:\r\n\r\n    charge =\r\n        current |> Quantity.for duration\r\n\r\n    alsoCharge =\r\n        duration |> Quantity.at current\r\n\r\n    duration =\r\n        charge |> Quantity.at_ current\r\n\r\n@docs Current, Amperes\r\n\r\n@docs amperes, inAmperes, milliamperes, inMilliamperes\r\n\r\n","unions":[],"aliases":[{"name":"Amperes","comment":" ","args":[],"type":"Quantity.Rate Charge.Coulombs Duration.Seconds"},{"name":"Current","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Current.Amperes"}],"values":[{"name":"amperes","comment":" Construct a current from a number of amperes.\r\n","type":"Basics.Float -> Current.Current"},{"name":"inAmperes","comment":" Convert a current to a number of amperes.\r\n\r\n    Charge.coulombs 10\r\n        |> Quantity.per (Duration.seconds 2)\r\n        |> Current.inAmperes\r\n    --> 5\r\n\r\n","type":"Current.Current -> Basics.Float"},{"name":"inMilliamperes","comment":" Convert a current to number of milliamperes.\r\n\r\n    Current.amperes 2 |> Current.inMilliamperes\r\n    --> 2000\r\n\r\n","type":"Current.Current -> Basics.Float"},{"name":"milliamperes","comment":" Construct a current from a number of milliamperes.\r\n\r\n    Current.milliamperes 500\r\n    --> Current.amperes 0.5\r\n\r\n","type":"Basics.Float -> Current.Current"}],"binops":[]},{"name":"Density","comment":" A `Density` value represents a density in grams per cubic centimeter, pounds\r\nper cubic inch, etc. It is stored as a number of kilograms per cubic meter.\r\n\r\nNote that since `KilogramsPerCubicMeter` is defined as `Rate Kilograms\r\nCubicMeters` (mass per unit volume), you can construct a `Density` value using\r\n`Quantity.per`:\r\n\r\n    density =\r\n        mass |> Quantity.per volume\r\n\r\nYou can also do rate-related calculations with `Density` values to compute\r\n`Mass` or `Volume`:\r\n\r\n    mass =\r\n        volume |> Quantity.at density\r\n\r\n    volume =\r\n        mass |> Quantity.at_ density\r\n\r\n@docs Density, KilogramsPerCubicMeter\r\n\r\n\r\n## Metric\r\n\r\n@docs kilogramsPerCubicMeter, inKilogramsPerCubicMeter, gramsPerCubicCentimeter, inGramsPerCubicCentimeter\r\n\r\n\r\n## Imperial\r\n\r\n@docs poundsPerCubicInch, inPoundsPerCubicInch, poundsPerCubicFoot, inPoundsPerCubicFoot\r\n\r\n","unions":[],"aliases":[{"name":"Density","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Density.KilogramsPerCubicMeter"},{"name":"KilogramsPerCubicMeter","comment":" ","args":[],"type":"Quantity.Rate Mass.Kilograms Volume.CubicMeters"}],"values":[{"name":"gramsPerCubicCentimeter","comment":" Construct a density from a number of grams per cubic centimeter.\r\n","type":"Basics.Float -> Density.Density"},{"name":"inGramsPerCubicCentimeter","comment":" Convert a density to a number of grams per cubic centimeter.\r\n","type":"Density.Density -> Basics.Float"},{"name":"inKilogramsPerCubicMeter","comment":" Convert a density to a number of kilograms per cubic meter.\r\n","type":"Density.Density -> Basics.Float"},{"name":"inPoundsPerCubicFoot","comment":" Convert a density to a number of pounds per cubic foot.\r\n","type":"Density.Density -> Basics.Float"},{"name":"inPoundsPerCubicInch","comment":" Convert a density to a number of pounds per cubic inch.\r\n","type":"Density.Density -> Basics.Float"},{"name":"kilogramsPerCubicMeter","comment":" Construct a density from a number of kilograms per cubic meter.\r\n","type":"Basics.Float -> Density.Density"},{"name":"poundsPerCubicFoot","comment":" Construct a density from a number of pounds per cubic foot.\r\n","type":"Basics.Float -> Density.Density"},{"name":"poundsPerCubicInch","comment":" Construct a density from a number of pounds per cubic inch.\r\n","type":"Basics.Float -> Density.Density"}],"binops":[]},{"name":"Duration","comment":" A `Duration` refers to an elapsed time in seconds, milliseconds, hours etc.,\r\nas opposed to a specific instant in time (which would generally be represented\r\nby a [`Posix`](https://package.elm-lang.org/packages/elm/time/latest/Time#Posix)\r\nvalue). It is stored as a number of seconds.\r\n\r\n@docs Duration, Seconds\r\n\r\n@docs from, seconds, inSeconds, milliseconds, inMilliseconds, minutes, inMinutes, hours, inHours, days, inDays, weeks, inWeeks, julianYears, inJulianYears\r\n\r\n","unions":[{"name":"Seconds","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"Duration","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Duration.Seconds"}],"values":[{"name":"days","comment":" Construct a `Duration` from a given number of days. A day is defined as\r\nexactly 24 hours or 86400 seconds. Therefore, it is only equal to the length of\r\na given calendar day if that calendar day does not include either a leap second\r\nor any added/removed daylight savings hours.\r\n\r\n    Duration.days 1\r\n    --> Duration.hours 24\r\n\r\n","type":"Basics.Float -> Duration.Duration"},{"name":"from","comment":" Find the elapsed time from a start time to an end time. For example,\r\nassuming that `nineAM` and `fivePM` are two [`Time.Posix`](https://package.elm-lang.org/packages/elm/time/latest/Time#Posix)\r\nvalues on the same day:\r\n\r\n    Duration.from nineAM fivePM\r\n    --> Duration.hours 8\r\n\r\n","type":"Time.Posix -> Time.Posix -> Duration.Duration"},{"name":"hours","comment":" Construct a `Duration` from a given number of hours.\r\n\r\n    Duration.hours 1\r\n    --> Duration.seconds 3600\r\n\r\n","type":"Basics.Float -> Duration.Duration"},{"name":"inDays","comment":" Convert a `Duration` to a value in days.\r\n\r\n    Duration.hours 72 |> Duration.inDays\r\n    --> 3\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"inHours","comment":" Convert a `Duration` to a value in hours.\r\n\r\n    Duration.minutes 120 |> Duration.inHours\r\n    --> 2\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"inJulianYears","comment":" Convert a `Duration` to a value in Julian years.\r\n\r\n    Duration.hours 10000 |> Duration.inJulianYears\r\n    --> 1.1407711613050422\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"inMilliseconds","comment":" Convert a `Duration` to a value in milliseconds.\r\n\r\n    Duration.seconds 0.5 |> Duration.inMilliseconds\r\n    --> 500\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"inMinutes","comment":" Convert a `Duration` to a value in minutes.\r\n\r\n    Duration.seconds 90 |> Duration.inMinutes\r\n    --> 1.5\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"inSeconds","comment":" Convert a `Duration` to a value in seconds.\r\n\r\n    Duration.milliseconds 10 |> Duration.inSeconds\r\n    --> 0.01\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"inWeeks","comment":" Convert a `Duration` to a value in weeks.\r\n\r\n    Duration.days 28 |> Duration.inWeeks\r\n    --> 4\r\n\r\n","type":"Duration.Duration -> Basics.Float"},{"name":"julianYears","comment":" Construct a `Duration` from a given number of [Julian years][julian_year].\r\nA Julian year is defined as exactly 365.25 days, the average length of a year in\r\nthe historical Julian calendar. This is 10 minutes and 48 seconds longer than\r\na Gregorian year (365.2425 days), which is the average length of a year in the\r\nmodern Gregorian calendar, but the Julian year is a bit easier to remember and\r\nreason about and has the virtue of being the 'year' value used in the definition\r\nof a [light year](Length#lightYears).\r\n\r\n    Duration.julianYears 1\r\n    --> Duration.days 365.25\r\n\r\n[julian_year]: https://en.wikipedia.org/wiki/Julian_year_(astronomy) \"Julian year\"\r\n\r\n","type":"Basics.Float -> Duration.Duration"},{"name":"milliseconds","comment":" Construct a `Duration` from a given number of milliseconds.\r\n\r\n    Duration.milliseconds 5000\r\n    --> Duration.seconds 5\r\n\r\n","type":"Basics.Float -> Duration.Duration"},{"name":"minutes","comment":" Construct a `Duration` from a given number of minutes.\r\n\r\n    Duration.minutes 3\r\n    --> Duration.seconds 180\r\n\r\n","type":"Basics.Float -> Duration.Duration"},{"name":"seconds","comment":" Construct a `Duration` from a given number of seconds.\r\n","type":"Basics.Float -> Duration.Duration"},{"name":"weeks","comment":" Construct a `Duration` from a given number of weeks.\r\n\r\n    Duration.weeks 1\r\n    --> Duration.days 7\r\n\r\n","type":"Basics.Float -> Duration.Duration"}],"binops":[]},{"name":"Energy","comment":" An `Energy` value represents an amount of energy (or work) in joules,\r\nkilowatt hours etc. It is stored as a number of joules.\r\n\r\nNote that since `Joules` is defined as `Product Newtons Meters`, you can compute\r\nenergy directly as a product of force and distance:\r\n\r\n    Force.newtons 5 |> Quantity.times (Length.meters 4)\r\n    --> Energy.joules 20\r\n\r\n@docs Energy, Joules\r\n\r\n@docs joules, inJoules, kilojoules, inKilojoules, megajoules, inMegajoules, kilowattHours, inKilowattHours\r\n\r\n","unions":[],"aliases":[{"name":"Energy","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Energy.Joules"},{"name":"Joules","comment":" ","args":[],"type":"Quantity.Product Force.Newtons Length.Meters"}],"values":[{"name":"inJoules","comment":" Convert an energy value to a number of joules.\r\n","type":"Energy.Energy -> Basics.Float"},{"name":"inKilojoules","comment":" Convert an energy value to a number of kilojoules.\r\n","type":"Energy.Energy -> Basics.Float"},{"name":"inKilowattHours","comment":" Convert an energy value to a number of kilowatt hours.\r\n","type":"Energy.Energy -> Basics.Float"},{"name":"inMegajoules","comment":" Convert an energy value to a number of megajoules.\r\n","type":"Energy.Energy -> Basics.Float"},{"name":"joules","comment":" Construct an energy value from a number of joules.\r\n","type":"Basics.Float -> Energy.Energy"},{"name":"kilojoules","comment":" Construct an energy value from a number of kilojoules.\r\n","type":"Basics.Float -> Energy.Energy"},{"name":"kilowattHours","comment":" Construct an energy value from a number of kilowatt hours.\r\n\r\n    Energy.kilowattHours 1\r\n    --> Energy.megajoules 3.6\r\n\r\n","type":"Basics.Float -> Energy.Energy"},{"name":"megajoules","comment":" Construct an energy value from a number of megajoules.\r\n","type":"Basics.Float -> Energy.Energy"}],"binops":[]},{"name":"Force","comment":" A `Force` value represents a force in newtons, pounds force etc. It is\r\nstored as a number of newtons.\r\n\r\nNote that since `Newtons` is defined as `Product Kilograms\r\nMetersPerSecondSquared`, you can compute force directly as a product of mass and\r\nacceleration:\r\n\r\n    mass =\r\n        Mass.kilograms 10\r\n\r\n    acceleration =\r\n        Acceleration.metersPerSecondSquared 2\r\n\r\n    mass |> Quantity.times acceleration\r\n    --> Force.newtons 20\r\n\r\n@docs Force, Newtons\r\n\r\n\r\n## Metric\r\n\r\n@docs newtons, inNewtons, kilonewtons, inKilonewtons, meganewtons, inMeganewtons\r\n\r\n\r\n## Imperial\r\n\r\n@docs pounds, inPounds, kips, inKips\r\n\r\n","unions":[],"aliases":[{"name":"Force","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Force.Newtons"},{"name":"Newtons","comment":" ","args":[],"type":"Quantity.Product Mass.Kilograms Acceleration.MetersPerSecondSquared"}],"values":[{"name":"inKilonewtons","comment":" Convert a force value to a number of kilonewtons.\r\n","type":"Force.Force -> Basics.Float"},{"name":"inKips","comment":" Convert a force value to a number of kips.\r\n","type":"Force.Force -> Basics.Float"},{"name":"inMeganewtons","comment":" Convert a force value to a number of meganewtons.\r\n","type":"Force.Force -> Basics.Float"},{"name":"inNewtons","comment":" Convert a force value to a number of newtons.\r\n","type":"Force.Force -> Basics.Float"},{"name":"inPounds","comment":" Convert a force value to a number of pounds force.\r\n","type":"Force.Force -> Basics.Float"},{"name":"kilonewtons","comment":" Construct a force value from a number of kilonewtons.\r\n","type":"Basics.Float -> Force.Force"},{"name":"kips","comment":" Construct a force value from a number of kips (kilopounds force).\r\n\r\n    Force.kips 2\r\n    --> Force.pounds 2000\r\n\r\n","type":"Basics.Float -> Force.Force"},{"name":"meganewtons","comment":" Construct a force value from a number of meganewtons.\r\n","type":"Basics.Float -> Force.Force"},{"name":"newtons","comment":" Construct a force value from a number of newtons.\r\n","type":"Basics.Float -> Force.Force"},{"name":"pounds","comment":" Construct a force value from a number of pounds force. One pound force is\r\nthe force required to accelerate one [pound mass][1] at a rate of [one gee][2].\r\n\r\n[1]: Mass#pounds\r\n[2]: Acceleration#gees\r\n\r\n","type":"Basics.Float -> Force.Force"}],"binops":[]},{"name":"Inductance","comment":" A `Inductance` value represents an electrical inductance in henries.\r\n\r\n@docs Inductance, Henries\r\n@docs henries, inHenries\r\n@docs nanohenries, inNanohenries, microhenries, inMicrohenries, millihenries, inMillihenries, kilohenries, inKilohenries\r\n\r\n","unions":[{"name":"Henries","comment":" ","args":[],"cases":[["Rate",["Voltage.Volts","Quantity.Rate Current.Amperes Duration.Seconds"]]]}],"aliases":[{"name":"Inductance","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Inductance.Henries"}],"values":[{"name":"henries","comment":" Construct an inductance from a number of henries.\r\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"inHenries","comment":" Convert an inductance to a number of henries.\r\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inKilohenries","comment":" Convert an inductance to a number of kilohenries.\r\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inMicrohenries","comment":" Convert an inductance to a number of microhenries.\r\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inMillihenries","comment":" Convert an inductance to a number of millihenries.\r\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inNanohenries","comment":" Convert an inductance to a number of nanohenries.\r\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"kilohenries","comment":" Construct an inductance from a number of kilohenries.\r\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"microhenries","comment":" Construct an inductance from a number of microhenries.\r\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"millihenries","comment":" Construct an inductance from a number of millihenries.\r\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"nanohenries","comment":" Construct an inductance from a number of nanohenries.\r\n","type":"Basics.Float -> Inductance.Inductance"}],"binops":[]},{"name":"Length","comment":" A `Length` represents a length in meters, feet, centimeters, miles etc. It\r\nis stored as a number of meters.\r\n\r\n@docs Length, Meters\r\n\r\n\r\n## Metric\r\n\r\n@docs meters, inMeters\r\n@docs microns, inMicrons, millimeters, inMillimeters, centimeters, inCentimeters, kilometers, inKilometers\r\n\r\n\r\n## Imperial\r\n\r\n@docs thou, inThou, inches, inInches, feet, inFeet, yards, inYards, miles, inMiles\r\n\r\n\r\n## Astronomical\r\n\r\n@docs astronomicalUnits, inAstronomicalUnits, parsecs, inParsecs, lightYears, inLightYears\r\n\r\n","unions":[{"name":"Meters","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"Length","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Length.Meters"}],"values":[{"name":"astronomicalUnits","comment":" Construct a length from a number of [astronomical units][au] (AU). One AU is\r\napproximately equal to the average distance of the Earth from the Sun.\r\n\r\n[au]: https://en.wikipedia.org/wiki/Astronomical_unit \"Astronomical unit\"\r\n\r\n","type":"Basics.Float -> Length.Length"},{"name":"centimeters","comment":" Construct a length from a number of centimeters.\r\n","type":"Basics.Float -> Length.Length"},{"name":"feet","comment":" Construct a length from a number of feet.\r\n","type":"Basics.Float -> Length.Length"},{"name":"inAstronomicalUnits","comment":" Convert a length to a number of astronomical units.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inCentimeters","comment":" Convert a length to a number of centimeters.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inFeet","comment":" Convert a length to a number of feet.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inInches","comment":" Convert a length to a number of inches.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inKilometers","comment":" Convert a length to a number of kilometers.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inLightYears","comment":" Convert a length to a number of light years.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inMeters","comment":" Convert a length to a number of meters.\r\n\r\n    Length.feet 1 |> Length.inMeters\r\n    --> 0.3048\r\n\r\n","type":"Length.Length -> Basics.Float"},{"name":"inMicrons","comment":" Convert a length to a number of microns (micrometers).\r\n\r\n    Length.millimeters 1 |> Length.inMicrons\r\n    --> 1000\r\n\r\n","type":"Length.Length -> Basics.Float"},{"name":"inMiles","comment":" Convert a length to a number of miles.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inMillimeters","comment":" Convert a length to number of millimeters.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inParsecs","comment":" Convert a length to a number of parsecs.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inThou","comment":" Convert a length to a number of thou (thousandths of an inch).\r\n\r\n    Length.millimeters 1 |> Length.inThou\r\n    --> 39.37007874015748\r\n\r\n","type":"Length.Length -> Basics.Float"},{"name":"inYards","comment":" Convert a length to a number of yards.\r\n","type":"Length.Length -> Basics.Float"},{"name":"inches","comment":" Construct a length from a number of inches.\r\n","type":"Basics.Float -> Length.Length"},{"name":"kilometers","comment":" Construct a length from a number of kilometers.\r\n","type":"Basics.Float -> Length.Length"},{"name":"lightYears","comment":" Construct a length from a number of light years. One light year is the\r\ndistance traveled when moving at the speed of light for one [Julian year](Duration#julianYear).\r\n","type":"Basics.Float -> Length.Length"},{"name":"meters","comment":" Construct a length from a number of meters.\r\n\r\n    height : Length\r\n    height =\r\n        Length.meters 2\r\n\r\n","type":"Basics.Float -> Length.Length"},{"name":"microns","comment":" Construct a length from a number of microns (micrometers).\r\n\r\n    Length.microns 1\r\n    --> Length.meters 1e-6\r\n\r\n","type":"Basics.Float -> Length.Length"},{"name":"miles","comment":" Construct a length from a number of miles.\r\n","type":"Basics.Float -> Length.Length"},{"name":"millimeters","comment":" Construct a length from number of millimeters.\r\n","type":"Basics.Float -> Length.Length"},{"name":"parsecs","comment":" Construct a length from a number of [parsecs][parsec].\r\n\r\n[parsec]: https://en.wikipedia.org/wiki/Parsec \"Parsec\"\r\n\r\n","type":"Basics.Float -> Length.Length"},{"name":"thou","comment":" Construct a length from a number of thou (thousandths of an inch).\r\n\r\n    Length.thou 5\r\n    --> Length.inches 0.005\r\n\r\n","type":"Basics.Float -> Length.Length"},{"name":"yards","comment":" Construct a length from a number of yards.\r\n","type":"Basics.Float -> Length.Length"}],"binops":[]},{"name":"Mass","comment":" A `Mass` represents a mass in kilograms, pounds, metric or imperial tons\r\netc. It is stored as a number of kilograms.\r\n\r\n@docs Mass, Kilograms\r\n\r\n\r\n## Metric\r\n\r\n@docs kilograms, inKilograms, grams, inGrams, metricTons, inMetricTons\r\n\r\n\r\n## Imperial\r\n\r\n@docs pounds, inPounds, ounces, inOunces, longTons, inLongTons\r\n\r\n\r\n## U.S. customary\r\n\r\n@docs shortTons, inShortTons\r\n\r\n","unions":[{"name":"Kilograms","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"Mass","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Mass.Kilograms"}],"values":[{"name":"grams","comment":" Construct a mass from a number of grams.\r\n","type":"Basics.Float -> Mass.Mass"},{"name":"inGrams","comment":" Convert a mass to a number of grams.\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"inKilograms","comment":" Convert a mass to a number of kilograms.\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"inLongTons","comment":" Convert a mass to a number of long tons.\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"inMetricTons","comment":" Convert a mass to a number of metric tons.\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"inOunces","comment":" Convert a mass to a number of ounces.\r\n\r\n    Mass.pounds 1 |> Mass.inOunces\r\n    --> 16\r\n\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"inPounds","comment":" Convert a mass to a number of pounds.\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"inShortTons","comment":" Convert a mass to a number of short tons.\r\n","type":"Mass.Mass -> Basics.Float"},{"name":"kilograms","comment":" Construct a mass from a number of kilograms.\r\n","type":"Basics.Float -> Mass.Mass"},{"name":"longTons","comment":" Construct a mass from a number of [long tons][1]. This is the 'ton' commonly\r\nused in the United Kingdom and British Commonwealth.\r\n\r\n    Mass.longTons 1\r\n    --> Mass.pounds 2240\r\n\r\n[1]: https://en.wikipedia.org/wiki/Long_ton\r\n\r\n","type":"Basics.Float -> Mass.Mass"},{"name":"metricTons","comment":" Construct a mass from a number of [metric tons][1].\r\n\r\n    Mass.metricTons 1\r\n    --> Mass.kilograms 1000\r\n\r\n[1]: https://en.wikipedia.org/wiki/Tonne\r\n\r\n","type":"Basics.Float -> Mass.Mass"},{"name":"ounces","comment":" Construct a mass from a number of ounces.\r\n","type":"Basics.Float -> Mass.Mass"},{"name":"pounds","comment":" Construct a mass from a number of pounds.\r\n","type":"Basics.Float -> Mass.Mass"},{"name":"shortTons","comment":" Construct a mass from a number of [short tons][1]. This is the 'ton'\r\ncommonly used in the United States.\r\n\r\n    Mass.shortTons 1\r\n    --> Mass.pounds 2000\r\n\r\n[1]: https://en.wikipedia.org/wiki/Short_ton\r\n\r\n","type":"Basics.Float -> Mass.Mass"}],"binops":[]},{"name":"Pixels","comment":" Although most of the focus of `elm-units` is on physical/scientific units,\r\nit's very useful to be able to safely convert back and forth between (for\r\nexample) [`Length`](Length) values in the real world and on-screen lengths in\r\npixels. This module provides a standard `Pixels` units type and basic functions\r\nfor constructing/converting values of type `Quantity number Pixels`, which\r\nallows you to do things like represent conversions between real-world and\r\non-screen lengths as [rates of change][1]. This in turn means that all the\r\nnormal `Quantity` functions can be used to convert between pixels and other\r\nunits, or even do type-safe math directly on pixel values.\r\n\r\n[1]: Quantity#working-with-rates\r\n\r\n@docs Pixels, PixelsPerSecond, PixelsPerSecondSquared, SquarePixels\r\n\r\n@docs pixels, inPixels\r\n\r\n@docs pixelsPerSecond, inPixelsPerSecond\r\n\r\n@docs pixelsPerSecondSquared, inPixelsPerSecondSquared\r\n\r\n@docs squarePixels, inSquarePixels\r\n\r\n","unions":[{"name":"Pixels","comment":" Units type representing one on-screen pixel.\r\n","args":[],"cases":[]}],"aliases":[{"name":"PixelsPerSecond","comment":" Units type representing an on-screen speed of one pixel per second.\r\n","args":[],"type":"Quantity.Rate Pixels.Pixels Duration.Seconds"},{"name":"PixelsPerSecondSquared","comment":" Units type representing an on-screen acceleration of one pixel per second\r\nsquared.\r\n","args":[],"type":"Quantity.Rate Pixels.PixelsPerSecond Duration.Seconds"},{"name":"SquarePixels","comment":" Units type representing an on-screen area of one square pixel. For example,\r\na 32x32 image has an area of 1024 square pixels.\r\n","args":[],"type":"Quantity.Squared Pixels.Pixels"}],"values":[{"name":"inPixels","comment":" Convert a `Pixels` value to a plain number of pixels.\r\n\r\n    pixelDensity =\r\n        pixels 96 |> Quantity.per (Length.inches 1)\r\n\r\n    Length.centimeters 1\r\n        |> Quantity.at pixelDensity\r\n        |> inPixels\r\n    --> 37.795275590551185\r\n\r\n","type":"Quantity.Quantity number Pixels.Pixels -> number"},{"name":"inPixelsPerSecond","comment":" Convert an on-screen speed to a number of pixels per second.\r\n\r\n    elapsedTime =\r\n        Duration.milliseconds 16\r\n\r\n    dragDistance =\r\n        pixels 2\r\n\r\n    dragSpeed =\r\n        dragDistance |> Quantity.per elapsedTime\r\n\r\n    dragSpeed |> inPixelsPerSecond\r\n    --> 125\r\n\r\n","type":"Quantity.Quantity Basics.Float Pixels.PixelsPerSecond -> Basics.Float"},{"name":"inPixelsPerSecondSquared","comment":" Convert an on-screen acceleration to a number of pixels per second squared.\r\n","type":"Quantity.Quantity Basics.Float Pixels.PixelsPerSecondSquared -> Basics.Float"},{"name":"inSquarePixels","comment":" Convert an on-screen area to a number of square pixels.\r\n\r\n    area =\r\n        pixels 1920 |> Quantity.times (pixels 1080)\r\n\r\n    area |> inSquarePixels\r\n    --> 2073600\r\n\r\n","type":"Quantity.Quantity number Pixels.SquarePixels -> number"},{"name":"pixels","comment":" Construct a quantity representing a given number of on-screen pixels:\r\n\r\n    screenWidth =\r\n        pixels 1920\r\n\r\nNote that passing an `Int` will give you a\r\n\r\n    Quantity Int Pixels\r\n\r\nwhile passing a `Float` will give you a\r\n\r\n    Quantity Float Pixels\r\n\r\nIf you pass a _literal_ integer like `1920`, the result can be used as either an\r\n`Int` _or_ `Float` number of pixels.\r\n\r\n","type":"number -> Quantity.Quantity number Pixels.Pixels"},{"name":"pixelsPerSecond","comment":" Construct an on-screen speed from a number of pixels per second.\r\n","type":"Basics.Float -> Quantity.Quantity Basics.Float Pixels.PixelsPerSecond"},{"name":"pixelsPerSecondSquared","comment":" Construct an on-screen acceleration from a number of pixels per second\r\nsquared.\r\n","type":"Basics.Float -> Quantity.Quantity Basics.Float Pixels.PixelsPerSecondSquared"},{"name":"squarePixels","comment":" Construct an on-screen area from a number of square pixels.\r\n","type":"number -> Quantity.Quantity number Pixels.SquarePixels"}],"binops":[]},{"name":"Power","comment":" A `Power` value represents power in watts or horsepower. It is stored as a\r\nnumber of watts.\r\n\r\nNote that since `Watts` is defined as `Rate Joules Seconds` (energy per unit\r\ntime), you can construct a `Power` value using `Quantity.per`:\r\n\r\n    power =\r\n        energy |> Quantity.per duration\r\n\r\nYou can also do rate-related calculations with `Power` values to compute\r\n`Energy` or `Duration`:\r\n\r\n    energy =\r\n        power |> Quantity.for duration\r\n\r\n    alsoEnergy =\r\n        duration |> Quantity.at power\r\n\r\n    duration =\r\n        energy |> Quantity.at_ power\r\n\r\n[1]: https://en.wikipedia.org/wiki/Horsepower#Definitions\r\n\r\n@docs Power, Watts\r\n\r\n\r\n## Watts\r\n\r\n@docs watts, inWatts, kilowatts, inKilowatts, megawatts, inMegawatts\r\n\r\n\r\n## Horsepower\r\n\r\nWho knew that there were not one, not two, but _three_ possible interpretations\r\nof \"one horsepower\"? (Actually there are more than that, but these three\r\nseemed the most reasonable.)\r\n\r\n@docs metricHorsepower, inMetricHorsepower, mechanicalHorsepower, inMechanicalHorsepower, electricalHorsepower, inElectricalHorsepower\r\n\r\n","unions":[],"aliases":[{"name":"Power","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Power.Watts"},{"name":"Watts","comment":" ","args":[],"type":"Quantity.Rate Energy.Joules Duration.Seconds"}],"values":[{"name":"electricalHorsepower","comment":" Construct a `Power` value from an number of [electrical horsepower][1].\r\n\r\n    Power.electricalHorsepower 1\r\n    --> Power.watts 746\r\n\r\n[1]: https://en.wikipedia.org/wiki/Horsepower#Electrical_horsepower\r\n\r\n","type":"Basics.Float -> Power.Power"},{"name":"inElectricalHorsepower","comment":" Convert a `Power` value to a number of electrical horsepower.\r\n","type":"Power.Power -> Basics.Float"},{"name":"inKilowatts","comment":" Convert a `Power` value to a number of kilowatts.\r\n","type":"Power.Power -> Basics.Float"},{"name":"inMechanicalHorsepower","comment":" Convert a `Power` value to a number of mechanical horsepower.\r\n","type":"Power.Power -> Basics.Float"},{"name":"inMegawatts","comment":" Convert a `Power` value to a number of megawatts.\r\n","type":"Power.Power -> Basics.Float"},{"name":"inMetricHorsepower","comment":" Convert a `Power` value to a number of metric horsepower.\r\n","type":"Power.Power -> Basics.Float"},{"name":"inWatts","comment":" Convert a `Power` value to a number of watts.\r\n","type":"Power.Power -> Basics.Float"},{"name":"kilowatts","comment":" Construct a `Power` value from a number of kilowatts.\r\n","type":"Basics.Float -> Power.Power"},{"name":"mechanicalHorsepower","comment":" Construct a `Power` value from an number of [mechanical horsepower][1].\r\n\r\n    Power.mechanicalHorsepower 1\r\n    --> Power.watts 745.6998715822702\r\n\r\n[1]: https://en.wikipedia.org/wiki/Horsepower#Mechanical_horsepower\r\n\r\n","type":"Basics.Float -> Power.Power"},{"name":"megawatts","comment":" Construct a `Power` value from a number of megawatts.\r\n","type":"Basics.Float -> Power.Power"},{"name":"metricHorsepower","comment":" Construct a `Power` value from an number of [metric horsepower][1].\r\n\r\n    Power.metricHorsepower 1\r\n    --> Power.watts 735.49875\r\n\r\n[1]: https://en.wikipedia.org/wiki/Horsepower#Metric_horsepower\r\n\r\n","type":"Basics.Float -> Power.Power"},{"name":"watts","comment":" Construct a `Power` value from a number of watts.\r\n","type":"Basics.Float -> Power.Power"}],"binops":[]},{"name":"Pressure","comment":" A `Pressure` value represents a pressure in kilopascals, pounds per square\r\ninch, [atmospheres][1] etc. It is stored as a number of pascals.\r\n\r\nNote that since `Pascals` is defined as `Rate Newtons SquareMeters` (force per\r\nunit area), you can construct a `Pressure` value using `Quantity.per`:\r\n\r\n    pressure =\r\n        force |> Quantity.per area\r\n\r\nYou can also do rate-related calculations with `Pressure` values to compute\r\n`Force` or `Area`:\r\n\r\n    force =\r\n        area |> Quantity.at pressure\r\n\r\n    area =\r\n        force |> Quantity.at_ pressure\r\n\r\n[1]: https://en.wikipedia.org/wiki/Atmosphere_(unit)\r\n\r\n@docs Pressure, Pascals\r\n\r\n@docs pascals, inPascals, kilopascals, inKilopascals, megapascals, inMegapascals, poundsPerSquareInch, inPoundsPerSquareInch, atmospheres, inAtmospheres\r\n\r\n","unions":[],"aliases":[{"name":"Pascals","comment":" ","args":[],"type":"Quantity.Rate Force.Newtons Area.SquareMeters"},{"name":"Pressure","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Pressure.Pascals"}],"values":[{"name":"atmospheres","comment":" Construct a pressure from a number of [atmospheres][1].\r\n\r\n[1]: https://en.wikipedia.org/wiki/Atmosphere_(unit)\r\n\r\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"inAtmospheres","comment":" Convert a pressure to a number of atmospheres.\r\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inKilopascals","comment":" Convert a pressure to a number of kilopascals.\r\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inMegapascals","comment":" Convert a pressure to a number of megapascals.\r\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inPascals","comment":" Convert a pressure to a number of pascals.\r\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inPoundsPerSquareInch","comment":" Convert a pressure to a number of pounds per square inch.\r\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"kilopascals","comment":" Construct a pressure from a number of kilopascals.\r\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"megapascals","comment":" Construct a pressure from a number of megapascals.\r\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"pascals","comment":" Construct a pressure from a number of pascals.\r\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"poundsPerSquareInch","comment":" Construct a pressure from a number of pounds per square inch.\r\n","type":"Basics.Float -> Pressure.Pressure"}],"binops":[]},{"name":"Quantity","comment":"\r\n\r\n@docs Quantity\r\n\r\n\r\n# Unit types\r\n\r\nThe `Squared`, `Cubed`, `Product` and `Rate` units types allow you to build up\r\nand work with composite units in a fairly flexible way.\r\n\r\n@docs Squared, Cubed, Product, Rate\r\n\r\n\r\n# Constants\r\n\r\n@docs zero, infinity, positiveInfinity, negativeInfinity\r\n\r\n\r\n# Comparison\r\n\r\n@docs lessThan, greaterThan, lessThanOrEqualTo, greaterThanOrEqualTo, compare, equalWithin, max, min, isNaN, isInfinite\r\n\r\n\r\n# Arithmetic\r\n\r\n@docs negate, abs, plus, minus, multiplyBy, divideBy, squared, sqrt, cubed, cbrt\r\n\r\n\r\n## Working with products\r\n\r\n@docs times, over, over_\r\n\r\n\r\n## Working with rates\r\n\r\n@docs per, at, at_, for, inverse\r\n\r\n\r\n## Miscellaneous\r\n\r\n@docs ratio, clamp, interpolateFrom, midpoint, range\r\n\r\n\r\n# `Int`/`Float` conversion\r\n\r\nThese functions only really make sense for quantities in units like pixels,\r\ncents or game tiles where an `Int` number of units is meaningful. For quantities\r\nlike `Length` or `Duration`, it doesn't really make sense to round to an `Int`\r\nvalue since the underyling base unit is pretty arbitrary - should `round`ing a\r\n`Duration` give you an `Int` number of seconds, milliseconds, or something else?\r\n\r\n@docs round, floor, ceiling, truncate, toFloatQuantity\r\n\r\n\r\n# List functions\r\n\r\nThese functions act just like the corresponding functions in the built-in `List`\r\nmodule. They're necessary because the built-in `List.sum` only supports `List\r\nInt` and `List Float`, and `minimum`/`maximum`/`sort` only support built-in\r\ncomparable types like `Int`, `Float`, `String` and tuples.\r\n\r\n@docs sum, minimum, maximum, sort, sortBy\r\n\r\n\r\n# Unitless quantities\r\n\r\nIt is sometimes useful to be able to represent _unitless_ quantities, especially\r\nwhen working with generic code (in most other cases, it is likely simpler and\r\neasier to just use `Int` or `Float` values directly). All the conversions in\r\nthis section simply wrap or unwrap a `Float` or `Int` value into a `Quantity`\r\nvalue, and so should get compiled away entirely when using `elm make\r\n--optimize`.\r\n\r\n@docs Unitless, int, toInt, float, toFloat\r\n\r\n","unions":[{"name":"Product","comment":" Represents a units type that is the product of two other units types. This\r\nis a more general form of `Squared` or `Cubed`. See [`times`](#product),\r\n[`over`](#over) and [`over_`](#over_) for how it can be used.\r\n","args":["units1","units2"],"cases":[]},{"name":"Quantity","comment":" A `Quantity` is effectively a `number` (an `Int` or `Float`) tagged with a\r\n`units` type. So a\r\n\r\n    Quantity Float Meters\r\n\r\nis a `Float` number of `Meters` and a\r\n\r\n    Quantity Int Pixels\r\n\r\nis an `Int` number of `Pixels`. When compiling with `elm make --optimize` the\r\n`Quantity` wrapper type will be compiled away, so the runtime performance should\r\nbe comparable to using a raw `Float` or `Int`.\r\n\r\n","args":["number","units"],"cases":[["Quantity",["number"]]]},{"name":"Rate","comment":" Represents the units type of a rate or quotient such as a speed (`Rate\r\nMeters Seconds`) or a pressure (`Rate Newtons SquareMeters`). See [Working with\r\nrates](#working-with-rates) for details.\r\n","args":["dependentUnits","independentUnits"],"cases":[]},{"name":"Unitless","comment":" A special units type representing 'no units'. A `Quantity Int Unitless`\r\nvalue is interchangeable with a simple `Int`, and a `Quantity Float Unitless`\r\nvalue is interchangeable with a simple `Float`.\r\n","args":[],"cases":[]}],"aliases":[{"name":"Cubed","comment":" Represents a units type that is the cube of some other units type; for\r\nexample, `Meters` is one units type (the units type of a [`Length`](Length)) and\r\n`Cubed Meters` is another (the units type of an [`Volume`](Volume)). See the\r\n[`cubed`](Quantity#cubed) and [`cbrt`](Quantity#cbrt) functions for examples of\r\nuse.\r\n\r\nThis is a special case of the `Product` units type.\r\n\r\n","args":["units"],"type":"Quantity.Product (Quantity.Product units units) units"},{"name":"Squared","comment":" Represents a units type that is the square of some other units type; for\r\nexample, `Meters` is one units type (the units type of a [`Length`](Length)) and\r\n`Squared Meters` is another (the units type of an [`Area`](Area)). See the\r\n[`squared`](#squared) and [`sqrt`](#sqrt) functions for examples of use.\r\n\r\nThis is a special case of the `Product` units type.\r\n\r\n","args":["units"],"type":"Quantity.Product units units"}],"values":[{"name":"abs","comment":" Get the absolute value of a quantity.\r\n\r\n    Quantity.abs (Duration.milliseconds -10)\r\n    --> Duration.milliseconds 10\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"at","comment":" Multiply a rate of change by an independent quantity (the denominator in\r\nthe rate) to get a total value:\r\n\r\n    Duration.minutes 30\r\n        |> Quantity.at\r\n            (Speed.kilometersPerHour 100)\r\n    --> Length.kilometers 50\r\n\r\nCan be useful to define conversion functions from one unit to another, since\r\nif you define a `rate` then `Quantity.at rate` will give you a conversion\r\nfunction:\r\n\r\n    pixelDensity : Quantity Float (Rate Pixels Meters)\r\n    pixelDensity =\r\n        Pixels.pixels 96 |> Quantity.per (Length.inches 1)\r\n\r\n    lengthToPixels : Length -> Quantity Float Pixels\r\n    lengthToPixels length =\r\n        Quantity.at pixelDensity length\r\n\r\n    lengthToPixels (Length.inches 3)\r\n    --> Pixels.pixels 288\r\n\r\nEagle-eyed readers will note that using partial application you could also\r\nsimply write\r\n\r\n    lengthToPixels =\r\n        Quantity.at pixelDensity\r\n\r\nNote that there are [other forms of multiplication](/#multiplication-and-division)!\r\n\r\n","type":"Quantity.Quantity number (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity number independentUnits -> Quantity.Quantity number dependentUnits"},{"name":"at_","comment":" Given a rate and a _dependent_ quantity (total value), determine the\r\nnecessary amount of the _independent_ quantity:\r\n\r\n    Length.kilometers 75\r\n        |> Quantity.at_\r\n            (Speed.kilometersPerHour 100)\r\n    --> Duration.minutes 45\r\n\r\nWhere `at` performs multiplication, `at_` performs division - you multiply a\r\nspeed by a duration to get a distance, but you divide a distance by a speed to\r\nget a duration.\r\n\r\nSimilar to `at`, `at_` can be used to define an _inverse_ conversion function:\r\n\r\n    pixelDensity : Quantity Float (Rate Pixels Meters)\r\n    pixelDensity =\r\n        Pixels.pixels 96 |> Quantity.per (Length.inches 1)\r\n\r\n    pixelsToLength : Quantity Float Pixels -> Length\r\n    pixelsToLength pixels =\r\n        Quantity.at_ pixelDensity pixels\r\n\r\n    pixelsToLength (Pixels.pixels 48)\r\n    --> Length.inches 0.5\r\n\r\n","type":"Quantity.Quantity Basics.Float (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity Basics.Float dependentUnits -> Quantity.Quantity Basics.Float independentUnits"},{"name":"cbrt","comment":" Take a quantity in `Cubed units` and return the cube root of that\r\nquantity in plain `units`.\r\n\r\n    Quantity.cbrt (Volume.liters 1)\r\n    --> Length.centimeters 10\r\n\r\n","type":"Quantity.Quantity Basics.Float (Quantity.Cubed units) -> Quantity.Quantity Basics.Float units"},{"name":"ceiling","comment":" Round a `Float`-valued quantity up to the nearest `Int`.\r\n\r\n    Quantity.ceiling (Pixels.pixels 1.2)\r\n    --> Pixels.pixels 2\r\n\r\n    Quantity.ceiling (Pixels.pixels -2.1)\r\n    --> Pixels.pixels -2\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"clamp","comment":" Given a lower and upper bound, clamp a given quantity to within those\r\nbounds. Say you wanted to clamp an angle to be between +/-30 degrees:\r\n\r\n    lowerBound =\r\n        Angle.degrees -30\r\n\r\n    upperBound =\r\n        Angle.degrees 30\r\n\r\n    Quantity.clamp lowerBound upperBound (Angle.degrees 5)\r\n    --> Angle.degrees 5\r\n\r\n    -- One radian is approximately 57 degrees\r\n    Quantity.clamp lowerBound upperBound (Angle.radians 1)\r\n    --> Angle.degrees 30\r\n\r\n    Quantity.clamp lowerBound upperBound (Angle.turns -0.5)\r\n    --> Angle.degrees -30\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"compare","comment":" Compare two quantities, returning an [`Order`](https://package.elm-lang.org/packages/elm/core/latest/Basics#Order)\r\nvalue indicating whether the first is less than, equal to or greater than the\r\nsecond.\r\n\r\n    Quantity.compare (Duration.minutes 90) (Duration.hours 1)\r\n    --> GT\r\n\r\n    Quantity.compare (Duration.minutes 60) (Duration.hours 1)\r\n    --> EQ\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Order"},{"name":"cubed","comment":" Cube a quantity with some `units`, resulting in a new quantity in\r\n`Cubed units`.\r\n\r\n    Quantity.cubed (Length.meters 5)\r\n    --> Volume.cubicMeters 125\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number (Quantity.Cubed units)"},{"name":"divideBy","comment":" Divide a `Quantity` by a `Float`.\r\n\r\n    Quantity.divideBy 2 (Duration.hours 1)\r\n    --> Duration.minutes 30\r\n\r\nNote that there are [other forms of division](/#multiplication-and-division)!\r\n\r\n","type":"Basics.Float -> Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units"},{"name":"equalWithin","comment":" Check if two quantities are equal within a given absolute tolerance. The\r\ngiven tolerance must be greater than or equal to zero - if it is negative, then\r\nthe result will always be false.\r\n\r\n    -- 3 feet is 91.44 centimeters or 0.9144 meters\r\n\r\n    Quantity.equalWithin (Length.centimeters 10)\r\n        (Length.meters 1)\r\n        (Length.feet 3)\r\n    --> True\r\n\r\n    Quantity.equalWithin (Length.centimeters 5)\r\n        (Length.meters 1)\r\n        (Length.feet 3)\r\n    --> False\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"float","comment":" Convert a plain `Float` into a `Quantity Float Unitless` value.\r\n","type":"Basics.Float -> Quantity.Quantity Basics.Float Quantity.Unitless"},{"name":"floor","comment":" Round a `Float`-valued quantity down to the nearest `Int`.\r\n\r\n    Quantity.floor (Pixels.pixels 2.9)\r\n    --> Pixels.pixels 2\r\n\r\n    Quantity.floor (Pixels.pixels -2.1)\r\n    --> Pixels.pixels -3\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"for","comment":" Same as `at` but with the argument order flipped, which may read better\r\nin some cases:\r\n\r\n    Speed.kilometersPerHour 100\r\n        |> Quantity.for\r\n            (Duration.minutes 30)\r\n    --> Length.kilometers 50\r\n\r\n","type":"Quantity.Quantity number independentUnits -> Quantity.Quantity number (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity number dependentUnits"},{"name":"greaterThan","comment":" Check if one quantity is greater than another. Note the [argument order](/#argument-order)!\r\n\r\n    oneMeter =\r\n        Length.meters 1\r\n\r\n    Length.feet 1 |> Quantity.greaterThan oneMeter\r\n    --> False\r\n\r\n    -- Same as:\r\n    Quantity.greaterThan oneMeter (Length.feet 1)\r\n    --> False\r\n\r\n    List.filter (Quantity.greaterThan oneMeter)\r\n        [ Length.feet 1\r\n        , Length.parsecs 1\r\n        , Length.yards 1\r\n        , Length.lightYears 1\r\n        ]\r\n    --> [ Length.parsecs 1, Length.lightYears 1 ]\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"greaterThanOrEqualTo","comment":" Check if one quantity is greater than or equal to another. Note the\r\n[argument order](/#argument-order)!\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"infinity","comment":" Alias for `positiveInfinity`.\r\n","type":"Quantity.Quantity Basics.Float units"},{"name":"int","comment":" Convert a plain `Int` into a `Quantity Int Unitless` value.\r\n","type":"Basics.Int -> Quantity.Quantity Basics.Int Quantity.Unitless"},{"name":"interpolateFrom","comment":" Interpolate from the first quantity to the second, based on a parameter that\r\nranges from zero to one. Passing a parameter value of zero will return the start\r\nvalue and passing a parameter value of one will return the end value.\r\n\r\n    fiveMeters =\r\n        Length.meters 5\r\n\r\n    tenMeters =\r\n        Length.meters 10\r\n\r\n    Quantity.interpolateFrom fiveMeters tenMeters 0\r\n    --> Length.meters 5\r\n\r\n    Quantity.interpolateFrom fiveMeters tenMeters 1\r\n    --> Length.meters 10\r\n\r\n    Quantity.interpolateFrom fiveMeters tenMeters 0.6\r\n    --> Length.meters 8\r\n\r\nThe end value can be less than the start value:\r\n\r\n    Quantity.interpolateFrom tenMeters fiveMeters 0.1\r\n    --> Length.meters 9.5\r\n\r\nParameter values less than zero or greater than one can be used to extrapolate:\r\n\r\n    Quantity.interpolateFrom fiveMeters tenMeters 1.5\r\n    --> Length.meters 12.5\r\n\r\n    Quantity.interpolateFrom fiveMeters tenMeters -0.5\r\n    --> Length.meters 2.5\r\n\r\n    Quantity.interpolateFrom tenMeters fiveMeters -0.2\r\n    --> Length.meters 11\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Basics.Float -> Quantity.Quantity Basics.Float units"},{"name":"inverse","comment":" Find the inverse of a given rate. May be useful if you are using a rate to\r\ndefine a conversion, and want to convert the other way;\r\n\r\n    Quantity.at (Quantity.inverse rate)\r\n\r\nis equivalent to\r\n\r\n    Quantity.at_ rate\r\n\r\n","type":"Quantity.Quantity Basics.Float (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity Basics.Float (Quantity.Rate independentUnits dependentUnits)"},{"name":"isInfinite","comment":" Check if a quantity is positive or negative infinity.\r\n\r\n    Quantity.isInfinite\r\n        (Length.meters 1\r\n            |> Quantity.per (Duration.seconds 0)\r\n        )\r\n    --> True\r\n\r\n    Quantity.isInfinite Quantity.negativeInfinity\r\n    --> True\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Basics.Bool"},{"name":"isNaN","comment":" Check if a quantity's underlying value is NaN (not-a-number).\r\n\r\n    Quantity.isNan (Quantity.sqrt (Area.squareMeters -4))\r\n    --> True\r\n\r\n    Quantity.isNan (Quantity.sqrt (Area.squareMeters 4))\r\n    --> False\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Basics.Bool"},{"name":"lessThan","comment":" Check if one quantity is less than another. Note the [argument order](/#argument-order)!\r\n\r\n    oneMeter =\r\n        Length.meters 1\r\n\r\n    Length.feet 1 |> Quantity.lessThan oneMeter\r\n    --> True\r\n\r\n    -- Same as:\r\n    Quantity.lessThan oneMeter (Length.feet 1)\r\n    --> True\r\n\r\n    List.filter (Quantity.lessThan oneMeter)\r\n        [ Length.feet 1\r\n        , Length.parsecs 1\r\n        , Length.yards 1\r\n        , Length.lightYears 1\r\n        ]\r\n    --> [ Length.feet 1, Length.yards 1 ]\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"lessThanOrEqualTo","comment":" Check if one quantity is less than or equal to another. Note the [argument\r\norder](/#argument-order)!\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"max","comment":" Find the maximum of two quantities.\r\n\r\n    Quantity.max (Duration.hours 2) (Duration.minutes 100)\r\n    --> Duration.hours 2\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"maximum","comment":" Find the maximum value in a list of quantities. Returns `Nothing` if the\r\nlist is empty.\r\n\r\n    Quantity.maximum\r\n        [ Mass.kilograms 1\r\n        , Mass.pounds 2\r\n        , Mass.tonnes 3\r\n        ]\r\n    --> Just (Mass.tonnes 3)\r\n\r\n","type":"List.List (Quantity.Quantity number units) -> Maybe.Maybe (Quantity.Quantity number units)"},{"name":"midpoint","comment":" Find the midpoint between two quantities.\r\n\r\n    Quantity.midpoint (Length.meters 5) (Length.meters 10)\r\n    --> Length.meters 7.5\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units"},{"name":"min","comment":" Find the minimum of two quantities.\r\n\r\n    Quantity.min (Duration.hours 2) (Duration.minutes 100)\r\n    --> Duration.minutes 100\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"minimum","comment":" Find the minimum value in a list of quantities. Returns `Nothing` if the\r\nlist is empty.\r\n\r\n    Quantity.minimum\r\n        [ Mass.kilograms 1\r\n        , Mass.pounds 2\r\n        , Mass.tonnes 3\r\n        ]\r\n    --> Just (Mass.pounds 2)\r\n\r\n","type":"List.List (Quantity.Quantity number units) -> Maybe.Maybe (Quantity.Quantity number units)"},{"name":"minus","comment":" Subtract one quantity from another. Note the [argument order](/#argument-order)!\r\n\r\n    fifteenMinutes =\r\n        Duration.minutes 15\r\n\r\n    Duration.hours 1 |> Quantity.minus fifteenMinutes\r\n    --> Duration.minutes 45\r\n\r\n    -- Same as:\r\n    Quantity.minus fifteenMinutes (Duration.hours 1)\r\n    --> Duration.minutes 45\r\n\r\n    List.map (Quantity.minus fifteenMinutes)\r\n        [ Duration.hours 1\r\n        , Duration.hours 2\r\n        , Duration.minutes 30\r\n        ]\r\n    --> [ Duration.minutes 45\r\n    --> , Duration.minutes 105\r\n    --> , Duration.minutes 15\r\n    --> ]\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"multiplyBy","comment":" Scale a `Quantity` by a `number`.\r\n\r\n    Quantity.multiplyBy 1.5 (Duration.hours 1)\r\n    --> Duration.minutes 90\r\n\r\nNote that there are [other forms of multiplication](/#multiplication-and-division)!\r\n\r\n","type":"number -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"negate","comment":" Negate a quantity!\r\n\r\n    Quantity.negate (Length.millimeters 10)\r\n    --> Length.millimeters -10\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"negativeInfinity","comment":" A generic negative infinity value.\r\n","type":"Quantity.Quantity Basics.Float units"},{"name":"over","comment":" Divide a quantity in `Product units1 units2` by a quantity in `units1`,\r\nresulting in another quantity in `units2`. For example, the units type of a\r\n`Force` is `Product Kilograms MetersPerSecondSquared` (mass times acceleration),\r\nso we could divide a force by a given mass to determine how fast that mass would\r\nbe accelerated by the given force:\r\n\r\n    Force.newtons 100\r\n        |> Quantity.over\r\n            (Mass.kilograms 50)\r\n    --> Acceleration.metersPerSecondSquared 2\r\n\r\nNote that there are [other forms of division](/#multiplication-and-division)!\r\n\r\n","type":"Quantity.Quantity Basics.Float units1 -> Quantity.Quantity Basics.Float (Quantity.Product units1 units2) -> Quantity.Quantity Basics.Float units2"},{"name":"over_","comment":" Just like `over` but divide by a quantity in `units2`, resulting in another\r\nquantity in `units1`. For example, we could divide a force by a desired\r\nacceleration to determine how much mass could be accelerated at that rate:\r\n\r\n    Force.newtons 100\r\n        |> Quantity.over_\r\n            (Acceleration.metersPerSecondSquared 5)\r\n    --> Mass.kilograms 20\r\n\r\n","type":"Quantity.Quantity Basics.Float units2 -> Quantity.Quantity Basics.Float (Quantity.Product units1 units2) -> Quantity.Quantity Basics.Float units1"},{"name":"per","comment":" Construct a rate of change by dividing a dependent quantity (numerator) by\r\nan independent quantity (denominator):\r\n\r\n    distance =\r\n        Length.miles 1\r\n\r\n    time =\r\n        Duration.minutes 1\r\n\r\n    speed =\r\n        distance |> Quantity.per time\r\n\r\n    speed |> Speed.inMilesPerHour\r\n    --> 60\r\n\r\nNote that we could directly use our rate of change value as a `Speed`! That is\r\nbecause many built-in quantity types are defined as rates of change, for\r\nexample:\r\n\r\n  - `Speed` is `Length` per `Duration`\r\n  - `Acceleration` is `Speed` per `Duration`\r\n  - `Pressure` is `Force` per `Area`\r\n  - `Power` is `Energy` per `Duration`\r\n  - `Current` is `Charge` per `Duration`\r\n  - `Resistance` is `Voltage` per `Current`\r\n  - `Voltage` is `Power` per `Current`\r\n\r\nNote that there are [other forms of division](/#multiplication-and-division)!\r\n\r\n","type":"Quantity.Quantity Basics.Float independentUnits -> Quantity.Quantity Basics.Float dependentUnits -> Quantity.Quantity Basics.Float (Quantity.Rate dependentUnits independentUnits)"},{"name":"plus","comment":" Add two quantities.\r\n\r\n    Length.meters 1 |> Quantity.plus (Length.centimeters 5)\r\n    --> Length.centimeters 105\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"positiveInfinity","comment":" A generic positive infinity value.\r\n","type":"Quantity.Quantity Basics.Float units"},{"name":"range","comment":" Construct a range of evenly-spaced values given a `start` value, an `end`\r\nvalue and the number of `steps` to take from the start to the end. The first\r\nvalue in the returned list will be equal to `start` and the last value will be\r\nequal to `end`. Note that the number of returned values will be one greater than\r\nthe number of steps!\r\n\r\n    Quantity.range\r\n        { start = Length.meters 2\r\n        , end = Length.meters 3\r\n        , steps = 5\r\n        }\r\n    --> [ Length.centimeters 200\r\n    --> , Length.centimeters 220\r\n    --> , Length.centimeters 240\r\n    --> , Length.centimeters 260\r\n    --> , Length.centimeters 280\r\n    --> , Length.centimeters 300\r\n    --> ]\r\n\r\nThe start and end values can be in either order:\r\n\r\n    Quantity.range\r\n        { start = Duration.hours 1\r\n        , end = Quantity.zero\r\n        , steps = 4\r\n        }\r\n    --> [ Duration.minutes 60\r\n    --> , Duration.minutes 45\r\n    --> , Duration.minutes 30\r\n    --> , Duration.minutes 15\r\n    --> , Duration.minutes 0\r\n    --> ]\r\n\r\nPassing a negative or zero `steps` value will result in an empty list being\r\nreturned.\r\n\r\nIf you need finer control over what values get generated, try combining\r\n`interpolateFrom` with the various functions in the\r\n[`elm-1d-parameter`](https://package.elm-lang.org/packages/ianmackenzie/elm-1d-parameter/latest/)\r\npackage. For example:\r\n\r\n    -- Same as using Quantity.range\r\n    Parameter1d.steps 4 <|\r\n        Quantity.interpolateFrom\r\n            (Length.meters 2)\r\n            (Length.meters 3)\r\n    --> [ Length.centimeters 200\r\n    --> , Length.centimeters 225\r\n    --> , Length.centimeters 250\r\n    --> , Length.centimeters 275\r\n    --> , Length.centimeters 300\r\n    --> ]\r\n\r\n    -- Omit the last value\r\n    Parameter1d.leading 4 <|\r\n        Quantity.interpolateFrom\r\n            (Length.meters 2)\r\n            (Length.meters 3)\r\n    --> [ Length.centimeters 200\r\n    --> , Length.centimeters 225\r\n    --> , Length.centimeters 250\r\n    --> , Length.centimeters 275\r\n    --> ]\r\n\r\n","type":"{ start : Quantity.Quantity Basics.Float units, end : Quantity.Quantity Basics.Float units, steps : Basics.Int } -> List.List (Quantity.Quantity Basics.Float units)"},{"name":"ratio","comment":" Find the ratio of two quantities with the same units.\r\n\r\n    Quantity.ratio (Length.miles 1) (Length.yards 1)\r\n    --> 1760\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Basics.Float"},{"name":"round","comment":" Round a `Float`-valued quantity to the nearest `Int`.\r\n\r\n    Quantity.round (Pixels.pixels 3.5)\r\n    --> Pixels.pixels 4\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"sort","comment":" Sort a list of quantities.\r\n\r\n    Quantity.sort\r\n        [ Mass.kilograms 1\r\n        , Mass.pounds 2\r\n        , Mass.tonnes 3\r\n        ]\r\n    --> [ Mass.pounds 2\r\n    --> , Mass.kilograms 1\r\n    --> , Mass.tonnes 3\r\n    --> ]\r\n\r\n","type":"List.List (Quantity.Quantity number units) -> List.List (Quantity.Quantity number units)"},{"name":"sortBy","comment":" Sort an arbitrary list of values by a derived `Quantity`. If you had\r\n\r\n    people =\r\n        [ { name = \"Bob\", height = Length.meters 1.6 }\r\n        , { name = \"Charlie\", height = Length.meters 2.0 }\r\n        , { name = \"Alice\", height = Length.meters 1.8 }\r\n        ]\r\n\r\nthen you could sort by name with\r\n\r\n    List.sortBy .name people\r\n    --> [ { name = \"Alice\", height = Length.meters 1.8 }\r\n    --> , { name = \"Bob\", height = Length.meters 1.6 }\r\n    --> , { name = \"Charlie\", height = Length.meters 2.0 }\r\n    --> ]\r\n\r\n(nothing new there!), and sort by height with\r\n\r\n    Quantity.sortBy .height people\r\n    --> [ { name = \"Bob\", height = Length.meters 1.6 }\r\n    --> , { name = \"Alice\", height = Length.meters 1.8 }\r\n    --> , { name = \"Charlie\", height = Length.meters 2.0 }\r\n    --> ]\r\n\r\n","type":"(a -> Quantity.Quantity number units) -> List.List a -> List.List a"},{"name":"sqrt","comment":" Take a quantity in `Squared units` and return the square root of that\r\nquantity in plain `units`:\r\n\r\n    Quantity.sqrt (Area.hectares 1)\r\n    --> Length.meters 100\r\n\r\nGetting fancier, you could write a 2D hypotenuse (magnitude) function that\r\nworked on _any_ quantity type (length, speed, force...) as\r\n\r\n    hypotenuse :\r\n        Quantity Float units\r\n        -> Quantity Float units\r\n        -> Quantity Float units\r\n    hypotenuse x y =\r\n        Quantity.sqrt\r\n            (Quantity.squared x\r\n                |> Quantity.plus\r\n                    (Quantity.squared y)\r\n            )\r\n\r\nThis works because:\r\n\r\n  - The `x` and `y` arguments are both in `units`\r\n  - So each squared item is in `Squared units`\r\n  - So the sum is also in `Squared units`\r\n  - And calling `sqrt` on something in `Squared units` returns a value back in\r\n    `units`\r\n\r\n","type":"Quantity.Quantity Basics.Float (Quantity.Squared units) -> Quantity.Quantity Basics.Float units"},{"name":"squared","comment":" Square a quantity with some `units`, resulting in a new quantity in\r\n`Squared units`:\r\n\r\n    Quantity.squared (Length.meters 5)\r\n    --> Area.squareMeters 25\r\n\r\n","type":"Quantity.Quantity number units -> Quantity.Quantity number (Quantity.Squared units)"},{"name":"sum","comment":" Find the sum of a list of quantities.\r\n\r\n    Quantity.sum\r\n        [ Length.meters 1\r\n        , Length.centimeters 2\r\n        , Length.millimeters 3\r\n        ]\r\n    --> Length.meters 1.023\r\n\r\n    Quantity.sum []\r\n    --> Quantity.zero\r\n\r\n","type":"List.List (Quantity.Quantity number units) -> Quantity.Quantity number units"},{"name":"times","comment":" Multiply two quantities with units types `units1` and `units2` together,\r\nresulting in a quantity with units type `Product units1 units2`. Note the\r\n[argument order](/#argument-order)!\r\n\r\nThis works for any two units types, but one special case is worth pointing out.\r\nThe units type of an [`Area`](Area) is `SquareMeters`, which is a type alias for\r\n`Squared Meters`, which in turn expands to `Product Meters Meters`. This means\r\nthat the product of two `Length`s does in fact give you an `Area`:\r\n\r\n    -- This is the definition of an acre, I kid you not 😈\r\n    Length.feet 66 |> Quantity.times (Length.feet 660)\r\n    --> Area.acres 1\r\n\r\nWe can also multiply an `Area` by a `Length` to get a `Volume`:\r\n\r\n    Area.squareMeters 1\r\n        |> Quantity.times\r\n            (Length.centimeters 1)\r\n    --> Volume.liters 10\r\n\r\nNote that there are [other forms of multiplication](/#multiplication-and-division)!\r\n\r\n","type":"Quantity.Quantity number units2 -> Quantity.Quantity number units1 -> Quantity.Quantity number (Quantity.Product units1 units2)"},{"name":"toFloat","comment":" Convert a `Quantity Float Unitless` value into a plain `Float`.\r\n\r\nIf you're looking for a function to convert a `Quantity Int units` to `Quantity\r\nFloat units`, check out [`toFloatQuantity`](#toFloatQuantity).\r\n\r\n","type":"Quantity.Quantity Basics.Float Quantity.Unitless -> Basics.Float"},{"name":"toFloatQuantity","comment":" Convert a `Quantity Int units` to a `Quantity Float units` with the same\r\nvalue. Useful when you have an `Int`-valued quantity and want to divide it by\r\nsomething, multiply it by a fractional value etc.\r\n","type":"Quantity.Quantity Basics.Int units -> Quantity.Quantity Basics.Float units"},{"name":"toInt","comment":" Convert a `Quantity Int Unitless` value into a plain `Int`.\r\n","type":"Quantity.Quantity Basics.Int Quantity.Unitless -> Basics.Int"},{"name":"truncate","comment":" Round a `Float`-valued quantity towards zero.\r\n\r\n    Quantity.truncate (Pixels.pixels -2.8)\r\n    --> Pixels.pixels -2\r\n\r\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"zero","comment":" A generic zero value. This can be treated as either an `Int` or `Float`\r\nquantity in any units type, similar to how `Nothing` can be treated as any kind\r\nof `Maybe` type and `[]` can be treated as any kind of `List`.\r\n","type":"Quantity.Quantity number units"}],"binops":[]},{"name":"Resistance","comment":" A `Resistance` value represents an electrical resistance in ohms.\r\n\r\nNote that since `Ohms` is defined as `Rate Volts Amperes` (voltage per unit\r\ncurrent), you can construct a `Resistance` value using `Quantity.per`:\r\n\r\n    resistance =\r\n        voltage |> Quantity.per current\r\n\r\nYou can also do rate-related calculations with `Resistance` values to compute\r\n`Voltage` or `Current`:\r\n\r\n    voltage =\r\n        current |> Quantity.at resistance\r\n\r\n    current =\r\n        voltage |> Quantity.at_ resistance\r\n\r\n@docs Resistance, Ohms\r\n\r\n@docs ohms, inOhms\r\n\r\n","unions":[],"aliases":[{"name":"Ohms","comment":" ","args":[],"type":"Quantity.Rate Voltage.Volts Current.Amperes"},{"name":"Resistance","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Resistance.Ohms"}],"values":[{"name":"inOhms","comment":" Convert a resistance to a number of ohms.\r\n","type":"Resistance.Resistance -> Basics.Float"},{"name":"ohms","comment":" Construct a resistance from a number of ohms.\r\n","type":"Basics.Float -> Resistance.Resistance"}],"binops":[]},{"name":"Speed","comment":" A `Speed` value represents a speed in meters per second, miles per hour etc.\r\nIt is stored as a number of meters per second.\r\n\r\nNote that since `MetersPerSecond` is defined as `Rate Meters Seconds` (length\r\nper unit time), you can construct a `Speed` value using `Quantity.per`:\r\n\r\n    speed =\r\n        length |> Quantity.per duration\r\n\r\nYou can also do rate-related calculations with `Speed` values to compute\r\n`Length` or `Duration`:\r\n\r\n    length =\r\n        speed |> Quantity.for duration\r\n\r\n    alsoLength =\r\n        duration |> Quantity.at speed\r\n\r\n    duration =\r\n        length |> Quantity.at_ speed\r\n\r\n@docs Speed, MetersPerSecond\r\n\r\n@docs metersPerSecond, inMetersPerSecond, feetPerSecond, inFeetPerSecond\r\n@docs kilometersPerHour, inKilometersPerHour, milesPerHour, inMilesPerHour\r\n\r\n","unions":[],"aliases":[{"name":"MetersPerSecond","comment":" ","args":[],"type":"Quantity.Rate Length.Meters Duration.Seconds"},{"name":"Speed","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Speed.MetersPerSecond"}],"values":[{"name":"feetPerSecond","comment":" Construct a speed from a number of feet per second.\r\n","type":"Basics.Float -> Speed.Speed"},{"name":"inFeetPerSecond","comment":" Convert a speed to a number of feet per second.\r\n","type":"Speed.Speed -> Basics.Float"},{"name":"inKilometersPerHour","comment":" Convert a speed to a number of kilometers per hour.\r\n","type":"Speed.Speed -> Basics.Float"},{"name":"inMetersPerSecond","comment":" Convert a speed to a number of meters per second.\r\n","type":"Speed.Speed -> Basics.Float"},{"name":"inMilesPerHour","comment":" Convert a speed to a number of miles per hour.\r\n","type":"Speed.Speed -> Basics.Float"},{"name":"kilometersPerHour","comment":" Construct a speed from a number of kilometers per hour.\r\n","type":"Basics.Float -> Speed.Speed"},{"name":"metersPerSecond","comment":" Construct a speed from a number of meters per second.\r\n","type":"Basics.Float -> Speed.Speed"},{"name":"milesPerHour","comment":" Construct a speed from a number of miles per hour.\r\n","type":"Basics.Float -> Speed.Speed"}],"binops":[]},{"name":"SubstanceAmount","comment":" A `SubstanceAmount` value represents a substance amount in [moles][1].\r\n\r\n[1]: https://en.wikipedia.org/wiki/Mole_(unit)\r\n\r\n@docs SubstanceAmount, Moles\r\n@docs moles, inMoles, picomoles, inPicomoles, nanomoles, inNanomoles\r\n@docs micromoles, inMicromoles, millimoles, inMillimoles, kilomoles, inKilomoles\r\n@docs megamoles, inMegamoles, gigamoles, inGigamoles\r\n\r\n","unions":[{"name":"Moles","comment":" ","args":[],"cases":[]}],"aliases":[{"name":"SubstanceAmount","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float SubstanceAmount.Moles"}],"values":[{"name":"gigamoles","comment":" Construct a substance amount from a number of gigamoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"inGigamoles","comment":" Convert a substance amount to a number of gigamoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inKilomoles","comment":" Convert a substance amount to a number of kilomoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMegamoles","comment":" Convert a substance amount to a number of megamoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMicromoles","comment":" Convert a substance amount to a number of micromoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMillimoles","comment":" Convert a substance amount to a number of millimoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMoles","comment":" Convert a substance amount to a number of moles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inNanomoles","comment":" Convert a substance amount to a number of nanomoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inPicomoles","comment":" Convert a substance amount to a number of picomoles.\r\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"kilomoles","comment":" Construct a substance amount from a number of kilomoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"megamoles","comment":" Construct a substance amount from a number of megamoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"micromoles","comment":" Construct a substance amount from a number of micromoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"millimoles","comment":" Construct a substance amount from a number of millimoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"moles","comment":" Construct a substance amount from a number of moles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"nanomoles","comment":" Construct a substance amount from a number of nanomoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"picomoles","comment":" Construct a substance amount from a number of picomoles.\r\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"}],"binops":[]},{"name":"Temperature","comment":" Unlike other modules in `elm-units`, this module contains two different\r\nprimary types:\r\n\r\n  - `Temperature`, which is not actually a `Quantity` since temperatures don't\r\n    really act like normal quantities. For example, it doesn't make sense to\r\n    add two temperatures or find the ratio between them.\r\n  - `Delta`, which represents the difference between two temperatures. A `Delta`\r\n    _is_ a `Quantity` since it does make sense to add two deltas to get a net\r\n    delta, find the ratio between two deltas (one rise in temperature might be\r\n    twice as much as another rise in temperature), etc.\r\n\r\nSince a `Temperature` value is not a `Quantity`, this module exposes specialized\r\nfunctions for doing the operations on `Temperature` values that _do_ make sense,\r\nsuch as comparing two temperatures or sorting a list of temperatures. It's also\r\npossible to find the delta from one temperature to another using [`minus`](Temperature#minus),\r\nand then add a `Delta` to a `Temperature` using [`plus`](Temperature#plus).\r\n\r\n@docs Temperature, Delta, CelsiusDegrees\r\n\r\n\r\n# Temperatures\r\n\r\n@docs degreesCelsius, inDegreesCelsius, degreesFahrenheit, inDegreesFahrenheit, kelvins, inKelvins, absoluteZero\r\n\r\n\r\n# Deltas\r\n\r\nFollowing the suggestion mentioned [here](https://en.wikipedia.org/wiki/Celsius#Temperatures_and_intervals),\r\nthis module uses (for example) `celsiusDegrees` to indicate a temperature delta\r\n(change in temperature), in contrast to `degreesCelsius` which indicates an\r\nactual temperature.\r\n\r\n@docs celsiusDegrees, inCelsiusDegrees, fahrenheitDegrees, inFahrenheitDegrees\r\n\r\n\r\n# Comparison\r\n\r\n@docs lessThan, greaterThan, lessThanOrEqualTo, greaterThanOrEqualTo, compare, equalWithin, min, max\r\n\r\n\r\n# Arithmetic\r\n\r\n@docs plus, minus, clamp\r\n\r\n\r\n# List functions\r\n\r\n@docs minimum, maximum, sort, sortBy\r\n\r\n","unions":[{"name":"CelsiusDegrees","comment":" Tempereature deltas are stored as a number of Celsius degrees.\r\n","args":[],"cases":[]},{"name":"Temperature","comment":" A temperature such as 25 degrees Celsius or 80 degrees Fahrenheit.\r\n","args":[],"cases":[]}],"aliases":[{"name":"Delta","comment":" A `Delta` represents the difference between two temperatures.\r\n","args":[],"type":"Quantity.Quantity Basics.Float Temperature.CelsiusDegrees"}],"values":[{"name":"absoluteZero","comment":" [Absolute zero](https://en.wikipedia.org/wiki/Absolute_zero), equal to zero\r\nkelvins or -273.15 degrees Celsius.\r\n\r\n    Temperature.absoluteZero\r\n    --> Temperature.degreesCelsius -273.15\r\n\r\n","type":"Temperature.Temperature"},{"name":"celsiusDegrees","comment":" Construct a temperature delta from a number of Celsius degrees.\r\n","type":"Basics.Float -> Temperature.Delta"},{"name":"clamp","comment":" Given a lower and upper bound, clamp a given temperature to within those\r\nbounds. Say you wanted to clamp a temperature to be between 18 and 22 degrees\r\nCelsius:\r\n\r\n    lowerBound =\r\n        Temperature.degreesCelsius 18\r\n\r\n    upperBound =\r\n        Temperature.degreesCelsius 22\r\n\r\n    Temperature.degreesCelsius 25\r\n        |> Temperature.clamp lowerBound upperBound\r\n    --> Temperature.degreesCelsius 22\r\n\r\n    Temperature.degreesFahrenheit 67 -- approx 19.4 °C\r\n        |> Temperature.clamp lowerBound upperBound\r\n    --> Temperature.degreesFahrenheit 67\r\n\r\n    Temperature.absoluteZero\r\n        |> Temperature.clamp lowerBound upperBound\r\n    --> Temperature.degreesCelsius 18\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature"},{"name":"compare","comment":" Compare two temperatures, returning an [`Order`](https://package.elm-lang.org/packages/elm/core/latest/Basics#Order)\r\nvalue indicating whether the first is less than, equal to or greater than the\r\nsecond.\r\n\r\n    Temperature.compare\r\n        (Temperature.degreesCelsius 25)\r\n        (Temperature.degreesFahrenheit 75)\r\n    --> GT\r\n\r\n    Temperature.compare\r\n        (Temperature.degreesCelsius 25)\r\n        (Temperature.degreesFahrenheit 77)\r\n    --> EQ\r\n\r\n(Note that due to floating-point roundoff, you generally shouldn't rely on\r\ntemperatures comparing as exactly equal.)\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Order"},{"name":"degreesCelsius","comment":" Construct a temperature from a number of degrees Celsius.\r\n","type":"Basics.Float -> Temperature.Temperature"},{"name":"degreesFahrenheit","comment":" Construct a temperature from a number of degrees Fahrenheit.\r\n","type":"Basics.Float -> Temperature.Temperature"},{"name":"equalWithin","comment":" Check if two temperatures are equal within a given delta tolerance. The\r\ntolerance must be greater than or equal to zero - if it is negative, then the\r\nresult will always be false.\r\n\r\n    Temperature.equalWithin (Temperature.fahrenheitDegrees 1)\r\n        (Temperature.degreesCelsius 25)\r\n        (Temperature.degreesFahrenheit 75)\r\n    --> False\r\n\r\n    Temperature.equalWithin (Temperature.fahrenheitDegrees 3)\r\n        (Temperature.degreesCelsius 25)\r\n        (Temperature.degreesFahrenheit 75)\r\n    --> True\r\n\r\n","type":"Temperature.Delta -> Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"fahrenheitDegrees","comment":" Construct a temperature delta from a number of Fahrenheit degrees.\r\n\r\n    Temperature.fahrenheitDegrees 36\r\n    --> Temperature.celsiusDegrees 20\r\n\r\n","type":"Basics.Float -> Temperature.Delta"},{"name":"greaterThan","comment":" Check if one temperature is greater than another. Note the [argument order](/#argument-order)!\r\n\r\n    roomTemperature =\r\n        Temperature.degreesCelsius 21\r\n\r\n    Temperature.degreesFahrenheit 50\r\n        |> Temperature.greaterThan roomTemperature\r\n    --> False\r\n\r\n    -- Same as:\r\n    Temperature.greaterThan roomTemperature\r\n        (Temperature.degreesFahrenheit 50)\r\n    --> False\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"greaterThanOrEqualTo","comment":" Check if one temperature is greater than or equal to another. Note the\r\n[argument order](/#argument-order)!\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"inCelsiusDegrees","comment":" Convert a temperature delta to a number of Celsius degrees.\r\n","type":"Temperature.Delta -> Basics.Float"},{"name":"inDegreesCelsius","comment":" Convert a temperature to a number of degrees Celsius.\r\n","type":"Temperature.Temperature -> Basics.Float"},{"name":"inDegreesFahrenheit","comment":" Convert a temperature to a number of degrees Fahrenheit.\r\n","type":"Temperature.Temperature -> Basics.Float"},{"name":"inFahrenheitDegrees","comment":" Convert a temperature delta to a number of Fahrenheit degrees.\r\n\r\n    Temperature.celsiusDegrees 10\r\n        |> Temperature.inFahrenheitDegrees\r\n    --> 18\r\n\r\n","type":"Temperature.Delta -> Basics.Float"},{"name":"inKelvins","comment":" Convert a temperature to a number of kelvins.\r\n\r\n    Temperature.degreesCelsius 0\r\n        |> Temperature.inKelvins\r\n    --> 273.15\r\n\r\n","type":"Temperature.Temperature -> Basics.Float"},{"name":"kelvins","comment":" Construct a temperature from a number of [kelvins][kelvin].\r\n\r\n    Temperature.kelvins 300\r\n    --> Temperature.degreesCelsius 26.85\r\n\r\n[kelvin]: https://en.wikipedia.org/wiki/Kelvin \"Kelvin\"\r\n\r\n","type":"Basics.Float -> Temperature.Temperature"},{"name":"lessThan","comment":" Check if one temperature is less than another. Note the [argument order](/#argument-order)!\r\n\r\n    roomTemperature =\r\n        Temperature.degreesCelsius 21\r\n\r\n    Temperature.degreesFahrenheit 50\r\n        |> Temperature.lessThan roomTemperature\r\n    --> True\r\n\r\n    -- Same as:\r\n    Temperature.lessThan roomTemperature\r\n        (Temperature.degreesFahrenheit 50)\r\n    --> True\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"lessThanOrEqualTo","comment":" Check if one temperature is less than or equal to another. Note the\r\n[argument order](/#argument-order)!\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"max","comment":" Find the maximum of two temperatures.\r\n\r\n    Temperature.max\r\n        (Temperature.degreesCelsius 25)\r\n        (Temperature.degreesFahrenheit 75)\r\n    --> Temperature.degreesCelsius 25\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature"},{"name":"maximum","comment":" Find the maximum of a list of temperatures. Returns `Nothing` if the list\r\nis empty.\r\n\r\n    Temperature.maximum\r\n        [ Temperature.degreesCelsius 20\r\n        , Temperature.kelvins 300\r\n        , Temperature.degreesFahrenheit 74\r\n        ]\r\n    --> Just (Temperature.kelvins 300)\r\n\r\n","type":"List.List Temperature.Temperature -> Maybe.Maybe Temperature.Temperature"},{"name":"min","comment":" Find the minimum of two temperatures.\r\n\r\n    Temperature.min\r\n        (Temperature.degreesCelsius 25)\r\n        (Temperature.degreesFahrenheit 75)\r\n    --> Temperature.degreesFahrenheit 75\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature"},{"name":"minimum","comment":" Find the minimum of a list of temperatures. Returns `Nothing` if the list\r\nis empty.\r\n\r\n    Temperature.minimum\r\n        [ Temperature.degreesCelsius 20\r\n        , Temperature.kelvins 300\r\n        , Temperature.degreesFahrenheit 74\r\n        ]\r\n    --> Just (Temperature.degreesCelsius 20)\r\n\r\n","type":"List.List Temperature.Temperature -> Maybe.Maybe Temperature.Temperature"},{"name":"minus","comment":" Subtract one `Temperature` from another to get a `Delta`. Note the [argument\r\norder](/#argument-order)!\r\n\r\n    -- 25 degrees Celsius is 77 degrees Fahrenheit\r\n    start =\r\n        Temperature.degreesCelsius 25\r\n\r\n    end =\r\n        Temperature.degreesFahrenheit 80\r\n\r\n    end |> Temperature.minus start\r\n    --> Temperature.fahrenheitDegrees 3\r\n\r\n    start |> Temperature.minus end\r\n    --> Temperature.fahrenheitDegrees -3\r\n\r\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Delta"},{"name":"plus","comment":" Add a `Delta` to a `Temperature` to get a new `Temperature`.\r\n\r\n    Temperature.degreesCelsius 25\r\n        |> Temperature.plus\r\n            (Temperature.celsiusDegrees 7)\r\n    --> Temperature.degreesCelsius 32\r\n\r\nIf you want to _subtract_ a `Delta` from a `Temperature`, you can [`negate`](Quantity#negate)\r\nthe delta first and then call `plus`.\r\n\r\n","type":"Temperature.Delta -> Temperature.Temperature -> Temperature.Temperature"},{"name":"sort","comment":" Sort a list of temperatures from lowest to highest.\r\n\r\n    Temperature.sort\r\n        [ Temperature.degreesCelsius 20\r\n        , Temperature.kelvins 300\r\n        , Temperature.degreesFahrenheit 74\r\n        ]\r\n    --> [ Temperature.degreesCelsius 20\r\n    --> , Temperature.degreesFahrenheit 74\r\n    --> , Temperature.kelvins 300\r\n    --> ]\r\n\r\n","type":"List.List Temperature.Temperature -> List.List Temperature.Temperature"},{"name":"sortBy","comment":" Sort an arbitrary list of values by a derived `Temperature`. If you had\r\n\r\n    rooms =\r\n        [ ( \"Lobby\", Temperature.degreesCelsius 21 )\r\n        , ( \"Locker room\", Temperature.degreesCelsius 17 )\r\n        , ( \"Rink\", Temperature.degreesCelsius -4 )\r\n        , ( \"Sauna\", Temperature.degreesCelsius 82 )\r\n        ]\r\n\r\nthen you could sort by temperature with\r\n\r\n    Temperature.sortBy Tuple.second rooms\r\n    --> [ ( \"Rink\", Temperature.degreesCelsius -4 )\r\n    --> , ( \"Locker room\", Temperature.degreesCelsius 17 )\r\n    --> , ( \"Lobby\", Temperature.degreesCelsius 21 )\r\n    --> , ( \"Sauna\", Temperature.degreesCelsius 82 )\r\n    --> ]\r\n\r\n","type":"(a -> Temperature.Temperature) -> List.List a -> List.List a"}],"binops":[]},{"name":"Voltage","comment":" A `Voltage` value represents a voltage (electric potential difference, if\r\nwe're being picky) in volts.\r\n\r\nNote that since `Volts` is defined as `Rate Watts Amperes` (power per unit\r\ncurrent), you can do rate-related calculations with `Voltage` values to compute\r\n`Power` or `Current`:\r\n\r\n    -- elm-units version of 'P = V * I'\r\n    power =\r\n        current |> Quantity.at voltage\r\n\r\n    -- I = P / V\r\n    current =\r\n        power |> Quantity.at_ voltage\r\n\r\nJust for fun, note that since you can also [express `Voltage` in terms of\r\n`Current` and `Resistance`](Resistance), you could rewrite the second example\r\nabove as\r\n\r\n    -- P = I^2 * R\r\n    power =\r\n        current\r\n            |> Quantity.at\r\n                (current\r\n                    |> Quantity.at resistance\r\n                )\r\n\r\n@docs Voltage, Volts\r\n\r\n@docs volts, inVolts\r\n\r\n","unions":[],"aliases":[{"name":"Voltage","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Voltage.Volts"},{"name":"Volts","comment":" ","args":[],"type":"Quantity.Rate Power.Watts Current.Amperes"}],"values":[{"name":"inVolts","comment":" Convert a voltage to a number of volts.\r\n","type":"Voltage.Voltage -> Basics.Float"},{"name":"volts","comment":" Construct a voltage from a number of volts.\r\n","type":"Basics.Float -> Voltage.Voltage"}],"binops":[]},{"name":"Volume","comment":" A `Volume` represents a volume in cubic meters, cubic feet, liters, US\r\nliquid gallons, imperial fluid ounces etc. It is stored as a number of cubic\r\nmeters.\r\n\r\n@docs Volume, CubicMeters\r\n\r\n\r\n## Metric\r\n\r\n@docs cubicMeters, inCubicMeters\r\n@docs milliliters, inMilliliters, liters, inLiters\r\n\r\n\r\n## Imperial\r\n\r\n@docs cubicInches, inCubicInches, cubicFeet, inCubicFeet, cubicYards, inCubicYards\r\n@docs usLiquidGallons, inUsLiquidGallons, usDryGallons, inUsDryGallons, imperialGallons, inImperialGallons\r\n@docs usLiquidQuarts, inUsLiquidQuarts, usDryQuarts, inUsDryQuarts, imperialQuarts, inImperialQuarts\r\n@docs usLiquidPints, inUsLiquidPints, usDryPints, inUsDryPints, imperialPints, inImperialPints\r\n@docs usFluidOunces, inUsFluidOunces, imperialFluidOunces, inImperialFluidOunces\r\n\r\n","unions":[],"aliases":[{"name":"CubicMeters","comment":" ","args":[],"type":"Quantity.Cubed Length.Meters"},{"name":"Volume","comment":" ","args":[],"type":"Quantity.Quantity Basics.Float Volume.CubicMeters"}],"values":[{"name":"cubicFeet","comment":" Construct a volume from a number of cubic feet.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"cubicInches","comment":" Construct a volume from a number of cubic inches.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"cubicMeters","comment":" Construct a volume from a number of cubic meters.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"cubicYards","comment":" Construct a volume from a number of cubic yards.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialFluidOunces","comment":" Construct a volume from a number of imperial fluid ounces.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialGallons","comment":" Construct a volume from a number of imperial gallons.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialPints","comment":" Construct a volume from a number of imperial pints.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialQuarts","comment":" Construct a volume from a number of imperial quarts.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"inCubicFeet","comment":" Convert a volume to a number of cubic feet.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inCubicInches","comment":" Convert a volume to a number of cubic inches.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inCubicMeters","comment":" Convert a volume to a number of cubic meters.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inCubicYards","comment":" Convert a volume to a number of cubic yards.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialFluidOunces","comment":" Convert a volume to a number of imperial fluid ounces.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialGallons","comment":" Convert a volume to a number of imperial gallons.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialPints","comment":" Convert a volume to a number of imperial pints.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialQuarts","comment":" Convert a volume to a number of imperial quarts.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inLiters","comment":" Convert a volume to a number of liters.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inMilliliters","comment":" Convert a volume to a number of milliliters.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsDryGallons","comment":" Convert a volume to a number of U.S. dry gallons.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsDryPints","comment":" Convert a volume to a number of U.S. dry pints.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsDryQuarts","comment":" Convert a volume to a number of U.S. dry quarts.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsFluidOunces","comment":" Convert a volume to a number of U.S. fluid ounces.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsLiquidGallons","comment":" Convert a volume to a number of U.S. liquid gallons.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsLiquidPints","comment":" Convert a volume to a number of U.S. liquid pints.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsLiquidQuarts","comment":" Convert a volume to a number of U.S. liquid quarts.\r\n","type":"Volume.Volume -> Basics.Float"},{"name":"liters","comment":" Construct a volume from a number of liters.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"milliliters","comment":" Construct a volume from a number of milliliters.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usDryGallons","comment":" Construct a volume from a number of U.S. dry gallons.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usDryPints","comment":" Construct a volume from a number of U.S. dry pints.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usDryQuarts","comment":" Construct a volume from a number of U.S. dry quarts.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usFluidOunces","comment":" Construct a volume from a number of U.S. fluid ounces.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usLiquidGallons","comment":" Construct a volume from a number of U.S. liquid gallon.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usLiquidPints","comment":" Construct a volume from a number of U.S. liquid pints.\r\n","type":"Basics.Float -> Volume.Volume"},{"name":"usLiquidQuarts","comment":" Construct a volume from a number of U.S. liquid quarts.\r\n","type":"Basics.Float -> Volume.Volume"}],"binops":[]}]