mirrors/phobos
1
0
Fork 0
mirror of https://github.com/dlang/phobos.git synced 2025-04-28 22:21:09 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

fix style in std.numeric

Browse source
This commit is contained in:
Ilya Yaroshenko 2016-04-28 10:23:16 +02:00
parent 4cfa177fb5
commit ce4f1692be
1 changed files with 45 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

88
std/numeric.d
View file

@ -12,7 +12,7 @@ WIKI = Phobos/StdNumeric
Copyright: Copyright Andrei Alexandrescu 2008 - 2009. Copyright: Copyright Andrei Alexandrescu 2008 - 2009.
License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0). License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
Authors: $(WEB erdani.org, Andrei Alexandrescu), Authors: $(WEB erdani.org, Andrei Alexandrescu),
Don Clugston, Robert Jacques Don Clugston, Robert Jacques, Ilya Yaroshenko
Source: $(PHOBOSSRC std/_numeric.d) Source: $(PHOBOSSRC std/_numeric.d)
*/ */
/* /*
@ -161,14 +161,14 @@ private:
// get the correct unsigned bitfield type to support > 32 bits // get the correct unsigned bitfield type to support > 32 bits
template uType(uint bits) template uType(uint bits)
{ {
static if(bits <= size_t.sizeof*8) alias uType = size_t; static if (bits <= size_t.sizeof*8) alias uType = size_t;
else alias uType = ulong ; else alias uType = ulong ;
} }
// get the correct signed bitfield type to support > 32 bits // get the correct signed bitfield type to support > 32 bits
template sType(uint bits) template sType(uint bits)
{ {
static if(bits <= ptrdiff_t.sizeof*8-1) alias sType = ptrdiff_t; static if (bits <= ptrdiff_t.sizeof*8-1) alias sType = ptrdiff_t;
else alias sType = long; else alias sType = long;
} }
@ -243,7 +243,7 @@ private:
// Convert denormalized form to normalized form // Convert denormalized form to normalized form
((flags&Flags.allowDenorm) && exp==0)) ((flags&Flags.allowDenorm) && exp==0))
{ {
if(sig > 0) if (sig > 0)
{ {
import core.bitop : bsr; import core.bitop : bsr;
auto shift2 = precision - bsr(sig); auto shift2 = precision - bsr(sig);
@ -465,7 +465,7 @@ public:
static if (flags & Flags.signed) static if (flags & Flags.signed)
value.sign = 0; value.sign = 0;
value.exponent = 1; value.exponent = 1;
static if(flags&Flags.storeNormalized) static if (flags&Flags.storeNormalized)
value.significand = 0; value.significand = 0;
else else
value.significand = cast(T_sig) 1uL << (precision - 1); value.significand = cast(T_sig) 1uL << (precision - 1);
@ -764,12 +764,12 @@ public:
/** Find a real root of a real function f(x) via bracketing. /** Find a real root of a real function f(x) via bracketing.
* *
* Given a function $(D f) and a range $(D [a..b]) such that $(D f(a)) * Given a function `f` and a range `[a..b]` such that `f(a)`
* and $(D f(b)) have opposite signs or at least one of them equals ±0, * and `f(b)` have opposite signs or at least one of them equals ±0,
* returns the value of $(D x) in * returns the value of `x` in
* the range which is closest to a root of $(D f(x)). If $(D f(x)) * the range which is closest to a root of `f(x)`. If `f(x)`
* has more than one root in the range, one will be chosen * has more than one root in the range, one will be chosen
* arbitrarily. If $(D f(x)) returns NaN, NaN will be returned; * arbitrarily. If `f(x)` returns NaN, NaN will be returned;
* otherwise, this algorithm is guaranteed to succeed. * otherwise, this algorithm is guaranteed to succeed.
* *
* Uses an algorithm based on TOMS748, which uses inverse cubic * Uses an algorithm based on TOMS748, which uses inverse cubic
@ -777,7 +777,7 @@ public:
* or secant interpolation. Compared to TOMS748, this implementation * or secant interpolation. Compared to TOMS748, this implementation
* improves worst-case performance by a factor of more than 100, and * improves worst-case performance by a factor of more than 100, and
* typical performance by a factor of 2. For 80-bit reals, most * typical performance by a factor of 2. For 80-bit reals, most
* problems require 8 to 15 calls to $(D f(x)) to achieve full machine * problems require 8 to 15 calls to `f(x)` to achieve full machine
* precision. The worst-case performance (pathological cases) is * precision. The worst-case performance (pathological cases) is
* approximately twice the number of bits. * approximately twice the number of bits.
* *
@ -789,17 +789,17 @@ public:
*/ */
T findRoot(T, DF, DT)(scope DF f, in T a, in T b, T findRoot(T, DF, DT)(scope DF f, in T a, in T b,
scope DT tolerance) //= (T a, T b) => false) scope DT tolerance) //= (T a, T b) => false)
if( if (
isFloatingPoint!T && isFloatingPoint!T &&
is(typeof(tolerance(T.init, T.init)) : bool) && is(typeof(tolerance(T.init, T.init)) : bool) &&
is(typeof(f(T.init)) == R, R) && isFloatingPoint!R is(typeof(f(T.init)) == R, R) && isFloatingPoint!R
) )
{ {
immutable fa = f(a); immutable fa = f(a);
if(fa == 0) if (fa == 0)
return a; return a;
immutable fb = f(b); immutable fb = f(b);
if(fb == 0) if (fb == 0)
return b; return b;
immutable r = findRoot(f, a, b, fa, fb, tolerance); immutable r = findRoot(f, a, b, fa, fb, tolerance);
// Return the first value if it is smaller or NaN // Return the first value if it is smaller or NaN
@ -819,10 +819,10 @@ T findRoot(T, DF)(scope DF f, in T a, in T b)
* *
* f = Function to be analyzed * f = Function to be analyzed
* *
* ax = Left bound of initial range of $(D f) known to contain the * ax = Left bound of initial range of `f` known to contain the
* root. * root.
* *
* bx = Right bound of initial range of $(D f) known to contain the * bx = Right bound of initial range of `f` known to contain the
* root. * root.
* *
* fax = Value of $(D f(ax)). * fax = Value of $(D f(ax)).
@ -840,14 +840,14 @@ T findRoot(T, DF)(scope DF f, in T a, in T b)
* Returns: * Returns:
* *
* A tuple consisting of two ranges. The first two elements are the * A tuple consisting of two ranges. The first two elements are the
* range (in $(D x)) of the root, while the second pair of elements * range (in `x`) of the root, while the second pair of elements
* are the corresponding function values at those points. If an exact * are the corresponding function values at those points. If an exact
* root was found, both of the first two elements will contain the * root was found, both of the first two elements will contain the
* root, and the second pair of elements will be 0. * root, and the second pair of elements will be 0.
*/ */
Tuple!(T, T, R, R) findRoot(T, R, DF, DT)(scope DF f, in T ax, in T bx, in R fax, in R fbx, Tuple!(T, T, R, R) findRoot(T, R, DF, DT)(scope DF f, in T ax, in T bx, in R fax, in R fbx,
scope DT tolerance) // = (T a, T b) => false) scope DT tolerance) // = (T a, T b) => false)
if( if (
isFloatingPoint!T && isFloatingPoint!T &&
is(typeof(tolerance(T.init, T.init)) : bool) && is(typeof(tolerance(T.init, T.init)) : bool) &&
is(typeof(f(T.init)) == R) && isFloatingPoint!R is(typeof(f(T.init)) == R) && isFloatingPoint!R
@ -1383,12 +1383,12 @@ unittest
} }
/++ /++
Find a real minimum of a real function $(D f(x)) via bracketing. Find a real minimum of a real function `f(x)` via bracketing.
Given a function $(D f) and a range $(D (ax..bx)), Given a function `f` and a range `(ax..bx)`,
returns the value of $(D x) in the range which is closest to a minimum of $(D f(x)). returns the value of `x` in the range which is closest to a minimum of `f(x)`.
$(D f) is never evaluted at the endpoints of $(D ax) and $(D bx). `f` is never evaluted at the endpoints of `ax` and `bx`.
If $(D f(x)) has more than one minimum in the range, one will be chosen arbitrarily. If `f(x)` has more than one minimum in the range, one will be chosen arbitrarily.
If $(D f(x)) returns NaN or -Infinity, $(D (x, f(x), NaN)) will be returned; If `f(x)` returns NaN or -Infinity, `(x, f(x), NaN)` will be returned;
otherwise, this algorithm is guaranteed to succeed. otherwise, this algorithm is guaranteed to succeed.
Params: Params:
@ -1399,12 +1399,12 @@ Params:
absTolerance = Absolute tolerance. absTolerance = Absolute tolerance.
Preconditions: Preconditions:
$(D ax) and $(D bx) shall be finite reals. $(BR) `ax` and `bx` shall be finite reals. $(BR)
$(D relTolerance) shall be normal positive real. $(BR) $(D relTolerance) shall be normal positive real. $(BR)
$(D absTolerance) shall be normal positive real no less then $(D T.epsilon*2). $(D absTolerance) shall be normal positive real no less then $(D T.epsilon*2).
Returns: Returns:
A tuple consisting of $(D x), $(D y = f(x)) and $(D error = 3 * (absTolerance * fabs(x) + relTolerance)). A tuple consisting of `x`, `y = f(x)` and `error = 3 * (absTolerance * fabs(x) + relTolerance)`.
The method used is a combination of golden section search and The method used is a combination of golden section search and
successive parabolic interpolation. Convergence is never much slower successive parabolic interpolation. Convergence is never much slower
@ -1453,7 +1453,7 @@ body
T v = a * cm1 + b * c; T v = a * cm1 + b * c;
assert(isFinite(v)); assert(isFinite(v));
R fv = f(v); R fv = f(v);
if(isNaN(fv) || fv == -T.infinity) if (isNaN(fv) || fv == -T.infinity)
{ {
return typeof(return)(v, fv, T.init); return typeof(return)(v, fv, T.init);
} }
@ -1462,15 +1462,15 @@ body
T x = v; T x = v;
R fx = fv; R fx = fv;
size_t i; size_t i;
for(R d = 0, e = 0;;) for (R d = 0, e = 0;;)
{ {
i++; i++;
T m = (a + b) / 2; T m = (a + b) / 2;
// This fix is not part of the original algorithm // This fix is not part of the original algorithm
if(!isFinite(m)) // fix infinity loop. Issue can be reproduced in R. if (!isFinite(m)) // fix infinity loop. Issue can be reproduced in R.
{ {
m = a / 2 + b / 2; m = a / 2 + b / 2;
if(!isFinite(m)) // fast-math compiler switch is enabled if (!isFinite(m)) // fast-math compiler switch is enabled
{ {
//SIMD instructions can be used by compiler, do not reduce declarations //SIMD instructions can be used by compiler, do not reduce declarations
int a_exp = void; int a_exp = void;
@ -1480,7 +1480,7 @@ body
immutable am = ldexp(an, a_exp-1); immutable am = ldexp(an, a_exp-1);
immutable bm = ldexp(bn, b_exp-1); immutable bm = ldexp(bn, b_exp-1);
m = am + bm; m = am + bm;
if(!isFinite(m)) // wrong input: constraints are disabled in release mode if (!isFinite(m)) // wrong input: constraints are disabled in release mode
{ {
return typeof(return).init; return typeof(return).init;
} }
@ -1533,7 +1533,7 @@ body
// f must not be evaluated too close to x // f must not be evaluated too close to x
u = x + (fabs(d) >= tolerance ? d : d > 0 ? tolerance : -tolerance); u = x + (fabs(d) >= tolerance ? d : d > 0 ? tolerance : -tolerance);
immutable fu = f(u); immutable fu = f(u);
if(isNaN(fu) || fu == -T.infinity) if (isNaN(fu) || fu == -T.infinity)
{ {
return typeof(return)(u, fu, T.init); return typeof(return)(u, fu, T.init);
} }
@ -1563,15 +1563,17 @@ body
} }
/// ///
unittest { unittest
{
auto ret = findLocalMin((double x) => (x-4)^^2, -1e7, 1e7); auto ret = findLocalMin((double x) => (x-4)^^2, -1e7, 1e7);
assert(ret.x.approxEqual(4.0)); assert(ret.x.approxEqual(4.0));
assert(ret.y.approxEqual(0.0)); assert(ret.y.approxEqual(0.0));
} }
unittest { unittest
{
import std.meta: AliasSeq; import std.meta: AliasSeq;
foreach(T; AliasSeq!(double, float, real)) foreach (T; AliasSeq!(double, float, real))
{ {
{ {
auto ret = findLocalMin!T((T x) => (x-4)^^2, T.min_normal, 1e7); auto ret = findLocalMin!T((T x) => (x-4)^^2, T.min_normal, 1e7);
@ -1659,7 +1661,7 @@ euclideanDistance(Range1, Range2, F)(Range1 a, Range2 b, F limit)
unittest unittest
{ {
import std.meta : AliasSeq; import std.meta : AliasSeq;
foreach(T; AliasSeq!(double, const double, immutable double)) foreach (T; AliasSeq!(double, const double, immutable double))
{ {
T[] a = [ 1.0, 2.0, ]; T[] a = [ 1.0, 2.0, ];
T[] b = [ 4.0, 6.0, ]; T[] b = [ 4.0, 6.0, ];
@ -1749,7 +1751,7 @@ dotProduct(F1, F2)(in F1[] avector, in F2[] bvector)
unittest unittest
{ {
import std.meta : AliasSeq; import std.meta : AliasSeq;
foreach(T; AliasSeq!(double, const double, immutable double)) foreach (T; AliasSeq!(double, const double, immutable double))
{ {
T[] a = [ 1.0, 2.0, ]; T[] a = [ 1.0, 2.0, ];
T[] b = [ 4.0, 6.0, ]; T[] b = [ 4.0, 6.0, ];
@ -1793,7 +1795,7 @@ cosineSimilarity(Range1, Range2)(Range1 a, Range2 b)
unittest unittest
{ {
import std.meta : AliasSeq; import std.meta : AliasSeq;
foreach(T; AliasSeq!(double, const double, immutable double)) foreach (T; AliasSeq!(double, const double, immutable double))
{ {
T[] a = [ 1.0, 2.0, ]; T[] a = [ 1.0, 2.0, ];
T[] b = [ 4.0, 3.0, ]; T[] b = [ 4.0, 3.0, ];
@ -1943,7 +1945,7 @@ if (isInputRange!Range &&
unittest unittest
{ {
import std.meta : AliasSeq; import std.meta : AliasSeq;
foreach(T; AliasSeq!(double, const double, immutable double)) foreach (T; AliasSeq!(double, const double, immutable double))
{ {
T[] p = [ 0.0, 0, 0, 1 ]; T[] p = [ 0.0, 0, 0, 1 ];
assert(entropy(p) == 0); assert(entropy(p) == 0);
@ -2635,7 +2637,7 @@ private:
auto recurseRange = range; auto recurseRange = range;
recurseRange.doubleSteps(); recurseRange.doubleSteps();
if(buf.length > 4) if (buf.length > 4)
{ {
fftImpl(recurseRange, buf[0..$ / 2]); fftImpl(recurseRange, buf[0..$ / 2]);
recurseRange.popHalf(); recurseRange.popHalf();
@ -2670,7 +2672,7 @@ private:
// Converts odd indices of range to the imaginary components of // Converts odd indices of range to the imaginary components of
// a range half the size. The even indices become the real components. // a range half the size. The even indices become the real components.
static if(isArray!R && isFloatingPoint!E) static if (isArray!R && isFloatingPoint!E)
{ {
// Then the memory layout of complex numbers provides a dirt // Then the memory layout of complex numbers provides a dirt
// cheap way to convert. This is a common case, so take advantage. // cheap way to convert. This is a common case, so take advantage.
@ -2852,7 +2854,7 @@ private:
* inefficient, but having all the lookups be next to each other in * inefficient, but having all the lookups be next to each other in
* memory at every level of iteration is a huge win performance-wise. * memory at every level of iteration is a huge win performance-wise.
*/ */
if(size == 0) if (size == 0)
{ {
return; return;
} }
@ -2957,7 +2959,7 @@ public:
* property that can be both read and written and are floating point numbers. * property that can be both read and written and are floating point numbers.
*/ */
void fft(Ret, R)(R range, Ret buf) const void fft(Ret, R)(R range, Ret buf) const
if(isRandomAccessRange!Ret && isComplexLike!(ElementType!Ret) && hasSlicing!Ret) if (isRandomAccessRange!Ret && isComplexLike!(ElementType!Ret) && hasSlicing!Ret)
{ {
enforce(buf.length == range.length); enforce(buf.length == range.length);
enforceSize(range); enforceSize(range);