##################################################################
# mann-whitney tests

function mwRank(data0,ranks,     data,starter,n,old,start,skipping,sum,i,j,r) {
    starter="someCraZYsymBOL";
    n     = asort(data0,data)    
    old   = starter
    start = 1;
    for(i=1;i<=n;i++) {
	skipping = (old == starter) || (data[i] == old);
	if (skipping) {
	    sum += i 
	} else {
	    r = sum/(i - start)
	    for(j=start;j<i;j++) 
		ranks[data[j]] = r;
	    start = i;
	    sum   = i;
	}
	old=data[i]
    }
    if (skipping)
	ranks[data[n]] = sum/(i - start)
    else 
	if (! (data[n] in ranks))
	    ranks[data[n]] = r+1
}

function mwu(x,pop1,pop2,up,critical,
	     i,data,ranks,n,n1,sum1,ranks1,n2,sum2,ranks2,	\
	     correction,meanU,sdU,z) {

    for(i in pop1) data[++n]=pop1[i]
    for(i in pop2) data[++n]=pop2[i]
    mwRank(data,ranks)
    for(i in pop1) { n1++; sum1 += ranks1[i] = ranks[pop1[i]] }
    for(i in pop2) { n2++; sum2 += ranks2[i] = ranks[pop2[i]] }

    meanU      = n1*(n1+n2+1)/2  # symmetric , so we just use pop1's z-value
    sdU        = (n1*n2*(n1+n2+1)/12)^0.5
    correction = sum1 > meanU ? -0.5 : 0.5  
    z          = abs((sum1 - meanU + correction )/sdU)

    if (z >= 0 && z <= critical) 
	return 0
    if (up)  {
	return 1
    }
    else {
	return -1
    }
}
function criticalValue(conf) {
    conf = conf ? conf  : 95
    if (conf==99) return 2.326
    if (conf==95) return 1.960 
    if (conf==90) return 1.645
}


function s2a(s,a,    tmp,i,n) {
    n=split(s,tmp,/ /)
    for(i=1;i<n;i+=2 )
		a[tmp[i]]=tmp[i+1]
}

function median(arrin,n,   low,a) {
    low = int(n/2);
    return oddp(n) ?  a[low+1] : (a[low] + a[low+1])/2
}


function multiple(a,n,  i) { for (i in a) a[i] *= n }
#function abs(x)            { return x < 0 ? -1*x : x }	
function oddp(n)           { return n % 2 }


##################################################################
# standard utils

function barph(str)       { print str >"/dev/stderr"; fflush("/dev/stderr") }
function push2(v,a,i)     { a[i,++a[i,0]] = v; return v }
function push(v,a)        { a[++a[0]] = v; return v }
function as100(n)         { return (n*100) + rand()/100 }
function abs(n)           { return n < 0 ? -1* n : n }
function max(n1,n2)       { return n1<n2 ? n2 : n1 }
function min(n1,n2)       { return n1<n2 ? n1 : n2 }
function no_(str)         { gsub(_,",",str); return str }
function round(i)         { return int(i+0.5) }

function copya(source,copy,	key) {
	split("",copy,"") #clear copy
	for (key in source) {
		copy[key] = source[key]
	}
}



#doesn't interpolate for even number  of values
#(if you want to get actual cases back)
function findAbsMedian(a,	n,floor,sorted) {
	n = asort(a,sorted)
	floor = int(n/2)
	if (n == 1)
		return sorted[1]
	else
		return sorted[floor]
}

#doesn't interpolate for even number of values
#(if you want to get actual cases back)
function findAbsSpread(a,  n,floor25,floor75,sorted) {
	n = asort(a,sorted)
	floor75 = sorted[int(3*n/4)+1]
	floor25 = sorted[int(n/4)+1]
	return floor75 - floor25
}

function findMedian(a,	n,floor,sorted) {
	n = asort(a,sorted)
	floor = int(n/2)
	if (n == 1)
		return sorted[1]
	else
		return oddp(n) ?  sorted[floor+1] : (sorted[floor] + sorted[floor+1])/2
}

function medianReduc(asis,tobe) {
    return 100 * (findMedian(asis) - findMedian(tobe)) / findMedian(asis)
}


function spreadReduc(asis,tobe) {
    return 100 * (findSpread(asis) - findSpread(tobe)) / findSpread(asis)
}

function findSpread(a, len,sorted) {
    len = asort(a, sorted)
    if (len == 2)
	return sorted[2] - sorted[1]

    if (len < 2)
	return 0

    return find75(a) - find25(a)
}

