[sf.cmath.sph_neumann] - C++14 → C++17

Files changed (1) hide show

tmp/tmpijoehg9r/{from.md → to.md} +283 -0

tmp/tmpijoehg9r/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,283 @@

+#### Spherical Neumann functions <a id="sf.cmath.sph_neumann">[[sf.cmath.sph_neumann]]</a>
+``` cpp
+double       sph_neumann(unsigned n, double x);
+float        sph_neumannf(unsigned n, float x);
+long double  sph_neumannl(unsigned n, long double x);
+```
+*Effects:* These functions compute the spherical Neumann functions, also
+known as the spherical Bessel functions of the second kind, of their
+respective arguments `n` and `x`.
+*Returns:* $$%
+  \mathsf{n}_n(x) =
+  (\pi/2x)^{1\!/\!2} \mathsf{N}_{n + 1\!/\!2}(x),
+       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
+*Remarks:* The effect of calling each of these functions is
+*implementation-defined* if `n >= 128`.
+See also [[sf.cmath.cyl_neumann]].
+<!-- Link reference definitions -->
+[accumulate]: #accumulate
+[adjacent.difference]: #adjacent.difference
+[algorithms]: algorithms.md#algorithms
+[bad.alloc]: language.md#bad.alloc
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.stc.thread]: basic.md#basic.stc.thread
+[basic.types]: basic.md#basic.types
+[c.math]: #c.math
+[c.math.abs]: #c.math.abs
+[c.math.fpclass]: #c.math.fpclass
+[c.math.hypot3]: #c.math.hypot3
+[c.math.rand]: #c.math.rand
+[cfenv]: #cfenv
+[cfenv.syn]: #cfenv.syn
+[class.gslice]: #class.gslice
+[class.gslice.overview]: #class.gslice.overview
+[class.slice]: #class.slice
+[class.slice.overview]: #class.slice.overview
+[cmath.syn]: #cmath.syn
+[cmplx.over]: #cmplx.over
+[complex]: #complex
+[complex.literals]: #complex.literals
+[complex.member.ops]: #complex.member.ops
+[complex.members]: #complex.members
+[complex.numbers]: #complex.numbers
+[complex.ops]: #complex.ops
+[complex.special]: #complex.special
+[complex.syn]: #complex.syn
+[complex.transcendentals]: #complex.transcendentals
+[complex.value.ops]: #complex.value.ops
+[cons.slice]: #cons.slice
+[conv.prom]: conv.md#conv.prom
+[cpp.pragma]: cpp.md#cpp.pragma
+[cstdlib.syn]: language.md#cstdlib.syn
+[dcl.array]: dcl.md#dcl.array
+[dcl.init]: dcl.md#dcl.init
+[exclusive.scan]: #exclusive.scan
+[function.objects]: utilities.md#function.objects
+[gslice.access]: #gslice.access
+[gslice.array.assign]: #gslice.array.assign
+[gslice.array.comp.assign]: #gslice.array.comp.assign
+[gslice.array.fill]: #gslice.array.fill
+[gslice.cons]: #gslice.cons
+[implimits]: limits.md#implimits
+[inclusive.scan]: #inclusive.scan
+[indirect.array.assign]: #indirect.array.assign
+[indirect.array.comp.assign]: #indirect.array.comp.assign
+[indirect.array.fill]: #indirect.array.fill
+[inner.product]: #inner.product
+[input.iterators]: iterators.md#input.iterators
+[input.output]: input.md#input.output
+[iostate.flags]: input.md#iostate.flags
+[istream.formatted]: input.md#istream.formatted
+[iterator.requirements.general]: iterators.md#iterator.requirements.general
+[library.c]: library.md#library.c
+[mask.array.assign]: #mask.array.assign
+[mask.array.comp.assign]: #mask.array.comp.assign
+[mask.array.fill]: #mask.array.fill
+[numarray]: #numarray
+[numeric.iota]: #numeric.iota
+[numeric.ops]: #numeric.ops
+[numeric.ops.gcd]: #numeric.ops.gcd
+[numeric.ops.lcm]: #numeric.ops.lcm
+[numeric.ops.overview]: #numeric.ops.overview
+[numeric.requirements]: #numeric.requirements
+[numerics]: #numerics
+[numerics.defns]: #numerics.defns
+[numerics.general]: #numerics.general
+[output.iterators]: iterators.md#output.iterators
+[partial.sum]: #partial.sum
+[rand]: #rand
+[rand.adapt]: #rand.adapt
+[rand.adapt.disc]: #rand.adapt.disc
+[rand.adapt.general]: #rand.adapt.general
+[rand.adapt.ibits]: #rand.adapt.ibits
+[rand.adapt.shuf]: #rand.adapt.shuf
+[rand.device]: #rand.device
+[rand.dist]: #rand.dist
+[rand.dist.bern]: #rand.dist.bern
+[rand.dist.bern.bernoulli]: #rand.dist.bern.bernoulli
+[rand.dist.bern.bin]: #rand.dist.bern.bin
+[rand.dist.bern.geo]: #rand.dist.bern.geo
+[rand.dist.bern.negbin]: #rand.dist.bern.negbin
+[rand.dist.general]: #rand.dist.general
+[rand.dist.norm]: #rand.dist.norm
+[rand.dist.norm.cauchy]: #rand.dist.norm.cauchy
+[rand.dist.norm.chisq]: #rand.dist.norm.chisq
+[rand.dist.norm.f]: #rand.dist.norm.f
+[rand.dist.norm.lognormal]: #rand.dist.norm.lognormal
+[rand.dist.norm.normal]: #rand.dist.norm.normal
+[rand.dist.norm.t]: #rand.dist.norm.t
+[rand.dist.pois]: #rand.dist.pois
+[rand.dist.pois.exp]: #rand.dist.pois.exp
+[rand.dist.pois.extreme]: #rand.dist.pois.extreme
+[rand.dist.pois.gamma]: #rand.dist.pois.gamma
+[rand.dist.pois.poisson]: #rand.dist.pois.poisson
+[rand.dist.pois.weibull]: #rand.dist.pois.weibull
+[rand.dist.samp]: #rand.dist.samp
+[rand.dist.samp.discrete]: #rand.dist.samp.discrete
+[rand.dist.samp.pconst]: #rand.dist.samp.pconst
+[rand.dist.samp.plinear]: #rand.dist.samp.plinear
+[rand.dist.uni]: #rand.dist.uni
+[rand.dist.uni.int]: #rand.dist.uni.int
+[rand.dist.uni.real]: #rand.dist.uni.real
+[rand.eng]: #rand.eng
+[rand.eng.lcong]: #rand.eng.lcong
+[rand.eng.mers]: #rand.eng.mers
+[rand.eng.sub]: #rand.eng.sub
+[rand.predef]: #rand.predef
+[rand.req]: #rand.req
+[rand.req.adapt]: #rand.req.adapt
+[rand.req.dist]: #rand.req.dist
+[rand.req.eng]: #rand.req.eng
+[rand.req.genl]: #rand.req.genl
+[rand.req.seedseq]: #rand.req.seedseq
+[rand.req.urng]: #rand.req.urng
+[rand.synopsis]: #rand.synopsis
+[rand.util]: #rand.util
+[rand.util.canonical]: #rand.util.canonical
+[rand.util.seedseq]: #rand.util.seedseq
+[random.access.iterators]: iterators.md#random.access.iterators
+[reduce]: #reduce
+[res.on.data.races]: library.md#res.on.data.races
+[sf.cmath]: #sf.cmath
+[sf.cmath.assoc_laguerre]: #sf.cmath.assoc_laguerre
+[sf.cmath.assoc_legendre]: #sf.cmath.assoc_legendre
+[sf.cmath.beta]: #sf.cmath.beta
+[sf.cmath.comp_ellint_1]: #sf.cmath.comp_ellint_1
+[sf.cmath.comp_ellint_2]: #sf.cmath.comp_ellint_2
+[sf.cmath.comp_ellint_3]: #sf.cmath.comp_ellint_3
+[sf.cmath.cyl_bessel_i]: #sf.cmath.cyl_bessel_i
+[sf.cmath.cyl_bessel_j]: #sf.cmath.cyl_bessel_j
+[sf.cmath.cyl_bessel_k]: #sf.cmath.cyl_bessel_k
+[sf.cmath.cyl_neumann]: #sf.cmath.cyl_neumann
+[sf.cmath.ellint_1]: #sf.cmath.ellint_1
+[sf.cmath.ellint_2]: #sf.cmath.ellint_2
+[sf.cmath.ellint_3]: #sf.cmath.ellint_3
+[sf.cmath.expint]: #sf.cmath.expint
+[sf.cmath.hermite]: #sf.cmath.hermite
+[sf.cmath.laguerre]: #sf.cmath.laguerre
+[sf.cmath.legendre]: #sf.cmath.legendre
+[sf.cmath.riemann_zeta]: #sf.cmath.riemann_zeta
+[sf.cmath.sph_bessel]: #sf.cmath.sph_bessel
+[sf.cmath.sph_legendre]: #sf.cmath.sph_legendre
+[sf.cmath.sph_neumann]: #sf.cmath.sph_neumann
+[slice.access]: #slice.access
+[slice.arr.assign]: #slice.arr.assign
+[slice.arr.comp.assign]: #slice.arr.comp.assign
+[slice.arr.fill]: #slice.arr.fill
+[strings]: strings.md#strings
+[tab:RandomDistribution]: #tab:RandomDistribution
+[tab:RandomEngine]: #tab:RandomEngine
+[tab:SeedSequence]: #tab:SeedSequence
+[tab:UniformRandomBitGenerator]: #tab:UniformRandomBitGenerator
+[tab:copyassignable]: #tab:copyassignable
+[tab:copyconstructible]: #tab:copyconstructible
+[tab:equalitycomparable]: #tab:equalitycomparable
+[tab:iterator.input.requirements]: iterators.md#tab:iterator.input.requirements
+[tab:moveassignable]: #tab:moveassignable
+[tab:moveconstructible]: #tab:moveconstructible
+[tab:numerics.lib.summary]: #tab:numerics.lib.summary
+[template.gslice.array]: #template.gslice.array
+[template.gslice.array.overview]: #template.gslice.array.overview
+[template.indirect.array]: #template.indirect.array
+[template.indirect.array.overview]: #template.indirect.array.overview
+[template.mask.array]: #template.mask.array
+[template.mask.array.overview]: #template.mask.array.overview
+[template.slice.array]: #template.slice.array
+[template.slice.array.overview]: #template.slice.array.overview
+[template.valarray]: #template.valarray
+[template.valarray.overview]: #template.valarray.overview
+[thread.thread.class]: thread.md#thread.thread.class
+[transform.exclusive.scan]: #transform.exclusive.scan
+[transform.inclusive.scan]: #transform.inclusive.scan
+[transform.reduce]: #transform.reduce
+[valarray.access]: #valarray.access
+[valarray.assign]: #valarray.assign
+[valarray.binary]: #valarray.binary
+[valarray.cassign]: #valarray.cassign
+[valarray.comparison]: #valarray.comparison
+[valarray.cons]: #valarray.cons
+[valarray.members]: #valarray.members
+[valarray.nonmembers]: #valarray.nonmembers
+[valarray.range]: #valarray.range
+[valarray.special]: #valarray.special
+[valarray.sub]: #valarray.sub
+[valarray.syn]: #valarray.syn
+[valarray.transcend]: #valarray.transcend
+[valarray.unary]: #valarray.unary
+[vector]: containers.md#vector
+[^1]: In other words, value types. These include arithmetic types,
+    pointers, the library class `complex`, and instantiations of
+    `valarray` for value types.
+[^2]: The name of this engine refers, in part, to a property of its
+    period: For properly-selected values of the parameters, the period
+    is closely related to a large Mersenne prime number.
+[^3]: The parameter is intended to allow an implementation to
+    differentiate between different sources of randomness.
+[^4]: If a device has n states whose respective probabilities are
+    P₀, …, Pₙ₋₁, the device entropy S is defined as
+    $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
+[^5]: b is introduced to avoid any attempt to produce more bits of
+    randomness than can be held in `RealType`.
+[^6]: The distribution corresponding to this probability density
+    function is also known (with a possible change of variable) as the
+    Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
+    distribution.
+[^7]: Annex  [[implimits]] recommends a minimum number of recursively
+    nested template instantiations. This requirement thus indirectly
+    suggests a minimum allowable complexity for valarray expressions.
+[^8]: The intent is to specify an array template that has the minimum
+    functionality necessary to address aliasing ambiguities and the
+    proliferation of temporaries. Thus, the `valarray` template is
+    neither a matrix class nor a field class. However, it is a very
+    useful building block for designing such classes.
+[^9]: This default constructor is essential, since arrays of `valarray`
+    may be useful. After initialization, the length of an empty array
+    can be increased with the `resize` member function.
+[^10]: This constructor is the preferred method for converting a C array
+    to a `valarray` object.
+[^11]: This copy constructor creates a distinct array rather than an
+    alias. Implementations in which arrays share storage are permitted,
+    but they shall implement a copy-on-reference mechanism to ensure
+    that arrays are conceptually distinct.
+[^12]: BLAS stands for *Basic Linear Algebra Subprograms.* C++programs
+    may instantiate this class. See, for example, Dongarra, Du Croz,
+    Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
+    Subprograms*; Technical Report MCS-P1-0888, Argonne National
+    Laboratory (USA), Mathematics and Computer Science Division, August,
+    1988.
+[^13]: The use of fully closed ranges is intentional.
+[^14]: `accumulate` is similar to the APL reduction operator and Common
+    Lisp reduce function, but it avoids the difficulty of defining the
+    result of reduction on an empty sequence by always requiring an
+    initial value.
+[^15]: The use of fully closed ranges is intentional.
+[^16]: The use of fully closed ranges is intentional.
+[^17]: The use of fully closed ranges is intentional.
+[^18]: A mathematical function is mathematically defined for a given set
+    of argument values (a) if it is explicitly defined for that set of
+    argument values, or (b) if its limiting value exists and does not
+    depend on the direction of approach.

Diff to HTML by rtfpessoa