145 #include <config_auto.h>
149 #include "allheaders.h"
180 l_float32 val1, val2;
183 return (
NUMA *)ERROR_PTR(
"na1, na2 not both defined", __func__, nad);
186 return (
NUMA *)ERROR_PTR(
"na1, na2 sizes differ", __func__, nad);
187 if (nad && nad != na1)
188 return (
NUMA *)ERROR_PTR(
"nad defined but not in-place", __func__, nad);
189 if (op != L_ARITH_ADD && op != L_ARITH_SUBTRACT &&
190 op != L_ARITH_MULTIPLY && op != L_ARITH_DIVIDE)
191 return (
NUMA *)ERROR_PTR(
"invalid op", __func__, nad);
192 if (op == L_ARITH_DIVIDE) {
193 for (i = 0; i < n; i++) {
196 return (
NUMA *)ERROR_PTR(
"na2 has 0 element", __func__, nad);
204 for (i = 0; i < n; i++) {
211 case L_ARITH_SUBTRACT:
214 case L_ARITH_MULTIPLY:
257 l_int32 i, n, val1, val2, val;
260 return (
NUMA *)ERROR_PTR(
"na1, na2 not both defined", __func__, nad);
263 return (
NUMA *)ERROR_PTR(
"na1, na2 sizes differ", __func__, nad);
264 if (nad && nad != na1)
265 return (
NUMA *)ERROR_PTR(
"nad defined; not in-place", __func__, nad);
266 if (op != L_UNION && op != L_INTERSECTION &&
267 op != L_SUBTRACTION && op != L_EXCLUSIVE_OR)
268 return (
NUMA *)ERROR_PTR(
"invalid op", __func__, nad);
274 for (i = 0; i < n; i++) {
277 val1 = (val1 == 0) ? 0 : 1;
278 val2 = (val2 == 0) ? 0 : 1;
281 val = (val1 || val2) ? 1 : 0;
285 val = (val1 && val2) ? 1 : 0;
289 val = (val1 && !val2) ? 1 : 0;
293 val = (val1 != val2) ? 1 : 0;
329 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, nad);
330 if (nad && nad != nas)
331 return (
NUMA *)ERROR_PTR(
"nad defined; not in-place", __func__, nad);
336 for (i = 0; i < n; i++) {
371 l_float32 val1, val2;
374 return ERROR_INT(
"&similar not defined", __func__, 1);
377 return ERROR_INT(
"na1 and na2 not both defined", __func__, 1);
378 maxdiff = L_ABS(maxdiff);
383 for (i = 0; i < n; i++) {
386 if (L_ABS(val1 - val2) > maxdiff)
return 0;
419 return ERROR_INT(
"na not defined", __func__, 1);
421 return ERROR_INT(
"na is empty", __func__, 1);
422 if (index < 0 || index >= n) {
423 L_ERROR(
"index %d not in [0,...,%d]\n", __func__, index, n - 1);
427 na->
array[index] += val;
448 l_int32 i, n, iminloc;
449 l_float32 val, minval;
451 if (!pminval && !piminloc)
452 return ERROR_INT(
"nothing to do", __func__, 1);
453 if (pminval) *pminval = 0.0;
454 if (piminloc) *piminloc = 0;
456 return ERROR_INT(
"na not defined", __func__, 1);
458 return ERROR_INT(
"na is empty", __func__, 1);
460 minval = +1000000000.;
462 for (i = 0; i < n; i++) {
470 if (pminval) *pminval = minval;
471 if (piminloc) *piminloc = iminloc;
489 l_int32 i, n, imaxloc;
490 l_float32 val, maxval;
492 if (!pmaxval && !pimaxloc)
493 return ERROR_INT(
"nothing to do", __func__, 1);
494 if (pmaxval) *pmaxval = 0.0;
495 if (pimaxloc) *pimaxloc = 0;
497 return ERROR_INT(
"na not defined", __func__, 1);
499 return ERROR_INT(
"na is empty", __func__, 1);
501 maxval = -1000000000.;
503 for (i = 0; i < n; i++) {
511 if (pmaxval) *pmaxval = maxval;
512 if (pimaxloc) *pimaxloc = imaxloc;
532 return ERROR_INT(
"&sum not defined", __func__, 1);
535 return ERROR_INT(
"na not defined", __func__, 1);
538 return ERROR_INT(
"na is empty", __func__, 1);
540 for (i = 0; i < n; i++) {
571 return (
NUMA *)ERROR_PTR(
"na not defined", __func__, NULL);
574 L_WARNING(
"na is empty\n", __func__);
577 for (i = 0; i < n; i++) {
605 return ERROR_INT(
"&sum not defined", __func__, 1);
608 return ERROR_INT(
"na not defined", __func__, 1);
612 return ERROR_INT(
"na is empty", __func__, 1);
613 if (first < 0) first = 0;
614 if (first >= n || last < -1)
618 last = L_MIN(last, n - 1);
620 for (i = first; i <= last; i++) {
644 return ERROR_INT(
"&allints not defined", __func__, 1);
647 return ERROR_INT(
"na not defined", __func__, 1);
650 return ERROR_INT(
"na is empty", __func__, 1);
651 for (i = 0; i < n; i ++) {
653 if (val != (l_int32)val) {
677 return ERROR_INT(
"&ave not defined", __func__, 1);
680 return ERROR_INT(
"na not defined", __func__, 1);
682 return ERROR_INT(
"na is empty", __func__, 1);
704 return ERROR_INT(
"&aveabs not defined", __func__, 1);
707 return ERROR_INT(
"na not defined", __func__, 1);
709 return ERROR_INT(
"na is empty", __func__, 1);
734 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
736 return (
NUMA *)ERROR_PTR(
"subfactor < 1", __func__, NULL);
740 L_WARNING(
"nas is empty\n", __func__);
741 for (i = 0; i < n; i++) {
742 if (i % subfactor != 0)
continue;
766 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
768 L_WARNING(
"n < 2; returning empty numa\n", __func__);
774 for (i = 1; i < n; i++) {
801 return (
NUMA *)ERROR_PTR(
"na not made", __func__, NULL);
803 for (i = 0; i < size; i++) {
804 val = startval + i * increment;
843 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
844 if (nad && nad != nas)
845 return (
NUMA *)ERROR_PTR(
"nad and not in-place", __func__, NULL);
850 for (i = 0; i < n; i++) {
852 nad->
array[i] = L_ABS(val);
875 l_float32 startx, delx;
876 l_float32 *fas, *fad;
880 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
881 if (left < 0) left = 0;
882 if (right < 0) right = 0;
883 if (left == 0 && right == 0)
887 len = n + left + right;
893 for (i = 0; i < n; i++)
894 fad[left + i] = fas[i];
920 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
921 if (left < 0) left = 0;
922 if (right < 0) right = 0;
923 if (left == 0 && right == 0)
926 return (
NUMA *)ERROR_PTR(
"invalid type", __func__, NULL);
929 return (
NUMA *)ERROR_PTR(
"border too large", __func__, NULL);
935 for (i = 0; i < left; i++)
937 for (i = n - right; i < n; i++)
938 fa[i] = fa[n - right - 1];
940 for (i = 0; i < left; i++)
941 fa[i] = fa[2 * left - 1 - i];
942 for (i = 0; i < right; i++)
943 fa[n - right + i] = fa[n - right - i - 1];
964 l_float32 startx, delx;
965 l_float32 *fas, *fad;
969 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
970 if (left < 0) left = 0;
971 if (right < 0) right = 0;
972 if (left == 0 && right == 0)
976 if ((len = n - left - right) < 0)
977 return (
NUMA *)ERROR_PTR(
"len < 0 after removal", __func__, NULL);
983 for (i = 0; i < len; i++)
984 fad[i] = fas[left + i];
1001 l_int32 n, i, val, count, inrun;
1004 return ERROR_INT(
"&count not defined", __func__, 1);
1007 return ERROR_INT(
"na not defined", __func__, 1);
1009 return ERROR_INT(
"na is empty", __func__, 1);
1013 for (i = 0; i < n; i++) {
1015 if (!inrun && val > 0) {
1018 }
else if (inrun && val == 0) {
1042 l_int32 n, i, found;
1045 if (pfirst) *pfirst = 0;
1046 if (plast) *plast = 0;
1047 if (!pfirst || !plast)
1048 return ERROR_INT(
"pfirst and plast not both defined", __func__, 1);
1050 return ERROR_INT(
"na not defined", __func__, 1);
1052 return ERROR_INT(
"na is empty", __func__, 1);
1055 for (i = 0; i < n; i++) {
1069 for (i = n - 1; i >= 0; i--) {
1092 l_int32 n, i, count;
1096 return ERROR_INT(
"&count not defined", __func__, 1);
1099 return ERROR_INT(
"na not defined", __func__, 1);
1101 return ERROR_INT(
"na is empty", __func__, 1);
1103 for (i = 0, count = 0; i < n; i++) {
1142 l_float32 val, startx, delx;
1146 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
1148 return (
NUMA *)ERROR_PTR(
"nas is empty", __func__, NULL);
1149 if (first < 0 || first > last)
1150 return (
NUMA *)ERROR_PTR(
"range not valid", __func__, NULL);
1152 return (
NUMA *)ERROR_PTR(
"no elements in range", __func__, NULL);
1154 last = L_MIN(last, n - 1);
1155 if ((nad =
numaCreate(last - first + 1)) == NULL)
1156 return (
NUMA *)ERROR_PTR(
"nad not made", __func__, NULL);
1157 for (i = first; i <= last; i++) {
1193 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
1195 return (
NUMA *)ERROR_PTR(
"nas is empty", __func__, NULL);
1198 for (i = 0; i < n; i++) {
1204 if (fval < thresh) ival = 1;
1207 if (fval > thresh) ival = 1;
1210 if (fval <= thresh) ival = 1;
1213 if (fval >= thresh) ival = 1;
1217 return (
NUMA *)ERROR_PTR(
"invalid type", __func__, NULL);
1243 l_int32 n, i, j, ileft, iright;
1244 l_float32 left, right, binsize, lfract, rfract, sum, startx, delx;
1249 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
1251 return (
NUMA *)ERROR_PTR(
"nas is empty", __func__, NULL);
1253 return (
NUMA *)ERROR_PTR(
"nsamp must be > 0", __func__, NULL);
1257 binsize = (l_float32)n / (l_float32)nsamp;
1261 for (i = 0; i < nsamp; i++) {
1263 right = left + binsize;
1264 ileft = (l_int32)left;
1265 lfract = 1.0 - left + ileft;
1268 iright = (l_int32)right;
1269 rfract = right - iright;
1270 iright = L_MIN(iright, n - 1);
1271 if (ileft == iright) {
1272 sum += (lfract + rfract - 1.0) * array[ileft];
1274 if (lfract > 0.0001)
1275 sum += lfract * array[ileft];
1276 if (rfract > 0.0001)
1277 sum += rfract * array[iright];
1278 for (j = ileft + 1; j < iright; j++)
1308 l_float32 val1, val2;
1311 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
1312 if (nad && nas != nad)
1313 return (
NUMA *)ERROR_PTR(
"nad defined but != nas", __func__, NULL);
1317 for (i = 0; i < n / 2; i++) {
1325 for (i = n - 1; i >= 0; i--) {
1361 l_int32 n, i, inrun;
1362 l_float32 maxval, threshval, fval, startx, delx, x0, x1;
1366 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
1368 return (
NUMA *)ERROR_PTR(
"nas is empty", __func__, NULL);
1369 if (thresh < 0.0 || thresh > 1.0)
1370 return (
NUMA *)ERROR_PTR(
"invalid thresh", __func__, NULL);
1379 threshval = thresh * maxval;
1385 for (i = 0; i < n; i++) {
1387 if (fval < threshval && inrun == FALSE) {
1389 x0 = startx + i * delx;
1390 }
else if (fval > threshval && inrun == TRUE) {
1392 x1 = startx + i * delx;
1397 if (inrun == TRUE) {
1398 x1 = startx + (n - 1) * delx;
1437 l_int32 n, i, istart, inband, output, sign;
1438 l_int32 startbelow, below, above, belowlast, abovelast;
1439 l_float32 maxval, threshval1, threshval2, fval, startx, delx, x0, x1;
1443 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
1445 return (
NUMA *)ERROR_PTR(
"nas is empty", __func__, NULL);
1446 if (thresh1 < 0.0 || thresh1 > 1.0 || thresh2 < 0.0 || thresh2 > 1.0)
1447 return (
NUMA *)ERROR_PTR(
"invalid thresholds", __func__, NULL);
1448 if (thresh2 < thresh1)
1449 return (
NUMA *)ERROR_PTR(
"thresh2 < thresh1", __func__, NULL);
1460 threshval1 = thresh1 * maxval;
1461 threshval2 = thresh2 * maxval;
1468 for (i = 0; i < n; i++) {
1471 belowlast = (fval < threshval1) ? TRUE : FALSE;
1472 abovelast = (fval > threshval2) ? TRUE : FALSE;
1473 if (belowlast == TRUE || abovelast == TRUE)
1484 startbelow = belowlast;
1486 x0 = startx + istart * delx;
1487 for (i = istart + 1; i < n; i++) {
1489 below = (fval < threshval1) ? TRUE : FALSE;
1490 above = (fval > threshval2) ? TRUE : FALSE;
1491 if (!inband && belowlast && above) {
1492 x1 = startx + i * delx;
1496 }
else if (!inband && abovelast && below) {
1497 x1 = startx + i * delx;
1501 }
else if (inband && startbelow && above) {
1502 x1 = startx + i * delx;
1507 }
else if (inband && !startbelow && below) {
1509 x1 = startx + i * delx;
1514 }
else if (inband && !startbelow && above) {
1515 x0 = startx + i * delx;
1517 }
else if (inband && startbelow && below) {
1518 x0 = startx + i * delx;
1520 }
else if (!inband && !above && !below) {
1522 startbelow = belowlast;
1523 }
else if (!inband && (above || below)) {
1524 x0 = startx + i * delx;
1533 x0 = startx + i * delx;
1559 return ERROR_INT(
"na not defined", __func__, 1);
1561 return ERROR_INT(
"na is empty", __func__, 1);
1563 return ERROR_INT(
"n is not odd", __func__, 1);
1565 if (nspans < 0 || span >= nspans)
1566 return ERROR_INT(
"invalid span", __func__, 1);
1595 return ERROR_INT(
"na not defined", __func__, 1);
1597 return ERROR_INT(
"na is empty", __func__, 1);
1599 return ERROR_INT(
"n % 3 is not 1", __func__, 1);
1600 nedges = (n - 1) / 3;
1601 if (edge < 0 || edge >= nedges)
1602 return ERROR_INT(
"invalid edge", __func__, 1);
1649 l_int32 i, n, i1, i2, i3;
1650 l_float32 x1, x2, x3, fy1, fy2, fy3, d1, d2, d3, del, fi, maxx;
1654 return ERROR_INT(
"&yval not defined", __func__, 1);
1657 return ERROR_INT(
"nay not defined", __func__, 1);
1659 return ERROR_INT(
"deltax not > 0", __func__, 1);
1661 return ERROR_INT(
"invalid interp type", __func__, 1);
1663 return ERROR_INT(
"not enough points", __func__, 1);
1666 L_WARNING(
"only 2 points; using linear interp\n", __func__);
1668 maxx = startx + deltax * (n - 1);
1669 if (xval < startx || xval > maxx)
1670 return ERROR_INT(
"xval is out of bounds", __func__, 1);
1673 fi = (xval - startx) / deltax;
1682 *pyval = fa[i] + del * (fa[i + 1] - fa[i]);
1687 d1 = d3 = 0.5 / (deltax * deltax);
1698 x1 = startx + i1 * deltax;
1699 x2 = startx + i2 * deltax;
1700 x3 = startx + i3 * deltax;
1704 *pyval = fy1 * (xval - x2) * (xval - x3) +
1705 fy2 * (xval - x1) * (xval - x3) +
1706 fy3 * (xval - x1) * (xval - x2);
1738 l_int32 i, im, nx, ny, i1, i2, i3;
1739 l_float32 delu, dell, fract, d1, d2, d3;
1740 l_float32 minx, maxx;
1741 l_float32 *fax, *fay;
1744 return ERROR_INT(
"&yval not defined", __func__, 1);
1747 return ERROR_INT(
"nax not defined", __func__, 1);
1749 return ERROR_INT(
"nay not defined", __func__, 1);
1751 return ERROR_INT(
"invalid interp type", __func__, 1);
1755 return ERROR_INT(
"nax and nay not same size arrays", __func__, 1);
1757 return ERROR_INT(
"not enough points", __func__, 1);
1760 L_WARNING(
"only 2 points; using linear interp\n", __func__);
1764 if (xval < minx || xval > maxx)
1765 return ERROR_INT(
"xval is out of bounds", __func__, 1);
1773 if (xval == fax[0]) {
1779 for (i = 1; i < nx; i++) {
1780 delu = fax[i] - xval;
1787 dell = xval - fax[im];
1791 fract = dell / (fax[i] - fax[im]);
1794 *pyval = fay[i] + fract * (fay[i + 1] - fay[i]);
1808 d1 = (fax[i1] - fax[i2]) * (fax[i1] - fax[i3]);
1809 d2 = (fax[i2] - fax[i1]) * (fax[i2] - fax[i3]);
1810 d3 = (fax[i3] - fax[i1]) * (fax[i3] - fax[i2]);
1811 *pyval = fay[i1] * (xval - fax[i2]) * (xval - fax[i3]) / d1 +
1812 fay[i2] * (xval - fax[i1]) * (xval - fax[i3]) / d2 +
1813 fay[i3] * (xval - fax[i1]) * (xval - fax[i2]) / d3;
1858 l_float32 x, yval, maxx, delx;
1861 if (pnax) *pnax = NULL;
1863 return ERROR_INT(
"&nay not defined", __func__, 1);
1866 return ERROR_INT(
"nasy not defined", __func__, 1);
1868 return ERROR_INT(
"n < 2", __func__, 1);
1870 return ERROR_INT(
"deltax not > 0", __func__, 1);
1872 return ERROR_INT(
"invalid interp type", __func__, 1);
1875 L_WARNING(
"only 2 points; using linear interp\n", __func__);
1877 maxx = startx + deltax * (n - 1);
1878 if (x0 < startx || x1 > maxx || x1 <= x0)
1879 return ERROR_INT(
"[x0 ... x1] is not valid", __func__, 1);
1881 return ERROR_INT(
"npts < 3", __func__, 1);
1882 delx = (x1 - x0) / (l_float32)(npts - 1);
1885 return ERROR_INT(
"nay not made", __func__, 1);
1893 for (i = 0; i < npts; i++) {
1943 l_int32 i, im, j, nx, ny, i1, i2, i3, sorted;
1945 l_float32 del, xval, yval, excess, fract, minx, maxx, d1, d2, d3;
1946 l_float32 *fax, *fay;
1947 NUMA *nasx, *nasy, *nadx, *nady;
1949 if (pnadx) *pnadx = NULL;
1951 return ERROR_INT(
"&nady not defined", __func__, 1);
1954 return ERROR_INT(
"nay not defined", __func__, 1);
1956 return ERROR_INT(
"nax not defined", __func__, 1);
1958 return ERROR_INT(
"invalid interp type", __func__, 1);
1960 return ERROR_INT(
"x0 > x1", __func__, 1);
1964 return ERROR_INT(
"nax and nay not same size arrays", __func__, 1);
1966 return ERROR_INT(
"not enough points", __func__, 1);
1969 L_WARNING(
"only 2 points; using linear interp\n", __func__);
1973 if (x0 < minx || x1 > maxx)
1974 return ERROR_INT(
"xval is out of bounds", __func__, 1);
1979 L_WARNING(
"we are sorting nax in increasing order\n", __func__);
1990 if ((index = (l_int32 *)LEPT_CALLOC(npts,
sizeof(l_int32))) == NULL) {
1993 return ERROR_INT(
"ind not made", __func__, 1);
1995 del = (x1 - x0) / (npts - 1.0);
1996 for (i = 0, j = 0; j < nx && i < npts; i++) {
1997 xval = x0 + i * del;
1998 while (j < nx - 1 && xval > fax[j])
2001 index[i] = L_MIN(j, nx - 1);
2003 index[i] = L_MAX(j - 1, 0);
2013 for (i = 0; i < npts; i++) {
2014 xval = x0 + i * del;
2018 excess = xval - fax[im];
2019 if (excess == 0.0) {
2023 fract = excess / (fax[im + 1] - fax[im]);
2026 yval = fay[im] + fract * (fay[im + 1] - fay[im]);
2041 d1 = (fax[i1] - fax[i2]) * (fax[i1] - fax[i3]);
2042 d2 = (fax[i2] - fax[i1]) * (fax[i2] - fax[i3]);
2043 d3 = (fax[i3] - fax[i1]) * (fax[i3] - fax[i2]);
2044 yval = fay[i1] * (xval - fax[i2]) * (xval - fax[i3]) / d1 +
2045 fay[i2] * (xval - fax[i1]) * (xval - fax[i3]) / d2 +
2046 fay[i3] * (xval - fax[i1]) * (xval - fax[i2]) / d3;
2101 l_float32 x1, x2, x3, y1, y2, y3, c1, c2, c3, a, b, xmax, ymax;
2103 if (pmaxval) *pmaxval = 0.0;
2104 if (pmaxloc) *pmaxloc = 0.0;
2106 return ERROR_INT(
"na not defined", __func__, 1);
2108 return ERROR_INT(
"na is empty", __func__, 1);
2110 return ERROR_INT(
"&maxval not defined", __func__, 1);
2112 return ERROR_INT(
"&maxloc not defined", __func__, 1);
2115 return ERROR_INT(
"na and naloc of unequal size", __func__, 1);
2121 if (imaxloc == 0 || imaxloc == n - 1) {
2153 if (x1 == x2 || x1 == x3 || x2 == x3) {
2160 c1 = y1 / ((x1 - x2) * (x1 - x3));
2161 c2 = y2 / ((x2 - x1) * (x2 - x3));
2162 c3 = y3 / ((x3 - x1) * (x3 - x2));
2164 b = c1 * (x2 + x3) + c2 * (x1 + x3) + c3 * (x1 + x2);
2166 ymax = c1 * (xmax - x2) * (xmax - x3) +
2167 c2 * (xmax - x1) * (xmax - x3) +
2168 c3 * (xmax - x1) * (xmax - x2);
2206 l_float32 minx, maxx, der, invdel;
2210 if (pnadx) *pnadx = NULL;
2212 return ERROR_INT(
"&nady not defined", __func__, 1);
2215 return ERROR_INT(
"nay not defined", __func__, 1);
2217 return ERROR_INT(
"nax not defined", __func__, 1);
2219 return ERROR_INT(
"x0 > x1", __func__, 1);
2223 return ERROR_INT(
"nax and nay not same size arrays", __func__, 1);
2225 return ERROR_INT(
"not enough points", __func__, 1);
2228 if (x0 < minx || x1 > maxx)
2229 return ERROR_INT(
"xval is out of bounds", __func__, 1);
2231 return ERROR_INT(
"npts < 2", __func__, 1);
2235 npts, pnadx, &naiy))
2236 return ERROR_INT(
"interpolation failed", __func__, 1);
2240 invdel = 0.5 * ((l_float32)npts - 1.0) / (x1 - x0);
2244 der = 0.5 * invdel * (fay[1] - fay[0]);
2246 for (i = 1; i < npts - 1; i++) {
2247 der = invdel * (fay[i + 1] - fay[i - 1]);
2250 der = 0.5 * invdel * (fay[npts - 1] - fay[npts - 2]);
2286 l_float32 minx, maxx, sum, del;
2291 return ERROR_INT(
"&sum not defined", __func__, 1);
2294 return ERROR_INT(
"nay not defined", __func__, 1);
2296 return ERROR_INT(
"nax not defined", __func__, 1);
2298 return ERROR_INT(
"x0 > x1", __func__, 1);
2300 return ERROR_INT(
"npts < 2", __func__, 1);
2304 return ERROR_INT(
"nax and nay not same size arrays", __func__, 1);
2306 return ERROR_INT(
"not enough points", __func__, 1);
2309 if (x0 < minx || x1 > maxx)
2310 return ERROR_INT(
"xval is out of bounds", __func__, 1);
2315 return ERROR_INT(
"interpolation failed", __func__, 1);
2317 del = (x1 - x0) / ((l_float32)npts - 1.0);
2321 sum = 0.5 * (fay[0] + fay[npts - 1]);
2322 for (i = 1; i < npts - 1; i++)
2390 NUMA *naindex = NULL;
2392 if (pnasort) *pnasort = NULL;
2393 if (pnaindex) *pnaindex = NULL;
2394 if (pnainvert) *pnainvert = NULL;
2396 return ERROR_INT(
"na not defined", __func__, 1);
2398 return ERROR_INT(
"invalid sort order", __func__, 1);
2400 return ERROR_INT(
"invalid sort type", __func__, 1);
2401 if (!pnasort && !pnaindex && !pnainvert)
2402 return ERROR_INT(
"nothing to do", __func__, 1);
2406 isize = (l_int32)size;
2407 if (isize > MaxInitPtraSize - 1) {
2408 L_WARNING(
"array too large; using shell sort\n", __func__);
2423 *pnaindex = naindex;
2450 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
2452 L_WARNING(
"nas is empty; returning copy\n", __func__);
2456 return (
NUMA *)ERROR_PTR(
"invalid sort order", __func__, NULL);
2460 return (
NUMA *)ERROR_PTR(
"invalid sort type", __func__, NULL);
2465 return numaSort(NULL, nas, sortorder);
2489 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
2491 L_WARNING(
"nas is empty; returning copy\n", __func__);
2495 return (
NUMA *)ERROR_PTR(
"invalid sort order", __func__, NULL);
2498 return (
NUMA *)ERROR_PTR(
"invalid sort type", __func__, NULL);
2524 l_float32 minval, maxval;
2527 return ERROR_INT(
"nas not defined", __func__, UNDEF);
2532 if (minval < 0.0 || n < 200)
2537 if (maxval > MaxInitPtraSize - 1)
2544 if (n * log((l_float32)n) < 0.003 * maxval)
2571 l_int32 i, n, gap, j;
2576 return (
NUMA *)ERROR_PTR(
"nain not defined", __func__, NULL);
2578 return (
NUMA *)ERROR_PTR(
"invalid sort order", __func__, NULL);
2583 else if (nain != naout)
2584 return (
NUMA *)ERROR_PTR(
"invalid: not in-place", __func__, NULL);
2586 L_WARNING(
"naout is empty\n", __func__);
2589 array = naout->
array;
2593 for (gap = n/2; gap > 0; gap = gap / 2) {
2594 for (i = gap; i < n; i++) {
2595 for (j = i - gap; j >= 0; j -= gap) {
2597 array[j] > array[j + gap]) ||
2599 array[j] < array[j + gap]))
2602 array[j] = array[j + gap];
2603 array[j + gap] = tmp;
2639 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
2641 L_WARNING(
"nas is empty; returning copy\n", __func__);
2645 return (
NUMA *)ERROR_PTR(
"invalid sort order", __func__, NULL);
2648 return (
NUMA *)ERROR_PTR(
"bin sort failed", __func__, NULL);
2667 l_int32 i, n, gap, j;
2674 return (
NUMA *)ERROR_PTR(
"na not defined", __func__, NULL);
2676 L_WARNING(
"na is empty\n", __func__);
2680 return (
NUMA *)ERROR_PTR(
"invalid sortorder", __func__, NULL);
2684 return (
NUMA *)ERROR_PTR(
"array not made", __func__, NULL);
2685 if ((iarray = (l_float32 *)LEPT_CALLOC(n,
sizeof(l_float32))) == NULL) {
2687 return (
NUMA *)ERROR_PTR(
"iarray not made", __func__, NULL);
2689 for (i = 0; i < n; i++)
2693 for (gap = n/2; gap > 0; gap = gap / 2) {
2694 for (i = gap; i < n; i++) {
2695 for (j = i - gap; j >= 0; j -= gap) {
2697 array[j] > array[j + gap]) ||
2699 array[j] < array[j + gap]))
2702 array[j] = array[j + gap];
2703 array[j + gap] = tmp;
2705 iarray[j] = iarray[j + gap];
2706 iarray[j + gap] = tmp;
2713 for (i = 0; i < n; i++)
2747 l_int32 i, n, isize, ival, imax;
2748 l_float32 minsize, size;
2749 NUMA *na, *nai, *nad;
2753 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
2755 L_WARNING(
"nas is empty\n", __func__);
2759 return (
NUMA *)ERROR_PTR(
"invalid sort order", __func__, NULL);
2762 return (
NUMA *)ERROR_PTR(
"nas has negative numbers", __func__, NULL);
2764 isize = (l_int32)size;
2765 if (isize > MaxInitPtraSize - 1) {
2766 L_ERROR(
"array too large: %d elements > max size = %d\n",
2767 __func__, isize, MaxInitPtraSize - 1);
2781 for (i = 0; i < n; i++) {
2797 for (i = 0; i <= imax; i++) {
2804 for (i = imax; i >= 0; i--) {
2828 l_int32 i, n, ni, index;
2833 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
2835 return (
NUMA *)ERROR_PTR(
"naindex not defined", __func__, NULL);
2839 return (
NUMA *)ERROR_PTR(
"numa sizes differ", __func__, NULL);
2841 L_WARNING(
"nas is empty\n", __func__);
2846 for (i = 0; i < n; i++) {
2877 l_float32 prevval, val;
2880 return ERROR_INT(
"&sorted not defined", __func__, 1);
2883 return ERROR_INT(
"nas not defined", __func__, 1);
2885 L_WARNING(
"nas is empty\n", __func__);
2890 return ERROR_INT(
"invalid sortorder", __func__, 1);
2894 for (i = 1; i < n; i++) {
2931 if (pnasx) *pnasx = NULL;
2932 if (pnasy) *pnasy = NULL;
2933 if (!pnasx || !pnasy)
2934 return ERROR_INT(
"&nasx and/or &nasy not defined", __func__, 1);
2936 return ERROR_INT(
"nax not defined", __func__, 1);
2938 return ERROR_INT(
"nay not defined", __func__, 1);
2940 return ERROR_INT(
"invalid sortorder", __func__, 1);
2943 if (sorted == TRUE) {
2973 l_int32 i, n, val, error;
2978 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
2980 L_WARNING(
"nas is empty\n", __func__);
2985 test = (l_int32 *)LEPT_CALLOC(n,
sizeof(l_int32));
2987 for (i = 0; i < n; i++) {
2994 if (test[val] == 0) {
3005 return (
NUMA *)ERROR_PTR(
"nas not invertible", __func__, NULL);
3031 return ERROR_INT(
"na not defined", __func__, 1);
3034 return ERROR_INT(
"insert failure", __func__, 1);
3067 l_int32 n, increasing, lindex, rindex, midindex;
3068 l_float32 val0, valn, valmid;
3071 return ERROR_INT(
"&index not defined", __func__, 1);
3074 return ERROR_INT(
"na not defined", __func__, 1);
3077 if (n == 0)
return 0;
3087 increasing = (valn >= val0) ? 1 : 0;
3094 }
else if (val > valn) {
3102 }
else if (val < valn) {
3112 midindex = (lindex + rindex) / 2;
3113 if (midindex == lindex || midindex == rindex)
break;
3154 l_int32 i, index, temp;
3159 return (
NUMA *)ERROR_PTR(
"size <= 0", __func__, NULL);
3161 if ((array = (l_int32 *)LEPT_CALLOC(size,
sizeof(l_int32))) == NULL)
3162 return (
NUMA *)ERROR_PTR(
"array not made", __func__, NULL);
3163 for (i = 0; i < size; i++)
3166 for (i = size - 1; i > 0; i--) {
3167 index = (l_int32)((i + 1) * ((l_float64)rand() / (l_float64)RAND_MAX));
3168 index = L_MIN(index, i);
3170 array[i] = array[index];
3171 array[index] = temp;
3191 l_int32 i, index, size;
3193 NUMA *naindex, *nad;
3196 return (
NUMA *)ERROR_PTR(
"nas not defined", __func__, NULL);
3198 L_WARNING(
"nas is empty\n", __func__);
3204 for (i = 0; i < size; i++) {
3255 return ERROR_INT(
"&val not defined", __func__, 1);
3258 return ERROR_INT(
"na not defined", __func__, 1);
3260 return ERROR_INT(
"na empty", __func__, 1);
3261 if (fract < 0.0 || fract > 1.0)
3262 return ERROR_INT(
"fract not in [0.0 ... 1.0]", __func__, 1);
3272 return ERROR_INT(
"nas not made", __func__, 1);
3274 index = (l_int32)(fract * (l_float32)(n - 1) + 0.5);
3300 return ERROR_INT(
"&val not defined", __func__, 1);
3303 return ERROR_INT(
"na not defined or empty", __func__, 1);
3332 return ERROR_INT(
"&val not defined", __func__, 1);
3335 return ERROR_INT(
"na not defined or empty", __func__, 1);
3360 return ERROR_INT(
"&dev not defined", __func__, 1);
3363 return ERROR_INT(
"na not defined", __func__, 1);
3365 return ERROR_INT(
"na is empty", __func__, 1);
3368 for (i = 0; i < n; i++) {
3370 dev += L_ABS(val - med);
3372 *pdev = dev / (l_float32)n;
3404 if (pmed) *pmed = 0.0;
3406 return ERROR_INT(
"&dev not defined", __func__, 1);
3409 return ERROR_INT(
"na not defined or empty", __func__, 1);
3412 if (pmed) *pmed = med;
3415 for (i = 0; i < n; i++) {
3447 l_int32 i, n, maxcount, prevcount;
3448 l_float32 val, maxval, prevval;
3452 if (pcount) *pcount = 0;
3454 return ERROR_INT(
"&val not defined", __func__, 1);
3457 return ERROR_INT(
"na not defined", __func__, 1);
3459 return ERROR_INT(
"na is empty", __func__, 1);
3462 return ERROR_INT(
"nas not made", __func__, 1);
3469 maxcount = prevcount;
3472 for (i = 1; i < n; i++) {
3474 if (val == prevval) {
3477 if (prevcount > maxcount) {
3478 maxcount = prevcount;
3487 if (prevcount > maxcount) {
3488 maxcount = prevcount;
3530 return ERROR_INT(
"nad not defined", __func__, 1);
3537 if (iend < 0 || iend >= n)
3540 return ERROR_INT(
"istart > iend; nothing to add", __func__, 1);
3542 for (i = istart; i <= iend; i++) {
3577 return ERROR_INT(
"naad not defined", __func__, 1);
3584 if (iend < 0 || iend >= n)
3587 return ERROR_INT(
"istart > iend; nothing to add", __func__, 1);
3589 for (i = istart; i <= iend; i++) {
3621 return (
NUMA *)ERROR_PTR(
"naa not defined", __func__, NULL);
3626 for (i = 0; i < nalloc; i++) {
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
l_ok numaReplaceNumber(NUMA *na, l_int32 index, l_float32 val)
numaReplaceNumber()
l_ok numaGetFValue(NUMA *na, l_int32 index, l_float32 *pval)
numaGetFValue()
NUMA ** numaaGetPtrArray(NUMAA *naa)
numaaGetPtrArray()
NUMA * numaCreate(l_int32 n)
numaCreate()
l_int32 numaaGetCount(NUMAA *naa)
numaaGetCount()
l_ok numaInsertNumber(NUMA *na, l_int32 index, l_float32 val)
numaInsertNumber()
NUMA * numaaGetNuma(NUMAA *naa, l_int32 index, l_int32 accessflag)
numaaGetNuma()
NUMA * numaClone(NUMA *na)
numaClone()
void numaDestroy(NUMA **pna)
numaDestroy()
l_ok numaSetValue(NUMA *na, l_int32 index, l_float32 val)
numaSetValue()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_ok numaaAddNuma(NUMAA *naa, NUMA *na, l_int32 copyflag)
numaaAddNuma()
NUMA * numaCopy(NUMA *na)
numaCopy()
l_ok numaGetParameters(NUMA *na, l_float32 *pstartx, l_float32 *pdelx)
numaGetParameters()
NUMA * numaCreateFromIArray(l_int32 *iarray, l_int32 size)
numaCreateFromIArray()
l_ok numaSetParameters(NUMA *na, l_float32 startx, l_float32 delx)
numaSetParameters()
l_float32 * numaGetFArray(NUMA *na, l_int32 copyflag)
numaGetFArray()
NUMA * numaInvert(NUMA *nad, NUMA *nas)
numaInvert()
NUMA * numaMakeThresholdIndicator(NUMA *nas, l_float32 thresh, l_int32 type)
numaMakeThresholdIndicator()
NUMA * numaPseudorandomSequence(l_int32 size, l_int32 seed)
numaPseudorandomSequence()
NUMA * numaSort(NUMA *naout, NUMA *nain, l_int32 sortorder)
numaSort()
l_ok numaaJoin(NUMAA *naad, NUMAA *naas, l_int32 istart, l_int32 iend)
numaaJoin()
l_ok numaGetMode(NUMA *na, l_float32 *pval, l_int32 *pcount)
numaGetMode()
l_ok numaInterpolateArbxVal(NUMA *nax, NUMA *nay, l_int32 type, l_float32 xval, l_float32 *pyval)
numaInterpolateArbxVal()
l_ok numaGetMeanAbsval(NUMA *na, l_float32 *paveabs)
numaGetMeanAbsval()
NUMA * numaMakeDelta(NUMA *nas)
numaMakeDelta()
NUMA * numaReverse(NUMA *nad, NUMA *nas)
numaReverse()
l_int32 numaGetEdgeValues(NUMA *na, l_int32 edge, l_int32 *pstart, l_int32 *pend, l_int32 *psign)
numaGetEdgeValues()
l_ok numaGetMedianDevFromMedian(NUMA *na, l_float32 *pmed, l_float32 *pdev)
numaGetMedianDevFromMedian()
l_int32 numaSimilar(NUMA *na1, NUMA *na2, l_float32 maxdiff, l_int32 *psimilar)
numaSimilar()
NUMA * numaLogicalOp(NUMA *nad, NUMA *na1, NUMA *na2, l_int32 op)
numaLogicalOp()
NUMA * numaAddBorder(NUMA *nas, l_int32 left, l_int32 right, l_float32 val)
numaAddBorder()
l_ok numaHasOnlyIntegers(NUMA *na, l_int32 *pallints)
numaHasOnlyIntegers()
l_ok numaGetMedian(NUMA *na, l_float32 *pval)
numaGetMedian()
NUMA * numaaFlattenToNuma(NUMAA *naa)
numaaFlattenToNuma()
l_ok numaGetMean(NUMA *na, l_float32 *pave)
numaGetMean()
NUMA * numaGetSortIndex(NUMA *na, l_int32 sortorder)
numaGetSortIndex()
l_ok numaSortPair(NUMA *nax, NUMA *nay, l_int32 sortorder, NUMA **pnasx, NUMA **pnasy)
numaSortPair()
l_ok numaFindSortedLoc(NUMA *na, l_float32 val, l_int32 *pindex)
numaFindSortedLoc()
NUMA * numaMakeAbsval(NUMA *nad, NUMA *nas)
numaMakeAbsval()
l_ok numaInterpolateEqxVal(l_float32 startx, l_float32 deltax, NUMA *nay, l_int32 type, l_float32 xval, l_float32 *pyval)
numaInterpolateEqxVal()
l_ok numaAddToNumber(NUMA *na, l_int32 index, l_float32 val)
numaAddToNumber()
NUMA * numaUniformSampling(NUMA *nas, l_int32 nsamp)
numaUniformSampling()
l_int32 numaIsSorted(NUMA *nas, l_int32 sortorder, l_int32 *psorted)
numaIsSorted()
l_ok numaGetSumOnInterval(NUMA *na, l_int32 first, l_int32 last, l_float32 *psum)
numaGetSumOnInterval()
NUMA * numaRemoveBorder(NUMA *nas, l_int32 left, l_int32 right)
numaRemoveBorder()
NUMA * numaSortAutoSelect(NUMA *nas, l_int32 sortorder)
numaSortAutoSelect()
l_ok numaGetCountRelativeToZero(NUMA *na, l_int32 type, l_int32 *pcount)
numaGetCountRelativeToZero()
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()
l_ok numaInterpolateArbxInterval(NUMA *nax, NUMA *nay, l_int32 type, l_float32 x0, l_float32 x1, l_int32 npts, NUMA **pnadx, NUMA **pnady)
numaInterpolateArbxInterval()
l_ok numaGetMeanDevFromMedian(NUMA *na, l_float32 med, l_float32 *pdev)
numaGetMeanDevFromMedian()
NUMA * numaRandomPermutation(NUMA *nas, l_int32 seed)
numaRandomPermutation()
l_ok numaJoin(NUMA *nad, NUMA *nas, l_int32 istart, l_int32 iend)
numaJoin()
l_ok numaGetRankValue(NUMA *na, l_float32 fract, NUMA *nasort, l_int32 usebins, l_float32 *pval)
numaGetRankValue()
l_ok numaGetMin(NUMA *na, l_float32 *pminval, l_int32 *piminloc)
numaGetMin()
NUMA * numaBinSort(NUMA *nas, l_int32 sortorder)
numaBinSort()
NUMA * numaSortIndexAutoSelect(NUMA *nas, l_int32 sortorder)
numaSortIndexAutoSelect()
NUMA * numaLowPassIntervals(NUMA *nas, l_float32 thresh, l_float32 maxn)
numaLowPassIntervals()
l_ok numaGetBinnedMedian(NUMA *na, l_int32 *pval)
numaGetBinnedMedian()
NUMA * numaInvertMap(NUMA *nas)
numaInvertMap()
l_ok numaAddSorted(NUMA *na, l_float32 val)
numaAddSorted()
NUMA * numaMakeConstant(l_float32 val, l_int32 size)
numaMakeConstant()
NUMA * numaClipToInterval(NUMA *nas, l_int32 first, l_int32 last)
numaClipToInterval()
NUMA * numaSubsample(NUMA *nas, l_int32 subfactor)
numaSubsample()
l_ok numaGetMax(NUMA *na, l_float32 *pmaxval, l_int32 *pimaxloc)
numaGetMax()
NUMA * numaGetPartialSums(NUMA *na)
numaGetPartialSums()
NUMA * numaThresholdEdges(NUMA *nas, l_float32 thresh1, l_float32 thresh2, l_float32 maxn)
numaThresholdEdges()
NUMA * numaArithOp(NUMA *nad, NUMA *na1, NUMA *na2, l_int32 op)
numaArithOp()
l_int32 numaChooseSortType(NUMA *nas)
numaChooseSortType()
l_int32 numaGetSpanValues(NUMA *na, l_int32 span, l_int32 *pstart, l_int32 *pend)
numaGetSpanValues()
NUMA * numaSortByIndex(NUMA *nas, NUMA *naindex)
numaSortByIndex()
NUMA * numaAddSpecifiedBorder(NUMA *nas, l_int32 left, l_int32 right, l_int32 type)
numaAddSpecifiedBorder()
l_ok numaSortGeneral(NUMA *na, NUMA **pnasort, NUMA **pnaindex, NUMA **pnainvert, l_int32 sortorder, l_int32 sorttype)
numaSortGeneral()
l_ok numaGetNonzeroRange(NUMA *na, l_float32 eps, l_int32 *pfirst, l_int32 *plast)
numaGetNonzeroRange()
NUMA * numaMakeSequence(l_float32 startval, l_float32 increment, l_int32 size)
numaMakeSequence()
l_ok numaFitMax(NUMA *na, l_float32 *pmaxval, NUMA *naloc, l_float32 *pmaxloc)
numaFitMax()
NUMA * numaGetBinSortIndex(NUMA *nas, l_int32 sortorder)
numaGetBinSortIndex()
l_ok numaCountNonzeroRuns(NUMA *na, l_int32 *pcount)
numaCountNonzeroRuns()
l_ok numaDifferentiateInterval(NUMA *nax, NUMA *nay, l_float32 x0, l_float32 x1, l_int32 npts, NUMA **pnadx, NUMA **pnady)
numaDifferentiateInterval()
l_ok numaGetSum(NUMA *na, l_float32 *psum)
numaGetSum()
l_ok numaIntegrateInterval(NUMA *nax, NUMA *nay, l_float32 x0, l_float32 x1, l_int32 npts, l_float32 *psum)
numaIntegrateInterval()
l_ok ptraInsert(L_PTRA *pa, l_int32 index, void *item, l_int32 shiftflag)
ptraInsert()
L_PTRA * ptraCreate(l_int32 n)
ptraCreate()
l_ok ptraGetMaxIndex(L_PTRA *pa, l_int32 *pmaxindex)
ptraGetMaxIndex()
void ptraDestroy(L_PTRA **ppa, l_int32 freeflag, l_int32 warnflag)
ptraDestroy()
void * ptraRemove(L_PTRA *pa, l_int32 index, l_int32 flag)
ptraRemove()
void * ptraGetPtrToItem(L_PTRA *pa, l_int32 index)
ptraGetPtrToItem()
void * ptraRemoveLast(L_PTRA *pa)
ptraRemoveLast()
void lept_stderr(const char *fmt,...)
lept_stderr()
l_int32 lept_roundftoi(l_float32 fval)
lept_roundftoi()