IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 27, 2005, 2:53:54 PM (21 years ago)
Author:
drobbin
Message:

psPolynomial fxns revised per apidelta-report-cycle6

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4392 r4405  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.111 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-06-25 02:02:05 $
     9 *  @version $Revision: 1.112 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-06-28 00:53:53 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    12321232}
    12331233
    1234 psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
    1235 {
    1236     PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    1237 
    1238     if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1239         return(ordPolynomial1DEval(x, myPoly));
    1240     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    1241         return(chebPolynomial1DEval(x, myPoly));
     1234psF64 psPolynomial1DEval(const psPolynomial1D* poly, psF64 x)
     1235{
     1236    PS_ASSERT_POLY_NON_NULL(poly, NAN);
     1237
     1238    if (poly->type == PS_POLYNOMIAL_ORD) {
     1239        return(ordPolynomial1DEval(x, poly));
     1240    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     1241        return(chebPolynomial1DEval(x, poly));
    12421242    } else {
    12431243        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    12441244                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
    1245                 myPoly->type);
     1245                poly->type);
    12461246    }
    12471247    return(NAN);
    12481248}
    12491249
    1250 psVector *psPolynomial1DEvalVector(const psPolynomial1D *myPoly,
     1250psVector *psPolynomial1DEvalVector(const psPolynomial1D *poly,
    12511251                                   const psVector *x)
    12521252{
    1253     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1253    PS_ASSERT_POLY_NON_NULL(poly, NULL);
    12541254    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
    12551255    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    … …  
    12591259    tmp = psVectorAlloc(x->n, PS_TYPE_F32);
    12601260    for (psS32 i=0;i<x->n;i++) {
    1261         tmp->data.F32[i] = psPolynomial1DEval(myPoly, x->data.F32[i]);
     1261        tmp->data.F32[i] = psPolynomial1DEval(poly, x->data.F32[i]);
    12621262    }
    12631263
    … …  
    12651265}
    12661266
    1267 psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
    1268 {
    1269     PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    1270 
    1271     if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1272         return(ordPolynomial2DEval(x, y, myPoly));
    1273     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    1274         return(chebPolynomial2DEval(x, y, myPoly));
     1267psF64 psPolynomial2DEval(const psPolynomial2D* poly, psF64 x, psF64 y)
     1268{
     1269    PS_ASSERT_POLY_NON_NULL(poly, NAN);
     1270
     1271    if (poly->type == PS_POLYNOMIAL_ORD) {
     1272        return(ordPolynomial2DEval(x, y, poly));
     1273    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     1274        return(chebPolynomial2DEval(x, y, poly));
    12751275    } else {
    12761276        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    12771277                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
    1278                 myPoly->type);
     1278                poly->type);
    12791279    }
    12801280    return(NAN);
    12811281}
    12821282
    1283 psVector *psPolynomial2DEvalVector(const psPolynomial2D *myPoly,
     1283psVector *psPolynomial2DEvalVector(const psPolynomial2D *poly,
    12841284                                   const psVector *x,
    12851285                                   const psVector *y)
    12861286
    12871287{
    1288     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1288    PS_ASSERT_POLY_NON_NULL(poly, NULL);
    12891289    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
    12901290    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    … …  
    13051305    // Evaluate the polynomial at the specified points
    13061306    for (psS32 i=0; i<vecLen; i++) {
    1307         tmp->data.F32[i] = psPolynomial2DEval(myPoly,x->data.F32[i],y->data.F32[i]);
     1307        tmp->data.F32[i] = psPolynomial2DEval(poly,x->data.F32[i],y->data.F32[i]);
    13081308    }
    13091309
    … …  
    13121312}
    13131313
    1314 psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
    1315 {
    1316     PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    1317 
    1318     if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1319         return(ordPolynomial3DEval(x, y, z, myPoly));
    1320     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    1321         return(chebPolynomial3DEval(x, y, z, myPoly));
     1314psF64 psPolynomial3DEval(const psPolynomial3D* poly, psF64 x, psF64 y, psF64 z)
     1315{
     1316    PS_ASSERT_POLY_NON_NULL(poly, NAN);
     1317
     1318    if (poly->type == PS_POLYNOMIAL_ORD) {
     1319        return(ordPolynomial3DEval(x, y, z, poly));
     1320    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     1321        return(chebPolynomial3DEval(x, y, z, poly));
    13221322    } else {
    13231323        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    13241324                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
    1325                 myPoly->type);
     1325                poly->type);
    13261326    }
    13271327    return(NAN);
    13281328}
    13291329
    1330 psVector *psPolynomial3DEvalVector(const psPolynomial3D *myPoly,
     1330psVector *psPolynomial3DEvalVector(const psPolynomial3D *poly,
    13311331                                   const psVector *x,
    13321332                                   const psVector *y,
    … …  
    13341334
    13351335{
    1336     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1336    PS_ASSERT_POLY_NON_NULL(poly, NULL);
    13371337    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
    13381338    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    … …  
    13581358    // Evaluate polynomial
    13591359    for (psS32 i = 0; i < vecLen; i++) {
    1360         tmp->data.F32[i] = psPolynomial3DEval(myPoly,
     1360        tmp->data.F32[i] = psPolynomial3DEval(poly,
    13611361                                              x->data.F32[i],
    13621362                                              y->data.F32[i],
    … …  
    13681368}
    13691369
    1370 psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
    1371 {
    1372     PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    1373 
    1374     if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1375         return(ordPolynomial4DEval(w,x,y,z, myPoly));
    1376     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    1377         return(chebPolynomial4DEval(w,x,y,z, myPoly));
     1370psF64 psPolynomial4DEval(const psPolynomial4D* poly, psF64 x, psF64 y, psF64 z, psF64 t)
     1371{
     1372    PS_ASSERT_POLY_NON_NULL(poly, NAN);
     1373
     1374    if (poly->type == PS_POLYNOMIAL_ORD) {
     1375        return(ordPolynomial4DEval(x,y,z,t, poly));
     1376    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     1377        return(chebPolynomial4DEval(x,y,z,t, poly));
    13781378    } else {
    13791379        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    13801380                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
    1381                 myPoly->type);
     1381                poly->type);
    13821382    }
    13831383    return(NAN);
    13841384}
    13851385
    1386 psVector *psPolynomial4DEvalVector(const psPolynomial4D *myPoly,
    1387                                    const psVector *w,
     1386psVector *psPolynomial4DEvalVector(const psPolynomial4D *poly,
    13881387                                   const psVector *x,
    13891388                                   const psVector *y,
    1390                                    const psVector *z)
    1391 {
    1392     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1393     PS_ASSERT_VECTOR_NON_NULL(w, NULL);
    1394     PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
     1389                                   const psVector *z,
     1390                                   const psVector *t)
     1391{
     1392    PS_ASSERT_POLY_NON_NULL(poly, NULL);
    13951393    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
    13961394    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    … …  
    13991397    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
    14001398    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
     1399    PS_ASSERT_VECTOR_NON_NULL(t, NULL);
     1400    PS_ASSERT_VECTOR_TYPE(t, PS_TYPE_F32, NULL);
    14011401
    14021402    psVector *tmp;
    1403     psS32 vecLen=w->n;
     1403    psS32 vecLen=x->n;
    14041404
    14051405    // Determine output vector size from min of input vectors
     1406    if (z->n < vecLen) {
     1407        vecLen = z->n;
     1408    }
    14061409    if (y->n < vecLen) {
    14071410        vecLen = y->n;
    14081411    }
    1409     if (x->n < vecLen) {
    1410         vecLen = x->n;
    1411     }
    1412     if (z->n < vecLen) {
    1413         vecLen = z->n;
     1412    if (t->n < vecLen) {
     1413        vecLen = t->n;
    14141414    }
    14151415
    … …  
    14191419    // Evaluate polynomial
    14201420    for (psS32 i = 0; i < vecLen; i++) {
    1421         tmp->data.F32[i] = psPolynomial4DEval(myPoly,
    1422                                               w->data.F32[i],
     1421        tmp->data.F32[i] = psPolynomial4DEval(poly,
    14231422                                              x->data.F32[i],
    14241423                                              y->data.F32[i],
    1425                                               z->data.F32[i]);
     1424                                              z->data.F32[i],
     1425                                              t->data.F32[i]);
    14261426    }
    14271427
Note: See TracChangeset for help on using the changeset viewer.