Array-Werte in einzelne Variablen schreiben

securom87

Ich hab meine funktion nun nochmal verändert und jeden Rechenschritt einzeln ausgeführt:

int binarytodecimal_vk(int *pv)
{
	int y=0;
	//int m = 0;
	//for (m = 0; m < countervor; m++){

		y = pv[0] * 1;
		y = y + pv[1] * 2;	
		y = y + pv[2] * 4;
		y = y + pv[3] * 8;
		y = y + pv[4] * 16;

		//y = (y + (pv[m] * (2 ^ m)));
	//}

	return y;
}

Nun kommt das richtige Ergebnis heraus, nur ich hab absoltut kein Schimmer was an meiner zuvor verwendeten Formel falsch sein könnte

SeppJ

^ ist XOR, keine Potenz.

securom87

SeppJ schrieb:

^ ist XOR, keine Potenz.

Super vielen Dank, das hat mir sehr weiter geholfen

nun habe ich noch ein letztes problem:

Hab mir nun noch eine Funktion geschrieben, die mir aus den Dual- Zahlen meine Dezimalzahl wieder heruasgibt:

double binarytodecimal_nk(int *pn)
{
	double z = 0;
	int n = 0;
	int a3 = 0;
	double basis = 2.0;
	for (n = 0; n <= counternach; n++){
		a3 = pow(basis, n + 1);
		z = (z + (pn[n] * (1 / a3)));
	}

	return z;
}

Hierbei habe ich nun noch das Problem, dass der Rückgabewert permanent 0 ergibt, wobei ich explizit in der obigen Gleichung doch jede Berechnung der einzelnen Array-Werte mit der dazugehörigen Stellenwertigkeit multipliziere.
Z bekommt einfach keine Werte zugeordnet.

hat jemand eine Idee was dort faul ist?

Dankeschön

SeppJ

Wenn du eine ganze Zahl durch eine ganze Zahl teilst, dann kommt auch wieder eine ganze Zahl raus. Das heißt, wenn der Teiler größer ist als das Geteilte, kommt 0 raus.

Gewöhn dir globale Variablen lieber sofort ab.

securom87

SeppJ schrieb:

Wenn du eine ganze Zahl durch eine ganze Zahl teilst, dann kommt auch wieder eine ganze Zahl raus. Das heißt, wenn der Teiler größer ist als das Geteilte, kommt 0 raus.

Gewöhn dir globale Variablen lieber sofort ab.

Okay, nur wie kann ich es denn erreichen, dass mir die Funktion eine Kommazahl zurückgibt bzw. eine Zahl die definitiv kleiner ist als 1?

Weil in der Funktion geht es ja nur um Zahlen kleiner 1.

Liebe Grüße

SeppJ

Dazu muss mindestens einer der Operanden in der Division von einem Fließkommatyp sein. Also a3 oder 1 oder beide. Ein Literal vom Typ double mit dem Wert 1 wäre beispielsweise 1.0

securom87

SeppJ schrieb:

Dazu muss mindestens einer der Operanden in der Division von einem Fließkommatyp sein. Also a3 oder 1 oder beide. Ein Literal vom Typ double mit dem Wert 1 wäre beispielsweise 1.0

Also habe a3 mal als double definiert, bringt aber keine Besserung. Der zurückgegebene Wert ist danach immer noch 0.

Meine Funktion sieht momentan so aus:

double binarytodecimal_nk(int *pn)
{
	double z = 0;
	int n = 0;
	double a3 = 0;
	double basis = 2.0;
	for (n = 0; n <= counternach; n++){

		a3 = pow(basis, n + 1);
		z = (z + (pn[n] * (1 /a3)));
	}

	return z;
}

securom87

Kommando zurück!!!! z hat sich mittlerweile doch verändert.

Es hatte anscheinend an den äußersten Klammern gelegen.
nachdem ich diese entfernt hatte funktionierte es einwandfrei.

Vielen Dank für diese Hilfestellung!

securom87

So vielen Dank nochmal an alle, die mir geholfen haben. Programm funktioniert nun einwandfrei und zu meiner vollsten Zufriedenheit.

Liebe Grüße

SeppJ

Alle deine Klammern sind unnötig, aber eigentlich (bzw. gerade deswegen) sollten sie nichts am Ergebnis ändern. Kannst du mal den Code vorher und nachher zeigen und sagen, was heraus kommt?

securom87

SeppJ schrieb:

Alle deine Klammern sind unnötig, aber eigentlich (bzw. gerade deswegen) sollten sie nichts am Ergebnis ändern. Kannst du mal den Code vorher und nachher zeigen und sagen, was heraus kommt?

Also entweder es lag an den Klammern oder vllt doch eher an der double Definition der Variablen, die an der Berechnung teilnehmen.

Hier ist nochmal der Code wo es nicht funktioniert hatte und z konstant 0 war:
Lag wohl wirklich daran, dass der Nachkommateil wegen des INT von a3 immer abgeschnitten wurde.

double binarytodecimal_nk(int *pn)
{
    double z = 0;
    int n = 0;
    int a3 = 0;
    double basis = 2.0;
    for (n = 0; n <= counternach; n++){
        a3 = pow(basis, n + 1);
        z = (z + (pn[n] * (1 / a3)));
    }

    return z;
}

Hier nun der Code der funktioniert:

double binarytodecimal_nk(int *pn)
{
	double z = 0;
	int n = 0;
	double a3 = 0;
	double basis = 2.0;
	for (n = 0; n <= MAX; n++){

		a3 = pow(basis, n + 1);
		z = z + (pn[n] * (1 /a3));
	}

	return z;
}

Liebe Grüße

In deinem ersten Beispiel ist 1/a3 immer 0 für alle a3 die > 2 oder < -2 sind. (Integer-Division, da Dividend und Divisor vom Typ einer Ganzzahl sind)

Ein 1.0/a3 beseitigt das Problem.