Skip to content
Snippets Groups Projects
calcul.cpp 5.69 KiB
Newer Older
  • Learn to ignore specific revisions
  • Martin Rusek's avatar
    Martin Rusek committed
    #pragma once
    
    #include "calcul.h"
    #include <ctime>
    #include <cmath>
    #include <iostream>
    #include <iomanip>
    #include <algorithm>
    
    using namespace std;
    
    
    double calcul::distancesMany_dtw(vtr2<double> const &points)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    	double sum = 0;
    
    	for (size_t i = 0; i < points.size(); i++)
    	{
    		for (size_t j = i + 1; j < points.size(); j++)
    		{
    
    			sum += distance_dtw(points[i], points[j]);
    
    Martin Rusek's avatar
    Martin Rusek committed
    		}
    	}
    
    	return sum;
    }
    
    
    double calcul::distance_dtw(vtr<double> const &u, vector<double> const &v)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    	double sum = 0;
    
    	//if (u.size() == 0 || v.size() == 0)
    	//	return 0;
    
    	//size_t uL = u.size(); //sizeof(u) / sizeof(*u);
    	//size_t vL = v.size(); //sizeof(v) / sizeof(*v);
    
    	//size_t shorterDim = (uL < vL) ? uL : vL;
    
    	for (size_t i = 0; i < u.size(); i++)
    	{		
    		sum += pow(u[i] - v[i], 2);
    
    		//sum += abs(u[i] - v[i]);
    
    Martin Rusek's avatar
    Martin Rusek committed
    		//su = u[i] - v[i];
    		//sum += (su + (su >> 31)) ^ (su >> 31);
    		//su = u[i] - v[i];
    		//sum += (su > 0) ? su : checked(-su);
    	}
    
    	//return (int)Math.Sqrt(sum);
    	return sum;
    }
    
    
    double calcul::distance_lcss(vector<double> const &u, vector<double> const &v, int idx)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    	if (u.size() == 0 || v.size() == 0)
    		return 0;
    
    	double sum = abs(u[idx] - v[idx]);
    
    	return sum;
    }
    
    bool calcul::isInWindow(int row, int col, float ratio, int percent)
    {
    
    	if (ratio < 1)
    	{
    		float r = 1 / ratio;
    		float tmp = ceil(col * r - row);
    		if (tmp >= -(percent - 1) * r && tmp < (r * percent))
    			return true;
    	}
    	else
    	{
    		float tmp = ceil(row * ratio - col);
    		if (tmp >= -(percent - 1) * ratio && tmp < (ratio * percent))
    			return true;
    	}
    	return false;
    
    Martin Rusek's avatar
    Martin Rusek committed
     }
    
    double calcul::scorePair_dtw_s1(double ratioRaw, size_t pathLength)
    {
    
    	return sqrt(ratioRaw) / pathLength;
    
    Martin Rusek's avatar
    Martin Rusek committed
    }
    
    double calcul::scorePair_dtw_s2(size_t lenIn, size_t lenOut, size_t lenPath)
    {
    
    	return 1 - (lenIn / static_cast<double>(lenPath) + lenOut / static_cast<double>(lenPath)) / 2;
    
    Martin Rusek's avatar
    Martin Rusek committed
    }
    
    double calcul::scorePair_dtw_s3(double ratioRaw)
    {
    
    Martin Rusek's avatar
    Martin Rusek committed
    }
    
    double calcul::scorePair_dtw_s4(double ratioRaw, double ratioRawMax)
    {
    
    	return /*1 -*/ (sqrt(ratioRaw) / sqrt(ratioRawMax));
    
    Martin Rusek's avatar
    Martin Rusek committed
    }
    
    double calcul::scorePair_dtw_s5(double ratioRaw, double ratioRawMax, double coeficient)
    {
    
    	return (/*1 -*/ sqrt(ratioRaw) / sqrt(ratioRawMax)) * coeficient;
    
    double calcul::scorePair_dtw_max(vtr2<double> const &A, vtr2<double> const &B)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    
    	double minA = numeric_limits<double>::max();
    	double maxB = numeric_limits<double>::min();
    
    	for (size_t i = 0; i < A.size(); i++)
    	{
    		double sum = 0;
    		for (size_t j = 0; j < A[i].size(); j++)
    		{
    			sum += A[i][j];
    		}
    
    		if (minA > sum)
    			minA = sum;
    	}
    	
    	for (size_t i = 0; i < B.size(); i++)
    	{
    		double sum = 0;
    		for (size_t j = 0; j < B[i].size(); j++)
    		{
    			sum += B[i][j];
    		}
    
    		if (maxB < sum)
    			maxB = sum;
    	}
    
    	return pow(maxB - minA, 2) * std::max(A.size(), B.size());
    
    double calcul::scorePair_lcss_s1(double ratioRaw, size_t pathLength)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    
    	return 1 -  ratioRaw / static_cast<double>(pathLength);
    
    double calcul::scorePair_lcss_s2(double ratioRaw, size_t maxABLen)
    {
    	return 1 - ratioRaw / maxABLen;
    }
    
    double calcul::scorePair_lcss_s3(double ratioRaw)
    {
    	return ratioRaw;
    }
    
    //double calcul::getPairRatio_lcss(int lenIN, int rawscore)
    //{
    //	return rawscore / (lenIN / 2.0);
    //}
    
    
    double calcul::getMultiRatio_dtw(vtr3<double> const &input, vtr3<double> const &output)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    
    	size_t sumA = 0;
    	for (auto s : input)
    		sumA += s.size();
    
    Martin Rusek's avatar
    Martin Rusek committed
    
    
    	size_t sumB = 0;
    	for (auto s : output)
    		sumB += s.size();
    
    Martin Rusek's avatar
    Martin Rusek committed
    
    
    	return sumA / static_cast<double>(sumB);
    
    //double calcul::GetMRRratio(vtr2<int> const &orderMatrix, map<int, int> &clusters)
    
    Martin Rusek's avatar
    Martin Rusek committed
    //{
    //    double mapRatio = 0;
    //    for (size_t i = 0; i < orderMatrix.size(); i++)         //query (ref sequence) //column
    //    {
    //        double pr = 0;
    //        double coverIdx = 0;
    //        for (size_t j = 1; j < orderMatrix.size(); j++)     // row / rank
    //        {
    //            if (clusters[orderMatrix[j][i]] == clusters[i + 1])
    //                //pr += 1.0 / j;
    //                pr += ++coverIdx / j;
    //        }
    //        mapRatio += pr / coverIdx;
    //        cout << setw(5) << pr / coverIdx << " ";
    //    }
    //    cout << endl;
    //
    //    return (orderMatrix.size() - 1);
    //}
    
    
    vtrD calcul::getMAPratio(vtr2<int> const &orderMatrix, map<int, int> const &clusters)
    
    Martin Rusek's avatar
    Martin Rusek committed
    {
    
    	vtrD ratios;
    	double mapRatio = 0;
    	for (size_t i = 0; i < orderMatrix.size(); i++)         //query (ref sequence) //column
    	{
    		double pr = 0;
    		double coverIdx = 0;
    		for (size_t j = 1; j < orderMatrix.size(); j++)     // row / rank
    		{
    			if (clusters.at(orderMatrix[j][i]) == clusters.at((int)i + 1))
    				pr += ++coverIdx / j;
    		}
    		mapRatio += pr / coverIdx;
    		ratios.push_back(pr / coverIdx);
    		//cout << setw(5) << fixed << pr / coverIdx;
    	}
    	//cout << " | ";
    
    	ratios.push_back(mapRatio / (orderMatrix.size()));
    
    	return ratios;
    
    Martin Rusek's avatar
    Martin Rusek committed
    }
    
    //
    //double GetMultiRatiolcss(Vtr<string, 3> input, vector<int> raws)
    //{
    //    size_t sumA = 0;
    //    for (auto s: input)
    //        sumA += s.size();
    //
    //    int sumB = 0;
    //    for (auto s: raws)
    //        sumB += s;
    //
    //    return sumA / (double)sumB;
    //}
    
    
    
    //double calcul::GetLowerBoundKim(vtr2<double> const &, vtr2<double> const &)
    
    Martin Rusek's avatar
    Martin Rusek committed
    //{
    //    double output;
    //
    //    return output;
    //}
    
    //float calcul::GetManyDistances(Vtr<string, 2> const  &S)
    //{
    //	float sum = 0;
    //	size_t a = S.size();
    //
    //	for (int i = 0; i < a; i++)
    //	{
    //		for (int j = i + 1; j < a; j++)
    //		{
    //			sum += GetDistance(S[i], S[j]);
    //		}
    //	}
    //
    //	return sum;
    //}
    
    //float calcul::GetDistance(string* const &u, string* const &v)
    //{
    //	int uL = sizeof(u) / sizeof(u);
    //	int vL = sizeof(v) / sizeof(v);
    //	double sum = 0;
    //	int shorterDim = (uL < vL) ? uL : vL;
    //
    //	//if (u == null || v == null)
    //	//    return 0;
    //	//else
    //	for (int i = 0; i < shorterDim; i++)
    //	{
    //		//sum += SubstitutionMatrixManager.GetDistance(u[i].ToString() + v[i].ToString());
    //	}
    //
    //	return (float)sum;
    //}