Import: 
distmm.txt




Entity:
StatLib 227 97
null  * 





Operation:
mean
StatLib
double
s Sequence(double) 
 query static
s.size > 0
result = (1.0*s.sum)/s.size





Operation:
median
StatLib
double
s Sequence(double) 
 query static
s.size > 0
s1 = s->sort() & ( s.size mod 2 = 1 => result = s1->at((1 + s.size)/2) ) & ( s.size mod 2 = 0  => result = ( s1->at(s.size/2) + s1->at(1 + (s.size/2)) )/2 )






Operation:
variance
StatLib
double
s Sequence(double) 
 query static
s.size > 0
m = StatLib.mean(s) & result = ( s->collect( x | (x - m)*(x - m) )->sum() ) / s.size





Operation:
sumsqdiffs
StatLib
double
s Sequence(double) t Sequence(double) 
 query static
s.size = t.size
result = Integer.subrange(1,s.size)->collect( i | (s[i] - t[i])*(s[i] - t[i]) )->sum() 




Operation:
sumsqdiff
StatLib
double
s Sequence(double) t double 
 query static
true
result = Integer.subrange(1,s.size)->collect( i | (s[i] - t)*(s[i] - t) )->sum() 





Operation:
frequencyDist
StatLib
Sequence(int)
s Sequence(double) 
 query static
true
result = s->collect( x | s->count(x) )




Operation:
histogram
StatLib
Sequence(int)
s Sequence(double) l double step double u double 
 query static
u > l
maxindex = ((u-l)/step)->ceil() & result = Integer.subrange(0,maxindex)->collect( i | s->select( x | l+i*step <= x & x < l + (i+1)*step )->size() )




Operation:
mode
StatLib
double
s Sequence(double) 
 query static
s.size > 0
fd = StatLib.frequencyDist(s) & maxfreq = fd->max() & result = s->select( y | s->count(y) = maxfreq )->any()





Operation:
skewness
StatLib
double
s Sequence(double) 
 query static
s.size > 0
var = StatLib.variance(s) & result = (StatLib.mean(s) - StatLib.median(s))/(var->sqrt())





Operation:
fit
StatLib
double
s Sequence(double) x double 
 query static
s.size > 0
var = StatLib.variance(s) & result = ((x - StatLib.mean(s))->abs())/(var->sqrt())









Operation:
moments
StatLib
void
s Sequence(double) 
 static
s.size > 0
StatLib.variance(s)->display() & StatLib.skewness(s)->display()







Operation:
pi
StatLib
double

 query static
true
result = 3.14159265











Entity:
NormalDist 38 195
null  * 



Operation:
normal
NormalDist
double
m double sigma double x double 
 query static
true
disp = x - m & denom = ( -0.5 * disp * disp / ( sigma * sigma ) )->exp() & num = sigma * ( 2 * StatLib.pi() )->sqrt() & result = denom / num




Operation:
cumulative
NormalDist
double
m double sigma double x double 
 query static
x >= m
k = ( 1 / ( 1 + 0.2316419 * ( x - m ) ) ) & poly = ( 0.31938153 * k ) + ( -0.356563782 * k * k ) + ( 1.781477937 * k * k * k ) + ( -1.821255978 * k * k * k * k ) + ( 1.330274429 * k * k * k * k * k ) & result = 1 - NormalDist.normal(m,sigma,x) * poly





Operation:
cdf
NormalDist
double
x double 
 query static
true
( x >= 0 => result = NormalDist.cumulative(0,1,x) ) & ( x < 0 => result = 1 - NormalDist.cumulative(0,1,-x) )













GeneralUseCase:
stattest 



false


Constraint:
null
true
StatLib.moments(Sequence{0,0.007,0.012,0.013,0.013,0.013,0.014,0.018,0.019,0.019,0.019,0.019,0.02,0.02,0.021,0.021,0.022,0.022,0.024,0.025,0.026,0.031,0.033,0.038,0.044})
null stattest
false






Constraint:
null
true
StatLib.moments(Sequence{0.006,0.006,0.007,0.011,0.0115, 0.012, 0.015, 0.015, 0.019, 0.021, 0.022, 0.023, 0.028, 0.029, 0.029, 0.038, 0.047, 0.053, 0.057, 0.059, 0.0625, 0.067, 0.083, 0.105, 0.173})
null stattest
false