function findAbs25(a,	n,sorted) {
	n = asort(a,sorted)
	return sorted[int(n/4)+1]
}

function findAbs75(a,	n,sorted) {
	n = asort(a,sorted)
	return sorted[int(3*n/4)+1]
}

function find25(a,	n,floor25,sorted) {
	n = asort(a,sorted)
	n%4 == 1 ? floor25 = sorted[int(n/4)+1] : floor25 = (sorted[int(n/4)] + sorted[int(n/4)+1]) / 2
	return floor25
}

function find75(a,	n,floor75,sorted) {
	n = asort(a,sorted)
	n%4 == 1 ? floor75 = sorted[int(3*n/4)+1] : floor75 = (sorted[int(3*n/4)] + sorted[int(3*n/4)+1]) / 2
	return floor75
}

function arrMax(a,    n,sorted) {
    n = asort(a, sorted)
    return sorted[n]
}

function arrMin(a,    n,sorted) {
    n = asort(a, sorted)
    return sorted[1]
}

function findAvg(a,     n,sorted,sum,num,i) {
    n = asort(a,sorted)
    for (i=1; i<=n; i++) {
	sum += sorted[i]
	num ++
    }
    return sum / num
}

function findStdev(a,     n,sorted,sum,num,mean,i,sumsq) {
    n = asort(a,sorted)
    for (i=1; i<=n; i++) {
	sum += sorted[i]
	num ++
    }
    mean = sum / num

    for (i=1; i<=n; i++) {
	sumsq += (sorted[i] - mean) * (sorted[i] - mean)
    }

    return sqrt(sumsq / num)
}


function arr2str(a,sep,    s,n,tmp) {
    sep = (sep ? sep : ",")
    n = asort(a,tmp)
    for (i=1; i<=n; i++) {
	s = (s ? s sep a[i] : a[i])
    }
    return s
}

function saya(a,s,   b,c,m,n,key,val,i,j,tmp,sep) {
	print ""
	m     = asorti(a,b)
	for(i=1;i<=m;i++)  {
		key=b[i]
		val=a[b[i]]
		printf("%s",  sep s "["  )
		n=split(key,tmp,_)
		c = ""
		for(j=1;j<=n;j++)	{	
			printf("%s", c tmp[j]  )
			c=","
		}
		if (val ~ _)
			val = no_(val)
		printf("%s", "]=" val )
		sep="\n";
	};
	print ""
 }

function scoreRow(row, data, classes,    maxes, mins,classCount,normClassVal,k,score,sumsqr,relyCol) {
    #normalize values
    for (k in classes) {
	maxes[k] = max(Test["max",classes[k]],Train["max",classes[k]])
	mins[k] = min(Test["min",classes[k]],Train["min",classes[k]])
	classCount++
	normClassVal[k] = ( data[row,classes[k]] - mins[k] ) / ( maxes[k]-mins[k] )
    }

    #Single-goal scoring (return goal value)
    if (classCount == 1) {
	score = data[row,classes[k]]
    }
    #Multi-goal scoring (collapse to a single value)
    else {

	#Normalized Euclidean
	if(ScoreMethod == 0) {
	    sumsqr = 0
	    for (k in normClassVal) {
		sumsqr += ( normClassVal[k] * normClassVal[k] )
	    }
	    score = sqrt(sumsqr)
	}

	#BFC (bias defects)
	if(ScoreMethod == 1) {
	    relyCol = Name["rely"]
	    if (!relyCol)
		print "ERROR: No rely column for BFC formula:"relyCol
	    if (!("defects" in classes))
		print "No defects class for BFC formula"

	    sumsqr = 0
	    for (k in normClassVal) {
		if (k ~ "defects") {
		    print "relyval:"data[row,relyCol]
		    sumsqr += (normClassVal[k] * (1 + 1.8^(data[row,relyCol] - 3)))^2
		}
		else
		    sumsqr += normClassVal[k]^2
	    }
	    score = sqrt(sumsqr)
	}

    }
    return score
}

function injectRanked(rules, ranked,       r) {
    print "injecting"
    r=0
    while(getline < rules) {
	n = Name[$1]
	if (!($1 in Name))
	    print "Error: Couldn't find "$1" in the dataset"
	else
	    print "Added "$1","$2" successfully"
	ranked[++r] = n SUBSEP $2

    }
    return r
}