Array mit double-Wertebereich füllen

[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.

[Ricky]

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

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)

@Quiche-Lorraine das mit der Funktion hatte ich verstanden das ist ja wie in Mathematik ja auch, man hat Funktionsargument was dann das x ist und dann den dementsprechenden Funktionswert in Abhängigkeit des Funktionsargumenten.

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.

Das habe ich jetzt nicht ganz verstanden gehabt

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?

Weil es doch der Werteberecih von 0- 2pi ist, daher hab ich dann probiert, oder eher gemacht, das ich die Schritte in x_ges ausrechne und dann mit pi multipliziere damit ich halt den Bereich von 0 - 2pi abgedeckt habe

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

Das ist korrekt zumindest versucht.

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]?

wenn i 0 ist, dann wäre es ja x_min+0x_gespi also dementsprechend 0 da x_min 0 und i auch 0 ist. Bei i=N, dann wäre es 0+100 * x_ges * pi= dann 2 * pi, oder ist das irgendwie falsch zumindest wollte ich es so programieren... kommt doch dann hin, oder?

Wie hoch die Differenz x[i+1]-x[i]?

das habe ich nicht ganz verstanden wieso genau ist das relevant für mich?
aber dann ja wenn i =0 wäre wäre es ja dann x[0+1]-x[0] somit x[1]... bei i = N wäre das dann ja auch x[1] weil x[100+1]-x[100] = x[1]

Vielen Dank auf jeden fall für die Antwort @Quiche-Lorraine .

[Quiche Lorraine]

@Ricky

Das habe ich jetzt nicht ganz verstanden gehabt

Und das verstehe ich nicht ganz. Denn du hast folgendes geschrieben...

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...

Deine Aufgabe scheint nämlich eine simple Plotting-Aufgabe zu sein. Da fehlt nur noch der Schritt "Schreiben sie die Daten in eine Gnuplot Datei und stellen sie die diese dar".

Weil es doch der Werteberecih von 0- 2pi ist, daher hab ich dann probiert, oder eher gemacht, das ich die Schritte in x_ges ausrechne und dann mit pi multipliziere damit ich halt den Bereich von 0 - 2pi abgedeckt habe

Warum dann nicht x_min = 0 und x_max = 2*pi setzen?

wenn i 0 ist, dann wäre es ja x_min+0x_gespi also dementsprechend 0 da x_min 0 und i auch 0 ist. Bei i=N, dann wäre es 0+100 * x_ges * pi= dann 2 * pi, oder ist das irgendwie falsch zumindest wollte ich es so programieren... kommt doch dann hin, oder?

Weil bei i = 0 x_min und bei i = N x_max herauskommen muss.

Wie hoch die Differenz x[i+1]-x[i]? das habe ich nicht ganz verstanden wieso genau ist das relevant für mich?

Weil du die Äquidistanz noch nicht verstanden hast und auf dem Schlauch stehst. Gebe diese mal in der Console aus, und schau dir die Werte. Ich fürchte dann fällt bei dir der Groschen.

[Ricky]

@Quiche-Lorraine Also ich habe es mir grade anzeigen lassen und für den letzten wert scheint es eine Bereichsüberschreitung zu geben, ich habe versucht das dann mit einer N- 1 in der Schleife und es hat dann geklappt das ich den Wert nicht mehr rausbekomme. Dann habe ich die x werte nochmal ausgeben lassen und wie du vorhin sagtest muss ja für i=100 auch dem entsprechend 2pi rauskommen, da hab ich mir einfach spaßeshalber die Operation von 2pi direkt daneben ausgeben lassen und es hat am Ende zwei Werte gefehlt, ich habe dann probiert bei dem x_ges, auch eine N-1 rein zu packen, aber dann blieb ein Wert am ende immernoch aus. dann hab ich einfach gesagt okay dann -2 bei x_ges und jetzt scheint es zu klappen, das ich auf jeden Fall 6.28 als letzten Wert bekomme.

