en funktion der kan ranke to talrækker

Hej udviklere,

Jeg prøver at finde ud af hvordan jeg kan passere et argument til en funktion, der fortæller hvilken variabel i en struct som funktionen skal arbejde på. Måske er løsningen for mig at gå til problemet på en helt anden måde, så jeg beskriver lige hele ideen.
jeg har siddet i et stykke tid og bokset med at lave en funktion der skal kunne udføre en spearman rank correlation. Problemet er at jeg har en række punkter med en x og en y værdi, altså (x,y). For at kunne lave testen skal alle mine x'er rankes fra laveste til højeste, og det skal alle mine y'er også. For at få det til at hænge sammen har jeg lavet en struct:

Kode 

struct Observation {                     
       double Var1; //de to variable                   
       double Var2; 
       double Rang1; // og deres rang
       double Rang2;
       };

Derved får jeg en vector:

Kode 

std::vector<Observation> Vec

som jeg sorterer med et predikat, som jeg har skrevet til at fortælle sort hvilken variabel den skal sortere for:

Kode 

sort (Vec.begin(), Vec.end(), ForVar2);

og så kan jeg faktisk bare rangere den ved at gå gennem vectoren med en for-løkke og give Vec.Rang2 værdien af indexet.

Problemet er at nogle værdier er ens (eks: 1,2,3,3,4), og at håndtere dette kræver en del mere kode, så der bliver en større sag. (Hele koden er indsat her, hvis der er noget jeg ikke har forklaret):

Kode 

double SpearmanRank (const vector<double>& Vec1, const vector<double>& Vec2)
       {    
       typedef vector<double>::size_type siz_d; 
       siz_d ObsInd = Vec1.size();                             // her laver jeg en vektor der kan holde værdierrne og rangtal sammen
       vector<Observation> Vec(ObsInd);                        // af samme størrelse som de to inputvektorer
                               
       if (Vec1.size() != Vec2.size())
          {
          throw domain_error("Korrelation af to ikke lige lange talrækker");
          }
          
       for (siz_d i = 0; i != ObsInd; ++i)                       // her kopieres de to vectors ind i en datastruktur der kan holde
          {                                                    // værdier og rangtal sammen
          Vec[i].Var1 = Vec1[i];
          Vec[i].Var2 = Vec2[i];
          }
                
       typedef vector<Observation>::size_type siz_t;  
       const siz_t AntalObs = Vec.size();                      // en variabel der kan holde styr på antallet af observationer


// alt dette burde gøres til en funktion, men hvordan?
      
	   sort (Vec.begin(), Vec.end(), ForVar1);                 // her rankes Var1 og rangen indskrives i Rang1
      
	   siz_t i = 0;

	   while(i != AntalObs)
       {
           if(i == AntalObs-1 || Vec[i].Var1 != Vec[i+1].Var1)	
		   {
			   Vec[i].Rang1 = i+1;								
			   ++i;
		   }
		   else
		   {
			   siz_t j = i;
			   siz_t sum = j;
			   
			   do 
			   {
				   ++j;
				   sum += j;
			   }
			   while(j != AntalObs-1 && Vec[j].Var1==Vec[j+1].Var1);
			   if(j == AntalObs-1)
			   {
				   ++j;
				   sum += j;
			   }


			   for(siz_t x=i; x!=j; ++x)
				   Vec[x].Rang1 = sum/(j-i+1);
			   i=j;
		   }
	   }  

Jeg vil derfor gerne putte det væk i en funktion. Ideelt skulle jeg kunne kalde denne funktion først med en besked om at sortere Vec.Var1 og læse værdien ind i Vec.Rang1, og dernæst med Vec.Var2 og Vec.Rang2.
Men er der nogen måde jeg kan gøre dette, eller burde jeg gentænke hele den måde jeg har løst problemet?

Kode 

 // her udregnes den summerede forskel i rang
       double RangDiff =0;
       
       for (siz_t i=0; i != AntalObs; ++i)
           {
           RangDiff += pow(Vec[i].Rang1 - Vec[i].Rang2, 2);
           }

       // her udregnes selve korrelationskoefficienten
      
       double SpearmanCorr;
	   double Obs = double(AntalObs);

       SpearmanCorr = (1-((6*RangDiff)/(pow(Obs, 3) - Obs)));
           
       return SpearmanCorr;
       }

Kode 

CorVar * p;
p = // ??  

Kode 

           if(i == AntalObs-1 || Vec[i].p->Var != Vec[i+1].p->Var)
		   {
			   Vec[i].p->Rang = i+1;								
			   ++i;

Kode 

struct Datapunkt{
double value;
double rank;
double obsID;
};

Kode 

#include <algorithm>
#include <vector>
#include <stdexcept>
#include <math.h>
#include "SpearmanRank.h"

// Her beskrives en funktion der laver en spearman rank correlation
// mellem 2 vektorer og returnerer r2 værdien

using std::sort;				using std::vector;      
using std::domain_error;

double SpearmanRank (const vector<double>& vec1, const vector<double>& vec2)
       {    
		                             
       if (vec1.size() != vec2.size())
          {
          throw domain_error("Korrelation af to ikke lige lange talrækker");
          }
       
	   typedef vector<double>::size_type siz_t;
	   const siz_t AntalObs = vec1.size();  // en variabel der kan holde styr på antallet af observationer

	   vector<double> rank1 = Rank(vec1);
	   vector<double> rank2 = Rank(vec2);
        
       // her udregnes den summerede forskel i rang
       double RangDiff =0;
       
       for (siz_t i=0; i != AntalObs; ++i)
           {
           RangDiff += pow(rank1[i] - rank2[i], 2);
           }

       // her udregnes selve korrelationskoefficienten
      
	   double Obs = double(AntalObs);

       return 1-((6*RangDiff)/(pow(Obs, 3) - Obs));
       }


vector<double> Rank(const vector<double>& vec)
{
	typedef vector<Datapunkt> Datavektor;
	typedef Datavektor::size_type siz_d;
	typedef Datavektor::iterator iter;

	siz_d AntalObs = siz_d(vec.size()); 
	Datavektor data(AntalObs);		// af samme størrelse som de to inputvektorer		
	siz_d i;

	for (i = 0; i != data.size(); ++i)               // her kopieres de to vectors ind i en datastruktur der kan holde
	{											     // værdier og rangtal sammen
		data[i].var = vec[i];						 // jeg bruger index og ikke iterator, idet jeg skal ind i flere vektorer
        data[i].obs = (int)i;
	}

	sort(data.begin(),data.end(),ForSize);


	double rangtaeller = 1.0;
	for (iter it = data.begin(); it != data.end(); ++it)
		if  (it+1 == data.end() || it->var != (it+1)->var)
		{
			it->rang = rangtaeller++;
		}
		else
		{
			iter j = it;
			double sum = 0.0;
			int n = 0;

			while (j != data.end() && j->var == it->var)
			{
				sum += rangtaeller++;
				++n;
				++j;
			}
			for (it; it!= j; it++)
			{
				it->rang = sum/n;
			}
			--it;									// spoler it tilbage, så den værdi der læses næste gang gennem den store
		}											// for-løkke bliver den værdi der nu peges af j

	

	sort(data.begin(),data.end(),ForObs);

	vector<double> ret;

	for (i = 0; i != data.size(); ++i)						  
	{														 
		ret.push_back(data[i].rang);
	}

	return ret;
}

bool ForSize(const Datapunkt& x, const Datapunkt& y)   
     {                                                     
     return x.var < y.var;
     }
     
bool ForObs(const Datapunkt& x, const Datapunkt& y)
     {
     return x.obs < y.obs;
     }