From Jason Turner

[sf.cmath.sph_neumann]

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpwq_9aap0/{from.md → to.md} +0 -283
tmp/tmpwq_9aap0/{from.md → to.md} RENAMED
@@ -1,283 +0,0 @@
1
- #### Spherical Neumann functions <a id="sf.cmath.sph_neumann">[[sf.cmath.sph_neumann]]</a>
2
-
3
- ``` cpp
4
- double sph_neumann(unsigned n, double x);
5
- float sph_neumannf(unsigned n, float x);
6
- long double sph_neumannl(unsigned n, long double x);
7
- ```
8
-
9
- *Effects:* These functions compute the spherical Neumann functions, also
10
- known as the spherical Bessel functions of the second kind, of their
11
- respective arguments `n` and `x`.
12
-
13
- *Returns:* $$%
14
- \mathsf{n}_n(x) =
15
- (\pi/2x)^{1\!/\!2} \mathsf{N}_{n + 1\!/\!2}(x),
16
- \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
17
-
18
- *Remarks:* The effect of calling each of these functions is
19
- *implementation-defined* if `n >= 128`.
20
-
21
- See also [[sf.cmath.cyl_neumann]].
22
-
23
- <!-- Link reference definitions -->
24
- [accumulate]: #accumulate
25
- [adjacent.difference]: #adjacent.difference
26
- [algorithms]: algorithms.md#algorithms
27
- [bad.alloc]: language.md#bad.alloc
28
- [basic.fundamental]: basic.md#basic.fundamental
29
- [basic.stc.thread]: basic.md#basic.stc.thread
30
- [basic.types]: basic.md#basic.types
31
- [c.math]: #c.math
32
- [c.math.abs]: #c.math.abs
33
- [c.math.fpclass]: #c.math.fpclass
34
- [c.math.hypot3]: #c.math.hypot3
35
- [c.math.rand]: #c.math.rand
36
- [cfenv]: #cfenv
37
- [cfenv.syn]: #cfenv.syn
38
- [class.gslice]: #class.gslice
39
- [class.gslice.overview]: #class.gslice.overview
40
- [class.slice]: #class.slice
41
- [class.slice.overview]: #class.slice.overview
42
- [cmath.syn]: #cmath.syn
43
- [cmplx.over]: #cmplx.over
44
- [complex]: #complex
45
- [complex.literals]: #complex.literals
46
- [complex.member.ops]: #complex.member.ops
47
- [complex.members]: #complex.members
48
- [complex.numbers]: #complex.numbers
49
- [complex.ops]: #complex.ops
50
- [complex.special]: #complex.special
51
- [complex.syn]: #complex.syn
52
- [complex.transcendentals]: #complex.transcendentals
53
- [complex.value.ops]: #complex.value.ops
54
- [cons.slice]: #cons.slice
55
- [conv.prom]: conv.md#conv.prom
56
- [cpp.pragma]: cpp.md#cpp.pragma
57
- [cstdlib.syn]: language.md#cstdlib.syn
58
- [dcl.array]: dcl.md#dcl.array
59
- [dcl.init]: dcl.md#dcl.init
60
- [exclusive.scan]: #exclusive.scan
61
- [function.objects]: utilities.md#function.objects
62
- [gslice.access]: #gslice.access
63
- [gslice.array.assign]: #gslice.array.assign
64
- [gslice.array.comp.assign]: #gslice.array.comp.assign
65
- [gslice.array.fill]: #gslice.array.fill
66
- [gslice.cons]: #gslice.cons
67
- [implimits]: limits.md#implimits
68
- [inclusive.scan]: #inclusive.scan
69
- [indirect.array.assign]: #indirect.array.assign
70
- [indirect.array.comp.assign]: #indirect.array.comp.assign
71
- [indirect.array.fill]: #indirect.array.fill
72
- [inner.product]: #inner.product
73
- [input.iterators]: iterators.md#input.iterators
74
- [input.output]: input.md#input.output
75
- [iostate.flags]: input.md#iostate.flags
76
- [istream.formatted]: input.md#istream.formatted
77
- [iterator.requirements.general]: iterators.md#iterator.requirements.general
78
- [library.c]: library.md#library.c
79
- [mask.array.assign]: #mask.array.assign
80
- [mask.array.comp.assign]: #mask.array.comp.assign
81
- [mask.array.fill]: #mask.array.fill
82
- [numarray]: #numarray
83
- [numeric.iota]: #numeric.iota
84
- [numeric.ops]: #numeric.ops
85
- [numeric.ops.gcd]: #numeric.ops.gcd
86
- [numeric.ops.lcm]: #numeric.ops.lcm
87
- [numeric.ops.overview]: #numeric.ops.overview
88
- [numeric.requirements]: #numeric.requirements
89
- [numerics]: #numerics
90
- [numerics.defns]: #numerics.defns
91
- [numerics.general]: #numerics.general
92
- [output.iterators]: iterators.md#output.iterators
93
- [partial.sum]: #partial.sum
94
- [rand]: #rand
95
- [rand.adapt]: #rand.adapt
96
- [rand.adapt.disc]: #rand.adapt.disc
97
- [rand.adapt.general]: #rand.adapt.general
98
- [rand.adapt.ibits]: #rand.adapt.ibits
99
- [rand.adapt.shuf]: #rand.adapt.shuf
100
- [rand.device]: #rand.device
101
- [rand.dist]: #rand.dist
102
- [rand.dist.bern]: #rand.dist.bern
103
- [rand.dist.bern.bernoulli]: #rand.dist.bern.bernoulli
104
- [rand.dist.bern.bin]: #rand.dist.bern.bin
105
- [rand.dist.bern.geo]: #rand.dist.bern.geo
106
- [rand.dist.bern.negbin]: #rand.dist.bern.negbin
107
- [rand.dist.general]: #rand.dist.general
108
- [rand.dist.norm]: #rand.dist.norm
109
- [rand.dist.norm.cauchy]: #rand.dist.norm.cauchy
110
- [rand.dist.norm.chisq]: #rand.dist.norm.chisq
111
- [rand.dist.norm.f]: #rand.dist.norm.f
112
- [rand.dist.norm.lognormal]: #rand.dist.norm.lognormal
113
- [rand.dist.norm.normal]: #rand.dist.norm.normal
114
- [rand.dist.norm.t]: #rand.dist.norm.t
115
- [rand.dist.pois]: #rand.dist.pois
116
- [rand.dist.pois.exp]: #rand.dist.pois.exp
117
- [rand.dist.pois.extreme]: #rand.dist.pois.extreme
118
- [rand.dist.pois.gamma]: #rand.dist.pois.gamma
119
- [rand.dist.pois.poisson]: #rand.dist.pois.poisson
120
- [rand.dist.pois.weibull]: #rand.dist.pois.weibull
121
- [rand.dist.samp]: #rand.dist.samp
122
- [rand.dist.samp.discrete]: #rand.dist.samp.discrete
123
- [rand.dist.samp.pconst]: #rand.dist.samp.pconst
124
- [rand.dist.samp.plinear]: #rand.dist.samp.plinear
125
- [rand.dist.uni]: #rand.dist.uni
126
- [rand.dist.uni.int]: #rand.dist.uni.int
127
- [rand.dist.uni.real]: #rand.dist.uni.real
128
- [rand.eng]: #rand.eng
129
- [rand.eng.lcong]: #rand.eng.lcong
130
- [rand.eng.mers]: #rand.eng.mers
131
- [rand.eng.sub]: #rand.eng.sub
132
- [rand.predef]: #rand.predef
133
- [rand.req]: #rand.req
134
- [rand.req.adapt]: #rand.req.adapt
135
- [rand.req.dist]: #rand.req.dist
136
- [rand.req.eng]: #rand.req.eng
137
- [rand.req.genl]: #rand.req.genl
138
- [rand.req.seedseq]: #rand.req.seedseq
139
- [rand.req.urng]: #rand.req.urng
140
- [rand.synopsis]: #rand.synopsis
141
- [rand.util]: #rand.util
142
- [rand.util.canonical]: #rand.util.canonical
143
- [rand.util.seedseq]: #rand.util.seedseq
144
- [random.access.iterators]: iterators.md#random.access.iterators
145
- [reduce]: #reduce
146
- [res.on.data.races]: library.md#res.on.data.races
147
- [sf.cmath]: #sf.cmath
148
- [sf.cmath.assoc_laguerre]: #sf.cmath.assoc_laguerre
149
- [sf.cmath.assoc_legendre]: #sf.cmath.assoc_legendre
150
- [sf.cmath.beta]: #sf.cmath.beta
151
- [sf.cmath.comp_ellint_1]: #sf.cmath.comp_ellint_1
152
- [sf.cmath.comp_ellint_2]: #sf.cmath.comp_ellint_2
153
- [sf.cmath.comp_ellint_3]: #sf.cmath.comp_ellint_3
154
- [sf.cmath.cyl_bessel_i]: #sf.cmath.cyl_bessel_i
155
- [sf.cmath.cyl_bessel_j]: #sf.cmath.cyl_bessel_j
156
- [sf.cmath.cyl_bessel_k]: #sf.cmath.cyl_bessel_k
157
- [sf.cmath.cyl_neumann]: #sf.cmath.cyl_neumann
158
- [sf.cmath.ellint_1]: #sf.cmath.ellint_1
159
- [sf.cmath.ellint_2]: #sf.cmath.ellint_2
160
- [sf.cmath.ellint_3]: #sf.cmath.ellint_3
161
- [sf.cmath.expint]: #sf.cmath.expint
162
- [sf.cmath.hermite]: #sf.cmath.hermite
163
- [sf.cmath.laguerre]: #sf.cmath.laguerre
164
- [sf.cmath.legendre]: #sf.cmath.legendre
165
- [sf.cmath.riemann_zeta]: #sf.cmath.riemann_zeta
166
- [sf.cmath.sph_bessel]: #sf.cmath.sph_bessel
167
- [sf.cmath.sph_legendre]: #sf.cmath.sph_legendre
168
- [sf.cmath.sph_neumann]: #sf.cmath.sph_neumann
169
- [slice.access]: #slice.access
170
- [slice.arr.assign]: #slice.arr.assign
171
- [slice.arr.comp.assign]: #slice.arr.comp.assign
172
- [slice.arr.fill]: #slice.arr.fill
173
- [strings]: strings.md#strings
174
- [tab:RandomDistribution]: #tab:RandomDistribution
175
- [tab:RandomEngine]: #tab:RandomEngine
176
- [tab:SeedSequence]: #tab:SeedSequence
177
- [tab:UniformRandomBitGenerator]: #tab:UniformRandomBitGenerator
178
- [tab:copyassignable]: #tab:copyassignable
179
- [tab:copyconstructible]: #tab:copyconstructible
180
- [tab:equalitycomparable]: #tab:equalitycomparable
181
- [tab:iterator.input.requirements]: iterators.md#tab:iterator.input.requirements
182
- [tab:moveassignable]: #tab:moveassignable
183
- [tab:moveconstructible]: #tab:moveconstructible
184
- [tab:numerics.lib.summary]: #tab:numerics.lib.summary
185
- [template.gslice.array]: #template.gslice.array
186
- [template.gslice.array.overview]: #template.gslice.array.overview
187
- [template.indirect.array]: #template.indirect.array
188
- [template.indirect.array.overview]: #template.indirect.array.overview
189
- [template.mask.array]: #template.mask.array
190
- [template.mask.array.overview]: #template.mask.array.overview
191
- [template.slice.array]: #template.slice.array
192
- [template.slice.array.overview]: #template.slice.array.overview
193
- [template.valarray]: #template.valarray
194
- [template.valarray.overview]: #template.valarray.overview
195
- [thread.thread.class]: thread.md#thread.thread.class
196
- [transform.exclusive.scan]: #transform.exclusive.scan
197
- [transform.inclusive.scan]: #transform.inclusive.scan
198
- [transform.reduce]: #transform.reduce
199
- [valarray.access]: #valarray.access
200
- [valarray.assign]: #valarray.assign
201
- [valarray.binary]: #valarray.binary
202
- [valarray.cassign]: #valarray.cassign
203
- [valarray.comparison]: #valarray.comparison
204
- [valarray.cons]: #valarray.cons
205
- [valarray.members]: #valarray.members
206
- [valarray.nonmembers]: #valarray.nonmembers
207
- [valarray.range]: #valarray.range
208
- [valarray.special]: #valarray.special
209
- [valarray.sub]: #valarray.sub
210
- [valarray.syn]: #valarray.syn
211
- [valarray.transcend]: #valarray.transcend
212
- [valarray.unary]: #valarray.unary
213
- [vector]: containers.md#vector
214
-
215
- [^1]: In other words, value types. These include arithmetic types,
216
- pointers, the library class `complex`, and instantiations of
217
- `valarray` for value types.
218
-
219
- [^2]: The name of this engine refers, in part, to a property of its
220
- period: For properly-selected values of the parameters, the period
221
- is closely related to a large Mersenne prime number.
222
-
223
- [^3]: The parameter is intended to allow an implementation to
224
- differentiate between different sources of randomness.
225
-
226
- [^4]: If a device has n states whose respective probabilities are
227
- P₀, …, Pₙ₋₁, the device entropy S is defined as
228
- $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
229
-
230
- [^5]: b is introduced to avoid any attempt to produce more bits of
231
- randomness than can be held in `RealType`.
232
-
233
- [^6]: The distribution corresponding to this probability density
234
- function is also known (with a possible change of variable) as the
235
- Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
236
- distribution.
237
-
238
- [^7]: Annex  [[implimits]] recommends a minimum number of recursively
239
- nested template instantiations. This requirement thus indirectly
240
- suggests a minimum allowable complexity for valarray expressions.
241
-
242
- [^8]: The intent is to specify an array template that has the minimum
243
- functionality necessary to address aliasing ambiguities and the
244
- proliferation of temporaries. Thus, the `valarray` template is
245
- neither a matrix class nor a field class. However, it is a very
246
- useful building block for designing such classes.
247
-
248
- [^9]: This default constructor is essential, since arrays of `valarray`
249
- may be useful. After initialization, the length of an empty array
250
- can be increased with the `resize` member function.
251
-
252
- [^10]: This constructor is the preferred method for converting a C array
253
- to a `valarray` object.
254
-
255
- [^11]: This copy constructor creates a distinct array rather than an
256
- alias. Implementations in which arrays share storage are permitted,
257
- but they shall implement a copy-on-reference mechanism to ensure
258
- that arrays are conceptually distinct.
259
-
260
- [^12]: BLAS stands for *Basic Linear Algebra Subprograms.* C++programs
261
- may instantiate this class. See, for example, Dongarra, Du Croz,
262
- Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
263
- Subprograms*; Technical Report MCS-P1-0888, Argonne National
264
- Laboratory (USA), Mathematics and Computer Science Division, August,
265
- 1988.
266
-
267
- [^13]: The use of fully closed ranges is intentional.
268
-
269
- [^14]: `accumulate` is similar to the APL reduction operator and Common
270
- Lisp reduce function, but it avoids the difficulty of defining the
271
- result of reduction on an empty sequence by always requiring an
272
- initial value.
273
-
274
- [^15]: The use of fully closed ranges is intentional.
275
-
276
- [^16]: The use of fully closed ranges is intentional.
277
-
278
- [^17]: The use of fully closed ranges is intentional.
279
-
280
- [^18]: A mathematical function is mathematically defined for a given set
281
- of argument values (a) if it is explicitly defined for that set of
282
- argument values, or (b) if its limiting value exists and does not
283
- depend on the direction of approach.