ich habe eine Hausaufgabe bekommen:

Das Unterprogramm ceiling nehme als einzigen (Wert-) Parameter x eine Fließkommazahl. Als Ergebnis liefere das Unterprogramm die kleinste Ganzzahl zurück, die größer oder gleich x ist.
Hinweis 1: Folgende zwei Beispiele sollen die Arbeitsweise des Unterprogramms ceiling erläutern:
ceiling(3.14) = 4
ceiling(-5.67) = -5
Es darf keine „Typumwandlung“ zwischen Fließkommazahlen und Ganzzahlen benutzen. Das Unterprogramm soll stattdessen das Ergebnis in mehreren Schritten berechnen, ausgehend von einer von Ihnen zu definierenden Ganzzahl als Startwert. Vergleichsoperationen wie >, ≥ etc. zwischen Fließkommazahlen und Ganzzahlen sind gestattet.

Ich brauche keinen fertigen Code, nur einen Hinweis wie ich das lösen könnte. Habe schon verschiedene Dinge probiert.

void Test(double f_in)
{
	do
	{
		//f_in = f_in + 0.01;
		f_in = f_in + 0.000000000000001;
		cout << "f_in " << f_in << " f_in /  100000000000000 " << f_in /  100000000000000 << "\n";
	}while(f_in / 100000000000000 != 0.0);
	cout << f_in << "\n";
}

void main()
{
	Test(2.9999999999999001);
	//Test(2.98);
	system("pause");
}

Das ganze läuft aber nicht zufriedenstellend. Aber bin ich auf dem richtigen Wege? Denke es hackt an den Nachkommastellen.....

Schreibe unter Windows7 VS2010.Net in C++.

Bin für jede Hilfe Dankbar!!!!
Danke fürs lesen und darüber nachdenken.
Magier

P.S. Ja ich weiß der Code ist nicht perfekt (Variablen Bezeichnung) usw.....

Denke ich sehe den Wald vor lauter Bäumen nicht mehr....
Aber schon mal DANKE!!!

Sie als return ceil(x); zu implementieren wird vermutlich nicht erwünscht sein.
Und wenn man davon ausgeht dass ceil() verboten ist, dann werden wohl floor() und fmod() auch verboten sein. Und dann fängt es an lächerlich zu werden.

magier-phil schrieb:

Eine schleife die alle Werte von Min bis Max double durchläuft und einen Vergleich nach Größer-Kleiner anstellt....

Fast, du suchst ja nur nach Ganzzahlen...

Gruß
Werner

Kurzform: die Zahl so lange halbieren bis man 1,xxxxxxxx hat (mitzählen). Dann das ganze wieder rückwärts, wobei man immer den 1er vorne wegnimmt.
Wenn man fertig ist, hat man (nur mehr) die Nachkommastellen der ursprünglichen Zahl.

Damit sollte sich dann arbeiten lassen.

EDIT: OK, die Variante von Werner ist auch gut.
Wobei man ein Problem bei riesen Zahlen bekommen wird. Also welche die grösser als die Mantisse sind. Da müsste man zumindest tricksen.

DANKE DANKE DANKE!!!

void Test(double d_in)
{	
	for (int int_Zahl = INT_MIN;  int_Zahl <= INT_MAX ; int_Zahl++ )
	{
		if( int_Zahl > int(d_in))
		{
			cout << int_Zahl << "\n";
			return;
		}
	}
}

void main()
{	
	cout << "ceiling(3.14) = ";
	Test(3.14);
	cout << "ceiling(-5.67) = ";
	Test(-5.67);
	system("pause");
}

Jetzt entspricht alles der Aufgabe!!!
Herzlichen Dank für den Denkanstoß und so
Wünsche eine gute Nacht!

{
       if( int_Zahl > int(f_in))
	{

heißen nicht
größer gleich.... soll ja den nächst größere Zeigen.
Vergleiche sind expizit erlaubt!

Vergleichsoperationen wie >, ≥ etc. zwischen Fließkommazahlen und Ganzzahlen sind gestattet.

DANKE!

btw: Was ist mit negativen Zahlen?

Und wenn du das schon machst, wofür dann überhaupt der ganze Rest!?

Welcher Rest?? Was meinst du?

INT_MIN <- Minimum von Integer (in <climits> festgelegt)
INT_MAX <- Maximum von Integer
void main()
{
cout << "ceiling(3.14) = "; //Ausgabe damit es so aussieht wie in der Aufgabenstellung
Test(3.14);
cout << "ceiling(-5.67) = ";
Test(-5.67);
system("pause"); //Erzeugt ein "HALT"....damit die Konsole offen bleibt
}

int(f_in) ist aber eine Typumwandlung. Lass das einfach weg...
btw: Was ist mit negativen Zahlen?

Naja denke die Typumwandlung geht in Ordnung.
Stimmt mit negativen Zahlen ist das Ergebnis zwar mathematisch richtig. Also der nächst größere Integer aber nicht nach Beispiel. Mhhhh....ach ich hasse das.
Hat jemand eine Idee??

void Test(double d_in)
{	
	for (int int_Zahl = INT_MIN;  int_Zahl <= INT_MAX ; int_Zahl++ )	
	{		
		if( int_Zahl > int(d_in))
		{
			if(int_Zahl >= 0)
			{
				cout << int_Zahl << "\n";
			}
			else
			{
				cout << int_Zahl - 1 << "\n";
			}
			return;
		}
	}
}

void main()
{	
	cout << "ceiling(3.14) = ";
	Test(3.14);
	cout << "ceiling(-5.67) = ";
	Test(-5.67);
	cout << "ceiling(0.67) = ";
	Test(0.67);
	system("pause");
}

Nicht schön aber selten......und so stimmt die Ausgabe!

ceiling(3.14) = 4
ceiling(-5.67) = -5

Und mit 0.XX läuft es auch...

Ausgabe:

ceiling(3.14) = 4
ceiling(-5.67) = -5
ceiling(0.67) = 1
Drücken Sie eine beliebige Taste . . .

Aber du verwendest immer noch die verbotene Typumwandlung und diese Lösung ist wahnsinnig langsam...

Ja ich weiß...ist aber ne Klausur/Hausaufgabe....auf Speed kommt es nicht an. Und ja du hast recht ohne ist es besser. Scheinbar rundet int(XX)....
so jetzt habe ich es...ohne Typenumwandlung....

void Test(double d_in)
{	
	for (int int_Zahl = INT_MIN;  int_Zahl <= INT_MAX ; int_Zahl++ )	
	{		
		if( int_Zahl > d_in)
		{			
			cout << int_Zahl << "\n";			
			return;
		}
	}
}

Benutzt INT_MIN/INT_MAX nur um den ganzen Bereich abzudecken.

ceiling(3.14) = 4
ceiling(-5.67) = -5
ceiling(0.67) = 1
Drücken Sie eine beliebige Taste . . .

dot schrieb:

Aber du verwendest immer noch die verbotene Typumwandlung und diese Lösung ist wahnsinnig langsam...

Ja ich weiß...ist aber ne Klausur/Hausaufgabe....auf Speed kommt es nicht an. Und ja du hast recht ohne ist es besser. Scheinbar rundet int(XX)....

Nö, int(XX) rundet nicht, es schneidet einfach den Nachkommateil weg ("truncate").