// globale Variable als Parameter für DGL_infektion
double lambda_global = 0.01;

// DGL erster Ordnung, die die Ausbreitung einer Infektion beschreibt
// benoetigt lambda_global als globale Variable
double DGL_infektion(CMyVektor y, double x)
{
	////////////////////////////////////////////////
	// TODO: Hier Ihre CMyVector-Zugriffsfunktion einsetzen
	////////////////////////////////////////////////
	double y_aktuell = y(0);     // y.getKomponent(0)
	///////////////////////////////////////////////

	return lambda_global * y_aktuell * (1 - y_aktuell);
}

// Funktion zur Berechnung der Summe von quadratischen Abweichungen
// der DGL-Loesungen mit Parametern parameter zu beobachteten Werten
// IN: CMyVektor mit zwei Eintraegen.
double DGL_abweichung(CMyVektor parameter)
{
	vector<double> m(7);
	////////////////////////////////////////////////
	// TODO: Hier Ihre individuellen Werte eintragen
	////////////////////////////////////////////////
	m[0] = 0.015;          // gemeldeter Anteil Woche 0
	m[1] = 0.026;          // gemeldeter Anteil Woche 1
	m[2] = 0.044;          // gemeldeter Anteil Woche 2
	m[3] = 0.077;          // gemeldeter Anteil Woche 3
	m[4] = 0.137;          // gemeldeter Anteil Woche 4
	m[5] = 0.224;          // gemeldeter Anteil Woche 5
	m[6] = 0.349;          // gemeldeter Anteil Woche 6
	///////////////////////////////////////////////

	double u;
	////////////////////////////////////////////////
	// TODO: Hier Ihre CMyVector-Zugriffsfunktion einsetzen
	////////////////////////////////////////////////
	lambda_global = parameter(0);   // parameter.getKomponent(0)
	u = parameter(1);				// parameter.getKomponent(1)
	///////////////////////////////////////////////

	// BEGINN: Berechnung der DGL-Lösung zu t=1,2,...,6

	C_DGLSolver solver(DGL_infektion);
	CMyVektor y(1);
	vector<double> DGL_loes(7);	// Vektor mit DGL-Loesungen in Woche k
	// Startwert setzen
	////////////////////////////////////////////////
	// TODO: Hier Ihre CMyVector-Zugriffsfunktion einsetzen
	////////////////////////////////////////////////
	y(0) = u * m[0];   // y.setKomponent(0) = u*m[0];
	///////////////////////////////////////////////
	DGL_loes[0] = u * m[0];

	// die DGL sukzessive von Woche zu Woche lösen
	// Endwert der aktuellen Woche ist Startwert der neuen Woche
	double x_start, x_end;
	for (int i = 1; i <= 6; i++)
	{
		x_start = (double)(i - 1);
		x_end = (double)(i);
		y = solver.heun(x_start, x_end, 100, y);

		// berechneten Wert in DGL_loes ablegen
		////////////////////////////////////////////////
		// TODO: Hier Ihre CMyVector-Zugriffsfunktion einsetzen
		////////////////////////////////////////////////
		DGL_loes[i] = y(0);   // y.getKomponent(0)
		///////////////////////////////////////////////
	}
	// ENDE: Berechnung der DGL-Lösung zu t=1,2,...,6

	// Summe der quadratischen Abweichungen berechnen
	double sum = 0;
	double hilf;
	for (int i = 0; i < 7; i++)
	{
		hilf = DGL_loes[i] - m[i];
		sum += hilf * hilf;
	}
	////////////////////////////////////////////////
	// Falls Sie keine explizite Methode zum
	// Minimieren haben, können Sie hier auch -sum
	// zurückgeben.
	////////////////////////////////////////////////
	return sum;
}

// berechnet den Gradienten zu DGL_abweichung
// Diese Funktion kann dem Newton-Verfahren übergeben werden,
// um, wenn man in der Nähe der Extremstelle ist, schneller
// die Extremstelle anzunaehern.
CMyVektor gradient_DGL_abweichung(CMyVektor x)
{
	CMyVektor erg = gradient(x, DGL_abweichung);
	return erg;
}