Make functions and variables private if possible

Author: Hypernoot

CFrelement.h

@@ -51,15 +51,17 @@ class CFrelement: public CTemporal
 		int save(const char* name,bool lossy = false);
 		int load(const char* name);
 
+		inline SFrelement* getPredictFrelements() {
+			return predictFrelements;
+		}
+
+	private:
 		float storedGain;
 		SFrelement *storedFrelements;
 		int id;
 		float predictGain;
 		SFrelement *predictFrelements;
-		int measurements;
 		int shortestTime;
-		int64_t firstTime;
-		int64_t  lastTime;
 };
 
 #endif

CHyperTime.cpp

@@ -117,15 +117,15 @@ void CHyperTime::update(int modelOrder,unsigned int* times,float* signal,int len
 		/*retrieve dominant error period*/	
 		int maxOrder = 1;
 		fremen.update(timeDimension/2+1);
-		int period = fremen.predictFrelements[0].period;
+		int period = fremen.getPredictFrelements()[0].period;
 		bool expand = true;
 		fremen.print(true);
 		std::cout << "Model error with "<< timeDimension <<" time dimensions and "<< order <<" clusters is "<< sumErr << std::endl;
 
 		/*if the period already exists, then skip it*/
 		for (int d = 0; d < timeDimension/2; d++)
 		{
-			if (period == periods[d]) period = fremen.predictFrelements[d+1].period;
+			if (period == periods[d]) period = fremen.getPredictFrelements()[d+1].period;
 		}
 		errors[timeDimension/2] = sumErr;
 

CHyperTime.h

@@ -51,6 +51,7 @@ class CHyperTime: public CTemporal
 		int save(const  char* name, bool lossy = false);
 		int load(const  char* name);
 
+	private:
 		SHyperTimeSample sampleArray[1000000];
 		int numSamples;
 		int positives;

CPerGaM.h

@@ -9,7 +9,7 @@
 #include <string.h>
 #include "CTimer.h"
 #include "CTemporal.h"
-	
+
 /**
 @author Tom Krajnik
 */
@@ -29,37 +29,38 @@ typedef struct
 
 class CPerGaM: public CTemporal
 {
-public:
-  CPerGaM(int id);
-  ~CPerGaM();
+	public:
+		CPerGaM(int id);
+		~CPerGaM();
 
-  //adds a serie of measurements to the data
-  int add(uint32_t time,float state);
-  void init(int iMaxPeriod,int elements,int numActivities);
+		//adds a serie of measurements to the data
+		int add(uint32_t time,float state);
+		void init(int iMaxPeriod,int elements,int numActivities);
 
-  //estimates the probability for the given times - using stored histogram 
-  float estimate(uint32_t time);
+		//estimates the probability for the given times - using stored histogram
+		float estimate(uint32_t time);
 
-  //predicts the probability for the given times - using updated histogram 
-  float predict(uint32_t time);
+		//predicts the probability for the given times - using updated histogram
+		float predict(uint32_t time);
 
-  void update(int maxOrder,unsigned int* times = NULL,float* signal = NULL,int length = 0);
-  void print(bool verbose=true);
+		void update(int maxOrder,unsigned int* times = NULL,float* signal = NULL,int length = 0);
+		void print(bool verbose=true);
 
-  int id;
-  int exportToArray(double* array,int maxLen);
-  int importFromArray(double* array,int len);
-  int save(FILE* file,bool lossy = false);
-  int load(FILE* file);
-  int save(const char* name,bool lossy = false);
-  int load(const char* name);
-  int loadTxt(FILE* file);
+		int id;
+		int exportToArray(double* array,int maxLen);
+		int importFromArray(double* array,int len);
+		int save(const char* name,bool lossy = false);
+		int load(const char* name);
+		int save(FILE* file,bool lossy = false);
+		int load(FILE* file);
+		int loadTxt(FILE* file);
 
-  SPerGaM *gaussian;
-  float *storedHistogram;
-  int offset;
-  float gain;
-  int numBins; 
+	private:
+		SPerGaM *gaussian;
+		float *storedHistogram;
+		int offset;
+		float gain;
+		int numBins;
 };
 
 #endif

CPythonHyperTime.h

@@ -41,15 +41,17 @@ class CPythonHyperTime: public CTemporal
 		float predict(uint32_t time);
 
 		void update(int maxOrder,unsigned int* times = NULL,float* signal = NULL,int length = 0);
-		int exportToArray(double* array,int maxLen);
-		int importFromArray(double* array,int len);
 		void print(bool verbose=true);
 
 		int save(FILE* file,bool lossy = false);
 		int load(FILE* file);
 		int save(const char* name,bool lossy = false);
 		int load(const char* name);
 
+	private:
+		int exportToArray(double* array,int maxLen);
+		int importFromArray(double* array,int len);
+
 		char id[MAX_ID_LENGTH];
 		int measurements;
 

CTimeAdaptiveHist.cpp

@@ -5,124 +5,124 @@ using namespace std;
 
 CTimeAdaptiveHist::CTimeAdaptiveHist(int idd)
 {
-    id = idd;
-    firstTime = -1;
-    lastTime = -1;
-    measurements = 0;
-    maxPeriod = 0;
-    numElements = 0;
-    type = TT_ADAPTIVE;
+		id = idd;
+		firstTime = -1;
+		lastTime = -1;
+		measurements = 0;
+		maxPeriod = 0;
+		numElements = 0;
+		type = TT_ADAPTIVE;
 }
 
 void CTimeAdaptiveHist::init(int imaxPeriod,int elements,int numActivities)
 {
-    maxPeriod = imaxPeriod;
-    numElements = BINS_PER_DAY;
-    def_sample_threshold=elements;
-    predictHistogram = (float*) malloc(sizeof(float)*numElements);
-    storedHistogram = (float*) malloc(sizeof(float)*numElements);
-    measurementHistogram = (uint32_t*) malloc(sizeof(uint32_t)*numElements);
-    for (int i=0;i<numElements;i++)
-    {
-        measurementHistogram[i]=0;
-        predictHistogram[i] = storedHistogram[i] = 0.5;
-    }
+		maxPeriod = imaxPeriod;
+		numElements = BINS_PER_DAY;
+		def_sample_threshold=elements;
+		predictHistogram = (float*) malloc(sizeof(float)*numElements);
+		storedHistogram = (float*) malloc(sizeof(float)*numElements);
+		measurementHistogram = (uint32_t*) malloc(sizeof(uint32_t)*numElements);
+		for (int i=0;i<numElements;i++)
+		{
+				measurementHistogram[i]=0;
+				predictHistogram[i] = storedHistogram[i] = 0.5;
+		}
 }
 
 CTimeAdaptiveHist::~CTimeAdaptiveHist()
 {
-    free(predictHistogram);
-    free(storedHistogram);
+		free(predictHistogram);
+		free(storedHistogram);
 }
 
 // adds new state observations at given times
 int CTimeAdaptiveHist::add(uint32_t time,float state)
 {
-    if (measurements == 0) firstTime = time;
-    lastTime = time;
+		if (measurements == 0) firstTime = time;
+		lastTime = time;
 
-    storedHistogram[((time%maxPeriod)*numElements/maxPeriod)%numElements] += state;
-    measurementHistogram[((time%maxPeriod)*numElements/maxPeriod)%numElements]++;
-    measurements++;
+		storedHistogram[((time%maxPeriod)*numElements/maxPeriod)%numElements] += state;
+		measurementHistogram[((time%maxPeriod)*numElements/maxPeriod)%numElements]++;
+		measurements++;
 
-    return 0;
+		return 0;
 }
 
 /*not required in incremental version*/
 void CTimeAdaptiveHist::update(int modelOrder,unsigned int* times,float* signal,int length)
 {
-    for (int i=0;i<numElements;i++) predictHistogram[i] = storedHistogram[i];
+		for (int i=0;i<numElements;i++) predictHistogram[i] = storedHistogram[i];
 }
 
 /*text representation of the fremen model*/
 void CTimeAdaptiveHist::print(bool verbose)
 {
-    std::cout << "Model " << id << " Size: " << measurements << " ";
-    if (verbose){
-        printf("Bin values: ");
-        for (int i = 0;i<numElements;i++) printf("%.3f ",storedHistogram[i]);
-    }
-    printf("\n");
+		std::cout << "Model " << id << " Size: " << measurements << " ";
+		if (verbose){
+				printf("Bin values: ");
+				for (int i = 0;i<numElements;i++) printf("%.3f ",storedHistogram[i]);
+		}
+		printf("\n");
 }
 
 float CTimeAdaptiveHist::estimate(uint32_t time)
 {
-    float estimate = storedHistogram[((time%maxPeriod)*numElements/maxPeriod)%numElements];
-    float saturation = 0.001;
-    if (estimate > 1.0-saturation) estimate =  1.0-saturation;
-    if (estimate < 0.0+saturation) estimate =  0.0+saturation;
-    return estimate;
+		float estimate = storedHistogram[((time%maxPeriod)*numElements/maxPeriod)%numElements];
+		float saturation = 0.001;
+		if (estimate > 1.0-saturation) estimate =  1.0-saturation;
+		if (estimate < 0.0+saturation) estimate =  0.0+saturation;
+		return estimate;
 }
 
 float CTimeAdaptiveHist::predict(uint32_t time,uint32_t sample_thres)
 {
-    int center=((time%maxPeriod)*numElements/maxPeriod)%numElements;
-    uint32_t sum=measurementHistogram[center];
-    float estimate = predictHistogram[center]*(float)measurementHistogram[center];
-    int i=0;
-    while(sum<sample_thres)
-    {
-        i++;
-        sum+=measurementHistogram[(center+i)%numElements];
-        sum+=measurementHistogram[(center-i)%numElements];
-        estimate+=predictHistogram[(center+i)%numElements]*(float)measurementHistogram[(center+i)%numElements];
-        estimate+=predictHistogram[(center-i)%numElements]*(float)measurementHistogram[(center-i)%numElements];
-    }
-    estimate=estimate/(float)sum;
-    float saturation = 0.001;
-    if (estimate > 1.0-saturation) estimate =  1.0-saturation;
-    if (estimate < 0.0+saturation) estimate =  0.0+saturation;
-    return estimate;
+		int center=((time%maxPeriod)*numElements/maxPeriod)%numElements;
+		uint32_t sum=measurementHistogram[center];
+		float estimate = predictHistogram[center]*(float)measurementHistogram[center];
+		int i=0;
+		while(sum<sample_thres)
+		{
+				i++;
+				sum+=measurementHistogram[(center+i)%numElements];
+				sum+=measurementHistogram[(center-i)%numElements];
+				estimate+=predictHistogram[(center+i)%numElements]*(float)measurementHistogram[(center+i)%numElements];
+				estimate+=predictHistogram[(center-i)%numElements]*(float)measurementHistogram[(center-i)%numElements];
+		}
+		estimate=estimate/(float)sum;
+		float saturation = 0.001;
+		if (estimate > 1.0-saturation) estimate =  1.0-saturation;
+		if (estimate < 0.0+saturation) estimate =  0.0+saturation;
+		return estimate;
 }
 float CTimeAdaptiveHist::predict(uint32_t time)
 {
-    return CTimeAdaptiveHist::predict(time,(uint32_t)def_sample_threshold);
+		return CTimeAdaptiveHist::predict(time,(uint32_t)def_sample_threshold);
 }
 int CTimeAdaptiveHist::save(const char* name,bool lossy)
 {
-    FILE* file = fopen(name,"w");
-    save(file);
-    fclose(file);
-    return 0;
+		FILE* file = fopen(name,"w");
+		save(file);
+		fclose(file);
+		return 0;
 }
 
 int CTimeAdaptiveHist::load(const char* name)
 {
-    FILE* file = fopen(name,"r");
-    load(file);
-    fclose(file);
-    return 0;
+		FILE* file = fopen(name,"r");
+		load(file);
+		fclose(file);
+		return 0;
 }
 
 
 int CTimeAdaptiveHist::save(FILE* file,bool lossy)
 {
-    return -1;
+		return -1;
 }
 
 int CTimeAdaptiveHist::load(FILE* file)
 {
-    return -1;
+		return -1;
 }
 
 int CTimeAdaptiveHist::exportToArray(double* array,int maxLen)
@@ -147,12 +147,12 @@ int CTimeAdaptiveHist::importFromArray(double* array,int len)
 	type = (ETemporalType)array[pos++];
 	numElements = array[pos++];
 	if (type != TT_ADAPTIVE) fprintf(stderr,"Error loading the model, type mismatch.\n");
-	id = array[pos++];  
+	id = array[pos++];
 	def_sample_threshold = array[pos++];
-	measurements = array[pos++]; 
- 
-	for (int i = 0;i<numElements && pos < MAX_TEMPORAL_MODEL_SIZE;i++)storedHistogram[i]=array[pos++]; 
-	for (int i = 0;i<numElements && pos < MAX_TEMPORAL_MODEL_SIZE;i++)measurementHistogram[i]=array[pos++]; 
+	measurements = array[pos++];
+
+	for (int i = 0;i<numElements && pos < MAX_TEMPORAL_MODEL_SIZE;i++)storedHistogram[i]=array[pos++];
+	for (int i = 0;i<numElements && pos < MAX_TEMPORAL_MODEL_SIZE;i++)measurementHistogram[i]=array[pos++];
 
 	if (pos == MAX_TEMPORAL_MODEL_SIZE) fprintf(stdout,"Model was not properly saved before.\n");
 	return pos;