Add D front-end, libphobos library, and D2 testsuite.

ChangeLog:

	* Makefile.def (target_modules): Add libphobos.
	(flags_to_pass): Add GDC, GDCFLAGS, GDC_FOR_TARGET and
	GDCFLAGS_FOR_TARGET.
	(dependencies): Make libphobos depend on libatomic, libbacktrace
	configure, and zlib configure.
	(language): Add language d.
	* Makefile.in: Rebuild.
	* Makefile.tpl (BUILD_EXPORTS): Add GDC and GDCFLAGS.
	(HOST_EXPORTS): Add GDC.
	(POSTSTAGE1_HOST_EXPORTS): Add GDC and GDC_FOR_BUILD.
	(BASE_TARGET_EXPORTS): Add GDC.
	(GDC_FOR_BUILD, GDC, GDCFLAGS): New variables.
	(GDC_FOR_TARGET, GDC_FLAGS_FOR_TARGET): New variables.
	(EXTRA_HOST_FLAGS): Add GDC.
	(STAGE1_FLAGS_TO_PASS): Add GDC.
	(EXTRA_TARGET_FLAGS): Add GDC and GDCFLAGS.
	* config-ml.in: Treat GDC and GDCFLAGS like other compiler/flag
	environment variables.
	* configure: Rebuild.
	* configure.ac: Add target-libphobos to target_libraries.  Set and
	substitute GDC_FOR_BUILD and GDC_FOR_TARGET.

config/ChangeLog:

	* multi.m4: Set GDC.

