Documentation Archive Developer
Search

Accelerate Changes for Objective-C

Accelerate

Alpha.h

Added vImagePremultipliedAlphaBlendDarken_RGBA8888()
Added vImagePremultipliedAlphaBlendLighten_RGBA8888()
Added vImagePremultipliedAlphaBlendMultiply_RGBA8888()
Added vImagePremultipliedAlphaBlendScreen_RGBA8888()

Convolution.h

Removed vImageGetMinimumTempBufferSizeForConvolution()
Modified vImageBoxConvolve_ARGB8888()
Declaration
From
vImage_Error vImageBoxConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    uint32_t kernel_height,
    uint32_t kernel_width,
    Pixel_8888 backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageBoxConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    uint32_t kernel_height,
    uint32_t kernel_width,
    const Pixel_8888 backgroundColor,
    vImage_Flags flags
);

Modified vImageConvolve_ARGB8888()
Declaration
From
vImage_Error vImageConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    int32_t divisor,
    Pixel_8888 backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    int32_t divisor,
    const Pixel_8888 backgroundColor,
    vImage_Flags flags
);

Modified vImageConvolve_ARGBFFFF()
Declaration
From
vImage_Error vImageConvolve_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    Pixel_FFFF backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageConvolve_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    const Pixel_FFFF backgroundColor,
    vImage_Flags flags
);

Modified vImageConvolveMultiKernel_ARGB8888()
Declaration
From
vImage_Error vImageConvolveMultiKernel_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernels[4],
    uint32_t kernel_height,
    uint32_t kernel_width,
    const int32_t divisors[4],
    const int32_t biases[4],
    Pixel_8888 backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageConvolveMultiKernel_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernels[4],
    uint32_t kernel_height,
    uint32_t kernel_width,
    const int32_t divisors[4],
    const int32_t biases[4],
    const Pixel_8888 backgroundColor,
    vImage_Flags flags
);

Modified vImageConvolveMultiKernel_ARGBFFFF()
Declaration
From
vImage_Error vImageConvolveMultiKernel_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernels[4],
    uint32_t kernel_height,
    uint32_t kernel_width,
    const float biases[4],
    Pixel_FFFF backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageConvolveMultiKernel_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernels[4],
    uint32_t kernel_height,
    uint32_t kernel_width,
    const float biases[4],
    const Pixel_FFFF backgroundColor,
    vImage_Flags flags
);

Modified vImageConvolveWithBias_ARGB8888()
Declaration
From
vImage_Error vImageConvolveWithBias_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    int32_t divisor,
    int32_t bias,
    Pixel_8888 backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageConvolveWithBias_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    int32_t divisor,
    int32_t bias,
    const Pixel_8888 backgroundColor,
    vImage_Flags flags
);

Modified vImageConvolveWithBias_ARGBFFFF()
Declaration
From
vImage_Error vImageConvolveWithBias_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    float bias,
    Pixel_FFFF backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageConvolveWithBias_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernel,
    uint32_t kernel_height,
    uint32_t kernel_width,
    float bias,
    const Pixel_FFFF backgroundColor,
    vImage_Flags flags
);

Modified vImageRichardsonLucyDeConvolve_ARGB8888()
Declaration
From
vImage_Error vImageRichardsonLucyDeConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernel,
    const int16_t *kernel2,
    uint32_t kernel_height,
    uint32_t kernel_width,
    uint32_t kernel_height2,
    uint32_t kernel_width2,
    int32_t divisor,
    int32_t divisor2,
    Pixel_8888 backgroundColor,
    uint32_t iterationCount,
    vImage_Flags flags
);
To
vImage_Error vImageRichardsonLucyDeConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const int16_t *kernel,
    const int16_t *kernel2,
    uint32_t kernel_height,
    uint32_t kernel_width,
    uint32_t kernel_height2,
    uint32_t kernel_width2,
    int32_t divisor,
    int32_t divisor2,
    const Pixel_8888 backgroundColor,
    uint32_t iterationCount,
    vImage_Flags flags
);

Modified vImageRichardsonLucyDeConvolve_ARGBFFFF()
Declaration
From
vImage_Error vImageRichardsonLucyDeConvolve_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernel,
    const float *kernel2,
    uint32_t kernel_height,
    uint32_t kernel_width,
    uint32_t kernel_height2,
    uint32_t kernel_width2,
    Pixel_FFFF backgroundColor,
    uint32_t iterationCount,
    vImage_Flags flags
);
To
vImage_Error vImageRichardsonLucyDeConvolve_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    const float *kernel,
    const float *kernel2,
    uint32_t kernel_height,
    uint32_t kernel_width,
    uint32_t kernel_height2,
    uint32_t kernel_width2,
    const Pixel_FFFF backgroundColor,
    uint32_t iterationCount,
    vImage_Flags flags
);

Modified vImageTentConvolve_ARGB8888()
Declaration
From
vImage_Error vImageTentConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    uint32_t kernel_height,
    uint32_t kernel_width,
    Pixel_8888 backgroundColor,
    vImage_Flags flags
);
To
vImage_Error vImageTentConvolve_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    uint32_t kernel_height,
    uint32_t kernel_width,
    const Pixel_8888 backgroundColor,
    vImage_Flags flags
);

Geometry.h

Removed vImageGetMinimumGeometryTempBufferSize()
Modified vImageAffineWarp_ARGB16S()
Declaration
From
vImage_Error vImageAffineWarp_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarp_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageAffineWarp_ARGB16U()
Declaration
From
vImage_Error vImageAffineWarp_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarp_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageAffineWarp_ARGB8888()
Declaration
From
vImage_Error vImageAffineWarp_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarp_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageAffineWarp_ARGBFFFF()
Declaration
From
vImage_Error vImageAffineWarp_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarp_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform *transform,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpCG_ARGB16S()
Declaration
From
vImage_Error vImageAffineWarpCG_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpCG_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpCG_ARGB16U()
Declaration
From
vImage_Error vImageAffineWarpCG_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpCG_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpCG_ARGB8888()
Declaration
From
vImage_Error vImageAffineWarpCG_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpCG_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpCG_ARGBFFFF()
Declaration
From
vImage_Error vImageAffineWarpCG_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpCG_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_CGAffineTransform *transform,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpD_ARGB16S()
Declaration
From
vImage_Error vImageAffineWarpD_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpD_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpD_ARGB16U()
Declaration
From
vImage_Error vImageAffineWarpD_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpD_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpD_ARGB8888()
Declaration
From
vImage_Error vImageAffineWarpD_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpD_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageAffineWarpD_ARGBFFFF()
Declaration
From
vImage_Error vImageAffineWarpD_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageAffineWarpD_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    const vImage_AffineTransform_Double *transform,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShear_ARGB16S()
Declaration
From
vImage_Error vImageHorizontalShear_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShear_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShear_ARGB16U()
Declaration
From
vImage_Error vImageHorizontalShear_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShear_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShear_ARGB8888()
Declaration
From
vImage_Error vImageHorizontalShear_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShear_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShear_ARGBFFFF()
Declaration
From
vImage_Error vImageHorizontalShear_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShear_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float xTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShearD_ARGB16S()
Declaration
From
vImage_Error vImageHorizontalShearD_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShearD_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShearD_ARGB16U()
Declaration
From
vImage_Error vImageHorizontalShearD_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShearD_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShearD_ARGB8888()
Declaration
From
vImage_Error vImageHorizontalShearD_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShearD_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageHorizontalShearD_ARGBFFFF()
Declaration
From
vImage_Error vImageHorizontalShearD_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageHorizontalShearD_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double xTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageRotate_ARGB16S()
Declaration
From
vImage_Error vImageRotate_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageRotate_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageRotate_ARGB16U()
Declaration
From
vImage_Error vImageRotate_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageRotate_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageRotate_ARGB8888()
Declaration
From
vImage_Error vImageRotate_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageRotate_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageRotate_ARGBFFFF()
Declaration
From
vImage_Error vImageRotate_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageRotate_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    void *tempBuffer,
    float angleInRadians,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageVerticalShear_ARGB16S()
Declaration
From
vImage_Error vImageVerticalShear_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShear_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageVerticalShear_ARGB16U()
Declaration
From
vImage_Error vImageVerticalShear_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShear_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageVerticalShear_ARGB8888()
Declaration
From
vImage_Error vImageVerticalShear_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShear_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageVerticalShear_ARGBFFFF()
Declaration
From
vImage_Error vImageVerticalShear_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShear_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    float yTranslate,
    float shearSlope,
    ResamplingFilter filter,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Modified vImageVerticalShearD_ARGB16S()
Declaration
From
vImage_Error vImageVerticalShearD_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16S backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShearD_ARGB16S (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16S backColor,
    vImage_Flags flags
);

Modified vImageVerticalShearD_ARGB16U()
Declaration
From
vImage_Error vImageVerticalShearD_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_ARGB_16U backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShearD_ARGB16U (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_ARGB_16U backColor,
    vImage_Flags flags
);

Modified vImageVerticalShearD_ARGB8888()
Declaration
From
vImage_Error vImageVerticalShearD_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_8888 backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShearD_ARGB8888 (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_8888 backColor,
    vImage_Flags flags
);

Modified vImageVerticalShearD_ARGBFFFF()
Declaration
From
vImage_Error vImageVerticalShearD_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    Pixel_FFFF backColor,
    vImage_Flags flags
);
To
vImage_Error vImageVerticalShearD_ARGBFFFF (
    const vImage_Buffer *src,
    const vImage_Buffer *dest,
    vImagePixelCount srcOffsetToROI_X,
    vImagePixelCount srcOffsetToROI_Y,
    double yTranslate,
    double shearSlope,
    ResamplingFilter filter,
    const Pixel_FFFF backColor,
    vImage_Flags flags
);

Histogram.h

Removed vImageGetMinimumTempBufferSizeForHistogram()

LinearAlgebra/object.h

Modified OS_la_object
Protocols
From--
ToNSObject

Morphology.h

Removed vImageGetMinimumTempBufferSizeForMinMax()

Sparse/BLAS.h (Added)

Added sparse_commit()
Added sparse_elementwise_norm_double()
Added sparse_elementwise_norm_float()
Added sparse_extract_block_double()
Added sparse_extract_block_float()
Added sparse_extract_sparse_column_double()
Added sparse_extract_sparse_column_float()
Added sparse_extract_sparse_row_double()
Added sparse_extract_sparse_row_float()
Added sparse_get_block_dimension_for_col()
Added sparse_get_block_dimension_for_row()
Added sparse_get_matrix_nonzero_count()
Added sparse_get_matrix_nonzero_count_for_column()
Added sparse_get_matrix_nonzero_count_for_row()
Added sparse_get_matrix_number_of_columns()
Added sparse_get_matrix_number_of_rows()
Added sparse_get_matrix_property()
Added sparse_get_vector_nonzero_count_double()
Added sparse_get_vector_nonzero_count_float()
Added sparse_inner_product_dense_double()
Added sparse_inner_product_dense_float()
Added sparse_inner_product_sparse_double()
Added sparse_inner_product_sparse_float()
Added sparse_insert_block_double()
Added sparse_insert_block_float()
Added sparse_insert_col_double()
Added sparse_insert_col_float()
Added sparse_insert_entries_double()
Added sparse_insert_entries_float()
Added sparse_insert_entry_double()
Added sparse_insert_entry_float()
Added sparse_insert_row_double()
Added sparse_insert_row_float()
Added sparse_matrix_block_create_double()
Added sparse_matrix_block_create_float()
Added sparse_matrix_create_double()
Added sparse_matrix_create_float()
Added sparse_matrix_destroy()
Added sparse_matrix_product_dense_double()
Added sparse_matrix_product_dense_float()
Added sparse_matrix_trace_double()
Added sparse_matrix_trace_float()
Added sparse_matrix_triangular_solve_dense_double()
Added sparse_matrix_triangular_solve_dense_float()
Added sparse_matrix_variable_block_create_double()
Added sparse_matrix_variable_block_create_float()
Added sparse_matrix_vector_product_dense_double()
Added sparse_matrix_vector_product_dense_float()
Added sparse_operator_norm_double()
Added sparse_operator_norm_float()
Added sparse_outer_product_dense_double()
Added sparse_outer_product_dense_float()
Added sparse_pack_vector_double()
Added sparse_pack_vector_float()
Added sparse_permute_cols_double()
Added sparse_permute_cols_float()
Added sparse_permute_rows_double()
Added sparse_permute_rows_float()
Added sparse_set_matrix_property()
Added sparse_unpack_vector_double()
Added sparse_unpack_vector_float()
Added sparse_vector_add_with_scale_dense_double()
Added sparse_vector_add_with_scale_dense_float()
Added sparse_vector_norm_double()
Added sparse_vector_norm_float()
Added sparse_vector_triangular_solve_dense_double()
Added sparse_vector_triangular_solve_dense_float()

Sparse/Types.h (Added)

Added SPARSE_CANNOT_SET_PROPERTY
Added sparse_dimension
Added SPARSE_ILLEGAL_PARAMETER
Added sparse_index
Added SPARSE_LOWER_SYMMETRIC
Added SPARSE_LOWER_TRIANGULAR
Added sparse_matrix_double
Added sparse_matrix_float
Added sparse_matrix_property
Added sparse_norm
Added SPARSE_NORM_INF
Added SPARSE_NORM_ONE
Added SPARSE_NORM_R1
Added SPARSE_NORM_TWO
Added sparse_status
Added sparse_stride
Added SPARSE_SUCCESS
Added SPARSE_SYSTEM_ERROR
Added SPARSE_UPPER_SYMMETRIC
Added SPARSE_UPPER_TRIANGULAR

Transform.h

Added vImageMatrixMultiply_ARGB8888ToPlanar8()
Added vImageMatrixMultiply_ARGBFFFFToPlanarF()
Added vImageSymmetricPiecewisePolynomial_PlanarF()
Modified vImageMultidimensionalTable_Create()
Declaration
From
vImage_MultidimensionalTable vImageMultidimensionalTable_Create (
    const uint16_t *tableData,
    uint32_t numSrcChannels,
    uint32_t numDestChannels,
    uint8_t table_entries_per_dimension[],
    vImageMDTableUsageHint hint,
    vImage_Flags flags,
    vImage_Error *err
);
To
vImage_MultidimensionalTable vImageMultidimensionalTable_Create (
    const uint16_t *tableData,
    uint32_t numSrcChannels,
    uint32_t numDestChannels,
    const uint8_t table_entries_per_dimension[],
    vImageMDTableUsageHint hint,
    vImage_Flags flags,
    vImage_Error *err
);

vBasicOps.h

Modified vS128Divide()
Declaration
From
vSInt32 vS128Divide (
    vSInt32 vN,
    vSInt32 vD,
    vSInt32 *vRemainder
);
To
vSInt32 vS128Divide (
    vSInt32 vN,
    vSInt32 vD,
    vSInt32 * _Nullable vRemainder
);

Modified vS16Divide()
Declaration
From
vSInt16 vS16Divide (
    vSInt16 vN,
    vSInt16 vD,
    vSInt16 *vRemainder
);
To
vSInt16 vS16Divide (
    vSInt16 vN,
    vSInt16 vD,
    vSInt16 * _Nullable vRemainder
);

Modified vS32Divide()
Declaration
From
vSInt32 vS32Divide (
    vSInt32 vN,
    vSInt32 vD,
    vSInt32 *vRemainder
);
To
vSInt32 vS32Divide (
    vSInt32 vN,
    vSInt32 vD,
    vSInt32 * _Nullable vRemainder
);

Modified vS64Divide()
Declaration
From
vSInt32 vS64Divide (
    vSInt32 vN,
    vSInt32 vD,
    vSInt32 *vRemainder
);
To
vSInt32 vS64Divide (
    vSInt32 vN,
    vSInt32 vD,
    vSInt32 * _Nullable vRemainder
);

Modified vS8Divide()
Declaration
From
vSInt8 vS8Divide (
    vSInt8 vN,
    vSInt8 vD,
    vSInt8 *vRemainder
);
To
vSInt8 vS8Divide (
    vSInt8 vN,
    vSInt8 vD,
    vSInt8 * _Nullable vRemainder
);

Modified vU128Divide()
Declaration
From
vUInt32 vU128Divide (
    vUInt32 vN,
    vUInt32 vD,
    vUInt32 *vRemainder
);
To
vUInt32 vU128Divide (
    vUInt32 vN,
    vUInt32 vD,
    vUInt32 * _Nullable vRemainder
);

Modified vU16Divide()
Declaration
From
vUInt16 vU16Divide (
    vUInt16 vN,
    vUInt16 vD,
    vUInt16 *vRemainder
);
To
vUInt16 vU16Divide (
    vUInt16 vN,
    vUInt16 vD,
    vUInt16 * _Nullable vRemainder
);

Modified vU32Divide()
Declaration
From
vUInt32 vU32Divide (
    vUInt32 vN,
    vUInt32 vD,
    vUInt32 *vRemainder
);
To
vUInt32 vU32Divide (
    vUInt32 vN,
    vUInt32 vD,
    vUInt32 * _Nullable vRemainder
);

Modified vU64Divide()
Declaration
From
vUInt32 vU64Divide (
    vUInt32 vN,
    vUInt32 vD,
    vUInt32 *vRemainder
);
To
vUInt32 vU64Divide (
    vUInt32 vN,
    vUInt32 vD,
    vUInt32 * _Nullable vRemainder
);

Modified vU8Divide()
Declaration
From
vUInt8 vU8Divide (
    vUInt8 vN,
    vUInt8 vD,
    vUInt8 *vRemainder
);
To
vUInt8 vU8Divide (
    vUInt8 vN,
    vUInt8 vD,
    vUInt8 * _Nullable vRemainder
);

vBigNum.h

Modified vA1024Shift()
Declaration
From
void vA1024Shift (
    const vS1024 *a,
    uint32_t shiftAmount,
    vS1024 *result
);
To
void vA1024Shift (
    const vS1024 * _Nonnull a,
    uint32_t shiftAmount,
    vS1024 * _Nonnull result
);

Modified vA256Shift()
Declaration
From
void vA256Shift (
    const vS256 *a,
    uint32_t shiftAmount,
    vS256 *result
);
To
void vA256Shift (
    const vS256 * _Nonnull a,
    uint32_t shiftAmount,
    vS256 * _Nonnull result
);

Modified vA512Shift()
Declaration
From
void vA512Shift (
    const vS512 *a,
    uint32_t shiftAmount,
    vS512 *result
);
To
void vA512Shift (
    const vS512 * _Nonnull a,
    uint32_t shiftAmount,
    vS512 * _Nonnull result
);

Modified vL1024Rotate()
Declaration
From
void vL1024Rotate (
    const vU1024 *a,
    uint32_t rotateAmount,
    vU1024 *result
);
To
void vL1024Rotate (
    const vU1024 * _Nonnull a,
    uint32_t rotateAmount,
    vU1024 * _Nonnull result
);

Modified vL256Rotate()
Declaration
From
void vL256Rotate (
    const vU256 *a,
    uint32_t rotateAmount,
    vU256 *result
);
To
void vL256Rotate (
    const vU256 * _Nonnull a,
    uint32_t rotateAmount,
    vU256 * _Nonnull result
);

