Höhere Mathematik in C++?

Es ist unglaublich, was digitale Technik kann...(mit ganz ainfachen , primitiven Mitteln)...

// Limes.cpp
#include <iostream>
#include <cmath>
using namespace std;
const float e = 2.71828182;
float deltaX = 1, x;
float derivation;
float ypsilon(float x) {
	return pow(x, 2) + x + 5;
}

float ypsilon2(float x) {
	return pow(x, 3) + 2*x - 5;
}

float ypsilon3(float x) {
	return pow(e, x);
}

int main() {

	cout << "Please the derivation point x: ";
	cin >> x;
	
	for (int u = 0; u < 6; u++) {
		deltaX /= 10;
		derivation = (ypsilon(x) - ypsilon(x - deltaX)) / deltaX;
		cout << " derivation mit deltaX: " << deltaX << " " << derivation << endl;
	}
	deltaX = 1;
	for (int u = 0; u < 5; u++) {
		deltaX /= 10;
		derivation = (ypsilon2(x) - ypsilon2(x - deltaX)) / deltaX;
		cout << " derivation with deltaX: " << deltaX << " " << derivation << endl;
	}

	deltaX = 1;
	for (int u = 0; u < 5; u++) {
		deltaX /= 10;
		derivation = (ypsilon3(x) - ypsilon3(x - deltaX)) / deltaX;
		cout << " derivation with deltaX: " << deltaX << " " << derivation << endl;
	}


}
```cpp
```cpp
```cpp

SeppJ

Falls da irgendwie eine Frage drin stecken sollte, was man zu dem Thema noch sagen kann: Das gezeigte ist nur die nullte Ordnung, dessen, was man da so machen kann. Hier ist Inspiration, wo die Reise in der Numerik hingehen kann: https://en.wikipedia.org/wiki/Numerical_differentiation

Man kann einem Computer auch beibringen, mit Formeln zu rechnen, also dass er dir zum Beispiel berechnet, dass die Ableitung von pow(x, 2) + x + 5 gleich 2 * x + 1 ist. Das ist dann aber gleich viel schwieriger, als nur die Formeln abzuschreiben, die ein Numeriker ausgerechnet hat.

Falls da eine Frage zur technischen Verbesserung der Programmierweise drin sein sollte:

Abstraktion erhöhen, anstatt den gleichen Code 3x fast identisch zu wiederholen. Funktionen können beispielsweise auch andere Funktionen als Argument haben, so dass man eine Funktion schreiben kann, welche die Ableitung einer gegebenen Funktion berechnet.
Globale Variablen rauswerfen, sondern stattdessen alles so lokal wie möglich machen. Auch keine Variablen für andere Zwecke wiederverwenden.

@SeppJ Danke , ich mach das....

Quiche Lorraine

@odalv sagte in Höhere Mathematik in C++?:

Es ist unglaublich, was digitale Technik kann...(mit ganz ainfachen , primitiven Mitteln)...

Ein kleiner Tip. Schaue dir doch mal die GSL - GNU Scientific Library an und stöbere in der Dokumentation.

Die GSL ist eine Numerik Lib mit welcher ich programmiertechnisch relativ schnell eine dünnbesetzte 10^7 x 10^7 Matrix invertieren konnte. Die Lib hat auch so schöne Dinge wie Simulated Annealing, FFT, Splines,...

@Quiche-Lorraine , vielen Dank, Das will ich lernen , merci....

@SeppJ ich wäre dankbar für jeden Kommentar, mein Problem ist das gesammelte Wissen hier zu implementieren.

GegenSache von Derivieren ist Integrieren::

ich hofe, es ist besser.....?

// Integral
#include <iostream>
#include <cmath>
using namespace std;



float ypsilon(float x) {
	return pow(x, 2);
}

float euler(float x) {
	return pow(2.718281, x);
}

float eLaL(float x) {
	return log(x);
}

void integral(float (* ypsilon)(float x), float x1, float x2) {
	int i = 1;
	float deltaX = (x2 - x1) / 100000;
	float integral = 0.0;
	for (double v = x1; v <= x2; i++) {
		integral += ypsilon(x1 + deltaX * i) * deltaX;
		v += deltaX;
	}
	cout << " integral mit deltaX: " << deltaX << " " << integral << endl;
}


int main() {
	float x1 = 0, x2 = 0;
	
	
	cout << "Bitte x1: ";
	cin >> x1;
	cout << "Bitte x2: ";
	cin >> x2;
	integral( ypsilon, x1, x2);
	integral(euler, x1, x2);
	integral(eLaL, x1, x2);
}

Man kann die LaufZeit noch messen, abhängig von deltaX.....

SeppJ

Viel besser . Eine Sache stört mich aber noch, und solltest du dir schnell abgewöhnen: Eine Funktion sollte exakt eine Sache machen. Deine macht zwei: Sie berechnet das Integral und sie gibt eine Textmeldung darüber aus. Nun kannst du niemals Integrale berechnen, ohne dass diese Meldung in dieser Form kommt. Du kannst nicht mehr entscheiden, was mit dem berechneten Ergebnis passiert. Besser: Eine Integrationsfunktion, die ihr Ergebnis als Rückgabe hat. Dann kann der Aufrufer entscheiden, was mit diesem Ergebnis zu tun ist. Das kann auch Übergabe an eine Textausgabefunktion sein, kann aber auch vieles anderes sein. So erhöht sich die Wiederverwertbarkeit deiner Funktionen. Außerdem werden sie viel einfacher und genauer zu testen.

@SeppJ danke für gute Vorschläge, ich war COBOL Programmierer und OOP muss ich mehr üben.