[{"name":"Angle.Interval","comment":"\n\n@docs sin, cos\n\n","unions":[],"aliases":[],"values":[{"name":"cos","comment":" For a given range of angle values θ, determine the possible range of values\nof cos(θ).\n\n    Angle.Interval.cos <|\n        Interval.from Quantity.zero (Angle.degrees 45)\n    --> Interval.from\n    -->     (Quantity.float 0.7071)\n    -->     (Quantity.float 1)\n\n    Angle.Interval.cos <|\n        Interval.from Quantity.zero (Angle.degrees 180)\n    --> Interval.from\n    -->     (Quantity.float -1)\n    -->     (Quantity.float 1)\n\n","type":"Angle.Interval.Interval -> Quantity.Interval.Interval Basics.Float Quantity.Unitless"},{"name":"sin","comment":" For a given range of angle values θ, determine the possible range of values\nof sin(θ).\n\n    Angle.Interval.sin <|\n        Interval.from Quantity.zero (Angle.degrees 45)\n    --> Interval.from Quantity.zero (Quantity.float 0.7071)\n\n    Angle.Interval.sin <|\n        Interval.from Quantity.zero (Angle.degrees 180)\n    --> Interval.from Quantity.zero (Quantity.float 1)\n\n","type":"Angle.Interval.Interval -> Quantity.Interval.Interval Basics.Float Quantity.Unitless"}],"binops":[]},{"name":"Quantity.Interval","comment":" This modules contains most of the core functionality for creating and\nworking with `Interval` values.\n\nNote: most examples assume that you have imported this module as\n\n    import Quantity.Interval as Interval\n\n@docs Interval\n\n\n# Constructors\n\n@docs from, fromEndpoints, singleton\n\n\n## Booleans\n\n@docs union, intersection\n\n\n## Hull\n\nThese functions let you construct an `Interval` containing one or more input\nvalues.\n\n@docs hull, hullN, hullOf, hullOfN, hull3\n\n\n## Aggregation\n\nThese functions let you 'aggregate' one or more intervals into a single larger\ninterval that contains all of them.\n\n@docs aggregate, aggregateN, aggregateOf, aggregateOfN, aggregate3\n\n\n# Properties\n\n@docs endpoints, minValue, maxValue, midpoint, width\n\n\n# Queries\n\n@docs contains, isContainedIn, intersects, isSingleton\n\n\n# Interpolation\n\n@docs interpolate, interpolationParameter\n\n\n# Arithmetic\n\nThese functions let you do math with `Interval` values, following the rules of\n[interval arithmetic](https://en.wikipedia.org/wiki/Interval_arithmetic).\n\n@docs negate, add, subtract, multiplyBy, divideBy, half, twice\n@docs plus, minus\n\n","unions":[{"name":"Interval","comment":" Represents a finite, closed interval with a minimum and maximum value.\n\nThe two type parameters match those of the [`Quantity`](https://package.elm-lang.org/packages/ianmackenzie/elm-units/latest/Quantity)\ntype from `elm-units`. For example, an `Interval Int Pixels` might represent a\nvalue between 200 and 300 pixels, and an `Interval Float Meters` might represent\na value between 2.5 and 3.7 centimeters. (As with the `Quantity` type, the\n`units` type parameter refers to the _base_ unit of a particular quantity type;\nlengths in meters, centimeters, feet, miles etc. are all internally stored in\nmeters.)\n\n","args":["number","units"],"cases":[]}],"aliases":[],"values":[{"name":"add","comment":" Add the given amount to an interval:\n\n    lengthInterval =\n        Interval.from\n            (Length.meters 2)\n            (Length.meters 3)\n\n    lengthInterval |> Interval.add (Length.centinmeters 20)\n    --> Interval.from\n    -->     (Length.meters 2.2)\n    -->     (Length.meters 3.2)\n\n","type":"Quantity.Quantity number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"aggregate","comment":" Construct an interval containing one or more given intervals:\n\n    Interval.aggregate\n        (Interval.singleton (Length.feet 2))\n        [ Interval.from\n            (Length.feet 3)\n            (Length.feet 4)\n        ]\n    --> Interval.from (Length.feet 2) (Length.feet 4)\n\nWorks much like [`hull`](#hull). See also [`aggregateN`](#aggregateN).\n\n","type":"Quantity.Interval.Interval number units -> List.List (Quantity.Interval.Interval number units) -> Quantity.Interval.Interval number units"},{"name":"aggregate3","comment":" Special case of [`aggregate`](#aggregate) for the case of three intervals;\n\n    Interval.aggregate3 first second third\n\nis equivalent to\n\n    Interval.aggregate first [ second, third ]\n\nbut is more efficient. (If you're looking for an `aggregate2` function,\n[`union`](#union) should do what you want.)\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"aggregateN","comment":" Attemp to construct an interval containing all of the intervals in the given\nlist. If the list is empty, returns `Nothing`. If you know you have at least one\ninterval, you can use [`aggregate`](#aggregate) instead.\n","type":"List.List (Quantity.Interval.Interval number units) -> Maybe.Maybe (Quantity.Interval.Interval number units)"},{"name":"aggregateOf","comment":" Like [`aggregate`](#aggregate), but lets you work on any kind of item as\nlong as an interval can be generated from it (similar to [`hullOf`](#hullOf)).\n","type":"(a -> Quantity.Interval.Interval number units) -> a -> List.List a -> Quantity.Interval.Interval number units"},{"name":"aggregateOfN","comment":" Combination of [`aggregateOf`](#aggregateOf) and [`aggregateN`](#aggregateN).\n","type":"(a -> Quantity.Interval.Interval number units) -> List.List a -> Maybe.Maybe (Quantity.Interval.Interval number units)"},{"name":"contains","comment":" Check if an interval contains a given value:\n\n    angleInterval =\n        Interval.from\n            (Angle.degrees -10)\n            (Angle.degrees 30)\n\n    angleInterval |> Interval.contains (Angle.degrees 0)\n    --> True\n\n    angleInterval |> Interval.contains (Angle.degrees 45)\n    --> False\n\nThe minimum and maximum values of an interval are considered to be contained in\nthe interval (but be careful of numerical roundoff):\n\n    angleInterval |> Interval.contains (Angle.degrees 30)\n    --> True\n\n","type":"Quantity.Quantity number units -> Quantity.Interval.Interval number units -> Basics.Bool"},{"name":"divideBy","comment":" Divide an interval by a given value:\n\n    Interval.divideBy 2 <|\n        Interval.from (Length.feet 2) (Length.feet 3)\n    --> Interval.from (Length.feet 1) (Length.feet 1.5)\n\nNote that this will flip the order of the interval's endpoints if the given\nvalue is negative:\n\n    Interval.divideBy -2 <|\n        Interval.from\n            (Angle.degrees 20)\n            (Angle.degrees 30)\n    --> Interval.from\n    -->     (Angle.degrees -15)\n    -->     (Angle.degrees -10)\n\n","type":"Basics.Float -> Quantity.Interval.Interval Basics.Float units -> Quantity.Interval.Interval Basics.Float units"},{"name":"endpoints","comment":" Get the endpoints of an interval (its minimum and maximum values) as a\ntuple. The first value will always be less than or equal to the second.\n\n    ( minValue, maxValue ) =\n        Interval.endpoints someInterval\n\nFor any interval,\n\n    Interval.endpoints interval\n\nis equivalent to (but more efficient than)\n\n    ( Interval.minValue interval\n    , Interval.maxValue interval\n    )\n\n","type":"Quantity.Interval.Interval number units -> ( Quantity.Quantity number units, Quantity.Quantity number units )"},{"name":"from","comment":" Construct an interval containing the two given values (which can be provided\nin either order).\n\n    -- \"The heights of people participating in the study\n    -- ranged from 1.2 to 1.9 meters\"\n    heightRange =\n        Interval.from\n            (Length.meters 1.2)\n            (Length.meters 1.9)\n\n    -- \"Please allow 4 to 6 weeks for delivery\"\n    estimatedShippingTime =\n        Interval.from\n            (Duration.weeks 4)\n            (Duration.weeks 6)\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Interval.Interval number units"},{"name":"fromEndpoints","comment":" Construct an interval from its endpoints (the minimum and maximum values of\nthe interval).\n\n    highwayCarSpeeds =\n        Interval.fromEndpoints\n            ( Speed.kilometersPerHour 90\n            , Speed.kilometersPerHour 130\n            )\n\nThe two values should be given in order but will be swapped if\nnecessary to ensure a valid interval is returned:\n\n    Interval.endpoints <|\n        Interval.fromEndpoints\n            ( Speed.kilometersPerHour 130\n            , Speed.kilometersPerHour 90\n            )\n    --> ( Speed.kilometersPerHour 90\n    --> , Speed.kilometersPerHour 130\n    --> )\n\n","type":"( Quantity.Quantity number units, Quantity.Quantity number units ) -> Quantity.Interval.Interval number units"},{"name":"half","comment":" Shorthand for `multiplyBy 0.5`.\n","type":"Quantity.Interval.Interval Basics.Float units -> Quantity.Interval.Interval Basics.Float units"},{"name":"hull","comment":" Find the interval containing one or more input values, by passing the first\nvalue as the first argument and then a list of all other values as the second\nargument. For example, to find the interval containing the values 5 cm, 2 cm,\n3 cm and 4 cm:\n\n    Interval.hull\n        (Length.centimeters 5)\n        [ Length.centimeters 3\n        , Length.centimeters 2\n        , Length.centimeters 4\n        ]\n    --> Interval.from\n    -->     (Length.centimeters 2)\n    -->     (Length.centimeters 5)\n\nWhy pass the first and all other values as separate arguments? It lets this\nfunction return an `Interval` instead of a `Maybe Interval`. If there was just a\nsingle list as an argument, then this function would have to handle the case of\nan empty list being passed by returning `Nothing`. As a result, when using this\nfunction you often end up using it within a `case` expression:\n\n    case values of\n        [] ->\n            -- some default behavior\n\n        first :: rest ->\n            let\n                interval =\n                    Interval.hull first rest\n            in\n            -- normal behavior using 'interval'\n\nIf you do want the simpler behavior of taking a single list and returning a\n`Maybe Interval`, check out [`hullN`](#hullN).\n\n","type":"Quantity.Quantity number units -> List.List (Quantity.Quantity number units) -> Quantity.Interval.Interval number units"},{"name":"hull3","comment":" Construct an interval containing the three given values;\n\n    Interval.hull3 a b c\n\nis equivalent to\n\n    Interval.hull a [ b, c ]\n\nbut is more efficient. (If you're looking for a `hull2` function, [`from`](#from)\nshould do what you want.)\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Interval.Interval number units"},{"name":"hullN","comment":" Attempt to construct an interval containing all _N_ values in the given\nlist. If the list is empty, returns `Nothing`. If you know you have at least one\nvalue, you can use [`hull`](#hull) instead.\n\n    Interval.hullN\n        [ Duration.hours 2\n        , Duration.hours 1\n        , Duration.hours 3\n        ]\n    --> Just <|\n    -->     Interval.from\n    -->         (Duration.hours 1)\n    -->         (Duration.hours 3)\n\n    Interval.hullN [ Duration.hours 5]\n    --> Just (Interval.singleton (Duration.hours 5))\n\n    Interval.hullN []\n    --> Nothing\n\n","type":"List.List (Quantity.Quantity number units) -> Maybe.Maybe (Quantity.Interval.Interval number units)"},{"name":"hullOf","comment":" Like [`hull`](#hull), but lets you work on any kind of item as long as a\n`Quantity` of some kind can be extracted from it. For example, if you had\n\n    type alias Person =\n        { name : String\n        , age : Duration\n        }\n\nthen given some people you could find their range of ages as an `Interval Float\nSeconds` using\n\n    Interval.hullOf .age\n        firstPerson\n        [ secondPerson\n        , thirdPerson\n        , fourthPerson\n        ]\n\nSee also [`hullOfN`](#hullOfN).\n\n","type":"(a -> Quantity.Quantity number units) -> a -> List.List a -> Quantity.Interval.Interval number units"},{"name":"hullOfN","comment":" Combination of [`hullOf`](#hullOf) and [`hullN`](#hullN).\n","type":"(a -> Quantity.Quantity number units) -> List.List a -> Maybe.Maybe (Quantity.Interval.Interval number units)"},{"name":"interpolate","comment":" Interpolate between an interval's endpoints based on a parameter value. A\nvalue of 0.0 corresponds to the minimum value of the interval, a value of 0.5\ncorresponds to its midpoint and a value of 1.0 corresponds to its maximum value:\n\n    lengthInterval =\n        Interval.from (Length.meters 1) (Length.meters 5)\n\n    Interval.interpolate lengthInterval 0\n    --> Length.meters 1\n\n    Interval.interpolate lengthInterval 0.75\n    --> Length.meters 4\n\nValues less than 0.0 or greater than 1.0 can be used to extrapolate:\n\n    Interval.interpolate lengthInterval 1.5\n    --> Length.meters 7\n\nNote that because of how [`Interval.from`](#from) works, the interpolation is in\nfact from the minimum value to the maximum, _not_ \"from the first\n`Interval.from` argument to the second\":\n\n    Interval.interpolate\n        (Interval.from\n            (Length.meters 0)\n            (Length.meters 10)\n        )\n        0.2\n    --> 2\n\n    Interval.interpolate\n        (Interval.from\n            (Length.meters 10)\n            (Length.meters 0)\n        )\n        0.2\n    --> 2 -- not 8!\n\nIf you want to interpolate from one number down to another, you can use\n[`Quantity.interpolateFrom`](https://package.elm-lang.org/packages/ianmackenzie/elm-units/latest/Quantity#interpolateFrom)\nfrom the `elm-units` package.\n\n","type":"Quantity.Interval.Interval Basics.Float units -> Basics.Float -> Quantity.Quantity Basics.Float units"},{"name":"interpolationParameter","comment":" Given an interval and a given value, determine the corresponding\ninterpolation parameter (the parameter that you would pass to [`interpolate`](#interpolate)\nto get the given value):\n\n    Interval.interpolationParameter\n        (Interval.from\n            (Duration.minutes 10)\n            (Duration.minutes 15)\n        )\n        (Duration.minutes 12)\n    --> 0.4\n\nThe result will be between 0 and 1 if (and only if) the given value is contained\nin the given interval:\n\n    Interval.interpolationParameter\n        (Interval.from\n            (Duration.minutes 10)\n            (Duration.minutes 15)\n        )\n        (Duration.minutes 18)\n    --> 1.6\n\n    Interval.interpolationParameter\n        (Interval.from\n            (Duration.minutes 10)\n            (Duration.minutes 15)\n        )\n        (Duration.minutes 9)\n    --> -0.2\n\nThis is the inverse of `interpolate`; for any non-zero-width `interval`,\n\n    Interval.interpolationParameter interval value\n        |> Interval.interpolate interval\n\nshould be equal to the original `value` (within numerical roundoff).\n\n","type":"Quantity.Interval.Interval Basics.Float units -> Quantity.Quantity Basics.Float units -> Basics.Float"},{"name":"intersection","comment":" Attempt to construct an interval containing all the values common to both\ngiven intervals. If the intervals do not intersect, returns `Nothing`.\n\n    Interval.intersection\n        (Interval.from (Mass.grams 1) (Mass.grams 3))\n        (Interval.from (Mass.grams 2) (Mass.grams 5))\n    --> Just (Interval.from (Mass.grams 2) (Mass.grams 3))\n\n    Interval.intersection\n        (Interval.from (Mass.grams 1) (Mass.grams 3))\n        (Interval.from (Mass.grams 4) (Mass.grams 7))\n    --> Nothing\n\nIf the two intervals just touch, a singleton interval will be returned:\n\n    Interval.intersection\n        (Interval.from (Mass.grams 1) (Mass.grams 3))\n        (Interval.from (Mass.grams 3) (Mass.grams 5))\n    --> Just (Interval.singleton (Mass.grams 3))\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Maybe.Maybe (Quantity.Interval.Interval number units)"},{"name":"intersects","comment":" Check if two intervals touch or overlap (have any values in common).\n\n    distanceInterval =\n        Interval.from\n            (Length.kilometers 5)\n            (Length.kilometers 10)\n\n    distanceInterval\n        |> Interval.intersects\n            (Interval.from\n                (Length.kilometers 8)\n                (Length.kilometers 12)\n            )\n    --> True\n\n    distanceInterval\n        |> Interval.intersects\n            (Interval.from\n                (Length.kilometers 12)\n                (Length.kilometers 15)\n            )\n    --> False\n\nIntervals that just touch each other are considered to intersect (this is\nconsistent with `intersection` which will return a zero-width interval for the\nintersection of two just-touching intervals):\n\n    distanceInterval\n        |> Interval.intersects\n            (Interval.from\n                (Length.kilometers 10)\n                (Length.kilometers 15)\n            )\n    --> True\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Basics.Bool"},{"name":"isContainedIn","comment":" Check if the second interval is fully contained in the first.\n\n    angleInterval =\n        Interval.from\n            (Angle.degrees -30)\n            (Angle.degrees 30)\n\n    Interval.from (Angle.degrees -5) (Angle.degrees 15)\n        |> Interval.isContainedIn angleInterval\n    --> True\n\n    Interval.from (Angle.degrees 15) (Angle.degrees 45)\n        |> Interval.isContainedIn angleInterval\n    --> False\n\nBe careful with the argument order! If not using the `|>` operator, the first\nexample would be written as:\n\n    Interval.isContainedIn angleInterval\n        (Interval.from\n            (Angle.degrees -5)\n            (Angle.degrees 15)\n        )\n    --> True\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Basics.Bool"},{"name":"isSingleton","comment":" Check if the interval is a singleton (the minimum and maximum values are the\nsame).\n\n    Interval.isSingleton <|\n        Interval.from (Length.meters 2) (Length.meters 2)\n    --> True\n\n    Interval.isSingleton <|\n        Interval.from (Length.meters 2) (Length.meters 3)\n    --> False\n\n","type":"Quantity.Interval.Interval number units -> Basics.Bool"},{"name":"maxValue","comment":" Get the maximum value of an interval.\n","type":"Quantity.Interval.Interval number units -> Quantity.Quantity number units"},{"name":"midpoint","comment":" Get the midpoint of an interval.\n\n    Interval.midpoint <|\n        Interval.from\n            (Duration.hours 2)\n            (Duration.hours 3)\n    --> Duration.hours 2.5\n\n","type":"Quantity.Interval.Interval Basics.Float units -> Quantity.Quantity Basics.Float units"},{"name":"minValue","comment":" Get the minimum value of an interval.\n","type":"Quantity.Interval.Interval number units -> Quantity.Quantity number units"},{"name":"minus","comment":" Subtract the first interval from the second. This means that `minus` makes\nthe most sense when using `|>`:\n\n    firstInterval =\n        Interval.from (Length.feet 5) (Length.feet 10)\n\n    secondInterval =\n        Interval.from (Length.feet 2) (Length.feet 3)\n\n    firstInterval |> Interval.minus secondInterval\n    --> Interval.from (Length.feet 2) (Length.feet 8)\n\nWithout the pipe operator, the above would be written as:\n\n    Interval.minus secondInterval firstInterval\n    --> Interval.from 2 8\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"multiplyBy","comment":" Multiply an interval by a given value:\n\n    Interval.multiplyBy 5 <|\n        Interval.from\n            (Duration.minutes 20)\n            (Duration.minutes 30)\n    --> Interval.from\n    -->     (Duration.minutes 100)\n    -->     (Duration.minutes 150)\n\nNote that this will flip the order of the interval's endpoints if the given\nvalue is negative:\n\n    Interval.multiplyBy -2 <|\n        Interval.from\n            (Angle.degrees 20)\n            (Angle.degrees 30)\n    --> Interval.from\n    -->     (Angle.degrees -60)\n    -->     (Angle.degrees -40)\n\n","type":"number -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"negate","comment":" Negate an interval. Note that this will flip the order of the endpoints.\n\n    Interval.negate <|\n        Interval.from\n            (Angle.degrees 20)\n            (Angle.degrees 30)\n    --> Interval.from\n    -->     (Angle.degrees -30)\n    -->     (Angle.degrees -20)\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"plus","comment":" Add two intervals together.\n\n    firstInterval =\n        Interval.from (Length.feet 5) (Length.feet 10)\n\n    secondInterval =\n        Interval.from (Length.feet 2) (Length.feet 3)\n\n    firstInterval |> Interval.plus secondInterval\n    --> Interval.from (Length.feet 7) (Length.feet 13)\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"singleton","comment":" Construct a zero-width interval containing a single value.\n\n    Interval.singleton (Length.meters 3)\n    --> Interval.fromEndpoints\n    -->     ( Length.meters 3\n    -->     , Length.meters 3\n    -->     )\n\n","type":"Quantity.Quantity number units -> Quantity.Interval.Interval number units"},{"name":"subtract","comment":" Subtract the given amount from an interval.\n\n    angleInterval =\n        Interval.from\n            (Angle.degrees -10)\n            (Angle.degrees 50)\n\n    angleInterval |> Interval.subtract (Angle.degrees 30)\n    --> Interval.from\n    -->     (Angle.degrees -40)\n    -->     (Angle.degrees 20)\n\n","type":"Quantity.Quantity number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"twice","comment":" Shorthand for `multiplyBy 2`.\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"union","comment":" Construct an interval containing both of the given intervals.\n\n    firstInterval =\n        Interval.from (Length.feet 1) (Length.feet 2)\n\n    secondInterval =\n        Interval.from (Length.feet 3) (Length.feet 6)\n\n    Interval.union firstInterval secondInterval\n    --> Interval.from (Length.feet 1) (Length.feet 6)\n\n(Note that this is not strictly speaking a 'union' in the precise mathematical\nsense, since the result will contain values that are _in between_ the two given\nintervals and not actually _in_ either of them if those two intervals do not\noverlap.)\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units -> Quantity.Interval.Interval number units"},{"name":"width","comment":" Get the width of an interval.\n\n    Interval.width <|\n        Interval.from\n            (Length.meters 1.2)\n            (Length.meters 1.35)\n    --> Length.centimeters 15\n\n","type":"Quantity.Interval.Interval number units -> Quantity.Quantity number units"}],"binops":[]},{"name":"Temperature.Interval","comment":" This module behaves much like [`Quantity.Interval`](Quantity-Interval), but\nworks on [`Temperature`](https://package.elm-lang.org/packages/ianmackenzie/elm-units/latest/Temperature)\nvalues.\n\n@docs Interval\n\n\n# Constructors\n\n@docs from, fromEndpoints, singleton\n\n\n## Booleans\n\n@docs union, intersection\n\n\n## Hull\n\nThese functions let you construct an `Interval` containing one or more input\ntemperatures.\n\n@docs hull, hullN, hullOf, hullOfN\n\n\n## Aggregation\n\nThese functions let you 'aggregate' one or more temperature intervals into a\nsingle larger interval that contains all of them.\n\n@docs aggregate, aggregateN, aggregateOf, aggregateOfN\n\n\n# Properties\n\n@docs endpoints, minValue, maxValue, midpoint, width\n\n\n# Queries\n\n@docs contains, isContainedIn, intersects, isSingleton\n\n\n# Interpolation\n\n@docs interpolate, interpolationParameter\n\n\n# Arithmetic\n\n@docs add, subtract\n\nThe `plus` and `minus` functions both involve `Interval Float CelsiusDegrees`\nvalues, where `Interval` in this case refers to the type in the\n`Quantity.Interval` module. This represents an interval of [temperature deltas](Temperatur#Delta).\n\n@docs plus, minus\n\n","unions":[{"name":"Interval","comment":" Represents a finite, closed interval with a minimum and maximum temperature,\nfor example the interval from 20 to 30 degrees Celsius.\n","args":[],"cases":[]}],"aliases":[],"values":[{"name":"add","comment":" Add a [temperature delta](Temperature#Delta) to a temperature interval.\n","type":"Temperature.Delta -> Temperature.Interval.Interval -> Temperature.Interval.Interval"},{"name":"aggregate","comment":" Construct an interval containing one or more given intervals.\n","type":"Temperature.Interval.Interval -> List.List Temperature.Interval.Interval -> Temperature.Interval.Interval"},{"name":"aggregateN","comment":" Construct an interval containing all of the intervals in the given list. If\nthe list is empty, returns `Nothing`.\n","type":"List.List Temperature.Interval.Interval -> Maybe.Maybe Temperature.Interval.Interval"},{"name":"aggregateOf","comment":" Like [`aggregate`](#aggregate), but lets you work on any kind of item as\nlong as a temperature interval can be generated from it (similar to [`hullOf`](#hullOf)).\n","type":"(a -> Temperature.Interval.Interval) -> a -> List.List a -> Temperature.Interval.Interval"},{"name":"aggregateOfN","comment":" Combination of [`aggregateOf`](#aggregateOf) and [`aggregateN`](#aggregateN).\n","type":"(a -> Temperature.Interval.Interval) -> List.List a -> Maybe.Maybe Temperature.Interval.Interval"},{"name":"contains","comment":" Check if an interval contains a given temperature. The minimum and maximum\ntemperatures of the interval are considered to be contained in the interval.\n","type":"Temperature.Temperature -> Temperature.Interval.Interval -> Basics.Bool"},{"name":"endpoints","comment":" Get the endpoints of an interval (its minimum and maximum temperatures) as a\ntuple. The first temperature will always be less than or equal to the second.\n","type":"Temperature.Interval.Interval -> ( Temperature.Temperature, Temperature.Temperature )"},{"name":"from","comment":" Construct an interval with the two given endpoints (which can be provided in\neither order).\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Interval.Interval"},{"name":"fromEndpoints","comment":" Construct an interval from its endpoints (the minimum and maximum\ntemperatures of the interval). The two values should be given in order but will\nbe swapped if necessary to ensure a valid interval is returned.\n","type":"( Temperature.Temperature, Temperature.Temperature ) -> Temperature.Interval.Interval"},{"name":"hull","comment":" Construct an interval containing one or more input temperatures.\n","type":"Temperature.Temperature -> List.List Temperature.Temperature -> Temperature.Interval.Interval"},{"name":"hullN","comment":" Construct an interval containing all temperatures in the given list. If the\nlist is empty, returns `Nothing`.\n","type":"List.List Temperature.Temperature -> Maybe.Maybe Temperature.Interval.Interval"},{"name":"hullOf","comment":" Like [`hull`](#hull), but lets you work on any kind of item as long as a\n`Temperature` can be extracted from it:\n\n    type alias WeatherMeasurement =\n        { windSpeed : Speed\n        , temperature : Temperature\n        , barometricPressure : Pressure\n        }\n\n    temperatureRange =\n        Temperature.Interval.hullOf .temperature <|\n            measurement1\n            [ measurement2\n            , measurement3\n            , measurement4\n            ]\n\n","type":"(a -> Temperature.Temperature) -> a -> List.List a -> Temperature.Interval.Interval"},{"name":"hullOfN","comment":" Combination of [`hullOf`](#hullOf) and [`hullN`](#hullN).\n","type":"(a -> Temperature.Temperature) -> List.List a -> Maybe.Maybe Temperature.Interval.Interval"},{"name":"interpolate","comment":" Interpolate between an interval's endpoints; a value of 0.0 corresponds to\nthe minimum temperature of the interval, a value of 0.5 corresponds to its\nmidpoint and a value of 1.0 corresponds to its maximum temperature. Values less\nthan 0.0 or greater than 1.0 can be used to extrapolate.\n","type":"Temperature.Interval.Interval -> Basics.Float -> Temperature.Temperature"},{"name":"interpolationParameter","comment":" Given an interval and a given value, determine the corresponding\ninterpolation parameter (the parameter that you would pass to [`interpolate`](#interpolate)\nto get the given value).\n","type":"Temperature.Interval.Interval -> Temperature.Temperature -> Basics.Float"},{"name":"intersection","comment":" Attempt to construct an interval containing all the temperatures common to\nboth given intervals. If the intervals do not intersect, returns `Nothing`. If\nthe two intervals just touch, a singleton interval will be returned.\n","type":"Temperature.Interval.Interval -> Temperature.Interval.Interval -> Maybe.Maybe Temperature.Interval.Interval"},{"name":"intersects","comment":" Check if two intervals touch or overlap (have any temperatures in common).\nIntervals that just touch each other are considered to intersect.\n","type":"Temperature.Interval.Interval -> Temperature.Interval.Interval -> Basics.Bool"},{"name":"isContainedIn","comment":" Check if the second interval is fully contained in the first.\n","type":"Temperature.Interval.Interval -> Temperature.Interval.Interval -> Basics.Bool"},{"name":"isSingleton","comment":" Check if the interval is a singleton (the minimum and maximum temperatures\nare the same).\n","type":"Temperature.Interval.Interval -> Basics.Bool"},{"name":"maxValue","comment":" Get the maximum temperature of an interval.\n","type":"Temperature.Interval.Interval -> Temperature.Temperature"},{"name":"midpoint","comment":" Get the midpoint of an interval.\n","type":"Temperature.Interval.Interval -> Temperature.Temperature"},{"name":"minValue","comment":" Get the minimum temperature of an interval.\n","type":"Temperature.Interval.Interval -> Temperature.Temperature"},{"name":"minus","comment":" Subtract the first given temperature interval from the second, resulting in\na temperature delta interval:\n\n    firstInterval =\n        Temperature.Interval.from\n            (Temperature.degreesCelsius 5)\n            (Temperature.degreesCelsius 10)\n\n    secondInterval =\n        Temperature.Interval.from\n            (Temperature.degreesCelsius 30)\n            (Temperature.degreesCelsius 40)\n\n    secondInterval\n        |> Temperature.Interval.minus firstInterval\n    --> Quantity.Interval.from\n    -->     (Temperature.celsiusDegrees 20)\n    -->     (Temperature.celsiusDegrees 35)\n\n","type":"Temperature.Interval.Interval -> Temperature.Interval.Interval -> Quantity.Interval.Interval Basics.Float Temperature.CelsiusDegrees"},{"name":"plus","comment":" Add a temperature delta interval to a temperature interval to give a new\ntemperature interval:\n\n    temperatureInterval =\n        Temperature.Interval.from\n            (Temperature.degreesCelsius 20)\n            (Temperature.degreesCelsius 25)\n\n    deltaInterval =\n        Quantity.Interval.from\n            (Temperature.celsiusDegrees -1)\n            (Temperature.celsiusDegrees 4)\n\n    temperatureInterval\n        |> Temperature.Interval.plus deltaInterval\n    --> Temperature.Interval.from\n    -->     (Temperature.degreesCelsius 19)\n    -->     (Temperature.degreesCelsius 29)\n\n","type":"Quantity.Interval.Interval Basics.Float Temperature.CelsiusDegrees -> Temperature.Interval.Interval -> Temperature.Interval.Interval"},{"name":"singleton","comment":" Construct a zero-width interval containing a single temperature.\n","type":"Temperature.Temperature -> Temperature.Interval.Interval"},{"name":"subtract","comment":" Subtract a [temperature delta](Temperature#Delta) from a temperature\ninterval.\n","type":"Temperature.Delta -> Temperature.Interval.Interval -> Temperature.Interval.Interval"},{"name":"union","comment":" Construct an interval containing both of the given intervals.\n","type":"Temperature.Interval.Interval -> Temperature.Interval.Interval -> Temperature.Interval.Interval"},{"name":"width","comment":" Get the width of an interval. This will never be negative. Note that this\nreturns a [`Temperature.Delta`](https://package.elm-lang.org/packages/ianmackenzie/elm-units/latest/Temperature#Delta),\nnot a `Temperature`.\n","type":"Temperature.Interval.Interval -> Temperature.Delta"}],"binops":[]}]