- Создано системой
1.8.15
|
Leptonica
1.54
|
Переменные | |
| static const l_int32 | INITIAL_PTR_ARRAYSIZE = 50 |
Input: daa
da (to be added)
copyflag (L_INSERT, L_COPY, L_CLONE)
Return: 0 if OK, 1 on error
Input: daa
index (of l_dna within l_dnaa)
val (number to be added; stored as a double)
Return: 0 if OK, 1 on error
Notes: (1) Adds to an existing l_dna only.
Input: size of l_dna ptr array to be alloc'd (0 for default) Return: daa, or null on error
Input: nptr: size of dna ptr array to be alloc'd
n: size of individual dna arrays to be alloc'd (0 for default)
Return: daa, or null on error
Notes: (1) This allocates a dnaa and fills the array with allocated dnas. In use, after calling this function, use l_dnaaAddNumber(dnaa, index, val); to add val to the index-th dna in dnaa.
Input: da
val (float or int to be added; stored as a float)
Return: 0 if OK, 1 on error
| void l_dnaaDestroy | ( | L_DNAA ** | pdaa | ) |
Input: &dnaa <to be nulled if it exists> Return: void
Input: daa Return: 0 if OK, 1 on error
Input: daa Return: count (number of l_dna), or 0 if no l_dna or on error
Input: daa
index (to the index-th l_dna)
accessflag (L_COPY or L_CLONE)
Return: l_dna, or null on error
Input: daa
index (of l_dna in daa)
Return: count of numbers in the referenced l_dna, or 0 on error.
Input: daa
Return: count (total number of numbers in the l_dnaa),
or 0 if no numbers or on error
Input: daa
i (index of l_dna within l_dnaa)
j (index into l_dna)
val (<return> double value)
Return: 0 if OK, 1 on error
| L_DNAA* l_dnaaRead | ( | const char * | filename | ) |
Input: filename Return: daa, or null on error
| L_DNAA* l_dnaaReadStream | ( | FILE * | fp | ) |
Input: stream Return: daa, or null on error
Input: daa
index (to the index-th l_dna)
l_dna (insert and replace any existing one)
Return: 0 if OK, 1 on error
Notes: (1) Any existing l_dna is destroyed, and the input one is inserted in its place. (2) If the index is invalid, return 1 (error)
Input: daa Return: 0 if OK, 1 on error
Notes: (1) This identifies the largest index containing a dna that has any numbers within it, destroys all dna beyond that index, and resets the count.
Input: filename, daa Return: 0 if OK, 1 on error
Input: stream, daa Return: 0 if OK, 1 on error
l_dnaChangeRefCount()
Input: da
delta (change to be applied)
Return: 0 if OK, 1 on error
Input: da Return: ptr to same l_dna, or null on error
Input: da Return: na, or null on error
Input: da Return: copy of l_dna, or null on error
Notes: (1) This removes unused ptrs above da->n.
Input: dad (destination DNuma)
das (source DNuma)
Return: 0 if OK, 1 on error
Input: size of number array to be alloc'd (0 for default) Return: da, or null on error
Input: da (float)
size (of the array)
copyflag (L_INSERT or L_COPY)
Return: da, or null on error
Notes: (1) With L_INSERT, ownership of the input array is transferred to the returned l_dna, and all @size elements are considered to be valid.
Input: iarray (integer)
size (of the array)
Return: da, or null on error
Notes: (1) We can't insert this int array into the l_dna, because a l_dna takes a double array. So this just copies the data from the input array into the l_dna. The input array continues to be owned by the caller.
| void l_dnaDestroy | ( | L_DNA ** | pda | ) |
Input: &da (<to be nulled if it exists>) Return: void
Notes: (1) Decrements the ref count and, if 0, destroys the l_dna. (2) Always nulls the input ptr.
Input: da Return: 0 if OK; 1 on error
Notes: (1) This does not change the allocation of the array. It just clears the number of stored numbers, so that the array appears to be empty.
Input: da Return: 0 if OK, 1 on error
Input: da
dahash (containing indices into @da)
val (searching for this number in @da)
&index (<return> index into da if found; -1 otherwise)
Return: 0 if OK; 1 on error
Notes: (1) Algo: hash @val into a key; hash the key to get the dna in @dahash (that holds indices into @da); traverse the dna of indices looking for @val in @da.
Input: da Return: count, or 0 if no numbers or on error
Input: da
copyflag (L_NOCOPY or L_COPY)
Return: either the bare internal array or a copy of it,
or null on error
Notes: (1) If copyflag == L_COPY, it makes a copy which the caller is responsible for freeing. Otherwise, it operates directly on the bare array of the l_dna. (2) Very important: for L_NOCOPY, any writes to the array will be in the l_dna. Do not write beyond the size of the count field, because it will not be accessible from the l_dna! If necessary, be sure to set the count field to a larger number (such as the alloc size) BEFORE calling this function. Creating with l_dnaMakeConstant() is another way to insure full initialization.
Input: da
index (into l_dna)
&val (<return> double value; 0.0 on error)
Return: 0 if OK; 1 on error
Notes: (1) Caller may need to check the function return value to decide if a 0.0 in the returned ival is valid.
Input: da
Return: a copy of the bare internal array, integerized
by rounding, or null on error
Notes: (1) A copy of the array is made, because we need to generate an integer array from the bare double array. The caller is responsible for freeing the array. (2) The array size is determined by the number of stored numbers, not by the size of the allocated array in the l_dna. (3) This function is provided to simplify calculations using the bare internal array, rather than continually calling accessors on the l_dna. It is typically used on an array of size 256.
Input: da
index (into l_dna)
&ival (<return> integer value; 0 on error)
Return: 0 if OK; 1 on error
Notes: (1) Caller may need to check the function return value to decide if a 0 in the returned ival is valid.
Input: da
&startx (<optional return> startx)
&delx (<optional return> delx)
Return: 0 if OK, 1 on error
l_dnaGetRefCount()
Input: da Return: refcount, or UNDEF on error
Input: dahash
key (key to be hashed into a bucket number)
value (float value to be appended to the specific dna)
Return: 0 if OK; 1 on error
Input: nbuckets (the number of buckets in the hash table,
which should be prime.)
initsize (initial size of each allocated numa; 0 for default)
Return: ptr to new dnahash, or null on error
Note: actual dna are created only as required by l_dnaHashAdd()
Input: da Return: dahash if OK; 1 on error
Notes: (1) The values stored in the @dahash are indices into @da; @dahash has no use without @da.
| void l_dnaHashDestroy | ( | L_DNAHASH ** | pdahash | ) |
Input: &dahash (<to be nulled, if it exists>) Return: void
Input: dahash Return: nbuckets (allocated, or 0 on error)
Input: dahash
key (key to be hashed into a bucket number)
copyflag (L_NOCOPY, L_COPY, L_CLONE)
Return: ptr to numa
Input: dahash Return: n (number of numbers in all dna, or 0 on error)
Input: da
index (location in da to insert new value)
val (float64 or integer to be added)
Return: 0 if OK, 1 on error
Notes: (1) This shifts da[i] --> da[i + 1] for all i >= index, and then inserts val as da[index]. (2) It should not be used repeatedly on large arrays, because the function is O(n).
Input: da1, da2 Return: dad (intersection of the number arrays), or null on error
Notes: (1) This uses the same method for building the intersection set as ptaIntersectionByHash() and sarrayIntersectionByHash().
Input: dad (dest dna; add to this one)
das (<optional> source dna; add from this one)
istart (starting index in das)
iend (ending index in das; use -1 to cat all)
Return: 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 das == NULL, this is a no-op
Input: das (input l_dna)
Return: dad (of difference values val[i+1] - val[i]),
or null on error
Input: das
&dahash (<return> hash map: val --> index)
&dav (<return> array of values: index --> val)
&dac (<return> histo array of counts: index --> count)
Return: 0 if OK; 1 on error
Notes: (1) Generates and returns a dna of occurrences (histogram), an aligned dna of values, and an associated hashmap. The hashmap takes @dav and a value, and points into the histogram in @dac. (2) The dna of values, @dav, is aligned with the histogram @dac, and is needed for fast lookup. It is a hash set, because the values are unique. (3) Lookup is simple: l_dnaFindValByHash(dav, dahash, val, &index); if (index >= 0) l_dnaGetIValue(dac, index, &icount); else icount = 0;
Input: startval
increment
size (of sequence)
Return: l_dna of sequence of evenly spaced values, or null on error
| L_DNA* l_dnaRead | ( | const char * | filename | ) |
Input: filename Return: da, or null on error
| L_DNA* l_dnaReadStream | ( | FILE * | fp | ) |
Input: stream Return: da, or null on error
Notes: (1) fscanf takes lf to read a double; fprintf takes f to write it.
Input: das
&dad (<return> hash set)
&dahash (<optional return> dnahash used for lookup)
Return: 0 if OK; 1 on error
Notes: (1) Generates a dna with unique values. (2) The dnahash is built up with dad to assure uniqueness. It can be used to find if an element is in the set: l_dnaFindValByHash(dad, dahash, val, &index)
Input: da
index (element to be removed)
Return: 0 if OK, 1 on error
Notes: (1) This shifts da[i] --> da[i - 1] for all i > index. (2) It should not be used repeatedly on large arrays, because the function is O(n).
Input: da
index (element to be replaced)
val (new value to replace old one)
Return: 0 if OK, 1 on error
Input: da
newcount
Return: 0 if OK, 1 on error
Notes: (1) If newcount <= da->nalloc, this resets da->n. Using newcount = 0 is equivalent to l_dnaEmpty(). (2) If newcount > da->nalloc, this causes a realloc to a size da->nalloc = newcount. (3) All the previously unused values in da are set to 0.0.
Input: da
startx (x value corresponding to da[0])
delx (difference in x values for the situation where the
elements of da correspond to the evaulation of a
function at equal intervals of size @delx)
Return: 0 if OK, 1 on error
Input: da
index (to element to be set)
val (to set element)
Return: 0 if OK; 1 on error
Input: da
index (to element to change relative to the current value)
diff (increment if diff > 0 or decrement if diff < 0)
Return: 0 if OK; 1 on error
Input: filename, da Return: 0 if OK, 1 on error
Input: stream, da Return: 0 if OK, 1 on error
|
static |
1.8.15