Array mit double-Wertebereich füllen

[Ricky]

Hallo liebe community,

in einem Monat schreibe ich meine Informatikklausur an einer Hochschule.
dabei habe ich einige Altklausuren des Professors bearbeitet und war immer erfolgreich bis er vor ein paar Tagen eine andere Altklausur hochgeladen hat, die mich zum verzweifeln bringt.

es geht darum, dass man zwei Vektoren deklariert x und y also eindimensionale Arrays mit einer länge von 100 Feldern. Die sollen wir auch beide mit null initialisieren soweit so gut, doch dann kommt die zweite Aufgabe. Wir sollen das x-Array mit Zahlen befüllen die einen Wertebereich von 0-2pi haben. Die Y-Werte des Vektors sollen das Ergebnis der jeweiligen X-Werte haben, sprich die X-werte aus dem x-Array auslesen und dann durch die Funktion jagen und mit den jeweiligen Ergebnis das y-Array füllen.

ich habe Ansätze gemacht die zufälligen Zahlen zwischen 0-2pi kriege ich nicht hin, unser Prof meinte wenn sowas ist müsst ihr das mit srand machen dann mit % und den Wertebereich abstimmen, aber wenn ich das mache kommen ja nur int-Werte raus durch die % Operation.

ich habe vieles versucht doch ich bekomme den Array nicht mit den double Werten befüllt. probiert hatte ich folgendes:

#include <iostream>
#include <cmath>
#include <math.h>
#include <numbers>

using namespace std;
#define _USE_MATH_DEFINES 

double const pi = acos(-1);

int main() {
	srand((unsigned int)time(NULL));
	const int N = 100;
	double X[N] = { 0 };
	double Y[N] = { 0 };

	for (int i = 0; i < N; i++) {
		double j = rand() % 2*pi;
		X[i] = {j};
		cout << X[i] << endl;
	}
	
}

Da kam als befüllen entweder 0 oder pi heraus, dann habe ich probiert beim rand()% (2pi); hier war das Problem das der compiler ansich schon gemotzt hat, also habe ich mir eine Variable pi1= 2pi; deklariert und dan rand()% pi1; aber dann kommen nur ganzzahlen heraus was auch logisch ist da es sich um den %-Operator handelt.

Ich kann mal die Klausur hier reinstellen damit ihr sie euch auch angucken könnt.

hier geht's zur Altklausur

Vielen Dank für eure Hilfe im voraus!

[Ricky]

#include <iostream>
#include <cmath>
#include <math.h>
#include <numbers>
#include <iomanip>

using namespace std;
#define _USE_MATH_DEFINES 

double const pi = acos(-1);

int main() {
	srand((unsigned int)time(NULL));
	const int N = 100;
	double X[N] = { 0 };
	double Y[N] = { 0 };
	for (int i = 0; i < N; i++) {
		double j = ((double)(rand() % 10) / 1000);
		double l = ((double)(rand() % 10) / 100);
		double m = ((double)(rand() % 10) / 10);
		double k = (((double)(rand() % 3)) + j + l + m);
		double o;
		double p;
		if (k > 2) {
			k = 2 - ((double)(rand() % 10) / 10);
			o = k * pi;
		}
		o = k * pi;
		X[i] = { o };
		p = sin(o) * sin(o);
		Y[i] = { p };
		cout << fixed;
		
		cout<<"X-Wert " << X[i]  << setprecision(2) << endl;
		
		cout <<"Y-Wert " << Y[i] << setprecision(2) << endl;
	}
	
}

ich habe es "gelöst" ich glaube unschöner und komplizierter hätte man es einfach nicht lösen können. vielleicht gibt es verbesserungsvorschläge das wäre sehr nett.
ich würde dann einfach dannach pi rechnen als kpi hinterher.

[SeppJ]

Hast du mal Multiplikation in Betracht gezogen?

[Ricky]

@SeppJ anstatt die ganzen Variablen mit )m+l+... ? meinst du dort? sprich Zeile 21

[SeppJ]

@Ricky sagte in Array mit double-Wertebereich füllen:

@SeppJ anstatt die ganzen Variablen mit )m+l+... ? meinst du dort? sprich Zeile 21

Nein, ich meine wie in "Schmeiß deine Lösung weg, nimm Abstand, und denk noch einmal ganz neu über die Problemstellung nach!". Und da könnte vielleicht das Stichwort "Multiplikation" helfen.

[Ricky]

