commands for binomci.MTB

noecho
# This macro produces approximate and exact c. i's for the parameter of a
# Bernoulli dist'n.  Before executing, one should set
#   k90  to be the sample size n,
#   k91  to be the number of successes y,
# & k92  to be the coverage probability 1 - alpha (e.g., 0.95, not 95).
let k93 = (1 - k92)/2
invcdf k93 k94;
norm 0 1.
let k94 = -k94
# k94 contains z_{alpha/2}.
# For the simplest c. i., I'll put the center (the point estimate) in k95
# and the plus-'n'-minus piece in k96.
let k95 = k91/k90
let k96 = k94*sqrt(k95*(1 - k95)/k90)
let k97 = k95 + k96
let k98 = k95 - k96
name k97 'Wald ucb' k98 'Wald lcb'
let k99 = k97 + 0.5/k90 
let k100 = k98 - 0.5/k90
name k99 'ccWald u' k100 'ccWald l'
let k101 = k90 + k94*k94
let k102 = k94*sqrt( k95*(k90 - k91) + k94*k94/4 )
let k103 = (k91 + k94*k94/2 + 0.5 + k102)/k101
let k104 = (k91 + k94*k94/2 - 0.5 - k102)/k101
name k103 'Wilson u' k104 'Wilson l'
let k105 = 2*k91
let k106 = 2*(k90 - k91 + 1)
invcdf k93 k107;
f k105 k106.
let k108 = 1 - k93
let k109 = 2*(k91 + 1)
let k110 = 2*(k90 - k91)
invcdf k108 k111;
f k109 k110.
let k112 = (k91 + 1)*k111/(k90 - k91 + (k91 + 1)*k111)
let k113 = k91*k107/(k90 - k91 + 1 + k91*k107)
name k112 'C-P ucb' k113 'C-P lcb'
print k97-k100 k103 k104 k112 k113
echo


commands for hd.MTB

noecho
# This macro produces Harrel-Davis estimate for qth quantile.
# Before executing, one should set
#   k90  to be the column number for the data,
# & k91  to be the value of q.
let k100 = n(ck90)
set c100
0:k100
let c100 = c100/k100
let k101 = k100 + 1
let k102= k91*k101
let k103 = k101 - k102
cdf c100 c101;
beta k102 k103.
let c102 = c101
dele 1 c102
dele k101 c101
let c103 = c102 - c101
sort ck90 c104
let k105 = sum(c103*c104)
name k105 'hd est' k91 'q'
print k91 k105
echo


commands for johnci.MTB

noecho
# macro for c.i. based on Johnson's mod. t stat.
# set k90 to column # where data is 
# set k92 to coverage prob. (e.g., 0.95 or 0.99)
let k101 = mean(ck90)
let k102 = stdev(ck90)     
let c92 = ck90 - k101
let c93 = c92*c92*c92
let k103 = n(ck90)*sum(c93)/((n(ck90) - 1)*(n(ck90) - 2))
let k110 = (1 + k92)/2
let k111 = n(ck90) - 1
invcdf k110 k112;
t k111.
let k120 = k101 + k103/(6*k102*k102*n(ck90))
let k121 = k112*k102/sqrt(n(ck90))
let k122 = k120 - k121
let k123 = k120 + k121
name k120 'center' k121 '+/-piece' k122 'lower cb' k123 'upper cb' 
name k92 'cov prob'
print k92 k120-k123
echo


commands for johnson.MTB

noecho
# This computes Johnson's modified t statistic for data
# in ck90 based on mu_0 value in k91.
let k101 = mean(ck90)
let k102 = stdev(ck90)     
let c92 = ck90 - k101
let c93 = c92*c92*c92
let k103 = n(ck90)*sum(c93)/((n(ck90) - 1)*(n(ck90) - 2))
let k104 = k103/(k102*k102*k102)
let k105 = (k104/(3*k102))*(k101 - k91)*(k101 - k91)
let k105 = k102*k104/(6*n(ck90)) + k105
let k105 = sqrt(n(ck90))*(k101 - k91 + k105)/k102
name k105 't_1'
print k105
echo


commands for qqlap.MTB

noecho
# makes a Q-Q plot of the data in ck90 based on Laplace dist'n
# (so enter  let k90 = 7  to make plot for data in c7)
let k91 = n(ck90)
set c91
1:k91
let c91 = c91/(k91 + 1)
invcdf c91 c92;
laplace 0, 1.
sort ck90 c90
plot c92 c90
echo


