ARL With Supplementary Run Rules
/****************************************************************/
/* S A S S A M P L E L I B R A R Y */
/* */
/* NAME: SHWARL2 */
/* TITLE: ARL With Supplementary Run Rules */
/* PRODUCT: QC */
/* SYSTEM: ALL */
/* KEYS: Shewhart Charts, Average Run Lengths, */
/* PROCS: IML GPLOT */
/* DATA: */
/* */
/* NOTES: */
/* MISC: */
/* */
/* REF: SAS/QC Software: Usage and Reference, Version 6, */
/* First Edition, Volume 1 and Volume 2 */
/* */
/* Champ C. W. and Woodall W. H. (1990), "A Program to */
/* Evaluate the Run Length Distribution of a Shewhart */
/* Control Chart with Supplementary Run Rules" */
/* Journal of Quality Technology, Vol. 22, pg. 68-73. */
/* */
/* Champ C. W. and Woodall W. H. (1987), "Exact */
/* Results for Shewhart Control Chart With */
/* Supplementary Runs Rules". Technometrics, Vol. 29, */
/* pg. 393-399. */
/* */
/* Examples in the documentation were created using the */
/* statement: ods listing style=statistical; */
/* */
/****************************************************************/
options ps=60 ls=80 nodate;
title1 'ARL with Supplementary Runs Rules';
* Input the Rules Defining the Chart ;
data rules;
input k m a b;
cards;
1 1 3 9
2 3 2 3
2 3 -3 -2
1 1 -9 -3
;
proc iml;
use rules; read all var {k m a b};
/********************************************************/
/* Input the Standarized Shift, */
/* the Upper Limit for the Calculation of ARL and Std, */
/* and the Upper Limit for the CDF Graph */
/********************************************************/
shf = 0.6;
uppcal = 0.99999;
uppgra = 0.99;
* Find the Regions of the Chart ;
r = -9//a//b//9;
r = unique(r);
nt = nrow(k);
nr = ncol(r)-1;
/***************************************************/
/* Find the Length of the State Vector */
/* and the pointers to the End of the Subvector */
/* Associated with Each Runs Rule */
/***************************************************/
nv = sum(m)-nt;
if(sum(m-k) = 0) then nv = nv+1;
di = j(nt,1,0);
di[1] = m[1]-1;
do i = 2 to nt;
if(m[i] > 1) then di[i] = di[i-1]+m[i]-1;
end;
/**************************************************/
/* Determine the Value of the Present */
/* Indicator Variable by Runs Rule and Region */
/* Combination */
/**************************************************/
a1 = j(nt,1,1);
a1 = a1*r;
x = j(nt,nr,0);
do j = 1 to nr;
x[,j] = (a <= a1[,j])#(b >= a1[,j+1]);
end;
* Determine the State to State Transitions by Regions ;
ps = j(nv,1,0);
s = j(nt,1,0);
a1 = j(1,nr,1);
nx = j(nv,1,0);
qqns = 2**nv-1;
ns = 1;
h = 1;
qq = 0;
q = a1;
do while ( h <= ns );
qh = qq[h];
do L = 1 to nv;
ps[L] = qh-2*int(qh/2);
qh = int(qh/2);
end;
do i = 1 to nt;
s[i] = 0;
if (m[i] > 1) then do
L = di[i]-m[i]+2 to di[i];
s[i] = s[i]+ps[L];
end;
end;
do j = 1 to nr;
sg = 0;
do i = 1 to nt;
if (sg = 0) then do;
if (s[i]+x[i,j] >= k[i]) then sg = 1;
else do;
if (m[i] > 1) then nx[di[i]-m[i]+2] = x[i,j];
if (m[i] > 2) then do
L = di[i]-m[i]+3 to di[i];
nx[L] = ps[L-1];
end;
end;
if (x[i,j] = 0 & m[i] > 1) then do;
tmp = s[i]-ps[di[i]]+1;
L = di[i];
ck = 0;
do while ( ck = 0 & L >= di[i]-m[i]+2 );
if (nx[L] = 1) then do;
ck = 1;
if (tmp < k[i]) then do;
nx[L] = 0;
tmp = tmp-1;
ck = 0;
end;
end;
L = L-1;
tmp = tmp+1;
end;
end;
end;
end;
if (sg = 0) then do;
qh = nx[1];
do L = 2 to nv;
qh = qh+nx[L]*(2**(L-1));
end;
ck = 0;
do L = 1 to ns;
if (ck = 0 & qh = qq[L]) then do;
q[h,j] = qq[L];
ck = 1;
end;
end;
if (ck = 0) then do;
ns = ns+1;
qq = qq//qh;
q[h,j] = qh;
end;
end;
else
q[h,j] = qqns;
end;
h = h+1;
q = q//(qqns*a1);
end;
ns = ns+1;
qq = qq//qqns;
free / q qq ns nr r shf qqns uppcal uppgra;
/******************************************/
/* Sort the States in Ascending Order */
/* of Their Base Two Representations */
/******************************************/
a1 = q;
a1[rank(qq),] = q;
q = a1;
a1 = qq;
a1[rank(qq),] = qq;
qq = a1;
* Remove any Duplicate States ;
ck = 1;
do while (ck = 1);
ck = 0;
i = 1;
do while (i <= ns-1);
j = i+1;
do while (j <= ns);
if (q[i,] = q[j,]) then do;
ck = 1;
q = q[remove(1:ns,j),];
a = (q = (0*q+qq[j]));
q = (q#(1-a))+(qq[i]#a);
qq = qq[remove(1:ns,j),];
j = j-1;
ns = ns-1;
end;
j = j+1;
end;
i = i+1;
end;
end;
* Number the Next-State Transitions ;
a1 = j(1,ns,1);
a2 = (qq*a1)`;
a3 = j(ns,nr,0);
do j = 1 to nr;
a3[,j] = ((q[,j]*a1) = a2)*((1:ns)`);
end;
a1 = (q < (0*q+qqns));
q = (ns#(1-a1))+(a3#a1);
free qq qqns ck a2 a3;
/**********************************************************/
/* Compute the Cumulative Distribution, */
/* Function, the Average Run Length (ARL) and the */
/* Standard Deviation (STD) of the Run Length for a */
/* Given Standarized Shift (SHF) in the Mean. */
/* */
/* The Iterative Process for the Calculation of the */
/* CDF, ARL and STD stops when the CDF is > UPPCAL */
/* */
/* The Number of Recorded Points for the CDF Graph */
/* Stops When CDF is > UPPGRA */
/**********************************************************/
pr = probnorm((r-shf)`);
pr = (pr[2:nr+1,]//0)-pr;
pr = pr[1:nr,];
pt = j(ns,ns,0);
do i = 1 to ns;
do j = 1 to nr;
pt[i,q[i,j]] = pt[i,q[i,j]]+pr[j];
end;
end;
a1 = pt[1:ns-1,ns];
pt = pt[1:ns-1,1:ns-1];
cdf = a1[1];
acu = a1[1];
n = 1;
do while ( acu <= uppcal );
a1 = pt*a1;
acu = acu+a1[1];
if ( acu <= uppgra ) then n=n+1;
cdf = cdf//a1[1];
end;
rl = do(1,nrow(cdf),1);
arl = rl*cdf;
std = sqrt(((rl##2)*cdf)-(arl*arl));
cdf = cusum(cdf);
rl = rl[,1:n]`;
cdf = cdf[1:n,];
create par var{arl std shf}; append; close par;
create cdf var{rl cdf}; append; close cdf;
reset center noname pagesize = 800 linesize = 80;
c1 = {"ARL" "STD"};
arl = arl//std;
print arl[rowname = c1 format = 10.6];
quit;
* Print Every 10th Run Length and associated CDF value ;
title1 'Run Length CDF';
proc print data=cdf noobs label;
label rl='Run Length' cdf='CDF of Run Length';
where mod(rl,10)=0;
run;
/******************************************************/
/* Annotate Dataset that will Superimpose a Table */
/* Containing the Mean and Standard Deviation of the */
/* Run Length */
/******************************************************/
data anno;
set par;
length text function style color $ 8;
shf = put(shf,7.3);
arl = put(arl,7.3);
std = put(std,7.3);
xsys = '1';
ysys = '1';
hsys = '1';
function = 'move'; x = 1; y = 99; output;
style = 'solid';
color = 'blue';
when = 'A';
xsys = 'A';
ysys = 'A';
hsys = '6';
function = 'poly'; x = 0; y = 0; output;
color = 'white';
function = 'polycont'; x = 0; y = -7; output;
function = 'polycont'; x = 17; y = -7; output;
function = 'polycont'; x = 17; y = 0; output;
xsys = '1';
ysys = '1';
hsys = '1';
function = 'move'; x = 1; y = 99; output;
function = 'cntl2txt'; output;
color = 'white';
line = 1;
style = 'none';
size = 1;
position = 'c';
xsys = 'A';
ysys = 'A';
hsys = '6';
x = 1;
function = 'label'; y = -2; text = 'SHIFT'; output;
function = 'cntl2txt'; output;
function = 'label'; y = -4; text = 'ARL'; output;
function = 'cntl2txt'; output;
function = 'label'; y = -6; text = 'STD'; output;
x = 7;
function = 'cntl2txt'; output;
function = 'label'; y = -2; text = '='; output;
function = 'cntl2txt'; output;
function = 'label'; y = -4; text = '='; output;
function = 'cntl2txt'; output;
function = 'label'; y = -6; text = '='; output;
position = 'a';
x = 16;
function = 'cntl2txt'; output;
function = 'label'; y = -2; text = shf; output;
function = 'cntl2txt'; output;
function = 'label'; y = -4; text = arl; output;
function = 'cntl2txt'; output;
function = 'label'; y = -6; text = std; output;
run;
/*************************************************************/
/* Display Graph of the Run Length Cumulative Distribution */
/* Function and the Annotate Dataset */
/*************************************************************/
title1 'Run Length Cumulative Distribution Function';
symbol1 color = white width = 2 interpol = join value = none
line = 1 ;
axis1 width = 1 label = ('Run Length');
axis2 width = 1 order = (0.0 to 1.0 by 0.1)
label = (justify = c a=-90 r=90 'Probability');
proc gplot data = cdf;
plot cdf*rl /
frame
annotate = anno
vminor = 0
hminor = 0
haxis = axis1
vaxis = axis2
vref = 0.2 to 0.8 by 0.2
lvref = 3
cvref = white
cframe = gray
nolegend;
run;
quit;
goptions reset=all;
