alpha              80 Magick++/lib/Magick++/Color.h     void alpha(double alpha_);
alpha              81 Magick++/lib/Magick++/Color.h     double alpha(void) const;
alpha            1185 coders/bmp.c             alpha,
alpha            1233 coders/bmp.c                   alpha=((pixel & bmp_info.alpha_mask) << shift.opacity) >> 16;
alpha            1235 coders/bmp.c                     alpha|=((alpha & 0xff00) >> 8);
alpha            1236 coders/bmp.c                   SetPixelAlpha(q,ScaleShortToQuantum((unsigned short) alpha));
alpha            1302 coders/bmp.c               alpha,
alpha            1330 coders/bmp.c                   alpha=((pixel & bmp_info.alpha_mask) << shift.opacity) >> 16;
alpha            1332 coders/bmp.c                     alpha|=(alpha >> 8);
alpha            1333 coders/bmp.c                   SetPixelAlpha(q,ScaleShortToQuantum((unsigned short) alpha));
alpha            1959 coders/dds.c       alpha;
alpha            2008 coders/dds.c                   alpha = 17U * (unsigned char) ((a0 >> (4*(4*j+i))) & 0xf);
alpha            2010 coders/dds.c                   alpha = 17U * (unsigned char) ((a1 >> (4*(4*(j-2)+i))) & 0xf);
alpha            2012 coders/dds.c                   alpha));
alpha            2051 coders/dds.c       alpha,
alpha            2099 coders/dds.c                   alpha = a0;
alpha            2101 coders/dds.c                   alpha = a1;
alpha            2103 coders/dds.c                   alpha = ((8-alpha_code) * a0 + (alpha_code-1) * a1) / 7;
alpha            2105 coders/dds.c                   alpha = 0;
alpha            2107 coders/dds.c                   alpha = 255;
alpha            2109 coders/dds.c                   alpha = (((6-alpha_code) * a0 + (alpha_code-1) * a1) / 5);
alpha            2111 coders/dds.c                   alpha));
alpha            2811 coders/dds.c           alpha;
alpha            2834 coders/dds.c               alpha = ScaleQuantumToChar(GetPixelAlpha(p));
alpha            2836 coders/dds.c               alpha = 255;
alpha            2838 coders/dds.c             alphas[4*by + bx] = (size_t)alpha;
alpha            2843 coders/dds.c             point.w = weightByAlpha ? (float)(alpha + 1) / 256.0f : 1.0f;
alpha            2852 coders/dds.c                   (alpha       >= 128 || compression == FOURCC_DXT5))
alpha            2873 coders/dds.c                   if (alpha < min7)
alpha            2874 coders/dds.c                     min7 = alpha;
alpha            2875 coders/dds.c                   if (alpha > max7)
alpha            2876 coders/dds.c                     max7 = alpha;
alpha            2877 coders/dds.c                   if (alpha != 0 && alpha < min5)
alpha            2878 coders/dds.c                     min5 = alpha;
alpha            2879 coders/dds.c                   if (alpha != 255 && alpha > max5)
alpha            2880 coders/dds.c                     max5 = alpha;
alpha             246 coders/debug.c               alpha[MaxTextExtent];
alpha             248 coders/debug.c             (void) FormatLocaleString(alpha,MaxTextExtent,",%.20g ",
alpha             250 coders/debug.c             (void) ConcatenateMagickString(tuple,alpha,MaxTextExtent);
alpha            1597 coders/gif.c             alpha,
alpha            1613 coders/gif.c                 alpha=fabs((double) image->colormap[i].opacity-
alpha            1617 coders/gif.c                 if (alpha < beta)
alpha            1631 coders/gif.c                     alpha=fabs((double) image->colormap[i].opacity-
alpha            1635 coders/gif.c                     if (alpha < beta)
alpha             972 coders/jp2.c       jp2_image->comps[3].alpha=1;
alpha             975 coders/jp2.c        jp2_image->comps[1].alpha=1;
alpha            7913 coders/msl.c               alpha;
alpha            7915 coders/msl.c             alpha=ParseCommandOption(MagickAlphaOptions,MagickFalse,value);
alpha            7916 coders/msl.c             if (alpha < 0)
alpha            7919 coders/msl.c               (void) SetImageAlphaChannel(image,(AlphaChannelType) alpha);
alpha              86 coders/pes.c       alpha;
alpha            3249 coders/png.c              alpha;
alpha            3285 coders/png.c                   alpha=ScaleCharToQuantum((unsigned char)*p++);
alpha            3287 coders/png.c                   SetPixelAlpha(q,alpha);
alpha            3289 coders/png.c                   if (alpha != QuantumRange-OpaqueOpacity)
alpha            3329 coders/png.c                     alpha=ScaleShortToQuantum(quantum);
alpha            3330 coders/png.c                     SetPixelAlpha(q,alpha);
alpha            3331 coders/png.c                     if (alpha != QuantumRange-OpaqueOpacity)
alpha            3342 coders/png.c                     alpha=*p++;
alpha            3343 coders/png.c                     SetPixelAlpha(q,alpha);
alpha            3344 coders/png.c                     if (alpha != QuantumRange-OpaqueOpacity)
alpha            6015 coders/png.c                   mng_info->global_sbit.alpha=p[3];
alpha            1235 coders/sixel.c         alpha,
alpha            1251 coders/sixel.c             alpha=(MagickRealType) image->colormap[i].opacity;
alpha            1253 coders/sixel.c             if (alpha > beta)
alpha            1267 coders/sixel.c                 alpha=(MagickRealType) image->colormap[i].opacity;
alpha            1269 coders/sixel.c                 if (alpha > beta)
alpha              93 coders/stegano.c #define GetBit(alpha,i) (((size_t) (alpha) >> (size_t) (i)) & 0x01)
alpha             308 coders/svg.c           alpha,
alpha             323 coders/svg.c         alpha=value-svg_info->view_box.width;
alpha             325 coders/svg.c         return(hypot(alpha,beta)/sqrt(2.0)/100.0);
alpha            4512 coders/svg.c             alpha,
alpha            4520 coders/svg.c           alpha=primitive_info[j+1].point.x-primitive_info[j].point.x;
alpha            4525 coders/svg.c             hypot(alpha,beta));
alpha             143 coders/xcf.c       alpha,
alpha             173 coders/xcf.c       alpha;
alpha             377 coders/xcf.c               inLayerInfo->alpha));
alpha             390 coders/xcf.c               SetPixelAlpha(q,xcfdata->alpha == 255U ? TransparentOpacity :
alpha             391 coders/xcf.c                 ScaleCharToQuantum((unsigned char) inLayerInfo->alpha));
alpha             413 coders/xcf.c       alpha;
alpha             443 coders/xcf.c     alpha=ScaleCharToQuantum((unsigned char) inLayerInfo->alpha);
alpha             490 coders/xcf.c                   SetPixelAlpha(q,alpha);
alpha             549 coders/xcf.c                   SetPixelAlpha(q,alpha);
alpha             807 coders/xcf.c         outLayer->alpha = ReadBlobMSBLong(image);
alpha             908 coders/xcf.c       ScaleCharToQuantum((unsigned char) (255-outLayer->alpha));
alpha             963 coders/xpm.c           alpha,
alpha             979 coders/xpm.c               alpha=(Quantum) TransparentOpacity-(MagickRealType)
alpha             983 coders/xpm.c               if (alpha < beta)
alpha             997 coders/xpm.c                   alpha=(Quantum) TransparentOpacity-(MagickRealType)
alpha            1001 coders/xpm.c                   if (alpha < beta)
alpha             633 magick/accelerate-private.h       alpha,
alpha             639 magick/accelerate-private.h     alpha=mwcReadPseudoRandomValue(r);
alpha             644 magick/accelerate-private.h         noise=(pixel+QuantumRange*SigmaUniform*(alpha-0.5f));
alpha             653 magick/accelerate-private.h         if (alpha == 0.0f)
alpha             654 magick/accelerate-private.h           alpha=1.0f;
alpha             656 magick/accelerate-private.h         gamma=sqrt(-2.0f*log(alpha));
alpha             667 magick/accelerate-private.h       if (alpha < (SigmaImpulse/2.0f))
alpha             670 magick/accelerate-private.h         if (alpha >= (1.0f-(SigmaImpulse/2.0f)))
alpha             678 magick/accelerate-private.h       if (alpha <= 0.5f)
alpha             680 magick/accelerate-private.h           if (alpha <= MagickEpsilon)
alpha             683 magick/accelerate-private.h             noise=(float) (pixel+QuantumRange*SigmaLaplacian*log(2.0f*alpha)+
alpha             687 magick/accelerate-private.h       beta=1.0f-alpha;
alpha             697 magick/accelerate-private.h       if (alpha > MagickEpsilon)
alpha             698 magick/accelerate-private.h         sigma=sqrt(-2.0f*log(alpha));
alpha             710 magick/accelerate-private.h       for (i=0; alpha > poisson; i++)
alpha             713 magick/accelerate-private.h         alpha*=beta;
alpha             720 magick/accelerate-private.h       noise=(float) (QuantumRange*SigmaRandom*alpha);
alpha            1222 magick/accelerate-private.h       const float alpha,const float4 *q,
alpha            1234 magick/accelerate-private.h       Sa=1.0-QuantumScale*alpha;
alpha            1247 magick/accelerate-private.h       const float alpha,const float4 *q,
alpha            1250 magick/accelerate-private.h       MagickPixelCompositePlus(p,(float) (QuantumRange-alpha*
alpha            1653 magick/accelerate-private.h             float alpha = QuantumScale*(QuantumRange-p.w);
alpha            1655 magick/accelerate-private.h             float g = alpha * f;
alpha            1741 magick/accelerate-private.h             float alpha = QuantumScale*(QuantumRange-p.w);
alpha            1743 magick/accelerate-private.h             float g = alpha * f;
alpha            2643 magick/accelerate-private.h           float alpha = QuantumScale*(QuantumRange-samplePixelValue.w);
alpha            2645 magick/accelerate-private.h           pixel.x = pixel.x + k * alpha * samplePixelValue.x;
alpha            2646 magick/accelerate-private.h           pixel.y = pixel.y + k * alpha * samplePixelValue.y;
alpha            2647 magick/accelerate-private.h           pixel.z = pixel.z + k * alpha * samplePixelValue.z;
alpha            2649 magick/accelerate-private.h           pixel.w += k * alpha * samplePixelValue.w;
alpha            2651 magick/accelerate-private.h           gamma+=k*alpha;
alpha            2733 magick/accelerate-private.h             float alpha = (float)(QuantumScale*(QuantumRange-p.w));
alpha            2734 magick/accelerate-private.h             result.x += alpha * p.x;
alpha            2735 magick/accelerate-private.h             result.y += alpha * p.y;
alpha            2736 magick/accelerate-private.h             result.z += alpha * p.z;
alpha            2738 magick/accelerate-private.h             gamma+=alpha;
alpha            2770 magick/accelerate-private.h       unsigned int alpha = (unsigned int)(s.y ^ (s.y << 11));
alpha            2774 magick/accelerate-private.h       s.x = (s.x ^ (s.x >> 19)) ^ (alpha ^ (alpha >> 8));
alpha            2804 magick/accelerate-private.h         unsigned int alpha = (unsigned int)(seed[1] ^ (seed[1] << 11));
alpha            2808 magick/accelerate-private.h         seed[0] = (seed[0] ^ (seed[0] >> 19)) ^ (alpha ^ (alpha >> 8));
alpha            2894 magick/accelerate-private.h       const float alpha=(float) (MagickPI*x);
alpha            2895 magick/accelerate-private.h       return sinpi(x)/alpha;
alpha            3119 magick/accelerate-private.h               float alpha = weight * QuantumScale * GetPixelAlpha(p);
alpha            3122 magick/accelerate-private.h               filteredPixel.x += alpha * cp.x;
alpha            3123 magick/accelerate-private.h               filteredPixel.y += alpha * cp.y;
alpha            3124 magick/accelerate-private.h               filteredPixel.z += alpha * cp.z;
alpha            3128 magick/accelerate-private.h               gamma+=alpha;
alpha            3312 magick/accelerate-private.h               float alpha = weight * QuantumScale * GetPixelAlpha(p);
alpha            3315 magick/accelerate-private.h               filteredPixel.x += alpha * cp.x;
alpha            3316 magick/accelerate-private.h               filteredPixel.y += alpha * cp.y;
alpha            3317 magick/accelerate-private.h               filteredPixel.z += alpha * cp.z;
alpha            3321 magick/accelerate-private.h               gamma+=alpha;
alpha            3239 magick/cache.c   const MagickRealType alpha,const MagickPixelPacket *q,
alpha            3245 magick/cache.c   if (alpha == TransparentOpacity)
alpha            3250 magick/cache.c   gamma=1.0-QuantumScale*QuantumScale*alpha*beta;
alpha            3252 magick/cache.c   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
alpha            3253 magick/cache.c   composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
alpha            3254 magick/cache.c   composite->blue=gamma*MagickOver_(p->blue,alpha,q->blue,beta);
alpha            3256 magick/cache.c     composite->index=gamma*MagickOver_(p->index,alpha,q->index,beta);
alpha            3266 magick/cache.c     alpha,
alpha            3314 magick/cache.c   GetMagickPixelPacket(image,&alpha);
alpha            3322 magick/cache.c     SetMagickPixelPacket(image,p,indexes+i,&alpha);
alpha            3324 magick/cache.c     MagickPixelCompositeMask(&beta,GetPixelIntensity(image,r),&alpha,
alpha            3325 magick/cache.c       alpha.opacity,&beta);
alpha             856 magick/channel.c             alpha,
alpha             859 magick/channel.c           alpha=QuantumScale*GetPixelAlpha(q);
alpha             860 magick/channel.c           gamma=PerceptibleReciprocal(alpha);
alpha             294 magick/cipher.c static inline unsigned char ByteMultiply(const unsigned char alpha,
alpha             300 magick/cipher.c   if ((alpha == 0) || (beta == 0))
alpha             302 magick/cipher.c   return(InverseLog[(Log[alpha]+Log[beta]) % 0xff]);
alpha             454 magick/cipher.c     alpha,
alpha             477 magick/cipher.c     alpha=(text[i] & 0x000000ff) | ((text[map[1][i]]) & 0x0000ff00) |
alpha             479 magick/cipher.c     key[i]=ByteSubTransform(alpha,SBox);
alpha             485 magick/cipher.c   alpha=0;
alpha             959 magick/cipher.c static inline void InverseAddRoundKey(const unsigned int *alpha,
alpha             970 magick/cipher.c       beta[i]|=(ByteMultiply(0xe,(alpha[i] >> (8*j)) & 0xff) ^
alpha             971 magick/cipher.c         ByteMultiply(0xb,(alpha[i] >> (8*((j+1) % 4))) & 0xff) ^
alpha             972 magick/cipher.c         ByteMultiply(0xd,(alpha[i] >> (8*((j+2) % 4))) & 0xff) ^
alpha             973 magick/cipher.c         ByteMultiply(0x9,(alpha[i] >> (8*((j+3) % 4))) & 0xff)) << (8*j);
alpha             977 magick/cipher.c static inline unsigned int XTime(unsigned char alpha)
alpha             982 magick/cipher.c   beta=(unsigned char) ((alpha & 0x80) != 0 ? 0x1b : 0);
alpha             983 magick/cipher.c   alpha<<=1;
alpha             984 magick/cipher.c   alpha^=beta;
alpha             985 magick/cipher.c   return(alpha);
alpha            1006 magick/cipher.c     alpha,
alpha            1043 magick/cipher.c     alpha=aes_info->encipher_key[i-1];
alpha            1046 magick/cipher.c         alpha=ByteSubTransform(RotateRight(alpha),SBox) ^ beta;
alpha            1051 magick/cipher.c         alpha=ByteSubTransform(alpha,SBox);
alpha            1052 magick/cipher.c     aes_info->encipher_key[i]=aes_info->encipher_key[i-n] ^ alpha;
alpha            1069 magick/cipher.c   alpha=0;
alpha              90 magick/color.c     alpha;
alpha             887 magick/color.c       p->alpha);
alpha              39 magick/composite-private.h   const MagickRealType alpha,const MagickRealType q,const MagickRealType beta)
alpha              45 magick/composite-private.h   Sa=1.0-QuantumScale*alpha;
alpha              51 magick/composite-private.h   const MagickRealType alpha,const PixelPacket *q,const MagickRealType beta,
alpha              62 magick/composite-private.h   Sa=1.0-QuantumScale*alpha;
alpha              70 magick/composite-private.h     GetPixelRed(p),alpha,(MagickRealType) GetPixelRed(q),beta)));
alpha              72 magick/composite-private.h     GetPixelGreen(p),alpha,(MagickRealType) GetPixelGreen(q),beta)));
alpha              74 magick/composite-private.h     GetPixelBlue(p),alpha,(MagickRealType) GetPixelBlue(q),beta)));
alpha              79 magick/composite-private.h     GetPixelRed(p),alpha,(MagickRealType) GetPixelRed(q),beta));
alpha              81 magick/composite-private.h     GetPixelGreen(p),alpha,(MagickRealType) GetPixelGreen(q),beta));
alpha              83 magick/composite-private.h     GetPixelBlue(p),alpha,(MagickRealType) GetPixelBlue(q),beta));
alpha              88 magick/composite-private.h   const MagickRealType alpha,const MagickPixelPacket *q,
alpha              99 magick/composite-private.h   Sa=1.0-QuantumScale*alpha;
alpha             104 magick/composite-private.h   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
alpha             105 magick/composite-private.h   composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
alpha             106 magick/composite-private.h   composite->blue=gamma*MagickOver_(p->blue,alpha,q->blue,beta);
alpha             108 magick/composite-private.h     composite->index=gamma*MagickOver_(p->index,alpha,q->index,beta);
alpha             112 magick/composite-private.h   const MagickRealType alpha,const MagickPixelPacket *q,
alpha             123 magick/composite-private.h   Sa=1.0-QuantumScale*alpha;
alpha             139 magick/composite-private.h   const MagickRealType alpha,const MagickPixelPacket *q,
alpha             142 magick/composite-private.h   MagickPixelCompositePlus(p,(MagickRealType) (QuantumRange-alpha*
alpha             151 magick/composite-private.h   const MagickRealType alpha,const MagickPixelPacket *q,
alpha             156 magick/composite-private.h     (QuantumRange-alpha),q,(MagickRealType) (QuantumRange-area*(QuantumRange-
alpha             355 magick/composite.c   const MagickRealType alpha,const MagickRealType q,const MagickRealType beta)
alpha             358 magick/composite.c     return(MagickOver_(p,alpha,q,beta));  /* src-over */
alpha             359 magick/composite.c   return(MagickOver_(q,beta,p,alpha));    /* dst-over */
alpha             785 magick/composite.c   const MagickRealType alpha,const MagickRealType q,const MagickRealType beta)
alpha             788 magick/composite.c      return(MagickOver_(p,alpha,q,beta));  /* src-over */
alpha             789 magick/composite.c    return(MagickOver_(q,beta,p,alpha));    /* dst-over */
alpha            1467 magick/composite.c     alpha,
alpha            1473 magick/composite.c   alpha=Dca/Da;
alpha            1475 magick/composite.c     return(Dca*(Sa+(2.0*Sca-Sa)*(1.0-alpha))+Sca*(1.0-Da)+Dca*(1.0-Sa));
alpha            1478 magick/composite.c       beta=Dca*Sa+Da*(2.0*Sca-Sa)*(4.0*alpha*(4.0*alpha+1.0)*(alpha-1.0)+7.0*
alpha            1479 magick/composite.c         alpha)+Sca*(1.0-Da)+Dca*(1.0-Sa);
alpha            1482 magick/composite.c   beta=Dca*Sa+Da*(2.0*Sca-Sa)*(pow(alpha,0.5)-alpha)+Sca*(1.0-Da)+Dca*(1.0-Sa);
alpha            3601 magick/deprecate.c     alpha,
alpha            3604 magick/deprecate.c   alpha=MagickMax(x+2.0,0.0);
alpha            3605 magick/deprecate.c   gamma=1.0*alpha*alpha*alpha;
alpha            3606 magick/deprecate.c   alpha=MagickMax(x+1.0,0.0);
alpha            3607 magick/deprecate.c   gamma-=4.0*alpha*alpha*alpha;
alpha            3608 magick/deprecate.c   alpha=MagickMax(x+0.0,0.0);
alpha            3609 magick/deprecate.c   gamma+=6.0*alpha*alpha*alpha;
alpha            3610 magick/deprecate.c   alpha=MagickMax(x-1.0,0.0);
alpha            3611 magick/deprecate.c   gamma-=4.0*alpha*alpha*alpha;
alpha            3659 magick/deprecate.c         alpha[16];
alpha            3670 magick/deprecate.c         alpha[i]=1.0;
alpha            3673 magick/deprecate.c             alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
alpha            3674 magick/deprecate.c             pixels[i].red*=alpha[i];
alpha            3675 magick/deprecate.c             pixels[i].green*=alpha[i];
alpha            3676 magick/deprecate.c             pixels[i].blue*=alpha[i];
alpha            3678 magick/deprecate.c               pixels[i].index*=alpha[i];
alpha            3680 magick/deprecate.c         gamma=alpha[i];
alpha            3699 magick/deprecate.c         alpha[16];
alpha            3715 magick/deprecate.c         alpha[i]=1.0;
alpha            3718 magick/deprecate.c             alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
alpha            3719 magick/deprecate.c             pixels[i].red*=alpha[i];
alpha            3720 magick/deprecate.c             pixels[i].green*=alpha[i];
alpha            3721 magick/deprecate.c             pixels[i].blue*=alpha[i];
alpha            3723 magick/deprecate.c               pixels[i].index*=alpha[i];
alpha            3747 magick/deprecate.c         alpha[16];
alpha            3761 magick/deprecate.c         alpha[i]=1.0;
alpha            3764 magick/deprecate.c             alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
alpha            3765 magick/deprecate.c             pixels[i].red*=alpha[i];
alpha            3766 magick/deprecate.c             pixels[i].green*=alpha[i];
alpha            3767 magick/deprecate.c             pixels[i].blue*=alpha[i];
alpha            3769 magick/deprecate.c               pixels[i].index*=alpha[i];
alpha            3775 magick/deprecate.c       gamma=(((1.0-delta.y)*((1.0-delta.x)*alpha[0]+delta.x*alpha[1])+delta.y*
alpha            3776 magick/deprecate.c         ((1.0-delta.x)*alpha[2]+delta.x*alpha[3])));
alpha            3855 magick/deprecate.c         alpha[4];
alpha            3870 magick/deprecate.c         alpha[i]=1.0;
alpha            3873 magick/deprecate.c             alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
alpha            3874 magick/deprecate.c             pixels[i].red*=alpha[i];
alpha            3875 magick/deprecate.c             pixels[i].green*=alpha[i];
alpha            3876 magick/deprecate.c             pixels[i].blue*=alpha[i];
alpha            3878 magick/deprecate.c               pixels[i].index*=alpha[i];
alpha            3897 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
alpha            3917 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
alpha            3942 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
alpha            3963 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
alpha            4003 magick/deprecate.c         alpha[16],
alpha            4029 magick/deprecate.c           alpha[n]=1.0;
alpha            4032 magick/deprecate.c               alpha[n]=QuantumScale*((MagickRealType)
alpha            4034 magick/deprecate.c               pixels[n].red*=alpha[n];
alpha            4035 magick/deprecate.c               pixels[n].green*=alpha[n];
alpha            4036 magick/deprecate.c               pixels[n].blue*=alpha[n];
alpha            4038 magick/deprecate.c                 pixels[n].index*=alpha[n];
alpha            4041 magick/deprecate.c           gamma=alpha[n];
alpha            2867 magick/draw.c            alpha,
alpha            2871 magick/draw.c          alpha=bounds.x2-bounds.x1;
alpha            2873 magick/draw.c          radius=hypot((double) alpha,(double) beta);
alpha            2917 magick/draw.c            alpha,
alpha            2921 magick/draw.c          alpha=bounds.x2-bounds.x1;
alpha            2923 magick/draw.c          radius=hypot((double) alpha,(double) beta);
alpha            3313 magick/draw.c        alpha,
alpha            3374 magick/draw.c                  alpha=(offset-gradient->stops[i].offset)/
alpha            3376 magick/draw.c                  MagickPixelCompositeBlend(&gradient->stops[i].color,1.0-alpha,
alpha            3377 magick/draw.c                    &gradient->stops[j].color,alpha,&composite);
alpha            3408 magick/draw.c                  alpha=(offset-gradient->stops[i].offset)/
alpha            3410 magick/draw.c                  MagickPixelCompositeBlend(&gradient->stops[i].color,1.0-alpha,
alpha            3411 magick/draw.c                    &gradient->stops[j].color,alpha,&composite);
alpha            3465 magick/draw.c                  alpha=(offset-gradient->stops[i].offset)/
alpha            3470 magick/draw.c                        alpha=length-repeat;
alpha            3472 magick/draw.c                        alpha=gradient->radius-repeat;
alpha            3476 magick/draw.c                  MagickPixelCompositeBlend(&gradient->stops[i].color,1.0-alpha,
alpha            3477 magick/draw.c                    &gradient->stops[j].color,alpha,&composite);
alpha            3666 magick/draw.c      alpha,
alpha            3732 magick/draw.c            alpha=delta.x*delta.x+delta.y*delta.y;
alpha            3733 magick/draw.c            if (beta > alpha)
alpha            3741 magick/draw.c                alpha=1.0/alpha;
alpha            3743 magick/draw.c                distance=alpha*beta*beta;
alpha            3752 magick/draw.c            alpha=mid+0.5;
alpha            3754 magick/draw.c                (distance <= ((alpha+0.25)*(alpha+0.25))))
alpha            3756 magick/draw.c                alpha=mid-0.5;
alpha            3757 magick/draw.c                if (distance <= ((alpha+0.25)*(alpha+0.25)))
alpha            3764 magick/draw.c                    alpha=beta-mid-0.5;
alpha            3765 magick/draw.c                    if (*stroke_opacity < ((alpha-0.25)*(alpha-0.25)))
alpha            3766 magick/draw.c                      *stroke_opacity=(alpha-0.25)*(alpha-0.25);
alpha            3785 magick/draw.c        alpha=beta-1.0;
alpha            3786 magick/draw.c        if (subpath_opacity < (alpha*alpha))
alpha            3787 magick/draw.c          subpath_opacity=alpha*alpha;
alpha            4969 magick/draw.c      alpha,
alpha            5026 magick/draw.c    alpha=points[1].x-points[0].x;
alpha            5028 magick/draw.c    factor=PerceptibleReciprocal(alpha*alpha+beta*beta)-0.25;
alpha            5038 magick/draw.c    center.y=(double) ((points[0].y+points[1].y)/2+factor*alpha);
alpha            5039 magick/draw.c    alpha=atan2(points[0].y-center.y,points[0].x-center.x);
alpha            5040 magick/draw.c    theta=atan2(points[1].y-center.y,points[1].x-center.x)-alpha;
alpha            5051 magick/draw.c      beta=0.5*((alpha+(i+1)*theta/arc_segments)-(alpha+i*theta/arc_segments));
alpha            5055 magick/draw.c      points[0].x=(double) (center.x+cos(fmod((double) (alpha+(double) i*theta/
alpha            5056 magick/draw.c        arc_segments),DegreesToRadians(360.0)))-gamma*sin(fmod((double) (alpha+
alpha            5058 magick/draw.c      points[0].y=(double) (center.y+sin(fmod((double) (alpha+(double) i*theta/
alpha            5059 magick/draw.c        arc_segments),DegreesToRadians(360.0)))+gamma*cos(fmod((double) (alpha+
alpha            5061 magick/draw.c      points[2].x=(double) (center.x+cos(fmod((double) (alpha+(double) (i+1)*
alpha            5063 magick/draw.c      points[2].y=(double) (center.y+sin(fmod((double) (alpha+(double) (i+1)*
alpha            5065 magick/draw.c      points[1].x=(double) (points[2].x+gamma*sin(fmod((double) (alpha+(double)
alpha            5067 magick/draw.c      points[1].y=(double) (points[2].y-gamma*cos(fmod((double) (alpha+(double)
alpha            5100 magick/draw.c      alpha,
alpha            5128 magick/draw.c        alpha=fabs(primitive_info[j].point.x-primitive_info[i].point.x);
alpha            5129 magick/draw.c        if (alpha > (double) quantum)
alpha            5130 magick/draw.c          quantum=(size_t) alpha;
alpha            5131 magick/draw.c        alpha=fabs(primitive_info[j].point.y-primitive_info[i].point.y);
alpha            5132 magick/draw.c        if (alpha > (double) quantum)
alpha            5133 magick/draw.c          quantum=(size_t) alpha;
alpha            5157 magick/draw.c      alpha=pow((double) (1.0-weight),(double) number_coordinates-1.0);
alpha            5160 magick/draw.c        point.x+=alpha*coefficients[j]*p->point.x;
alpha            5161 magick/draw.c        point.y+=alpha*coefficients[j]*p->point.y;
alpha            5162 magick/draw.c        alpha*=weight/(1.0-weight);
alpha            5193 magick/draw.c      alpha,
alpha            5201 magick/draw.c    alpha=end.x-start.x;
alpha            5203 magick/draw.c    radius=hypot((double) alpha,(double) beta);
alpha             317 magick/effect.c         alpha,
alpha             356 magick/effect.c           alpha=1.0;
alpha             359 magick/effect.c             alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(p));
alpha             361 magick/effect.c             pixel.red+=(*k)*alpha*GetPixelRed(p);
alpha             363 magick/effect.c             pixel.green+=(*k)*alpha*GetPixelGreen(p);
alpha             365 magick/effect.c             pixel.blue+=(*k)*alpha*GetPixelBlue(p);
alpha             370 magick/effect.c             pixel.index+=(*k)*alpha*GetPixelIndex(indexes+x+(width-i)*v+u);
alpha             371 magick/effect.c           gamma+=(*k)*alpha;
alpha             639 magick/effect.c         alpha,
alpha             678 magick/effect.c           alpha=1.0;
alpha             681 magick/effect.c             alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(p));
alpha             683 magick/effect.c             pixel.red+=(*k)*alpha*GetPixelRed(p);
alpha             685 magick/effect.c             pixel.green+=(*k)*alpha*GetPixelGreen(p);
alpha             687 magick/effect.c             pixel.blue+=(*k)*alpha*GetPixelBlue(p);
alpha             692 magick/effect.c             pixel.index+=(*k)*alpha*GetPixelIndex(indexes+x+(width-i)*v+u);
alpha             693 magick/effect.c           gamma+=(*k)*alpha;
alpha            1699 magick/effect.c             alpha,
alpha            1707 magick/effect.c               alpha=(MagickRealType) (QuantumScale*(QuantumRange-
alpha            1709 magick/effect.c               pixel.red+=(*k)*alpha*GetPixelRed(kernel_pixels+u);
alpha            1710 magick/effect.c               pixel.green+=(*k)*alpha*GetPixelGreen(kernel_pixels+u);
alpha            1711 magick/effect.c               pixel.blue+=(*k)*alpha*GetPixelBlue(kernel_pixels+u);
alpha            1712 magick/effect.c               gamma+=(*k)*alpha;
alpha            1752 magick/effect.c                   alpha=(MagickRealType) (QuantumScale*(QuantumRange-
alpha            1754 magick/effect.c                   pixel.index+=(*k)*alpha*GetPixelIndex(kernel_indexes+u);
alpha            2130 magick/effect.c             alpha,
alpha            2133 magick/effect.c           alpha=0.0;
alpha            2139 magick/effect.c             alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(&pixel));
alpha            2140 magick/effect.c             qixel.red+=(*k)*alpha*pixel.red;
alpha            2141 magick/effect.c             qixel.green+=(*k)*alpha*pixel.green;
alpha            2142 magick/effect.c             qixel.blue+=(*k)*alpha*pixel.blue;
alpha            2147 magick/effect.c                 qixel.index+=(*k)*alpha*GetPixelIndex(indexes);
alpha            2149 magick/effect.c             gamma+=(*k)*alpha;
alpha            3478 magick/effect.c             alpha,
alpha            3481 magick/effect.c           alpha=1.0;
alpha            3489 magick/effect.c             alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(&pixel));
alpha            3490 magick/effect.c             qixel.red+=alpha*pixel.red;
alpha            3491 magick/effect.c             qixel.green+=alpha*pixel.green;
alpha            3492 magick/effect.c             qixel.blue+=alpha*pixel.blue;
alpha            3497 magick/effect.c                 qixel.index+=alpha*(*indexes);
alpha            3499 magick/effect.c             gamma+=alpha;
alpha            3877 magick/effect.c             alpha;
alpha            3886 magick/effect.c                   alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(p+u+j));
alpha            3887 magick/effect.c                   pixel.red+=(*k)*alpha*GetPixelRed(p+u+j);
alpha            3888 magick/effect.c                   pixel.green+=(*k)*alpha*GetPixelGreen(p+u+j);
alpha            3889 magick/effect.c                   pixel.blue+=(*k)*alpha*GetPixelBlue(p+u+j);
alpha            3891 magick/effect.c                   gamma+=(*k)*alpha;
alpha            3935 magick/effect.c                       alpha=(MagickRealType) (QuantumScale*
alpha            3937 magick/effect.c                       pixel.index+=(*k)*alpha*GetPixelIndex(indexes+x+u+j);
alpha             287 magick/enhance.c     alpha,
alpha             302 magick/enhance.c   alpha=contrast;
alpha             303 magick/enhance.c   slope=tan((double) (MagickPI*(alpha/100.0+1.0)/4.0));
alpha            1244 magick/fx.c    static MagickOffsetType FxGCD(MagickOffsetType alpha,MagickOffsetType beta)
alpha            1247 magick/fx.c        return(FxGCD(beta,alpha % beta));
alpha            1248 magick/fx.c      return(alpha);
alpha            1292 magick/fx.c        alpha,
alpha            1354 magick/fx.c                  alpha=FxEvaluateSubexpression(fx_info,channel,x,y,subexpression,
alpha            1356 magick/fx.c                  i=(ssize_t) (alpha+0.5);
alpha            1383 magick/fx.c                  alpha=FxEvaluateSubexpression(fx_info,channel,x,y,subexpression,
alpha            1385 magick/fx.c                  point.x=alpha;
alpha            1408 magick/fx.c                    alpha=FxEvaluateSubexpression(fx_info,channel,x,y,subexpression,
alpha            1410 magick/fx.c                    point.x+=alpha;
alpha            1489 magick/fx.c                alpha;
alpha            1493 magick/fx.c              alpha=(double) (QuantumScale*GetPixelAlpha(&pixel));
alpha            1494 magick/fx.c              return(alpha);
alpha            2121 magick/fx.c        alpha,
alpha            2140 magick/fx.c          alpha=FxEvaluateSubexpression(fx_info,channel,x,y,subexpression,depth,
alpha            2159 magick/fx.c              *beta=pow((double) alpha,(double) FxEvaluateSubexpression(fx_info,
alpha            2168 magick/fx.c              return(alpha*(*beta));
alpha            2180 magick/fx.c              return(alpha/(*beta));
alpha            2193 magick/fx.c              return(fmod((double) alpha,(double) *beta));
alpha            2199 magick/fx.c              return(alpha+(*beta));
alpha            2205 magick/fx.c              return(alpha-(*beta));
alpha            2211 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) << (size_t) (gamma+0.5));
alpha            2218 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) >> (size_t) (gamma+0.5));
alpha            2225 magick/fx.c              return(alpha < *beta ? 1.0 : 0.0);
alpha            2231 magick/fx.c              return(alpha <= *beta ? 1.0 : 0.0);
alpha            2237 magick/fx.c              return(alpha > *beta ? 1.0 : 0.0);
alpha            2243 magick/fx.c              return(alpha >= *beta ? 1.0 : 0.0);
alpha            2249 magick/fx.c              return(fabs(alpha-(*beta)) < MagickEpsilon ? 1.0 : 0.0);
alpha            2255 magick/fx.c              return(fabs(alpha-(*beta)) >= MagickEpsilon ? 1.0 : 0.0);
alpha            2261 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) & (size_t) (gamma+0.5));
alpha            2268 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) | (size_t) (gamma+0.5));
alpha            2274 magick/fx.c              if (alpha <= 0.0)
alpha            2287 magick/fx.c              if (alpha > 0.0) 
alpha            2311 magick/fx.c              if (fabs((double) alpha) >= MagickEpsilon)
alpha            2347 magick/fx.c              return(alpha);
alpha            2357 magick/fx.c              gamma=alpha*FxEvaluateSubexpression(fx_info,channel,x,y,p,depth,beta,
alpha            2401 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2403 magick/fx.c              return(fabs((double) alpha));
alpha            2408 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2410 magick/fx.c              return(acosh((double) alpha));
alpha            2415 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2417 magick/fx.c              return(acos((double) alpha));
alpha            2422 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2424 magick/fx.c              if (alpha == 0.0)
alpha            2426 magick/fx.c              gamma=2.0*j1((double) (MagickPI*alpha))/(MagickPI*alpha);
alpha            2433 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2435 magick/fx.c              return(asinh((double) alpha));
alpha            2440 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2442 magick/fx.c              return(asin((double) alpha));
alpha            2446 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2448 magick/fx.c              return(((ssize_t) alpha) & 0x01 ? -1.0 : 1.0);
alpha            2452 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2454 magick/fx.c              return(atan2((double) alpha,(double) *beta));
alpha            2459 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2461 magick/fx.c              return(atanh((double) alpha));
alpha            2466 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2468 magick/fx.c              return(atan((double) alpha));
alpha            2486 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2488 magick/fx.c              return(ceil((double) alpha));
alpha            2492 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2494 magick/fx.c              if (alpha < 0.0)
alpha            2496 magick/fx.c              if (alpha > 1.0)
alpha            2498 magick/fx.c              return(alpha);
alpha            2502 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,             beta,exception);
alpha            2503 magick/fx.c              return(cosh((double) alpha));
alpha            2507 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2509 magick/fx.c              return(cos((double) alpha));
alpha            2523 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2551 magick/fx.c                   (double) alpha);
alpha            2556 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2558 magick/fx.c              return((alpha/(*beta*(alpha-1.0)+1.0)));
alpha            2569 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2571 magick/fx.c              return(exp((double) alpha));
alpha            2582 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2584 magick/fx.c              return(floor((double) alpha));
alpha            2593 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2595 magick/fx.c              gamma=exp((double) (-alpha*alpha/2.0))/sqrt(2.0*MagickPI);
alpha            2603 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2605 magick/fx.c              gcd=FxGCD((MagickOffsetType) (alpha+0.5),(MagickOffsetType)
alpha            2622 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2624 magick/fx.c              return(hypot((double) alpha,(double) *beta));
alpha            2642 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2644 magick/fx.c              return(floor(alpha));
alpha            2648 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2650 magick/fx.c              return((double) !!IsNaN((double) alpha));
alpha            2664 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+2,depth,
alpha            2666 magick/fx.c              return(j0((double) alpha));
alpha            2672 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+2,depth,             beta,exception);
alpha            2673 magick/fx.c              return(j1((double) alpha));
alpha            2679 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2681 magick/fx.c              if (alpha == 0.0)
alpha            2683 magick/fx.c              gamma=(2.0*j1((double) (MagickPI*alpha))/(MagickPI*alpha));
alpha            2694 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+2,depth,
alpha            2696 magick/fx.c              return(log((double) alpha));
alpha            2700 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+6,depth,
alpha            2702 magick/fx.c              return(log10((double) alpha))/log10(2.0);
alpha            2706 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2708 magick/fx.c              return(log10((double) alpha));
alpha            2723 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2725 magick/fx.c              return(alpha > *beta ? alpha : *beta);
alpha            2731 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2733 magick/fx.c              return(alpha < *beta ? alpha : *beta);
alpha            2737 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2739 magick/fx.c              gamma=alpha-floor((double) (alpha/(*beta)))*(*beta);
alpha            2751 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2753 magick/fx.c              return((double) (alpha < MagickEpsilon));
alpha            2777 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2779 magick/fx.c              return(pow((double) alpha,(double) *beta));
alpha            2800 magick/fx.c                alpha;
alpha            2805 magick/fx.c              alpha=GetPseudoRandomValue(fx_info->random_info);
alpha            2806 magick/fx.c              return(alpha);
alpha            2810 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2812 magick/fx.c              return(floor((double) alpha+0.5));
alpha            2825 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2827 magick/fx.c              return(alpha < 0.0 ? -1.0 : 1.0);
alpha            2831 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2833 magick/fx.c              if (alpha == 0)
alpha            2835 magick/fx.c              gamma=(sin((double) (MagickPI*alpha))/(MagickPI*alpha));
alpha            2840 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2842 magick/fx.c              return(sinh((double) alpha));
alpha            2846 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2848 magick/fx.c              return(sin((double) alpha));
alpha            2852 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2854 magick/fx.c              return(sqrt((double) alpha));
alpha            2858 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+6,depth,
alpha            2860 magick/fx.c              return((1.0/(1.0+exp((double) (-alpha)))));
alpha            2871 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+4,depth,
alpha            2873 magick/fx.c              return(tanh((double) alpha));
alpha            2877 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+3,depth,
alpha            2879 magick/fx.c              return(tan((double) alpha));
alpha            2885 magick/fx.c              alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,depth,
alpha            2887 magick/fx.c              if (alpha >= 0.0)
alpha            2888 magick/fx.c                return(floor((double) alpha));
alpha            2889 magick/fx.c              return(ceil((double) alpha));
alpha            2916 magick/fx.c                alpha=FxEvaluateSubexpression(fx_info,channel,x,y,expression+5,
alpha            2918 magick/fx.c              } while (fabs((double) alpha) >= MagickEpsilon);
alpha            2943 magick/fx.c      alpha=InterpretSiPrefixValue(expression,&q);
alpha            2946 magick/fx.c      return(alpha);
alpha            2950 magick/fx.c      double *alpha,ExceptionInfo *exception)
alpha            2955 magick/fx.c      status=FxEvaluateChannelExpression(fx_info,GrayChannel,0,0,alpha,exception);
alpha            2960 magick/fx.c      double *alpha,ExceptionInfo *exception)
alpha            2970 magick/fx.c      status=FxEvaluateChannelExpression(fx_info,GrayChannel,0,0,alpha,exception);
alpha            2976 magick/fx.c      const ChannelType channel,const ssize_t x,const ssize_t y,double *alpha,
alpha            2987 magick/fx.c      *alpha=FxEvaluateSubexpression(fx_info,channel,x,y,fx_info->expression,&depth,
alpha            3044 magick/fx.c        alpha;
alpha            3076 magick/fx.c        status=FxPreprocessExpression(fx_info[i],&alpha,exception);
alpha            3155 magick/fx.c          alpha;
alpha            3175 magick/fx.c        alpha=0.0;
alpha            3181 magick/fx.c                &alpha,exception);
alpha            3182 magick/fx.c              SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*alpha));
alpha            3187 magick/fx.c                &alpha,exception);
alpha            3188 magick/fx.c              SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*alpha));
alpha            3193 magick/fx.c                &alpha,exception);
alpha            3194 magick/fx.c              SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*alpha));
alpha            3199 magick/fx.c                &alpha,exception);
alpha            3202 magick/fx.c                  alpha));
alpha            3205 magick/fx.c                  QuantumRange*alpha)));
alpha            3211 magick/fx.c                &alpha,exception);
alpha            3213 magick/fx.c                QuantumRange*alpha));
alpha            3469 magick/fx.c        alpha,
alpha            3545 magick/fx.c          alpha=1.0-beta;
alpha            3546 magick/fx.c          morph_image=ResizeImage(next,(size_t) (alpha*next->columns+beta*
alpha            3547 magick/fx.c            GetNextImageInList(next)->columns+0.5),(size_t) (alpha*
alpha            3604 magick/fx.c              SetPixelRed(q,ClampToQuantum(alpha*
alpha            3606 magick/fx.c              SetPixelGreen(q,ClampToQuantum(alpha*
alpha            3608 magick/fx.c              SetPixelBlue(q,ClampToQuantum(alpha*
alpha            3610 magick/fx.c              SetPixelOpacity(q,ClampToQuantum(alpha*
alpha            4782 magick/fx.c    #define GetBit(alpha,i) ((((size_t) (alpha) >> (size_t) (i)) & 0x01) != 0)
alpha            4783 magick/fx.c    #define SetBit(alpha,i,set) (alpha)=(Quantum) ((set) != 0 ? (size_t) (alpha) \
alpha            4784 magick/fx.c      | (one << (size_t) (i)) : (size_t) (alpha) & ~(one << (size_t) (i)))
alpha              68 magick/gem-private.h     alpha;
alpha              77 magick/gem-private.h   alpha=PerceptibleReciprocal(X+15.0*Y+3.0*Z);
alpha              78 magick/gem-private.h   *u=13.0*(*L)*((4.0*alpha*X)-(4.0*D65X/(D65X+15.0*D65Y+3.0*D65Z)));
alpha              79 magick/gem-private.h   *v=13.0*(*L)*((9.0*alpha*Y)-(9.0*D65Y/(D65X+15.0*D65Y+3.0*D65Z)));
alpha            1074 magick/gem.c       alpha,
alpha            1092 magick/gem.c     alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
alpha            1094 magick/gem.c     *hue=atan2(beta,alpha)*(180.0/MagickPI)/360.0;
alpha            1500 magick/gem.c       alpha,
alpha            1505 magick/gem.c     alpha=GetPseudoRandomValue(random_info);
alpha            1511 magick/gem.c         noise=(double) (pixel+QuantumRange*SigmaUniform*(alpha-0.5));
alpha            1520 magick/gem.c         if (alpha == 0.0)
alpha            1521 magick/gem.c           alpha=1.0;
alpha            1523 magick/gem.c         gamma=sqrt(-2.0*log(alpha));
alpha            1532 magick/gem.c         if (alpha < (SigmaImpulse/2.0))
alpha            1535 magick/gem.c           if (alpha >= (1.0-(SigmaImpulse/2.0)))
alpha            1543 magick/gem.c         if (alpha <= 0.5)
alpha            1545 magick/gem.c             if (alpha <= MagickEpsilon)
alpha            1548 magick/gem.c               noise=(double) (pixel+QuantumRange*SigmaLaplacian*log(2.0*alpha)+
alpha            1552 magick/gem.c         beta=1.0-alpha;
alpha            1562 magick/gem.c         if (alpha > MagickEpsilon)
alpha            1563 magick/gem.c           sigma=sqrt(-2.0*log(alpha));
alpha            1578 magick/gem.c         for (i=0; alpha > poisson; i++)
alpha            1581 magick/gem.c           alpha*=beta;
alpha            1588 magick/gem.c         noise=(double) (QuantumRange*SigmaRandom*alpha);
alpha            1626 magick/gem.c       alpha,
alpha            1647 magick/gem.c     alpha=PerceptibleReciprocal(2.0*gamma*gamma);
alpha            1654 magick/gem.c         normalize+=exp(-((double) (i*i))*alpha)*beta;
alpha            1655 magick/gem.c       value=exp(-((double) (j*j))*alpha)*beta/normalize;
alpha            1667 magick/gem.c       alpha,
alpha            1687 magick/gem.c     alpha=PerceptibleReciprocal(2.0*gamma*gamma);
alpha            1695 magick/gem.c           normalize+=exp(-((double) (u*u+v*v))*alpha)*beta;
alpha            1696 magick/gem.c       value=exp(-((double) (j*j))*alpha)*beta/normalize;
alpha            1141 magick/morphology.c           alpha, beta;
alpha            1178 magick/morphology.c             alpha = 1.0/(2.0*sigma*sigma);
alpha            1182 magick/morphology.c                               exp(-((double)(u*u))*alpha)*beta;
alpha            1193 magick/morphology.c           { alpha = 1.0/(2.0*sigma*sigma);    /* simplify loop expressions */
alpha            1196 magick/morphology.c               kernel->values[i] = exp(-((double)(u*u))*alpha)*beta;
alpha            1314 magick/morphology.c               alpha = order_f / ( fact((size_t) v) * fact(kernel->height-v-1) );
alpha            1317 magick/morphology.c                 (alpha * order_f / ( fact((size_t) u) * fact(kernel->height-u-1) ));
alpha            2769 magick/morphology.c               alpha;  /* alpha weighting for colors : alpha  */
alpha            2778 magick/morphology.c               alpha=QuantumScale*(QuantumRange-GetPixelOpacity(k_pixels));
alpha            2780 magick/morphology.c               alpha*=(*k);    /* include kernel weighting now */
alpha            2781 magick/morphology.c               gamma += alpha; /* normalize alpha weights only */
alpha            2782 magick/morphology.c               result.red     += alpha*GetPixelRed(k_pixels);
alpha            2783 magick/morphology.c               result.green   += alpha*GetPixelGreen(k_pixels);
alpha            2784 magick/morphology.c               result.blue    += alpha*GetPixelBlue(k_pixels);
alpha            2787 magick/morphology.c                 result.index += alpha*(*k_indexes);
alpha            3014 magick/morphology.c                   alpha,  /* alpha weighting for colors : alpha  */
alpha            3025 magick/morphology.c                     alpha=QuantumScale*(QuantumRange-k_pixels[u].opacity);
alpha            3027 magick/morphology.c                     alpha*=(*k);  /* include kernel weighting now */
alpha            3028 magick/morphology.c                     gamma += alpha;    /* normalize alpha weights only */
alpha            3029 magick/morphology.c                     result.red     += alpha*k_pixels[u].red;
alpha            3030 magick/morphology.c                     result.green   += alpha*k_pixels[u].green;
alpha            3031 magick/morphology.c                     result.blue    += alpha*k_pixels[u].blue;
alpha            3034 magick/morphology.c                       result.index+=alpha*GetPixelIndex(k_indexes+u);
alpha              41 magick/pixel-private.h       alpha,
alpha              44 magick/pixel-private.h     alpha=GetPixelRed(pixel)-(double) GetPixelGreen(pixel);
alpha              46 magick/pixel-private.h     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
alpha              64 magick/pixel-private.h       alpha,
alpha              67 magick/pixel-private.h     alpha=GetPixelRed(pixel)-(double) GetPixelGreen(pixel);
alpha              71 magick/pixel-private.h         (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
alpha            4336 magick/pixel.c   MagickRealType *alpha)
alpha            4340 magick/pixel.c       *alpha=1.0;
alpha            4352 magick/pixel.c   *alpha=QuantumScale*GetPixelAlpha(color);
alpha            4353 magick/pixel.c   pixel->red=(*alpha*GetPixelRed(color));
alpha            4354 magick/pixel.c   pixel->green=(*alpha*GetPixelGreen(color));
alpha            4355 magick/pixel.c   pixel->blue=(*alpha*GetPixelBlue(color));
alpha            4361 magick/pixel.c     pixel->index=(*alpha*GetPixelIndex(indexes));
alpha            4376 magick/pixel.c     alpha,
alpha            4380 magick/pixel.c   alpha=(MagickRealType) 1.0-x;
alpha            4381 magick/pixel.c   beta=(MagickRealType) (-0.5)*x*alpha;
alpha            4382 magick/pixel.c   (*weights)[0]=alpha*beta;
alpha            4389 magick/pixel.c   (*weights)[1]=alpha-(*weights)[0]+gamma;
alpha            4404 magick/pixel.c     alpha,
alpha            4407 magick/pixel.c   alpha=(MagickRealType) 1.0-x;
alpha            4409 magick/pixel.c   (*weights)[0]=(MagickRealType) (1.0/6.0)*alpha*alpha*alpha;
alpha            4411 magick/pixel.c   (*weights)[1]=alpha-(*weights)[0]+beta;
alpha            4436 magick/pixel.c     alpha[16];
alpha            4503 magick/pixel.c         AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels,alpha);
alpha            4504 magick/pixel.c         gamma=PerceptibleReciprocal(alpha[0]);
alpha            4545 magick/pixel.c         AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
alpha            4551 magick/pixel.c       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
alpha            4552 magick/pixel.c         (epsilon.x*alpha[2]+delta.x*alpha[3])));
alpha            4585 magick/pixel.c         AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
alpha            4592 magick/pixel.c             alpha[i]=alpha[i+2];
alpha            4599 magick/pixel.c               alpha[i]+=alpha[i+2];  /* add up alpha weights */
alpha            4609 magick/pixel.c           alpha[0]=alpha[1];
alpha            4616 magick/pixel.c             alpha[0]+=alpha[1];  /* add up alpha weights */
alpha            4624 magick/pixel.c       alpha[0]=PerceptibleReciprocal(alpha[0]);  /* 1/sum(alpha) */
alpha            4625 magick/pixel.c       pixel->red=alpha[0]*pixels[0].red;
alpha            4626 magick/pixel.c       pixel->green=alpha[0]*pixels[0].green;  /* divide by sum of alpha */
alpha            4627 magick/pixel.c       pixel->blue=alpha[0]*pixels[0].blue;
alpha            4628 magick/pixel.c       pixel->index=alpha[0]*pixels[0].index;
alpha            4650 magick/pixel.c         AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
alpha            4753 magick/pixel.c         AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
alpha            4770 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
alpha            4791 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
alpha            4817 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
alpha            4839 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
alpha            4887 magick/pixel.c         AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
alpha            2052 magick/property.c     alpha;
alpha            2119 magick/property.c           status=FxEvaluateChannelExpression(fx_info,DefaultChannels,0,0,&alpha,
alpha            2128 magick/property.c                 GetMagickPrecision(),(double) alpha);
alpha            2161 magick/property.c           status=FxEvaluateChannelExpression(fx_info,RedChannel,0,0,&alpha,
alpha            2163 magick/property.c           pixel.red=(MagickRealType) QuantumRange*alpha;
alpha            2164 magick/property.c           status&=FxEvaluateChannelExpression(fx_info,GreenChannel,0,0,&alpha,
alpha            2166 magick/property.c           pixel.green=(MagickRealType) QuantumRange*alpha;
alpha            2167 magick/property.c           status&=FxEvaluateChannelExpression(fx_info,BlueChannel,0,0,&alpha,
alpha            2169 magick/property.c           pixel.blue=(MagickRealType) QuantumRange*alpha;
alpha            2170 magick/property.c           status&=FxEvaluateChannelExpression(fx_info,OpacityChannel,0,0,&alpha,
alpha            2172 magick/property.c           pixel.opacity=(MagickRealType) QuantumRange*(1.0-alpha);
alpha            2176 magick/property.c                 &alpha,exception);
alpha            2177 magick/property.c               pixel.index=(MagickRealType) QuantumRange*alpha;
alpha             429 magick/quantize.c     alpha;
alpha             440 magick/quantize.c   alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetPixelOpacity(pixel)));
alpha             441 magick/quantize.c   alpha_pixel->red=alpha*GetPixelRed(pixel);
alpha             442 magick/quantize.c   alpha_pixel->green=alpha*GetPixelGreen(pixel);
alpha             443 magick/quantize.c   alpha_pixel->blue=alpha*GetPixelBlue(pixel);
alpha            1075 magick/quantize.c         alpha,
alpha            1087 magick/quantize.c       alpha=1.0;
alpha            1091 magick/quantize.c           alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(p));
alpha            1094 magick/quantize.c       pixel=alpha*GetPixelRed(p)-beta*GetPixelRed(q);
alpha            1098 magick/quantize.c           pixel=alpha*GetPixelGreen(p)-beta*GetPixelGreen(q);
alpha            1102 magick/quantize.c               pixel=alpha*GetPixelBlue(p)-beta*GetPixelBlue(q);
alpha            1212 magick/quantize.c         alpha;
alpha            1221 magick/quantize.c       alpha=(MagickRealType) ((MagickOffsetType) node_info->number_unique);
alpha            1222 magick/quantize.c       alpha=PerceptibleReciprocal(alpha);
alpha            1225 magick/quantize.c           SetPixelRed(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1227 magick/quantize.c           SetPixelGreen(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1229 magick/quantize.c           SetPixelBlue(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1238 magick/quantize.c           opacity=(MagickRealType) (alpha*QuantumRange*
alpha            1243 magick/quantize.c               SetPixelRed(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1245 magick/quantize.c               SetPixelGreen(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1247 magick/quantize.c               SetPixelBlue(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1257 magick/quantize.c               SetPixelRed(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1259 magick/quantize.c               SetPixelGreen(q,ClampToQuantum((MagickRealType) (alpha*
alpha            1261 magick/quantize.c               SetPixelBlue(q,ClampToQuantum((MagickRealType) (alpha*
alpha            2109 magick/quantize.c     alpha,
alpha            2131 magick/quantize.c   alpha=1.0;
alpha            2156 magick/quantize.c           alpha=(MagickRealType) (QuantumScale*(GetPixelAlpha(p)));
alpha            2160 magick/quantize.c       distance=fabs((double) (alpha*GetPixelRed(p)-beta*
alpha            2166 magick/quantize.c       distance=fabs((double) (alpha*GetPixelGreen(p)-beta*
alpha            2172 magick/quantize.c       distance=fabs((double) (alpha*GetPixelBlue(p)-beta*
alpha            3819 magick/quantum-export.c     alpha;
alpha            3872 magick/quantum-export.c         alpha=QuantumScale*GetPixelAlpha(q);
alpha            3873 magick/quantum-export.c         SetPixelRed(q,ClampToQuantum(alpha*GetPixelRed(q)));
alpha            3874 magick/quantum-export.c         SetPixelGreen(q,ClampToQuantum(alpha*GetPixelGreen(q)));
alpha            3875 magick/quantum-export.c         SetPixelBlue(q,ClampToQuantum(alpha*GetPixelBlue(q)));
alpha            4187 magick/quantum-import.c         alpha;
alpha            4201 magick/quantum-import.c         alpha=QuantumScale*GetPixelAlpha(q);
alpha            4202 magick/quantum-import.c         alpha=PerceptibleReciprocal(alpha);
alpha            4203 magick/quantum-import.c         SetPixelRed(q,ClampToQuantum(alpha*GetPixelRed(q)));
alpha            4204 magick/quantum-import.c         SetPixelGreen(q,ClampToQuantum(alpha*GetPixelGreen(q)));
alpha            4205 magick/quantum-import.c         SetPixelBlue(q,ClampToQuantum(alpha*GetPixelBlue(q)));
alpha            4207 magick/quantum-import.c           SetPixelBlack(indexes+x,ClampToQuantum(alpha*GetPixelBlack(
alpha             636 magick/quantum-private.h         alpha;
alpha             644 magick/quantum-private.h       alpha=1.0e10;
alpha             646 magick/quantum-private.h         alpha*=alpha;
alpha             618 magick/random.c     alpha;
alpha             623 magick/random.c     alpha=(unsigned long) (seed[1] ^ (seed[1] << 11));
alpha             627 magick/random.c     seed[0]=(seed[0] ^ (seed[0] >> 19)) ^ (alpha ^ (alpha >> 8));
alpha            1143 magick/resample.c   { double alpha, beta, gamma, Major, Minor;
alpha            1146 magick/resample.c     alpha = A+C;
alpha            1150 magick/resample.c     if ( alpha - gamma <= MagickEpsilon )
alpha            1153 magick/resample.c       Major= sqrt(2*F/(alpha - gamma));
alpha            1154 magick/resample.c     Minor = sqrt(2*F/(alpha + gamma));
alpha             412 magick/resize.c       const MagickRealType alpha=(MagickRealType) (MagickPI*x);
alpha             413 magick/resize.c       return(sin((double) alpha)/alpha);
alpha             449 magick/resize.c       const MagickRealType alpha=(MagickRealType) (MagickPI*x);
alpha             450 magick/resize.c       return(sin((double) alpha)/alpha);
alpha            2557 magick/resize.c         alpha;
alpha            2572 magick/resize.c             alpha=contribution[i].weight;
alpha            2573 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
alpha            2574 magick/resize.c             pixel.green+=alpha*GetPixelGreen(p+j);
alpha            2575 magick/resize.c             pixel.blue+=alpha*GetPixelBlue(p+j);
alpha            2576 magick/resize.c             pixel.opacity+=alpha*GetPixelOpacity(p+j);
alpha            2589 magick/resize.c                 alpha=contribution[i].weight;
alpha            2590 magick/resize.c                 pixel.index+=alpha*GetPixelIndex(indexes+j);
alpha            2605 magick/resize.c             alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
alpha            2606 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
alpha            2607 magick/resize.c             pixel.green+=alpha*GetPixelGreen(p+j);
alpha            2608 magick/resize.c             pixel.blue+=alpha*GetPixelBlue(p+j);
alpha            2610 magick/resize.c             gamma+=alpha;
alpha            2624 magick/resize.c                 alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
alpha            2625 magick/resize.c                 pixel.index+=alpha*GetPixelIndex(indexes+j);
alpha            2803 magick/resize.c         alpha;
alpha            2818 magick/resize.c             alpha=contribution[i].weight;
alpha            2819 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
alpha            2820 magick/resize.c             pixel.green+=alpha*GetPixelGreen(p+j);
alpha            2821 magick/resize.c             pixel.blue+=alpha*GetPixelBlue(p+j);
alpha            2822 magick/resize.c             pixel.opacity+=alpha*GetPixelOpacity(p+j);
alpha            2835 magick/resize.c                 alpha=contribution[i].weight;
alpha            2836 magick/resize.c                 pixel.index+=alpha*GetPixelIndex(indexes+j);
alpha            2851 magick/resize.c             alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
alpha            2852 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
alpha            2853 magick/resize.c             pixel.green+=alpha*GetPixelGreen(p+j);
alpha            2854 magick/resize.c             pixel.blue+=alpha*GetPixelBlue(p+j);
alpha            2856 magick/resize.c             gamma+=alpha;
alpha            2870 magick/resize.c                 alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
alpha            2871 magick/resize.c                 pixel.index+=alpha*GetPixelIndex(indexes+j);
alpha            3273 magick/resize.c     alpha;
alpha            3374 magick/resize.c     alpha=1.0;
alpha            3392 magick/resize.c             alpha=QuantumScale*GetPixelAlpha(p);
alpha            3393 magick/resize.c           x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
alpha            3394 magick/resize.c           x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
alpha            3395 magick/resize.c           x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(p));
alpha            3399 magick/resize.c             x_vector[x].index=(MagickRealType) (alpha*GetPixelIndex(indexes+x));
alpha            3427 magick/resize.c                   alpha=QuantumScale*GetPixelAlpha(p);
alpha            3428 magick/resize.c                 x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
alpha            3429 magick/resize.c                 x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
alpha            3430 magick/resize.c                 x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(p));
alpha            3434 magick/resize.c                   x_vector[x].index=(MagickRealType) (alpha*
alpha            3470 magick/resize.c                 alpha=QuantumScale*GetPixelAlpha(p);
alpha            3471 magick/resize.c               x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
alpha            3472 magick/resize.c               x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
alpha            3473 magick/resize.c               x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(p));
alpha            3477 magick/resize.c                 x_vector[x].index=(MagickRealType) (alpha*
alpha            3521 magick/resize.c             alpha=QuantumScale*GetPixelAlpha(s);
alpha            3522 magick/resize.c           alpha=PerceptibleReciprocal(alpha);
alpha            3523 magick/resize.c           SetPixelRed(q,ClampToQuantum(alpha*s->red));
alpha            3524 magick/resize.c           SetPixelGreen(q,ClampToQuantum(alpha*s->green));
alpha            3525 magick/resize.c           SetPixelBlue(q,ClampToQuantum(alpha*s->blue));
alpha            3529 magick/resize.c             SetPixelIndex(scale_indexes+x,ClampToQuantum(alpha*s->index));
alpha            3620 magick/resize.c           alpha=QuantumScale*GetPixelAlpha(t);
alpha            3621 magick/resize.c         alpha=PerceptibleReciprocal(alpha);
alpha            3622 magick/resize.c         SetPixelRed(q,ClampToQuantum(alpha*t->red));
alpha            3623 magick/resize.c         SetPixelGreen(q,ClampToQuantum(alpha*t->green));
alpha            3624 magick/resize.c         SetPixelBlue(q,ClampToQuantum(alpha*t->blue));
alpha            3628 magick/resize.c           SetPixelIndex(scale_indexes+x,ClampToQuantum(alpha*t->index));
alpha            1702 magick/segment.c     alpha,
alpha            1714 magick/segment.c   alpha=1.0/(tau*sqrt(2.0*MagickPI));
alpha            1729 magick/segment.c     scale_histogram[x]=(MagickRealType) (alpha*sum);
alpha             476 magick/version.c         alpha;
alpha             483 magick/version.c         alpha=i;
alpha             485 magick/version.c           alpha=(alpha & 0x01) ? (0xEDB88320 ^ (alpha >> 1)) : (alpha >> 1);
alpha             486 magick/version.c         crc_xor[i]=alpha;
alpha             282 tests/validate.c     alpha;
alpha             288 tests/validate.c   alpha=PerceptibleReciprocal(X+15.0*Y+3.0*Z);
alpha             289 tests/validate.c   *u=13.0*(*L)*((4.0*alpha*X)-(4.0*D65X/(D65X+15.0*D65Y+3.0*D65Z)));
alpha             290 tests/validate.c   *v=13.0*(*L)*((9.0*alpha*Y)-(9.0*D65Y/(D65X+15.0*D65Y+3.0*D65Z)));
alpha            1641 wand/deprecate.c   const double alpha,const double fuzz,const PixelWand *bordercolor,
alpha            1666 wand/deprecate.c     (MagickRealType) QuantumRange-QuantumRange*alpha),x,y,bordercolor !=
alpha            2040 wand/deprecate.c   const PixelWand *target,const double alpha,const double fuzz)
alpha            2042 wand/deprecate.c   return(MagickTransparentPaintImage(wand,target,alpha,fuzz,MagickFalse));
alpha            2375 wand/deprecate.c   const PixelWand *target,const double alpha,const double fuzz)
alpha            2377 wand/deprecate.c   return(MagickPaintTransparentImage(wand,target,alpha,fuzz));
alpha            1399 wand/drawing-wand.c     alpha;
alpha            1405 wand/drawing-wand.c   alpha=(double) QuantumScale*(QuantumRange-CurrentContext->fill.opacity);
alpha            1406 wand/drawing-wand.c   return(alpha);
alpha            1744 wand/drawing-wand.c     alpha;
alpha            1750 wand/drawing-wand.c   alpha=(double) QuantumScale*(QuantumRange-CurrentContext->opacity);
alpha            1751 wand/drawing-wand.c   return(alpha);
alpha            2053 wand/drawing-wand.c     alpha;
alpha            2059 wand/drawing-wand.c   alpha=(double) QuantumScale*(QuantumRange-CurrentContext->stroke.opacity);
alpha            2060 wand/drawing-wand.c   return(alpha);
alpha            10815 wand/magick-image.c   const double alpha)
alpha            10827 wand/magick-image.c     QuantumRange-QuantumRange*alpha));
alpha            11654 wand/magick-image.c   const MagickBooleanType sharpen,const double alpha,const double beta)
alpha            11660 wand/magick-image.c     alpha,beta);
alpha            11666 wand/magick-image.c   const double alpha,const double beta)
alpha            11677 wand/magick-image.c   status=SigmoidalContrastImageChannel(wand->images,channel,sharpen,alpha,beta);
alpha            12700 wand/magick-image.c   const PixelWand *target,const double alpha,const double fuzz,
alpha            12718 wand/magick-image.c     (MagickRealType) QuantumRange-QuantumRange*alpha),invert);
alpha            1462 wand/pixel-wand.c WandExport void PixelSetAlpha(PixelWand *wand,const double alpha)
alpha            1469 wand/pixel-wand.c     ClampToQuantum((MagickRealType) QuantumRange*alpha));