Constraint:
null
true
StatLib.moments(Sequence{0,0,0,0.009,0.012,0.0145,0.0235,0.025,0.027,0.029,0.031,0.032,0.036,0.04,0.042,0.042})
null stattest
false







Constraint: 
null
true
StatLib.moments(Sequence{0,0,0,0,0.005,0.008,0.009,0.014,0.014,0.014,0.015,0.019,0.021,0.024,0.025,0.028,0.032,0.033,0.036,0.038,0.041,0.052,0.083})
null stattest
false














Entity:
CliffsDelta 227 497
null  * 
d Sequence(Sequence(double)) 3 false false false di Sequence(double) 3 false false false dj Sequence(double) 3 false false false delta double 3 false false false variance double 3 false false false z90 double 3 false false false z95 double 3 false false false z99 double 3 false false false








Operation:
diff
CliffsDelta
double
x double y double 
 query static
true
(x < y => result = -1.0) & (x > y => result = 1.0) & (x = y => result = 0.0)






Operation:
dominanceMatrix
CliffsDelta
Sequence(Sequence(double))
x Sequence(double) y Sequence(double) 
 query static
x.size > 0 & y.size > 0
n = x.size & m = y.size & nseq = Integer.subrange(1,n) & mseq = Integer.subrange(1,m) & result = nseq->collect( i | mseq->collect( j | CliffsDelta.diff(x[i],y[j])))





Operation:
computeDelta
CliffsDelta
double
n int m int
 query 
n > 0 & m > 0
nseq = Integer.subrange(1,n) & mseq = Integer.subrange(1,m) & di = nseq->collect( i | StatLib.mean(d->at(i)) ) & dj = mseq->collect( j | StatLib.mean( d->collect( x | x->at(j) ) ) ) & delta = StatLib.mean(di) & result = delta








Operation:
computeVariance
CliffsDelta
double
n int m int
 query 
n > 0 & m > 0
diffi = StatLib.sumsqdiff(di,delta)/(n-1) & diffj = StatLib.sumsqdiff(dj,delta)/(m-1) & diffij = (d->collect(sq | sq->collect(z | (z-delta)*(z-delta))->sum())->sum())/((n-1)*(m-1)) & variance = ((m-1)*diffi + (n-1)*diffj + diffij)/(n*m) & result = variance






Operation:
computeZ
CliffsDelta
double

 query 
variance > 0
result = delta/(variance->sqrt())






Operation:
compute99limits
CliffsDelta
Sequence(double)

 query
variance > 0
ci99factor = (z99 * variance->sqrt()) * ( ( 1 - delta * delta )->sqr() + z99 * z99 * variance )->sqrt() & den = 1 - delta * delta + z99 * z99 * variance & ci99u = ( delta - delta->pow(3) + ci99factor ) / den & ci99l = ( delta - delta->pow(3) - ci99factor ) / den & result = Sequence{ci99l,ci99u}






Operation:
compute95limits
CliffsDelta
Sequence(double)

 query
true
ci95factor = (z95 * variance->sqrt()) * ( ( 1 - delta * delta )->sqr() + z95 * z95 * variance )->sqrt() & den = 1 - delta * delta + z95 * z95 * variance & ci95u = ( delta - delta->pow(3) + ci95factor ) / den & ci95l = ( delta - delta->pow(3) - ci95factor ) / den & result = Sequence{ci95l,ci95u}







Operation:
compute90limits
CliffsDelta
Sequence(double)

 query
true
ci90factor = (z90 * variance->sqrt()) * ( ( 1 - delta * delta )->sqr() + z90 * z90 * variance )->sqrt() & den = 1 - delta * delta + z90 * z90 * variance & ci90u = ( delta - delta->pow(3) + ci90factor ) / den & ci90l = ( delta - delta->pow(3) - ci90factor ) / den & result = Sequence{ci90l,ci90u}












GeneralUseCase:
deltatest 



false


Constraint:
null
true
CliffsDelta->exists( cd | cd.z90 = 1.645 & cd.z95 = 1.96 & cd.z99 = 2.576 ) 
null deltatest
false




