IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 1723


Ignore:
Timestamp:
Sep 7, 2004, 8:23:16 PM (22 years ago)
Author:
gusciora
Message:

...

Location:
trunk/psLib/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/dataManip/psFunctions.c

    r1719 r1723  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-09-08 06:01:21 $
     9 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-09-08 06:23:16 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3636/* DEFINE STATEMENTS                                                         */
    3737/*****************************************************************************/
    38 
     38/*
     39 * The following macros take the vector IN as input.  If IN is not of
     40 * the correct type, then a new vector OUT is created of the correct
     41 * type, and the elements of IN and converted to OUT.
     42 *
     43 * If vector IN is the correct type, then OUT is simply set to IN.
     44 */
    3945#define PS_CONVERT_VECTOR_F32(IN, OUT) \
    4046if (IN->type.type != PS_TYPE_F32) { \
    … …  
    7682
    7783
    78 
    7984/*****************************************************************************/
    8085/* TYPE DEFINITIONS                                                          */
    … …  
    141146 Gaussian distribution as well.
    142147 
    143  NOTE: There is no way to seed the random generator.
     148 NOTE: XXX: There is no way to seed the random generator.
    144149 *****************************************************************************/
    145150psVector* psGaussianDev(float mean, float sigma, int Npts)
    … …  
    394399    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    395400 
    396     XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used
     401    XXX: Determine, from IfA, whether or not the "mask[]" terms should be used
    397402    in polynomial evaluation.  If so, then all of the following polynomial
    398403    evaluation functions must be modified to do so.
    … …  
    400405    XXX: Should the "coeffErr[]" should be used as well?
    401406 *****************************************************************************/
    402 float p_psOrgPolynomial1DEval(float x, const psPolynomial1D* myPoly)
     407float p_psOrdPolynomial1DEval(float x, const psPolynomial1D* myPoly)
    403408{
    404409    int loop_x = 0;
    … …  
    456461{
    457462    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    458         return(p_psOrgPolynomial1DEval(x, myPoly));
     463        return(p_psOrdPolynomial1DEval(x, myPoly));
    459464    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    460465        return(p_psChebPolynomial1DEval(x, myPoly));
    … …  
    486491
    487492
    488 float p_psOrgPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
     493float p_psOrdPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
    489494{
    490495    int loop_x = 0;
    … …  
    508513float p_psChebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
    509514{
     515    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     516    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    510517    return(0.0);
    511518}
    … …  
    514521{
    515522    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    516         return(p_psOrgPolynomial2DEval(x, y, myPoly));
     523        return(p_psOrdPolynomial2DEval(x, y, myPoly));
    517524    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    518525        return(p_psChebPolynomial2DEval(x, y, myPoly));
    … …  
    559566
    560567
    561 float p_psOrgPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
     568float p_psOrdPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
    562569{
    563570    int loop_x = 0;
    … …  
    587594float p_psChebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
    588595{
     596    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     597    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    589598    return(0.0);
    590599}
    … …  
    593602{
    594603    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    595         return(p_psOrgPolynomial3DEval(x, y, z, myPoly));
     604        return(p_psOrdPolynomial3DEval(x, y, z, myPoly));
    596605    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    597606        return(p_psChebPolynomial3DEval(x, y, z, myPoly));
    … …  
    650659
    651660
    652 float p_psOrgPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
     661float p_psOrdPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
    653662{
    654663    int loop_w = 0;
    … …  
    684693float p_psChebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
    685694{
     695    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     696    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    686697    return(0.0);
    687698}
    … …  
    690701{
    691702    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    692         return(p_psOrgPolynomial4DEval(w,x,y,z, myPoly));
     703        return(p_psOrdPolynomial4DEval(w,x,y,z, myPoly));
    693704    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    694705        return(p_psChebPolynomial4DEval(w,x,y,z, myPoly));
    … …  
    977988    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    978989 *****************************************************************************/
    979 double p_psDOrgPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
     990double p_psDOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
    980991{
    981992    int loop_x = 0;
    … …  
    9961007}
    9971008
     1009// XXX: You can do this without having to psAlloc() vector d.
    9981010double p_psDChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
    9991011{
    1000     return(0.0);
     1012    psVector *d;
     1013    int n;
     1014    int i;
     1015    double tmp;
     1016
     1017    n = myPoly->n;
     1018    d = psVectorAlloc(n, PS_TYPE_F64);
     1019    d->data.F64[n-1] = myPoly->coeff[n-1];
     1020    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]) + myPoly->coeff[n-2];
     1021    for (i=n-3;i>=1;i--) {
     1022        d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) -
     1023                         (d->data.F64[i+2]) +
     1024                         (myPoly->coeff[i]);
     1025    }
     1026
     1027    tmp = (x * d->data.F64[1]) -
     1028          (d->data.F64[2]) +
     1029          (0.5 * myPoly->coeff[0]);
     1030
     1031    psFree(d);
     1032    return(tmp);
    10011033}
    10021034
    … …  
    10041036{
    10051037    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1006         return(p_psDOrgPolynomial1DEval(x, myPoly));
     1038        return(p_psDOrdPolynomial1DEval(x, myPoly));
    10071039    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    10081040        return(p_psDChebPolynomial1DEval(x, myPoly));
    … …  
    10351067
    10361068
    1037 double p_psDOrgPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
     1069double p_psDOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
    10381070{
    10391071    int loop_x = 0;
    … …  
    10571089double p_psDChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
    10581090{
     1091    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1092    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    10591093    return(0.0);
    10601094}
    … …  
    10631097{
    10641098    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1065         return(p_psDOrgPolynomial2DEval(x, y, myPoly));
     1099        return(p_psDOrdPolynomial2DEval(x, y, myPoly));
    10661100    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    10671101        return(p_psDChebPolynomial2DEval(x, y, myPoly));
    … …  
    11071141
    11081142
    1109 double p_psDOrgPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
     1143double p_psDOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
    11101144{
    11111145    int loop_x = 0;
    … …  
    11351169double p_psDChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
    11361170{
     1171    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1172    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    11371173    return(0.0);
    11381174}
    … …  
    11411177{
    11421178    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1143         return(p_psDOrgPolynomial3DEval(x, y, z, myPoly));
     1179        return(p_psDOrdPolynomial3DEval(x, y, z, myPoly));
    11441180    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    11451181        return(p_psDChebPolynomial3DEval(x, y, z, myPoly));
    … …  
    12001236
    12011237
    1202 double p_psDOrgPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
     1238double p_psDOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
    12031239{
    12041240    int loop_w = 0;
    … …  
    12341270double p_psDChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
    12351271{
     1272    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1273    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    12361274    return(0.0);
    12371275}
    … …  
    12401278{
    12411279    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1242         return(p_psDOrgPolynomial4DEval(w,x,y,z, myPoly));
     1280        return(p_psDOrdPolynomial4DEval(w,x,y,z, myPoly));
    12431281    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    12441282        return(p_psDChebPolynomial4DEval(w,x,y,z, myPoly));

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

    r1719 r1723  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-09-08 06:01:21 $
     9 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-09-08 06:23:16 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3636/* DEFINE STATEMENTS                                                         */
    3737/*****************************************************************************/
    38 
     38/*
     39 * The following macros take the vector IN as input.  If IN is not of
     40 * the correct type, then a new vector OUT is created of the correct
     41 * type, and the elements of IN and converted to OUT.
     42 *
     43 * If vector IN is the correct type, then OUT is simply set to IN.
     44 */
    3945#define PS_CONVERT_VECTOR_F32(IN, OUT) \
    4046if (IN->type.type != PS_TYPE_F32) { \
    … …  
    7682
    7783
    78 
    7984/*****************************************************************************/
    8085/* TYPE DEFINITIONS                                                          */
    … …  
    141146 Gaussian distribution as well.
    142147 
    143  NOTE: There is no way to seed the random generator.
     148 NOTE: XXX: There is no way to seed the random generator.
    144149 *****************************************************************************/
    145150psVector* psGaussianDev(float mean, float sigma, int Npts)
    … …  
    394399    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    395400 
    396     XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used
     401    XXX: Determine, from IfA, whether or not the "mask[]" terms should be used
    397402    in polynomial evaluation.  If so, then all of the following polynomial
    398403    evaluation functions must be modified to do so.
    … …  
    400405    XXX: Should the "coeffErr[]" should be used as well?
    401406 *****************************************************************************/
    402 float p_psOrgPolynomial1DEval(float x, const psPolynomial1D* myPoly)
     407float p_psOrdPolynomial1DEval(float x, const psPolynomial1D* myPoly)
    403408{
    404409    int loop_x = 0;
    … …  
    456461{
    457462    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    458         return(p_psOrgPolynomial1DEval(x, myPoly));
     463        return(p_psOrdPolynomial1DEval(x, myPoly));
    459464    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    460465        return(p_psChebPolynomial1DEval(x, myPoly));
    … …  
    486491
    487492
    488 float p_psOrgPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
     493float p_psOrdPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
    489494{
    490495    int loop_x = 0;
    … …  
    508513float p_psChebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
    509514{
     515    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     516    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    510517    return(0.0);
    511518}
    … …  
    514521{
    515522    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    516         return(p_psOrgPolynomial2DEval(x, y, myPoly));
     523        return(p_psOrdPolynomial2DEval(x, y, myPoly));
    517524    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    518525        return(p_psChebPolynomial2DEval(x, y, myPoly));
    … …  
    559566
    560567
    561 float p_psOrgPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
     568float p_psOrdPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
    562569{
    563570    int loop_x = 0;
    … …  
    587594float p_psChebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
    588595{
     596    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     597    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    589598    return(0.0);
    590599}
    … …  
    593602{
    594603    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    595         return(p_psOrgPolynomial3DEval(x, y, z, myPoly));
     604        return(p_psOrdPolynomial3DEval(x, y, z, myPoly));
    596605    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    597606        return(p_psChebPolynomial3DEval(x, y, z, myPoly));
    … …  
    650659
    651660
    652 float p_psOrgPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
     661float p_psOrdPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
    653662{
    654663    int loop_w = 0;
    … …  
    684693float p_psChebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
    685694{
     695    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     696    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    686697    return(0.0);
    687698}
    … …  
    690701{
    691702    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    692         return(p_psOrgPolynomial4DEval(w,x,y,z, myPoly));
     703        return(p_psOrdPolynomial4DEval(w,x,y,z, myPoly));
    693704    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    694705        return(p_psChebPolynomial4DEval(w,x,y,z, myPoly));
    … …  
    977988    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    978989 *****************************************************************************/
    979 double p_psDOrgPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
     990double p_psDOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
    980991{
    981992    int loop_x = 0;
    … …  
    9961007}
    9971008
     1009// XXX: You can do this without having to psAlloc() vector d.
    9981010double p_psDChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
    9991011{
    1000     return(0.0);
     1012    psVector *d;
     1013    int n;
     1014    int i;
     1015    double tmp;
     1016
     1017    n = myPoly->n;
     1018    d = psVectorAlloc(n, PS_TYPE_F64);
     1019    d->data.F64[n-1] = myPoly->coeff[n-1];
     1020    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]) + myPoly->coeff[n-2];
     1021    for (i=n-3;i>=1;i--) {
     1022        d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) -
     1023                         (d->data.F64[i+2]) +
     1024                         (myPoly->coeff[i]);
     1025    }
     1026
     1027    tmp = (x * d->data.F64[1]) -
     1028          (d->data.F64[2]) +
     1029          (0.5 * myPoly->coeff[0]);
     1030
     1031    psFree(d);
     1032    return(tmp);
    10011033}
    10021034
    … …  
    10041036{
    10051037    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1006         return(p_psDOrgPolynomial1DEval(x, myPoly));
     1038        return(p_psDOrdPolynomial1DEval(x, myPoly));
    10071039    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    10081040        return(p_psDChebPolynomial1DEval(x, myPoly));
    … …  
    10351067
    10361068
    1037 double p_psDOrgPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
     1069double p_psDOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
    10381070{
    10391071    int loop_x = 0;
    … …  
    10571089double p_psDChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
    10581090{
     1091    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1092    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    10591093    return(0.0);
    10601094}
    … …  
    10631097{
    10641098    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1065         return(p_psDOrgPolynomial2DEval(x, y, myPoly));
     1099        return(p_psDOrdPolynomial2DEval(x, y, myPoly));
    10661100    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    10671101        return(p_psDChebPolynomial2DEval(x, y, myPoly));
    … …  
    11071141
    11081142
    1109 double p_psDOrgPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
     1143double p_psDOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
    11101144{
    11111145    int loop_x = 0;
    … …  
    11351169double p_psDChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
    11361170{
     1171    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1172    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    11371173    return(0.0);
    11381174}
    … …  
    11411177{
    11421178    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1143         return(p_psDOrgPolynomial3DEval(x, y, z, myPoly));
     1179        return(p_psDOrdPolynomial3DEval(x, y, z, myPoly));
    11441180    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    11451181        return(p_psDChebPolynomial3DEval(x, y, z, myPoly));
    … …  
    12001236
    12011237
    1202 double p_psDOrgPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
     1238double p_psDOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
    12031239{
    12041240    int loop_w = 0;
    … …  
    12341270double p_psDChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
    12351271{
     1272    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1273    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    12361274    return(0.0);
    12371275}
    … …  
    12401278{
    12411279    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1242         return(p_psDOrgPolynomial4DEval(w,x,y,z, myPoly));
     1280        return(p_psDOrdPolynomial4DEval(w,x,y,z, myPoly));
    12431281    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    12441282        return(p_psDChebPolynomial4DEval(w,x,y,z, myPoly));

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

    r1719 r1723  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-09-08 06:01:21 $
     9 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-09-08 06:23:16 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3636/* DEFINE STATEMENTS                                                         */
    3737/*****************************************************************************/
    38 
     38/*
     39 * The following macros take the vector IN as input.  If IN is not of
     40 * the correct type, then a new vector OUT is created of the correct
     41 * type, and the elements of IN and converted to OUT.
     42 *
     43 * If vector IN is the correct type, then OUT is simply set to IN.
     44 */
    3945#define PS_CONVERT_VECTOR_F32(IN, OUT) \
    4046if (IN->type.type != PS_TYPE_F32) { \
    … …  
    7682
    7783
    78 
    7984/*****************************************************************************/
    8085/* TYPE DEFINITIONS                                                          */
    … …  
    141146 Gaussian distribution as well.
    142147 
    143  NOTE: There is no way to seed the random generator.
     148 NOTE: XXX: There is no way to seed the random generator.
    144149 *****************************************************************************/
    145150psVector* psGaussianDev(float mean, float sigma, int Npts)
    … …  
    394399    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    395400 
    396     XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used
     401    XXX: Determine, from IfA, whether or not the "mask[]" terms should be used
    397402    in polynomial evaluation.  If so, then all of the following polynomial
    398403    evaluation functions must be modified to do so.
    … …  
    400405    XXX: Should the "coeffErr[]" should be used as well?
    401406 *****************************************************************************/
    402 float p_psOrgPolynomial1DEval(float x, const psPolynomial1D* myPoly)
     407float p_psOrdPolynomial1DEval(float x, const psPolynomial1D* myPoly)
    403408{
    404409    int loop_x = 0;
    … …  
    456461{
    457462    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    458         return(p_psOrgPolynomial1DEval(x, myPoly));
     463        return(p_psOrdPolynomial1DEval(x, myPoly));
    459464    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    460465        return(p_psChebPolynomial1DEval(x, myPoly));
    … …  
    486491
    487492
    488 float p_psOrgPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
     493float p_psOrdPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
    489494{
    490495    int loop_x = 0;
    … …  
    508513float p_psChebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
    509514{
     515    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     516    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    510517    return(0.0);
    511518}
    … …  
    514521{
    515522    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    516         return(p_psOrgPolynomial2DEval(x, y, myPoly));
     523        return(p_psOrdPolynomial2DEval(x, y, myPoly));
    517524    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    518525        return(p_psChebPolynomial2DEval(x, y, myPoly));
    … …  
    559566
    560567
    561 float p_psOrgPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
     568float p_psOrdPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
    562569{
    563570    int loop_x = 0;
    … …  
    587594float p_psChebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
    588595{
     596    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     597    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    589598    return(0.0);
    590599}
    … …  
    593602{
    594603    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    595         return(p_psOrgPolynomial3DEval(x, y, z, myPoly));
     604        return(p_psOrdPolynomial3DEval(x, y, z, myPoly));
    596605    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    597606        return(p_psChebPolynomial3DEval(x, y, z, myPoly));
    … …  
    650659
    651660
    652 float p_psOrgPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
     661float p_psOrdPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
    653662{
    654663    int loop_w = 0;
    … …  
    684693float p_psChebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
    685694{
     695    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     696    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    686697    return(0.0);
    687698}
    … …  
    690701{
    691702    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    692         return(p_psOrgPolynomial4DEval(w,x,y,z, myPoly));
     703        return(p_psOrdPolynomial4DEval(w,x,y,z, myPoly));
    693704    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    694705        return(p_psChebPolynomial4DEval(w,x,y,z, myPoly));
    … …  
    977988    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    978989 *****************************************************************************/
    979 double p_psDOrgPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
     990double p_psDOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
    980991{
    981992    int loop_x = 0;
    … …  
    9961007}
    9971008
     1009// XXX: You can do this without having to psAlloc() vector d.
    9981010double p_psDChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
    9991011{
    1000     return(0.0);
     1012    psVector *d;
     1013    int n;
     1014    int i;
     1015    double tmp;
     1016
     1017    n = myPoly->n;
     1018    d = psVectorAlloc(n, PS_TYPE_F64);
     1019    d->data.F64[n-1] = myPoly->coeff[n-1];
     1020    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]) + myPoly->coeff[n-2];
     1021    for (i=n-3;i>=1;i--) {
     1022        d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) -
     1023                         (d->data.F64[i+2]) +
     1024                         (myPoly->coeff[i]);
     1025    }
     1026
     1027    tmp = (x * d->data.F64[1]) -
     1028          (d->data.F64[2]) +
     1029          (0.5 * myPoly->coeff[0]);
     1030
     1031    psFree(d);
     1032    return(tmp);
    10011033}
    10021034
    … …  
    10041036{
    10051037    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1006         return(p_psDOrgPolynomial1DEval(x, myPoly));
     1038        return(p_psDOrdPolynomial1DEval(x, myPoly));
    10071039    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    10081040        return(p_psDChebPolynomial1DEval(x, myPoly));
    … …  
    10351067
    10361068
    1037 double p_psDOrgPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
     1069double p_psDOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
    10381070{
    10391071    int loop_x = 0;
    … …  
    10571089double p_psDChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
    10581090{
     1091    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1092    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    10591093    return(0.0);
    10601094}
    … …  
    10631097{
    10641098    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1065         return(p_psDOrgPolynomial2DEval(x, y, myPoly));
     1099        return(p_psDOrdPolynomial2DEval(x, y, myPoly));
    10661100    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    10671101        return(p_psDChebPolynomial2DEval(x, y, myPoly));
    … …  
    11071141
    11081142
    1109 double p_psDOrgPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
     1143double p_psDOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
    11101144{
    11111145    int loop_x = 0;
    … …  
    11351169double p_psDChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
    11361170{
     1171    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1172    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    11371173    return(0.0);
    11381174}
    … …  
    11411177{
    11421178    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1143         return(p_psDOrgPolynomial3DEval(x, y, z, myPoly));
     1179        return(p_psDOrdPolynomial3DEval(x, y, z, myPoly));
    11441180    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    11451181        return(p_psDChebPolynomial3DEval(x, y, z, myPoly));
    … …  
    12001236
    12011237
    1202 double p_psDOrgPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
     1238double p_psDOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
    12031239{
    12041240    int loop_w = 0;
    … …  
    12341270double p_psDChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
    12351271{
     1272    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
     1273    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
    12361274    return(0.0);
    12371275}
    … …  
    12401278{
    12411279    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    1242         return(p_psDOrgPolynomial4DEval(w,x,y,z, myPoly));
     1280        return(p_psDOrdPolynomial4DEval(w,x,y,z, myPoly));
    12431281    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    12441282        return(p_psDChebPolynomial4DEval(w,x,y,z, myPoly));
Note: See TracChangeset for help on using the changeset viewer.