Für meine Bachelorarbeit arbeite ich an einem Spektrallöser in 2D, wofür ich u.A. die Gauß-Lobatto Integration brauche.

Da die Berechnung nicht beliebig oft wiederholt werden soll, habe ich mir eine Art 'Tresor' Klasse gebaut, die zu jeder Ordnung gespeicherte Datensätze abrufen und ggf. neue berechnen lassen kann.

Das Grundgerüst sieht so aus:

class Computation_Safe {
private:
    vector< vector < double > >                                             nodes;
    vector< vector < double > >                                             weights;
    vector< int >                                                           computed_orders;
    vector< unsigned int >                                                  map_order_to_index;
public:
    Computation_Safe                                                        (                                                   );
    ~Computation_Safe                                                       (                                                   );

    //Getter
    pair<vector<double>*,vector<double>* >   operator[]                      (   unsigned int                                    );
    bool                                    computed_nodesAndWeights_forOrder(  unsigned int order                              );

};

Und hier die Routine die Probleme macht:

pair<vector<double>*, vector<double>* > Computation_Safe::operator[](unsigned int order)
{
    if(!computed_nodesAndWeights_forOrder(order))
    {
        if (order >= computed_orders.size()) {
            for (unsigned long i = computed_orders.size(); i < order; ++i) {
                computed_orders.push_back(0);
                map_order_to_index.push_back(-1);
            }
        }
        //Letzter Eintrag:
        computed_orders.push_back(1);
        map_order_to_index.push_back((unsigned int)nodes.size());
        //Neue Knoten und Gewichte berechnen
        pair<vector<double>, vector<double>> new_nodesAndWeights = compute_nodesAndWeights_gaussLobattoQuadrature(order);
        //Und schreiben
        nodes.push_back(new_nodesAndWeights.first);
        weights.push_back(new_nodesAndWeights.second);        
    }
    pair<vector<double>*, vector<double>* > nodesAndWeights_forOrder;
    nodesAndWeights_forOrder.first = &nodes[order];
    nodesAndWeights_forOrder.second = &weights[order];

    return nodesAndWeights_forOrder;
}

Es wird alles korrekt gespeichert innerhalb der Instanz von 'Computation_Safe', aber in nodesAndWeights_forOrder.second wird nichts gespeichert. In .first ist alles prima...

Wie kann das kommen?

Vertragen sich pair und vector* aus unerklärlichen Gründen nicht?

Viele Grüße und danke im Voraus!

Denis

~(Edit v. Arcoth, Code-Tags)~

for (unsigned long i = computed_orders.size(); i < order; ++i) {
                computed_orders.push_back(0);
                map_order_to_index.push_back(-1);
            }

computed_orders   .resize( order, 0 );
map_order_to_index.resize( order, std::numeric_limits<unsigned int>::max() ); // Edit: Ist die zweite Zeile auch korrekt? Ist die Größe von map_order... dieselbe wie die von computed_orders?

_________________________________________________________________________

nodes.push_back(new_nodesAndWeights.first);
weights.push_back(new_nodesAndWeights.second);

Falls möglich umschreiben zu

nodes  .push_back( std::move(new_nodesAndWeights.first ) );
weights.push_back( std::move(new_nodesAndWeights.second) );

_________________________________________________________________________

pair<vector<double>*, vector<double>* > nodesAndWeights_forOrder;
    nodesAndWeights_forOrder.first = &nodes[order];
    nodesAndWeights_forOrder.second = &weights[order];

    return nodesAndWeights_forOrder;

return {&nodes[order], &weights[order]};

Nachdem ich den Post abgeschickt habe hat's keine 5 Minuten mehr gedauert:

Ich Idiot hab' falsch auf die Daten zugegriffen. Richtig ist:

nodesAndWeights_forOrder.first = &nodes[map_order_to_index[order]];
    nodesAndWeights_forOrder.second = &weights[map_order_to_index[order]];

Witzig, dass sich der Compiler nicht beschwert hat (-Wall -pedantic), und trotzdem an erster Stelle das richtige Ergebnis stand.

Sorry Dafür!

vector< vector< pair< double, double > > >  weighted_nodes;
// oder wenigstens
vector< pair< vector< double >, vector< double > > >  weighted_nodes;

Der gesamte if-Zweig sollte in einer eigenen Funktion stehen. Dann wird das Ganze übersichtlicher.

nodes  .push_back( std::move(new_nodesAndWeights.first ) );
weights.push_back( std::move(new_nodesAndWeights.second) );

andere Variante wäre hier mal tie zu verwenden:

nodes.push_back( {} );
weights.push_back( {} );
tie( nodes.back(), weights.back() ) = compute_nodesAndWeights_gaussLobattoQuadrature(order);

(mit weighted_nodes wird es noch einfacher).

EIn Rückgabetyp

pair<vector<double>&, vector<double>& >

könnte syntaktisch bequemer sein. Dann ist nämlich zum Beispiel der Zugriff etwa auf den Indexoperator der Vectoren direkt möglich, sonst erfordert die extra Derenzierung zusätzlichen Schreibaufwand.

tie hab' ich bisher noch nie wirklich genutzt, die Doku dazu sieht aber vielversprechend aus für das, was ich eigentlich suche.

Mein erster Versuch für die Klasse war mit deinem zweiten Vorschlag:

vector< pair< vector< double >, vector< double > > >  weightsAndNodes;

Da hab' ich aber eben mit den Rückgabetypen was nicht hin bekommen:

Angenommen ich nehme das Format oben.
Was ist denn dann mein Rückgabetyp??
Das hier:

pair < vector < double > , vector < double > >&

?
Sorry, aber bei sowas bin ich immer total hilflos..

Danke für eure Hilfe!

Angenommen ich nehme das Format oben.
Was ist denn dann mein Rückgabetyp??
Das hier:

pair < vector < double > , vector < double > >&

Genau (pair < vector < double >&, vector < double >& >) würde allerdings auch funktionieren.

Die Berechnung wird dann einfach zu

weightsAndNodes.emplace_back( compute_nodesAndWeights_gaussLobattoQuadrature(order));

Die Rückgabefunktion sieht jetzt so aus, und funktioniert:

pair < vector<double>&, vector<double>& > Computation_Safe::get_nodesAndWeights_forOrder(unsigned int order)
{
    resize_ifNecessary(order); // Berechnet auch Gewichte und Knoten falls nötig
    return { nodes[map_order_to_index[order]],weights[map_order_to_index[order]] };
}

1. Frage: Der Tipp mit den geschweiften Klammern kam von euch aus dem Forum. Was genau macht das?

2. Frage: Kann mir jemand erklären wie ich denn jetzt den Rückgabetyp mit make_pair (theoretisch) angeben könnte??

return make_pair(nodes[map_order_to_index[order]],weights[map_order_to_index[order]]

bringt mir nur ein 'no viable conversion from [...] to [...]'.

EDIT: Wenn ich die Arbeit abgebe, muss ich das auf jeden Fall noch umschreiben. Die Version mit den geschweiften Klammern kompiliert problemlos in xCode, aber nur unter Verwendung vom LLVM Compiler. Sowohl G++ als auch CLANG bekommen das (aus dem Terminal) nicht kompiliert.

Liebe Grüße,
Denis

bringt mir nur ein 'no viable conversion from [...] to [...]'.

was genau in den [...] steht, würde uns da schon interessieren.

denis2102 schrieb:

Die Version mit den geschweiften Klammern kompiliert problemlos in xCode, aber nur unter Verwendung vom LLVM Compiler. Sowohl G++ als auch CLANG bekommen das (aus dem Terminal) nicht kompiliert.

-std=c++0x oder -std=c++11 mit angeben

No viable conversion from 'pair<typename __make_pair_return<class vector<double, class allocator<double> > &>::type, typename __make_pair_return<class vector<double, class allocator<double> > &>::type>' to 'pair<vector<double> &, vector<double> &>'

Das mit -std=C++** funktioniert dabei auch nicht.

Was macht denn jetzt die geschweifte Klammer?

Verzeiht meine Ratlosigkeit

return make_pair(std::ref(nodes[map_order_to_index[order]]),std::ref(weights[map_order_to_index[order]]));

lauten und braucht dann auch C++11. In C++03 bleibt dir nichts anderes übrig, als den Rückgabetypen direkt beim return nochmal hinzuschreiben.

nodes.push_back( {} );
weights.push_back( {} );

Hier sollte wohl eher emplace_back ohne Argumente stehen.

weightsAndNodes.emplace_back( compute_nodesAndWeights_gaussLobattoQuadrature(order));

Und hier sollte push_back stehen.

Noch kürzer geht es auch

tie( *back_inserter(nodes), *back_inserter(weights) ) = compute_nodesAndWeights_gaussLobattoQuadrature(order);

Was genau macht das?

Das nennt sich list-initialization; hier speziell copy-list-initialization. Es übergibt - grob beschrieben - die Listenelemente als Konstruktorargumente an das Rückgabeobjekt.

tie( *back_inserter(nodes), *back_inserter(weights) ) = compute_nodesAndWeights_gaussLobattoQuadrature(order);

interessante Idee.