Constraint:
null
true
d = CliffsDelta.dominanceMatrix(Sequence{0,0.007,0.012,0.013,0.013,0.013,0.014,0.018,0.019,0.019,0.019,0.019,0.02,0.02,0.021,0.021,0.022,0.022,0.024,0.025,0.026,0.031,0.033,0.038,0.044}, Sequence{0.006,0.006,0.007,0.011,0.0115, 0.012, 0.015, 0.015, 0.019, 0.021, 0.022, 0.023, 0.028, 0.029, 0.029, 0.038, 0.047, 0.053, 0.057, 0.059, 0.0625, 0.067, 0.083, 0.105, 0.173})
CliffsDelta deltatest
false




Constraint:
null
true
("Delta = " + computeDelta(25,25))->display()
CliffsDelta deltatest
false






Constraint:
null
true
("di = " + di)->display() & ("dj = " + dj)->display()
CliffsDelta deltatest
false






Constraint:
null
true
("Variance = " + computeVariance(25,25))->display()
CliffsDelta deltatest
false




Constraint:
null
true
("Z = " + computeZ())->display()
CliffsDelta deltatest
false






Constraint:
null
true
("99% confidence limits: " + compute99limits())->display()
CliffsDelta deltatest
false






Constraint:
null
true
("95% confidence limits: " + compute95limits())->display()
CliffsDelta deltatest
false







Constraint:
null
true
("90% confidence limits: " + compute90limits())->display()
CliffsDelta deltatest
false







Entity:
AndersonDarling 27 497
null  * 







Operation:
adNormalTerm
AndersonDarling
double
i int y Sequence(double) 
 query static
true
n = y.size & result = (2*i - 1)*(NormalDist.cdf(y[i])->log() + (1 - NormalDist.cdf(y[(n+1-i)]))->log())







Operation:
andersonDarlingNormal
AndersonDarling
double
x Sequence(double) 
 query static
x.size > 0
n = x.size & mu = StatLib.mean(x) & variance = StatLib.variance(x) & sigma = variance.sqrt & y = x->collect( v | (v - mu)/sigma ) & result = -n - (1.0/n)*Integer.Sum(1,n,i,AndersonDarling.adNormalTerm(i,y))








GeneralUseCase:
normtest 



false


Constraint:
null
true
AndersonDarling->exists( ad | true ) 
null normtest
false







Constraint:
null
true
("Anderson-Darling for ATL: " + AndersonDarling.andersonDarlingNormal(Sequence{0,0.007,0.012,0.013,0.013,0.013,0.014,0.018,0.019,0.019,0.019,0.019,0.02,0.02,0.021,0.021,0.022,0.022,0.024,0.025,0.026,0.031,0.033,0.038,0.044}))->display()
AndersonDarling normtest
false







Constraint:
null
true
("Anderson-Darling for ETL: " + AndersonDarling.andersonDarlingNormal(Sequence{0.006,0.006,0.007,0.011,0.0115, 0.012, 0.015, 0.015, 0.019, 0.021, 0.022, 0.023, 0.028, 0.029, 0.029, 0.038, 0.047, 0.053, 0.057, 0.059, 0.0625, 0.067, 0.083, 0.105, 0.173}))->display()
AndersonDarling normtest
false





Constraint:
null
true
("Anderson-Darling for QVT-R: " + AndersonDarling.andersonDarlingNormal(Sequence{0,0,0,0.009,0.012,0.0145,0.0235,0.025,0.027,0.029,0.031,0.032,0.036,0.04,0.042,0.042}))->display()
AndersonDarling normtest
false







Constraint:
null
true
("Anderson-Darling for UML-RSDS: " + AndersonDarling.andersonDarlingNormal(Sequence{0,0,0,0,0.005,0.008,0.009,0.014,0.014,0.014,0.015,0.019,0.021,0.024,0.025,0.028,0.032,0.033,0.036,0.038,0.041,0.052,0.083}))->display()
AndersonDarling normtest
false










Entity:
KolmogorovSmirnov 427 497
null  * 








Operation:
kstest2
KolmogorovSmirnov
double
d1 Distribution d2 Distribution 
 query static
true
result = (d1.points->collect( x | (d1.cdf(x) - d2.cdf(x))->abs()))->union(d2.points->collect( z | (d2.cdf(z) - d1.cdf(z))->abs()))->max()







Operation:
kstest1
KolmogorovSmirnov
double
d1 Distribution d2 Distribution 
 query static
true
ks = KolmogorovSmirnov.kstest2(d1,d2) & n = d1.points.size & m = d2.points.size & factor = ((1.0*(n + m))/(n*m))->sqrt() & c = ks/factor & result = (-2.0*c*c)->exp()









GeneralUseCase:
kstest 