Modified vL512Rotate()
Declaration
From
void vL512Rotate (
    const vU512 *a,
    uint32_t rotateAmount,
    vU512 *result
);
To
void vL512Rotate (
    const vU512 * _Nonnull a,
    uint32_t rotateAmount,
    vU512 * _Nonnull result
);

Modified vLL1024Shift()
Declaration
From
void vLL1024Shift (
    const vU1024 *a,
    uint32_t shiftAmount,
    vU1024 *result
);
To
void vLL1024Shift (
    const vU1024 * _Nonnull a,
    uint32_t shiftAmount,
    vU1024 * _Nonnull result
);

Modified vLL256Shift()
Declaration
From
void vLL256Shift (
    const vU256 *a,
    uint32_t shiftAmount,
    vU256 *result
);
To
void vLL256Shift (
    const vU256 * _Nonnull a,
    uint32_t shiftAmount,
    vU256 * _Nonnull result
);

Modified vLL512Shift()
Declaration
From
void vLL512Shift (
    const vU512 *a,
    uint32_t shiftAmount,
    vU512 *result
);
To
void vLL512Shift (
    const vU512 * _Nonnull a,
    uint32_t shiftAmount,
    vU512 * _Nonnull result
);

Modified vLR1024Shift()
Declaration
From
void vLR1024Shift (
    const vU1024 *a,
    uint32_t shiftAmount,
    vU1024 *result
);
To
void vLR1024Shift (
    const vU1024 * _Nonnull a,
    uint32_t shiftAmount,
    vU1024 * _Nonnull result
);

Modified vLR256Shift()
Declaration
From
void vLR256Shift (
    const vU256 *a,
    uint32_t shiftAmount,
    vU256 *result
);
To
void vLR256Shift (
    const vU256 * _Nonnull a,
    uint32_t shiftAmount,
    vU256 * _Nonnull result
);

Modified vLR512Shift()
Declaration
From
void vLR512Shift (
    const vU512 *a,
    uint32_t shiftAmount,
    vU512 *result
);
To
void vLR512Shift (
    const vU512 * _Nonnull a,
    uint32_t shiftAmount,
    vU512 * _Nonnull result
);

Modified vR1024Rotate()
Declaration
From
void vR1024Rotate (
    const vU1024 *a,
    uint32_t rotateAmount,
    vU1024 *result
);
To
void vR1024Rotate (
    const vU1024 * _Nonnull a,
    uint32_t rotateAmount,
    vU1024 * _Nonnull result
);

Modified vR256Rotate()
Declaration
From
void vR256Rotate (
    const vU256 *a,
    uint32_t rotateAmount,
    vU256 *result
);
To
void vR256Rotate (
    const vU256 * _Nonnull a,
    uint32_t rotateAmount,
    vU256 * _Nonnull result
);

Modified vR512Rotate()
Declaration
From
void vR512Rotate (
    const vU512 *a,
    uint32_t rotateAmount,
    vU512 *result
);
To
void vR512Rotate (
    const vU512 * _Nonnull a,
    uint32_t rotateAmount,
    vU512 * _Nonnull result
);

Modified vS1024Add()
Declaration
From
void vS1024Add (
    const vS1024 *a,
    const vS1024 *b,
    vS1024 *result
);
To
void vS1024Add (
    const vS1024 * _Nonnull a,
    const vS1024 * _Nonnull b,
    vS1024 * _Nonnull result
);

Modified vS1024AddS()
Declaration
From
void vS1024AddS (
    const vS1024 *a,
    const vS1024 *b,
    vS1024 *result
);
To
void vS1024AddS (
    const vS1024 * _Nonnull a,
    const vS1024 * _Nonnull b,
    vS1024 * _Nonnull result
);

Modified vS1024Divide()
Declaration
From
void vS1024Divide (
    const vS1024 *numerator,
    const vS1024 *divisor,
    vS1024 *result,
    vS1024 *remainder
);
To
void vS1024Divide (
    const vS1024 * _Nonnull numerator,
    const vS1024 * _Nonnull divisor,
    vS1024 * _Nonnull result,
    vS1024 * _Nullable remainder
);

Modified vS1024HalfMultiply()
Declaration
From
void vS1024HalfMultiply (
    const vS1024 *a,
    const vS1024 *b,
    vS1024 *result
);
To
void vS1024HalfMultiply (
    const vS1024 * _Nonnull a,
    const vS1024 * _Nonnull b,
    vS1024 * _Nonnull result
);

Modified vS1024Mod()
Declaration
From
void vS1024Mod (
    const vS1024 *numerator,
    const vS1024 *divisor,
    vS1024 *remainder
);
To
void vS1024Mod (
    const vS1024 * _Nonnull numerator,
    const vS1024 * _Nonnull divisor,
    vS1024 * _Nonnull remainder
);

Modified vS1024Neg()
Declaration
From
void vS1024Neg (
    const vS1024 *a,
    vS1024 *result
);
To
void vS1024Neg (
    const vS1024 * _Nonnull a,
    vS1024 * _Nonnull result
);

Modified vS1024Sub()
Declaration
From
void vS1024Sub (
    const vS1024 *a,
    const vS1024 *b,
    vS1024 *result
);
To
void vS1024Sub (
    const vS1024 * _Nonnull a,
    const vS1024 * _Nonnull b,
    vS1024 * _Nonnull result
);

Modified vS1024SubS()
Declaration
From
void vS1024SubS (
    const vS1024 *a,
    const vS1024 *b,
    vS1024 *result
);
To
void vS1024SubS (
    const vS1024 * _Nonnull a,
    const vS1024 * _Nonnull b,
    vS1024 * _Nonnull result
);

Modified vS128FullMultiply()
Declaration
From
void vS128FullMultiply (
    const vS128 *a,
    const vS128 *b,
    vS256 *result
);
To
void vS128FullMultiply (
    const vS128 * _Nonnull a,
    const vS128 * _Nonnull b,
    vS256 * _Nonnull result
);

Modified vS256Add()
Declaration
From
void vS256Add (
    const vS256 *a,
    const vS256 *b,
    vS256 *result
);
To
void vS256Add (
    const vS256 * _Nonnull a,
    const vS256 * _Nonnull b,
    vS256 * _Nonnull result
);

Modified vS256AddS()
Declaration
From
void vS256AddS (
    const vS256 *a,
    const vS256 *b,
    vS256 *result
);
To
void vS256AddS (
    const vS256 * _Nonnull a,
    const vS256 * _Nonnull b,
    vS256 * _Nonnull result
);

Modified vS256Divide()
Declaration
From
void vS256Divide (
    const vS256 *numerator,
    const vS256 *divisor,
    vS256 *result,
    vS256 *remainder
);
To
void vS256Divide (
    const vS256 * _Nonnull numerator,
    const vS256 * _Nonnull divisor,
    vS256 * _Nonnull result,
    vS256 * _Nullable remainder
);

Modified vS256FullMultiply()
Declaration
From
void vS256FullMultiply (
    const vS256 *a,
    const vS256 *b,
    vS512 *result
);
To
void vS256FullMultiply (
    const vS256 * _Nonnull a,
    const vS256 * _Nonnull b,
    vS512 * _Nonnull result
);

Modified vS256HalfMultiply()
Declaration
From
void vS256HalfMultiply (
    const vS256 *a,
    const vS256 *b,
    vS256 *result
);
To
void vS256HalfMultiply (
    const vS256 * _Nonnull a,
    const vS256 * _Nonnull b,
    vS256 * _Nonnull result
);

Modified vS256Mod()
Declaration
From
void vS256Mod (
    const vS256 *numerator,
    const vS256 *divisor,
    vS256 *remainder
);
To
void vS256Mod (
    const vS256 * _Nonnull numerator,
    const vS256 * _Nonnull divisor,
    vS256 * _Nonnull remainder
);

Modified vS256Neg()
Declaration
From
void vS256Neg (
    const vS256 *a,
    vS256 *result
);
To
void vS256Neg (
    const vS256 * _Nonnull a,
    vS256 * _Nonnull result
);

Modified vS256Sub()
Declaration
From
void vS256Sub (
    const vS256 *a,
    const vS256 *b,
    vS256 *result
);
To
void vS256Sub (
    const vS256 * _Nonnull a,
    const vS256 * _Nonnull b,
    vS256 * _Nonnull result
);

Modified vS256SubS()
Declaration
From
void vS256SubS (
    const vS256 *a,
    const vS256 *b,
    vS256 *result
);
To
void vS256SubS (
    const vS256 * _Nonnull a,
    const vS256 * _Nonnull b,
    vS256 * _Nonnull result
);

Modified vS512Add()
Declaration
From
void vS512Add (
    const vS512 *a,
    const vS512 *b,
    vS512 *result
);
To
void vS512Add (
    const vS512 * _Nonnull a,
    const vS512 * _Nonnull b,
    vS512 * _Nonnull result
);

Modified vS512AddS()
Declaration
From
void vS512AddS (
    const vS512 *a,
    const vS512 *b,
    vS512 *result
);
To
void vS512AddS (
    const vS512 * _Nonnull a,
    const vS512 * _Nonnull b,
    vS512 * _Nonnull result
);

Modified vS512Divide()
Declaration
From
void vS512Divide (
    const vS512 *numerator,
    const vS512 *divisor,
    vS512 *result,
    vS512 *remainder
);
To
void vS512Divide (
    const vS512 * _Nonnull numerator,
    const vS512 * _Nonnull divisor,
    vS512 * _Nonnull result,
    vS512 * _Nullable remainder
);

Modified vS512FullMultiply()
Declaration
From
void vS512FullMultiply (
    const vS512 *a,
    const vS512 *b,
    vS1024 *result
);
To
void vS512FullMultiply (
    const vS512 * _Nonnull a,
    const vS512 * _Nonnull b,
    vS1024 * _Nonnull result
);

Modified vS512HalfMultiply()
Declaration
From
void vS512HalfMultiply (
    const vS512 *a,
    const vS512 *b,
    vS512 *result
);
To
void vS512HalfMultiply (
    const vS512 * _Nonnull a,
    const vS512 * _Nonnull b,
    vS512 * _Nonnull result
);

Modified vS512Mod()
Declaration
From
void vS512Mod (
    const vS512 *numerator,
    const vS512 *divisor,
    vS512 *remainder
);
To
void vS512Mod (
    const vS512 * _Nonnull numerator,
    const vS512 * _Nonnull divisor,
    vS512 * _Nonnull remainder
);

Modified vS512Neg()
Declaration
From
void vS512Neg (
    const vS512 *a,
    vS512 *result
);
To
void vS512Neg (
    const vS512 * _Nonnull a,
    vS512 * _Nonnull result
);

Modified vS512Sub()
Declaration
From
void vS512Sub (
    const vS512 *a,
    const vS512 *b,
    vS512 *result
);
To
void vS512Sub (
    const vS512 * _Nonnull a,
    const vS512 * _Nonnull b,
    vS512 * _Nonnull result
);

Modified vS512SubS()
Declaration
From
void vS512SubS (
    const vS512 *a,
    const vS512 *b,
    vS512 *result
);
To
void vS512SubS (
    const vS512 * _Nonnull a,
    const vS512 * _Nonnull b,
    vS512 * _Nonnull result
);

Modified vU1024Add()
Declaration
From
void vU1024Add (
    const vU1024 *a,
    const vU1024 *b,
    vU1024 *result
);
To
void vU1024Add (
    const vU1024 * _Nonnull a,
    const vU1024 * _Nonnull b,
    vU1024 * _Nonnull result
);

Modified vU1024AddS()
Declaration
From
void vU1024AddS (
    const vU1024 *a,
    const vU1024 *b,
    vU1024 *result
);
To
void vU1024AddS (
    const vU1024 * _Nonnull a,
    const vU1024 * _Nonnull b,
    vU1024 * _Nonnull result
);

Modified vU1024Divide()
Declaration
From
void vU1024Divide (
    const vU1024 *numerator,
    const vU1024 *divisor,
    vU1024 *result,
    vU1024 *remainder
);
To
void vU1024Divide (
    const vU1024 * _Nonnull numerator,
    const vU1024 * _Nonnull divisor,
    vU1024 * _Nonnull result,
    vU1024 * _Nullable remainder
);

Modified vU1024HalfMultiply()
Declaration
From
void vU1024HalfMultiply (
    const vU1024 *a,
    const vU1024 *b,
    vU1024 *result
);
To
void vU1024HalfMultiply (
    const vU1024 * _Nonnull a,
    const vU1024 * _Nonnull b,
    vU1024 * _Nonnull result
);

Modified vU1024Mod()
Declaration
From
void vU1024Mod (
    const vU1024 *numerator,
    const vU1024 *divisor,
    vU1024 *remainder
);
To
void vU1024Mod (
    const vU1024 * _Nonnull numerator,
    const vU1024 * _Nonnull divisor,
    vU1024 * _Nonnull remainder
);

Modified vU1024Neg()
Declaration
From
void vU1024Neg (
    const vU1024 *a,
    vU1024 *result
);
To
void vU1024Neg (
    const vU1024 * _Nonnull a,
    vU1024 * _Nonnull result
);

Modified vU1024Sub()
Declaration
From
void vU1024Sub (
    const vU1024 *a,
    const vU1024 *b,
    vU1024 *result
);
To
void vU1024Sub (
    const vU1024 * _Nonnull a,
    const vU1024 * _Nonnull b,
    vU1024 * _Nonnull result
);

Modified vU1024SubS()
Declaration
From
void vU1024SubS (
    const vU1024 *a,
    const vU1024 *b,
    vU1024 *result
);
To
void vU1024SubS (
    const vU1024 * _Nonnull a,
    const vU1024 * _Nonnull b,
    vU1024 * _Nonnull result
);

Modified vU128FullMultiply()
Declaration
From
void vU128FullMultiply (
    const vU128 *a,
    const vU128 *b,
    vU256 *result
);
To
void vU128FullMultiply (
    const vU128 * _Nonnull a,
    const vU128 * _Nonnull b,
    vU256 * _Nonnull result
);

Modified vU256Add()
Declaration
From
void vU256Add (
    const vU256 *a,
    const vU256 *b,
    vU256 *result
);
To
void vU256Add (
    const vU256 * _Nonnull a,
    const vU256 * _Nonnull b,
    vU256 * _Nonnull result
);

Modified vU256AddS()
Declaration
From
void vU256AddS (
    const vU256 *a,
    const vU256 *b,
    vU256 *result
);
To
void vU256AddS (
    const vU256 * _Nonnull a,
    const vU256 * _Nonnull b,
    vU256 * _Nonnull result
);

Modified vU256Divide()
Declaration
From
void vU256Divide (
    const vU256 *numerator,
    const vU256 *divisor,
    vU256 *result,
    vU256 *remainder
);
To
void vU256Divide (
    const vU256 * _Nonnull numerator,
    const vU256 * _Nonnull divisor,
    vU256 * _Nonnull result,
    vU256 * _Nullable remainder
);

Modified vU256FullMultiply()
Declaration
From
void vU256FullMultiply (
    const vU256 *a,
    const vU256 *b,
    vU512 *result
);
To
void vU256FullMultiply (
    const vU256 * _Nonnull a,
    const vU256 * _Nonnull b,
    vU512 * _Nonnull result
);

Modified vU256HalfMultiply()
Declaration
From
void vU256HalfMultiply (
    const vU256 *a,
    const vU256 *b,
    vU256 *result
);
To
void vU256HalfMultiply (
    const vU256 * _Nonnull a,
    const vU256 * _Nonnull b,
    vU256 * _Nonnull result
);

Modified vU256Mod()
Declaration
From
void vU256Mod (
    const vU256 *numerator,
    const vU256 *divisor,
    vU256 *remainder
);
To
void vU256Mod (
    const vU256 * _Nonnull numerator,
    const vU256 * _Nonnull divisor,
    vU256 * _Nonnull remainder
);

Modified vU256Neg()
Declaration
From
void vU256Neg (
    const vU256 *a,
    vU256 *result
);
To
void vU256Neg (
    const vU256 * _Nonnull a,
    vU256 * _Nonnull result
);

Modified vU256Sub()
Declaration
From
void vU256Sub (
    const vU256 *a,
    const vU256 *b,
    vU256 *result
);
To
void vU256Sub (
    const vU256 * _Nonnull a,
    const vU256 * _Nonnull b,
    vU256 * _Nonnull result
);

Modified vU256SubS()
Declaration
From
void vU256SubS (
    const vU256 *a,
    const vU256 *b,
    vU256 *result
);
To
void vU256SubS (
    const vU256 * _Nonnull a,
    const vU256 * _Nonnull b,
    vU256 * _Nonnull result
);

Modified vU512Add()
Declaration
From
void vU512Add (
    const vU512 *a,
    const vU512 *b,
    vU512 *result
);
To
void vU512Add (
    const vU512 * _Nonnull a,
    const vU512 * _Nonnull b,
    vU512 * _Nonnull result
);

Modified vU512AddS()
Declaration
From
void vU512AddS (
    const vU512 *a,
    const vU512 *b,
    vU512 *result
);
To
void vU512AddS (
    const vU512 * _Nonnull a,
    const vU512 * _Nonnull b,
    vU512 * _Nonnull result
);

Modified vU512Divide()
Declaration
From
void vU512Divide (
    const vU512 *numerator,
    const vU512 *divisor,
    vU512 *result,
    vU512 *remainder
);
To
void vU512Divide (
    const vU512 * _Nonnull numerator,
    const vU512 * _Nonnull divisor,
    vU512 * _Nonnull result,
    vU512 * _Nullable remainder
);

Modified vU512FullMultiply()
Declaration
From
void vU512FullMultiply (
    const vU512 *a,
    const vU512 *b,
    vU1024 *result
);
To
void vU512FullMultiply (
    const vU512 * _Nonnull a,
    const vU512 * _Nonnull b,
    vU1024 * _Nonnull result
);

Modified vU512HalfMultiply()
Declaration
From
void vU512HalfMultiply (
    const vU512 *a,
    const vU512 *b,
    vU512 *result
);
To
void vU512HalfMultiply (
    const vU512 * _Nonnull a,
    const vU512 * _Nonnull b,
    vU512 * _Nonnull result
);

Modified vU512Mod()
Declaration
From
void vU512Mod (
    const vU512 *numerator,
    const vU512 *divisor,
    vU512 *remainder
);
To
void vU512Mod (
    const vU512 * _Nonnull numerator,
    const vU512 * _Nonnull divisor,
    vU512 * _Nonnull remainder
);

Modified vU512Neg()
Declaration
From
void vU512Neg (
    const vU512 *a,
    vU512 *result
);
To
void vU512Neg (
    const vU512 * _Nonnull a,
    vU512 * _Nonnull result
);

Modified vU512Sub()
Declaration
From
void vU512Sub (
    const vU512 *a,
    const vU512 *b,
    vU512 *result
);
To
void vU512Sub (
    const vU512 * _Nonnull a,
    const vU512 * _Nonnull b,
    vU512 * _Nonnull result
);

Modified vU512SubS()
Declaration
From
void vU512SubS (
    const vU512 *a,
    const vU512 *b,
    vU512 *result
);
To
void vU512SubS (
    const vU512 * _Nonnull a,
    const vU512 * _Nonnull b,
    vU512 * _Nonnull result
);

vDSP.h

Added vDSP_biquadm_SetActiveFilters()
Added vDSP_biquadm_SetCoefficientsDouble()
Added vDSP_biquadm_SetCoefficientsSingle()
Added vDSP_biquadm_SetTargetsDouble()
Added vDSP_biquadm_SetTargetsSingle()
Modified conv()
DeclarationDeprecation
From
void conv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void conv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __F,
    vDSP_Stride __IF,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified convD()
