PackagesReroutesAboutlamdera.com

malaire/elm-safe-int/1.0.0

Rerouted (cache, verified). The original is gone. This copy comes from a Lamdera package cache made before it went. The Lamdera package server serves a copy recovered from a Lamdera package cache from 2021-02-13.

What we checked: Rebuilt from the unpacked sources in a Lamdera package cache (5 copies agree), which Elm only writes after the published SHA-1 checked out; elm.json is byte-identical to package.elm-lang.org's; the exposed modules match docs.json; the zip is our own, so its SHA-1 is not the published one.

The Lamdera compiler uses this copy and prints a one-line notice saying so. elm itself fails to download this version.

Details · package.elm-lang.org's zip: https://github.com/malaire/elm-safe-int/zipball/1.0.0/

READMEAboutVersionsSourceModules

SafeInt.Unchecked

Unchecked versions of SafeInt functions which operate directly on Float values.

import SafeInt.Unchecked as Unchecked


-- `2^40 / 10`
Unchecked.pow 2 40
    |> Unchecked.divBy 10
    --> 109951162777

It is recommended to use SafeInt functions instead of Unchecked functions, unless more speed is required at the cost of some lost safety and features.

Difference to SafeInt

Unchecked functions are faster than corresponding SafeInt functions because they

  • operate directly on Float values
  • don't support undefined value
  • don't check that arguments are valid
  • don't check whether result would be between minValue and maxValue

Therefore with Unchecked functions it's users responsibility to make sure that arguments are valid and such that result will be within allowed limits.

As long as undefined behavior is avoided, Unchecked functions will work exactly like corresponding SafeInt functions.

Usage rules

When using Unchecked functions

  • arguments must be exact integer(*) values and
  • arguments must be between minValue and maxValue and
  • arguments must be such that corresponding SafeInt function would not return undefined

*) This doesn't apply to round, ceiling, truncate and floor which allow non-integer arguments.

If these rules are not followed, behavior of Unchecked functions is undefined.

Constants

minValue : Float

Minimum possible value, - (2^53 - 1) = - 9 007 199 254 740 991.

Equal to Number.MIN_SAFE_INTEGER in JavaScript.

SafeInt.Unchecked.minValue
    --> -9007199254740991
maxValue : Float

Maximum possible value, 2^53 - 1 = 9 007 199 254 740 991.

Equal to Number.MAX_SAFE_INTEGER in JavaScript.

SafeInt.Unchecked.maxValue
    --> 9007199254740991

Conversion from/to Int

fromInt : Int -> Float

Convert Int to Float.

Behavior is undefined if

Note: You can use Basics.toFloat instead of this function.

Note: Unlike SafeInt.fromInt, this function does not allow non-integer argument.

toInt : Float -> Int

Convert Float to Int.

Behavior is undefined if

Note: You can use Basics.round, Basics.floor or Basics.ceiling instead of this function.

Note: Unlike SafeInt.toInt, return value is Int instead of Maybe Int as Unchecked functions don't support undefined value.

Rounding

Comparison of rounding functions:

          -3.8 -3.5 -3.2   ~    3.2  3.5  3.8
          ---- ---- ----       ---- ---- ----
round     -4   -3   -3          3    4    4
ceiling   -3   -3   -3          4    4    4
truncate  -3   -3   -3          3    3    3
floor     -4   -4   -4          3    3    3
round : Float -> Float

Round to nearest integer and half towards positive infinity.

Behavior is undefined if argument is NaN, below minValue or above maxValue.

[ 3.2, 3.5, 3.8 ]
    |> List.map SafeInt.Unchecked.round
    --> [ 3.0, 4.0, 4.0 ]


[ -3.8, -3.5, -3.2 ]
    |> List.map SafeInt.Unchecked.round
    --> [ -4.0, -3.0, -3.0 ]
ceiling : Float -> Float

Round to integer towards positive infinity.

Behavior is undefined if argument is NaN, below minValue or above maxValue.

SafeInt.Unchecked.ceiling 3.8
    --> 4.0


SafeInt.Unchecked.ceiling -3.8
    --> -3.0
truncate : Float -> Float

Round to integer towards zero.

Behavior is undefined if argument is NaN, below minValue or above maxValue.

SafeInt.Unchecked.truncate 3.8
    --> 3.0


SafeInt.Unchecked.truncate -3.8
    --> -3.0
floor : Float -> Float

Round to integer towards negative infinity.

Behavior is undefined if argument is NaN, below minValue or above maxValue.

SafeInt.Unchecked.floor 3.8
    --> 3.0


SafeInt.Unchecked.floor -3.8
    --> -4.0

Math

add : Float -> Float -> Float

Addition.

Behavior is undefined if