false




Constraint:
null
true
"ATL and ETL:"->display() & Distribution->exists( d1 | d1.points = Sequence{0,0.007,0.012,0.013,0.013,0.013,0.014,0.018,0.019,0.019,0.019,0.019,0.02,0.02,0.021,0.021,0.022,0.022,0.024,0.025,0.026,0.031,0.033,0.038,0.044} & Distribution->exists( d2 | d2.points = Sequence{0.006,0.006,0.007,0.011,0.0115, 0.012, 0.015, 0.015, 0.019, 0.021, 0.022, 0.023, 0.028, 0.029, 0.029, 0.038, 0.047, 0.053, 0.057, 0.059, 0.0625, 0.067, 0.083, 0.105, 0.173} & KolmogorovSmirnov.kstest1(d1,d2)->display()))
null kstest
false






Constraint:
null
true
"QVT and UML-RSDS:"->display() & Distribution->exists( d3 | d3.points = Sequence{0,0,0,0.009,0.012,0.0145,0.0235,0.025,0.027,0.029,0.031,0.032,0.036,0.04,0.042,0.042} & Distribution->exists( d4 | d4.points = Sequence{0,0,0,0,0.005,0.008,0.009,0.014,0.014,0.014,0.015,0.019,0.021,0.024,0.025,0.028,0.032,0.033,0.036,0.038,0.041,0.052,0.083} & KolmogorovSmirnov.kstest1(d3,d4)->display()))
null kstest
false










Constraint:
null
true
"ATL and QVT:"->display() & Distribution->exists( d5 | d5.points = Sequence{0,0.007,0.012,0.013,0.013,0.013,0.014,0.018,0.019,0.019,0.019,0.019,0.02,0.02,0.021,0.021,0.022,0.022,0.024,0.025,0.026,0.031,0.033,0.038,0.044} & Distribution->exists( d6 | d6.points = Sequence{0,0,0,0.009,0.012,0.0145,0.0235,0.025,0.027,0.029,0.031,0.032,0.036,0.04,0.042,0.042} & KolmogorovSmirnov.kstest1(d5,d6)->display()))
null kstest
false









Constraint:
null
true
"ATL and UMLRSDS:"->display() & Distribution->exists( d7 | d7.points = Sequence{0,0.007,0.012,0.013,0.013,0.013,0.014,0.018,0.019,0.019,0.019,0.019,0.02,0.02,0.021,0.021,0.022,0.022,0.024,0.025,0.026,0.031,0.033,0.038,0.044} & Distribution->exists( d8 | d8.points = Sequence{0,0,0,0,0.005,0.008,0.009,0.014,0.014,0.014,0.015,0.019,0.021,0.024,0.025,0.028,0.032,0.033,0.036,0.038,0.041,0.052,0.083}  & KolmogorovSmirnov.kstest1(d7,d8)->display()))
null kstest
false










Constraint:
null
true
"QVT and ETL:"->display() & Distribution->exists( d9 | d9.points = Sequence{0,0,0,0.009,0.012,0.0145,0.0235,0.025,0.027,0.029,0.031,0.032,0.036,0.04,0.042,0.042} & Distribution->exists( d10 | d10.points = Sequence{0.006,0.006,0.007,0.011,0.0115, 0.012, 0.015, 0.015, 0.019, 0.021, 0.022, 0.023, 0.028, 0.029, 0.029, 0.038, 0.047, 0.053, 0.057, 0.059, 0.0625, 0.067, 0.083, 0.105, 0.173} & KolmogorovSmirnov.kstest1(d9,d10)->display()))
null kstest
false







Constraint:
null
true
"UMLRSDS and ETL:"->display() & Distribution->exists( d11 | d11.points = Sequence{0,0,0,0,0.005,0.008,0.009,0.014,0.014,0.014,0.015,0.019,0.021,0.024,0.025,0.028,0.032,0.033,0.036,0.038,0.041,0.052,0.083} & Distribution->exists( d12 | d12.points = Sequence{0.006,0.006,0.007,0.011,0.0115, 0.012, 0.015, 0.015, 0.019, 0.021, 0.022, 0.023, 0.028, 0.029, 0.029, 0.038, 0.047, 0.053, 0.057, 0.059, 0.0625, 0.067, 0.083, 0.105, 0.173} & KolmogorovSmirnov.kstest1(d11,d12)->display()))
null kstest
false