From b4d2569f46b48e6962f0f6fbc3b19376b7bb3c84 Mon Sep 17 00:00:00 2001
From: kbecke23 <kevin.becker@telekom.de>
Date: Mon, 7 May 2018 15:10:11 +0200
Subject: [PATCH] .cpp File for Visual Studio Support

---
 bin/NLMSvariants.cpp | 674 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 674 insertions(+)
 create mode 100644 bin/NLMSvariants.cpp

diff --git a/bin/NLMSvariants.cpp b/bin/NLMSvariants.cpp
new file mode 100644
index 0000000..0849c02
--- /dev/null
+++ b/bin/NLMSvariants.cpp
@@ -0,0 +1,674 @@
+//
+//  
+//  NLMSvariants.c
+//
+//  Created by FBRDNLMS on 26.04.18.
+//  Copyright © 2018 FBRDNLMS. All rights reserved.
+//
+
+#include <stdio.h>
+#include <math.h>
+#include <time.h>
+#include <stdlib.h>
+#include <string.h>
+#include <float.h> // DBL_MAX
+#include <codecvt>          // std::codecvt_utf8_utf16
+#include <locale>           // std::wstring_convert
+#include <string>           // std::wstring
+
+#define M 1000
+#define tracking 40 //Count of weights
+#define learnrate 1.0
+#define PURE_WEIGHTS 0
+#define USED_WEIGHTS 1
+#define RESULTS 3
+#define DIRECT_PREDECESSOR 2
+#define LOCAL_MEAN 4
+#define RGB_COLOR 255
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+double x[] = { 0 };
+double _x[M] = { 0 };
+double w[M][M] = { { 0 },{ 0 } };
+
+/* UTF-8 to UTF-16 win Format*/
+auto wstring_from_utf8(char const* const utf8_string)
+-> std::wstring
+{
+	std::wstring_convert< std::codecvt_utf8_utf16< wchar_t > > converter;
+	return converter.from_bytes(utf8_string);
+}
+
+/* *svg graph building* */
+typedef struct {
+	double xVal[7];
+	double yVal[7];
+}point_t;
+
+point_t points[M]; // [0]=xActual, [1]=xPredicted from directPredecessor, [2]=xPredicted from localMean
+
+				   /* *ppm reader/writer* */
+typedef struct {
+	unsigned char red, green, blue;
+}colorChannel_t;
+
+typedef struct {
+	int x, y;
+	colorChannel_t *data;
+}imagePixel_t;
+
+static imagePixel_t * readPPM(char *fileName);
+void mkPpmFile(char *fileNamem, imagePixel_t *image);
+int * ppmColorChannel(imagePixel_t *image);
+
+/* *file handling* */
+char * mkFileName(char* buffer, size_t max_len, int suffixId);
+char *fileSuffix(int id);
+void myLogger(FILE* fp, point_t points[]);
+#ifdef _WIN32 
+size_t getline(char **lineptr, size_t *n, FILE *stream);
+#endif
+void mkSvgGraph(point_t points[]);
+
+/* *rand seed* */
+double r2(void);
+double rndm(void);
+
+/* *math* */
+double sum_array(double x[], int length);
+void directPredecessor(void);
+void localMean(void);
+
+
+
+int main(int argc, char **argv) {
+	char fileName[50];
+	int i;
+
+	srand((unsigned int)time(NULL));
+
+	for (i = 0; i < M; i++) {
+		_x[i] += ((255.0 / M) * i); // Init test values
+		for (int k = 0; k < M; k++) {
+			w[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 <= tracking; i++) {
+		for (int k = 0; k < tracking; k++) {
+			fprintf(fp0, "[%d][%d] %lf\n", k, i, w[k][i]);
+		}
+	}
+	fclose(fp0);
+
+
+	// math magic
+	localMean();
+	directPredecessor(); // TODO: used_weights.txt has gone missing! 
+
+						 // 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 < tracking; k++) {
+			fprintf(fp1, "[%d][%d] %lf\n", k, i, w[k][i]);
+		}
+
+	}
+	fclose(fp1);
+
+	// getchar();
+	printf("DONE!");
+
+}
+
+
+/*
+=======================================================================================
+
+localMean
+
+
+Variant (1/3), substract local mean.
+
+=======================================================================================
+*/
+
+void localMean(void) {
+	char fileName[50];
+	double xError[M]; // includes e(n)
+	memset(xError, 0, M);// initialize xError-array with Zero
+	int xCount = 0; // runtime var	
+	int i;
+	mkFileName(fileName, sizeof(fileName), LOCAL_MEAN);
+	FILE* fp4 = fopen(fileName, "w");
+	fprintf(fp4, "\n\n\n\n*********************LocalMean*********************\n");
+
+	for (xCount = 1; xCount < M; xCount++) {
+
+		//double xPartArray[xCount]; //includes all values at the size of runtime var
+
+		double xMean = (xCount > 0) ? (sum_array(_x, xCount) / xCount) : 0;// xCount can not be zero 
+
+		double xPredicted = 0.0;
+		double xActual = _x[xCount + 1];
+
+		for (i = 1; i < xCount; i++) { //get predicted value
+			xPredicted += (w[i][xCount] * (_x[xCount - i] - xMean));
+		}
+
+		xPredicted += xMean;
+		xError[xCount] = xActual - xPredicted;
+		points[xCount].xVal[2] = xCount;
+		points[xCount].yVal[2] = xPredicted;
+		double xSquared = 0.0;
+
+		for (i = 1; i < xCount; i++) { //get x squared
+			xSquared = +pow(_x[xCount - i], 2);
+		}
+
+		for (i - 1; i < xCount; i++) { //update weights
+			w[i][xCount + 1] = w[i][xCount] + learnrate * xError[xCount] * (_x[xCount - i] / xSquared);
+		}
+
+		fprintf(fp4, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
+	}
+	int xErrorLength = sizeof(xError) / sizeof(xError[0]);
+	double mean = sum_array(xError, xErrorLength) / M;
+	double deviation = 0.0;
+
+	// Mean square
+	for (i = 0; i < M - 1; i++) {
+		deviation += pow(xError[i], 2);
+	}
+	deviation /= xErrorLength;
+
+
+	// write in file
+	mkFileName(fileName, sizeof(fileName), RESULTS);
+	FILE *fp2 = fopen(fileName, "w");
+	fprintf(fp2, "quadr. Varianz(x_error): {%f}\nMittelwert:(x_error): {%f}\n\n", deviation, mean);
+	fclose(fp2);
+	fclose(fp4);
+}
+
+
+/*
+===================================
+
+directPredecessor
+
+
+Variant (2/3),
+substract direct predecessor
+
+===================================
+*/
+
+void directPredecessor(void) {
+	char fileName[512];
+	double xError[2048];
+	int xCount = 0, i;
+	double xActual;
+
+	// File handling
+	mkFileName(fileName, sizeof(fileName), DIRECT_PREDECESSOR);
+	FILE *fp3 = fopen(fileName, "w");
+	fprintf(fp3, "\n\n\n\n*********************DirectPredecessor*********************\n");
+
+	for (xCount = 1; xCount < M + 1; xCount++) {
+		xActual = _x[xCount + 1];
+		double xPredicted = 0.0;
+
+		for (i = 1; i < xCount; i++) {
+			xPredicted += (w[i][xCount] * (_x[xCount - i] - _x[xCount - i - 1]));
+		}
+		xPredicted += _x[xCount - 1];
+		xError[xCount] = xActual - xPredicted;
+
+		fprintf(fp3, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
+		points[xCount].xVal[0] = xCount;
+		points[xCount].yVal[0] = xActual;
+		points[xCount].xVal[1] = xCount;
+		points[xCount].yVal[1] = xPredicted;
+
+		double xSquared = 0.0;
+
+		for (i = 1; i < xCount; i++) {
+			xSquared += pow(_x[xCount - i] - _x[xCount - i - 1], 2); // substract direct predecessor
+		}
+		for (i = 1; i < xCount; i++) {
+			w[i][xCount + 1] = w[i][xCount] + learnrate * xError[xCount] * ((_x[xCount - i] - _x[xCount - i - 1]) / xSquared); //TODO: double val out of bounds
+		}
+	}
+
+	int 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);
+	}
+
+
+	mkSvgGraph(points);
+	fprintf(fp3, "{%d}.\tLeast Mean Squared{%f}\tMean{%f}\n\n", xCount, deviation, mean);
+	fclose(fp3);
+}
+
+
+
+
+/*
+=========================================================================
+
+mkFileName
+
+
+Writes the current date plus the suffix with index suffixId
+into the given buffer. If[M ?K 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" };
+	return suffix[id];
+}
+
+
+/*
+==========================================================================
+
+svgGraph
+
+
+==========================================================================
+*/
+/*
+void Graph ( ) {
+char fileName[50];
+mkFileName(fileName, sizeof(fileName), GRAPH);
+FILE* fp4 = fopen(fileName, "w");
+pfrintf
+*/
+
+
+/*
+==========================================================================
+
+myLogger
+
+
+Logs on filepointer, used for svg graphing
+
+==========================================================================
+*/
+
+void myLogger(FILE* fp, point_t points[]) {
+	/*int i;
+	for (i = 0; i <= M; i++) { // xActual
+		fprintf(fp, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]);
+	}
+	fprintf(fp, "\" fill=\"none\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
+	for (i = 0; i < M - 1; i++) { // xPred from directPredecessor
+		fprintf(fp, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
+	}
+	fprintf(fp, "\" fill=\"none\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
+	for (i = 0; i <= M; i++) { //xPred from lastMean
+		fprintf(fp, "L %f %f\n", points[i].xVal[2], points[i].yVal[2]);
+	}*/
+}
+
+void bufferLogger(char *buffer, point_t points[]) {
+	int i;
+	char _buffer[512] = "";
+
+	for (i = 0; i <= M; i++) { // xActual
+		sprintf(_buffer, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
+		strcat(buffer, _buffer);
+	}
+	strcat(buffer, "\" fill=\"none\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
+	for (i = 0; i < M - 1; i++) { // xPred from directPredecessor
+		sprintf(_buffer, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
+		strcat(buffer, _buffer);
+	}
+	strcat(buffer, "\" fill=\"none\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
+	for (i = 0; i <= M; i++) { //xPred from lastMean
+		sprintf(_buffer, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
+		strcat(buffer, _buffer);
+	}
+}
+
+
+/*
+=========================================================================
+
+sum_array
+
+
+Sum of all elements in x within a defined length
+
+=========================================================================
+*/
+
+double sum_array(double x[], int length) {
+	int i = 0;
+	double sum = 0.0;
+
+	for (i = 0; i< length; i++) {
+		sum += x[i];
+	}
+	return sum;
+}
+
+
+/*
+==========================================================================
+
+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;
+}
+
+
+
+/*
+==========================================================================
+
+getline
+
+This code is public domain -- Will Hartung 4/9/09 //edited by Kevin Becker
+Microsoft Windows is not POSIX conform and does not support getline.
+
+=========================================================================
+*/
+#ifdef _WIN32 
+size_t getline(char **lineptr, size_t *n, FILE *stream) {
+	char *bufptr = NULL;
+	char *p = bufptr;
+	size_t size;
+	int c;
+
+	if (lineptr == NULL) {
+		return -1;
+	}
+	if (stream == NULL) {
+		return -1;
+	}
+	if (n == NULL) {
+		return -1;
+	}
+	bufptr = *lineptr;
+	size = *n;
+
+	c = fgetc(stream);
+	if (c == EOF) {
+		return -1;
+	}
+	if (bufptr == NULL) {
+		char c[128];
+		memset(c, 0, sizeof(c));
+		bufptr = c;
+		if (bufptr == NULL) {
+			return -1;
+		}
+		size = 128;
+	}
+	p = bufptr;
+	while (c != EOF) {
+		if ((p - bufptr) > (size - 1)) {
+			size = size + 128;
+			realloc(bufptr, size);
+			if (bufptr == NULL) {
+				return -1;
+			}
+		}
+		*p++ = c;
+		if (c == '\n') {
+			break;
+		}
+		c = fgetc(stream);
+	}
+
+	*p++ = '\0';
+	*lineptr = bufptr;
+	*n = size;
+
+	return p - bufptr - 1;
+}
+#endif
+
+
+/*
+==========================================================================
+
+mkSvgGraph
+
+parses template.svg and writes results in said template
+
+==========================================================================
+*/
+
+void mkSvgGraph(point_t points[]) {
+	FILE *input = fopen("template.svg", "r");
+	FILE *target = fopen("output.svg", "w");
+	char line[512];
+	// char *ptr;
+	//size_t len = 0;
+	//ssize_t read;
+	//char values[64];
+	char firstGraph[15] = { "<path d=\"M0 0" };  
+
+	if (input == NULL) {
+		exit(EXIT_FAILURE);
+	}
+	
+	char buffer[131072] = "";
+	
+	memset(buffer, '\0', sizeof(buffer));
+	//int length = 0;
+	while(!feof(input)) {
+		fgets(line, 512, input);
+		strncat(buffer, line,strlen(line));
+		printf("%s\n", line);
+		if (strstr(line, firstGraph) != NULL) {
+			bufferLogger(buffer, points);
+		}
+
+	}
+	fprintf(target, buffer);
+	//int c = 0;
+	puts(buffer);
+	//getchar();
+	
+	//if (strstr(line, firstGraph) != NULL) {
+	//	//fprintf(target,"HECK!!!\n");
+	//	bufferLogger(strstr(line, firstGraph),sizeof(firstGraph), points);
+	//}
+
+	/*while ((read = getline(&line, &len, input)) != -1) {
+		//printf("Retrieved line of length %zu :\n", read);
+		//puts(line); // debug purpose 
+		fprintf(target, "%s", line);
+		if (strstr(line, firstGraph) != NULL) {
+			fprintf(target,"HECK!!!\n");
+			myLogger(target, points);
+		}
+	}*/
+
+	/*free(line);
+	free(target);
+	free(input);*/
+	//exit(EXIT_SUCCESS);
+}
+
+/*
+===========================================================================
+
+rdPPM
+
+reads data from file of type PPM, stores colorchannels in a struct in the
+size of given picture
+
+==========================================================================
+*/
+
+static imagePixel_t *rdPPM(const 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 mkPpmFile. Best Case is a
+carbon copy of the source image
+
+=======================================================================================
+*/
+
+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 returns the array
+
+======================================================================================
+*/
+
+int * ppmColorChannel(imagePixel_t *image) {
+	int length = (image->x * image->y) / 3;
+	int i = 0;
+	int buffer[10];
+	realloc(buffer,length);
+
+	printf("%d\n", length);
+	if (image) {
+		for (i = 0; i < length; i++) {
+			buffer[i] = image->data[i].green;
+			//output[i] = image->data[i].blue;
+			//output[i] = image->data[i].red;
+		}
+	}
+	return buffer;
+}
\ No newline at end of file