commands for qqlog.MTB

noecho
# makes a Q-Q plot of the data in ck90 based on logistic dist'n
# (so enter  let k90 = 7  to make plot for data in c7)
let k91 = n(ck90)
set c91
1:k91
let c91 = c91/(k91 + 1)
invcdf c91 c92;
logistic 0, 1.
sort ck90 c90
plot c92 c90
echo


commands for qqnorm.MTB

noecho
# makes a Q-Q plot of the data in ck90 based on N(0,1) dist'n
# (so enter  let k90 = 7  to make plot for data in c7)
# I prefer to use this for probit plots instead of using Minitab's  
# nscore command (because I don't like how nscore handles ties)
let k91 = n(ck90)
set c91
1:k91
let c91 = (c91 - 3/8)/(k91 + 1/4)
invcdf c91 c92;
norm 0, 1.
sort ck90 c90
plot c92 c90
echo


commands for qqt4.MTB

noecho
# makes a Q-Q plot of the data in ck90 based on T_4 dist'n
# (so enter  let k90 = 7  to make plot for data in c7)
let k91 = n(ck90)
set c91
1:k91
let c91 = c91/(k91 + 1)
invcdf c91 c92;
t 4.
sort ck90 c90
plot c92 c90
echo


commands for qqt6.MTB

noecho
# makes a Q-Q plot of the data in ck90 based on T_6 dist'n
# (so enter  let k90 = 7  to make plot for data in c7)
let k91 = n(ck90)
set c91
1:k91
let c91 = c91/(k91 + 1)
invcdf c91 c92;
t 6.
sort ck90 c90
plot c92 c90
echo


commands for skku.MTB

noecho
# Data is assumed to be in ck90 (so if data is in c7, for example,
# enter the command   let k90 = 7   before executing 'skku').
let k91 = n(ck90)
let k92 = stdev(ck90)
let c91 = ck90 - mean(ck90)
let c93 = c91*c91*c91
let k93 = sum(c93)
let c94 = c93*c91
let k94 = sum(c94)
let k95 = k91*k93/((k91 - 1)*(k91 - 2)*k92*k92*k92)
let k96 = k91*(k91 + 1)*k94/((k91 - 1)*(k91 - 2)*(k91 - 3))
let k96 = k96/(k92*k92*k92*k92)
let k96 = k96 - 3*(k91 - 1)*(k91 - 1)/((k91 - 2)*(k91 - 3))
name k95 'skewness' k96 'kurtosis'
print k95 k96
echo


commands for symplote.MTB

noecho
# symmetry plot for data in ck90 (if sample size is even)
let k91 = n(ck90)/2
set c91
k91(0) k91(1)
# c91 contains the appropriate subscripts
sort ck90 c90
# c90 contains the ordered data
unstack c90 c92 c93;
subscripts c91.
let k92 = median(c90)
let c94 = k92 - c92
let c95 = c93 - k92
sort c94 c94
plot c94 c95
# deviations below median on vertical axis
# deviations above median on horizontal axis
echo


commands for symploto.MTB

noecho
# symmetry plot for data in ck90 (if sample size is odd)
# (note: the point (0,0) is not included)
let k91 = ( n(ck90) - 1 )/2
set c91
k91(0) 1 k91(2)
# c91 contains the appropriate subscripts
sort ck90 c90
# c90 contains the ordered data
unstack c90 c92 k99 c93;
subscripts c91.
let k92 = median(c90)
let c94 = k92 - c92
let c95 = c93 - k92
sort c94 c94
plot c94 c95
# deviations below median on vertical axis
# deviations above median on horizontal axis
echo


commands for tttest.MTB

