numafunc1.c File Reference

#include <math.h>
#include "allheaders.h"
#include "array_internal.h"

Go to the source code of this file.

Functions
NUMA *	numaArithOp (NUMA *nad, NUMA *na1, NUMA *na2, l_int32 op)
NUMA *	numaLogicalOp (NUMA *nad, NUMA *na1, NUMA *na2, l_int32 op)
NUMA *	numaInvert (NUMA *nad, NUMA *nas)
l_int32	numaSimilar (NUMA *na1, NUMA *na2, l_float32 maxdiff, l_int32 *psimilar)
l_ok	numaAddToNumber (NUMA *na, l_int32 index, l_float32 val)
l_ok	numaGetMin (NUMA *na, l_float32 *pminval, l_int32 *piminloc)
l_ok	numaGetMax (NUMA *na, l_float32 *pmaxval, l_int32 *pimaxloc)
l_ok	numaGetSum (NUMA *na, l_float32 *psum)
NUMA *	numaGetPartialSums (NUMA *na)
l_ok	numaGetSumOnInterval (NUMA *na, l_int32 first, l_int32 last, l_float32 *psum)
l_ok	numaHasOnlyIntegers (NUMA *na, l_int32 *pallints)
l_ok	numaGetMean (NUMA *na, l_float32 *pave)
l_ok	numaGetMeanAbsval (NUMA *na, l_float32 *paveabs)
NUMA *	numaSubsample (NUMA *nas, l_int32 subfactor)
NUMA *	numaMakeDelta (NUMA *nas)
NUMA *	numaMakeSequence (l_float32 startval, l_float32 increment, l_int32 size)
NUMA *	numaMakeConstant (l_float32 val, l_int32 size)
NUMA *	numaMakeAbsval (NUMA *nad, NUMA *nas)
NUMA *	numaAddBorder (NUMA *nas, l_int32 left, l_int32 right, l_float32 val)
NUMA *	numaAddSpecifiedBorder (NUMA *nas, l_int32 left, l_int32 right, l_int32 type)
NUMA *	numaRemoveBorder (NUMA *nas, l_int32 left, l_int32 right)
l_ok	numaCountNonzeroRuns (NUMA *na, l_int32 *pcount)
l_ok	numaGetNonzeroRange (NUMA *na, l_float32 eps, l_int32 *pfirst, l_int32 *plast)
l_ok	numaGetCountRelativeToZero (NUMA *na, l_int32 type, l_int32 *pcount)
NUMA *	numaClipToInterval (NUMA *nas, l_int32 first, l_int32 last)
NUMA *	numaMakeThresholdIndicator (NUMA *nas, l_float32 thresh, l_int32 type)
NUMA *	numaUniformSampling (NUMA *nas, l_int32 nsamp)
NUMA *	numaReverse (NUMA *nad, NUMA *nas)
NUMA *	numaLowPassIntervals (NUMA *nas, l_float32 thresh, l_float32 maxn)
NUMA *	numaThresholdEdges (NUMA *nas, l_float32 thresh1, l_float32 thresh2, l_float32 maxn)
l_int32	numaGetSpanValues (NUMA *na, l_int32 span, l_int32 *pstart, l_int32 *pend)
l_int32	numaGetEdgeValues (NUMA *na, l_int32 edge, l_int32 *pstart, l_int32 *pend, l_int32 *psign)
l_ok	numaInterpolateEqxVal (l_float32 startx, l_float32 deltax, NUMA *nay, l_int32 type, l_float32 xval, l_float32 *pyval)
l_ok	numaInterpolateArbxVal (NUMA *nax, NUMA *nay, l_int32 type, l_float32 xval, l_float32 *pyval)
l_ok	numaInterpolateEqxInterval (l_float32 startx, l_float32 deltax, NUMA *nasy, l_int32 type, l_float32 x0, l_float32 x1, l_int32 npts, NUMA **pnax, NUMA **pnay)
l_ok	numaInterpolateArbxInterval (NUMA *nax, NUMA *nay, l_int32 type, l_float32 x0, l_float32 x1, l_int32 npts, NUMA **pnadx, NUMA **pnady)
l_ok	numaFitMax (NUMA *na, l_float32 *pmaxval, NUMA *naloc, l_float32 *pmaxloc)
l_ok	numaDifferentiateInterval (NUMA *nax, NUMA *nay, l_float32 x0, l_float32 x1, l_int32 npts, NUMA **pnadx, NUMA **pnady)
l_ok	numaIntegrateInterval (NUMA *nax, NUMA *nay, l_float32 x0, l_float32 x1, l_int32 npts, l_float32 *psum)
l_ok	numaSortGeneral (NUMA *na, NUMA **pnasort, NUMA **pnaindex, NUMA **pnainvert, l_int32 sortorder, l_int32 sorttype)
NUMA *	numaSortAutoSelect (NUMA *nas, l_int32 sortorder)
NUMA *	numaSortIndexAutoSelect (NUMA *nas, l_int32 sortorder)
l_int32	numaChooseSortType (NUMA *nas)
NUMA *	numaSort (NUMA *naout, NUMA *nain, l_int32 sortorder)
NUMA *	numaBinSort (NUMA *nas, l_int32 sortorder)
NUMA *	numaGetSortIndex (NUMA *na, l_int32 sortorder)
NUMA *	numaGetBinSortIndex (NUMA *nas, l_int32 sortorder)
NUMA *	numaSortByIndex (NUMA *nas, NUMA *naindex)
l_int32	numaIsSorted (NUMA *nas, l_int32 sortorder, l_int32 *psorted)
l_ok	numaSortPair (NUMA *nax, NUMA *nay, l_int32 sortorder, NUMA **pnasx, NUMA **pnasy)
NUMA *	numaInvertMap (NUMA *nas)
l_ok	numaAddSorted (NUMA *na, l_float32 val)
l_ok	numaFindSortedLoc (NUMA *na, l_float32 val, l_int32 *pindex)
NUMA *	numaPseudorandomSequence (l_int32 size, l_int32 seed)
NUMA *	numaRandomPermutation (NUMA *nas, l_int32 seed)
l_ok	numaGetRankValue (NUMA *na, l_float32 fract, NUMA *nasort, l_int32 usebins, l_float32 *pval)
l_ok	numaGetMedian (NUMA *na, l_float32 *pval)
l_ok	numaGetBinnedMedian (NUMA *na, l_int32 *pval)
l_ok	numaGetMeanDevFromMedian (NUMA *na, l_float32 med, l_float32 *pdev)
l_ok	numaGetMedianDevFromMedian (NUMA *na, l_float32 *pmed, l_float32 *pdev)
l_ok	numaGetMode (NUMA *na, l_float32 *pval, l_int32 *pcount)
l_ok	numaJoin (NUMA *nad, NUMA *nas, l_int32 istart, l_int32 iend)
l_ok	numaaJoin (NUMAA *naad, NUMAA *naas, l_int32 istart, l_int32 iend)
NUMA *	numaaFlattenToNuma (NUMAA *naa)