@SeppJ vielleicht hast du recht... vielleicht brauche ich einfach auch mal eine Pause die "lösung" funktioniert auf erster linie schonmal aber es ist einfach sehr umständlich gemacht... ich werde das dann bis Morgen ruhen lassen. Auch wenn es nicht zufriedenstellend ist so ins bett zu gehen. Aber Danke für den Anstoß! dein "jemanden komplett aus der Bahn werfen" hat mir grade auch irgendwie gut getan, sonst hätte ich bis morgens 5 Uhr noch versucht meine Lösung zu optimieren.

[SeppJ]

Vielleicht noch ein Hinweis: Die Lösung ist ganz furchtbar einfach.

[Th69]

@Ricky: Schau dir mal den Wertebereich von rand an und überlege, wie du dann eine Projektion auf den Wertebereich 0 - 2*PI hinbekommst (das eine Stichwort hat @SeppJ ja schon gegeben - und das andere ist das Gegenteil davon ;-).

[Quiche Lorraine]

@Ricky sagte in Array mit double-Wertebereich füllen:

ich habe Ansätze gemacht die zufälligen Zahlen zwischen 0-2pi kriege ich nicht hin, unser Prof meinte wenn sowas ist müsst ihr das mit srand machen dann mit % und den Wertebereich abstimmen, aber wenn ich das mache kommen ja nur int-Werte raus durch die % Operation.

Warum rand()? C++ hat doch viel bessere Möglichkeiten Zufallszahlen zu erzeugen.

Warum also keine Gleichverteilung nehmen?

Oder eine wunderschöne Normalverteilung?

[DirkB]

@Ricky Ist dir das Makro RAND_MAX bekannt?

https://en.cppreference.com/w/cpp/numeric/random/RAND_MAX

[Ricky]

@SeppJ @Th69 @Quiche-Lorraine ich habe auch mal mit dem Prof geschrieben... er meinte es ginge nicht darum den Array mit zufallszahlen zu füllen, sondern das de rAbstand zwischen den Werten gleich sein soll er hat mir dazu noch eine Aufgabe geschickt aber da blicke ich gar nicht mehr durch... da wollte ich es schritt für schritt durch arbeiten, aber ich blick es einfach nicht...
(
Die beiden Parameter µ (Mittelwert) und σ (Standardabweichung) sollen als
veränderliche Parameter vorgegeben werden.
b) Legen Sie eine konstante Variable DIM an, in der die Gesamtanzahl an
berechneten Werten gespeichert wird.
c) Legen Sie einen Vektor x für die x-Werte und einen Vektor y für die y-Werte der
Funktion mit der Länge DIM an.
d) Legen Sie die Variablen x_min und x_max an. Bestimmen Sie alle x-Werte im
Intervall [x_min; x_max]. Es sollen exakt DIM Werte berechnet werden und
der Abstand zwischen zwei Werten soll immer gleich groß sein. Die Ergebnisse
werden im Vektor x gespeichert.
)

bei d bin ich komplett raus, da habe ich keine Ahnung was genau gemeint ist wie ich das speicher und so ist kein thema, nur verstehe ich das mit dem abstand nicht, wenn es doch bis DIM geht und DIM ein int ist und DIM z.B. 1000 groß ist muss ich dann von 0-1000 die x werte da rein knallen in den Array? das macht doch keinen Sinn.... aber so hätte jeder Wert den gleichen Abstand zu dem anderen und zwar 1...

[Ricky]

@DirkB ja das ist mir bekannt, ist das ein wichtiges Problem?

[DirkB]

@Ricky sagte in Array mit double-Wertebereich füllen:

@DirkB ja das ist mir bekannt, ist das ein wichtiges Problem?

Damit kannst du den Wertebereich von rand() leicht auf 0.0 bis 1.0 umrechnen. Von da aus sollte es kein Problem sein, auf andere Bereiche zu rechnen.

[SeppJ]

@Ricky sagte in Array mit double-Wertebereich füllen:

d) Legen Sie die Variablen x_min und x_max an. Bestimmen Sie alle x-Werte im
Intervall [x_min; x_max]. Es sollen exakt DIM Werte berechnet werden und
der Abstand zwischen zwei Werten soll immer gleich groß sein. Die Ergebnisse
werden im Vektor x gespeichert.
)

bei d bin ich komplett raus, da habe ich keine Ahnung was genau gemeint ist wie ich das speicher und so ist kein thema, nur verstehe ich das mit dem abstand nicht, wenn es doch bis DIM geht und DIM ein int ist und DIM z.B. 1000 groß ist muss ich dann von 0-1000 die x werte da rein knallen in den Array?

