C/C++ Forum :: delete [] thread-safe machen

curry-king Mitglied 15:34:00 31.01.2012 Titel:

Hallo zusammen,

warum reicht es nicht aus, wenn ich jeden Aufruf von delete [] durch ein Mutex schütze? Was ist noch zu beachten?

Danke für Eure Antworten!

dot Mitglied 15:36:32 31.01.2012 Titel:

Ich versteh nicht ganz, warum solltest du jeden Aufruf von delete[] durch ein Mutex "schützen"? Bist du dir sicher dass du den Sinn von einem Mutex verstanden hast?

314159265358979 Mitglied 15:39:28 31.01.2012 Titel:

Die "default"-Implementierung von delete[] ist doch threadsafe, oder?

dot Mitglied 15:40:40 31.01.2012 Titel:

Ja.

curry-king Mitglied 15:41:31 31.01.2012 Titel:

Denn Sinn eines Mutex kenne ich denke ich. Es dient dazu, gleichzeitigen Zugriff auf begrentzte Resourcen zu unterbinden bzw. exklusiv zu gewähren.

Was ich allerdings mit dem Mutex bei delete [] zu erreichen versuche weiss ich auch nicht ganz.

Das Problem ist, dass meine Threads auf dem Heap Speicher allokieren und diesen auch wieder freigeben.

Beim Freigeben knallt es dann aber. Das mit dem Mutex war ein Schnellschuß, das Problem zu lösen.

Was kann ich tun?

dot Mitglied 15:42:08 31.01.2012 Titel:

curry-king schrieb:

Was kann ich tun?

Rausfinden warum es knallt.

Kann es sein dass eben einfach mehrere Treads versuchen das selbe Array zu deleten[]? Wenn ja, dann hilft natürlich kein Mutex um delete[] herum, weil ob die Threads das Array nun alle parallel deleten oder schön der Reihe nach ändert nix dran, dass das Array am Ende zu oft deleted wird...

314159265358979 Mitglied 15:42:39 31.01.2012 Titel:

Schon mal den Debugger angeworfen? Double-Delete? Delete auf Speicher, der dir nicht gehört? Das kann viele Gründe haben.
Allerdings solltest du new[] und delete[] ohnehin nicht verwenden, denn dafür gibt es std::vector.

curry-king Mitglied 15:46:15 31.01.2012 Titel:

dot schrieb:

curry-king schrieb:

Was kann ich tun?

Rausfinden warum es knallt.

Like it

314159265358979 schrieb:

Allerdings solltest du new[] und delete[] ohnehin nicht verwenden, denn dafür gibt es std::vector.

Ich arbeite mit 3000 Zeilen Code vom Vorgänger die voll von new[] und delete[] sind...

Ich werde den Debugger mal Fragen!

314159265358979 Mitglied 15:47:22 31.01.2012 Titel:

Dann würde ich den Code an deiner Stelle neu schreiben.

pumuckl Moderator 15:52:05 31.01.2012 Titel:

curry-king schrieb:

Ich arbeite mit 3000 Zeilen Code vom Vorgänger

Dass jemand anderes den Code geschrieben hat ist kein Grund, von einem nötigen Refactoring abzusehen

cooky451 Mitglied 16:32:37 31.01.2012 Titel:

pumuckl schrieb:

curry-king schrieb:

Ich arbeite mit 3000 Zeilen Code vom Vorgänger

Dass jemand anderes den Code geschrieben hat ist kein Grund, von einem nötigen Refactoring abzusehen

Denke ich auch. 3000 Zeilen sind in einer Stunde durch, da lohnt das Ärgern doch nicht.

hustbaer Mitglied 02:20:39 01.02.2012 Titel:

3000 Zeilen in einer Stunde refactorn ist ne hübsch naive Vorstellung.
Das müssen schon recht zivilisierte 3000 Zeilen sein dass sich das ausgeht.
Erstmal muss man verstehen was überhaupt abgeht, dann kann man es geradebiegen. Im Idealfall kann man sich Stück für Stück ansehen, Stück für Stück verstehen und dann umbauen, und am Ende hat man ein Programm das funktioniert. Und selbst das kann länger dauern als ne Stunde.

