changes
This commit is contained in:
gurkenhabicht
parent
6091d2cc2a
commit
f78156882d
|
|
@ -0,0 +1,789 @@
|
|||
//
|
||||
//
|
||||
// NLMSvariants.c
|
||||
//
|
||||
// Created by FBRDNLMS on 26.04.18.
|
||||
//
|
||||
//
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <time.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <float.h> // DBL_MAX
|
||||
|
||||
#define NUMBER_OF_SAMPLES 500
|
||||
#define WINDOWSIZE 5
|
||||
#define learnrate 0.8
|
||||
#define RGB_COLOR 255
|
||||
#if defined(_MSC_VER)
|
||||
#include <BaseTsd.h>
|
||||
typedef SSIZE_T ssize_t;
|
||||
#endif
|
||||
|
||||
enum fileSuffix_t{ // used in conjunction with mkFileName()
|
||||
PURE_WEIGHTS,
|
||||
USED_WEIGHTS,
|
||||
DIRECT_PREDECESSOR,
|
||||
RESULTS,
|
||||
LOCAL_MEAN,
|
||||
TEST_VALUES,
|
||||
DIFFERENTIAL_PREDECESSOR
|
||||
};
|
||||
|
||||
double xSamples[NUMBER_OF_SAMPLES] = { 0.0 };
|
||||
|
||||
/* *svg graph building* */
|
||||
typedef struct {
|
||||
double xVal[7];
|
||||
double yVal[7];
|
||||
}point_t;
|
||||
|
||||
point_t points[NUMBER_OF_SAMPLES]; // [0] = xActual, [1]=xpredicted from localMean, [2]=xpredicted from directPredecessor, [3] = xpredicted from differentialpredecessor, [4] = xError from localMean, [5] xError from directPredecessor, [6] xError from differentialPredecessor
|
||||
|
||||
/* *ppm read, copy, write* */
|
||||
typedef struct {
|
||||
unsigned char red, green, blue;
|
||||
}colorChannel_t;
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
colorChannel_t *data;
|
||||
}imagePixel_t;
|
||||
|
||||
static imagePixel_t * rdPPM(char *fileName); // read PPM file format
|
||||
void mkPpmFile(char *fileName, imagePixel_t *image); // writes PPM file
|
||||
int ppmColorChannel(FILE* fp, imagePixel_t *image); // writes colorChannel from PPM file to log file
|
||||
void colorSamples(FILE* fp); // stores color channel values in xSamples[]
|
||||
|
||||
/* *file handling* */
|
||||
char * mkFileName(char* buffer, size_t max_len, int suffixId);
|
||||
char *fileSuffix(int id);
|
||||
void myLogger(FILE* fp, point_t points[]);
|
||||
void mkSvgGraph(point_t points[]);
|
||||
//void weightsLogger(double *weights, int var);
|
||||
/* *rand seed* */
|
||||
double r2(void);
|
||||
double rndm(void);
|
||||
|
||||
/* *math* */
|
||||
double sum_array(double x[], int length);
|
||||
void directPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]);
|
||||
void localMean(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]);
|
||||
void differentialPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]);
|
||||
//void differentialPredecessor(double *weights);
|
||||
double *popNAN(double *xError); //return new array without NAN values
|
||||
double windowXMean(int _arraylength, int xCount);
|
||||
|
||||
|
||||
//int main(int argc, char **argv) {
|
||||
int main( void ) {
|
||||
double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]; // = { { 0.0 }, {0.0} };
|
||||
// double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
|
||||
char fileName[50];
|
||||
int i,k, xLength;
|
||||
imagePixel_t *image;
|
||||
|
||||
image = rdPPM("cow.ppm");
|
||||
mkFileName(fileName, sizeof(fileName), TEST_VALUES);
|
||||
FILE* fp5 = fopen(fileName, "w");
|
||||
xLength = ppmColorChannel(fp5, image);
|
||||
printf("%d\n", xLength);
|
||||
FILE* fp6 = fopen(fileName, "r");
|
||||
colorSamples(fp6);
|
||||
|
||||
srand( (unsigned int)time(NULL) );
|
||||
for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
|
||||
for (int k = 0; k < WINDOWSIZE; k++) {
|
||||
weights[k][i] = rndm(); // Init weights
|
||||
}
|
||||
}
|
||||
mkFileName(fileName, sizeof(fileName), PURE_WEIGHTS);
|
||||
// save plain test_array before math magic happens
|
||||
FILE *fp0 = fopen(fileName, "w");
|
||||
for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
|
||||
for (k = 0; k < WINDOWSIZE; k++) {
|
||||
fprintf(fp0, "[%d][%d]%lf\n", k, i, weights[k][i]);
|
||||
}
|
||||
}
|
||||
fclose(fp0);
|
||||
// math magic
|
||||
localMean(weights);
|
||||
directPredecessor(weights);
|
||||
differentialPredecessor(weights);
|
||||
mkSvgGraph(points);
|
||||
// save test_array after math magic happened
|
||||
// memset( fileName, '\0', sizeof(fileName) );
|
||||
/* mkFileName(fileName, sizeof(fileName), USED_WEIGHTS);
|
||||
FILE *fp1 = fopen(fileName, "w");
|
||||
for (i = 0; i < tracking; i++) {
|
||||
for (int k = 0; k < WINDOWSIZE; k++) {
|
||||
fprintf(fp1, "[%d][%d] %lf\n", k, i, w[k][i]);
|
||||
}
|
||||
|
||||
}
|
||||
fclose(fp1);
|
||||
*/
|
||||
printf("\nDONE!\n");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
localMean
|
||||
|
||||
Variant (1/3), substract local mean.
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
void localMean(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
|
||||
//double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
|
||||
double (*local_weights)[WINDOWSIZE] = malloc(sizeof(double) * (WINDOWSIZE+1) * (NUMBER_OF_SAMPLES+1));
|
||||
// double *local_weights[WINDOWSIZE];
|
||||
memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES);
|
||||
char fileName[50];
|
||||
double xError[2048]; // includes e(n)
|
||||
memset(xError, 0.0, NUMBER_OF_SAMPLES);// initialize xError-array with Zero
|
||||
int xCount = 0, i; // runtime var;
|
||||
mkFileName(fileName, sizeof(fileName), LOCAL_MEAN);
|
||||
FILE* fp4 = fopen(fileName, "w");
|
||||
fprintf(fp4, "\n=====================================LocalMean=====================================\nNo.\txPredicted\txActual\t\txError\n");
|
||||
|
||||
double xMean = xSamples[0];
|
||||
double xSquared = 0.0;
|
||||
double xPredicted = 0.0;
|
||||
double xActual = 0.0;
|
||||
|
||||
for (xCount = 1; xCount < NUMBER_OF_SAMPLES; xCount++) { // first value will not get predicted
|
||||
|
||||
int _arrayLength = ( xCount > WINDOWSIZE ) ? WINDOWSIZE + 1 : xCount;
|
||||
xMean = (xCount > 0) ? windowXMean(_arrayLength, xCount) : 0;
|
||||
xPredicted = 0.0;
|
||||
xActual = xSamples[xCount + 1];
|
||||
// weightedSum += _x[ xCount-1 ] * w[xCount][0];
|
||||
|
||||
for (i = 1; i < _arrayLength; i++) { //get predicted value
|
||||
xPredicted += (local_weights[i][xCount] * (xSamples[xCount - i] - xMean));
|
||||
}
|
||||
xPredicted += xMean;
|
||||
xError[xCount] = xActual - xPredicted;
|
||||
points[xCount].xVal[1] = xCount;
|
||||
points[xCount].yVal[1] = xPredicted;
|
||||
points[xCount].xVal[4] = xCount;
|
||||
points[xCount].yVal[4] = xError[xCount];
|
||||
|
||||
xSquared = 0.0;
|
||||
for (i = 1; i < _arrayLength; i++) { //get xSquared
|
||||
xSquared += pow(xSamples[xCount - i] - xMean, 2);
|
||||
}
|
||||
if (xSquared == 0.0) { // Otherwise returns Pred: -1.#IND00 in some occassions
|
||||
xSquared = 1.0;
|
||||
}
|
||||
for (i = 1; i < _arrayLength; i++) { //update weights
|
||||
local_weights[i][xCount+1] = local_weights[i][xCount] + learnrate * xError[xCount] * ((xSamples[xCount - i] - xMean) / xSquared);
|
||||
}
|
||||
fprintf(fp4, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
|
||||
}
|
||||
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
|
||||
double xErrorLength = *xErrorPtr; // Watch popNAN()!
|
||||
xErrorPtr[0] = 0.0;
|
||||
printf("Xerrorl:%lf", xErrorLength);
|
||||
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
|
||||
double deviation = 0.0;
|
||||
|
||||
// Mean square
|
||||
for (i = 1; i < xErrorLength; i++) {
|
||||
deviation += pow(xError[i] - mean, 2);
|
||||
}
|
||||
deviation /= xErrorLength;
|
||||
printf("mean:%lf, devitation:%lf", mean, deviation);
|
||||
|
||||
// write in file
|
||||
//mkFileName(fileName, sizeof(fileName), RESULTS);
|
||||
//FILE *fp2 = fopen(fileName, "w");
|
||||
fprintf(fp4, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
|
||||
//fclose(fp2);
|
||||
free(local_weights);
|
||||
fclose(fp4);
|
||||
|
||||
//weightsLogger( local_weights, USED_WEIGHTS );
|
||||
}
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
directPredecessor
|
||||
|
||||
Variant (2/3),
|
||||
substract direct predecessor
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
void directPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
|
||||
double (*local_weights)[WINDOWSIZE] = malloc(sizeof(double) * (WINDOWSIZE+1) * (NUMBER_OF_SAMPLES+1));
|
||||
|
||||
// double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
|
||||
memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES );
|
||||
char fileName[512];
|
||||
double xError[2048];
|
||||
int xCount = 0, i;
|
||||
double xActual = 0.0;
|
||||
double xPredicted = 0.0;
|
||||
// File handling
|
||||
mkFileName(fileName, sizeof(fileName), DIRECT_PREDECESSOR);
|
||||
FILE *fp3 = fopen(fileName, "w");
|
||||
fprintf(fp3, "\n=====================================DirectPredecessor=====================================\nNo.\txPredicted\txAcutal\t\txError\n");
|
||||
|
||||
|
||||
for (xCount = 1; xCount < NUMBER_OF_SAMPLES; xCount++) { // first value will not get predicted
|
||||
//double xPartArray[1000]; //includes all values at the size of runtime var
|
||||
//int _sourceIndex = (xCount > WINDOWSIZE) ? xCount - WINDOWSIZE : xCount;
|
||||
int _arrayLength = (xCount > WINDOWSIZE) ? WINDOWSIZE + 1 : xCount;
|
||||
//printf("xCount:%d, length:%d\n", xCount, _arrayLength);
|
||||
// printf("WINDOWSIZE:%f\n", windowXMean(_arrayLength, xCount));
|
||||
xPredicted = 0.0;
|
||||
xActual = xSamples[xCount + 1];
|
||||
// weightedSum += _x[ xCount-1 ] * w[xCount][0];
|
||||
|
||||
for (i = 1; i < _arrayLength; i++) {
|
||||
xPredicted += (local_weights[i][xCount] * (xSamples[xCount - 1] - xSamples[xCount - i - 1]));
|
||||
}
|
||||
xPredicted += xSamples[xCount - 1];
|
||||
xError[xCount] = xActual - xPredicted;
|
||||
|
||||
//fprintf(fp3, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
|
||||
points[xCount].xVal[2] = xCount;
|
||||
points[xCount].yVal[2] = xPredicted;
|
||||
points[xCount].xVal[5] = xCount;
|
||||
points[xCount].yVal[5] = xError[xCount];
|
||||
|
||||
double xSquared = 0.0;
|
||||
|
||||
for (i = 1; i < _arrayLength; i++) {
|
||||
xSquared += pow(xSamples[xCount - 1] - xSamples[xCount - i - 1], 2); // substract direct predecessor
|
||||
}
|
||||
for (i = 1; i < _arrayLength; i++) {
|
||||
local_weights[i][xCount+1] = local_weights[i][xCount] + learnrate * xError[xCount] * ( (xSamples[xCount - 1] - xSamples[xCount - i - 1]) / xSquared);
|
||||
}
|
||||
fprintf(fp3, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
|
||||
}
|
||||
|
||||
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
|
||||
//printf("%lf", xErrorPtr[499]);
|
||||
double xErrorLength = *xErrorPtr; // Watch popNAN()!
|
||||
xErrorPtr[0] = 0.0;
|
||||
printf("Xerrorl:%lf", xErrorLength);
|
||||
|
||||
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
|
||||
double deviation = 0.0;
|
||||
|
||||
// Mean square
|
||||
for (i = 1; i < xErrorLength; i++) {
|
||||
deviation += pow(xError[i] - mean, 2);
|
||||
}
|
||||
deviation /= xErrorLength;
|
||||
printf("mean:%lf, devitation:%lf", mean, deviation);
|
||||
|
||||
// write in file
|
||||
//mkFileName(fileName, sizeof(fileName), RESULTS);
|
||||
//FILE *fp2 = fopen(fileName, "wa");
|
||||
fprintf(fp3, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
|
||||
fclose(fp3);
|
||||
//fclose(fp2);
|
||||
free(local_weights);
|
||||
|
||||
//weightsLogger( local_weights, USED_WEIGHTS );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
differentialPredecessor
|
||||
|
||||
variant (3/3),
|
||||
differential predecessor.
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
void differentialPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
|
||||
// double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
|
||||
double (*local_weights)[WINDOWSIZE] = malloc(sizeof(double) * (WINDOWSIZE+1) * (NUMBER_OF_SAMPLES+1));
|
||||
|
||||
memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES );
|
||||
char fileName[512];
|
||||
double xError[2048];
|
||||
int xCount = 0, i;
|
||||
double xPredicted = 0.0;
|
||||
double xActual = 0.0;
|
||||
|
||||
// File handling
|
||||
mkFileName(fileName, sizeof(fileName), DIFFERENTIAL_PREDECESSOR);
|
||||
FILE *fp6 = fopen(fileName, "w");
|
||||
fprintf(fp6, "\n=====================================DifferentialPredecessor=====================================\nNo.\txPredicted\txAcutal\t\txError\n");
|
||||
|
||||
for (xCount = 1; xCount < NUMBER_OF_SAMPLES; xCount++) { // first value will not get predicted
|
||||
|
||||
int _arrayLength = (xCount > WINDOWSIZE) ? WINDOWSIZE + 1 : xCount;
|
||||
xPredicted = 0.0;
|
||||
xActual = xSamples[xCount + 1];
|
||||
|
||||
for (i = 1; i < _arrayLength; i++) {
|
||||
xPredicted += (local_weights[i][xCount] * (xSamples[xCount - i] - xSamples[xCount - i - 1]));
|
||||
}
|
||||
xPredicted += xSamples[xCount - 1];
|
||||
xError[xCount] = xActual - xPredicted;
|
||||
|
||||
//fprintf(fp6, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
|
||||
points[xCount].xVal[3] = xCount;
|
||||
points[xCount].yVal[3] = xPredicted;
|
||||
points[xCount].xVal[6] = xCount;
|
||||
points[xCount].yVal[6] = xError[xCount];
|
||||
double xSquared = 0.0;
|
||||
|
||||
for (i = 1; i < _arrayLength; i++) {
|
||||
xSquared += pow(xSamples[xCount - i] - xSamples[xCount - i - 1], 2); // substract direct predecessor
|
||||
}
|
||||
for (i = 1; i < _arrayLength; i++) {
|
||||
local_weights[i][xCount+1] = local_weights[i][xCount] + learnrate * xError[xCount] * ((xSamples[xCount - i] - xSamples[xCount - i - 1]) / xSquared);
|
||||
}
|
||||
fprintf(fp6, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
|
||||
}
|
||||
|
||||
/* int xErrorLength = sizeof(xError) / sizeof(xError[0]);
|
||||
printf("vor:%d", xErrorLength);
|
||||
popNAN(xError);
|
||||
printf("nach:%d", xErrorLength);
|
||||
xErrorLength = sizeof(xError) / sizeof(xError[0]);
|
||||
double mean = sum_array(xError, xErrorLength) / xErrorLength;
|
||||
double deviation = 0.0;
|
||||
|
||||
for (i = 0; i < xErrorLength - 1; i++) {
|
||||
deviation += pow(xError[i] - mean, 2);
|
||||
}
|
||||
deviation /= xErrorLength;
|
||||
|
||||
//mkSvgGraph(points);
|
||||
fprintf(fp6, "{%d}.\tLeast Mean Squared{%f}\tMean{%f}\n\n", xCount, deviation, mean);
|
||||
*/
|
||||
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
|
||||
//printf("%lf", xErrorPtr[499]);
|
||||
double xErrorLength = *xErrorPtr; // Watch popNAN()!
|
||||
xErrorPtr[0] = 0.0;
|
||||
printf("Xerrorl:%lf", xErrorLength);
|
||||
|
||||
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
|
||||
double deviation = 0.0;
|
||||
|
||||
// Mean square
|
||||
for (i = 1; i < xErrorLength; i++) {
|
||||
deviation += pow(xError[i] - mean, 2);
|
||||
}
|
||||
deviation /= xErrorLength;
|
||||
printf("mean:%lf, devitation:%lf", mean, deviation);
|
||||
|
||||
// write in file
|
||||
//mkFileName(fileName, sizeof(fileName), RESULTS);
|
||||
//FILE *fp2 = fopen(fileName, "wa");
|
||||
fprintf(fp6, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
|
||||
//fclose(fp2);
|
||||
fclose(fp6);
|
||||
free(local_weights);
|
||||
|
||||
//weightsLogger( local_weights, USED_WEIGHTS );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
mkFileName
|
||||
|
||||
Writes the current date plus the suffix with index suffixId
|
||||
into the given buffer. If the total length is longer than max_len,
|
||||
only max_len characters will be written.
|
||||
|
||||
======================================================================================================
|
||||
|
||||
*/
|
||||
|
||||
char *mkFileName(char* buffer, size_t max_len, int suffixId) {
|
||||
const char * format_str = "%Y-%m-%d_%H_%M_%S";
|
||||
size_t date_len;
|
||||
const char * suffix = fileSuffix(suffixId);
|
||||
time_t now = time(NULL);
|
||||
|
||||
strftime(buffer, max_len, format_str, localtime(&now));
|
||||
date_len = strlen(buffer);
|
||||
strncat(buffer, suffix, max_len - date_len);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
fileSuffix
|
||||
|
||||
Contains and returns every suffix for all existing filenames
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
char * fileSuffix(int id) {
|
||||
char * suffix[] = { "_weights_pure.txt", "_weights_used.txt", "_direct_predecessor.txt", "_ergebnisse.txt", "_localMean.txt","_testvalues.txt", "_differential_predecessor.txt" };
|
||||
return suffix[id];
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
myLogger
|
||||
|
||||
Logs x,y points to svg graph
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
void weightsLogger (double weights[WINDOWSIZE], int val ) {
|
||||
char fileName[512];
|
||||
int i;
|
||||
mkFileName(fileName, sizeof(fileName), val);
|
||||
FILE* fp = fopen(fileName, "wa");
|
||||
for (i = 0; i < WINDOWSIZE; i++) {
|
||||
// for (int k = 0; k < WINDOWSIZE; k++) {
|
||||
fprintf(fp, "[%d]%lf\n", i, weights[i]);
|
||||
// }
|
||||
}
|
||||
fprintf(fp,"\n\n\n\n=====================NEXT=====================\n");
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
bufferLogger
|
||||
|
||||
formats output of mkSvgGraph -- Please open graphResults.html to see the output--
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
void bufferLogger(char *buffer, point_t points[]) {
|
||||
int i;
|
||||
char _buffer[512] = "";
|
||||
|
||||
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) { // xActual
|
||||
sprintf(_buffer, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]);
|
||||
strcat(buffer, _buffer);
|
||||
}
|
||||
strcat(buffer, "\" fill=\"none\" id=\"svg_1\" stroke=\"black\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
|
||||
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) { // xPredicted from localMean
|
||||
sprintf(_buffer, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
|
||||
strcat(buffer, _buffer);
|
||||
}
|
||||
strcat(buffer, "\" fill=\"none\" id=\"svg_2\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
|
||||
for (i = 0; i <= NUMBER_OF_SAMPLES - 1; i++) { //xPreddicted from directPredecessor
|
||||
sprintf(_buffer, "L %f %f\n", points[i].xVal[2], points[i].yVal[2]);
|
||||
strcat(buffer, _buffer);
|
||||
}
|
||||
strcat(buffer, "\" fill=\"none\" id=\"svg_3\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
|
||||
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) { //xPredicted from diff Pred
|
||||
sprintf(_buffer, "L %f %f\n", points[i].xVal[3], points[i].yVal[3]);
|
||||
strcat(buffer, _buffer);
|
||||
}
|
||||
strcat(buffer, "\" fill=\"none\" id=\"svg_4\" stroke=\"red\" stroke-width=\"0.4px\"/>\n");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
sum_array
|
||||
|
||||
Sum of all elements in x within a defined length
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
double sum_array(double x[], int xlength) {
|
||||
int i = 0;
|
||||
double sum = 0.0;
|
||||
|
||||
if (xlength != 0) {
|
||||
for (i = 0; i < xlength; i++) {
|
||||
sum += x[i];
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
popNanLength
|
||||
|
||||
returns length of new array without NAN values
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
double *popNAN(double *xError) {
|
||||
int i, counter = 1;
|
||||
double tmpLength = 0.0;
|
||||
double *tmp = NULL;
|
||||
double *more_tmp = NULL;
|
||||
|
||||
for ( i = 0; i < NUMBER_OF_SAMPLES; i++ ) {
|
||||
counter ++;
|
||||
more_tmp = (double *) realloc ( tmp, counter*(sizeof(double) ));
|
||||
if ( !isnan(xError[i]) ) {
|
||||
tmp = more_tmp;
|
||||
tmp[counter - 1] = xError[i];
|
||||
printf("xERROR:%lf\n", tmp[counter - 1]);
|
||||
tmpLength++;
|
||||
}
|
||||
}
|
||||
counter += 1;
|
||||
more_tmp = (double *) realloc ( tmp, counter * sizeof(double) );
|
||||
tmp = more_tmp;
|
||||
*tmp = tmpLength; // Length of array has to be stored in tmp[0],
|
||||
// Cause length is needed later on in the math functions.
|
||||
// xError counting has to begin with 1 in the other functions !
|
||||
printf("tmpLength in tmp:%lf, %lf\n", tmp[counter-2], *tmp);
|
||||
return tmp;
|
||||
|
||||
}
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
r2
|
||||
|
||||
returns a random double value between 0 and 1
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
double r2(void) {
|
||||
return((rand() % 10000) / 10000.0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
rndm
|
||||
|
||||
fills a double variable with random value and returns it
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
double rndm(void) {
|
||||
double rndmval = r2();
|
||||
return rndmval;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
mkSvgGraph
|
||||
|
||||
parses template.svg and writes results in said template
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
void mkSvgGraph(point_t points[]) {
|
||||
FILE *input = fopen("graphResults_template.html", "r");
|
||||
FILE *target = fopen("graphResults.html", "w");
|
||||
char line[512];
|
||||
char firstGraph[15] = { "<path d=\"M0 0" };
|
||||
|
||||
if (input == NULL) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
char buffer[131072] = "";
|
||||
|
||||
memset(buffer, '\0', sizeof(buffer));
|
||||
while (!feof(input)) {
|
||||
fgets(line, 512, input);
|
||||
strncat(buffer, line, strlen(line));
|
||||
if (strstr(line, firstGraph) != NULL) {
|
||||
bufferLogger(buffer, points);
|
||||
}
|
||||
|
||||
}
|
||||
fprintf(target, buffer);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
rdPPM
|
||||
|
||||
reads data from file of type PPM, stores colorchannels in a struct in the
|
||||
size of given picture
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
static imagePixel_t *rdPPM(char *fileName) {
|
||||
char buffer[16];
|
||||
imagePixel_t *image;
|
||||
int c, rgbColor;
|
||||
|
||||
FILE *fp = fopen(fileName, "rb");
|
||||
if (!fp) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
if (!fgets(buffer, sizeof(buffer), fp)) {
|
||||
perror(fileName);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
if (buffer[0] != 'P' || buffer[1] != '6') {
|
||||
fprintf(stderr, "No PPM file format\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
image = (imagePixel_t *)malloc(sizeof(imagePixel_t));
|
||||
if (!image) {
|
||||
fprintf(stderr, "malloc() failed");
|
||||
}
|
||||
c = getc(fp);
|
||||
while (c == '#') {
|
||||
while (getc(fp) != '\n');
|
||||
c = getc(fp);
|
||||
}
|
||||
ungetc(c, fp);
|
||||
if (fscanf(fp, "%d %d", &image->x, &image->y) != 2) {
|
||||
fprintf(stderr, "Invalid image size in %s\n", fileName);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
if (fscanf(fp, "%d", &rgbColor) != 1) {
|
||||
fprintf(stderr, "Invalid rgb component in %s\n", fileName);
|
||||
}
|
||||
if (rgbColor != RGB_COLOR) {
|
||||
fprintf(stderr, "Invalid image color range in %s\n", fileName);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
while (fgetc(fp) != '\n');
|
||||
image->data = (colorChannel_t *)malloc(image->x * image->y * sizeof(imagePixel_t));
|
||||
if (!image) {
|
||||
fprintf(stderr, "malloc() failed");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
if (fread(image->data, 3 * image->x, image->y, fp) != image->y) {
|
||||
fprintf(stderr, "Loading image failed");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
fclose(fp);
|
||||
return image;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
mkPpmFile
|
||||
|
||||
gets output from the result of rdPpmFile and writes a new PPM file. Best Case is a
|
||||
carbon copy of the source image. Build for debugging
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
void mkPpmFile(char *fileName, imagePixel_t *image) {
|
||||
FILE* fp = fopen(fileName, "wb");
|
||||
if (!fp) {
|
||||
fprintf(stderr, "Opening file failed.");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
fprintf(fp, "P6\n");
|
||||
fprintf(fp, "%d %d\n", image->x, image->y);
|
||||
fprintf(fp, "%d\n", RGB_COLOR);
|
||||
fwrite(image->data, 3 * image->x, image->y, fp);
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
ppmColorChannel
|
||||
|
||||
gets one of the rgb color channels and writes them to a file
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
int ppmColorChannel(FILE* fp, imagePixel_t *image) {
|
||||
// int length = (image->x * image->y) / 3;
|
||||
int i = 0;
|
||||
|
||||
if (image) {
|
||||
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) {
|
||||
fprintf(fp, "%d\n", image->data[i].green);
|
||||
}
|
||||
}
|
||||
fclose(fp);
|
||||
return NUMBER_OF_SAMPLES;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
colorSamples
|
||||
|
||||
reads colorChannel values from file and stores them in xSamples as well as points datatype for
|
||||
creating the SVG graph
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
void colorSamples(FILE* fp) {
|
||||
int i = 0;
|
||||
char buffer[NUMBER_OF_SAMPLES];
|
||||
|
||||
while (!feof(fp)) {
|
||||
if (fgets(buffer, NUMBER_OF_SAMPLES, fp) != NULL) {
|
||||
sscanf(buffer, "%lf", &xSamples[i]);
|
||||
//printf("%lf\n", xSamples[i] );
|
||||
points[i].yVal[0] = xSamples[i];
|
||||
points[i].xVal[0] = i;
|
||||
++i;
|
||||
}
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================================================================================================
|
||||
|
||||
windowXMean
|
||||
|
||||
returns mean value of given input, which has a length of WINDOWSIZE
|
||||
|
||||
======================================================================================================
|
||||
*/
|
||||
|
||||
double windowXMean(int _arraylength, int xCount) {
|
||||
double sum = 0.0;
|
||||
double *ptr;
|
||||
|
||||
for (ptr = &xSamples[xCount - _arraylength]; ptr != &xSamples[xCount]; ptr++) { //set ptr to beginning of window
|
||||
sum += *ptr;
|
||||
}
|
||||
return sum / (double)_arraylength;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
## Installation
|
||||
|
||||
Use `$ make` or compile it anywhere else.
|
||||
It had to be ANSI C so it even compiles on VS.
|
||||
This code is ANSI compatible . Nevertheless if you use Visual Studio use the C++ implementation in __../src/cpp_implementation__
|
||||
|
||||
|
||||
## Features
|
||||
|
|
@ -12,7 +12,7 @@ This little piece of code compares 3 different implementations of a least mean s
|
|||
+ direct predecessor
|
||||
+ differential predecessor
|
||||
|
||||
Greyscale PPM files can be used for input at this iteration. Output will be generated as .txt files with predicted value generated by the filter and its error value as well as given actual value from the PPM file. Furthermore there is an output as an svg graph to compare the implementatiosn on a visual level. Just open __graphResults.html__.
|
||||
Greyscale PPM files can be used for input at this iteration. Output will be generated as .txt files with predicted value generated by the filter and its error value as well as given actual value from the PPM file. Furthermore there is an output as an svg graph to compare the implementatiosn on a visual level. These graphical results are build from __graphResults_template.html__ which creates the actual output to __graphResults.html__. Open this file to see the results.
|
||||
You can hide graphs by clicking on its name for better visibility.
|
||||
|
||||
Use `$ ./lms -h` for help.
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue