Mac OS 9
Data Structures | Macros | Typedefs | Enumerations | Functions
vDSP.h File Reference
Math

AltiVec DSP Interfaces. More...

#include <ConditionalMacros.h>
#include <MacTypes.h>

Go to the source code of this file.

Data Structures

struct  DSPComplex
 
struct  DSPSplitComplex
 

Macros

#define USE_NONE_APPLE_STANDARD_DATATYPES   1
 

Typedefs

typedef struct DSPComplex DSPComplex
 
typedef struct DSPSplitComplex DSPSplitComplex
 
typedef struct OpaqueFFTSetup * FFTSetup
 
typedef SInt32 FFTDirection
 
typedef SInt32 FFTRadix
 
typedef DSPComplex COMPLEX
 
typedef DSPSplitComplex COMPLEX_SPLIT
 

Enumerations

enum  { kFFTDirection_Forward = 1 , kFFTDirection_Inverse = -1 }
 
enum  { kFFTRadix2 = 0 , kFFTRadix3 = 1 , kFFTRadix5 = 2 }
 
enum  { FFT_FORWARD = kFFTDirection_Forward , FFT_INVERSE = kFFTDirection_Inverse }
 
enum  { FFT_RADIX2 = kFFTRadix2 , FFT_RADIX3 = kFFTRadix3 , FFT_RADIX5 = kFFTRadix5 }
 

Functions

FFTSetup create_fftsetup (UInt32 log2n, FFTRadix radix)
 
void destroy_fftsetup (FFTSetup setup)
 
void ctoz (const DSPComplex C[], SInt32 strideC, DSPSplitComplex *Z, SInt32 strideZ, UInt32 size)
 
void ztoc (const DSPSplitComplex *Z, SInt32 strideZ, DSPComplex C[], SInt32 strideC, UInt32 size)
 
void fft_zip (FFTSetup setup, DSPSplitComplex *ioData, SInt32 stride, UInt32 log2n, FFTDirection direction)
 
void fft_zipt (FFTSetup setup, DSPSplitComplex *ioData, SInt32 stride, DSPSplitComplex *bufferTemp, UInt32 log2n, FFTDirection direction)
 
void fft_zop (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStride, DSPSplitComplex *result, SInt32 strideResult, UInt32 log2n, FFTDirection direction)
 
void fft_zopt (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStride, DSPSplitComplex *result, SInt32 strideResult, DSPSplitComplex *bufferTemp, UInt32 log2n, FFTDirection direction)
 
void fft_zrip (FFTSetup setup, DSPSplitComplex *ioData, SInt32 stride, UInt32 log2n, FFTDirection direction)
 
void fft_zript (FFTSetup setup, DSPSplitComplex *ioData, SInt32 stride, DSPSplitComplex *bufferTemp, UInt32 log2n, FFTDirection direction)
 
void fft_zrop (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStride, DSPSplitComplex *result, SInt32 strideResult, UInt32 log2n, FFTDirection direction)
 
void fft_zropt (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStride, DSPSplitComplex *result, SInt32 strideResult, DSPSplitComplex *bufferTemp, UInt32 log2n, FFTDirection direction)
 
void fft2d_zip (FFTSetup setup, DSPSplitComplex *ioData, SInt32 strideInRow, SInt32 strideInCol, UInt32 log2nInCol, UInt32 log2nInRow, FFTDirection direction)
 
void fft2d_zipt (FFTSetup setup, DSPSplitComplex *ioData, SInt32 strideInRow, SInt32 strideInCol, DSPSplitComplex *bufferTemp, UInt32 log2nInCol, UInt32 log2nInRow, FFTDirection direction)
 
void fft2d_zop (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStrideInRow, SInt32 signalStrideInCol, DSPSplitComplex *result, SInt32 strideResultInRow, SInt32 strideResultInCol, UInt32 log2nInCol, UInt32 log2nInRow, SInt32 flag)
 
void fft2d_zopt (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStrideInRow, SInt32 signalStrideInCol, DSPSplitComplex *result, SInt32 strideResultInRow, SInt32 strideResultInCol, DSPSplitComplex *bufferTemp, UInt32 log2nInCol, UInt32 log2nInRow, SInt32 flag)
 
void fft2d_zrip (FFTSetup setup, DSPSplitComplex *ioData, SInt32 strideInRow, SInt32 strideInCol, UInt32 log2nInCol, UInt32 log2nInRow, FFTDirection direction)
 
void fft2d_zript (FFTSetup setup, DSPSplitComplex *ioData, SInt32 strideInRow, SInt32 strideInCol, DSPSplitComplex *bufferTemp, UInt32 log2nInCol, UInt32 log2nInRow, FFTDirection direction)
 
void fft2d_zrop (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStrideInRow, SInt32 signalStrideInCol, DSPSplitComplex *result, SInt32 strideResultInRow, SInt32 strideResultInCol, UInt32 log2nInCol, UInt32 log2nInRow, SInt32 flag)
 
void fft2d_zropt (FFTSetup setup, DSPSplitComplex *signal, SInt32 signalStrideInRow, SInt32 signalStrideInCol, DSPSplitComplex *result, SInt32 strideResultInRow, SInt32 strideResultInCol, DSPSplitComplex *bufferTemp, UInt32 log2nInCol, UInt32 log2nInRow, SInt32 flag)
 
void conv (const float signal[], SInt32 signalStride, const float filter[], SInt32 strideFilter, float result[], SInt32 strideResult, SInt32 lenResult, SInt32 lenFilter)
 
void vadd (const float input1[], SInt32 stride1, const float input2[], SInt32 stride2, float result[], SInt32 strideResult, UInt32 size)
 
void vsub (const float input1[], SInt32 stride1, const float input2[], SInt32 stride2, float result[], SInt32 strideResult, UInt32 size)
 
void vmul (const float input1[], SInt32 stride1, const float input2[], SInt32 stride2, float result[], SInt32 strideResult, UInt32 size)
 
void vsmul (const float input1[], SInt32 stride1, const float *input2, float result[], SInt32 strideResult, UInt32 size)
 
void vsq (const float input[], SInt32 strideInput, float result[], SInt32 strideResult, UInt32 size)
 
void vssq (const float input[], SInt32 strideInput, float result[], SInt32 strideResult, UInt32 size)
 
void dotpr (const float input1[], SInt32 stride1, const float input2[], SInt32 stride2, float *result, UInt32 size)
 
void vam (const float input1[], SInt32 stride1, const float input2[], SInt32 stride2, const float input3[], SInt32 stride3, float result[], SInt32 strideResult, UInt32 size)
 
void zconv (DSPSplitComplex *signal, SInt32 signalStride, DSPSplitComplex *filter, SInt32 strideFilter, DSPSplitComplex *result, SInt32 strideResult, SInt32 lenResult, SInt32 lenFilter)
 
void zvadd (DSPSplitComplex *input1, SInt32 stride1, DSPSplitComplex *input2, SInt32 stride2, DSPSplitComplex *result, SInt32 strideResult, UInt32 size)
 
void zvsub (DSPSplitComplex *input1, SInt32 stride1, DSPSplitComplex *input2, SInt32 stride2, DSPSplitComplex *result, SInt32 strideResult, UInt32 size)
 
void zvmul (DSPSplitComplex *input1, SInt32 stride1, DSPSplitComplex *input2, SInt32 stride2, DSPSplitComplex *result, SInt32 strideResult, UInt32 size, SInt32 conjugate)
 
void zdotpr (DSPSplitComplex *input1, SInt32 stride1, DSPSplitComplex *input2, SInt32 stride2, DSPSplitComplex *result, UInt32 size)
 
void zidotpr (DSPSplitComplex *input1, SInt32 stride1, DSPSplitComplex *input2, SInt32 stride2, DSPSplitComplex *result, UInt32 size)
 
void zrdotpr (DSPSplitComplex *input1, SInt32 stride1, const float input2[], SInt32 stride2, DSPSplitComplex *result, UInt32 size)
 
void zvcma (DSPSplitComplex *input1, SInt32 stride1, DSPSplitComplex *input2, SInt32 stride2, DSPSplitComplex *input3, SInt32 stride3, DSPSplitComplex *result, SInt32 strideResult, UInt32 size)
 
void zrvadd (DSPSplitComplex *input1, SInt32 stride1, const float input2[], SInt32 stride2, DSPSplitComplex *result, SInt32 strideResult, UInt32 size)
 
void zrvsub (DSPSplitComplex *input1, SInt32 stride1, const float input2[], SInt32 stride2, DSPSplitComplex *result, SInt32 strideResult, UInt32 size)
 
void zrvmul (DSPSplitComplex *input1, SInt32 stride1, const float input2[], SInt32 stride2, DSPSplitComplex *result, SInt32 strideResult, UInt32 size)
 

Detailed Description

AltiVec DSP Interfaces.

Introduced In: 1.0
Avaliable From: Universal Interfaces 3.4.1
Copyright: © 2000-2001 by Apple Computer, Inc., all rights reserved.

For bug reports, consult the following page on the World Wide Web: 

http://developer.apple.com/bugreporter/

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

!defined(USE_NONE_APPLE_STANDARD_DATATYPES)

Function Documentation

◆ conv()

void conv ( const float  signal[],
SInt32  signalStride,
const float  filter[],
SInt32  strideFilter,
float  result[],
SInt32  strideResult,
SInt32  lenResult,
SInt32  lenFilter 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function conv

Floating Point Convolution and Correlation

Criteria to invoke PowerPC vector code:

  1. signal and result must have relative alignement.
  2. 4 <= lenFilter <= 256
  3. lenResult > 36
  4. signalStride = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. strideFilter can be positive for correlation or negative for convolution. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© conv()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ create_fftsetup()

FFTSetup create_fftsetup ( UInt32  log2n,
FFTRadix  radix 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© The criteria to invoke the PowerPC vector implementation is subject to change and become less restrictive in the future. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions create_fftsetup and destroy_fftsetup.

create_fftsetup will allocate memory and setup a weight array used by the FFT. The call destroy_fftsetup will free the array. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© create_fftsetup()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ ctoz()

void ctoz ( const DSPComplex  C[],
SInt32  strideC,
DSPSplitComplex *  Z,
SInt32  strideZ,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions ctoz and ztoc.

ctoz converts a complex array to a complex-split array ztoc converts a complex-split array to a complex array

Criteria to invoke PowerPC vector code:

  1. size > 3
  2. strideC = 2
  3. strideZ = 1
  4. Z.realp and Z.imagp are relatively aligned.
  5. C is 8-byte aligned if Z.realp and Z.imagp are 4-byte- aligned or C is 16-byte aligned if Z.realp and Z.imagp are at least 8-byte aligned. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© ctoz()
Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ destroy_fftsetup()

void destroy_fftsetup ( FFTSetup  setup)

destroy_fftsetup()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ dotpr()

void dotpr ( const float  input1[],
SInt32  stride1,
const float  input2[],
SInt32  stride2,
float *  result,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function dotpr

Floating Point Dot product

Criteria to invoke PowerPC vector code:

  1. input1 and input2 are relatively aligned.
  2. size >= 20
  3. stride1 = 1
  4. stride2 = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© dotpr()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zip()

void fft2d_zip ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  strideInRow,
SInt32  strideInCol,
UInt32  log2nInCol,
UInt32  log2nInRow,
FFTDirection  direction 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft2d_zip and fft2d_zipt

In-place two dimensional Split Complex Fourier Transform with or without temporary memory

Criteria to invoke PowerPC vector code:

  1. ioData.realp and ioData.imagp must be 16-byte aligned.
  2. strideInRow = 1;
  3. strideInCol must be a multiple of 4
  4. 2 <= log2nInRow <= 12
  5. 2 <= log2nInCol <= 12
  6. bufferTemp.realp and bufferTemp.imagp must be 16-byte aligned.

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. ( log2n = log2nInRow + log2nInCol ) Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft2d_zip()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zipt()

void fft2d_zipt ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  strideInRow,
SInt32  strideInCol,
DSPSplitComplex *  bufferTemp,
UInt32  log2nInCol,
UInt32  log2nInRow,
FFTDirection  direction 
)

fft2d_zipt()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zop()

void fft2d_zop ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStrideInRow,
SInt32  signalStrideInCol,
DSPSplitComplex *  result,
SInt32  strideResultInRow,
SInt32  strideResultInCol,
UInt32  log2nInCol,
UInt32  log2nInRow,
SInt32  flag 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft2d_zop and fft2d_zopt

Out-of-Place two dimemsional Split Complex Fourier Transform with or without temporary memory

Criteria to invoke PowerPC vector code:

  1. signal.realp and signal.imagp must be 16-byte aligned.
  2. signalStrideInRow = 1;
  3. signalStrideInCol must be a multiple of 4
  4. result.realp and result.imagp must be 16-byte aligned.
  5. strideResultInRow = 1;
  6. strideResultInCol must be a multiple of 4
  7. 2 <= log2nInRow <= 12
  8. 2 <= log2nInCol <= 12
  9. bufferTemp.realp and bufferTemp.imagp must be 16-byte aligned.

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. ( log2n = log2nInRow + log2nInCol ) Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft2d_zop()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zopt()

void fft2d_zopt ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStrideInRow,
SInt32  signalStrideInCol,
DSPSplitComplex *  result,
SInt32  strideResultInRow,
SInt32  strideResultInCol,
DSPSplitComplex *  bufferTemp,
UInt32  log2nInCol,
UInt32  log2nInRow,
SInt32  flag 
)

fft2d_zopt()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zrip()

void fft2d_zrip ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  strideInRow,
SInt32  strideInCol,
UInt32  log2nInCol,
UInt32  log2nInRow,
FFTDirection  direction 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft2d_zrip and fft2d_zript

In-place two dimensional Real Fourier Transform with or without temporary memory, Split Complex Format

Criteria to invoke PowerPC vector code:

  1. ioData.realp and ioData.imagp must be 16-byte aligned.
  2. strideInRow = 1;
  3. strideInCol must be a multiple of 4
  4. 3 <= log2nInRow <= 12
  5. 3 <= log2nInCol <= 13
  6. bufferTemp.realp and bufferTemp.imagp must be 16-byte aligned.

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. ( log2n = log2nInRow + log2nInCol ) Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft2d_zrip()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zript()

void fft2d_zript ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  strideInRow,
SInt32  strideInCol,
DSPSplitComplex *  bufferTemp,
UInt32  log2nInCol,
UInt32  log2nInRow,
FFTDirection  direction 
)

fft2d_zript()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zrop()

void fft2d_zrop ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStrideInRow,
SInt32  signalStrideInCol,
DSPSplitComplex *  result,
SInt32  strideResultInRow,
SInt32  strideResultInCol,
UInt32  log2nInCol,
UInt32  log2nInRow,
SInt32  flag 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft2d_zrop and fft2d_zropt

Out-of-Place Two-Dimemsional Real Fourier Transform with or without temporary memory, Split Complex Format

Criteria to invoke PowerPC vector code:

  1. signal.realp and signal.imagp must be 16-byte aligned.
  2. signalStrideInRow = 1;
  3. signalStrideInCol must be a multiple of 4
  4. result.realp and result.imagp must be 16-byte aligned.
  5. strideResultInRow = 1;
  6. strideResultInCol must be a multiple of 4
  7. 3 <= log2nInRow <= 12
  8. 3 <= log2nInCol <= 13
  9. bufferTemp.realp and bufferTemp.imagp must be 16-byte aligned.

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. ( log2n = log2nInRow + log2nInCol ) Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft2d_zrop()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft2d_zropt()

void fft2d_zropt ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStrideInRow,
SInt32  signalStrideInCol,
DSPSplitComplex *  result,
SInt32  strideResultInRow,
SInt32  strideResultInCol,
DSPSplitComplex *  bufferTemp,
UInt32  log2nInCol,
UInt32  log2nInRow,
SInt32  flag 
)

fft2d_zropt()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zip()

void fft_zip ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  stride,
UInt32  log2n,
FFTDirection  direction 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft_zip and fft_zipt

In-place Split Complex Fourier Transform with or without temporary memory.

Criteria to invoke PowerPC vector code:

  1. ioData.realp and ioData.imagp must be 16-byte aligned.
  2. stride = 1
  3. 2 <= log2n <= 20
  4. bufferTemp.realp and bufferTemp.imagp must be 16-byte aligned.

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft_zip()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zipt()

void fft_zipt ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  stride,
DSPSplitComplex *  bufferTemp,
UInt32  log2n,
FFTDirection  direction 
)

fft_zipt()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zop()

void fft_zop ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStride,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  log2n,
FFTDirection  direction 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft_zop and fft_zopt

Out-of-place Split Complex Fourier Transform with or without temporary memory

Criteria to invoke PowerPC vector code:

  1. signal.realp and signal.imagp must be 16-byte aligned.
  2. signalStride = 1
  3. result.realp and result.imagp must be 16-byte aligned.
  4. strideResult = 1
  5. 2 <= log2n <= 20
  6. bufferTemp.realp and bufferTemp.imagp must be 16-byte aligned.

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft_zop()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zopt()

void fft_zopt ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStride,
DSPSplitComplex *  result,
SInt32  strideResult,
DSPSplitComplex *  bufferTemp,
UInt32  log2n,
FFTDirection  direction 
)

fft_zopt()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zrip()

void fft_zrip ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  stride,
UInt32  log2n,
FFTDirection  direction 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft_zrip and fft_zript

In-Place Real Fourier Transform with or without temporary memory, split Complex Format

Criteria to invoke PowerPC vector code:

  1. ioData.realp and ioData.imagp must be 16-byte aligned.
  2. stride = 1
  3. 3 <= log2n <= 13

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft_zrip()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zript()

void fft_zript ( FFTSetup  setup,
DSPSplitComplex *  ioData,
SInt32  stride,
DSPSplitComplex *  bufferTemp,
UInt32  log2n,
FFTDirection  direction 
)

fft_zript()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zrop()

void fft_zrop ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStride,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  log2n,
FFTDirection  direction 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Functions fft_zrop and fft_zropt

Out-of-Place Real Fourier Transform with or without temporary memory, split Complex Format

Criteria to invoke PowerPC vector code:

  1. signal.realp and signal.imagp must be 16-byte aligned.
  2. signalStride = 1
  3. result.realp and result.imagp must be be 16-byte aligned.
  4. strideResult = 1
  5. 3 <= log2n <= 13

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The size of temporary memory for each part is the lower value of 4*n and 16k. Direction can be either kFFTDirection_Forward or kFFTDirection_Inverse. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© fft_zrop()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ fft_zropt()

void fft_zropt ( FFTSetup  setup,
DSPSplitComplex *  signal,
SInt32  signalStride,
DSPSplitComplex *  result,
SInt32  strideResult,
DSPSplitComplex *  bufferTemp,
UInt32  log2n,
FFTDirection  direction 
)

fft_zropt()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vadd()

