Real AnalyticBarrierEngine::B(Real phi) const { Real x2 = std::log(underlying()/barrier())/stdDeviation() + muSigma(); Real N1 = f_(phi*x2); Real N2 = f_(phi*(x2-stdDeviation())); return phi*(underlying() * dividendDiscount() * N1 - strike() * riskFreeDiscount() * N2); }
Real AnalyticBarrierEngine::D(Real eta, Real phi) const { Real HS = barrier()/underlying(); Real powHS0 = std::pow(HS, 2 * mu()); Real powHS1 = powHS0 * HS * HS; Real y2 = std::log(barrier()/underlying())/stdDeviation() + muSigma(); Real N1 = f_(eta*y2); Real N2 = f_(eta*(y2-stdDeviation())); return phi*(underlying() * dividendDiscount() * powHS1 * N1 - strike() * riskFreeDiscount() * powHS0 * N2); }
Real AnalyticBarrierEngine::E(Real eta) const { if (rebate() > 0) { Real powHS0 = std::pow(barrier()/underlying(), 2 * mu()); Real x2 = std::log(underlying()/barrier())/stdDeviation() + muSigma(); Real y2 = std::log(barrier()/underlying())/stdDeviation() + muSigma(); Real N1 = f_(eta*(x2 - stdDeviation())); Real N2 = f_(eta*(y2 - stdDeviation())); return rebate() * riskFreeDiscount() * (N1 - powHS0 * N2); } else { return 0.0; } }
Real AnalyticContinuousFloatingLookbackEngine::A(Real eta) const { Volatility vol = volatility(); Real lambda = 2.0*(riskFreeRate() - dividendYield())/(vol*vol); Real s = underlying()/minmax(); Real d1 = std::log(s)/stdDeviation() + 0.5*(lambda+1.0)*stdDeviation(); Real n1 = f_(eta*d1); Real n2 = f_(eta*(d1-stdDeviation())); Real n3 = f_(eta*(-d1+lambda*stdDeviation())); Real n4 = f_(eta*-d1); Real pow_s = std::pow(s, -lambda); return eta*((underlying() * dividendDiscount() * n1 - minmax() * riskFreeDiscount() * n2) + (underlying() * riskFreeDiscount() * (pow_s * n3 - dividendDiscount()* n4/riskFreeDiscount())/ lambda)); }
int main(int argc, char** argv){ initializeBoard(); initializeUSB1208(); int k=0,i=1,nSamples=16; float angle; float* measurement=calloc(sizeof(float),nSamples); float* involts=calloc(sizeof(float),NUMCHANNELS); printf(" VERT VERTsd | HORIZ HORIZsd | REF REFsd | Approx Angle\n"); for(k=1;k<NUMCHANNELS+1;k++){ for (i=0;i<nSamples;i++){ getUSB1208AnalogIn(k,&measurement[i]); involts[k-1]=involts[k-1]+measurement[i]; delay(10); } involts[k-1]=fabs(involts[k-1])/(float)nSamples; printf(" %0.4f %0.4f ",involts[k-1],stdDeviation(measurement,nSamples)); if(k<NUMCHANNELS) printf(" | "); } printf("\t"); angle=atan(sqrt(involts[0]/involts[1])); printf("%0.3f",angle); printf("\n"); return 0; }
inline Disposable<Matrix> StochasticProcess1D::stdDeviation( Time t0, const Array& x0, Time dt) const { #if defined(QL_EXTRA_SAFETY_CHECKS) QL_REQUIRE(x0.size() == 1, "1-D array required"); #endif Matrix m(1, 1, stdDeviation(t0, x0[0], dt)); return m; }
float collectDiscreteFourierData(FILE* fp, int* photoDetector, int numPhotoDetectors,int motor, int revolutions) { float sumSin=0; float sumCos=0; int count=0; int steps,i,j,k; float angle; float laserAngle=-100; int nSamples=16; float* measurement = malloc(nSamples*sizeof(float)); float* involts = calloc(numPhotoDetectors,sizeof(float)); float* stdDev = calloc(numPhotoDetectors,sizeof(float)); for (k=0;k<revolutions;k++){ //revolutions for (steps=0;steps < STEPSPERREV;steps+=(int)STEPSIZE){ // steps // (STEPSPERREV) in increments of STEPSIZE delay(300); // watching the o-scope, it looks like it takes ~100ms for the ammeter to settle after a change in LP. UPDATE: with the Lock-in at a time scale of 100 ms, it takes 500 ms to settle. // With time scale of 30 ms, takes 300 ms to settle. //get samples and average for(j=0;j<numPhotoDetectors;j++){ // numPhotoDet1 involts[j]=0.0; for (i=0;i<nSamples;i++){ // nSamples getUSB1208AnalogIn(photoDetector[j],&measurement[i]); involts[j]=involts[j]+fabs(measurement[i]); delay(WAITTIME); } // nSamples involts[j]=involts[j]/(float)nSamples; stdDev[j]=stdDeviation(measurement,nSamples); } // numPhotoDet1 fprintf(fp,"%d\t",steps+(int)STEPSPERREV*k); for(j=0;j<numPhotoDetectors;j++){ if(j!=numPhotoDetectors-1) fprintf(fp,"%f\t%f\t",involts[j],stdDev[j]); else fprintf(fp,"%f\t%f\n",involts[j],stdDev[j]); } angle=2.0*PI*(steps)/STEPSPERREV; sumSin+=involts[1]*sin(2*angle); sumCos+=involts[1]*cos(2*angle); count++; stepMotor(motor,CLK,(int)STEPSIZE); } // steps laserAngle=180/PI*0.5*atan2(sumCos,sumSin); } // revolutions free(measurement); free(stdDev); free(involts); return laserAngle; }
Real AnalyticDoubleBarrierEngine::callKO() const { // N.B. for flat barriers mu3=mu1 and mu2=0 Real mu1 = 2 * costOfCarry() / volatilitySquared() + 1; Real bsigma = (costOfCarry() + volatilitySquared() / 2.0) * residualTime() / stdDeviation(); Real acc1 = 0; Real acc2 = 0; for (int n = -series_ ; n <= series_ ; ++n) { Real L2n = std::pow(barrierLo(), 2 * n); Real U2n = std::pow(barrierHi(), 2 * n); Real d1 = std::log( underlying()* U2n / (strike() * L2n) ) / stdDeviation() + bsigma; Real d2 = std::log( underlying()* U2n / (barrierHi() * L2n) ) / stdDeviation() + bsigma; Real d3 = std::log( std::pow(barrierLo(), 2 * n + 2) / (strike() * underlying() * U2n) ) / stdDeviation() + bsigma; Real d4 = std::log( std::pow(barrierLo(), 2 * n + 2) / (barrierHi() * underlying() * U2n) ) / stdDeviation() + bsigma; acc1 += std::pow( std::pow(barrierHi(), n) / std::pow(barrierLo(), n), mu1 ) * (f_(d1) - f_(d2)) - std::pow( std::pow(barrierLo(), n+1) / (std::pow(barrierHi(), n) * underlying()), mu1 ) * (f_(d3) - f_(d4)); acc2 += std::pow( std::pow(barrierHi(), n) / std::pow(barrierLo(), n), mu1-2) * (f_(d1 - stdDeviation()) - f_(d2 - stdDeviation())) - std::pow( std::pow(barrierLo(), n+1) / (std::pow(barrierHi(), n) * underlying()), mu1-2 ) * (f_(d3-stdDeviation()) - f_(d4-stdDeviation())); } Real rend = std::exp(-dividendYield() * residualTime()); Real kov = underlying() * rend * acc1 - strike() * riskFreeDiscount() * acc2; return std::max(0.0, kov); }
Real AnalyticDoubleBarrierEngine::vanillaEquivalent() const { // Call KI equates to vanilla - callKO boost::shared_ptr<StrikedTypePayoff> payoff = boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff); Real forwardPrice = underlying() * dividendDiscount() / riskFreeDiscount(); BlackCalculator black(payoff, forwardPrice, stdDeviation(), riskFreeDiscount()); Real vanilla = black.value(); if (vanilla < 0.0) vanilla = 0.0; return vanilla; }
inline const Real GeneralizedJcirProcess<__URng_Poisson_Type, __URng_Exp_Type>::evolve(Time t0, Real x0, Time dt, Real dw) const { Real xContinuous, totalJump = 0.; xContinuous = apply(expectation(t0, x0, dt), stdDeviation(t0, x0, dt)*dw); InverseCumulativePoisson invP(jumpIntensity_*dt); int Pt = (int)invP(URng_Poisson_.next().value); for (int i = 0; i < Pt; ++i) { totalJump += -mean*std::log(1 - URng_Exp_.next().value); } return apply(xContinuous, totalJump); }
Real GeneralizedBlackScholesProcess::evolve(Time t0, Real x0, Time dt, Real dw) const { localVolatility(); // trigger update if (isStrikeIndependent_ && !forceDiscretization_) { // exact value for curves Real var = variance(t0, x0, dt); Real drift = (riskFreeRate_->forwardRate(t0, t0 + dt, Continuous, NoFrequency, true) - dividendYield_->forwardRate(t0, t0 + dt, Continuous, NoFrequency, true)) * dt - 0.5 * var; return apply(x0, std::sqrt(var) * dw + drift); } else return apply(x0, discretization_->drift(*this, t0, x0, dt) + stdDeviation(t0, x0, dt) * dw); }
void collectDiscreteFourierData(FILE* fp, int* photoDetector, int numPhotoDetectors,int motor, int revolutions) { int count=0; int steps,i,j,k; int nSamples=16; float* measurement = malloc(nSamples*sizeof(float)); float* involts = calloc(numPhotoDetectors,sizeof(float)); float* stdDev = calloc(numPhotoDetectors,sizeof(float)); for (k=0;k<revolutions;k++){ //revolutions for (steps=0;steps < NUMSTEPS;steps+=STEPSIZE){ // steps // (NUMSTEPS) in increments of STEPSIZE delay(150); // watching the o-scope, it looks like it takes ~100ms for the ammeter to settle after a change in LP //get samples and average for(j=0;j<numPhotoDetectors;j++){ // numPhotoDet1 involts[j]=0.0; for (i=0;i<nSamples;i++){ // nSamples getMCPAnalogIn(photoDetector[j],&measurement[i]); involts[j]=involts[j]+measurement[i]; delay(WAITTIME); } // nSamples involts[j]=involts[j]/(float)nSamples; stdDev[j]=stdDeviation(measurement,nSamples); } // numPhotoDet1 fprintf(fp,"%d\t",steps+NUMSTEPS*k); for(j=0;j<numPhotoDetectors;j++){ if(j!=numPhotoDetectors-1) fprintf(fp,"%f\t%f\t",involts[j],stdDev[j]); else fprintf(fp,"%f\t%f\n",involts[j],stdDev[j]); } count++; stepMotor(motor,CLK,STEPSIZE); } // steps } // revolutions free(measurement); free(stdDev); free(involts); }
Real AnalyticBarrierEngine::F(Real eta) const { if (rebate() > 0) { Rate m = mu(); Volatility vol = volatility(); Real lambda = std::sqrt(m*m + 2.0*riskFreeRate()/(vol * vol)); Real HS = barrier()/underlying(); Real powHSplus = std::pow(HS, m + lambda); Real powHSminus = std::pow(HS, m - lambda); Real sigmaSqrtT = stdDeviation(); Real z = std::log(barrier()/underlying())/sigmaSqrtT + lambda * sigmaSqrtT; Real N1 = f_(eta * z); Real N2 = f_(eta * (z - 2.0 * lambda * sigmaSqrtT)); return rebate() * (powHSplus * N1 + powHSminus * N2); } else { return 0.0; } }
/* * Output statistical properties to file */ void Average::output(std::ostream& out) { // Find first stage (descending) with nSample >= 16 AverageStage* ptr = 0; int n = descendants_.size(); int i = n; int nSample = 1; while (nSample < 16 && i > 0) { --i; ptr = descendants_[i]; nSample = ptr->nSample(); } double error = ptr->error(); double sigma = error/sqrt(2.0*double(nSample-1)); double weight = 1.0/(sigma*sigma); double sum = error*weight; double norm = weight; double aveErr = error; double oldSig; // Find weighted average within plateau bool next = true; while (next && i > 0) { oldSig = sigma; --i; ptr = descendants_[i]; error = ptr->error(); if (fabs(error - aveErr) < 2.0*oldSig) { nSample = ptr->nSample(); sigma = error/sqrt(2.0*double(nSample-1)); weight = 1.0/(sigma*sigma); sum += error*weight; norm += weight; aveErr = sum/norm; } else { next = false; } } out << "Average " << Dbl(average()) << " +- " << Dbl(aveErr, 9, 2) << std::endl; out << "Variance " << Dbl(variance()) << std::endl; out << "Std Dev " << Dbl(stdDeviation()) << std::endl; out << std::endl; out << "Hierarchichal Error Analysis:" << std::endl; int interval; for (int i = 0; i < n; ++i) { ptr = descendants_[i]; error = ptr->error(); nSample = ptr->nSample(); interval = ptr->stageInterval(); if (nSample >= 16) { out << Int(i) << Int(interval) << Dbl(error) << Dbl(error/sqrt(double(nSample))) << Int(nSample) << std::endl; } } out << std::endl; }
inline void Evaluation::generateOutput() { cv::FileStorage storage; cv::Mat_<float> output; int nLabels = this->labelsName.size(); output.release(); output.create(cv::Size(9, nLabels)); //4 = TP, FP, FN, TN, precision, recall, specificity, accuracy per class, balanced accuracy per class output = 0; float precision, recall, specificity; std::map<int, std::vector<float>> TPScores, FPScores, FNScores, TNScores; //first = class, second = scores //Create output file storage.open("output.yml", cv::FileStorage::WRITE); if (storage.isOpened() == false) std::cerr << "Invalid file storage!" << std::endl; storage << "ClassificationOutput" << "{"; // TP - True Positive for (int tp = 0; tp < nLabels; tp++) { output[tp][0] = this->confusionMat[tp][tp]; for (int score = 0; score < this->confusionMatScores[tp][tp].size(); score++) TPScores[tp].push_back(this->confusionMatScores[tp][tp].at(score)); } // FP - False Positive for (int col = 0; col < nLabels; col++) { for (int row = 0; row < nLabels; row++) { output[col][1] += this->confusionMat[row][col]; if (col != row) for (int score = 0; score < this->confusionMatScores[row][col].size(); score++) FPScores[col].push_back(this->confusionMatScores[row][col].at(score)); } output[col][1] -= output[col][0]; } // FN - False Negative for (int row = 0; row < nLabels; row++) { for (int col = 0; col < nLabels; col++) { output[row][2] += this->confusionMat[row][col]; if (col != row) for (int score = 0; score < this->confusionMatScores[row][col].size(); score++) FNScores[row].push_back(this->confusionMatScores[row][col].at(score)); } output[row][2] -= output[row][0]; } // TN - True Negative cv::Scalar sum = cv::sum(this->confusionMat); for (int tn = 0; tn < nLabels; tn++) output[tn][3] = sum[0] - output[tn][0] - output[tn][1] - output[tn][2]; for (int l = 0; l < nLabels; l++) { precision = output[l][0] / (output[l][0] + output[l][1]); output[l][4] = precision; recall = output[l][0] / (output[l][0] + output[l][2]); output[l][5] = recall; specificity = output[l][3] / (output[l][3] + output[l][1]); output[l][6] = specificity; output[l][7] = (output[l][0] + output[l][3]) / (output[l][0] + output[l][1] + output[l][2] + output[l][3]); //accuracy per class output[l][8] = balancedAccuracy(output[l][0], output[l][1], output[l][2], output[l][3]); //balanced accuracy per class } float *ap = new float[nLabels]; for (int label = 0; label < nLabels; label++) ap[label] = averagePrecision(label, output[label][0], output[label][2], TPScores, FPScores); double meanAP = std::accumulate(ap, ap + nLabels, 0.0f); double meanACC = meanAccuracy(output.col(7)); double stdDev = stdDeviation(output.col(7), meanACC); double meanBalACC = meanAccuracy(output.col(8)); double stdDevBal = stdDeviation(output.col(8), meanBalACC); storage << "MeanBalancedAccuracy" << meanBalACC; storage << "StandardDeviationBalACC" << stdDevBal; //storage << "MeanAccuracy" << meanACC; // Removed because we are using balanced accuracy //storage << "StandardDeviationACC" << stdDev; // Removed because we are using balanced accuracy storage << "MeanAveragePrecision" << meanAP; for (int label = 0; label < nLabels; label++) { std::stringstream classLabel; classLabel << "Class" << label; storage << classLabel.str() << "{"; storage << "Label" << this->labelsName[label]; storage << "TP" << output[label][0]; storage << "FP" << output[label][1]; storage << "FN" << output[label][2]; storage << "TN" << output[label][3]; storage << "precision" << output[label][4]; storage << "recall" << output[label][5]; storage << "specificity" << output[label][6]; //storage << "accPerClass" << output[label][7]; // Removed because we are using balanced accuracy storage << "accBalPerClass" << output[label][8]; storage << "apPerClass" << ap[label]; storage << "}"; } storage.release(); delete ap; }
Real VarianceGammaProcess::evolve(Time t0, Real x0, Time dt, Real dg, Real dw) const { Real drift = discretization_->drift(*this,t0,x0,dt); X0_ += theta() * dg + stdDeviation(t0,x0,dt) * sqrt(dg) * dw; return apply(x0, drift + X0_); }
Real GeneralizedBlackScholesProcess::evolve(Time t0, Real x0, Time dt, Real dw) const { return apply(x0, discretization_->drift(*this,t0,x0,dt) + stdDeviation(t0,x0,dt)*dw); }
int main(int argc, char *argv[]) { int i, npart; idxtype *part; float ncut=0; GraphType graph; char filename[256],outputFile[256]; int wgtflag = 0, addSelfLoop=1, outputFileGiven=0, txtFormat=0 ; int randomInit = 0; idxtype minEdgeWeight = 0; Options opt; timer TOTALTmr, METISTmr, IOTmr; initOptions(&opt); if (argc < 2) { print_help(argv[0]); exit(0); } for (argv++; *argv != NULL; argv++){ if ((*argv)[0] == '-') { int temp; switch ((*argv)[1]) { case 'b': case 'B': opt.penalty_power=atof(*(++argv)); break; case 'i': case 'I': opt.gamma=atof(*(++argv)); break; case 'o': case 'O': strcpy(outputFile,*(++argv)); outputFileGiven=1; break; case 'D'://quality threshold. This is a post-processing step proposed in SR-MCL. If you dont want post-processing (this is what original MLR-MCL, R-MCL, MCL do, please set "-d 0" case 'd': opt.quality_threshold = atof(*(++argv)); break; case 'w': case 'W': opt.weighted_density = true; break; case 'c': case 'C': opt.coarsenTo= atoi(*(++argv)); break; default: printf("Invalid option %s\n", *argv); print_help(argv[0]); exit(0); } } else { strcpy(filename, *argv); } } if ( randomInit > 0 ) InitRandom(time(NULL)); else InitRandom(-1); cleartimer(TOTALTmr); cleartimer(METISTmr); cleartimer(IOTmr); starttimer(TOTALTmr); starttimer(IOTmr); ReadGraph(&graph, filename, &wgtflag, addSelfLoop, txtFormat); if ( opt.matchType == MATCH_UNSPECIFIED ) { // opt.matchType = (graph.nvtxs>50000) ? MATCH_POWERLAW_FC : // MATCH_SHEMN; opt.matchType = MATCH_SHEMN; } stoptimer(IOTmr); if (graph.nvtxs <= 0) { printf("Empty graph. Nothing to do.\n"); exit(0); } int noOfSingletons = 0; GraphType *noSingletonGraph ; idxtype* nodeMap = lookForSingletons(&graph, &noOfSingletons); if ( noOfSingletons > 0 ) { getSubgraph(&graph, nodeMap, graph.nvtxs-noOfSingletons, wgtflag, &noSingletonGraph); GKfree((void**)&(graph.xadj), (void**)&(graph.adjncy), LTERM); if ( wgtflag&1 > 0 ) GKfree( (void**)&(graph.adjwgt), LTERM); // free(graph.gdata); printf("Found %d singleton nodes in the", noOfSingletons); printf(" input graph. Removing them.\n"); } if ( !outputFileGiven ) { strcpy(outputFile, filename); sprintf(outputFile,"%s.c%d.i%1.1f.b%1.1f",outputFile,opt.coarsenTo,opt.gamma,opt.penalty_power); } printf("Input graph information ---------------------------------------------------\n"); printf(" Name: %s, #Vertices: %d, #Edges: %d\n", filename, graph.nvtxs, graph.nedges/2); printf("Output shall be placed in the file %s\n", outputFile); fflush(stdout); part = idxmalloc(graph.nvtxs, "main: part"); printf("------------------------------------------------\n"); printf("Clustering....\n"); fflush(stdout); starttimer(METISTmr); //YK: main algorithm starts here! if ( noOfSingletons > 0 ) { mlmcl(&(noSingletonGraph->nvtxs), noSingletonGraph->xadj, noSingletonGraph->adjncy, noSingletonGraph->vwgt,noSingletonGraph->adjwgt, &wgtflag, part, opt ); } else { mlmcl(&graph.nvtxs, graph.xadj, graph.adjncy,graph.vwgt, graph.adjwgt, &wgtflag, part, opt ); } stoptimer(METISTmr); printf("------------------------------------------------\n"); if ( noOfSingletons > 0 ) { npart=mapPartition(part,noSingletonGraph->nvtxs); ncut=ComputeNCut(noSingletonGraph, part,npart); // printf("In graph that does not include singletons,"); // printf("No. of Clusters: %d, N-Cut value: %.2f\n",npart,ncut); idxtype *clusterSizes = histogram(part, graph.nvtxs-noOfSingletons, npart); int maxSize = clusterSizes[idxamax(npart, clusterSizes)]; float avgClusterSize = (graph.nvtxs-noOfSingletons)*1.0/(npart); float balance = (maxSize*1.0) / ((graph.nvtxs-noOfSingletons)*1.0/npart); float stdDevn = stdDeviation(clusterSizes, npart); float avgNcut = ncut * 1.0/npart; float normStdDevn = stdDevn/avgClusterSize; // Warning: This computation only works if the singletons // have been placed in their own clusters. This works for // MLR-MCL, in other words, because it is guaranteed to // place singletons in their own clusters. printf("Output statistics for graph without singletons\n"); printf("Clusters: %d N-Cut: %.3f", npart, ncut); printf(" AvgN-Cut: %.3f Balance in cluster sizes: %.2f ",avgNcut, balance); printf("Std_Deviation in cluster sizes: %.2f ", stdDevn); printf("Coefficient_of_Variation: %.2f\n", normStdDevn); free( clusterSizes ); npart += noOfSingletons; // ncut += noOfSingletons; printf("Output statistics for original graph\n"); mapIndices(part, nodeMap, graph.nvtxs, npart-noOfSingletons); } else { npart=mapPartition(part,graph.nvtxs); ncut=ComputeNCut(&graph, part,npart); } idxtype* clusterSizes = histogram(part, graph.nvtxs, npart); int maxSize = clusterSizes[idxamax(npart, clusterSizes)]; float avgClusterSize = (graph.nvtxs)*1.0/(npart); float balance = (maxSize*1.0)/(graph.nvtxs*1.0/npart); float stdDevn = stdDeviation(clusterSizes, npart); float avgNcut = ncut * 1.0/npart; float normStdDevn = stdDevn/avgClusterSize; printf("Clusters: %d N-Cut: %.3f AvgN-Cut: %.3f", npart, ncut, avgNcut ); printf(" Balance in cluster sizes: %.2f Std.Deviation in cluster sizes: %.2f ", balance, stdDevn); printf("Coefficient_of_Variation: %.2f\n", normStdDevn); starttimer(IOTmr); my_WritePartition(outputFile, part, graph.nvtxs, opt.gamma); if ( noOfSingletons > 0 ) { free(nodeMap); nodeMap = NULL; } printf("\nOutput is written to file: %s\n", outputFile); stoptimer(IOTmr); stoptimer(TOTALTmr); printf("\nTiming Information --------------------------------------------------\n"); printf(" I/O: \t\t %7.3f\n", gettimer(IOTmr)); printf(" Partitioning: \t\t %7.3f (MLR-MCL time)\n", gettimer(METISTmr)); printf(" Total: \t\t %7.3f\n", gettimer(TOTALTmr)); printf("**********************************************************************\n"); GKfree((void**)&graph.xadj, (void**)&graph.adjncy, (void**)&graph.vwgt, (void**)&graph.adjwgt, (void**)&part, LTERM); }
Real AnalyticBarrierEngine::muSigma() const { return (1 + mu()) * stdDeviation(); }
void collectAndRecordData(char* fileName, float startvalue, float endvalue, float stepsize){ float value; FILE* fp; int k=0,i; int nSamples; int count=0; float involts[NUMCHANNELS]; float kensWaveLength; fp=fopen(fileName,"a"); if (!fp) { printf("unable to open file: %s\n",fileName); exit(1); } // Allocate some memory to store measurements for calculating // error bars. nSamples = 16; float* measurement = malloc(nSamples*sizeof(float)); value=startvalue; setVortexPiezo(value); delay(10000); for (value=startvalue;value < endvalue && value >= startvalue;value+=stepsize){ if(count%15==0) printf(" \t \t\t\tVERTICAL | HORIZONTAL | REFERENCE\n"); setVortexPiezo(value); printf("VOLT %3.1f \t",value); fprintf(fp,"%f\t",value); // delay to allow transients to settle delay(200); getProbeDetuning(&kensWaveLength);// Getting the wavelength invokes a significant delay // So we no longer need the previous delay statement. //kensWaveLength = -1; fprintf(fp,"%03.4f\t",kensWaveLength); printf("%03.4f\t",kensWaveLength); for(k=0;k<NUMCHANNELS;k++){ involts[k]=0.0; } // grab several readings and average for(k=1;k<NUMCHANNELS;k++){ for (i=0;i<nSamples;i++){ getMCPAnalogIn(k,&measurement[i]); involts[k-1]=involts[k-1]+measurement[i]; delay(10); } // for (i=0;i<nSamples;i++){ // getUSB1208AnalogIn(k,&measurement[i]); // involts[k-1]=involts[k-1]+measurement[i]; // delay(10); // } involts[k-1]=fabs(involts[k-1])/(float)nSamples; fprintf(fp,"%0.4f\t%0.4f\t",involts[k-1],stdDeviation(measurement,nSamples)); printf(" %0.4f %0.4f ",involts[k-1],stdDeviation(measurement,nSamples)); if(k<NUMCHANNELS) printf(" | "); } for (i=0;i<nSamples;i++){ getUSB1208AnalogIn(k,&measurement[i]); involts[k-1]=involts[k-1]+measurement[i]; delay(10); } involts[k-1]=fabs(involts[k-1])/(float)nSamples; fprintf(fp,"%0.4f\t%0.4f\t",involts[k-1],stdDeviation(measurement,nSamples)); printf(" %0.4f %0.4f ",involts[k-1],stdDeviation(measurement,nSamples)); fprintf(fp,"\n"); printf("\n"); count++; } fprintf(fp,"\n"); fclose(fp); free(measurement); }