OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

core: killed all math wrappers

This commit is contained in:
Stefan Plantikow 2011-12-23 02:31:24 +01:00
parent 49d36c7f85
commit 57ac67a5aa
7 changed files with 195 additions and 796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/libcore/cmath.rs
View File

@ -1,9 +1,11 @@
export c_double;
export c_float;
export bessel;
import ctypes::c_int;
import ctypes::c_float;
import ctypes::c_double;
// FIXME scalbn copysign
#[link_name = "m"]
#[abi = "cdecl"]
native mod c_double {
@ -16,6 +18,7 @@ native mod c_double {
pure fn atan2(a: c_double, b: c_double) -> c_double;
pure fn cbrt(n: c_double) -> c_double;
pure fn ceil(n: c_double) -> c_double;
pure fn copysign(x: c_double, y: c_double) -> c_double;
pure fn cos(n: c_double) -> c_double;
pure fn cosh(n: c_double) -> c_double;
pure fn erf(n: c_double) -> c_double;
@ -26,15 +29,16 @@ native mod c_double {
#[link_name="fabs"] pure fn abs(n: c_double) -> c_double;
#[link_name="fdim"] pure fn sub_pos(a: c_double, b: c_double) -> c_double;
pure fn floor(n: c_double) -> c_double;
#[link_name="fma"] pure fn mul_add(a: c_double, b: c_double, c: c_double) -> c_double;
#[link_name="fma"] pure fn mul_add(a: c_double, b: c_double,
c: c_double) -> c_double;
#[link_name="fmax"] pure fn fmax(a: c_double, b: c_double) -> c_double;
#[link_name="fmin"] pure fn fmin(a: c_double, b: c_double) -> c_double;
pure fn nextafter(x: c_double, y: c_double) -> c_double;
#[link_name="fmod"] pure fn rem(x: c_double, y: c_double) -> c_double;
pure fn frexp(n: c_double, &value: c_int) -> c_double;
pure fn hypot(x: c_double, y: c_double) -> c_double;
pure fn ldexp(x: c_double, n: c_int) -> c_double;
#[link_name="lgamma_r"] pure fn lgamma(n: c_double, &sign: c_int) -> c_double;
#[link_name="lgamma_r"] pure fn lgamma(n: c_double,
&sign: c_int) -> c_double;
#[link_name="log"] pure fn ln(n: c_double) -> c_double;
pure fn logb(n: c_double) -> c_double;
#[link_name="log1p"] pure fn ln1p(n: c_double) -> c_double;
@ -45,6 +49,7 @@ native mod c_double {
pure fn pow(n: c_double, e: c_double) -> c_double;
pure fn rint(n: c_double) -> c_double;
pure fn round(n: c_double) -> c_double;
pure fn scalbn(n: c_double, i: c_int) -> c_double;
pure fn sin(n: c_double) -> c_double;
pure fn sinh(n: c_double) -> c_double;
pure fn sqrt(n: c_double) -> c_double;
@ -66,6 +71,8 @@ native mod c_float {
#[link_name="atan2f"] pure fn atan2(a: c_float, b: c_float) -> c_float;
#[link_name="cbrtf"] pure fn cbrt(n: c_float) -> c_float;
#[link_name="ceilf"] pure fn ceil(n: c_float) -> c_float;
#[link_name="copysignf"] pure fn copysign(x: c_float,
y: c_float) -> c_float;
#[link_name="cosf"] pure fn cos(n: c_float) -> c_float;
#[link_name="coshf"] pure fn cosh(n: c_float) -> c_float;
#[link_name="erff"] pure fn erf(n: c_float) -> c_float;
@ -76,25 +83,30 @@ native mod c_float {
#[link_name="fabsf"] pure fn abs(n: c_float) -> c_float;
#[link_name="fdimf"] pure fn sub_pos(a: c_float, b: c_float) -> c_float;
#[link_name="floorf"] pure fn floor(n: c_float) -> c_float;
#[link_name="frexpf"] pure fn frexp(n: c_double, &value: c_int) -> c_float;
#[link_name="fmaf"] pure fn mul_add(a: c_float, b: c_float, c: c_float) -> c_float;
#[link_name="frexpf"] pure fn frexp(n: c_double,
&value: c_int) -> c_float;
#[link_name="fmaf"] pure fn mul_add(a: c_float,
b: c_float, c: c_float) -> c_float;
#[link_name="fmaxf"] pure fn fmax(a: c_float, b: c_float) -> c_float;
#[link_name="fminf"] pure fn fmin(a: c_float, b: c_float) -> c_float;
#[link_name="nextafterf"] pure fn nextafter(x: c_float, y: c_float) -> c_float;
#[link_name="fmodf"] pure fn rem(x: c_float, y: c_float) -> c_float;
#[link_name="nextafterf"] pure fn nextafter(x: c_float,
y: c_float) -> c_float;
#[link_name="hypotf"] pure fn hypot(x: c_float, y: c_float) -> c_float;
#[link_name="ldexpf"] pure fn ldexp(x: c_float, n: c_int) -> c_float;
#[link_name="lgammaf_r"] pure fn lgamma(n: c_float, &sign: c_int) -> c_float;
#[link_name="lgammaf_r"] pure fn lgamma(n: c_float,
&sign: c_int) -> c_float;
#[link_name="logf"] pure fn ln(n: c_float) -> c_float;
#[link_name="logbf"] pure fn logb(n: c_float) -> c_float;
#[link_name="log1p"] pure fn ln1p(n: c_double) -> c_double;
#[link_name="log2f"] pure fn log2(n: c_float) -> c_float;
#[link_name="log10f"] pure fn log10(n: c_float) -> c_float;
#[link_name="ilogbf"] pure fn ilogb(n: c_float) -> c_int;
#[link_name="modff"] pure fn modf(n: c_float, &iptr: c_float) -> c_float;
#[link_name="modff"] pure fn modf(n: c_float,
&iptr: c_float) -> c_float;
#[link_name="powf"] pure fn pow(n: c_float, e: c_float) -> c_float;
#[link_name="rintf"] pure fn rint(n: c_float) -> c_float;
#[link_name="roundf"] pure fn round(n: c_float) -> c_float;
#[link_name="scalbnf"] pure fn scalbn(n: c_float, i: c_int) -> c_float;
#[link_name="sinf"] pure fn sin(n: c_float) -> c_float;
#[link_name="sinhf"] pure fn sinh(n: c_float) -> c_float;
#[link_name="sqrtf"] pure fn sqrt(n: c_float) -> c_float;

