iOS vDSP中的单矢量生成

最新推荐文章于 2022-12-05 15:36:50 发布
最新推荐文章于 2022-12-05 15:36:50 发布
阅读量876 收藏
点赞数
分类专栏： iOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014068781/article/details/52188555
版权

注：注意数组越界问题。

vDSP_Length和vDSP_Stride数据类型：

typedef unsigned long vDSP_Length;
typedef long          vDSP_Stride;

矢量生成 vDSP_vramp方法

    extern void vDSP_vramp(
    const float *__A,
    const float *__B,
    float       *__C,
    vDSP_Stride  __IC,
    vDSP_Length  __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);

方法算法：
         
    for (n = 0; n < N; ++n)
        C[n] = A[0] + n*B[0];

函数使用例子： 

float A[1]={3},B[1]={2};
    float C[8]={0};
    printf("input:\n");
    printf("A:%f B:%f",A[0],B[0]);
    vDSP_vramp(A, B, C, 1,8);
    printf("\nvDSP_vramp(A,B,C,1,8) C:\n");
    for (int i=0; i<8; i++) {
        printf("%f ",C[i]);
        C[i]=0;
    }
    
    vDSP_vramp(A, B, C, 2,4);
    printf("\nvDSP_vramp(A,B,C,2,4) C\n");
    for (int i=0; i<8; i++) {
        printf("%f ",C[i]);
        C[i]=0;
    }
    
    vDSP_vramp(A, B, C, 1,4);
    printf("\nvDSP_vramp(A,B,C,1,4) C:\n");
    for (int i=0; i<8; i++) {
        printf("%f ",C[i]);
    }



输出结果如下：

input:
A:3.000000 B:2.000000
vDSP_vramp(A,B,C,1,8) C:
3.000000 5.000000 7.000000 9.000000 11.000000 13.000000 15.000000 17.000000 
vDSP_vramp(A,B,C,2,4) C
3.000000 0.000000 5.000000 0.000000 7.000000 0.000000 9.000000 0.000000 
vDSP_vramp(A,B,C,1,4) C:
3.000000 5.000000 7.000000 9.000000 0.000000 0.000000 0.000000 0.000000 


矢量生成  vDSP_vrampD方法

extern void vDSP_vrampD(
    const double *__A,
    const double *__B,
    double       *__C,
    vDSP_Stride   __IC,
    vDSP_Length   __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);

方法算法：
         
    for (n = 0; n < N; ++n)
        C[n] = A[0] + n*B[0];

矢量生成 vDSP_vrampmul方法

    void vDSP_vrampmul(
    const float *__I, vDSP_Stride __IS,
    float *__Start,
    const float *__Step,
    float *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);


方法算法： 

     for (i = 0; i < N; ++i){
          O[i*OS] = *Start * I[i*IS];
          *Start += *Step;
     }

方法使用例子： 

float start=0,step=2;
    float I[8],O[8]={0};
    printf("input:\n");
    for(int i=0;i<8;i++){
        I[i]=i;
        printf("%f ",I[i]);
    }
    vDSP_vrampmul(I,1, &start, &step, O, 1, 8);
    printf("\nvDSP_vrampmul(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
        O[i]=0;
    }
    start=0;step=2;
    vDSP_vrampmul(I,2, &start, &step, O, 1, 4);
    printf("\nvDSP_vrampmul(I,2, &start, &step, O, 1, 4) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
        O[i]=0;
    }
    start=0;step=2;
    vDSP_vrampmul(I,1, &start, &step, O, 2, 4);
    printf("\nvDSP_vrampmul(I,1, &start, &step, O, 2, 4) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
        O[i]=0;
    }
    start=0;step=2;
    vDSP_vrampmul(I,1, &start, &step, O, 1, 4);
    printf("\nvDSP_vrampmul(I,1, &start, &step, O, 1, 4) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
    }

输出结果： 
input:
0.000000 1.000000 2.000000 3.000000 4.000000 5.000000 6.000000 7.000000 
vDSP_vrampmul(I,1, &start, &step, O, 1, 8) O:
0.000000 2.000000 8.000000 18.000000 32.000000 50.000000 72.000000 98.000000 
vDSP_vrampmul(I,2, &start, &step, O, 1, 4) O:
0.000000 4.000000 16.000000 36.000000 0.000000 0.000000 0.000000 0.000000 
vDSP_vrampmul(I,1, &start, &step, O, 2, 4) O:
0.000000 0.000000 2.000000 0.000000 8.000000 0.000000 18.000000 0.000000 
vDSP_vrampmul(I,1, &start, &step, O, 1, 4) O:
0.000000 2.000000 8.000000 18.000000 0.000000 0.000000 0.000000 0.000000


矢量生成 vDSP_vrampmulD方法

void vDSP_vrampmulD(
    const double *__I, vDSP_Stride __IS,
    double *__Start,
    const double *__Step,
    double *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);



vDSP_vrampmulD方法计算方式： 

     for (i = 0; i < N; ++i){
          O[i*OS] = *Start * I[i*IS];
          *Start += *Step;
     }

矢量生成 vDSP_vrampmul_s1_15方法

void vDSP_vrampmul_s1_15(
    const short int *__I, vDSP_Stride __IS,
    short int *__Start,
    const short int *__Step,
    short int *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);

方法算法： 

     for (i = 0; i < N; ++i){
          O[i*OS] = （*Start * I[i*IS]）/32768;//（2的15次方32768）
          *Start += *Step;
     }

例子： 

short int start=1,step=2;
    short int I[8],O[8]={0};
    printf("input:\n");
    for(short int i=0;i<8;i++){
        I[i]=32768/2;
        printf("%d ",I[i]);
    }
    vDSP_vrampmul_s1_15(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
        O[i]=0;
    }
    start=1;step=2;
    vDSP_vrampmul_s1_15(I,2, &start, &step, O, 1, 4);
    printf("\n(I,2, &start, &step, O, 1, 4) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
        O[i]=0;
    }
    start=1;step=2;
    vDSP_vrampmul_s1_15(I,1, &start, &step, O, 2, 4);
    printf("\n(I,1, &start, &step, O, 2, 4) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
        O[i]=0;
    }
    start=1;step=2;
    vDSP_vrampmul_s1_15(I,1, &start, &step, O, 1, 4);
    printf("\n(I,1, &start, &step, O, 1, 4) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
    }



打印结果：

input:
16384 16384 16384 16384 16384 16384 16384 16384 
(I,1, &start, &step, O, 1, 8) O:
0 1 2 3 4 5 6 7 
(I,2, &start, &step, O, 1, 4) O:
0 1 2 3 0 0 0 0 
(I,1, &start, &step, O, 2, 4) O:
0 0 1 0 2 0 3 0 
(I,1, &start, &step, O, 1, 4) O:
0 1 2 3 0 0 0 0 



矢量生成  vDSP_vrampmul_s8_24方法

void vDSP_vrampmul_s8_24(
    const int *__I, vDSP_Stride __IS,
    int *__Start,
    const int *__Step,
    int *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);

方法算法： 

     for (i = 0; i < N; ++i){
          O[i*OS] = （*Start * I[i*IS]）/16777216;//（2的24次方16777216）
          *Start += *Step;
     }

矢量生成 vDSP_vrampmul2方法

void vDSP_vrampmul2(
    const float *__I0, const float *__I1, vDSP_Stride __IS,
    float *__Start,
    const float *__Step,
    float *__O0, float *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);


方法算法： 

for (i = 0; i < N; ++i) {
    O0[i*OS] = *Start * I0[i*IS];
    O1[i*OS] = *Start * I1[i*IS];
    *Start += *Step;
}


矢量生成  vDSP_vrampmul2D方法


