Resources

Acceptance Probabilities for Partial Link Sampling

 /****************************************************************/
 /*          S A S   S A M P L E   L I B R A R Y                 */
 /*                                                              */
 /*    NAME: IEPLINK                                             */
 /*   TITLE: Acceptance Probabilities for Partial Link Sampling  */
 /* PRODUCT: QC                                                  */
 /*  SYSTEM: ALL                                                 */
 /*    KEYS: Inspection Sampling,                                */
 /*   PROCS: TABULATE                                            */
 /*    DATA:                                                     */
 /*                                                              */
 /*    MISC:                                                     */
 /*                                                              */
 /*   NOTES: This program tabulates the acceptance probability   */
 /*          for partial link sampling from multiple lots under  */
 /*          an imperfect inspection model (partial link samp-   */
 /*          ling in the sense introduced by Harishchandra and   */
 /*          Srivenkataramana, 1982).                            */
 /*                                                              */
 /*          Notation:                                           */
 /*                                                              */
 /*          nlot    = size of lot                               */
 /*          d1      = number of nonconforming items in lot i-1  */
 /*          d2      = number of nonconforming items in lot i    */
 /*                                                              */
 /*          nsample = sample size                               */
 /*                                                              */
 /*          c1      = acceptance number                         */
 /*          c2      = rejection  number                         */
 /*          c2p     = acceptance number                         */
 /*                                                              */
 /*          z1      = number of apparent defectives in sample   */
 /*                    from (i-1)st lot                          */
 /*          z2      = number of apparent defectives in first    */
 /*                    sample from ith lot                       */
 /*          z2p     = number of apparent defectives in second   */
 /*                    sample from ith lot                       */
 /*                                                              */
 /*          p       = Pr[ nonconforming item is classified      */
 /*                        as nonconforming ]                    */
 /*          pprime  = Pr[ conforming item is classified as      */
 /*                        nonconforming ]                       */
 /*                                                              */
 /*          accprob = Pr[ acceptance ]                          */
 /*                                                              */
 /*                                                              */
 /*          General Procedure:                                  */
 /*                                                              */
 /*          Take a random sample of size n from the ith lot.    */
 /*          Record the apparent number Zi of defective items.   */
 /*                                                              */
 /*          (a) If Zi <= c1 then accept.                        */
 /*                                                              */
 /*          (b) If Zi > c1 then reject.                         */
 /*                                                              */
 /*          (c) If c1 < Zi <= c2 then take a second sample of   */
 /*              size nsample from the ith lot, and record the   */
 /*              apparent number Zi of defective items.  If      */
 /*                                                              */
 /*              Zi-1 + Zi + Zi' <= c2p ,                        */
 /*                                                              */
 /*              then accept.                                    */
 /*                                                              */
 /*          (d) If c1 < Zi <= c2 and                            */
 /*                                                              */
 /*              Zi-1 + Zi + Zi' > c2p ,                         */
 /*                                                              */
 /*              then reject.                                    */
 /*                                                              */
 /*          Note that in the program, Zi-1 is denoted by z1,    */
 /*          Zi by z2, and Zi' by z2p.                           */
 /*                                                              */
 /*                                                              */
 /*     REF: Harishchandra, K. and Srivenkataramana, T. (1982).  */
 /*          Link Sampling for Attributes, Communications in     */
 /*          Statistics--Theory and Methods 11, 1855-1868.       */
 /*                                                              */
 /*          Johnson, N. L., Kotz, S., and Rodriguez, R. N.      */
 /*          (1986), Statistical Effects of Imperfect Inspection */
 /*          Sampling:  II. Double Sampling and Link Sampling,   */
 /*          Journal of Quality Technology 18, 116-138.          */
 /*          See Table 5.                                        */
 /*                                                              */
 /*          Johnson, N. L., Kotz, S., and Wu, X. (1991).        */
 /*          Inspection Errors for Attributes in Quality         */
 /*          Control.  London:  Chapman & Hall.  See Chapter 4.  */
 /*                                                              */
 /****************************************************************/