2
src/libcore/core.rc
View File

@ -10,7 +10,7 @@
export box, char, float, f32, f64, int, str, ptr;
export uint, u8, u32, u64, vec, bool;
export either, option, result;
export ctypes, mtypes, sys, unsafe, comm, task;
export ctypes, sys, unsafe, comm, task;
export extfmt;
// Built-in-type support modules

187
src/libcore/f32.rs
View File

@ -1,118 +1,95 @@
/*
Module: f32
Floating point operations and constants for `f32`
This exposes the same operations as `math`, just for `f32` even though
they do not show up in the docs right now!
*/
export t;
export
acos,
asin,
atan,
atan2,
cbrt,
ceil,
cos,
cosh,
erf,
erfc,
exp,
expm1,
exp2,
abs,
sub_pos,
floor,
mul_add,
fmax,
fmin,
nextafter,
frexp,
hypot,
ldexp,
lgamma,
ln,
logb,
ln1p,
log10,
log2,
ilogb,
modf,
pow,
rem,
rint,
round,
sin,
sinh,
sqrt,
tan,
tanh,
tgamma,
trunc;
export consts;
export radix, mantissa_digits, digits, epsilon, min_value, max_value,
min_exp, max_exp, min_10_exp, max_10_exp;
// PORT
import cops = cmath::c_float;
type t = f64;
import
cops::acos,
cops::asin,
cops::atan,
cops::atan2,
cops::cbrt,
cops::ceil,
cops::cos,
cops::cosh,
cops::erf,
cops::erfc,
cops::exp,
cops::expm1,
cops::exp2,
cops::abs,
cops::sub_pos,
cops::floor,
cops::mul_add,
cops::max,
cops::min,
cops::nextafter,
cops::fmod,
cops::frexp,
cops::hypot,
cops::ldexp,
cops::lgamma,
cops::ln,
cops::logb,
cops::ln1p,
cops::log10,
cops::log2,
cops::ilogb,
cops::modf,
cops::pow,
cops::rem,
cops::rint,
cops::round,
cops::sin,
cops::sinh,
cops::sqrt,
cops::tan,
cops::tanh,
cops::tgamma,
cops::trunc;
import cmath::c_float::*;
type t = f32;
/* Const: NaN */
const NaN: f32 = 0.0f32/0.0f32;
/* Const: infinity */
const infinity: f32 = 1.0f32/0.0f32;
/* Const: neg_infinity */
const neg_infinity: f32 = -1.0f32/0.0f32;
/* Predicate: isNaN */
pure fn isNaN(f: f32) -> bool { f != f }
/* Function: add */
pure fn add(x: f32, y: f32) -> f32 { ret x + y; }
/* Function: sub */
pure fn sub(x: f32, y: f32) -> f32 { ret x - y; }
/* Function: mul */
pure fn mul(x: f32, y: f32) -> f32 { ret x * y; }
/* Function: div */
pure fn div(x: f32, y: f32) -> f32 { ret x / y; }
/* Function: rem */
pure fn rem(x: f32, y: f32) -> f32 { ret x % y; }
/* Predicate: lt */
pure fn lt(x: f32, y: f32) -> bool { ret x < y; }
/* Predicate: le */
pure fn le(x: f32, y: f32) -> bool { ret x <= y; }
/* Predicate: eq */
pure fn eq(x: f32, y: f32) -> bool { ret x == y; }
/* Predicate: ne */
pure fn ne(x: f32, y: f32) -> bool { ret x != y; }
/* Predicate: ge */
pure fn ge(x: f32, y: f32) -> bool { ret x >= y; }
/* Predicate: gt */
pure fn gt(x: f32, y: f32) -> bool { ret x > y; }
/*
Predicate: positive
Returns true if `x` is a positive number, including +0.0f320 and +Infinity.
*/
pure fn positive(x: f32) -> bool
{ ret x > 0.0f32 || (1.0f32/x) == infinity; }
/*
Predicate: negative
Returns true if `x` is a negative number, including -0.0f320 and -Infinity.
*/
pure fn negative(x: f32) -> bool
{ ret x < 0.0f32 || (1.0f32/x) == neg_infinity; }
/*
Predicate: nonpositive
Returns true if `x` is a negative number, including -0.0f320 and -Infinity.
(This is the same as `f32::negative`.)
*/
pure fn nonpositive(x: f32) -> bool {
ret x < 0.0f32 || (1.0f32/x) == neg_infinity;
}
/*
Predicate: nonnegative
Returns true if `x` is a positive number, including +0.0f320 and +Infinity.
(This is the same as `f32::positive`.)
*/
pure fn nonnegative(x: f32) -> bool {
ret x > 0.0f32 || (1.0f32/x) == infinity;
}
/* Module: consts */
mod consts {

183
src/libcore/f64.rs
View File

@ -1,114 +1,95 @@
/*
Module: f64
Floating point operations and constants for `f64`s
This exposes the same operations as `math`, just for `f64` even though
they do not show up in the docs right now!
Floating point operations and constants for `f64`
*/
export t;
export
acos,
asin,
atan,
atan2,
cbrt,
ceil,
cos,
cosh,
erf,
erfc,
exp,
expm1,
exp2,
abs,
sub_pos,
floor,
mul_add,
fmax,
fmin,
nextafter,
frexp,
hypot,
ldexp,
lgamma,
ln,
logb,
ln1p,
log10,
log2,
ilogb,
modf,
pow,
rem,
rint,
round,
sin,
sinh,
sqrt,
tan,
tanh,
tgamma,
trunc;
export consts;
export radix, mantissa_digits, digits, epsilon, min_value, max_value,
min_exp, max_exp, min_10_exp, max_10_exp;
// PORT
import cops = cmath::c_double;
import cmath::c_double::*;
type t = f64;
import
cops::acos,
cops::asin,
cops::atan,
cops::atan2,
cops::cbrt,
cops::ceil,
cops::cos,
cops::cosh,
cops::erf,
cops::erfc,
cops::exp,
cops::expm1,
cops::exp2,
cops::abs,
cops::sub_pos,
cops::floor,
cops::mul_add,
cops::max,
cops::min,
cops::nextafter,
cops::fmod,
cops::frexp,
cops::hypot,
cops::ldexp,
cops::lgamma,
cops::ln,
cops::logb,
cops::ln1p,
cops::log10,
cops::log2,
cops::ilogb,
cops::modf,
cops::pow,
cops::rem,
cops::rint,
cops::round,
cops::sin,
cops::sinh,
cops::sqrt,
cops::tan,
cops::tanh,
cops::tgamma,
cops::trunc;
/* Const: NaN */
const NaN: f64 = 0.0f64/0.0f64;
/* Const: infinity */
const infinity: f64 = 1.0f64/0.0f64;
/* Const: neg_infinity */
const neg_infinity: f64 = -1.0f64/0.0f64;
/* Predicate: isNaN */
pure fn isNaN(f: f64) -> bool { f != f }
/* Function: add */
pure fn add(x: f64, y: f64) -> f64 { ret x + y; }
/* Function: sub */
pure fn sub(x: f64, y: f64) -> f64 { ret x - y; }
/* Function: mul */
pure fn mul(x: f64, y: f64) -> f64 { ret x * y; }
/* Function: div */
pure fn div(x: f64, y: f64) -> f64 { ret x / y; }
/* Function: rem */
pure fn rem(x: f64, y: f64) -> f64 { ret x % y; }
/* Predicate: lt */
pure fn lt(x: f64, y: f64) -> bool { ret x < y; }
/* Predicate: le */
pure fn le(x: f64, y: f64) -> bool { ret x <= y; }
/* Predicate: eq */
pure fn eq(x: f64, y: f64) -> bool { ret x == y; }
/* Predicate: ne */
pure fn ne(x: f64, y: f64) -> bool { ret x != y; }
/* Predicate: ge */
pure fn ge(x: f64, y: f64) -> bool { ret x >= y; }
/* Predicate: gt */
pure fn gt(x: f64, y: f64) -> bool { ret x > y; }
/*
Predicate: positive
Returns true if `x` is a positive number, including +0.0f640 and +Infinity.
*/
pure fn positive(x: f64) -> bool
{ ret x > 0.0f64 || (1.0f64/x) == infinity; }
/*
Predicate: negative
Returns true if `x` is a negative number, including -0.0f640 and -Infinity.
*/
pure fn negative(x: f64) -> bool
{ ret x < 0.0f64 || (1.0f64/x) == neg_infinity; }
/*
Predicate: nonpositive
Returns true if `x` is a negative number, including -0.0f640 and -Infinity.
(This is the same as `f64::negative`.)
*/
pure fn nonpositive(x: f64) -> bool {
ret x < 0.0f64 || (1.0f64/x) == neg_infinity;
}
/*
Predicate: nonnegative
Returns true if `x` is a positive number, including +0.0f640 and +Infinity.
(This is the same as `f64::positive`.)
*/
pure fn nonnegative(x: f64) -> bool {
ret x > 0.0f64 || (1.0f64/x) == infinity;
}
/* Module: consts */
mod consts {

518
src/libcore/float.rs
View File

@ -2,77 +2,12 @@
Module: float
*/
// Currently this module supports from -lm
// C95 + log2 + log1p + trunc + round + rint
export t;
export consts;
export
acos,
asin,
atan,
atan2,
cbrt,
ceil,
cos,
cosh,
erf,
erfc,
exp,
expm1,
exp2,
abs,
sub_pos,
floor,
mul_add,
max,
min,
nextafter,
rem,
frexp,
hypot,
ldexp,
lgamma,
ln,
logb,
ln1p,
log10,
log2,
ilogb,
modf,
pow,
rint,
round,
sin,
sinh,
sqrt,
tan,
tanh,
tgamma,
trunc;
export radix, mantissa_digits, digits, epsilon, min_value, max_value,
min_exp, max_exp, min_10_exp, max_10_exp;
export to_str_common, to_str_exact, to_str, from_str;
export lt, le, eq, ne, gt, eq;
export NaN, isNaN, infinity, neg_infinity;
export pow_uint_to_uint_as_float;
export min, max;
export add, sub, mul, div;
export positive, negative, nonpositive, nonnegative;
import mtypes::m_float;
import ctypes::c_int;
import ptr;
// PORT This must match in width according to architecture
import f64;
import m_float = f64;
type t = m_float;
import m_float::*;
type t = float;
/**
* Section: String Conversions
@ -325,185 +260,6 @@ fn pow_uint_to_uint_as_float(x: uint, pow: uint) -> float {
}
/* Const: NaN */
const NaN: float = 0./0.;
/* Const: infinity */
const infinity: float = 1./0.;
/* Const: neg_infinity */
const neg_infinity: float = -1./0.;
/* Predicate: isNaN */
pure fn isNaN(f: float) -> bool { f != f }
/* Function: add */
pure fn add(x: float, y: float) -> float { ret x + y; }
/* Function: sub */
pure fn sub(x: float, y: float) -> float { ret x - y; }
/* Function: mul */
pure fn mul(x: float, y: float) -> float { ret x * y; }
/* Function: div */
pure fn div(x: float, y: float) -> float { ret x / y; }
/* Function: rem */
pure fn rem(x: float, y: float) -> float { ret x % y; }
/* Predicate: lt */
pure fn lt(x: float, y: float) -> bool { ret x < y; }
/* Predicate: le */
pure fn le(x: float, y: float) -> bool { ret x <= y; }
/* Predicate: eq */
pure fn eq(x: float, y: float) -> bool { ret x == y; }
/* Predicate: ne */
pure fn ne(x: float, y: float) -> bool { ret x != y; }
/* Predicate: ge */
pure fn ge(x: float, y: float) -> bool { ret x >= y; }
/* Predicate: gt */
pure fn gt(x: float, y: float) -> bool { ret x > y; }
/*
Predicate: positive
Returns true if `x` is a positive number, including +0.0 and +Infinity.
*/
pure fn positive(x: float) -> bool { ret x > 0. || (1./x) == infinity; }
/*
Predicate: negative
Returns true if `x` is a negative number, including -0.0 and -Infinity.
*/
pure fn negative(x: float) -> bool { ret x < 0. || (1./x) == neg_infinity; }
/*
Predicate: nonpositive
Returns true if `x` is a negative number, including -0.0 and -Infinity.
(This is the same as `float::negative`.)
*/
pure fn nonpositive(x: float) -> bool {
ret x < 0. || (1./x) == neg_infinity;
}
/*
Predicate: nonnegative
Returns true if `x` is a positive number, including +0.0 and +Infinity.
(This is the same as `float::positive`.)
*/
pure fn nonnegative(x: float) -> bool {
ret x > 0. || (1./x) == infinity;
}
/*
Module: consts
*/
mod consts {
/*
Const: pi
Archimedes' constant
*/
const pi: float = 3.14159265358979323846264338327950288;
/*
Const: frac_pi_2
pi/2.0
*/
const frac_pi_2: float = 1.57079632679489661923132169163975144;
/*
Const: frac_pi_4
pi/4.0
*/
const frac_pi_4: float = 0.785398163397448309615660845819875721;
/*
Const: frac_1_pi
1.0/pi
*/
const frac_1_pi: float = 0.318309886183790671537767526745028724;
/*
Const: frac_2_pi
2.0/pi
*/
const frac_2_pi: float = 0.636619772367581343075535053490057448;
/*
Const: frac_2_sqrtpi
2.0/sqrt(pi)
*/
const frac_2_sqrtpi: float = 1.12837916709551257389615890312154517;
/*
Const: sqrt2
sqrt(2.0)
*/
const sqrt2: float = 1.41421356237309504880168872420969808;
/*
Const: frac_1_sqrt2
1.0/sqrt(2.0)
*/
const frac_1_sqrt2: float = 0.707106781186547524400844362104849039;
/*
Const: e
Euler's number
*/
const e: float = 2.71828182845904523536028747135266250;
/*
Const: log2_e
log2(e)
*/
const log2_e: float = 1.44269504088896340735992468100189214;
/*
Const: log10_e
log10(e)
*/
const log10_e: float = 0.434294481903251827651128918916605082;
/*
Const: ln_2
ln(2.0)
*/
const ln_2: float = 0.693147180559945309417232121458176568;
/*
Const: ln_10
ln(10.0)
*/
const ln_10: float = 2.30258509299404568401799145468436421;
}
// FIXME min/max type specialize via libm when overloading works
// (in theory fmax/fmin, fmaxf, fminf /should/ be faster)
/*
Function: min
@ -518,274 +274,6 @@ Returns the maximum of two values
*/
pure fn max<copy T>(x: T, y: T) -> T { x < y ? y : x }
/*
Function: acos
Returns the arccosine of an angle (measured in rad)
*/
pure fn acos(x: float) -> float
{ ret m_float::acos(x as m_float) as float }
/*
Function: asin
Returns the arcsine of an angle (measured in rad)
*/
pure fn asin(x: float) -> float
{ ret m_float::asin(x as m_float) as float }
/*
Function: atan
Returns the arctangents of an angle (measured in rad)
*/
pure fn atan(x: float) -> float
{ ret m_float::atan(x as m_float) as float }
/*
Function: atan2
Returns the arctangent of an angle (measured in rad)
*/
pure fn atan2(y: float, x: float) -> float
{ ret m_float::atan2(y as m_float, x as m_float) as float }
/*
Function: ceil
Returns the smallest integral value less than or equal to `n`
*/
pure fn ceil(n: float) -> float
{ ret m_float::ceil(n as m_float) as float }
/*
Function: cos
Returns the cosine of an angle `x` (measured in rad)
*/
pure fn cos(x: float) -> float
{ ret m_float::cos(x as m_float) as float }
/*
Function: cosh
Returns the hyperbolic cosine of `x`
*/
pure fn cosh(x: float) -> float
{ ret m_float::cosh(x as m_float) as float }
/*
Function: exp
Returns `consts::e` to the power of `n*
*/
pure fn exp(n: float) -> float
{ ret m_float::exp(n as m_float) as float }
/*
Function: abs
Returns the absolute value of `n`
*/
pure fn abs(n: float) -> float
{ ret m_float::abs(n as m_float) as float }
/*
Function: floor
Returns the largest integral value less than or equal to `n`
*/
pure fn floor(n: float) -> float
{ ret m_float::floor(n as m_float) as float }
/*
Function: fmod
Returns the floating-point remainder of `x/y`
*/
pure fn fmod(x: float, y: float) -> float
{ ret m_float::fmod(x as m_float, y as m_float) as float }
/*
Function: ln
Returns the natural logaritm of `n`
*/
pure fn ln(n: float) -> float
{ ret m_float::ln(n as m_float) as float }
/*
Function: ldexp
Returns `x` multiplied by 2 to the power of `n`
*/
pure fn ldexp(n: float, i: int) -> float
{ ret m_float::ldexp(n as m_float, i as c_int) as float }
/*
Function: ln1p
Returns the natural logarithm of `1+n` accurately,
even for very small values of `n`
*/
pure fn ln1p(n: float) -> float
{ ret m_float::ln1p(n as m_float) as float }
/*
Function: log10
Returns the logarithm to base 10 of `n`
*/
pure fn log10(n: float) -> float
{ ret m_float::log10(n as m_float) as float }
/*
Function: log2
Returns the logarithm to base 2 of `n`
*/
pure fn log2(n: float) -> float
{ ret m_float::log2(n as m_float) as float }
/*
Function: modf
Breaks `n` into integral and fractional parts such that both
have the same sign as `n`
The integral part is stored in `iptr`.
Returns:
The fractional part of `n`
*/
#[no(warn_trivial_casts)] // FIXME Implement
pure fn modf(n: float, &iptr: float) -> float { unsafe {
ret m_float::modf(n as m_float, ptr::addr_of(iptr) as *m_float) as float
} }
/*
Function: frexp
Breaks `n` into a normalized fraction and an integral power of 2
The inegral part is stored in iptr.
The functions return a number x such that x has a magnitude in the interval
[1/2, 1) or 0, and `n == x*(2 to the power of exp)`.
Returns:
The fractional part of `n`
*/
pure fn frexp(n: float, &exp: c_int) -> float
{ ret m_float::frexp(n as m_float, exp) as float }
/*
Function: pow
*/
pure fn pow(v: float, e: float) -> float
{ ret m_float::pow(v as m_float, e as m_float) as float }
/*
Function: rint
Returns the integral value nearest to `x` (according to the
prevailing rounding mode) in floating-point format
*/
pure fn rint(x: float) -> float
{ ret m_float::rint(x as m_float) as float }
/*
Function: round
Return the integral value nearest to `x` rounding half-way
cases away from zero, regardless of the current rounding direction.
*/
pure fn round(x: float) -> float
{ ret m_float::round(x as m_float) as float }
/*
Function: sin
Returns the sine of an angle `x` (measured in rad)
*/
pure fn sin(x: float) -> float
{ ret m_float::sin(x as m_float) as float }
/*
Function: sinh
Returns the hyperbolic sine of an angle `x` (measured in rad)
*/
pure fn sinh(x: float) -> float
{ ret m_float::sinh(x as m_float) as float }
/*
Function: sqrt
Returns the square root of `x`
*/
pure fn sqrt(x: float) -> float
{ ret m_float::sqrt(x as m_float) as float }
/*
Function: tan
Returns the tangent of an angle `x` (measured in rad)
*/
pure fn tan(x: float) -> float
{ ret m_float::tan(x as m_float) as float }
/*
Function: tanh
Returns the hyperbolic tangent of an angle `x` (measured in rad)
*/
pure fn tanh(x: float) -> float
{ ret m_float::tanh(x as m_float) as float }
/*
Function: trunc
Returns the integral value nearest to but no larger in magnitude than `x`
*/
pure fn trunc(x: float) -> float
{ ret m_float::trunc(x as m_float) as float }
/*
FIXME implement this as soon as const expressions may refer to each other
export radix, mantissa_digits, digits, epsilon, min_value, max_value,
min_exp, max_exp, min_10_exp, max_10_exp;
const radix: m_float = m_float::radix as m_float;
const mantissa_digits: m_float = m_float::mantissa_digits as m_float;
const digits: m_float = m_float::digits as m_float;
const epsilon: m_float = m_float::epsilon as m_float;
const min_value: m_float = m_float::min_value as m_float;
const max_value: m_float = m_float::max_value as m_float;
const min_exp: m_float = m_float::min_exp as m_float;
const max_exp: m_float = m_float::max_exp as m_float;
const min_10_exp: m_float = m_float::min_10_exp as m_float;
const max_10_exp: m_float = m_float::max_10_exp as m_float;
*/
//
// Local Variables:
// mode: rust

62
src/libcore/mtypes.rs
View File

@ -1,62 +0,0 @@
/*
Module: mtypes
Machine type equivalents of rust int, uint, float, and complex.
Types useful for interop with C when writing bindings that exist
for different types (float, f32, f64, ...; cf float.rs for an example)
*/
// PORT Change this when porting to a new architecture
/*
Type: m_int
Machine type equivalent of an int
*/
#[cfg(target_arch="x86")]
type m_int = i32;
#[cfg(target_arch="x86_64")]
type m_int = i64;
// PORT Change this when porting to a new architecture
/*
Type: m_uint
Machine type equivalent of a uint
*/
#[cfg(target_arch="x86")]
type m_uint = u32;
#[cfg(target_arch="x86_64")]
type m_uint = u64;
// PORT *must* match with "import m_float = fXX" in core::float per arch
/*
Type: m_float
Machine type equivalent of a float
*/
type m_float = f64;
/*
FIXME Type m_complex
// PORT *must* match "import m_complex = ..." in core::complex per arch
Machine type representing a complex value that uses floats for
both the real and the imaginary part.
*/
// type m_complex = complex_c64::t;
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:
//

5
src/test/stdtest/math.rs
View File

@ -18,6 +18,7 @@ fn test_max_min() {
// FIXME use macros to execute the tests below for all float types
/*
#[test]
fn test_trig() {
assert sin(0.0) == 0.0;
@ -297,4 +298,6 @@ fn test_log_functions() {
assert ln1p(-1.0) == float::neg_infinity;
assert float::isNaN(ln1p(-2.0f));
assert ln1p(float::infinity) == float::infinity;
}
}
*/