### 45 releases

Uses old Rust 2015

0.7.0 | Apr 23, 2022 |
---|---|

0.6.0 | Jun 2, 2021 |

0.5.9 | Aug 14, 2020 |

0.5.8 | Jul 19, 2020 |

0.1.6 | Jun 24, 2015 |

#**434** in Math

**926** downloads per month

Used in **6** crates

**Apache-2.0**

330KB

9K
SLoC

# Deprecated

**This crate is no longer being maintained.**

Fortunately, there's lots of alternatives to

. Thanks for the good times :`)`ramp`

# RAMP - Rust Arithmetic in Multiple Precision

Ramp is a high-performance multiple-precision (aka "BigNum") library for working with numbers bigger than can normally be handled. Usage is very easy, you can almost use them as regular numbers.

## Example

`
``extern` `crate` ramp`;`
`use` `ramp``::`Int`;`
`//` Calculates n!
`fn` `factorial``(``n``:` `usize``)`` ``->` Int `{`
`let` `mut` a `=` `Int``::`from`(``1``)``;`
`for` i `in` `2``..`n `{`
a `*=` i`;`
`}`
`return` a `*` n`;`
`}`

As you can see, it is very easy to work with these numbers.

Operator overloads have been provided for by-value, which consumes the operand(s) and by-reference, which does not. The by-value overloads will attempt to re-use the space for the result (this isn't always possible).

Operator overloads have also been provided for

and `i32`

, allowing easy (and efficient)
operations when you have smaller numbers. The above example actually uses the `usize`

overload,
meaning only one `usize`

is ever allocated.`Int`

**NOTE** Due to use of unstable features (notably inline assembly), Ramp can only be compiled with
a nightly build of

.`rustc`

## Why another library?

The

crate provides some bignum types that can be used, so why use Ramp? Well, Ramp is
specifically focussed on multiple-precision arithmetic, while `num`

is a general-purpose numerics
library that happens to provide some multiple-precision arithmetic.`num`

You should

if you aren't able to use unstable Rust features or just want a small amount of
functionality. Ramp should be used when you need high-performance and extra functionality.`num`

## Overall Design

Ramp is split into two main parts: high-level code and low-level code. The high-level code is what you should be using, however the low-level code is where the real work is done.

The low-level routines (in

) are predominantly unsafe functions that work with raw pointers,
and some of the routines are implemented using inline assembly to gain access to processor-specific
functionality.`ll`

### Limbs

The term "Limb" is used frequently in Ramp. It's a term borrowed from GMP and is a single "digit" for the base that Ramp works in. Since the base is equal to 2^word_size, these are very large "digits", hence the use of the word "Limb" instead.

## Future Work

Ramp is currently very rough and incomplete. Broadly, there are three types Ramp aims to provide:
integers, rationals, and floats. Integers (

) are present and mostly complete, Rationals are
present and have a basic implementation. Floats are not yet implemented.`Int`

In the low-level routines, there are a few operations, notably multiplication and division, that are currently implemented using the simplest working algorithm. While this is sufficient for relatively small numbers, larger numbers should be using better algorithms.

#### Dependencies

~0.5–0.8MB

~15K SLoC