ParaMonte Fortran 2.0.0
Parallel Monte Carlo and Machine Learning Library
See the latest version documentation.
pm_sampleQuan.F90
Go to the documentation of this file.
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
59
60!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
61
62module pm_sampleQuan
63
64 use pm_polation, only: setInterp
65 use pm_polation, only: neimean, neimean_type
66 use pm_polation, only: neinear, neinear_type
67 use pm_polation, only: neinext, neinext_type
68 use pm_polation, only: neiprev, neiprev_type
69 use pm_polation, only: piwilin, piwilin_type
70 use pm_kind, only: SK, IK, LK
71
72 implicit none
73
74 character(*, SK), parameter :: MODULE_NAME = "@pm_sampleQuan"
75
76!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
77
202
203 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
204
205 ! ND1 WNO piwilin
206
207 interface getQuan
208
209 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
210
211#if RK5_ENABLED
212 PURE module function getQuanPWLN_ND1_QD0_WNO_RK5(method, prob, sample) result(quan)
213#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
214 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WNO_RK5
215#endif
216 use pm_kind, only: TKG => RK5
217 real(TKG) :: quan
218 real(TKG) , intent(in) :: prob
219 real(TKG) , intent(in) , contiguous :: sample(:)
220 type(piwilin_type) , intent(in) :: method
221 end function
222#endif
223
224#if RK4_ENABLED
225 PURE module function getQuanPWLN_ND1_QD0_WNO_RK4(method, prob, sample) result(quan)
226#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
227 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WNO_RK4
228#endif
229 use pm_kind, only: TKG => RK4
230 real(TKG) :: quan
231 real(TKG) , intent(in) :: prob
232 real(TKG) , intent(in) , contiguous :: sample(:)
233 type(piwilin_type) , intent(in) :: method
234 end function
235#endif
236
237#if RK3_ENABLED
238 PURE module function getQuanPWLN_ND1_QD0_WNO_RK3(method, prob, sample) result(quan)
239#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
240 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WNO_RK3
241#endif
242 use pm_kind, only: TKG => RK3
243 real(TKG) :: quan
244 real(TKG) , intent(in) :: prob
245 real(TKG) , intent(in) , contiguous :: sample(:)
246 type(piwilin_type) , intent(in) :: method
247 end function
248#endif
249
250#if RK2_ENABLED
251 PURE module function getQuanPWLN_ND1_QD0_WNO_RK2(method, prob, sample) result(quan)
252#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
253 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WNO_RK2
254#endif
255 use pm_kind, only: TKG => RK2
256 real(TKG) :: quan
257 real(TKG) , intent(in) :: prob
258 real(TKG) , intent(in) , contiguous :: sample(:)
259 type(piwilin_type) , intent(in) :: method
260 end function
261#endif
262
263#if RK1_ENABLED
264 PURE module function getQuanPWLN_ND1_QD0_WNO_RK1(method, prob, sample) result(quan)
265#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
266 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WNO_RK1
267#endif
268 use pm_kind, only: TKG => RK1
269 real(TKG) :: quan
270 real(TKG) , intent(in) :: prob
271 real(TKG) , intent(in) , contiguous :: sample(:)
272 type(piwilin_type) , intent(in) :: method
273 end function
274#endif
275
276 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
277
278#if RK5_ENABLED
279 PURE module function getQuanPWLN_ND1_QD1_WNO_RK5(method, prob, sample) result(quan)
280#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
281 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WNO_RK5
282#endif
283 use pm_kind, only: TKG => RK5
284 real(TKG) , intent(in) , contiguous :: sample(:)
285 real(TKG) , intent(in) , contiguous :: prob(:)
286 real(TKG) :: quan(size(prob, 1, IK))
287 type(piwilin_type) , intent(in) :: method
288 end function
289#endif
290
291#if RK4_ENABLED
292 PURE module function getQuanPWLN_ND1_QD1_WNO_RK4(method, prob, sample) result(quan)
293#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
294 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WNO_RK4
295#endif
296 use pm_kind, only: TKG => RK4
297 real(TKG) , intent(in) , contiguous :: sample(:)
298 real(TKG) , intent(in) , contiguous :: prob(:)
299 real(TKG) :: quan(size(prob, 1, IK))
300 type(piwilin_type) , intent(in) :: method
301 end function
302#endif
303
304#if RK3_ENABLED
305 PURE module function getQuanPWLN_ND1_QD1_WNO_RK3(method, prob, sample) result(quan)
306#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
307 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WNO_RK3
308#endif
309 use pm_kind, only: TKG => RK3
310 real(TKG) , intent(in) , contiguous :: sample(:)
311 real(TKG) , intent(in) , contiguous :: prob(:)
312 real(TKG) :: quan(size(prob, 1, IK))
313 type(piwilin_type) , intent(in) :: method
314 end function
315#endif
316
317#if RK2_ENABLED
318 PURE module function getQuanPWLN_ND1_QD1_WNO_RK2(method, prob, sample) result(quan)
319#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
320 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WNO_RK2
321#endif
322 use pm_kind, only: TKG => RK2
323 real(TKG) , intent(in) , contiguous :: sample(:)
324 real(TKG) , intent(in) , contiguous :: prob(:)
325 real(TKG) :: quan(size(prob, 1, IK))
326 type(piwilin_type) , intent(in) :: method
327 end function
328#endif
329
330#if RK1_ENABLED
331 PURE module function getQuanPWLN_ND1_QD1_WNO_RK1(method, prob, sample) result(quan)
332#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
333 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WNO_RK1
334#endif
335 use pm_kind, only: TKG => RK1
336 real(TKG) , intent(in) , contiguous :: sample(:)
337 real(TKG) , intent(in) , contiguous :: prob(:)
338 real(TKG) :: quan(size(prob, 1, IK))
339 type(piwilin_type) , intent(in) :: method
340 end function
341#endif
342
343 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
344
345 end interface
346
347 ! ND1 WNO neimean
348
349 interface getQuan
350
351 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
352
353#if RK5_ENABLED
354 PURE module function getQuanMEAN_ND1_QD0_WNO_RK5(method, prob, sample) result(quan)
355#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
356 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WNO_RK5
357#endif
358 use pm_kind, only: TKG => RK5
359 real(TKG) :: quan
360 real(TKG) , intent(in) :: prob
361 real(TKG) , intent(in) , contiguous :: sample(:)
362 type(neimean_type) , intent(in) :: method
363 end function
364#endif
365
366#if RK4_ENABLED
367 PURE module function getQuanMEAN_ND1_QD0_WNO_RK4(method, prob, sample) result(quan)
368#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
369 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WNO_RK4
370#endif
371 use pm_kind, only: TKG => RK4
372 real(TKG) :: quan
373 real(TKG) , intent(in) :: prob
374 real(TKG) , intent(in) , contiguous :: sample(:)
375 type(neimean_type) , intent(in) :: method
376 end function
377#endif
378
379#if RK3_ENABLED
380 PURE module function getQuanMEAN_ND1_QD0_WNO_RK3(method, prob, sample) result(quan)
381#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
382 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WNO_RK3
383#endif
384 use pm_kind, only: TKG => RK3
385 real(TKG) :: quan
386 real(TKG) , intent(in) :: prob
387 real(TKG) , intent(in) , contiguous :: sample(:)
388 type(neimean_type) , intent(in) :: method
389 end function
390#endif
391
392#if RK2_ENABLED
393 PURE module function getQuanMEAN_ND1_QD0_WNO_RK2(method, prob, sample) result(quan)
394#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
395 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WNO_RK2
396#endif
397 use pm_kind, only: TKG => RK2
398 real(TKG) :: quan
399 real(TKG) , intent(in) :: prob
400 real(TKG) , intent(in) , contiguous :: sample(:)
401 type(neimean_type) , intent(in) :: method
402 end function
403#endif
404
405#if RK1_ENABLED
406 PURE module function getQuanMEAN_ND1_QD0_WNO_RK1(method, prob, sample) result(quan)
407#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
408 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WNO_RK1
409#endif
410 use pm_kind, only: TKG => RK1
411 real(TKG) :: quan
412 real(TKG) , intent(in) :: prob
413 real(TKG) , intent(in) , contiguous :: sample(:)
414 type(neimean_type) , intent(in) :: method
415 end function
416#endif
417
418 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
419
420#if RK5_ENABLED
421 PURE module function getQuanMEAN_ND1_QD1_WNO_RK5(method, prob, sample) result(quan)
422#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
423 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WNO_RK5
424#endif
425 use pm_kind, only: TKG => RK5
426 real(TKG) , intent(in) , contiguous :: sample(:)
427 real(TKG) , intent(in) , contiguous :: prob(:)
428 real(TKG) :: quan(size(prob, 1, IK))
429 type(neimean_type) , intent(in) :: method
430 end function
431#endif
432
433#if RK4_ENABLED
434 PURE module function getQuanMEAN_ND1_QD1_WNO_RK4(method, prob, sample) result(quan)
435#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
436 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WNO_RK4
437#endif
438 use pm_kind, only: TKG => RK4
439 real(TKG) , intent(in) , contiguous :: sample(:)
440 real(TKG) , intent(in) , contiguous :: prob(:)
441 real(TKG) :: quan(size(prob, 1, IK))
442 type(neimean_type) , intent(in) :: method
443 end function
444#endif
445
446#if RK3_ENABLED
447 PURE module function getQuanMEAN_ND1_QD1_WNO_RK3(method, prob, sample) result(quan)
448#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
449 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WNO_RK3
450#endif
451 use pm_kind, only: TKG => RK3
452 real(TKG) , intent(in) , contiguous :: sample(:)
453 real(TKG) , intent(in) , contiguous :: prob(:)
454 real(TKG) :: quan(size(prob, 1, IK))
455 type(neimean_type) , intent(in) :: method
456 end function
457#endif
458
459#if RK2_ENABLED
460 PURE module function getQuanMEAN_ND1_QD1_WNO_RK2(method, prob, sample) result(quan)
461#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
462 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WNO_RK2
463#endif
464 use pm_kind, only: TKG => RK2
465 real(TKG) , intent(in) , contiguous :: sample(:)
466 real(TKG) , intent(in) , contiguous :: prob(:)
467 real(TKG) :: quan(size(prob, 1, IK))
468 type(neimean_type) , intent(in) :: method
469 end function
470#endif
471
472#if RK1_ENABLED
473 PURE module function getQuanMEAN_ND1_QD1_WNO_RK1(method, prob, sample) result(quan)
474#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
475 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WNO_RK1
476#endif
477 use pm_kind, only: TKG => RK1
478 real(TKG) , intent(in) , contiguous :: sample(:)
479 real(TKG) , intent(in) , contiguous :: prob(:)
480 real(TKG) :: quan(size(prob, 1, IK))
481 type(neimean_type) , intent(in) :: method
482 end function
483#endif
484
485 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
486
487 end interface
488
489 ! ND1 WNO neinear
490
491 interface getQuan
492
493 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
494
495#if RK5_ENABLED
496 PURE module function getQuanNEAR_ND1_QD0_WNO_RK5(method, prob, sample) result(quan)
497#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
498 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WNO_RK5
499#endif
500 use pm_kind, only: TKG => RK5
501 real(TKG) :: quan
502 real(TKG) , intent(in) :: prob
503 real(TKG) , intent(in) , contiguous :: sample(:)
504 type(neinear_type) , intent(in) :: method
505 end function
506#endif
507
508#if RK4_ENABLED
509 PURE module function getQuanNEAR_ND1_QD0_WNO_RK4(method, prob, sample) result(quan)
510#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
511 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WNO_RK4
512#endif
513 use pm_kind, only: TKG => RK4
514 real(TKG) :: quan
515 real(TKG) , intent(in) :: prob
516 real(TKG) , intent(in) , contiguous :: sample(:)
517 type(neinear_type) , intent(in) :: method
518 end function
519#endif
520
521#if RK3_ENABLED
522 PURE module function getQuanNEAR_ND1_QD0_WNO_RK3(method, prob, sample) result(quan)
523#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
524 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WNO_RK3
525#endif
526 use pm_kind, only: TKG => RK3
527 real(TKG) :: quan
528 real(TKG) , intent(in) :: prob
529 real(TKG) , intent(in) , contiguous :: sample(:)
530 type(neinear_type) , intent(in) :: method
531 end function
532#endif
533
534#if RK2_ENABLED
535 PURE module function getQuanNEAR_ND1_QD0_WNO_RK2(method, prob, sample) result(quan)
536#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
537 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WNO_RK2
538#endif
539 use pm_kind, only: TKG => RK2
540 real(TKG) :: quan
541 real(TKG) , intent(in) :: prob
542 real(TKG) , intent(in) , contiguous :: sample(:)
543 type(neinear_type) , intent(in) :: method
544 end function
545#endif
546
547#if RK1_ENABLED
548 PURE module function getQuanNEAR_ND1_QD0_WNO_RK1(method, prob, sample) result(quan)
549#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
550 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WNO_RK1
551#endif
552 use pm_kind, only: TKG => RK1
553 real(TKG) :: quan
554 real(TKG) , intent(in) :: prob
555 real(TKG) , intent(in) , contiguous :: sample(:)
556 type(neinear_type) , intent(in) :: method
557 end function
558#endif
559
560 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
561
562#if RK5_ENABLED
563 PURE module function getQuanNEAR_ND1_QD1_WNO_RK5(method, prob, sample) result(quan)
564#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
565 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WNO_RK5
566#endif
567 use pm_kind, only: TKG => RK5
568 real(TKG) , intent(in) , contiguous :: sample(:)
569 real(TKG) , intent(in) , contiguous :: prob(:)
570 real(TKG) :: quan(size(prob, 1, IK))
571 type(neinear_type) , intent(in) :: method
572 end function
573#endif
574
575#if RK4_ENABLED
576 PURE module function getQuanNEAR_ND1_QD1_WNO_RK4(method, prob, sample) result(quan)
577#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
578 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WNO_RK4
579#endif
580 use pm_kind, only: TKG => RK4
581 real(TKG) , intent(in) , contiguous :: sample(:)
582 real(TKG) , intent(in) , contiguous :: prob(:)
583 real(TKG) :: quan(size(prob, 1, IK))
584 type(neinear_type) , intent(in) :: method
585 end function
586#endif
587
588#if RK3_ENABLED
589 PURE module function getQuanNEAR_ND1_QD1_WNO_RK3(method, prob, sample) result(quan)
590#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
591 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WNO_RK3
592#endif
593 use pm_kind, only: TKG => RK3
594 real(TKG) , intent(in) , contiguous :: sample(:)
595 real(TKG) , intent(in) , contiguous :: prob(:)
596 real(TKG) :: quan(size(prob, 1, IK))
597 type(neinear_type) , intent(in) :: method
598 end function
599#endif
600
601#if RK2_ENABLED
602 PURE module function getQuanNEAR_ND1_QD1_WNO_RK2(method, prob, sample) result(quan)
603#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
604 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WNO_RK2
605#endif
606 use pm_kind, only: TKG => RK2
607 real(TKG) , intent(in) , contiguous :: sample(:)
608 real(TKG) , intent(in) , contiguous :: prob(:)
609 real(TKG) :: quan(size(prob, 1, IK))
610 type(neinear_type) , intent(in) :: method
611 end function
612#endif
613
614#if RK1_ENABLED
615 PURE module function getQuanNEAR_ND1_QD1_WNO_RK1(method, prob, sample) result(quan)
616#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
617 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WNO_RK1
618#endif
619 use pm_kind, only: TKG => RK1
620 real(TKG) , intent(in) , contiguous :: sample(:)
621 real(TKG) , intent(in) , contiguous :: prob(:)
622 real(TKG) :: quan(size(prob, 1, IK))
623 type(neinear_type) , intent(in) :: method
624 end function
625#endif
626
627 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
628
629 end interface
630
631 ! ND1 WNO neinext
632
633 interface getQuan
634
635 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
636
637#if RK5_ENABLED
638 PURE module function getQuanNEXT_ND1_QD0_WNO_RK5(method, prob, sample) result(quan)
639#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
640 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WNO_RK5
641#endif
642 use pm_kind, only: TKG => RK5
643 real(TKG) :: quan
644 real(TKG) , intent(in) :: prob
645 real(TKG) , intent(in) , contiguous :: sample(:)
646 type(neinext_type) , intent(in) :: method
647 end function
648#endif
649
650#if RK4_ENABLED
651 PURE module function getQuanNEXT_ND1_QD0_WNO_RK4(method, prob, sample) result(quan)
652#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
653 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WNO_RK4
654#endif
655 use pm_kind, only: TKG => RK4
656 real(TKG) :: quan
657 real(TKG) , intent(in) :: prob
658 real(TKG) , intent(in) , contiguous :: sample(:)
659 type(neinext_type) , intent(in) :: method
660 end function
661#endif
662
663#if RK3_ENABLED
664 PURE module function getQuanNEXT_ND1_QD0_WNO_RK3(method, prob, sample) result(quan)
665#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
666 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WNO_RK3
667#endif
668 use pm_kind, only: TKG => RK3
669 real(TKG) :: quan
670 real(TKG) , intent(in) :: prob
671 real(TKG) , intent(in) , contiguous :: sample(:)
672 type(neinext_type) , intent(in) :: method
673 end function
674#endif
675
676#if RK2_ENABLED
677 PURE module function getQuanNEXT_ND1_QD0_WNO_RK2(method, prob, sample) result(quan)
678#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
679 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WNO_RK2
680#endif
681 use pm_kind, only: TKG => RK2
682 real(TKG) , intent(in) :: prob
683 real(TKG) :: quan
684 real(TKG) , intent(in) , contiguous :: sample(:)
685 type(neinext_type) , intent(in) :: method
686 end function
687#endif
688
689#if RK1_ENABLED
690 PURE module function getQuanNEXT_ND1_QD0_WNO_RK1(method, prob, sample) result(quan)
691#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
692 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WNO_RK1
693#endif
694 use pm_kind, only: TKG => RK1
695 real(TKG) :: quan
696 real(TKG) , intent(in) :: prob
697 real(TKG) , intent(in) , contiguous :: sample(:)
698 type(neinext_type) , intent(in) :: method
699 end function
700#endif
701
702 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
703
704#if RK5_ENABLED
705 PURE module function getQuanNEXT_ND1_QD1_WNO_RK5(method, prob, sample) result(quan)
706#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
707 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WNO_RK5
708#endif
709 use pm_kind, only: TKG => RK5
710 real(TKG) , intent(in) , contiguous :: sample(:)
711 real(TKG) , intent(in) , contiguous :: prob(:)
712 real(TKG) :: quan(size(prob, 1, IK))
713 type(neinext_type) , intent(in) :: method
714 end function
715#endif
716
717#if RK4_ENABLED
718 PURE module function getQuanNEXT_ND1_QD1_WNO_RK4(method, prob, sample) result(quan)
719#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
720 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WNO_RK4
721#endif
722 use pm_kind, only: TKG => RK4
723 real(TKG) , intent(in) , contiguous :: sample(:)
724 real(TKG) , intent(in) , contiguous :: prob(:)
725 real(TKG) :: quan(size(prob, 1, IK))
726 type(neinext_type) , intent(in) :: method
727 end function
728#endif
729
730#if RK3_ENABLED
731 PURE module function getQuanNEXT_ND1_QD1_WNO_RK3(method, prob, sample) result(quan)
732#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
733 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WNO_RK3
734#endif
735 use pm_kind, only: TKG => RK3
736 real(TKG) , intent(in) , contiguous :: sample(:)
737 real(TKG) , intent(in) , contiguous :: prob(:)
738 real(TKG) :: quan(size(prob, 1, IK))
739 type(neinext_type) , intent(in) :: method
740 end function
741#endif
742
743#if RK2_ENABLED
744 PURE module function getQuanNEXT_ND1_QD1_WNO_RK2(method, prob, sample) result(quan)
745#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
746 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WNO_RK2
747#endif
748 use pm_kind, only: TKG => RK2
749 real(TKG) , intent(in) , contiguous :: sample(:)
750 real(TKG) , intent(in) , contiguous :: prob(:)
751 real(TKG) :: quan(size(prob, 1, IK))
752 type(neinext_type) , intent(in) :: method
753 end function
754#endif
755
756#if RK1_ENABLED
757 PURE module function getQuanNEXT_ND1_QD1_WNO_RK1(method, prob, sample) result(quan)
758#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
759 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WNO_RK1
760#endif
761 use pm_kind, only: TKG => RK1
762 real(TKG) , intent(in) , contiguous :: sample(:)
763 real(TKG) , intent(in) , contiguous :: prob(:)
764 real(TKG) :: quan(size(prob, 1, IK))
765 type(neinext_type) , intent(in) :: method
766 end function
767#endif
768
769 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
770
771 end interface
772
773 ! ND1 WNO neiprev
774
775 interface getQuan
776
777 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
778
779#if RK5_ENABLED
780 PURE module function getQuanPREV_ND1_QD0_WNO_RK5(method, prob, sample) result(quan)
781#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
782 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WNO_RK5
783#endif
784 use pm_kind, only: TKG => RK5
785 real(TKG) :: quan
786 real(TKG) , intent(in) :: prob
787 real(TKG) , intent(in) , contiguous :: sample(:)
788 type(neiprev_type) , intent(in) :: method
789 end function
790#endif
791
792#if RK4_ENABLED
793 PURE module function getQuanPREV_ND1_QD0_WNO_RK4(method, prob, sample) result(quan)
794#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
795 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WNO_RK4
796#endif
797 use pm_kind, only: TKG => RK4
798 real(TKG) :: quan
799 real(TKG) , intent(in) :: prob
800 real(TKG) , intent(in) , contiguous :: sample(:)
801 type(neiprev_type) , intent(in) :: method
802 end function
803#endif
804
805#if RK3_ENABLED
806 PURE module function getQuanPREV_ND1_QD0_WNO_RK3(method, prob, sample) result(quan)
807#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
808 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WNO_RK3
809#endif
810 use pm_kind, only: TKG => RK3
811 real(TKG) :: quan
812 real(TKG) , intent(in) :: prob
813 real(TKG) , intent(in) , contiguous :: sample(:)
814 type(neiprev_type) , intent(in) :: method
815 end function
816#endif
817
818#if RK2_ENABLED
819 PURE module function getQuanPREV_ND1_QD0_WNO_RK2(method, prob, sample) result(quan)
820#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
821 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WNO_RK2
822#endif
823 use pm_kind, only: TKG => RK2
824 real(TKG) :: quan
825 real(TKG) , intent(in) :: prob
826 real(TKG) , intent(in) , contiguous :: sample(:)
827 type(neiprev_type) , intent(in) :: method
828 end function
829#endif
830
831#if RK1_ENABLED
832 PURE module function getQuanPREV_ND1_QD0_WNO_RK1(method, prob, sample) result(quan)
833#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
834 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WNO_RK1
835#endif
836 use pm_kind, only: TKG => RK1
837 real(TKG) :: quan
838 real(TKG) , intent(in) :: prob
839 real(TKG) , intent(in) , contiguous :: sample(:)
840 type(neiprev_type) , intent(in) :: method
841 end function
842#endif
843
844 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
845
846#if RK5_ENABLED
847 PURE module function getQuanPREV_ND1_QD1_WNO_RK5(method, prob, sample) result(quan)
848#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
849 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WNO_RK5
850#endif
851 use pm_kind, only: TKG => RK5
852 real(TKG) , intent(in) , contiguous :: sample(:)
853 real(TKG) , intent(in) , contiguous :: prob(:)
854 real(TKG) :: quan(size(prob, 1, IK))
855 type(neiprev_type) , intent(in) :: method
856 end function
857#endif
858
859#if RK4_ENABLED
860 PURE module function getQuanPREV_ND1_QD1_WNO_RK4(method, prob, sample) result(quan)
861#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
862 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WNO_RK4
863#endif
864 use pm_kind, only: TKG => RK4
865 real(TKG) , intent(in) , contiguous :: sample(:)
866 real(TKG) , intent(in) , contiguous :: prob(:)
867 real(TKG) :: quan(size(prob, 1, IK))
868 type(neiprev_type) , intent(in) :: method
869 end function
870#endif
871
872#if RK3_ENABLED
873 PURE module function getQuanPREV_ND1_QD1_WNO_RK3(method, prob, sample) result(quan)
874#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
875 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WNO_RK3
876#endif
877 use pm_kind, only: TKG => RK3
878 real(TKG) , intent(in) , contiguous :: sample(:)
879 real(TKG) , intent(in) , contiguous :: prob(:)
880 real(TKG) :: quan(size(prob, 1, IK))
881 type(neiprev_type) , intent(in) :: method
882 end function
883#endif
884
885#if RK2_ENABLED
886 PURE module function getQuanPREV_ND1_QD1_WNO_RK2(method, prob, sample) result(quan)
887#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
888 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WNO_RK2
889#endif
890 use pm_kind, only: TKG => RK2
891 real(TKG) , intent(in) , contiguous :: sample(:)
892 real(TKG) , intent(in) , contiguous :: prob(:)
893 real(TKG) :: quan(size(prob, 1, IK))
894 type(neiprev_type) , intent(in) :: method
895 end function
896#endif
897
898#if RK1_ENABLED
899 PURE module function getQuanPREV_ND1_QD1_WNO_RK1(method, prob, sample) result(quan)
900#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
901 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WNO_RK1
902#endif
903 use pm_kind, only: TKG => RK1
904 real(TKG) , intent(in) , contiguous :: sample(:)
905 real(TKG) , intent(in) , contiguous :: prob(:)
906 real(TKG) :: quan(size(prob, 1, IK))
907 type(neiprev_type) , intent(in) :: method
908 end function
909#endif
910
911 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
912
913 end interface
914
915 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
916
917 ! ND1 WTI piwilin
918
919 interface getQuan
920
921 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
922
923#if RK5_ENABLED
924 PURE module function getQuanPWLN_ND1_QD0_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
925#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
926 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTI_RK5
927#endif
928 use pm_kind, only: TKG => RK5
929 real(TKG) :: quan
930 real(TKG) , intent(in) :: prob
931 real(TKG) , intent(in) , contiguous :: sample(:)
932 integer(IK) , intent(in) , contiguous :: weight(:)
933 integer(IK) , intent(in) , optional :: weisum
934 type(piwilin_type) , intent(in) :: method
935 end function
936#endif
937
938#if RK4_ENABLED
939 PURE module function getQuanPWLN_ND1_QD0_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
940#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
941 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTI_RK4
942#endif
943 use pm_kind, only: TKG => RK4
944 real(TKG) :: quan
945 real(TKG) , intent(in) :: prob
946 real(TKG) , intent(in) , contiguous :: sample(:)
947 integer(IK) , intent(in) , contiguous :: weight(:)
948 integer(IK) , intent(in) , optional :: weisum
949 type(piwilin_type) , intent(in) :: method
950 end function
951#endif
952
953#if RK3_ENABLED
954 PURE module function getQuanPWLN_ND1_QD0_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
955#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
956 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTI_RK3
957#endif
958 use pm_kind, only: TKG => RK3
959 real(TKG) :: quan
960 real(TKG) , intent(in) :: prob
961 real(TKG) , intent(in) , contiguous :: sample(:)
962 integer(IK) , intent(in) , contiguous :: weight(:)
963 integer(IK) , intent(in) , optional :: weisum
964 type(piwilin_type) , intent(in) :: method
965 end function
966#endif
967
968#if RK2_ENABLED
969 PURE module function getQuanPWLN_ND1_QD0_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
970#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
971 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTI_RK2
972#endif
973 use pm_kind, only: TKG => RK2
974 real(TKG) :: quan
975 real(TKG) , intent(in) :: prob
976 real(TKG) , intent(in) , contiguous :: sample(:)
977 integer(IK) , intent(in) , contiguous :: weight(:)
978 integer(IK) , intent(in) , optional :: weisum
979 type(piwilin_type) , intent(in) :: method
980 end function
981#endif
982
983#if RK1_ENABLED
984 PURE module function getQuanPWLN_ND1_QD0_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
985#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
986 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTI_RK1
987#endif
988 use pm_kind, only: TKG => RK1
989 real(TKG) :: quan
990 real(TKG) , intent(in) :: prob
991 real(TKG) , intent(in) , contiguous :: sample(:)
992 integer(IK) , intent(in) , contiguous :: weight(:)
993 integer(IK) , intent(in) , optional :: weisum
994 type(piwilin_type) , intent(in) :: method
995 end function
996#endif
997
998 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
999
1000#if RK5_ENABLED
1001 PURE module function getQuanPWLN_ND1_QD1_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1002#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1003 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTI_RK5
1004#endif
1005 use pm_kind, only: TKG => RK5
1006 real(TKG) , intent(in) , contiguous :: sample(:)
1007 real(TKG) , intent(in) , contiguous :: prob(:)
1008 real(TKG) :: quan(size(prob, 1, IK))
1009 integer(IK) , intent(in) , contiguous :: weight(:)
1010 integer(IK) , intent(in) , optional :: weisum
1011 type(piwilin_type) , intent(in) :: method
1012 end function
1013#endif
1014
1015#if RK4_ENABLED
1016 PURE module function getQuanPWLN_ND1_QD1_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1017#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1018 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTI_RK4
1019#endif
1020 use pm_kind, only: TKG => RK4
1021 real(TKG) , intent(in) , contiguous :: sample(:)
1022 real(TKG) , intent(in) , contiguous :: prob(:)
1023 real(TKG) :: quan(size(prob, 1, IK))
1024 integer(IK) , intent(in) , contiguous :: weight(:)
1025 integer(IK) , intent(in) , optional :: weisum
1026 type(piwilin_type) , intent(in) :: method
1027 end function
1028#endif
1029
1030#if RK3_ENABLED
1031 PURE module function getQuanPWLN_ND1_QD1_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1032#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1033 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTI_RK3
1034#endif
1035 use pm_kind, only: TKG => RK3
1036 real(TKG) , intent(in) , contiguous :: sample(:)
1037 real(TKG) , intent(in) , contiguous :: prob(:)
1038 real(TKG) :: quan(size(prob, 1, IK))
1039 integer(IK) , intent(in) , contiguous :: weight(:)
1040 integer(IK) , intent(in) , optional :: weisum
1041 type(piwilin_type) , intent(in) :: method
1042 end function
1043#endif
1044
1045#if RK2_ENABLED
1046 PURE module function getQuanPWLN_ND1_QD1_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1047#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1048 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTI_RK2
1049#endif
1050 use pm_kind, only: TKG => RK2
1051 real(TKG) , intent(in) , contiguous :: sample(:)
1052 real(TKG) , intent(in) , contiguous :: prob(:)
1053 real(TKG) :: quan(size(prob, 1, IK))
1054 integer(IK) , intent(in) , contiguous :: weight(:)
1055 integer(IK) , intent(in) , optional :: weisum
1056 type(piwilin_type) , intent(in) :: method
1057 end function
1058#endif
1059
1060#if RK1_ENABLED
1061 PURE module function getQuanPWLN_ND1_QD1_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1062#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1063 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTI_RK1
1064#endif
1065 use pm_kind, only: TKG => RK1
1066 real(TKG) , intent(in) , contiguous :: sample(:)
1067 real(TKG) , intent(in) , contiguous :: prob(:)
1068 real(TKG) :: quan(size(prob, 1, IK))
1069 integer(IK) , intent(in) , contiguous :: weight(:)
1070 integer(IK) , intent(in) , optional :: weisum
1071 type(piwilin_type) , intent(in) :: method
1072 end function
1073#endif
1074
1075 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1076
1077 end interface
1078
1079 ! ND1 WTI neimean
1080
1081 interface getQuan
1082
1083 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1084
1085#if RK5_ENABLED
1086 PURE module function getQuanMEAN_ND1_QD0_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1087#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1088 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTI_RK5
1089#endif
1090 use pm_kind, only: TKG => RK5
1091 real(TKG) :: quan
1092 real(TKG) , intent(in) :: prob
1093 real(TKG) , intent(in) , contiguous :: sample(:)
1094 integer(IK) , intent(in) , contiguous :: weight(:)
1095 integer(IK) , intent(in) , optional :: weisum
1096 type(neimean_type) , intent(in) :: method
1097 end function
1098#endif
1099
1100#if RK4_ENABLED
1101 PURE module function getQuanMEAN_ND1_QD0_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1102#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1103 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTI_RK4
1104#endif
1105 use pm_kind, only: TKG => RK4
1106 real(TKG) :: quan
1107 real(TKG) , intent(in) :: prob
1108 real(TKG) , intent(in) , contiguous :: sample(:)
1109 integer(IK) , intent(in) , contiguous :: weight(:)
1110 integer(IK) , intent(in) , optional :: weisum
1111 type(neimean_type) , intent(in) :: method
1112 end function
1113#endif
1114
1115#if RK3_ENABLED
1116 PURE module function getQuanMEAN_ND1_QD0_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1117#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1118 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTI_RK3
1119#endif
1120 use pm_kind, only: TKG => RK3
1121 real(TKG) :: quan
1122 real(TKG) , intent(in) :: prob
1123 real(TKG) , intent(in) , contiguous :: sample(:)
1124 integer(IK) , intent(in) , contiguous :: weight(:)
1125 integer(IK) , intent(in) , optional :: weisum
1126 type(neimean_type) , intent(in) :: method
1127 end function
1128#endif
1129
1130#if RK2_ENABLED
1131 PURE module function getQuanMEAN_ND1_QD0_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1132#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1133 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTI_RK2
1134#endif
1135 use pm_kind, only: TKG => RK2
1136 real(TKG) :: quan
1137 real(TKG) , intent(in) :: prob
1138 real(TKG) , intent(in) , contiguous :: sample(:)
1139 integer(IK) , intent(in) , contiguous :: weight(:)
1140 integer(IK) , intent(in) , optional :: weisum
1141 type(neimean_type) , intent(in) :: method
1142 end function
1143#endif
1144
1145#if RK1_ENABLED
1146 PURE module function getQuanMEAN_ND1_QD0_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1147#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1148 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTI_RK1
1149#endif
1150 use pm_kind, only: TKG => RK1
1151 real(TKG) :: quan
1152 real(TKG) , intent(in) :: prob
1153 real(TKG) , intent(in) , contiguous :: sample(:)
1154 integer(IK) , intent(in) , contiguous :: weight(:)
1155 integer(IK) , intent(in) , optional :: weisum
1156 type(neimean_type) , intent(in) :: method
1157 end function
1158#endif
1159
1160 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1161
1162#if RK5_ENABLED
1163 PURE module function getQuanMEAN_ND1_QD1_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1164#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1165 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTI_RK5
1166#endif
1167 use pm_kind, only: TKG => RK5
1168 real(TKG) , intent(in) , contiguous :: sample(:)
1169 real(TKG) , intent(in) , contiguous :: prob(:)
1170 real(TKG) :: quan(size(prob, 1, IK))
1171 integer(IK) , intent(in) , contiguous :: weight(:)
1172 integer(IK) , intent(in) , optional :: weisum
1173 type(neimean_type) , intent(in) :: method
1174 end function
1175#endif
1176
1177#if RK4_ENABLED
1178 PURE module function getQuanMEAN_ND1_QD1_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1179#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1180 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTI_RK4
1181#endif
1182 use pm_kind, only: TKG => RK4
1183 real(TKG) , intent(in) , contiguous :: sample(:)
1184 real(TKG) , intent(in) , contiguous :: prob(:)
1185 real(TKG) :: quan(size(prob, 1, IK))
1186 integer(IK) , intent(in) , contiguous :: weight(:)
1187 integer(IK) , intent(in) , optional :: weisum
1188 type(neimean_type) , intent(in) :: method
1189 end function
1190#endif
1191
1192#if RK3_ENABLED
1193 PURE module function getQuanMEAN_ND1_QD1_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1194#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1195 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTI_RK3
1196#endif
1197 use pm_kind, only: TKG => RK3
1198 real(TKG) , intent(in) , contiguous :: sample(:)
1199 real(TKG) , intent(in) , contiguous :: prob(:)
1200 real(TKG) :: quan(size(prob, 1, IK))
1201 integer(IK) , intent(in) , contiguous :: weight(:)
1202 integer(IK) , intent(in) , optional :: weisum
1203 type(neimean_type) , intent(in) :: method
1204 end function
1205#endif
1206
1207#if RK2_ENABLED
1208 PURE module function getQuanMEAN_ND1_QD1_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1209#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1210 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTI_RK2
1211#endif
1212 use pm_kind, only: TKG => RK2
1213 real(TKG) , intent(in) , contiguous :: sample(:)
1214 real(TKG) , intent(in) , contiguous :: prob(:)
1215 real(TKG) :: quan(size(prob, 1, IK))
1216 integer(IK) , intent(in) , contiguous :: weight(:)
1217 integer(IK) , intent(in) , optional :: weisum
1218 type(neimean_type) , intent(in) :: method
1219 end function
1220#endif
1221
1222#if RK1_ENABLED
1223 PURE module function getQuanMEAN_ND1_QD1_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1224#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1225 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTI_RK1
1226#endif
1227 use pm_kind, only: TKG => RK1
1228 real(TKG) , intent(in) , contiguous :: sample(:)
1229 real(TKG) , intent(in) , contiguous :: prob(:)
1230 real(TKG) :: quan(size(prob, 1, IK))
1231 integer(IK) , intent(in) , contiguous :: weight(:)
1232 integer(IK) , intent(in) , optional :: weisum
1233 type(neimean_type) , intent(in) :: method
1234 end function
1235#endif
1236
1237 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1238
1239 end interface
1240
1241 ! ND1 WTI neinear
1242
1243 interface getQuan
1244
1245 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1246
1247#if RK5_ENABLED
1248 PURE module function getQuanNEAR_ND1_QD0_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1249#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1250 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTI_RK5
1251#endif
1252 use pm_kind, only: TKG => RK5
1253 real(TKG) :: quan
1254 real(TKG) , intent(in) :: prob
1255 real(TKG) , intent(in) , contiguous :: sample(:)
1256 integer(IK) , intent(in) , contiguous :: weight(:)
1257 integer(IK) , intent(in) , optional :: weisum
1258 type(neinear_type) , intent(in) :: method
1259 end function
1260#endif
1261
1262#if RK4_ENABLED
1263 PURE module function getQuanNEAR_ND1_QD0_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1264#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1265 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTI_RK4
1266#endif
1267 use pm_kind, only: TKG => RK4
1268 real(TKG) :: quan
1269 real(TKG) , intent(in) :: prob
1270 real(TKG) , intent(in) , contiguous :: sample(:)
1271 integer(IK) , intent(in) , contiguous :: weight(:)
1272 integer(IK) , intent(in) , optional :: weisum
1273 type(neinear_type) , intent(in) :: method
1274 end function
1275#endif
1276
1277#if RK3_ENABLED
1278 PURE module function getQuanNEAR_ND1_QD0_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1279#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1280 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTI_RK3
1281#endif
1282 use pm_kind, only: TKG => RK3
1283 real(TKG) :: quan
1284 real(TKG) , intent(in) :: prob
1285 real(TKG) , intent(in) , contiguous :: sample(:)
1286 integer(IK) , intent(in) , contiguous :: weight(:)
1287 integer(IK) , intent(in) , optional :: weisum
1288 type(neinear_type) , intent(in) :: method
1289 end function
1290#endif
1291
1292#if RK2_ENABLED
1293 PURE module function getQuanNEAR_ND1_QD0_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1294#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1295 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTI_RK2
1296#endif
1297 use pm_kind, only: TKG => RK2
1298 real(TKG) :: quan
1299 real(TKG) , intent(in) :: prob
1300 real(TKG) , intent(in) , contiguous :: sample(:)
1301 integer(IK) , intent(in) , contiguous :: weight(:)
1302 integer(IK) , intent(in) , optional :: weisum
1303 type(neinear_type) , intent(in) :: method
1304 end function
1305#endif
1306
1307#if RK1_ENABLED
1308 PURE module function getQuanNEAR_ND1_QD0_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1309#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1310 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTI_RK1
1311#endif
1312 use pm_kind, only: TKG => RK1
1313 real(TKG) :: quan
1314 real(TKG) , intent(in) :: prob
1315 real(TKG) , intent(in) , contiguous :: sample(:)
1316 integer(IK) , intent(in) , contiguous :: weight(:)
1317 integer(IK) , intent(in) , optional :: weisum
1318 type(neinear_type) , intent(in) :: method
1319 end function
1320#endif
1321
1322 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1323
1324#if RK5_ENABLED
1325 PURE module function getQuanNEAR_ND1_QD1_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1326#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1327 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTI_RK5
1328#endif
1329 use pm_kind, only: TKG => RK5
1330 real(TKG) , intent(in) , contiguous :: sample(:)
1331 real(TKG) , intent(in) , contiguous :: prob(:)
1332 real(TKG) :: quan(size(prob, 1, IK))
1333 integer(IK) , intent(in) , contiguous :: weight(:)
1334 integer(IK) , intent(in) , optional :: weisum
1335 type(neinear_type) , intent(in) :: method
1336 end function
1337#endif
1338
1339#if RK4_ENABLED
1340 PURE module function getQuanNEAR_ND1_QD1_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1341#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1342 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTI_RK4
1343#endif
1344 use pm_kind, only: TKG => RK4
1345 real(TKG) , intent(in) , contiguous :: sample(:)
1346 real(TKG) , intent(in) , contiguous :: prob(:)
1347 real(TKG) :: quan(size(prob, 1, IK))
1348 integer(IK) , intent(in) , contiguous :: weight(:)
1349 integer(IK) , intent(in) , optional :: weisum
1350 type(neinear_type) , intent(in) :: method
1351 end function
1352#endif
1353
1354#if RK3_ENABLED
1355 PURE module function getQuanNEAR_ND1_QD1_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1356#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1357 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTI_RK3
1358#endif
1359 use pm_kind, only: TKG => RK3
1360 real(TKG) , intent(in) , contiguous :: sample(:)
1361 real(TKG) , intent(in) , contiguous :: prob(:)
1362 real(TKG) :: quan(size(prob, 1, IK))
1363 integer(IK) , intent(in) , contiguous :: weight(:)
1364 integer(IK) , intent(in) , optional :: weisum
1365 type(neinear_type) , intent(in) :: method
1366 end function
1367#endif
1368
1369#if RK2_ENABLED
1370 PURE module function getQuanNEAR_ND1_QD1_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1371#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1372 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTI_RK2
1373#endif
1374 use pm_kind, only: TKG => RK2
1375 real(TKG) , intent(in) , contiguous :: sample(:)
1376 real(TKG) , intent(in) , contiguous :: prob(:)
1377 real(TKG) :: quan(size(prob, 1, IK))
1378 integer(IK) , intent(in) , contiguous :: weight(:)
1379 integer(IK) , intent(in) , optional :: weisum
1380 type(neinear_type) , intent(in) :: method
1381 end function
1382#endif
1383
1384#if RK1_ENABLED
1385 PURE module function getQuanNEAR_ND1_QD1_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1386#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1387 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTI_RK1
1388#endif
1389 use pm_kind, only: TKG => RK1
1390 real(TKG) , intent(in) , contiguous :: sample(:)
1391 real(TKG) , intent(in) , contiguous :: prob(:)
1392 real(TKG) :: quan(size(prob, 1, IK))
1393 integer(IK) , intent(in) , contiguous :: weight(:)
1394 integer(IK) , intent(in) , optional :: weisum
1395 type(neinear_type) , intent(in) :: method
1396 end function
1397#endif
1398
1399 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1400
1401 end interface
1402
1403 ! ND1 WTI neinext
1404
1405 interface getQuan
1406
1407 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1408
1409#if RK5_ENABLED
1410 PURE module function getQuanNEXT_ND1_QD0_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1411#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1412 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTI_RK5
1413#endif
1414 use pm_kind, only: TKG => RK5
1415 real(TKG) :: quan
1416 real(TKG) , intent(in) :: prob
1417 real(TKG) , intent(in) , contiguous :: sample(:)
1418 integer(IK) , intent(in) , contiguous :: weight(:)
1419 integer(IK) , intent(in) , optional :: weisum
1420 type(neinext_type) , intent(in) :: method
1421 end function
1422#endif
1423
1424#if RK4_ENABLED
1425 PURE module function getQuanNEXT_ND1_QD0_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1426#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1427 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTI_RK4
1428#endif
1429 use pm_kind, only: TKG => RK4
1430 real(TKG) :: quan
1431 real(TKG) , intent(in) :: prob
1432 real(TKG) , intent(in) , contiguous :: sample(:)
1433 integer(IK) , intent(in) , contiguous :: weight(:)
1434 integer(IK) , intent(in) , optional :: weisum
1435 type(neinext_type) , intent(in) :: method
1436 end function
1437#endif
1438
1439#if RK3_ENABLED
1440 PURE module function getQuanNEXT_ND1_QD0_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1441#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1442 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTI_RK3
1443#endif
1444 use pm_kind, only: TKG => RK3
1445 real(TKG) :: quan
1446 real(TKG) , intent(in) :: prob
1447 real(TKG) , intent(in) , contiguous :: sample(:)
1448 integer(IK) , intent(in) , contiguous :: weight(:)
1449 integer(IK) , intent(in) , optional :: weisum
1450 type(neinext_type) , intent(in) :: method
1451 end function
1452#endif
1453
1454#if RK2_ENABLED
1455 PURE module function getQuanNEXT_ND1_QD0_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1456#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1457 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTI_RK2
1458#endif
1459 use pm_kind, only: TKG => RK2
1460 real(TKG) , intent(in) :: prob
1461 real(TKG) :: quan
1462 real(TKG) , intent(in) , contiguous :: sample(:)
1463 integer(IK) , intent(in) , contiguous :: weight(:)
1464 integer(IK) , intent(in) , optional :: weisum
1465 type(neinext_type) , intent(in) :: method
1466 end function
1467#endif
1468
1469#if RK1_ENABLED
1470 PURE module function getQuanNEXT_ND1_QD0_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1471#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1472 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTI_RK1
1473#endif
1474 use pm_kind, only: TKG => RK1
1475 real(TKG) :: quan
1476 real(TKG) , intent(in) :: prob
1477 real(TKG) , intent(in) , contiguous :: sample(:)
1478 integer(IK) , intent(in) , contiguous :: weight(:)
1479 integer(IK) , intent(in) , optional :: weisum
1480 type(neinext_type) , intent(in) :: method
1481 end function
1482#endif
1483
1484 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1485
1486#if RK5_ENABLED
1487 PURE module function getQuanNEXT_ND1_QD1_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1488#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1489 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTI_RK5
1490#endif
1491 use pm_kind, only: TKG => RK5
1492 real(TKG) , intent(in) , contiguous :: sample(:)
1493 real(TKG) , intent(in) , contiguous :: prob(:)
1494 real(TKG) :: quan(size(prob, 1, IK))
1495 integer(IK) , intent(in) , contiguous :: weight(:)
1496 integer(IK) , intent(in) , optional :: weisum
1497 type(neinext_type) , intent(in) :: method
1498 end function
1499#endif
1500
1501#if RK4_ENABLED
1502 PURE module function getQuanNEXT_ND1_QD1_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1503#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1504 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTI_RK4
1505#endif
1506 use pm_kind, only: TKG => RK4
1507 real(TKG) , intent(in) , contiguous :: sample(:)
1508 real(TKG) , intent(in) , contiguous :: prob(:)
1509 real(TKG) :: quan(size(prob, 1, IK))
1510 integer(IK) , intent(in) , contiguous :: weight(:)
1511 integer(IK) , intent(in) , optional :: weisum
1512 type(neinext_type) , intent(in) :: method
1513 end function
1514#endif
1515
1516#if RK3_ENABLED
1517 PURE module function getQuanNEXT_ND1_QD1_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1518#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1519 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTI_RK3
1520#endif
1521 use pm_kind, only: TKG => RK3
1522 real(TKG) , intent(in) , contiguous :: sample(:)
1523 real(TKG) , intent(in) , contiguous :: prob(:)
1524 real(TKG) :: quan(size(prob, 1, IK))
1525 integer(IK) , intent(in) , contiguous :: weight(:)
1526 integer(IK) , intent(in) , optional :: weisum
1527 type(neinext_type) , intent(in) :: method
1528 end function
1529#endif
1530
1531#if RK2_ENABLED
1532 PURE module function getQuanNEXT_ND1_QD1_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1533#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1534 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTI_RK2
1535#endif
1536 use pm_kind, only: TKG => RK2
1537 real(TKG) , intent(in) , contiguous :: sample(:)
1538 real(TKG) , intent(in) , contiguous :: prob(:)
1539 real(TKG) :: quan(size(prob, 1, IK))
1540 integer(IK) , intent(in) , contiguous :: weight(:)
1541 integer(IK) , intent(in) , optional :: weisum
1542 type(neinext_type) , intent(in) :: method
1543 end function
1544#endif
1545
1546#if RK1_ENABLED
1547 PURE module function getQuanNEXT_ND1_QD1_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1548#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1549 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTI_RK1
1550#endif
1551 use pm_kind, only: TKG => RK1
1552 real(TKG) , intent(in) , contiguous :: sample(:)
1553 real(TKG) , intent(in) , contiguous :: prob(:)
1554 real(TKG) :: quan(size(prob, 1, IK))
1555 integer(IK) , intent(in) , contiguous :: weight(:)
1556 integer(IK) , intent(in) , optional :: weisum
1557 type(neinext_type) , intent(in) :: method
1558 end function
1559#endif
1560
1561 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1562
1563 end interface
1564
1565 ! ND1 WTI neiprev
1566
1567 interface getQuan
1568
1569 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1570
1571#if RK5_ENABLED
1572 PURE module function getQuanPREV_ND1_QD0_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1573#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1574 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTI_RK5
1575#endif
1576 use pm_kind, only: TKG => RK5
1577 real(TKG) :: quan
1578 real(TKG) , intent(in) :: prob
1579 real(TKG) , intent(in) , contiguous :: sample(:)
1580 integer(IK) , intent(in) , contiguous :: weight(:)
1581 integer(IK) , intent(in) , optional :: weisum
1582 type(neiprev_type) , intent(in) :: method
1583 end function
1584#endif
1585
1586#if RK4_ENABLED
1587 PURE module function getQuanPREV_ND1_QD0_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1588#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1589 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTI_RK4
1590#endif
1591 use pm_kind, only: TKG => RK4
1592 real(TKG) :: quan
1593 real(TKG) , intent(in) :: prob
1594 real(TKG) , intent(in) , contiguous :: sample(:)
1595 integer(IK) , intent(in) , contiguous :: weight(:)
1596 integer(IK) , intent(in) , optional :: weisum
1597 type(neiprev_type) , intent(in) :: method
1598 end function
1599#endif
1600
1601#if RK3_ENABLED
1602 PURE module function getQuanPREV_ND1_QD0_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1603#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1604 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTI_RK3
1605#endif
1606 use pm_kind, only: TKG => RK3
1607 real(TKG) :: quan
1608 real(TKG) , intent(in) :: prob
1609 real(TKG) , intent(in) , contiguous :: sample(:)
1610 integer(IK) , intent(in) , contiguous :: weight(:)
1611 integer(IK) , intent(in) , optional :: weisum
1612 type(neiprev_type) , intent(in) :: method
1613 end function
1614#endif
1615
1616#if RK2_ENABLED
1617 PURE module function getQuanPREV_ND1_QD0_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1618#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1619 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTI_RK2
1620#endif
1621 use pm_kind, only: TKG => RK2
1622 real(TKG) :: quan
1623 real(TKG) , intent(in) :: prob
1624 real(TKG) , intent(in) , contiguous :: sample(:)
1625 integer(IK) , intent(in) , contiguous :: weight(:)
1626 integer(IK) , intent(in) , optional :: weisum
1627 type(neiprev_type) , intent(in) :: method
1628 end function
1629#endif
1630
1631#if RK1_ENABLED
1632 PURE module function getQuanPREV_ND1_QD0_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1633#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1634 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTI_RK1
1635#endif
1636 use pm_kind, only: TKG => RK1
1637 real(TKG) :: quan
1638 real(TKG) , intent(in) :: prob
1639 real(TKG) , intent(in) , contiguous :: sample(:)
1640 integer(IK) , intent(in) , contiguous :: weight(:)
1641 integer(IK) , intent(in) , optional :: weisum
1642 type(neiprev_type) , intent(in) :: method
1643 end function
1644#endif
1645
1646 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1647
1648#if RK5_ENABLED
1649 PURE module function getQuanPREV_ND1_QD1_WTI_RK5(method, prob, sample, weight, weisum) result(quan)
1650#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1651 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTI_RK5
1652#endif
1653 use pm_kind, only: TKG => RK5
1654 real(TKG) , intent(in) , contiguous :: sample(:)
1655 real(TKG) , intent(in) , contiguous :: prob(:)
1656 real(TKG) :: quan(size(prob, 1, IK))
1657 integer(IK) , intent(in) , contiguous :: weight(:)
1658 integer(IK) , intent(in) , optional :: weisum
1659 type(neiprev_type) , intent(in) :: method
1660 end function
1661#endif
1662
1663#if RK4_ENABLED
1664 PURE module function getQuanPREV_ND1_QD1_WTI_RK4(method, prob, sample, weight, weisum) result(quan)
1665#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1666 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTI_RK4
1667#endif
1668 use pm_kind, only: TKG => RK4
1669 real(TKG) , intent(in) , contiguous :: sample(:)
1670 real(TKG) , intent(in) , contiguous :: prob(:)
1671 real(TKG) :: quan(size(prob, 1, IK))
1672 integer(IK) , intent(in) , contiguous :: weight(:)
1673 integer(IK) , intent(in) , optional :: weisum
1674 type(neiprev_type) , intent(in) :: method
1675 end function
1676#endif
1677
1678#if RK3_ENABLED
1679 PURE module function getQuanPREV_ND1_QD1_WTI_RK3(method, prob, sample, weight, weisum) result(quan)
1680#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1681 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTI_RK3
1682#endif
1683 use pm_kind, only: TKG => RK3
1684 real(TKG) , intent(in) , contiguous :: sample(:)
1685 real(TKG) , intent(in) , contiguous :: prob(:)
1686 real(TKG) :: quan(size(prob, 1, IK))
1687 integer(IK) , intent(in) , contiguous :: weight(:)
1688 integer(IK) , intent(in) , optional :: weisum
1689 type(neiprev_type) , intent(in) :: method
1690 end function
1691#endif
1692
1693#if RK2_ENABLED
1694 PURE module function getQuanPREV_ND1_QD1_WTI_RK2(method, prob, sample, weight, weisum) result(quan)
1695#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1696 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTI_RK2
1697#endif
1698 use pm_kind, only: TKG => RK2
1699 real(TKG) , intent(in) , contiguous :: sample(:)
1700 real(TKG) , intent(in) , contiguous :: prob(:)
1701 real(TKG) :: quan(size(prob, 1, IK))
1702 integer(IK) , intent(in) , contiguous :: weight(:)
1703 integer(IK) , intent(in) , optional :: weisum
1704 type(neiprev_type) , intent(in) :: method
1705 end function
1706#endif
1707
1708#if RK1_ENABLED
1709 PURE module function getQuanPREV_ND1_QD1_WTI_RK1(method, prob, sample, weight, weisum) result(quan)
1710#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1711 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTI_RK1
1712#endif
1713 use pm_kind, only: TKG => RK1
1714 real(TKG) , intent(in) , contiguous :: sample(:)
1715 real(TKG) , intent(in) , contiguous :: prob(:)
1716 real(TKG) :: quan(size(prob, 1, IK))
1717 integer(IK) , intent(in) , contiguous :: weight(:)
1718 integer(IK) , intent(in) , optional :: weisum
1719 type(neiprev_type) , intent(in) :: method
1720 end function
1721#endif
1722
1723 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1724
1725 end interface
1726
1727 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1728
1729 ! ND1 WTR piwilin
1730
1731 interface getQuan
1732
1733 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1734
1735#if RK5_ENABLED
1736 PURE module function getQuanPWLN_ND1_QD0_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
1737#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1738 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTR_RK5
1739#endif
1740 use pm_kind, only: TKG => RK5
1741 real(TKG) :: quan
1742 real(TKG) , intent(in) :: prob
1743 real(TKG) , intent(in) , contiguous :: sample(:)
1744 real(TKG) , intent(in) , contiguous :: weight(:)
1745 real(TKG) , intent(in) , optional :: weisum
1746 type(piwilin_type) , intent(in) :: method
1747 end function
1748#endif
1749
1750#if RK4_ENABLED
1751 PURE module function getQuanPWLN_ND1_QD0_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
1752#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1753 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTR_RK4
1754#endif
1755 use pm_kind, only: TKG => RK4
1756 real(TKG) :: quan
1757 real(TKG) , intent(in) :: prob
1758 real(TKG) , intent(in) , contiguous :: sample(:)
1759 real(TKG) , intent(in) , contiguous :: weight(:)
1760 real(TKG) , intent(in) , optional :: weisum
1761 type(piwilin_type) , intent(in) :: method
1762 end function
1763#endif
1764
1765#if RK3_ENABLED
1766 PURE module function getQuanPWLN_ND1_QD0_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
1767#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1768 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTR_RK3
1769#endif
1770 use pm_kind, only: TKG => RK3
1771 real(TKG) :: quan
1772 real(TKG) , intent(in) :: prob
1773 real(TKG) , intent(in) , contiguous :: sample(:)
1774 real(TKG) , intent(in) , contiguous :: weight(:)
1775 real(TKG) , intent(in) , optional :: weisum
1776 type(piwilin_type) , intent(in) :: method
1777 end function
1778#endif
1779
1780#if RK2_ENABLED
1781 PURE module function getQuanPWLN_ND1_QD0_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
1782#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1783 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTR_RK2
1784#endif
1785 use pm_kind, only: TKG => RK2
1786 real(TKG) :: quan
1787 real(TKG) , intent(in) :: prob
1788 real(TKG) , intent(in) , contiguous :: sample(:)
1789 real(TKG) , intent(in) , contiguous :: weight(:)
1790 real(TKG) , intent(in) , optional :: weisum
1791 type(piwilin_type) , intent(in) :: method
1792 end function
1793#endif
1794
1795#if RK1_ENABLED
1796 PURE module function getQuanPWLN_ND1_QD0_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
1797#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1798 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD0_WTR_RK1
1799#endif
1800 use pm_kind, only: TKG => RK1
1801 real(TKG) :: quan
1802 real(TKG) , intent(in) :: prob
1803 real(TKG) , intent(in) , contiguous :: sample(:)
1804 real(TKG) , intent(in) , contiguous :: weight(:)
1805 real(TKG) , intent(in) , optional :: weisum
1806 type(piwilin_type) , intent(in) :: method
1807 end function
1808#endif
1809
1810 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1811
1812#if RK5_ENABLED
1813 PURE module function getQuanPWLN_ND1_QD1_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
1814#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1815 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTR_RK5
1816#endif
1817 use pm_kind, only: TKG => RK5
1818 real(TKG) , intent(in) , contiguous :: sample(:)
1819 real(TKG) , intent(in) , contiguous :: prob(:)
1820 real(TKG) :: quan(size(prob, 1, IK))
1821 real(TKG) , intent(in) , contiguous :: weight(:)
1822 real(TKG) , intent(in) , optional :: weisum
1823 type(piwilin_type) , intent(in) :: method
1824 end function
1825#endif
1826
1827#if RK4_ENABLED
1828 PURE module function getQuanPWLN_ND1_QD1_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
1829#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1830 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTR_RK4
1831#endif
1832 use pm_kind, only: TKG => RK4
1833 real(TKG) , intent(in) , contiguous :: sample(:)
1834 real(TKG) , intent(in) , contiguous :: prob(:)
1835 real(TKG) :: quan(size(prob, 1, IK))
1836 real(TKG) , intent(in) , contiguous :: weight(:)
1837 real(TKG) , intent(in) , optional :: weisum
1838 type(piwilin_type) , intent(in) :: method
1839 end function
1840#endif
1841
1842#if RK3_ENABLED
1843 PURE module function getQuanPWLN_ND1_QD1_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
1844#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1845 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTR_RK3
1846#endif
1847 use pm_kind, only: TKG => RK3
1848 real(TKG) , intent(in) , contiguous :: sample(:)
1849 real(TKG) , intent(in) , contiguous :: prob(:)
1850 real(TKG) :: quan(size(prob, 1, IK))
1851 real(TKG) , intent(in) , contiguous :: weight(:)
1852 real(TKG) , intent(in) , optional :: weisum
1853 type(piwilin_type) , intent(in) :: method
1854 end function
1855#endif
1856
1857#if RK2_ENABLED
1858 PURE module function getQuanPWLN_ND1_QD1_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
1859#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1860 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTR_RK2
1861#endif
1862 use pm_kind, only: TKG => RK2
1863 real(TKG) , intent(in) , contiguous :: sample(:)
1864 real(TKG) , intent(in) , contiguous :: prob(:)
1865 real(TKG) :: quan(size(prob, 1, IK))
1866 real(TKG) , intent(in) , contiguous :: weight(:)
1867 real(TKG) , intent(in) , optional :: weisum
1868 type(piwilin_type) , intent(in) :: method
1869 end function
1870#endif
1871
1872#if RK1_ENABLED
1873 PURE module function getQuanPWLN_ND1_QD1_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
1874#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1875 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND1_QD1_WTR_RK1
1876#endif
1877 use pm_kind, only: TKG => RK1
1878 real(TKG) , intent(in) , contiguous :: sample(:)
1879 real(TKG) , intent(in) , contiguous :: prob(:)
1880 real(TKG) :: quan(size(prob, 1, IK))
1881 real(TKG) , intent(in) , contiguous :: weight(:)
1882 real(TKG) , intent(in) , optional :: weisum
1883 type(piwilin_type) , intent(in) :: method
1884 end function
1885#endif
1886
1887 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1888
1889 end interface
1890
1891 ! ND1 WTR neimean
1892
1893 interface getQuan
1894
1895 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1896
1897#if RK5_ENABLED
1898 PURE module function getQuanMEAN_ND1_QD0_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
1899#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1900 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTR_RK5
1901#endif
1902 use pm_kind, only: TKG => RK5
1903 real(TKG) :: quan
1904 real(TKG) , intent(in) :: prob
1905 real(TKG) , intent(in) , contiguous :: sample(:)
1906 real(TKG) , intent(in) , contiguous :: weight(:)
1907 real(TKG) , intent(in) , optional :: weisum
1908 type(neimean_type) , intent(in) :: method
1909 end function
1910#endif
1911
1912#if RK4_ENABLED
1913 PURE module function getQuanMEAN_ND1_QD0_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
1914#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1915 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTR_RK4
1916#endif
1917 use pm_kind, only: TKG => RK4
1918 real(TKG) :: quan
1919 real(TKG) , intent(in) :: prob
1920 real(TKG) , intent(in) , contiguous :: sample(:)
1921 real(TKG) , intent(in) , contiguous :: weight(:)
1922 real(TKG) , intent(in) , optional :: weisum
1923 type(neimean_type) , intent(in) :: method
1924 end function
1925#endif
1926
1927#if RK3_ENABLED
1928 PURE module function getQuanMEAN_ND1_QD0_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
1929#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1930 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTR_RK3
1931#endif
1932 use pm_kind, only: TKG => RK3
1933 real(TKG) :: quan
1934 real(TKG) , intent(in) :: prob
1935 real(TKG) , intent(in) , contiguous :: sample(:)
1936 real(TKG) , intent(in) , contiguous :: weight(:)
1937 real(TKG) , intent(in) , optional :: weisum
1938 type(neimean_type) , intent(in) :: method
1939 end function
1940#endif
1941
1942#if RK2_ENABLED
1943 PURE module function getQuanMEAN_ND1_QD0_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
1944#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1945 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTR_RK2
1946#endif
1947 use pm_kind, only: TKG => RK2
1948 real(TKG) :: quan
1949 real(TKG) , intent(in) :: prob
1950 real(TKG) , intent(in) , contiguous :: sample(:)
1951 real(TKG) , intent(in) , contiguous :: weight(:)
1952 real(TKG) , intent(in) , optional :: weisum
1953 type(neimean_type) , intent(in) :: method
1954 end function
1955#endif
1956
1957#if RK1_ENABLED
1958 PURE module function getQuanMEAN_ND1_QD0_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
1959#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1960 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD0_WTR_RK1
1961#endif
1962 use pm_kind, only: TKG => RK1
1963 real(TKG) :: quan
1964 real(TKG) , intent(in) :: prob
1965 real(TKG) , intent(in) , contiguous :: sample(:)
1966 real(TKG) , intent(in) , contiguous :: weight(:)
1967 real(TKG) , intent(in) , optional :: weisum
1968 type(neimean_type) , intent(in) :: method
1969 end function
1970#endif
1971
1972 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1973
1974#if RK5_ENABLED
1975 PURE module function getQuanMEAN_ND1_QD1_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
1976#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1977 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTR_RK5
1978#endif
1979 use pm_kind, only: TKG => RK5
1980 real(TKG) , intent(in) , contiguous :: sample(:)
1981 real(TKG) , intent(in) , contiguous :: prob(:)
1982 real(TKG) :: quan(size(prob, 1, IK))
1983 real(TKG) , intent(in) , contiguous :: weight(:)
1984 real(TKG) , intent(in) , optional :: weisum
1985 type(neimean_type) , intent(in) :: method
1986 end function
1987#endif
1988
1989#if RK4_ENABLED
1990 PURE module function getQuanMEAN_ND1_QD1_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
1991#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1992 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTR_RK4
1993#endif
1994 use pm_kind, only: TKG => RK4
1995 real(TKG) , intent(in) , contiguous :: sample(:)
1996 real(TKG) , intent(in) , contiguous :: prob(:)
1997 real(TKG) :: quan(size(prob, 1, IK))
1998 real(TKG) , intent(in) , contiguous :: weight(:)
1999 real(TKG) , intent(in) , optional :: weisum
2000 type(neimean_type) , intent(in) :: method
2001 end function
2002#endif
2003
2004#if RK3_ENABLED
2005 PURE module function getQuanMEAN_ND1_QD1_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2006#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2007 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTR_RK3
2008#endif
2009 use pm_kind, only: TKG => RK3
2010 real(TKG) , intent(in) , contiguous :: sample(:)
2011 real(TKG) , intent(in) , contiguous :: prob(:)
2012 real(TKG) :: quan(size(prob, 1, IK))
2013 real(TKG) , intent(in) , contiguous :: weight(:)
2014 real(TKG) , intent(in) , optional :: weisum
2015 type(neimean_type) , intent(in) :: method
2016 end function
2017#endif
2018
2019#if RK2_ENABLED
2020 PURE module function getQuanMEAN_ND1_QD1_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2021#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2022 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTR_RK2
2023#endif
2024 use pm_kind, only: TKG => RK2
2025 real(TKG) , intent(in) , contiguous :: sample(:)
2026 real(TKG) , intent(in) , contiguous :: prob(:)
2027 real(TKG) :: quan(size(prob, 1, IK))
2028 real(TKG) , intent(in) , contiguous :: weight(:)
2029 real(TKG) , intent(in) , optional :: weisum
2030 type(neimean_type) , intent(in) :: method
2031 end function
2032#endif
2033
2034#if RK1_ENABLED
2035 PURE module function getQuanMEAN_ND1_QD1_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2036#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2037 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND1_QD1_WTR_RK1
2038#endif
2039 use pm_kind, only: TKG => RK1
2040 real(TKG) , intent(in) , contiguous :: sample(:)
2041 real(TKG) , intent(in) , contiguous :: prob(:)
2042 real(TKG) :: quan(size(prob, 1, IK))
2043 real(TKG) , intent(in) , contiguous :: weight(:)
2044 real(TKG) , intent(in) , optional :: weisum
2045 type(neimean_type) , intent(in) :: method
2046 end function
2047#endif
2048
2049 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2050
2051 end interface
2052
2053 ! ND1 WTR neinear
2054
2055 interface getQuan
2056
2057 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2058
2059#if RK5_ENABLED
2060 PURE module function getQuanNEAR_ND1_QD0_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
2061#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2062 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTR_RK5
2063#endif
2064 use pm_kind, only: TKG => RK5
2065 real(TKG) :: quan
2066 real(TKG) , intent(in) :: prob
2067 real(TKG) , intent(in) , contiguous :: sample(:)
2068 real(TKG) , intent(in) , contiguous :: weight(:)
2069 real(TKG) , intent(in) , optional :: weisum
2070 type(neinear_type) , intent(in) :: method
2071 end function
2072#endif
2073
2074#if RK4_ENABLED
2075 PURE module function getQuanNEAR_ND1_QD0_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
2076#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2077 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTR_RK4
2078#endif
2079 use pm_kind, only: TKG => RK4
2080 real(TKG) :: quan
2081 real(TKG) , intent(in) :: prob
2082 real(TKG) , intent(in) , contiguous :: sample(:)
2083 real(TKG) , intent(in) , contiguous :: weight(:)
2084 real(TKG) , intent(in) , optional :: weisum
2085 type(neinear_type) , intent(in) :: method
2086 end function
2087#endif
2088
2089#if RK3_ENABLED
2090 PURE module function getQuanNEAR_ND1_QD0_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2091#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2092 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTR_RK3
2093#endif
2094 use pm_kind, only: TKG => RK3
2095 real(TKG) :: quan
2096 real(TKG) , intent(in) :: prob
2097 real(TKG) , intent(in) , contiguous :: sample(:)
2098 real(TKG) , intent(in) , contiguous :: weight(:)
2099 real(TKG) , intent(in) , optional :: weisum
2100 type(neinear_type) , intent(in) :: method
2101 end function
2102#endif
2103
2104#if RK2_ENABLED
2105 PURE module function getQuanNEAR_ND1_QD0_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2106#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2107 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTR_RK2
2108#endif
2109 use pm_kind, only: TKG => RK2
2110 real(TKG) :: quan
2111 real(TKG) , intent(in) :: prob
2112 real(TKG) , intent(in) , contiguous :: sample(:)
2113 real(TKG) , intent(in) , contiguous :: weight(:)
2114 real(TKG) , intent(in) , optional :: weisum
2115 type(neinear_type) , intent(in) :: method
2116 end function
2117#endif
2118
2119#if RK1_ENABLED
2120 PURE module function getQuanNEAR_ND1_QD0_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2121#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2122 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD0_WTR_RK1
2123#endif
2124 use pm_kind, only: TKG => RK1
2125 real(TKG) :: quan
2126 real(TKG) , intent(in) :: prob
2127 real(TKG) , intent(in) , contiguous :: sample(:)
2128 real(TKG) , intent(in) , contiguous :: weight(:)
2129 real(TKG) , intent(in) , optional :: weisum
2130 type(neinear_type) , intent(in) :: method
2131 end function
2132#endif
2133
2134 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2135
2136#if RK5_ENABLED
2137 PURE module function getQuanNEAR_ND1_QD1_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
2138#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2139 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTR_RK5
2140#endif
2141 use pm_kind, only: TKG => RK5
2142 real(TKG) , intent(in) , contiguous :: sample(:)
2143 real(TKG) , intent(in) , contiguous :: prob(:)
2144 real(TKG) :: quan(size(prob, 1, IK))
2145 real(TKG) , intent(in) , contiguous :: weight(:)
2146 real(TKG) , intent(in) , optional :: weisum
2147 type(neinear_type) , intent(in) :: method
2148 end function
2149#endif
2150
2151#if RK4_ENABLED
2152 PURE module function getQuanNEAR_ND1_QD1_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
2153#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2154 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTR_RK4
2155#endif
2156 use pm_kind, only: TKG => RK4
2157 real(TKG) , intent(in) , contiguous :: sample(:)
2158 real(TKG) , intent(in) , contiguous :: prob(:)
2159 real(TKG) :: quan(size(prob, 1, IK))
2160 real(TKG) , intent(in) , contiguous :: weight(:)
2161 real(TKG) , intent(in) , optional :: weisum
2162 type(neinear_type) , intent(in) :: method
2163 end function
2164#endif
2165
2166#if RK3_ENABLED
2167 PURE module function getQuanNEAR_ND1_QD1_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2168#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2169 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTR_RK3
2170#endif
2171 use pm_kind, only: TKG => RK3
2172 real(TKG) , intent(in) , contiguous :: sample(:)
2173 real(TKG) , intent(in) , contiguous :: prob(:)
2174 real(TKG) :: quan(size(prob, 1, IK))
2175 real(TKG) , intent(in) , contiguous :: weight(:)
2176 real(TKG) , intent(in) , optional :: weisum
2177 type(neinear_type) , intent(in) :: method
2178 end function
2179#endif
2180
2181#if RK2_ENABLED
2182 PURE module function getQuanNEAR_ND1_QD1_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2183#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2184 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTR_RK2
2185#endif
2186 use pm_kind, only: TKG => RK2
2187 real(TKG) , intent(in) , contiguous :: sample(:)
2188 real(TKG) , intent(in) , contiguous :: prob(:)
2189 real(TKG) :: quan(size(prob, 1, IK))
2190 real(TKG) , intent(in) , contiguous :: weight(:)
2191 real(TKG) , intent(in) , optional :: weisum
2192 type(neinear_type) , intent(in) :: method
2193 end function
2194#endif
2195
2196#if RK1_ENABLED
2197 PURE module function getQuanNEAR_ND1_QD1_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2198#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2199 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND1_QD1_WTR_RK1
2200#endif
2201 use pm_kind, only: TKG => RK1
2202 real(TKG) , intent(in) , contiguous :: sample(:)
2203 real(TKG) , intent(in) , contiguous :: prob(:)
2204 real(TKG) :: quan(size(prob, 1, IK))
2205 real(TKG) , intent(in) , contiguous :: weight(:)
2206 real(TKG) , intent(in) , optional :: weisum
2207 type(neinear_type) , intent(in) :: method
2208 end function
2209#endif
2210
2211 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2212
2213 end interface
2214
2215 ! ND1 WTR neinext
2216
2217 interface getQuan
2218
2219 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2220
2221#if RK5_ENABLED
2222 PURE module function getQuanNEXT_ND1_QD0_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
2223#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2224 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTR_RK5
2225#endif
2226 use pm_kind, only: TKG => RK5
2227 real(TKG) :: quan
2228 real(TKG) , intent(in) :: prob
2229 real(TKG) , intent(in) , contiguous :: sample(:)
2230 real(TKG) , intent(in) , contiguous :: weight(:)
2231 real(TKG) , intent(in) , optional :: weisum
2232 type(neinext_type) , intent(in) :: method
2233 end function
2234#endif
2235
2236#if RK4_ENABLED
2237 PURE module function getQuanNEXT_ND1_QD0_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
2238#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2239 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTR_RK4
2240#endif
2241 use pm_kind, only: TKG => RK4
2242 real(TKG) :: quan
2243 real(TKG) , intent(in) :: prob
2244 real(TKG) , intent(in) , contiguous :: sample(:)
2245 real(TKG) , intent(in) , contiguous :: weight(:)
2246 real(TKG) , intent(in) , optional :: weisum
2247 type(neinext_type) , intent(in) :: method
2248 end function
2249#endif
2250
2251#if RK3_ENABLED
2252 PURE module function getQuanNEXT_ND1_QD0_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2253#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2254 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTR_RK3
2255#endif
2256 use pm_kind, only: TKG => RK3
2257 real(TKG) :: quan
2258 real(TKG) , intent(in) :: prob
2259 real(TKG) , intent(in) , contiguous :: sample(:)
2260 real(TKG) , intent(in) , contiguous :: weight(:)
2261 real(TKG) , intent(in) , optional :: weisum
2262 type(neinext_type) , intent(in) :: method
2263 end function
2264#endif
2265
2266#if RK2_ENABLED
2267 PURE module function getQuanNEXT_ND1_QD0_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2268#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2269 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTR_RK2
2270#endif
2271 use pm_kind, only: TKG => RK2
2272 real(TKG) , intent(in) :: prob
2273 real(TKG) :: quan
2274 real(TKG) , intent(in) , contiguous :: sample(:)
2275 real(TKG) , intent(in) , contiguous :: weight(:)
2276 real(TKG) , intent(in) , optional :: weisum
2277 type(neinext_type) , intent(in) :: method
2278 end function
2279#endif
2280
2281#if RK1_ENABLED
2282 PURE module function getQuanNEXT_ND1_QD0_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2283#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2284 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD0_WTR_RK1
2285#endif
2286 use pm_kind, only: TKG => RK1
2287 real(TKG) :: quan
2288 real(TKG) , intent(in) :: prob
2289 real(TKG) , intent(in) , contiguous :: sample(:)
2290 real(TKG) , intent(in) , contiguous :: weight(:)
2291 real(TKG) , intent(in) , optional :: weisum
2292 type(neinext_type) , intent(in) :: method
2293 end function
2294#endif
2295
2296 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2297
2298#if RK5_ENABLED
2299 PURE module function getQuanNEXT_ND1_QD1_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
2300#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2301 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTR_RK5
2302#endif
2303 use pm_kind, only: TKG => RK5
2304 real(TKG) , intent(in) , contiguous :: sample(:)
2305 real(TKG) , intent(in) , contiguous :: prob(:)
2306 real(TKG) :: quan(size(prob, 1, IK))
2307 real(TKG) , intent(in) , contiguous :: weight(:)
2308 real(TKG) , intent(in) , optional :: weisum
2309 type(neinext_type) , intent(in) :: method
2310 end function
2311#endif
2312
2313#if RK4_ENABLED
2314 PURE module function getQuanNEXT_ND1_QD1_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
2315#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2316 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTR_RK4
2317#endif
2318 use pm_kind, only: TKG => RK4
2319 real(TKG) , intent(in) , contiguous :: sample(:)
2320 real(TKG) , intent(in) , contiguous :: prob(:)
2321 real(TKG) :: quan(size(prob, 1, IK))
2322 real(TKG) , intent(in) , contiguous :: weight(:)
2323 real(TKG) , intent(in) , optional :: weisum
2324 type(neinext_type) , intent(in) :: method
2325 end function
2326#endif
2327
2328#if RK3_ENABLED
2329 PURE module function getQuanNEXT_ND1_QD1_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2330#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2331 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTR_RK3
2332#endif
2333 use pm_kind, only: TKG => RK3
2334 real(TKG) , intent(in) , contiguous :: sample(:)
2335 real(TKG) , intent(in) , contiguous :: prob(:)
2336 real(TKG) :: quan(size(prob, 1, IK))
2337 real(TKG) , intent(in) , contiguous :: weight(:)
2338 real(TKG) , intent(in) , optional :: weisum
2339 type(neinext_type) , intent(in) :: method
2340 end function
2341#endif
2342
2343#if RK2_ENABLED
2344 PURE module function getQuanNEXT_ND1_QD1_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2345#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2346 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTR_RK2
2347#endif
2348 use pm_kind, only: TKG => RK2
2349 real(TKG) , intent(in) , contiguous :: sample(:)
2350 real(TKG) , intent(in) , contiguous :: prob(:)
2351 real(TKG) :: quan(size(prob, 1, IK))
2352 real(TKG) , intent(in) , contiguous :: weight(:)
2353 real(TKG) , intent(in) , optional :: weisum
2354 type(neinext_type) , intent(in) :: method
2355 end function
2356#endif
2357
2358#if RK1_ENABLED
2359 PURE module function getQuanNEXT_ND1_QD1_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2360#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2361 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND1_QD1_WTR_RK1
2362#endif
2363 use pm_kind, only: TKG => RK1
2364 real(TKG) , intent(in) , contiguous :: sample(:)
2365 real(TKG) , intent(in) , contiguous :: prob(:)
2366 real(TKG) :: quan(size(prob, 1, IK))
2367 real(TKG) , intent(in) , contiguous :: weight(:)
2368 real(TKG) , intent(in) , optional :: weisum
2369 type(neinext_type) , intent(in) :: method
2370 end function
2371#endif
2372
2373 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2374
2375 end interface
2376
2377 ! ND1 WTR neiprev
2378
2379 interface getQuan
2380
2381 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2382
2383#if RK5_ENABLED
2384 PURE module function getQuanPREV_ND1_QD0_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
2385#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2386 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTR_RK5
2387#endif
2388 use pm_kind, only: TKG => RK5
2389 real(TKG) :: quan
2390 real(TKG) , intent(in) :: prob
2391 real(TKG) , intent(in) , contiguous :: sample(:)
2392 real(TKG) , intent(in) , contiguous :: weight(:)
2393 real(TKG) , intent(in) , optional :: weisum
2394 type(neiprev_type) , intent(in) :: method
2395 end function
2396#endif
2397
2398#if RK4_ENABLED
2399 PURE module function getQuanPREV_ND1_QD0_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
2400#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2401 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTR_RK4
2402#endif
2403 use pm_kind, only: TKG => RK4
2404 real(TKG) :: quan
2405 real(TKG) , intent(in) :: prob
2406 real(TKG) , intent(in) , contiguous :: sample(:)
2407 real(TKG) , intent(in) , contiguous :: weight(:)
2408 real(TKG) , intent(in) , optional :: weisum
2409 type(neiprev_type) , intent(in) :: method
2410 end function
2411#endif
2412
2413#if RK3_ENABLED
2414 PURE module function getQuanPREV_ND1_QD0_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2415#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2416 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTR_RK3
2417#endif
2418 use pm_kind, only: TKG => RK3
2419 real(TKG) :: quan
2420 real(TKG) , intent(in) :: prob
2421 real(TKG) , intent(in) , contiguous :: sample(:)
2422 real(TKG) , intent(in) , contiguous :: weight(:)
2423 real(TKG) , intent(in) , optional :: weisum
2424 type(neiprev_type) , intent(in) :: method
2425 end function
2426#endif
2427
2428#if RK2_ENABLED
2429 PURE module function getQuanPREV_ND1_QD0_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2430#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2431 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTR_RK2
2432#endif
2433 use pm_kind, only: TKG => RK2
2434 real(TKG) :: quan
2435 real(TKG) , intent(in) :: prob
2436 real(TKG) , intent(in) , contiguous :: sample(:)
2437 real(TKG) , intent(in) , contiguous :: weight(:)
2438 real(TKG) , intent(in) , optional :: weisum
2439 type(neiprev_type) , intent(in) :: method
2440 end function
2441#endif
2442
2443#if RK1_ENABLED
2444 PURE module function getQuanPREV_ND1_QD0_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2445#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2446 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD0_WTR_RK1
2447#endif
2448 use pm_kind, only: TKG => RK1
2449 real(TKG) :: quan
2450 real(TKG) , intent(in) :: prob
2451 real(TKG) , intent(in) , contiguous :: sample(:)
2452 real(TKG) , intent(in) , contiguous :: weight(:)
2453 real(TKG) , intent(in) , optional :: weisum
2454 type(neiprev_type) , intent(in) :: method
2455 end function
2456#endif
2457
2458 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2459
2460#if RK5_ENABLED
2461 PURE module function getQuanPREV_ND1_QD1_WTR_RK5(method, prob, sample, weight, weisum) result(quan)
2462#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2463 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTR_RK5
2464#endif
2465 use pm_kind, only: TKG => RK5
2466 real(TKG) , intent(in) , contiguous :: sample(:)
2467 real(TKG) , intent(in) , contiguous :: prob(:)
2468 real(TKG) :: quan(size(prob, 1, IK))
2469 real(TKG) , intent(in) , contiguous :: weight(:)
2470 real(TKG) , intent(in) , optional :: weisum
2471 type(neiprev_type) , intent(in) :: method
2472 end function
2473#endif
2474
2475#if RK4_ENABLED
2476 PURE module function getQuanPREV_ND1_QD1_WTR_RK4(method, prob, sample, weight, weisum) result(quan)
2477#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2478 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTR_RK4
2479#endif
2480 use pm_kind, only: TKG => RK4
2481 real(TKG) , intent(in) , contiguous :: sample(:)
2482 real(TKG) , intent(in) , contiguous :: prob(:)
2483 real(TKG) :: quan(size(prob, 1, IK))
2484 real(TKG) , intent(in) , contiguous :: weight(:)
2485 real(TKG) , intent(in) , optional :: weisum
2486 type(neiprev_type) , intent(in) :: method
2487 end function
2488#endif
2489
2490#if RK3_ENABLED
2491 PURE module function getQuanPREV_ND1_QD1_WTR_RK3(method, prob, sample, weight, weisum) result(quan)
2492#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2493 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTR_RK3
2494#endif
2495 use pm_kind, only: TKG => RK3
2496 real(TKG) , intent(in) , contiguous :: sample(:)
2497 real(TKG) , intent(in) , contiguous :: prob(:)
2498 real(TKG) :: quan(size(prob, 1, IK))
2499 real(TKG) , intent(in) , contiguous :: weight(:)
2500 real(TKG) , intent(in) , optional :: weisum
2501 type(neiprev_type) , intent(in) :: method
2502 end function
2503#endif
2504
2505#if RK2_ENABLED
2506 PURE module function getQuanPREV_ND1_QD1_WTR_RK2(method, prob, sample, weight, weisum) result(quan)
2507#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2508 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTR_RK2
2509#endif
2510 use pm_kind, only: TKG => RK2
2511 real(TKG) , intent(in) , contiguous :: sample(:)
2512 real(TKG) , intent(in) , contiguous :: prob(:)
2513 real(TKG) :: quan(size(prob, 1, IK))
2514 real(TKG) , intent(in) , contiguous :: weight(:)
2515 real(TKG) , intent(in) , optional :: weisum
2516 type(neiprev_type) , intent(in) :: method
2517 end function
2518#endif
2519
2520#if RK1_ENABLED
2521 PURE module function getQuanPREV_ND1_QD1_WTR_RK1(method, prob, sample, weight, weisum) result(quan)
2522#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2523 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND1_QD1_WTR_RK1
2524#endif
2525 use pm_kind, only: TKG => RK1
2526 real(TKG) , intent(in) , contiguous :: sample(:)
2527 real(TKG) , intent(in) , contiguous :: prob(:)
2528 real(TKG) :: quan(size(prob, 1, IK))
2529 real(TKG) , intent(in) , contiguous :: weight(:)
2530 real(TKG) , intent(in) , optional :: weisum
2531 type(neiprev_type) , intent(in) :: method
2532 end function
2533#endif
2534
2535 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2536
2537 end interface
2538
2539 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2540
2541 ! ND2 WNO piwilin
2542
2543 interface getQuan
2544
2545 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2546
2547#if RK5_ENABLED
2548 PURE module function getQuanPWLN_ND2_QD0_WNO_RK5(method, prob, sample, dim) result(quan)
2549#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2550 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WNO_RK5
2551#endif
2552 use pm_kind, only: TKG => RK5
2553 integer(IK) , intent(in) :: dim
2554 real(TKG) , intent(in) , contiguous :: sample(:,:)
2555 real(TKG) , intent(in) :: prob
2556 real(TKG) :: quan(size(sample, 3 - dim, IK))
2557 type(piwilin_type) , intent(in) :: method
2558 end function
2559#endif
2560
2561#if RK4_ENABLED
2562 PURE module function getQuanPWLN_ND2_QD0_WNO_RK4(method, prob, sample, dim) result(quan)
2563#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2564 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WNO_RK4
2565#endif
2566 use pm_kind, only: TKG => RK4
2567 integer(IK) , intent(in) :: dim
2568 real(TKG) , intent(in) , contiguous :: sample(:,:)
2569 real(TKG) , intent(in) :: prob
2570 real(TKG) :: quan(size(sample, 3 - dim, IK))
2571 type(piwilin_type) , intent(in) :: method
2572 end function
2573#endif
2574
2575#if RK3_ENABLED
2576 PURE module function getQuanPWLN_ND2_QD0_WNO_RK3(method, prob, sample, dim) result(quan)
2577#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2578 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WNO_RK3
2579#endif
2580 use pm_kind, only: TKG => RK3
2581 integer(IK) , intent(in) :: dim
2582 real(TKG) , intent(in) , contiguous :: sample(:,:)
2583 real(TKG) , intent(in) :: prob
2584 real(TKG) :: quan(size(sample, 3 - dim, IK))
2585 type(piwilin_type) , intent(in) :: method
2586 end function
2587#endif
2588
2589#if RK2_ENABLED
2590 PURE module function getQuanPWLN_ND2_QD0_WNO_RK2(method, prob, sample, dim) result(quan)
2591#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2592 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WNO_RK2
2593#endif
2594 use pm_kind, only: TKG => RK2
2595 integer(IK) , intent(in) :: dim
2596 real(TKG) , intent(in) , contiguous :: sample(:,:)
2597 real(TKG) , intent(in) :: prob
2598 real(TKG) :: quan(size(sample, 3 - dim, IK))
2599 type(piwilin_type) , intent(in) :: method
2600 end function
2601#endif
2602
2603#if RK1_ENABLED
2604 PURE module function getQuanPWLN_ND2_QD0_WNO_RK1(method, prob, sample, dim) result(quan)
2605#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2606 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WNO_RK1
2607#endif
2608 use pm_kind, only: TKG => RK1
2609 integer(IK) , intent(in) :: dim
2610 real(TKG) , intent(in) , contiguous :: sample(:,:)
2611 real(TKG) , intent(in) :: prob
2612 real(TKG) :: quan(size(sample, 3 - dim, IK))
2613 type(piwilin_type) , intent(in) :: method
2614 end function
2615#endif
2616
2617 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2618
2619#if RK5_ENABLED
2620 PURE module function getQuanPWLN_ND2_QD1_WNO_RK5(method, prob, sample, dim) result(quan)
2621#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2622 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WNO_RK5
2623#endif
2624 use pm_kind, only: TKG => RK5
2625 integer(IK) , intent(in) :: dim
2626 real(TKG) , intent(in) , contiguous :: sample(:,:)
2627 real(TKG) , intent(in) , contiguous :: prob(:)
2628 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2629 type(piwilin_type) , intent(in) :: method
2630 end function
2631#endif
2632
2633#if RK4_ENABLED
2634 PURE module function getQuanPWLN_ND2_QD1_WNO_RK4(method, prob, sample, dim) result(quan)
2635#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2636 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WNO_RK4
2637#endif
2638 use pm_kind, only: TKG => RK4
2639 integer(IK) , intent(in) :: dim
2640 real(TKG) , intent(in) , contiguous :: sample(:,:)
2641 real(TKG) , intent(in) , contiguous :: prob(:)
2642 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2643 type(piwilin_type) , intent(in) :: method
2644 end function
2645#endif
2646
2647#if RK3_ENABLED
2648 PURE module function getQuanPWLN_ND2_QD1_WNO_RK3(method, prob, sample, dim) result(quan)
2649#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2650 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WNO_RK3
2651#endif
2652 use pm_kind, only: TKG => RK3
2653 integer(IK) , intent(in) :: dim
2654 real(TKG) , intent(in) , contiguous :: sample(:,:)
2655 real(TKG) , intent(in) , contiguous :: prob(:)
2656 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2657 type(piwilin_type) , intent(in) :: method
2658 end function
2659#endif
2660
2661#if RK2_ENABLED
2662 PURE module function getQuanPWLN_ND2_QD1_WNO_RK2(method, prob, sample, dim) result(quan)
2663#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2664 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WNO_RK2
2665#endif
2666 use pm_kind, only: TKG => RK2
2667 integer(IK) , intent(in) :: dim
2668 real(TKG) , intent(in) , contiguous :: sample(:,:)
2669 real(TKG) , intent(in) , contiguous :: prob(:)
2670 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2671 type(piwilin_type) , intent(in) :: method
2672 end function
2673#endif
2674
2675#if RK1_ENABLED
2676 PURE module function getQuanPWLN_ND2_QD1_WNO_RK1(method, prob, sample, dim) result(quan)
2677#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2678 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WNO_RK1
2679#endif
2680 use pm_kind, only: TKG => RK1
2681 integer(IK) , intent(in) :: dim
2682 real(TKG) , intent(in) , contiguous :: sample(:,:)
2683 real(TKG) , intent(in) , contiguous :: prob(:)
2684 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2685 type(piwilin_type) , intent(in) :: method
2686 end function
2687#endif
2688
2689 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2690
2691 end interface
2692
2693 ! ND2 WNO neimean
2694
2695 interface getQuan
2696
2697 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2698
2699#if RK5_ENABLED
2700 PURE module function getQuanMEAN_ND2_QD0_WNO_RK5(method, prob, sample, dim) result(quan)
2701#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2702 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WNO_RK5
2703#endif
2704 use pm_kind, only: TKG => RK5
2705 integer(IK) , intent(in) :: dim
2706 real(TKG) , intent(in) , contiguous :: sample(:,:)
2707 real(TKG) , intent(in) :: prob
2708 real(TKG) :: quan(size(sample, 3 - dim, IK))
2709 type(neimean_type) , intent(in) :: method
2710 end function
2711#endif
2712
2713#if RK4_ENABLED
2714 PURE module function getQuanMEAN_ND2_QD0_WNO_RK4(method, prob, sample, dim) result(quan)
2715#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2716 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WNO_RK4
2717#endif
2718 use pm_kind, only: TKG => RK4
2719 integer(IK) , intent(in) :: dim
2720 real(TKG) , intent(in) , contiguous :: sample(:,:)
2721 real(TKG) , intent(in) :: prob
2722 real(TKG) :: quan(size(sample, 3 - dim, IK))
2723 type(neimean_type) , intent(in) :: method
2724 end function
2725#endif
2726
2727#if RK3_ENABLED
2728 PURE module function getQuanMEAN_ND2_QD0_WNO_RK3(method, prob, sample, dim) result(quan)
2729#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2730 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WNO_RK3
2731#endif
2732 use pm_kind, only: TKG => RK3
2733 integer(IK) , intent(in) :: dim
2734 real(TKG) , intent(in) , contiguous :: sample(:,:)
2735 real(TKG) , intent(in) :: prob
2736 real(TKG) :: quan(size(sample, 3 - dim, IK))
2737 type(neimean_type) , intent(in) :: method
2738 end function
2739#endif
2740
2741#if RK2_ENABLED
2742 PURE module function getQuanMEAN_ND2_QD0_WNO_RK2(method, prob, sample, dim) result(quan)
2743#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2744 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WNO_RK2
2745#endif
2746 use pm_kind, only: TKG => RK2
2747 integer(IK) , intent(in) :: dim
2748 real(TKG) , intent(in) , contiguous :: sample(:,:)
2749 real(TKG) , intent(in) :: prob
2750 real(TKG) :: quan(size(sample, 3 - dim, IK))
2751 type(neimean_type) , intent(in) :: method
2752 end function
2753#endif
2754
2755#if RK1_ENABLED
2756 PURE module function getQuanMEAN_ND2_QD0_WNO_RK1(method, prob, sample, dim) result(quan)
2757#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2758 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WNO_RK1
2759#endif
2760 use pm_kind, only: TKG => RK1
2761 integer(IK) , intent(in) :: dim
2762 real(TKG) , intent(in) , contiguous :: sample(:,:)
2763 real(TKG) , intent(in) :: prob
2764 real(TKG) :: quan(size(sample, 3 - dim, IK))
2765 type(neimean_type) , intent(in) :: method
2766 end function
2767#endif
2768
2769 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2770
2771#if RK5_ENABLED
2772 PURE module function getQuanMEAN_ND2_QD1_WNO_RK5(method, prob, sample, dim) result(quan)
2773#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2774 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WNO_RK5
2775#endif
2776 use pm_kind, only: TKG => RK5
2777 integer(IK) , intent(in) :: dim
2778 real(TKG) , intent(in) , contiguous :: sample(:,:)
2779 real(TKG) , intent(in) , contiguous :: prob(:)
2780 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2781 type(neimean_type) , intent(in) :: method
2782 end function
2783#endif
2784
2785#if RK4_ENABLED
2786 PURE module function getQuanMEAN_ND2_QD1_WNO_RK4(method, prob, sample, dim) result(quan)
2787#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2788 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WNO_RK4
2789#endif
2790 use pm_kind, only: TKG => RK4
2791 integer(IK) , intent(in) :: dim
2792 real(TKG) , intent(in) , contiguous :: sample(:,:)
2793 real(TKG) , intent(in) , contiguous :: prob(:)
2794 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2795 type(neimean_type) , intent(in) :: method
2796 end function
2797#endif
2798
2799#if RK3_ENABLED
2800 PURE module function getQuanMEAN_ND2_QD1_WNO_RK3(method, prob, sample, dim) result(quan)
2801#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2802 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WNO_RK3
2803#endif
2804 use pm_kind, only: TKG => RK3
2805 integer(IK) , intent(in) :: dim
2806 real(TKG) , intent(in) , contiguous :: sample(:,:)
2807 real(TKG) , intent(in) , contiguous :: prob(:)
2808 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2809 type(neimean_type) , intent(in) :: method
2810 end function
2811#endif
2812
2813#if RK2_ENABLED
2814 PURE module function getQuanMEAN_ND2_QD1_WNO_RK2(method, prob, sample, dim) result(quan)
2815#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2816 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WNO_RK2
2817#endif
2818 use pm_kind, only: TKG => RK2
2819 integer(IK) , intent(in) :: dim
2820 real(TKG) , intent(in) , contiguous :: sample(:,:)
2821 real(TKG) , intent(in) , contiguous :: prob(:)
2822 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2823 type(neimean_type) , intent(in) :: method
2824 end function
2825#endif
2826
2827#if RK1_ENABLED
2828 PURE module function getQuanMEAN_ND2_QD1_WNO_RK1(method, prob, sample, dim) result(quan)
2829#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2830 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WNO_RK1
2831#endif
2832 use pm_kind, only: TKG => RK1
2833 integer(IK) , intent(in) :: dim
2834 real(TKG) , intent(in) , contiguous :: sample(:,:)
2835 real(TKG) , intent(in) , contiguous :: prob(:)
2836 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2837 type(neimean_type) , intent(in) :: method
2838 end function
2839#endif
2840
2841 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2842
2843 end interface
2844
2845 ! ND2 WNO neinear
2846
2847 interface getQuan
2848
2849 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2850
2851#if RK5_ENABLED
2852 PURE module function getQuanNEAR_ND2_QD0_WNO_RK5(method, prob, sample, dim) result(quan)
2853#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2854 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WNO_RK5
2855#endif
2856 use pm_kind, only: TKG => RK5
2857 integer(IK) , intent(in) :: dim
2858 real(TKG) , intent(in) , contiguous :: sample(:,:)
2859 real(TKG) , intent(in) :: prob
2860 real(TKG) :: quan(size(sample, 3 - dim, IK))
2861 type(neinear_type) , intent(in) :: method
2862 end function
2863#endif
2864
2865#if RK4_ENABLED
2866 PURE module function getQuanNEAR_ND2_QD0_WNO_RK4(method, prob, sample, dim) result(quan)
2867#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2868 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WNO_RK4
2869#endif
2870 use pm_kind, only: TKG => RK4
2871 integer(IK) , intent(in) :: dim
2872 real(TKG) , intent(in) , contiguous :: sample(:,:)
2873 real(TKG) , intent(in) :: prob
2874 real(TKG) :: quan(size(sample, 3 - dim, IK))
2875 type(neinear_type) , intent(in) :: method
2876 end function
2877#endif
2878
2879#if RK3_ENABLED
2880 PURE module function getQuanNEAR_ND2_QD0_WNO_RK3(method, prob, sample, dim) result(quan)
2881#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2882 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WNO_RK3
2883#endif
2884 use pm_kind, only: TKG => RK3
2885 integer(IK) , intent(in) :: dim
2886 real(TKG) , intent(in) , contiguous :: sample(:,:)
2887 real(TKG) , intent(in) :: prob
2888 real(TKG) :: quan(size(sample, 3 - dim, IK))
2889 type(neinear_type) , intent(in) :: method
2890 end function
2891#endif
2892
2893#if RK2_ENABLED
2894 PURE module function getQuanNEAR_ND2_QD0_WNO_RK2(method, prob, sample, dim) result(quan)
2895#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2896 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WNO_RK2
2897#endif
2898 use pm_kind, only: TKG => RK2
2899 integer(IK) , intent(in) :: dim
2900 real(TKG) , intent(in) , contiguous :: sample(:,:)
2901 real(TKG) , intent(in) :: prob
2902 real(TKG) :: quan(size(sample, 3 - dim, IK))
2903 type(neinear_type) , intent(in) :: method
2904 end function
2905#endif
2906
2907#if RK1_ENABLED
2908 PURE module function getQuanNEAR_ND2_QD0_WNO_RK1(method, prob, sample, dim) result(quan)
2909#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2910 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WNO_RK1
2911#endif
2912 use pm_kind, only: TKG => RK1
2913 integer(IK) , intent(in) :: dim
2914 real(TKG) , intent(in) , contiguous :: sample(:,:)
2915 real(TKG) , intent(in) :: prob
2916 real(TKG) :: quan(size(sample, 3 - dim, IK))
2917 type(neinear_type) , intent(in) :: method
2918 end function
2919#endif
2920
2921 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2922
2923#if RK5_ENABLED
2924 PURE module function getQuanNEAR_ND2_QD1_WNO_RK5(method, prob, sample, dim) result(quan)
2925#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2926 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WNO_RK5
2927#endif
2928 use pm_kind, only: TKG => RK5
2929 integer(IK) , intent(in) :: dim
2930 real(TKG) , intent(in) , contiguous :: sample(:,:)
2931 real(TKG) , intent(in) , contiguous :: prob(:)
2932 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2933 type(neinear_type) , intent(in) :: method
2934 end function
2935#endif
2936
2937#if RK4_ENABLED
2938 PURE module function getQuanNEAR_ND2_QD1_WNO_RK4(method, prob, sample, dim) result(quan)
2939#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2940 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WNO_RK4
2941#endif
2942 use pm_kind, only: TKG => RK4
2943 integer(IK) , intent(in) :: dim
2944 real(TKG) , intent(in) , contiguous :: sample(:,:)
2945 real(TKG) , intent(in) , contiguous :: prob(:)
2946 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2947 type(neinear_type) , intent(in) :: method
2948 end function
2949#endif
2950
2951#if RK3_ENABLED
2952 PURE module function getQuanNEAR_ND2_QD1_WNO_RK3(method, prob, sample, dim) result(quan)
2953#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2954 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WNO_RK3
2955#endif
2956 use pm_kind, only: TKG => RK3
2957 integer(IK) , intent(in) :: dim
2958 real(TKG) , intent(in) , contiguous :: sample(:,:)
2959 real(TKG) , intent(in) , contiguous :: prob(:)
2960 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2961 type(neinear_type) , intent(in) :: method
2962 end function
2963#endif
2964
2965#if RK2_ENABLED
2966 PURE module function getQuanNEAR_ND2_QD1_WNO_RK2(method, prob, sample, dim) result(quan)
2967#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2968 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WNO_RK2
2969#endif
2970 use pm_kind, only: TKG => RK2
2971 integer(IK) , intent(in) :: dim
2972 real(TKG) , intent(in) , contiguous :: sample(:,:)
2973 real(TKG) , intent(in) , contiguous :: prob(:)
2974 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2975 type(neinear_type) , intent(in) :: method
2976 end function
2977#endif
2978
2979#if RK1_ENABLED
2980 PURE module function getQuanNEAR_ND2_QD1_WNO_RK1(method, prob, sample, dim) result(quan)
2981#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2982 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WNO_RK1
2983#endif
2984 use pm_kind, only: TKG => RK1
2985 integer(IK) , intent(in) :: dim
2986 real(TKG) , intent(in) , contiguous :: sample(:,:)
2987 real(TKG) , intent(in) , contiguous :: prob(:)
2988 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
2989 type(neinear_type) , intent(in) :: method
2990 end function
2991#endif
2992
2993 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2994
2995 end interface
2996
2997 ! ND2 WNO neinext
2998
2999 interface getQuan
3000
3001 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3002
3003#if RK5_ENABLED
3004 PURE module function getQuanNEXT_ND2_QD0_WNO_RK5(method, prob, sample, dim) result(quan)
3005#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3006 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WNO_RK5
3007#endif
3008 use pm_kind, only: TKG => RK5
3009 integer(IK) , intent(in) :: dim
3010 real(TKG) , intent(in) , contiguous :: sample(:,:)
3011 real(TKG) , intent(in) :: prob
3012 real(TKG) :: quan(size(sample, 3 - dim, IK))
3013 type(neinext_type) , intent(in) :: method
3014 end function
3015#endif
3016
3017#if RK4_ENABLED
3018 PURE module function getQuanNEXT_ND2_QD0_WNO_RK4(method, prob, sample, dim) result(quan)
3019#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3020 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WNO_RK4
3021#endif
3022 use pm_kind, only: TKG => RK4
3023 integer(IK) , intent(in) :: dim
3024 real(TKG) , intent(in) , contiguous :: sample(:,:)
3025 real(TKG) , intent(in) :: prob
3026 real(TKG) :: quan(size(sample, 3 - dim, IK))
3027 type(neinext_type) , intent(in) :: method
3028 end function
3029#endif
3030
3031#if RK3_ENABLED
3032 PURE module function getQuanNEXT_ND2_QD0_WNO_RK3(method, prob, sample, dim) result(quan)
3033#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3034 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WNO_RK3
3035#endif
3036 use pm_kind, only: TKG => RK3
3037 integer(IK) , intent(in) :: dim
3038 real(TKG) , intent(in) , contiguous :: sample(:,:)
3039 real(TKG) , intent(in) :: prob
3040 real(TKG) :: quan(size(sample, 3 - dim, IK))
3041 type(neinext_type) , intent(in) :: method
3042 end function
3043#endif
3044
3045#if RK2_ENABLED
3046 PURE module function getQuanNEXT_ND2_QD0_WNO_RK2(method, prob, sample, dim) result(quan)
3047#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3048 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WNO_RK2
3049#endif
3050 use pm_kind, only: TKG => RK2
3051 integer(IK) , intent(in) :: dim
3052 real(TKG) , intent(in) , contiguous :: sample(:,:)
3053 real(TKG) , intent(in) :: prob
3054 real(TKG) :: quan(size(sample, 3 - dim, IK))
3055 type(neinext_type) , intent(in) :: method
3056 end function
3057#endif
3058
3059#if RK1_ENABLED
3060 PURE module function getQuanNEXT_ND2_QD0_WNO_RK1(method, prob, sample, dim) result(quan)
3061#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3062 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WNO_RK1
3063#endif
3064 use pm_kind, only: TKG => RK1
3065 integer(IK) , intent(in) :: dim
3066 real(TKG) , intent(in) , contiguous :: sample(:,:)
3067 real(TKG) , intent(in) :: prob
3068 real(TKG) :: quan(size(sample, 3 - dim, IK))
3069 type(neinext_type) , intent(in) :: method
3070 end function
3071#endif
3072
3073 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3074
3075#if RK5_ENABLED
3076 PURE module function getQuanNEXT_ND2_QD1_WNO_RK5(method, prob, sample, dim) result(quan)
3077#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3078 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WNO_RK5
3079#endif
3080 use pm_kind, only: TKG => RK5
3081 integer(IK) , intent(in) :: dim
3082 real(TKG) , intent(in) , contiguous :: sample(:,:)
3083 real(TKG) , intent(in) , contiguous :: prob(:)
3084 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3085 type(neinext_type) , intent(in) :: method
3086 end function
3087#endif
3088
3089#if RK4_ENABLED
3090 PURE module function getQuanNEXT_ND2_QD1_WNO_RK4(method, prob, sample, dim) result(quan)
3091#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3092 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WNO_RK4
3093#endif
3094 use pm_kind, only: TKG => RK4
3095 integer(IK) , intent(in) :: dim
3096 real(TKG) , intent(in) , contiguous :: sample(:,:)
3097 real(TKG) , intent(in) , contiguous :: prob(:)
3098 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3099 type(neinext_type) , intent(in) :: method
3100 end function
3101#endif
3102
3103#if RK3_ENABLED
3104 PURE module function getQuanNEXT_ND2_QD1_WNO_RK3(method, prob, sample, dim) result(quan)
3105#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3106 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WNO_RK3
3107#endif
3108 use pm_kind, only: TKG => RK3
3109 integer(IK) , intent(in) :: dim
3110 real(TKG) , intent(in) , contiguous :: sample(:,:)
3111 real(TKG) , intent(in) , contiguous :: prob(:)
3112 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3113 type(neinext_type) , intent(in) :: method
3114 end function
3115#endif
3116
3117#if RK2_ENABLED
3118 PURE module function getQuanNEXT_ND2_QD1_WNO_RK2(method, prob, sample, dim) result(quan)
3119#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3120 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WNO_RK2
3121#endif
3122 use pm_kind, only: TKG => RK2
3123 integer(IK) , intent(in) :: dim
3124 real(TKG) , intent(in) , contiguous :: sample(:,:)
3125 real(TKG) , intent(in) , contiguous :: prob(:)
3126 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3127 type(neinext_type) , intent(in) :: method
3128 end function
3129#endif
3130
3131#if RK1_ENABLED
3132 PURE module function getQuanNEXT_ND2_QD1_WNO_RK1(method, prob, sample, dim) result(quan)
3133#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3134 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WNO_RK1
3135#endif
3136 use pm_kind, only: TKG => RK1
3137 integer(IK) , intent(in) :: dim
3138 real(TKG) , intent(in) , contiguous :: sample(:,:)
3139 real(TKG) , intent(in) , contiguous :: prob(:)
3140 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3141 type(neinext_type) , intent(in) :: method
3142 end function
3143#endif
3144
3145 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3146
3147 end interface
3148
3149 ! ND2 WNO neiprev
3150
3151 interface getQuan
3152
3153 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3154
3155#if RK5_ENABLED
3156 PURE module function getQuanPREV_ND2_QD0_WNO_RK5(method, prob, sample, dim) result(quan)
3157#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3158 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WNO_RK5
3159#endif
3160 use pm_kind, only: TKG => RK5
3161 integer(IK) , intent(in) :: dim
3162 real(TKG) , intent(in) , contiguous :: sample(:,:)
3163 real(TKG) , intent(in) :: prob
3164 real(TKG) :: quan(size(sample, 3 - dim, IK))
3165 type(neiprev_type) , intent(in) :: method
3166 end function
3167#endif
3168
3169#if RK4_ENABLED
3170 PURE module function getQuanPREV_ND2_QD0_WNO_RK4(method, prob, sample, dim) result(quan)
3171#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3172 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WNO_RK4
3173#endif
3174 use pm_kind, only: TKG => RK4
3175 integer(IK) , intent(in) :: dim
3176 real(TKG) , intent(in) , contiguous :: sample(:,:)
3177 real(TKG) , intent(in) :: prob
3178 real(TKG) :: quan(size(sample, 3 - dim, IK))
3179 type(neiprev_type) , intent(in) :: method
3180 end function
3181#endif
3182
3183#if RK3_ENABLED
3184 PURE module function getQuanPREV_ND2_QD0_WNO_RK3(method, prob, sample, dim) result(quan)
3185#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3186 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WNO_RK3
3187#endif
3188 use pm_kind, only: TKG => RK3
3189 integer(IK) , intent(in) :: dim
3190 real(TKG) , intent(in) , contiguous :: sample(:,:)
3191 real(TKG) , intent(in) :: prob
3192 real(TKG) :: quan(size(sample, 3 - dim, IK))
3193 type(neiprev_type) , intent(in) :: method
3194 end function
3195#endif
3196
3197#if RK2_ENABLED
3198 PURE module function getQuanPREV_ND2_QD0_WNO_RK2(method, prob, sample, dim) result(quan)
3199#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3200 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WNO_RK2
3201#endif
3202 use pm_kind, only: TKG => RK2
3203 integer(IK) , intent(in) :: dim
3204 real(TKG) , intent(in) , contiguous :: sample(:,:)
3205 real(TKG) , intent(in) :: prob
3206 real(TKG) :: quan(size(sample, 3 - dim, IK))
3207 type(neiprev_type) , intent(in) :: method
3208 end function
3209#endif
3210
3211#if RK1_ENABLED
3212 PURE module function getQuanPREV_ND2_QD0_WNO_RK1(method, prob, sample, dim) result(quan)
3213#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3214 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WNO_RK1
3215#endif
3216 use pm_kind, only: TKG => RK1
3217 integer(IK) , intent(in) :: dim
3218 real(TKG) , intent(in) , contiguous :: sample(:,:)
3219 real(TKG) , intent(in) :: prob
3220 real(TKG) :: quan(size(sample, 3 - dim, IK))
3221 type(neiprev_type) , intent(in) :: method
3222 end function
3223#endif
3224
3225 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3226
3227#if RK5_ENABLED
3228 PURE module function getQuanPREV_ND2_QD1_WNO_RK5(method, prob, sample, dim) result(quan)
3229#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3230 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WNO_RK5
3231#endif
3232 use pm_kind, only: TKG => RK5
3233 integer(IK) , intent(in) :: dim
3234 real(TKG) , intent(in) , contiguous :: sample(:,:)
3235 real(TKG) , intent(in) , contiguous :: prob(:)
3236 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3237 type(neiprev_type) , intent(in) :: method
3238 end function
3239#endif
3240
3241#if RK4_ENABLED
3242 PURE module function getQuanPREV_ND2_QD1_WNO_RK4(method, prob, sample, dim) result(quan)
3243#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3244 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WNO_RK4
3245#endif
3246 use pm_kind, only: TKG => RK4
3247 integer(IK) , intent(in) :: dim
3248 real(TKG) , intent(in) , contiguous :: sample(:,:)
3249 real(TKG) , intent(in) , contiguous :: prob(:)
3250 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3251 type(neiprev_type) , intent(in) :: method
3252 end function
3253#endif
3254
3255#if RK3_ENABLED
3256 PURE module function getQuanPREV_ND2_QD1_WNO_RK3(method, prob, sample, dim) result(quan)
3257#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3258 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WNO_RK3
3259#endif
3260 use pm_kind, only: TKG => RK3
3261 integer(IK) , intent(in) :: dim
3262 real(TKG) , intent(in) , contiguous :: sample(:,:)
3263 real(TKG) , intent(in) , contiguous :: prob(:)
3264 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3265 type(neiprev_type) , intent(in) :: method
3266 end function
3267#endif
3268
3269#if RK2_ENABLED
3270 PURE module function getQuanPREV_ND2_QD1_WNO_RK2(method, prob, sample, dim) result(quan)
3271#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3272 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WNO_RK2
3273#endif
3274 use pm_kind, only: TKG => RK2
3275 integer(IK) , intent(in) :: dim
3276 real(TKG) , intent(in) , contiguous :: sample(:,:)
3277 real(TKG) , intent(in) , contiguous :: prob(:)
3278 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3279 type(neiprev_type) , intent(in) :: method
3280 end function
3281#endif
3282
3283#if RK1_ENABLED
3284 PURE module function getQuanPREV_ND2_QD1_WNO_RK1(method, prob, sample, dim) result(quan)
3285#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3286 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WNO_RK1
3287#endif
3288 use pm_kind, only: TKG => RK1
3289 integer(IK) , intent(in) :: dim
3290 real(TKG) , intent(in) , contiguous :: sample(:,:)
3291 real(TKG) , intent(in) , contiguous :: prob(:)
3292 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3293 type(neiprev_type) , intent(in) :: method
3294 end function
3295#endif
3296
3297 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3298
3299 end interface
3300
3301 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3302
3303 ! ND2 WTI piwilin
3304
3305 interface getQuan
3306
3307 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3308
3309#if RK5_ENABLED
3310 PURE module function getQuanPWLN_ND2_QD0_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3311#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3312 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTI_RK5
3313#endif
3314 use pm_kind, only: TKG => RK5
3315 integer(IK) , intent(in) :: dim
3316 real(TKG) , intent(in) , contiguous :: sample(:,:)
3317 integer(IK) , intent(in) , contiguous :: weight(:)
3318 integer(IK) , intent(in) , optional :: weisum
3319 real(TKG) , intent(in) :: prob
3320 real(TKG) :: quan(size(sample, 3 - dim, IK))
3321 type(piwilin_type) , intent(in) :: method
3322 end function
3323#endif
3324
3325#if RK4_ENABLED
3326 PURE module function getQuanPWLN_ND2_QD0_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3327#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3328 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTI_RK4
3329#endif
3330 use pm_kind, only: TKG => RK4
3331 integer(IK) , intent(in) :: dim
3332 real(TKG) , intent(in) , contiguous :: sample(:,:)
3333 integer(IK) , intent(in) , contiguous :: weight(:)
3334 integer(IK) , intent(in) , optional :: weisum
3335 real(TKG) , intent(in) :: prob
3336 real(TKG) :: quan(size(sample, 3 - dim, IK))
3337 type(piwilin_type) , intent(in) :: method
3338 end function
3339#endif
3340
3341#if RK3_ENABLED
3342 PURE module function getQuanPWLN_ND2_QD0_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3343#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3344 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTI_RK3
3345#endif
3346 use pm_kind, only: TKG => RK3
3347 integer(IK) , intent(in) :: dim
3348 real(TKG) , intent(in) , contiguous :: sample(:,:)
3349 integer(IK) , intent(in) , contiguous :: weight(:)
3350 integer(IK) , intent(in) , optional :: weisum
3351 real(TKG) , intent(in) :: prob
3352 real(TKG) :: quan(size(sample, 3 - dim, IK))
3353 type(piwilin_type) , intent(in) :: method
3354 end function
3355#endif
3356
3357#if RK2_ENABLED
3358 PURE module function getQuanPWLN_ND2_QD0_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3359#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3360 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTI_RK2
3361#endif
3362 use pm_kind, only: TKG => RK2
3363 integer(IK) , intent(in) :: dim
3364 real(TKG) , intent(in) , contiguous :: sample(:,:)
3365 integer(IK) , intent(in) , contiguous :: weight(:)
3366 integer(IK) , intent(in) , optional :: weisum
3367 real(TKG) , intent(in) :: prob
3368 real(TKG) :: quan(size(sample, 3 - dim, IK))
3369 type(piwilin_type) , intent(in) :: method
3370 end function
3371#endif
3372
3373#if RK1_ENABLED
3374 PURE module function getQuanPWLN_ND2_QD0_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3375#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3376 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTI_RK1
3377#endif
3378 use pm_kind, only: TKG => RK1
3379 integer(IK) , intent(in) :: dim
3380 real(TKG) , intent(in) , contiguous :: sample(:,:)
3381 integer(IK) , intent(in) , contiguous :: weight(:)
3382 integer(IK) , intent(in) , optional :: weisum
3383 real(TKG) , intent(in) :: prob
3384 real(TKG) :: quan(size(sample, 3 - dim, IK))
3385 type(piwilin_type) , intent(in) :: method
3386 end function
3387#endif
3388
3389 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3390
3391#if RK5_ENABLED
3392 PURE module function getQuanPWLN_ND2_QD1_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3393#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3394 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTI_RK5
3395#endif
3396 use pm_kind, only: TKG => RK5
3397 integer(IK) , intent(in) :: dim
3398 real(TKG) , intent(in) , contiguous :: sample(:,:)
3399 real(TKG) , intent(in) , contiguous :: prob(:)
3400 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3401 integer(IK) , intent(in) , contiguous :: weight(:)
3402 integer(IK) , intent(in) , optional :: weisum
3403 type(piwilin_type) , intent(in) :: method
3404 end function
3405#endif
3406
3407#if RK4_ENABLED
3408 PURE module function getQuanPWLN_ND2_QD1_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3409#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3410 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTI_RK4
3411#endif
3412 use pm_kind, only: TKG => RK4
3413 integer(IK) , intent(in) :: dim
3414 real(TKG) , intent(in) , contiguous :: sample(:,:)
3415 real(TKG) , intent(in) , contiguous :: prob(:)
3416 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3417 integer(IK) , intent(in) , contiguous :: weight(:)
3418 integer(IK) , intent(in) , optional :: weisum
3419 type(piwilin_type) , intent(in) :: method
3420 end function
3421#endif
3422
3423#if RK3_ENABLED
3424 PURE module function getQuanPWLN_ND2_QD1_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3425#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3426 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTI_RK3
3427#endif
3428 use pm_kind, only: TKG => RK3
3429 integer(IK) , intent(in) :: dim
3430 real(TKG) , intent(in) , contiguous :: sample(:,:)
3431 real(TKG) , intent(in) , contiguous :: prob(:)
3432 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3433 integer(IK) , intent(in) , contiguous :: weight(:)
3434 integer(IK) , intent(in) , optional :: weisum
3435 type(piwilin_type) , intent(in) :: method
3436 end function
3437#endif
3438
3439#if RK2_ENABLED
3440 PURE module function getQuanPWLN_ND2_QD1_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3441#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3442 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTI_RK2
3443#endif
3444 use pm_kind, only: TKG => RK2
3445 integer(IK) , intent(in) :: dim
3446 real(TKG) , intent(in) , contiguous :: sample(:,:)
3447 real(TKG) , intent(in) , contiguous :: prob(:)
3448 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3449 integer(IK) , intent(in) , contiguous :: weight(:)
3450 integer(IK) , intent(in) , optional :: weisum
3451 type(piwilin_type) , intent(in) :: method
3452 end function
3453#endif
3454
3455#if RK1_ENABLED
3456 PURE module function getQuanPWLN_ND2_QD1_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3457#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3458 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTI_RK1
3459#endif
3460 use pm_kind, only: TKG => RK1
3461 integer(IK) , intent(in) :: dim
3462 real(TKG) , intent(in) , contiguous :: sample(:,:)
3463 real(TKG) , intent(in) , contiguous :: prob(:)
3464 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3465 integer(IK) , intent(in) , contiguous :: weight(:)
3466 integer(IK) , intent(in) , optional :: weisum
3467 type(piwilin_type) , intent(in) :: method
3468 end function
3469#endif
3470
3471 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3472
3473 end interface
3474
3475 ! ND2 WTI neimean
3476
3477 interface getQuan
3478
3479 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3480
3481#if RK5_ENABLED
3482 PURE module function getQuanMEAN_ND2_QD0_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3483#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3484 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTI_RK5
3485#endif
3486 use pm_kind, only: TKG => RK5
3487 integer(IK) , intent(in) :: dim
3488 real(TKG) , intent(in) , contiguous :: sample(:,:)
3489 integer(IK) , intent(in) , contiguous :: weight(:)
3490 integer(IK) , intent(in) , optional :: weisum
3491 real(TKG) , intent(in) :: prob
3492 real(TKG) :: quan(size(sample, 3 - dim, IK))
3493 type(neimean_type) , intent(in) :: method
3494 end function
3495#endif
3496
3497#if RK4_ENABLED
3498 PURE module function getQuanMEAN_ND2_QD0_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3499#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3500 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTI_RK4
3501#endif
3502 use pm_kind, only: TKG => RK4
3503 integer(IK) , intent(in) :: dim
3504 real(TKG) , intent(in) , contiguous :: sample(:,:)
3505 integer(IK) , intent(in) , contiguous :: weight(:)
3506 integer(IK) , intent(in) , optional :: weisum
3507 real(TKG) , intent(in) :: prob
3508 real(TKG) :: quan(size(sample, 3 - dim, IK))
3509 type(neimean_type) , intent(in) :: method
3510 end function
3511#endif
3512
3513#if RK3_ENABLED
3514 PURE module function getQuanMEAN_ND2_QD0_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3515#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3516 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTI_RK3
3517#endif
3518 use pm_kind, only: TKG => RK3
3519 integer(IK) , intent(in) :: dim
3520 real(TKG) , intent(in) , contiguous :: sample(:,:)
3521 integer(IK) , intent(in) , contiguous :: weight(:)
3522 integer(IK) , intent(in) , optional :: weisum
3523 real(TKG) , intent(in) :: prob
3524 real(TKG) :: quan(size(sample, 3 - dim, IK))
3525 type(neimean_type) , intent(in) :: method
3526 end function
3527#endif
3528
3529#if RK2_ENABLED
3530 PURE module function getQuanMEAN_ND2_QD0_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3531#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3532 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTI_RK2
3533#endif
3534 use pm_kind, only: TKG => RK2
3535 integer(IK) , intent(in) :: dim
3536 real(TKG) , intent(in) , contiguous :: sample(:,:)
3537 integer(IK) , intent(in) , contiguous :: weight(:)
3538 integer(IK) , intent(in) , optional :: weisum
3539 real(TKG) , intent(in) :: prob
3540 real(TKG) :: quan(size(sample, 3 - dim, IK))
3541 type(neimean_type) , intent(in) :: method
3542 end function
3543#endif
3544
3545#if RK1_ENABLED
3546 PURE module function getQuanMEAN_ND2_QD0_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3547#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3548 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTI_RK1
3549#endif
3550 use pm_kind, only: TKG => RK1
3551 integer(IK) , intent(in) :: dim
3552 real(TKG) , intent(in) , contiguous :: sample(:,:)
3553 integer(IK) , intent(in) , contiguous :: weight(:)
3554 integer(IK) , intent(in) , optional :: weisum
3555 real(TKG) , intent(in) :: prob
3556 real(TKG) :: quan(size(sample, 3 - dim, IK))
3557 type(neimean_type) , intent(in) :: method
3558 end function
3559#endif
3560
3561 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3562
3563#if RK5_ENABLED
3564 PURE module function getQuanMEAN_ND2_QD1_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3565#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3566 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTI_RK5
3567#endif
3568 use pm_kind, only: TKG => RK5
3569 integer(IK) , intent(in) :: dim
3570 real(TKG) , intent(in) , contiguous :: sample(:,:)
3571 real(TKG) , intent(in) , contiguous :: prob(:)
3572 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3573 integer(IK) , intent(in) , contiguous :: weight(:)
3574 integer(IK) , intent(in) , optional :: weisum
3575 type(neimean_type) , intent(in) :: method
3576 end function
3577#endif
3578
3579#if RK4_ENABLED
3580 PURE module function getQuanMEAN_ND2_QD1_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3581#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3582 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTI_RK4
3583#endif
3584 use pm_kind, only: TKG => RK4
3585 integer(IK) , intent(in) :: dim
3586 real(TKG) , intent(in) , contiguous :: sample(:,:)
3587 real(TKG) , intent(in) , contiguous :: prob(:)
3588 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3589 integer(IK) , intent(in) , contiguous :: weight(:)
3590 integer(IK) , intent(in) , optional :: weisum
3591 type(neimean_type) , intent(in) :: method
3592 end function
3593#endif
3594
3595#if RK3_ENABLED
3596 PURE module function getQuanMEAN_ND2_QD1_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3597#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3598 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTI_RK3
3599#endif
3600 use pm_kind, only: TKG => RK3
3601 integer(IK) , intent(in) :: dim
3602 real(TKG) , intent(in) , contiguous :: sample(:,:)
3603 real(TKG) , intent(in) , contiguous :: prob(:)
3604 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3605 integer(IK) , intent(in) , contiguous :: weight(:)
3606 integer(IK) , intent(in) , optional :: weisum
3607 type(neimean_type) , intent(in) :: method
3608 end function
3609#endif
3610
3611#if RK2_ENABLED
3612 PURE module function getQuanMEAN_ND2_QD1_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3613#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3614 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTI_RK2
3615#endif
3616 use pm_kind, only: TKG => RK2
3617 integer(IK) , intent(in) :: dim
3618 real(TKG) , intent(in) , contiguous :: sample(:,:)
3619 real(TKG) , intent(in) , contiguous :: prob(:)
3620 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3621 integer(IK) , intent(in) , contiguous :: weight(:)
3622 integer(IK) , intent(in) , optional :: weisum
3623 type(neimean_type) , intent(in) :: method
3624 end function
3625#endif
3626
3627#if RK1_ENABLED
3628 PURE module function getQuanMEAN_ND2_QD1_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3629#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3630 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTI_RK1
3631#endif
3632 use pm_kind, only: TKG => RK1
3633 integer(IK) , intent(in) :: dim
3634 real(TKG) , intent(in) , contiguous :: sample(:,:)
3635 real(TKG) , intent(in) , contiguous :: prob(:)
3636 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3637 integer(IK) , intent(in) , contiguous :: weight(:)
3638 integer(IK) , intent(in) , optional :: weisum
3639 type(neimean_type) , intent(in) :: method
3640 end function
3641#endif
3642
3643 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3644
3645 end interface
3646
3647 ! ND2 WTI neinear
3648
3649 interface getQuan
3650
3651 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3652
3653#if RK5_ENABLED
3654 PURE module function getQuanNEAR_ND2_QD0_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3655#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3656 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTI_RK5
3657#endif
3658 use pm_kind, only: TKG => RK5
3659 integer(IK) , intent(in) :: dim
3660 real(TKG) , intent(in) , contiguous :: sample(:,:)
3661 integer(IK) , intent(in) , contiguous :: weight(:)
3662 integer(IK) , intent(in) , optional :: weisum
3663 real(TKG) , intent(in) :: prob
3664 real(TKG) :: quan(size(sample, 3 - dim, IK))
3665 type(neinear_type) , intent(in) :: method
3666 end function
3667#endif
3668
3669#if RK4_ENABLED
3670 PURE module function getQuanNEAR_ND2_QD0_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3671#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3672 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTI_RK4
3673#endif
3674 use pm_kind, only: TKG => RK4
3675 integer(IK) , intent(in) :: dim
3676 real(TKG) , intent(in) , contiguous :: sample(:,:)
3677 integer(IK) , intent(in) , contiguous :: weight(:)
3678 integer(IK) , intent(in) , optional :: weisum
3679 real(TKG) , intent(in) :: prob
3680 real(TKG) :: quan(size(sample, 3 - dim, IK))
3681 type(neinear_type) , intent(in) :: method
3682 end function
3683#endif
3684
3685#if RK3_ENABLED
3686 PURE module function getQuanNEAR_ND2_QD0_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3687#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3688 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTI_RK3
3689#endif
3690 use pm_kind, only: TKG => RK3
3691 integer(IK) , intent(in) :: dim
3692 real(TKG) , intent(in) , contiguous :: sample(:,:)
3693 integer(IK) , intent(in) , contiguous :: weight(:)
3694 integer(IK) , intent(in) , optional :: weisum
3695 real(TKG) , intent(in) :: prob
3696 real(TKG) :: quan(size(sample, 3 - dim, IK))
3697 type(neinear_type) , intent(in) :: method
3698 end function
3699#endif
3700
3701#if RK2_ENABLED
3702 PURE module function getQuanNEAR_ND2_QD0_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3703#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3704 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTI_RK2
3705#endif
3706 use pm_kind, only: TKG => RK2
3707 integer(IK) , intent(in) :: dim
3708 real(TKG) , intent(in) , contiguous :: sample(:,:)
3709 integer(IK) , intent(in) , contiguous :: weight(:)
3710 integer(IK) , intent(in) , optional :: weisum
3711 real(TKG) , intent(in) :: prob
3712 real(TKG) :: quan(size(sample, 3 - dim, IK))
3713 type(neinear_type) , intent(in) :: method
3714 end function
3715#endif
3716
3717#if RK1_ENABLED
3718 PURE module function getQuanNEAR_ND2_QD0_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3719#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3720 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTI_RK1
3721#endif
3722 use pm_kind, only: TKG => RK1
3723 integer(IK) , intent(in) :: dim
3724 real(TKG) , intent(in) , contiguous :: sample(:,:)
3725 integer(IK) , intent(in) , contiguous :: weight(:)
3726 integer(IK) , intent(in) , optional :: weisum
3727 real(TKG) , intent(in) :: prob
3728 real(TKG) :: quan(size(sample, 3 - dim, IK))
3729 type(neinear_type) , intent(in) :: method
3730 end function
3731#endif
3732
3733 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3734
3735#if RK5_ENABLED
3736 PURE module function getQuanNEAR_ND2_QD1_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3737#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3738 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTI_RK5
3739#endif
3740 use pm_kind, only: TKG => RK5
3741 integer(IK) , intent(in) :: dim
3742 real(TKG) , intent(in) , contiguous :: sample(:,:)
3743 real(TKG) , intent(in) , contiguous :: prob(:)
3744 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3745 integer(IK) , intent(in) , contiguous :: weight(:)
3746 integer(IK) , intent(in) , optional :: weisum
3747 type(neinear_type) , intent(in) :: method
3748 end function
3749#endif
3750
3751#if RK4_ENABLED
3752 PURE module function getQuanNEAR_ND2_QD1_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3753#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3754 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTI_RK4
3755#endif
3756 use pm_kind, only: TKG => RK4
3757 integer(IK) , intent(in) :: dim
3758 real(TKG) , intent(in) , contiguous :: sample(:,:)
3759 real(TKG) , intent(in) , contiguous :: prob(:)
3760 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3761 integer(IK) , intent(in) , contiguous :: weight(:)
3762 integer(IK) , intent(in) , optional :: weisum
3763 type(neinear_type) , intent(in) :: method
3764 end function
3765#endif
3766
3767#if RK3_ENABLED
3768 PURE module function getQuanNEAR_ND2_QD1_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3769#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3770 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTI_RK3
3771#endif
3772 use pm_kind, only: TKG => RK3
3773 integer(IK) , intent(in) :: dim
3774 real(TKG) , intent(in) , contiguous :: sample(:,:)
3775 real(TKG) , intent(in) , contiguous :: prob(:)
3776 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3777 integer(IK) , intent(in) , contiguous :: weight(:)
3778 integer(IK) , intent(in) , optional :: weisum
3779 type(neinear_type) , intent(in) :: method
3780 end function
3781#endif
3782
3783#if RK2_ENABLED
3784 PURE module function getQuanNEAR_ND2_QD1_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3785#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3786 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTI_RK2
3787#endif
3788 use pm_kind, only: TKG => RK2
3789 integer(IK) , intent(in) :: dim
3790 real(TKG) , intent(in) , contiguous :: sample(:,:)
3791 real(TKG) , intent(in) , contiguous :: prob(:)
3792 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3793 integer(IK) , intent(in) , contiguous :: weight(:)
3794 integer(IK) , intent(in) , optional :: weisum
3795 type(neinear_type) , intent(in) :: method
3796 end function
3797#endif
3798
3799#if RK1_ENABLED
3800 PURE module function getQuanNEAR_ND2_QD1_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3801#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3802 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTI_RK1
3803#endif
3804 use pm_kind, only: TKG => RK1
3805 integer(IK) , intent(in) :: dim
3806 real(TKG) , intent(in) , contiguous :: sample(:,:)
3807 real(TKG) , intent(in) , contiguous :: prob(:)
3808 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3809 integer(IK) , intent(in) , contiguous :: weight(:)
3810 integer(IK) , intent(in) , optional :: weisum
3811 type(neinear_type) , intent(in) :: method
3812 end function
3813#endif
3814
3815 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3816
3817 end interface
3818
3819 ! ND2 WTI neinext
3820
3821 interface getQuan
3822
3823 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3824
3825#if RK5_ENABLED
3826 PURE module function getQuanNEXT_ND2_QD0_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3827#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3828 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTI_RK5
3829#endif
3830 use pm_kind, only: TKG => RK5
3831 integer(IK) , intent(in) :: dim
3832 real(TKG) , intent(in) , contiguous :: sample(:,:)
3833 integer(IK) , intent(in) , contiguous :: weight(:)
3834 integer(IK) , intent(in) , optional :: weisum
3835 real(TKG) , intent(in) :: prob
3836 real(TKG) :: quan(size(sample, 3 - dim, IK))
3837 type(neinext_type) , intent(in) :: method
3838 end function
3839#endif
3840
3841#if RK4_ENABLED
3842 PURE module function getQuanNEXT_ND2_QD0_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3843#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3844 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTI_RK4
3845#endif
3846 use pm_kind, only: TKG => RK4
3847 integer(IK) , intent(in) :: dim
3848 real(TKG) , intent(in) , contiguous :: sample(:,:)
3849 integer(IK) , intent(in) , contiguous :: weight(:)
3850 integer(IK) , intent(in) , optional :: weisum
3851 real(TKG) , intent(in) :: prob
3852 real(TKG) :: quan(size(sample, 3 - dim, IK))
3853 type(neinext_type) , intent(in) :: method
3854 end function
3855#endif
3856
3857#if RK3_ENABLED
3858 PURE module function getQuanNEXT_ND2_QD0_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3859#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3860 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTI_RK3
3861#endif
3862 use pm_kind, only: TKG => RK3
3863 integer(IK) , intent(in) :: dim
3864 real(TKG) , intent(in) , contiguous :: sample(:,:)
3865 integer(IK) , intent(in) , contiguous :: weight(:)
3866 integer(IK) , intent(in) , optional :: weisum
3867 real(TKG) , intent(in) :: prob
3868 real(TKG) :: quan(size(sample, 3 - dim, IK))
3869 type(neinext_type) , intent(in) :: method
3870 end function
3871#endif
3872
3873#if RK2_ENABLED
3874 PURE module function getQuanNEXT_ND2_QD0_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3875#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3876 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTI_RK2
3877#endif
3878 use pm_kind, only: TKG => RK2
3879 integer(IK) , intent(in) :: dim
3880 real(TKG) , intent(in) , contiguous :: sample(:,:)
3881 integer(IK) , intent(in) , contiguous :: weight(:)
3882 integer(IK) , intent(in) , optional :: weisum
3883 real(TKG) , intent(in) :: prob
3884 real(TKG) :: quan(size(sample, 3 - dim, IK))
3885 type(neinext_type) , intent(in) :: method
3886 end function
3887#endif
3888
3889#if RK1_ENABLED
3890 PURE module function getQuanNEXT_ND2_QD0_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3891#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3892 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTI_RK1
3893#endif
3894 use pm_kind, only: TKG => RK1
3895 integer(IK) , intent(in) :: dim
3896 real(TKG) , intent(in) , contiguous :: sample(:,:)
3897 integer(IK) , intent(in) , contiguous :: weight(:)
3898 integer(IK) , intent(in) , optional :: weisum
3899 real(TKG) , intent(in) :: prob
3900 real(TKG) :: quan(size(sample, 3 - dim, IK))
3901 type(neinext_type) , intent(in) :: method
3902 end function
3903#endif
3904
3905 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3906
3907#if RK5_ENABLED
3908 PURE module function getQuanNEXT_ND2_QD1_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3909#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3910 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTI_RK5
3911#endif
3912 use pm_kind, only: TKG => RK5
3913 integer(IK) , intent(in) :: dim
3914 real(TKG) , intent(in) , contiguous :: sample(:,:)
3915 real(TKG) , intent(in) , contiguous :: prob(:)
3916 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3917 integer(IK) , intent(in) , contiguous :: weight(:)
3918 integer(IK) , intent(in) , optional :: weisum
3919 type(neinext_type) , intent(in) :: method
3920 end function
3921#endif
3922
3923#if RK4_ENABLED
3924 PURE module function getQuanNEXT_ND2_QD1_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
3925#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3926 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTI_RK4
3927#endif
3928 use pm_kind, only: TKG => RK4
3929 integer(IK) , intent(in) :: dim
3930 real(TKG) , intent(in) , contiguous :: sample(:,:)
3931 real(TKG) , intent(in) , contiguous :: prob(:)
3932 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3933 integer(IK) , intent(in) , contiguous :: weight(:)
3934 integer(IK) , intent(in) , optional :: weisum
3935 type(neinext_type) , intent(in) :: method
3936 end function
3937#endif
3938
3939#if RK3_ENABLED
3940 PURE module function getQuanNEXT_ND2_QD1_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
3941#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3942 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTI_RK3
3943#endif
3944 use pm_kind, only: TKG => RK3
3945 integer(IK) , intent(in) :: dim
3946 real(TKG) , intent(in) , contiguous :: sample(:,:)
3947 real(TKG) , intent(in) , contiguous :: prob(:)
3948 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3949 integer(IK) , intent(in) , contiguous :: weight(:)
3950 integer(IK) , intent(in) , optional :: weisum
3951 type(neinext_type) , intent(in) :: method
3952 end function
3953#endif
3954
3955#if RK2_ENABLED
3956 PURE module function getQuanNEXT_ND2_QD1_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
3957#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3958 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTI_RK2
3959#endif
3960 use pm_kind, only: TKG => RK2
3961 integer(IK) , intent(in) :: dim
3962 real(TKG) , intent(in) , contiguous :: sample(:,:)
3963 real(TKG) , intent(in) , contiguous :: prob(:)
3964 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3965 integer(IK) , intent(in) , contiguous :: weight(:)
3966 integer(IK) , intent(in) , optional :: weisum
3967 type(neinext_type) , intent(in) :: method
3968 end function
3969#endif
3970
3971#if RK1_ENABLED
3972 PURE module function getQuanNEXT_ND2_QD1_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
3973#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3974 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTI_RK1
3975#endif
3976 use pm_kind, only: TKG => RK1
3977 integer(IK) , intent(in) :: dim
3978 real(TKG) , intent(in) , contiguous :: sample(:,:)
3979 real(TKG) , intent(in) , contiguous :: prob(:)
3980 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
3981 integer(IK) , intent(in) , contiguous :: weight(:)
3982 integer(IK) , intent(in) , optional :: weisum
3983 type(neinext_type) , intent(in) :: method
3984 end function
3985#endif
3986
3987 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3988
3989 end interface
3990
3991 ! ND2 WTI neiprev
3992
3993 interface getQuan
3994
3995 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3996
3997#if RK5_ENABLED
3998 PURE module function getQuanPREV_ND2_QD0_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
3999#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4000 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTI_RK5
4001#endif
4002 use pm_kind, only: TKG => RK5
4003 integer(IK) , intent(in) :: dim
4004 real(TKG) , intent(in) , contiguous :: sample(:,:)
4005 integer(IK) , intent(in) , contiguous :: weight(:)
4006 integer(IK) , intent(in) , optional :: weisum
4007 real(TKG) , intent(in) :: prob
4008 real(TKG) :: quan(size(sample, 3 - dim, IK))
4009 type(neiprev_type) , intent(in) :: method
4010 end function
4011#endif
4012
4013#if RK4_ENABLED
4014 PURE module function getQuanPREV_ND2_QD0_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4015#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4016 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTI_RK4
4017#endif
4018 use pm_kind, only: TKG => RK4
4019 integer(IK) , intent(in) :: dim
4020 real(TKG) , intent(in) , contiguous :: sample(:,:)
4021 integer(IK) , intent(in) , contiguous :: weight(:)
4022 integer(IK) , intent(in) , optional :: weisum
4023 real(TKG) , intent(in) :: prob
4024 real(TKG) :: quan(size(sample, 3 - dim, IK))
4025 type(neiprev_type) , intent(in) :: method
4026 end function
4027#endif
4028
4029#if RK3_ENABLED
4030 PURE module function getQuanPREV_ND2_QD0_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4031#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4032 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTI_RK3
4033#endif
4034 use pm_kind, only: TKG => RK3
4035 integer(IK) , intent(in) :: dim
4036 real(TKG) , intent(in) , contiguous :: sample(:,:)
4037 integer(IK) , intent(in) , contiguous :: weight(:)
4038 integer(IK) , intent(in) , optional :: weisum
4039 real(TKG) , intent(in) :: prob
4040 real(TKG) :: quan(size(sample, 3 - dim, IK))
4041 type(neiprev_type) , intent(in) :: method
4042 end function
4043#endif
4044
4045#if RK2_ENABLED
4046 PURE module function getQuanPREV_ND2_QD0_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4047#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4048 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTI_RK2
4049#endif
4050 use pm_kind, only: TKG => RK2
4051 integer(IK) , intent(in) :: dim
4052 real(TKG) , intent(in) , contiguous :: sample(:,:)
4053 integer(IK) , intent(in) , contiguous :: weight(:)
4054 integer(IK) , intent(in) , optional :: weisum
4055 real(TKG) , intent(in) :: prob
4056 real(TKG) :: quan(size(sample, 3 - dim, IK))
4057 type(neiprev_type) , intent(in) :: method
4058 end function
4059#endif
4060
4061#if RK1_ENABLED
4062 PURE module function getQuanPREV_ND2_QD0_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4063#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4064 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTI_RK1
4065#endif
4066 use pm_kind, only: TKG => RK1
4067 integer(IK) , intent(in) :: dim
4068 real(TKG) , intent(in) , contiguous :: sample(:,:)
4069 integer(IK) , intent(in) , contiguous :: weight(:)
4070 integer(IK) , intent(in) , optional :: weisum
4071 real(TKG) , intent(in) :: prob
4072 real(TKG) :: quan(size(sample, 3 - dim, IK))
4073 type(neiprev_type) , intent(in) :: method
4074 end function
4075#endif
4076
4077 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4078
4079#if RK5_ENABLED
4080 PURE module function getQuanPREV_ND2_QD1_WTI_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4081#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4082 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTI_RK5
4083#endif
4084 use pm_kind, only: TKG => RK5
4085 integer(IK) , intent(in) :: dim
4086 real(TKG) , intent(in) , contiguous :: sample(:,:)
4087 real(TKG) , intent(in) , contiguous :: prob(:)
4088 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4089 integer(IK) , intent(in) , contiguous :: weight(:)
4090 integer(IK) , intent(in) , optional :: weisum
4091 type(neiprev_type) , intent(in) :: method
4092 end function
4093#endif
4094
4095#if RK4_ENABLED
4096 PURE module function getQuanPREV_ND2_QD1_WTI_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4097#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4098 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTI_RK4
4099#endif
4100 use pm_kind, only: TKG => RK4
4101 integer(IK) , intent(in) :: dim
4102 real(TKG) , intent(in) , contiguous :: sample(:,:)
4103 real(TKG) , intent(in) , contiguous :: prob(:)
4104 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4105 integer(IK) , intent(in) , contiguous :: weight(:)
4106 integer(IK) , intent(in) , optional :: weisum
4107 type(neiprev_type) , intent(in) :: method
4108 end function
4109#endif
4110
4111#if RK3_ENABLED
4112 PURE module function getQuanPREV_ND2_QD1_WTI_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4113#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4114 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTI_RK3
4115#endif
4116 use pm_kind, only: TKG => RK3
4117 integer(IK) , intent(in) :: dim
4118 real(TKG) , intent(in) , contiguous :: sample(:,:)
4119 real(TKG) , intent(in) , contiguous :: prob(:)
4120 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4121 integer(IK) , intent(in) , contiguous :: weight(:)
4122 integer(IK) , intent(in) , optional :: weisum
4123 type(neiprev_type) , intent(in) :: method
4124 end function
4125#endif
4126
4127#if RK2_ENABLED
4128 PURE module function getQuanPREV_ND2_QD1_WTI_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4129#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4130 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTI_RK2
4131#endif
4132 use pm_kind, only: TKG => RK2
4133 integer(IK) , intent(in) :: dim
4134 real(TKG) , intent(in) , contiguous :: sample(:,:)
4135 real(TKG) , intent(in) , contiguous :: prob(:)
4136 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4137 integer(IK) , intent(in) , contiguous :: weight(:)
4138 integer(IK) , intent(in) , optional :: weisum
4139 type(neiprev_type) , intent(in) :: method
4140 end function
4141#endif
4142
4143#if RK1_ENABLED
4144 PURE module function getQuanPREV_ND2_QD1_WTI_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4145#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4146 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTI_RK1
4147#endif
4148 use pm_kind, only: TKG => RK1
4149 integer(IK) , intent(in) :: dim
4150 real(TKG) , intent(in) , contiguous :: sample(:,:)
4151 real(TKG) , intent(in) , contiguous :: prob(:)
4152 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4153 integer(IK) , intent(in) , contiguous :: weight(:)
4154 integer(IK) , intent(in) , optional :: weisum
4155 type(neiprev_type) , intent(in) :: method
4156 end function
4157#endif
4158
4159 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4160
4161 end interface
4162
4163 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4164
4165 ! ND2 WTR piwilin
4166
4167 interface getQuan
4168
4169 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4170
4171#if RK5_ENABLED
4172 PURE module function getQuanPWLN_ND2_QD0_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4173#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4174 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTR_RK5
4175#endif
4176 use pm_kind, only: TKG => RK5
4177 integer(IK) , intent(in) :: dim
4178 real(TKG) , intent(in) , contiguous :: sample(:,:)
4179 real(TKG) , intent(in) , contiguous :: weight(:)
4180 real(TKG) , intent(in) , optional :: weisum
4181 real(TKG) , intent(in) :: prob
4182 real(TKG) :: quan(size(sample, 3 - dim, IK))
4183 type(piwilin_type) , intent(in) :: method
4184 end function
4185#endif
4186
4187#if RK4_ENABLED
4188 PURE module function getQuanPWLN_ND2_QD0_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4189#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4190 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTR_RK4
4191#endif
4192 use pm_kind, only: TKG => RK4
4193 integer(IK) , intent(in) :: dim
4194 real(TKG) , intent(in) , contiguous :: sample(:,:)
4195 real(TKG) , intent(in) , contiguous :: weight(:)
4196 real(TKG) , intent(in) , optional :: weisum
4197 real(TKG) , intent(in) :: prob
4198 real(TKG) :: quan(size(sample, 3 - dim, IK))
4199 type(piwilin_type) , intent(in) :: method
4200 end function
4201#endif
4202
4203#if RK3_ENABLED
4204 PURE module function getQuanPWLN_ND2_QD0_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4205#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4206 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTR_RK3
4207#endif
4208 use pm_kind, only: TKG => RK3
4209 integer(IK) , intent(in) :: dim
4210 real(TKG) , intent(in) , contiguous :: sample(:,:)
4211 real(TKG) , intent(in) , contiguous :: weight(:)
4212 real(TKG) , intent(in) , optional :: weisum
4213 real(TKG) , intent(in) :: prob
4214 real(TKG) :: quan(size(sample, 3 - dim, IK))
4215 type(piwilin_type) , intent(in) :: method
4216 end function
4217#endif
4218
4219#if RK2_ENABLED
4220 PURE module function getQuanPWLN_ND2_QD0_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4221#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4222 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTR_RK2
4223#endif
4224 use pm_kind, only: TKG => RK2
4225 integer(IK) , intent(in) :: dim
4226 real(TKG) , intent(in) , contiguous :: sample(:,:)
4227 real(TKG) , intent(in) , contiguous :: weight(:)
4228 real(TKG) , intent(in) , optional :: weisum
4229 real(TKG) , intent(in) :: prob
4230 real(TKG) :: quan(size(sample, 3 - dim, IK))
4231 type(piwilin_type) , intent(in) :: method
4232 end function
4233#endif
4234
4235#if RK1_ENABLED
4236 PURE module function getQuanPWLN_ND2_QD0_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4237#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4238 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD0_WTR_RK1
4239#endif
4240 use pm_kind, only: TKG => RK1
4241 integer(IK) , intent(in) :: dim
4242 real(TKG) , intent(in) , contiguous :: sample(:,:)
4243 real(TKG) , intent(in) , contiguous :: weight(:)
4244 real(TKG) , intent(in) , optional :: weisum
4245 real(TKG) , intent(in) :: prob
4246 real(TKG) :: quan(size(sample, 3 - dim, IK))
4247 type(piwilin_type) , intent(in) :: method
4248 end function
4249#endif
4250
4251 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4252
4253#if RK5_ENABLED
4254 PURE module function getQuanPWLN_ND2_QD1_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4255#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4256 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTR_RK5
4257#endif
4258 use pm_kind, only: TKG => RK5
4259 integer(IK) , intent(in) :: dim
4260 real(TKG) , intent(in) , contiguous :: sample(:,:)
4261 real(TKG) , intent(in) , contiguous :: prob(:)
4262 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4263 real(TKG) , intent(in) , contiguous :: weight(:)
4264 real(TKG) , intent(in) , optional :: weisum
4265 type(piwilin_type) , intent(in) :: method
4266 end function
4267#endif
4268
4269#if RK4_ENABLED
4270 PURE module function getQuanPWLN_ND2_QD1_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4271#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4272 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTR_RK4
4273#endif
4274 use pm_kind, only: TKG => RK4
4275 integer(IK) , intent(in) :: dim
4276 real(TKG) , intent(in) , contiguous :: sample(:,:)
4277 real(TKG) , intent(in) , contiguous :: prob(:)
4278 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4279 real(TKG) , intent(in) , contiguous :: weight(:)
4280 real(TKG) , intent(in) , optional :: weisum
4281 type(piwilin_type) , intent(in) :: method
4282 end function
4283#endif
4284
4285#if RK3_ENABLED
4286 PURE module function getQuanPWLN_ND2_QD1_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4287#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4288 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTR_RK3
4289#endif
4290 use pm_kind, only: TKG => RK3
4291 integer(IK) , intent(in) :: dim
4292 real(TKG) , intent(in) , contiguous :: sample(:,:)
4293 real(TKG) , intent(in) , contiguous :: prob(:)
4294 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4295 real(TKG) , intent(in) , contiguous :: weight(:)
4296 real(TKG) , intent(in) , optional :: weisum
4297 type(piwilin_type) , intent(in) :: method
4298 end function
4299#endif
4300
4301#if RK2_ENABLED
4302 PURE module function getQuanPWLN_ND2_QD1_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4303#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4304 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTR_RK2
4305#endif
4306 use pm_kind, only: TKG => RK2
4307 integer(IK) , intent(in) :: dim
4308 real(TKG) , intent(in) , contiguous :: sample(:,:)
4309 real(TKG) , intent(in) , contiguous :: prob(:)
4310 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4311 real(TKG) , intent(in) , contiguous :: weight(:)
4312 real(TKG) , intent(in) , optional :: weisum
4313 type(piwilin_type) , intent(in) :: method
4314 end function
4315#endif
4316
4317#if RK1_ENABLED
4318 PURE module function getQuanPWLN_ND2_QD1_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4319#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4320 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPWLN_ND2_QD1_WTR_RK1
4321#endif
4322 use pm_kind, only: TKG => RK1
4323 integer(IK) , intent(in) :: dim
4324 real(TKG) , intent(in) , contiguous :: sample(:,:)
4325 real(TKG) , intent(in) , contiguous :: prob(:)
4326 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4327 real(TKG) , intent(in) , contiguous :: weight(:)
4328 real(TKG) , intent(in) , optional :: weisum
4329 type(piwilin_type) , intent(in) :: method
4330 end function
4331#endif
4332
4333 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4334
4335 end interface
4336
4337 ! ND2 WTR neimean
4338
4339 interface getQuan
4340
4341 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4342
4343#if RK5_ENABLED
4344 PURE module function getQuanMEAN_ND2_QD0_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4345#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4346 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTR_RK5
4347#endif
4348 use pm_kind, only: TKG => RK5
4349 integer(IK) , intent(in) :: dim
4350 real(TKG) , intent(in) , contiguous :: sample(:,:)
4351 real(TKG) , intent(in) , contiguous :: weight(:)
4352 real(TKG) , intent(in) , optional :: weisum
4353 real(TKG) , intent(in) :: prob
4354 real(TKG) :: quan(size(sample, 3 - dim, IK))
4355 type(neimean_type) , intent(in) :: method
4356 end function
4357#endif
4358
4359#if RK4_ENABLED
4360 PURE module function getQuanMEAN_ND2_QD0_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4361#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4362 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTR_RK4
4363#endif
4364 use pm_kind, only: TKG => RK4
4365 integer(IK) , intent(in) :: dim
4366 real(TKG) , intent(in) , contiguous :: sample(:,:)
4367 real(TKG) , intent(in) , contiguous :: weight(:)
4368 real(TKG) , intent(in) , optional :: weisum
4369 real(TKG) , intent(in) :: prob
4370 real(TKG) :: quan(size(sample, 3 - dim, IK))
4371 type(neimean_type) , intent(in) :: method
4372 end function
4373#endif
4374
4375#if RK3_ENABLED
4376 PURE module function getQuanMEAN_ND2_QD0_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4377#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4378 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTR_RK3
4379#endif
4380 use pm_kind, only: TKG => RK3
4381 integer(IK) , intent(in) :: dim
4382 real(TKG) , intent(in) , contiguous :: sample(:,:)
4383 real(TKG) , intent(in) , contiguous :: weight(:)
4384 real(TKG) , intent(in) , optional :: weisum
4385 real(TKG) , intent(in) :: prob
4386 real(TKG) :: quan(size(sample, 3 - dim, IK))
4387 type(neimean_type) , intent(in) :: method
4388 end function
4389#endif
4390
4391#if RK2_ENABLED
4392 PURE module function getQuanMEAN_ND2_QD0_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4393#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4394 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTR_RK2
4395#endif
4396 use pm_kind, only: TKG => RK2
4397 integer(IK) , intent(in) :: dim
4398 real(TKG) , intent(in) , contiguous :: sample(:,:)
4399 real(TKG) , intent(in) , contiguous :: weight(:)
4400 real(TKG) , intent(in) , optional :: weisum
4401 real(TKG) , intent(in) :: prob
4402 real(TKG) :: quan(size(sample, 3 - dim, IK))
4403 type(neimean_type) , intent(in) :: method
4404 end function
4405#endif
4406
4407#if RK1_ENABLED
4408 PURE module function getQuanMEAN_ND2_QD0_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4409#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4410 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD0_WTR_RK1
4411#endif
4412 use pm_kind, only: TKG => RK1
4413 integer(IK) , intent(in) :: dim
4414 real(TKG) , intent(in) , contiguous :: sample(:,:)
4415 real(TKG) , intent(in) , contiguous :: weight(:)
4416 real(TKG) , intent(in) , optional :: weisum
4417 real(TKG) , intent(in) :: prob
4418 real(TKG) :: quan(size(sample, 3 - dim, IK))
4419 type(neimean_type) , intent(in) :: method
4420 end function
4421#endif
4422
4423 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4424
4425#if RK5_ENABLED
4426 PURE module function getQuanMEAN_ND2_QD1_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4427#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4428 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTR_RK5
4429#endif
4430 use pm_kind, only: TKG => RK5
4431 integer(IK) , intent(in) :: dim
4432 real(TKG) , intent(in) , contiguous :: sample(:,:)
4433 real(TKG) , intent(in) , contiguous :: prob(:)
4434 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4435 real(TKG) , intent(in) , contiguous :: weight(:)
4436 real(TKG) , intent(in) , optional :: weisum
4437 type(neimean_type) , intent(in) :: method
4438 end function
4439#endif
4440
4441#if RK4_ENABLED
4442 PURE module function getQuanMEAN_ND2_QD1_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4443#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4444 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTR_RK4
4445#endif
4446 use pm_kind, only: TKG => RK4
4447 integer(IK) , intent(in) :: dim
4448 real(TKG) , intent(in) , contiguous :: sample(:,:)
4449 real(TKG) , intent(in) , contiguous :: prob(:)
4450 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4451 real(TKG) , intent(in) , contiguous :: weight(:)
4452 real(TKG) , intent(in) , optional :: weisum
4453 type(neimean_type) , intent(in) :: method
4454 end function
4455#endif
4456
4457#if RK3_ENABLED
4458 PURE module function getQuanMEAN_ND2_QD1_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4459#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4460 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTR_RK3
4461#endif
4462 use pm_kind, only: TKG => RK3
4463 integer(IK) , intent(in) :: dim
4464 real(TKG) , intent(in) , contiguous :: sample(:,:)
4465 real(TKG) , intent(in) , contiguous :: prob(:)
4466 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4467 real(TKG) , intent(in) , contiguous :: weight(:)
4468 real(TKG) , intent(in) , optional :: weisum
4469 type(neimean_type) , intent(in) :: method
4470 end function
4471#endif
4472
4473#if RK2_ENABLED
4474 PURE module function getQuanMEAN_ND2_QD1_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4475#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4476 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTR_RK2
4477#endif
4478 use pm_kind, only: TKG => RK2
4479 integer(IK) , intent(in) :: dim
4480 real(TKG) , intent(in) , contiguous :: sample(:,:)
4481 real(TKG) , intent(in) , contiguous :: prob(:)
4482 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4483 real(TKG) , intent(in) , contiguous :: weight(:)
4484 real(TKG) , intent(in) , optional :: weisum
4485 type(neimean_type) , intent(in) :: method
4486 end function
4487#endif
4488
4489#if RK1_ENABLED
4490 PURE module function getQuanMEAN_ND2_QD1_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4491#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4492 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanMEAN_ND2_QD1_WTR_RK1
4493#endif
4494 use pm_kind, only: TKG => RK1
4495 integer(IK) , intent(in) :: dim
4496 real(TKG) , intent(in) , contiguous :: sample(:,:)
4497 real(TKG) , intent(in) , contiguous :: prob(:)
4498 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4499 real(TKG) , intent(in) , contiguous :: weight(:)
4500 real(TKG) , intent(in) , optional :: weisum
4501 type(neimean_type) , intent(in) :: method
4502 end function
4503#endif
4504
4505 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4506
4507 end interface
4508
4509 ! ND2 WTR neinear
4510
4511 interface getQuan
4512
4513 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4514
4515#if RK5_ENABLED
4516 PURE module function getQuanNEAR_ND2_QD0_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4517#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4518 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTR_RK5
4519#endif
4520 use pm_kind, only: TKG => RK5
4521 integer(IK) , intent(in) :: dim
4522 real(TKG) , intent(in) , contiguous :: sample(:,:)
4523 real(TKG) , intent(in) , contiguous :: weight(:)
4524 real(TKG) , intent(in) , optional :: weisum
4525 real(TKG) , intent(in) :: prob
4526 real(TKG) :: quan(size(sample, 3 - dim, IK))
4527 type(neinear_type) , intent(in) :: method
4528 end function
4529#endif
4530
4531#if RK4_ENABLED
4532 PURE module function getQuanNEAR_ND2_QD0_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4533#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4534 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTR_RK4
4535#endif
4536 use pm_kind, only: TKG => RK4
4537 integer(IK) , intent(in) :: dim
4538 real(TKG) , intent(in) , contiguous :: sample(:,:)
4539 real(TKG) , intent(in) , contiguous :: weight(:)
4540 real(TKG) , intent(in) , optional :: weisum
4541 real(TKG) , intent(in) :: prob
4542 real(TKG) :: quan(size(sample, 3 - dim, IK))
4543 type(neinear_type) , intent(in) :: method
4544 end function
4545#endif
4546
4547#if RK3_ENABLED
4548 PURE module function getQuanNEAR_ND2_QD0_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4549#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4550 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTR_RK3
4551#endif
4552 use pm_kind, only: TKG => RK3
4553 integer(IK) , intent(in) :: dim
4554 real(TKG) , intent(in) , contiguous :: sample(:,:)
4555 real(TKG) , intent(in) , contiguous :: weight(:)
4556 real(TKG) , intent(in) , optional :: weisum
4557 real(TKG) , intent(in) :: prob
4558 real(TKG) :: quan(size(sample, 3 - dim, IK))
4559 type(neinear_type) , intent(in) :: method
4560 end function
4561#endif
4562
4563#if RK2_ENABLED
4564 PURE module function getQuanNEAR_ND2_QD0_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4565#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4566 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTR_RK2
4567#endif
4568 use pm_kind, only: TKG => RK2
4569 integer(IK) , intent(in) :: dim
4570 real(TKG) , intent(in) , contiguous :: sample(:,:)
4571 real(TKG) , intent(in) , contiguous :: weight(:)
4572 real(TKG) , intent(in) , optional :: weisum
4573 real(TKG) , intent(in) :: prob
4574 real(TKG) :: quan(size(sample, 3 - dim, IK))
4575 type(neinear_type) , intent(in) :: method
4576 end function
4577#endif
4578
4579#if RK1_ENABLED
4580 PURE module function getQuanNEAR_ND2_QD0_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4581#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4582 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD0_WTR_RK1
4583#endif
4584 use pm_kind, only: TKG => RK1
4585 integer(IK) , intent(in) :: dim
4586 real(TKG) , intent(in) , contiguous :: sample(:,:)
4587 real(TKG) , intent(in) , contiguous :: weight(:)
4588 real(TKG) , intent(in) , optional :: weisum
4589 real(TKG) , intent(in) :: prob
4590 real(TKG) :: quan(size(sample, 3 - dim, IK))
4591 type(neinear_type) , intent(in) :: method
4592 end function
4593#endif
4594
4595 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4596
4597#if RK5_ENABLED
4598 PURE module function getQuanNEAR_ND2_QD1_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4599#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4600 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTR_RK5
4601#endif
4602 use pm_kind, only: TKG => RK5
4603 integer(IK) , intent(in) :: dim
4604 real(TKG) , intent(in) , contiguous :: sample(:,:)
4605 real(TKG) , intent(in) , contiguous :: prob(:)
4606 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4607 real(TKG) , intent(in) , contiguous :: weight(:)
4608 real(TKG) , intent(in) , optional :: weisum
4609 type(neinear_type) , intent(in) :: method
4610 end function
4611#endif
4612
4613#if RK4_ENABLED
4614 PURE module function getQuanNEAR_ND2_QD1_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4615#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4616 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTR_RK4
4617#endif
4618 use pm_kind, only: TKG => RK4
4619 integer(IK) , intent(in) :: dim
4620 real(TKG) , intent(in) , contiguous :: sample(:,:)
4621 real(TKG) , intent(in) , contiguous :: prob(:)
4622 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4623 real(TKG) , intent(in) , contiguous :: weight(:)
4624 real(TKG) , intent(in) , optional :: weisum
4625 type(neinear_type) , intent(in) :: method
4626 end function
4627#endif
4628
4629#if RK3_ENABLED
4630 PURE module function getQuanNEAR_ND2_QD1_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4631#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4632 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTR_RK3
4633#endif
4634 use pm_kind, only: TKG => RK3
4635 integer(IK) , intent(in) :: dim
4636 real(TKG) , intent(in) , contiguous :: sample(:,:)
4637 real(TKG) , intent(in) , contiguous :: prob(:)
4638 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4639 real(TKG) , intent(in) , contiguous :: weight(:)
4640 real(TKG) , intent(in) , optional :: weisum
4641 type(neinear_type) , intent(in) :: method
4642 end function
4643#endif
4644
4645#if RK2_ENABLED
4646 PURE module function getQuanNEAR_ND2_QD1_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4647#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4648 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTR_RK2
4649#endif
4650 use pm_kind, only: TKG => RK2
4651 integer(IK) , intent(in) :: dim
4652 real(TKG) , intent(in) , contiguous :: sample(:,:)
4653 real(TKG) , intent(in) , contiguous :: prob(:)
4654 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4655 real(TKG) , intent(in) , contiguous :: weight(:)
4656 real(TKG) , intent(in) , optional :: weisum
4657 type(neinear_type) , intent(in) :: method
4658 end function
4659#endif
4660
4661#if RK1_ENABLED
4662 PURE module function getQuanNEAR_ND2_QD1_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4663#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4664 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEAR_ND2_QD1_WTR_RK1
4665#endif
4666 use pm_kind, only: TKG => RK1
4667 integer(IK) , intent(in) :: dim
4668 real(TKG) , intent(in) , contiguous :: sample(:,:)
4669 real(TKG) , intent(in) , contiguous :: prob(:)
4670 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4671 real(TKG) , intent(in) , contiguous :: weight(:)
4672 real(TKG) , intent(in) , optional :: weisum
4673 type(neinear_type) , intent(in) :: method
4674 end function
4675#endif
4676
4677 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4678
4679 end interface
4680
4681 ! ND2 WTR neinext
4682
4683 interface getQuan
4684
4685 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4686
4687#if RK5_ENABLED
4688 PURE module function getQuanNEXT_ND2_QD0_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4689#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4690 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTR_RK5
4691#endif
4692 use pm_kind, only: TKG => RK5
4693 integer(IK) , intent(in) :: dim
4694 real(TKG) , intent(in) , contiguous :: sample(:,:)
4695 real(TKG) , intent(in) , contiguous :: weight(:)
4696 real(TKG) , intent(in) , optional :: weisum
4697 real(TKG) , intent(in) :: prob
4698 real(TKG) :: quan(size(sample, 3 - dim, IK))
4699 type(neinext_type) , intent(in) :: method
4700 end function
4701#endif
4702
4703#if RK4_ENABLED
4704 PURE module function getQuanNEXT_ND2_QD0_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4705#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4706 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTR_RK4
4707#endif
4708 use pm_kind, only: TKG => RK4
4709 integer(IK) , intent(in) :: dim
4710 real(TKG) , intent(in) , contiguous :: sample(:,:)
4711 real(TKG) , intent(in) , contiguous :: weight(:)
4712 real(TKG) , intent(in) , optional :: weisum
4713 real(TKG) , intent(in) :: prob
4714 real(TKG) :: quan(size(sample, 3 - dim, IK))
4715 type(neinext_type) , intent(in) :: method
4716 end function
4717#endif
4718
4719#if RK3_ENABLED
4720 PURE module function getQuanNEXT_ND2_QD0_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4721#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4722 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTR_RK3
4723#endif
4724 use pm_kind, only: TKG => RK3
4725 integer(IK) , intent(in) :: dim
4726 real(TKG) , intent(in) , contiguous :: sample(:,:)
4727 real(TKG) , intent(in) , contiguous :: weight(:)
4728 real(TKG) , intent(in) , optional :: weisum
4729 real(TKG) , intent(in) :: prob
4730 real(TKG) :: quan(size(sample, 3 - dim, IK))
4731 type(neinext_type) , intent(in) :: method
4732 end function
4733#endif
4734
4735#if RK2_ENABLED
4736 PURE module function getQuanNEXT_ND2_QD0_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4737#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4738 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTR_RK2
4739#endif
4740 use pm_kind, only: TKG => RK2
4741 integer(IK) , intent(in) :: dim
4742 real(TKG) , intent(in) , contiguous :: sample(:,:)
4743 real(TKG) , intent(in) , contiguous :: weight(:)
4744 real(TKG) , intent(in) , optional :: weisum
4745 real(TKG) , intent(in) :: prob
4746 real(TKG) :: quan(size(sample, 3 - dim, IK))
4747 type(neinext_type) , intent(in) :: method
4748 end function
4749#endif
4750
4751#if RK1_ENABLED
4752 PURE module function getQuanNEXT_ND2_QD0_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4753#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4754 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD0_WTR_RK1
4755#endif
4756 use pm_kind, only: TKG => RK1
4757 integer(IK) , intent(in) :: dim
4758 real(TKG) , intent(in) , contiguous :: sample(:,:)
4759 real(TKG) , intent(in) , contiguous :: weight(:)
4760 real(TKG) , intent(in) , optional :: weisum
4761 real(TKG) , intent(in) :: prob
4762 real(TKG) :: quan(size(sample, 3 - dim, IK))
4763 type(neinext_type) , intent(in) :: method
4764 end function
4765#endif
4766
4767 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4768
4769#if RK5_ENABLED
4770 PURE module function getQuanNEXT_ND2_QD1_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4771#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4772 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTR_RK5
4773#endif
4774 use pm_kind, only: TKG => RK5
4775 integer(IK) , intent(in) :: dim
4776 real(TKG) , intent(in) , contiguous :: sample(:,:)
4777 real(TKG) , intent(in) , contiguous :: prob(:)
4778 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4779 real(TKG) , intent(in) , contiguous :: weight(:)
4780 real(TKG) , intent(in) , optional :: weisum
4781 type(neinext_type) , intent(in) :: method
4782 end function
4783#endif
4784
4785#if RK4_ENABLED
4786 PURE module function getQuanNEXT_ND2_QD1_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4787#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4788 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTR_RK4
4789#endif
4790 use pm_kind, only: TKG => RK4
4791 integer(IK) , intent(in) :: dim
4792 real(TKG) , intent(in) , contiguous :: sample(:,:)
4793 real(TKG) , intent(in) , contiguous :: prob(:)
4794 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4795 real(TKG) , intent(in) , contiguous :: weight(:)
4796 real(TKG) , intent(in) , optional :: weisum
4797 type(neinext_type) , intent(in) :: method
4798 end function
4799#endif
4800
4801#if RK3_ENABLED
4802 PURE module function getQuanNEXT_ND2_QD1_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4803#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4804 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTR_RK3
4805#endif
4806 use pm_kind, only: TKG => RK3
4807 integer(IK) , intent(in) :: dim
4808 real(TKG) , intent(in) , contiguous :: sample(:,:)
4809 real(TKG) , intent(in) , contiguous :: prob(:)
4810 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4811 real(TKG) , intent(in) , contiguous :: weight(:)
4812 real(TKG) , intent(in) , optional :: weisum
4813 type(neinext_type) , intent(in) :: method
4814 end function
4815#endif
4816
4817#if RK2_ENABLED
4818 PURE module function getQuanNEXT_ND2_QD1_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4819#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4820 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTR_RK2
4821#endif
4822 use pm_kind, only: TKG => RK2
4823 integer(IK) , intent(in) :: dim
4824 real(TKG) , intent(in) , contiguous :: sample(:,:)
4825 real(TKG) , intent(in) , contiguous :: prob(:)
4826 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4827 real(TKG) , intent(in) , contiguous :: weight(:)
4828 real(TKG) , intent(in) , optional :: weisum
4829 type(neinext_type) , intent(in) :: method
4830 end function
4831#endif
4832
4833#if RK1_ENABLED
4834 PURE module function getQuanNEXT_ND2_QD1_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4835#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4836 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanNEXT_ND2_QD1_WTR_RK1
4837#endif
4838 use pm_kind, only: TKG => RK1
4839 integer(IK) , intent(in) :: dim
4840 real(TKG) , intent(in) , contiguous :: sample(:,:)
4841 real(TKG) , intent(in) , contiguous :: prob(:)
4842 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4843 real(TKG) , intent(in) , contiguous :: weight(:)
4844 real(TKG) , intent(in) , optional :: weisum
4845 type(neinext_type) , intent(in) :: method
4846 end function
4847#endif
4848
4849 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4850
4851 end interface
4852
4853 ! ND2 WTR neiprev
4854
4855 interface getQuan
4856
4857 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4858
4859#if RK5_ENABLED
4860 PURE module function getQuanPREV_ND2_QD0_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4861#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4862 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTR_RK5
4863#endif
4864 use pm_kind, only: TKG => RK5
4865 integer(IK) , intent(in) :: dim
4866 real(TKG) , intent(in) , contiguous :: sample(:,:)
4867 real(TKG) , intent(in) , contiguous :: weight(:)
4868 real(TKG) , intent(in) , optional :: weisum
4869 real(TKG) , intent(in) :: prob
4870 real(TKG) :: quan(size(sample, 3 - dim, IK))
4871 type(neiprev_type) , intent(in) :: method
4872 end function
4873#endif
4874
4875#if RK4_ENABLED
4876 PURE module function getQuanPREV_ND2_QD0_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4877#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4878 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTR_RK4
4879#endif
4880 use pm_kind, only: TKG => RK4
4881 integer(IK) , intent(in) :: dim
4882 real(TKG) , intent(in) , contiguous :: sample(:,:)
4883 real(TKG) , intent(in) , contiguous :: weight(:)
4884 real(TKG) , intent(in) , optional :: weisum
4885 real(TKG) , intent(in) :: prob
4886 real(TKG) :: quan(size(sample, 3 - dim, IK))
4887 type(neiprev_type) , intent(in) :: method
4888 end function
4889#endif
4890
4891#if RK3_ENABLED
4892 PURE module function getQuanPREV_ND2_QD0_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4893#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4894 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTR_RK3
4895#endif
4896 use pm_kind, only: TKG => RK3
4897 integer(IK) , intent(in) :: dim
4898 real(TKG) , intent(in) , contiguous :: sample(:,:)
4899 real(TKG) , intent(in) , contiguous :: weight(:)
4900 real(TKG) , intent(in) , optional :: weisum
4901 real(TKG) , intent(in) :: prob
4902 real(TKG) :: quan(size(sample, 3 - dim, IK))
4903 type(neiprev_type) , intent(in) :: method
4904 end function
4905#endif
4906
4907#if RK2_ENABLED
4908 PURE module function getQuanPREV_ND2_QD0_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4909#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4910 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTR_RK2
4911#endif
4912 use pm_kind, only: TKG => RK2
4913 integer(IK) , intent(in) :: dim
4914 real(TKG) , intent(in) , contiguous :: sample(:,:)
4915 real(TKG) , intent(in) , contiguous :: weight(:)
4916 real(TKG) , intent(in) , optional :: weisum
4917 real(TKG) , intent(in) :: prob
4918 real(TKG) :: quan(size(sample, 3 - dim, IK))
4919 type(neiprev_type) , intent(in) :: method
4920 end function
4921#endif
4922
4923#if RK1_ENABLED
4924 PURE module function getQuanPREV_ND2_QD0_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
4925#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4926 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD0_WTR_RK1
4927#endif
4928 use pm_kind, only: TKG => RK1
4929 integer(IK) , intent(in) :: dim
4930 real(TKG) , intent(in) , contiguous :: sample(:,:)
4931 real(TKG) , intent(in) , contiguous :: weight(:)
4932 real(TKG) , intent(in) , optional :: weisum
4933 real(TKG) , intent(in) :: prob
4934 real(TKG) :: quan(size(sample, 3 - dim, IK))
4935 type(neiprev_type) , intent(in) :: method
4936 end function
4937#endif
4938
4939 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4940
4941#if RK5_ENABLED
4942 PURE module function getQuanPREV_ND2_QD1_WTR_RK5(method, prob, sample, dim, weight, weisum) result(quan)
4943#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4944 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTR_RK5
4945#endif
4946 use pm_kind, only: TKG => RK5
4947 integer(IK) , intent(in) :: dim
4948 real(TKG) , intent(in) , contiguous :: sample(:,:)
4949 real(TKG) , intent(in) , contiguous :: prob(:)
4950 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4951 real(TKG) , intent(in) , contiguous :: weight(:)
4952 real(TKG) , intent(in) , optional :: weisum
4953 type(neiprev_type) , intent(in) :: method
4954 end function
4955#endif
4956
4957#if RK4_ENABLED
4958 PURE module function getQuanPREV_ND2_QD1_WTR_RK4(method, prob, sample, dim, weight, weisum) result(quan)
4959#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4960 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTR_RK4
4961#endif
4962 use pm_kind, only: TKG => RK4
4963 integer(IK) , intent(in) :: dim
4964 real(TKG) , intent(in) , contiguous :: sample(:,:)
4965 real(TKG) , intent(in) , contiguous :: prob(:)
4966 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4967 real(TKG) , intent(in) , contiguous :: weight(:)
4968 real(TKG) , intent(in) , optional :: weisum
4969 type(neiprev_type) , intent(in) :: method
4970 end function
4971#endif
4972
4973#if RK3_ENABLED
4974 PURE module function getQuanPREV_ND2_QD1_WTR_RK3(method, prob, sample, dim, weight, weisum) result(quan)
4975#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4976 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTR_RK3
4977#endif
4978 use pm_kind, only: TKG => RK3
4979 integer(IK) , intent(in) :: dim
4980 real(TKG) , intent(in) , contiguous :: sample(:,:)
4981 real(TKG) , intent(in) , contiguous :: prob(:)
4982 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4983 real(TKG) , intent(in) , contiguous :: weight(:)
4984 real(TKG) , intent(in) , optional :: weisum
4985 type(neiprev_type) , intent(in) :: method
4986 end function
4987#endif
4988
4989#if RK2_ENABLED
4990 PURE module function getQuanPREV_ND2_QD1_WTR_RK2(method, prob, sample, dim, weight, weisum) result(quan)
4991#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4992 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTR_RK2
4993#endif
4994 use pm_kind, only: TKG => RK2
4995 integer(IK) , intent(in) :: dim
4996 real(TKG) , intent(in) , contiguous :: sample(:,:)
4997 real(TKG) , intent(in) , contiguous :: prob(:)
4998 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
4999 real(TKG) , intent(in) , contiguous :: weight(:)
5000 real(TKG) , intent(in) , optional :: weisum
5001 type(neiprev_type) , intent(in) :: method
5002 end function
5003#endif
5004
5005#if RK1_ENABLED
5006 PURE module function getQuanPREV_ND2_QD1_WTR_RK1(method, prob, sample, dim, weight, weisum) result(quan)
5007#if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5008 !DEC$ ATTRIBUTES DLLEXPORT :: getQuanPREV_ND2_QD1_WTR_RK1
5009#endif
5010 use pm_kind, only: TKG => RK1
5011 integer(IK) , intent(in) :: dim
5012 real(TKG) , intent(in) , contiguous :: sample(:,:)
5013 real(TKG) , intent(in) , contiguous :: prob(:)
5014 real(TKG) :: quan(size(prob, 1, IK), size(sample, 3 - dim, IK))
5015 real(TKG) , intent(in) , contiguous :: weight(:)
5016 real(TKG) , intent(in) , optional :: weisum
5017 type(neiprev_type) , intent(in) :: method
5018 end function
5019#endif
5020
5021 !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5022
5023 end interface
5024
5025!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5026
5027end module pm_sampleQuan
pm_polation::setInterp
Generate and return the approximate polynomial interpolation value of the input specified point x for...
Definition: pm_polation.F90:1447
pm_sampleQuan::getQuan
Generate and return the approximate sample quantile for the given method at the specified probabiliti...
Definition: pm_sampleQuan.F90:207
pm_kind
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
Definition: pm_kind.F90:268
pm_kind::RK5
integer, parameter RK5
Definition: pm_kind.F90:478
pm_kind::RK4
integer, parameter RK4
Definition: pm_kind.F90:489
pm_kind::RK2
integer, parameter RK2
Definition: pm_kind.F90:511
pm_kind::RK3
integer, parameter RK3
Definition: pm_kind.F90:500
pm_kind::LK
integer, parameter LK
The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(....
Definition: pm_kind.F90:541
pm_kind::IK
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
Definition: pm_kind.F90:540
pm_kind::SK
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
Definition: pm_kind.F90:539
pm_kind::RK1
integer, parameter RK1
Definition: pm_kind.F90:522
pm_polation
This module contains procedures and data types for interpolation of finite samples of data.
Definition: pm_polation.F90:142
pm_polation::piwilin
type(piwilin_type), parameter piwilin
Definition: pm_polation.F90:324
pm_polation::neiprev
type(neiprev_type), parameter neiprev
Definition: pm_polation.F90:289
pm_polation::neinext
type(neinext_type), parameter neinext
Definition: pm_polation.F90:253
pm_polation::neinear
type(neinear_type), parameter neinear
Definition: pm_polation.F90:217
pm_polation::neimean
type(neimean_type), parameter neimean
Definition: pm_polation.F90:181
pm_polation::MODULE_NAME
character(*, SK), parameter MODULE_NAME
Definition: pm_polation.F90:148
pm_sampleQuan
This module contains procedures and data types for computing sample quantile.
Definition: pm_sampleQuan.F90:62
pm_polation::neimean_type
This is a concrete derived type whose instances are exclusively used to signify an interpolation usin...
Definition: pm_polation.F90:180
pm_polation::neinear_type
This is a concrete derived type whose instances are exclusively used to signify an interpolation usin...
Definition: pm_polation.F90:216
pm_polation::neinext_type
This is a concrete derived type whose instances are exclusively used to signify an interpolation usin...
Definition: pm_polation.F90:252
pm_polation::neiprev_type
This is a concrete derived type whose instances are exclusively used to signify an interpolation usin...
Definition: pm_polation.F90:288
pm_polation::piwilin_type
This is a concrete derived type whose instances are exclusively used to signify an interpolation usin...
Definition: pm_polation.F90:323