gcc/ChangeLog:

	* Makefile.in (tm_d_file_list, tm_d_include_list): New variables.
	(TM_D_H, D_TARGET_DEF, D_TARGET_H, D_TARGET_OBJS): New variables.
	(tm_d.h, cs-tm_d.h, default-d.o): New rules.
	(d/d-target-hooks-def.h, s-d-target-hooks-def-h): New rules.
	(s-tm-texi): Also check timestamp on d-target.def.
	(generated_files): Add TM_D_H and d-target-hooks-def.h.
	(build/genhooks.o): Also depend on D_TARGET_DEF.
	* config.gcc (tm_d_file, d_target_objs, target_has_targetdm): New
	variables.
	* config/aarch64/aarch64-d.c: New file.
	* config/aarch64/aarch64-linux.h (GNU_USER_TARGET_D_CRITSEC_SIZE):
	Define.
	* config/aarch64/aarch64-protos.h (aarch64_d_target_versions): New
	prototype.
	* config/aarch64/aarch64.h (TARGET_D_CPU_VERSIONS): Define.
	* config/aarch64/t-aarch64 (aarch64-d.o): New rule.
	* config/arm/arm-d.c: New file.
	* config/arm/arm-protos.h (arm_d_target_versions): New prototype.
	* config/arm/arm.h (TARGET_D_CPU_VERSIONS): Define.
	* config/arm/linux-eabi.h (EXTRA_TARGET_D_OS_VERSIONS): Define.
	* config/arm/t-arm (arm-d.o): New rule.
	* config/default-d.c: New file.
	* config/glibc-d.c: New file.
	* config/gnu.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/i386/i386-d.c: New file.
	* config/i386/i386-protos.h (ix86_d_target_versions): New prototype.
	* config/i386/i386.h (TARGET_D_CPU_VERSIONS): Define.
	* config/i386/linux-common.h (EXTRA_TARGET_D_OS_VERSIONS): Define.
	(GNU_USER_TARGET_D_CRITSEC_SIZE): Define.
	* config/i386/t-i386 (i386-d.o): New rule.
	* config/kfreebsd-gnu.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/kopensolaris-gnu.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/linux-android.h (ANDROID_TARGET_D_OS_VERSIONS): Define.
	* config/linux.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/mips/linux-common.h (EXTRA_TARGET_D_OS_VERSIONS): Define.
	* config/mips/mips-d.c: New file.
	* config/mips/mips-protos.h (mips_d_target_versions): New prototype.
	* config/mips/mips.h (TARGET_D_CPU_VERSIONS): Define.
	* config/mips/t-mips (mips-d.o): New rule.
	* config/powerpcspe/linux.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/powerpcspe/linux64.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/powerpcspe/powerpcspe-d.c: New file.
	* config/powerpcspe/powerpcspe-protos.h (rs6000_d_target_versions):
	New prototype.
	* config/powerpcspe/powerpcspe.c (rs6000_output_function_epilogue):
	Support GNU D by using 0 as the language type.
	* config/powerpcspe/powerpcspe.h (TARGET_D_CPU_VERSIONS): Define.
	* config/powerpcspe/t-powerpcspe (powerpcspe-d.o): New rule.
	* config/riscv/riscv-d.c: New file.
	* config/riscv/riscv-protos.h (riscv_d_target_versions): New
	prototype.
	* config/riscv/riscv.h (TARGET_D_CPU_VERSIONS): Define.
	* config/riscv/t-riscv (riscv-d.o): New rule.
	* config/rs6000/linux.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/rs6000/linux64.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/rs6000/rs6000-d.c: New file.
	* config/rs6000/rs6000-protos.h (rs6000_d_target_versions): New
	prototype.
	* config/rs6000/rs6000.c (rs6000_output_function_epilogue):
	Support GNU D by using 0 as the language type.
	* config/rs6000/rs6000.h (TARGET_D_CPU_VERSIONS): Define.
	* config/rs6000/t-rs6000 (rs6000-d.o): New rule.
	* config/s390/s390-d.c: New file.
	* config/s390/s390-protos.h (s390_d_target_versions): New prototype.
	* config/s390/s390.h (TARGET_D_CPU_VERSIONS): Define.
	* config/s390/t-s390 (s390-d.o): New rule.
	* config/sparc/sparc-d.c: New file.
	* config/sparc/sparc-protos.h (sparc_d_target_versions): New
	prototype.
	* config/sparc/sparc.h (TARGET_D_CPU_VERSIONS): Define.
	* config/sparc/t-sparc (sparc-d.o): New rule.
	* config/t-glibc (glibc-d.o): New rule.
	* configure: Regenerated.
	* configure.ac (tm_d_file): New variable.
	(tm_d_file_list, tm_d_include_list, d_target_objs): Add substitutes.
	* doc/contrib.texi (Contributors): Add self for the D frontend.
	* doc/frontends.texi (G++ and GCC): Mention D as a supported language.
	* doc/install.texi (Configuration): Mention libphobos as an option for
	--enable-shared.  Mention d as an option for --enable-languages.
	(Testing): Mention check-d as a target.
	* doc/invoke.texi (Overall Options): Mention .d, .dd, and .di as file
	name suffixes.  Mention d as a -x option.
	* doc/sourcebuild.texi (Top Level): Mention libphobos.
	* doc/standards.texi (Standards): Add section on D language.
	* doc/tm.texi: Regenerated.
	* doc/tm.texi.in: Add @node for D language and ABI, and @hook for
	TARGET_CPU_VERSIONS, TARGET_D_OS_VERSIONS, and TARGET_D_CRITSEC_SIZE.
	* dwarf2out.c (is_dlang): New function.
	(gen_compile_unit_die): Use DW_LANG_D for D.
	(declare_in_namespace): Return module die for D, instead of adding
	extra declarations into the namespace.
	(gen_namespace_die): Generate DW_TAG_module for D.
	(gen_decl_die): Handle CONST_DECLSs for D.
	(dwarf2out_decl): Likewise.
	(prune_unused_types_walk_local_classes): Handle DW_tag_interface_type.
	(prune_unused_types_walk): Handle DW_tag_interface_type same as other
	kinds of aggregates.
	* gcc.c (default_compilers): Add entries for .d, .dd and .di.
	* genhooks.c: Include d/d-target.def.

gcc/po/ChangeLog:

	* EXCLUDES: Add sources from d/dmd.