Note: You can use + operator instead of this function.

sub : Float -> Float -> Float

Subtraction.

Behavior is undefined if

Note: You can use - operator instead of this function.

mul : Float -> Float -> Float

Multiplication.

Behavior is undefined if

Note: You can use * operator instead of this function.

pow : Float -> Float -> Float

Power aka exponentiation, rounding towards zero.

Behavior is undefined if

The table below shows the return values of pow a b near zero. U denotes undefined behavior and *0 denotes non-integer result rounded towards zero.

  b: -2 -1  0  1  2
 a   -- -- -- -- --
--
-2   *0 *0  1 -2  4
-1    1 -1  1 -1  1
 0    U  U  U  0  0
 1    1  1  1  1  1
 2   *0 *0  1  2  4

Example

SafeInt.Unchecked.pow 2 40
    --> 1099511627776

Note: Opinions differ on what the result of 0 ^ 0 should be. SafeInt takes the stance that when uncertain, it's undefined behavior. For more information see e.g. Zero to the power of zero🢅.

Division Basics

Division undefined

Behavior of division functions is undefined if

  • divisor is 0
  • either argument is not exact integer
  • either argument is below minValue or above maxValue
div : Float -> Float -> Float

Integer division, rounding towards negative infinity.

See Division undefined for undefined behavior and SafeInt § Division Basics for more information about division functions.

SafeInt.Unchecked.div 1234 100
    --> 12


SafeInt.Unchecked.div -1234 100
    --> -13
mod : Float -> Float -> Float

Remainder after div. This is also used for modular arithmetic🢅.

See Division undefined for undefined behavior and SafeInt § Division Basics for more information about division functions.

SafeInt.Unchecked.mod 1234 100
    --> 34


SafeInt.Unchecked.mod -1234 100
    --> 66
quotient : Float -> Float -> Float

Integer division, rounding towards zero.

This is similar to // operator.

See Division undefined for undefined behavior and SafeInt § Division Basics for more information about division functions.

SafeInt.Unchecked.quotient 1234 100
    --> 12


SafeInt.Unchecked.quotient -1234 100
    --> -12
remainder : Float -> Float -> Float

Remainder after quotient.

See Division undefined for undefined behavior and SafeInt § Division Basics for more information about division functions.

SafeInt.Unchecked.remainder 1234 100
    --> 34


SafeInt.Unchecked.remainder -1234 100
    --> -34

Division Reversed

Functions divBy, modBy, quotientBy and remainderBy are same as basic division functions, except with reversed arguments.

modBy is similar to Basics.modBy and remainderBy to Basics.remainderBy.

import SafeInt.Unchecked as Unchecked


-- `2^40 / 10`
Unchecked.pow 2 40
    |> Unchecked.divBy 10
    --> 109951162777
divBy : Float -> Float -> Float

Same as div except with reversed arguments.

modBy : Float -> Float -> Float

Same as mod except with reversed arguments.

This is similar to Basics.modBy.

quotientBy : Float -> Float -> Float

Same as quotient except with reversed arguments.

remainderBy : Float -> Float -> Float

Same as remainder except with reversed arguments.

This is similar to Basics.remainderBy.

Division Combined

divMod : Float -> Float -> ( Float, Float )

Combines div and mod into a single function.

divMod a b is same as ( div a b, mod a b ) except faster.

SafeInt.Unchecked.divMod 1234 100
    --> ( 12, 34 )


SafeInt.Unchecked.divMod -1234 100
    --> ( -13, 66 )
quotRem : Float -> Float -> ( Float, Float )

Combines quotient and remainder into a single function.

quotRem a b is same as ( quotient a b, remainder a b ) except faster.

SafeInt.Unchecked.quotRem 1234 100
    --> ( 12, 34 )


SafeInt.Unchecked.quotRem -1234 100
    --> ( -12, -34 )
divModBy : Float -> Float -> ( Float, Float )

Same as divMod except with reversed arguments.

quotRemBy : Float -> Float -> ( Float, Float )

Same as quotRem except with reversed arguments.

Signs

abs : Float -> Float

Absolute value.

Behavior is undefined if

Note: You can use Basics.abs instead of this function.

negate : Float -> Float

Negation.

Behavior is undefined if

Note: You can use Basics.negate instead of this function.

sign : Float -> Float

Sign.

  • 1 if argument is positive
  • -1 if argument is negative
  • 0 if argument is zero

Behavior is undefined if

Examples

SafeInt.Unchecked.sign 123
    --> 1


SafeInt.Unchecked.sign -123
    --> -1

Modules

About this package serverReroutesreroutes.json
Pages and docs rendering from package.elm-lang.org, © 2012-2020 Evan Czaplicki. © 2026 Lamdera