Changeset 7675


Ignore:
Timestamp:
03/25/11 20:25:53 (9 years ago)
Author:
aivar
Message:

Got rid of the global old_chisquare, it's passed in as a parameter now. Some test code, commented out, bails out if the delta params go to zero. This gives about a 10% boost in performance. At least, in this case, we should avoid making new alpha and beta matrices.

Location:
trunk/projects/slim-curve/src/main/c
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-curve/src/main/c/EcfGlobal.c

    r7611 r7675  
    32453245////                                    yfit[i], dy[i], alpha_scratch, beta_scratch, 
    32463246                                        yfit[0], dy[0], alpha_scratch, beta_scratch, 
    3247                                         &chisq_trans[i], (i == 0) ? alambda : 0.0, 
     3247                                        &chisq_trans[i], 0.0f, (i == 0) ? alambda : 0.0, //TODO ARG added 0.0f here for new old_chisq parameter 
    32483248                                        pfnvals, pdy_dparam_pure, pdy_dparam_conv, 
    32493249                                        pfnvals_len, pdy_dparam_nparam_size); 
  • trunk/projects/slim-curve/src/main/c/EcfInternal.h

    r7387 r7675  
    3333                                   void (*fitfunc)(float, float [], float *, float [], int), 
    3434                                   float yfit[], float dy[], 
    35                                    float **alpha, float beta[], float *chisq, 
     35                                   float **alpha, float beta[], float *chisq, float old_chisq, 
    3636                                   float alambda,        
    3737                                        float **pfnvals, float ***pdy_dparam_pure, float ***pdy_dparam_conv, 
  • trunk/projects/slim-curve/src/main/c/EcfSingle.c

    r7606 r7675  
    2727 
    2828/* Globals */ 
    29 static float global_chisq = 0.0f; 
    3029//static float *fnvals, **dy_dparam_pure, **dy_dparam_conv; 
    3130//static int fnvals_len=0, dy_dparam_nparam_size=0; 
     
    654653                        if (paramfree[j]) 
    655654                                (*pmfit)++; 
    656     global_chisq = 0.0f; 
     655 
    657656                if (GCI_marquardt_compute_fn_instr(xincr, y, ndata, fit_start, fit_end, 
    658657                                                                                   instr, ninstr, noise, sig, 
    659658                                                                                   param, paramfree, nparam, fitfunc, 
    660                                                                                    yfit, dy, alpha, beta, chisq, 
     659                                                                                   yfit, dy, alpha, beta, chisq, 0.0, 
    661660                                                                                   *alambda,     
    662661                                                                                        pfnvals, pdy_dparam_pure, pdy_dparam_conv, 
     
    705704        } 
    706705 
    707         /* Did the trial succeed? */ 
     706        /* Did the trial succeed? * 
     707        int allzeroes = 1; 
    708708        for (j=0, l=0; l<nparam; l++) 
    709                 if (paramfree[l]) 
     709                if (paramfree[l]) { 
     710//TODO I don't think it ever recovers if all dparams are zero; alambda grows and grows, goes from int to inf!! 
     711// could be an early way to detect we're done. 
     712// at least, if delta params is all zeroes, there is no point in calculating a new alpha and beta. 
     713//                    printf("paramtry[%d] was %f becomes %f, param[%d] or %f plus dparam[%d] or %f\n", l, paramtry[l], param[l] + dparam[j], l, param[l], j, dparam[j]); 
     714                    if (dparam[j] != 0.0) allzeroes = 0; 
    710715                        paramtry[l] = param[l] + dparam[j++]; 
     716} 
     717     //TODO experimental: 
     718     //  gave about a 10% speedup 
     719        if (allzeroes) return -12345; */ 
    711720 
    712721        if (restrain == ECF_RESTRAIN_DEFAULT) 
     
    720729                return 0; 
    721730        } 
    722     global_chisq = *pochisq; //TODO this is a cheap mechanism to "pass in" the original chisq by using a global variable; seems to be a valid optimization, within this function don't setup matrices if chisq is not an improvment 
    723731        if (GCI_marquardt_compute_fn_instr(xincr, y, ndata, fit_start, fit_end, 
    724732                                                                           instr, ninstr, noise, sig, 
    725733                                                                           paramtry, paramfree, nparam, fitfunc, 
    726734                                                                           yfit, dy, covar, dparam, 
    727                                                                            chisq, *alambda,      
     735                                                                           chisq, *pochisq, *alambda, 
    728736                                                                           pfnvals, pdy_dparam_pure, pdy_dparam_conv, 
    729737                                                                           pfnvals_len, pdy_dparam_nparam_size) != 0) { 
     
    733741        /* Success, accept the new solution */ 
    734742        if (*chisq < *pochisq) { 
     743//            printf("success, alambda goes from %f to %f\n", *alambda, (*alambda)*0.1); 
    735744                *alambda *= 0.1; 
    736745                *pochisq = *chisq; 
     
    743752                        param[l] = paramtry[l]; 
    744753        } else { /* Failure, increase alambda and return */ 
     754//TODO if alambda goes to inf, can we recover? 
     755//            printf("failure, alambda goes from %f to %f\n", *alambda, (*alambda)*10.0); 
    745756                *alambda *= 10.0; 
    746757                *chisq = *pochisq; 
     
    789800                                   void (*fitfunc)(float, float [], float *, float [], int), 
    790801                                   float yfit[], float dy[], 
    791                                    float **alpha, float beta[], float *chisq, 
     802                                   float **alpha, float beta[], float *chisq, float old_chisq, 
    792803                                   float alambda, 
    793804                                        float **pfnvals, float ***pdy_dparam_pure, float ***pdy_dparam_conv, 
     
    10421053 
    10431054        // Check if chi square worsened: 
    1044         if (0.0f != global_chisq && *chisq >= global_chisq) { //TODO pass in the old chi square as a parameter 
     1055        if (0.0f != old_chisq && *chisq >= old_chisq) { 
    10451056            // don't bother to set up the matrices for solution 
    10461057            return 0; 
     
    10851096                ++i_free; 
    10861097            } 
     1098            //else printf("param not free %d\n", i); 
    10871099        } // i loop 
     1100 
     1101 /*       printf("i_free is %d j_free %d\n", i_free, j_free); 
     1102        //TODO try padding with zeroes; leftovers would affect AX=B solution 
     1103        for (i = i_free; i < nparam; ++i) { 
     1104            for (j = 0; j < nparam; ++j) { 
     1105                alpha[i][j] = alpha[j][i] = 0.0f; 
     1106            } 
     1107            beta[i] = 0.0f; 
     1108        }*/ 
     1109 
    10881110        } 
    10891111        return 0; 
Note: See TracChangeset for help on using the changeset viewer.