DeclarationDeprecation
From
void convD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void convD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __F,
    vDSP_Stride __IF,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified create_fftsetup()
DeclarationDeprecation
From
FFTSetup create_fftsetup (
    vDSP_Length __vDSP_Log2n,
    FFTRadix __vDSP_Radix
);
--
To
FFTSetup _Nonnull create_fftsetup (
    vDSP_Length __Log2n,
    FFTRadix __Radix
);
OS X 10.11

Modified create_fftsetupD()
DeclarationDeprecation
From
FFTSetupD create_fftsetupD (
    vDSP_Length __vDSP_Log2n,
    FFTRadix __vDSP_Radix
);
--
To
FFTSetupD _Nonnull create_fftsetupD (
    vDSP_Length __Log2n,
    FFTRadix __Radix
);
OS X 10.11

Modified ctoz()
DeclarationDeprecation
From
void ctoz (
    const DSPComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    vDSP_Length __vDSP_N
);
--
To
void ctoz (
    const DSPComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    vDSP_Length __N
);
OS X 10.11

Modified ctozD()
DeclarationDeprecation
From
void ctozD (
    const DSPDoubleComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    vDSP_Length __vDSP_N
);
--
To
void ctozD (
    const DSPDoubleComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    vDSP_Length __N
);
OS X 10.11

Modified destroy_fftsetup()
DeclarationDeprecation
From
void destroy_fftsetup (
    FFTSetup __vDSP_setup
);
--
To
void destroy_fftsetup (
    FFTSetup _Nonnull __setup
);
OS X 10.11

Modified destroy_fftsetupD()
DeclarationDeprecation
From
void destroy_fftsetupD (
    FFTSetupD __vDSP_setup
);
--
To
void destroy_fftsetupD (
    FFTSetupD _Nonnull __setup
);
OS X 10.11

Modified dotpr()
DeclarationDeprecation
From
void dotpr (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void dotpr (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified dotprD()
DeclarationDeprecation
From
void dotprD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void dotprD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified f3x3()
DeclarationDeprecation
From
void f3x3 (
    const float *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const float *__vDSP_F,
    float *__vDSP_C
);
--
To
void f3x3 (
    const float * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const float * _Nonnull __F,
    float * _Nonnull __C
);
OS X 10.11

Modified f3x3D()
DeclarationDeprecation
From
void f3x3D (
    const double *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const double *__vDSP_F,
    double *__vDSP_C
);
--
To
void f3x3D (
    const double * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const double * _Nonnull __F,
    double * _Nonnull __C
);
OS X 10.11

Modified f5x5()
DeclarationDeprecation
From
void f5x5 (
    const float *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const float *__vDSP_F,
    float *__vDSP_C
);
--
To
void f5x5 (
    const float * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const float * _Nonnull __F,
    float * _Nonnull __C
);
OS X 10.11

Modified f5x5D()
DeclarationDeprecation
From
void f5x5D (
    const double *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const double *__vDSP_F,
    double *__vDSP_C
);
--
To
void f5x5D (
    const double * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const double * _Nonnull __F,
    double * _Nonnull __C
);
OS X 10.11

Modified fft2d_zip()
DeclarationDeprecation
From
void fft2d_zip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zipD()
DeclarationDeprecation
From
void fft2d_zipD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zipD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zipt()
DeclarationDeprecation
From
void fft2d_zipt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC1,
    vDSP_Stride __vDSP_IC0,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zipt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC1,
    vDSP_Stride __IC0,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_ziptD()
DeclarationDeprecation
From
void fft2d_ziptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_ziptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zop()
DeclarationDeprecation
From
void fft2d_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zopD()
DeclarationDeprecation
From
void fft2d_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zopt()
DeclarationDeprecation
From
void fft2d_zopt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zopt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zoptD()
DeclarationDeprecation
From
void fft2d_zoptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zoptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zrip()
DeclarationDeprecation
From
void fft2d_zrip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zrip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zripD()
DeclarationDeprecation
From
void fft2d_zripD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_flag
);
--
To
void fft2d_zripD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __flag
);
OS X 10.11

Modified fft2d_zript()
DeclarationDeprecation
From
void fft2d_zript (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zript (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zriptD()
DeclarationDeprecation
From
void fft2d_zriptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_flag
);
--
To
void fft2d_zriptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __flag
);
OS X 10.11

Modified fft2d_zrop()
DeclarationDeprecation
From
void fft2d_zrop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zrop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zropD()
DeclarationDeprecation
From
void fft2d_zropD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zropD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zropt()
DeclarationDeprecation
From
void fft2d_zropt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zropt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft2d_zroptD()
DeclarationDeprecation
From
void fft2d_zroptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
--
To
void fft2d_zroptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);
OS X 10.11

