//Dies ist der vector der sich verändert
std::vector< double >            M;

//Aufruf einer Insert funktion siehe unten
//p_col = [1,0,0,1] z.B und e_k_hat = [4,3,0,0] als Beispiel
Insert(M, p_col, e_k_hat);

//Hier hat M jetzt einträge
//Es folgt ein Aufruf einer Fortran Funktion
fortranf_                     (SIDE,
                                   TRANS,
                                    &m,
                                    &n,
                                    &k,
                                    &A_hat[0],
                                    &lda,
                                    &tau[0],
                                    &e_k_hat[0],
                                    &lda,
                                    &work[0],
                                    &lwork,
                                    &info);

und hier hat  M ein paar werte anders...

//Kopierfunktion:
void 
MyClass::Insert(std::vector< double >& M, 
                     const std::vector< double >& p_col,
                     const std::vector< double >& e_k_hat)
{
    std::vector< double >::const_iterator el = e_k_hat.begin(); 
    for( std::vector< double >::const_iterator i = p_col.begin(); 
         i != p_col.end(); 
         ++i ) 
    { 
        if( *i != 0.0 )
            M.push_back(*el++);  
        else 
            M.push_back(0.0);   
    } 
}

ich sehe den fehler nicht...
der aufruf der fortranfunktion kann doch M nicht verändern weil ich doch M gar nicht übergebe?
Ich steh total auf dem schlauch....

Wichtig ist:
Die fortran funktion operiert auf dem e_k_hat und verändert es.
Kann das was mit dem Kopieren in der insert funktion zu tun haben und im nachhinein wird dann e_k_hat verändert und damit auch M? Ich kann mir das nicht erklären...

Hier noch die veränderung:

0.0549
0
0
0.3244

wird zu
0.0523
0.1607
0
0.3244

Danke euch!

Aber das wäre ja nicht so toll...kann ich so einem Überlauf entgegenwirken? Wüsste jetzt nicht wie...die fortranf_ funktion ist nicht von mir...ich kann sie also nicht beeinflussen...

edit:
es ist so: die fortranf_ funktion wird in ner schleife mehrmals aufgerufen und das M wächst von iteration zu iteration. Erst beim zweiten aufruf also bei der 2ten iteration verändern sich plötzlich die ersten beiden werte die in erster iteration geschrieben wurden...danach also in den nachfolgenden iterationen ist immer alles ok also das "phänomen" taucht nur bei erster iteration mit nur einer eingabe (bisher) auf...

*grmpf

double* dummy = (double*)calloc(100000,sizeof(double));

        fortranf_                     (SIDE,
                                     TRANS,
                                     &m,
                                     &n,
                                     &k,
                                     &A_hat[0],
                                     &lda,
                                     &tau[0],
                                     &e_k_hat[0],
                                     &lda,
                                     &work[0],
                                     &lwork,
                                     &info);
        free(dummy);

Naja die fortran funktion in c++ schreiben...leider brauche ich es ultra-effizient....die bibliotheksfunktion gilt als die schnellste ich glaub net dass ich das besser hinkriegen würde...

Ich schau mich mal nach speicherüberlauf programmen um für linux...

danke

Edit:
Hmm habe folgendes gemacht und M ändert den wert nicht mehr....ist das ein beweis dass ein speicherüberlauf stattfindet?

einfach ganz am anfang eingefügt:

for(int t = 0; t < 100; t++)
        M.push_back(t);
    M.clear();

so passt es und der fortran aufruf ändert das M nimmer ab....

Nur so nebenbei: Kann es nicht sein dass ich schuld bin? Ich meine vielleicht sollte ich das M anders konstruieren...

...

...
Insert(M, p_col, e_k_hat);
...

Danke euch!

Hi,

magst Du mal zeigen, wie Du p_col und e_k_hat definierst und füllst ?
Außerdem fällt mir auf, dass Du hier

...    
    std::vector< double >::const_iterator el = e_k_hat.begin();
    for( std::vector< double >::const_iterator i = p_col.begin(); i != p_col.end(); ++i ) {
        if( *i != 0.0 )
            M.push_back(*el++);  
        else
            M.push_back(0.0);  
    }

durch e_k_hat iterierst, ohne sicherzustellen, dass Du nicht über sein Ende hinweg liest (sollte zwar nicht so schlimm sein, ist aber trotzdem unsicher).

Gruß,

Simon2.

ich erstelle die vektoren so:

const int dimension = ...;

std::vector< double >   e_k_hat,
                                     p_col(dimension);

gefüllt werden sie so:

void
Class::Create_e_k(const int col, 
                 const int dimension, 
                 std::vector< double >& e_k_hat)
{
    e_k_hat.clear();
    e_k_hat.resize(dimension, 0.0);
    e_k_hat[col] = 1.0;
}

//und p_col

void
Class::Get_Pattern_Column(std::vector< double >& p_col, 
                         const std::vector< double >& P, 
                         const int col, 
                         const int dimension)
{
    p_col.clear();
    p_col.insert(p_col.begin(), 
                 P.begin() + dimension * col, 
                 P.begin() + dimension * ( col + 1 ));
}

danke - du hast so natürlich recht mit dem drüber hinaus lesen...
man muss natürlich wissen dass e_k_hat nie grösser sein kann als p_col...ist in meinem Algorithmus so...
aber vielleicht gibt es eine elegantere lösung ??

Danke für Ratschläge....

Ist meine Annahme richtig dass mit den drei zeilen mit speicher alloziieren dann ein speicherüberlauf statt findet in der fortran - funktion?

also ich sehe da so erstmal nichts Falsches. Allerdings ist mir Dein Umgang mit den Vektoren ein wenig ungewohnt - gerade so das "resizen" und das Hin- und Herkopieren von Teilvektoren. Aber das entspringt nur meinem persönlichen Geschmack. Das heißt nicht, dass es irgendwie falsch/schlecht/unsicher wäre.

Liegt wohl doch eher in der Fortranfunktion.

Gruß,

Simon2.

im moment weiß ich nicht wie ich vorgehen soll zwecks dem speicherüberlauf bzw. obs überhaupt einer is...

nur so interessenhalber zwecks den vektoren und dem resizen...
wie würdest du/ihr das denn so machen....
ich lese immer nur code-reuse zwecks STL etc...

Und so gehts halt bequem -

Danke