codekingpro/portable-devtools
114k
1 /* Copyright 2010-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2 *
3 * NOTICE TO LICENSEE:
4 *
5 * The source code and/or documentation ("Licensed Deliverables") are
6 * subject to NVIDIA intellectual property rights under U.S. and
7 * international Copyright laws.
8 *
9 * The Licensed Deliverables contained herein are PROPRIETARY and
10 * CONFIDENTIAL to NVIDIA and are being provided under the terms and
11 * conditions of a form of NVIDIA software license agreement by and
12 * between NVIDIA and Licensee ("License Agreement") or electronically
13 * accepted by Licensee. Notwithstanding any terms or conditions to
14 * the contrary in the License Agreement, reproduction or disclosure
15 * of the Licensed Deliverables to any third party without the express
16 * written consent of NVIDIA is prohibited.
17 *
18 * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
19 * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
20 * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE. THEY ARE
21 * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
22 * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
23 * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
24 * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
25 * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
26 * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
27 * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
28 * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
29 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
30 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
31 * OF THESE LICENSED DELIVERABLES.
32 *
33 * U.S. Government End Users. These Licensed Deliverables are a
34 * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
35 * 1995), consisting of "commercial computer software" and "commercial
36 * computer software documentation" as such terms are used in 48
37 * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government
38 * only as a commercial end item. Consistent with 48 C.F.R.12.212 and
39 * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
40 * U.S. Government End Users acquire the Licensed Deliverables with
41 * only those rights set forth herein.
42 *
43 * Any use of the Licensed Deliverables in individual and commercial
44 * software must include, in the user documentation and internal
45 * comments to the code, the above Disclaimer and U.S. Government End
46 * Users Notice.
47 */
48#ifndef NV_NPPS_STATISTICS_FUNCTIONS_H
49#define NV_NPPS_STATISTICS_FUNCTIONS_H
50
51/**
52 * \file npps_statistics_functions.h
53 * NPP Signal Processing Functionality.
54 */
55
56#include "nppdefs.h"
57
58
59#ifdef __cplusplus
60extern "C" {
61#endif
62
63
64/**
65 * \page signal_statistical_functions Statistical Functions
66 * @defgroup signal_statistical_functions Statistical Functions
67 * @ingroup npps
68 * Functions that provide global signal statistics like: sum, mean, standard
69 * deviation, min, max, etc.
70 *
71 * @{
72 *
73 */
74
75/**
76 * \section signal_min_every_or_max_every MinEvery And MaxEvery Functions
77 * @defgroup signal_min_every_or_max_every MinEvery And MaxEvery Functions
78 * Performs the min or max operation on the samples of a signal.
79 *
80 * @{
81 *
82 */
83
84/**
85 * 8-bit in place min value for each pair of elements.
86 * \param pSrc \ref source_signal_pointer.
87 * \param pSrcDst \ref in_place_signal_pointer.
88 * \param nLength \ref length_specification.
89 * \param nppStreamCtx \ref application_managed_stream_context.
90 * \return \ref signal_data_error_codes, \ref length_error_codes.
91 */
92NppStatus
93nppsMinEvery_8u_I_Ctx(const Npp8u * pSrc, Npp8u * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
94/**
95 * 8-bit in place min value for each pair of elements.
96 * \param pSrc \ref source_signal_pointer.
97 * \param pSrcDst \ref in_place_signal_pointer.
98 * \param nLength \ref length_specification.
99 * \return \ref signal_data_error_codes, \ref length_error_codes.
100 */
101NppStatus
102nppsMinEvery_8u_I(const Npp8u * pSrc, Npp8u * pSrcDst, size_t nLength);
103
104/**
105 * 16-bit unsigned short integer in place min value for each pair of elements.
106 * \param pSrc \ref source_signal_pointer.
107 * \param pSrcDst \ref in_place_signal_pointer.
108 * \param nLength \ref length_specification.
109 * \param nppStreamCtx \ref application_managed_stream_context.
110 * \return \ref signal_data_error_codes, \ref length_error_codes.
111 */
112NppStatus
113nppsMinEvery_16u_I_Ctx(const Npp16u * pSrc, Npp16u * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
114/**
115 * 16-bit unsigned short integer in place min value for each pair of elements.
116 * \param pSrc \ref source_signal_pointer.
117 * \param pSrcDst \ref in_place_signal_pointer.
118 * \param nLength \ref length_specification.
119
120 * \return \ref signal_data_error_codes, \ref length_error_codes.
121 */
122NppStatus
123nppsMinEvery_16u_I(const Npp16u * pSrc, Npp16u * pSrcDst, size_t nLength);
124
125/**
126 * 16-bit signed short integer in place min value for each pair of elements.
127 * \param pSrc \ref source_signal_pointer.
128 * \param pSrcDst \ref in_place_signal_pointer.
129 * \param nLength \ref length_specification.
130 * \param nppStreamCtx \ref application_managed_stream_context.
131 * \return \ref signal_data_error_codes, \ref length_error_codes.
132 */
133NppStatus
134nppsMinEvery_16s_I_Ctx(const Npp16s * pSrc, Npp16s * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
135/**
136 * 16-bit signed short integer in place min value for each pair of elements.
137 * \param pSrc \ref source_signal_pointer.
138 * \param pSrcDst \ref in_place_signal_pointer.
139 * \param nLength \ref length_specification.
140
141 * \return \ref signal_data_error_codes, \ref length_error_codes.
142 */
143NppStatus
144nppsMinEvery_16s_I(const Npp16s * pSrc, Npp16s * pSrcDst, size_t nLength);
145
146/**
147 * 32-bit signed integer in place min value for each pair of elements.
148 * \param pSrc \ref source_signal_pointer.
149 * \param pSrcDst \ref in_place_signal_pointer.
150 * \param nLength \ref length_specification.
151 * \param nppStreamCtx \ref application_managed_stream_context.
152 * \return \ref signal_data_error_codes, \ref length_error_codes.
153 */
154NppStatus
155nppsMinEvery_32s_I_Ctx(const Npp32s * pSrc, Npp32s * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
156/**
157 * 32-bit signed integer in place min value for each pair of elements.
158 * \param pSrc \ref source_signal_pointer.
159 * \param pSrcDst \ref in_place_signal_pointer.
160 * \param nLength \ref length_specification.
161
162 * \return \ref signal_data_error_codes, \ref length_error_codes.
163 */
164NppStatus
165nppsMinEvery_32s_I(const Npp32s * pSrc, Npp32s * pSrcDst, size_t nLength);
166
167/**
168 * 32-bit floating point in place min value for each pair of elements.
169 * \param pSrc \ref source_signal_pointer.
170 * \param pSrcDst \ref in_place_signal_pointer.
171 * \param nLength \ref length_specification.
172 * \param nppStreamCtx \ref application_managed_stream_context.
173 * \return \ref signal_data_error_codes, \ref length_error_codes.
174 */
175NppStatus
176nppsMinEvery_32f_I_Ctx(const Npp32f * pSrc, Npp32f * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
177/**
178 * 32-bit floating point in place min value for each pair of elements.
179 * \param pSrc \ref source_signal_pointer.
180 * \param pSrcDst \ref in_place_signal_pointer.
181 * \param nLength \ref length_specification.
182
183 * \return \ref signal_data_error_codes, \ref length_error_codes.
184 */
185NppStatus
186nppsMinEvery_32f_I(const Npp32f * pSrc, Npp32f * pSrcDst, size_t nLength);
187
188/**
189 * 64-bit floating point in place min value for each pair of elements.
190 * \param pSrc \ref source_signal_pointer.
191 * \param pSrcDst \ref in_place_signal_pointer.
192 * \param nLength \ref length_specification.
193 * \param nppStreamCtx \ref application_managed_stream_context.
194 * \return \ref signal_data_error_codes, \ref length_error_codes.
195 */
196NppStatus
197nppsMinEvery_64f_I_Ctx(const Npp64f * pSrc, Npp64f * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
198/**
199 * 64-bit floating point in place min value for each pair of elements.
200 * \param pSrc \ref source_signal_pointer.
201 * \param pSrcDst \ref in_place_signal_pointer.
202 * \param nLength \ref length_specification.
203
204 * \return \ref signal_data_error_codes, \ref length_error_codes.
205 */
206NppStatus
207nppsMinEvery_64f_I(const Npp64f * pSrc, Npp64f * pSrcDst, size_t nLength);
208
209/**
210 * 8-bit in place max value for each pair of elements.
211 * \param pSrc \ref source_signal_pointer.
212 * \param pSrcDst \ref in_place_signal_pointer.
213 * \param nLength \ref length_specification.
214 * \param nppStreamCtx \ref application_managed_stream_context.
215 * \return \ref signal_data_error_codes, \ref length_error_codes.
216 */
217NppStatus
218nppsMaxEvery_8u_I_Ctx(const Npp8u * pSrc, Npp8u * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
219/**
220 * 8-bit in place max value for each pair of elements.
221 * \param pSrc \ref source_signal_pointer.
222 * \param pSrcDst \ref in_place_signal_pointer.
223 * \param nLength \ref length_specification.
224
225 * \return \ref signal_data_error_codes, \ref length_error_codes.
226 */
227NppStatus
228nppsMaxEvery_8u_I(const Npp8u * pSrc, Npp8u * pSrcDst, size_t nLength);
229
230/**
231 * 16-bit unsigned short integer in place max value for each pair of elements.
232 * \param pSrc \ref source_signal_pointer.
233 * \param pSrcDst \ref in_place_signal_pointer.
234 * \param nLength \ref length_specification.
235 * \param nppStreamCtx \ref application_managed_stream_context.
236 * \return \ref signal_data_error_codes, \ref length_error_codes.
237 */
238NppStatus
239nppsMaxEvery_16u_I_Ctx(const Npp16u * pSrc, Npp16u * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
240/**
241 * 16-bit unsigned short integer in place max value for each pair of elements.
242 * \param pSrc \ref source_signal_pointer.
243 * \param pSrcDst \ref in_place_signal_pointer.
244 * \param nLength \ref length_specification.
245
246 * \return \ref signal_data_error_codes, \ref length_error_codes.
247 */
248NppStatus
249nppsMaxEvery_16u_I(const Npp16u * pSrc, Npp16u * pSrcDst, size_t nLength);
250
251/**
252 * 16-bit signed short integer in place max value for each pair of elements.
253 * \param pSrc \ref source_signal_pointer.
254 * \param pSrcDst \ref in_place_signal_pointer.
255 * \param nLength \ref length_specification.
256 * \param nppStreamCtx \ref application_managed_stream_context.
257 * \return \ref signal_data_error_codes, \ref length_error_codes.
258 */
259NppStatus
260nppsMaxEvery_16s_I_Ctx(const Npp16s * pSrc, Npp16s * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
261/**
262 * 16-bit signed short integer in place max value for each pair of elements.
263 * \param pSrc \ref source_signal_pointer.
264 * \param pSrcDst \ref in_place_signal_pointer.
265 * \param nLength \ref length_specification.
266
267 * \return \ref signal_data_error_codes, \ref length_error_codes.
268 */
269NppStatus
270nppsMaxEvery_16s_I(const Npp16s * pSrc, Npp16s * pSrcDst, size_t nLength);
271
272/**
273 * 32-bit signed integer in place max value for each pair of elements.
274 * \param pSrc \ref source_signal_pointer.
275 * \param pSrcDst \ref in_place_signal_pointer.
276 * \param nLength \ref length_specification.
277 * \param nppStreamCtx \ref application_managed_stream_context.
278 * \return \ref signal_data_error_codes, \ref length_error_codes.
279 */
280NppStatus
281nppsMaxEvery_32s_I_Ctx(const Npp32s * pSrc, Npp32s * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
282/**
283 * 32-bit signed integer in place max value for each pair of elements.
284 * \param pSrc \ref source_signal_pointer.
285 * \param pSrcDst \ref in_place_signal_pointer.
286 * \param nLength \ref length_specification.
287
288 * \return \ref signal_data_error_codes, \ref length_error_codes.
289 */
290NppStatus
291nppsMaxEvery_32s_I(const Npp32s * pSrc, Npp32s * pSrcDst, size_t nLength);
292
293/**
294 * 32-bit floating point in place max value for each pair of elements.
295 * \param pSrc \ref source_signal_pointer.
296 * \param pSrcDst \ref in_place_signal_pointer.
297 * \param nLength \ref length_specification.
298 * \param nppStreamCtx \ref application_managed_stream_context.
299 * \return \ref signal_data_error_codes, \ref length_error_codes.
300 */
301NppStatus
302nppsMaxEvery_32f_I_Ctx(const Npp32f * pSrc, Npp32f * pSrcDst, size_t nLength, NppStreamContext nppStreamCtx);
303/**
304 * 32-bit floating point in place max value for each pair of elements.
305 * \param pSrc \ref source_signal_pointer.
306 * \param pSrcDst \ref in_place_signal_pointer.
307 * \param nLength \ref length_specification.
308
309 * \return \ref signal_data_error_codes, \ref length_error_codes.
310 */
311NppStatus
312nppsMaxEvery_32f_I(const Npp32f * pSrc, Npp32f * pSrcDst, size_t nLength);
313
314/**
315 *
316 * @} signal_min_every_or_max_every
317 *
318 */
319
320/**
321 * \section signal_sum Sum
322 * @defgroup signal_sum Sum
323 * Performs the sum operation on the samples of a signal.
324 * @{
325 *
326 */
327
328 /**
329 * Device scratch buffer size (in bytes) for nppsSum_32f.
330 * \param nLength \ref length_specification.
331 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
332 * <em>host pointer.</em> \ref general_scratch_buffer.
333 * \param nppStreamCtx \ref application_managed_stream_context.
334 * \return NPP_SUCCESS
335 */
336NppStatus
337nppsSumGetBufferSize_32f_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
338 /**
339 * Device scratch buffer size (in bytes) for nppsSum_32f.
340 * \param nLength \ref length_specification.
341 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
342 * <em>host pointer.</em> \ref general_scratch_buffer.
343
344 * \return NPP_SUCCESS
345 */
346NppStatus
347nppsSumGetBufferSize_32f(size_t nLength, size_t * hpBufferSize /* host pointer */);
348
349/**
350 * Device scratch buffer size (in bytes) for nppsSum_32fc.
351 * \param nLength \ref length_specification.
352 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
353 * <em>host pointer.</em> \ref general_scratch_buffer.
354 * \param nppStreamCtx \ref application_managed_stream_context.
355 * \return NPP_SUCCESS
356 */
357NppStatus
358nppsSumGetBufferSize_32fc_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
359/**
360 * Device scratch buffer size (in bytes) for nppsSum_32fc.
361 * \param nLength \ref length_specification.
362 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
363 * <em>host pointer.</em> \ref general_scratch_buffer.
364
365 * \return NPP_SUCCESS
366 */
367NppStatus
368nppsSumGetBufferSize_32fc(size_t nLength, size_t * hpBufferSize /* host pointer */);
369
370/**
371 * Device scratch buffer size (in bytes) for nppsSum_64f.
372 * \param nLength \ref length_specification.
373 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
374 * <em>host pointer.</em> \ref general_scratch_buffer.
375 * \param nppStreamCtx \ref application_managed_stream_context.
376 * \return NPP_SUCCESS
377 */
378NppStatus
379nppsSumGetBufferSize_64f_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
380/**
381 * Device scratch buffer size (in bytes) for nppsSum_64f.
382 * \param nLength \ref length_specification.
383 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
384 * <em>host pointer.</em> \ref general_scratch_buffer.
385
386 * \return NPP_SUCCESS
387 */
388NppStatus
389nppsSumGetBufferSize_64f(size_t nLength, size_t * hpBufferSize /* host pointer */);
390
391/**
392 * Device scratch buffer size (in bytes) for nppsSum_64fc.
393 * \param nLength \ref length_specification.
394 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
395 * <em>host pointer.</em> \ref general_scratch_buffer.
396 * \param nppStreamCtx \ref application_managed_stream_context.
397 * \return NPP_SUCCESS
398 */
399NppStatus
400nppsSumGetBufferSize_64fc_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
401/**
402 * Device scratch buffer size (in bytes) for nppsSum_64fc.
403 * \param nLength \ref length_specification.
404 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
405 * <em>host pointer.</em> \ref general_scratch_buffer.
406
407 * \return NPP_SUCCESS
408 */
409NppStatus
410nppsSumGetBufferSize_64fc(size_t nLength, size_t * hpBufferSize /* host pointer */);
411
412/**
413 * Device scratch buffer size (in bytes) for nppsSum_16s_Sfs.
414 * \param nLength \ref length_specification.
415 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
416 * <em>host pointer.</em> \ref general_scratch_buffer.
417 * \param nppStreamCtx \ref application_managed_stream_context.
418 * \return NPP_SUCCESS
419 */
420NppStatus
421nppsSumGetBufferSize_16s_Sfs_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
422/**
423 * Device scratch buffer size (in bytes) for nppsSum_16s_Sfs.
424 * \param nLength \ref length_specification.
425 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
426 * <em>host pointer.</em> \ref general_scratch_buffer.
427
428 * \return NPP_SUCCESS
429 */
430NppStatus
431nppsSumGetBufferSize_16s_Sfs(size_t nLength, size_t * hpBufferSize /* host pointer */);
432
433/**
434 * Device scratch buffer size (in bytes) for nppsSum_16sc_Sfs.
435 * \param nLength \ref length_specification.
436 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
437 * <em>host pointer.</em> \ref general_scratch_buffer.
438 * \param nppStreamCtx \ref application_managed_stream_context.
439 * \return NPP_SUCCESS
440 */
441NppStatus
442nppsSumGetBufferSize_16sc_Sfs_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
443/**
444 * Device scratch buffer size (in bytes) for nppsSum_16sc_Sfs.
445 * \param nLength \ref length_specification.
446 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
447 * <em>host pointer.</em> \ref general_scratch_buffer.
448
449 * \return NPP_SUCCESS
450 */
451NppStatus
452nppsSumGetBufferSize_16sc_Sfs(size_t nLength, size_t * hpBufferSize /* host pointer */);
453
454/**
455 * Device scratch buffer size (in bytes) for nppsSum_16sc32sc_Sfs.
456 * \param nLength \ref length_specification.
457 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
458 * <em>host pointer.</em> \ref general_scratch_buffer.
459 * \param nppStreamCtx \ref application_managed_stream_context.
460 * \return NPP_SUCCESS
461 */
462NppStatus
463nppsSumGetBufferSize_16sc32sc_Sfs_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
464/**
465 * Device scratch buffer size (in bytes) for nppsSum_16sc32sc_Sfs.
466 * \param nLength \ref length_specification.
467 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
468 * <em>host pointer.</em> \ref general_scratch_buffer.
469
470 * \return NPP_SUCCESS
471 */
472NppStatus
473nppsSumGetBufferSize_16sc32sc_Sfs(size_t nLength, size_t * hpBufferSize /* host pointer */);
474
475/**
476 * Device scratch buffer size (in bytes) for nppsSum_32s_Sfs.
477 * \param nLength \ref length_specification.
478 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
479 * <em>host pointer.</em> \ref general_scratch_buffer.
480 * \param nppStreamCtx \ref application_managed_stream_context.
481 * \return NPP_SUCCESS
482 */
483NppStatus
484nppsSumGetBufferSize_32s_Sfs_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
485/**
486 * Device scratch buffer size (in bytes) for nppsSum_32s_Sfs.
487 * \param nLength \ref length_specification.
488 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
489 * <em>host pointer.</em> \ref general_scratch_buffer.
490
491 * \return NPP_SUCCESS
492 */
493NppStatus
494nppsSumGetBufferSize_32s_Sfs(size_t nLength, size_t * hpBufferSize /* host pointer */);
495
496/**
497 * Device scratch buffer size (in bytes) for nppsSum_16s32s_Sfs.
498 * \param nLength \ref length_specification.
499 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
500 * <em>host pointer.</em> \ref general_scratch_buffer.
501 * \param nppStreamCtx \ref application_managed_stream_context.
502 * \return NPP_SUCCESS
503 */
504NppStatus
505nppsSumGetBufferSize_16s32s_Sfs_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
506/**
507 * Device scratch buffer size (in bytes) for nppsSum_16s32s_Sfs.
508 * \param nLength \ref length_specification.
509 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
510 * <em>host pointer.</em> \ref general_scratch_buffer.
511
512 * \return NPP_SUCCESS
513 */
514NppStatus
515nppsSumGetBufferSize_16s32s_Sfs(size_t nLength, size_t * hpBufferSize /* host pointer */);
516
517/**
518 * 32-bit float vector sum method
519 * \param pSrc \ref source_signal_pointer.
520 * \param nLength \ref length_specification.
521 * \param pSum Pointer to the output result.
522 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
523 * Use \ref nppsSumGetBufferSize_32f to determine the minium number of bytes required.
524 * \param nppStreamCtx \ref application_managed_stream_context.
525 * \return \ref signal_data_error_codes, \ref length_error_codes.
526 */
527NppStatus
528nppsSum_32f_Ctx(const Npp32f * pSrc, size_t nLength, Npp32f * pSum, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
529/**
530 * 32-bit float vector sum method
531 * \param pSrc \ref source_signal_pointer.
532 * \param nLength \ref length_specification.
533 * \param pSum Pointer to the output result.
534 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
535 * Use \ref nppsSumGetBufferSize_32f to determine the minium number of bytes required.
536
537 * \return \ref signal_data_error_codes, \ref length_error_codes.
538 */
539NppStatus
540nppsSum_32f(const Npp32f * pSrc, size_t nLength, Npp32f * pSum, Npp8u * pDeviceBuffer);
541
542/**
543 * 32-bit float complex vector sum method
544 * \param pSrc \ref source_signal_pointer.
545 * \param nLength \ref length_specification.
546 * \param pSum Pointer to the output result.
547 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
548 * Use \ref nppsSumGetBufferSize_32fc to determine the minium number of bytes required.
549 * \param nppStreamCtx \ref application_managed_stream_context.
550 * \return \ref signal_data_error_codes, \ref length_error_codes.
551 */
552NppStatus
553nppsSum_32fc_Ctx(const Npp32fc * pSrc, size_t nLength, Npp32fc * pSum, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
554/**
555 * 32-bit float complex vector sum method
556 * \param pSrc \ref source_signal_pointer.
557 * \param nLength \ref length_specification.
558 * \param pSum Pointer to the output result.
559 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
560 * Use \ref nppsSumGetBufferSize_32fc to determine the minium number of bytes required.
561
562 * \return \ref signal_data_error_codes, \ref length_error_codes.
563 */
564NppStatus
565nppsSum_32fc(const Npp32fc * pSrc, size_t nLength, Npp32fc * pSum, Npp8u * pDeviceBuffer);
566
567/**
568 * 64-bit double vector sum method
569 * \param pSrc \ref source_signal_pointer.
570 * \param nLength \ref length_specification.
571 * \param pSum Pointer to the output result.
572 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
573 * Use \ref nppsSumGetBufferSize_64f to determine the minium number of bytes required.
574 * \param nppStreamCtx \ref application_managed_stream_context.
575 * \return \ref signal_data_error_codes, \ref length_error_codes.
576 */
577NppStatus
578nppsSum_64f_Ctx(const Npp64f * pSrc, size_t nLength, Npp64f * pSum, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
579/**
580 * 64-bit double vector sum method
581 * \param pSrc \ref source_signal_pointer.
582 * \param nLength \ref length_specification.
583 * \param pSum Pointer to the output result.
584 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
585 * Use \ref nppsSumGetBufferSize_64f to determine the minium number of bytes required.
586
587 * \return \ref signal_data_error_codes, \ref length_error_codes.
588 */
589NppStatus
590nppsSum_64f(const Npp64f * pSrc, size_t nLength, Npp64f * pSum, Npp8u * pDeviceBuffer);
591
592/**
593 * 64-bit double complex vector sum method
594 * \param pSrc \ref source_signal_pointer.
595 * \param nLength \ref length_specification.
596 * \param pSum Pointer to the output result.
597 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
598 * Use \ref nppsSumGetBufferSize_64fc to determine the minium number of bytes required.
599 * \param nppStreamCtx \ref application_managed_stream_context.
600 * \return \ref signal_data_error_codes, \ref length_error_codes.
601 */
602NppStatus
603nppsSum_64fc_Ctx(const Npp64fc * pSrc, size_t nLength, Npp64fc * pSum, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
604/**
605 * 64-bit double complex vector sum method
606 * \param pSrc \ref source_signal_pointer.
607 * \param nLength \ref length_specification.
608 * \param pSum Pointer to the output result.
609 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
610 * Use \ref nppsSumGetBufferSize_64fc to determine the minium number of bytes required.
611 * \return \ref signal_data_error_codes, \ref length_error_codes.
612 */
613NppStatus
614nppsSum_64fc(const Npp64fc * pSrc, size_t nLength, Npp64fc * pSum, Npp8u * pDeviceBuffer);
615
616/**
617 * 16-bit short vector sum with integer scaling method
618 * \param pSrc \ref source_signal_pointer.
619 * \param nLength \ref length_specification.
620 * \param pSum Pointer to the output result.
621 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
622 * Use \ref nppsSumGetBufferSize_16s_Sfs to determine the minium number of bytes required.
623 * \param nScaleFactor \ref integer_result_scaling.
624 * \param nppStreamCtx \ref application_managed_stream_context.
625 * \return \ref signal_data_error_codes, \ref length_error_codes.
626 */
627NppStatus
628nppsSum_16s_Sfs_Ctx(const Npp16s * pSrc, size_t nLength, Npp16s * pSum, int nScaleFactor,
629 Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
630/**
631 * 16-bit short vector sum with integer scaling method
632 * \param pSrc \ref source_signal_pointer.
633 * \param nLength \ref length_specification.
634 * \param pSum Pointer to the output result.
635 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
636 * Use \ref nppsSumGetBufferSize_16s_Sfs to determine the minium number of bytes required.
637 * \param nScaleFactor \ref integer_result_scaling.
638 * \return \ref signal_data_error_codes, \ref length_error_codes.
639 */
640NppStatus
641nppsSum_16s_Sfs(const Npp16s * pSrc, size_t nLength, Npp16s * pSum, int nScaleFactor,
642 Npp8u * pDeviceBuffer);
643
644/**
645 * 32-bit integer vector sum with integer scaling method
646 * \param pSrc \ref source_signal_pointer.
647 * \param nLength \ref length_specification.
648 * \param pSum Pointer to the output result.
649 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
650 * Use \ref nppsSumGetBufferSize_32s_Sfs to determine the minium number of bytes required.
651 * \param nScaleFactor \ref integer_result_scaling.
652 * \param nppStreamCtx \ref application_managed_stream_context.
653 * \return \ref signal_data_error_codes, \ref length_error_codes.
654 */
655NppStatus
656nppsSum_32s_Sfs_Ctx(const Npp32s * pSrc, size_t nLength, Npp32s * pSum, int nScaleFactor,
657 Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
658/**
659 * 32-bit integer vector sum with integer scaling method
660 * \param pSrc \ref source_signal_pointer.
661 * \param nLength \ref length_specification.
662 * \param pSum Pointer to the output result.
663 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
664 * Use \ref nppsSumGetBufferSize_32s_Sfs to determine the minium number of bytes required.
665 * \param nScaleFactor \ref integer_result_scaling.
666 * \return \ref signal_data_error_codes, \ref length_error_codes.
667 */
668NppStatus
669nppsSum_32s_Sfs(const Npp32s * pSrc, size_t nLength, Npp32s * pSum, int nScaleFactor,
670 Npp8u * pDeviceBuffer);
671
672/**
673 * 16-bit short complex vector sum with integer scaling method
674 * \param pSrc \ref source_signal_pointer.
675 * \param nLength \ref length_specification.
676 * \param pSum Pointer to the output result.
677 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
678 * Use \ref nppsSumGetBufferSize_16sc_Sfs to determine the minium number of bytes required.
679 * \param nScaleFactor \ref integer_result_scaling.
680 * \param nppStreamCtx \ref application_managed_stream_context.
681 * \return \ref signal_data_error_codes, \ref length_error_codes.
682 */
683NppStatus
684nppsSum_16sc_Sfs_Ctx(const Npp16sc * pSrc, size_t nLength, Npp16sc * pSum, int nScaleFactor,
685 Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
686/**
687 * 16-bit short complex vector sum with integer scaling method
688 * \param pSrc \ref source_signal_pointer.
689 * \param nLength \ref length_specification.
690 * \param pSum Pointer to the output result.
691 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
692 * Use \ref nppsSumGetBufferSize_16sc_Sfs to determine the minium number of bytes required.
693 * \param nScaleFactor \ref integer_result_scaling.
694 * \return \ref signal_data_error_codes, \ref length_error_codes.
695 */
696NppStatus
697nppsSum_16sc_Sfs(const Npp16sc * pSrc, size_t nLength, Npp16sc * pSum, int nScaleFactor,
698 Npp8u * pDeviceBuffer);
699
700/**
701 * 16-bit short complex vector sum (32bit int complex) with integer scaling
702 * method
703 * \param pSrc \ref source_signal_pointer.
704 * \param nLength \ref length_specification.
705 * \param pSum Pointer to the output result.
706 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
707 * Use \ref nppsSumGetBufferSize_16sc32sc_Sfs to determine the minium number of bytes required.
708 * \param nScaleFactor \ref integer_result_scaling.
709 * \param nppStreamCtx \ref application_managed_stream_context.
710 * \return \ref signal_data_error_codes, \ref length_error_codes.
711 */
712NppStatus
713nppsSum_16sc32sc_Sfs_Ctx(const Npp16sc * pSrc, size_t nLength, Npp32sc * pSum, int nScaleFactor,
714 Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
715/**
716 * 16-bit short complex vector sum (32bit int complex) with integer scaling
717 * method
718 * \param pSrc \ref source_signal_pointer.
719 * \param nLength \ref length_specification.
720 * \param pSum Pointer to the output result.
721 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
722 * Use \ref nppsSumGetBufferSize_16sc32sc_Sfs to determine the minium number of bytes required.
723 * \param nScaleFactor \ref integer_result_scaling.
724 * \return \ref signal_data_error_codes, \ref length_error_codes.
725 */
726NppStatus
727nppsSum_16sc32sc_Sfs(const Npp16sc * pSrc, size_t nLength, Npp32sc * pSum, int nScaleFactor,
728 Npp8u * pDeviceBuffer);
729
730/**
731 * 16-bit integer vector sum (32bit) with integer scaling method
732 * \param pSrc \ref source_signal_pointer.
733 * \param nLength \ref length_specification.
734 * \param pSum Pointer to the output result.
735 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
736 * Use \ref nppsSumGetBufferSize_16s32s_Sfs to determine the minium number of bytes required.
737 * \param nScaleFactor \ref integer_result_scaling.
738 * \param nppStreamCtx \ref application_managed_stream_context.
739 * \return \ref signal_data_error_codes, \ref length_error_codes.
740 */
741NppStatus
742nppsSum_16s32s_Sfs_Ctx(const Npp16s * pSrc, size_t nLength, Npp32s * pSum, int nScaleFactor,
743 Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
744/**
745 * 16-bit integer vector sum (32bit) with integer scaling method
746 * \param pSrc \ref source_signal_pointer.
747 * \param nLength \ref length_specification.
748 * \param pSum Pointer to the output result.
749 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
750 * Use \ref nppsSumGetBufferSize_16s32s_Sfs to determine the minium number of bytes required.
751 * \param nScaleFactor \ref integer_result_scaling.
752 * \return \ref signal_data_error_codes, \ref length_error_codes.
753 */
754NppStatus
755nppsSum_16s32s_Sfs(const Npp16s * pSrc, size_t nLength, Npp32s * pSum, int nScaleFactor,
756 Npp8u * pDeviceBuffer);
757
758/** @} signal_sum */
759
760
761/**
762 * \section signal_max Maximum
763 * @defgroup signal_max Maximum
764 * Performs the maximum operation on the samples of a signal.
765 * @{
766 *
767 */
768
769/**
770 * Device scratch buffer size (in bytes) for nppsMax_16s.
771 * \param nLength \ref length_specification.
772 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
773 * <em>host pointer.</em> \ref general_scratch_buffer.
774 * \param nppStreamCtx \ref application_managed_stream_context.
775 * \return NPP_SUCCESS
776 */
777NppStatus
778nppsMaxGetBufferSize_16s_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
779/**
780 * Device scratch buffer size (in bytes) for nppsMax_16s.
781 * \param nLength \ref length_specification.
782 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
783 * <em>host pointer.</em> \ref general_scratch_buffer.
784 * \return NPP_SUCCESS
785 */
786NppStatus
787nppsMaxGetBufferSize_16s(size_t nLength, size_t * hpBufferSize /* host pointer */);
788
789/**
790 * Device scratch buffer size (in bytes) for nppsMax_32s.
791 * \param nLength \ref length_specification.
792 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
793 * <em>host pointer.</em> \ref general_scratch_buffer.
794 * \param nppStreamCtx \ref application_managed_stream_context.
795 * \return NPP_SUCCESS
796 */
797NppStatus
798nppsMaxGetBufferSize_32s_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
799/**
800 * Device scratch buffer size (in bytes) for nppsMax_32s.
801 * \param nLength \ref length_specification.
802 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
803 * <em>host pointer.</em> \ref general_scratch_buffer.
804 * \return NPP_SUCCESS
805 */
806NppStatus
807nppsMaxGetBufferSize_32s(size_t nLength, size_t * hpBufferSize /* host pointer */);
808
809/**
810 * Device scratch buffer size (in bytes) for nppsMax_32f.
811 * \param nLength \ref length_specification.
812 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
813 * <em>host pointer.</em> \ref general_scratch_buffer.
814 * \param nppStreamCtx \ref application_managed_stream_context.
815 * \return NPP_SUCCESS
816 */
817NppStatus
818nppsMaxGetBufferSize_32f_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
819/**
820 * Device scratch buffer size (in bytes) for nppsMax_32f.
821 * \param nLength \ref length_specification.
822 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
823 * <em>host pointer.</em> \ref general_scratch_buffer.
824 * \return NPP_SUCCESS
825 */
826NppStatus
827nppsMaxGetBufferSize_32f(size_t nLength, size_t * hpBufferSize /* host pointer */);
828
829/**
830 * Device scratch buffer size (in bytes) for nppsMax_64f.
831 * \param nLength \ref length_specification.
832 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
833 * <em>host pointer.</em> \ref general_scratch_buffer.
834 * \param nppStreamCtx \ref application_managed_stream_context.
835 * \return NPP_SUCCESS
836 */
837NppStatus
838nppsMaxGetBufferSize_64f_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
839/**
840 * Device scratch buffer size (in bytes) for nppsMax_64f.
841 * \param nLength \ref length_specification.
842 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
843 * <em>host pointer.</em> \ref general_scratch_buffer.
844 * \return NPP_SUCCESS
845 */
846NppStatus
847nppsMaxGetBufferSize_64f(size_t nLength, size_t * hpBufferSize /* host pointer */);
848
849/**
850 * 16-bit integer vector max method
851 * \param pSrc \ref source_signal_pointer.
852 * \param nLength \ref length_specification.
853 * \param pMax Pointer to the output result.
854 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
855 * Use \ref nppsMaxGetBufferSize_16s to determine the minium number of bytes required.
856 * \param nppStreamCtx \ref application_managed_stream_context.
857 * \return \ref signal_data_error_codes, \ref length_error_codes.
858 */
859NppStatus
860nppsMax_16s_Ctx(const Npp16s * pSrc, size_t nLength, Npp16s * pMax, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
861/**
862 * 16-bit integer vector max method
863 * \param pSrc \ref source_signal_pointer.
864 * \param nLength \ref length_specification.
865 * \param pMax Pointer to the output result.
866 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
867 * Use \ref nppsMaxGetBufferSize_16s to determine the minium number of bytes required.
868 * \return \ref signal_data_error_codes, \ref length_error_codes.
869 */
870NppStatus
871nppsMax_16s(const Npp16s * pSrc, size_t nLength, Npp16s * pMax, Npp8u * pDeviceBuffer);
872
873/**
874 * 32-bit integer vector max method
875 * \param pSrc \ref source_signal_pointer.
876 * \param nLength \ref length_specification.
877 * \param pMax Pointer to the output result.
878 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
879 * Use \ref nppsMaxGetBufferSize_32s to determine the minium number of bytes required.
880 * \param nppStreamCtx \ref application_managed_stream_context.
881 * \return \ref signal_data_error_codes, \ref length_error_codes.
882 */
883NppStatus
884nppsMax_32s_Ctx(const Npp32s * pSrc, size_t nLength, Npp32s * pMax, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
885/**
886 * 32-bit integer vector max method
887 * \param pSrc \ref source_signal_pointer.
888 * \param nLength \ref length_specification.
889 * \param pMax Pointer to the output result.
890 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
891 * Use \ref nppsMaxGetBufferSize_32s to determine the minium number of bytes required.
892 * \return \ref signal_data_error_codes, \ref length_error_codes.
893 */
894NppStatus
895nppsMax_32s(const Npp32s * pSrc, size_t nLength, Npp32s * pMax, Npp8u * pDeviceBuffer);
896
897/**
898 * 32-bit float vector max method
899 * \param pSrc \ref source_signal_pointer.
900 * \param nLength \ref length_specification.
901 * \param pMax Pointer to the output result.
902 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
903 * Use \ref nppsMaxGetBufferSize_32f to determine the minium number of bytes required.
904 * \param nppStreamCtx \ref application_managed_stream_context.
905 * \return \ref signal_data_error_codes, \ref length_error_codes.
906 */
907NppStatus
908nppsMax_32f_Ctx(const Npp32f * pSrc, size_t nLength, Npp32f * pMax, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
909/**
910 * 32-bit float vector max method
911 * \param pSrc \ref source_signal_pointer.
912 * \param nLength \ref length_specification.
913 * \param pMax Pointer to the output result.
914 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
915 * Use \ref nppsMaxGetBufferSize_32f to determine the minium number of bytes required.
916 * \return \ref signal_data_error_codes, \ref length_error_codes.
917 */
918NppStatus
919nppsMax_32f(const Npp32f * pSrc, size_t nLength, Npp32f * pMax, Npp8u * pDeviceBuffer);
920
921/**
922 * 64-bit float vector max method
923 * \param pSrc \ref source_signal_pointer.
924 * \param nLength \ref length_specification.
925 * \param pMax Pointer to the output result.
926 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
927 * Use \ref nppsMaxGetBufferSize_64f to determine the minium number of bytes required.
928 * \param nppStreamCtx \ref application_managed_stream_context.
929 * \return \ref signal_data_error_codes, \ref length_error_codes.
930 */
931NppStatus
932nppsMax_64f_Ctx(const Npp64f * pSrc, size_t nLength, Npp64f * pMax, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
933/**
934 * 64-bit float vector max method
935 * \param pSrc \ref source_signal_pointer.
936 * \param nLength \ref length_specification.
937 * \param pMax Pointer to the output result.
938 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
939 * Use \ref nppsMaxGetBufferSize_64f to determine the minium number of bytes required.
940 * \return \ref signal_data_error_codes, \ref length_error_codes.
941 */
942NppStatus
943nppsMax_64f(const Npp64f * pSrc, size_t nLength, Npp64f * pMax, Npp8u * pDeviceBuffer);
944
945/**
946 * Device scratch buffer size (in bytes) for nppsMaxIndx_16s.
947 * \param nLength \ref length_specification.
948 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
949 * <em>host pointer.</em> \ref general_scratch_buffer.
950 * \param nppStreamCtx \ref application_managed_stream_context.
951 * \return NPP_SUCCESS
952 */
953NppStatus
954nppsMaxIndxGetBufferSize_16s_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
955/**
956 * Device scratch buffer size (in bytes) for nppsMaxIndx_16s.
957 * \param nLength \ref length_specification.
958 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
959 * <em>host pointer.</em> \ref general_scratch_buffer.
960 * \return NPP_SUCCESS
961 */
962NppStatus
963nppsMaxIndxGetBufferSize_16s(size_t nLength, size_t * hpBufferSize /* host pointer */);
964
965/**
966 * Device scratch buffer size (in bytes) for nppsMaxIndx_32s.
967 * \param nLength \ref length_specification.
968 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
969 * <em>host pointer.</em> \ref general_scratch_buffer.
970 * \param nppStreamCtx \ref application_managed_stream_context.
971 * \return NPP_SUCCESS
972 */
973NppStatus
974nppsMaxIndxGetBufferSize_32s_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
975/**
976 * Device scratch buffer size (in bytes) for nppsMaxIndx_32s.
977 * \param nLength \ref length_specification.
978 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
979 * <em>host pointer.</em> \ref general_scratch_buffer.
980 * \return NPP_SUCCESS
981 */
982NppStatus
983nppsMaxIndxGetBufferSize_32s(size_t nLength, size_t * hpBufferSize /* host pointer */);
984
985/**
986 * Device scratch buffer size (in bytes) for nppsMaxIndx_32f.
987 * \param nLength \ref length_specification.
988 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
989 * <em>host pointer.</em> \ref general_scratch_buffer.
990 * \param nppStreamCtx \ref application_managed_stream_context.
991 * \return NPP_SUCCESS
992 */
993NppStatus
994nppsMaxIndxGetBufferSize_32f_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
995/**
996 * Device scratch buffer size (in bytes) for nppsMaxIndx_32f.
997 * \param nLength \ref length_specification.
998 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
999 * <em>host pointer.</em> \ref general_scratch_buffer.
1000 * \return NPP_SUCCESS
1001 */
1002NppStatus
1003nppsMaxIndxGetBufferSize_32f(size_t nLength, size_t * hpBufferSize /* host pointer */);
1004
1005/**
1006 * Device scratch buffer size (in bytes) for nppsMaxIndx_64f.
1007 * \param nLength \ref length_specification.
1008 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
1009 * <em>host pointer.</em> \ref general_scratch_buffer.
1010 * \param nppStreamCtx \ref application_managed_stream_context.
1011 * \return NPP_SUCCESS
1012 */
1013NppStatus
1014nppsMaxIndxGetBufferSize_64f_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
1015/**
1016 * Device scratch buffer size (in bytes) for nppsMaxIndx_64f.
1017 * \param nLength \ref length_specification.
1018 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
1019 * <em>host pointer.</em> \ref general_scratch_buffer.
1020 * \return NPP_SUCCESS
1021 */
1022NppStatus
1023nppsMaxIndxGetBufferSize_64f(size_t nLength, size_t * hpBufferSize /* host pointer */);
1024
1025/**
1026 * 16-bit integer vector max index method
1027 * \param pSrc \ref source_signal_pointer.
1028 * \param nLength \ref length_specification.
1029 * \param pMax Pointer to the output result.
1030 * \param pIndx Pointer to the index value of the first maximum element.
1031 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1032 * Use \ref nppsMaxIndxGetBufferSize_16s to determine the minium number of bytes required.
1033 * \param nppStreamCtx \ref application_managed_stream_context.
1034 * \return \ref signal_data_error_codes, \ref length_error_codes.
1035 */
1036NppStatus
1037nppsMaxIndx_16s_Ctx(const Npp16s * pSrc, size_t nLength, Npp16s * pMax, int * pIndx, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
1038/**
1039 * 16-bit integer vector max index method
1040 * \param pSrc \ref source_signal_pointer.
1041 * \param nLength \ref length_specification.
1042 * \param pMax Pointer to the output result.
1043 * \param pIndx Pointer to the index value of the first maximum element.
1044 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1045 * Use \ref nppsMaxIndxGetBufferSize_16s to determine the minium number of bytes required.
1046 * \return \ref signal_data_error_codes, \ref length_error_codes.
1047 */
1048NppStatus
1049nppsMaxIndx_16s(const Npp16s * pSrc, size_t nLength, Npp16s * pMax, int * pIndx, Npp8u * pDeviceBuffer);
1050
1051/**
1052 * 32-bit integer vector max index method
1053 * \param pSrc \ref source_signal_pointer.
1054 * \param nLength \ref length_specification.
1055 * \param pMax Pointer to the output result.
1056 * \param pIndx Pointer to the index value of the first maximum element.
1057 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1058 * Use \ref nppsMaxIndxGetBufferSize_32s to determine the minium number of bytes required.
1059 * \param nppStreamCtx \ref application_managed_stream_context.
1060 * \return \ref signal_data_error_codes, \ref length_error_codes.
1061 */
1062NppStatus
1063nppsMaxIndx_32s_Ctx(const Npp32s * pSrc, size_t nLength, Npp32s * pMax, int * pIndx, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
1064/**
1065 * 32-bit integer vector max index method
1066 * \param pSrc \ref source_signal_pointer.
1067 * \param nLength \ref length_specification.
1068 * \param pMax Pointer to the output result.
1069 * \param pIndx Pointer to the index value of the first maximum element.
1070 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1071 * Use \ref nppsMaxIndxGetBufferSize_32s to determine the minium number of bytes required.
1072 * \return \ref signal_data_error_codes, \ref length_error_codes.
1073 */
1074NppStatus
1075nppsMaxIndx_32s(const Npp32s * pSrc, size_t nLength, Npp32s * pMax, int * pIndx, Npp8u * pDeviceBuffer);
1076
1077/**
1078 * 32-bit float vector max index method
1079 * \param pSrc \ref source_signal_pointer.
1080 * \param nLength \ref length_specification.
1081 * \param pMax Pointer to the output result.
1082 * \param pIndx Pointer to the index value of the first maximum element.
1083 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1084 * Use \ref nppsMaxIndxGetBufferSize_32f to determine the minium number of bytes required.
1085 * \param nppStreamCtx \ref application_managed_stream_context.
1086 * \return \ref signal_data_error_codes, \ref length_error_codes.
1087 */
1088NppStatus
1089nppsMaxIndx_32f_Ctx(const Npp32f * pSrc, size_t nLength, Npp32f * pMax, int * pIndx, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
1090/**
1091 * 32-bit integer vector max index method
1092 * \param pSrc \ref source_signal_pointer.
1093 * \param nLength \ref length_specification.
1094 * \param pMax Pointer to the output result.
1095 * \param pIndx Pointer to the index value of the first maximum element.
1096 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1097 * Use \ref nppsMaxIndxGetBufferSize_32s to determine the minium number of bytes required.
1098 * \return \ref signal_data_error_codes, \ref length_error_codes.
1099 */
1100NppStatus
1101nppsMaxIndx_32f(const Npp32f * pSrc, size_t nLength, Npp32f * pMax, int * pIndx, Npp8u * pDeviceBuffer);
1102
1103/**
1104 * 64-bit float vector max index method
1105 * \param pSrc \ref source_signal_pointer.
1106 * \param nLength \ref length_specification.
1107 * \param pMax Pointer to the output result.
1108 * \param pIndx Pointer to the index value of the first maximum element.
1109 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1110 * Use \ref nppsMaxIndxGetBufferSize_64f to determine the minium number of bytes required.
1111 * \param nppStreamCtx \ref application_managed_stream_context.
1112 * \return \ref signal_data_error_codes, \ref length_error_codes.
1113 */
1114NppStatus
1115nppsMaxIndx_64f_Ctx(const Npp64f * pSrc, size_t nLength, Npp64f * pMax, int * pIndx, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
1116/**
1117 * 64-bit float vector max index method
1118 * \param pSrc \ref source_signal_pointer.
1119 * \param nLength \ref length_specification.
1120 * \param pMax Pointer to the output result.
1121 * \param pIndx Pointer to the index value of the first maximum element.
1122 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1123 * Use \ref nppsMaxIndxGetBufferSize_64f to determine the minium number of bytes required.
1124 * \return \ref signal_data_error_codes, \ref length_error_codes.
1125 */
1126NppStatus
1127nppsMaxIndx_64f(const Npp64f * pSrc, size_t nLength, Npp64f * pMax, int * pIndx, Npp8u * pDeviceBuffer);
1128
1129/**
1130 * Device scratch buffer size (in bytes) for nppsMaxAbs_16s.
1131 * \param nLength \ref length_specification.
1132 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
1133 * <em>host pointer.</em> \ref general_scratch_buffer.
1134 * \param nppStreamCtx \ref application_managed_stream_context.
1135 * \return NPP_SUCCESS
1136 */
1137NppStatus
1138nppsMaxAbsGetBufferSize_16s_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
1139/**
1140 * Device scratch buffer size (in bytes) for nppsMaxAbs_16s.
1141 * \param nLength \ref length_specification.
1142 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
1143 * <em>host pointer.</em> \ref general_scratch_buffer.
1144 * \return NPP_SUCCESS
1145 */
1146NppStatus
1147nppsMaxAbsGetBufferSize_16s(size_t nLength, size_t * hpBufferSize /* host pointer */);
1148
1149/**
1150 * Device scratch buffer size (in bytes) for nppsMaxAbs_32s.
1151 * \param nLength \ref length_specification.
1152 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
1153 * <em>host pointer.</em> \ref general_scratch_buffer.
1154 * \param nppStreamCtx \ref application_managed_stream_context.
1155 * \return NPP_SUCCESS
1156 */
1157NppStatus
1158nppsMaxAbsGetBufferSize_32s_Ctx(size_t nLength, size_t * hpBufferSize /* host pointer */, NppStreamContext nppStreamCtx);
1159/**
1160 * Device scratch buffer size (in bytes) for nppsMaxAbs_32s.
1161 * \param nLength \ref length_specification.
1162 * \param hpBufferSize Required buffer size. Important: hpBufferSize is a
1163 * <em>host pointer.</em> \ref general_scratch_buffer.
1164 * \return NPP_SUCCESS
1165 */
1166NppStatus
1167nppsMaxAbsGetBufferSize_32s(size_t nLength, size_t * hpBufferSize /* host pointer */);
1168
1169/**
1170 * 16-bit integer vector max absolute method
1171 * \param pSrc \ref source_signal_pointer.
1172 * \param nLength \ref length_specification.
1173 * \param pMaxAbs Pointer to the output result.
1174 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1175 * Use \ref nppsMaxAbsGetBufferSize_16s to determine the minium number of bytes required.
1176 * \param nppStreamCtx \ref application_managed_stream_context.
1177 * \return \ref signal_data_error_codes, \ref length_error_codes.
1178 */
1179NppStatus
1180nppsMaxAbs_16s_Ctx(const Npp16s * pSrc, size_t nLength, Npp16s * pMaxAbs, Npp8u * pDeviceBuffer, NppStreamContext nppStreamCtx);
1181/**
1182 * 16-bit integer vector max absolute method
1183 * \param pSrc \ref source_signal_pointer.
1184 * \param nLength \ref length_specification.
1185 * \param pMaxAbs Pointer to the output result.
1186 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1187 * Use \ref nppsMaxAbsGetBufferSize_16s to determine the minium number of bytes required.
1188 * \return \ref signal_data_error_codes, \ref length_error_codes.
1189 */
1190NppStatus
1191nppsMaxAbs_16s(const Npp16s * pSrc, size_t nLength, Npp16s * pMaxAbs, Npp8u * pDeviceBuffer);
1192
1193/**
1194 * 32-bit integer vector max absolute method
1195 * \param pSrc \ref source_signal_pointer.
1196 * \param nLength \ref length_specification.
1197 * \param pMaxAbs Pointer to the output result.
1198 * \param pDeviceBuffer Pointer to the required device memory allocation, \ref general_scratch_buffer.
1199 * Use \ref nppsMaxAbsGetBufferSize_32s to determine the minium number of bytes required.
1200 * \param nppStreamCtx \ref application_managed_stream_context.