c_colldet.c

dsp6713开发板的许多例程.对入门特别有用

/****************************************************************************/
/*         Copyright (C) 1996-2000 Texas Instruments Incorporated           */
/*                      All Rights Reserved                                 */
/*                                                                          */
/* C_COLLDET.C - Collision detection example.                               */
/*               Example code from Programmer's Guide on optimizing C code. */
/*                                                                          */
/****************************************************************************/
#include <stdio.h>
#include <time.h>

int colldet1(float * restrict, float * restrict, float, float, int);
int colldet2(float * restrict, float * restrict, float, float, int);

float a[] = {  1.20,  2.30,  3.40,  2.30,  2.30,  3.40,  2.30,  2.30,  1.20,
               2.30,  2.30,  3.40,  1.20,  2.30,  3.40,  1.20,  2.30,  3.40,
               0.01,  1.32,  2.11, 91.11, 11.11, 35.11,  1.23,  2.91,  5.10,
               1.20,  2.30,  3.40,  2.30,  2.30,  3.40,  1.20,  2.30,  3.40,
               2.30,  2.30,  3.40,  1.20,  2.30,  3.40,  1.20,  2.30,  3.40,
               2.45,  2.10,  3.80,  7.20,  1.30,  6.40,  3.20,  2.30,  0.40,
               0.10,  1.20,  2.30,  3.40,  4.40,  5.60,  0.19,  1.12,  2.32,
               1.20,  2.30,  3.40,  1.20,  2.30,  3.40,  4.70,  5.60,  6.90,
               1.20,  2.30,  3.40,  0.90,  1.20,  2.30,  3.40,  4.70,  5.60,
               6.90,  7.30,  8.10,  9.30, 10.10, 11.33, 12.44, 13.55, 14.66,
               0.10,  1.20,  2.30,  3.40,  4.40,  5.60, 20.19, 21.12, 22.32,
               9.23, 10.35, 11.48, 12.60, 13.29, 14.93, 15.12, 16.47, 17.17,
              18.18, 19.19, 21.21, 15.51, 16.61, 17.71, 16.78, 19.11, 12.96,
              23.37, 24.83, 25.81 };

float b[] = { 1.2, 2.3, 3.4 };
float point = 146;
short num = 40;
float distance = 10.2;
int ret1, ret2;

/****************************************************************************/
/* TOP LEVEL DRIVER FOR THE TEST.                                           */
/****************************************************************************/
int main()
{
    clock_t t_overhead, t_start, t_stop;

    /************************************************************************/
    /* COMPUTE THE OVERHEAD OF CALLING CLOCK TWICE TO GET TIMING INFO.      */
    /************************************************************************/
    t_start    = clock();
    t_stop     = clock();
    t_overhead = t_stop - t_start;

    /************************************************************************/
    /* TIME COLLDET1                                                        */
    /************************************************************************/
    t_start = clock();
    ret1 = colldet1(a, b, point, distance, num);
    t_stop = clock();
    printf("COLLDET1: %d cycles\n", t_stop - t_start - t_overhead);

    /************************************************************************/
    /* TIME COLLDET2                                                        */
    /************************************************************************/
    t_start = clock();
    ret2 = colldet2(a, b, point, distance, num);
    t_stop = clock();
    printf("COLLDET2: %d cycles\n", t_stop - t_start - t_overhead);
    if (ret2 != ret1) printf("Result failure colldet2()\n");
    else              printf("Correct result colldet\n");
}

/****************************************************************************/
/* COLLDET1 - BASIC FORM.                                                   */
/****************************************************************************/
int colldet1(float * restrict x, float * restrict p, float point, 
             float distance, int count)
{
    int i, retval = 0;
    float sum0, sum1, dist0, dist1;

    for (i = 0; i < (count * 3); i += 6)
    {
        sum0  = x[i+0] * p[0] + x[i+1] * p[1] + x[i+2] * p[2];
        sum1  = x[i+3] * p[0] + x[i+4] * p[1] + x[i+5] * p[2];
        dist0 = sum0 - point;
        dist1 = sum1 - point;
        dist0 = fabs(dist0);
        dist1 = fabs(dist1);
        if (dist0 < distance)
        {
            retval = (int)&x[i+0];
            break;
        }
        if (dist1 < distance)
        {
            retval = (int)&x[i+3];
            break;
        }
    }

    return retval;
}

/****************************************************************************/
/* COLLDET2 - MODIFIED C CODE.                                              */
/****************************************************************************/
int colldet2(float * restrict x, float * restrict p, float point,
             float distance, int count)
{
    int i, retval = 0;
    float sum0, sum1, dist0, dist1;

    for (i = 0; i < (count * 3); i++)
    {
        sum0  = x[i+0] * p[0] + x[i+1] * p[1] + x[i+2] * p[2];
        sum1  = x[i+3] * p[0] + x[i+4] * p[1] + x[i+5] * p[2];
        dist0 = sum0 - point;
        dist1 = sum1 - point;
        dist0 = fabs(dist0);
        dist1 = fabs(dist1);
        if (!retval && (dist0 < distance)) retval = (int)&x[i+0];
        if (!retval && (dist1 < distance)) retval = (int)&x[i+3];
    }

    return retval;
}