void vDSP_vrampmul2D(
    const double *__I0, const double *__I1, vDSP_Stride __IS,
          double *__Start,
    const double *__Step,
          double *__O0, double *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);


方法算法： 

for (i = 0; i < N; ++i) {
    O0[i*OS] = *Start * I0[i*IS];
    O1[i*OS] = *Start * I1[i*IS];
    *Start += *Step;
}


矢量生成  vDSP_vrampmul2_s1_15方法

void vDSP_vrampmul2_s1_15(
    const short int *__I0, const short int *__I1, vDSP_Stride __IS,
    short int *__Start,
    const short int *__Step,
    short int *__O0, short int *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);

方法算法： 

for (i = 0; i < N; ++i) {
    O0[i*OS] = *Start * I0[i*IS]/32768;//2^15=32768
    O1[i*OS] = *Start * I1[i*IS]/32768;//2^15=32768
    *Start += *Step;
}
<pre name="code" class="objc">
 
 
 

 

 
 
 

 

矢量生成 vDSP_vrampmul2_s8_24方法
 

 
 
 

 

 
 
void vDSP_vrampmul2_s8_24(
    const int *__I0, const int *__I1, vDSP_Stride __IS,
    int *__Start,
    const int *__Step,
    int *__O0, int *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);
 
 
 
 

   方法算法： 
 
 
 
 
  
 
 
 
 
 
  
for (i = 0; i < N; ++i) {
    O0[i*OS] = *Start * I0[i*IS]/16777216;//2^24=16777216
    O1[i*OS] = *Start * I1[i*IS]/1677216;//2^24=16777216
    *Start += *Step;
}
 
 
 
 
 

 

 
 
 

 

矢量生成 vDSP_vrampmuladd 方法
 

 
 
 

 

 
 
void vDSP_vrampmuladd(
    const float *__I, vDSP_Stride __IS,
    float *__Start,
    const float *__Step,
    float *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);
 
 
 方法算法： 

 

 
 
 

 

 
 
for (i = 0; i < N; ++i) {
    O[i*OS] += *Start * I[i*IS];
    *Start += *Step;
}
 
 
 
 
 

 


  例子： 

 

 
 
float start=1,step=2;
    float I[8],O[8]={0};
    printf("input:\n");
    for(int i=0;i<8;i++){
        I[i]=2;
        O[i]=0;
        printf("%f ",I[i]);
    }
    vDSP_vrampmuladd(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
        O[i]=1;
    }
    start=1;step=2;
    vDSP_vrampmuladd(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
        O[i]=2;
    }
    start=1;step=2;
    vDSP_vrampmuladd(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
        O[i]=3;
    }
    start=1;step=2;
    vDSP_vrampmuladd(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%f ",O[i]);
    }
 
 
 
 
 

 


  输出结果： 

 

 
 
 

 

 
 
input:
2.000000 2.000000 2.000000 2.000000 2.000000 2.000000 2.000000 2.000000 
(I,1, &start, &step, O, 1, 8) O:
2.000000 6.000000 10.000000 14.000000 18.000000 22.000000 26.000000 30.000000 
(I,1, &start, &step, O, 1, 8) O:
3.000000 7.000000 11.000000 15.000000 19.000000 23.000000 27.000000 31.000000 
(I,1, &start, &step, O, 1, 8) O:
4.000000 8.000000 12.000000 16.000000 20.000000 24.000000 28.000000 32.000000 
(I,1, &start, &step, O, 1, 8) O:
5.000000 9.000000 13.000000 17.000000 21.000000 25.000000 29.000000 33.000000 
 
 
 
 
 

 

矢量生成 vDSP_vrampmuladdD方法
 

 
 
void vDSP_vrampmuladdD(
    const double *__I, vDSP_Stride __IS,
          double *__Start,
    const double *__Step,
          double *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
 
 
 
 

   方法算法： 
 
 
 
 
  
 
 
 
 
 
  
for (i = 0; i < N; ++i) {
    O[i*OS] += *Start * I[i*IS];
    *Start += *Step;
}
 
 
 
 
 
  
 
 
 
 
矢量生成 vDSP_vrampmul_s1_15方法
 

 

 
 
void vDSP_vrampmuladd_s1_15(
    const short int *__I, vDSP_Stride __IS,
    short int *__Start,
    const short int *__Step,
    short int *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);
 
 
 

 


  方法算法： 

 

 
 
 

 

 
 
for (i = 0; i < N; ++i) {
    O[i*OS] += (*Start * I[i*IS])/32768;//2^15=32768
    *Start += *Step;
}
 

 

 
 
 例子： 

 

 
 
 

 

 
 
short int start=1,step=2;
    short int I[8],O[8]={0};
    printf("input:\n");
    for(int i=0;i<8;i++){
        I[i]=32768/2;
        O[i]=32768-8;
        printf("%d ",I[i]);
    }
    vDSP_vrampmuladd_s1_15(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
        O[i]=32768-9;
    }
    start=1;step=2;
    vDSP_vrampmuladd_s1_15(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
        O[i]=32768-10;
    }
    start=1;step=2;
    vDSP_vrampmuladd_s1_15(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
        O[i]=32768-100;
    }
    start=1;step=2;
    vDSP_vrampmuladd_s1_15(I,1, &start, &step, O, 1, 8);
    printf("\n(I,1, &start, &step, O, 1, 8) O:\n");
    for(int i=0;i<8;i++){
        printf("%d ",O[i]);
    }

 
 
 
 
 

 


  输出结果： 

 

 
 
 

 


  input: 
 
 16384 16384 16384 16384 16384 16384 16384 16384  
 
 (I,1, &start, &step, O, 1, 8) O: 
 
 32760 32761 32762 32763 32764 32765 32766 32767  
 
 (I,1, &start, &step, O, 1, 8) O: 
 
 32759 32760 32761 32762 32763 32764 32765 32766  
 
 (I,1, &start, &step, O, 1, 8) O: 
 
 32758 32759 32760 32761 32762 32763 32764 32765  
 
 (I,1, &start, &step, O, 1, 8) O: 
 
 32668 32669 32670 32671 32672 32673 32674 32675  
 
 

 

 
 
 

 

 
 
 

 

矢量生成  vDSP_vrampmuladd_s8_24方法
 

 
 
 

 

 
 
void vDSP_vrampmuladd_s8_24(
    const int *__I, vDSP_Stride __IS,
    int *__Start,
    const int *__Step,
    int *__O, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);

 
 
 方法算法： 

 

 
 
 

 

 
 
for (i = 0; i < N; ++i) {
    O[i*OS] += (*Start * I[i*IS])/16777216;//2^24=16777216
    *Start += *Step;
}
 
 
 

 

 
 
 

 

矢量生成 vDSP_vrampmuladd2方法
 

 
 
void vDSP_vrampmuladd2(
    const float *__I0, const float *__I1, vDSP_Stride __IS,
    float *__Start,
    const float *__Step,
    float *__O0, float *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);
 
 
 方法算法： 

 

 
 
 

 

 
 
for (i = 0; i < N; ++i){
      O0[i*OS] += *Start * I0[i*IS];
      O1[i*OS] += *Start * I1[i*IS];
      *Start += *Step;
}
 
 
 

 

 
 
 

 

矢量生成 vDSP_vrampmuladd2D方法
 

 
 
 

 

 
 
void vDSP_vrampmuladd2D(
    const double *__I0, const double *__I1, vDSP_Stride __IS,
    double *__Start,
    const double *__Step,
    double *__O0, double *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
 
 
 
 

   方法算法： 
 
 
 
 
  
 
 
 
 
 
  
for (i = 0; i < N; ++i){
      O0[i*OS] += *Start * I0[i*IS];
      O1[i*OS] += *Start * I1[i*IS];
      *Start += *Step;
}
 
 
 
 
 
  
 
 
 
 
矢量生成 vDSP_vrampmul2_s1_15方法
 

 

 
 
void vDSP_vrampmul2_s1_15(
    const short int *__I0, const short int *__I1, vDSP_Stride __IS,
    short int *__Start,
    const short int *__Step,
    short int *__O0, short int *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);
 
 
 
 

   方法算法： 
 
 
 
 
  
 
 
 
 
 
  
for (i = 0; i < N; ++i){
      O0[i*OS] += *Start * I0[i*IS]/32768;//2^15=32768
      O1[i*OS] += *Start * I1[i*IS]/32768;//2^15=32768
      *Start += *Step;
}
 
 
 

 

 
 
 

 

 
 
 

 

矢量生成 vDSP_vrampmul2_s8_24方法
 

 
 
 

 

 
 
void vDSP_vrampmul2_s8_24(
    const int *__I0, const int *__I1, vDSP_Stride __IS,
    int *__Start,
    const int *__Step,
    int *__O0, int *__O1, vDSP_Stride __OS,
    vDSP_Length __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_4_0);

 
 
 

 

 
 
 

 

 
 

   方法算法： 
 
 
 
 
  
 
 
 
 
 
  
for (i = 0; i < N; ++i){
      O0[i*OS] += *Start * I0[i*IS]/16777216;//2^24=16777216
      O1[i*OS] += *Start * I1[i*IS]/16777216;//2^24=16777216
      *Start += *Step;
}
 
 
 
 
 

 

 
 
 

 

矢量生成 vDSP_vgen方法 生成锥形轨道
 

 
 
extern void vDSP_vgen(
    const float *__A,
    const float *__B,
    float       *__C,
    vDSP_Stride  __IC,
    vDSP_Length  __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);
 
 
 方法算法： 

 

 
 
 

 

 
 
for (n = 0; n < N; ++n)
     C[n] = A[0] + (B[0] - A[0]) * n/(N-1);
 
 
 例子： 

 

 
 
 

 

 
 
    float A[1]={1},B[1]={3};
    float C[16]={0};
    printf("input:\n");
    printf("A:%f B:%f",A[0],B[0]);
    vDSP_vgen(A, B, C, 1,8);
    printf("\nvDSP_vgen(A,B,C,1,8) C:\n");
    for (int i=0; i<8; i++) {
        printf("%f ",C[i]);
        C[i]=0;
    }
    
    vDSP_vgen(A, B, C, 2,8);
    printf("\nvDSP_vgen(A,B,C,2,8) C\n");
    for (int i=0; i<8; i++) {
        printf("%f ",C[i]);
        C[i]=0;
    }

 
 
 
 
 

 


  输出结果： 
 
 
 
 
 
 

 


  input: 
 
 A:1.000000 B:3.000000 
 
 vDSP_vgen(A,B,C,1,8) C: 
 
 1.000000 1.285714 1.571429 1.857143 2.142857 2.428571 2.714286 3.000000  
 
 vDSP_vgen(A,B,C,2,4) C 
 
 1.000000 0.000000 1.285714 0.000000 1.571429 0.000000 1.857143 0.000000  
 
 

 

 
 
 

 

 
 
 

 

矢量生成 vDSP_vgenD方法 生成锥形轨道
 

 
 
 

 

 
 
extern void vDSP_vgenD(
    const double *__A,
    const double *__B,
    double       *__C,
    vDSP_Stride   __IC,
    vDSP_Length   __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);
 
 
 

 


  方法算法： 

 

 
 
 

 

 
 
for (n = 0; n < N; ++n)
     C[n] = A[0] + (B[0] - A[0]) * n/(N-1);
 

 

 
 
 

 

矢量生成 vDSP_vgenp方法 生成外推和插值
 

 
 注：M是A、B的长 

 

 
 
extern void vDSP_vgenp(
    const float *__A,
    vDSP_Stride  __IA,
    const float *__B,
    vDSP_Stride  __IB,
    float       *__C,
    vDSP_Stride  __IC,
    vDSP_Length  __N,
    vDSP_Length  __M)  // Length of A and of B.
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);
 
 
 
 
 

 


  方法算法 

 

 
 
 

 

 
 
for (n = 0; n < N; ++n)
     If n <= B[0],  then C[n] = A[0].
     If B[M-1] < n, then C[n] = A[M-1].
     Otherwise:
        Let m be such that B[m] < n <= B[m+1].
        C[n] = A[m] + (A[m+1]-A[m]) * (n-B[m]) / (B[m+1]-B[m]).
 
 
 
 
 

 

 
 
矢量生成 vDSP_vgenpD方法 生成外推和插值
 
 
 
  注：M是A、B的长 A，B
  
 
 
 
extern void vDSP_vgenpD(
    const double *__A,
    vDSP_Stride   __IA,
    const double *__B,
    vDSP_Stride   __IB,
    double       *__C,
    vDSP_Stride   __IC,
    vDSP_Length   __N,
    vDSP_Length   __M)  // Length of A and of B.
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);

 
 
 
 

   方法算法 
 
 
 
 
  
 
 
 
 
 
  
