vector_support.h

ecos为实时嵌入式操作系统

} // checkErrorAcceptable()


// This allows us to run through any test vectors of form:
// double = fn(double, double)
// double = fn(double)
// double = fn(double, int)
// double = fn(double, int *)
// double = fn(double, double *)
//
// result type being non-double is left as a future enhancement
//
// This returns true if the tests all succeeded and false if any failed
//
static cyg_bool
doTestVec( CYG_ADDRESS func_ptr,
           Cyg_libm_test_arg_type arg1_type,
           Cyg_libm_test_arg_type arg2_type,
           Cyg_libm_test_arg_type result_type,
           const Cyg_libm_test_double_vec_t *vectors,
           cyg_ucount32 num_vectors )
{
    cyg_ucount32 problems=0;
    cyg_ucount32 i;
    Cyg_libm_ieee_double_shape_type arg1, arg2, result_wanted, ret;
    cyg_ucount32 alive_count = num_vectors / 10;

    if ((arg1_type != CYG_LIBM_TEST_VEC_DOUBLE) ||
        (result_type != CYG_LIBM_TEST_VEC_DOUBLE) ) {
        CYG_TEST_FAIL("Test vector arguments are not correct type!");
        return false;
    } // if

    switch (arg2_type) {
    case CYG_LIBM_TEST_VEC_DOUBLE:

        {
            ddfn fn = (ddfn) func_ptr;

            for (i=0;
                 (i < num_vectors) && (problems < PROBLEM_THRESHOLD);
                 i++) {

                if (0 == i % alive_count)
                    CYG_TEST_STILL_ALIVE(i, "Still crunching, please wait...");

                arg1.parts.msw = vectors[i].arg1_msw;
                arg1.parts.lsw = vectors[i].arg1_lsw;

                arg2.parts.msw = vectors[i].arg2_msw;
                arg2.parts.lsw = vectors[i].arg2_lsw;

                result_wanted.parts.msw = vectors[i].result_msw;
                result_wanted.parts.lsw = vectors[i].result_lsw;

                ret.value = (*fn)( arg1.value, arg2.value );

                if ((vectors[i].errno_val) != 0) {

#ifndef CYGSEM_LIBM_COMPAT_IEEE_ONLY
                    // In IEEE-mode we can't check the answer if this
                    // is an error case

                    if ((cyg_libm_get_compat_mode() !=
                        CYGNUM_LIBM_COMPAT_IEEE) &&
                        (errno != vectors[i].errno_val)) {

                        ++problems;
                        diag_printf("Vector #%d\n", i+1);
                        CYG_TEST_FAIL( "error not set correctly");

                    } // if
#endif

                    continue; // no point checking value in an error case
                } // if
                if (checkErrorAcceptable( ret, result_wanted,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Result out of tolerance");
                } // if
            } // for
            
        } // compound
            
        break;

    case CYG_LIBM_TEST_VEC_INT:

        {
            difn fn = (difn) func_ptr;
        
            for (i=0;
                 (i < num_vectors) && (problems < PROBLEM_THRESHOLD);
                 i++) {

                if (0 == i % alive_count)
                    CYG_TEST_STILL_ALIVE(i, "Still crunching, please wait...");

                arg1.parts.msw = vectors[i].arg1_msw;
                arg1.parts.lsw = vectors[i].arg1_lsw;

                result_wanted.parts.msw = vectors[i].result_msw;
                result_wanted.parts.lsw = vectors[i].result_lsw;

                ret.value = (*fn)( arg1.value, vectors[i].arg2_lsw );
                if (checkErrorAcceptable( ret, result_wanted,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Result out of tolerance");
                } // if
            } // for
            
        } // compound
            
        break;

    case CYG_LIBM_TEST_VEC_INT_P:

        {
            dipfn fn = (dipfn) func_ptr;
            int my_int;
            Cyg_libm_ieee_double_shape_type my_doub1, my_doub2;
        
            for (i=0;
                 (i < num_vectors) && (problems < PROBLEM_THRESHOLD);
                 i++) {

                if (0 == i % alive_count)
                    CYG_TEST_STILL_ALIVE(i, "Still crunching, please wait...");

                arg1.parts.msw = vectors[i].arg1_msw;
                arg1.parts.lsw = vectors[i].arg1_lsw;


                result_wanted.parts.msw = vectors[i].result_msw;
                result_wanted.parts.lsw = vectors[i].result_lsw;

                ret.value = (*fn)( arg1.value, &my_int );
                if (checkErrorAcceptable( ret, result_wanted,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Result out of tolerance");
                } // if

                my_doub1.value = (double) my_int;
                my_doub2.value = (double) (signed)vectors[i].arg2_lsw;
                
                if (checkErrorAcceptable( my_doub1, my_doub2,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Integer result out of tolerance");
                } // if

                
            } // for
            
        } // compound
            
        break;

    case CYG_LIBM_TEST_VEC_DOUBLE_P:

        {
            ddpfn fn = (ddpfn) func_ptr;
            Cyg_libm_ieee_double_shape_type my_doub1;
        
            for (i=0;
                 (i < num_vectors) && (problems < PROBLEM_THRESHOLD);
                 i++) {

                if (0 == i % alive_count)
                    CYG_TEST_STILL_ALIVE(i, "Still crunching, please wait...");

                arg1.parts.msw = vectors[i].arg1_msw;
                arg1.parts.lsw = vectors[i].arg1_lsw;

                arg2.parts.msw = vectors[i].arg2_msw;
                arg2.parts.lsw = vectors[i].arg2_lsw;


                result_wanted.parts.msw = vectors[i].result_msw;
                result_wanted.parts.lsw = vectors[i].result_lsw;

                ret.value = (*fn)( arg1.value, &my_doub1.value );
                if (checkErrorAcceptable( ret, result_wanted,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Result out of tolerance");
                } // if

                if (checkErrorAcceptable( my_doub1, arg2,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Returned double result out of "
                                   "tolerance");
                } // if

                
            } // for
            
        } // compound
            
        break;

    case CYG_LIBM_TEST_VEC_NONE:

        {
            dfn fn = (dfn) func_ptr;
        
            for (i=0;
                 (i < num_vectors) && (problems < PROBLEM_THRESHOLD);
                 i++) {

                if (0 == i % alive_count)
                    CYG_TEST_STILL_ALIVE(i, "Still crunching, please wait...");

                arg1.parts.msw = vectors[i].arg1_msw;
                arg1.parts.lsw = vectors[i].arg1_lsw;

                result_wanted.parts.msw = vectors[i].result_msw;
                result_wanted.parts.lsw = vectors[i].result_lsw;

                ret.value = (*fn)( arg1.value );
                if (checkErrorAcceptable( ret, result_wanted,
                                          vectors[i].tolerance) ) {
                    ++problems;
                    diag_printf("Vector #%d\n", i+1);
                    CYG_TEST_FAIL( "Result out of tolerance");
                } // if
            } // for
            
        } // compound
            
        break;

    default:
        CYG_TEST_FAIL("Second argument of unknown type!");
        return false;
    } // switch

    if (problems != 0)
        return false;
    else
        return true;

} // doTestVec()

#endif // ifdef CYGPKG_LIBM     

#endif // CYGONCE_LIBM_VECTOR_SUPPORT_H multiple inclusion protection

// EOF vector_support.h