Detailed Description

     --------------------------------------
     This file has these Numa utilities:
        - arithmetic operations
        - simple data analysis
        - generation of special sequences
        - permutations
        - interpolation
        - sorting
        - data analysis requiring sorting
        - joins and rearrangements
     --------------------------------------

     Arithmetic and logic
         NUMA        *numaArithOp()
         NUMA        *numaLogicalOp()
         NUMA        *numaInvert()
         l_int32      numaSimilar()
         l_int32      numaAddToNumber()

     Simple extractions
         l_int32      numaGetMin()
         l_int32      numaGetMax()
         l_int32      numaGetSum()
         NUMA        *numaGetPartialSums()
         l_int32      numaGetSumOnInterval()
         l_int32      numaHasOnlyIntegers()
         l_int32      numaGetMean()
         l_int32      numaGetMeanAbsval()
         NUMA        *numaSubsample()
         NUMA        *numaMakeDelta()
         NUMA        *numaMakeSequence()
         NUMA        *numaMakeConstant()
         NUMA        *numaMakeAbsval()
         NUMA        *numaAddBorder()
         NUMA        *numaAddSpecifiedBorder()
         NUMA        *numaRemoveBorder()
         l_int32      numaCountNonzeroRuns()
         l_int32      numaGetNonzeroRange()
         l_int32      numaGetCountRelativeToZero()
         NUMA        *numaClipToInterval()
         NUMA        *numaMakeThresholdIndicator()
         NUMA        *numaUniformSampling()
         NUMA        *numaReverse()

     Signal feature extraction
         NUMA        *numaLowPassIntervals()
         NUMA        *numaThresholdEdges()
         NUMA        *numaGetSpanValues()
         NUMA        *numaGetEdgeValues()

     Interpolation
         l_int32      numaInterpolateEqxVal()
         l_int32      numaInterpolateEqxInterval()
         l_int32      numaInterpolateArbxVal()
         l_int32      numaInterpolateArbxInterval()

     Functions requiring interpolation
         l_int32      numaFitMax()
         l_int32      numaDifferentiateInterval()
         l_int32      numaIntegrateInterval()

     Sorting
         NUMA        *numaSortGeneral()
         NUMA        *numaSortAutoSelect()
         NUMA        *numaSortIndexAutoSelect()
         l_int32      numaChooseSortType()
         NUMA        *numaSort()
         NUMA        *numaBinSort()
         NUMA        *numaGetSortIndex()
         NUMA        *numaGetBinSortIndex()
         NUMA        *numaSortByIndex()
         l_int32      numaIsSorted()
         l_int32      numaSortPair()
         NUMA        *numaInvertMap()
         l_int32      numaAddSorted()
         l_int32      numaFindSortedLoc()

     Random permutation
         NUMA        *numaPseudorandomSequence()
         NUMA        *numaRandomPermutation()

     Functions requiring sorting
         l_int32      numaGetRankValue()
         l_int32      numaGetMedian()
         l_int32      numaGetBinnedMedian()
         l_int32      numaGetMeanDevFromMedian()
         l_int32      numaGetMedianDevFromMedian()
         l_int32      numaGetMode()

     Rearrangements
         l_int32      numaJoin()
         l_int32      numaaJoin()
         NUMA        *numaaFlattenToNuma()

   Things to remember when using the Numa:

   (1) The numa is a struct, not an array.  Always use accessors
       (see numabasic.c), never the fields directly.

   (2) The number array holds l_float32 values.  It can also
       be used to store l_int32 values.  See numabasic.c for
       details on using the accessors.

   (3) If you use numaCreate(), no numbers are stored and the size is 0.
       You have to add numbers to increase the size.
       If you want to start with a numa of a fixed size, with each
       entry initialized to the same value, use numaMakeConstant().

   (4) Occasionally, in the comments we denote the i-th element of a
       numa by na[i].  This is conceptual only -- the numa is not an array!

Definition in file numafunc1.c.

Function Documentation

numaAddBorder()

NUMA * numaAddBorder	(	NUMA *	nas,
		l_int32	left,
		l_int32	right,
		l_float32	val )

numaAddBorder()

Parameters

[in]	nas
[in]	left	number of elements to add before the start
[in]	right	number of elements to add after the end
[in]	val	initialize border elements

Returns

nad with added elements at left and right, or NULL on error

Definition at line 869 of file numafunc1.c.

References L_NOCOPY, and numaMakeConstant().

Referenced by numaAddSpecifiedBorder().

numaAddSorted()

l_ok numaAddSorted	(	NUMA *	na,
		l_float32	val )

numaAddSorted()

Parameters

[in]	na	sorted input
[in]	val	value to be inserted in sorted order

Returns

0 if OK, 1 on error

Notes:
     (1) The input na is sorted.  This function determines the
         sort order of na and inserts val into the array.

Definition at line 3025 of file numafunc1.c.

References numaFindSortedLoc().

numaAddSpecifiedBorder()

NUMA * numaAddSpecifiedBorder	(	NUMA *	nas,
		l_int32	left,
		l_int32	right,
		l_int32	type )

numaAddSpecifiedBorder()

Parameters

[in]	nas
[in]	left	number of elements to add before the start
[in]	right	number of elements to add after the end
[in]	type	L_CONTINUED_BORDER, L_MIRRORED_BORDER

Returns

nad with added elements at left and right, or NULL on error

Definition at line 910 of file numafunc1.c.

References L_CONTINUED_BORDER, L_MIRRORED_BORDER, L_NOCOPY, and numaAddBorder().

numaAddToNumber()

l_ok numaAddToNumber	(	NUMA *	na,
		l_int32	index,
		l_float32	val )

numaAddToNumber()

Parameters

[in]	na	source numa
[in]	index	element to be changed
[in]	val	new value to be added

Returns

0 if OK, 1 on error

Notes:
     (1) This is useful for accumulating sums, regardless of the index
         order in which the values are made available.
     (2) Before use, the numa has to be filled up to index.  This would
         typically be used by creating the numa with the full sized
         array, initialized to 0.0, using numaMakeConstant().

Definition at line 412 of file numafunc1.c.

References Numa::array.

numaaFlattenToNuma()

NUMA * numaaFlattenToNuma

(

NUMAA *

naa

)

numaaFlattenToNuma()

Parameters

[in]

naa

Returns

numa, or NULL on error

Notes:
     (1) This 'flattens' the Numaa to a Numa, by joining successively
         each Numa in the Numaa.
     (2) It doesn't make any assumptions about the location of the
         Numas in the Numaa array, unlike most Numaa functions.
     (3) It leaves the input Numaa unchanged.