for (n = 0; n < N; ++n)
     If n <= B[0],  then C[n] = A[0].
     If B[M-1] < n, then C[n] = A[M-1].
     Otherwise:
        Let m be such that B[m] < n <= B[m+1].
        C[n] = A[m] + (A[m+1]-A[m]) * (n-B[m]) / (B[m+1]-B[m]).
 
 
 
 
 
 
 

 

 
 
矢量生成  vDSP_vtabi方法 矢量查表和插值
 
 
extern void vDSP_vtabi(
    const float *__A,
    vDSP_Stride  __IA,
    const float *__S1,
    const float *__S2,
    const float *__C,
    vDSP_Length  __M,
    float       *__D,
    vDSP_Stride  __ID,
    vDSP_Length  __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);
 
 
 方法算法： 
 
 
 
 

 

 
 
 for (n = 0; n < N; ++n){
      p = S1[0] * A[n] + S2[0];
      if (p < 0)
          D[n] = C[0];
      else if (p < M-1){
           q = trunc(p);
           r = p-q;
           D[n] = (1-r)*C[q] + r*C[q+1];
      }
      else
           D[n] = C[M-1];
 }

 
 
 
 
 

 

 
 
矢量生成  vDSP_vtabiD方法 矢量查表和插值
 
 
extern void vDSP_vtabiD(
    const double *__A,
    vDSP_Stride   __IA,
    const double *__S1,
    const double *__S2,
    const double *__C,
    vDSP_Length   __M,
    double       *__ID,
    vDSP_Stride   __L,
    vDSP_Length   __N)
        __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_4_0);

 
 
 
 
 

 

 
 

   方法算法： 
  
 
  
 
 
 
 
 
  
 for (n = 0; n < N; ++n){
      p = S1[0] * A[n] + S2[0];
      if (p < 0)
          D[n] = C[0];
      else if (p < M-1){
           q = trunc(p);
           r = p-q;
           D[n] = (1-r)*C[q] + r*C[q+1];
      }
      else
           D[n] = C[M-1];
 }
 
 
 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 


                

        

        

    




    

      

        

            

              
                
                  u014068781
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
VDSP软件说明

				
			

			

				

					10-14
				

			

		

		

			
				