Zeig mal die Stelle, wo steht, dass es bis DIM gehen soll.

[Ricky]

@SeppJ genau das war es was ich nicht verstanden hatte in der Aufgabe x_min und x_max haben ja keinen Wertebereich habe beide einfach mal definiert und kam zu einem ergebnis was mir eventuell in meiner eigentlichen aufgabe helfen würde ich habe jetzt für meine EIGENTLICHE frage in diesem Forum jetzt sowas hier, jedoch weiß ich nicht genau ob dies richtig ist.

#include <cmath>
#include <iostream>
#include <iomanip>

#define _USE_MATH_DEFINES
#include <math.h>

using namespace std;

int main() {
	
	const int N = 100;
	double x[N] = {};
	double y[N] = {};
	double x_min = 0;
	double x_max = 2;
	double x_ges = (x_max - x_min) / N;

	for (int i = 0; i < N; i++) {
		x[i] = x_min + i * x_ges * M_PI;

		y[i] = (sin((x[i])) * sin((x[i])));
		cout << fixed;
		cout << setprecision(2);
		cout << "Xwerte: " << x[i] << endl;
		cout << "Ywerte: " << y[i] << endl;
		
	}


}

[Belli]

@Ricky sagte in Array mit double-Wertebereich füllen:

sondern das de rAbstand zwischen den Werten gleich sein soll

also Abstand = (max - min) / Anzahl?

Edit:
mhm, oder ... / (Anzahl - 1)

[Quiche Lorraine]

@Ricky sagte in Array mit double-Wertebereich füllen:

genau das war es was ich nicht verstanden hatte in der Aufgabe x_min und x_max haben ja keinen Wertebereich habe beide einfach mal definiert und kam zu einem ergebnis was mir eventuell in meiner eigentlichen aufgabe helfen würde ich habe jetzt für meine EIGENTLICHE frage in diesem Forum jetzt sowas hier, jedoch weiß ich nicht genau ob dies richtig ist.

Oh oh, das sind Grundlagen.

Ich hole man ein wenig weiter aus. Hast du die Gleichung y=f(x) verstanden? Man steckt ein x rein und bekommt ein y raus. Nun möchte man sich ein Bild der Funktion machen. Also geht man hin, definiert sich eine Menge von x, steckt jeden einzelnen Wert in die Funktion und bekommt so eine Menge y. Und nun plottet man die x Werte gegenüber den y Werten.

Ein Beispiel in R:

x=seq(0, 2, 0.1)
y=sin(x)*sin(x)
plot(x, y)

Zu deinen vermutlichen Problemen:

1.) Die Funktion f(x) muss nicht unbedingt von x abhängen. Da kann beispielsweise auch f(x) = 1 stehen. Oder f(x) liefert Zufallswerte zurück.

2.) Für die Berechnung der x Werte nimmt man fast immer äquidistante Werte:

//x[i] = x_min + i * x_ges * M_PI;
x[i] = x_min + i * x_ges;                   // Warum nicht so?

In der Variable xges berechnest du in die Breite des Intervalls geteilt durch die Anzahl der Schritte N. Variable xges ist also die Schrittweite.

Was kommt also raus, wenn i 0 ist, und was kommt raus, wenn i N ist? Und wie hoch die Differenz x[i+1]-x[i]?

[wob]

@Quiche-Lorraine sagte in Array mit double-Wertebereich füllen:

In der Variable xges berechnest du in die Breite des Intervalls geteilt durch die Anzahl der Schritte N. Variable xges ist also die Schrittweite.

Meine Frage dazu wäre dann: wofür steht das "ges"? Ich würde eine Variable, die die Schrittweite in x bezeichnet, eher delta_x nennen. Oder auch dx. Oder auch x_stepsize. (oder: hier andere unmissverständliche Bezeichnung einfügen) Aber unter "ges" verstehe ich eher "gesamt", wenn es ein deutschsprachiges Programm ist - ansonsten kann ich mir darunter nichts vorstellen.

[Quiche Lorraine]

@wob
Natürlich hast du Recht. Ich habe den Namen aus dem Code von @Ricky übernommen.

Ich wollte aber zuerst mal die Bedeutung der Variable erklären. Im nächsten Schritt hätte ich ihm dann empfohlen den Namen zu ändern. Ich bin mir nämlich nicht sicher, auf welchem Stand der TE ist.

[wob]

@Quiche-Lorraine Ja, meine Bemerkung war zwar eine Antwort auf deinen Text, aber war natürlich hauptsächlich an @Ricky gerichtet.