IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 42825


Ignore:
Timestamp:
May 8, 2025, 4:47:17 PM (12 months ago)
Author:
eugene
Message:

add 1,3,4D versions of psPolynomialXDRecycle and psPolynomialXDCopy

Location:
trunk/psLib/src/math
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/math/psPolynomial.c

    r41896 r42825  
    806806}
    807807
    808 // XXX add 1D, 3D, 4D versions
    809 bool psPolynomial2DRecycle(psPolynomial2D *poly,
    810                            psPolynomialType type,
    811                            unsigned int nX,
    812                            unsigned int nY)
    813 {
    814     PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
    815     PS_ASSERT_INT_NONNEGATIVE(nY, NULL);
    816 
    817     bool match = true;
    818     match &= (poly->type == type);
    819     match &= (poly->nX == type);
    820     match &= (poly->nY == type);
    821 
    822     if (!match) {
    823         for (int i = 0; i < poly->nX + 1; i++) {
    824             psFree (poly->coeff[i]);
    825             psFree (poly->coeffErr[i]);
    826             psFree (poly->coeffMask[i]);
    827         }
    828         psFree (poly->coeff);
    829         psFree (poly->coeffErr);
    830         psFree (poly->coeffMask);
    831 
    832         poly->type = type;
    833         poly->nX = nX;
    834         poly->nY = nY;
    835 
    836         poly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
    837         poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
    838         poly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
    839         for (int i = 0; i < (1 + nX); i++) {
    840             poly->coeff[i] = psAlloc((1 + nY) * sizeof(psF64));
    841             poly->coeffErr[i] = psAlloc((1 + nY) * sizeof(psF64));
    842             poly->coeffMask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
    843         }
    844     }
    845     for (int i = 0; i < (1 + nX); i++) {
    846         for (int j = 0; j < (1 + nY); j++) {
    847             poly->coeff[i][j] = 0.0;
    848             poly->coeffErr[i][j] = 0.0;
    849             poly->coeffMask[i][j] = PS_POLY_MASK_NONE;
    850         }
    851     }
    852     return(true);
    853 }
    854 
    855 // XXX add 1D, 3D, 4D versions
    856 psPolynomial2D *psPolynomial2DCopy(psPolynomial2D *out,
    857                                    psPolynomial2D *poly)
    858 {
    859     if (out == NULL) {
    860         out = psPolynomial2DAlloc (poly->type, poly->nX, poly->nY);
    861     } else {
    862         psPolynomial2DRecycle (out, poly->type, poly->nX, poly->nY);
    863     }
    864 
    865     for (int i = 0; i < (1 + poly->nX); i++) {
    866         for (int j = 0; j < (1 + poly->nY); j++) {
    867             out->coeff[i][j] = poly->coeff[i][j];
    868             out->coeffErr[i][j] = poly->coeffErr[i][j];
    869             out->coeffMask[i][j] = poly->coeffMask[i][j];
    870         }
    871     }
    872     return(out);
    873 }
    874 
    875808psPolynomial3D* psPolynomial3DAlloc(
    876809    psPolynomialType type,
    … …  
    1002935}
    1003936
     937// XXX add 3D, 4D versions
     938bool psPolynomial1DRecycle(psPolynomial1D *poly,
     939                           psPolynomialType type,
     940                           unsigned int nX)
     941{
     942    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
     943
     944    bool match = true;
     945    match &= (poly->type == type);
     946    match &= (poly->nX   == nX);
     947
     948    if (!match) {
     949        polynomial1DFree (poly); // frees the coeffs
     950
     951        poly->type = type;
     952        poly->nX   = nX;
     953
     954        poly->coeff = psAlloc((1 + nX) * sizeof(psF64));
     955        poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64));
     956        poly->coeffMask = (psMaskType *)psAlloc((1 + nX) * sizeof(psMaskType));
     957    }
     958    for (int i = 0; i < (1 + nX); i++) {
     959        poly->coeff[i] = 0.0;
     960        poly->coeffErr[i] = 0.0;
     961        poly->coeffMask[i] = PS_POLY_MASK_NONE;
     962    }
     963    return(true);
     964}
     965
     966bool psPolynomial2DRecycle(psPolynomial2D *poly,
     967                           psPolynomialType type,
     968                           unsigned int nX,
     969                           unsigned int nY)
     970{
     971    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
     972    PS_ASSERT_INT_NONNEGATIVE(nY, NULL);
     973
     974    bool match = true;
     975    match &= (poly->type == type);
     976    match &= (poly->nX ==   nX);
     977    match &= (poly->nY ==   nY);
     978
     979    if (!match) {
     980        polynomial2DFree (poly); // frees the coeffs
     981
     982        poly->type = type;
     983        poly->nX   = nX;
     984        poly->nY   = nY;
     985
     986        poly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
     987        poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
     988        poly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
     989        for (int i = 0; i < (1 + nX); i++) {
     990            poly->coeff[i] = psAlloc((1 + nY) * sizeof(psF64));
     991            poly->coeffErr[i] = psAlloc((1 + nY) * sizeof(psF64));
     992            poly->coeffMask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
     993        }
     994    }
     995    for (int i = 0; i < (1 + nX); i++) {
     996        for (int j = 0; j < (1 + nY); j++) {
     997            poly->coeff[i][j] = 0.0;
     998            poly->coeffErr[i][j] = 0.0;
     999            poly->coeffMask[i][j] = PS_POLY_MASK_NONE;
     1000        }
     1001    }
     1002    return(true);
     1003}
     1004
     1005bool psPolynomial3DRecycle(psPolynomial3D *poly,
     1006                           psPolynomialType type,
     1007                           unsigned int nX,
     1008                           unsigned int nY,
     1009                           unsigned int nZ)
     1010{
     1011    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
     1012    PS_ASSERT_INT_NONNEGATIVE(nY, NULL);
     1013    PS_ASSERT_INT_NONNEGATIVE(nZ, NULL);
     1014
     1015    bool match = true;
     1016    match &= (poly->type == type);
     1017    match &= (poly->nX   == nX);
     1018    match &= (poly->nY   == nY);
     1019    match &= (poly->nZ   == nZ);
     1020
     1021    if (!match) {
     1022        polynomial3DFree (poly); // frees the coeffs
     1023
     1024        poly->type = type;
     1025        poly->nX = nX;
     1026        poly->nY = nY;
     1027        poly->nZ = nZ;
     1028
     1029        poly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
     1030        poly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 **));
     1031        poly->coeffMask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
     1032        for (int ix = 0; ix < (1 + nX); ix++) {
     1033            poly->coeff[ix] = psAlloc((nY + 1) * sizeof(psF64 *));
     1034            poly->coeffErr[ix] = psAlloc((nY + 1) * sizeof(psF64 *));
     1035            poly->coeffMask[ix] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
     1036            for (int iy = 0; iy < (nY + 1); iy++) {
     1037                poly->coeff[ix][iy] = psAlloc((nZ + 1) * sizeof(psF64));
     1038                poly->coeffErr[ix][iy] = psAlloc((nZ + 1) * sizeof(psF64));
     1039                poly->coeffMask[ix][iy] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
     1040            }
     1041        }
     1042    }
     1043    for (int ix = 0; ix < (1 + nX); ix++) {
     1044        for (int iy = 0; iy < (1 + nY); iy++) {
     1045            for (int iz = 0; iz < (1 + nZ); iz++) {
     1046                poly->coeff[ix][iy][iz]     = 0.0;
     1047                poly->coeffErr[ix][iy][iz]  = 0.0;
     1048                poly->coeffMask[ix][iy][iz] = PS_POLY_MASK_NONE;
     1049            }
     1050        }
     1051    }
     1052    return(true);
     1053}
     1054
     1055bool psPolynomial4DRecycle(psPolynomial4D *poly,
     1056                           psPolynomialType type,
     1057                           unsigned int nX,
     1058                           unsigned int nY,
     1059                           unsigned int nZ,
     1060                           unsigned int nT)
     1061{
     1062    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
     1063    PS_ASSERT_INT_NONNEGATIVE(nY, NULL);
     1064    PS_ASSERT_INT_NONNEGATIVE(nZ, NULL);
     1065    PS_ASSERT_INT_NONNEGATIVE(nT, NULL);
     1066
     1067    bool match = true;
     1068    match &= (poly->type == type);
     1069    match &= (poly->nX   == nX);
     1070    match &= (poly->nY   == nY);
     1071    match &= (poly->nZ   == nZ);
     1072    match &= (poly->nT   == nT);
     1073
     1074    if (!match) {
     1075        polynomial4DFree (poly); // frees the coeffs
     1076
     1077        poly->type = type;
     1078        poly->nX = nX;
     1079        poly->nY = nY;
     1080        poly->nZ = nZ;
     1081        poly->nT = nT;
     1082
     1083        poly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));
     1084        poly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 ***));
     1085        poly->coeffMask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
     1086        for (int ix = 0; ix < (nX + 1); ix++) {
     1087            poly->coeff[ix] = psAlloc((nY + 1) * sizeof(psF64 **));
     1088            poly->coeffErr[ix] = psAlloc((nY + 1) * sizeof(psF64 **));
     1089            poly->coeffMask[ix] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
     1090            for (int iy = 0; iy < (nY + 1); iy++) {
     1091                poly->coeff[ix][iy] = psAlloc((nZ + 1) * sizeof(psF64 *));
     1092                poly->coeffErr[ix][iy] = psAlloc((nZ + 1) * sizeof(psF64 *));
     1093                poly->coeffMask[ix][iy] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
     1094                for (int iz = 0; iz < (nZ + 1); iz++) {
     1095                    poly->coeff[ix][iy][iz] = psAlloc((nT + 1) * sizeof(psF64));
     1096                    poly->coeffErr[ix][iy][iz] = psAlloc((nT + 1) * sizeof(psF64));
     1097                    poly->coeffMask[ix][iy][iz] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
     1098                }
     1099            }
     1100        }
     1101    }
     1102    for (int ix = 0; ix < (1 + nX); ix++) {
     1103        for (int iy = 0; iy < (1 + nY); iy++) {
     1104            for (int iz = 0; iz < (1 + nZ); iz++) {
     1105                for (int it = 0; it < (1 + nT); it++) {
     1106                    poly->coeff[ix][iy][iz][it]     = 0.0;
     1107                    poly->coeffErr[ix][iy][iz][it]  = 0.0;
     1108                    poly->coeffMask[ix][iy][iz][it] = PS_POLY_MASK_NONE;
     1109                }
     1110            }
     1111        }
     1112    }
     1113    return(true);
     1114}
     1115
     1116// ######## Copy polynomials ########
     1117psPolynomial1D *psPolynomial1DCopy(psPolynomial1D *out,
     1118                                   psPolynomial1D *poly)
     1119{
     1120    if (out == NULL) {
     1121        out = psPolynomial1DAlloc (poly->type, poly->nX);
     1122    } else {
     1123        psPolynomial1DRecycle (out, poly->type, poly->nX);
     1124    }
     1125
     1126    for (int i = 0; i < (1 + poly->nX); i++) {
     1127        out->coeff[i] = poly->coeff[i];
     1128        out->coeffErr[i] = poly->coeffErr[i];
     1129        out->coeffMask[i] = poly->coeffMask[i];
     1130    }
     1131    return(out);
     1132}
     1133psPolynomial2D *psPolynomial2DCopy(psPolynomial2D *out,
     1134                                   psPolynomial2D *poly)
     1135{
     1136    if (out == NULL) {
     1137        out = psPolynomial2DAlloc (poly->type, poly->nX, poly->nY);
     1138    } else {
     1139        psPolynomial2DRecycle (out, poly->type, poly->nX, poly->nY);
     1140    }
     1141
     1142    for (int i = 0; i < (1 + poly->nX); i++) {
     1143        for (int j = 0; j < (1 + poly->nY); j++) {
     1144            out->coeff[i][j] = poly->coeff[i][j];
     1145            out->coeffErr[i][j] = poly->coeffErr[i][j];
     1146            out->coeffMask[i][j] = poly->coeffMask[i][j];
     1147        }
     1148    }
     1149    return(out);
     1150}
     1151psPolynomial3D *psPolynomial3DCopy(psPolynomial3D *out,
     1152                                   psPolynomial3D *poly)
     1153{
     1154    if (out == NULL) {
     1155        out = psPolynomial3DAlloc (poly->type, poly->nX, poly->nY, poly->nZ);
     1156    } else {
     1157        psPolynomial3DRecycle (out, poly->type, poly->nX, poly->nY, poly->nZ);
     1158    }
     1159
     1160    for (int ix = 0; ix < (1 + poly->nX); ix++) {
     1161        for (int iy = 0; iy < (1 + poly->nY); iy++) {
     1162            for (int iz = 0; iz < (1 + poly->nZ); iz++) {
     1163                out->coeff[ix][iy][iz] = poly->coeff[ix][iy][iz];
     1164                out->coeffErr[ix][iy][iz] = poly->coeffErr[ix][iy][iz];
     1165                out->coeffMask[ix][iy][iz] = poly->coeffMask[ix][iy][iz];
     1166            }
     1167        }
     1168    }
     1169    return(out);
     1170}
     1171psPolynomial4D *psPolynomial4DCopy(psPolynomial4D *out,
     1172                                   psPolynomial4D *poly)
     1173{
     1174    if (out == NULL) {
     1175        out = psPolynomial4DAlloc (poly->type, poly->nX, poly->nY, poly->nZ, poly->nT);
     1176    } else {
     1177        psPolynomial4DRecycle (out, poly->type, poly->nX, poly->nY, poly->nZ, poly->nT);
     1178    }
     1179
     1180    for (int ix = 0; ix < (1 + poly->nX); ix++) {
     1181        for (int iy = 0; iy < (1 + poly->nY); iy++) {
     1182            for (int iz = 0; iz < (1 + poly->nZ); iz++) {
     1183                for (int it = 0; it < (1 + poly->nT); it++) {
     1184                    out->coeff[ix][iy][iz][it] = poly->coeff[ix][iy][iz][it];
     1185                    out->coeffErr[ix][iy][iz][it] = poly->coeffErr[ix][iy][iz][it];
     1186                    out->coeffMask[ix][iy][iz][it] = poly->coeffMask[ix][iy][iz][it];
     1187                }
     1188            }
     1189        }
     1190    }
     1191    return(out);
     1192}
     1193
    10041194/* note these functions accept unscaled values and apply the scaling saved on poly */
    10051195psF64 psPolynomial1DEval(const psPolynomial1D* poly,
    … …  
    10341224
    10351225    switch (x->type.type) {
    1036     case PS_TYPE_F64:
     1226      case PS_TYPE_F64:
    10371227        tmp = psVectorAlloc(x->n, PS_TYPE_F64);
    10381228        for (unsigned int i=0;i<x->n;i++) {
    … …  
    10401230        }
    10411231        break;
    1042     case PS_TYPE_F32:
     1232      case PS_TYPE_F32:
    10431233        tmp = psVectorAlloc(x->n, PS_TYPE_F32);
    10441234        for (unsigned int i=0;i<x->n;i++) {
    … …  
    10461236        }
    10471237        break;
    1048     default:
     1238      default:
    10491239        psError(PS_ERR_UNKNOWN, false, "invalid input data type.\n");
    10501240        return (NULL);

  • trunk/psLib/src/math/psPolynomial.h

    r42336 r42825  
    161161) PS_ATTR_MALLOC;
    162162
     163bool psPolynomial1DRecycle(psPolynomial1D *poly,
     164                           psPolynomialType type,
     165                           unsigned int nX);
    163166bool psPolynomial2DRecycle(psPolynomial2D *poly,
    164167                           psPolynomialType type,
    165168                           unsigned int nX,
    166169                           unsigned int nY);
    167 
     170bool psPolynomial3DRecycle(psPolynomial3D *poly,
     171                           psPolynomialType type,
     172                           unsigned int nX,
     173                           unsigned int nY,
     174                           unsigned int nZ);
     175bool psPolynomial4DRecycle(psPolynomial4D *poly,
     176                           psPolynomialType type,
     177                           unsigned int nX,
     178                           unsigned int nY,
     179                           unsigned int nZ,
     180                           unsigned int nT);
     181
     182psPolynomial1D *psPolynomial1DCopy(psPolynomial1D *out,
     183                                   psPolynomial1D *poly);
    168184psPolynomial2D *psPolynomial2DCopy(psPolynomial2D *out,
    169185                                   psPolynomial2D *poly);
     186psPolynomial3D *psPolynomial3DCopy(psPolynomial3D *out,
     187                                   psPolynomial3D *poly);
     188psPolynomial4D *psPolynomial4DCopy(psPolynomial4D *out,
     189                                   psPolynomial4D *poly);
    170190
    171191/** Evaluates a 1-D polynomial at specific coordinates.
Note: See TracChangeset for help on using the changeset viewer.