void vadd ( const float  input1[],
SInt32  stride1,
const float  input2[],
SInt32  stride2,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vadd

Floating Point Add

Criteria to invoke PowerPC vector code:

  1. input1 and input2 and result are all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vadd()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vam()

void vam ( const float  input1[],
SInt32  stride1,
const float  input2[],
SInt32  stride2,
const float  input3[],
SInt32  stride3,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vam

Floating Point vadd and Multiply

Criteria to invoke PowerPC vector code:

  1. input1, input2, input_3 and result are all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. stride_3 = 1
  6. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vam()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vmul()

void vmul ( const float  input1[],
SInt32  stride1,
const float  input2[],
SInt32  stride2,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vmul

Floating Point Multiply

Criteria to invoke PowerPC vector code:

  1. input1 and input2 and result must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vmul()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vsmul()

void vsmul ( const float  input1[],
SInt32  stride1,
const float *  input2,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vsmul

Floating Point - Scalar Multiply

Criteria to invoke PowerPC vector code:

  1. input1 and result are all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vsmul()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vsq()

void vsq ( const float  input[],
SInt32  strideInput,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vsq

Floating Point Square

Criteria to invoke PowerPC vector code:

  1. input and result are relatively aligned.
  2. size >= 8
  3. strideInput = 1
  4. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vsq()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vssq()

void vssq ( const float  input[],
SInt32  strideInput,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vssq

Floating Point Signed Square

Criteria to invoke PowerPC vector code:

  1. input and result must be all relatively aligned.
  2. size >= 8
  3. strideInput = 1
  4. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vssq()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ vsub()

void vsub ( const float  input1[],
SInt32  stride1,
const float  input2[],
SInt32  stride2,
float  result[],
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function vsub

Floating Point Substract

Criteria to invoke PowerPC vector code:

  1. input1 and input2 and result are all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© vsub()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zconv()

void zconv ( DSPSplitComplex *  signal,
SInt32  signalStride,
DSPSplitComplex *  filter,
SInt32  strideFilter,
DSPSplitComplex *  result,
SInt32  strideResult,
SInt32  lenResult,
SInt32  lenFilter 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zconv

Split Complex Convolution and Correlation

Criteria to invoke PowerPC vector code:

  1. signal->realp, signal->imagp, result->realp, result->imagp must be relatively aligned.
  2. 4 <= lenFilter <= 128
  3. lenResult > 20
  4. signalStride = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. strideFilter can be positive for correlation or negative for convolution ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zconv()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zdotpr()

void zdotpr ( DSPSplitComplex *  input1,
SInt32  stride1,
DSPSplitComplex *  input2,
SInt32  stride2,
DSPSplitComplex *  result,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zdotpr

Split Complex Dot product

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2.realp, input2.imagp are all relatively aligned.
  2. size >= 20
  3. stride1 = 1
  4. stride2 = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zdotpr()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zidotpr()

void zidotpr ( DSPSplitComplex *  input1,
SInt32  stride1,
DSPSplitComplex *  input2,
SInt32  stride2,
DSPSplitComplex *  result,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zidotpr

Split Complex Inner Dot product

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2.realp, input2.imagp must be all relatively aligned.
  2. size >= 20
  3. stride1 = 1
  4. stride2 = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zidotpr()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zrdotpr()

void zrdotpr ( DSPSplitComplex *  input1,
SInt32  stride1,
const float  input2[],
SInt32  stride2,
DSPSplitComplex *  result,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zrdotpr

Split Complex - Real Dot product

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2 are must be relatively aligned.
  2. size >= 16
  3. stride1 = 1
  4. stride2 = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zrdotpr()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zrvadd()

void zrvadd ( DSPSplitComplex *  input1,
SInt32  stride1,
const float  input2[],
SInt32  stride2,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zrvadd

Split Complex - Real Add

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2, result.realp, result.imagp are all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zrvadd()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zrvmul()

void zrvmul ( DSPSplitComplex *  input1,
SInt32  stride1,
const float  input2[],
SInt32  stride2,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zrvmul

Split Complex - Real Multiply

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2, result.realp, result.imagp must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zrvmul()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zrvsub()

void zrvsub ( DSPSplitComplex *  input1,
SInt32  stride1,
const float  input2[],
SInt32  stride2,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zrvsub

Split Complex - Real Substract

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2, result.realp, result.imagp must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zrvsub()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ ztoc()

void ztoc ( const DSPSplitComplex *  Z,
SInt32  strideZ,
DSPComplex  C[],
SInt32  strideC,
UInt32  size 
)

ztoc()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zvadd()

void zvadd ( DSPSplitComplex *  input1,
SInt32  stride1,
DSPSplitComplex *  input2,
SInt32  stride2,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zvadd

Split Complex vadd

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2.realp, input2.imagp, result.realp, result.imagp must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zvadd()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zvcma()

void zvcma ( DSPSplitComplex *  input1,
SInt32  stride1,
DSPSplitComplex *  input2,
SInt32  stride2,
DSPSplitComplex *  input3,
SInt32  stride3,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zvcma

Split Complex Conjugate Multiply And vadd

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2.realp, input2.imagp, input_3.realp, input_3.imagp, result.realp, result.imagp must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. stride_3 = 1
  6. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zvcma()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zvmul()

void zvmul ( DSPSplitComplex *  input1,
SInt32  stride1,
DSPSplitComplex *  input2,
SInt32  stride2,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size,
SInt32  conjugate 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zvmul

Split Complex Multiply

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2.realp, input2.imagp, result.realp, result.imagp must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. The conjugate value can be 1 or -1. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zvmul()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later

◆ zvsub()

void zvsub ( DSPSplitComplex *  input1,
SInt32  stride1,
DSPSplitComplex *  input2,
SInt32  stride2,
DSPSplitComplex *  result,
SInt32  strideResult,
UInt32  size 
)

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© Function zvsub

Split Complex Substract

Criteria to invoke PowerPC vector code:

  1. input1.realp, input1.imagp, input2.realp, input2.imagp, result.realp, result.imagp must be all relatively aligned.
  2. size >= 8
  3. stride1 = 1
  4. stride2 = 1
  5. strideResult = 1

If any of the above criteria are not satisfied, the PowerPC scalor code implementation will be used. ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©© zvsub()

Non-Carbon CFM: in vecLib 1.0 and later
Carbon Lib: not in Carbon, but vecLib is compatible with Carbon
Mac OS X: in version 10.0 and later