VDSP软件说明。对于visual dsp++软件的介绍，以及如何创建工程等的介绍

			
		

	



                

              
                



	

		

			

				
					
理解单片机(MCU)、ARM、DSP，vDSP(Vision DSP )都是处理器，

				
			

			

				

					cy413026的博客
				

				

					08-26
					
					6122
					
				

			

		

		

			
				
可以具体参考知乎上的讨论怎么深入浅出地理解「单片机、ARM、DSP 有互通之处，都是 CPU」？

一.理解MCU，ARM cpu, DSP

作者：匠人时尚
链接：https://www.zhihu.com/question/19862452/answer/155272152
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。


单片机又叫MCU，ARM和DSP...

			
		

	



                


  
              

                


	

		

			

				
					
用ADSP-21489开发板教你做音频开发，有手就行（二）软件和硬件的开发环境搭建

				
			

			

				

					ADI_OP的博客
				

				

					12-05
					
					2267
					
				

			

		

		

			
				
ADSP-21489的开发详解，软件的安装和硬件的接线说明

			
		

	





	

		

			

				
					
IOS 快速傅立叶变换(使用系统框架vDSP)

				
			

			

				

					zhong015的专栏
				

				

					12-26
					
					5413
					
				

			

		

		

			
				
简介：
vDSP的API提供了一维信号与二维信号，在时域与频域中的傅立叶变换。