#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*M_PI;
	double x_delta = (x_max - x_min) / (N-2);

	for (int i = 0; i < N-1; i++) {
		x[i] = x_min + i * x_delta;

		y[i] = (sin((x[i])) * sin((x[i])));

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

damit stimmen jetzt sowohl Werte als auch die Differenz x[i+1]-x[i]. Vielleicht habe ich aber noch etwas übersehen...

[Th69]

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

for (int i = 0; i < N-1; i++) {

Warum läuft denn deine Schleife nur bis N-1?

[SeppJ]

Du hast zwar das (scheinbar) richtige Ergebnis, aber deine Vorgehensweise wird in Zukunft keinen Erfolg haben. Kompliziertere Probleme kann man nur durch verstehen lösen, nicht indem man zufällige Faktoren +1/-1 im Code verteilt, bis das Ergebnis für einen Testfall passt.

Auch hier passt deine Lösung schon nicht, denn du berechnest ja gar nicht DIM Werte, sondern DIM-1 Werte. Dein Programm gibt derzeit 99 Wertepaare aus. Probier mal N=3, oder gar N=2 oder N=1.

Probier mal, den Algorithmus an einfachen Beispielen zu formulieren, etwa 1 Wert, 2 Werte, 3 Werte, bis 5. Und statt 0 bis 2 Pi nimm 0 bis 1 als Wertebereich. Da solltest du in der Lage sein, die Lösungen im Kopf (oder auf Papier, sehr nützliches Hilfsmittel) zu formulieren und kannst so das Muster dahinter verstehen.

PS: Mir fällt dabei übrigens auf, dass die Aufgabe unterdefiniert ist. Man hat die Freiheit, einen beliebigen Abstand zu den Intervallgrenzen zu wählen. Naheliegend wäre natürlich 0 auf beiden Seiten (geht aber im Fall DIM=1 nicht) oder der gleiche Abstand wie zwischen den berechneten Punkten (dann geht es auch konsistent mit DIM=1), aber prinzipiell könnte man den beliebig wählen und trotzdem die Anforderung erfüllen. Es steht ja schließlich nirgends, dass x_min und x_max selber Teil der Wertemenge sein müssen. Wenn man den Lehrer ärgern will, wählt man als linken Abstand 0 und als rechten Abstand 2*Pi und man gibt dann DIM Male 0 aus. Die haben dann alle gleichmäßigen Abstand, nämlich auch 0.

[Ricky]

@Th69 wegen dieser differenz die quiche lorraine wenn ich das nicht mache und es ausgebe kommt als letzer wert eine ungeheure große zahl raus wenn ich die nur bis n-1 laufen lasse dann hab ich das problem nicht also die Differenz x[i+1]-x[i]

[Ricky]

@SeppJ wenn ich das mit kleinen zahlen mache von 0-1 und das dann durch x_delta jagen würde hätte ich ja als Ergebnis 0.1 für n=10 und wen nicht bei x_delta halt nicht -1 mache dann fehlt mir der Wert 1 am ende... wenn ich <=N mache in der schleife habe ich einen Pufferbereichsfehler. also geht das ja auch nicht wenn ich i=1 einsetze damit er mit dem ersten Wert anfängt statt 0 fehlt mir immer noch der letzte Wert und zwar die 1. sobald ich nämlich ein <=N in die schleife reinhaue ist es verloren, aber ich bekomme ja sonst nie den Wert1 als ausgabe

[Ricky]

Dieser Beitrag wurde gelöscht!

[Ricky]

@SeppJ

#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*M_PI;
	double x_delta = (x_max - x_min) / N;

	for (int i = 0; i < N; i++) {
		x[i] = x_min + x_delta + i * x_delta;
		y[i] = (sin((x[i])) * sin((x[i])));

		cout << fixed;
		cout << setprecision(2);
		cout << i;
		cout << " Xwerte: " << x[i] << endl;
		cout << "Ywerte: " << y[i] << endl;
		//cout << "test: " << x[i + 1] - x[i]<< endl; <= hierfuer immernoch keine Lösung
		
	}


}

hatte es jetzt wie du sagst oft mit den kleinen Werten probiert jetzt hab ich alle ergebnisse ich habe ein x_delta noch addiert in der schleife. Jetzt sollte es aber stimmen, oder?

[wob]

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

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

Jetzt sollte es aber stimmen, oder?

Nein. Du fängst ja nicht bei x_min an, sondern bei x_min + x_delta.

Auch das hier:

double x_delta = (x_max - x_min) / N;

Ob das wohl richtig ist? Angenommen du hast N=2. Also zwei Punkte, bei denen du das berechnen willst. Dann solltest du bei x_min und bei x_max einen Punkt haben, würde ich denken (ok, ist unterdefiniert, aber das wäre meine Annahne). Ob da dann nicht vielleicht ein -1 fehlt?

Wie @SeppJ sagte: spiel dir das für kleine Zahlen selbst durch und überlege, was rauskommen soll.

[Ricky]

@wob wenn ich doch n- 1 rechne dann berechne ich doch nicht mehr N sondern nur noch /99 statt 100, dass ist doch das was @SeppJ meinte, oder nicht? aber selbst mit dem -1 habe ich es versucht, es klappt nicht. ich weiß einfach wirklich nicht mehr weiter Leute, ich habe es mit kleinen Zahlen probiert... von 0-1 und nur 10 zahlen dann kommt als Ergebnis 0.1 raus schön und gut, aber trotzdem kriege ich den Maximalwert nicht raus wenn ich den minimalwert noch einbeziehen möchte, egal wie ich es mache, aber ist ja auch logisch da ich ja nicht bis zum N in der schleife gehe, sondern nur kleiner N bleibe, aber sobald ich da ein = mache kriege ich Bereichsüberschreitung. also in der schleife habe ich es probiert for(int i = 0; i<=N;i++) funktioniert nicht for(int i = 1 ; <= N ;i++) funktioniert nicht. ich habe jetzt wirklich viel probiert, aber ich komme nicht auf die Lösung. Egal was ich mache ich kriege entweder den minimalenwert, oder den max. wert raus. Jedesmal wenn ich denke jetzt müsste es logisch sein, wieder was anderes... ich habe mit der Aufgabe am Samstag angefangen. Das ist für mich sehr demotivierend wenn ich weiß das ich nichtmal die ersten zwei Aufgaben hinbekomme.