1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

// Copyright © 2016–2017 University of Malta

// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.

//! # Multiple-precision floating-point numbers
//!
//! The `rugflo` crate provides multiple-precision floating-point
//! numbers using the [GNU MPFR Library](http://www.mpfr.org/), a
//! library for multiple-precision floating-point computations. It
//! can be helpful to refer to the documentation at the
//! [MPFR](http://www.mpfr.org/mpfr-current/mpfr.html) page.
//!
//! This crate is free software: you can redistribute it and/or modify
//! it under the terms of the GNU Lesser General Public License as
//! published by the Free Software Foundation, either version 3 of the
//! License, or (at your option) any later version.
//!
//! This crate is one of a group of four crates:
//!
//!   * [`rugint`](../rugint/index.html) for arbitrary-precision
//!     integers,
//!   * [`rugrat`](../rugrat/index.html) for arbitrary-precision
//!     rational numbers,
//!   * [`rugflo`](../rugflo/index.html) for multiple-precision
//!     floating-point numbers, and
//!   * [`rugcom`](../rugcom/index.html) for multiple-precision
//!     complex numbers.
//!
//! # Basic use
//!
//! The crate provides the [`Float`](./struct.Float.html) type, which
//! holds a multiple-precision floating-point number.
//! 
//! ## Examples
//! 
//! ```rust
//! extern crate rugint;
//! extern crate rugflo;
//! use rugint::Assign;
//! use rugflo::Float;
//! 
//! fn main() {
//!     // Create a floating-point number with 53 bits of precision.
//!     // (An `f64` has 53 bits of precision too.) 
//!     let flo53 = Float::from((0xff00ff, 53));
//!     assert!(flo.to_f64() == 0xff00ff as f64);
//!     // Create a floating-point number with only 16 bits of precision.
//!     let flo16 = Float::from((0xff00ff, 16));
//!     // Now the number is rounded.
//!     assert!(flo16.to_f64() == 0xff0100 as f64);
//! }
//! ```

extern crate gmp_mpfr_sys;
extern crate rugint;
extern crate rugrat;

mod float;

pub use float::{Constant, Exp, Float, Prec, Round, Special, exp_max, exp_min,
                prec_max, prec_min};
use std::cmp::Ordering;

/// Assigns to a number from another value, applying the specified
/// rounding method.
pub trait AssignRound<T, R = Round, O = Ordering> {
    /// Peforms the assignment and rounding.
    fn assign_round(&mut self, T, R) -> O;
}

/// Construct `Self` via a conversion with a specified precision,
/// applying the specified rounding method.
pub trait FromRound<T, P = Prec, R = Round, O = Ordering>
    where Self: Sized
{
    /// Performs the conversion.
    fn from_round(T, P, R) -> (Self, O);
}

/// Provides addition with a specified rounding method.
pub trait AddRound<T, R = Round, O = Ordering> {
    /// The resulting type after the addition.
    type Output;
    /// Performs the addition.
    fn add_round(self, T, R) -> (Self::Output, O);
}

/// Provides subtraction with a specified rounding method.
pub trait SubRound<T, R = Round, O = Ordering> {
    /// The resulting type after the subtraction.
    type Output;
    /// Performs the subtraction.
    fn sub_round(self, T, R) -> (Self::Output, O);
}

/// Provides multiplication with a specified rounding method.
pub trait MulRound<T, R = Round, O = Ordering> {
    /// The resulting type after the multiplication.
    type Output;
    /// Performs the multiplication.
    fn mul_round(self, T, R) -> (Self::Output, O);
}

/// Provides division with a specified rounding method.
pub trait DivRound<T, R = Round, O = Ordering> {
    /// The resulting type after the division.
    type Output;
    /// Performs the division.
    fn div_round(self, T, R) -> (Self::Output, O);
}

/// Provides the left shift operation with a specified rounding
/// method.
pub trait ShlRound<T, R = Round, O = Ordering> {
    /// The resulting type after the left shift operation.
    type Output;
    /// Performs the left shift operation.
    fn shl_round(self, T, R) -> (Self::Output, O);
}

/// Provides the right shift operation with a specified rounding
/// method.
pub trait ShrRound<T, R = Round, O = Ordering> {
    /// The resulting type after the right shift operation.
    type Output;
    /// Performs the right shift operation.
    fn shr_round(self, T, R) -> (Self::Output, O);
}

/// Provides the power operation inside `self` with a specified
/// rounding method.
pub trait PowRound<T, R = Round, O = Ordering> {
    /// The resulting type after the power operation.
    type Output;
    /// Performs the power operation.
    fn pow_round(self, T, R) -> (Self::Output, O);
}