FFT权重数组：
为了更好的精度，vDSP处理频域的函数需要一个已经存在的，复杂的指数数组来调用。一旦创建一次，那么所有的FFT变换就可以共享这个数组。这个权重数组可以使用vDSP_create_fftsetup(single-precision)
 或者vDSP_create_fftsetupD
(

			
		

	



		

			
		



	

		

			

				
					
vDSP加速的应用

				
			

			

				

					weixin_30598225的博客
				

				

					07-19
					
					695
					
				

			

		

		

			
				
vDSP 是IOS提供一系列加速处理算法。。在优化时可以考虑应用一二。。。
1、在项目中加入Accelerate.framework库
　　点开项目属性->Build Phases->Link Binary With Libraries->+Accelerate.framework;
2、在应用的类头文件加上引用

#include <Accelerate/Ac...

			
		

	





	

		

			

				
					
如何在VDSP下生成和调用DSP库

				
			

			

				

					04-04
				

			

		

		

			
				
本文将通过两个简单的例程来一步一步演示如何在VisualDSP++里创建并调用基于C 语言的DSP库文件(*.dlb)。虽然例程是基于Blackfin 处理器实的，但创建过程和调用方法依然适用于SHARC、TigerSHARC 等ADI 公司的处理器。

			
		

	





	

		

			

				
					
BDMA.zip_BDMA_VDSP_dma_字节内存

				
			

			

				

					09-21
				

			

		

		

			
				
标题中的“BDMA.zip_BDMA_VDSP_dma_字节内存”揭示了我们即将讨论的核心主题：BDMA（Block Direct Memory Access）技术，它与VDSP（Vector Digital Signal Processor）相关，涉及DMA（Direct Memory Access）操作...

			
		

	





	

		

			

				
					
iOS傅里叶变换

				
			

			

				

					04-02
				

			

		

		

			
				
在iOS中，我们可以使用Accelerate框架中的`vDSP_fft_zrip`函数进行FFT计算。  3. **音频缓冲区与采样率**：在iOS中，音频数据是以缓冲区的形式获取和处理的，每个缓冲区包含一定数量的采样点。采样率决定了每秒采集...

			
		

	





	

		

			

				
					
vdsp查表法

				
			

			

				

					05-01
				

			

		

		

			
				
vdsp C语言编程 正弦函数查表法，专门运用于vdsp中。

			
		

	





	

		

			

				
					
用ADSP-21489开发板教你做音频开发，有手就行（九）如何正确的结束调试

				
			

			

				

					ADI_OP的博客
				

				

					12-05
					
					246
					
				

			

		

		

			
				
ADSP-21489的开发详解，如何正确结束调试，注意这个很关键，不正确结束的话，下一次调试有可能会报错的。

			
		

	





	

		

			

				
					
NVDSP, 用于音频的ios/osx DSP ( 带 Novocaine ).zip

				
			

			

				

					09-18
				

			

		

		

			
				
NVDSP, 用于音频的ios/osx DSP ( 带 Novocaine ) 和OSX上的音频过滤器只需几行代码和 Novocaine插件，或者你自己的音频库，实现高质量的音频过滤器。NVDSP提供了多种音频过滤器：所有传递过滤器( NVAllpassFilter )带通滤波器，0dB 增益( NVBan

			
		

	





	

		

			

				
					
用ADSP-21489开发板教你做音频开发，有手就行（五）SDRAM 内存的硬件设计和软件例程（含源代码）

				
			

			

				

					ADI_OP的博客
				

				

					12-05
					
					516
					
				

			

		

		

			
				
ADSP-21489的开发中，外存（SDRAM）的硬件设计，及软件校验、自检例程源码

			
		

	





	

		

			

				
					
用ADSP-21489开发板教你做音频开发，有手就行（四）按键控制 LED 灯（含源代码）

				
			

			

				

					ADI_OP的博客
				

				

					12-05
					
					1442
					
				

			

		

		

			
				
ADSP-21489的IO，从按键和LED灯开始，最基础的硬件设计原理和软件教程

			
		

	





	

		

			

				
					
IOS中的矩阵和向量运算

				
			

			

				

					Leo的专栏
				

				

					11-20
					
					8303
					
				

			

		

		

			
				
较完整的描述了，向量的加减乘除，矩阵的乘法，矩阵的转置以及矩阵的逆矩阵

			
		

	





	

		

			

				
					
用ADSP-21489开发板教你做音频开发，有手就行（七）Block-Based Talkthru 48 or 96 kHz）（含源代码）

				
			

			

				

					ADI_OP的博客
				

				

					12-05
					
					2093
					
				

			

		

		

			
				
ADSP-21489的开发详解，音频的4进8出，直通的设计，从硬件到软件详解

			
		

	





	

		

			

				
					
音频频谱动画的原理与实现（一）

				
			

			

				

					zhangdongxuan的博客
				

				

					08-01
					
					2587
					
				

			

		

		

			
				
频谱是指一个时域的信号在频域下的表示方式，可以将时域信号进行傅里叶变换得到频域数据，并将其以动画形式表现出来，可以反映出声音的特征。

			
		

	





	

		

			

				
					
Vdsp(bf561)中的浮点运算（10）：fract16类型表示

				
			

			

				

					嵌云阁
				

				

					08-17
					
					3417
					
				

			

		

		

			
				
快乐虾http://blog.csdn.net/lights_joy/lights@hb165.com  本文适用于ADSP-BF561Visual DSP++ 5.0 (update 6)Vdsp dual processor simulate  欢迎转载，但请保留作者信息   fract16是VDSP的另一种浮点类型，它使用1.15的格式： 

			
		

	





	

		

			

				
					
让vdsp与uclinux共舞（8）：vdsp驱动框架

				
			

			

				

					嵌云阁
				

				

					11-03
					
					1722
					
				

			

		

		

			
				
 快乐虾http://blog.csdn.net/lights_joy/lights@hb165.com 本文适用于ADSP-BF561Visual DSP++ 5.0(update 6)Bfin-uclinux-2009r1.6 欢迎转载，但请保留作者信息   做好前面的准

			
		

	





	

		

			

				
					
用ADSP-21489开发板教你做音频开发，有手就行（一）科普一下开发逻辑和概念

				
			

			

				

					ADI_OP的博客
				

				

					12-05
					
					1895
					
				

			

		

		

			
				
从0开始，手把手教你开发ADSP-21489！有手就行！

			
		

	





	

		

			

				
					
如何理解VDSP的情况

					
最新发布

				
			

			

				

					07-13
				

			

		

		

			
				
2. 数据对齐要求：VDSP通常要求数据在内存中按照特定的对齐方式存储。这是因为向量指令需要访问连续的内存地址来读取数据，如果数据没有按照对齐要求存储，可能会导致性能下降。  3. 应用领域：VDSP广泛应用于数字...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
u014068781

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值