Definition at line 3614 of file numafunc1.c.

References Numaa::nalloc, and numaJoin().

numaaJoin()

l_ok numaaJoin	(	NUMAA *	naad,
		NUMAA *	naas,
		l_int32	istart,
		l_int32	iend )

numaaJoin()

Parameters

[in]	naad	dest naa; add to this one
[in]	naas	[optional] source naa; add from this one
[in]	istart	starting index in nas
[in]	iend	ending index in naas; use -1 to cat all

Returns

0 if OK, 1 on error

Notes:
     (1) istart < 0 is taken to mean 'read from the start' (istart = 0)
     (2) iend < 0 means 'read to the end'
     (3) if naas == NULL, this is a no-op

Definition at line 3568 of file numafunc1.c.

References L_CLONE, and L_INSERT.

numaArithOp()

NUMA * numaArithOp	(	NUMA *	nad,
		NUMA *	na1,
		NUMA *	na2,
		l_int32	op )

numaArithOp()

Parameters

[in]	nad	[optional] can be null or equal to na1 (in-place
[in]	na1
[in]	na2
[in]	op	L_ARITH_ADD, L_ARITH_SUBTRACT, L_ARITH_MULTIPLY, L_ARITH_DIVIDE

Returns

nad always: operation applied to na1 and na2

Notes:
     (1) The sizes of na1 and na2 must be equal.
     (2) nad can only null or equal to na1.
     (3) To add a constant to a numa, or to multiply a numa by
         a constant, use numaTransform().

Definition at line 174 of file numafunc1.c.

numaBinSort()

NUMA * numaBinSort	(	NUMA *	nas,
		l_int32	sortorder )

numaBinSort()

Parameters

[in]	nas	of non-negative integers with a max that can not exceed (MaxInitPtraSize - 1)
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING

Returns

na sorted, or NULL on error

Notes:
     (1) Because this uses a bin sort with buckets of size 1, it
         is not appropriate for sorting either small arrays or
         arrays containing very large integer values.  For such
         arrays, use a standard general sort function like
         numaSort().
     (2) You can use numaSortAutoSelect() to decide which sorting
         method to use.

Definition at line 2633 of file numafunc1.c.

References L_SORT_DECREASING, L_SORT_INCREASING, numaGetBinSortIndex(), and numaSortByIndex().

Referenced by numaGetRankValue(), and numaSortAutoSelect().

numaChooseSortType()

l_int32 numaChooseSortType

(

NUMA *

nas

)

numaChooseSortType()

Parameters

[in]

nas

to be sorted

Returns

sorttype L_SHELL_SORT or L_BIN_SORT, or UNDEF on error.

Notes:
     (1) This selects either a shell sort or a bin sort, depending on
         the number of elements in nas and the dynamic range.
     (2) If there are negative values in nas, it selects shell sort.

Definition at line 2521 of file numafunc1.c.

References L_BIN_SORT, L_SHELL_SORT, numaGetMax(), and numaGetMin().

Referenced by numaSortAutoSelect(), and numaSortIndexAutoSelect().

numaClipToInterval()

NUMA * numaClipToInterval	(	NUMA *	nas,
		l_int32	first,
		l_int32	last )

numaClipToInterval()

Parameters

[in]	nas
[in]	first	>= 0; <= last
[in]	last

Returns

numa with the same values as the input, but clipped to the specified interval

Notes:
       If you want the indices of the array values to be unchanged,
       use first = 0.
 Usage:
       This is useful to clip a histogram that has a few nonzero
       values to its nonzero range.

Definition at line 1137 of file numafunc1.c.

numaCountNonzeroRuns()

l_ok numaCountNonzeroRuns	(	NUMA *	na,
		l_int32 *	pcount )

numaCountNonzeroRuns()

Parameters

[in]	na	e.g., of pixel counts in rows or columns
[out]	pcount	number of nonzero runs

Returns

0 if OK, 1 on error

Definition at line 998 of file numafunc1.c.

numaDifferentiateInterval()

l_ok numaDifferentiateInterval	(	NUMA *	nax,
		NUMA *	nay,
		l_float32	x0,
		l_float32	x1,
		l_int32	npts,
		NUMA **	pnadx,
		NUMA **	pnady )

numaDifferentiateInterval()

Parameters

[in]	nax	numa of abscissa values
[in]	nay	numa of ordinate values, corresponding to nax
[in]	x0	start value of interval
[in]	x1	end value of interval
[in]	npts	number of points to evaluate function in interval
[out]	pnadx	[optional] array of x values in interval
[out]	pnady	array of derivatives in interval

Returns

0 if OK, 1 on error e.g., if x0 or x1 is outside range

Notes:
     (1) The values in nax must be sorted in increasing order.
         If they are not sorted, it is done in the interpolation
         step, and a warning is issued.
     (2) Caller should check for valid return.

Definition at line 2197 of file numafunc1.c.

References L_LINEAR_INTERP, L_NOCOPY, numaGetMax(), numaGetMin(), and numaInterpolateArbxInterval().

numaFindSortedLoc()

l_ok numaFindSortedLoc	(	NUMA *	na,
		l_float32	val,
		l_int32 *	pindex )

numaFindSortedLoc()

Parameters

[in]	na	sorted input
[in]	val	value to be inserted in sorted order
[out]	*ploc	index location to insert @val

Returns

0 if OK, 1 on error

Notes:
     (1) The input na is sorted.  This determines the sort order of @na,
         either increasing or decreasing, and does a binary search for the
         location to insert val into the array.  The search is O(log n).
     (2) The index returned is the location to insert into the array.
         The value at the index, and all values to the right, are
         moved to the right (increasing their index location by 1).
     (3) If n is the size of na, *ploc can be anything in [0 ... n].
         if *ploc == 0, the value is inserted at the beginning of the
         array; if *ploc == n, it is inserted at the end.
     (4) If the size of na is 1, insert with an increasing sort.

Definition at line 3063 of file numafunc1.c.

Referenced by numaAddSorted().

numaFitMax()

l_ok numaFitMax	(	NUMA *	na,
		l_float32 *	pmaxval,
		NUMA *	naloc,
		l_float32 *	pmaxloc )

numaFitMax()

Parameters

[in]	na	numa of ordinate values, to fit a max to
[out]	pmaxval	max value
[in]	naloc	[optional] associated numa of abscissa values
[out]	pmaxloc	abscissa value that gives max value in na; if naloc == null, this is given as an interpolated index value

Returns

0 if OK; 1 on error

Notes:
       If naloc is given, there is no requirement that the
       data points are evenly spaced.  Lagrangian interpolation
       handles that.  The only requirement is that the
       data points are ordered so that the values in naloc
       are either increasing or decreasing.  We test to make
       sure that the sizes of na and naloc are equal, and it
       is assumed that the correspondences na[i] as a function
       of naloc[i] are properly arranged for all i.

 The formula for Lagrangian interpolation through 3 data pts is:
      y(x) = y1(x-x2)(x-x3)/((x1-x2)(x1-x3)) +
             y2(x-x1)(x-x3)/((x2-x1)(x2-x3)) +
             y3(x-x1)(x-x2)/((x3-x1)(x3-x2))

 Then the derivative, using the constants (c1,c2,c3) defined below,
 is set to 0:
      y'(x) = 2x(c1+c2+c3) - c1(x2+x3) - c2(x1+x3) - c3(x1+x2) = 0

Definition at line 2093 of file numafunc1.c.

References numaGetMax().

numaGetBinnedMedian()

l_ok numaGetBinnedMedian	(	NUMA *	na,
		l_int32 *	pval )

numaGetBinnedMedian()

Parameters

[in]	na	source numa
[out]	pval	integer median value

Returns

0 if OK; 1 on error

Notes:
     (1) Computes the median value of the numbers in the numa,
         using bin sort and finding the middle value in the sorted array.
     (2) See numaGetRankValue() for conditions on na for which
         this should be used.  Otherwise, use numaGetMedian().

Definition at line 3325 of file numafunc1.c.

References numaGetRankValue().

numaGetBinSortIndex()

NUMA * numaGetBinSortIndex	(	NUMA *	nas,
		l_int32	sortorder )

numaGetBinSortIndex()

Parameters

[in]	nas	of non-negative integers with a max that can not exceed (MaxInitPtraSize - 1)
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING

Returns

na sorted, or NULL on error

Notes:
     (1) This creates an array (or lookup table) that contains
         the sorted position of the elements in the input Numa.
     (2) Because it uses a bin sort with buckets of size 1, it
         is not appropriate for sorting either small arrays or
         arrays containing very large integer values.  For such
         arrays, use a standard general sort function like
         numaGetSortIndex().
     (3) You can use numaSortIndexAutoSelect() to decide which
         sorting method to use.

Definition at line 2744 of file numafunc1.c.

References L_MIN_DOWNSHIFT, L_NO_COMPACTION, L_SORT_DECREASING, L_SORT_INCREASING, numaGetMax(), numaGetMin(), and numaJoin().

Referenced by numaBinSort(), numaSortGeneral(), and numaSortIndexAutoSelect().

numaGetCountRelativeToZero()

l_ok numaGetCountRelativeToZero	(	NUMA *	na,
		l_int32	type,
		l_int32 *	pcount )

numaGetCountRelativeToZero()

Parameters

[in]	na	source numa
[in]	type	L_LESS_THAN_ZERO, L_EQUAL_TO_ZERO, L_GREATER_THAN_ZERO
[out]	pcount	count of values of given type

Returns

0 if OK, 1 on error

Definition at line 1088 of file numafunc1.c.

References L_EQUAL_TO_ZERO, L_GREATER_THAN_ZERO, and L_LESS_THAN_ZERO.

numaGetEdgeValues()

l_int32 numaGetEdgeValues	(	NUMA *	na,
		l_int32	edge,
		l_int32 *	pstart,
		l_int32 *	pend,
		l_int32 *	psign )

numaGetEdgeValues()

Parameters

[in]	na	numa that is output of numaThresholdEdges()
[in]	edge	edge number, zero-based
[out]	pstart	[optional] location of start of transition
[out]	pend	[optional] location of end of transition
[out]	psign	[optional] transition sign: +1 is rising, -1 is falling

Returns

0 if OK, 1 on error

Definition at line 1586 of file numafunc1.c.

numaGetMax()

l_ok numaGetMax	(	NUMA *	na,
		l_float32 *	pmaxval,
		l_int32 *	pimaxloc )

numaGetMax()

Parameters

[in]	na	source numa
[out]	pmaxval	[optional] max value
[out]	pimaxloc	[optional] index of max location

Returns

0 if OK; 1 on error

Definition at line 485 of file numafunc1.c.

Referenced by numaChooseSortType(), numaDifferentiateInterval(), numaFitMax(), numaGetBinSortIndex(), numaIntegrateInterval(), numaInterpolateArbxInterval(), numaLowPassIntervals(), numaSortGeneral(), and numaThresholdEdges().

numaGetMean()

l_ok numaGetMean	(	NUMA *	na,
		l_float32 *	pave )

numaGetMean()

Parameters

[in]	na	source numa
[out]	pave	average of values

Returns

0 if OK, 1 on error

Definition at line 670 of file numafunc1.c.

References numaGetSum().

Referenced by numaGetMeanAbsval().

numaGetMeanAbsval()

l_ok numaGetMeanAbsval	(	NUMA *	na,
		l_float32 *	paveabs )

numaGetMeanAbsval()

Parameters

[in]	na	source numa
[out]	paveabs	average of absolute values

Returns

0 if OK, 1 on error

Definition at line 697 of file numafunc1.c.

References numaGetMean(), and numaMakeAbsval().

numaGetMeanDevFromMedian()

l_ok numaGetMeanDevFromMedian	(	NUMA *	na,
		l_float32	med,
		l_float32 *	pdev )

numaGetMeanDevFromMedian()

Parameters

[in]	na	source numa
[in]	med	median value
[out]	pdev	average absolute value deviation from median value

Returns

0 if OK; 1 on error

Definition at line 3352 of file numafunc1.c.

numaGetMedian()

l_ok numaGetMedian	(	NUMA *	na,
		l_float32 *	pval )

numaGetMedian()

Parameters

[in]	na	source numa
[out]	pval	median value

Returns

0 if OK; 1 on error

Notes:
     (1) Computes the median value of the numbers in the numa, by
         sorting and finding the middle value in the sorted array.

Definition at line 3296 of file numafunc1.c.

References numaGetRankValue().

Referenced by numaGetMedianDevFromMedian().

numaGetMedianDevFromMedian()

l_ok numaGetMedianDevFromMedian	(	NUMA *	na,
		l_float32 *	pmed,
		l_float32 *	pdev )

numaGetMedianDevFromMedian()

Parameters

[in]	na	source numa
[out]	pmed	[optional] median value
[out]	pdev	median deviation from median val

Returns

0 if OK; 1 on error

Notes:
     (1) Finds the median of the absolute value of the deviation from
         the median value in the array.  Why take the absolute value?
         Consider the case where you have values equally distributed
         about both sides of a median value.  Without taking the absolute
         value of the differences, you will get 0 for the deviation,
         and this is not useful.

Definition at line 3396 of file numafunc1.c.

References numaGetMedian().

numaGetMin()

l_ok numaGetMin	(	NUMA *	na,
		l_float32 *	pminval,
		l_int32 *	piminloc )

numaGetMin()

Parameters

[in]	na	source numa
[out]	pminval	[optional] min value
[out]	piminloc	[optional] index of min location

Returns

0 if OK; 1 on error

Definition at line 444 of file numafunc1.c.

Referenced by numaChooseSortType(), numaDifferentiateInterval(), numaGetBinSortIndex(), numaIntegrateInterval(), and numaInterpolateArbxInterval().

numaGetMode()

l_ok numaGetMode	(	NUMA *	na,
		l_float32 *	pval,
		l_int32 *	pcount )

numaGetMode()

Parameters

[in]	na	source numa
[out]	pval	mode val
[out]	pcount	[optional] mode count

Returns

0 if OK; 1 on error

Notes:
     (1) Computes the mode value of the numbers in the numa, by
         sorting and finding the value of the number with the
         largest count.
     (2) Optionally, also returns that count.

Definition at line 3443 of file numafunc1.c.

References L_NOCOPY, L_SORT_DECREASING, and numaSort().

numaGetNonzeroRange()

l_ok numaGetNonzeroRange	(	NUMA *	na,
		l_float32	eps,
		l_int32 *	pfirst,
		l_int32 *	plast )

numaGetNonzeroRange()

Parameters

[in]	na	source numa
[in]	eps	largest value considered to be zero
[out]	pfirst,plast	interval of array indices where values are nonzero

Returns

0 if OK, 1 on error or if no nonzero range is found.

Definition at line 1037 of file numafunc1.c.

numaGetPartialSums()

NUMA * numaGetPartialSums

(

NUMA *

na

)

numaGetPartialSums()

Parameters

[in]

na

source numa

Returns

nasum, or NULL on error

Notes:
     (1) nasum[i] is the sum for all j <= i of na[j].
         So nasum[0] = na[0].
     (2) If you want to generate a rank function, where rank[0] - 0.0,
         insert a 0.0 at the beginning of the nasum array.

Definition at line 564 of file numafunc1.c.

numaGetRankValue()

l_ok numaGetRankValue	(	NUMA *	na,
		l_float32	fract,
		NUMA *	nasort,
		l_int32	usebins,
		l_float32 *	pval )

numaGetRankValue()

Parameters

[in]	na	source numa
[in]	fract	use 0.0 for smallest, 1.0 for largest
[in]	nasort	[optional] increasing sorted version of na
[in]	usebins	0 for general sort; 1 for bin sort
[out]	pval	rank val

Returns

0 if OK; 1 on error

Notes:
     (1) Computes the rank value of a number in the na, which is
         the number that is a fraction fract from the small
         end of the sorted version of na.
     (2) If you do this multiple times for different rank values,
         sort the array in advance and use that for nasort;
         if you're only calling this once, input nasort == NULL.
     (3) If usebins == 1, this uses a bin sorting method.
         Use this only where:
          * the numbers are non-negative integers
          * there are over 100 numbers
          * the maximum value is less than about 50,000
     (4) The advantage of using a bin sort is that it is O(n),
         instead of O(nlogn) for general sort routines.

Definition at line 3245 of file numafunc1.c.

References L_SORT_INCREASING, numaBinSort(), and numaSort().

Referenced by numaGetBinnedMedian(), and numaGetMedian().

numaGetSortIndex()

NUMA * numaGetSortIndex	(	NUMA *	na,
		l_int32	sortorder )

numaGetSortIndex()

Parameters

[in]	na	source numa
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING

Returns

na giving an array of indices that would sort the input array, or NULL on error

Definition at line 2664 of file numafunc1.c.

References L_COPY, L_SORT_DECREASING, and L_SORT_INCREASING.

Referenced by numaSortGeneral(), numaSortIndexAutoSelect(), and numaSortPair().

numaGetSpanValues()

l_int32 numaGetSpanValues	(	NUMA *	na,
		l_int32	span,
		l_int32 *	pstart,
		l_int32 *	pend )

numaGetSpanValues()

Parameters

[in]	na	numa that is output of numaLowPassIntervals()
[in]	span	span number, zero-based
[out]	pstart	[optional] location of start of transition
[out]	pend	[optional] location of end of transition

Returns

0 if OK, 1 on error

Definition at line 1551 of file numafunc1.c.

numaGetSum()

l_ok numaGetSum	(	NUMA *	na,
		l_float32 *	psum )

numaGetSum()

Parameters

[in]	na	source numa
[out]	psum	sum of values

Returns

0 if OK, 1 on error

Definition at line 525 of file numafunc1.c.

Referenced by numaGetMean().

numaGetSumOnInterval()

l_ok numaGetSumOnInterval	(	NUMA *	na,
		l_int32	first,
		l_int32	last,
		l_float32 *	psum )

numaGetSumOnInterval()

Parameters

[in]	na	source numa
[in]	first	beginning index
[in]	last	final index; use -1 to go to the end
[out]	psum	sum of values in the index interval range

Returns

0 if OK, 1 on error

Definition at line 596 of file numafunc1.c.

numaHasOnlyIntegers()

l_ok numaHasOnlyIntegers	(	NUMA *	na,
		l_int32 *	pallints )

numaHasOnlyIntegers()

Parameters

[in]	na	source numa
[out]	pallints	1 if all sampled values are ints; else 0

Returns

0 if OK, 1 on error

Definition at line 637 of file numafunc1.c.

numaIntegrateInterval()

l_ok numaIntegrateInterval	(	NUMA *	nax,
		NUMA *	nay,
		l_float32	x0,
		l_float32	x1,
		l_int32	npts,
		l_float32 *	psum )

numaIntegrateInterval()

Parameters

[in]	nax	numa of abscissa values
[in]	nay	numa of ordinate values, corresponding to nax
[in]	x0	start value of interval
[in]	x1	end value of interval
[in]	npts	number of points to evaluate function in interval
[out]	psum	integral of function over interval

Returns

0 if OK, 1 on error e.g., if x0 or x1 is outside range

Notes:
     (1) The values in nax must be sorted in increasing order.
         If they are not sorted, it is done in the interpolation
         step, and a warning is issued.
     (2) Caller should check for valid return.

Definition at line 2278 of file numafunc1.c.

References L_LINEAR_INTERP, L_NOCOPY, numaGetMax(), numaGetMin(), and numaInterpolateArbxInterval().

numaInterpolateArbxInterval()

l_ok numaInterpolateArbxInterval	(	NUMA *	nax,
		NUMA *	nay,
		l_int32	type,
		l_float32	x0,
		l_float32	x1,
		l_int32	npts,
		NUMA **	pnadx,
		NUMA **	pnady )

numaInterpolateArbxInterval()

Parameters

[in]	nax	numa of abscissa values
[in]	nay	numa of ordinate values, corresponding to nax
[in]	type	L_LINEAR_INTERP, L_QUADRATIC_INTERP
[in]	x0	start value of interval
[in]	x1	end value of interval
[in]	npts	number of points to evaluate function in interval
[out]	pnadx	[optional] array of x values in interval
[out]	pnady	array of y values in interval

Returns

0 if OK, 1 on error e.g., if x0 or x1 is outside range

Notes:
     (1) The values in nax must be sorted in increasing order.
         If they are not sorted, we do it here, and complain.
     (2) If the values in nax are equally spaced, you can use
         numaInterpolateEqxInterval().
     (3) Caller should check for valid return.
     (4) We don't call numaInterpolateArbxVal() for each output
         point, because that requires an O(n) search for
         each point.  Instead, we do a single O(n) pass through
         nax, saving the indices to be used for each output yval.
     (5) Uses lagrangian interpolation.  See numaInterpolateEqxVal()
         for formulas.

Definition at line 1934 of file numafunc1.c.

References L_LINEAR_INTERP, L_NOCOPY, L_QUADRATIC_INTERP, L_SORT_INCREASING, numaGetMax(), numaGetMin(), numaIsSorted(), and numaSortPair().

Referenced by numaDifferentiateInterval(), and numaIntegrateInterval().

numaInterpolateArbxVal()

l_ok numaInterpolateArbxVal	(	NUMA *	nax,
		NUMA *	nay,
		l_int32	type,
		l_float32	xval,
		l_float32 *	pyval )

numaInterpolateArbxVal()

Parameters

[in]	nax	numa of abscissa values
[in]	nay	numa of ordinate values, corresponding to nax
[in]	type	L_LINEAR_INTERP, L_QUADRATIC_INTERP
[in]	xval
[out]	pyval	interpolated value

Returns

0 if OK, 1 on error e.g., if xval is outside range

Notes:
     (1) The values in nax must be sorted in increasing order.
         If, additionally, they are equally spaced, you can use
         numaInterpolateEqxVal().
     (2) Caller should check for valid return.
     (3) Uses lagrangian interpolation.  See numaInterpolateEqxVal()
         for formulas.

Definition at line 1732 of file numafunc1.c.

References L_LINEAR_INTERP, L_NOCOPY, and L_QUADRATIC_INTERP.

numaInterpolateEqxInterval()

l_ok numaInterpolateEqxInterval	(	l_float32	startx,
		l_float32	deltax,
		NUMA *	nasy,
		l_int32	type,
		l_float32	x0,
		l_float32	x1,
		l_int32	npts,
		NUMA **	pnax,
		NUMA **	pnay )

numaInterpolateEqxInterval()

Parameters

[in]	startx	xval corresponding to first element in nas
[in]	deltax	x increment between array elements in nas
[in]	nasy	numa of ordinate values, assumed equally spaced
[in]	type	L_LINEAR_INTERP, L_QUADRATIC_INTERP
[in]	x0	start value of interval
[in]	x1	end value of interval
[in]	npts	number of points to evaluate function in interval
[out]	pnax	[optional] array of x values in interval
[out]	pnay	array of y values in interval

Returns

0 if OK, 1 on error

Notes:
     (1) Considering nasy as a function of x, the x values
         are equally spaced.
     (2) This creates nay (and optionally nax) of interpolated
         values over the specified interval (x0, x1).
     (3) If the interval (x0, x1) lies partially outside the array
         nasy (as interpreted by startx and deltax), it is an
         error and returns 1.
     (4) Note that deltax is the intrinsic x-increment for the input
         array nasy, whereas delx is the intrinsic x-increment for the
         output interpolated array nay.

Definition at line 1847 of file numafunc1.c.

References L_LINEAR_INTERP, L_QUADRATIC_INTERP, and numaInterpolateEqxVal().

numaInterpolateEqxVal()

l_ok numaInterpolateEqxVal	(	l_float32	startx,
		l_float32	deltax,
		NUMA *	nay,
		l_int32	type,
		l_float32	xval,
		l_float32 *	pyval )

numaInterpolateEqxVal()

Parameters

[in]	startx	xval corresponding to first element in array
[in]	deltax	x increment between array elements
[in]	nay	numa of ordinate values, assumed equally spaced
[in]	type	L_LINEAR_INTERP, L_QUADRATIC_INTERP
[in]	xval
[out]	pyval	interpolated value

Returns

0 if OK, 1 on error e.g., if xval is outside range

Notes:
     (1) Considering nay as a function of x, the x values
         are equally spaced
     (2) Caller should check for valid return.

 For linear Lagrangian interpolation (through 2 data pts):
        y(x) = y1(x-x2)/(x1-x2) + y2(x-x1)/(x2-x1)

 For quadratic Lagrangian interpolation (through 3 data pts):
        y(x) = y1(x-x2)(x-x3)/((x1-x2)(x1-x3)) +
               y2(x-x1)(x-x3)/((x2-x1)(x2-x3)) +
               y3(x-x1)(x-x2)/((x3-x1)(x3-x2))

Definition at line 1642 of file numafunc1.c.

References L_LINEAR_INTERP, L_NOCOPY, and L_QUADRATIC_INTERP.

Referenced by numaInterpolateEqxInterval().

numaInvert()

NUMA * numaInvert	(	NUMA *	nad,
		NUMA *	nas )

numaInvert()

Parameters

[in]	nad	[optional] can be null or equal to nas (in-place
[in]	nas

Returns

nad always: 'inverts' nas

Notes:
     (1) This is intended for use with indicator arrays (0s and 1s).
         It gives a boolean-type output, taking the input as
         an integer and inverting it:
             0              -->  1
             anything else  -->   0

Definition at line 323 of file numafunc1.c.

numaInvertMap()

NUMA * numaInvertMap

(

NUMA *

nas

)

numaInvertMap()

Parameters

[in]

nas

Returns

nad the inverted map, or NULL on error or if not invertible

Notes:
     (1) This requires that nas contain each integer from 0 to n-1.
         The array is typically an index array into a sort or permutation
         of another array.

Definition at line 2971 of file numafunc1.c.

References numaMakeConstant().

Referenced by numaSortGeneral().

numaIsSorted()

l_int32 numaIsSorted	(	NUMA *	nas,
		l_int32	sortorder,
		l_int32 *	psorted )

numaIsSorted()

Parameters

[in]	nas
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING
[out]	psorted	1 if sorted; 0 if not

Returns

1 if OK; 0 on error

Notes:
     (1) This is a quick O(n) test if nas is sorted.  It is useful
         in situations where the array is likely to be already
         sorted, and a sort operation can be avoided.

Definition at line 2872 of file numafunc1.c.

References L_SORT_DECREASING, and L_SORT_INCREASING.

Referenced by numaInterpolateArbxInterval(), and numaSortPair().

numaJoin()

l_ok numaJoin	(	NUMA *	nad,
		NUMA *	nas,
		l_int32	istart,
		l_int32	iend )

numaJoin()

Parameters

[in]	nad	dest numa; add to this one
[in]	nas	[optional] source numa; add from this one
[in]	istart	starting index in nas
[in]	iend	ending index in nas; use -1 to cat all

Returns

0 if OK, 1 on error

Notes:
     (1) istart < 0 is taken to mean 'read from the start' (istart = 0)
     (2) iend < 0 means 'read to the end'
     (3) if nas == NULL, this is a no-op

Definition at line 3521 of file numafunc1.c.

Referenced by numaaFlattenToNuma(), and numaGetBinSortIndex().

numaLogicalOp()

NUMA * numaLogicalOp	(	NUMA *	nad,
		NUMA *	na1,
		NUMA *	na2,
		l_int32	op )

numaLogicalOp()

Parameters

[in]	nad	[optional] can be null or equal to na1 (in-place
[in]	na1
[in]	na2
[in]	op	L_UNION, L_INTERSECTION, L_SUBTRACTION, L_EXCLUSIVE_OR

Returns

nad always: operation applied to na1 and na2

Notes:
     (1) The sizes of na1 and na2 must be equal.
     (2) nad can only be null or equal to na1.
     (3) This is intended for use with indicator arrays (0s and 1s).
         Input data is extracted as integers (0 == false, anything
         else == true); output results are 0 and 1.
     (4) L_SUBTRACTION is subtraction of val2 from val1.  For bit logical
         arithmetic this is (val1 & ~val2), but because these values
         are integers, we use (val1 && !val2).

Definition at line 252 of file numafunc1.c.

numaLowPassIntervals()

NUMA * numaLowPassIntervals	(	NUMA *	nas,
		l_float32	thresh,
		l_float32	maxn )

numaLowPassIntervals()

Parameters

[in]	nas	input numa
[in]	thresh	threshold fraction of max; in [0.0 ... 1.0]
[in]	maxn	for normalizing; set maxn = 0.0 to use the max in nas

Returns

nad : interval abscissa pairs, or NULL on error

Notes:
     (1) For each interval where the value is less than a specified
         fraction of the maximum, this records the left and right "x"
         value.

Definition at line 1357 of file numafunc1.c.

References numaGetMax().

numaMakeAbsval()

NUMA * numaMakeAbsval	(	NUMA *	nad,
		NUMA *	nas )

numaMakeAbsval()

Parameters

[in]	nad	can be null for new array, or the same as nas for inplace
[in]	nas	input numa

Returns

nad with all numbers being the absval of the input, or NULL on error

Definition at line 836 of file numafunc1.c.

References Numa::array.

Referenced by numaGetMeanAbsval().

numaMakeConstant()

NUMA * numaMakeConstant	(	l_float32	val,
		l_int32	size )

numaMakeConstant()

Parameters

[in]	val
[in]	size	of numa

Returns

numa of given size with all entries equal to 'val', or NULL on error

Definition at line 820 of file numafunc1.c.

References numaMakeSequence().

Referenced by numaAddBorder(), numaInvertMap(), and numaRemoveBorder().

numaMakeDelta()

NUMA * numaMakeDelta

(

NUMA *

nas

)

numaMakeDelta()

Parameters

[in]

nas

input numa

Returns

numa of difference values val[i+1] - val[i], or NULL on error

Definition at line 759 of file numafunc1.c.

numaMakeSequence()

NUMA * numaMakeSequence	(	l_float32	startval,
		l_float32	increment,
		l_int32	size )

numaMakeSequence()

Parameters

[in]	startval
[in]	increment
[in]	size	of sequence

Returns

numa of sequence of evenly spaced values, or NULL on error

Definition at line 792 of file numafunc1.c.

Referenced by numaMakeConstant().

numaMakeThresholdIndicator()

NUMA * numaMakeThresholdIndicator	(	NUMA *	nas,
		l_float32	thresh,
		l_int32	type )

numaMakeThresholdIndicator()

Parameters

[in]	nas	input numa
[in]	thresh	threshold value
[in]	type	L_SELECT_IF_LT, L_SELECT_IF_GT, L_SELECT_IF_LTE, L_SELECT_IF_GTE

Returns

nad : indicator array: values are 0 and 1

Notes:
     (1) For each element in nas, if the constraint given by 'type'
         correctly specifies its relation to thresh, a value of 1
         is recorded in nad.

Definition at line 1184 of file numafunc1.c.

References L_SELECT_IF_GT, L_SELECT_IF_GTE, L_SELECT_IF_LT, and L_SELECT_IF_LTE.

numaPseudorandomSequence()

NUMA * numaPseudorandomSequence	(	l_int32	size,
		l_int32	seed )

numaPseudorandomSequence()

Parameters

[in]	size	of sequence
[in]	seed	for random number generation

Returns

na pseudorandom on [0,...,size - 1], or NULL on error

Notes:
     (1) This uses the Durstenfeld shuffle.
         See: http://en.wikipedia.org/wiki/Fisher–Yates_shuffle.
         Result is a pseudorandom permutation of the sequence of integers
         from 0 to size - 1.

Definition at line 3151 of file numafunc1.c.

Referenced by numaRandomPermutation().

numaRandomPermutation()

NUMA * numaRandomPermutation	(	NUMA *	nas,
		l_int32	seed )

numaRandomPermutation()

Parameters

[in]	nas	input array
[in]	seed	for random number generation

Returns

nas randomly shuffled array, or NULL on error

Definition at line 3188 of file numafunc1.c.

References numaPseudorandomSequence().

numaRemoveBorder()

NUMA * numaRemoveBorder	(	NUMA *	nas,
		l_int32	left,
		l_int32	right )

numaRemoveBorder()

Parameters

[in]	nas
[in]	left	number of elements to remove from the start
[in]	right	number of elements to remove up to the end

Returns

nad with removed elements at left and right, or NULL on error

Definition at line 959 of file numafunc1.c.

References L_NOCOPY, and numaMakeConstant().

numaReverse()

NUMA * numaReverse	(	NUMA *	nad,
		NUMA *	nas )

numaReverse()

Parameters

[in]	nad	[optional] can be null or equal to nas
[in]	nas	input numa

Returns

nad : reversed, or NULL on error

Notes:
     (1) Usage:
           numaReverse(nas, nas);   // in-place
           nad = numaReverse(NULL, nas);  // makes a new one

Definition at line 1304 of file numafunc1.c.

References Numa::delx, and Numa::startx.

numaSimilar()

l_int32 numaSimilar	(	NUMA *	na1,
		NUMA *	na2,
		l_float32	maxdiff,
		l_int32 *	psimilar )

numaSimilar()

Parameters

[in]	na1
[in]	na2
[in]	maxdiff	use 0.0 for exact equality
[out]	psimilar	1 if similar; 0 if different

Returns

0 if OK, 1 on error

Notes:
     (1) Float values can differ slightly due to roundoff and
         accumulated errors.  Using maxdiff > 0.0 allows similar
         arrays to be identified.

Definition at line 365 of file numafunc1.c.

numaSort()

NUMA * numaSort	(	NUMA *	naout,
		NUMA *	nain,
		l_int32	sortorder )

numaSort()

Parameters

[in]	naout	output numa; can be NULL or equal to nain
[in]	nain	input numa
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING

Returns

naout output sorted numa, or NULL on error

Notes:
     (1) Set naout = nain for in-place; otherwise, set naout = NULL.
     (2) Source: Shell sort, modified from K&R, 2nd edition, p.62.
         Slow but simple O(n logn) sort.

Definition at line 2567 of file numafunc1.c.

References Numa::array, L_SORT_DECREASING, and L_SORT_INCREASING.

Referenced by numaGetMode(), numaGetRankValue(), and numaSortAutoSelect().

numaSortAutoSelect()

NUMA * numaSortAutoSelect	(	NUMA *	nas,
		l_int32	sortorder )

numaSortAutoSelect()

Parameters

[in]	nas
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING

Returns

naout output sorted numa, or NULL on error

Notes:
     (1) This does either a shell sort or a bin sort, depending on
         the number of elements in nas and the dynamic range.

Definition at line 2444 of file numafunc1.c.

References L_BIN_SORT, L_SHELL_SORT, L_SORT_DECREASING, L_SORT_INCREASING, numaBinSort(), numaChooseSortType(), and numaSort().

numaSortByIndex()

NUMA * numaSortByIndex	(	NUMA *	nas,
		NUMA *	naindex )

numaSortByIndex()

Parameters

[in]	nas
[in]	naindex	na that maps from the new numa to the input numa

Returns

nad sorted, or NULL on error

Definition at line 2825 of file numafunc1.c.

Referenced by numaBinSort(), numaSortGeneral(), and numaSortPair().

numaSortGeneral()

l_ok numaSortGeneral	(	NUMA *	na,
		NUMA **	pnasort,
		NUMA **	pnaindex,
		NUMA **	pnainvert,
		l_int32	sortorder,
		l_int32	sorttype )

numaSortGeneral()

Parameters

[in]	na	source numa
[out]	pnasort	[optional] sorted numa
[out]	pnaindex	[optional] index of elements in na associated with each element of nasort
[out]	pnainvert	[optional] index of elements in nasort associated with each element of na
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING
[in]	sorttype	L_SHELL_SORT or L_BIN_SORT

Returns

0 if OK, 1 on error

Notes:
     (1) Sorting can be confusing.  Here's an array of five values with
         the results shown for the 3 output arrays.

         na      nasort   naindex   nainvert
         -----------------------------------
         3         9         2         3
         4         6         3         2
         9         4         1         0
         6         3         0         1
         1         1         4         4

         Note that naindex is a LUT into na for the sorted array values,
         and nainvert directly gives the sorted index values for the
         input array.  It is useful to view naindex is as a map:
                0  -->  2
                1  -->  3
                2  -->  1
                3  -->  0
                4  -->  4
         and nainvert, the inverse of this map:
                0  -->  3
                1  -->  2
                2  -->  0
                3  -->  1
                4  -->  4

         We can write these relations symbolically as:
             nasort[i] = na[naindex[i]]
             na[i] = nasort[nainvert[i]]

Definition at line 2381 of file numafunc1.c.

References L_BIN_SORT, L_SHELL_SORT, L_SORT_DECREASING, L_SORT_INCREASING, numaGetBinSortIndex(), numaGetMax(), numaGetSortIndex(), numaInvertMap(), and numaSortByIndex().

numaSortIndexAutoSelect()

NUMA * numaSortIndexAutoSelect	(	NUMA *	nas,
		l_int32	sortorder )

numaSortIndexAutoSelect()

Parameters

[in]	nas
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING

Returns

nad indices of nas, sorted by value in nas, or NULL on error

Notes:
     (1) This does either a shell sort or a bin sort, depending on
         the number of elements in nas and the dynamic range.

Definition at line 2483 of file numafunc1.c.

References L_BIN_SORT, L_SHELL_SORT, L_SORT_DECREASING, L_SORT_INCREASING, numaChooseSortType(), numaGetBinSortIndex(), and numaGetSortIndex().

numaSortPair()

l_ok numaSortPair	(	NUMA *	nax,
		NUMA *	nay,
		l_int32	sortorder,
		NUMA **	pnasx,
		NUMA **	pnasy )

numaSortPair()

Parameters

[in]	nax,nay	input arrays
[in]	sortorder	L_SORT_INCREASING or L_SORT_DECREASING
[out]	pnasx	sorted
[out]	pnasy	sorted exactly in order of nasx

Returns

0 if OK, 1 on error

Notes:
     (1) This function sorts the two input arrays, nax and nay,
         together, using nax as the key for sorting.

Definition at line 2922 of file numafunc1.c.

References L_SORT_DECREASING, L_SORT_INCREASING, numaGetSortIndex(), numaIsSorted(), and numaSortByIndex().

Referenced by numaInterpolateArbxInterval().

numaSubsample()

NUMA * numaSubsample	(	NUMA *	nas,
		l_int32	subfactor )

numaSubsample()

Parameters

[in]	nas
[in]	subfactor	subsample factor, >= 1

Returns

nad evenly sampled values from nas, or NULL on error

Definition at line 726 of file numafunc1.c.

numaThresholdEdges()

NUMA * numaThresholdEdges	(	NUMA *	nas,
		l_float32	thresh1,
		l_float32	thresh2,
		l_float32	maxn )

numaThresholdEdges()

Parameters

[in]	nas	input numa
[in]	thresh1	low threshold as fraction of max; in [0.0 ... 1.0]
[in]	thresh2	high threshold as fraction of max; in [0.0 ... 1.0]
[in]	maxn	for normalizing; set maxn = 0.0 to use the max in nas

Returns

nad edge interval triplets, or NULL on error

Notes:
     (1) For each edge interval, where the value is less
         than thresh1 on one side, greater than thresh2 on
         the other, and between these thresholds throughout the
         interval, this records a triplet of values: the
         'left' and 'right' edges, and either +1 or -1, depending
         on whether the edge is rising or falling.
     (2) No assumption is made about the value outside the array,
         so if the value at the array edge is between the threshold
         values, it is not considered part of an edge.  We start
         looking for edge intervals only after leaving the thresholded
         band.

Definition at line 1432 of file numafunc1.c.

References numaGetMax().

numaUniformSampling()

NUMA * numaUniformSampling	(	NUMA *	nas,
		l_int32	nsamp )

numaUniformSampling()

Parameters

[in]	nas	input numa
[in]	nsamp	number of samples

Returns

nad : resampled array, or NULL on error

Notes:
     (1) This resamples the values in the array, using nsamp
         equal divisions.

Definition at line 1240 of file numafunc1.c.

References L_NOCOPY.