|
|
|
|
|
|
|
|
|
|
|
|
|
Coole Seite, Gore.
Ich werd verrückt. Ich hab eine % Anzeige in meiner Simulation, und habe das Gefühl, dass ich die zu oft update und damit meine Berechnung verlangsame.
| |
| Code: |
size_t N = 100000000;
for(i = 0; i < N; i++)
{
...
if(i * 100 % N == 0)
printf("\rSimulating...: \t\t\t\t%2d%%", (int)(100L * i / N));
} |
|
Irgendwie funktioniert diese If-Bedingung nicht richtig. Es wird gar nicht angezeigt!
|
|
|
|
|
|
|
|
|
|
|
der Modulo-Operator ist "stärker" als + und -
if((i*100)% N == 0)
sollte gehen.
Und ja, if in for-Schleifen sind langsam
//ah moment, das ist ja ein * 
hmm... dann sollte es ja schon gehen...
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von _Ac_ am 22.02.2011 20:12]
|
|
|
|
|
|
|
|
|
aber printf wird doch noch langsamer sein?
Wie würde ich sowas optimalerweise lösen?
Dein Vorschlag geht auch nicht. Hier ein Minimalbeispiel:
| |
| Code: |
#include <stdio.h>
int
main(int argc, char **argv)
{
int i, N = 100000000;
for(i = 0; i < N; i++)
if((i * 100) % N == 0)
printf("\rSimulating...: \t\t\t\t%2d%%", (int)(100L * i / N));
printf("\n");
return 0;
} |
|
/e: Das gibt bei mir genau einmal ne Zahl aus, und zwar 21%. Auch bei mehrmaligem Ausführen... o_O
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von OliOli am 22.02.2011 20:14]
|
|
|
|
|
|
|
|
|
|
zwei verschachtelte for-Schleifen und die äußere hat das Print?
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von RichterSkala
zwei verschachtelte for-Schleifen und die äußere hat das Print?
| |
Alter, das ist mal intelligent. 
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von OliOli
aber printf wird doch noch langsamer sein?
Wie würde ich sowas optimalerweise lösen?
Dein Vorschlag geht auch nicht. Hier ein Minimalbeispiel:
| |
| Code: |
#include <stdio.h>
int
main(int argc, char **argv)
{
int i, N = 100000000;
for(i = 0; i < N; i++)
if((i * 100) % N == 0)
printf("\rSimulating...: \t\t\t\t%2d%%", (int)(100L * i / N));
printf("\n");
return 0;
} |
|
/e: Das gibt bei mir genau einmal ne Zahl aus, und zwar 21%. Auch bei mehrmaligem Ausführen... o_O
| |
oh in der tat liegt das Problem woanders: if((i * 100) % N == 0)
das Fett markierte wird wieder ein int und durch die Multiplikation zu groß.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Aclebeth am 22.02.2011 20:44]
|
|
|
|
|
|
|
|
|
die nicht vorhandene klammerung macht mich fertig 
|
|
|
|
|
|
|
|
|
|
|
funzt immer noch nicht wie ich will.
Habs mit 2 for-Schleifen gemacht, aber dennoch. 
| |
| Code: |
#include <stdio.h>
int main(int argc, char **argv)
{
size_t i, j, N = 1000000, haha = 0;
for(j = 0; j < 100; j++) {
printf("\rSimulating...: \t\t\t\t%2d%%", (int)j);
for(i = 0; i < N / 100; i++)
haha++;
}
printf("\n");
for(i = 0; i < N; i++)
printf("\rSimulating...: \t\t\t\t%2d%%", (int)(100L * i / N));
printf("\n");
return 0;
} |
|
Das zweite geht. WIESO???
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von OliOli am 22.02.2011 20:43]
|
|
|
|
|
|
|
|
|
Irgendwie mag ich diese mathematische Art, Dinge beizubringen nicht.
Als Physiker kann man sich darauf verlassen, für (fast) alles irgendwo Lösungen oder zumindest Hinweise dazu finden. Wenn man also irgendwo hängt, kann man sich Inspiration holen und weitermachen.
Aber Mathematiker? Die geben dir eine Aufgabe und lassen dich erstmal hängen.
----
@Virtus: Danke nochmal! 
You need a reason to live! You don't need excuses to die!
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Wraith of Seth am 22.02.2011 20:41]
|
|
|
|
|
|
|
|
|
Es ist weniger das if in der Schleife, das langsam ist, als mehr die Bedingung - Moduloberechnung ist langsam.
| |
| Code: |
//Möglichkeit 1
for (i = 0; i < 1000000; ++i) {
for (j = 0; j < 100; ++j) {
r = calculate(i*100 + j);
}
print(i);
}
//Möglichkeit 2
for (i = 0; i < 100000000; ++i) {
r = calculate (i);
if ( i % 100 == 0)
print(i);
}
//Möglichkeit 3
for (i = 0; i < 100000000; ++i) {
r = calculate (i);
if (!(i & 100))
print(i);
}
|
|
Methode 1 und 3 sind dabei fast gleich schnell - bei meinen Tests eben war die 3 sogar etwas schneller. Methode 2 war etwa um ein drittel langsamer.
Es ist aber wohl auch net die Berechnung als mehr die Ausgabe selbst, die langsam ist. Weniger oder asynchrone Ausgaben lösen das Problem.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von B0rG*
Methode 1 und 3 sind dabei fast gleich schnell - bei meinen Tests eben war die 3 sogar etwas schneller. Methode 2 war etwa um ein drittel langsamer.
Es ist aber wohl auch net die Berechnung als mehr die Ausgabe selbst, die langsam ist. Weniger oder asynchrone Ausgaben lösen das Problem.
| |
Danke, das dritte ist natürlich echt elegant. Nunja, ich hab halt wirklich sone Schleife über bisweile 100mio Durchläufe und wollte daher die Ausgaben limitieren.
|
|
|
|
|
|
|
|
|
|
|
Ha, gerade rausgefunden wieso's nicht geht:
printf() schreibt irgendwie nur das letzte, wenn ich's mit cout mache, gehts...
C-Funktionen sind so beschissen...
|
|
|
|
|
|
|
|
|
|
|
Was ja sehr richtig ist. Mach einfach noch weniger ausgaben (eine alle paar Sekunden oder so) und s passt.
e/ Auf Oli bezogen
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von B0rG* am 22.02.2011 20:48]
|
|
|
|
|
|
|
|
|
| | Zitat von _Ac_
Ha, gerade rausgefunden wieso's nicht geht:
printf() schreibt irgendwie nur das letzte, wenn ich's mit cout mache, gehts...
C-Funktionen sind so beschissen...
| |
Naja - du solltest vielleicht auch flushen. 
|
|
|
|
|
|
|
|
|
|
|
dann reich ich das mal an Oli weiter: Klammern richtig setzen und flushen
| |
| Code: |
int
main(int argc, char **argv)
{
int i, N = 100000000;
for(i = 0; i < N; i++)
{
if((i * 100) % N == 0)
{
printf("\rSimulating...: \t\t\t\t%2d%%", (int)(100L * i / N));
printf("\n");
}
}
return 0;
} |
|
funktioniert tadellos
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von B0rG*
Was ja sehr richtig ist. Mach einfach noch weniger ausgaben (eine alle paar Sekunden oder so) und s passt.
e/ Auf Oli bezogen
| |
Hm naja diese bitwise operation... Die erste Möglichkeit erlaubt es mir, genau 100 mal den Stand auszugeben, das ist was ich will. Das kriegt man glaube ich mit den bitweisen dingern nicht hin oder?
/e: _Ac_: Ich will das ja in einer Zeile stehen haben.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von OliOli am 22.02.2011 21:01]
|
|
|
|
|
|
|
|
|
| | Zitat von OliOli
Hm naja diese bitwise operation... Die erste Möglichkeit erlaubt es mir, genau 100 mal den Stand auszugeben, das ist was ich will. Das kriegt man glaube ich mit den bitweisen dingern nicht hin oder?
| |
Ist bloß eine "Abkürzung" für [Edit: Das ist falsch, siehe weiter unten.]
(Wobei mich wundert, dass der Compiler das nicht umwandelt, aber so genau habi mi da mit jetz net beschäftigt)
Du könntest also rausfinden Modulo was es null sein muss, damit dus anzeigen willst, das _vor_ der Schleife einmal Ausrechnen und dann immer überprüfen.
e/ Also sowas:
| |
| Code: |
int N, i, q;
N = 100000000;
q = N / 100;
for (i = 0; i < N, ++i) {
calculate(i);
if (!(i & q)) {
print(i);
}
}
|
|
Das sichert aber nicht, dass die letzte Ausgabe auch wirklich aus dem letzten Schleifendurchlauf stammt - für den Fall, dass dir das wichtig ist.
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von B0rG* am 23.02.2011 1:59]
|
|
|
|
|
|
|
|
|
Wofür bin ich dann zu doof?
| |
| Code: |
#include <stdio.h>
int main(int argc, char **argv)
{
size_t N = 1000000;
int i;
printf("\n");
for(i = 0; i < N; i++)
if (!(i & 100))
printf("%d\n",i);
printf("\n");
return 0;
} |
|
/e: Es sieht ziemlich so aus, als würde er die 100 als bits auffassen. Aber ein (int) cast bringt auch nichts.
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von OliOli am 22.02.2011 21:12]
|
|
|
|
|
|
|
|
|
| | Zitat von _Ac_
dann reich ich das mal an Oli weiter: Klammern richtig setzen und flushen
| |
| Code: |
int
main(int argc, char **argv)
{
int i, N = 100000000;
for(i = 0; i < N; i++)
{
if((i * 100) % N == 0)
{
printf("\rSimulating...: \t\t\t\t%2d%%", (int)(100L * i / N));
printf("\n");
}
}
return 0;
} |
|
funktioniert tadellos
| |
Ich dachte ja eher an fflush(stdout). Dass eine leere Zeile flusht ist afaik nicht standardisiert.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von [Dicope] am 22.02.2011 21:18]
|
|
|
|
|
|
|
|
| | Zitat von B0rG*
Ist bloß eine "Abkürzung" für
| |
The fuck?
a = 01001000 (72)
b = 00010000 (32)
a & b = 00000000
!(a & b) = 11111111
a % b = 00001000
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von [Dicope]
Ich dachte ja eher an fflush(stdout). Dass eine leere Zeile flusht ist afaik nicht standardisiert.
| |
hab ich gerade probiert und das funktioniert nicht 
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von [Dicope]
The fuck?
a = 01001000 (72)
b = 00010000 (32)
a & b = 00000000
!(a & b) = 11111111
a % b = 00001000
| |
Das ist ein logisches nicht.
Ich gebe aber zu nicht zu lange drüber nachgedacht zu haben, mag falsch sein, hab jetzt leider auch grad keine Zeit mehr. Ich melde mich in paar Stunden .
|
|
|
|
|
|
|
|
|
|
|
ist falsch.
Ich habe jetzt die doppel-schleife und fflush(stdout) benutzt.
Danke an alle, ich wollte gar nicht so viele Posts provozieren.
|
|
|
|
|
|
|
|
|
|
|
Mir is beim aus der Tür gehen eingefallen warum das natürlich falsch ist -.-.
Es geht mit Zweierpotenzen (wenn man die Null irgendwie mitbehandelt) und ansonsten hat das ein etwas anderes Verhalten. Kommt davon wenn man sich kurz erinnert und zu faul ist groß nachzudenken.
Was du mit solchen Operationen aber durchaus hinkriegen kannst eventuell ist das Verhalten, das du möchtest. Weil ne Modulorechnung dafür ja eigentlich schon etwas Overkill ist. Das lässt mich jetzt irgendwie nich mehr los .
|
|
|
|
|
|
|
|
|
|
|
|
aber ist die Condition an und für sich nicht schon overkill und die Variante mit der verschachtelten Schleife (wenn man die Zählervariable nicht braucht) bietet eh die bessere Performance?
|
|
|
|
|
|
|
|
|
|
|
Als ob das ein Argument wäre .
Weiß nich, aber die geschachtelten Schleifen wirken auf mich irgendwie nich elegant... das muss doch hübscher gehen.
|
|
|
|
|
|
|
|
|
|
|
Ich finde dazu irgendwie nicht viel, aber wie zitiere ich innerhalb von Source Code? Wenn ich also sagen will, den und den Algorithmus aus diesem und jenem Paper genommen zu haben.
Gibts da eine Konvention?
|
|
|
|
|
|
|
|
|
|
|
c++doc? 
|
|
|
|
|
|
|
|
|
|
|
Bei uns gibt es keine direkte Konvention, es wird allerdings erwartet dass man bei großen übernommenen Teilen oder Algorithmen im Quellcode selber einen Kommentar zur Quelle macht, wenn auch nicht zwingend formal wie in geschriebenem Text. Üblicherweise wird in der jeweiligen begleitenden Arbeit, soweit es diese denn gibt, dann eh genauer auf die verwendeten Algorithmen und ihren Sinn + Laufzeit eingegangen, da dann natürlich mit ausführlicherer Quellenangabe.
Wenn du nur den Quellcode hast pack soviel wie möglich Quelleninformation als Kommentar dazu, wenn du dazu einen Text hast halte dich eher kurz und verweise auf entsprechende Textstelle.
Echte Quellcode-Doku schreibt ja leider eh keine Sau, was mich gerade bei meiner Diplomarbeit doch sehr sehr ankotzt
|
|
|
|
|
|
|
|
| Thema: pOT-Informatiker, Mathematiker, Physiker V ( Haaahaaaaahaa...LabView...Hahahahaaa...oh wow ) |
![[Dicope]](./avatare/drkleiner.gif)
![AUP [smith] 29.07.2010](./avatare/upload/U1066026--zeratul.png)