#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define WITHHEXDUMP 0

// MIN A
double *allocate_double(long len);
void free_double(double *mem);
void print(double *mem, long len);

// MIN B
double *double_size(double *zahl, long old_size);
long sub(double *a, long size1, double *b, long size2,
	double *c, long size3);

void clearstdin();


void clearstdin()
{
	while(getchar()!='\n');
}

double *allocate_double(long len)
{
	long size_bytes=len*sizeof(double);
	double *adrptr=0;
	printf("*** ALLOCATE_DOUBLE ***\n");
	printf("ALLOCATION OF %ld BYTES FOR %ld DOUBLES:\n",
	size_bytes, len);
	if(!(adrptr=malloc(size_bytes)))
	{
		printf("MALLOC ERROR OR OUT OF MEMORY.\n");
		printf("BUY DISCOUNTED RAM CHEAP: 1-800-HYNIX.\n");
		exit(-1);
	}
	printf("ALLOCATION DONE AT %p\n",adrptr);
	return adrptr;
}

void free_double(double *mem)
{
	printf("*** FREE_DOUBLE ***\n");
	if(!mem)
	{
		printf("ATTEMPT TO FREE A NULL POINTER.\n");
		exit(-1);
	}
	free(mem);
	printf("FREED MEMORY AT %p\n",mem);
}



void print(double *mem, long len)
{
	int i;
	unsigned char *byteptr=(unsigned char*) mem;
	printf("*** PRINT ***\n");
	printf("ACCESSING MEMORY AT %p\n",mem);
	for(i=0;i<len;i++)
		printf("%20lf%c", mem[i], (i+1)%3?' ':'\n');
	putchar('\n');

#if WITHHEXDUMP

	// "welche die darin enthaltenen Zeichen ausgibt" ?!!?!
	// OK, hier kommt der HEX-Dump:
	// Ich glaube nicht, dass es ernst gemeint ist sondern
	// ein Fehler in der Angabe... Aber ein HEX-Dump ist
	// nuetzlich um zu sehen, wie es im Speicher aussieht
	// und die Adressen.
	// Diesen Teil kann man also ziemlich sicher WEGLASSEN:

	for(i=0;i<len*sizeof(double);i++)
	{
		if(!(i%16))
			printf("\n%p:",byteptr+i);
		printf("%02X ", byteptr[i]);
	}
	putchar('\n');
#endif

}



double *double_size(double *zahl, long old_size)
{
	long size_bytes=old_size*2*sizeof(double);
	double *adrptr=0;
	printf("*** DOUBLE_SIZE ***\n");
	printf("REALLOCATION OF %ld BYTES FOR %ld DOUBLES\n",size_bytes,old_size*2);
	if(!(adrptr=realloc(zahl, size_bytes)))
		printf("REALLOCATION FAILED.\n");
	else
		printf("NEW ADRESS %p\n", adrptr);
	return adrptr;
	//Warum wird hier nicht explizit return 0 gemacht? Weil realloc ja bereits
	//0 zurueckliefert und sich um das sowieso im Beispiel die aufrufende
	//Fkt kuemmert, daher kommt nur eine Fehlermeldung.
}

// Ergibt mit double's irgendwie keinen Sinn, sie "numerisch" (Ziffer fuer Ziffer) zu subtrahieren?
long sub(double *a, long size1, double *b, long size2, double *c, long size3)
{
	printf("*** SUB ***\n");
	printf("ACCESSING A AT %p\n",a);
	printf("ACCESSING B AT %p\n",b);
	printf("ACCESSING C AT %p\n",c);
	if(size2>size1)
	{
		printf("CANNOT SUBTRACT LARGER FROM SMALLER NUMBER\n");
		return 0;
	}
	if(size3<size1)
	{
		printf("NOT ENAUGH ROOM FOR RESULT.\n");
		return 0;
	}
	if(!a || !b || !c)
	{
		printf("MEMORY BUFFER(S) NOT ALLOCATED.\n");
		return(0);
	}
	memset(c, 0, size3*sizeof(double));
	int i, carry=0;

	//Anm: Eigentlich heisst es korrekt "borrow" und nicht "carry" beim Subtr.
	for(i=1;i<=size1;i++)
	{
		c[size3-i]=a[size1-i]-carry;	//Ein ev. Carry aus dem vorherigen Schritt abziehn
		if(!(i>size2))			//Solange es Zahlen zum subtrahieren gibt
			c[size3-i]-=b[size2-i];	//diese auch abziehen
		carry=0;			//Carry null setzen
		if(c[size3-i] < 0)		//Wenn etwas negatives rauskommt:
		{
			c[size3-i]=10+c[size3-i]; // Wrap-Around um 10
			carry=1;		 //Carry setzen
		}
	}
	return 1;
}