gcc/testsuite/ChangeLog:

	* gcc.misc-tests/help.exp: Add D to option descriptions check.
	* gdc.dg/asan/asan.exp: New file.
	* gdc.dg/asan/gdc272.d: New test.
	* gdc.dg/compilable.d: New test.
	* gdc.dg/dg.exp: New file.
	* gdc.dg/gdc254.d: New test.
	* gdc.dg/gdc260.d: New test.
	* gdc.dg/gdc270a.d: New test.
	* gdc.dg/gdc270b.d: New test.
	* gdc.dg/gdc282.d: New test.
	* gdc.dg/gdc283.d: New test.
	* gdc.dg/imports/gdc170.d: New test.
	* gdc.dg/imports/gdc231.d: New test.
	* gdc.dg/imports/gdc239.d: New test.
	* gdc.dg/imports/gdc241a.d: New test.
	* gdc.dg/imports/gdc241b.d: New test.
	* gdc.dg/imports/gdc251a.d: New test.
	* gdc.dg/imports/gdc251b.d: New test.
	* gdc.dg/imports/gdc253.d: New test.
	* gdc.dg/imports/gdc254a.d: New test.
	* gdc.dg/imports/gdc256.d: New test.
	* gdc.dg/imports/gdc27.d: New test.
	* gdc.dg/imports/gdcpkg256/package.d: New test.
	* gdc.dg/imports/runnable.d: New test.
	* gdc.dg/link.d: New test.
	* gdc.dg/lto/lto.exp: New file.
	* gdc.dg/lto/ltotests_0.d: New test.
	* gdc.dg/lto/ltotests_1.d: New test.
	* gdc.dg/runnable.d: New test.
	* gdc.dg/simd.d: New test.
	* gdc.test/gdc-test.exp: New file.
	* lib/gdc-dg.exp: New file.
	* lib/gdc.exp: New file.

libphobos/ChangeLog:

	* Makefile.am: New file.
	* Makefile.in: New file.
	* acinclude.m4: New file.
	* aclocal.m4: New file.
	* config.h.in: New file.
	* configure: New file.
	* configure.ac: New file.
	* d_rules.am: New file.
	* libdruntime/Makefile.am: New file.
	* libdruntime/Makefile.in: New file.
	* libdruntime/__entrypoint.di: New file.
	* libdruntime/__main.di: New file.
	* libdruntime/gcc/attribute.d: New file.
	* libdruntime/gcc/backtrace.d: New file.
	* libdruntime/gcc/builtins.d: New file.
	* libdruntime/gcc/config.d.in: New file.
	* libdruntime/gcc/deh.d: New file.
	* libdruntime/gcc/libbacktrace.d.in: New file.
	* libdruntime/gcc/unwind/arm.d: New file.
	* libdruntime/gcc/unwind/arm_common.d: New file.
	* libdruntime/gcc/unwind/c6x.d: New file.
	* libdruntime/gcc/unwind/generic.d: New file.
	* libdruntime/gcc/unwind/package.d: New file.
	* libdruntime/gcc/unwind/pe.d: New file.
	* m4/autoconf.m4: New file.
	* m4/druntime.m4: New file.
	* m4/druntime/cpu.m4: New file.
	* m4/druntime/libraries.m4: New file.
	* m4/druntime/os.m4: New file.
	* m4/gcc_support.m4: New file.
	* m4/gdc.m4: New file.
	* m4/libtool.m4: New file.
	* src/Makefile.am: New file.
	* src/Makefile.in: New file.
	* src/libgphobos.spec.in: New file.
	* testsuite/Makefile.am: New file.
	* testsuite/Makefile.in: New file.
	* testsuite/config/default.exp: New file.
	* testsuite/lib/libphobos-dg.exp: New file.
	* testsuite/lib/libphobos.exp: New file.
	* testsuite/testsuite_flags.in: New file.

From-SVN: r265573

1 files changed, 361 insertions, 0 deletions

