# HalfIntegers

This package provides data types for half-integer numbers. Here, any number *n*/2 where *n*
is an integer is considered a half-integer – contrary to the
common definition,
*n* does not have to be odd, i.e., the integers are a subset of the half-integers.

For example, the `HalfInt`

type provided by this package can be used to represent numbers
*n*/2 where *n* is an `Int`

. Likewise, there exist half-integer types for all of Julia’s
signed and unsigned integer types, e.g., `HalfInt8`

, `HalfUInt128`

, and `BigHalfInt`

for
arbitrarily large half-integers. All half-integer types are subtypes of the abstract type
`HalfInteger`

.

## Installation

HalfIntegers.jl is compatible with Julia ≥ 1.0. It can be installed by typing

```
] add HalfIntegers
```

in the Julia REPL or via

`using Pkg; Pkg.add("HalfIntegers")`

## Basic usage

`HalfInteger`

s can be created from any other number type by using constructors or `convert`

:

```
julia> HalfInt(-2.5)
-5/2
julia> convert(HalfUInt16, 7//2)
7/2
julia> BigHalfInt(2)
2
```

Another way of creating an `HalfInteger`

is the `half`

function:

```
julia> half(11)
11/2
julia> half(HalfInt8, -3)
-3/2
```

`HalfInteger`

types support all standard arithmetic operations. Furthermore, this package
defines the function `twice`

. For any number *x*, the function `twice`

returns the number
2*x*. For `HalfInteger`

types, it returns an `Integer`

type.

```
julia> twice(1.5)
3.0
julia> twice(HalfInt64(1.5))
3
julia> typeof(ans)
Int64
```

`Half{T<:Integer}`

type

The All concrete half-integer types provided by this package are actually just aliases for
`Half{T}`

with a specific `T`

:

```
julia> typeof(HalfInt64(1/2))
Half{Int64}
```

The type `Half{T}`

accepts arbitrary `<:Integer`

types as parameter. It can be used to
define half-integers based on other (non-standard) integers. For example, since `HalfInt`

etc. are based on standard integer arithmetic, they are subject to
integer overflow.
If you prefer checked arithmetic, you can use the
SaferIntegers
package and use `Half{SafeInt}`

instead of `HalfInt`

.

## Alternatives to this package

- FixedPointNumbers.jl implements
numbers with a fixed number of fraction bits. Thus, the
`Fixed{Int,1}`

type from`FixedPointNumbers`

can be considered equivalent to the`HalfInt`

type from this package. However, the types behave differently in some ways. For example, multiplying two`Fixed{T,f}`

numbers results in another`Fixed{T,f}`

number, whereas multiplying two`HalfInteger`

s results in a floating-point number.