Xamarin Accelerate iOS macOS C#

Accelerate.cs

public unsafe static class Accelerate
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct DSPComplex
        {
            public float real;
            public float imag;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct DSPSplitComplex
        {
            public float* realp;
            public float* imagp;
        }

        public const int FFT_FORWARD = 1;
        public const int FFT_INVERSE = -1;

        /// <summary>
        /// Converts an array of unsigned 32-bit integers to single-precision floating-point values.
        /// </summary>
        /// <param name="A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_K"></param>
        /// <param name="__vDSP_N"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vfltu32")]
        unsafe public extern static void vDSP_vfltu32(uint* A,
                                                       int __vDSP_I,
                                                       float* __vDSP_C,
                                                       int __vDSP_K,
                                                       ulong __vDSP_N);

        /// <summary>
        /// Converts an array of signed 32-bit integers to single-precision floating-point values.
        /// </summary>
        /// <param name="A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_K"></param>
        /// <param name="__vDSP_N"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vflt32")]
        unsafe public extern static void vDSP_vflt32(int* A,
                                                       int __vDSP_I,
                                                       float* __vDSP_C,
                                                       int __vDSP_K,
                                                       ulong __vDSP_N);

        /// <summary>
        /// Converts an array of signed 16-bit integers to single-precision floating-point values.
        /// </summary>
        /// <param name="A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_K"></param>
        /// <param name="__vDSP_N"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vflt16")]
        unsafe public extern static void vDSP_vflt16(short* A,
                                                      int __vDSP_I,
                                                      float* __vDSP_C,
                                                      int __vDSP_K,
                                                      ulong __vDSP_N);

        /// <summary>
        /// Returns a setup structure that contains precalculated data for single-precision FFT functions.
        /// </summary>
        /// <param name="__vDSP_log2n"></param>
        /// <param name="__vDSP_radix"></param>
        /// <returns></returns>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_create_fftsetup")]
        unsafe public extern static void* vDSP_create_fftsetup(ulong __vDSP_log2n,
                                                                 int __vDSP_radix);

        /// <summary>
        /// Copies the contents of an interleaved complex vector C to a split complex vector Z; single precision.
        /// </summary>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_strideC"></param>
        /// <param name="__vDSP_Z"></param>
        /// <param name="__vDSP_strideZ"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_ctoz")]
        unsafe public extern static void vDSP_ctoz(
            DSPComplex* __vDSP_C,
                int __vDSP_strideC,
                DSPSplitComplex* __vDSP_Z,
                int __vDSP_strideZ,
            ulong __vDSP_size);


        /// <summary>
        /// Computes a forward or inverse in-place, single-precision real FFT.
        /// </summary>
        /// <param name="__vDSP_setup"></param>
        /// <param name="__vDSP_ioData"></param>
        /// <param name="__vDSP_stride"></param>
        /// <param name="__vDSP_log2n"></param>
        /// <param name="__vDSP_direction"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_fft_zrip")]
        unsafe public extern static void
            vDSP_fft_zrip(
                void* __vDSP_setup,
                DSPSplitComplex* __vDSP_ioData,
                int __vDSP_stride,
                ulong __vDSP_log2n,
                int __vDSP_direction);

        /// <summary>
        /// Copies the contents of a split complex vector Z to an interleaved complex vector C; single precision.
        /// </summary>
        /// <param name="__vDSP_Z"></param>
        /// <param name="__vDSP_strideZ"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_strideC"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_ztoc")]
        unsafe public extern static void
            vDSP_ztoc(
                 DSPSplitComplex* __vDSP_Z,
                int __vDSP_strideZ,
                DSPComplex[] __vDSP_C,
                int __vDSP_strideC,
                ulong __vDSP_size);

        /// <summary>
        /// Multiplies a single-precision scalar value by a single-precision vector.
        /// </summary>
        /// <param name="__vDSP_input1"></param>
        /// <param name="__vDSP_stride1"></param>
        /// <param name="__vDSP_input2"></param>
        /// <param name="__vDSP_result"></param>
        /// <param name="__vDSP_strideResult"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vsmul")]
        unsafe public extern static void
            vDSP_vsmul(

                float* __vDSP_input1,
                int __vDSP_stride1,
                 float* __vDSP_input2,

                float* __vDSP_result,
                int __vDSP_strideResult,
                ulong __vDSP_size);

        /// <summary>
        /// Multiplies two single-precision vectors.
        /// </summary>
        /// <param name="__vDSP_input1"></param>
        /// <param name="__vDSP_stride1"></param>
        /// <param name="__vDSP_input2"></param>
        /// <param name="__vDSP_stride2"></param>
        /// <param name="__vDSP_result"></param>
        /// <param name="__vDSP_strideResult"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vmul")]
        unsafe public extern static void
            vDSP_vmul(

                float* __vDSP_input1,
                int __vDSP_stride1,
                float* __vDSP_input2,
                int __vDSP_stride2,
                float* __vDSP_result,
                int __vDSP_strideResult,
                ulong __vDSP_size);


        /// <summary>
        /// Computes the squared magnitude value of each element in the supplied complex single-precision vector.
        /// </summary>
        /// <param name="__vDSP_A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_K"></param>
        /// <param name="__vDSP_N"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_zvmags")]
        unsafe public extern static void
            vDSP_zvmags(
                DSPSplitComplex* __vDSP_A,
                int __vDSP_I,
                float* __vDSP_C,
                int __vDSP_K,
                ulong __vDSP_N);

        /// <summary>
        /// Complex vector absolute values; single precision.
        /// </summary>
        /// <param name="__vDSP_A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_K"></param>
        /// <param name="__vDSP_N"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_zvabs")]
        unsafe public extern static void
            vDSP_zvabs(
                DSPSplitComplex* __vDSP_A,
                int __vDSP_I,
                float* __vDSP_C,
                int __vDSP_K,
                ulong __vDSP_N);

        /// <summary>
        /// Creates a single-precision Hamming window.
        /// </summary>
        /// <param name="hammingWindow"></param>
        /// <param name="mAudioBufferSize"></param>
        /// <param name="i"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_hamm_window")]
        unsafe public extern static void vDSP_hamm_window(float* hammingWindow, int mAudioBufferSize, int i);

        /// <summary>
        /// Converts single-precision power or amplitude values to decibel values.
        /// </summary>
        /// <param name="__vDSP_A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_B"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_K"></param>
        /// <param name="__vDSP_N"></param>
        /// <param name="__vDSP_F"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vdbcon")]
        unsafe public extern static void vDSP_vdbcon(float* __vDSP_A,
                                                      int __vDSP_I,
                                                      float* __vDSP_B,
                                                      float* __vDSP_C,
                                                      int __vDSP_K,
                                                      ulong __vDSP_N,
                                                      uint __vDSP_F);

        /// <summary>
        /// Calculates the maximum value and corresponding index in a single-precision vector.
        /// </summary>
        /// <param name="__vDSP_A"></param>
        /// <param name="__vDSP_I"></param>
        /// <param name="__vDSP_C"></param>
        /// <param name="__vDSP_IC"></param>
        /// <param name="__vDSP_N"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_maxvi")]
        unsafe public extern static void vDSP_maxvi(
            float* __vDSP_A,
            int __vDSP_I,
            float* __vDSP_C,
            int* __vDSP_IC,
            ulong __vDSP_N
        );

        /// <summary>
        /// Calculates the root mean square of a single-precision vector.
        /// </summary>
        /// <param name="__vDSP_input1"></param>
        /// <param name="__vDSP_stride1"></param>
        /// <param name="__vDSP_outputScalar"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_rmsqv")]
        unsafe public extern static void
        vDSP_rmsqv(
            float* __vDSP_input1,
            int __vDSP_stride1,
            float* __vDSP_outputScalar,
            ulong __vDSP_size
        );

        /// <summary>
        /// Calculates the minimum value in a single-precision vector.
        /// </summary>
        /// <param name="__vDSP_input1"></param>
        /// <param name="__vDSP_stride1"></param>
        /// <param name="__vDSP_outputScalar"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_minv")]
        unsafe public extern static void
        vDSP_minv(
            float* __vDSP_input1,
            int __vDSP_stride1,
            float* __vDSP_outputScalar,
            ulong __vDSP_size
        );

        /// <summary>
        /// Calculates the maximum value in a single-precision vector.
        /// </summary>
        /// <param name="__vDSP_input1"></param>
        /// <param name="__vDSP_stride1"></param>
        /// <param name="__vDSP_outputScalar"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_maxv")]
        unsafe public extern static void
        vDSP_maxv(
            float* __vDSP_input1,
            int __vDSP_stride1,
            float* __vDSP_outputScalar,
            ulong __vDSP_size
        );

        /// <summary>
        /// <summary>
        /// Multiplies the sum of two single-precision vectors by a single-precision scalar value. 
        /// </summary>
        /// <param name="__vDSP_input1"></param>
        /// <param name="__vDSP_stride1"></param>
        /// <param name="__vDSP_input2"></param>
        /// <param name="__vDSP_stride2"></param>
        /// <param name="__vDSP_Scalar"></param>
        /// <param name="__vDSP_output"></param>
        /// <param name="__vDSP_outputStride"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vasm")]
        unsafe public extern static void
        vDSP_vasm(
            float* __vDSP_input1,
            int __vDSP_stride1,
            float* __vDSP_input2,
            int __vDSP_stride2,
            float* __vDSP_Scalar,
            float* __vDSP_output,
            int __vDSP_outputStride,
            ulong __vDSP_size
        );

        /// <summary>
        /// Generates a single-precision vector by extrapolation and interpolation.
        /// </summary>
        /// <param name="__vDSP_inputA"></param>
        /// <param name="__vDSP_strideA"></param>
        /// <param name="__vDSP_inputB"></param>
        /// <param name="__vDSP_strideB"></param>
        /// <param name="__vDSP_inputC"></param>
        /// <param name="__vDSP_strideC"></param>
        /// <param name="__vDSP_countC"></param>
        /// <param name="__vDSP_countAB"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_vgenp")]
        unsafe public extern static void
        vDSP_vgenp(
            float* __vDSP_inputA,
            int __vDSP_strideA,
            float* __vDSP_inputB,
            int __vDSP_strideB,
            float* __vDSP_inputC,
            int __vDSP_strideC,
            uint __vDSP_countC,
            uint __vDSP_countAB
        );

        /// <summary>
        /// Builds a data structure that contains precalculated data for use by the single-precision cascaded biquad IIR filter function
        /// </summary>
        /// <param name="__vDSP_coefficients"></param>
        /// <param name="__vDSP_length"></param>
        /// <returns></returns>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_biquad_CreateSetup")]
        unsafe public extern static void* vDSP_biquad_CreateSetup(double* __vDSP_coefficients,
                                                                 uint __vDSP_length);


        /// <summary>
        /// Applies a single-precision single-channel biquad IIR filter.
        /// </summary>
        /// <param name="__vDSP_setup"></param>
        /// <param name="__vDSP_delay"></param>
        /// <param name="__vDSP_inputX"></param>
        /// <param name="__vDSP_strideX"></param>
        /// <param name="__vDSP_outputY"></param>
        /// <param name="__vDSP_strideY"></param>
        /// <param name="__vDSP_size"></param>
        [DllImport("/System/Library/Frameworks/Accelerate.framework/Accelerate", EntryPoint = "vDSP_biquad")]
        unsafe public extern static void
        vDSP_biquad(
            void* __vDSP_setup,
            float* __vDSP_delay,
            float* __vDSP_inputX,
            int __vDSP_strideX,
            float* __vDSP_outputY,
            int __vDSP_strideY,
            ulong __vDSP_size
        );

    }

Just adding as I need them.