Line data Source code
1 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3 : !!!! !!!!
4 : !!!! ParaMonte: Parallel Monte Carlo and Machine Learning Library. !!!!
5 : !!!! !!!!
6 : !!!! Copyright (C) 2012-present, The Computational Data Science Lab !!!!
7 : !!!! !!!!
8 : !!!! This file is part of the ParaMonte library. !!!!
9 : !!!! !!!!
10 : !!!! LICENSE !!!!
11 : !!!! !!!!
12 : !!!! https://github.com/cdslaborg/paramonte/blob/main/LICENSE.md !!!!
13 : !!!! !!!!
14 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
15 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
16 :
17 : !> \brief
18 : !> This module contains procedures and data types for interpolation of finite samples of data.<br>
19 : !>
20 : !> \details
21 : !> Interpolation is a type of estimation, a method of constructing (finding) new data points based on the range of a discrete set of known data points.<br>
22 : !>
23 : !> Piecewise constant interpolation
24 : !> ================================
25 : !>
26 : !> The simplest interpolation method is to locate the nearest data value, and assign the same value.<br>
27 : !> In simple problems, this method is unlikely to be used, as linear interpolation (see below) is almost as easy,
28 : !> but in higher-dimensional multivariate interpolation, this could be a favorable choice for its speed and simplicity.<br>
29 : !>
30 : !> \htmlonly
31 : !> <img src="pm_polation@constant.png" style="width:500px;">
32 : !> \endhtmlonly
33 : !>
34 : !> Linear interpolation
35 : !> ====================
36 : !>
37 : !> Linear interpolation is a method of curve fitting using linear polynomials
38 : !> to construct new data points within the range of a discrete set of known data points.<br>
39 : !>
40 : !> If the two known points are given by the coordinates \f$(x_{0},y_{0})\f$ and \f$(x_{1},y_{1})\f$,
41 : !> the linear interpolant is the straight line between these points.<br>
42 : !> For a value \f$x\f$ in the interval \f$(x_{0},x_{1})\f$, the value \f$y\f$ along the straight line is given from the equation of slopes
43 : !> \f{equation}{
44 : !> \frac {y-y_{0}}{x-x_{0}} = \frac{y_{1}-y_{0}}{x_{1}-x_{0}} ~,
45 : !> \f}
46 : !> which can be derived geometrically from the figure on the right.<br>
47 : !> It is a special case of **polynomial interpolation** with \f$n = 1\f$.<br>
48 : !>
49 : !> Solving this equation for \f$y\f$, which is the unknown value at \f$x\f$, gives
50 : !> \f{equation}{
51 : !> \begin{aligned} y
52 : !> &= y_{0} + (x - x_{0}) {\frac{y_{1} - y_{0}}{x_{1}-x_{0}}} \\
53 : !> &= \frac{y_{0}(x_{1}-x_{0})}{x_{1}-x_{0}} + \frac{y_{1}(x-x_{0})-y_{0}(x-x_{0})}{x_{1}-x_{0}} \\
54 : !> &= \frac{y_{1} x - y_{1} x_{0} - y_{0} x + y_{0} x_{0} + y_{0} x_{1} - y_{0} x_{0}}{x_{1} - x_{0}} \\
55 : !> &= \frac{y_{0}(x_{1} - x) + y_{1}(x - x_{0})}{x_{1} - x_{0}} ~,
56 : !> \end{aligned}
57 : !> \f}
58 : !> which is the formula for linear interpolation in the interval \f$(x_{0}, x_{1})\f$.<br>
59 : !> Outside this interval, the formula is identical to linear extrapolation.<br>
60 : !> This formula can also be understood as a weighted average.<br>
61 : !> The weights are inversely related to the distance from the end points to the unknown point; the closer point has more influence than the farther point.<br>
62 : !> Thus, the weights are \f$\textstyle 1 - (x - x_{0}) / (x_{1} - x_{0})\f$ and \f$\textstyle 1 - (x_{1} - x) / (x_{1} - x_{0})\f$,
63 : !> which are normalized distances between the unknown point and each of the end points.<br>
64 : !> Because these sum to \f$1\f$,
65 : !> \f{equation}{
66 : !> \begin{aligned} y
67 : !> &= y_{0} \left(1 - {\frac{x - x_{0}}{x_{1} - x_{0}}} \right) + y_{1} \left(1-{\frac {x_{1}-x}{x_{1}-x_{0}}}\right) \\
68 : !> &= y_{0} \left(1 - {\frac{x - x_{0}}{x_{1} - x_{0}}}\right) + y_{1}\left({\frac {x-x_{0}}{x_{1}-x_{0}}}\right) \\
69 : !> &= y_{0} \left({\frac{x_{1} - x}{x_{1} - x_{0}}}\right) + y_{1}\left({\frac{x - x_{0}}{x_{1} - x_{0}}}\right)
70 : !> \end{aligned}
71 : !> \f}
72 : !> yielding the formula for linear interpolation given above.<br>
73 : !>
74 : !> \htmlonly
75 : !> <img src="pm_polation@linear.png" style="width:500px;">
76 : !> \endhtmlonly
77 : !>
78 : !> Polynomial interpolation
79 : !> ========================
80 : !>
81 : !> Polynomial interpolation is a generalization of linear interpolation.<br>
82 : !> For a sample of \f$n\f$ data points, there is exactly one polynomial of degree at most \f$n − 1\f$ going through all the data points.<br>
83 : !> Formally, given a set of \f$n + 1\f$ data points \f$(x_{0},y_{0}),\ldots ,(x_{n},y_{n})\f$, with no two \f$x_{j}\f$ the same,
84 : !> a polynomial function \f$p(x) = a_{0} + a_{1}x + \cdots + a_{n}x^{n}\f$ is said to interpolate the data if \f$p(x_{j}) = y_{j}\f$ for each \f$j\in\{0,1,\dotsc,n\}\f$.<br>
85 : !> There is always a unique such polynomial, commonly given explicitly as either a **Lagrange polynomial** or **Newton polynomial**.<br>
86 : !>
87 : !> The polynomial interpolation error is proportional to the distance between the data points to the power \f$n\f$.<br>
88 : !> Furthermore, the interpolant is a polynomial and thus infinitely differentiable.<br>
89 : !> As such, polynomial interpolation overcomes most of the problems of linear interpolation.<br>
90 : !>
91 : !> However, polynomial interpolation also has some disadvantages:<br>
92 : !> <ol>
93 : !> <li> Calculating the interpolating polynomial is computationally expensive (see computational complexity) compared to linear interpolation.<br>
94 : !> <li> Polynomial interpolation may exhibit oscillatory artifacts, especially at the end points, known as **Runge phenomenon**.<br>
95 : !> </ol>
96 : !>
97 : !> \htmlonly
98 : !> <img src="pm_polation@polynomial.png" style="width:500px;">
99 : !> \endhtmlonly
100 : !>
101 : !> The Neville algorithm
102 : !> ---------------------
103 : !>
104 : !> The Neville algorithm, derived by the mathematician Eric Harold Neville in 1934, is used for polynomial interpolation.<br>
105 : !> Given \f$n + 1\f$ points \f$\{(x_i, y_i), i = 1, \ldots, n + 1\}\f$, there is a unique polynomial of degree \f$\leq n\f$ which goes through the given points.<br>
106 : !> The Neville algorithm approximates this unknown polynomial at a desired point \f$x\f$ **without explicitly evaluating the exact-fit polynomial coefficients**.<br>
107 : !> As such, the Neville algorithm may be computationally inappropriate for usage with many query points on the same input data abscissa and function values.<br>
108 : !> Unlike the Lagrange polynomial method, the Neville algorithm interpolation method is computationally faster and provides
109 : !> an estimate of the error in the output approximation.<br>
110 : !>
111 : !> Spline interpolation
112 : !> ====================
113 : !>
114 : !> Spline interpolation is a form of interpolation where the interpolant is a special type of piecewise polynomial called a **spline**.<br>
115 : !> That is, instead of fitting a single, high-degree polynomial to all of the values at once, spline interpolation fits low-degree polynomials
116 : !> to small subsets of the values, for example, fitting nine cubic polynomials between each of the pairs of ten points,
117 : !> instead of fitting a single degree-ten polynomial to all of them.<br>
118 : !> Spline interpolation is often preferred over polynomial interpolation because the
119 : !> interpolation error can be made small even when using low-degree polynomials for the spline.<br>
120 : !> Spline interpolation also avoids the problem of **Runge phenomenon**,
121 : !> in which oscillation can occur between points when interpolating using high-degree polynomials.<br>
122 : !>
123 : !> \see
124 : !> [pm_polynomial](@ref pm_polynomial)<br>
125 : !> [bspline-fortran by Jacob Williams](https://github.com/jacobwilliams/bspline-fortran)<br>
126 : !> [polynomial interpolation](https://en.wikipedia.org/wiki/Polynomial_interpolation)<br>
127 : !>
128 : !> \todo
129 : !> \phigh
130 : !> Routines for spline and higher-dimensional interpolation methods must be implemented.<br>
131 : !>
132 : !> \test
133 : !> [test_pm_polation](@ref test_pm_polation)
134 : !>
135 : !> \finmain
136 : !>
137 : !> \author
138 : !> \AmirShahmoradi, Tuesday March 7, 2017, 3:50 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
139 :
140 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
141 :
142 : module pm_polation
143 :
144 : use pm_kind, only: SK, IK, LK, RK
145 :
146 : implicit none
147 :
148 : character(*, SK), parameter :: MODULE_NAME = "@pm_polation"
149 :
150 : !> \brief
151 : !> This is a concrete derived type whose instances are exclusively used
152 : !> to signify an interpolation using the smallest node larger than the query point within an interface of a procedure of the ParaMonte library.<br>
153 : !> The name `neimean` stands for *neighbor mean*.<br>
154 : !>
155 : !> \details
156 : !> Objects instantiated from this derived type are exclusively used to differentiate
157 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
158 : !> As such, this concrete derived type does not contain any attributes.<br>
159 : !>
160 : !> \note
161 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
162 : !> Instead, the end users should use the specific object parameter instance of this derived type
163 : !> (e.g., [neimean](@ref pm_polation::neimean)) as directed by the documentation of the specific procedure they intend to use.<br>
164 : !>
165 : !> \see
166 : !> [neimean](@ref pm_polation::neimean)<br>
167 : !> [neinext](@ref pm_polation::neinext)<br>
168 : !> [neiprev](@ref pm_polation::neiprev)<br>
169 : !> [monopol](@ref pm_polation::monopol)<br>
170 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
171 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
172 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
173 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
174 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
175 : !>
176 : !> \finmain{neimean_type}
177 : !>
178 : !> \author
179 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
180 : type :: neimean_type; end type
181 : type(neimean_type), parameter :: neimean = neimean_type()
182 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
183 : !DIR$ ATTRIBUTES DLLEXPORT :: neimean
184 : #endif
185 :
186 : !> \brief
187 : !> This is a concrete derived type whose instances are exclusively used
188 : !> to signify an interpolation using the smallest node larger than the query point within an interface of a procedure of the ParaMonte library.<br>
189 : !> The name `neinear` stands for *neighbor nearest*.<br>
190 : !>
191 : !> \details
192 : !> Objects instantiated from this derived type are exclusively used to differentiate
193 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
194 : !> As such, this concrete derived type does not contain any attributes.<br>
195 : !>
196 : !> \note
197 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
198 : !> Instead, the end users should use the specific object parameter instance of this derived type
199 : !> (e.g., [neinear](@ref pm_polation::neinear)) as directed by the documentation of the specific procedure they intend to use.<br>
200 : !>
201 : !> \see
202 : !> [neimean](@ref pm_polation::neimean)<br>
203 : !> [neinext](@ref pm_polation::neinext)<br>
204 : !> [neiprev](@ref pm_polation::neiprev)<br>
205 : !> [monopol](@ref pm_polation::monopol)<br>
206 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
207 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
208 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
209 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
210 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
211 : !>
212 : !> \finmain{neinear_type}
213 : !>
214 : !> \author
215 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
216 : type :: neinear_type; end type
217 : type(neinear_type), parameter :: neinear = neinear_type()
218 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
219 : !DIR$ ATTRIBUTES DLLEXPORT :: neinear
220 : #endif
221 :
222 : !> \brief
223 : !> This is a concrete derived type whose instances are exclusively used
224 : !> to signify an interpolation using the smallest node larger than the query point within an interface of a procedure of the ParaMonte library.<br>
225 : !> The name `neinext` stands for *neighbor next*.<br>
226 : !>
227 : !> \details
228 : !> Objects instantiated from this derived type are exclusively used to differentiate
229 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
230 : !> As such, this concrete derived type does not contain any attributes.<br>
231 : !>
232 : !> \note
233 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
234 : !> Instead, the end users should use the specific object parameter instance of this derived type
235 : !> (e.g., [neinext](@ref pm_polation::neinext)) as directed by the documentation of the specific procedure they intend to use.<br>
236 : !>
237 : !> \see
238 : !> [neimean](@ref pm_polation::neimean)<br>
239 : !> [neinext](@ref pm_polation::neinext)<br>
240 : !> [neiprev](@ref pm_polation::neiprev)<br>
241 : !> [monopol](@ref pm_polation::monopol)<br>
242 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
243 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
244 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
245 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
246 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
247 : !>
248 : !> \finmain{neinext_type}
249 : !>
250 : !> \author
251 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
252 : type :: neinext_type; end type
253 : type(neinext_type), parameter :: neinext = neinext_type()
254 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
255 : !DIR$ ATTRIBUTES DLLEXPORT :: neinext
256 : #endif
257 :
258 : !> \brief
259 : !> This is a concrete derived type whose instances are exclusively used
260 : !> to signify an interpolation using the largest node smaller than the query point within an interface of a procedure of the ParaMonte library.<br>
261 : !> The name `neiprev` stands for *neighbor previous*.<br>
262 : !>
263 : !> \details
264 : !> Objects instantiated from this derived type are exclusively used to differentiate
265 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
266 : !> As such, this concrete derived type does not contain any attributes.<br>
267 : !>
268 : !> \note
269 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
270 : !> Instead, the end users should use the specific object parameter instance of this derived type
271 : !> (e.g., [neiprev](@ref pm_polation::neiprev)) as directed by the documentation of the specific procedure they intend to use.<br>
272 : !>
273 : !> \see
274 : !> [neimean](@ref pm_polation::neimean)<br>
275 : !> [neinext](@ref pm_polation::neinext)<br>
276 : !> [neiprev](@ref pm_polation::neiprev)<br>
277 : !> [monopol](@ref pm_polation::monopol)<br>
278 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
279 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
280 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
281 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
282 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
283 : !>
284 : !> \finmain{neiprev_type}
285 : !>
286 : !> \author
287 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
288 : type :: neiprev_type; end type
289 : type(neiprev_type), parameter :: neiprev = neiprev_type()
290 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
291 : !DIR$ ATTRIBUTES DLLEXPORT :: neiprev
292 : #endif
293 :
294 : !> \brief
295 : !> This is a concrete derived type whose instances are exclusively used
296 : !> to signify an interpolation using piecewise lines within an interface of a procedure of the ParaMonte library.<br>
297 : !>
298 : !> \details
299 : !> Objects instantiated from this derived type are exclusively used to differentiate
300 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
301 : !> As such, this concrete derived type does not contain any attributes.<br>
302 : !>
303 : !> \note
304 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
305 : !> Instead, the end users should use the specific object parameter instance of this derived type
306 : !> (e.g., [piwilin](@ref pm_polation::piwilin)) as directed by the documentation of the specific procedure they intend to use.<br>
307 : !>
308 : !> \see
309 : !> [neimean](@ref pm_polation::neimean)<br>
310 : !> [neinext](@ref pm_polation::neinext)<br>
311 : !> [neiprev](@ref pm_polation::neiprev)<br>
312 : !> [monopol](@ref pm_polation::monopol)<br>
313 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
314 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
315 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
316 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
317 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
318 : !>
319 : !> \finmain{piwilin_type}
320 : !>
321 : !> \author
322 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
323 : type :: piwilin_type; end type
324 : type(piwilin_type), parameter :: piwilin = piwilin_type()
325 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
326 : !DIR$ ATTRIBUTES DLLEXPORT :: piwilin
327 : #endif
328 :
329 : !> \brief
330 : !> This is a concrete derived type whose instances are exclusively used
331 : !> to signify an interpolation using a single polynomial of highest degree possible given the abscissa within an interface of a procedure of the ParaMonte library.<br>
332 : !>
333 : !> \details
334 : !> Objects instantiated from this derived type are exclusively used to differentiate
335 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
336 : !> As such, this concrete derived type does not contain any attributes.<br>
337 : !>
338 : !> \note
339 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
340 : !> Instead, the end users should use the specific object parameter instance of this derived type
341 : !> (e.g., [monopol](@ref pm_polation::monopol)) as directed by the documentation of the specific procedure they intend to use.<br>
342 : !>
343 : !> \see
344 : !> [neimean](@ref pm_polation::neimean)<br>
345 : !> [neinext](@ref pm_polation::neinext)<br>
346 : !> [neiprev](@ref pm_polation::neiprev)<br>
347 : !> [monopol](@ref pm_polation::monopol)<br>
348 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
349 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
350 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
351 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
352 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
353 : !>
354 : !> \finmain{monopol_type}
355 : !>
356 : !> \author
357 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
358 : type :: monopol_type; end type
359 : type(monopol_type), parameter :: monopol = monopol_type()
360 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
361 : !DIR$ ATTRIBUTES DLLEXPORT :: monopol
362 : #endif
363 :
364 : !> \brief
365 : !> This is a concrete derived type whose instances are exclusively used
366 : !> to signify an interpolation using multiple **piecewise polynomial** of arbitrary degree possible given the abscissa within an interface of a procedure of the ParaMonte library.<br>
367 : !>
368 : !> \details
369 : !> Objects instantiated from this derived type are exclusively used to differentiate
370 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
371 : !> As such, this concrete derived type does not contain any attributes.<br>
372 : !>
373 : !> \see
374 : !> [neimean](@ref pm_polation::neimean)<br>
375 : !> [neinext](@ref pm_polation::neinext)<br>
376 : !> [neiprev](@ref pm_polation::neiprev)<br>
377 : !> [monopol](@ref pm_polation::monopol)<br>
378 : !> [neimean_type](@ref pm_polation::neimean_type)<br>
379 : !> [neinext_type](@ref pm_polation::neinext_type)<br>
380 : !> [neiprev_type](@ref pm_polation::neiprev_type)<br>
381 : !> [monopol_type](@ref pm_polation::monopol_type) <br>
382 : !> [piwipol_type](@ref pm_polation::piwipol_type)<br>
383 : !>
384 : !> \finmain{piwipol_type}
385 : !>
386 : !> \author
387 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
388 : type :: piwipol_type
389 : integer(IK) :: degree !< \public The scalar `integer` of default kind \IK, containing the degree of the piecewise polynomials.
390 : end type
391 :
392 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
393 :
394 : !> \brief
395 : !> Generate and return the approximate **polynomial interpolation** value of the input specified point `x` for the specified `method`.
396 : !>
397 : !> \details
398 : !> For polynomial interpolation, the computation relies on the **Neville algorithm**.<br>
399 : !>
400 : !> \param[in] method : The input scalar constant that can be,
401 : !> <ol>
402 : !> <li> The scalar constant [neimean](@ref pm_polation::neimean) or a scalar object of type [neimean_type](@ref pm_polation::neimean_type)
403 : !> implying the use of the average of the `func` values of the two nearest neighbors of the input `queryx` smaller and larger than it as the output `interp`.<br>
404 : !> <li> The scalar constant [neinear](@ref pm_polation::neinear) or a scalar object of type [neinear_type](@ref pm_polation::neinear_type)
405 : !> implying the use of the average of the `func` value of the nearest neighbor of the input `queryx` as the output `interp`.<br>
406 : !> Note that the nearest neighbor in this case is measured by actual Euclidean distances of neighbors to the input `queryx`.<br>
407 : !> <li> The scalar constant [neiprev](@ref pm_polation::neiprev) or a scalar object of type [neiprev_type](@ref pm_polation::neiprev_type)
408 : !> implying the use of the `func` value of the largest abscissa in the input `crdx` smaller than the input `queryx` as the output `interp`.<br>
409 : !> <li> The scalar constant [neinext](@ref pm_polation::neinext) or a scalar object of type [neinext_type](@ref pm_polation::neinext_type)
410 : !> implying the use of the `func` value of the smallest abscissa in the input `crdx` larger than the input `queryx` as the output `interp`.<br>
411 : !> <li> The scalar constant [piwilin](@ref pm_polation::piwilin) or a scalar object of type [piwilin_type](@ref pm_polation::piwilin_type)
412 : !> implying the use of the **linear interpolation** of the `func` values of the two `crdx` points that bracket `queryx` as the output `interp`.<br>
413 : !> The linear interpolation implemented in this constructor is based on the Lagrange classical formula for linear interpolation.<br>
414 : !> Suppose an input query point \f$x\f$ falls between two nodes \f$x_i\f$ and \f$x_{i+1}\f$ with the corresponding function values
415 : !> \f$y_i\f$ and \f$y_{i+1}\f$ and we wish to estimate the corresponding interpolated value \f$y(x)\f$, which can be computed as,
416 : !> \f{equation*}{
417 : !> y(x) = \frac {x - x_{i+1}} {x_i - x_{i+1}} y_i + \frac {x - x_{i}} {x_{i+1} - x_{i}} y_{i+1} ~.
418 : !> \f}
419 : !> <li> The scalar constant [monopol](@ref pm_polation::monopol) or a scalar object of type [monopol_type](@ref pm_polation::monopol_type)
420 : !> implying the use of a single **polynomial interpolation** of highest degree `size(crdx) - 1` possible to all pairs of `(crdx, func)` for computing the output `interp`.<br>
421 : !> The Neville algorithm is used to approximate the polynomial interpolation.<br>
422 : !> </ol>
423 : !> \param[in] crdx : The input `contiguous` vector of<br>
424 : !> <ol>
425 : !> <li> type `real` of kind \RKALL,
426 : !> </ol>
427 : !> containing the set of abscissa in **strictly ascending order** through which the constructed polynomial must pass.<br>
428 : !> If needed, the input values for `crdx` and `sortedY` can be sorted in ascending order by calling either
429 : !> [setSorted()](@ref pm_arraySort::setSorted) or [setSorted()](@ref pm_arraySort::setSorted).
430 : !> \param[in] func : The input `contiguous` vector of the same type, kind, and size as `crdx`,
431 : !> containing the set of function values corresponding to the input abscissa `crdx` through which the constructed polynomial must pass.
432 : !> \param[in] queryx : The input scalar or vector of the same type and kind as `crdx`, containing the abscissa (x-value) of the queryx point.
433 : !>
434 : !> \return
435 : !>
436 : !> `interp` : The output object of the same type, kind, rank, and shape as `queryx`,
437 : !> containing the (approximate) interpolated y-value(s) corresponding to the `queryx` point(s).
438 : !>
439 : !> \interface{getInterp}
440 : !> \code{.F90}
441 : !>
442 : !> use pm_polation, only: getInterp
443 : !>
444 : !> interp = getInterp(method, crdx(1:nsam), func(1:nsam), queryx)
445 : !> interp(1:nque) = getInterp(method, crdx(1:nsam), func(1:nsam), queryx(1:nque))
446 : !>
447 : !> \endcode
448 : !>
449 : !> \warning
450 : !> The condition `size(crdx) == size(func)` must hold for the corresponding input arguments.<br>
451 : !> The condition `all([minval(crdx, 1) <= queryx .and. queryx <= maxval(crdx, 1))` must hold for the corresponding input arguments.<br>
452 : !> The condition `isAscendingAll(crdx) .or. same_type_as(method, monopol_type())` must hold for the corresponding input arguments.<br>
453 : !> \vericons
454 : !>
455 : !> \warnpure
456 : !>
457 : !> \see
458 : !> [getExtrap](@ref pm_polation::getExtrap)<br>
459 : !> [setExtrap](@ref pm_polation::setExtrap)<br>
460 : !> [getInterp](@ref pm_polation::getInterp)<br>
461 : !> [setInterp](@ref pm_polation::setInterp)<br>
462 : !> [pm_sampleQuan](@ref pm_sampleQuan)<br>
463 : !> [pm_arraySort](@ref pm_arraySort)<br>
464 : !> [pm_quadRomb](@ref pm_quadRomb)<br>
465 : !>
466 : !> \example{getInterp}
467 : !> \include{lineno} example/pm_polation/getInterp/main.F90
468 : !> \compilef{getInterp}
469 : !> \output{getInterp}
470 : !> \include{lineno} example/pm_polation/getInterp/main.out.F90
471 : !> \postproc{getInterp}
472 : !> \include{lineno} example/pm_polation/getInterp/main.py
473 : !> \vis{getInterp}
474 : !> \image html pm_polation/getInterp/getInterp.neimean.interp.png width=700
475 : !> \image html pm_polation/getInterp/getInterp.neinear.interp.png width=700
476 : !> \image html pm_polation/getInterp/getInterp.neinext.interp.png width=700
477 : !> \image html pm_polation/getInterp/getInterp.neiprev.interp.png width=700
478 : !> \image html pm_polation/getInterp/getInterp.piwilin.interp.png width=700
479 : !> \image html pm_polation/getInterp/getInterp.monopol.interp.png width=700
480 : !> \image html pm_polation/getInterp/getInterp.rungeEffect.interp.png width=700
481 : !>
482 : !> \test
483 : !> [test_pm_polation](@ref test_pm_polation)
484 : !>
485 : !> \finmain{getInterp}
486 : !>
487 : !> \author
488 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
489 :
490 : ! monopol MNPLD
491 :
492 : interface getInterp
493 :
494 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
495 :
496 : #if RK5_ENABLED
497 : PURE module function getInterpMNPLD_ND1_QD0_RK5(method, crdx, func, queryx) result(interp)
498 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
499 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD0_RK5
500 : #endif
501 : use pm_kind, only: RKC => RK5
502 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
503 : real(RKC) , intent(in) :: queryx
504 : real(RKC) :: interp
505 : type(monopol_type) , intent(in) :: method
506 : end function
507 : #endif
508 :
509 : #if RK4_ENABLED
510 : PURE module function getInterpMNPLD_ND1_QD0_RK4(method, crdx, func, queryx) result(interp)
511 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
512 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD0_RK4
513 : #endif
514 : use pm_kind, only: RKC => RK4
515 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
516 : real(RKC) , intent(in) :: queryx
517 : real(RKC) :: interp
518 : type(monopol_type) , intent(in) :: method
519 : end function
520 : #endif
521 :
522 : #if RK3_ENABLED
523 : PURE module function getInterpMNPLD_ND1_QD0_RK3(method, crdx, func, queryx) result(interp)
524 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
525 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD0_RK3
526 : #endif
527 : use pm_kind, only: RKC => RK3
528 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
529 : real(RKC) , intent(in) :: queryx
530 : real(RKC) :: interp
531 : type(monopol_type) , intent(in) :: method
532 : end function
533 : #endif
534 :
535 : #if RK2_ENABLED
536 : PURE module function getInterpMNPLD_ND1_QD0_RK2(method, crdx, func, queryx) result(interp)
537 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
538 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD0_RK2
539 : #endif
540 : use pm_kind, only: RKC => RK2
541 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
542 : real(RKC) , intent(in) :: queryx
543 : real(RKC) :: interp
544 : type(monopol_type) , intent(in) :: method
545 : end function
546 : #endif
547 :
548 : #if RK1_ENABLED
549 : PURE module function getInterpMNPLD_ND1_QD0_RK1(method, crdx, func, queryx) result(interp)
550 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
551 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD0_RK1
552 : #endif
553 : use pm_kind, only: RKC => RK1
554 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
555 : real(RKC) , intent(in) :: queryx
556 : real(RKC) :: interp
557 : type(monopol_type) , intent(in) :: method
558 : end function
559 : #endif
560 :
561 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
562 :
563 : #if RK5_ENABLED
564 : PURE module function getInterpMNPLD_ND1_QD1_RK5(method, crdx, func, queryx) result(interp)
565 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
566 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD1_RK5
567 : #endif
568 : use pm_kind, only: RKC => RK5
569 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
570 : real(RKC) , intent(in) , contiguous :: queryx(:)
571 : real(RKC) :: interp(size(queryx, 1, IK))
572 : type(monopol_type) , intent(in) :: method
573 : end function
574 : #endif
575 :
576 : #if RK4_ENABLED
577 : PURE module function getInterpMNPLD_ND1_QD1_RK4(method, crdx, func, queryx) result(interp)
578 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
579 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD1_RK4
580 : #endif
581 : use pm_kind, only: RKC => RK4
582 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
583 : real(RKC) , intent(in) , contiguous :: queryx(:)
584 : real(RKC) :: interp(size(queryx, 1, IK))
585 : type(monopol_type) , intent(in) :: method
586 : end function
587 : #endif
588 :
589 : #if RK3_ENABLED
590 : PURE module function getInterpMNPLD_ND1_QD1_RK3(method, crdx, func, queryx) result(interp)
591 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
592 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD1_RK3
593 : #endif
594 : use pm_kind, only: RKC => RK3
595 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
596 : real(RKC) , intent(in) , contiguous :: queryx(:)
597 : real(RKC) :: interp(size(queryx, 1, IK))
598 : type(monopol_type) , intent(in) :: method
599 : end function
600 : #endif
601 :
602 : #if RK2_ENABLED
603 : PURE module function getInterpMNPLD_ND1_QD1_RK2(method, crdx, func, queryx) result(interp)
604 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
605 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD1_RK2
606 : #endif
607 : use pm_kind, only: RKC => RK2
608 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
609 : real(RKC) , intent(in) , contiguous :: queryx(:)
610 : real(RKC) :: interp(size(queryx, 1, IK))
611 : type(monopol_type) , intent(in) :: method
612 : end function
613 : #endif
614 :
615 : #if RK1_ENABLED
616 : PURE module function getInterpMNPLD_ND1_QD1_RK1(method, crdx, func, queryx) result(interp)
617 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
618 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMNPLD_ND1_QD1_RK1
619 : #endif
620 : use pm_kind, only: RKC => RK1
621 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
622 : real(RKC) , intent(in) , contiguous :: queryx(:)
623 : real(RKC) :: interp(size(queryx, 1, IK))
624 : type(monopol_type) , intent(in) :: method
625 : end function
626 : #endif
627 :
628 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
629 :
630 : end interface
631 :
632 : ! piwilin
633 :
634 : interface getInterp
635 :
636 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
637 :
638 : #if RK5_ENABLED
639 : PURE module function getInterpPWLN_ND1_QD0_RK5(method, crdx, func, queryx) result(interp)
640 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
641 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD0_RK5
642 : #endif
643 : use pm_kind, only: RKC => RK5
644 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
645 : real(RKC) , intent(in) :: queryx
646 : real(RKC) :: interp
647 : type(piwilin_type) , intent(in) :: method
648 : end function
649 : #endif
650 :
651 : #if RK4_ENABLED
652 : PURE module function getInterpPWLN_ND1_QD0_RK4(method, crdx, func, queryx) result(interp)
653 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
654 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD0_RK4
655 : #endif
656 : use pm_kind, only: RKC => RK4
657 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
658 : real(RKC) , intent(in) :: queryx
659 : real(RKC) :: interp
660 : type(piwilin_type) , intent(in) :: method
661 : end function
662 : #endif
663 :
664 : #if RK3_ENABLED
665 : PURE module function getInterpPWLN_ND1_QD0_RK3(method, crdx, func, queryx) result(interp)
666 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
667 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD0_RK3
668 : #endif
669 : use pm_kind, only: RKC => RK3
670 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
671 : real(RKC) , intent(in) :: queryx
672 : real(RKC) :: interp
673 : type(piwilin_type) , intent(in) :: method
674 : end function
675 : #endif
676 :
677 : #if RK2_ENABLED
678 : PURE module function getInterpPWLN_ND1_QD0_RK2(method, crdx, func, queryx) result(interp)
679 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
680 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD0_RK2
681 : #endif
682 : use pm_kind, only: RKC => RK2
683 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
684 : real(RKC) , intent(in) :: queryx
685 : real(RKC) :: interp
686 : type(piwilin_type) , intent(in) :: method
687 : end function
688 : #endif
689 :
690 : #if RK1_ENABLED
691 : PURE module function getInterpPWLN_ND1_QD0_RK1(method, crdx, func, queryx) result(interp)
692 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
693 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD0_RK1
694 : #endif
695 : use pm_kind, only: RKC => RK1
696 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
697 : real(RKC) , intent(in) :: queryx
698 : real(RKC) :: interp
699 : type(piwilin_type) , intent(in) :: method
700 : end function
701 : #endif
702 :
703 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
704 :
705 : #if RK5_ENABLED
706 : PURE module function getInterpPWLN_ND1_QD1_RK5(method, crdx, func, queryx) result(interp)
707 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
708 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD1_RK5
709 : #endif
710 : use pm_kind, only: RKC => RK5
711 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
712 : real(RKC) , intent(in) , contiguous :: queryx(:)
713 : real(RKC) :: interp(size(queryx, 1, IK))
714 : type(piwilin_type) , intent(in) :: method
715 : end function
716 : #endif
717 :
718 : #if RK4_ENABLED
719 : PURE module function getInterpPWLN_ND1_QD1_RK4(method, crdx, func, queryx) result(interp)
720 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
721 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD1_RK4
722 : #endif
723 : use pm_kind, only: RKC => RK4
724 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
725 : real(RKC) , intent(in) , contiguous :: queryx(:)
726 : real(RKC) :: interp(size(queryx, 1, IK))
727 : type(piwilin_type) , intent(in) :: method
728 : end function
729 : #endif
730 :
731 : #if RK3_ENABLED
732 : PURE module function getInterpPWLN_ND1_QD1_RK3(method, crdx, func, queryx) result(interp)
733 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
734 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD1_RK3
735 : #endif
736 : use pm_kind, only: RKC => RK3
737 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
738 : real(RKC) , intent(in) , contiguous :: queryx(:)
739 : real(RKC) :: interp(size(queryx, 1, IK))
740 : type(piwilin_type) , intent(in) :: method
741 : end function
742 : #endif
743 :
744 : #if RK2_ENABLED
745 : PURE module function getInterpPWLN_ND1_QD1_RK2(method, crdx, func, queryx) result(interp)
746 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
747 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD1_RK2
748 : #endif
749 : use pm_kind, only: RKC => RK2
750 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
751 : real(RKC) , intent(in) , contiguous :: queryx(:)
752 : real(RKC) :: interp(size(queryx, 1, IK))
753 : type(piwilin_type) , intent(in) :: method
754 : end function
755 : #endif
756 :
757 : #if RK1_ENABLED
758 : PURE module function getInterpPWLN_ND1_QD1_RK1(method, crdx, func, queryx) result(interp)
759 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
760 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPWLN_ND1_QD1_RK1
761 : #endif
762 : use pm_kind, only: RKC => RK1
763 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
764 : real(RKC) , intent(in) , contiguous :: queryx(:)
765 : real(RKC) :: interp(size(queryx, 1, IK))
766 : type(piwilin_type) , intent(in) :: method
767 : end function
768 : #endif
769 :
770 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
771 :
772 : end interface
773 :
774 : ! neimean
775 :
776 : interface getInterp
777 :
778 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
779 :
780 : #if RK5_ENABLED
781 : PURE module function getInterpMEAN_ND1_QD0_RK5(method, crdx, func, queryx) result(interp)
782 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
783 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD0_RK5
784 : #endif
785 : use pm_kind, only: RKC => RK5
786 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
787 : real(RKC) , intent(in) :: queryx
788 : real(RKC) :: interp
789 : type(neimean_type) , intent(in) :: method
790 : end function
791 : #endif
792 :
793 : #if RK4_ENABLED
794 : PURE module function getInterpMEAN_ND1_QD0_RK4(method, crdx, func, queryx) result(interp)
795 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
796 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD0_RK4
797 : #endif
798 : use pm_kind, only: RKC => RK4
799 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
800 : real(RKC) , intent(in) :: queryx
801 : real(RKC) :: interp
802 : type(neimean_type) , intent(in) :: method
803 : end function
804 : #endif
805 :
806 : #if RK3_ENABLED
807 : PURE module function getInterpMEAN_ND1_QD0_RK3(method, crdx, func, queryx) result(interp)
808 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
809 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD0_RK3
810 : #endif
811 : use pm_kind, only: RKC => RK3
812 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
813 : real(RKC) , intent(in) :: queryx
814 : real(RKC) :: interp
815 : type(neimean_type) , intent(in) :: method
816 : end function
817 : #endif
818 :
819 : #if RK2_ENABLED
820 : PURE module function getInterpMEAN_ND1_QD0_RK2(method, crdx, func, queryx) result(interp)
821 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
822 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD0_RK2
823 : #endif
824 : use pm_kind, only: RKC => RK2
825 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
826 : real(RKC) , intent(in) :: queryx
827 : real(RKC) :: interp
828 : type(neimean_type) , intent(in) :: method
829 : end function
830 : #endif
831 :
832 : #if RK1_ENABLED
833 : PURE module function getInterpMEAN_ND1_QD0_RK1(method, crdx, func, queryx) result(interp)
834 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
835 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD0_RK1
836 : #endif
837 : use pm_kind, only: RKC => RK1
838 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
839 : real(RKC) , intent(in) :: queryx
840 : real(RKC) :: interp
841 : type(neimean_type) , intent(in) :: method
842 : end function
843 : #endif
844 :
845 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
846 :
847 : #if RK5_ENABLED
848 : PURE module function getInterpMEAN_ND1_QD1_RK5(method, crdx, func, queryx) result(interp)
849 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
850 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD1_RK5
851 : #endif
852 : use pm_kind, only: RKC => RK5
853 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
854 : real(RKC) , intent(in) , contiguous :: queryx(:)
855 : real(RKC) :: interp(size(queryx, 1, IK))
856 : type(neimean_type) , intent(in) :: method
857 : end function
858 : #endif
859 :
860 : #if RK4_ENABLED
861 : PURE module function getInterpMEAN_ND1_QD1_RK4(method, crdx, func, queryx) result(interp)
862 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
863 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD1_RK4
864 : #endif
865 : use pm_kind, only: RKC => RK4
866 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
867 : real(RKC) , intent(in) , contiguous :: queryx(:)
868 : real(RKC) :: interp(size(queryx, 1, IK))
869 : type(neimean_type) , intent(in) :: method
870 : end function
871 : #endif
872 :
873 : #if RK3_ENABLED
874 : PURE module function getInterpMEAN_ND1_QD1_RK3(method, crdx, func, queryx) result(interp)
875 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
876 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD1_RK3
877 : #endif
878 : use pm_kind, only: RKC => RK3
879 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
880 : real(RKC) , intent(in) , contiguous :: queryx(:)
881 : real(RKC) :: interp(size(queryx, 1, IK))
882 : type(neimean_type) , intent(in) :: method
883 : end function
884 : #endif
885 :
886 : #if RK2_ENABLED
887 : PURE module function getInterpMEAN_ND1_QD1_RK2(method, crdx, func, queryx) result(interp)
888 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
889 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD1_RK2
890 : #endif
891 : use pm_kind, only: RKC => RK2
892 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
893 : real(RKC) , intent(in) , contiguous :: queryx(:)
894 : real(RKC) :: interp(size(queryx, 1, IK))
895 : type(neimean_type) , intent(in) :: method
896 : end function
897 : #endif
898 :
899 : #if RK1_ENABLED
900 : PURE module function getInterpMEAN_ND1_QD1_RK1(method, crdx, func, queryx) result(interp)
901 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
902 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpMEAN_ND1_QD1_RK1
903 : #endif
904 : use pm_kind, only: RKC => RK1
905 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
906 : real(RKC) , intent(in) , contiguous :: queryx(:)
907 : real(RKC) :: interp(size(queryx, 1, IK))
908 : type(neimean_type) , intent(in) :: method
909 : end function
910 : #endif
911 :
912 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
913 :
914 : end interface
915 :
916 : ! neinear
917 :
918 : interface getInterp
919 :
920 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
921 :
922 : #if RK5_ENABLED
923 : PURE module function getInterpNEAR_ND1_QD0_RK5(method, crdx, func, queryx) result(interp)
924 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
925 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD0_RK5
926 : #endif
927 : use pm_kind, only: RKC => RK5
928 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
929 : real(RKC) , intent(in) :: queryx
930 : real(RKC) :: interp
931 : type(neinear_type) , intent(in) :: method
932 : end function
933 : #endif
934 :
935 : #if RK4_ENABLED
936 : PURE module function getInterpNEAR_ND1_QD0_RK4(method, crdx, func, queryx) result(interp)
937 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
938 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD0_RK4
939 : #endif
940 : use pm_kind, only: RKC => RK4
941 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
942 : real(RKC) , intent(in) :: queryx
943 : real(RKC) :: interp
944 : type(neinear_type) , intent(in) :: method
945 : end function
946 : #endif
947 :
948 : #if RK3_ENABLED
949 : PURE module function getInterpNEAR_ND1_QD0_RK3(method, crdx, func, queryx) result(interp)
950 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
951 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD0_RK3
952 : #endif
953 : use pm_kind, only: RKC => RK3
954 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
955 : real(RKC) , intent(in) :: queryx
956 : real(RKC) :: interp
957 : type(neinear_type) , intent(in) :: method
958 : end function
959 : #endif
960 :
961 : #if RK2_ENABLED
962 : PURE module function getInterpNEAR_ND1_QD0_RK2(method, crdx, func, queryx) result(interp)
963 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
964 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD0_RK2
965 : #endif
966 : use pm_kind, only: RKC => RK2
967 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
968 : real(RKC) , intent(in) :: queryx
969 : real(RKC) :: interp
970 : type(neinear_type) , intent(in) :: method
971 : end function
972 : #endif
973 :
974 : #if RK1_ENABLED
975 : PURE module function getInterpNEAR_ND1_QD0_RK1(method, crdx, func, queryx) result(interp)
976 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
977 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD0_RK1
978 : #endif
979 : use pm_kind, only: RKC => RK1
980 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
981 : real(RKC) , intent(in) :: queryx
982 : real(RKC) :: interp
983 : type(neinear_type) , intent(in) :: method
984 : end function
985 : #endif
986 :
987 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
988 :
989 : #if RK5_ENABLED
990 : PURE module function getInterpNEAR_ND1_QD1_RK5(method, crdx, func, queryx) result(interp)
991 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
992 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD1_RK5
993 : #endif
994 : use pm_kind, only: RKC => RK5
995 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
996 : real(RKC) , intent(in) , contiguous :: queryx(:)
997 : real(RKC) :: interp(size(queryx, 1, IK))
998 : type(neinear_type) , intent(in) :: method
999 : end function
1000 : #endif
1001 :
1002 : #if RK4_ENABLED
1003 : PURE module function getInterpNEAR_ND1_QD1_RK4(method, crdx, func, queryx) result(interp)
1004 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1005 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD1_RK4
1006 : #endif
1007 : use pm_kind, only: RKC => RK4
1008 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1009 : real(RKC) , intent(in) , contiguous :: queryx(:)
1010 : real(RKC) :: interp(size(queryx, 1, IK))
1011 : type(neinear_type) , intent(in) :: method
1012 : end function
1013 : #endif
1014 :
1015 : #if RK3_ENABLED
1016 : PURE module function getInterpNEAR_ND1_QD1_RK3(method, crdx, func, queryx) result(interp)
1017 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1018 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD1_RK3
1019 : #endif
1020 : use pm_kind, only: RKC => RK3
1021 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1022 : real(RKC) , intent(in) , contiguous :: queryx(:)
1023 : real(RKC) :: interp(size(queryx, 1, IK))
1024 : type(neinear_type) , intent(in) :: method
1025 : end function
1026 : #endif
1027 :
1028 : #if RK2_ENABLED
1029 : PURE module function getInterpNEAR_ND1_QD1_RK2(method, crdx, func, queryx) result(interp)
1030 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1031 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD1_RK2
1032 : #endif
1033 : use pm_kind, only: RKC => RK2
1034 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1035 : real(RKC) , intent(in) , contiguous :: queryx(:)
1036 : real(RKC) :: interp(size(queryx, 1, IK))
1037 : type(neinear_type) , intent(in) :: method
1038 : end function
1039 : #endif
1040 :
1041 : #if RK1_ENABLED
1042 : PURE module function getInterpNEAR_ND1_QD1_RK1(method, crdx, func, queryx) result(interp)
1043 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1044 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEAR_ND1_QD1_RK1
1045 : #endif
1046 : use pm_kind, only: RKC => RK1
1047 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1048 : real(RKC) , intent(in) , contiguous :: queryx(:)
1049 : real(RKC) :: interp(size(queryx, 1, IK))
1050 : type(neinear_type) , intent(in) :: method
1051 : end function
1052 : #endif
1053 :
1054 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1055 :
1056 : end interface
1057 :
1058 : ! neinext
1059 :
1060 : interface getInterp
1061 :
1062 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1063 :
1064 : #if RK5_ENABLED
1065 : PURE module function getInterpNEXT_ND1_QD0_RK5(method, crdx, func, queryx) result(interp)
1066 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1067 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD0_RK5
1068 : #endif
1069 : use pm_kind, only: RKC => RK5
1070 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1071 : real(RKC) , intent(in) :: queryx
1072 : real(RKC) :: interp
1073 : type(neinext_type) , intent(in) :: method
1074 : end function
1075 : #endif
1076 :
1077 : #if RK4_ENABLED
1078 : PURE module function getInterpNEXT_ND1_QD0_RK4(method, crdx, func, queryx) result(interp)
1079 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1080 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD0_RK4
1081 : #endif
1082 : use pm_kind, only: RKC => RK4
1083 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1084 : real(RKC) , intent(in) :: queryx
1085 : real(RKC) :: interp
1086 : type(neinext_type) , intent(in) :: method
1087 : end function
1088 : #endif
1089 :
1090 : #if RK3_ENABLED
1091 : PURE module function getInterpNEXT_ND1_QD0_RK3(method, crdx, func, queryx) result(interp)
1092 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1093 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD0_RK3
1094 : #endif
1095 : use pm_kind, only: RKC => RK3
1096 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1097 : real(RKC) , intent(in) :: queryx
1098 : real(RKC) :: interp
1099 : type(neinext_type) , intent(in) :: method
1100 : end function
1101 : #endif
1102 :
1103 : #if RK2_ENABLED
1104 : PURE module function getInterpNEXT_ND1_QD0_RK2(method, crdx, func, queryx) result(interp)
1105 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1106 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD0_RK2
1107 : #endif
1108 : use pm_kind, only: RKC => RK2
1109 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1110 : real(RKC) , intent(in) :: queryx
1111 : real(RKC) :: interp
1112 : type(neinext_type) , intent(in) :: method
1113 : end function
1114 : #endif
1115 :
1116 : #if RK1_ENABLED
1117 : PURE module function getInterpNEXT_ND1_QD0_RK1(method, crdx, func, queryx) result(interp)
1118 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1119 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD0_RK1
1120 : #endif
1121 : use pm_kind, only: RKC => RK1
1122 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1123 : real(RKC) , intent(in) :: queryx
1124 : real(RKC) :: interp
1125 : type(neinext_type) , intent(in) :: method
1126 : end function
1127 : #endif
1128 :
1129 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1130 :
1131 : #if RK5_ENABLED
1132 : PURE module function getInterpNEXT_ND1_QD1_RK5(method, crdx, func, queryx) result(interp)
1133 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1134 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD1_RK5
1135 : #endif
1136 : use pm_kind, only: RKC => RK5
1137 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1138 : real(RKC) , intent(in) , contiguous :: queryx(:)
1139 : real(RKC) :: interp(size(queryx, 1, IK))
1140 : type(neinext_type) , intent(in) :: method
1141 : end function
1142 : #endif
1143 :
1144 : #if RK4_ENABLED
1145 : PURE module function getInterpNEXT_ND1_QD1_RK4(method, crdx, func, queryx) result(interp)
1146 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1147 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD1_RK4
1148 : #endif
1149 : use pm_kind, only: RKC => RK4
1150 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1151 : real(RKC) , intent(in) , contiguous :: queryx(:)
1152 : real(RKC) :: interp(size(queryx, 1, IK))
1153 : type(neinext_type) , intent(in) :: method
1154 : end function
1155 : #endif
1156 :
1157 : #if RK3_ENABLED
1158 : PURE module function getInterpNEXT_ND1_QD1_RK3(method, crdx, func, queryx) result(interp)
1159 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1160 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD1_RK3
1161 : #endif
1162 : use pm_kind, only: RKC => RK3
1163 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1164 : real(RKC) , intent(in) , contiguous :: queryx(:)
1165 : real(RKC) :: interp(size(queryx, 1, IK))
1166 : type(neinext_type) , intent(in) :: method
1167 : end function
1168 : #endif
1169 :
1170 : #if RK2_ENABLED
1171 : PURE module function getInterpNEXT_ND1_QD1_RK2(method, crdx, func, queryx) result(interp)
1172 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1173 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD1_RK2
1174 : #endif
1175 : use pm_kind, only: RKC => RK2
1176 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1177 : real(RKC) , intent(in) , contiguous :: queryx(:)
1178 : real(RKC) :: interp(size(queryx, 1, IK))
1179 : type(neinext_type) , intent(in) :: method
1180 : end function
1181 : #endif
1182 :
1183 : #if RK1_ENABLED
1184 : PURE module function getInterpNEXT_ND1_QD1_RK1(method, crdx, func, queryx) result(interp)
1185 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1186 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpNEXT_ND1_QD1_RK1
1187 : #endif
1188 : use pm_kind, only: RKC => RK1
1189 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1190 : real(RKC) , intent(in) , contiguous :: queryx(:)
1191 : real(RKC) :: interp(size(queryx, 1, IK))
1192 : type(neinext_type) , intent(in) :: method
1193 : end function
1194 : #endif
1195 :
1196 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1197 :
1198 : end interface
1199 :
1200 : ! neiprev
1201 :
1202 : interface getInterp
1203 :
1204 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1205 :
1206 : #if RK5_ENABLED
1207 : PURE module function getInterpPREV_ND1_QD0_RK5(method, crdx, func, queryx) result(interp)
1208 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1209 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD0_RK5
1210 : #endif
1211 : use pm_kind, only: RKC => RK5
1212 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1213 : real(RKC) , intent(in) :: queryx
1214 : real(RKC) :: interp
1215 : type(neiprev_type) , intent(in) :: method
1216 : end function
1217 : #endif
1218 :
1219 : #if RK4_ENABLED
1220 : PURE module function getInterpPREV_ND1_QD0_RK4(method, crdx, func, queryx) result(interp)
1221 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1222 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD0_RK4
1223 : #endif
1224 : use pm_kind, only: RKC => RK4
1225 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1226 : real(RKC) , intent(in) :: queryx
1227 : real(RKC) :: interp
1228 : type(neiprev_type) , intent(in) :: method
1229 : end function
1230 : #endif
1231 :
1232 : #if RK3_ENABLED
1233 : PURE module function getInterpPREV_ND1_QD0_RK3(method, crdx, func, queryx) result(interp)
1234 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1235 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD0_RK3
1236 : #endif
1237 : use pm_kind, only: RKC => RK3
1238 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1239 : real(RKC) , intent(in) :: queryx
1240 : real(RKC) :: interp
1241 : type(neiprev_type) , intent(in) :: method
1242 : end function
1243 : #endif
1244 :
1245 : #if RK2_ENABLED
1246 : PURE module function getInterpPREV_ND1_QD0_RK2(method, crdx, func, queryx) result(interp)
1247 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1248 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD0_RK2
1249 : #endif
1250 : use pm_kind, only: RKC => RK2
1251 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1252 : real(RKC) , intent(in) :: queryx
1253 : real(RKC) :: interp
1254 : type(neiprev_type) , intent(in) :: method
1255 : end function
1256 : #endif
1257 :
1258 : #if RK1_ENABLED
1259 : PURE module function getInterpPREV_ND1_QD0_RK1(method, crdx, func, queryx) result(interp)
1260 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1261 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD0_RK1
1262 : #endif
1263 : use pm_kind, only: RKC => RK1
1264 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1265 : real(RKC) , intent(in) :: queryx
1266 : real(RKC) :: interp
1267 : type(neiprev_type) , intent(in) :: method
1268 : end function
1269 : #endif
1270 :
1271 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1272 :
1273 : #if RK5_ENABLED
1274 : PURE module function getInterpPREV_ND1_QD1_RK5(method, crdx, func, queryx) result(interp)
1275 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1276 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD1_RK5
1277 : #endif
1278 : use pm_kind, only: RKC => RK5
1279 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1280 : real(RKC) , intent(in) , contiguous :: queryx(:)
1281 : real(RKC) :: interp(size(queryx, 1, IK))
1282 : type(neiprev_type) , intent(in) :: method
1283 : end function
1284 : #endif
1285 :
1286 : #if RK4_ENABLED
1287 : PURE module function getInterpPREV_ND1_QD1_RK4(method, crdx, func, queryx) result(interp)
1288 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1289 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD1_RK4
1290 : #endif
1291 : use pm_kind, only: RKC => RK4
1292 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1293 : real(RKC) , intent(in) , contiguous :: queryx(:)
1294 : real(RKC) :: interp(size(queryx, 1, IK))
1295 : type(neiprev_type) , intent(in) :: method
1296 : end function
1297 : #endif
1298 :
1299 : #if RK3_ENABLED
1300 : PURE module function getInterpPREV_ND1_QD1_RK3(method, crdx, func, queryx) result(interp)
1301 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1302 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD1_RK3
1303 : #endif
1304 : use pm_kind, only: RKC => RK3
1305 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1306 : real(RKC) , intent(in) , contiguous :: queryx(:)
1307 : real(RKC) :: interp(size(queryx, 1, IK))
1308 : type(neiprev_type) , intent(in) :: method
1309 : end function
1310 : #endif
1311 :
1312 : #if RK2_ENABLED
1313 : PURE module function getInterpPREV_ND1_QD1_RK2(method, crdx, func, queryx) result(interp)
1314 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1315 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD1_RK2
1316 : #endif
1317 : use pm_kind, only: RKC => RK2
1318 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1319 : real(RKC) , intent(in) , contiguous :: queryx(:)
1320 : real(RKC) :: interp(size(queryx, 1, IK))
1321 : type(neiprev_type) , intent(in) :: method
1322 : end function
1323 : #endif
1324 :
1325 : #if RK1_ENABLED
1326 : PURE module function getInterpPREV_ND1_QD1_RK1(method, crdx, func, queryx) result(interp)
1327 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1328 : !DEC$ ATTRIBUTES DLLEXPORT :: getInterpPREV_ND1_QD1_RK1
1329 : #endif
1330 : use pm_kind, only: RKC => RK1
1331 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1332 : real(RKC) , intent(in) , contiguous :: queryx(:)
1333 : real(RKC) :: interp(size(queryx, 1, IK))
1334 : type(neiprev_type) , intent(in) :: method
1335 : end function
1336 : #endif
1337 :
1338 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1339 :
1340 : end interface
1341 :
1342 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1343 :
1344 : !> \brief
1345 : !> Generate and return the approximate **polynomial interpolation** value of the input specified point `x` for the specified `method`.
1346 : !>
1347 : !> \details
1348 : !> For polynomial interpolation, the computation relies on the **Neville algorithm**.<br>
1349 : !>
1350 : !> \param[in] method : The input scalar constant that can be,
1351 : !> <ol>
1352 : !> <li> The scalar constant [neimean](@ref pm_polation::neimean) or a scalar object of type [neimean_type](@ref pm_polation::neimean_type)
1353 : !> implying the use of the average of the `func` values of the two nearest neighbors of the input `queryx` smaller and larger than it as the output `interp`.<br>
1354 : !> <li> The scalar constant [neinear](@ref pm_polation::neinear) or a scalar object of type [neinear_type](@ref pm_polation::neinear_type)
1355 : !> implying the use of the average of the `func` value of the `neinear` nearest neighbor of the input `queryx` as the output `interp`.<br>
1356 : !> Note that the nearest neighbor in this case is measured by actual Euclidean distances of neighbors to the input `queryx`.<br>
1357 : !> <li> The scalar constant [neiprev](@ref pm_polation::neiprev) or a scalar object of type [neiprev_type](@ref pm_polation::neiprev_type)
1358 : !> implying the use of the `func` value of the largest abscissa in the input `crdx` smaller than the input `queryx` as the output `interp`.<br>
1359 : !> <li> The scalar constant [neinext](@ref pm_polation::neinext) or a scalar object of type [neinext_type](@ref pm_polation::neinext_type)
1360 : !> implying the use of the `func` value of the smallest abscissa in the input `crdx` larger than the input `queryx` as the output `interp`.<br>
1361 : !> <li> The scalar constant [piwilin](@ref pm_polation::piwilin) or a scalar object of type [piwilin_type](@ref pm_polation::piwilin_type)
1362 : !> implying the use of the **linear interpolation** of the `func` values of the two `crdx` points that bracket `queryx` as the output `interp`.<br>
1363 : !> The linear interpolation implemented in this constructor is based on the Lagrange classical formula for linear interpolation.<br>
1364 : !> Suppose an input query point \f$x\f$ falls between two nodes \f$x_i\f$ and \f$x_{i+1}\f$ with the corresponding function values
1365 : !> \f$y_i\f$ and \f$y_{i+1}\f$ and we wish to estimate the corresponding interpolated value \f$y(x)\f$, which can be computed as,
1366 : !> \f{equation*}{
1367 : !> y(x) = \frac {x - x_{i+1}} {x_i - x_{i+1}} y_i + \frac {x - x_{i}} {x_{i+1} - x_{i}} y_{i+1} ~.
1368 : !> \f}
1369 : !> <li> The scalar constant [monopol](@ref pm_polation::monopol) or a scalar object of type [monopol_type](@ref pm_polation::monopol_type)
1370 : !> implying the use of a single **polynomial interpolation** of highest degree `size(crdx) - 1` possible to all pairs of `(crdx, func)` for computing the output `interp`.<br>
1371 : !> The Neville algorithm is used to approximate the polynomial interpolation.<br>
1372 : !> </ol>
1373 : !> \param[in] crdx : The input `contiguous` vector of<br>
1374 : !> <ol>
1375 : !> <li> type `real` of kind \RKALL,
1376 : !> </ol>
1377 : !> containing the set of abscissa in **strictly ascending order** through which the constructed polynomial must pass.<br>
1378 : !> If needed, the input values for `crdx` and `sortedY` can be sorted in ascending order by calling either
1379 : !> [setSorted()](@ref pm_arraySort::setSorted) or [setSorted()](@ref pm_arraySort::setSorted).
1380 : !> \param[in] func : The input `contiguous` vector of the same type, kind, and size as `crdx`,
1381 : !> containing the set of function values corresponding to the input abscissa `crdx` through which the constructed polynomial must pass.
1382 : !> \param[in] queryx : The input scalar or vector of the same type and kind as `crdx`, containing the abscissa (x-value) of the queryx point.
1383 : !> \param[out] interp : The output object of the same type, kind, rank, and shape as `queryx`,
1384 : !> containing the (approximate) interpolated y-value(s) corresponding to the `queryx` point(s).
1385 : !> \param[out] relerr : The output scalar of the same type and kind as `crdx`, containing the estimated error in the output `interp`.
1386 : !> (**optional**. It can be present **if and only** the input argument `method` is set to
1387 : !> [monopol](@ref pm_polation::monopol) or a scalar object of type [monopol_type](@ref pm_polation::monopol_type) .)
1388 : !>
1389 : !> \interface{setInterp}
1390 : !> \code{.F90}
1391 : !>
1392 : !> use pm_polation, only: setInterp
1393 : !>
1394 : !> call setInterp(method, crdx(1:nsam), func(1:nsam), queryx, interp)
1395 : !> call setInterp(method, crdx(1:nsam), func(1:nsam), queryx(1:nque), interp(1:nque))
1396 : !>
1397 : !> call setInterp(method, crdx(1:nsam), func(1:nsam), queryx, interp, relerr) ! method = monopol
1398 : !> call setInterp(method, crdx(1:nsam), func(1:nsam), queryx(1:nque), interp(1:nque), relerr(1:nque)) ! method = monopol
1399 : !>
1400 : !> \endcode
1401 : !>
1402 : !> \warning
1403 : !> The condition `size(crdx) == size(func)` must hold for the corresponding input arguments.<br>
1404 : !> The condition `all(shape(queryx) == shape(interp))` must hold for the corresponding input arguments.<br>
1405 : !> The condition `all(shape(queryx) == shape(relerr))` must hold for the corresponding input arguments.<br>
1406 : !> The condition `all([minval(crdx, 1) <= queryx .and. queryx <= maxval(crdx, 1))` must hold for the corresponding input arguments.<br>
1407 : !> The condition `isAscendingAll(crdx) .or. same_type_as(method, monopol_type())` must hold for the corresponding input arguments.<br>
1408 : !> \vericons
1409 : !>
1410 : !> \warnpure
1411 : !>
1412 : !> \see
1413 : !> [getExtrap](@ref pm_polation::getExtrap)<br>
1414 : !> [setExtrap](@ref pm_polation::setExtrap)<br>
1415 : !> [getInterp](@ref pm_polation::getInterp)<br>
1416 : !> [setInterp](@ref pm_polation::setInterp)<br>
1417 : !> [pm_sampleQuan](@ref pm_sampleQuan)<br>
1418 : !> [pm_arraySort](@ref pm_arraySort)<br>
1419 : !> [pm_quadRomb](@ref pm_quadRomb)<br>
1420 : !>
1421 : !> \example{setInterp}
1422 : !> \include{lineno} example/pm_polation/setInterp/main.F90
1423 : !> \compilef{setInterp}
1424 : !> \output{setInterp}
1425 : !> \include{lineno} example/pm_polation/setInterp/main.out.F90
1426 : !> \postproc{setInterp}
1427 : !> \include{lineno} example/pm_polation/setInterp/main.py
1428 : !> \vis{setInterp}
1429 : !> \image html pm_polation/setInterp/setInterp.neimean.interp.png width=700
1430 : !> \image html pm_polation/setInterp/setInterp.neinear.interp.png width=700
1431 : !> \image html pm_polation/setInterp/setInterp.neinext.interp.png width=700
1432 : !> \image html pm_polation/setInterp/setInterp.neiprev.interp.png width=700
1433 : !> \image html pm_polation/setInterp/setInterp.piwilin.interp.png width=700
1434 : !> \image html pm_polation/setInterp/setInterp.monopol.interp.png width=700
1435 : !> \image html pm_polation/setInterp/setInterp.rungeEffect.interp.png width=700
1436 : !>
1437 : !> \test
1438 : !> [test_pm_polation](@ref test_pm_polation)
1439 : !>
1440 : !> \finmain{setInterp}
1441 : !>
1442 : !> \author
1443 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1444 :
1445 : ! monopol MNPLD
1446 :
1447 : interface setInterp
1448 :
1449 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1450 :
1451 : #if RK5_ENABLED
1452 : PURE module subroutine setInterpMNPLD_ND1_QD0_RK5(method, crdx, func, queryx, interp)
1453 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1454 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD0_RK5
1455 : #endif
1456 : use pm_kind, only: RKC => RK5
1457 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1458 : real(RKC) , intent(in) :: queryx
1459 : real(RKC) , intent(out) :: interp
1460 : type(monopol_type) , intent(in) :: method
1461 : end subroutine
1462 : #endif
1463 :
1464 : #if RK4_ENABLED
1465 : PURE module subroutine setInterpMNPLD_ND1_QD0_RK4(method, crdx, func, queryx, interp)
1466 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1467 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD0_RK4
1468 : #endif
1469 : use pm_kind, only: RKC => RK4
1470 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1471 : real(RKC) , intent(in) :: queryx
1472 : real(RKC) , intent(out) :: interp
1473 : type(monopol_type) , intent(in) :: method
1474 : end subroutine
1475 : #endif
1476 :
1477 : #if RK3_ENABLED
1478 : PURE module subroutine setInterpMNPLD_ND1_QD0_RK3(method, crdx, func, queryx, interp)
1479 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1480 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD0_RK3
1481 : #endif
1482 : use pm_kind, only: RKC => RK3
1483 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1484 : real(RKC) , intent(in) :: queryx
1485 : real(RKC) , intent(out) :: interp
1486 : type(monopol_type) , intent(in) :: method
1487 : end subroutine
1488 : #endif
1489 :
1490 : #if RK2_ENABLED
1491 : PURE module subroutine setInterpMNPLD_ND1_QD0_RK2(method, crdx, func, queryx, interp)
1492 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1493 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD0_RK2
1494 : #endif
1495 : use pm_kind, only: RKC => RK2
1496 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1497 : real(RKC) , intent(in) :: queryx
1498 : real(RKC) , intent(out) :: interp
1499 : type(monopol_type) , intent(in) :: method
1500 : end subroutine
1501 : #endif
1502 :
1503 : #if RK1_ENABLED
1504 : PURE module subroutine setInterpMNPLD_ND1_QD0_RK1(method, crdx, func, queryx, interp)
1505 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1506 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD0_RK1
1507 : #endif
1508 : use pm_kind, only: RKC => RK1
1509 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1510 : real(RKC) , intent(in) :: queryx
1511 : real(RKC) , intent(out) :: interp
1512 : type(monopol_type) , intent(in) :: method
1513 : end subroutine
1514 : #endif
1515 :
1516 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1517 :
1518 : #if RK5_ENABLED
1519 : PURE module subroutine setInterpMNPLD_ND1_QD1_RK5(method, crdx, func, queryx, interp)
1520 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1521 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD1_RK5
1522 : #endif
1523 : use pm_kind, only: RKC => RK5
1524 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1525 : real(RKC) , intent(in) , contiguous :: queryx(:)
1526 : real(RKC) , intent(out) , contiguous :: interp(:)
1527 : type(monopol_type) , intent(in) :: method
1528 : end subroutine
1529 : #endif
1530 :
1531 : #if RK4_ENABLED
1532 : PURE module subroutine setInterpMNPLD_ND1_QD1_RK4(method, crdx, func, queryx, interp)
1533 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1534 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD1_RK4
1535 : #endif
1536 : use pm_kind, only: RKC => RK4
1537 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1538 : real(RKC) , intent(in) , contiguous :: queryx(:)
1539 : real(RKC) , intent(out) , contiguous :: interp(:)
1540 : type(monopol_type) , intent(in) :: method
1541 : end subroutine
1542 : #endif
1543 :
1544 : #if RK3_ENABLED
1545 : PURE module subroutine setInterpMNPLD_ND1_QD1_RK3(method, crdx, func, queryx, interp)
1546 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1547 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD1_RK3
1548 : #endif
1549 : use pm_kind, only: RKC => RK3
1550 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1551 : real(RKC) , intent(in) , contiguous :: queryx(:)
1552 : real(RKC) , intent(out) , contiguous :: interp(:)
1553 : type(monopol_type) , intent(in) :: method
1554 : end subroutine
1555 : #endif
1556 :
1557 : #if RK2_ENABLED
1558 : PURE module subroutine setInterpMNPLD_ND1_QD1_RK2(method, crdx, func, queryx, interp)
1559 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1560 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD1_RK2
1561 : #endif
1562 : use pm_kind, only: RKC => RK2
1563 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1564 : real(RKC) , intent(in) , contiguous :: queryx(:)
1565 : real(RKC) , intent(out) , contiguous :: interp(:)
1566 : type(monopol_type) , intent(in) :: method
1567 : end subroutine
1568 : #endif
1569 :
1570 : #if RK1_ENABLED
1571 : PURE module subroutine setInterpMNPLD_ND1_QD1_RK1(method, crdx, func, queryx, interp)
1572 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1573 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLD_ND1_QD1_RK1
1574 : #endif
1575 : use pm_kind, only: RKC => RK1
1576 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1577 : real(RKC) , intent(in) , contiguous :: queryx(:)
1578 : real(RKC) , intent(out) , contiguous :: interp(:)
1579 : type(monopol_type) , intent(in) :: method
1580 : end subroutine
1581 : #endif
1582 :
1583 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1584 :
1585 : end interface
1586 :
1587 : ! monopol MNPLE
1588 :
1589 : interface setInterp
1590 :
1591 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1592 :
1593 : #if RK5_ENABLED
1594 : PURE module subroutine setInterpMNPLE_ND1_QD0_RK5(method, crdx, func, queryx, interp, relerr)
1595 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1596 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD0_RK5
1597 : #endif
1598 : use pm_kind, only: RKC => RK5
1599 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1600 : real(RKC) , intent(in) :: queryx
1601 : real(RKC) , intent(out) :: interp, relerr
1602 : type(monopol_type) , intent(in) :: method
1603 : end subroutine
1604 : #endif
1605 :
1606 : #if RK4_ENABLED
1607 : PURE module subroutine setInterpMNPLE_ND1_QD0_RK4(method, crdx, func, queryx, interp, relerr)
1608 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1609 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD0_RK4
1610 : #endif
1611 : use pm_kind, only: RKC => RK4
1612 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1613 : real(RKC) , intent(in) :: queryx
1614 : real(RKC) , intent(out) :: interp, relerr
1615 : type(monopol_type) , intent(in) :: method
1616 : end subroutine
1617 : #endif
1618 :
1619 : #if RK3_ENABLED
1620 : PURE module subroutine setInterpMNPLE_ND1_QD0_RK3(method, crdx, func, queryx, interp, relerr)
1621 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1622 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD0_RK3
1623 : #endif
1624 : use pm_kind, only: RKC => RK3
1625 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1626 : real(RKC) , intent(in) :: queryx
1627 : real(RKC) , intent(out) :: interp, relerr
1628 : type(monopol_type) , intent(in) :: method
1629 : end subroutine
1630 : #endif
1631 :
1632 : #if RK2_ENABLED
1633 : PURE module subroutine setInterpMNPLE_ND1_QD0_RK2(method, crdx, func, queryx, interp, relerr)
1634 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1635 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD0_RK2
1636 : #endif
1637 : use pm_kind, only: RKC => RK2
1638 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1639 : real(RKC) , intent(in) :: queryx
1640 : real(RKC) , intent(out) :: interp, relerr
1641 : type(monopol_type) , intent(in) :: method
1642 : end subroutine
1643 : #endif
1644 :
1645 : #if RK1_ENABLED
1646 : PURE module subroutine setInterpMNPLE_ND1_QD0_RK1(method, crdx, func, queryx, interp, relerr)
1647 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1648 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD0_RK1
1649 : #endif
1650 : use pm_kind, only: RKC => RK1
1651 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1652 : real(RKC) , intent(in) :: queryx
1653 : real(RKC) , intent(out) :: interp, relerr
1654 : type(monopol_type) , intent(in) :: method
1655 : end subroutine
1656 : #endif
1657 :
1658 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1659 :
1660 : #if RK5_ENABLED
1661 : PURE module subroutine setInterpMNPLE_ND1_QD1_RK5(method, crdx, func, queryx, interp, relerr)
1662 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1663 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD1_RK5
1664 : #endif
1665 : use pm_kind, only: RKC => RK5
1666 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1667 : real(RKC) , intent(in) , contiguous :: queryx(:)
1668 : real(RKC) , intent(out) , contiguous :: interp(:), relerr(:)
1669 : type(monopol_type) , intent(in) :: method
1670 : end subroutine
1671 : #endif
1672 :
1673 : #if RK4_ENABLED
1674 : PURE module subroutine setInterpMNPLE_ND1_QD1_RK4(method, crdx, func, queryx, interp, relerr)
1675 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1676 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD1_RK4
1677 : #endif
1678 : use pm_kind, only: RKC => RK4
1679 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1680 : real(RKC) , intent(in) , contiguous :: queryx(:)
1681 : real(RKC) , intent(out) , contiguous :: interp(:), relerr(:)
1682 : type(monopol_type) , intent(in) :: method
1683 : end subroutine
1684 : #endif
1685 :
1686 : #if RK3_ENABLED
1687 : PURE module subroutine setInterpMNPLE_ND1_QD1_RK3(method, crdx, func, queryx, interp, relerr)
1688 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1689 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD1_RK3
1690 : #endif
1691 : use pm_kind, only: RKC => RK3
1692 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1693 : real(RKC) , intent(in) , contiguous :: queryx(:)
1694 : real(RKC) , intent(out) , contiguous :: interp(:), relerr(:)
1695 : type(monopol_type) , intent(in) :: method
1696 : end subroutine
1697 : #endif
1698 :
1699 : #if RK2_ENABLED
1700 : PURE module subroutine setInterpMNPLE_ND1_QD1_RK2(method, crdx, func, queryx, interp, relerr)
1701 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1702 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD1_RK2
1703 : #endif
1704 : use pm_kind, only: RKC => RK2
1705 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1706 : real(RKC) , intent(in) , contiguous :: queryx(:)
1707 : real(RKC) , intent(out) , contiguous :: interp(:), relerr(:)
1708 : type(monopol_type) , intent(in) :: method
1709 : end subroutine
1710 : #endif
1711 :
1712 : #if RK1_ENABLED
1713 : PURE module subroutine setInterpMNPLE_ND1_QD1_RK1(method, crdx, func, queryx, interp, relerr)
1714 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1715 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMNPLE_ND1_QD1_RK1
1716 : #endif
1717 : use pm_kind, only: RKC => RK1
1718 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1719 : real(RKC) , intent(in) , contiguous :: queryx(:)
1720 : real(RKC) , intent(out) , contiguous :: interp(:), relerr(:)
1721 : type(monopol_type) , intent(in) :: method
1722 : end subroutine
1723 : #endif
1724 :
1725 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1726 :
1727 : end interface
1728 :
1729 : ! piwilin
1730 :
1731 : interface setInterp
1732 :
1733 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1734 :
1735 : #if RK5_ENABLED
1736 : PURE module subroutine setInterpPWLN_ND1_QD0_RK5(method, crdx, func, queryx, interp)
1737 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1738 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD0_RK5
1739 : #endif
1740 : use pm_kind, only: RKC => RK5
1741 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1742 : real(RKC) , intent(in) :: queryx
1743 : real(RKC) , intent(out) :: interp
1744 : type(piwilin_type) , intent(in) :: method
1745 : end subroutine
1746 : #endif
1747 :
1748 : #if RK4_ENABLED
1749 : PURE module subroutine setInterpPWLN_ND1_QD0_RK4(method, crdx, func, queryx, interp)
1750 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1751 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD0_RK4
1752 : #endif
1753 : use pm_kind, only: RKC => RK4
1754 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1755 : real(RKC) , intent(in) :: queryx
1756 : real(RKC) , intent(out) :: interp
1757 : type(piwilin_type) , intent(in) :: method
1758 : end subroutine
1759 : #endif
1760 :
1761 : #if RK3_ENABLED
1762 : PURE module subroutine setInterpPWLN_ND1_QD0_RK3(method, crdx, func, queryx, interp)
1763 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1764 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD0_RK3
1765 : #endif
1766 : use pm_kind, only: RKC => RK3
1767 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1768 : real(RKC) , intent(in) :: queryx
1769 : real(RKC) , intent(out) :: interp
1770 : type(piwilin_type) , intent(in) :: method
1771 : end subroutine
1772 : #endif
1773 :
1774 : #if RK2_ENABLED
1775 : PURE module subroutine setInterpPWLN_ND1_QD0_RK2(method, crdx, func, queryx, interp)
1776 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1777 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD0_RK2
1778 : #endif
1779 : use pm_kind, only: RKC => RK2
1780 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1781 : real(RKC) , intent(in) :: queryx
1782 : real(RKC) , intent(out) :: interp
1783 : type(piwilin_type) , intent(in) :: method
1784 : end subroutine
1785 : #endif
1786 :
1787 : #if RK1_ENABLED
1788 : PURE module subroutine setInterpPWLN_ND1_QD0_RK1(method, crdx, func, queryx, interp)
1789 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1790 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD0_RK1
1791 : #endif
1792 : use pm_kind, only: RKC => RK1
1793 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1794 : real(RKC) , intent(in) :: queryx
1795 : real(RKC) , intent(out) :: interp
1796 : type(piwilin_type) , intent(in) :: method
1797 : end subroutine
1798 : #endif
1799 :
1800 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1801 :
1802 : #if RK5_ENABLED
1803 : PURE module subroutine setInterpPWLN_ND1_QD1_RK5(method, crdx, func, queryx, interp)
1804 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1805 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD1_RK5
1806 : #endif
1807 : use pm_kind, only: RKC => RK5
1808 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1809 : real(RKC) , intent(in) , contiguous :: queryx(:)
1810 : real(RKC) , intent(out) , contiguous :: interp(:)
1811 : type(piwilin_type) , intent(in) :: method
1812 : end subroutine
1813 : #endif
1814 :
1815 : #if RK4_ENABLED
1816 : PURE module subroutine setInterpPWLN_ND1_QD1_RK4(method, crdx, func, queryx, interp)
1817 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1818 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD1_RK4
1819 : #endif
1820 : use pm_kind, only: RKC => RK4
1821 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1822 : real(RKC) , intent(in) , contiguous :: queryx(:)
1823 : real(RKC) , intent(out) , contiguous :: interp(:)
1824 : type(piwilin_type) , intent(in) :: method
1825 : end subroutine
1826 : #endif
1827 :
1828 : #if RK3_ENABLED
1829 : PURE module subroutine setInterpPWLN_ND1_QD1_RK3(method, crdx, func, queryx, interp)
1830 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1831 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD1_RK3
1832 : #endif
1833 : use pm_kind, only: RKC => RK3
1834 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1835 : real(RKC) , intent(in) , contiguous :: queryx(:)
1836 : real(RKC) , intent(out) , contiguous :: interp(:)
1837 : type(piwilin_type) , intent(in) :: method
1838 : end subroutine
1839 : #endif
1840 :
1841 : #if RK2_ENABLED
1842 : PURE module subroutine setInterpPWLN_ND1_QD1_RK2(method, crdx, func, queryx, interp)
1843 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1844 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD1_RK2
1845 : #endif
1846 : use pm_kind, only: RKC => RK2
1847 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1848 : real(RKC) , intent(in) , contiguous :: queryx(:)
1849 : real(RKC) , intent(out) , contiguous :: interp(:)
1850 : type(piwilin_type) , intent(in) :: method
1851 : end subroutine
1852 : #endif
1853 :
1854 : #if RK1_ENABLED
1855 : PURE module subroutine setInterpPWLN_ND1_QD1_RK1(method, crdx, func, queryx, interp)
1856 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1857 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPWLN_ND1_QD1_RK1
1858 : #endif
1859 : use pm_kind, only: RKC => RK1
1860 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1861 : real(RKC) , intent(in) , contiguous :: queryx(:)
1862 : real(RKC) , intent(out) , contiguous :: interp(:)
1863 : type(piwilin_type) , intent(in) :: method
1864 : end subroutine
1865 : #endif
1866 :
1867 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1868 :
1869 : end interface
1870 :
1871 : ! neimean
1872 :
1873 : interface setInterp
1874 :
1875 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1876 :
1877 : #if RK5_ENABLED
1878 : PURE module subroutine setInterpMEAN_ND1_QD0_RK5(method, crdx, func, queryx, interp)
1879 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1880 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD0_RK5
1881 : #endif
1882 : use pm_kind, only: RKC => RK5
1883 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1884 : real(RKC) , intent(in) :: queryx
1885 : real(RKC) , intent(out) :: interp
1886 : type(neimean_type) , intent(in) :: method
1887 : end subroutine
1888 : #endif
1889 :
1890 : #if RK4_ENABLED
1891 : PURE module subroutine setInterpMEAN_ND1_QD0_RK4(method, crdx, func, queryx, interp)
1892 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1893 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD0_RK4
1894 : #endif
1895 : use pm_kind, only: RKC => RK4
1896 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1897 : real(RKC) , intent(in) :: queryx
1898 : real(RKC) , intent(out) :: interp
1899 : type(neimean_type) , intent(in) :: method
1900 : end subroutine
1901 : #endif
1902 :
1903 : #if RK3_ENABLED
1904 : PURE module subroutine setInterpMEAN_ND1_QD0_RK3(method, crdx, func, queryx, interp)
1905 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1906 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD0_RK3
1907 : #endif
1908 : use pm_kind, only: RKC => RK3
1909 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1910 : real(RKC) , intent(in) :: queryx
1911 : real(RKC) , intent(out) :: interp
1912 : type(neimean_type) , intent(in) :: method
1913 : end subroutine
1914 : #endif
1915 :
1916 : #if RK2_ENABLED
1917 : PURE module subroutine setInterpMEAN_ND1_QD0_RK2(method, crdx, func, queryx, interp)
1918 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1919 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD0_RK2
1920 : #endif
1921 : use pm_kind, only: RKC => RK2
1922 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1923 : real(RKC) , intent(in) :: queryx
1924 : real(RKC) , intent(out) :: interp
1925 : type(neimean_type) , intent(in) :: method
1926 : end subroutine
1927 : #endif
1928 :
1929 : #if RK1_ENABLED
1930 : PURE module subroutine setInterpMEAN_ND1_QD0_RK1(method, crdx, func, queryx, interp)
1931 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1932 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD0_RK1
1933 : #endif
1934 : use pm_kind, only: RKC => RK1
1935 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1936 : real(RKC) , intent(in) :: queryx
1937 : real(RKC) , intent(out) :: interp
1938 : type(neimean_type) , intent(in) :: method
1939 : end subroutine
1940 : #endif
1941 :
1942 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1943 :
1944 : #if RK5_ENABLED
1945 : PURE module subroutine setInterpMEAN_ND1_QD1_RK5(method, crdx, func, queryx, interp)
1946 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1947 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD1_RK5
1948 : #endif
1949 : use pm_kind, only: RKC => RK5
1950 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1951 : real(RKC) , intent(in) , contiguous :: queryx(:)
1952 : real(RKC) , intent(out) , contiguous :: interp(:)
1953 : type(neimean_type) , intent(in) :: method
1954 : end subroutine
1955 : #endif
1956 :
1957 : #if RK4_ENABLED
1958 : PURE module subroutine setInterpMEAN_ND1_QD1_RK4(method, crdx, func, queryx, interp)
1959 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1960 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD1_RK4
1961 : #endif
1962 : use pm_kind, only: RKC => RK4
1963 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1964 : real(RKC) , intent(in) , contiguous :: queryx(:)
1965 : real(RKC) , intent(out) , contiguous :: interp(:)
1966 : type(neimean_type) , intent(in) :: method
1967 : end subroutine
1968 : #endif
1969 :
1970 : #if RK3_ENABLED
1971 : PURE module subroutine setInterpMEAN_ND1_QD1_RK3(method, crdx, func, queryx, interp)
1972 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1973 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD1_RK3
1974 : #endif
1975 : use pm_kind, only: RKC => RK3
1976 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1977 : real(RKC) , intent(in) , contiguous :: queryx(:)
1978 : real(RKC) , intent(out) , contiguous :: interp(:)
1979 : type(neimean_type) , intent(in) :: method
1980 : end subroutine
1981 : #endif
1982 :
1983 : #if RK2_ENABLED
1984 : PURE module subroutine setInterpMEAN_ND1_QD1_RK2(method, crdx, func, queryx, interp)
1985 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1986 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD1_RK2
1987 : #endif
1988 : use pm_kind, only: RKC => RK2
1989 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
1990 : real(RKC) , intent(in) , contiguous :: queryx(:)
1991 : real(RKC) , intent(out) , contiguous :: interp(:)
1992 : type(neimean_type) , intent(in) :: method
1993 : end subroutine
1994 : #endif
1995 :
1996 : #if RK1_ENABLED
1997 : PURE module subroutine setInterpMEAN_ND1_QD1_RK1(method, crdx, func, queryx, interp)
1998 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1999 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpMEAN_ND1_QD1_RK1
2000 : #endif
2001 : use pm_kind, only: RKC => RK1
2002 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2003 : real(RKC) , intent(in) , contiguous :: queryx(:)
2004 : real(RKC) , intent(out) , contiguous :: interp(:)
2005 : type(neimean_type) , intent(in) :: method
2006 : end subroutine
2007 : #endif
2008 :
2009 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2010 :
2011 : end interface
2012 :
2013 : ! neinear
2014 :
2015 : interface setInterp
2016 :
2017 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2018 :
2019 : #if RK5_ENABLED
2020 : PURE module subroutine setInterpNEAR_ND1_QD0_RK5(method, crdx, func, queryx, interp)
2021 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2022 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD0_RK5
2023 : #endif
2024 : use pm_kind, only: RKC => RK5
2025 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2026 : real(RKC) , intent(in) :: queryx
2027 : real(RKC) , intent(out) :: interp
2028 : type(neinear_type) , intent(in) :: method
2029 : end subroutine
2030 : #endif
2031 :
2032 : #if RK4_ENABLED
2033 : PURE module subroutine setInterpNEAR_ND1_QD0_RK4(method, crdx, func, queryx, interp)
2034 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2035 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD0_RK4
2036 : #endif
2037 : use pm_kind, only: RKC => RK4
2038 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2039 : real(RKC) , intent(in) :: queryx
2040 : real(RKC) , intent(out) :: interp
2041 : type(neinear_type) , intent(in) :: method
2042 : end subroutine
2043 : #endif
2044 :
2045 : #if RK3_ENABLED
2046 : PURE module subroutine setInterpNEAR_ND1_QD0_RK3(method, crdx, func, queryx, interp)
2047 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2048 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD0_RK3
2049 : #endif
2050 : use pm_kind, only: RKC => RK3
2051 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2052 : real(RKC) , intent(in) :: queryx
2053 : real(RKC) , intent(out) :: interp
2054 : type(neinear_type) , intent(in) :: method
2055 : end subroutine
2056 : #endif
2057 :
2058 : #if RK2_ENABLED
2059 : PURE module subroutine setInterpNEAR_ND1_QD0_RK2(method, crdx, func, queryx, interp)
2060 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2061 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD0_RK2
2062 : #endif
2063 : use pm_kind, only: RKC => RK2
2064 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2065 : real(RKC) , intent(in) :: queryx
2066 : real(RKC) , intent(out) :: interp
2067 : type(neinear_type) , intent(in) :: method
2068 : end subroutine
2069 : #endif
2070 :
2071 : #if RK1_ENABLED
2072 : PURE module subroutine setInterpNEAR_ND1_QD0_RK1(method, crdx, func, queryx, interp)
2073 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2074 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD0_RK1
2075 : #endif
2076 : use pm_kind, only: RKC => RK1
2077 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2078 : real(RKC) , intent(in) :: queryx
2079 : real(RKC) , intent(out) :: interp
2080 : type(neinear_type) , intent(in) :: method
2081 : end subroutine
2082 : #endif
2083 :
2084 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2085 :
2086 : #if RK5_ENABLED
2087 : PURE module subroutine setInterpNEAR_ND1_QD1_RK5(method, crdx, func, queryx, interp)
2088 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2089 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD1_RK5
2090 : #endif
2091 : use pm_kind, only: RKC => RK5
2092 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2093 : real(RKC) , intent(in) , contiguous :: queryx(:)
2094 : real(RKC) , intent(out) , contiguous :: interp(:)
2095 : type(neinear_type) , intent(in) :: method
2096 : end subroutine
2097 : #endif
2098 :
2099 : #if RK4_ENABLED
2100 : PURE module subroutine setInterpNEAR_ND1_QD1_RK4(method, crdx, func, queryx, interp)
2101 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2102 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD1_RK4
2103 : #endif
2104 : use pm_kind, only: RKC => RK4
2105 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2106 : real(RKC) , intent(in) , contiguous :: queryx(:)
2107 : real(RKC) , intent(out) , contiguous :: interp(:)
2108 : type(neinear_type) , intent(in) :: method
2109 : end subroutine
2110 : #endif
2111 :
2112 : #if RK3_ENABLED
2113 : PURE module subroutine setInterpNEAR_ND1_QD1_RK3(method, crdx, func, queryx, interp)
2114 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2115 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD1_RK3
2116 : #endif
2117 : use pm_kind, only: RKC => RK3
2118 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2119 : real(RKC) , intent(in) , contiguous :: queryx(:)
2120 : real(RKC) , intent(out) , contiguous :: interp(:)
2121 : type(neinear_type) , intent(in) :: method
2122 : end subroutine
2123 : #endif
2124 :
2125 : #if RK2_ENABLED
2126 : PURE module subroutine setInterpNEAR_ND1_QD1_RK2(method, crdx, func, queryx, interp)
2127 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2128 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD1_RK2
2129 : #endif
2130 : use pm_kind, only: RKC => RK2
2131 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2132 : real(RKC) , intent(in) , contiguous :: queryx(:)
2133 : real(RKC) , intent(out) , contiguous :: interp(:)
2134 : type(neinear_type) , intent(in) :: method
2135 : end subroutine
2136 : #endif
2137 :
2138 : #if RK1_ENABLED
2139 : PURE module subroutine setInterpNEAR_ND1_QD1_RK1(method, crdx, func, queryx, interp)
2140 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2141 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEAR_ND1_QD1_RK1
2142 : #endif
2143 : use pm_kind, only: RKC => RK1
2144 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2145 : real(RKC) , intent(in) , contiguous :: queryx(:)
2146 : real(RKC) , intent(out) , contiguous :: interp(:)
2147 : type(neinear_type) , intent(in) :: method
2148 : end subroutine
2149 : #endif
2150 :
2151 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2152 :
2153 : end interface
2154 :
2155 : ! neinext
2156 :
2157 : interface setInterp
2158 :
2159 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2160 :
2161 : #if RK5_ENABLED
2162 : PURE module subroutine setInterpNEXT_ND1_QD0_RK5(method, crdx, func, queryx, interp)
2163 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2164 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD0_RK5
2165 : #endif
2166 : use pm_kind, only: RKC => RK5
2167 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2168 : real(RKC) , intent(in) :: queryx
2169 : real(RKC) , intent(out) :: interp
2170 : type(neinext_type) , intent(in) :: method
2171 : end subroutine
2172 : #endif
2173 :
2174 : #if RK4_ENABLED
2175 : PURE module subroutine setInterpNEXT_ND1_QD0_RK4(method, crdx, func, queryx, interp)
2176 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2177 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD0_RK4
2178 : #endif
2179 : use pm_kind, only: RKC => RK4
2180 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2181 : real(RKC) , intent(in) :: queryx
2182 : real(RKC) , intent(out) :: interp
2183 : type(neinext_type) , intent(in) :: method
2184 : end subroutine
2185 : #endif
2186 :
2187 : #if RK3_ENABLED
2188 : PURE module subroutine setInterpNEXT_ND1_QD0_RK3(method, crdx, func, queryx, interp)
2189 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2190 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD0_RK3
2191 : #endif
2192 : use pm_kind, only: RKC => RK3
2193 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2194 : real(RKC) , intent(in) :: queryx
2195 : real(RKC) , intent(out) :: interp
2196 : type(neinext_type) , intent(in) :: method
2197 : end subroutine
2198 : #endif
2199 :
2200 : #if RK2_ENABLED
2201 : PURE module subroutine setInterpNEXT_ND1_QD0_RK2(method, crdx, func, queryx, interp)
2202 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2203 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD0_RK2
2204 : #endif
2205 : use pm_kind, only: RKC => RK2
2206 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2207 : real(RKC) , intent(in) :: queryx
2208 : real(RKC) , intent(out) :: interp
2209 : type(neinext_type) , intent(in) :: method
2210 : end subroutine
2211 : #endif
2212 :
2213 : #if RK1_ENABLED
2214 : PURE module subroutine setInterpNEXT_ND1_QD0_RK1(method, crdx, func, queryx, interp)
2215 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2216 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD0_RK1
2217 : #endif
2218 : use pm_kind, only: RKC => RK1
2219 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2220 : real(RKC) , intent(in) :: queryx
2221 : real(RKC) , intent(out) :: interp
2222 : type(neinext_type) , intent(in) :: method
2223 : end subroutine
2224 : #endif
2225 :
2226 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2227 :
2228 : #if RK5_ENABLED
2229 : PURE module subroutine setInterpNEXT_ND1_QD1_RK5(method, crdx, func, queryx, interp)
2230 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2231 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD1_RK5
2232 : #endif
2233 : use pm_kind, only: RKC => RK5
2234 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2235 : real(RKC) , intent(in) , contiguous :: queryx(:)
2236 : real(RKC) , intent(out) , contiguous :: interp(:)
2237 : type(neinext_type) , intent(in) :: method
2238 : end subroutine
2239 : #endif
2240 :
2241 : #if RK4_ENABLED
2242 : PURE module subroutine setInterpNEXT_ND1_QD1_RK4(method, crdx, func, queryx, interp)
2243 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2244 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD1_RK4
2245 : #endif
2246 : use pm_kind, only: RKC => RK4
2247 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2248 : real(RKC) , intent(in) , contiguous :: queryx(:)
2249 : real(RKC) , intent(out) , contiguous :: interp(:)
2250 : type(neinext_type) , intent(in) :: method
2251 : end subroutine
2252 : #endif
2253 :
2254 : #if RK3_ENABLED
2255 : PURE module subroutine setInterpNEXT_ND1_QD1_RK3(method, crdx, func, queryx, interp)
2256 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2257 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD1_RK3
2258 : #endif
2259 : use pm_kind, only: RKC => RK3
2260 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2261 : real(RKC) , intent(in) , contiguous :: queryx(:)
2262 : real(RKC) , intent(out) , contiguous :: interp(:)
2263 : type(neinext_type) , intent(in) :: method
2264 : end subroutine
2265 : #endif
2266 :
2267 : #if RK2_ENABLED
2268 : PURE module subroutine setInterpNEXT_ND1_QD1_RK2(method, crdx, func, queryx, interp)
2269 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2270 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD1_RK2
2271 : #endif
2272 : use pm_kind, only: RKC => RK2
2273 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2274 : real(RKC) , intent(in) , contiguous :: queryx(:)
2275 : real(RKC) , intent(out) , contiguous :: interp(:)
2276 : type(neinext_type) , intent(in) :: method
2277 : end subroutine
2278 : #endif
2279 :
2280 : #if RK1_ENABLED
2281 : PURE module subroutine setInterpNEXT_ND1_QD1_RK1(method, crdx, func, queryx, interp)
2282 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2283 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpNEXT_ND1_QD1_RK1
2284 : #endif
2285 : use pm_kind, only: RKC => RK1
2286 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2287 : real(RKC) , intent(in) , contiguous :: queryx(:)
2288 : real(RKC) , intent(out) , contiguous :: interp(:)
2289 : type(neinext_type) , intent(in) :: method
2290 : end subroutine
2291 : #endif
2292 :
2293 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2294 :
2295 : end interface
2296 :
2297 : ! neiprev
2298 :
2299 : interface setInterp
2300 :
2301 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2302 :
2303 : #if RK5_ENABLED
2304 : PURE module subroutine setInterpPREV_ND1_QD0_RK5(method, crdx, func, queryx, interp)
2305 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2306 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD0_RK5
2307 : #endif
2308 : use pm_kind, only: RKC => RK5
2309 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2310 : real(RKC) , intent(in) :: queryx
2311 : real(RKC) , intent(out) :: interp
2312 : type(neiprev_type) , intent(in) :: method
2313 : end subroutine
2314 : #endif
2315 :
2316 : #if RK4_ENABLED
2317 : PURE module subroutine setInterpPREV_ND1_QD0_RK4(method, crdx, func, queryx, interp)
2318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2319 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD0_RK4
2320 : #endif
2321 : use pm_kind, only: RKC => RK4
2322 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2323 : real(RKC) , intent(in) :: queryx
2324 : real(RKC) , intent(out) :: interp
2325 : type(neiprev_type) , intent(in) :: method
2326 : end subroutine
2327 : #endif
2328 :
2329 : #if RK3_ENABLED
2330 : PURE module subroutine setInterpPREV_ND1_QD0_RK3(method, crdx, func, queryx, interp)
2331 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2332 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD0_RK3
2333 : #endif
2334 : use pm_kind, only: RKC => RK3
2335 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2336 : real(RKC) , intent(in) :: queryx
2337 : real(RKC) , intent(out) :: interp
2338 : type(neiprev_type) , intent(in) :: method
2339 : end subroutine
2340 : #endif
2341 :
2342 : #if RK2_ENABLED
2343 : PURE module subroutine setInterpPREV_ND1_QD0_RK2(method, crdx, func, queryx, interp)
2344 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2345 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD0_RK2
2346 : #endif
2347 : use pm_kind, only: RKC => RK2
2348 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2349 : real(RKC) , intent(in) :: queryx
2350 : real(RKC) , intent(out) :: interp
2351 : type(neiprev_type) , intent(in) :: method
2352 : end subroutine
2353 : #endif
2354 :
2355 : #if RK1_ENABLED
2356 : PURE module subroutine setInterpPREV_ND1_QD0_RK1(method, crdx, func, queryx, interp)
2357 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2358 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD0_RK1
2359 : #endif
2360 : use pm_kind, only: RKC => RK1
2361 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2362 : real(RKC) , intent(in) :: queryx
2363 : real(RKC) , intent(out) :: interp
2364 : type(neiprev_type) , intent(in) :: method
2365 : end subroutine
2366 : #endif
2367 :
2368 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2369 :
2370 : #if RK5_ENABLED
2371 : PURE module subroutine setInterpPREV_ND1_QD1_RK5(method, crdx, func, queryx, interp)
2372 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2373 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD1_RK5
2374 : #endif
2375 : use pm_kind, only: RKC => RK5
2376 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2377 : real(RKC) , intent(in) , contiguous :: queryx(:)
2378 : real(RKC) , intent(out) , contiguous :: interp(:)
2379 : type(neiprev_type) , intent(in) :: method
2380 : end subroutine
2381 : #endif
2382 :
2383 : #if RK4_ENABLED
2384 : PURE module subroutine setInterpPREV_ND1_QD1_RK4(method, crdx, func, queryx, interp)
2385 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2386 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD1_RK4
2387 : #endif
2388 : use pm_kind, only: RKC => RK4
2389 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2390 : real(RKC) , intent(in) , contiguous :: queryx(:)
2391 : real(RKC) , intent(out) , contiguous :: interp(:)
2392 : type(neiprev_type) , intent(in) :: method
2393 : end subroutine
2394 : #endif
2395 :
2396 : #if RK3_ENABLED
2397 : PURE module subroutine setInterpPREV_ND1_QD1_RK3(method, crdx, func, queryx, interp)
2398 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2399 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD1_RK3
2400 : #endif
2401 : use pm_kind, only: RKC => RK3
2402 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2403 : real(RKC) , intent(in) , contiguous :: queryx(:)
2404 : real(RKC) , intent(out) , contiguous :: interp(:)
2405 : type(neiprev_type) , intent(in) :: method
2406 : end subroutine
2407 : #endif
2408 :
2409 : #if RK2_ENABLED
2410 : PURE module subroutine setInterpPREV_ND1_QD1_RK2(method, crdx, func, queryx, interp)
2411 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2412 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD1_RK2
2413 : #endif
2414 : use pm_kind, only: RKC => RK2
2415 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2416 : real(RKC) , intent(in) , contiguous :: queryx(:)
2417 : real(RKC) , intent(out) , contiguous :: interp(:)
2418 : type(neiprev_type) , intent(in) :: method
2419 : end subroutine
2420 : #endif
2421 :
2422 : #if RK1_ENABLED
2423 : PURE module subroutine setInterpPREV_ND1_QD1_RK1(method, crdx, func, queryx, interp)
2424 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2425 : !DEC$ ATTRIBUTES DLLEXPORT :: setInterpPREV_ND1_QD1_RK1
2426 : #endif
2427 : use pm_kind, only: RKC => RK1
2428 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2429 : real(RKC) , intent(in) , contiguous :: queryx(:)
2430 : real(RKC) , intent(out) , contiguous :: interp(:)
2431 : type(neiprev_type) , intent(in) :: method
2432 : end subroutine
2433 : #endif
2434 :
2435 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2436 :
2437 : end interface
2438 :
2439 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2440 :
2441 : !> \brief
2442 : !> Generate and return the approximate **polynomial interpolation/extrapolation** value of the input specified point `x` for the specified `method`.
2443 : !>
2444 : !> \details
2445 : !> For polynomial interpolation/extrapolation, the computation relies on the **Neville algorithm**.<br>
2446 : !> The extrapolation is done as if the out-of-bound query point is within the boundary (first or last)
2447 : !> interpolation segment specified by the input `(crdx, func)` pairs of values.<br>
2448 : !>
2449 : !> \param[in] method : The input scalar constant that can be,
2450 : !> <ol>
2451 : !> <li> The scalar constant [neimean](@ref pm_polation::neimean) or a scalar object of type [neimean_type](@ref pm_polation::neimean_type)
2452 : !> implying the use of the average of the `func` values of the two nearest neighbors of the input `queryx` smaller and larger than it as the output `extrap`.<br>
2453 : !> <li> The scalar constant [neinear](@ref pm_polation::neinear) or a scalar object of type [neinear_type](@ref pm_polation::neinear_type)
2454 : !> implying the use of the average of the `func` value of the `neinear` nearest neighbor of the input `queryx` as the output `extrap`.<br>
2455 : !> Note that the nearest neighbor in this case is measured by actual Euclidean distances of neighbors to the input `queryx`.<br>
2456 : !> <li> The scalar constant [neiprev](@ref pm_polation::neiprev) or a scalar object of type [neiprev_type](@ref pm_polation::neiprev_type)
2457 : !> implying the use of the `func` value of the largest abscissa in the input `crdx` smaller than the input `queryx` as the output `extrap`.<br>
2458 : !> <li> The scalar constant [neinext](@ref pm_polation::neinext) or a scalar object of type [neinext_type](@ref pm_polation::neinext_type)
2459 : !> implying the use of the `func` value of the smallest abscissa in the input `crdx` larger than the input `queryx` as the output `extrap`.<br>
2460 : !> <li> The scalar constant [piwilin](@ref pm_polation::piwilin) or a scalar object of type [piwilin_type](@ref pm_polation::piwilin_type)
2461 : !> implying the use of the **linear interpolation/extrapolation** of the `func` values of the two `crdx` points that bracket `queryx` as the output `extrap`.<br>
2462 : !> The linear interpolation/extrapolation implemented in this constructor is based on the Lagrange classical formula for linear interpolation/extrapolation.<br>
2463 : !> Suppose an input query point \f$x\f$ falls between two nodes \f$x_i\f$ and \f$x_{i+1}\f$ with the corresponding function values
2464 : !> \f$y_i\f$ and \f$y_{i+1}\f$ and we wish to estimate the corresponding interpolated/extrapolated value \f$y(x)\f$, which can be computed as,
2465 : !> \f{equation*}{
2466 : !> y(x) = \frac {x - x_{i+1}} {x_i - x_{i+1}} y_i + \frac {x - x_{i}} {x_{i+1} - x_{i}} y_{i+1} ~.
2467 : !> \f}
2468 : !> <li> The scalar constant [monopol](@ref pm_polation::monopol) or a scalar object of type [monopol_type](@ref pm_polation::monopol_type)
2469 : !> implying the use of a single **polynomial interpolation/extrapolation** of highest degree `size(crdx) - 1` possible to all pairs of `(crdx, func)` for computing the output `extrap`.<br>
2470 : !> The Neville algorithm is used to approximate the polynomial interpolation/extrapolation.<br>
2471 : !> </ol>
2472 : !> \param[in] crdx : The input `contiguous` vector of<br>
2473 : !> <ol>
2474 : !> <li> type `real` of kind \RKALL,
2475 : !> </ol>
2476 : !> containing the set of abscissa in **strictly ascending order** through which the constructed polynomial must pass.<br>
2477 : !> If needed, the input values for `crdx` and `sortedY` can be sorted in ascending order by calling either
2478 : !> [setSorted()](@ref pm_arraySort::setSorted) or [setSorted()](@ref pm_arraySort::setSorted).
2479 : !> \param[in] func : The input `contiguous` vector of the same type, kind, and size as `crdx`,
2480 : !> containing the set of function values corresponding to the input abscissa `crdx` through which the constructed polynomial must pass.
2481 : !> \param[in] queryx : The input scalar or vector of the same type and kind as `crdx`, containing the abscissa (x-value) of the queryx point.
2482 : !>
2483 : !> \return
2484 : !>
2485 : !> `extrap` : The output object of the same type, kind, rank, and shape as `queryx`,
2486 : !> containing the (approximate) interpolated/extrapolated y-value(s) corresponding to the `queryx` point(s).
2487 : !>
2488 : !> \interface{getExtrap}
2489 : !> \code{.F90}
2490 : !>
2491 : !> use pm_polation, only: getExtrap
2492 : !>
2493 : !> extrap = getExtrap(method, crdx(1:nsam), func(1:nsam), queryx)
2494 : !> extrap(1:nque) = getExtrap(method, crdx(1:nsam), func(1:nsam), queryx(1:nque))
2495 : !>
2496 : !> \endcode
2497 : !>
2498 : !> \warning
2499 : !> The condition `size(crdx) == size(func)` must hold for the corresponding input arguments.<br>
2500 : !> The condition `isAscendingAll(crdx) .or. same_type_as(method, monopol_type())` must hold for the corresponding input arguments.<br>
2501 : !> \vericons
2502 : !>
2503 : !> \warnpure
2504 : !>
2505 : !> \see
2506 : !> [getExtrap](@ref pm_polation::getExtrap)<br>
2507 : !> [setExtrap](@ref pm_polation::setExtrap)<br>
2508 : !> [getInterp](@ref pm_polation::getInterp)<br>
2509 : !> [setInterp](@ref pm_polation::setInterp)<br>
2510 : !> [pm_sampleQuan](@ref pm_sampleQuan)<br>
2511 : !> [pm_arraySort](@ref pm_arraySort)<br>
2512 : !> [pm_quadRomb](@ref pm_quadRomb)<br>
2513 : !>
2514 : !> \example{getExtrap}
2515 : !> \include{lineno} example/pm_polation/getExtrap/main.F90
2516 : !> \compilef{getExtrap}
2517 : !> \output{getExtrap}
2518 : !> \include{lineno} example/pm_polation/getExtrap/main.out.F90
2519 : !> \postproc{getExtrap}
2520 : !> \include{lineno} example/pm_polation/getExtrap/main.py
2521 : !> \vis{getExtrap}
2522 : !> \image html pm_polation/getExtrap/getExtrap.neimean.extrap.png width=700
2523 : !> \image html pm_polation/getExtrap/getExtrap.neinear.extrap.png width=700
2524 : !> \image html pm_polation/getExtrap/getExtrap.neinext.extrap.png width=700
2525 : !> \image html pm_polation/getExtrap/getExtrap.neiprev.extrap.png width=700
2526 : !> \image html pm_polation/getExtrap/getExtrap.piwilin.extrap.png width=700
2527 : !> \image html pm_polation/getExtrap/getExtrap.monopol.extrap.png width=700
2528 : !> \image html pm_polation/getExtrap/getExtrap.rungeEffect.extrap.png width=700
2529 : !>
2530 : !> \test
2531 : !> [test_pm_polation](@ref test_pm_polation)
2532 : !>
2533 : !> \finmain{getExtrap}
2534 : !>
2535 : !> \author
2536 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2537 :
2538 : ! monopol MNPLD
2539 :
2540 : interface getExtrap
2541 :
2542 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2543 :
2544 : #if RK5_ENABLED
2545 : PURE module function getExtrapMNPLD_ND1_QD0_RK5(method, crdx, func, queryx) result(extrap)
2546 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2547 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD0_RK5
2548 : #endif
2549 : use pm_kind, only: RKC => RK5
2550 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2551 : real(RKC) , intent(in) :: queryx
2552 : real(RKC) :: extrap
2553 : type(monopol_type) , intent(in) :: method
2554 : end function
2555 : #endif
2556 :
2557 : #if RK4_ENABLED
2558 : PURE module function getExtrapMNPLD_ND1_QD0_RK4(method, crdx, func, queryx) result(extrap)
2559 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2560 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD0_RK4
2561 : #endif
2562 : use pm_kind, only: RKC => RK4
2563 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2564 : real(RKC) , intent(in) :: queryx
2565 : real(RKC) :: extrap
2566 : type(monopol_type) , intent(in) :: method
2567 : end function
2568 : #endif
2569 :
2570 : #if RK3_ENABLED
2571 : PURE module function getExtrapMNPLD_ND1_QD0_RK3(method, crdx, func, queryx) result(extrap)
2572 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2573 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD0_RK3
2574 : #endif
2575 : use pm_kind, only: RKC => RK3
2576 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2577 : real(RKC) , intent(in) :: queryx
2578 : real(RKC) :: extrap
2579 : type(monopol_type) , intent(in) :: method
2580 : end function
2581 : #endif
2582 :
2583 : #if RK2_ENABLED
2584 : PURE module function getExtrapMNPLD_ND1_QD0_RK2(method, crdx, func, queryx) result(extrap)
2585 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2586 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD0_RK2
2587 : #endif
2588 : use pm_kind, only: RKC => RK2
2589 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2590 : real(RKC) , intent(in) :: queryx
2591 : real(RKC) :: extrap
2592 : type(monopol_type) , intent(in) :: method
2593 : end function
2594 : #endif
2595 :
2596 : #if RK1_ENABLED
2597 : PURE module function getExtrapMNPLD_ND1_QD0_RK1(method, crdx, func, queryx) result(extrap)
2598 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2599 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD0_RK1
2600 : #endif
2601 : use pm_kind, only: RKC => RK1
2602 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2603 : real(RKC) , intent(in) :: queryx
2604 : real(RKC) :: extrap
2605 : type(monopol_type) , intent(in) :: method
2606 : end function
2607 : #endif
2608 :
2609 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2610 :
2611 : #if RK5_ENABLED
2612 : PURE module function getExtrapMNPLD_ND1_QD1_RK5(method, crdx, func, queryx) result(extrap)
2613 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2614 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD1_RK5
2615 : #endif
2616 : use pm_kind, only: RKC => RK5
2617 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2618 : real(RKC) , intent(in) , contiguous :: queryx(:)
2619 : real(RKC) :: extrap(size(queryx, 1, IK))
2620 : type(monopol_type) , intent(in) :: method
2621 : end function
2622 : #endif
2623 :
2624 : #if RK4_ENABLED
2625 : PURE module function getExtrapMNPLD_ND1_QD1_RK4(method, crdx, func, queryx) result(extrap)
2626 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2627 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD1_RK4
2628 : #endif
2629 : use pm_kind, only: RKC => RK4
2630 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2631 : real(RKC) , intent(in) , contiguous :: queryx(:)
2632 : real(RKC) :: extrap(size(queryx, 1, IK))
2633 : type(monopol_type) , intent(in) :: method
2634 : end function
2635 : #endif
2636 :
2637 : #if RK3_ENABLED
2638 : PURE module function getExtrapMNPLD_ND1_QD1_RK3(method, crdx, func, queryx) result(extrap)
2639 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2640 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD1_RK3
2641 : #endif
2642 : use pm_kind, only: RKC => RK3
2643 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2644 : real(RKC) , intent(in) , contiguous :: queryx(:)
2645 : real(RKC) :: extrap(size(queryx, 1, IK))
2646 : type(monopol_type) , intent(in) :: method
2647 : end function
2648 : #endif
2649 :
2650 : #if RK2_ENABLED
2651 : PURE module function getExtrapMNPLD_ND1_QD1_RK2(method, crdx, func, queryx) result(extrap)
2652 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2653 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD1_RK2
2654 : #endif
2655 : use pm_kind, only: RKC => RK2
2656 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2657 : real(RKC) , intent(in) , contiguous :: queryx(:)
2658 : real(RKC) :: extrap(size(queryx, 1, IK))
2659 : type(monopol_type) , intent(in) :: method
2660 : end function
2661 : #endif
2662 :
2663 : #if RK1_ENABLED
2664 : PURE module function getExtrapMNPLD_ND1_QD1_RK1(method, crdx, func, queryx) result(extrap)
2665 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2666 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMNPLD_ND1_QD1_RK1
2667 : #endif
2668 : use pm_kind, only: RKC => RK1
2669 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2670 : real(RKC) , intent(in) , contiguous :: queryx(:)
2671 : real(RKC) :: extrap(size(queryx, 1, IK))
2672 : type(monopol_type) , intent(in) :: method
2673 : end function
2674 : #endif
2675 :
2676 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2677 :
2678 : end interface
2679 :
2680 : ! piwilin
2681 :
2682 : interface getExtrap
2683 :
2684 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2685 :
2686 : #if RK5_ENABLED
2687 : PURE module function getExtrapPWLN_ND1_QD0_RK5(method, crdx, func, queryx) result(extrap)
2688 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2689 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD0_RK5
2690 : #endif
2691 : use pm_kind, only: RKC => RK5
2692 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2693 : real(RKC) , intent(in) :: queryx
2694 : real(RKC) :: extrap
2695 : type(piwilin_type) , intent(in) :: method
2696 : end function
2697 : #endif
2698 :
2699 : #if RK4_ENABLED
2700 : PURE module function getExtrapPWLN_ND1_QD0_RK4(method, crdx, func, queryx) result(extrap)
2701 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2702 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD0_RK4
2703 : #endif
2704 : use pm_kind, only: RKC => RK4
2705 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2706 : real(RKC) , intent(in) :: queryx
2707 : real(RKC) :: extrap
2708 : type(piwilin_type) , intent(in) :: method
2709 : end function
2710 : #endif
2711 :
2712 : #if RK3_ENABLED
2713 : PURE module function getExtrapPWLN_ND1_QD0_RK3(method, crdx, func, queryx) result(extrap)
2714 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2715 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD0_RK3
2716 : #endif
2717 : use pm_kind, only: RKC => RK3
2718 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2719 : real(RKC) , intent(in) :: queryx
2720 : real(RKC) :: extrap
2721 : type(piwilin_type) , intent(in) :: method
2722 : end function
2723 : #endif
2724 :
2725 : #if RK2_ENABLED
2726 : PURE module function getExtrapPWLN_ND1_QD0_RK2(method, crdx, func, queryx) result(extrap)
2727 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2728 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD0_RK2
2729 : #endif
2730 : use pm_kind, only: RKC => RK2
2731 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2732 : real(RKC) , intent(in) :: queryx
2733 : real(RKC) :: extrap
2734 : type(piwilin_type) , intent(in) :: method
2735 : end function
2736 : #endif
2737 :
2738 : #if RK1_ENABLED
2739 : PURE module function getExtrapPWLN_ND1_QD0_RK1(method, crdx, func, queryx) result(extrap)
2740 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2741 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD0_RK1
2742 : #endif
2743 : use pm_kind, only: RKC => RK1
2744 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2745 : real(RKC) , intent(in) :: queryx
2746 : real(RKC) :: extrap
2747 : type(piwilin_type) , intent(in) :: method
2748 : end function
2749 : #endif
2750 :
2751 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2752 :
2753 : #if RK5_ENABLED
2754 : PURE module function getExtrapPWLN_ND1_QD1_RK5(method, crdx, func, queryx) result(extrap)
2755 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2756 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD1_RK5
2757 : #endif
2758 : use pm_kind, only: RKC => RK5
2759 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2760 : real(RKC) , intent(in) , contiguous :: queryx(:)
2761 : real(RKC) :: extrap(size(queryx, 1, IK))
2762 : type(piwilin_type) , intent(in) :: method
2763 : end function
2764 : #endif
2765 :
2766 : #if RK4_ENABLED
2767 : PURE module function getExtrapPWLN_ND1_QD1_RK4(method, crdx, func, queryx) result(extrap)
2768 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2769 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD1_RK4
2770 : #endif
2771 : use pm_kind, only: RKC => RK4
2772 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2773 : real(RKC) , intent(in) , contiguous :: queryx(:)
2774 : real(RKC) :: extrap(size(queryx, 1, IK))
2775 : type(piwilin_type) , intent(in) :: method
2776 : end function
2777 : #endif
2778 :
2779 : #if RK3_ENABLED
2780 : PURE module function getExtrapPWLN_ND1_QD1_RK3(method, crdx, func, queryx) result(extrap)
2781 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2782 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD1_RK3
2783 : #endif
2784 : use pm_kind, only: RKC => RK3
2785 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2786 : real(RKC) , intent(in) , contiguous :: queryx(:)
2787 : real(RKC) :: extrap(size(queryx, 1, IK))
2788 : type(piwilin_type) , intent(in) :: method
2789 : end function
2790 : #endif
2791 :
2792 : #if RK2_ENABLED
2793 : PURE module function getExtrapPWLN_ND1_QD1_RK2(method, crdx, func, queryx) result(extrap)
2794 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2795 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD1_RK2
2796 : #endif
2797 : use pm_kind, only: RKC => RK2
2798 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2799 : real(RKC) , intent(in) , contiguous :: queryx(:)
2800 : real(RKC) :: extrap(size(queryx, 1, IK))
2801 : type(piwilin_type) , intent(in) :: method
2802 : end function
2803 : #endif
2804 :
2805 : #if RK1_ENABLED
2806 : PURE module function getExtrapPWLN_ND1_QD1_RK1(method, crdx, func, queryx) result(extrap)
2807 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2808 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPWLN_ND1_QD1_RK1
2809 : #endif
2810 : use pm_kind, only: RKC => RK1
2811 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2812 : real(RKC) , intent(in) , contiguous :: queryx(:)
2813 : real(RKC) :: extrap(size(queryx, 1, IK))
2814 : type(piwilin_type) , intent(in) :: method
2815 : end function
2816 : #endif
2817 :
2818 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2819 :
2820 : end interface
2821 :
2822 : ! neimean
2823 :
2824 : interface getExtrap
2825 :
2826 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2827 :
2828 : #if RK5_ENABLED
2829 : PURE module function getExtrapMEAN_ND1_QD0_RK5(method, crdx, func, queryx) result(extrap)
2830 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2831 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD0_RK5
2832 : #endif
2833 : use pm_kind, only: RKC => RK5
2834 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2835 : real(RKC) , intent(in) :: queryx
2836 : real(RKC) :: extrap
2837 : type(neimean_type) , intent(in) :: method
2838 : end function
2839 : #endif
2840 :
2841 : #if RK4_ENABLED
2842 : PURE module function getExtrapMEAN_ND1_QD0_RK4(method, crdx, func, queryx) result(extrap)
2843 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2844 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD0_RK4
2845 : #endif
2846 : use pm_kind, only: RKC => RK4
2847 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2848 : real(RKC) , intent(in) :: queryx
2849 : real(RKC) :: extrap
2850 : type(neimean_type) , intent(in) :: method
2851 : end function
2852 : #endif
2853 :
2854 : #if RK3_ENABLED
2855 : PURE module function getExtrapMEAN_ND1_QD0_RK3(method, crdx, func, queryx) result(extrap)
2856 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2857 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD0_RK3
2858 : #endif
2859 : use pm_kind, only: RKC => RK3
2860 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2861 : real(RKC) , intent(in) :: queryx
2862 : real(RKC) :: extrap
2863 : type(neimean_type) , intent(in) :: method
2864 : end function
2865 : #endif
2866 :
2867 : #if RK2_ENABLED
2868 : PURE module function getExtrapMEAN_ND1_QD0_RK2(method, crdx, func, queryx) result(extrap)
2869 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2870 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD0_RK2
2871 : #endif
2872 : use pm_kind, only: RKC => RK2
2873 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2874 : real(RKC) , intent(in) :: queryx
2875 : real(RKC) :: extrap
2876 : type(neimean_type) , intent(in) :: method
2877 : end function
2878 : #endif
2879 :
2880 : #if RK1_ENABLED
2881 : PURE module function getExtrapMEAN_ND1_QD0_RK1(method, crdx, func, queryx) result(extrap)
2882 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2883 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD0_RK1
2884 : #endif
2885 : use pm_kind, only: RKC => RK1
2886 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2887 : real(RKC) , intent(in) :: queryx
2888 : real(RKC) :: extrap
2889 : type(neimean_type) , intent(in) :: method
2890 : end function
2891 : #endif
2892 :
2893 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2894 :
2895 : #if RK5_ENABLED
2896 : PURE module function getExtrapMEAN_ND1_QD1_RK5(method, crdx, func, queryx) result(extrap)
2897 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2898 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD1_RK5
2899 : #endif
2900 : use pm_kind, only: RKC => RK5
2901 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2902 : real(RKC) , intent(in) , contiguous :: queryx(:)
2903 : real(RKC) :: extrap(size(queryx, 1, IK))
2904 : type(neimean_type) , intent(in) :: method
2905 : end function
2906 : #endif
2907 :
2908 : #if RK4_ENABLED
2909 : PURE module function getExtrapMEAN_ND1_QD1_RK4(method, crdx, func, queryx) result(extrap)
2910 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2911 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD1_RK4
2912 : #endif
2913 : use pm_kind, only: RKC => RK4
2914 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2915 : real(RKC) , intent(in) , contiguous :: queryx(:)
2916 : real(RKC) :: extrap(size(queryx, 1, IK))
2917 : type(neimean_type) , intent(in) :: method
2918 : end function
2919 : #endif
2920 :
2921 : #if RK3_ENABLED
2922 : PURE module function getExtrapMEAN_ND1_QD1_RK3(method, crdx, func, queryx) result(extrap)
2923 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2924 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD1_RK3
2925 : #endif
2926 : use pm_kind, only: RKC => RK3
2927 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2928 : real(RKC) , intent(in) , contiguous :: queryx(:)
2929 : real(RKC) :: extrap(size(queryx, 1, IK))
2930 : type(neimean_type) , intent(in) :: method
2931 : end function
2932 : #endif
2933 :
2934 : #if RK2_ENABLED
2935 : PURE module function getExtrapMEAN_ND1_QD1_RK2(method, crdx, func, queryx) result(extrap)
2936 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2937 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD1_RK2
2938 : #endif
2939 : use pm_kind, only: RKC => RK2
2940 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2941 : real(RKC) , intent(in) , contiguous :: queryx(:)
2942 : real(RKC) :: extrap(size(queryx, 1, IK))
2943 : type(neimean_type) , intent(in) :: method
2944 : end function
2945 : #endif
2946 :
2947 : #if RK1_ENABLED
2948 : PURE module function getExtrapMEAN_ND1_QD1_RK1(method, crdx, func, queryx) result(extrap)
2949 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2950 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapMEAN_ND1_QD1_RK1
2951 : #endif
2952 : use pm_kind, only: RKC => RK1
2953 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2954 : real(RKC) , intent(in) , contiguous :: queryx(:)
2955 : real(RKC) :: extrap(size(queryx, 1, IK))
2956 : type(neimean_type) , intent(in) :: method
2957 : end function
2958 : #endif
2959 :
2960 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2961 :
2962 : end interface
2963 :
2964 : ! neinear
2965 :
2966 : interface getExtrap
2967 :
2968 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2969 :
2970 : #if RK5_ENABLED
2971 : PURE module function getExtrapNEAR_ND1_QD0_RK5(method, crdx, func, queryx) result(extrap)
2972 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2973 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD0_RK5
2974 : #endif
2975 : use pm_kind, only: RKC => RK5
2976 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2977 : real(RKC) , intent(in) :: queryx
2978 : real(RKC) :: extrap
2979 : type(neinear_type) , intent(in) :: method
2980 : end function
2981 : #endif
2982 :
2983 : #if RK4_ENABLED
2984 : PURE module function getExtrapNEAR_ND1_QD0_RK4(method, crdx, func, queryx) result(extrap)
2985 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2986 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD0_RK4
2987 : #endif
2988 : use pm_kind, only: RKC => RK4
2989 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
2990 : real(RKC) , intent(in) :: queryx
2991 : real(RKC) :: extrap
2992 : type(neinear_type) , intent(in) :: method
2993 : end function
2994 : #endif
2995 :
2996 : #if RK3_ENABLED
2997 : PURE module function getExtrapNEAR_ND1_QD0_RK3(method, crdx, func, queryx) result(extrap)
2998 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2999 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD0_RK3
3000 : #endif
3001 : use pm_kind, only: RKC => RK3
3002 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3003 : real(RKC) , intent(in) :: queryx
3004 : real(RKC) :: extrap
3005 : type(neinear_type) , intent(in) :: method
3006 : end function
3007 : #endif
3008 :
3009 : #if RK2_ENABLED
3010 : PURE module function getExtrapNEAR_ND1_QD0_RK2(method, crdx, func, queryx) result(extrap)
3011 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3012 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD0_RK2
3013 : #endif
3014 : use pm_kind, only: RKC => RK2
3015 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3016 : real(RKC) , intent(in) :: queryx
3017 : real(RKC) :: extrap
3018 : type(neinear_type) , intent(in) :: method
3019 : end function
3020 : #endif
3021 :
3022 : #if RK1_ENABLED
3023 : PURE module function getExtrapNEAR_ND1_QD0_RK1(method, crdx, func, queryx) result(extrap)
3024 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3025 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD0_RK1
3026 : #endif
3027 : use pm_kind, only: RKC => RK1
3028 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3029 : real(RKC) , intent(in) :: queryx
3030 : real(RKC) :: extrap
3031 : type(neinear_type) , intent(in) :: method
3032 : end function
3033 : #endif
3034 :
3035 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3036 :
3037 : #if RK5_ENABLED
3038 : PURE module function getExtrapNEAR_ND1_QD1_RK5(method, crdx, func, queryx) result(extrap)
3039 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3040 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD1_RK5
3041 : #endif
3042 : use pm_kind, only: RKC => RK5
3043 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3044 : real(RKC) , intent(in) , contiguous :: queryx(:)
3045 : real(RKC) :: extrap(size(queryx, 1, IK))
3046 : type(neinear_type) , intent(in) :: method
3047 : end function
3048 : #endif
3049 :
3050 : #if RK4_ENABLED
3051 : PURE module function getExtrapNEAR_ND1_QD1_RK4(method, crdx, func, queryx) result(extrap)
3052 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3053 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD1_RK4
3054 : #endif
3055 : use pm_kind, only: RKC => RK4
3056 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3057 : real(RKC) , intent(in) , contiguous :: queryx(:)
3058 : real(RKC) :: extrap(size(queryx, 1, IK))
3059 : type(neinear_type) , intent(in) :: method
3060 : end function
3061 : #endif
3062 :
3063 : #if RK3_ENABLED
3064 : PURE module function getExtrapNEAR_ND1_QD1_RK3(method, crdx, func, queryx) result(extrap)
3065 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3066 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD1_RK3
3067 : #endif
3068 : use pm_kind, only: RKC => RK3
3069 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3070 : real(RKC) , intent(in) , contiguous :: queryx(:)
3071 : real(RKC) :: extrap(size(queryx, 1, IK))
3072 : type(neinear_type) , intent(in) :: method
3073 : end function
3074 : #endif
3075 :
3076 : #if RK2_ENABLED
3077 : PURE module function getExtrapNEAR_ND1_QD1_RK2(method, crdx, func, queryx) result(extrap)
3078 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3079 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD1_RK2
3080 : #endif
3081 : use pm_kind, only: RKC => RK2
3082 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3083 : real(RKC) , intent(in) , contiguous :: queryx(:)
3084 : real(RKC) :: extrap(size(queryx, 1, IK))
3085 : type(neinear_type) , intent(in) :: method
3086 : end function
3087 : #endif
3088 :
3089 : #if RK1_ENABLED
3090 : PURE module function getExtrapNEAR_ND1_QD1_RK1(method, crdx, func, queryx) result(extrap)
3091 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3092 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEAR_ND1_QD1_RK1
3093 : #endif
3094 : use pm_kind, only: RKC => RK1
3095 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3096 : real(RKC) , intent(in) , contiguous :: queryx(:)
3097 : real(RKC) :: extrap(size(queryx, 1, IK))
3098 : type(neinear_type) , intent(in) :: method
3099 : end function
3100 : #endif
3101 :
3102 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3103 :
3104 : end interface
3105 :
3106 : ! neinext
3107 :
3108 : interface getExtrap
3109 :
3110 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3111 :
3112 : #if RK5_ENABLED
3113 : PURE module function getExtrapNEXT_ND1_QD0_RK5(method, crdx, func, queryx) result(extrap)
3114 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3115 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD0_RK5
3116 : #endif
3117 : use pm_kind, only: RKC => RK5
3118 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3119 : real(RKC) , intent(in) :: queryx
3120 : real(RKC) :: extrap
3121 : type(neinext_type) , intent(in) :: method
3122 : end function
3123 : #endif
3124 :
3125 : #if RK4_ENABLED
3126 : PURE module function getExtrapNEXT_ND1_QD0_RK4(method, crdx, func, queryx) result(extrap)
3127 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3128 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD0_RK4
3129 : #endif
3130 : use pm_kind, only: RKC => RK4
3131 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3132 : real(RKC) , intent(in) :: queryx
3133 : real(RKC) :: extrap
3134 : type(neinext_type) , intent(in) :: method
3135 : end function
3136 : #endif
3137 :
3138 : #if RK3_ENABLED
3139 : PURE module function getExtrapNEXT_ND1_QD0_RK3(method, crdx, func, queryx) result(extrap)
3140 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3141 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD0_RK3
3142 : #endif
3143 : use pm_kind, only: RKC => RK3
3144 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3145 : real(RKC) , intent(in) :: queryx
3146 : real(RKC) :: extrap
3147 : type(neinext_type) , intent(in) :: method
3148 : end function
3149 : #endif
3150 :
3151 : #if RK2_ENABLED
3152 : PURE module function getExtrapNEXT_ND1_QD0_RK2(method, crdx, func, queryx) result(extrap)
3153 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3154 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD0_RK2
3155 : #endif
3156 : use pm_kind, only: RKC => RK2
3157 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3158 : real(RKC) , intent(in) :: queryx
3159 : real(RKC) :: extrap
3160 : type(neinext_type) , intent(in) :: method
3161 : end function
3162 : #endif
3163 :
3164 : #if RK1_ENABLED
3165 : PURE module function getExtrapNEXT_ND1_QD0_RK1(method, crdx, func, queryx) result(extrap)
3166 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3167 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD0_RK1
3168 : #endif
3169 : use pm_kind, only: RKC => RK1
3170 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3171 : real(RKC) , intent(in) :: queryx
3172 : real(RKC) :: extrap
3173 : type(neinext_type) , intent(in) :: method
3174 : end function
3175 : #endif
3176 :
3177 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3178 :
3179 : #if RK5_ENABLED
3180 : PURE module function getExtrapNEXT_ND1_QD1_RK5(method, crdx, func, queryx) result(extrap)
3181 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3182 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD1_RK5
3183 : #endif
3184 : use pm_kind, only: RKC => RK5
3185 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3186 : real(RKC) , intent(in) , contiguous :: queryx(:)
3187 : real(RKC) :: extrap(size(queryx, 1, IK))
3188 : type(neinext_type) , intent(in) :: method
3189 : end function
3190 : #endif
3191 :
3192 : #if RK4_ENABLED
3193 : PURE module function getExtrapNEXT_ND1_QD1_RK4(method, crdx, func, queryx) result(extrap)
3194 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3195 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD1_RK4
3196 : #endif
3197 : use pm_kind, only: RKC => RK4
3198 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3199 : real(RKC) , intent(in) , contiguous :: queryx(:)
3200 : real(RKC) :: extrap(size(queryx, 1, IK))
3201 : type(neinext_type) , intent(in) :: method
3202 : end function
3203 : #endif
3204 :
3205 : #if RK3_ENABLED
3206 : PURE module function getExtrapNEXT_ND1_QD1_RK3(method, crdx, func, queryx) result(extrap)
3207 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3208 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD1_RK3
3209 : #endif
3210 : use pm_kind, only: RKC => RK3
3211 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3212 : real(RKC) , intent(in) , contiguous :: queryx(:)
3213 : real(RKC) :: extrap(size(queryx, 1, IK))
3214 : type(neinext_type) , intent(in) :: method
3215 : end function
3216 : #endif
3217 :
3218 : #if RK2_ENABLED
3219 : PURE module function getExtrapNEXT_ND1_QD1_RK2(method, crdx, func, queryx) result(extrap)
3220 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3221 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD1_RK2
3222 : #endif
3223 : use pm_kind, only: RKC => RK2
3224 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3225 : real(RKC) , intent(in) , contiguous :: queryx(:)
3226 : real(RKC) :: extrap(size(queryx, 1, IK))
3227 : type(neinext_type) , intent(in) :: method
3228 : end function
3229 : #endif
3230 :
3231 : #if RK1_ENABLED
3232 : PURE module function getExtrapNEXT_ND1_QD1_RK1(method, crdx, func, queryx) result(extrap)
3233 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3234 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapNEXT_ND1_QD1_RK1
3235 : #endif
3236 : use pm_kind, only: RKC => RK1
3237 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3238 : real(RKC) , intent(in) , contiguous :: queryx(:)
3239 : real(RKC) :: extrap(size(queryx, 1, IK))
3240 : type(neinext_type) , intent(in) :: method
3241 : end function
3242 : #endif
3243 :
3244 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3245 :
3246 : end interface
3247 :
3248 : ! neiprev
3249 :
3250 : interface getExtrap
3251 :
3252 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3253 :
3254 : #if RK5_ENABLED
3255 : PURE module function getExtrapPREV_ND1_QD0_RK5(method, crdx, func, queryx) result(extrap)
3256 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3257 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD0_RK5
3258 : #endif
3259 : use pm_kind, only: RKC => RK5
3260 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3261 : real(RKC) , intent(in) :: queryx
3262 : real(RKC) :: extrap
3263 : type(neiprev_type) , intent(in) :: method
3264 : end function
3265 : #endif
3266 :
3267 : #if RK4_ENABLED
3268 : PURE module function getExtrapPREV_ND1_QD0_RK4(method, crdx, func, queryx) result(extrap)
3269 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3270 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD0_RK4
3271 : #endif
3272 : use pm_kind, only: RKC => RK4
3273 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3274 : real(RKC) , intent(in) :: queryx
3275 : real(RKC) :: extrap
3276 : type(neiprev_type) , intent(in) :: method
3277 : end function
3278 : #endif
3279 :
3280 : #if RK3_ENABLED
3281 : PURE module function getExtrapPREV_ND1_QD0_RK3(method, crdx, func, queryx) result(extrap)
3282 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3283 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD0_RK3
3284 : #endif
3285 : use pm_kind, only: RKC => RK3
3286 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3287 : real(RKC) , intent(in) :: queryx
3288 : real(RKC) :: extrap
3289 : type(neiprev_type) , intent(in) :: method
3290 : end function
3291 : #endif
3292 :
3293 : #if RK2_ENABLED
3294 : PURE module function getExtrapPREV_ND1_QD0_RK2(method, crdx, func, queryx) result(extrap)
3295 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3296 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD0_RK2
3297 : #endif
3298 : use pm_kind, only: RKC => RK2
3299 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3300 : real(RKC) , intent(in) :: queryx
3301 : real(RKC) :: extrap
3302 : type(neiprev_type) , intent(in) :: method
3303 : end function
3304 : #endif
3305 :
3306 : #if RK1_ENABLED
3307 : PURE module function getExtrapPREV_ND1_QD0_RK1(method, crdx, func, queryx) result(extrap)
3308 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3309 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD0_RK1
3310 : #endif
3311 : use pm_kind, only: RKC => RK1
3312 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3313 : real(RKC) , intent(in) :: queryx
3314 : real(RKC) :: extrap
3315 : type(neiprev_type) , intent(in) :: method
3316 : end function
3317 : #endif
3318 :
3319 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3320 :
3321 : #if RK5_ENABLED
3322 : PURE module function getExtrapPREV_ND1_QD1_RK5(method, crdx, func, queryx) result(extrap)
3323 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3324 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD1_RK5
3325 : #endif
3326 : use pm_kind, only: RKC => RK5
3327 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3328 : real(RKC) , intent(in) , contiguous :: queryx(:)
3329 : real(RKC) :: extrap(size(queryx, 1, IK))
3330 : type(neiprev_type) , intent(in) :: method
3331 : end function
3332 : #endif
3333 :
3334 : #if RK4_ENABLED
3335 : PURE module function getExtrapPREV_ND1_QD1_RK4(method, crdx, func, queryx) result(extrap)
3336 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3337 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD1_RK4
3338 : #endif
3339 : use pm_kind, only: RKC => RK4
3340 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3341 : real(RKC) , intent(in) , contiguous :: queryx(:)
3342 : real(RKC) :: extrap(size(queryx, 1, IK))
3343 : type(neiprev_type) , intent(in) :: method
3344 : end function
3345 : #endif
3346 :
3347 : #if RK3_ENABLED
3348 : PURE module function getExtrapPREV_ND1_QD1_RK3(method, crdx, func, queryx) result(extrap)
3349 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3350 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD1_RK3
3351 : #endif
3352 : use pm_kind, only: RKC => RK3
3353 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3354 : real(RKC) , intent(in) , contiguous :: queryx(:)
3355 : real(RKC) :: extrap(size(queryx, 1, IK))
3356 : type(neiprev_type) , intent(in) :: method
3357 : end function
3358 : #endif
3359 :
3360 : #if RK2_ENABLED
3361 : PURE module function getExtrapPREV_ND1_QD1_RK2(method, crdx, func, queryx) result(extrap)
3362 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3363 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD1_RK2
3364 : #endif
3365 : use pm_kind, only: RKC => RK2
3366 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3367 : real(RKC) , intent(in) , contiguous :: queryx(:)
3368 : real(RKC) :: extrap(size(queryx, 1, IK))
3369 : type(neiprev_type) , intent(in) :: method
3370 : end function
3371 : #endif
3372 :
3373 : #if RK1_ENABLED
3374 : PURE module function getExtrapPREV_ND1_QD1_RK1(method, crdx, func, queryx) result(extrap)
3375 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3376 : !DEC$ ATTRIBUTES DLLEXPORT :: getExtrapPREV_ND1_QD1_RK1
3377 : #endif
3378 : use pm_kind, only: RKC => RK1
3379 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3380 : real(RKC) , intent(in) , contiguous :: queryx(:)
3381 : real(RKC) :: extrap(size(queryx, 1, IK))
3382 : type(neiprev_type) , intent(in) :: method
3383 : end function
3384 : #endif
3385 :
3386 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3387 :
3388 : end interface
3389 :
3390 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3391 :
3392 : !> \brief
3393 : !> Generate and return the approximate **polynomial interpolation/extrapolation** value of the input specified point `x` for the specified `method`.
3394 : !>
3395 : !> \details
3396 : !> For polynomial interpolation/extrapolation, the computation relies on the **Neville algorithm**.<br>
3397 : !> The extrapolation is done as if the out-of-bound query point is within the boundary (first or last)
3398 : !> interpolation segment specified by the input `(crdx, func)` pairs of values.<br>
3399 : !>
3400 : !> \param[in] method : The input scalar constant that can be,
3401 : !> <ol>
3402 : !> <li> The scalar constant [neimean](@ref pm_polation::neimean) or a scalar object of type [neimean_type](@ref pm_polation::neimean_type)
3403 : !> implying the use of the average of the `func` values of the two nearest neighbors of the input `queryx` smaller and larger than it as the output `extrap`.<br>
3404 : !> <li> The scalar constant [neinear](@ref pm_polation::neinear) or a scalar object of type [neinear_type](@ref pm_polation::neinear_type)
3405 : !> implying the use of the average of the `func` value of the `neinear` nearest neighbor of the input `queryx` as the output `extrap`.<br>
3406 : !> Note that the nearest neighbor in this case is measured by actual Euclidean distances of neighbors to the input `queryx`.<br>
3407 : !> <li> The scalar constant [neiprev](@ref pm_polation::neiprev) or a scalar object of type [neiprev_type](@ref pm_polation::neiprev_type)
3408 : !> implying the use of the `func` value of the largest abscissa in the input `crdx` smaller than the input `queryx` as the output `extrap`.<br>
3409 : !> <li> The scalar constant [neinext](@ref pm_polation::neinext) or a scalar object of type [neinext_type](@ref pm_polation::neinext_type)
3410 : !> implying the use of the `func` value of the smallest abscissa in the input `crdx` larger than the input `queryx` as the output `extrap`.<br>
3411 : !> <li> The scalar constant [piwilin](@ref pm_polation::piwilin) or a scalar object of type [piwilin_type](@ref pm_polation::piwilin_type)
3412 : !> implying the use of the **linear interpolation/extrapolation** of the `func` values of the two `crdx` points that bracket `queryx` as the output `extrap`.<br>
3413 : !> The linear interpolation/extrapolation implemented in this constructor is based on the Lagrange classical formula for linear interpolation/extrapolation.<br>
3414 : !> Suppose an input query point \f$x\f$ falls between two nodes \f$x_i\f$ and \f$x_{i+1}\f$ with the corresponding function values
3415 : !> \f$y_i\f$ and \f$y_{i+1}\f$ and we wish to estimate the corresponding interpolated/extrapolated value \f$y(x)\f$, which can be computed as,
3416 : !> \f{equation*}{
3417 : !> y(x) = \frac {x - x_{i+1}} {x_i - x_{i+1}} y_i + \frac {x - x_{i}} {x_{i+1} - x_{i}} y_{i+1} ~.
3418 : !> \f}
3419 : !> <li> The scalar constant [monopol](@ref pm_polation::monopol) or a scalar object of type [monopol_type](@ref pm_polation::monopol_type)
3420 : !> implying the use of a single **polynomial interpolation/extrapolation** of highest degree `size(crdx) - 1` possible to all pairs of `(crdx, func)` for computing the output `extrap`.<br>
3421 : !> The Neville algorithm is used to approximate the polynomial interpolation/extrapolation.<br>
3422 : !> </ol>
3423 : !> \param[in] crdx : The input `contiguous` vector of<br>
3424 : !> <ol>
3425 : !> <li> type `real` of kind \RKALL,
3426 : !> </ol>
3427 : !> containing the set of abscissa in **strictly ascending order** through which the constructed polynomial must pass.<br>
3428 : !> If needed, the input values for `crdx` and `sortedY` can be sorted in ascending order by calling either
3429 : !> [setSorted()](@ref pm_arraySort::setSorted) or [setSorted()](@ref pm_arraySort::setSorted).
3430 : !> \param[in] func : The input `contiguous` vector of the same type, kind, and size as `crdx`,
3431 : !> containing the set of function values corresponding to the input abscissa `crdx` through which the constructed polynomial must pass.
3432 : !> \param[in] queryx : The input scalar or vector of the same type and kind as `crdx`, containing the abscissa (x-value) of the queryx point.
3433 : !> \param[out] extrap : The output object of the same type, kind, rank, and shape as `queryx`,
3434 : !> containing the (approximate) interpolated/extrapolated y-value(s) corresponding to the `queryx` point(s).
3435 : !> \param[out] relerr : The output scalar of the same type and kind as `crdx`, containing the estimated error in the output `extrap`.
3436 : !> (**optional**. It can be present **if and only** the input argument `method` is set to
3437 : !> [monopol](@ref pm_polation::monopol) or a scalar object of type [monopol_type](@ref pm_polation::monopol_type) .)
3438 : !>
3439 : !> \interface{setExtrap}
3440 : !> \code{.F90}
3441 : !>
3442 : !> use pm_polation, only: setExtrap
3443 : !>
3444 : !> call setExtrap(method, crdx(1:nsam), func(1:nsam), queryx, extrap)
3445 : !> call setExtrap(method, crdx(1:nsam), func(1:nsam), queryx(1:nque), extrap(1:nque))
3446 : !>
3447 : !> call setExtrap(method, crdx(1:nsam), func(1:nsam), queryx, extrap, relerr) ! method = monopol
3448 : !> call setExtrap(method, crdx(1:nsam), func(1:nsam), queryx(1:nque), extrap(1:nque), relerr(1:nque)) ! method = monopol
3449 : !>
3450 : !> \endcode
3451 : !>
3452 : !> \warning
3453 : !> The condition `size(crdx) == size(func)` must hold for the corresponding input arguments.<br>
3454 : !> The condition `all(shape(queryx) == shape(extrap))` must hold for the corresponding input arguments.<br>
3455 : !> The condition `all(shape(queryx) == shape(relerr))` must hold for the corresponding input arguments.<br>
3456 : !> The condition `isAscendingAll(crdx) .or. same_type_as(method, monopol_type())` must hold for the corresponding input arguments.<br>
3457 : !> \vericons
3458 : !>
3459 : !> \warnpure
3460 : !>
3461 : !> \see
3462 : !> [getExtrap](@ref pm_polation::getExtrap)<br>
3463 : !> [setExtrap](@ref pm_polation::setExtrap)<br>
3464 : !> [getInterp](@ref pm_polation::getInterp)<br>
3465 : !> [setInterp](@ref pm_polation::setInterp)<br>
3466 : !> [pm_sampleQuan](@ref pm_sampleQuan)<br>
3467 : !> [pm_arraySort](@ref pm_arraySort)<br>
3468 : !> [pm_quadRomb](@ref pm_quadRomb)<br>
3469 : !>
3470 : !> \example{setExtrap}
3471 : !> \include{lineno} example/pm_polation/setExtrap/main.F90
3472 : !> \compilef{setExtrap}
3473 : !> \output{setExtrap}
3474 : !> \include{lineno} example/pm_polation/setExtrap/main.out.F90
3475 : !> \postproc{setExtrap}
3476 : !> \include{lineno} example/pm_polation/setExtrap/main.py
3477 : !> \vis{setExtrap}
3478 : !> \image html pm_polation/setExtrap/setExtrap.neimean.extrap.png width=700
3479 : !> \image html pm_polation/setExtrap/setExtrap.neinear.extrap.png width=700
3480 : !> \image html pm_polation/setExtrap/setExtrap.neinext.extrap.png width=700
3481 : !> \image html pm_polation/setExtrap/setExtrap.neiprev.extrap.png width=700
3482 : !> \image html pm_polation/setExtrap/setExtrap.piwilin.extrap.png width=700
3483 : !> \image html pm_polation/setExtrap/setExtrap.monopol.extrap.png width=700
3484 : !> \image html pm_polation/setExtrap/setExtrap.rungeEffect.extrap.png width=700
3485 : !>
3486 : !> \test
3487 : !> [test_pm_polation](@ref test_pm_polation)
3488 : !>
3489 : !> \finmain{setExtrap}
3490 : !>
3491 : !> \author
3492 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3493 :
3494 : ! monopol MNPLD
3495 :
3496 : interface setExtrap
3497 :
3498 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3499 :
3500 : #if RK5_ENABLED
3501 : PURE module subroutine setExtrapMNPLD_ND1_QD0_RK5(method, crdx, func, queryx, extrap)
3502 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3503 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD0_RK5
3504 : #endif
3505 : use pm_kind, only: RKC => RK5
3506 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3507 : real(RKC) , intent(in) :: queryx
3508 : real(RKC) , intent(out) :: extrap
3509 : type(monopol_type) , intent(in) :: method
3510 : end subroutine
3511 : #endif
3512 :
3513 : #if RK4_ENABLED
3514 : PURE module subroutine setExtrapMNPLD_ND1_QD0_RK4(method, crdx, func, queryx, extrap)
3515 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3516 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD0_RK4
3517 : #endif
3518 : use pm_kind, only: RKC => RK4
3519 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3520 : real(RKC) , intent(in) :: queryx
3521 : real(RKC) , intent(out) :: extrap
3522 : type(monopol_type) , intent(in) :: method
3523 : end subroutine
3524 : #endif
3525 :
3526 : #if RK3_ENABLED
3527 : PURE module subroutine setExtrapMNPLD_ND1_QD0_RK3(method, crdx, func, queryx, extrap)
3528 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3529 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD0_RK3
3530 : #endif
3531 : use pm_kind, only: RKC => RK3
3532 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3533 : real(RKC) , intent(in) :: queryx
3534 : real(RKC) , intent(out) :: extrap
3535 : type(monopol_type) , intent(in) :: method
3536 : end subroutine
3537 : #endif
3538 :
3539 : #if RK2_ENABLED
3540 : PURE module subroutine setExtrapMNPLD_ND1_QD0_RK2(method, crdx, func, queryx, extrap)
3541 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3542 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD0_RK2
3543 : #endif
3544 : use pm_kind, only: RKC => RK2
3545 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3546 : real(RKC) , intent(in) :: queryx
3547 : real(RKC) , intent(out) :: extrap
3548 : type(monopol_type) , intent(in) :: method
3549 : end subroutine
3550 : #endif
3551 :
3552 : #if RK1_ENABLED
3553 : PURE module subroutine setExtrapMNPLD_ND1_QD0_RK1(method, crdx, func, queryx, extrap)
3554 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3555 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD0_RK1
3556 : #endif
3557 : use pm_kind, only: RKC => RK1
3558 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3559 : real(RKC) , intent(in) :: queryx
3560 : real(RKC) , intent(out) :: extrap
3561 : type(monopol_type) , intent(in) :: method
3562 : end subroutine
3563 : #endif
3564 :
3565 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3566 :
3567 : #if RK5_ENABLED
3568 : PURE module subroutine setExtrapMNPLD_ND1_QD1_RK5(method, crdx, func, queryx, extrap)
3569 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3570 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD1_RK5
3571 : #endif
3572 : use pm_kind, only: RKC => RK5
3573 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3574 : real(RKC) , intent(in) , contiguous :: queryx(:)
3575 : real(RKC) , intent(out) , contiguous :: extrap(:)
3576 : type(monopol_type) , intent(in) :: method
3577 : end subroutine
3578 : #endif
3579 :
3580 : #if RK4_ENABLED
3581 : PURE module subroutine setExtrapMNPLD_ND1_QD1_RK4(method, crdx, func, queryx, extrap)
3582 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3583 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD1_RK4
3584 : #endif
3585 : use pm_kind, only: RKC => RK4
3586 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3587 : real(RKC) , intent(in) , contiguous :: queryx(:)
3588 : real(RKC) , intent(out) , contiguous :: extrap(:)
3589 : type(monopol_type) , intent(in) :: method
3590 : end subroutine
3591 : #endif
3592 :
3593 : #if RK3_ENABLED
3594 : PURE module subroutine setExtrapMNPLD_ND1_QD1_RK3(method, crdx, func, queryx, extrap)
3595 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3596 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD1_RK3
3597 : #endif
3598 : use pm_kind, only: RKC => RK3
3599 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3600 : real(RKC) , intent(in) , contiguous :: queryx(:)
3601 : real(RKC) , intent(out) , contiguous :: extrap(:)
3602 : type(monopol_type) , intent(in) :: method
3603 : end subroutine
3604 : #endif
3605 :
3606 : #if RK2_ENABLED
3607 : PURE module subroutine setExtrapMNPLD_ND1_QD1_RK2(method, crdx, func, queryx, extrap)
3608 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3609 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD1_RK2
3610 : #endif
3611 : use pm_kind, only: RKC => RK2
3612 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3613 : real(RKC) , intent(in) , contiguous :: queryx(:)
3614 : real(RKC) , intent(out) , contiguous :: extrap(:)
3615 : type(monopol_type) , intent(in) :: method
3616 : end subroutine
3617 : #endif
3618 :
3619 : #if RK1_ENABLED
3620 : PURE module subroutine setExtrapMNPLD_ND1_QD1_RK1(method, crdx, func, queryx, extrap)
3621 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3622 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLD_ND1_QD1_RK1
3623 : #endif
3624 : use pm_kind, only: RKC => RK1
3625 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3626 : real(RKC) , intent(in) , contiguous :: queryx(:)
3627 : real(RKC) , intent(out) , contiguous :: extrap(:)
3628 : type(monopol_type) , intent(in) :: method
3629 : end subroutine
3630 : #endif
3631 :
3632 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3633 :
3634 : end interface
3635 :
3636 : ! monopol MNPLE
3637 :
3638 : interface setExtrap
3639 :
3640 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3641 :
3642 : #if RK5_ENABLED
3643 : PURE module subroutine setExtrapMNPLE_ND1_QD0_RK5(method, crdx, func, queryx, extrap, relerr)
3644 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3645 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD0_RK5
3646 : #endif
3647 : use pm_kind, only: RKC => RK5
3648 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3649 : real(RKC) , intent(in) :: queryx
3650 : real(RKC) , intent(out) :: extrap, relerr
3651 : type(monopol_type) , intent(in) :: method
3652 : end subroutine
3653 : #endif
3654 :
3655 : #if RK4_ENABLED
3656 : PURE module subroutine setExtrapMNPLE_ND1_QD0_RK4(method, crdx, func, queryx, extrap, relerr)
3657 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3658 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD0_RK4
3659 : #endif
3660 : use pm_kind, only: RKC => RK4
3661 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3662 : real(RKC) , intent(in) :: queryx
3663 : real(RKC) , intent(out) :: extrap, relerr
3664 : type(monopol_type) , intent(in) :: method
3665 : end subroutine
3666 : #endif
3667 :
3668 : #if RK3_ENABLED
3669 : PURE module subroutine setExtrapMNPLE_ND1_QD0_RK3(method, crdx, func, queryx, extrap, relerr)
3670 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3671 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD0_RK3
3672 : #endif
3673 : use pm_kind, only: RKC => RK3
3674 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3675 : real(RKC) , intent(in) :: queryx
3676 : real(RKC) , intent(out) :: extrap, relerr
3677 : type(monopol_type) , intent(in) :: method
3678 : end subroutine
3679 : #endif
3680 :
3681 : #if RK2_ENABLED
3682 : PURE module subroutine setExtrapMNPLE_ND1_QD0_RK2(method, crdx, func, queryx, extrap, relerr)
3683 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3684 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD0_RK2
3685 : #endif
3686 : use pm_kind, only: RKC => RK2
3687 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3688 : real(RKC) , intent(in) :: queryx
3689 : real(RKC) , intent(out) :: extrap, relerr
3690 : type(monopol_type) , intent(in) :: method
3691 : end subroutine
3692 : #endif
3693 :
3694 : #if RK1_ENABLED
3695 : PURE module subroutine setExtrapMNPLE_ND1_QD0_RK1(method, crdx, func, queryx, extrap, relerr)
3696 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3697 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD0_RK1
3698 : #endif
3699 : use pm_kind, only: RKC => RK1
3700 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3701 : real(RKC) , intent(in) :: queryx
3702 : real(RKC) , intent(out) :: extrap, relerr
3703 : type(monopol_type) , intent(in) :: method
3704 : end subroutine
3705 : #endif
3706 :
3707 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3708 :
3709 : #if RK5_ENABLED
3710 : PURE module subroutine setExtrapMNPLE_ND1_QD1_RK5(method, crdx, func, queryx, extrap, relerr)
3711 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3712 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD1_RK5
3713 : #endif
3714 : use pm_kind, only: RKC => RK5
3715 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3716 : real(RKC) , intent(in) , contiguous :: queryx(:)
3717 : real(RKC) , intent(out) , contiguous :: extrap(:), relerr(:)
3718 : type(monopol_type) , intent(in) :: method
3719 : end subroutine
3720 : #endif
3721 :
3722 : #if RK4_ENABLED
3723 : PURE module subroutine setExtrapMNPLE_ND1_QD1_RK4(method, crdx, func, queryx, extrap, relerr)
3724 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3725 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD1_RK4
3726 : #endif
3727 : use pm_kind, only: RKC => RK4
3728 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3729 : real(RKC) , intent(in) , contiguous :: queryx(:)
3730 : real(RKC) , intent(out) , contiguous :: extrap(:), relerr(:)
3731 : type(monopol_type) , intent(in) :: method
3732 : end subroutine
3733 : #endif
3734 :
3735 : #if RK3_ENABLED
3736 : PURE module subroutine setExtrapMNPLE_ND1_QD1_RK3(method, crdx, func, queryx, extrap, relerr)
3737 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3738 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD1_RK3
3739 : #endif
3740 : use pm_kind, only: RKC => RK3
3741 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3742 : real(RKC) , intent(in) , contiguous :: queryx(:)
3743 : real(RKC) , intent(out) , contiguous :: extrap(:), relerr(:)
3744 : type(monopol_type) , intent(in) :: method
3745 : end subroutine
3746 : #endif
3747 :
3748 : #if RK2_ENABLED
3749 : PURE module subroutine setExtrapMNPLE_ND1_QD1_RK2(method, crdx, func, queryx, extrap, relerr)
3750 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3751 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD1_RK2
3752 : #endif
3753 : use pm_kind, only: RKC => RK2
3754 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3755 : real(RKC) , intent(in) , contiguous :: queryx(:)
3756 : real(RKC) , intent(out) , contiguous :: extrap(:), relerr(:)
3757 : type(monopol_type) , intent(in) :: method
3758 : end subroutine
3759 : #endif
3760 :
3761 : #if RK1_ENABLED
3762 : PURE module subroutine setExtrapMNPLE_ND1_QD1_RK1(method, crdx, func, queryx, extrap, relerr)
3763 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3764 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMNPLE_ND1_QD1_RK1
3765 : #endif
3766 : use pm_kind, only: RKC => RK1
3767 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3768 : real(RKC) , intent(in) , contiguous :: queryx(:)
3769 : real(RKC) , intent(out) , contiguous :: extrap(:), relerr(:)
3770 : type(monopol_type) , intent(in) :: method
3771 : end subroutine
3772 : #endif
3773 :
3774 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3775 :
3776 : end interface
3777 :
3778 : ! piwilin
3779 :
3780 : interface setExtrap
3781 :
3782 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3783 :
3784 : #if RK5_ENABLED
3785 : PURE module subroutine setExtrapPWLN_ND1_QD0_RK5(method, crdx, func, queryx, extrap)
3786 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3787 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD0_RK5
3788 : #endif
3789 : use pm_kind, only: RKC => RK5
3790 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3791 : real(RKC) , intent(in) :: queryx
3792 : real(RKC) , intent(out) :: extrap
3793 : type(piwilin_type) , intent(in) :: method
3794 : end subroutine
3795 : #endif
3796 :
3797 : #if RK4_ENABLED
3798 : PURE module subroutine setExtrapPWLN_ND1_QD0_RK4(method, crdx, func, queryx, extrap)
3799 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3800 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD0_RK4
3801 : #endif
3802 : use pm_kind, only: RKC => RK4
3803 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3804 : real(RKC) , intent(in) :: queryx
3805 : real(RKC) , intent(out) :: extrap
3806 : type(piwilin_type) , intent(in) :: method
3807 : end subroutine
3808 : #endif
3809 :
3810 : #if RK3_ENABLED
3811 : PURE module subroutine setExtrapPWLN_ND1_QD0_RK3(method, crdx, func, queryx, extrap)
3812 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3813 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD0_RK3
3814 : #endif
3815 : use pm_kind, only: RKC => RK3
3816 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3817 : real(RKC) , intent(in) :: queryx
3818 : real(RKC) , intent(out) :: extrap
3819 : type(piwilin_type) , intent(in) :: method
3820 : end subroutine
3821 : #endif
3822 :
3823 : #if RK2_ENABLED
3824 : PURE module subroutine setExtrapPWLN_ND1_QD0_RK2(method, crdx, func, queryx, extrap)
3825 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3826 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD0_RK2
3827 : #endif
3828 : use pm_kind, only: RKC => RK2
3829 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3830 : real(RKC) , intent(in) :: queryx
3831 : real(RKC) , intent(out) :: extrap
3832 : type(piwilin_type) , intent(in) :: method
3833 : end subroutine
3834 : #endif
3835 :
3836 : #if RK1_ENABLED
3837 : PURE module subroutine setExtrapPWLN_ND1_QD0_RK1(method, crdx, func, queryx, extrap)
3838 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3839 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD0_RK1
3840 : #endif
3841 : use pm_kind, only: RKC => RK1
3842 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3843 : real(RKC) , intent(in) :: queryx
3844 : real(RKC) , intent(out) :: extrap
3845 : type(piwilin_type) , intent(in) :: method
3846 : end subroutine
3847 : #endif
3848 :
3849 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3850 :
3851 : #if RK5_ENABLED
3852 : PURE module subroutine setExtrapPWLN_ND1_QD1_RK5(method, crdx, func, queryx, extrap)
3853 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3854 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD1_RK5
3855 : #endif
3856 : use pm_kind, only: RKC => RK5
3857 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3858 : real(RKC) , intent(in) , contiguous :: queryx(:)
3859 : real(RKC) , intent(out) , contiguous :: extrap(:)
3860 : type(piwilin_type) , intent(in) :: method
3861 : end subroutine
3862 : #endif
3863 :
3864 : #if RK4_ENABLED
3865 : PURE module subroutine setExtrapPWLN_ND1_QD1_RK4(method, crdx, func, queryx, extrap)
3866 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3867 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD1_RK4
3868 : #endif
3869 : use pm_kind, only: RKC => RK4
3870 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3871 : real(RKC) , intent(in) , contiguous :: queryx(:)
3872 : real(RKC) , intent(out) , contiguous :: extrap(:)
3873 : type(piwilin_type) , intent(in) :: method
3874 : end subroutine
3875 : #endif
3876 :
3877 : #if RK3_ENABLED
3878 : PURE module subroutine setExtrapPWLN_ND1_QD1_RK3(method, crdx, func, queryx, extrap)
3879 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3880 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD1_RK3
3881 : #endif
3882 : use pm_kind, only: RKC => RK3
3883 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3884 : real(RKC) , intent(in) , contiguous :: queryx(:)
3885 : real(RKC) , intent(out) , contiguous :: extrap(:)
3886 : type(piwilin_type) , intent(in) :: method
3887 : end subroutine
3888 : #endif
3889 :
3890 : #if RK2_ENABLED
3891 : PURE module subroutine setExtrapPWLN_ND1_QD1_RK2(method, crdx, func, queryx, extrap)
3892 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3893 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD1_RK2
3894 : #endif
3895 : use pm_kind, only: RKC => RK2
3896 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3897 : real(RKC) , intent(in) , contiguous :: queryx(:)
3898 : real(RKC) , intent(out) , contiguous :: extrap(:)
3899 : type(piwilin_type) , intent(in) :: method
3900 : end subroutine
3901 : #endif
3902 :
3903 : #if RK1_ENABLED
3904 : PURE module subroutine setExtrapPWLN_ND1_QD1_RK1(method, crdx, func, queryx, extrap)
3905 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3906 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPWLN_ND1_QD1_RK1
3907 : #endif
3908 : use pm_kind, only: RKC => RK1
3909 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3910 : real(RKC) , intent(in) , contiguous :: queryx(:)
3911 : real(RKC) , intent(out) , contiguous :: extrap(:)
3912 : type(piwilin_type) , intent(in) :: method
3913 : end subroutine
3914 : #endif
3915 :
3916 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3917 :
3918 : end interface
3919 :
3920 : ! neimean
3921 :
3922 : interface setExtrap
3923 :
3924 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3925 :
3926 : #if RK5_ENABLED
3927 : PURE module subroutine setExtrapMEAN_ND1_QD0_RK5(method, crdx, func, queryx, extrap)
3928 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3929 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD0_RK5
3930 : #endif
3931 : use pm_kind, only: RKC => RK5
3932 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3933 : real(RKC) , intent(in) :: queryx
3934 : real(RKC) , intent(out) :: extrap
3935 : type(neimean_type) , intent(in) :: method
3936 : end subroutine
3937 : #endif
3938 :
3939 : #if RK4_ENABLED
3940 : PURE module subroutine setExtrapMEAN_ND1_QD0_RK4(method, crdx, func, queryx, extrap)
3941 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3942 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD0_RK4
3943 : #endif
3944 : use pm_kind, only: RKC => RK4
3945 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3946 : real(RKC) , intent(in) :: queryx
3947 : real(RKC) , intent(out) :: extrap
3948 : type(neimean_type) , intent(in) :: method
3949 : end subroutine
3950 : #endif
3951 :
3952 : #if RK3_ENABLED
3953 : PURE module subroutine setExtrapMEAN_ND1_QD0_RK3(method, crdx, func, queryx, extrap)
3954 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3955 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD0_RK3
3956 : #endif
3957 : use pm_kind, only: RKC => RK3
3958 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3959 : real(RKC) , intent(in) :: queryx
3960 : real(RKC) , intent(out) :: extrap
3961 : type(neimean_type) , intent(in) :: method
3962 : end subroutine
3963 : #endif
3964 :
3965 : #if RK2_ENABLED
3966 : PURE module subroutine setExtrapMEAN_ND1_QD0_RK2(method, crdx, func, queryx, extrap)
3967 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3968 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD0_RK2
3969 : #endif
3970 : use pm_kind, only: RKC => RK2
3971 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3972 : real(RKC) , intent(in) :: queryx
3973 : real(RKC) , intent(out) :: extrap
3974 : type(neimean_type) , intent(in) :: method
3975 : end subroutine
3976 : #endif
3977 :
3978 : #if RK1_ENABLED
3979 : PURE module subroutine setExtrapMEAN_ND1_QD0_RK1(method, crdx, func, queryx, extrap)
3980 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3981 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD0_RK1
3982 : #endif
3983 : use pm_kind, only: RKC => RK1
3984 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
3985 : real(RKC) , intent(in) :: queryx
3986 : real(RKC) , intent(out) :: extrap
3987 : type(neimean_type) , intent(in) :: method
3988 : end subroutine
3989 : #endif
3990 :
3991 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3992 :
3993 : #if RK5_ENABLED
3994 : PURE module subroutine setExtrapMEAN_ND1_QD1_RK5(method, crdx, func, queryx, extrap)
3995 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3996 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD1_RK5
3997 : #endif
3998 : use pm_kind, only: RKC => RK5
3999 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4000 : real(RKC) , intent(in) , contiguous :: queryx(:)
4001 : real(RKC) , intent(out) , contiguous :: extrap(:)
4002 : type(neimean_type) , intent(in) :: method
4003 : end subroutine
4004 : #endif
4005 :
4006 : #if RK4_ENABLED
4007 : PURE module subroutine setExtrapMEAN_ND1_QD1_RK4(method, crdx, func, queryx, extrap)
4008 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4009 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD1_RK4
4010 : #endif
4011 : use pm_kind, only: RKC => RK4
4012 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4013 : real(RKC) , intent(in) , contiguous :: queryx(:)
4014 : real(RKC) , intent(out) , contiguous :: extrap(:)
4015 : type(neimean_type) , intent(in) :: method
4016 : end subroutine
4017 : #endif
4018 :
4019 : #if RK3_ENABLED
4020 : PURE module subroutine setExtrapMEAN_ND1_QD1_RK3(method, crdx, func, queryx, extrap)
4021 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4022 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD1_RK3
4023 : #endif
4024 : use pm_kind, only: RKC => RK3
4025 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4026 : real(RKC) , intent(in) , contiguous :: queryx(:)
4027 : real(RKC) , intent(out) , contiguous :: extrap(:)
4028 : type(neimean_type) , intent(in) :: method
4029 : end subroutine
4030 : #endif
4031 :
4032 : #if RK2_ENABLED
4033 : PURE module subroutine setExtrapMEAN_ND1_QD1_RK2(method, crdx, func, queryx, extrap)
4034 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4035 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD1_RK2
4036 : #endif
4037 : use pm_kind, only: RKC => RK2
4038 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4039 : real(RKC) , intent(in) , contiguous :: queryx(:)
4040 : real(RKC) , intent(out) , contiguous :: extrap(:)
4041 : type(neimean_type) , intent(in) :: method
4042 : end subroutine
4043 : #endif
4044 :
4045 : #if RK1_ENABLED
4046 : PURE module subroutine setExtrapMEAN_ND1_QD1_RK1(method, crdx, func, queryx, extrap)
4047 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4048 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapMEAN_ND1_QD1_RK1
4049 : #endif
4050 : use pm_kind, only: RKC => RK1
4051 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4052 : real(RKC) , intent(in) , contiguous :: queryx(:)
4053 : real(RKC) , intent(out) , contiguous :: extrap(:)
4054 : type(neimean_type) , intent(in) :: method
4055 : end subroutine
4056 : #endif
4057 :
4058 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4059 :
4060 : end interface
4061 :
4062 : ! neinear
4063 :
4064 : interface setExtrap
4065 :
4066 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4067 :
4068 : #if RK5_ENABLED
4069 : PURE module subroutine setExtrapNEAR_ND1_QD0_RK5(method, crdx, func, queryx, extrap)
4070 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4071 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD0_RK5
4072 : #endif
4073 : use pm_kind, only: RKC => RK5
4074 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4075 : real(RKC) , intent(in) :: queryx
4076 : real(RKC) , intent(out) :: extrap
4077 : type(neinear_type) , intent(in) :: method
4078 : end subroutine
4079 : #endif
4080 :
4081 : #if RK4_ENABLED
4082 : PURE module subroutine setExtrapNEAR_ND1_QD0_RK4(method, crdx, func, queryx, extrap)
4083 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4084 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD0_RK4
4085 : #endif
4086 : use pm_kind, only: RKC => RK4
4087 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4088 : real(RKC) , intent(in) :: queryx
4089 : real(RKC) , intent(out) :: extrap
4090 : type(neinear_type) , intent(in) :: method
4091 : end subroutine
4092 : #endif
4093 :
4094 : #if RK3_ENABLED
4095 : PURE module subroutine setExtrapNEAR_ND1_QD0_RK3(method, crdx, func, queryx, extrap)
4096 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4097 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD0_RK3
4098 : #endif
4099 : use pm_kind, only: RKC => RK3
4100 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4101 : real(RKC) , intent(in) :: queryx
4102 : real(RKC) , intent(out) :: extrap
4103 : type(neinear_type) , intent(in) :: method
4104 : end subroutine
4105 : #endif
4106 :
4107 : #if RK2_ENABLED
4108 : PURE module subroutine setExtrapNEAR_ND1_QD0_RK2(method, crdx, func, queryx, extrap)
4109 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4110 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD0_RK2
4111 : #endif
4112 : use pm_kind, only: RKC => RK2
4113 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4114 : real(RKC) , intent(in) :: queryx
4115 : real(RKC) , intent(out) :: extrap
4116 : type(neinear_type) , intent(in) :: method
4117 : end subroutine
4118 : #endif
4119 :
4120 : #if RK1_ENABLED
4121 : PURE module subroutine setExtrapNEAR_ND1_QD0_RK1(method, crdx, func, queryx, extrap)
4122 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4123 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD0_RK1
4124 : #endif
4125 : use pm_kind, only: RKC => RK1
4126 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4127 : real(RKC) , intent(in) :: queryx
4128 : real(RKC) , intent(out) :: extrap
4129 : type(neinear_type) , intent(in) :: method
4130 : end subroutine
4131 : #endif
4132 :
4133 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4134 :
4135 : #if RK5_ENABLED
4136 : PURE module subroutine setExtrapNEAR_ND1_QD1_RK5(method, crdx, func, queryx, extrap)
4137 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4138 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD1_RK5
4139 : #endif
4140 : use pm_kind, only: RKC => RK5
4141 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4142 : real(RKC) , intent(in) , contiguous :: queryx(:)
4143 : real(RKC) , intent(out) , contiguous :: extrap(:)
4144 : type(neinear_type) , intent(in) :: method
4145 : end subroutine
4146 : #endif
4147 :
4148 : #if RK4_ENABLED
4149 : PURE module subroutine setExtrapNEAR_ND1_QD1_RK4(method, crdx, func, queryx, extrap)
4150 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4151 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD1_RK4
4152 : #endif
4153 : use pm_kind, only: RKC => RK4
4154 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4155 : real(RKC) , intent(in) , contiguous :: queryx(:)
4156 : real(RKC) , intent(out) , contiguous :: extrap(:)
4157 : type(neinear_type) , intent(in) :: method
4158 : end subroutine
4159 : #endif
4160 :
4161 : #if RK3_ENABLED
4162 : PURE module subroutine setExtrapNEAR_ND1_QD1_RK3(method, crdx, func, queryx, extrap)
4163 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4164 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD1_RK3
4165 : #endif
4166 : use pm_kind, only: RKC => RK3
4167 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4168 : real(RKC) , intent(in) , contiguous :: queryx(:)
4169 : real(RKC) , intent(out) , contiguous :: extrap(:)
4170 : type(neinear_type) , intent(in) :: method
4171 : end subroutine
4172 : #endif
4173 :
4174 : #if RK2_ENABLED
4175 : PURE module subroutine setExtrapNEAR_ND1_QD1_RK2(method, crdx, func, queryx, extrap)
4176 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4177 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD1_RK2
4178 : #endif
4179 : use pm_kind, only: RKC => RK2
4180 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4181 : real(RKC) , intent(in) , contiguous :: queryx(:)
4182 : real(RKC) , intent(out) , contiguous :: extrap(:)
4183 : type(neinear_type) , intent(in) :: method
4184 : end subroutine
4185 : #endif
4186 :
4187 : #if RK1_ENABLED
4188 : PURE module subroutine setExtrapNEAR_ND1_QD1_RK1(method, crdx, func, queryx, extrap)
4189 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4190 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEAR_ND1_QD1_RK1
4191 : #endif
4192 : use pm_kind, only: RKC => RK1
4193 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4194 : real(RKC) , intent(in) , contiguous :: queryx(:)
4195 : real(RKC) , intent(out) , contiguous :: extrap(:)
4196 : type(neinear_type) , intent(in) :: method
4197 : end subroutine
4198 : #endif
4199 :
4200 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4201 :
4202 : end interface
4203 :
4204 : ! neinext
4205 :
4206 : interface setExtrap
4207 :
4208 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4209 :
4210 : #if RK5_ENABLED
4211 : PURE module subroutine setExtrapNEXT_ND1_QD0_RK5(method, crdx, func, queryx, extrap)
4212 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4213 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD0_RK5
4214 : #endif
4215 : use pm_kind, only: RKC => RK5
4216 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4217 : real(RKC) , intent(in) :: queryx
4218 : real(RKC) , intent(out) :: extrap
4219 : type(neinext_type) , intent(in) :: method
4220 : end subroutine
4221 : #endif
4222 :
4223 : #if RK4_ENABLED
4224 : PURE module subroutine setExtrapNEXT_ND1_QD0_RK4(method, crdx, func, queryx, extrap)
4225 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4226 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD0_RK4
4227 : #endif
4228 : use pm_kind, only: RKC => RK4
4229 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4230 : real(RKC) , intent(in) :: queryx
4231 : real(RKC) , intent(out) :: extrap
4232 : type(neinext_type) , intent(in) :: method
4233 : end subroutine
4234 : #endif
4235 :
4236 : #if RK3_ENABLED
4237 : PURE module subroutine setExtrapNEXT_ND1_QD0_RK3(method, crdx, func, queryx, extrap)
4238 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4239 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD0_RK3
4240 : #endif
4241 : use pm_kind, only: RKC => RK3
4242 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4243 : real(RKC) , intent(in) :: queryx
4244 : real(RKC) , intent(out) :: extrap
4245 : type(neinext_type) , intent(in) :: method
4246 : end subroutine
4247 : #endif
4248 :
4249 : #if RK2_ENABLED
4250 : PURE module subroutine setExtrapNEXT_ND1_QD0_RK2(method, crdx, func, queryx, extrap)
4251 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4252 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD0_RK2
4253 : #endif
4254 : use pm_kind, only: RKC => RK2
4255 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4256 : real(RKC) , intent(in) :: queryx
4257 : real(RKC) , intent(out) :: extrap
4258 : type(neinext_type) , intent(in) :: method
4259 : end subroutine
4260 : #endif
4261 :
4262 : #if RK1_ENABLED
4263 : PURE module subroutine setExtrapNEXT_ND1_QD0_RK1(method, crdx, func, queryx, extrap)
4264 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4265 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD0_RK1
4266 : #endif
4267 : use pm_kind, only: RKC => RK1
4268 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4269 : real(RKC) , intent(in) :: queryx
4270 : real(RKC) , intent(out) :: extrap
4271 : type(neinext_type) , intent(in) :: method
4272 : end subroutine
4273 : #endif
4274 :
4275 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4276 :
4277 : #if RK5_ENABLED
4278 : PURE module subroutine setExtrapNEXT_ND1_QD1_RK5(method, crdx, func, queryx, extrap)
4279 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4280 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD1_RK5
4281 : #endif
4282 : use pm_kind, only: RKC => RK5
4283 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4284 : real(RKC) , intent(in) , contiguous :: queryx(:)
4285 : real(RKC) , intent(out) , contiguous :: extrap(:)
4286 : type(neinext_type) , intent(in) :: method
4287 : end subroutine
4288 : #endif
4289 :
4290 : #if RK4_ENABLED
4291 : PURE module subroutine setExtrapNEXT_ND1_QD1_RK4(method, crdx, func, queryx, extrap)
4292 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4293 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD1_RK4
4294 : #endif
4295 : use pm_kind, only: RKC => RK4
4296 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4297 : real(RKC) , intent(in) , contiguous :: queryx(:)
4298 : real(RKC) , intent(out) , contiguous :: extrap(:)
4299 : type(neinext_type) , intent(in) :: method
4300 : end subroutine
4301 : #endif
4302 :
4303 : #if RK3_ENABLED
4304 : PURE module subroutine setExtrapNEXT_ND1_QD1_RK3(method, crdx, func, queryx, extrap)
4305 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4306 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD1_RK3
4307 : #endif
4308 : use pm_kind, only: RKC => RK3
4309 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4310 : real(RKC) , intent(in) , contiguous :: queryx(:)
4311 : real(RKC) , intent(out) , contiguous :: extrap(:)
4312 : type(neinext_type) , intent(in) :: method
4313 : end subroutine
4314 : #endif
4315 :
4316 : #if RK2_ENABLED
4317 : PURE module subroutine setExtrapNEXT_ND1_QD1_RK2(method, crdx, func, queryx, extrap)
4318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4319 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD1_RK2
4320 : #endif
4321 : use pm_kind, only: RKC => RK2
4322 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4323 : real(RKC) , intent(in) , contiguous :: queryx(:)
4324 : real(RKC) , intent(out) , contiguous :: extrap(:)
4325 : type(neinext_type) , intent(in) :: method
4326 : end subroutine
4327 : #endif
4328 :
4329 : #if RK1_ENABLED
4330 : PURE module subroutine setExtrapNEXT_ND1_QD1_RK1(method, crdx, func, queryx, extrap)
4331 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4332 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapNEXT_ND1_QD1_RK1
4333 : #endif
4334 : use pm_kind, only: RKC => RK1
4335 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4336 : real(RKC) , intent(in) , contiguous :: queryx(:)
4337 : real(RKC) , intent(out) , contiguous :: extrap(:)
4338 : type(neinext_type) , intent(in) :: method
4339 : end subroutine
4340 : #endif
4341 :
4342 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4343 :
4344 : end interface
4345 :
4346 : ! neiprev
4347 :
4348 : interface setExtrap
4349 :
4350 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4351 :
4352 : #if RK5_ENABLED
4353 : PURE module subroutine setExtrapPREV_ND1_QD0_RK5(method, crdx, func, queryx, extrap)
4354 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4355 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD0_RK5
4356 : #endif
4357 : use pm_kind, only: RKC => RK5
4358 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4359 : real(RKC) , intent(in) :: queryx
4360 : real(RKC) , intent(out) :: extrap
4361 : type(neiprev_type) , intent(in) :: method
4362 : end subroutine
4363 : #endif
4364 :
4365 : #if RK4_ENABLED
4366 : PURE module subroutine setExtrapPREV_ND1_QD0_RK4(method, crdx, func, queryx, extrap)
4367 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4368 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD0_RK4
4369 : #endif
4370 : use pm_kind, only: RKC => RK4
4371 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4372 : real(RKC) , intent(in) :: queryx
4373 : real(RKC) , intent(out) :: extrap
4374 : type(neiprev_type) , intent(in) :: method
4375 : end subroutine
4376 : #endif
4377 :
4378 : #if RK3_ENABLED
4379 : PURE module subroutine setExtrapPREV_ND1_QD0_RK3(method, crdx, func, queryx, extrap)
4380 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4381 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD0_RK3
4382 : #endif
4383 : use pm_kind, only: RKC => RK3
4384 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4385 : real(RKC) , intent(in) :: queryx
4386 : real(RKC) , intent(out) :: extrap
4387 : type(neiprev_type) , intent(in) :: method
4388 : end subroutine
4389 : #endif
4390 :
4391 : #if RK2_ENABLED
4392 : PURE module subroutine setExtrapPREV_ND1_QD0_RK2(method, crdx, func, queryx, extrap)
4393 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4394 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD0_RK2
4395 : #endif
4396 : use pm_kind, only: RKC => RK2
4397 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4398 : real(RKC) , intent(in) :: queryx
4399 : real(RKC) , intent(out) :: extrap
4400 : type(neiprev_type) , intent(in) :: method
4401 : end subroutine
4402 : #endif
4403 :
4404 : #if RK1_ENABLED
4405 : PURE module subroutine setExtrapPREV_ND1_QD0_RK1(method, crdx, func, queryx, extrap)
4406 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4407 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD0_RK1
4408 : #endif
4409 : use pm_kind, only: RKC => RK1
4410 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4411 : real(RKC) , intent(in) :: queryx
4412 : real(RKC) , intent(out) :: extrap
4413 : type(neiprev_type) , intent(in) :: method
4414 : end subroutine
4415 : #endif
4416 :
4417 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4418 :
4419 : #if RK5_ENABLED
4420 : PURE module subroutine setExtrapPREV_ND1_QD1_RK5(method, crdx, func, queryx, extrap)
4421 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4422 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD1_RK5
4423 : #endif
4424 : use pm_kind, only: RKC => RK5
4425 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4426 : real(RKC) , intent(in) , contiguous :: queryx(:)
4427 : real(RKC) , intent(out) , contiguous :: extrap(:)
4428 : type(neiprev_type) , intent(in) :: method
4429 : end subroutine
4430 : #endif
4431 :
4432 : #if RK4_ENABLED
4433 : PURE module subroutine setExtrapPREV_ND1_QD1_RK4(method, crdx, func, queryx, extrap)
4434 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4435 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD1_RK4
4436 : #endif
4437 : use pm_kind, only: RKC => RK4
4438 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4439 : real(RKC) , intent(in) , contiguous :: queryx(:)
4440 : real(RKC) , intent(out) , contiguous :: extrap(:)
4441 : type(neiprev_type) , intent(in) :: method
4442 : end subroutine
4443 : #endif
4444 :
4445 : #if RK3_ENABLED
4446 : PURE module subroutine setExtrapPREV_ND1_QD1_RK3(method, crdx, func, queryx, extrap)
4447 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4448 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD1_RK3
4449 : #endif
4450 : use pm_kind, only: RKC => RK3
4451 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4452 : real(RKC) , intent(in) , contiguous :: queryx(:)
4453 : real(RKC) , intent(out) , contiguous :: extrap(:)
4454 : type(neiprev_type) , intent(in) :: method
4455 : end subroutine
4456 : #endif
4457 :
4458 : #if RK2_ENABLED
4459 : PURE module subroutine setExtrapPREV_ND1_QD1_RK2(method, crdx, func, queryx, extrap)
4460 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4461 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD1_RK2
4462 : #endif
4463 : use pm_kind, only: RKC => RK2
4464 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4465 : real(RKC) , intent(in) , contiguous :: queryx(:)
4466 : real(RKC) , intent(out) , contiguous :: extrap(:)
4467 : type(neiprev_type) , intent(in) :: method
4468 : end subroutine
4469 : #endif
4470 :
4471 : #if RK1_ENABLED
4472 : PURE module subroutine setExtrapPREV_ND1_QD1_RK1(method, crdx, func, queryx, extrap)
4473 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4474 : !DEC$ ATTRIBUTES DLLEXPORT :: setExtrapPREV_ND1_QD1_RK1
4475 : #endif
4476 : use pm_kind, only: RKC => RK1
4477 : real(RKC) , intent(in) , contiguous :: crdx(:), func(:)
4478 : real(RKC) , intent(in) , contiguous :: queryx(:)
4479 : real(RKC) , intent(out) , contiguous :: extrap(:)
4480 : type(neiprev_type) , intent(in) :: method
4481 : end subroutine
4482 : #endif
4483 :
4484 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4485 :
4486 : end interface
4487 :
4488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4489 :
4490 0 : end module pm_polation
|