Modified fft3_zop()
DeclarationDeprecation
From
void fft3_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft3_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft3_zopD()
DeclarationDeprecation
From
void fft3_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft3_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft5_zop()
DeclarationDeprecation
From
void fft5_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft5_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft5_zopD()
DeclarationDeprecation
From
void fft5_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft5_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zip()
DeclarationDeprecation
From
void fft_zip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zipD()
DeclarationDeprecation
From
void fft_zipD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zipD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zipt()
DeclarationDeprecation
From
void fft_zipt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zipt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_ziptD()
DeclarationDeprecation
From
void fft_ziptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_ziptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zop()
DeclarationDeprecation
From
void fft_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zopD()
DeclarationDeprecation
From
void fft_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zopt()
DeclarationDeprecation
From
void fft_zopt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zopt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zoptD()
DeclarationDeprecation
From
void fft_zoptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zoptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zrip()
DeclarationDeprecation
From
void fft_zrip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zrip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zripD()
DeclarationDeprecation
From
void fft_zripD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zripD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zript()
DeclarationDeprecation
From
void fft_zript (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zript (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zriptD()
DeclarationDeprecation
From
void fft_zriptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zriptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zrop()
DeclarationDeprecation
From
void fft_zrop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zrop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zropD()
DeclarationDeprecation
From
void fft_zropD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zropD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zropt()
DeclarationDeprecation
From
void fft_zropt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zropt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fft_zroptD()
DeclarationDeprecation
From
void fft_zroptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void fft_zroptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zip()
DeclarationDeprecation
From
void fftm_zip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zipD()
DeclarationDeprecation
From
void fftm_zipD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zipD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zipt()
DeclarationDeprecation
From
void fftm_zipt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zipt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_ziptD()
DeclarationDeprecation
From
void fftm_ziptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_ziptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zop()
DeclarationDeprecation
From
void fftm_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zopD()
DeclarationDeprecation
From
void fftm_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zopt()
DeclarationDeprecation
From
void fftm_zopt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zopt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zoptD()
DeclarationDeprecation
From
void fftm_zoptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zoptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zrip()
DeclarationDeprecation
From
void fftm_zrip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zrip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zripD()
DeclarationDeprecation
From
void fftm_zripD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zripD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zript()
DeclarationDeprecation
From
void fftm_zript (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zript (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zriptD()
DeclarationDeprecation
From
void fftm_zriptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zriptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zrop()
DeclarationDeprecation
From
void fftm_zrop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zrop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zropD()
DeclarationDeprecation
From
void fftm_zropD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zropD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zropt()
DeclarationDeprecation
From
void fftm_zropt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zropt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified fftm_zroptD()
DeclarationDeprecation
From
void fftm_zroptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
--
To
void fftm_zroptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);
OS X 10.11

Modified imgfir()
DeclarationDeprecation
From
void imgfir (
    const float *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const float *__vDSP_F,
    float *__vDSP_C,
    vDSP_Length __vDSP_P,
    vDSP_Length __vDSP_Q
);
--
To
void imgfir (
    const float * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const float * _Nonnull __F,
    float * _Nonnull __C,
    vDSP_Length __P,
    vDSP_Length __Q
);
OS X 10.11

Modified imgfirD()
DeclarationDeprecation
From
void imgfirD (
    const double *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const double *__vDSP_F,
    double *__vDSP_C,
    vDSP_Length __vDSP_P,
    vDSP_Length __vDSP_Q
);
--
To
void imgfirD (
    const double * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const double * _Nonnull __F,
    double * _Nonnull __C,
    vDSP_Length __P,
    vDSP_Length __Q
);
OS X 10.11

Modified mmul()
DeclarationDeprecation
From
void mmul (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void mmul (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified mmulD()
DeclarationDeprecation
From
void mmulD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void mmulD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified mtrans()
DeclarationDeprecation
From
void mtrans (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N
);
--
To
void mtrans (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N
);
OS X 10.11

Modified mtransD()
DeclarationDeprecation
From
void mtransD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N
);
--
To
void mtransD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N
);
OS X 10.11

Modified vadd()
DeclarationDeprecation
From
void vadd (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vadd (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vaddD()
DeclarationDeprecation
From
void vaddD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vaddD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vam()
DeclarationDeprecation
From
void vam (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
--
To
void vam (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);
OS X 10.11

Modified vamD()
DeclarationDeprecation
From
void vamD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_IDD,
    vDSP_Length __vDSP_N
);
--
To
void vamD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __IDD,
    vDSP_Length __N
);
OS X 10.11

Modified vDSP_biquad()
Declaration
From
void vDSP_biquad (
    const struct vDSP_biquad_SetupStruct *__vDSP_Setup,
    float *__vDSP_Delay,
    const float *__vDSP_X,
    vDSP_Stride __vDSP_IX,
    float *__vDSP_Y,
    vDSP_Stride __vDSP_IY,
    vDSP_Length __vDSP_N
);
To
void vDSP_biquad (
    const struct vDSP_biquad_SetupStruct * _Nonnull __Setup,
    float * _Nonnull __Delay,
    const float * _Nonnull __X,
    vDSP_Stride __IX,
    float * _Nonnull __Y,
    vDSP_Stride __IY,
    vDSP_Length __N
);

Modified vDSP_biquad_CreateSetup()
Declaration
From
vDSP_biquad_Setup vDSP_biquad_CreateSetup (
    const double *__vDSP_Coefficients,
    vDSP_Length __vDSP_M
);
To
vDSP_biquad_Setup _Nullable vDSP_biquad_CreateSetup (
    const double * _Nonnull __Coefficients,
    vDSP_Length __M
);

Modified vDSP_biquad_CreateSetupD()
Declaration
From
vDSP_biquad_SetupD vDSP_biquad_CreateSetupD (
    const double *__vDSP_Coefficients,
    vDSP_Length __vDSP_M
);
To
vDSP_biquad_SetupD _Nullable vDSP_biquad_CreateSetupD (
    const double * _Nonnull __Coefficients,
    vDSP_Length __M
);

Modified vDSP_biquad_DestroySetup()
Declaration
From
void vDSP_biquad_DestroySetup (
    vDSP_biquad_Setup __vDSP_setup
);
To
void vDSP_biquad_DestroySetup (
    vDSP_biquad_Setup _Nullable __setup
);

Modified vDSP_biquad_DestroySetupD()
Declaration
From
void vDSP_biquad_DestroySetupD (
    vDSP_biquad_SetupD __vDSP_setup
);
To
void vDSP_biquad_DestroySetupD (
    vDSP_biquad_SetupD _Nullable __setup
);

Modified vDSP_biquadD()
Declaration
From
void vDSP_biquadD (
    const struct vDSP_biquad_SetupStructD *__vDSP_Setup,
    double *__vDSP_Delay,
    const double *__vDSP_X,
    vDSP_Stride __vDSP_IX,
    double *__vDSP_Y,
    vDSP_Stride __vDSP_IY,
    vDSP_Length __vDSP_N
);
To
void vDSP_biquadD (
    const struct vDSP_biquad_SetupStructD * _Nonnull __Setup,
    double * _Nonnull __Delay,
    const double * _Nonnull __X,
    vDSP_Stride __IX,
    double * _Nonnull __Y,
    vDSP_Stride __IY,
    vDSP_Length __N
);

Modified vDSP_biquadm()
Declaration
From
void vDSP_biquadm (
    vDSP_biquadm_Setup __vDSP_Setup,
    const float **__vDSP_X,
    vDSP_Stride __vDSP_IX,
    float **__vDSP_Y,
    vDSP_Stride __vDSP_IY,
    vDSP_Length __vDSP_N
);
To
void vDSP_biquadm (
    vDSP_biquadm_Setup _Nonnull __Setup,
    const float * _Nonnull * _Nonnull __X,
    vDSP_Stride __IX,
    float * _Nonnull * _Nonnull __Y,
    vDSP_Stride __IY,
    vDSP_Length __N
);

Modified vDSP_biquadm_CopyState()
Declaration
From
void vDSP_biquadm_CopyState (
    vDSP_biquadm_Setup __vDSP_dest,
    const struct vDSP_biquadm_SetupStruct *__vDSP_src
);
To
void vDSP_biquadm_CopyState (
    vDSP_biquadm_Setup _Nonnull __dest,
    const struct vDSP_biquadm_SetupStruct * _Nonnull __src
);

Modified vDSP_biquadm_CopyStateD()
Declaration
From
void vDSP_biquadm_CopyStateD (
    vDSP_biquadm_SetupD __vDSP_dest,
    const struct vDSP_biquadm_SetupStructD *__vDSP_src
);
To
void vDSP_biquadm_CopyStateD (
    vDSP_biquadm_SetupD _Nonnull __dest,
    const struct vDSP_biquadm_SetupStructD * _Nonnull __src
);

Modified vDSP_biquadm_CreateSetup()
Declaration
From
vDSP_biquadm_Setup vDSP_biquadm_CreateSetup (
    const double *__vDSP_coeffs,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N
);
To
vDSP_biquadm_Setup _Nullable vDSP_biquadm_CreateSetup (
    const double * _Nonnull __coeffs,
    vDSP_Length __M,
    vDSP_Length __N
);

Modified vDSP_biquadm_CreateSetupD()
Declaration
From
vDSP_biquadm_SetupD vDSP_biquadm_CreateSetupD (
    const double *__vDSP_coeffs,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N
);
To
vDSP_biquadm_SetupD _Nullable vDSP_biquadm_CreateSetupD (
    const double * _Nonnull __coeffs,
    vDSP_Length __M,
    vDSP_Length __N
);

Modified vDSP_biquadm_DestroySetup()
Declaration
From
void vDSP_biquadm_DestroySetup (
    vDSP_biquadm_Setup __vDSP_setup
);
To
void vDSP_biquadm_DestroySetup (
    vDSP_biquadm_Setup _Nonnull __setup
);

Modified vDSP_biquadm_DestroySetupD()
Declaration
From
void vDSP_biquadm_DestroySetupD (
    vDSP_biquadm_SetupD __vDSP_setup
);
To
void vDSP_biquadm_DestroySetupD (
    vDSP_biquadm_SetupD _Nonnull __setup
);

Modified vDSP_biquadm_ResetState()
Declaration
From
void vDSP_biquadm_ResetState (
    vDSP_biquadm_Setup __vDSP_setup
);
To
void vDSP_biquadm_ResetState (
    vDSP_biquadm_Setup _Nonnull __setup
);

Modified vDSP_biquadm_ResetStateD()
Declaration
From
void vDSP_biquadm_ResetStateD (
    vDSP_biquadm_SetupD __vDSP_setup
);
To
void vDSP_biquadm_ResetStateD (
    vDSP_biquadm_SetupD _Nonnull __setup
);

Modified vDSP_biquadmD()
Declaration
From
void vDSP_biquadmD (
    vDSP_biquadm_SetupD __vDSP_Setup,
    const double **__vDSP_X,
    vDSP_Stride __vDSP_IX,
    double **__vDSP_Y,
    vDSP_Stride __vDSP_IY,
    vDSP_Length __vDSP_N
);
To
void vDSP_biquadmD (
    vDSP_biquadm_SetupD _Nonnull __Setup,
    const double * _Nonnull * _Nonnull __X,
    vDSP_Stride __IX,
    double * _Nonnull * _Nonnull __Y,
    vDSP_Stride __IY,
    vDSP_Length __N
);

Modified vDSP_blkman_window()
Declaration
From
void vDSP_blkman_window (
    float *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Flag
);
To
void vDSP_blkman_window (
    float * _Nonnull __C,
    vDSP_Length __N,
    int __Flag
);

Modified vDSP_blkman_windowD()
Declaration
From
void vDSP_blkman_windowD (
    double *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Flag
);
To
void vDSP_blkman_windowD (
    double * _Nonnull __C,
    vDSP_Length __N,
    int __Flag
);

Modified vDSP_conv()
Declaration
From
void vDSP_conv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_conv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __F,
    vDSP_Stride __IF,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_convD()
Declaration
From
void vDSP_convD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_convD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __F,
    vDSP_Stride __IF,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_create_fftsetup()
Declaration
From
FFTSetup vDSP_create_fftsetup (
    vDSP_Length __vDSP_Log2n,
    FFTRadix __vDSP_Radix
);
To
FFTSetup _Nullable vDSP_create_fftsetup (
    vDSP_Length __Log2n,
    FFTRadix __Radix
);

Modified vDSP_create_fftsetupD()
Declaration
From
FFTSetupD vDSP_create_fftsetupD (
    vDSP_Length __vDSP_Log2n,
    FFTRadix __vDSP_Radix
);
To
FFTSetupD _Nullable vDSP_create_fftsetupD (
    vDSP_Length __Log2n,
    FFTRadix __Radix
);

Modified vDSP_ctoz()
Declaration
From
void vDSP_ctoz (
    const DSPComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    vDSP_Length __vDSP_N
);
To
void vDSP_ctoz (
    const DSPComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    vDSP_Length __N
);

Modified vDSP_ctozD()
Declaration
From
void vDSP_ctozD (
    const DSPDoubleComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    vDSP_Length __vDSP_N
);
To
void vDSP_ctozD (
    const DSPDoubleComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    vDSP_Length __N
);

Modified vDSP_DCT_CreateSetup()
Declaration
From
vDSP_DFT_Setup vDSP_DCT_CreateSetup (
    vDSP_DFT_Setup __vDSP_Previous,
    vDSP_Length __vDSP_Length,
    vDSP_DCT_Type __vDSP_Type
);
To
vDSP_DFT_Setup _Nullable vDSP_DCT_CreateSetup (
    vDSP_DFT_Setup _Nullable __Previous,
    vDSP_Length __Length,
    vDSP_DCT_Type __Type
);

Modified vDSP_DCT_Execute()
Declaration
From
void vDSP_DCT_Execute (
    const struct vDSP_DFT_SetupStruct *__vDSP_Setup,
    const float *__vDSP_Input,
    float *__vDSP_Output
);
To
void vDSP_DCT_Execute (
    const struct vDSP_DFT_SetupStruct * _Nonnull __Setup,
    const float * _Nonnull __Input,
    float * _Nonnull __Output
);

Modified vDSP_deq22()
Declaration
From
void vDSP_deq22 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_deq22 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_deq22D()
Declaration
From
void vDSP_deq22D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_deq22D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_desamp()
Declaration
From
void vDSP_desamp (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const float *__vDSP_F,
    float *__vDSP_C,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_desamp (
    const float * _Nonnull __A,
    vDSP_Stride __DF,
    const float * _Nonnull __F,
    float * _Nonnull __C,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_desampD()
Declaration
From
void vDSP_desampD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const double *__vDSP_F,
    double *__vDSP_C,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_desampD (
    const double * _Nonnull __A,
    vDSP_Stride __DF,
    const double * _Nonnull __F,
    double * _Nonnull __C,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_destroy_fftsetup()
Declaration
From
void vDSP_destroy_fftsetup (
    FFTSetup __vDSP_setup
);
To
void vDSP_destroy_fftsetup (
    FFTSetup _Nullable __setup
);

Modified vDSP_destroy_fftsetupD()
Declaration
From
void vDSP_destroy_fftsetupD (
    FFTSetupD __vDSP_setup
);
To
void vDSP_destroy_fftsetupD (
    FFTSetupD _Nullable __setup
);

Modified vDSP_DFT_CreateSetup()
Declaration
From
vDSP_DFT_Setup vDSP_DFT_CreateSetup (
    vDSP_DFT_Setup __vDSP_Previous,
    vDSP_Length __vDSP_Length
);
To
vDSP_DFT_Setup _Nullable vDSP_DFT_CreateSetup (
    vDSP_DFT_Setup _Nullable __Previous,
    vDSP_Length __Length
);

Modified vDSP_DFT_DestroySetup()
Declaration
From
void vDSP_DFT_DestroySetup (
    vDSP_DFT_Setup __vDSP_Setup
);
To
void vDSP_DFT_DestroySetup (
    vDSP_DFT_Setup _Nullable __Setup
);

Modified vDSP_DFT_DestroySetupD()
Declaration
From
void vDSP_DFT_DestroySetupD (
    vDSP_DFT_SetupD __vDSP_Setup
);
To
void vDSP_DFT_DestroySetupD (
    vDSP_DFT_SetupD _Nullable __Setup
);

Modified vDSP_DFT_Execute()
Declaration
From
void vDSP_DFT_Execute (
    const struct vDSP_DFT_SetupStruct *__vDSP_Setup,
    const float *__vDSP_Ir,
    const float *__vDSP_Ii,
    float *__vDSP_Or,
    float *__vDSP_Oi
);
To
void vDSP_DFT_Execute (
    const struct vDSP_DFT_SetupStruct * _Nonnull __Setup,
    const float * _Nonnull __Ir,
    const float * _Nonnull __Ii,
    float * _Nonnull __Or,
    float * _Nonnull __Oi
);

Modified vDSP_DFT_ExecuteD()
Declaration
From
void vDSP_DFT_ExecuteD (
    const struct vDSP_DFT_SetupStructD *__vDSP_Setup,
    const double *__vDSP_Ir,
    const double *__vDSP_Ii,
    double *__vDSP_Or,
    double *__vDSP_Oi
);
To
void vDSP_DFT_ExecuteD (
    const struct vDSP_DFT_SetupStructD * _Nonnull __Setup,
    const double * _Nonnull __Ir,
    const double * _Nonnull __Ii,
    double * _Nonnull __Or,
    double * _Nonnull __Oi
);

Modified vDSP_DFT_zop()
Declaration
From
void vDSP_DFT_zop (
    const struct vDSP_DFT_SetupStruct *__vDSP_Setup,
    const float *__vDSP_Ir,
    const float *__vDSP_Ii,
    vDSP_Stride __vDSP_Is,
    float *__vDSP_Or,
    float *__vDSP_Oi,
    vDSP_Stride __vDSP_Os,
    vDSP_DFT_Direction __vDSP_Direction
);
To
void vDSP_DFT_zop (
    const struct vDSP_DFT_SetupStruct * _Nonnull __Setup,
    const float * _Nonnull __Ir,
    const float * _Nonnull __Ii,
    vDSP_Stride __Is,
    float * _Nonnull __Or,
    float * _Nonnull __Oi,
    vDSP_Stride __Os,
    vDSP_DFT_Direction __Direction
);

Modified vDSP_DFT_zop_CreateSetup()
Declaration
From
vDSP_DFT_Setup vDSP_DFT_zop_CreateSetup (
    vDSP_DFT_Setup __vDSP_Previous,
    vDSP_Length __vDSP_Length,
    vDSP_DFT_Direction __vDSP_Direction
);
To
vDSP_DFT_Setup _Nullable vDSP_DFT_zop_CreateSetup (
    vDSP_DFT_Setup _Nullable __Previous,
    vDSP_Length __Length,
    vDSP_DFT_Direction __Direction
);

Modified vDSP_DFT_zop_CreateSetupD()
Declaration
From
vDSP_DFT_SetupD vDSP_DFT_zop_CreateSetupD (
    vDSP_DFT_SetupD __vDSP_Previous,
    vDSP_Length __vDSP_Length,
    vDSP_DFT_Direction __vDSP_Direction
);
To
vDSP_DFT_SetupD _Nullable vDSP_DFT_zop_CreateSetupD (
    vDSP_DFT_SetupD _Nullable __Previous,
    vDSP_Length __Length,
    vDSP_DFT_Direction __Direction
);

Modified vDSP_DFT_zrop_CreateSetup()
Declaration
From
vDSP_DFT_Setup vDSP_DFT_zrop_CreateSetup (
    vDSP_DFT_Setup __vDSP_Previous,
    vDSP_Length __vDSP_Length,
    vDSP_DFT_Direction __vDSP_Direction
);
To
vDSP_DFT_Setup _Nullable vDSP_DFT_zrop_CreateSetup (
    vDSP_DFT_Setup _Nullable __Previous,
    vDSP_Length __Length,
    vDSP_DFT_Direction __Direction
);

Modified vDSP_DFT_zrop_CreateSetupD()
Declaration
From
vDSP_DFT_SetupD vDSP_DFT_zrop_CreateSetupD (
    vDSP_DFT_SetupD __vDSP_Previous,
    vDSP_Length __vDSP_Length,
    vDSP_DFT_Direction __vDSP_Direction
);
To
vDSP_DFT_SetupD _Nullable vDSP_DFT_zrop_CreateSetupD (
    vDSP_DFT_SetupD _Nullable __Previous,
    vDSP_Length __Length,
    vDSP_DFT_Direction __Direction
);

Modified vDSP_distancesq()
Declaration
From
void vDSP_distancesq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_distancesq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_distancesqD()
Declaration
From
void vDSP_distancesqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_distancesqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_dotpr()
Declaration
From
void vDSP_dotpr (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_dotpr (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_dotpr2()
Declaration
From
void vDSP_dotpr2 (
    const float *__vDSP_A0,
    vDSP_Stride __vDSP_A0Stride,
    const float *__vDSP_A1,
    vDSP_Stride __vDSP_A1Stride,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_BStride,
    float *__vDSP_C0,
    float *__vDSP_C1,
    vDSP_Length __vDSP_Length
);
To
void vDSP_dotpr2 (
    const float * _Nonnull __A0,
    vDSP_Stride __A0Stride,
    const float * _Nonnull __A1,
    vDSP_Stride __A1Stride,
    const float * _Nonnull __B,
    vDSP_Stride __BStride,
    float * _Nonnull __C0,
    float * _Nonnull __C1,
    vDSP_Length __Length
);

Modified vDSP_dotpr2_s1_15()
Declaration
From
void vDSP_dotpr2_s1_15 (
    const short *__vDSP_A0,
    vDSP_Stride __vDSP_A0Stride,
    const short *__vDSP_A1,
    vDSP_Stride __vDSP_A1Stride,
    const short *__vDSP_B,
    vDSP_Stride __vDSP_BStride,
    short *__vDSP_C0,
    short *__vDSP_C1,
    vDSP_Length __vDSP_N
);
To
void vDSP_dotpr2_s1_15 (
    const short * _Nonnull __A0,
    vDSP_Stride __A0Stride,
    const short * _Nonnull __A1,
    vDSP_Stride __A1Stride,
    const short * _Nonnull __B,
    vDSP_Stride __BStride,
    short * _Nonnull __C0,
    short * _Nonnull __C1,
    vDSP_Length __N
);

Modified vDSP_dotpr2_s8_24()
Declaration
From
void vDSP_dotpr2_s8_24 (
    const int *__vDSP_A0,
    vDSP_Stride __vDSP_A0Stride,
    const int *__vDSP_A1,
    vDSP_Stride __vDSP_A1Stride,
    const int *__vDSP_B,
    vDSP_Stride __vDSP_BStride,
    int *__vDSP_C0,
    int *__vDSP_C1,
    vDSP_Length __vDSP_N
);
To
void vDSP_dotpr2_s8_24 (
    const int * _Nonnull __A0,
    vDSP_Stride __A0Stride,
    const int * _Nonnull __A1,
    vDSP_Stride __A1Stride,
    const int * _Nonnull __B,
    vDSP_Stride __BStride,
    int * _Nonnull __C0,
    int * _Nonnull __C1,
    vDSP_Length __N
);

Modified vDSP_dotpr2D()
Declaration
From
void vDSP_dotpr2D (
    const double *__vDSP_A0,
    vDSP_Stride __vDSP_A0Stride,
    const double *__vDSP_A1,
    vDSP_Stride __vDSP_A1Stride,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_BStride,
    double *__vDSP_C0,
    double *__vDSP_C1,
    vDSP_Length __vDSP_Length
);
To
void vDSP_dotpr2D (
    const double * _Nonnull __A0,
    vDSP_Stride __A0Stride,
    const double * _Nonnull __A1,
    vDSP_Stride __A1Stride,
    const double * _Nonnull __B,
    vDSP_Stride __BStride,
    double * _Nonnull __C0,
    double * _Nonnull __C1,
    vDSP_Length __Length
);

Modified vDSP_dotpr_s1_15()
Declaration
From
void vDSP_dotpr_s1_15 (
    const short *__vDSP_A,
    vDSP_Stride __vDSP_AStride,
    const short *__vDSP_B,
    vDSP_Stride __vDSP_BStride,
    short *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_dotpr_s1_15 (
    const short * _Nonnull __A,
    vDSP_Stride __AStride,
    const short * _Nonnull __B,
    vDSP_Stride __BStride,
    short * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_dotpr_s8_24()
Declaration
From
void vDSP_dotpr_s8_24 (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_AStride,
    const int *__vDSP_B,
    vDSP_Stride __vDSP_BStride,
    int *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_dotpr_s8_24 (
    const int * _Nonnull __A,
    vDSP_Stride __AStride,
    const int * _Nonnull __B,
    vDSP_Stride __BStride,
    int * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_dotprD()
Declaration
From
void vDSP_dotprD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_dotprD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_f3x3()
Declaration
From
void vDSP_f3x3 (
    const float *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const float *__vDSP_F,
    float *__vDSP_C
);
To
void vDSP_f3x3 (
    const float * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const float * _Nonnull __F,
    float * _Nonnull __C
);

Modified vDSP_f3x3D()
Declaration
From
void vDSP_f3x3D (
    const double *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const double *__vDSP_F,
    double *__vDSP_C
);
To
void vDSP_f3x3D (
    const double * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const double * _Nonnull __F,
    double * _Nonnull __C
);

Modified vDSP_f5x5()
Declaration
From
void vDSP_f5x5 (
    const float *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const float *__vDSP_F,
    float *__vDSP_C
);
To
void vDSP_f5x5 (
    const float * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const float * _Nonnull __F,
    float * _Nonnull __C
);

Modified vDSP_f5x5D()
Declaration
From
void vDSP_f5x5D (
    const double *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const double *__vDSP_F,
    double *__vDSP_C
);
To
void vDSP_f5x5D (
    const double * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const double * _Nonnull __F,
    double * _Nonnull __C
);

Modified vDSP_FFT16_copv()
Declaration
From
void vDSP_FFT16_copv (
    float *__vDSP_Output,
    const float *__vDSP_Input,
    FFTDirection __vDSP_Direction
);
To
void vDSP_FFT16_copv (
    float * _Nonnull __Output,
    const float * _Nonnull __Input,
    FFTDirection __Direction
);

Modified vDSP_FFT16_zopv()
Declaration
From
void vDSP_FFT16_zopv (
    float *__vDSP_Or,
    float *__vDSP_Oi,
    const float *__vDSP_Ir,
    const float *__vDSP_Ii,
    FFTDirection __vDSP_Direction
);
To
void vDSP_FFT16_zopv (
    float * _Nonnull __Or,
    float * _Nonnull __Oi,
    const float * _Nonnull __Ir,
    const float * _Nonnull __Ii,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zip()
Declaration
From
void vDSP_fft2d_zip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zipD()
Declaration
From
void vDSP_fft2d_zipD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zipD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zipt()
Declaration
From
void vDSP_fft2d_zipt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC1,
    vDSP_Stride __vDSP_IC0,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zipt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC1,
    vDSP_Stride __IC0,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_ziptD()
Declaration
From
void vDSP_fft2d_ziptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_ziptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zop()
Declaration
From
void vDSP_fft2d_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zopD()
Declaration
From
void vDSP_fft2d_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zopt()
Declaration
From
void vDSP_fft2d_zopt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zopt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zoptD()
Declaration
From
void vDSP_fft2d_zoptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zoptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zrip()
Declaration
From
void vDSP_fft2d_zrip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zrip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zripD()
Declaration
From
void vDSP_fft2d_zripD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_flag
);
To
void vDSP_fft2d_zripD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __flag
);

Modified vDSP_fft2d_zript()
Declaration
From
void vDSP_fft2d_zript (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zript (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zriptD()
Declaration
From
void vDSP_fft2d_zriptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_flag
);
To
void vDSP_fft2d_zriptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __flag
);

Modified vDSP_fft2d_zrop()
Declaration
From
void vDSP_fft2d_zrop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zrop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zropD()
Declaration
From
void vDSP_fft2d_zropD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zropD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zropt()
Declaration
From
void vDSP_fft2d_zropt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zropt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_fft2d_zroptD()
Declaration
From
void vDSP_fft2d_zroptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA0,
    vDSP_Stride __vDSP_IA1,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC0,
    vDSP_Stride __vDSP_IC1,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N0,
    vDSP_Length __vDSP_Log2N1,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft2d_zroptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA0,
    vDSP_Stride __IA1,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC0,
    vDSP_Stride __IC1,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N0,
    vDSP_Length __Log2N1,
    FFTDirection __Direction
);

Modified vDSP_FFT32_copv()
Declaration
From
void vDSP_FFT32_copv (
    float *__vDSP_Output,
    const float *__vDSP_Input,
    FFTDirection __vDSP_Direction
);
To
void vDSP_FFT32_copv (
    float * _Nonnull __Output,
    const float * _Nonnull __Input,
    FFTDirection __Direction
);

Modified vDSP_FFT32_zopv()
Declaration
From
void vDSP_FFT32_zopv (
    float *__vDSP_Or,
    float *__vDSP_Oi,
    const float *__vDSP_Ir,
    const float *__vDSP_Ii,
    FFTDirection __vDSP_Direction
);
To
void vDSP_FFT32_zopv (
    float * _Nonnull __Or,
    float * _Nonnull __Oi,
    const float * _Nonnull __Ir,
    const float * _Nonnull __Ii,
    FFTDirection __Direction
);

Modified vDSP_fft3_zop()
DeclarationDeprecation
From
void vDSP_fft3_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void vDSP_fft3_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified vDSP_fft3_zopD()
DeclarationDeprecation
From
void vDSP_fft3_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void vDSP_fft3_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified vDSP_fft5_zop()
DeclarationDeprecation
From
void vDSP_fft5_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void vDSP_fft5_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified vDSP_fft5_zopD()
DeclarationDeprecation
From
void vDSP_fft5_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
--
To
void vDSP_fft5_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);
OS X 10.11

Modified vDSP_fft_zip()
Declaration
From
void vDSP_fft_zip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zipD()
Declaration
From
void vDSP_fft_zipD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zipD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zipt()
Declaration
From
void vDSP_fft_zipt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zipt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_ziptD()
Declaration
From
void vDSP_fft_ziptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_ziptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zop()
Declaration
From
void vDSP_fft_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zopD()
Declaration
From
void vDSP_fft_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zopt()
Declaration
From
void vDSP_fft_zopt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zopt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zoptD()
Declaration
From
void vDSP_fft_zoptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zoptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zrip()
Declaration
From
void vDSP_fft_zrip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zrip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zripD()
Declaration
From
void vDSP_fft_zripD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zripD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zript()
Declaration
From
void vDSP_fft_zript (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zript (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zriptD()
Declaration
From
void vDSP_fft_zriptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zriptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zrop()
Declaration
From
void vDSP_fft_zrop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zrop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zropD()
Declaration
From
void vDSP_fft_zropD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zropD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zropt()
Declaration
From
void vDSP_fft_zropt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zropt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fft_zroptD()
Declaration
From
void vDSP_fft_zroptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fft_zroptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    FFTDirection __Direction
);

Modified vDSP_fftm_zip()
Declaration
From
void vDSP_fftm_zip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zipD()
Declaration
From
void vDSP_fftm_zipD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zipD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zipt()
Declaration
From
void vDSP_fftm_zipt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zipt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_ziptD()
Declaration
From
void vDSP_fftm_ziptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_ziptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zop()
Declaration
From
void vDSP_fftm_zop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zopD()
Declaration
From
void vDSP_fftm_zopD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zopD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zopt()
Declaration
From
void vDSP_fftm_zopt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zopt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zoptD()
Declaration
From
void vDSP_fftm_zoptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zoptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zrip()
Declaration
From
void vDSP_fftm_zrip (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zrip (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zripD()
Declaration
From
void vDSP_fftm_zripD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zripD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zript()
Declaration
From
void vDSP_fftm_zript (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zript (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zriptD()
Declaration
From
void vDSP_fftm_zriptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IM,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zriptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IM,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zrop()
Declaration
From
void vDSP_fftm_zrop (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zrop (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zropD()
Declaration
From
void vDSP_fftm_zropD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zropD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zropt()
Declaration
From
void vDSP_fftm_zropt (
    FFTSetup __vDSP_Setup,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zropt (
    FFTSetup _Nonnull __Setup,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_fftm_zroptD()
Declaration
From
void vDSP_fftm_zroptD (
    FFTSetupD __vDSP_Setup,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Stride __vDSP_IMA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Stride __vDSP_IMC,
    const DSPDoubleSplitComplex *__vDSP_Buffer,
    vDSP_Length __vDSP_Log2N,
    vDSP_Length __vDSP_M,
    FFTDirection __vDSP_Direction
);
To
void vDSP_fftm_zroptD (
    FFTSetupD _Nonnull __Setup,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Stride __IMA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Stride __IMC,
    const DSPDoubleSplitComplex * _Nonnull __Buffer,
    vDSP_Length __Log2N,
    vDSP_Length __M,
    FFTDirection __Direction
);

Modified vDSP_hamm_window()
Declaration
From
void vDSP_hamm_window (
    float *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Flag
);
To
void vDSP_hamm_window (
    float * _Nonnull __C,
    vDSP_Length __N,
    int __Flag
);

Modified vDSP_hamm_windowD()
Declaration
From
void vDSP_hamm_windowD (
    double *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Flag
);
To
void vDSP_hamm_windowD (
    double * _Nonnull __C,
    vDSP_Length __N,
    int __Flag
);

Modified vDSP_hann_window()
Declaration
From
void vDSP_hann_window (
    float *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Flag
);
To
void vDSP_hann_window (
    float * _Nonnull __C,
    vDSP_Length __N,
    int __Flag
);

Modified vDSP_hann_windowD()
Declaration
From
void vDSP_hann_windowD (
    double *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Flag
);
To
void vDSP_hann_windowD (
    double * _Nonnull __C,
    vDSP_Length __N,
    int __Flag
);

Modified vDSP_imgfir()
Declaration
From
void vDSP_imgfir (
    const float *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const float *__vDSP_F,
    float *__vDSP_C,
    vDSP_Length __vDSP_P,
    vDSP_Length __vDSP_Q
);
To
void vDSP_imgfir (
    const float * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const float * _Nonnull __F,
    float * _Nonnull __C,
    vDSP_Length __P,
    vDSP_Length __Q
);

Modified vDSP_imgfirD()
Declaration
From
void vDSP_imgfirD (
    const double *__vDSP_A,
    vDSP_Length __vDSP_NR,
    vDSP_Length __vDSP_NC,
    const double *__vDSP_F,
    double *__vDSP_C,
    vDSP_Length __vDSP_P,
    vDSP_Length __vDSP_Q
);
To
void vDSP_imgfirD (
    const double * _Nonnull __A,
    vDSP_Length __NR,
    vDSP_Length __NC,
    const double * _Nonnull __F,
    double * _Nonnull __C,
    vDSP_Length __P,
    vDSP_Length __Q
);

Modified vDSP_maxmgv()
Declaration
From
void vDSP_maxmgv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxmgv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_maxmgvD()
Declaration
From
void vDSP_maxmgvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxmgvD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_maxmgvi()
Declaration
From
void vDSP_maxmgvi (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxmgvi (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_maxmgviD()
Declaration
From
void vDSP_maxmgviD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxmgviD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_maxv()
Declaration
From
void vDSP_maxv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_maxvD()
Declaration
From
void vDSP_maxvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_I,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxvD (
    const double * _Nonnull __A,
    vDSP_Stride __I,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_maxvi()
Declaration
From
void vDSP_maxvi (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxvi (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_maxviD()
Declaration
From
void vDSP_maxviD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_maxviD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_meamgv()
Declaration
From
void vDSP_meamgv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_meamgv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_meamgvD()
Declaration
From
void vDSP_meamgvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_meamgvD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_meanv()
Declaration
From
void vDSP_meanv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_meanv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_meanvD()
Declaration
From
void vDSP_meanvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_meanvD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_measqv()
Declaration
From
void vDSP_measqv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_measqv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_measqvD()
Declaration
From
void vDSP_measqvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_I,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_measqvD (
    const double * _Nonnull __A,
    vDSP_Stride __I,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_minmgv()
Declaration
From
void vDSP_minmgv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_minmgv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_minmgvD()
Declaration
From
void vDSP_minmgvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_minmgvD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_minmgvi()
Declaration
From
void vDSP_minmgvi (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_minmgvi (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_minmgviD()
Declaration
From
void vDSP_minmgviD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_minmgviD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_minv()
Declaration
From
void vDSP_minv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_minv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_minvD()
Declaration
From
void vDSP_minvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_minvD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_minvi()
Declaration
From
void vDSP_minvi (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_minvi (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_minviD()
Declaration
From
void vDSP_minviD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length __vDSP_N
);
To
void vDSP_minviD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length __N
);

Modified vDSP_mmov()
Declaration
From
void vDSP_mmov (
    const float *__vDSP_A,
    float *__vDSP_C,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_TA,
    vDSP_Length __vDSP_TC
);
To
void vDSP_mmov (
    const float * _Nonnull __A,
    float * _Nonnull __C,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __TA,
    vDSP_Length __TC
);

Modified vDSP_mmovD()
Declaration
From
void vDSP_mmovD (
    const double *__vDSP_A,
    double *__vDSP_C,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_TA,
    vDSP_Length __vDSP_TC
);
To
void vDSP_mmovD (
    const double * _Nonnull __A,
    double * _Nonnull __C,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __TA,
    vDSP_Length __TC
);

Modified vDSP_mmul()
Declaration
From
void vDSP_mmul (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_mmul (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_mmulD()
Declaration
From
void vDSP_mmulD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_mmulD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_mtrans()
Declaration
From
void vDSP_mtrans (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N
);
To
void vDSP_mtrans (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N
);

Modified vDSP_mtransD()
Declaration
From
void vDSP_mtransD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N
);
To
void vDSP_mtransD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N
);

Modified vDSP_mvessq()
Declaration
From
void vDSP_mvessq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_mvessq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_mvessqD()
Declaration
From
void vDSP_mvessqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_mvessqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_normalize()
Declaration
From
void vDSP_normalize (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_Mean,
    float *__vDSP_StandardDeviation,
    vDSP_Length __vDSP_N
);
To
void vDSP_normalize (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nullable __C,
    vDSP_Stride __IC,
    float * _Nonnull __Mean,
    float * _Nonnull __StandardDeviation,
    vDSP_Length __N
);

Modified vDSP_normalizeD()
Declaration
From
void vDSP_normalizeD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_Mean,
    double *__vDSP_StandardDeviation,
    vDSP_Length __vDSP_N
);
To
void vDSP_normalizeD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nullable __C,
    vDSP_Stride __IC,
    double * _Nonnull __Mean,
    double * _Nonnull __StandardDeviation,
    vDSP_Length __N
);

Modified vDSP_nzcros()
Declaration
From
void vDSP_nzcros (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Length __vDSP_B,
    vDSP_Length *__vDSP_C,
    vDSP_Length *__vDSP_D,
    vDSP_Length __vDSP_N
);
To
void vDSP_nzcros (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Length __B,
    vDSP_Length * _Nonnull __C,
    vDSP_Length * _Nonnull __D,
    vDSP_Length __N
);

Modified vDSP_nzcrosD()
Declaration
From
void vDSP_nzcrosD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    vDSP_Length __vDSP_B,
    vDSP_Length *__vDSP_C,
    vDSP_Length *__vDSP_D,
    vDSP_Length __vDSP_N
);
To
void vDSP_nzcrosD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    vDSP_Length __B,
    vDSP_Length * _Nonnull __C,
    vDSP_Length * _Nonnull __D,
    vDSP_Length __N
);

Modified vDSP_polar()
Declaration
From
void vDSP_polar (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_polar (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_polarD()
Declaration
From
void vDSP_polarD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_polarD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_rect()
Declaration
From
void vDSP_rect (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_rect (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_rectD()
Declaration
From
void vDSP_rectD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_rectD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_rmsqv()
Declaration
From
void vDSP_rmsqv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_rmsqv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_rmsqvD()
Declaration
From
void vDSP_rmsqvD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_rmsqvD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svdiv()
Declaration
From
void vDSP_svdiv (
    const float *__vDSP_A,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_svdiv (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_svdivD()
Declaration
From
void vDSP_svdivD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_svdivD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_sve()
Declaration
From
void vDSP_sve (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_I,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_sve (
    const float * _Nonnull __A,
    vDSP_Stride __I,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_sve_svesq()
Declaration
From
void vDSP_sve_svesq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_Sum,
    float *__vDSP_SumOfSquares,
    vDSP_Length __vDSP_N
);
To
void vDSP_sve_svesq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __Sum,
    float * _Nonnull __SumOfSquares,
    vDSP_Length __N
);

Modified vDSP_sve_svesqD()
Declaration
From
void vDSP_sve_svesqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_Sum,
    double *__vDSP_SumOfSquares,
    vDSP_Length __vDSP_N
);
To
void vDSP_sve_svesqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __Sum,
    double * _Nonnull __SumOfSquares,
    vDSP_Length __N
);

Modified vDSP_sveD()
Declaration
From
void vDSP_sveD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_I,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_sveD (
    const double * _Nonnull __A,
    vDSP_Stride __I,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svemg()
Declaration
From
void vDSP_svemg (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_svemg (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svemgD()
Declaration
From
void vDSP_svemgD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_svemgD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svesq()
Declaration
From
void vDSP_svesq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_svesq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svesqD()
Declaration
From
void vDSP_svesqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_svesqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svs()
Declaration
From
void vDSP_svs (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_svs (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_svsD()
Declaration
From
void vDSP_svsD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_svsD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_vaam()
Declaration
From
void vDSP_vaam (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vaam (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    vDSP_Stride __ID,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vaamD()
Declaration
From
void vDSP_vaamD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vaamD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    vDSP_Stride __ID,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vabs()
Declaration
From
void vDSP_vabs (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vabs (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vabsD()
Declaration
From
void vDSP_vabsD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vabsD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vabsi()
Declaration
From
void vDSP_vabsi (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vabsi (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vadd()
Declaration
From
void vDSP_vadd (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vadd (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vaddD()
Declaration
From
void vDSP_vaddD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vaddD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vaddi()
Declaration
From
void vDSP_vaddi (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const int *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vaddi (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    const int * _Nonnull __B,
    vDSP_Stride __IB,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vaddsub()
Declaration
From
void vDSP_vaddsub (
    const float *__vDSP_I0,
    vDSP_Stride __vDSP_I0S,
    const float *__vDSP_I1,
    vDSP_Stride __vDSP_I1S,
    float *__vDSP_O0,
    vDSP_Stride __vDSP_O0S,
    float *__vDSP_O1,
    vDSP_Stride __vDSP_O1S,
    vDSP_Length __vDSP_N
);
To
void vDSP_vaddsub (
    const float * _Nonnull __I0,
    vDSP_Stride __I0S,
    const float * _Nonnull __I1,
    vDSP_Stride __I1S,
    float * _Nonnull __O0,
    vDSP_Stride __O0S,
    float * _Nonnull __O1,
    vDSP_Stride __O1S,
    vDSP_Length __N
);

Modified vDSP_vaddsubD()
Declaration
From
void vDSP_vaddsubD (
    const double *__vDSP_I0,
    vDSP_Stride __vDSP_I0S,
    const double *__vDSP_I1,
    vDSP_Stride __vDSP_I1S,
    double *__vDSP_O0,
    vDSP_Stride __vDSP_O0S,
    double *__vDSP_O1,
    vDSP_Stride __vDSP_O1S,
    vDSP_Length __vDSP_N
);
To
void vDSP_vaddsubD (
    const double * _Nonnull __I0,
    vDSP_Stride __I0S,
    const double * _Nonnull __I1,
    vDSP_Stride __I1S,
    double * _Nonnull __O0,
    vDSP_Stride __O0S,
    double * _Nonnull __O1,
    vDSP_Stride __O1S,
    vDSP_Length __N
);

Modified vDSP_vam()
Declaration
From
void vDSP_vam (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vam (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vamD()
Declaration
From
void vDSP_vamD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_IDD,
    vDSP_Length __vDSP_N
);
To
void vDSP_vamD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __IDD,
    vDSP_Length __N
);

Modified vDSP_vasbm()
Declaration
From
void vDSP_vasbm (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vasbm (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    vDSP_Stride __ID,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vasbmD()
Declaration
From
void vDSP_vasbmD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vasbmD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    vDSP_Stride __ID,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vasm()
Declaration
From
void vDSP_vasm (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vasm (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vasmD()
Declaration
From
void vDSP_vasmD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vasmD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vavlin()
Declaration
From
void vDSP_vavlin (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vavlin (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vavlinD()
Declaration
From
void vDSP_vavlinD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vavlinD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vclip()
Declaration
From
void vDSP_vclip (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vclip (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vclipc()
Declaration
From
void vDSP_vclipc (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N,
    vDSP_Length *__vDSP_NLow,
    vDSP_Length *__vDSP_NHigh
);
To
void vDSP_vclipc (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N,
    vDSP_Length * _Nonnull __NLow,
    vDSP_Length * _Nonnull __NHigh
);

Modified vDSP_vclipcD()
Declaration
From
void vDSP_vclipcD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N,
    vDSP_Length *__vDSP_NLow,
    vDSP_Length *__vDSP_NHigh
);
To
void vDSP_vclipcD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N,
    vDSP_Length * _Nonnull __NLow,
    vDSP_Length * _Nonnull __NHigh
);

Modified vDSP_vclipD()
Declaration
From
void vDSP_vclipD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vclipD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vclr()
Declaration
From
void vDSP_vclr (
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vclr (
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vclrD()
Declaration
From
void vDSP_vclrD (
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vclrD (
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vcmprs()
Declaration
From
void vDSP_vcmprs (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vcmprs (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vcmprsD()
Declaration
From
void vDSP_vcmprsD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vcmprsD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vdbcon()
Declaration
From
void vDSP_vdbcon (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    unsigned int __vDSP_F
);
To
void vDSP_vdbcon (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    unsigned int __F
);

Modified vDSP_vdbconD()
Declaration
From
void vDSP_vdbconD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    unsigned int __vDSP_F
);
To
void vDSP_vdbconD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    unsigned int __F
);

Modified vDSP_vdist()
Declaration
From
void vDSP_vdist (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_J,
    float *__vDSP_C,
    vDSP_Stride __vDSP_K,
    vDSP_Length __vDSP_N
);
To
void vDSP_vdist (
    const float * _Nonnull __A,
    vDSP_Stride __I,
    const float * _Nonnull __B,
    vDSP_Stride __J,
    float * _Nonnull __C,
    vDSP_Stride __K,
    vDSP_Length __N
);

Modified vDSP_vdistD()
Declaration
From
void vDSP_vdistD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_J,
    double *__vDSP_C,
    vDSP_Stride __vDSP_K,
    vDSP_Length __vDSP_N
);
To
void vDSP_vdistD (
    const double * _Nonnull __A,
    vDSP_Stride __I,
    const double * _Nonnull __B,
    vDSP_Stride __J,
    double * _Nonnull __C,
    vDSP_Stride __K,
    vDSP_Length __N
);

Modified vDSP_vdiv()
Declaration
From
void vDSP_vdiv (
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vdiv (
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vdivD()
Declaration
From
void vDSP_vdivD (
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vdivD (
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vdivi()
Declaration
From
void vDSP_vdivi (
    const int *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vdivi (
    const int * _Nonnull __B,
    vDSP_Stride __IB,
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vdpsp()
Declaration
From
void vDSP_vdpsp (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vdpsp (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_venvlp()
Declaration
From
void vDSP_venvlp (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_venvlp (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_venvlpD()
Declaration
From
void vDSP_venvlpD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_venvlpD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_veqvi()
Declaration
From
void vDSP_veqvi (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const int *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_veqvi (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    const int * _Nonnull __B,
    vDSP_Stride __IB,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfill()
Declaration
From
void vDSP_vfill (
    const float *__vDSP_A,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IA,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfill (
    const float * _Nonnull __A,
    float * _Nonnull __C,
    vDSP_Stride __IA,
    vDSP_Length __N
);

Modified vDSP_vfillD()
Declaration
From
void vDSP_vfillD (
    const double *__vDSP_A,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfillD (
    const double * _Nonnull __A,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfilli()
Declaration
From
void vDSP_vfilli (
    const int *__vDSP_A,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfilli (
    const int * _Nonnull __A,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfix16()
Declaration
From
void vDSP_vfix16 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfix16 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfix16D()
Declaration
From
void vDSP_vfix16D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfix16D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfix32()
Declaration
From
void vDSP_vfix32 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfix32 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfix32D()
Declaration
From
void vDSP_vfix32D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfix32D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfix8()
Declaration
From
void vDSP_vfix8 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfix8 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfix8D()
Declaration
From
void vDSP_vfix8D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfix8D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixr16()
Declaration
From
void vDSP_vfixr16 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixr16 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixr16D()
Declaration
From
void vDSP_vfixr16D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixr16D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixr32()
Declaration
From
void vDSP_vfixr32 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixr32 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixr32D()
Declaration
From
void vDSP_vfixr32D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixr32D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixr8()
Declaration
From
void vDSP_vfixr8 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixr8 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixr8D()
Declaration
From
void vDSP_vfixr8D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixr8D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixru16()
Declaration
From
void vDSP_vfixru16 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixru16 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixru16D()
Declaration
From
void vDSP_vfixru16D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixru16D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixru32()
Declaration
From
void vDSP_vfixru32 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixru32 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixru32D()
Declaration
From
void vDSP_vfixru32D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixru32D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixru8()
Declaration
From
void vDSP_vfixru8 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixru8 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixru8D()
Declaration
From
void vDSP_vfixru8D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixru8D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixu16()
Declaration
From
void vDSP_vfixu16 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixu16 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixu16D()
Declaration
From
void vDSP_vfixu16D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned short *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixu16D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned short * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixu32()
Declaration
From
void vDSP_vfixu32 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixu32 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixu32D()
Declaration
From
void vDSP_vfixu32D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixu32D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixu8()
Declaration
From
void vDSP_vfixu8 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixu8 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfixu8D()
Declaration
From
void vDSP_vfixu8D (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    unsigned char *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfixu8D (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    unsigned char * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt16()
Declaration
From
void vDSP_vflt16 (
    const short *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt16 (
    const short * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt16D()
Declaration
From
void vDSP_vflt16D (
    const short *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt16D (
    const short * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt24()
Declaration
From
void vDSP_vflt24 (
    const vDSP_int24 *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt24 (
    const vDSP_int24 * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt32()
Declaration
From
void vDSP_vflt32 (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt32 (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt32D()
Declaration
From
void vDSP_vflt32D (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt32D (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt8()
Declaration
From
void vDSP_vflt8 (
    const char *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt8 (
    const char * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vflt8D()
Declaration
From
void vDSP_vflt8D (
    const char *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vflt8D (
    const char * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltsm24()
Declaration
From
void vDSP_vfltsm24 (
    const vDSP_int24 *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltsm24 (
    const vDSP_int24 * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltsmu24()
Declaration
From
void vDSP_vfltsmu24 (
    const vDSP_uint24 *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltsmu24 (
    const vDSP_uint24 * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu16()
Declaration
From
void vDSP_vfltu16 (
    const unsigned short *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu16 (
    const unsigned short * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu16D()
Declaration
From
void vDSP_vfltu16D (
    const unsigned short *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu16D (
    const unsigned short * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu24()
Declaration
From
void vDSP_vfltu24 (
    const vDSP_uint24 *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu24 (
    const vDSP_uint24 * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu32()
Declaration
From
void vDSP_vfltu32 (
    const unsigned int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu32 (
    const unsigned int * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu32D()
Declaration
From
void vDSP_vfltu32D (
    const unsigned int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu32D (
    const unsigned int * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu8()
Declaration
From
void vDSP_vfltu8 (
    const unsigned char *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu8 (
    const unsigned char * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfltu8D()
Declaration
From
void vDSP_vfltu8D (
    const unsigned char *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfltu8D (
    const unsigned char * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfrac()
Declaration
From
void vDSP_vfrac (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfrac (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vfracD()
Declaration
From
void vDSP_vfracD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vfracD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgathr()
Declaration
From
void vDSP_vgathr (
    const float *__vDSP_A,
    const vDSP_Length *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vgathr (
    const float * _Nonnull __A,
    const vDSP_Length * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgathra()
Declaration
From
void vDSP_vgathra (
    const float **__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vgathra (
    const float * _Nonnull * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgathraD()
Declaration
From
void vDSP_vgathraD (
    const double **__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vgathraD (
    const double * _Nonnull * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgathrD()
Declaration
From
void vDSP_vgathrD (
    const double *__vDSP_A,
    const vDSP_Length *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vgathrD (
    const double * _Nonnull __A,
    const vDSP_Length * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgen()
Declaration
From
void vDSP_vgen (
    const float *__vDSP_A,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vgen (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgenD()
Declaration
From
void vDSP_vgenD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vgenD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vgenp()
Declaration
From
void vDSP_vgenp (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_M
);
To
void vDSP_vgenp (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __M
);

Modified vDSP_vgenpD()
Declaration
From
void vDSP_vgenpD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_M
);
To
void vDSP_vgenpD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __M
);

Modified vDSP_viclip()
Declaration
From
void vDSP_viclip (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_viclip (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_viclipD()
Declaration
From
void vDSP_viclipD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_viclipD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vindex()
Declaration
From
void vDSP_vindex (
    const float *__vDSP_A,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vindex (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vindexD()
Declaration
From
void vDSP_vindexD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vindexD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vintb()
Declaration
From
void vDSP_vintb (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vintb (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vintbD()
Declaration
From
void vDSP_vintbD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vintbD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vlim()
Declaration
From
void vDSP_vlim (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vlim (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vlimD()
Declaration
From
void vDSP_vlimD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vlimD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vlint()
Declaration
From
void vDSP_vlint (
    const float *__vDSP_A,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_M
);
To
void vDSP_vlint (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __M
);

Modified vDSP_vlintD()
Declaration
From
void vDSP_vlintD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_M
);
To
void vDSP_vlintD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __M
);

Modified vDSP_vma()
Declaration
From
void vDSP_vma (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vma (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vmaD()
Declaration
From
void vDSP_vmaD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmaD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vmax()
Declaration
From
void vDSP_vmax (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmax (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vmaxD()
Declaration
From
void vDSP_vmaxD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmaxD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vmaxmg()
Declaration
From
void vDSP_vmaxmg (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmaxmg (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vmaxmgD()
Declaration
From
void vDSP_vmaxmgD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmaxmgD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vmin()
Declaration
From
void vDSP_vmin (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmin (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vminD()
Declaration
From
void vDSP_vminD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vminD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vminmg()
Declaration
From
void vDSP_vminmg (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vminmg (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vminmgD()
Declaration
From
void vDSP_vminmgD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vminmgD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vmma()
Declaration
From
void vDSP_vmma (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmma (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    vDSP_Stride __ID,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vmmaD()
Declaration
From
void vDSP_vmmaD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmmaD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    vDSP_Stride __ID,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vmmsb()
Declaration
From
void vDSP_vmmsb (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmmsb (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    vDSP_Stride __ID,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vmmsbD()
Declaration
From
void vDSP_vmmsbD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmmsbD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    vDSP_Stride __ID,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vmsa()
Declaration
From
void vDSP_vmsa (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmsa (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vmsaD()
Declaration
From
void vDSP_vmsaD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmsaD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vmsb()
Declaration
From
void vDSP_vmsb (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmsb (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vmsbD()
Declaration
From
void vDSP_vmsbD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmsbD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vmul()
Declaration
From
void vDSP_vmul (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmul (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vmulD()
Declaration
From
void vDSP_vmulD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vmulD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vnabs()
Declaration
From
void vDSP_vnabs (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vnabs (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vnabsD()
Declaration
From
void vDSP_vnabsD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vnabsD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vneg()
Declaration
From
void vDSP_vneg (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vneg (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vnegD()
Declaration
From
void vDSP_vnegD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vnegD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vpoly()
Declaration
From
void vDSP_vpoly (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_vpoly (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_vpolyD()
Declaration
From
void vDSP_vpolyD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_vpolyD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_vpythg()
Declaration
From
void vDSP_vpythg (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vpythg (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    vDSP_Stride __ID,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vpythgD()
Declaration
From
void vDSP_vpythgD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vpythgD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    vDSP_Stride __ID,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vqint()
Declaration
From
void vDSP_vqint (
    const float *__vDSP_A,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_M
);
To
void vDSP_vqint (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __M
);

Modified vDSP_vqintD()
Declaration
From
void vDSP_vqintD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_M
);
To
void vDSP_vqintD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __M
);

Modified vDSP_vramp()
Declaration
From
void vDSP_vramp (
    const float *__vDSP_A,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vramp (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vrampD()
Declaration
From
void vDSP_vrampD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vrampmul()
Declaration
From
void vDSP_vrampmul (
    const float *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    float *__vDSP_Start,
    const float *__vDSP_Step,
    float *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul (
    const float * _Nonnull __I,
    vDSP_Stride __IS,
    float * _Nonnull __Start,
    const float * _Nonnull __Step,
    float * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmul2()
Declaration
From
void vDSP_vrampmul2 (
    const float *__vDSP_I0,
    const float *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    float *__vDSP_Start,
    const float *__vDSP_Step,
    float *__vDSP_O0,
    float *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul2 (
    const float * _Nonnull __I0,
    const float * _Nonnull __I1,
    vDSP_Stride __IS,
    float * _Nonnull __Start,
    const float * _Nonnull __Step,
    float * _Nonnull __O0,
    float * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmul2_s1_15()
Declaration
From
void vDSP_vrampmul2_s1_15 (
    const short *__vDSP_I0,
    const short *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    short *__vDSP_Start,
    const short *__vDSP_Step,
    short *__vDSP_O0,
    short *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul2_s1_15 (
    const short * _Nonnull __I0,
    const short * _Nonnull __I1,
    vDSP_Stride __IS,
    short * _Nonnull __Start,
    const short * _Nonnull __Step,
    short * _Nonnull __O0,
    short * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmul2_s8_24()
Declaration
From
void vDSP_vrampmul2_s8_24 (
    const int *__vDSP_I0,
    const int *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    int *__vDSP_Start,
    const int *__vDSP_Step,
    int *__vDSP_O0,
    int *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul2_s8_24 (
    const int * _Nonnull __I0,
    const int * _Nonnull __I1,
    vDSP_Stride __IS,
    int * _Nonnull __Start,
    const int * _Nonnull __Step,
    int * _Nonnull __O0,
    int * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmul2D()
Declaration
From
void vDSP_vrampmul2D (
    const double *__vDSP_I0,
    const double *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    double *__vDSP_Start,
    const double *__vDSP_Step,
    double *__vDSP_O0,
    double *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul2D (
    const double * _Nonnull __I0,
    const double * _Nonnull __I1,
    vDSP_Stride __IS,
    double * _Nonnull __Start,
    const double * _Nonnull __Step,
    double * _Nonnull __O0,
    double * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmul_s1_15()
Declaration
From
void vDSP_vrampmul_s1_15 (
    const short *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    short *__vDSP_Start,
    const short *__vDSP_Step,
    short *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul_s1_15 (
    const short * _Nonnull __I,
    vDSP_Stride __IS,
    short * _Nonnull __Start,
    const short * _Nonnull __Step,
    short * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmul_s8_24()
Declaration
From
void vDSP_vrampmul_s8_24 (
    const int *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    int *__vDSP_Start,
    const int *__vDSP_Step,
    int *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmul_s8_24 (
    const int * _Nonnull __I,
    vDSP_Stride __IS,
    int * _Nonnull __Start,
    const int * _Nonnull __Step,
    int * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd()
Declaration
From
void vDSP_vrampmuladd (
    const float *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    float *__vDSP_Start,
    const float *__vDSP_Step,
    float *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd (
    const float * _Nonnull __I,
    vDSP_Stride __IS,
    float * _Nonnull __Start,
    const float * _Nonnull __Step,
    float * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd2()
Declaration
From
void vDSP_vrampmuladd2 (
    const float *__vDSP_I0,
    const float *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    float *__vDSP_Start,
    const float *__vDSP_Step,
    float *__vDSP_O0,
    float *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd2 (
    const float * _Nonnull __I0,
    const float * _Nonnull __I1,
    vDSP_Stride __IS,
    float * _Nonnull __Start,
    const float * _Nonnull __Step,
    float * _Nonnull __O0,
    float * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd2_s1_15()
Declaration
From
void vDSP_vrampmuladd2_s1_15 (
    const short *__vDSP_I0,
    const short *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    short *__vDSP_Start,
    const short *__vDSP_Step,
    short *__vDSP_O0,
    short *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd2_s1_15 (
    const short * _Nonnull __I0,
    const short * _Nonnull __I1,
    vDSP_Stride __IS,
    short * _Nonnull __Start,
    const short * _Nonnull __Step,
    short * _Nonnull __O0,
    short * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd2_s8_24()
Declaration
From
void vDSP_vrampmuladd2_s8_24 (
    const int *__vDSP_I0,
    const int *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    int *__vDSP_Start,
    const int *__vDSP_Step,
    int *__vDSP_O0,
    int *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd2_s8_24 (
    const int * _Nonnull __I0,
    const int * _Nonnull __I1,
    vDSP_Stride __IS,
    int * _Nonnull __Start,
    const int * _Nonnull __Step,
    int * _Nonnull __O0,
    int * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd2D()
Declaration
From
void vDSP_vrampmuladd2D (
    const double *__vDSP_I0,
    const double *__vDSP_I1,
    vDSP_Stride __vDSP_IS,
    double *__vDSP_Start,
    const double *__vDSP_Step,
    double *__vDSP_O0,
    double *__vDSP_O1,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd2D (
    const double * _Nonnull __I0,
    const double * _Nonnull __I1,
    vDSP_Stride __IS,
    double * _Nonnull __Start,
    const double * _Nonnull __Step,
    double * _Nonnull __O0,
    double * _Nonnull __O1,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd_s1_15()
Declaration
From
void vDSP_vrampmuladd_s1_15 (
    const short *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    short *__vDSP_Start,
    const short *__vDSP_Step,
    short *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd_s1_15 (
    const short * _Nonnull __I,
    vDSP_Stride __IS,
    short * _Nonnull __Start,
    const short * _Nonnull __Step,
    short * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladd_s8_24()
Declaration
From
void vDSP_vrampmuladd_s8_24 (
    const int *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    int *__vDSP_Start,
    const int *__vDSP_Step,
    int *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladd_s8_24 (
    const int * _Nonnull __I,
    vDSP_Stride __IS,
    int * _Nonnull __Start,
    const int * _Nonnull __Step,
    int * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmuladdD()
Declaration
From
void vDSP_vrampmuladdD (
    const double *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    double *__vDSP_Start,
    const double *__vDSP_Step,
    double *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmuladdD (
    const double * _Nonnull __I,
    vDSP_Stride __IS,
    double * _Nonnull __Start,
    const double * _Nonnull __Step,
    double * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrampmulD()
Declaration
From
void vDSP_vrampmulD (
    const double *__vDSP_I,
    vDSP_Stride __vDSP_IS,
    double *__vDSP_Start,
    const double *__vDSP_Step,
    double *__vDSP_O,
    vDSP_Stride __vDSP_OS,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrampmulD (
    const double * _Nonnull __I,
    vDSP_Stride __IS,
    double * _Nonnull __Start,
    const double * _Nonnull __Step,
    double * _Nonnull __O,
    vDSP_Stride __OS,
    vDSP_Length __N
);

Modified vDSP_vrsum()
Declaration
From
void vDSP_vrsum (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_S,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrsum (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __S,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vrsumD()
Declaration
From
void vDSP_vrsumD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_S,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrsumD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __S,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vrvrs()
Declaration
From
void vDSP_vrvrs (
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrvrs (
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vrvrsD()
Declaration
From
void vDSP_vrvrsD (
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vrvrsD (
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsadd()
Declaration
From
void vDSP_vsadd (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsadd (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsaddD()
Declaration
From
void vDSP_vsaddD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsaddD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsaddi()
Declaration
From
void vDSP_vsaddi (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const int *__vDSP_B,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsaddi (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    const int * _Nonnull __B,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsbm()
Declaration
From
void vDSP_vsbm (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsbm (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsbmD()
Declaration
From
void vDSP_vsbmD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsbmD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsbsbm()
Declaration
From
void vDSP_vsbsbm (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsbsbm (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    vDSP_Stride __ID,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vsbsbmD()
Declaration
From
void vDSP_vsbsbmD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsbsbmD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    vDSP_Stride __ID,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vsbsm()
Declaration
From
void vDSP_vsbsm (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsbsm (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsbsmD()
Declaration
From
void vDSP_vsbsmD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsbsmD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsdiv()
Declaration
From
void vDSP_vsdiv (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsdiv (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsdivD()
Declaration
From
void vDSP_vsdivD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsdivD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsdivi()
Declaration
From
void vDSP_vsdivi (
    const int *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const int *__vDSP_B,
    int *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsdivi (
    const int * _Nonnull __A,
    vDSP_Stride __IA,
    const int * _Nonnull __B,
    int * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsimps()
Declaration
From
void vDSP_vsimps (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsimps (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsimpsD()
Declaration
From
void vDSP_vsimpsD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsimpsD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsma()
Declaration
From
void vDSP_vsma (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsma (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsmaD()
Declaration
From
void vDSP_vsmaD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmaD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsmfix24()
Declaration
From
void vDSP_vsmfix24 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_int24 *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmfix24 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_int24 * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsmfixu24()
Declaration
From
void vDSP_vsmfixu24 (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_uint24 *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmfixu24 (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_uint24 * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsmsa()
Declaration
From
void vDSP_vsmsa (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmsa (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vsmsaD()
Declaration
From
void vDSP_vsmsaD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    double *__vDSP_ID,
    vDSP_Stride __vDSP_L,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmsaD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    double * _Nonnull __ID,
    vDSP_Stride __L,
    vDSP_Length __N
);

Modified vDSP_vsmsb()
Declaration
From
void vDSP_vsmsb (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const float *__vDSP_B,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_K,
    float *__vDSP_D,
    vDSP_Stride __vDSP_L,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmsb (
    const float * _Nonnull __A,
    vDSP_Stride __I,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    vDSP_Stride __K,
    float * _Nonnull __D,
    vDSP_Stride __L,
    vDSP_Length __N
);

Modified vDSP_vsmsbD()
Declaration
From
void vDSP_vsmsbD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const double *__vDSP_B,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_K,
    double *__vDSP_D,
    vDSP_Stride __vDSP_L,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmsbD (
    const double * _Nonnull __A,
    vDSP_Stride __I,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    vDSP_Stride __K,
    double * _Nonnull __D,
    vDSP_Stride __L,
    vDSP_Length __N
);

Modified vDSP_vsmsma()
Declaration
From
void vDSP_vsmsma (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const float *__vDSP_D,
    float *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmsma (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    vDSP_Stride __IC,
    const float * _Nonnull __D,
    float * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vsmsmaD()
Declaration
From
void vDSP_vsmsmaD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const double *__vDSP_D,
    double *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmsmaD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    vDSP_Stride __IC,
    const double * _Nonnull __D,
    double * _Nonnull __E,
    vDSP_Stride __IE,
    vDSP_Length __N
);

Modified vDSP_vsmul()
Declaration
From
void vDSP_vsmul (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmul (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsmulD()
Declaration
From
void vDSP_vsmulD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsmulD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsort()
Declaration
From
void vDSP_vsort (
    float *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Order
);
To
void vDSP_vsort (
    float * _Nonnull __C,
    vDSP_Length __N,
    int __Order
);

Modified vDSP_vsortD()
Declaration
From
void vDSP_vsortD (
    double *__vDSP_C,
    vDSP_Length __vDSP_N,
    int __vDSP_Order
);
To
void vDSP_vsortD (
    double * _Nonnull __C,
    vDSP_Length __N,
    int __Order
);

Modified vDSP_vsorti()
Declaration
From
void vDSP_vsorti (
    const float *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length *__vDSP_Temporary,
    vDSP_Length __vDSP_N,
    int __vDSP_Order
);
To
void vDSP_vsorti (
    const float * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length * _Nullable __Temporary,
    vDSP_Length __N,
    int __Order
);

Modified vDSP_vsortiD()
Declaration
From
void vDSP_vsortiD (
    const double *__vDSP_C,
    vDSP_Length *__vDSP_I,
    vDSP_Length *__vDSP_Temporary,
    vDSP_Length __vDSP_N,
    int __vDSP_Order
);
To
void vDSP_vsortiD (
    const double * _Nonnull __C,
    vDSP_Length * _Nonnull __I,
    vDSP_Length * _Nullable __Temporary,
    vDSP_Length __N,
    int __Order
);

Modified vDSP_vspdp()
Declaration
From
void vDSP_vspdp (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vspdp (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsq()
Declaration
From
void vDSP_vsq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsqD()
Declaration
From
void vDSP_vsqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vssq()
Declaration
From
void vDSP_vssq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vssq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vssqD()
Declaration
From
void vDSP_vssqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vssqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsub()
Declaration
From
void vDSP_vsub (
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsub (
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vsubD()
Declaration
From
void vDSP_vsubD (
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vsubD (
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vswap()
Declaration
From
void vDSP_vswap (
    float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    vDSP_Length __vDSP_N
);
To
void vDSP_vswap (
    float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __B,
    vDSP_Stride __IB,
    vDSP_Length __N
);

Modified vDSP_vswapD()
Declaration
From
void vDSP_vswapD (
    double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    vDSP_Length __vDSP_N
);
To
void vDSP_vswapD (
    double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __B,
    vDSP_Stride __IB,
    vDSP_Length __N
);

Modified vDSP_vswmax()
Declaration
From
void vDSP_vswmax (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_WindowLength
);
To
void vDSP_vswmax (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __WindowLength
);

Modified vDSP_vswmaxD()
Declaration
From
void vDSP_vswmaxD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_WindowLength
);
To
void vDSP_vswmaxD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __WindowLength
);

Modified vDSP_vswsum()
Declaration
From
void vDSP_vswsum (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_vswsum (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_vswsumD()
Declaration
From
void vDSP_vswsumD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_vswsumD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_vtabi()
Declaration
From
void vDSP_vtabi (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_S1,
    const float *__vDSP_S2,
    const float *__vDSP_C,
    vDSP_Length __vDSP_M,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vtabi (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __S1,
    const float * _Nonnull __S2,
    const float * _Nonnull __C,
    vDSP_Length __M,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vtabiD()
Declaration
From
void vDSP_vtabiD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_S1,
    const double *__vDSP_S2,
    const double *__vDSP_C,
    vDSP_Length __vDSP_M,
    double *__vDSP_ID,
    vDSP_Stride __vDSP_L,
    vDSP_Length __vDSP_N
);
To
void vDSP_vtabiD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __S1,
    const double * _Nonnull __S2,
    const double * _Nonnull __C,
    vDSP_Length __M,
    double * _Nonnull __ID,
    vDSP_Stride __L,
    vDSP_Length __N
);

Modified vDSP_vthr()
Declaration
From
void vDSP_vthr (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vthr (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vthrD()
Declaration
From
void vDSP_vthrD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vthrD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vthres()
Declaration
From
void vDSP_vthres (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vthres (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vthresD()
Declaration
From
void vDSP_vthresD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vthresD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vthrsc()
Declaration
From
void vDSP_vthrsc (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    const float *__vDSP_C,
    float *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vthrsc (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    const float * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vthrscD()
Declaration
From
void vDSP_vthrscD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    const double *__vDSP_C,
    double *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_vthrscD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    const double * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_vtmerg()
Declaration
From
void vDSP_vtmerg (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vtmerg (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vtmergD()
Declaration
From
void vDSP_vtmergD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vtmergD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vtrapz()
Declaration
From
void vDSP_vtrapz (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vtrapz (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_vtrapzD()
Declaration
From
void vDSP_vtrapzD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_vtrapzD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_wiener()
Declaration
From
void vDSP_wiener (
    vDSP_Length __vDSP_L,
    const float *__vDSP_A,
    const float *__vDSP_C,
    float *__vDSP_F,
    float *__vDSP_P,
    int __vDSP_Flag,
    int *__vDSP_Error
);
To
void vDSP_wiener (
    vDSP_Length __L,
    const float * _Nonnull __A,
    const float * _Nonnull __C,
    float * _Nonnull __F,
    float * _Nonnull __P,
    int __Flag,
    int * _Nonnull __Error
);

Modified vDSP_wienerD()
Declaration
From
void vDSP_wienerD (
    vDSP_Length __vDSP_L,
    const double *__vDSP_A,
    const double *__vDSP_C,
    double *__vDSP_F,
    double *__vDSP_P,
    int __vDSP_Flag,
    int *__vDSP_Error
);
To
void vDSP_wienerD (
    vDSP_Length __L,
    const double * _Nonnull __A,
    const double * _Nonnull __C,
    double * _Nonnull __F,
    double * _Nonnull __P,
    int __Flag,
    int * _Nonnull __Error
);

Modified vDSP_zaspec()
Declaration
From
void vDSP_zaspec (
    const DSPSplitComplex *__vDSP_A,
    float *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zaspec (
    const DSPSplitComplex * _Nonnull __A,
    float * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zaspecD()
Declaration
From
void vDSP_zaspecD (
    const DSPDoubleSplitComplex *__vDSP_A,
    double *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zaspecD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    double * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zcoher()
Declaration
From
void vDSP_zcoher (
    const float *__vDSP_A,
    const float *__vDSP_B,
    const DSPSplitComplex *__vDSP_C,
    float *__vDSP_D,
    vDSP_Length __vDSP_N
);
To
void vDSP_zcoher (
    const float * _Nonnull __A,
    const float * _Nonnull __B,
    const DSPSplitComplex * _Nonnull __C,
    float * _Nonnull __D,
    vDSP_Length __N
);

Modified vDSP_zcoherD()
Declaration
From
void vDSP_zcoherD (
    const double *__vDSP_A,
    const double *__vDSP_B,
    const DSPDoubleSplitComplex *__vDSP_C,
    double *__vDSP_D,
    vDSP_Length __vDSP_N
);
To
void vDSP_zcoherD (
    const double * _Nonnull __A,
    const double * _Nonnull __B,
    const DSPDoubleSplitComplex * _Nonnull __C,
    double * _Nonnull __D,
    vDSP_Length __N
);

Modified vDSP_zconv()
Declaration
From
void vDSP_zconv (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zconv (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __F,
    vDSP_Stride __IF,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zconvD()
Declaration
From
void vDSP_zconvD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zconvD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __F,
    vDSP_Stride __IF,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zcspec()
Declaration
From
void vDSP_zcspec (
    const DSPSplitComplex *__vDSP_A,
    const DSPSplitComplex *__vDSP_B,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zcspec (
    const DSPSplitComplex * _Nonnull __A,
    const DSPSplitComplex * _Nonnull __B,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zcspecD()
Declaration
From
void vDSP_zcspecD (
    const DSPDoubleSplitComplex *__vDSP_A,
    const DSPDoubleSplitComplex *__vDSP_B,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zcspecD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    const DSPDoubleSplitComplex * _Nonnull __B,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zdotpr()
Declaration
From
void vDSP_zdotpr (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zdotpr (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zdotprD()
Declaration
From
void vDSP_zdotprD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zdotprD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zidotpr()
Declaration
From
void vDSP_zidotpr (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zidotpr (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zidotprD()
Declaration
From
void vDSP_zidotprD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zidotprD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zmma()
Declaration
From
void vDSP_zmma (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmma (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmmaD()
Declaration
From
void vDSP_zmmaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmmaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmms()
Declaration
From
void vDSP_zmms (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmms (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmmsD()
Declaration
From
void vDSP_zmmsD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmmsD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmmul()
Declaration
From
void vDSP_zmmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmmulD()
Declaration
From
void vDSP_zmmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmsm()
Declaration
From
void vDSP_zmsm (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmsm (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zmsmD()
Declaration
From
void vDSP_zmsmD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zmsmD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zrdesamp()
Declaration
From
void vDSP_zrdesamp (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const float *__vDSP_F,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zrdesamp (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __DF,
    const float * _Nonnull __F,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zrdesampD()
Declaration
From
void vDSP_zrdesampD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_I,
    const double *__vDSP_F,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
To
void vDSP_zrdesampD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __DF,
    const double * _Nonnull __F,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N,
    vDSP_Length __P
);

Modified vDSP_zrdotpr()
Declaration
From
void vDSP_zrdotpr (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrdotpr (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zrdotprD()
Declaration
From
void vDSP_zrdotprD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrdotprD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zrvadd()
Declaration
From
void vDSP_zrvadd (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvadd (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvaddD()
Declaration
From
void vDSP_zrvaddD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvaddD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvdiv()
Declaration
From
void vDSP_zrvdiv (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvdiv (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvdivD()
Declaration
From
void vDSP_zrvdivD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvdivD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvmul()
Declaration
From
void vDSP_zrvmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvmulD()
Declaration
From
void vDSP_zrvmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvsub()
Declaration
From
void vDSP_zrvsub (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvsub (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zrvsubD()
Declaration
From
void vDSP_zrvsubD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zrvsubD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_ztoc()
Declaration
From
void vDSP_ztoc (
    const DSPSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    DSPComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_ztoc (
    const DSPSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    DSPComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_ztocD()
Declaration
From
void vDSP_ztocD (
    const DSPDoubleSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    DSPDoubleComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_ztocD (
    const DSPDoubleSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    DSPDoubleComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_ztrans()
Declaration
From
void vDSP_ztrans (
    const float *__vDSP_A,
    const DSPSplitComplex *__vDSP_B,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_ztrans (
    const float * _Nonnull __A,
    const DSPSplitComplex * _Nonnull __B,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_ztransD()
Declaration
From
void vDSP_ztransD (
    const double *__vDSP_A,
    const DSPDoubleSplitComplex *__vDSP_B,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
To
void vDSP_ztransD (
    const double * _Nonnull __A,
    const DSPDoubleSplitComplex * _Nonnull __B,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);

Modified vDSP_zvabs()
Declaration
From
void vDSP_zvabs (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvabs (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvabsD()
Declaration
From
void vDSP_zvabsD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvabsD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvadd()
Declaration
From
void vDSP_zvadd (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvadd (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvaddD()
Declaration
From
void vDSP_zvaddD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvaddD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvcma()
Declaration
From
void vDSP_zvcma (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvcma (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_zvcmaD()
Declaration
From
void vDSP_zvcmaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvcmaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_zvcmul()
Declaration
From
void vDSP_zvcmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvcmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvcmulD()
Declaration
From
void vDSP_zvcmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_iC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvcmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __iC,
    vDSP_Length __N
);

Modified vDSP_zvconj()
Declaration
From
void vDSP_zvconj (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvconj (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvconjD()
Declaration
From
void vDSP_zvconjD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvconjD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvdiv()
Declaration
From
void vDSP_zvdiv (
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvdiv (
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvdivD()
Declaration
From
void vDSP_zvdivD (
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvdivD (
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvfill()
Declaration
From
void vDSP_zvfill (
    const DSPSplitComplex *__vDSP_A,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvfill (
    const DSPSplitComplex * _Nonnull __A,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvfillD()
Declaration
From
void vDSP_zvfillD (
    const DSPDoubleSplitComplex *__vDSP_A,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvfillD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvma()
Declaration
From
void vDSP_zvma (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvma (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_zvmaD()
Declaration
From
void vDSP_zvmaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_zvmags()
Declaration
From
void vDSP_zvmags (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmags (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvmagsD()
Declaration
From
void vDSP_zvmagsD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmagsD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvmgsa()
Declaration
From
void vDSP_zvmgsa (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmgsa (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvmgsaD()
Declaration
From
void vDSP_zvmgsaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmgsaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvmmaa()
Declaration
From
void vDSP_zvmmaa (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    const DSPSplitComplex *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    const DSPSplitComplex *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmmaa (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    const DSPSplitComplex * _Nonnull __E,
    vDSP_Stride __IE,
    const DSPSplitComplex * _Nonnull __F,
    vDSP_Stride __IF,
    vDSP_Length __N
);

Modified vDSP_zvmmaaD()
Declaration
From
void vDSP_zvmmaaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    const DSPDoubleSplitComplex *__vDSP_E,
    vDSP_Stride __vDSP_IE,
    const DSPDoubleSplitComplex *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmmaaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    const DSPDoubleSplitComplex * _Nonnull __E,
    vDSP_Stride __IE,
    const DSPDoubleSplitComplex * _Nonnull __F,
    vDSP_Stride __IF,
    vDSP_Length __N
);

Modified vDSP_zvmov()
Declaration
From
void vDSP_zvmov (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmov (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvmovD()
Declaration
From
void vDSP_zvmovD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvmovD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvmul()
Declaration
From
void vDSP_zvmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    int __vDSP_Conjugate
);
To
void vDSP_zvmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    int __Conjugate
);

Modified vDSP_zvmulD()
Declaration
From
void vDSP_zvmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    int __vDSP_Conjugate
);
To
void vDSP_zvmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    int __Conjugate
);

Modified vDSP_zvneg()
Declaration
From
void vDSP_zvneg (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvneg (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvnegD()
Declaration
From
void vDSP_zvnegD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvnegD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvphas()
Declaration
From
void vDSP_zvphas (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvphas (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvphasD()
Declaration
From
void vDSP_zvphasD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvphasD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvsma()
Declaration
From
void vDSP_zvsma (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvsma (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_zvsmaD()
Declaration
From
void vDSP_zvsmaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvsmaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);

Modified vDSP_zvsub()
Declaration
From
void vDSP_zvsub (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvsub (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvsubD()
Declaration
From
void vDSP_zvsubD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvsubD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvzsml()
Declaration
From
void vDSP_zvzsml (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvzsml (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vDSP_zvzsmlD()
Declaration
From
void vDSP_zvzsmlD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
To
void vDSP_zvzsmlD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);

Modified vmul()
DeclarationDeprecation
From
void vmul (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vmul (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vmulD()
DeclarationDeprecation
From
void vmulD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vmulD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vsmul()
DeclarationDeprecation
From
void vsmul (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vsmul (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vsmulD()
DeclarationDeprecation
From
void vsmulD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vsmulD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vsq()
DeclarationDeprecation
From
void vsq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vsq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vsqD()
DeclarationDeprecation
From
void vsqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vsqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vssq()
DeclarationDeprecation
From
void vssq (
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vssq (
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vssqD()
DeclarationDeprecation
From
void vssqD (
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vssqD (
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vsub()
DeclarationDeprecation
From
void vsub (
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const float *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    float *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vsub (
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const float * _Nonnull __A,
    vDSP_Stride __IA,
    float * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified vsubD()
DeclarationDeprecation
From
void vsubD (
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const double *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    double *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void vsubD (
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const double * _Nonnull __A,
    vDSP_Stride __IA,
    double * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zconv()
DeclarationDeprecation
From
void zconv (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zconv (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __F,
    vDSP_Stride __IF,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zconvD()
DeclarationDeprecation
From
void zconvD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_F,
    vDSP_Stride __vDSP_IF,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zconvD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __F,
    vDSP_Stride __IF,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zdotpr()
DeclarationDeprecation
From
void zdotpr (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void zdotpr (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified zdotprD()
DeclarationDeprecation
From
void zdotprD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void zdotprD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified zidotpr()
DeclarationDeprecation
From
void zidotpr (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void zidotpr (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified zidotprD()
DeclarationDeprecation
From
void zidotprD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void zidotprD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified zmma()
DeclarationDeprecation
From
void zmma (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmma (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmmaD()
DeclarationDeprecation
From
void zmmaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmmaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmms()
DeclarationDeprecation
From
void zmms (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmms (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmmsD()
DeclarationDeprecation
From
void zmmsD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmmsD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmmul()
DeclarationDeprecation
From
void zmmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmmulD()
DeclarationDeprecation
From
void zmmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmsm()
DeclarationDeprecation
From
void zmsm (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmsm (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zmsmD()
DeclarationDeprecation
From
void zmsmD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_M,
    vDSP_Length __vDSP_N,
    vDSP_Length __vDSP_P
);
--
To
void zmsmD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __M,
    vDSP_Length __N,
    vDSP_Length __P
);
OS X 10.11

Modified zrdotpr()
DeclarationDeprecation
From
void zrdotpr (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void zrdotpr (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified zrdotprD()
DeclarationDeprecation
From
void zrdotprD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Length __vDSP_N
);
--
To
void zrdotprD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Length __N
);
OS X 10.11

Modified zrvadd()
DeclarationDeprecation
From
void zrvadd (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zrvadd (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zrvaddD()
DeclarationDeprecation
From
void zrvaddD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zrvaddD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zrvmul()
DeclarationDeprecation
From
void zrvmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zrvmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zrvmulD()
DeclarationDeprecation
From
void zrvmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zrvmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zrvsub()
DeclarationDeprecation
From
void zrvsub (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const float *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zrvsub (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const float * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zrvsubD()
DeclarationDeprecation
From
void zrvsubD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const double *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zrvsubD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const double * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified ztoc()
DeclarationDeprecation
From
void ztoc (
    const DSPSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    DSPComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void ztoc (
    const DSPSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    DSPComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified ztocD()
DeclarationDeprecation
From
void ztocD (
    const DSPDoubleSplitComplex *__vDSP_Z,
    vDSP_Stride __vDSP_IZ,
    DSPDoubleComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void ztocD (
    const DSPDoubleSplitComplex * _Nonnull __Z,
    vDSP_Stride __IZ,
    DSPDoubleComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zvadd()
DeclarationDeprecation
From
void zvadd (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zvadd (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zvaddD()
DeclarationDeprecation
From
void zvaddD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zvaddD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zvcma()
DeclarationDeprecation
From
void zvcma (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
--
To
void zvcma (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);
OS X 10.11

Modified zvcmaD()
DeclarationDeprecation
From
void zvcmaD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    const DSPDoubleSplitComplex *__vDSP_D,
    vDSP_Stride __vDSP_ID,
    vDSP_Length __vDSP_N
);
--
To
void zvcmaD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    const DSPDoubleSplitComplex * _Nonnull __D,
    vDSP_Stride __ID,
    vDSP_Length __N
);
OS X 10.11

Modified zvmul()
DeclarationDeprecation
From
void zvmul (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    int __vDSP_Conjugate
);
--
To
void zvmul (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    int __Conjugate
);
OS X 10.11

Modified zvmulD()
DeclarationDeprecation
From
void zvmulD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N,
    int __vDSP_Conjugate
);
--
To
void zvmulD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N,
    int __Conjugate
);
OS X 10.11

Modified zvsub()
DeclarationDeprecation
From
void zvsub (
    const DSPSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zvsub (
    const DSPSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

Modified zvsubD()
DeclarationDeprecation
From
void zvsubD (
    const DSPDoubleSplitComplex *__vDSP_A,
    vDSP_Stride __vDSP_IA,
    const DSPDoubleSplitComplex *__vDSP_B,
    vDSP_Stride __vDSP_IB,
    const DSPDoubleSplitComplex *__vDSP_C,
    vDSP_Stride __vDSP_IC,
    vDSP_Length __vDSP_N
);
--
To
void zvsubD (
    const DSPDoubleSplitComplex * _Nonnull __A,
    vDSP_Stride __IA,
    const DSPDoubleSplitComplex * _Nonnull __B,
    vDSP_Stride __IB,
    const DSPDoubleSplitComplex * _Nonnull __C,
    vDSP_Stride __IC,
    vDSP_Length __N
);
OS X 10.11

vDSP_translate.h

Removed #def vDSP_conv
Removed #def vDSP_convD
Removed #def vDSP_create_fftsetup
Removed #def vDSP_create_fftsetupD
Removed #def vDSP_ctoz
Removed #def vDSP_ctozD
Removed #def vDSP_destroy_fftsetup
Removed #def vDSP_destroy_fftsetupD
Removed #def vDSP_dotpr
Removed #def vDSP_dotprD
Removed #def vDSP_f3x3
Removed #def vDSP_f3x3D
Removed #def vDSP_f5x5
Removed #def vDSP_f5x5D
Removed #def vDSP_fft2d_zip
Removed #def vDSP_fft2d_zipD
Removed #def vDSP_fft2d_zipt
Removed #def vDSP_fft2d_ziptD
Removed #def vDSP_fft2d_zop
Removed #def vDSP_fft2d_zopD
Removed #def vDSP_fft2d_zopt
Removed #def vDSP_fft2d_zoptD
Removed #def vDSP_fft2d_zrip
Removed #def vDSP_fft2d_zripD
Removed #def vDSP_fft2d_zript
Removed #def vDSP_fft2d_zriptD
Removed #def vDSP_fft2d_zrop
Removed #def vDSP_fft2d_zropD
Removed #def vDSP_fft2d_zropt
Removed #def vDSP_fft2d_zroptD
Removed #def vDSP_fft3_zop
Removed #def vDSP_fft3_zopD
Removed #def vDSP_fft5_zop
Removed #def vDSP_fft5_zopD
Removed #def vDSP_fft_cip
Removed #def vDSP_fft_cipt
Removed #def vDSP_fft_cop
Removed #def vDSP_fft_copt
Removed #def vDSP_fft_zip
Removed #def vDSP_fft_zipD
Removed #def vDSP_fft_zipt
Removed #def vDSP_fft_ziptD
Removed #def vDSP_fft_zop
Removed #def vDSP_fft_zopD
Removed #def vDSP_fft_zopt
Removed #def vDSP_fft_zoptD
Removed #def vDSP_fft_zrip
Removed #def vDSP_fft_zripD
Removed #def vDSP_fft_zript
Removed #def vDSP_fft_zriptD
Removed #def vDSP_fft_zrop
Removed #def vDSP_fft_zropD
Removed #def vDSP_fft_zropt
Removed #def vDSP_fft_zroptD
Removed #def vDSP_fftm_zip
Removed #def vDSP_fftm_zipD
Removed #def vDSP_fftm_zipt
Removed #def vDSP_fftm_ziptD
Removed #def vDSP_fftm_zop
Removed #def vDSP_fftm_zopD
Removed #def vDSP_fftm_zopt
Removed #def vDSP_fftm_zoptD
Removed #def vDSP_fftm_zrip
Removed #def vDSP_fftm_zripD
Removed #def vDSP_fftm_zript
Removed #def vDSP_fftm_zriptD
Removed #def vDSP_fftm_zrop
Removed #def vDSP_fftm_zropD
Removed #def vDSP_fftm_zropt
Removed #def vDSP_fftm_zroptD
Removed #def vDSP_imgfir
Removed #def vDSP_imgfirD
Removed #def vDSP_mmul
Removed #def vDSP_mmulD
Removed #def vDSP_mtrans
Removed #def vDSP_mtransD
Removed #def vDSP_vadd
Removed #def vDSP_vaddD
Removed #def vDSP_vam
Removed #def vDSP_vamD
Removed #def vDSP_vmul
Removed #def vDSP_vmulD
Removed #def vDSP_vsmul
Removed #def vDSP_vsmulD
Removed #def vDSP_vsq
Removed #def vDSP_vsqD
Removed #def vDSP_vssq
Removed #def vDSP_vssqD
Removed #def vDSP_vsub
Removed #def vDSP_vsubD
Removed #def vDSP_zconv
Removed #def vDSP_zconvD
Removed #def vDSP_zdotpr
Removed #def vDSP_zdotprD
Removed #def vDSP_zidotpr
Removed #def vDSP_zidotprD
Removed #def vDSP_zmma
Removed #def vDSP_zmmaD
Removed #def vDSP_zmms
Removed #def vDSP_zmmsD
Removed #def vDSP_zmmul
Removed #def vDSP_zmmulD
Removed #def vDSP_zmsm
Removed #def vDSP_zmsmD
Removed #def vDSP_zrdotpr
Removed #def vDSP_zrdotprD
Removed #def vDSP_zrvadd
Removed #def vDSP_zrvaddD
Removed #def vDSP_zrvmul
Removed #def vDSP_zrvmulD
Removed #def vDSP_zrvsub
Removed #def vDSP_zrvsubD
Removed #def vDSP_ztoc
Removed #def vDSP_ztocD
Removed #def vDSP_zvadd
Removed #def vDSP_zvaddD
Removed #def vDSP_zvcma
Removed #def vDSP_zvcmaD
Removed #def vDSP_zvmul
Removed #def vDSP_zvmulD
Removed #def vDSP_zvsub
Removed #def vDSP_zvsubD
Added #def vDSP_DeprecateTranslations

vecLibTypes.h

Removed vBool32
Removed vDouble
Removed vFloat
Removed vSInt16
Removed vSInt32
Removed vSInt64
Removed vSInt8
Removed vUInt16
Removed vUInt32
Removed vUInt64
Removed vUInt8

vectorOps.h

Modified vIsamax()
Declaration
From
int32_t vIsamax (
    int32_t count,
    const vFloat x[]
);
To
int32_t vIsamax (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vIsamin()
Declaration
From
int32_t vIsamin (
    int32_t count,
    const vFloat x[]
);
To
int32_t vIsamin (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vIsmax()
Declaration
From
int32_t vIsmax (
    int32_t count,
    const vFloat x[]
);
To
int32_t vIsmax (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vIsmin()
Declaration
From
int32_t vIsmin (
    int32_t count,
    const vFloat x[]
);
To
int32_t vIsmin (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vSasum()
Declaration
From
float vSasum (
    int32_t count,
    const vFloat x[]
);
To
float vSasum (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vSaxpy()
Declaration
From
void vSaxpy (
    int32_t n,
    float alpha,
    const vFloat x[],
    vFloat y[]
);
To
void vSaxpy (
    int32_t n,
    float alpha,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vScopy()
Declaration
From
void vScopy (
    int32_t n,
    const vFloat x[],
    vFloat y[]
);
To
void vScopy (
    int32_t n,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSdot()
Declaration
From
float vSdot (
    int32_t n,
    const vFloat x[],
    const vFloat y[]
);
To
float vSdot (
    int32_t n,
    const vFloat * _Nonnull x,
    const vFloat * _Nonnull y
);

Modified vSgeadd()
Declaration
From
void vSgeadd (
    int32_t height,
    int32_t width,
    const vFloat a[],
    char forma,
    const vFloat b[],
    char formb,
    vFloat c[]
);
To
void vSgeadd (
    int32_t height,
    int32_t width,
    const vFloat * _Nonnull a,
    char forma,
    const vFloat * _Nonnull b,
    char formb,
    vFloat * _Nonnull c
);

Modified vSgemm()
Declaration
From
void vSgemm (
    int32_t l,
    int32_t m,
    int32_t n,
    const vFloat a[],
    char forma,
    const vFloat b[],
    char formb,
    vFloat c[],
    float alpha,
    float beta,
    vFloat matrix[]
);
To
void vSgemm (
    int32_t l,
    int32_t m,
    int32_t n,
    const vFloat * _Nonnull a,
    char forma,
    const vFloat * _Nonnull b,
    char formb,
    vFloat * _Nonnull c,
    float alpha,
    float beta,
    vFloat * _Nonnull matrix
);

Modified vSgemtx()
Declaration
From
void vSgemtx (
    int32_t m,
    int32_t n,
    float alpha,
    const vFloat a[],
    const vFloat x[],
    vFloat y[]
);
To
void vSgemtx (
    int32_t m,
    int32_t n,
    float alpha,
    const vFloat * _Nonnull a,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSgemul()
Declaration
From
void vSgemul (
    int32_t l,
    int32_t m,
    int32_t n,
    const vFloat a[],
    char forma,
    const vFloat b[],
    char formb,
    vFloat matrix[]
);
To
void vSgemul (
    int32_t l,
    int32_t m,
    int32_t n,
    const vFloat * _Nonnull a,
    char forma,
    const vFloat * _Nonnull b,
    char formb,
    vFloat * _Nonnull matrix
);

Modified vSgemv()
Declaration
From
void vSgemv (
    char forma,
    int32_t m,
    int32_t n,
    float alpha,
    const vFloat a[],
    const vFloat x[],
    float beta,
    vFloat y[]
);
To
void vSgemv (
    char forma,
    int32_t m,
    int32_t n,
    float alpha,
    const vFloat * _Nonnull a,
    const vFloat * _Nonnull x,
    float beta,
    vFloat * _Nonnull y
);

Modified vSgemx()
Declaration
From
void vSgemx (
    int32_t m,
    int32_t n,
    float alpha,
    const vFloat a[],
    const vFloat x[],
    vFloat y[]
);
To
void vSgemx (
    int32_t m,
    int32_t n,
    float alpha,
    const vFloat * _Nonnull a,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSgesub()
Declaration
From
void vSgesub (
    int32_t height,
    int32_t width,
    const vFloat a[],
    char forma,
    const vFloat b[],
    char formb,
    vFloat c[]
);
To
void vSgesub (
    int32_t height,
    int32_t width,
    const vFloat * _Nonnull a,
    char forma,
    const vFloat * _Nonnull b,
    char formb,
    vFloat * _Nonnull c
);

Modified vSgetmi()
Declaration
From
void vSgetmi (
    int32_t size,
    vFloat x[]
);
To
void vSgetmi (
    int32_t size,
    vFloat * _Nonnull x
);

Modified vSgetmo()
Declaration
From
void vSgetmo (
    int32_t height,
    int32_t width,
    const vFloat x[],
    vFloat y[]
);
To
void vSgetmo (
    int32_t height,
    int32_t width,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSgevv()
Declaration
From
void vSgevv (
    int32_t l,
    int32_t n,
    const vFloat A[],
    const vFloat B[],
    vFloat M[]
);
To
void vSgevv (
    int32_t l,
    int32_t n,
    const vFloat * _Nonnull A,
    const vFloat * _Nonnull B,
    vFloat * _Nonnull M
);

Modified vSnaxpy()
Declaration
From
void vSnaxpy (
    int32_t n,
    int32_t m,
    const vFloat a[],
    const vFloat x[],
    vFloat y[]
);
To
void vSnaxpy (
    int32_t n,
    int32_t m,
    const vFloat * _Nonnull a,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSndot()
Declaration
From
void vSndot (
    int32_t n,
    int32_t m,
    float s[],
    int32_t isw,
    const vFloat x[],
    const vFloat y[]
);
To
void vSndot (
    int32_t n,
    int32_t m,
    float * _Nonnull s,
    int32_t isw,
    const vFloat * _Nonnull x,
    const vFloat * _Nonnull y
);

Modified vSnorm2()
Declaration
From
float vSnorm2 (
    int32_t count,
    const vFloat x[]
);
To
float vSnorm2 (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vSnrm2()
Declaration
From
float vSnrm2 (
    int32_t count,
    const vFloat x[]
);
To
float vSnrm2 (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vSrot()
Declaration
From
void vSrot (
    int32_t n,
    vFloat x[],
    vFloat y[],
    float c,
    float s
);
To
void vSrot (
    int32_t n,
    vFloat * _Nonnull x,
    vFloat * _Nonnull y,
    float c,
    float s
);

Modified vSscal()
Declaration
From
void vSscal (
    int32_t n,
    float alpha,
    vFloat x[]
);
To
void vSscal (
    int32_t n,
    float alpha,
    vFloat * _Nonnull x
);

Modified vSsum()
Declaration
From
float vSsum (
    int32_t count,
    const vFloat x[]
);
To
float vSsum (
    int32_t count,
    const vFloat * _Nonnull x
);

Modified vSswap()
Declaration
From
void vSswap (
    int32_t n,
    vFloat x[],
    vFloat y[]
);
To
void vSswap (
    int32_t n,
    vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSyax()
Declaration
From
void vSyax (
    int32_t n,
    float alpha,
    const vFloat x[],
    vFloat y[]
);
To
void vSyax (
    int32_t n,
    float alpha,
    const vFloat * _Nonnull x,
    vFloat * _Nonnull y
);

Modified vSzaxpy()
Declaration
From
void vSzaxpy (
    int32_t n,
    float alpha,
    const vFloat x[],
    const vFloat yY[],
    vFloat z[]
);
To
void vSzaxpy (
    int32_t n,
    float alpha,
    const vFloat * _Nonnull x,
    const vFloat * _Nonnull y,
    vFloat * _Nonnull z
);

vForce.h

Modified vvacos()
Declaration
From
void vvacos (
    double *,
    const double *,
    const int *
);
To
void vvacos (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvacosf()
Declaration
From
void vvacosf (
    float *,
    const float *,
    const int *
);
To
void vvacosf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvacosh()
Declaration
From
void vvacosh (
    double *,
    const double *,
    const int *
);
To
void vvacosh (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvacoshf()
Declaration
From
void vvacoshf (
    float *,
    const float *,
    const int *
);
To
void vvacoshf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvasin()
Declaration
From
void vvasin (
    double *,
    const double *,
    const int *
);
To
void vvasin (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvasinf()
Declaration
From
void vvasinf (
    float *,
    const float *,
    const int *
);
To
void vvasinf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvasinh()
Declaration
From
void vvasinh (
    double *,
    const double *,
    const int *
);
To
void vvasinh (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvasinhf()
Declaration
From
void vvasinhf (
    float *,
    const float *,
    const int *
);
To
void vvasinhf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvatan()
Declaration
From
void vvatan (
    double *,
    const double *,
    const int *
);
To
void vvatan (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvatan2()
Declaration
From
void vvatan2 (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvatan2 (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvatan2f()
Declaration
From
void vvatan2f (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvatan2f (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvatanf()
Declaration
From
void vvatanf (
    float *,
    const float *,
    const int *
);
To
void vvatanf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvatanh()
Declaration
From
void vvatanh (
    double *,
    const double *,
    const int *
);
To
void vvatanh (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvatanhf()
Declaration
From
void vvatanhf (
    float *,
    const float *,
    const int *
);
To
void vvatanhf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvcbrt()
Declaration
From
void vvcbrt (
    double *,
    const double *,
    const int *
);
To
void vvcbrt (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvcbrtf()
Declaration
From
void vvcbrtf (
    float *,
    const float *,
    const int *
);
To
void vvcbrtf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvceil()
Declaration
From
void vvceil (
    double *,
    const double *,
    const int *
);
To
void vvceil (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvceilf()
Declaration
From
void vvceilf (
    float *,
    const float *,
    const int *
);
To
void vvceilf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvcopysign()
Declaration
From
void vvcopysign (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvcopysign (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvcopysignf()
Declaration
From
void vvcopysignf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvcopysignf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvcos()
Declaration
From
void vvcos (
    double *,
    const double *,
    const int *
);
To
void vvcos (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvcosf()
Declaration
From
void vvcosf (
    float *,
    const float *,
    const int *
);
To
void vvcosf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvcosh()
Declaration
From
void vvcosh (
    double *,
    const double *,
    const int *
);
To
void vvcosh (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvcoshf()
Declaration
From
void vvcoshf (
    float *,
    const float *,
    const int *
);
To
void vvcoshf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvcosisin()
Declaration
From
void vvcosisin (
    __double_complex_t *,
    const double *,
    const int *
);
To
void vvcosisin (
    __double_complex_t * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvcosisinf()
Declaration
From
void vvcosisinf (
    __float_complex_t *,
    const float *,
    const int *
);
To
void vvcosisinf (
    __float_complex_t * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvcospi()
Declaration
From
void vvcospi (
    double *,
    const double *,
    const int *
);
To
void vvcospi (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvcospif()
Declaration
From
void vvcospif (
    float *,
    const float *,
    const int *
);
To
void vvcospif (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvdiv()
Declaration
From
void vvdiv (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvdiv (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvdivf()
Declaration
From
void vvdivf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvdivf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvexp()
Declaration
From
void vvexp (
    double *,
    const double *,
    const int *
);
To
void vvexp (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvexp2()
Declaration
From
void vvexp2 (
    double *,
    const double *,
    const int *
);
To
void vvexp2 (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvexp2f()
Declaration
From
void vvexp2f (
    float *,
    const float *,
    const int *
);
To
void vvexp2f (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvexpf()
Declaration
From
void vvexpf (
    float *,
    const float *,
    const int *
);
To
void vvexpf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvexpm1()
Declaration
From
void vvexpm1 (
    double *,
    const double *,
    const int *
);
To
void vvexpm1 (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvexpm1f()
Declaration
From
void vvexpm1f (
    float *,
    const float *,
    const int *
);
To
void vvexpm1f (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvfabf()
Declaration
From
void vvfabf (
    float *,
    const float *,
    const int *
);
To
void vvfabf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvfabs()
Declaration
From
void vvfabs (
    double *,
    const double *,
    const int *
);
To
void vvfabs (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvfabsf()
Declaration
From
void vvfabsf (
    float *,
    const float *,
    const int *
);
To
void vvfabsf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvfloor()
Declaration
From
void vvfloor (
    double *,
    const double *,
    const int *
);
To
void vvfloor (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvfloorf()
Declaration
From
void vvfloorf (
    float *,
    const float *,
    const int *
);
To
void vvfloorf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvfmod()
Declaration
From
void vvfmod (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvfmod (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvfmodf()
Declaration
From
void vvfmodf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvfmodf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvint()
Declaration
From
void vvint (
    double *,
    const double *,
    const int *
);
To
void vvint (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvintf()
Declaration
From
void vvintf (
    float *,
    const float *,
    const int *
);
To
void vvintf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvlog()
Declaration
From
void vvlog (
    double *,
    const double *,
    const int *
);
To
void vvlog (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvlog10()
Declaration
From
void vvlog10 (
    double *,
    const double *,
    const int *
);
To
void vvlog10 (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvlog10f()
Declaration
From
void vvlog10f (
    float *,
    const float *,
    const int *
);
To
void vvlog10f (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvlog1p()
Declaration
From
void vvlog1p (
    double *,
    const double *,
    const int *
);
To
void vvlog1p (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvlog1pf()
Declaration
From
void vvlog1pf (
    float *,
    const float *,
    const int *
);
To
void vvlog1pf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvlog2()
Declaration
From
void vvlog2 (
    double *,
    const double *,
    const int *
);
To
void vvlog2 (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvlog2f()
Declaration
From
void vvlog2f (
    float *,
    const float *,
    const int *
);
To
void vvlog2f (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvlogb()
Declaration
From
void vvlogb (
    double *,
    const double *,
    const int *
);
To
void vvlogb (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvlogbf()
Declaration
From
void vvlogbf (
    float *,
    const float *,
    const int *
);
To
void vvlogbf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvlogf()
Declaration
From
void vvlogf (
    float *,
    const float *,
    const int *
);
To
void vvlogf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvnextafter()
Declaration
From
void vvnextafter (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvnextafter (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvnextafterf()
Declaration
From
void vvnextafterf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvnextafterf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvnint()
Declaration
From
void vvnint (
    double *,
    const double *,
    const int *
);
To
void vvnint (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvnintf()
Declaration
From
void vvnintf (
    float *,
    const float *,
    const int *
);
To
void vvnintf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvpow()
Declaration
From
void vvpow (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvpow (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvpowf()
Declaration
From
void vvpowf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvpowf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvpows()
Declaration
From
void vvpows (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvpows (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvpowsf()
Declaration
From
void vvpowsf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvpowsf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvrec()
Declaration
From
void vvrec (
    double *,
    const double *,
    const int *
);
To
void vvrec (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvrecf()
Declaration
From
void vvrecf (
    float *,
    const float *,
    const int *
);
To
void vvrecf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvremainder()
Declaration
From
void vvremainder (
    double *,
    const double *,
    const double *,
    const int *
);
To
void vvremainder (
    double * _Nonnull,
    const double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvremainderf()
Declaration
From
void vvremainderf (
    float *,
    const float *,
    const float *,
    const int *
);
To
void vvremainderf (
    float * _Nonnull,
    const float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvrsqrt()
Declaration
From
void vvrsqrt (
    double *,
    const double *,
    const int *
);
To
void vvrsqrt (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvrsqrtf()
Declaration
From
void vvrsqrtf (
    float *,
    const float *,
    const int *
);
To
void vvrsqrtf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvsin()
Declaration
From
void vvsin (
    double *,
    const double *,
    const int *
);
To
void vvsin (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvsincos()
Declaration
From
void vvsincos (
    double *,
    double *,
    const double *,
    const int *
);
To
void vvsincos (
    double * _Nonnull,
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvsincosf()
Declaration
From
void vvsincosf (
    float *,
    float *,
    const float *,
    const int *
);
To
void vvsincosf (
    float * _Nonnull,
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvsinf()
Declaration
From
void vvsinf (
    float *,
    const float *,
    const int *
);
To
void vvsinf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvsinh()
Declaration
From
void vvsinh (
    double *,
    const double *,
    const int *
);
To
void vvsinh (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvsinhf()
Declaration
From
void vvsinhf (
    float *,
    const float *,
    const int *
);
To
void vvsinhf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvsinpi()
Declaration
From
void vvsinpi (
    double *,
    const double *,
    const int *
);
To
void vvsinpi (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvsinpif()
Declaration
From
void vvsinpif (
    float *,
    const float *,
    const int *
);
To
void vvsinpif (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvsqrt()
Declaration
From
void vvsqrt (
    double *,
    const double *,
    const int *
);
To
void vvsqrt (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvsqrtf()
Declaration
From
void vvsqrtf (
    float *,
    const float *,
    const int *
);
To
void vvsqrtf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvtan()
Declaration
From
void vvtan (
    double *,
    const double *,
    const int *
);
To
void vvtan (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvtanf()
Declaration
From
void vvtanf (
    float *,
    const float *,
    const int *
);
To
void vvtanf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvtanh()
Declaration
From
void vvtanh (
    double *,
    const double *,
    const int *
);
To
void vvtanh (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvtanhf()
Declaration
From
void vvtanhf (
    float *,
    const float *,
    const int *
);
To
void vvtanhf (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

Modified vvtanpi()
Declaration
From
void vvtanpi (
    double *,
    const double *,
    const int *
);
To
void vvtanpi (
    double * _Nonnull,
    const double * _Nonnull,
    const int * _Nonnull
);

Modified vvtanpif()
Declaration
From
void vvtanpif (
    float *,
    const float *,
    const int *
);
To
void vvtanpif (
    float * _Nonnull,
    const float * _Nonnull,
    const int * _Nonnull
);

vfp.h

Modified vremquof()
Declaration
From
vFloat vremquof (
    vFloat,
    vFloat,
    vUInt32 *
);
To
vFloat vremquof (
    vFloat,
    vFloat,
    vUInt32 * _Nonnull
);

Modified vsincosf()
Declaration
From
vFloat vsincosf (
    vFloat,
    vFloat *
);
To
vFloat vsincosf (
    vFloat,
    vFloat * _Nonnull
);

Modified vtablelookup()
Declaration
From
vUInt32 vtablelookup (
    vSInt32,
    uint32_t *
);
To
vUInt32 vtablelookup (
    vSInt32,
    uint32_t * _Nonnull
);

vImage_CVUtilities.h

Added vImageCreateMonochromeColorSpaceWithWhitePointAndTransferFunction()
Added vImageWhitePoint

vImage_Types.h

Added #def CF_BRIDGED_TYPE
Added kvImageHDRContent