noecho
# for g = 1, 2, ..., 7 computes trimmed means, their estimated standard
# errors, and gives test statistics and p-values for trimmed mean t test
# need to let k90 be column number where data is, and k91 be mu_0 
# need n >= 16 to avoid dividing by 0
sort ck90 c100
let c101 = c100
let k101 = n(c100)
let k102 = k101 - 1
let k103 = k102 - 1
let k104 = k103 - 1
let k105 = k104 - 1
let k106 = k105 - 1
let k107 = k106 - 1
let k108 = k107 - 1
let k109 = k108 - 1
let k110 = k109 - 1
let k111 = k110 - 1
let k112 = k111 - 1
let k113 = k112 - 1
let k114 = k113 - 1
let k115 = k114 - 1
let k116 = k115 - 1
let c100(1) = c100(2)
let c100(k101) = c100(k102)
let k171 = stdev(c100)
let c100(1) = c100(3)
let c100(2) = c100(3)
let c100(k101) = c100(k103)
let c100(k102) = c100(k103)
let k172 = stdev(c100)
let c100(1) = c100(4)
let c100(2) = c100(4)
let c100(3) = c100(4)
let c100(k101) = c100(k104)
let c100(k102) = c100(k104)
let c100(k103) = c100(k104)
let k173 = stdev(c100)
let c100(1) = c100(5)
let c100(2) = c100(5)
let c100(3) = c100(5)
let c100(4) = c100(5)
let c100(k101) = c100(k105)
let c100(k102) = c100(k105)
let c100(k103) = c100(k105)
let c100(k104) = c100(k105)
let k174 = stdev(c100)
let c100(1) = c100(6)
let c100(2) = c100(6)
let c100(3) = c100(6)
let c100(4) = c100(6)
let c100(5) = c100(6)
let c100(k101) = c100(k106)
let c100(k102) = c100(k106)
let c100(k103) = c100(k106)
let c100(k104) = c100(k106)
let c100(k105) = c100(k106)
let k175 = stdev(c100)
let c100(1) = c100(7)
let c100(2) = c100(7)
let c100(3) = c100(7)
let c100(4) = c100(7)
let c100(5) = c100(7)
let c100(6) = c100(7)
let c100(k101) = c100(k107)
let c100(k102) = c100(k107)
let c100(k103) = c100(k107)
let c100(k104) = c100(k107)
let c100(k105) = c100(k107)
let c100(k106) = c100(k107)
let k176 = stdev(c100)
let c100(1) = c100(8)
let c100(2) = c100(8)
let c100(3) = c100(8)
let c100(4) = c100(8)
let c100(5) = c100(8)
let c100(6) = c100(8)
let c100(7) = c100(8)
let c100(k101) = c100(k108)
let c100(k102) = c100(k108)
let c100(k103) = c100(k108)
let c100(k104) = c100(k108)
let c100(k105) = c100(k108)
let c100(k106) = c100(k108)
let c100(k107) = c100(k108)
let k177 = stdev(c100)
delete 1 k101 c101
let k121 = mean(c101)
delete 1 k103 c101
let k122 = mean(c101)
delete 1 k105 c101
let k123 = mean(c101)
delete 1 k107 c101
let k124 = mean(c101)
delete 1 k109 c101
let k125 = mean(c101)
delete 1 k111 c101
let k126 = mean(c101)
delete 1 k113 c101
let k127 = mean(c101)
let k201 = k171*sqrt(k102/(k103*k104))
let k202 = k172*sqrt(k102/(k105*k106))
let k203 = k173*sqrt(k102/(k107*k108))
let k204 = k174*sqrt(k102/(k109*k110))
let k205 = k175*sqrt(k102/(k111*k112))
let k206 = k176*sqrt(k102/(k113*k114))
let k207 = k177*sqrt(k102/(k115*k116))
let k211 = (k121 - k91)/k201
let k212 = (k122 - k91)/k202
let k213 = (k123 - k91)/k203
let k214 = (k124 - k91)/k204
let k215 = (k125 - k91)/k205
let k216 = (k126 - k91)/k206
let k217 = (k127 - k91)/k207
cdf k211 k141;
t k104.
cdf k212 k142;
t k106.
cdf k213 k143;
t k108.
cdf k214 k144;
t k110.
cdf k215 k145;
t k112.
cdf k216 k146;
t k114.
cdf k217 k147;
t k116.
let k151 = 1 - k141
let k152 = 1 - k142
let k153 = 1 - k143
let k154 = 1 - k144
let k155 = 1 - k145
let k156 = 1 - k146
let k157 = 1 - k147
stack k201-k207 c201
stack k121-k127 c202
stack k211-k217 c203
stack k141-k147 c204
stack k151-k157 c205
stack 1 2 3 4 5 6 7 c200
name c200 'g' c201 'std err' c202 'tr mean' c203 't stat' c204 'low p-v'
name c205 'upp p-v'
print c200-c205
echo