diff --git a/libphobos/src/std/mathspecial.d b/libphobos/src/std/mathspecial.d
new file mode 100644
index 0000000..e35c74c
--- /dev/null
+++ b/libphobos/src/std/mathspecial.d
@@ -0,0 +1,361 @@
+// Written in the D programming language.
+
+/**
+ * Mathematical Special Functions
+ *
+ * The technical term 'Special Functions' includes several families of
+ * transcendental functions, which have important applications in particular
+ * branches of mathematics and physics.
+ *
+ * The gamma and related functions, and the error function are crucial for
+ * mathematical statistics.
+ * The Bessel and related functions arise in problems involving wave propagation
+ * (especially in optics).
+ * Other major categories of special functions include the elliptic integrals
+ * (related to the arc length of an ellipse), and the hypergeometric functions.
+ *
+ * Status:
+ *  Many more functions will be added to this module.
+ *  The naming convention for the distribution functions (gammaIncomplete, etc)
+ *  is not yet finalized and will probably change.
+ *
+ * Macros:
+ *      TABLE_SV = <table border="1" cellpadding="4" cellspacing="0">
+ *              <caption>Special Values</caption>
+ *              $0</table>
+ *      SVH = $(TR $(TH $1) $(TH $2))
+ *      SV  = $(TR $(TD $1) $(TD $2))
+ *
+ *      NAN = $(RED NAN)
+ *      SUP = <span style="vertical-align:super;font-size:smaller">$0</span>
+ *      GAMMA = &#915;
+ *      THETA = &theta;
+ *      INTEGRAL = &#8747;
+ *      INTEGRATE = $(BIG &#8747;<sub>$(SMALL $1)</sub><sup>$2</sup>)
+ *      POWER = $1<sup>$2</sup>
+ *      SUB = $1<sub>$2</sub>
+ *      BIGSUM = $(BIG &Sigma; <sup>$2</sup><sub>$(SMALL $1)</sub>)
+ *      CHOOSE = $(BIG &#40;) <sup>$(SMALL $1)</sup><sub>$(SMALL $2)</sub> $(BIG &#41;)
+ *      PLUSMN = &plusmn;
+ *      INFIN = &infin;
+ *      PLUSMNINF = &plusmn;&infin;
+ *      PI = &pi;
+ *      LT = &lt;
+ *      GT = &gt;
+ *      SQRT = &radic;
+ *      HALF = &frac12;
+ *
+ *
+ * Copyright: Based on the CEPHES math library, which is
+ *            Copyright (C) 1994 Stephen L. Moshier (moshier@world.std.com).
+ * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
+ * Authors:   Stephen L. Moshier (original C code). Conversion to D by Don Clugston
+ * Source:    $(PHOBOSSRC std/_mathspecial.d)
+ */
+module std.mathspecial;
+import std.internal.math.errorfunction;
+import std.internal.math.gammafunction;
+public import std.math;
+
+/* ***********************************************
+ *            GAMMA AND RELATED FUNCTIONS        *
+ * ***********************************************/
+
+pure:
+nothrow:
+@safe:
+@nogc:
+
+/** The Gamma function, $(GAMMA)(x)
+ *
+ *  $(GAMMA)(x) is a generalisation of the factorial function
+ *  to real and complex numbers.
+ *  Like x!, $(GAMMA)(x+1) = x * $(GAMMA)(x).
+ *
+ *  Mathematically, if z.re > 0 then
+ *   $(GAMMA)(z) = $(INTEGRATE 0, $(INFIN)) $(POWER t, z-1)$(POWER e, -t) dt
+ *
+ *  $(TABLE_SV
+ *    $(SVH  x,           $(GAMMA)(x) )
+ *    $(SV  $(NAN),       $(NAN)      )
+ *    $(SV  $(PLUSMN)0.0, $(PLUSMNINF))
+ *    $(SV integer > 0,   (x-1)!      )
+ *    $(SV integer < 0,   $(NAN)      )
+ *    $(SV +$(INFIN),      +$(INFIN)   )
+ *    $(SV -$(INFIN),      $(NAN)      )
+ *  )
+ */
+real gamma(real x)
+{
+    return std.internal.math.gammafunction.gamma(x);
+}
+
+/** Natural logarithm of the gamma function, $(GAMMA)(x)
+ *
+ * Returns the base e (2.718...) logarithm of the absolute
+ * value of the gamma function of the argument.
+ *
+ * For reals, logGamma is equivalent to log(fabs(gamma(x))).
+ *
+ *  $(TABLE_SV
+ *    $(SVH  x,             logGamma(x)   )
+ *    $(SV  $(NAN),         $(NAN)      )
+ *    $(SV integer <= 0,    +$(INFIN)    )
+ *    $(SV $(PLUSMNINF),    +$(INFIN)    )
+ *  )
+ */
+real logGamma(real x)
+{
+    return std.internal.math.gammafunction.logGamma(x);
+}
+
+/** The sign of $(GAMMA)(x).
+ *
+ * Returns -1 if $(GAMMA)(x) < 0,  +1 if $(GAMMA)(x) > 0,
+ * $(NAN) if sign is indeterminate.
+ *
+ * Note that this function can be used in conjunction with logGamma(x) to
+ * evaluate gamma for very large values of x.
+ */
+real sgnGamma(real x)
+{
+    /* Author: Don Clugston. */
+    if (isNaN(x)) return x;
+    if (x > 0) return 1.0;
+    if (x < -1/real.epsilon)
+    {
+        // Large negatives lose all precision
+        return real.nan;
+    }
+    long n = rndtol(x);
+    if (x == n)
+    {
+        return x == 0 ?  copysign(1, x) : real.nan;
+    }
+    return n & 1 ? 1.0 : -1.0;
+}
+
+@safe unittest
+{
+    assert(sgnGamma(5.0) == 1.0);
+    assert(isNaN(sgnGamma(-3.0)));
+    assert(sgnGamma(-0.1) == -1.0);
+    assert(sgnGamma(-55.1) == 1.0);
+    assert(isNaN(sgnGamma(-real.infinity)));
+    assert(isIdentical(sgnGamma(NaN(0xABC)), NaN(0xABC)));
+}
+
+/** Beta function
+ *
+ * The beta function is defined as
+ *
+ * beta(x, y) = ($(GAMMA)(x) * $(GAMMA)(y)) / $(GAMMA)(x + y)
+ */
+real beta(real x, real y)
+{
+    if ((x+y)> MAXGAMMA)
+    {
+        return exp(logGamma(x) + logGamma(y) - logGamma(x+y));
+    } else return gamma(x) * gamma(y) / gamma(x+y);
+}
+
+@safe unittest
+{
+    assert(isIdentical(beta(NaN(0xABC), 4), NaN(0xABC)));
+    assert(isIdentical(beta(2, NaN(0xABC)), NaN(0xABC)));
+}
+
+/** Digamma function
+ *
+ *  The digamma function is the logarithmic derivative of the gamma function.
+ *
+ *  digamma(x) = d/dx logGamma(x)
+ *
+ *  See_Also: $(LREF logmdigamma), $(LREF logmdigammaInverse).
+ */
+real digamma(real x)
+{
+    return std.internal.math.gammafunction.digamma(x);
+}
+
+/** Log Minus Digamma function
+ *
+ *  logmdigamma(x) = log(x) - digamma(x)
+ *
+ *  See_Also: $(LREF digamma), $(LREF logmdigammaInverse).
+ */
+real logmdigamma(real x)
+{
+    return std.internal.math.gammafunction.logmdigamma(x);
+}
+
+/** Inverse of the Log Minus Digamma function
+ *
+ *  Given y, the function finds x such log(x) - digamma(x) = y.
+ *
+ *  See_Also: $(LREF logmdigamma), $(LREF digamma).
+ */
+real logmdigammaInverse(real x)
+{
+    return std.internal.math.gammafunction.logmdigammaInverse(x);
+}
+
+/** Incomplete beta integral
+ *
+ * Returns incomplete beta integral of the arguments, evaluated
+ * from zero to x. The regularized incomplete beta function is defined as
+ *
+ * betaIncomplete(a, b, x) = $(GAMMA)(a + b) / ( $(GAMMA)(a) $(GAMMA)(b) ) *
+ * $(INTEGRATE 0, x) $(POWER t, a-1)$(POWER (1-t), b-1) dt
+ *
+ * and is the same as the the cumulative distribution function.
+ *
+ * The domain of definition is 0 <= x <= 1.  In this
+ * implementation a and b are restricted to positive values.
+ * The integral from x to 1 may be obtained by the symmetry
+ * relation
+ *
+ *    betaIncompleteCompl(a, b, x )  =  betaIncomplete( b, a, 1-x )
+ *
+ * The integral is evaluated by a continued fraction expansion
+ * or, when b * x is small, by a power series.
+ */
+real betaIncomplete(real a, real b, real x )
+{
+    return std.internal.math.gammafunction.betaIncomplete(a, b, x);
+}
+
+/** Inverse of incomplete beta integral
+ *
+ * Given y, the function finds x such that
+ *
+ *  betaIncomplete(a, b, x) == y
+ *
+ *  Newton iterations or interval halving is used.
+ */
+real betaIncompleteInverse(real a, real b, real y )
+{
+    return std.internal.math.gammafunction.betaIncompleteInv(a, b, y);
+}
+
+/** Incomplete gamma integral and its complement
+ *
+ * These functions are defined by
+ *
+ *   gammaIncomplete = ( $(INTEGRATE 0, x) $(POWER e, -t) $(POWER t, a-1) dt )/ $(GAMMA)(a)
+ *
+ *  gammaIncompleteCompl(a,x)   =   1 - gammaIncomplete(a,x)
+ * = ($(INTEGRATE x, $(INFIN)) $(POWER e, -t) $(POWER t, a-1) dt )/ $(GAMMA)(a)
+ *
+ * In this implementation both arguments must be positive.
+ * The integral is evaluated by either a power series or
+ * continued fraction expansion, depending on the relative
+ * values of a and x.
+ */
+real gammaIncomplete(real a, real x )
+in {
+   assert(x >= 0);
+   assert(a > 0);
+}
+body {
+    return std.internal.math.gammafunction.gammaIncomplete(a, x);
+}
+
+/** ditto */
+real gammaIncompleteCompl(real a, real x )
+in {
+   assert(x >= 0);
+   assert(a > 0);
+}
+body {
+    return std.internal.math.gammafunction.gammaIncompleteCompl(a, x);
+}
+
+/** Inverse of complemented incomplete gamma integral
+ *
+ * Given a and p, the function finds x such that
+ *
+ *  gammaIncompleteCompl( a, x ) = p.
+ */
+real gammaIncompleteComplInverse(real a, real p)
+in {
+  assert(p >= 0 && p <= 1);
+  assert(a > 0);
+}
+body {
+    return std.internal.math.gammafunction.gammaIncompleteComplInv(a, p);
+}
+
+
+/* ***********************************************
+ *     ERROR FUNCTIONS & NORMAL DISTRIBUTION     *
+ * ***********************************************/
+
+ /** Error function
+ *
+ * The integral is
+ *
+ *  erf(x) =  2/ $(SQRT)($(PI))
+ *     $(INTEGRATE 0, x) exp( - $(POWER t, 2)) dt
+ *
+ * The magnitude of x is limited to about 106.56 for IEEE 80-bit
+ * arithmetic; 1 or -1 is returned outside this range.
+ */
+real erf(real x)
+{
+    return std.internal.math.errorfunction.erf(x);
+}
+
+/** Complementary error function
+ *
+ * erfc(x) = 1 - erf(x)
+ *         = 2/ $(SQRT)($(PI))
+ *     $(INTEGRATE x, $(INFIN)) exp( - $(POWER t, 2)) dt
+ *
+ * This function has high relative accuracy for
+ * values of x far from zero. (For values near zero, use erf(x)).
+ */
+real erfc(real x)
+{
+    return std.internal.math.errorfunction.erfc(x);
+}
+
+
+/** Normal distribution function.
+ *
+ * The normal (or Gaussian, or bell-shaped) distribution is
+ * defined as:
+ *
+ * normalDist(x) = 1/$(SQRT)(2$(PI)) $(INTEGRATE -$(INFIN), x) exp( - $(POWER t, 2)/2) dt
+ *   = 0.5 + 0.5 * erf(x/sqrt(2))
+ *   = 0.5 * erfc(- x/sqrt(2))
+ *
+ * To maintain accuracy at values of x near 1.0, use
+ *      normalDistribution(x) = 1.0 - normalDistribution(-x).
+ *
+ * References:
+ * $(LINK http://www.netlib.org/cephes/ldoubdoc.html),
+ * G. Marsaglia, "Evaluating the Normal Distribution",
+ * Journal of Statistical Software <b>11</b>, (July 2004).
+ */
+real normalDistribution(real x)
+{
+    return std.internal.math.errorfunction.normalDistributionImpl(x);
+}
+
+/** Inverse of Normal distribution function
+ *
+ * Returns the argument, x, for which the area under the
+ * Normal probability density function (integrated from
+ * minus infinity to x) is equal to p.
+ *
+ * Note: This function is only implemented to 80 bit precision.
+ */
+real normalDistributionInverse(real p)
+in {
+  assert(p >= 0.0L && p <= 1.0L, "Domain error");
+}
+body
+{
+    return std.internal.math.errorfunction.normalDistributionInvImpl(p);
+}