int main()
{
	int i;
	int num;
	int size1, size2, size3;
	double *new;
	double *buffer=allocate_double(20);
	double *a, *b, *c;
	sranddev();
	for(i=0;i<20;i++)
		buffer[i]=sin(rand())*rand();
	print(buffer,20);
	printf("PRESS RETURN\n");
	clearstdin(); // WAIT KEY
	new=double_size(buffer,20);
	if(!new)
	{
		printf("COULDN'T DOUBLE BUFFER SIZE...\n");	//Realloc ging nicht
		free_double(buffer);
		buffer=0;
	}
	else
	{
		buffer=new;					//Realloc ging, dann noch paar konstante Werte als Beweis
		printf("ADDING SOME CONSTANT VALUES...\n");	//reinschreiben und diese ausgeben.
		for(i=20;i<40;i++)
			buffer[i]=1234;
		print(buffer,40);
		free_double(buffer);
		buffer = new = 0;
	}
	printf("PRESS RETURN\n");
	clearstdin(); // WAIT KEY

	// Groessen fuer 3 Arrays abfragen und diese dann allocen
	// Diese Arrays werden nachher zum subtrahieren verwendet
	// Deswegen sollte B kleiner als A sein und C mindestens
	// so gross wie A (z.b. A=10, B=5, C=10)
	printf("ENTER SIZE (ELEMENTS) OF 3 DYNAMIC ARRAYS:\n");
	printf("1: ");
	scanf("%d",&size1);
	clearstdin();
	printf("2: ");
	scanf("%d",&size2);
	clearstdin();
	printf("3: ");
	scanf("%d",&size3);
	clearstdin();
	a=allocate_double(size1);
	b=allocate_double(size2);
	c=allocate_double(size3);
	printf("PRESS RETURN\n");
	clearstdin(); // WAIT KEY

	i=0;
	do
	{
		printf("RANDOM FILL? Y/N: ");
		switch(getchar())
		{
			case 'y':			//Mit ZUfallszahlen ausfuellen
			case 'Y':
				for(i=0;i<size1;i++)
					a[i]=rand()%10;	//Modulo 10 dient dazu, damit nur 1 Ziffer drinsteht
				for(i=0;i<size2;i++)
					b[i]=rand()%10;
				break;
			case 'n':
			case 'N':			//Ziffern manuell eingeben (Achtung, nur 1 Ziffer eingeben,
							Angabe ist hier sinnlos wegen Doubles, also nicht 0.5 eingb)
				printf("VALUES FOR A:\n");
				for(i=0;i<size1;i++)
				{
					printf("%u: ",i);
					scanf("%lf",&a[i]);
				}
				printf("VALUES FOR B:\n");
				for(i=0;i<size2;i++)
				{
					printf("%u: ",i);
					scanf("%lf",&b[i]);
				}
				break;
			default:
				clearstdin();
				continue;
		}
	} while(!i);
	print(a,size1);
	printf("PRESS RETURN\n");
	clearstdin();	//WAIT KEY
	print(b,size2);
	printf("PRESS RETURN\n");
	clearstdin();	//WAIT KEY
	printf("SUBTRACTING...\n");
	sub(a,size1,b,size2,c,size3);
	print(c,size3);
	printf("PRESS RETURN\n");
	clearstdin();  //WAIT KEY
	if(a)
		free_double(a);
	if(b)
		free_double(b);
	if(c)
		free_double(c);
	printf("That's all folks...\n");
	return 0;
}