for(int iz = 0;iz<n;++iz)
	{
		vector<int> f = vec[iz];
		double score = 0;
		for(int  is = 0;is<m;++is)
		{	
				int y = y_vector[is];
				int v = f[is];
				double p_i = p_ivector[is];

				if(y==0)                
				{					
					 p=1.0-p_i;

                 }
                 else
				 {					
					  p=p_i;
                 }

				if(y== v) 
				 {		

					 score +=sqrt((1-p)/(p));					
                 }
                 else
                 {					
					 score -=sqrt((p)/(1-p));			

                 }
		}

		UserScore[iz] = score;
	}

Vielen danke

edit: Teste aber die Techniken aus dem verlinkten Artikel lieber nochmal selber. Als ich mal die im Artikel gelobte Quake3-Wurzel getestet habe, hat die gegen die Wurzelfunktion meiner (damals recht neuen) CPU verloren.

ich wollte die funktion optimieren damit ich ein schnelere laufzeit habe

Wie groß sind die Vektoren? Ach, eigentlich fast egal. Übergabe sollte jedenfalls per Referenz erfolgen, das bringt schon einmal ungeheure Vorteile beim Aufruf der Funktion.

Ist vector<vector> wirklich nötig? Das ist schon sehr sehr indirekt und daher lahm. Meistens wird das von Anfängern gemacht, die das gar nicht brauchen und die eigentlich die innere Dimension fest haben wollen. Da ist dann ein std::array angebracht.

Musst du in Zeile 8 wirklich eine Kopie machen? So wie ich das sehe, reicht da ebenfalls eine Referenz.

Wenn ich das richtig sehe, ließe sich die gesamte Rechnung auch parallelisieren, wenn du das p erst dort definieren würdest, wo es gebraucht wird. Dann sind die Rechnungen zum iz nämlich komplett unabhängig. Bei vielen iz lohnt sich dann eine Parallelisierung.

Ansonsten drück mal möglichst präzise aus, was die Funktion überhaupt machen soll. Vielleicht kann man am Algorithmus selber noch was schrauben, anstatt nur an der technischen Umsetzung.

Da du dich nicht präzise ausdrücken möchtest, was du erreichen möchtest, ist das erst einmal alles was man sagen kann.

Die dicksten Klöpse sind jedenfalls erst einmal die ganzen Kopien, nicht nur Zeile 8 sondern eben auch bei der Parameterübergabe. Ich hoffe, die hast du ebenfalls weg gemacht.

meine matrix ist fast 5000 *1000(matrix mit 0und 1 ausgefuhlt)

Wenn die "innere" Dimension eine konstante Größe hat, auf jeden Fall durch ein std::array ersetzen.

vector< vector<int> >

Hat den riesigen Nachteil das die inneren std::vector meist ihre Speicherbereiche verprenkelt haben und immer wenn ein neuer std::vector bearbeitet wird, erstmal ein CPU-Cachemiss auftritt.

Mit std::array/boost::array bzw einer eigenen Wrapperklasse für Arrays liegt der ganze Speicher am Stück, was massiv Zeit spart.

Alternativ kannst du, wenn beide Dimensionen dynamisch sein müssen, einen einfachen vector<int> mit n * m Größe nehmen und die Index-Zugriffe umrechen, spart auch sehr viel Zeit.

Alternativ kannst du, wenn beide Dimensionen dynamisch sein müssen, einen einfachen vector<int> mit n * m Größe nehmen und die Index-Zugriffe umrechen, spart auch sehr viel Zeit.

Dann ist die innere Dimension aber nicht mehr dynamisch. Wenn sie dynamisch sein muss, dann führt nichts an vector<vector>> vorbei, wenn sie statisch ist, dann sind vector<array> und vector(m*m) äquivalent.

Ethon schrieb:

Alternativ kannst du, wenn beide Dimensionen dynamisch sein müssen, einen einfachen vector<int> mit n * m Größe nehmen und die Index-Zugriffe umrechen, spart auch sehr viel Zeit.

Dann ist die innere Dimension aber nicht mehr dynamisch. Wenn sie dynamisch sein muss, dann führt nichts an vector<vector>> vorbei, wenn sie statisch ist, dann sind vector<array> und vector(m*m) äquivalent.

Ich hab mich falsch ausgedrückt, ich meinte wenn die Größen Laufzeitparameter sind.

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <functional>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <tuple>
#include <utility>
#include <vector>

void score(const std::vector<double>& p_ivector, const std::vector<int>& y_vector, std::vector<std::vector<int>>& vec, std::vector<double>& UserScore)
{
    std::vector<std::tuple<int, double, double>> p2;
    p2.reserve( p_ivector.size() );
    std::transform(
        p_ivector.cbegin(),
        p_ivector.cend(),
        y_vector.cbegin(),
        std::back_inserter( p2 ),
        [](double p, int y)
        {
            return y == 0
                ? std::make_tuple( y, std::sqrt( p / ( 1 - p ) ), -std::sqrt( ( 1 - p ) / p ) )
                : std::make_tuple( y, std::sqrt( ( 1 - p ) / p ), -std::sqrt( p / ( 1 - p ) ) );
        } );

    std::transform(
        vec.cbegin(),
        vec.cend(),
        UserScore.begin(),
        [&](const std::vector<int>& f)
        {
            return std::inner_product(
                p2.cbegin(),
                p2.cend(),
                f.begin(),
                0.0,
                std::plus<double>(),
                [](const std::tuple<int, double, double>& t, int v)
                {
                    return std::get<0>( t ) == v ? std::get<1>( t ) : std::get<2>( t );
                } );
        } );
}