Exemple #1
0
int main( int argc, char *argv[]){
    int nobs;
    if ( 3!=argc){ fputs("Usage: wLR nobs filename\n",stderr); return EXIT_FAILURE;}
 
    FILE * fp = fopen(argv[2],"r");
    sscanf(argv[1],"%d",&nobs);
    real_t * vars = readmatrix(fp,nobs,3);

    fputs("* Standard linear regression.\n",stdout);
    real_t * res = linearRegression(vars+nobs,vars+2*nobs,NULL,nobs,NULL);
    fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);

    fputs("* Weighted linear regression, using weights from file.\n",stdout);
    res = wLinearRegression(vars,vars+nobs,vars+2*nobs,NULL,nobs,res);
    fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
    
    fputs("* Iteratively reWeighted Least Squares, Cauchy.\n",stdout); 
    res = iwlsLinearRegression(cauchy,vars+nobs,vars+2*nobs,NULL,100,nobs,res);
    fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
    fputs("* Iteratively reWeighted Least Squares, Tukey biweight.\n",stdout); 
    res = iwlsLinearRegression(tukey_biweight,vars+nobs,vars+2*nobs,NULL,100,nobs,res);
    fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
    
    return EXIT_SUCCESS;
}
Exemple #2
0
// Estimation of information dimension
double estimate(int xnum, double *yall, int width, _Bool cov, double minent) {
  _Bool flag;
  int i, j, i_end;
  double a, b, rsq, rsq_before = 0, coef = 0, *x, *y;

  i_end = xnum - width + 1;
  x = (double *)malloc(sizeof(double) * width);
  y = (double *)malloc(sizeof(double) * width);

  for (i = 1; i <= i_end; i++) {
    flag = 0;
    for (j = 0; j < width; j++) {
      x[j] = i + j;
      y[j] = yall[i + j - 1];
      if (j > 0 && y[j] == y[j - 1]) flag = 1;
    }
    if (flag == 1) {
      a = 0; rsq = 0;
    } else {
      linearRegression(width, x, y, &a, &b, &rsq);
    }
    if (cov == 0) {
      if (rsq > rsq_before) coef = a;
    } else {
      if (rsq > rsq_before && a > minent) coef = a;
    }
    rsq_before = rsq;
  }

  if (cov == 1 && coef == 0) coef = minent;
  return coef;
}
Exemple #3
0
void shakeData::loadKNET(string filename)
{
	file=filename;
	ifstream input(ofToDataPath(file).c_str());
	string buffer;
	int lineCount=0;
	double scale;
	double averg=0;
	vector<double> val;
	while(lineCount<18){
		getline(input, buffer);
		string result;
		KNETresults rslt=getVal(buffer,result);
		switch(rslt){
			case FREQ:
				sampFreq=ofToInt(result);
				break;
			case SCALE_AMOUNT:
				scale=ofToInt(result.substr(0,result.find_first_of("(")));
				scale/=ofToInt(result.substr(result.find_last_of("/")+1));
				break;
			case MAX_ACCEL:
				break;
			default:
				break;
		}
		lineCount++;
	}
	while(!input.eof()){
		getline(input, buffer);
		for(int i=0; i<8; i++){
			if(buffer.length()>(i+1)*9){
				val.push_back(ofToInt(buffer.substr(i*9,9)));
			}
		}
	}
	input.close();
	double a1,a0;
	linearRegression(val,a1,a0);
	for(unsigned int i=0; i<val.size(); i++){
		val[i]-=a0+a1*i;
		val[i]*=scale;
	}
	bandpassFilter(val,sampFreq,3);
	for(unsigned int i=0; i<val.size(); i++){
		uData.push_back(dataPoint(val[i],1/sampFreq));
	}
	processData();
}
void PlotDataFitFunction::fitData() {
    if (fittingValues_.regressionType == FunctionLibrary::LINEAR)
        linearRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::SQRT)
        sqrtRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::SIMPLESPLINE)
        simpleSplineRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::CONSTANTSPLINE)
        constantSpline(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::BSPLINE)
        bSplineRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::CUBICSPLINE)
        cubicSplineRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::SQUARE)
        squareRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::CUBIC)
        cubicRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::POLYNOMIAL)
        multiRegression(fittingValues_.dimension,fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::LOGARITHMIC)
        logarithmicRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::POWER)
        powerRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::EXPONENTIAL)
        exponentialRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::SIN)
        sinRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::COS)
        cosRegression(fittingValues_.column);
    else if (fittingValues_.regressionType == FunctionLibrary::INTERPOLATION)
        interpolRegression(fittingValues_.column);
    else {
        if (getProcessorWidget()){
            getProcessorWidget()->updateFromProcessor();
        }
    }
}
Exemple #5
0
//implementation of the ransac algorithm
void ransac(){
	int i, j, k = 0, index_p1, index_p2, n_inliers = 0, n_inliers2;
	float slope, intercept;
	point inliers[1000], inliers2[1000];
	segment segTemp1, segTemp2;
	
	while(n_data >= 8){
		segments[n_segments].n_inliers = 0;
		
		//try to find a segment to different models
		for(i = 0; i < 500; i++){
			//get 2 random points of the data set
			index_p1 = getRandomPoint();
			index_p2 = getRandomPoint();
			while(index_p1 == index_p2 || data[index_p2].x == data[index_p1].x)
				index_p2 = getRandomPoint();
			
			//fit the model
			slope = (data[index_p2].y - data[index_p1].y) / (data[index_p2].x - data[index_p1].x);
			intercept = data[index_p1].y - (slope * data[index_p1].x); 
			
			//find the inliers
			findInliers(slope, intercept, inliers, &n_inliers);
			
			//find the biggest segment
			segTemp1 = getBiggestSegment(slope, intercept, inliers, &n_inliers);
			
			//there is no point in continue trying if the segment explains all data
			if(segTemp1.n_inliers == n_data){
				segments[n_segments] = segTemp1;
				break;
			}
				
			//apply regression to the segment until it gets less inliers
			segTemp2.n_inliers = 0;
			while(1){
				copyPoints(inliers2, inliers, n_inliers);
				n_inliers2 = n_inliers;
				
				segTemp2 = linearRegression(inliers2, &n_inliers2);
				
				if(segTemp2.n_inliers > segTemp1.n_inliers){
					segTemp1 = segTemp2;
					copyPoints(inliers, inliers2, n_inliers2);
					n_inliers = n_inliers2;
				}
				
				else
					break;
			}
			
			//compare with the biggest segments until now
			if(segTemp1.n_inliers > segments[n_segments].n_inliers)
				segments[n_segments] = segTemp1;
		}
		
		if(segments[n_segments].n_inliers >= 8){
			//remove inliers of the segment
			removeInliers(segments[n_segments]);
			n_segments++;
		}
		else
			break;
	}
}
Exemple #6
0
map<long int, tTPSRegion> tTPSFilter::tagPathSequenceFilter(tNode *n, bool css) {
	wstring originalTPS;
	vector<tNode *> originalNodeSequence;
	queue<pair<wstring,long int>> seqQueue;
	vector<long int> start;
	map<long int,tTPSRegion> structured;
	int originalTPSsize;
	long int sizeThreshold;

	buildTagPath("",n,false,css,false);
	originalTPS = tagPathSequence;
	originalNodeSequence = nodeSequence;
	originalTPSsize = originalTPS.size();
	sizeThreshold = (originalTPSsize*5)/100; // % page size

	seqQueue.push(make_pair(originalTPS,0)); // insert first sequence in queue for processing

	while (seqQueue.size()) {
		long int len,off,rlen,pos;
		wstring tps;

		auto s = seqQueue.front();

		seqQueue.pop();

		tps = s.first;
		len = tps.size();
		off = s.second;
		pos = searchRegion(tps);
		rlen = tagPathSequence.size();

		if (len > rlen) {
			if (pos > 0)
				seqQueue.push(make_pair(tps.substr(0,pos),off));
			if ((len-pos-rlen) > 0)
				seqQueue.push(make_pair(tps.substr(pos+rlen),off+pos+rlen));
			if (rlen > sizeThreshold) {
				_regions[off+pos].len=rlen;
				_regions[off+pos].tps = originalTPS.substr(off+pos,rlen);
			}
		}
	}

	if (_regions.size()) {
		auto r=_regions.begin();
		if ((*r).first > sizeThreshold) {
			_regions[0].len = (*r).first;
			_regions[0].tps = originalTPS.substr(0,(*r).first);
		}
	} else {
		_regions[0].len=originalTPSsize;
		_regions[0].tps = originalTPS;
	}
	// select structured regions
	float angCoeffThreshold=0.1;

	for (auto i=_regions.begin();i!=_regions.end();i++) {
		tLinearCoeff lc;
		lc = linearRegression((*i).second.tps);
		(*i).second.lc.a = lc.a;
		(*i).second.lc.b = lc.b;
		(*i).second.lc.e = lc.e;

		cerr << "size: " << (*i).second.len << " ang.coeff.: " << (*i).second.lc.a << endl;

		if (abs((*i).second.lc.a) < angCoeffThreshold)
			structured.insert(*i);
	}

	tagPathSequence = originalTPS;
	nodeSequence = originalNodeSequence;

	return structured;
}