data table;

   keep nlot d1 d2 nsample c1 c2 c2p p pprime accprob;

   label nlot    = 'N (lot)'
         d1      = 'D(i-1)'
         d2      = 'D(i)'
         nsample = 'n'
         c1      = 'c1'
         c2      = 'c2'
         c2p     = 'c2'''
         p       = 'p'
         pprime  = 'p'''
         accprob = 'Pr[ Accept ]';

   format zprob   6.4
          accprob 6.4 ;

   /*---set main parameters---*/
   nlot    = 100;
   nsample = 20;
   d1      = 15;
   d2      = 10;
   c1      = 1;
   c2      = 5;
   c2p     = 5;

   /*---loop over p values---*/
   do p = 0.75, 0.90, 0.95, 0.98, 1.00;

      /*---loop over pprime values---*/
      do pprime = 0.0, 0.01, 0.02, 0.05, 0.10;

         /*---compute term1---*/
         link first;

         /*---computer term2---*/
         link second;

         accprob = term1 + term2;

         output;

         end;  /* finish loop over pprime values */

      end;  /* finish loop over p values */

   return;  /* finish main program */

   /*------------------------------------------------------------*/
   /*                                                            */
   /* This module computes the probability Pr[ Z2 <= c1 ]        */
   /*                                                            */
   /* The following serve as input parameters:                   */
   /*                                                            */
   /*    c1      = acceptance value for first sample             */
   /*    nlot    = lot size                                      */
   /*    d       = number of defectives in lot                   */
   /*    nsample = sample size                                   */
   /*    p       = Pr[ correctly classifying a defective item ]  */
   /*    pprime  = Pr[ incorrectly classifying a good item ]     */
   /*                                                            */
   /* The following is returned:                                 */
   /*                                                            */
   /*    term1   = Pr[ Z2 <= c1 ]                                */
   /*                                                            */
   /*------------------------------------------------------------*/
   first:

   term1 = 0.0 ;
   do z2 = 0 to c1 by 1;

      /* nlot, nsample, p, pprime are globally defined */
      z = z2;
      d = d2;
      link uncond;

      term1 = term1 + zprob;

      end;

   return;  /* finish first */

   /*------------------------------------------------------------*/
   /*                                                            */
   /* This module computes the probability                       */
   /*                                                            */
   /*    term2   = Pr[ c1 < Z2 <= c2, Z1 + Z2 + Z2p <= c2p ]     */
   /*                                                            */
   /*                                                            */
   /* The following serve as input parameters:                   */
   /*                                                            */
   /*    c2      = acceptance value                              */
   /*    c2p     = acceptance value                              */
   /*    nlot    = lot size                                      */
   /*    d1      = number of defectives in lot i-1               */
   /*    d2      = number of defectives in lot i                 */
   /*    nsample = sample size                                   */
   /*    p       = Pr[ correctly classifying a defective item ]  */
   /*    pprime  = Pr[ incorrectly classifying a good item ]     */
   /*                                                            */
   /*                                                            */
   /*------------------------------------------------------------*/
   second:

   term2 = 0.0 ;
   zimax = max( c2, c2p );

   do z1 = 0 to zimax by 1;

      do z2 = 0 to zimax by 1;

         do z2p = 0 to zimax by 1;

            if ( c1 < z2 ) & ( z2 <= c2 ) & ( z1+z2+z2p <= c2p )
            then do;

               /* nlot, nsample, p, pprime are globally defined */
               z = z1;
               d = d1;
               link uncond;
               product = zprob;

               /* obtain joint probability that Z2=z2, Z2P=z2p */
               link uncond2;
               product = product * unprb2;

               term2 = term2 + product;
               end;

            end;

         end;

      end;

   return;  /* finish second */

   /*------------------------------------------------------------*/
   /*                                                            */
   /* This module computes the unconditional joint distribution  */
   /* of Z2 and Z2P.                                             */
   /*                                                            */
   /* The following serve as input parameters:                   */
   /*                                                            */
   /*    z2      = number of items classified as defective       */
   /*    z2p     = number of items classified as defective       */
   /*    nlot    = lot size                                      */
   /*    d2      = number of defectives in lot                   */
   /*    nsample = sample size                                   */
   /*    p       = Pr[ correctly classifying a defective item ]  */
   /*    pprime  = Pr[ incorrectly classifying a good item ]     */
   /*                                                            */
   /* The following is returned:                                 */
   /*                                                            */
   /*    unprb2  =                                               */
   /*                                                            */
   /*------------------------------------------------------------*/
   uncond2:

   unprb2 = 0.0 ;
   upp1   = min( d2, nsample );
   lsum   = max( 0, 2 * nsample + d2 - nlot );
   usum   = min( d2, 2 * nsample );

   do ylocal = 0 to upp1 by 1;

      do yplocal = 0 to upp1 by 1;

         if ( lsum <= ylocal + yplocal ) &
            ( ylocal + yplocal <= usum )
         then do;

            /*---absolute hypergeometric probability---*/
            bign_ = nlot;
            litn_ = 2 * nsample;
            d_    = d2;
            y_    = ylocal + yplocal;
            link hypergmt;
            hprob1 = hypprob;

            bign_ = 2 * nsample;
            litn_ = nsample;
            d_    = ylocal + yplocal;
            y_    = ylocal;
            link hypergmt;
            hprob2 = hypprob;

            mhyp = hprob1 * hprob2;

            /*--conditional probability that Z2 = z2 ---*/
            nval = nsample;
            zval = z2;
            yval = ylocal;
            dval = d2;
            link cond;
            mhyp = mhyp * cprob;

            /*---conditional probability that Z2P = z2p ---*/
            nval = nsample;
            zval = z2p;
            yval = yplocal;
            dval = d2;
            link cond;
            mhyp=mhyp * cprob;

            *--add over y and yp--;
            unprb2 = unprb2 + mhyp;

            end;

         end;

      end;

   return;  /* finish uncond2 */


   /*------------------------------------------------------------*/
   /*                                                            */
   /* This module computes the conditional probability           */
   /*                                                            */
   /*    cprob   = Pr[ Z = zval | Y = yval ]                     */
   /*                                                            */
   /* where                                                      */
   /*                                                            */
   /*    zval    = number of items classified as defective       */
   /*    yval    = number of actually defective items in sample  */
   /*                                                            */
   /*    dval    = number of defectives in the lot               */
   /*    nval    = sample size                                   */
   /*    nlot    = lot size                                      */
   /*    p       = Pr[ correctly classifying a defective item ]  */
   /*    pprime  = Pr[ incorrectly classifying a good item ]     */
   /*                                                            */
   /*                                                            */
   /*------------------------------------------------------------*/
   cond:

   /*---initialize result to zero---*/
   cprob = 0.0;

   /*---set limits for subscript---*/
   lolim = max( 0, nval + dval - nlot );
   uplim = min( nval, dval );

   if ( p = 0 ) & ( pprime = 0 ) then do;

      if ( yval >= lolim ) & ( yval <= uplim) then do;

         if zval = 0 then cprob = 1;

         end;

      end;

   else
   if ( p = 0 ) & ( abs( pprime - 1 ) < fuzz ) then do;

      if ( yval >= lolim ) & ( yval <= uplim ) then do;

         if zval = nval - yval then cprob = 1;

         end;

      end;

   else
   if ( abs( p - 1 ) < fuzz ) & ( pprime = 0 ) then do;

      if ( lolim <= yval ) & ( yval <= uplim ) then do;

         if zval = yval then cprob = 1;

         end;

      end;

   else
   if ( abs( p - 1 ) < fuzz ) & ( pprime > 0 ) & ( pprime < 1 )
   then do;

      if ( lolim <= yval ) & ( yval <= uplim ) then do;

         if ( yval <= zval ) & ( zval <= nval ) then do;

            n_ = nval - yval;
            p_ = pprime;
            k_ = zval - yval;

            link binomial;

            cprob = binprob;

            end;

         end;

      end;

   else
   if ( p > 0 ) & ( p < 1 ) & ( abs( pprime-1 ) < fuzz ) then do;

      if ( lolim <= yval ) & ( yval <= uplim ) then do;

         if ( nval - yval <= zval ) & ( zval <= nval ) then do;

            n_ = yval;
            p_ = p;
            k_ = zval - ( nval - yval );
            link binomial;

            cprob = binprob;
            end;

         end;

      end;

   else
   if ( abs( p-1 ) < fuzz ) & ( abs( pprime-1 ) < fuzz ) then do;

      if ( lolim <= yval ) & ( yval <= uplim ) then do;

         if zval =nval then cprob = 1;

         end;

      end;

   else
   if ( 0 < p ) & ( p < 1) & ( pprime > 0 ) & ( pprime < 1 )
   then do;

      if ( lolim <= yval ) & ( yval <= uplim ) then do;

         if ( 0 <= zval ) & ( zval <= nval ) then do;

            xlo = max( 0, yval + zval - nval );
            xup = min( yval, zval );

            /*---convolution of binomial distributions---*/
            do xval = xlo to xup by 1;

               p_ = p;
               k_ = xval;
               n_ = yval;
               link binomial;
               f1 = binprob;

               p_ = pprime;
               k_ = zval - xval;
               n_ = nval - yval;
               link binomial;
               f2 = binprob;

               cprob =cprob + f1 * f2;

               end;

            end;

         end;

      end;

   else
   if ( p = 0 ) & ( 0 < pprime ) & ( pprime < 1 ) then do;

      if ( yval >= lolim ) & ( yval <= uplim ) then do;

         if ( zval >= 0 ) & ( zval <= nval - yval ) then do;

            n_ = nval - yval;
            p_ = pprime;
            k_ = zval;
            link binomial;

            cprob=binprob;

            end;

         end;

      end;


   else
   if ( pprime = 0 ) & ( 0 < p ) & ( p < 1 ) then do;

      if ( lolim <= yval ) &  ( yval <= uplim ) then do;

         if ( zval >= 0 ) & ( zval <= yval ) then do;

            n_ = yval;
            p_ = p;
            k_ = zval;
            link binomial;

            cprob = binprob ;

            end;

         end;

      end;

   return;  /* finish cond */


   /*------------------------------------------------------------*/
   /*                                                            */
   /* This module computes the probability Pr[ Z = z ], where Z  */
   /* is the number of items classified as defective.            */
   /*                                                            */
   /* The following serve as input parameters:                   */
   /*                                                            */
   /*    z       = number of items classified as defective       */
   /*    nlot    = lot size                                      */
   /*    d       = number of defectives in lot                   */
   /*    nsample = sample size                                   */
   /*    p       = Pr[ correctly classifying a defective item ]  */
   /*    pprime  = Pr[ incorrectly classifying a good item ]     */
   /*                                                            */
   /* The following is returned:                                 */
   /*                                                            */
   /*    zprob   = Pr[ Z = z ]                                   */
   /*                                                            */
   /*------------------------------------------------------------*/
   uncond:

   /*---used for roundoff---*/
   fuzz = 0.0001 ;

   /*---lower and upper limits for y---*/
   miny = max( 0, nsample + d - nlot );
   maxy = min( nsample, d );

   /*---initialize probability to zero---*/
   zprob = 0.0 ;

   /*---Case I: p = 0 ---*/
   if p = 0 then do;

      /*---Ia: pprime = 0 ---*/
      if pprime = 0 then do;

         if z = 0 then zprob = 1 ;

         end;  /* finish Ia */

      /*---Ib: pprime = 1 ---*/
      else if abs( pprime - 1 ) < fuzz then do;

         minz = max( 0, nsample - d );
         maxz = min( nsample, nlot - d );

         if ( minz <= z ) & ( z <= maxz ) then do;

            bign_ = nlot;
            litn_ = nsample;
            d_    = d;
            y_    = nsample - z;
            link hypergmt;

            zprob = hypprob;

            end;

         end;  /* finish Ib */

      /*---Ic:  0 < pprime < 1 ---*/
      else do;

         /* Note: minz =  0 */
         maxz = nsample - max( 0, nsample + d - nlot );

         if ( z <= maxz ) then
         do y = miny to maxy by 1;

            /*---obtain Pr[ Y = y ]---*/
            bign_ = nlot;
            litn_ = nsample;
            d_    = d;
            y_    = y;
            link hypergmt;

            /*---obtain Pr[ Z = z | Y = y ]---*/
            n_ = nsample - y;
            k_ = z;
            p_ = pprime;
            link binomial;

            zprob = zprob + binprob * hypprob ;

            end;

         end;  /* finish Ic */

      end;  /* finish Case I */


   /*---Case II:  p = 1 ---*/
   else if ( abs( p - 1 ) < fuzz ) then do;

      /*---IIa:  pprime = 0 (perfect inspection) ---*/
      if pprime = 0 then do;

         minz = max( 0, nsample + d - nlot );
         maxz = min( nsample, d );

         if ( minz <= z ) & ( z <= maxz ) then do;

            bign_ = nlot;
            litn_ = nsample;
            d_    = d;
            y_    = z;
            link hypergmt;

            zprob = hypprob;

            end;

         end;  /* finish IIa */

      /*---IIb:  pprime = 1 ---*/
      else if ( abs( pprime - 1 ) < fuzz ) then do;

         if z = nsample then zprob = 1 ;

         end;  /* finish IIb */

      /*---IIc:  0 < pprime < 1 ---*/
      else do;

         minz = max( 0, nsample + d - nlot );
         maxz = nsample ;

         if ( minz <= z ) & ( z <= maxz ) then
         do y = miny to maxy by 1;

            /*---compute Pr[ Y = y ] ---*/
            bign_ = nlot ;
            litn_ = nsample ;
            d_    = d;
            y_    = y;
            link hypergmt;

            /*---obtain Pr[ Z = z | Y = y ]---*/
            p_ = pprime;
            k_ = z - y;
            n_ = nsample - y;
            link binomial;

            zprob = zprob + hypprob * binprob;

            end;

         end;  /* finish IIb */

      end;  /* finish Case II */


   /*---Case III:  0 < p < 1---*/
   else do;

      /*---IIIa:  pprime = 0 ---*/
      if pprime = 0 then do;

         /* zmin = 0 */
         zmax = min( nsample, d );

         if z <= zmax then
         do y = miny to maxy by 1;

            /*---obtain Pr[ Y = y ]---*/
            bign_ = nlot ;
            litn_ = nsample ;
            d_    = d;
            y_    = y;
            link hypergmt;

            /*---obtain Pr[ Z = z | Y = y ]---*/
            p_ = p;
            k_ = z;
            n_ = y;
            link binomial;

            /*---increment unconditional probability---*/
            zprob = zprob + binprob * hypprob ;

            end;

         end;  /* finish IIIa */

      /*---IIIb:  pprime = 1 ---*/
      else if abs( pprime - 1 ) < fuzz then do;

         zmin = nsample - min( nsample, d );
         /* zmax = nsample */

         if z >= zmin then
         do y = miny to maxy by 1;

            /*---obtain Pr[ Y = y ]---*/
            bign_ = nlot;
            litn_ = nsample;
            d_    = d;
            y_    = y;
            link hypergmt;

            /*---obtain Pr[ Z = z | Y = y ]---*/
            p_ = p;
            k_ = z - ( nsample - y );
            n_ = y;
            link binomial;

            /*---increment unconditional probability---*/
            zprob = zprob + binprob * hypprob ;

            end;

         end;  /* finish Case IIIb */

      /*---IIIc:  0 < pprime < 1 ---*/
      else
      do y = miny to maxy by 1;

         /*---obtain Pr[ Y = y ]---*/
         bign_ = nlot;
         litn_ = nsample;
         d_    = d;
         y_    = y;
         link hypergmt;

         /*---obtain Pr[ Z = z | Y = y ]---*/
         condprob = 0.0 ;
         minx     = max( 0, y + z - nsample );
         maxx     = min( y, z );

         do x = minx to maxx by 1;

            p_ = p;
            k_ = x;
            n_ = y;
            link binomial;
            factor1 = binprob;

            p_ = pprime;
            k_ = z - x;
            n_ = nsample - y;
            link binomial;
            factor2 = binprob;

            condprob = condprob + factor1 * factor2;

            end;

         /*---increment unconditional probability---*/
         zprob = zprob + condprob * hypprob ;

         end;  /* finish IIIc */

      end;  /* finish Case III */

   return;  /* finish uncond */

   /*---Compute Binomial Probability---*/
   binomial:

   binprob=0.0;

   if n_ = 0 then do;

      if k_ = 0 then binprob = 1.0 ;

      end;

   else
   if n_ > 0 then do;

      if ( k_ > 0 ) & ( k_ < n_ ) then
         binprob = probbnml( p_, n_, k_ ) -
                   probbnml( p_, n_, k_-1 );

      else
      if k_ = n_ then do;
         if ( p_> 0.0 ) & ( p_ < 1.0 ) then
            binprob = p_**n_;
         else if p_ = 1.0 then
            binprob = 1.0;
         end;

      else
      if k_ = 0 then do;
         if ( p_ > 0.0 ) & ( p_ < 1.0 ) then
            binprob = (1.0 - p_)**n_;
         else if p_ = 0.0 then
            binprob = 1.0;
         end;

      end;

   /*---finish binomial computation---*/
   return;

   /*---Compute Hypergeometric Probability---*/
   hypergmt:

      hypprob = 0 ;
      minarg  = max( 0, litn_ + d_ - bign_ );
      maxarg  = min( litn_, d_ );

      if y_ = minarg then

         hypprob = probhypr( bign_, d_, litn_, y_ );

      else
      if ( minarg < y_ ) & ( y_ <= maxarg ) then

         hypprob = probhypr( bign_, d_, litn_, y_     ) -
                   probhypr( bign_, d_, litn_, y_ - 1 );

   /*---finish hypergeometric computation---*/
   return;

run;

proc sort data=table;
   by nlot d1 d2 nsample c1 c2 c2p;

proc tabulate data=table noseps;
   by nlot d1 d2 nsample c1 c2 c2p;
   class p pprime;
   var accprob;
   table p, pprime*accprob=' '*sum=' '*f=8.4 / rts=7;
run;