// Koerper.cpp: Implementierung der Klasse Koerper.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "koerper.h"
#include <stdlib.h>
#include <iostream.h>
#include <string.h>

//////////////////////////////////////////////////////////////////////
// Konstruktion/Destruktion
//////////////////////////////////////////////////////////////////////

koerper::koerper(unsigned short n, unsigned short epsilon) /* n gibt die Anzahl der Elemente des Körpers an, epsilon = 0/1 */
{
	koerper::anzahl = n;
	koerper::epsilon = epsilon;
	koerper::initAdd();
	koerper::initMult();
	koerper::initInv();
}

koerper::~koerper()
{
	free(additionstafel);
	free(multiplikationstafel);
	free(inverses);
}

int koerper::getIndex(zahl z1, zahl z2) /* gibt den Index in der Multiplikations- bzw. Additionstabelle zurück */
{
	return(z1.x*anzahl*anzahl*anzahl + z1.eps*anzahl*anzahl + z2.x*anzahl + z2.eps);
}

void koerper::initAdd()
{
	/* erstellt die Additionstabelle */
	/* Matrix zahl x zahl = zahl */
	
	unsigned short i;
	unsigned short j;
	unsigned short k;
	unsigned short l;

	additionstafel = (zahl*)malloc(sizeof(zahl)*anzahl*anzahl*anzahl*anzahl);
	zahl z1;
	zahl z2;
	int index;
	for (i=0; i<anzahl; i++)
		for (j=0; j<((anzahl-1)*epsilon)+1; j++)
			for (k=0; k<anzahl; k++)
				for (l=0; l<((anzahl-1)*epsilon)+1; l++)
				{
					z1 = zahl(i,j);
					z2 = zahl(k,l);
					index = getIndex(z1, z2);
					additionstafel[index].x = ((int)z1.x + (int)z2.x)%anzahl;
					additionstafel[index].eps = ((int)z1.eps + (int)z2.eps)%anzahl;
//					if ((z1.x == 17) && (z2.x== 18) )
//						cout << z1.x << ',' << z1.eps << " + " << z2.x << ',' << z2.eps << " = " << additionstafel[index].x << ',' << additionstafel[index].eps << '\n';
				}

	cout << "Addition OK\n";
	cout.flush();
}

void koerper::initMult()
{
	/* erstellt die Multiplikationstabelle */
	/* Matrix zahl x zahl = zahl */
	
	unsigned short i;
	unsigned short j;
	unsigned short k;
	unsigned short l;
	zahl z1;
	zahl z2;
	int index;


	multiplikationstafel = (zahl*)malloc(sizeof(zahl)*anzahl*anzahl*anzahl*anzahl);
	for (i=0; i<anzahl; i++)
		for (j=0; j<((anzahl-1)*epsilon)+1; j++)
			for (k=0; k<anzahl; k++)
				for (l=0; l<((anzahl-1)*epsilon)+1; l++)
				{
					z1 = zahl(i,j);
					z2 = zahl(k,l);
					index = getIndex(z1, z2);
					multiplikationstafel[index].x = ((int)z1.x * (int)z2.x)%anzahl;
					multiplikationstafel[index].eps = ((int)z1.x * (int)z2.eps + (int)z2.x * (int)z1.eps)%anzahl;
//					if ((z1.x == 17) && (z2.x== 18))
//						cout << z1.x << ',' << z1.eps << " * " << z2.x << ',' << z2.eps << " = " << multiplikationstafel[index].x << ',' << multiplikationstafel[index].eps << '\n';
					/* eps * eps = 0 */
				}

	cout << "Multiplikation OK\n";
	cout.flush();
}

void koerper::initInv()
{
	/* erstellt die Tabelle für Inverses */
	/* Matrix zahl = zahl */

	unsigned short i;
	unsigned short j;
	unsigned short k;
	unsigned short l;
	zahl z1;
	zahl z2;
	zahl z;

	inverses = (zahl*)malloc(sizeof(zahl)*anzahl*anzahl);
	for (i=0; i<anzahl; i++)
		for (j=0; j<((anzahl-1)*epsilon)+1; j++)
		{
			z1 = zahl(i,j);
			inverses[getIndex(0, z1)]  = 0; /* falls kein inverses gefunden */
			for (k=0; k<anzahl; k++)
				for (l=0; l<((anzahl-1)*epsilon)+1; l++)
				{
					
					z2 = zahl(k,l);
					z = multipliziere (z1, z2);
					if ((z.x == 1)&&(z.eps==0))
					{
						inverses[getIndex(0, z1)] = z2;
						break;
					}
				}
		}
	cout << "Inverses OK\n";
	cout.flush();

}

zahl koerper::addiere(zahl a, zahl b)
{
	//addiert zwei Zahlen
	zahl z;

	zahlOK(&a);
	zahlOK(&b);

	z = additionstafel[getIndex(a, b)];

	return(z);
}

zahl koerper::addiere(zahl a, zahl b, zahl c)
{
	return (addiere(addiere(a, b), c));
}

zahl koerper::multipliziere(zahl a, zahl b)
{
	//multipliziert zwei Zahlen
	zahl z;

	zahlOK(&a);
	zahlOK(&b);
	z = multiplikationstafel[getIndex(a,b)];

	
	return(z);
}

zahl koerper::multipliziere(zahl a, zahl b, zahl c)
{
	return(multipliziere(multipliziere(a, b), c));
}

zahl koerper::invers(zahl a)
{
	//invertiert eine Zahl
	zahl z;

	zahlOK(&a);
	z = inverses[getIndex(0, a)];

	if ((z.x==0) && (z.eps == 0))
	{
		char fehler[1000];
		int j;
		j = sprintf(fehler, "0001: Fehler bei Division bei 1 / (%d,%d*eps) " , a.x , a.eps );
		throw(fehler);
	}
	return(z);
}

zahl koerper::dividiere(zahl a, zahl b)
{
	//bildet a / b
	zahl z;
	zahl bInvers;

	bInvers = invers(b);
	z = multipliziere(a, bInvers);

	return(z);
}

zahl koerper::negativ(zahl a)
{
	//bildet -a
	zahl z;
	zahlOK(&a);
	z.x = (anzahl - a.x) % anzahl;
	z.eps = (anzahl - a.eps) % anzahl;

	return(z);
}

zahl koerper::naechsteZahl (zahl a)
{
	//bildet a+1
	zahl z(1);
	return addiere(a,z);
}

void koerper::zahlOK(zahl *a)
{
	if ((a->x >= anzahl)) //||(a->x<0)) da unsigned gibt es kein < 0
		a->x = a->x % anzahl;
	if ((a->eps >= anzahl)) //||(a->eps <0))da unsigned gibt es kein < 0
		a->eps = a->eps % anzahl;
}