Module

Data.Int53

Package
purescript-int-53
Repository
rgrempel/purescript-int-53

Purescript's built-in Int type is restricted to 32-bit integers. However, the Javascript runtime is capable of working with 53-bit integers. So, this module provides an Int53 type, for cases where you want all 53 bits (from -9,007,199,254,740,991 to 9,007,199,254,740,991).

For even larger numbers, consider purescript-bigints, or purescript-hugenums. The advantage of purescript-int-53 over those is that purescript-int-53 is likely to be faster, since it provides a "thinner" wrapper over the underlying Javascript operations.

Making an Int53

To create an Int53 from a Number, use fromNumber or, more often, ceil, floor, round or truncate.

To create an Int53 from an Int, use fromInt.

If you're starting from a String, then there is fromString.

Using an Int53

Once you have an Int53, you can do things like add, subtract, multiply, etc., in the usual way, since the ordinary classes for arithmetic are implemented. It should feel pretty much like using an ordinary integer.

There are also functions for even, odd, pow, and abs.

Converting an Int53 to something else

When you need a Number again, you can use toNumber -- and when you need an Int, there is toInt.

To get back to a String, there is a Show instance, so you can use show. However, that includes the Int53 tag in the resulting string, so you might sometimes want toString instead.

The Int53Value class

There is also a class for Int53Value, which might sometimes be useful if you have a function where you'd like to accept either an Int or an Int53. Often you won't need this.

#Int53 Source

newtype Int53

A 53-bit signed integer.

It is implemented a newtype over a Number (that is, a Javascript number), with matters arranged so that it will always be an integer.

In case you've forgotten what all the instances mean, you've got:

Semiring: add, zero, mul, one, (+), (*)
Ring: sub, (-), negate
EuclideanRing: div, mod, (/), degree

... plus the usual Eq, Ord and Show.

There's also top and bottom from Bounded, which indicate the maximum and minimum values available for an Int53.

Instances

#Int53Value Source

class Int53Value a  where

A class which allows a function to accept eitner an Int or an Int53, work with Int53 internally, and then return whatever type was provided.

For instance, you can do something like:

doSomethingWithIntOrInt53 :: ∀ a. (Int53Value a) => a -> a
doSomethingWithIntOrInt53 =
    fromInt53 <<< doSometingWithInt53 <<< toInt53

doSomethingWithInt53 :: Int53 -> Int53
doSomethingWithInt53 = ...

This is basically for cases where only some intermediate steps need the Int53 range -- that is, where an input in the Int range will produce an output in the Int range, but one needs an Int53 in the middle.

So, you won't need this very often ... it's just a convenience in some cases.

Members

Instances

#fromNumber Source

fromNumber :: Number -> Maybe Int53

Creates an Int53 from a Number value. The number must already be an integer and fall within the valid range of values for the Int53 type. Otherwise, Nothing is returned.

fromNumber Global.nan == Nothing
fromNumber 2.5 == Nothing
fromNumber 1.0e65 == Nothing
fromNumber (-1.0e65) == Nothing
fromNumber 27.0 == Just (fromInt 27)

#toNumber Source

toNumber :: Int53 -> Number

Converts an Int53 value back into a Number. Any Int53 is a valid Number so there is no loss of precision with this function.

#fromInt Source

fromInt :: Int -> Int53

Converts an Int to an Int53.

#toInt Source

toInt :: Int53 -> Int

Converts an Int53 to an Int. Values outside the Int range are clamped.

toInt (fromInt 27) ==> 27
toInt (floor (1.0e52)) ==> 2147483647
toInt (floor (-1.0e52)) ==> (-2147483648)

#fromString Source

fromString :: String -> Maybe Int53

Reads an Int53 from a String value. The number must parse as an integer and fall within the valid range of values for the Int53 type, otherwise Nothing is returned.

fromString "not a number" == Nothing
fromString "2.5" == Nothing
fromString "1.0e65" == Nothing
fromString "-1.0e65" == Nothing
fromString "27.0" == Just (fromInt 27)
fromString "27" == Just (fromInt 27)

#toString Source

toString :: Int53 -> String

Converts an Int53 to a String.

There is also a Show instance (so you can use show), but that includes the Int53 tag in the string, which isn't always what you'll want.

 toString (fromInt 27) == "27"
 show (fromInt 27) == "(Int53 27.0)"

#ceil Source

ceil :: Number -> Int53

Convert a Number to an Int53, by taking the closest integer equal to or greater than the argument. Values outside the Int53 range are clamped.

ceil 27.1 == fromInt 28
ceil 27.9 == fromInt 28
ceil (-27.1) == fromInt (-27)
ceil (-27.9) == fromInt (-27)
ceil (1.0e65) == top
ceil (-1.0e65) == bottom

#floor Source

floor :: Number -> Int53

Convert a Number to an Int53, by taking the closest integer equal to or less than the argument. Values outside the Int53 range are clamped.

floor 27.1 == fromInt 27
floor 27.9 == fromInt 27
floor (-27.1) == fromInt (-28)
floor (-27.9) == fromInt (-28)
floor (1.0e65) == top
floor (-1.0e65) == bottom

#round Source

round :: Number -> Int53

Convert a Number to an Int53, by taking the nearest integer to the argument. Values outside the Int53 range are clamped.

round 27.1 == fromInt 27
round 27.9 == fromInt 28
round (-27.1) == fromInt (-27)
round (-27.9) == fromInt (-28)
round (1.0e65) == top
round (-1.0e65) == bottom

#truncate Source

truncate :: Number -> Int53

Convert a Number to an Int53, by rounding towards zero. Values outside the Int53 range are clamped.

truncate 27.1 == fromInt 27
truncate 27.9 == fromInt 27
truncate (-27.1) == fromInt (-27)
truncate (-27.9) == fromInt (-27)
truncate (1.0e65) == top
truncate (-1.0e65) == bottom

#even Source

even :: Int53 -> Boolean

Returns whether an Int53 is an even number.

even (fromInt 0) == true
even (fromInt 1) == false

#odd Source

odd :: Int53 -> Boolean

The negation of even.

odd (fromInt 0) == false
odd (fromInt 1) == true

#pow Source

pow :: Int53 -> Int53 -> Int53

Raises the first argument to the power of the second argument (the exponent).

If the exponent is less than 0, then pow returns 0.

pow (fromInt 2) (fromInt 3) == (fromInt 8)
pow (fromInt 2) (fromInt 0) == (fromInt 1)
pow (fromInt 0) (fromInt 0) == (fromInt 1)
pow (fromInt 2) (fromInt (-2)) == (fromInt 0)

#abs Source

abs :: Int53 -> Int53

Takes the absolute value.

abs (fromInt 2) == (fromInt 2)
abs (fromInt (-2)) == (fromInt 2)
abs (fromInt 0) == (fromInt 0)
Modules
Data.Int53