daddy_felix Mitglied 10:02:37 01.02.2012 Titel:

wenn der Code gut mit Unit Tests abgedeckt ist, sollte das Refactoring recht schnell gehen. Wenn diese aber nur unvollständig oder gar nciht vorhanden sind, dann wird es unangenehm...

hustbaer Mitglied 13:05:58 01.02.2012 Titel:

Auch das ist Wunschdenken.
Kein nicht-trivialer Code ist soweit mit Unit-Tests abgesichert, dass diese 100% aller möglichen Fälle abdecken. Meist nichtmal 100% aller relevanten Fälle.

OK, man *kann* dann flott refactorn, nur kann man eben nicht sicher sein dass nachher auch wirklich alles passt, nur weil die Tests durchlaufen. Fehlerbehandlung ist z.B. etwas, was in kaum einem Projekt auch nur annähernd brauchbar von automatischen Tests abgedeckt ist.

Unregistrierter

cooky451 schrieb:

Denke ich auch. 3000 Zeilen sind in einer Stunde durch, da lohnt das Ärgern doch nicht.

Du hast noch keinen wirklich üblen Code übernehmen müssen. 3000 Zeilen können ausreichen, um einen Tage- oder Wochenlang zu beschäftigen. Neu schreiben ist manchmal auch nicht drin. Z.B. wenn dieser Code mit Hardware kommuniziert, aber nichts, nicht mal das Protokoll, dokumentiert ist. So einen haufen Müll zu verstehen dauert sehr lange. Und teilweise ist das alles noch so fragil, dass jede Änderung Adrenalinschübe verursacht.

Willkommen in der realen Welt

Unregistrierter

Und selbst bei wirklich guten Code* führt man keine größeren Änderungen in einer Stunde durch. Du hast Vorstellunge...

*Was der Notwendigkeit nach Überarbeitung natürlich widerspricht.

curry-king Mitglied 10:34:04 03.02.2012 Titel:

Bei über 3000 Zeilen von folgendem Code würde das refactoring dann wahrscheinlich ein MJ dauern :-)...
Mein Problem ist gelöst, ich hatte mehr freigegeben als ich allokiert hatte!

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69	int update_table2(vector<string> staterows, vector<string> transrows, vector<string> columns,bool* table, string stream, size_t old_states, size_t old_trans, size_t old_columns) { bool new_table; (new_table) = new bool* [(columns).size()]; for(unsigned int iu=0;iu<(columns).size();iu++) (new_table)[iu] = new bool[(staterows).size()+(transrows).size()]; string newquerry(""); for(unsigned int iu=0;iu<(staterows).size()+(transrows).size();iu++) { for(unsigned int ju=0;ju<(columns).size();ju++) { if((iu<old_states)&&(ju<old_columns-1)) { // copy old states new_table[ju][iu] = (table)[ju][iu]; } else{ if((iu>staterows.size()-1)&&(ju<old_columns-1)&&(iu<staterows.size()+old_trans)){ //copy old transitions* new_table[ju][iu] = (table)[ju][iu-staterows.size()+old_states]; } else{ newquerry = (iu>(staterows).size()-1)? (transrows)[iu-(staterows).size()] : (staterows)[iu]; newquerry += (columns)[ju]; (new_table)[ju][iu]=querry(newquerry,stream); //transitions* } } } } // copy new_table into table delete [] (table); (table) = new bool* [(columns).size()]; for(unsigned int iu=0;iu<(columns).size();iu++) (table)[iu] = new bool[(staterows).size()+(transrows).size()]; for(unsigned int* iu=0;iu<(staterows).size()+(transrows).size();iu++) { for(unsigned int ju=0;ju<(columns).size();ju++) { (table)[ju][iu]=new_table[ju][iu]; //copy* } } delete [] new_table; return 0; } bool fix_closed(vector<string> staterows, vector<string> transrows, vector<string> columns, vector<string>alpha, bool* **table,string stream) { size_t old_state = (staterows).size(); size_t old_trans = (transrows).size(); size_t old_col = (columns).size(); bool found; string transition; string help; for(unsigned int i=0;i<(transrows).size();i++) { for(unsigned int* j=0;j<(staterows).size();j++) { found = true; for(unsigned int* k=0;k<(columns).size();k++) { if ((table)[k][j] != (table)[k][i+(staterows).size()]) {found = false; break;} } if(found) break; } if (!found) {// fix transrow transition = (transrows)[i]; (staterows.......................................

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69	int update_table2(vector<string> staterows, vector<string> transrows, vector<string> columns,bool* table, string stream, size_t old_states, size_t old_trans, size_t old_columns) { bool new_table; (new_table) = new bool* [(columns).size()]; for(unsigned int iu=0;iu<(columns).size();iu++) (new_table)[iu] = new bool[(staterows).size()+(transrows).size()]; string newquerry(""); for(unsigned int iu=0;iu<(staterows).size()+(transrows).size();iu++) { for(unsigned int ju=0;ju<(columns).size();ju++) { if((iu<old_states)&&(ju<old_columns-1)) { // copy old states new_table[ju][iu] = (table)[ju][iu]; } else{ if((iu>staterows.size()-1)&&(ju<old_columns-1)&&(iu<staterows.size()+old_trans)){ //copy old transitions* new_table[ju][iu] = (table)[ju][iu-staterows.size()+old_states]; } else{ newquerry = (iu>(staterows).size()-1)? (transrows)[iu-(staterows).size()] : (staterows)[iu]; newquerry += (columns)[ju]; (new_table)[ju][iu]=querry(newquerry,stream); //transitions* } } } } // copy new_table into table delete [] (table); (table) = new bool* [(columns).size()]; for(unsigned int iu=0;iu<(columns).size();iu++) (table)[iu] = new bool[(staterows).size()+(transrows).size()]; for(unsigned int* iu=0;iu<(staterows).size()+(transrows).size();iu++) { for(unsigned int ju=0;ju<(columns).size();ju++) { (table)[ju][iu]=new_table[ju][iu]; //copy* } } delete [] new_table; return 0; } bool fix_closed(vector<string> staterows, vector<string> transrows, vector<string> columns, vector<string>alpha, bool* **table,string stream) { size_t old_state = (staterows).size(); size_t old_trans = (transrows).size(); size_t old_col = (columns).size(); bool found; string transition; string help; for(unsigned int i=0;i<(transrows).size();i++) { for(unsigned int* j=0;j<(staterows).size();j++) { found = true; for(unsigned int* k=0;k<(columns).size();k++) { if ((table)[k][j] != (table)[k][i+(staterows).size()]) {found = false; break;} } if(found) break; } if (!found) {// fix transrow transition = (transrows)[i]; (staterows.......................................

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69	int update_table2(vector<string> staterows, vector<string> transrows, vector<string> columns,bool* table, string stream, size_t old_states, size_t old_trans, size_t old_columns) { bool new_table; (new_table) = new bool* [(columns).size()]; for(unsigned int iu=0;iu<(columns).size();iu++) (new_table)[iu] = new bool[(staterows).size()+(transrows).size()]; string newquerry(""); for(unsigned int iu=0;iu<(staterows).size()+(transrows).size();iu++) { for(unsigned int ju=0;ju<(columns).size();ju++) { if((iu<old_states)&&(ju<old_columns-1)) { // copy old states new_table[ju][iu] = (table)[ju][iu]; } else{ if((iu>staterows.size()-1)&&(ju<old_columns-1)&&(iu<staterows.size()+old_trans)){ //copy old transitions* new_table[ju][iu] = (table)[ju][iu-staterows.size()+old_states]; } else{ newquerry = (iu>(staterows).size()-1)? (transrows)[iu-(staterows).size()] : (staterows)[iu]; newquerry += (columns)[ju]; (new_table)[ju][iu]=querry(newquerry,stream); //transitions* } } } } // copy new_table into table delete [] (table); (table) = new bool* [(columns).size()]; for(unsigned int iu=0;iu<(columns).size();iu++) (table)[iu] = new bool[(staterows).size()+(transrows).size()]; for(unsigned int* iu=0;iu<(staterows).size()+(transrows).size();iu++) { for(unsigned int ju=0;ju<(columns).size();ju++) { (table)[ju][iu]=new_table[ju][iu]; //copy* } } delete [] new_table; return 0; } bool fix_closed(vector<string> staterows, vector<string> transrows, vector<string> columns, vector<string>alpha, bool* **table,string stream) { size_t old_state = (staterows).size(); size_t old_trans = (transrows).size(); size_t old_col = (columns).size(); bool found; string transition; string help; for(unsigned int i=0;i<(transrows).size();i++) { for(unsigned int* j=0;j<(staterows).size();j++) { found = true; for(unsigned int* k=0;k<(columns).size();k++) { if ((table)[k][j] != (table)[k][i+(staterows).size()]) {found = false; break;} } if(found) break; } if (!found) {// fix transrow transition = (transrows)[i]; (staterows.......................................

Shiba Mitglied 11:01:27 03.02.2012 Titel:

cooky451 schrieb:

3000 Zeilen sind in einer Stunde durch, da lohnt das Ärgern doch nicht.

Respekt

Erfassen, verstehen und eventuell korrigieren einer Zeile in 1,2 Sekunden.

Unregistrierter

Shiba schrieb:

Respekt

Erfassen, verstehen und eventuell korrigieren einer Zeile in 1,2 Sekunden.

Naja, es ist ja nicht jede Zeile betroffen. Eine Stunde ist natürlich dennoch viel zu wenig.

Aber bei dem geposteten Code ist dennoch durch minimale Änderungen einiges zu verbessern. Bspw. die Übergabe als Wert und damit das notwendige Kopieren könnte mit konstanten Referenzen leicht umgangen werden, ohne den Code zu ändern.
Und auch sonst wäre in diesem Beispiel wahrscheinlich der Einsatz von Pointer-Containern die bessere Wahl...

camper Mitglied 11:50:41 03.02.2012 Titel:

Hier lässt sich sogar ohne stilistische Änderungen einiges verbessern.
Wer löscht eigentlich die alten bool-Arrays? Ich vermisse da ein delete[].
Kann nat. auch an anderer Stelle des Programmes stehen... in diesem Fall wäre es allerdings diese geteilte Zuständigkeit, um die ich mich zuerst kümmern würde.

314159265358979 Mitglied 11:51:03 03.02.2012 Titel:

@Code: LOL, den Typen würde ich entlassen. Drei-Sterne-Programmierer. :eek:

Ethon Mitglied 11:55:11 03.02.2012 Titel:

314159265358979 schrieb:

@Code: LOL, den Typen würde ich entlassen. Drei-Sterne-Programmierer. :eek:

Tja, oft ist es aber besonders für die fähigsten Mathematiker/Physiker unter ihrem Niveau zu Programmieren. Und du würdest nicht die besten Leute raushauen nur weil sie übermäßig komplexe Programme raushauen, die machen was sie sollen.

(Nicht a7uf das Beispiel bezogen)

314159265358979 Mitglied 11:58:28 03.02.2012 Titel:

Dann soll er nicht programmieren, sondern tun, was er kann.

Ethon Mitglied 12:04:40 03.02.2012 Titel:

314159265358979 schrieb:

Dann soll er nicht programmieren, sondern tun, was er kann.

Dann musst du aber wiederrum einen Programmierer finden, der das Konzept versteht. Und da viele gute Programmierer sonst nix können (diese ganzen FH-Gestalten :o)

) ist das dann auch höchstens geringfügig besser.

314159265358979 Mitglied 12:05:50 03.02.2012 Titel:

Ach, viel schlimmer gehts doch kaum.

curry-king Mitglied 12:46:58 03.02.2012 Titel:

camper schrieb:

Hier lässt sich sogar ohne stilistische Änderungen einiges verbessern.
Wer löscht eigentlich die alten bool-Arrays? Ich vermisse da ein delete[].
Kann nat. auch an anderer Stelle des Programmes stehen... in diesem Fall wäre es allerdings diese geteilte Zuständigkeit, um die ich mich zuerst kümmern würde.

In meiner ersten überarbeiteten Version

habe ich dieses Speicherleck schon geschlossen :live:

curry-king Mitglied 12:55:28 03.02.2012 Titel:

314159265358979 schrieb:

Dann soll er nicht programmieren, sondern tun, was er kann.

Der Urheber des Codes hat ne absolut saubere Masterarbeit in 6 Monaten hingelegt. Das der Code stilistisch schei sse und von Speicherlecks durchlöchert ist/war schmälert seine Arbeit nicht. Der Code ist ein proof-of-concept eines speziellen automata lernaers. Für seine Bedürfnisse völlig ausreichend. In seinem Fall hätte ich das Softwareengineering wohl auch ganz hinten angestellt...

hustbaer Mitglied 13:06:04 03.02.2012 Titel:

@curry-king
Nimm Pi nicht zu ernst, der ist nur glücklich wenn er jmd. bashen kann.

314159265358979 Mitglied 14:43:42 03.02.2012 Titel:

So nen Code schreib ich nicht mal bei irgend nem komischen Konzept. Einfach grauenhaft.

Bashar Mitglied 14:53:27 03.02.2012 Titel:

curry-king schrieb:

Der Code ist ein proof-of-concept eines speziellen automata lernaers.

Einen Proof-of-concept wirft man, wenn er funktioniert, weg und refaktorisiert ihn nicht.

hustbaer Mitglied 16:43:38 03.02.2012 Titel:

Die Grenze zwischen refactoring und neu implementieren ist ziemlich schwammig. Ich sehe kein Problem darin, funktionierenden Proof-Of-Concept Code umzubauen.
Und SO katastrophal ist der Code nicht. Sieht für mich eher so aus, als ob der relativ einfach umzubauen wäre.

@314159265358979
Du bist aber auch das komplett andere Extrem wie der der den Code geschrieben hat.
Du bist C++ Sprachfetischist, dir kommt es mehr auf das "wie" an als darauf dass irgendwas fertig wird.
Der der den Code geschrieben hat hatte anscheinend kaum C++ Kenntnisse, und wollte das Teil einfach zum Laufen bekommen, alles andere war für ihn vermutlich total nebensächlich.

Deswegen ist der Code aber nicht total katastrophaler Müll, und muss jetzt geschmäht und weggeworfen werden.

phlox81 Moderator 20:13:30 03.02.2012 Titel:

Würde den Code mal durch Cppcheck laufen lassen, dann hast du die gröbsten Schnitzer schon mal analysiert, und kannst evtl. memleaks korrigieren.

Unregistrierter

Die Funktionen passen ja auf eine Seite. Das ist ja nicht wirklich schwer zu refactoren.

otze Mitglied 22:18:25 03.02.2012 Titel:

314159265358979 schrieb:

So nen Code schreib ich nicht mal bei irgend nem komischen Konzept. Einfach grauenhaft.

du hast noch nie wirklich schlimmen Code gesehen. Der Code ist lesbar, ja gar verständlich. Die Variablen haben mehr als 1 Zeichen und es wird nix 10 mal wiederverwendet. Ein Traum.

Da habe ich schon so viel schlimmere Dinge gesehen (allerdings war das schlimmste eine Bibliothek geschrieben von einem template-fetischisten. Da hat beim code-review unsere gesamte Arbeitsgruppe kapituliert)

314159265358979 Mitglied 22:30:25 03.02.2012 Titel:

Mag sein, dass ich der "C++ Sprachfetischist" bin, wie hustbaer es gesagt hat, aber der Code ist in jeder Hinsicht schlecht.

hustbaer Mitglied 22:44:29 03.02.2012 Titel:

@314159265358979
Was otze schreibt ist die Realität.
Wie willst du beurteilen was Sache ist, wenn du noch nie irgendwo als Programmierer gearbeitet hast?

Das ist das nervige bei deinen Beiträgen, dass du immer glaubst alles zu wissen und alles einschätzen zu können, und dich immer und überall wichtig machen musst.

Der Code ist nicht "ist in jeder Hinsicht schlecht", das ist einfach nur Schwachsinn.

cooky451 Mitglied 23:01:53 03.02.2012 Titel:

hustbaer schrieb:

Der Code ist nicht "ist in jeder Hinsicht schlecht", das ist einfach nur Schwachsinn.

Pi ist nur frustriert, weil er bereits jetzt (mit 16, siehe Altersthread) offensichtlich wesentlich besser programmieren kann als die meisten berufstätigen Programmierer, er aber keine oder nicht genug Anerkennung dafür bekommt. Der einzige psychologische Ausweg ist also, seine eigenen Fähigkeiten als untere Messlatte anzusetzen, und alle die bedeutend weniger können als er selbst als hoffnungslose Versager zu sehen.

Mit freundlichen Grüßen
Ihr Experten-Internet-Hobbypsychologenteam®

theta Mitglied 23:22:31 03.02.2012 Titel:

cooky451 schrieb:

hustbaer schrieb:

Der Code ist nicht "ist in jeder Hinsicht schlecht", das ist einfach nur Schwachsinn.

Pi ist nur frustriert, weil er bereits jetzt (mit 16, siehe Altersthread) offensichtlich wesentlich besser programmieren kann als die meisten berufstätigen Programmierer, er aber keine oder nicht genug Anerkennung dafür bekommt. Der einzige psychologische Ausweg ist also, seine eigenen Fähigkeiten als untere Messlatte anzusetzen, und alle die bedeutend weniger können als er selbst als hoffnungslose Versager zu sehen.

Mit freundlichen Grüßen
Ihr Experten-Internet-Hobbypsychologenteam®

otze Mitglied 00:29:35 04.02.2012 Titel:

314159265358979 schrieb:

der Code ist in jeder Hinsicht schlecht.

Das ist quark. Du kannst völlig problemlos die Struktur des Codes begreifen. Du kannst verstehen, was er macht. Er ist im Grunde gut strukturiert, nur merkt man, dass der Benutzer wenig Ahnung von der Sprache und kaum Programmiererfahrung hat. Ein erfahrener Programmeir geht da einmal drüber, ersetzt die Konstrukte durch die mit besserem C++-Stil und ist fertig.

Ich zeige dir mal schlechten Code. Der stammt 1:1 aus dem Code eines Papers und ist leider so wichtig, dass wir ihn nicht raus werfen können. Bislang konnte sich niemand aufraffen, sich so tief in den Algorithmus einzuarbeiten, dass er den Algorithmus weg werfen kann.

http://shark-project.svn.sourceforge.net/viewvc/sh ....... ithms/SigmoidFit.cpp?revision=1632&view=markup

Zeile 90ff (ich bitte den dynamic_cast in der Datei zu ignorieren, der kommt da bald nach langen Diskussionen weg

).

cooky451 Mitglied 00:46:49 04.02.2012 Titel:

Den Haialarm find ich gut.

zeusosc Mitglied 00:53:01 04.02.2012 Titel:

@Pi und dot

314159265358979 schrieb:

Die "default"-Implementierung von delete[] ist doch threadsafe, oder?

Jain,..
delete[] hat keine atomare sondern nur eine elementbezogendes LOCK# prefix...

Unregistrierter

otze schrieb:

Ich zeige dir mal schlechten Code. Der stammt 1:1 aus dem Code eines Papers und ist leider so wichtig, dass wir ihn nicht raus werfen können. Bislang konnte sich niemand aufraffen, sich so tief in den Algorithmus einzuarbeiten, dass er den Algorithmus weg werfen kann.

http://shark-project.svn.sourceforge.net/viewvc/sh ....... ithms/SigmoidFit.cpp?revision=1632&view=markup

Zeile 90ff (ich bitte den dynamic_cast in der Datei zu ignorieren, der kommt da bald nach langen Diskussionen weg

).

Also wenn man "platt's method" kennt, sollte der auch nicht so schwer zu verstehen sein, wenn das die einzige Doku zu platt's method ist, dann wird es schwieriger.

zeusosc Mitglied 01:14:20 04.02.2012 Titel:

otze schrieb:

http://shark-project.svn.sourceforge.net/viewvc/sh ....... ithms/SigmoidFit.cpp?revision=1632&view=markup

http://www.csie.ntu.edu.tw/~cjlin/papers/plattprob.pdf
http://de.wikipedia.org/wiki/Logistische_Regression
http://de.wikipedia.org/wiki/Gradientenverfahren

Damit sollte das Rätsel gelöst sein.

Es handelst sich wohl um eine Logistische Regression die
mittels eines Gradientenabstiegsverfahren durchgeführt wird.

Aber mal ganz erhlich,... soo hässlich ist der code nun auch wieder nicht...

Unregistrierter

314159265358979 schrieb:

aber der Code ist in jeder Hinsicht schlecht.

Begründung?

otze Mitglied 08:54:25 04.02.2012 Titel:

zeusosc schrieb:

Es handelst sich wohl um eine Logistische Regression die
mittels eines Gradientenabstiegsverfahren durchgeführt wird.

Na, das ist die Methode die bei Zeile 60 beginnt und bei Zeile 70 fertig ist

.
Uns ist bewusst, dass die Methode ein Newton-step Liniensuchverfahren ist. Trotzdem möchte da niemand dran rum basteln.

//edit Die Dokumentationssituation hat sich auch absolut geändert, nachdem jemand auf die Idee kam, das Ding nicht mehr nur SigmoidFit zu nennen, sondern zumindest den Namen des Erfinders der Methode dazu zu schreiben.

314159265358979 Mitglied 09:46:20 04.02.2012 Titel:

hustbaer schrieb:

Wie willst du beurteilen was Sache ist, wenn du noch nie irgendwo als Programmierer gearbeitet hast?

Hab ich doch schon. Nur nicht als C++-Programmierer, sondern C#.

hustbaer Mitglied 21:44:59 04.02.2012 Titel:

cooky451 schrieb:

hustbaer schrieb:

Der Code ist nicht "ist in jeder Hinsicht schlecht", das ist einfach nur Schwachsinn.

Pi ist nur frustriert, weil er bereits jetzt (mit 16, siehe Altersthread) offensichtlich wesentlich besser programmieren kann als die meisten berufstätigen Programmierer

Das bestreite ich. Pi kann Grammatik. Er hat noch nie, nichtmal ansatzweise demonstriert, dass er damit Aufsätze schreiben kann.

Hacker Mitglied 13:17:42 05.02.2012 Titel:

314159265358979 schrieb:

hustbaer schrieb:

Wie willst du beurteilen was Sache ist, wenn du noch nie irgendwo als Programmierer gearbeitet hast?

Hab ich doch schon. Nur nicht als C++-Programmierer, sondern C#.

Wo? glaub ich nicht. Nicht offiziell.

Edit: Ich glaube es nicht "nicht offiziell", sondern ich glaube nicht dass du schon einmal irgendwo offiziell gearbeitet hast.

314159265358979 Mitglied 13:28:22 05.02.2012 Titel:

Dann glaubs mir halt nicht, ist mir auch egal.