[Beignet] [PATCH v5] Add test cases generator.

Zhigang Gong zhigang.gong at linux.intel.com
Tue Dec 24 22:01:28 PST 2013


Pushed, thanks.

On Tue, Dec 24, 2013 at 11:15:18AM +0800, Yi Sun wrote:
>     v1:
>     File utest_generator.py contain the base class and function for generating
>     File utest_math_gen.py can generate most math function for all the gentype
>     utest_math_gen.py can be run during cmake.
> 
>     v2:
>     1. Put all the generated unit test cases to folder utest/generated.
>     2. Delete all generated folder while involve make clean.
>     3. At the top of the generated test cases, add some comments
>     4. Instead of defined FLT_ULP(0.000001) as the ulp unit, caculate the float ulp before using it.
>     5. Add several math functions' test case.
> 
>     v3:
>     1. Refine the calculation for float, and calculate each float got from cpu function.
> 
>     v4:
>     Refine the calculation for float.
> 
>     Following fucntions test cases fail with input 0, 1 or 3.14:
> 	builtin_atan2_float
> 	builtin_atanh_float
> 	builtin_rootn_float
>     builtin_cos_float
>     builtin_cospi_float
>     builtin_erf_float
>     builtin_erfc_float
>     builtin_mad_float
>     builtin_nextafter_float
>     builtin_pown_float
>     builtin_powr_float
>     builtin_rint_float
>     builtin_sinpi_float
>     builtin_tan_float
>     builtin_tanpi_float
> 
>     v5:
>     remove case builtin_mad_float
> 
> 	todo:
> 	atan2pi
> 	fmax
> 	fmin
> 	sincos
> 
> Signed-off-by: Yi Sun <yi.sun at intel.com>
> Signed-off-by: Yangwei Shui <yangweix.shui at intel.com>
> ---
>  utests/CMakeLists.txt     |    9 +
>  utests/utest_generator.py |  374 +++++++++++++++++++++++++++++++
>  utests/utest_helper.cpp   |   30 +++
>  utests/utest_helper.hpp   |    6 +
>  utests/utest_math_gen.py  |  531 +++++++++++++++++++++++++++++++++++++++++++++
>  5 files changed, 950 insertions(+), 0 deletions(-)
>  create mode 100644 utests/utest_generator.py
>  create mode 100755 utests/utest_math_gen.py
> 
> diff --git a/utests/CMakeLists.txt b/utests/CMakeLists.txt
> index 5e0bc19..836c80d 100644
> --- a/utests/CMakeLists.txt
> +++ b/utests/CMakeLists.txt
> @@ -1,10 +1,19 @@
>  INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}
>                      ${CMAKE_CURRENT_SOURCE_DIR}/../include)
>  
> +EXEC_PROGRAM(mkdir ${CMAKE_CURRENT_SOURCE_DIR} ARGS generated -p)
> +##### Math Function Part:
> +EXEC_PROGRAM(python ${CMAKE_CURRENT_SOURCE_DIR} ARGS utest_math_gen.py OUTPUT_VARIABLE GEN_MATH_STRING)
> +string(REGEX REPLACE " " ";" ADDMATHFUNC ${GEN_MATH_STRING})
> +string(REGEX REPLACE " " "\n" NAMEMATHLIST ${GEN_MATH_STRING})
> +MESSAGE(STATUS "Generated Builtin Math Functions:\n" ${NAMEMATHLIST})
> +set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES generated/)
> +
>  link_directories (${LLVM_LIBRARY_DIR})
>  set (utests_sources
>    cl_create_kernel.cpp
>    utest_error.c
> +  ${ADDMATHFUNC}
>    compiler_basic_arithmetic.cpp
>    compiler_displacement_map_element.cpp
>    compiler_shader_toy.cpp
> diff --git a/utests/utest_generator.py b/utests/utest_generator.py
> new file mode 100644
> index 0000000..626ac96
> --- /dev/null
> +++ b/utests/utest_generator.py
> @@ -0,0 +1,374 @@
> +#!/usr/bin/python
> +import os,sys,re
> +
> +FLT_MAX_POSI='0x1.fffffep127f'
> +FLT_MIN_NEGA='-0x1.fffffep127f'
> +FLT_MIN_POSI='0x1.0p-126f'
> +FLT_MAX_NEGA='-0x1.0p-126f'
> +
> +paraTypeList={'float':'%.20f','int':'%d','double':'%lf','uint':'%d','string':'%s'}
> +
> +
> +def ulpUnit(ulpSize):
> +  return re.findall(r"([a-zA-Z_]+)",ulpSize)[0]
> +
> +def ulpNum(ulpSize):
> +  return re.findall(r"([0-9]+)",ulpSize)[0]
> +
> +def udebug(ulpSize,returnType):
> +  #ulpUnit=re.findall(r"([a-zA-Z_]+)",ulpSize)[0]
> +  #ulpNum=re.findall(r"([0-9]+)",ulpSize)[0]
> +  text='''
> +    static const char* INFORNAN;
> +    static %s ULPSIZE;
> +    
> +    if (isinf(cpu_data[index])){
> +      INFORNAN="INF";
> +    }
> +    else if (isnan(cpu_data[index])){
> +      INFORNAN="NAN";
> +    }
> +    else{
> +      ULPSIZE=cl_%s(cpu_data[index]) * %s;
> +    }
> +
> +#if udebug 
> +    if (isinf(cpu_data[index])){ 
> +      if (isinf(gpu_data[index]))
> +        printf("%s expect:%s\\n", log, INFORNAN);
> +      else
> +        printf_c("%s expect:%s\\n", log, INFORNAN);
> +      }
> +    else if (isnan(cpu_data[index])){
> +      if (isnan(gpu_data[index]))
> +        printf("%s expect:%s\\n", log, INFORNAN);
> +      else
> +        printf_c("%s expect:%s\\n", log, INFORNAN);
> +      }
> +    else if (diff <= ULPSIZE){
> +      printf("%s expect:%s\\n", log, ULPSIZE);
> +      }
> +    else
> +      printf_c("%s expect:%s\\n", log, ULPSIZE);
> +#else
> +    if (isinf(cpu_data[index])){
> +      sprintf(log, "%s expect:%s\\n", log, INFORNAN);
> +      OCL_ASSERTM(isinf(gpu_data[index]),log);
> +      }
> +    else if (isnan(cpu_data[index])){
> +      sprintf(log, "%s expect:%s\\n", log, INFORNAN);
> +      OCL_ASSERTM(isnan(gpu_data[index]),log);
> +      }
> +    else{
> +      sprintf(log, "%s expect:%s\\n", log, ULPSIZE);
> +      OCL_ASSERTM(fabs(gpu_data[index]-cpu_data[index]) <= ULPSIZE, log);
> +      }
> +#endif
> +  }
> +}\n'''%(returnType,\
> +        ulpUnit(ulpSize),ulpNum(ulpSize),\
> +        paraTypeList['string'],paraTypeList['string'],\
> +        paraTypeList['string'],paraTypeList['string'],\
> +        paraTypeList['string'],paraTypeList['string'],\
> +        paraTypeList['string'],paraTypeList['string'],\
> +        paraTypeList['string'],paraTypeList['%s'%(returnType)],\
> +        paraTypeList['string'],paraTypeList['%s'%(returnType)],\
> +        paraTypeList['string'],paraTypeList['string'],\
> +        paraTypeList['string'],paraTypeList['string'],\
> +        paraTypeList['string'],paraTypeList['%s'%(returnType)])
> +
> +  return text
> +
> +def gene2ValuesLoop(values1,values2,inputValues):
> +  values2=values2+inputValues*len(inputValues)
> +
> +  for i in inputValues:
> +    for j in range(0,len(inputValues)):
> +      values1 += [i]
> +
> +  return values1,values2
> +
> +def gene3ValuesLoop(values1,values2,values3,inputValues):
> +  for i in inputValues:
> +    for j in range(0,len(inputValues)):
> +      for k in range(0,len(inputValues)):
> +        values1 += [i]
> +
> +  for i in inputValues:
> +    for j in inputValues:
> +      for k in range(0,len(inputValues)):
> +        values2 += [j]
> +
> +  values3=inputValues*(len(inputValues)**2)
> +  return values1,values2,values3
> +
> +class func:
> +  """ This class will define all needed instance attribute in fundation a c programing file. """
> +
> +  def __init__(self,name,cpuFuncName,inputType,outputType,values,ulp, cpu_func=''):
> +    self.funcName = name
> +    self.cpuFuncName = cpuFuncName
> +    self.fileName = 'builtin_'+name
> +    self.inputtype = inputType
> +    self.outputtype = outputType
> +    self.values = values
> +    self.ulp = ulp
> +    self.cpufunc=cpu_func
> +    self.cpplines = []
> +    
> +#####cpp file required information:
> +    self.Head='''/*
> +This file is generated by utest_generator.py.
> +Usually you need NOT modify this file manually.
> +But when any bug occured, you can change the value of udebug from 0 to 1,
> +which can print more values and information to assist debuging the issue.
> +*/
> +
> +#include "utest_helper.hpp"
> +#include <stdio.h>
> +#include <math.h>
> +#include <algorithm>
> +
> +#define udebug 0
> +#define FLT_MAX 0x1.fffffep127f
> +#define FLT_MIN 0x1.0p-126f
> +#define INT_ULP 0
> +
> +#define printf_c(...) \\
> +{\\
> +  printf("\\033[1m\\033[40;31m");\\
> +  printf( __VA_ARGS__ );\\
> +  printf("\\033[0m");\\
> +}
> +'''
> +    #########Execute class itself
> +    self.geneProcess()
> +
> +#####Computer vector && argument type:
> +  def argtype(self,paraN,index):
> +    return re.findall(r"[a-zA-Z_]+",self.inputtype[paraN][index])[0]
> +
> +  def argvector(self,paraN,index):
> +    vector=re.findall(r"[0-9]+",self.inputtype[paraN][index])
> +    if vector:
> +      vector=vector[0]
> +    else:
> +      vector=1
> +    return vector
> +
> +  def returnVector(self,index):
> +    returnVector=re.findall(r"[0-9]+",self.outputtype[index])
> +    if returnVector:
> +      returnVector=returnVector[0]
> +    else:
> +      returnVector=1
> +    return returnVector
> +
> +  def retType(self,index):
> +    return re.findall("[a-zA-Z_]+",self.outputtype[index])[0]
> +
> +  def inputNumFormat(self,paraN,index):
> +    return paraTypeList['%s'%(self.argtype(paraN,index))]
> +
> +  def outputNumFormat(self,index):
> +    return paraTypeList['%s'%(self.retType(index))]
> +
> +#####Cpu values analyse
> +  def GenInputValues(self,index):
> +    #namesuffix=self.inputtype[0][index]
> +    for i in range(0,self.values.__len__()):
> +      self.cpplines += [ "const %s input_data%d[] = {%s};" %(self.argtype(i,index),i+1,str(self.values[i]).strip('[]').replace('\'','')) ]
> +    self.cpplines += [ "const int count_input = sizeof(input_data1) / sizeof(input_data1[0]);" ]
> +    self.cpplines += [ "const int vector = %s;\n"%(self.argvector(self.inputtype.__len__()-1,index)) ]
> +
> +#####Cpu Function
> +  def GenCpuCompilerMath(self,index):
> +    #namesuffix=self.inputtype[0][index]
> +    defline='static void cpu_compiler_math(%s *dst, '%(self.retType(index))
> +    cpufunargs='('
> +    funcline = ['{']
> +    vectorargs=[]
> +
> +    if (self.returnVector(index) == 1 and self.argvector(0,index) != 1):
> +      for i in range(0,self.values.__len__()):
> +        defline += 'const %s *src%d'%(self.argtype(i,index),i+1)
> +        defline += ( i == self.values.__len__()-1 ) and ')' or ','
> +        vectorargs.append('(')
> +      for i in range(0,self.values.__len__()):
> +        for j in range(0,self.vector):
> +          vectorargs += "x%d%d"%(i+1,j+1)
> +          vectorargs += ( j == self.vector-1 ) and ');' or ','
> +          funcline += ["  const %s x%d%d = *(src%d+%d);"%(self.argtype(i,index),i+1,j+1,i+1,j)]
> +
> +      return 0
> +
> +    for i in range(0,self.values.__len__()):
> +      defline += 'const %s *src%d'%(self.argtype(i,index),i+1)
> +      defline += ( i == self.values.__len__()-1 ) and ')' or ','
> +      cpufunargs += "x%d"%(i+1)
> +      cpufunargs += ( i == self.values.__len__()-1 ) and ');' or ','
> +      funcline += ["  const %s x%d = *src%d;"%(self.argtype(i,index),i+1,i+1)]
> +
> +    funcline += [ "  dst[0] = %s%s"%(self.cpuFuncName, cpufunargs) ]
> +    funcline += [ '}'] 
> +
> +    funcline = [defline] + funcline
> +
> +    self.cpplines += funcline
> +#    self.writeCPP( '\n'.join(funcline), 'a', namesuffix)
> +
> +  def writeCPP(self,content,authority,namesuffix):
> +    file_object = open("generated/%s_%s.cpp"%(self.fileName,namesuffix),authority)
> +    file_object.writelines(content)
> +    file_object.close()
> +
> +  def writeCL(self,content,authority,namesuffix):
> +    file_object = open(os.getcwd()+"/../kernels/%s_%s.cl"%(self.fileName,namesuffix),authority)
> +    file_object.writelines(content)
> +    file_object.close()
> +
> +  def nameForCmake(self,content,namesuffix):
> +    print("generated/%s_%s.cpp"%(self.fileName,namesuffix)),
> +
> +  def utestFunc(self,index):
> +    funcLines=[]
> +    namesuffix=self.inputtype[0][index]
> +    funcline=[]
> +    funchead='''
> +static void %s_%s(void)
> +{
> +  int index;
> +  %s gpu_data[count_input] = {0}, cpu_data[count_input] = {0}, diff=0.0;
> +  char log[1024] = {0};
> +
> +  OCL_CREATE_KERNEL(\"%s_%s\");
> +  OCL_CREATE_BUFFER(buf[0], CL_MEM_READ_WRITE, count_input * sizeof(%s), NULL); 
> +
> +  globals[0] = count_input;
> +  locals[0] = 1;
> + '''%(self.fileName,namesuffix,\
> +     self.retType(index),\
> +     self.fileName, namesuffix,\
> +     self.retType(index))
> +
> +    funcline += [funchead]
> +    for i in range(1,self.values.__len__()+1): 
> +      funcline += ["  OCL_CREATE_BUFFER(buf[%d], CL_MEM_READ_WRITE, count_input * sizeof(%s), NULL);"%(i,self.argtype(i-1,index))]
> +      funcline += ["  clEnqueueWriteBuffer( queue, buf[%d], CL_TRUE, 0, count_input * sizeof(%s), input_data%d, 0, NULL, NULL);"%(i,self.argtype(i-1,index),i)]
> +
> +    funcline += ["  OCL_CREATE_BUFFER(buf[%d], CL_MEM_READ_WRITE, sizeof(int), NULL);"%(self.inputtype.__len__()+1)]
> +    funcline += ["  clEnqueueWriteBuffer( queue, buf[%d], CL_TRUE, 0, sizeof(int), &vector, 0, NULL, NULL);"%(self.inputtype.__len__()+1)]
> +
> +	#0=output 1=input1 2=input2 ... len+2=output
> +    for i in range(0,self.values.__len__()+2): 
> +      funcline += ["  OCL_SET_ARG(%d, sizeof(cl_mem), &buf[%d]);"%(i,i)]
> +
> +    funcrun='''
> +  // Run the kernel:
> +  OCL_NDRANGE( 1 );
> +  clEnqueueReadBuffer( queue, buf[0], CL_TRUE, 0, sizeof(%s) * count_input, gpu_data, 0, NULL, NULL);
> +'''%(self.inputtype.__len__()+1)
> +    funcline += [ funcrun ]
> +
> +    funcsprintfa='    sprintf(log, \"'
> +    funcsprintfb=''
> +    if (self.returnVector(index) == 1 and self.argvector(0,index) != 1):
> +      funccompare='''
> +  for (index = 0; index < count_input/vector; index++)
> +  {
> +    cpu_compiler_math( cpu_data + index, '''
> +    else:
> +      funccompare='''
> +  for (index = 0; index < count_input; index++)
> +  {
> +    cpu_compiler_math( cpu_data + index,'''
> +
> +    for i in range(0,self.values.__len__()):
> +      funccompare += " input_data%d + index"%(i+1)
> +      funccompare += (self.values.__len__() - 1 == i) and ');' or ','
> +
> +      funcsprintfa += "input_data%d:"%(i+1)
> +      funcsprintfa += "%s "%(self.inputNumFormat(i,index))
> +      funcsprintfb += " input_data%d[index],"%(i+1)
> +
> +    funcline += [ funccompare ]
> +
> +    funcsprintfa += " -> gpu:%s  cpu:%s diff:%s\","%(self.outputNumFormat(index),self.outputNumFormat(index),self.outputNumFormat(index))#,self.outputNumFormat(index))
> +    funcsprintfb += " gpu_data[index], cpu_data[index], diff);"#%(ulpUnit(self.ulp),ulpNum(self.ulp))
> +
> +    #funcdiff = "    diff = fabs((gpu_data[index]-cpu_data[index])"
> +    #funcdiff += (self.retType(index) == "int") and ');' or '/(cpu_data[index]>1?cpu_data[index]:1));'
> +    funcdiff = "    diff = fabs((gpu_data[index]-cpu_data[index]));"
> +    funcline += [ funcdiff ]
> +    funcline += [ funcsprintfa + funcsprintfb ]
> +
> +    self.cpplines += funcline
> +
> +    self.cpplines += [ udebug(self.ulp,self.retType(index)) ]
> +    self.cpplines += [ "MAKE_UTEST_FROM_FUNCTION(%s_%s)"%(self.fileName,namesuffix) ]
> +
> +  def genCL(self,index):
> +    namesuffix=self.inputtype[0][index]
> +    clLine = []
> +    clhead = '__kernel void %s_%s(__global %s *dst, '%(self.fileName,namesuffix,self.retType(index))
> +    clvalueDef=''
> +    clcomputer=''
> +    tmp=''
> +
> +    for i in range(0,self.values.__len__()):
> +      clhead += ' __global %s *src%d,'%(self.argtype(i,index),i+1)
> +      clvalueDef +=   '  %s x%d = (%s) ('%(self.inputtype[i][index],i+1,self.inputtype[i][index])
> +      tmp = 'src%d[i * (*vector) + '%(i+1)
> +      for j in range(0,int(self.argvector(i,index))):
> +        clvalueDef += tmp + ((int(self.argvector(i-1,index)) == j+1 ) and '%d]);\n'%(j) or '%d],'%(j))
> +      clcomputer += (self.values.__len__() == i+1) and 'x%d);'%(i+1) or 'x%d,'%(i+1)
> +      
> +    clhead += ' __global int *vector) {\n'
> +    clhead += '  int i = get_global_id(0);'
> +    clLine += [ clhead ]
> +    clLine += [ clvalueDef ]
> +    clLine += [ '  %s ret;'%(self.outputtype[index]) ]
> +    clLine += [ '  ret = %s('%(self.funcName) + clcomputer ] 
> +
> +    if (int(self.returnVector(index)) == 1):
> +      clLine += [ '  dst[i] = ret;' ]
> +    else:
> +      for i in range(0,int(self.returnVector(index))):
> +        clLine += [ '  dst[i * (*vector) + %d] = ret[%d];'%(i,i) ]
> +    clLine += [ '};' ]
> +
> +    self.writeCL('\n'.join(clLine),'w',namesuffix)
> +  
> +  def geneProcess(self):
> +    for i in range(0,self.inputtype[0].__len__()):
> +##########Write Cpp file          
> +      namesuffix=self.inputtype[0][i]
> +      self.cpplines = []
> +      #The head:
> +      self.cpplines += [self.Head]
> +
> +      #Parameters:
> +      self.GenInputValues(i)
> +
> +      #cpu function generator:
> +      self.cpplines += [self.cpufunc]
> +
> +      #Cpu function:
> +      self.GenCpuCompilerMath(i)
> +
> +      #utest function
> +      self.utestFunc(i)
> +
> +      #kernel cl
> +      self.genCL(i)
> +
> +      #CMakelists.txt
> +      self.nameForCmake(self.fileName,namesuffix)
> +
> +      self.writeCPP( '\n'.join(self.cpplines) ,'w',namesuffix)
> +#########End
> +
> +#def main():
> +#
> +#if __name__ == "__main__":
> +#  main()
> diff --git a/utests/utest_helper.cpp b/utests/utest_helper.cpp
> index 65af727..8b9ae5f 100644
> --- a/utests/utest_helper.cpp
> +++ b/utests/utest_helper.cpp
> @@ -641,3 +641,33 @@ int cl_check_image(const int *img, int w, int h, const char *bmp)
>    return (float(discrepancy) / float(n) > max_error_ratio) ? 0 : 1;
>  }
>  
> +typedef struct
> +{
> +  unsigned int mantissa:23;
> +  unsigned int exponent:8;
> +  unsigned int sign:1;
> +} FLOAT;
> +
> +typedef union
> +{
> +  float f;
> +  unsigned int i;
> +  FLOAT spliter;
> +} SF;
> +
> +const float cl_FLT_ULP(float float_number)
> +{
> +  SF floatBin, ulpBin;
> +  floatBin.f = float_number;
> +
> +  ulpBin.spliter.sign = floatBin.spliter.sign;
> +  ulpBin.spliter.exponent = floatBin.spliter.exponent;
> +  ulpBin.spliter.mantissa = 0x1;
> +  
> +  return ulpBin.f;
> +}
> +
> +const int cl_INT_ULP(int int_number)
> +{
> +  return 0;
> +}
> diff --git a/utests/utest_helper.hpp b/utests/utest_helper.hpp
> index 29a21d5..79e7417 100644
> --- a/utests/utest_helper.hpp
> +++ b/utests/utest_helper.hpp
> @@ -216,5 +216,11 @@ extern void cl_write_bmp(const int *data, int width, int height, const char *fil
>  /* Check data from img against bmp file located at "bmp" */
>  extern int cl_check_image(const int *img, int w, int h, const char *bmp);
>  
> +/* Calculator ULP of each FLOAT value */
> +extern const float cl_FLT_ULP(float float_number);
> +
> +/* Calculator ULP of each INT value */
> +extern const int cl_INT_ULP(int int_number);
> +
>  #endif /* __UTEST_HELPER_HPP__ */
>  
> diff --git a/utests/utest_math_gen.py b/utests/utest_math_gen.py
> new file mode 100755
> index 0000000..7a4b678
> --- /dev/null
> +++ b/utests/utest_math_gen.py
> @@ -0,0 +1,531 @@
> +#!/usr/bin/python
> +from utest_generator import *
> +import os,sys
> +
> +#base_input_values = [80, -80, 3.14, -3.14, -0.5, 0.5, 1, -1, 0.0,6,-6,1500.24,-1500.24]
> +#extend_input_values = [FLT_MAX_POSI,FLT_MIN_NEGA,FLT_MIN_POSI,FLT_MAX_NEGA,80, -80, 3.14, -3.14, -0.5, 0.5, 1, -1, 0.0,6,-6,1500.24,-1500.24]
> +
> +#func:
> +#    gpufuncName 
> +#    cpuFuncName
> +#    fileName: 'builtin_'+name
> +#    inputtype: a 2-D list because there're more than one input data
> +#    outputtype: a list
> +#    values
> +#    ulp
> +
> +base_input_values = [ 0, 1, 3.14]
> +def main():
> +  ##### gentype acos(gentype)
> +  acos_input_values = base_input_values
> +  acos_input_type = ['float','float2','float4','float8','float16']
> +  acos_output_type = ['float','float2','float4','float8','float16']
> +  acosUtests = func('acos','acos',[acos_input_type],acos_output_type,[acos_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype acosh(gentype)
> +  acosh_input_values = base_input_values
> +  acosh_input_type = ['float','float2','float4','float8','float16']
> +  acosh_output_type = ['float','float2','float4','float8','float16']
> +  acoshUtests = func('acosh','acosh',[acosh_input_type],acosh_output_type,[acosh_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype acospi(gentype x)
> +  acospi_input_values = base_input_values
> +  acospi_input_type = ['float','float2','float4','float8','float16']
> +  acospi_output_type = ['float','float2','float4','float8','float16']
> +  acospi_cpu_func='''
> +static float acospi(float x){
> +  return acos(x)/M_PI;
> +} '''
> +  acospiUtests = func('acospi','acospi',[acospi_input_type],acospi_output_type,[acospi_input_values],'4 * FLT_ULP',acospi_cpu_func)
> +  
> +  ##### gentype asin(gentype)
> +  asin_input_values = base_input_values
> +  asin_input_type = ['float','float2','float4','float8','float16']
> +  asin_output_type = ['float','float2','float4','float8','float16']
> +  asinUtests = func('asin','asin',[asin_input_type],asin_output_type,[asin_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype asinh(gentype)
> +  asinh_input_values = base_input_values
> +  asinh_input_type = ['float','float2','float4','float8','float16']
> +  asinh_output_type = ['float','float2','float4','float8','float16']
> +  asinhUtests = func('asinh','asinh',[asinh_input_type],asinh_output_type,[asinh_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype asinpi(gentype x)
> +  asinpi_input_values = base_input_values
> +  asinpi_input_type = ['float','float2','float4','float8','float16']
> +  asinpi_output_type = ['float','float2','float4','float8','float16']
> +  asinpi_cpu_func='''
> +static float asinpi(float x){
> +  return asin(x)/M_PI;
> +} '''
> +  asinpiUtests = func('asinpi','asinpi',[asinpi_input_type],asinpi_output_type,[asinpi_input_values],'4 * FLT_ULP',asinpi_cpu_func)
> +  
> +  ##### gentype atan(gentype y_over_x)
> +  atan_input_values = base_input_values
> +  atan_input_type = ['float','float2','float4','float8','float16']
> +  atan_output_type = ['float','float2','float4','float8','float16']
> +  atanUtests = func('atan','atan',[atan_input_type],atan_output_type,[atan_input_values],'5 * FLT_ULP')
> +  
> +  ##### gentype atan2(gentype y, gentype x)
> +  atan2_base_values = base_input_values
> +  atan2_input_values1 = []
> +  atan2_input_values2 = []
> +  atan2_input_values1,atan2_input_values2=gene2ValuesLoop(atan2_input_values1,atan2_input_values2,atan2_base_values)
> +  atan2_input_type1 = ['float','float2','float4','float8','float16']
> +  atan2_input_type2 = ['float','float2','float4','float8','float16']
> +  atan2_output_type = ['float','float2','float4','float8','float16']
> +  atan2Utests = func('atan2','atan2',[atan2_input_type1,atan2_input_type2],atan2_output_type,[atan2_input_values1,atan2_input_values2],'6 * FLT_ULP')
> +  
> +  ##### gentype atanh(gentype)
> +  atanh_input_values = base_input_values
> +  atanh_input_type = ['float','float2','float4','float8','float16']
> +  atanh_output_type = ['float','float2','float4','float8','float16']
> +  atanhUtests = func('atanh','atanh',[atanh_input_type],atanh_output_type,[atanh_input_values],'5 * FLT_ULP')
> +  
> +  ##### gentype atanpi(gentype x)
> +  atanpi_input_values = base_input_values
> +  atanpi_input_type = ['float','float2','float4','float8','float16']
> +  atanpi_output_type = ['float','float2','float4','float8','float16']
> +  atanpi_cpu_func='''
> +static float atanpi(float x){
> +  return atan(x)/M_PI;
> +} '''
> +  atanpiUtests = func('atanpi','atanpi',[atanpi_input_type],atanpi_output_type,[atanpi_input_values],'4 * FLT_ULP',atanpi_cpu_func)
> +  
> +#  ##### gentype atan2pi(gentype y, gentype x)
> +#  atan2pi_base_values = base_input_values
> +#  atan2pi_input_values1 = []
> +#  atan2pi_input_values2 = []
> +#  atan2pi_input_values1,atan2pi_input_values2=gene2ValuesLoop(atan2pi_input_values1,atan2pi_input_values2,atan2pi_base_values)
> +#  atan2pi_input_type1 = ['float','float2','float4','float8','float16']
> +#  atan2pi_input_type2 = ['float','float2','float4','float8','float16']
> +#  atan2pi_output_type = ['float','float2','float4','float8','float16']
> +#  atan2pi_cpu_func='''
> +#static float atan2pi(float y, float x){
> +#  return atan2(y,x)/M_PI;
> +#} '''
> +#  atan2piUtests = func('atan2pi','atan2pi',[atan2pi_input_type1,atan2pi_input_type2],atan2pi_output_type,[atan2pi_input_values1,atan2pi_input_values2],'6 * FLT_ULP',atan2pi_cpu_func)
> +  
> +  ##### gentype cbrt(gentype)
> +  cbrt_input_values = base_input_values
> +  cbrt_input_type = ['float','float2','float4','float8','float16']
> +  cbrt_output_type = ['float','float2','float4','float8','float16']
> +  cbrtUtests = func('cbrt','cbrt',[cbrt_input_type],cbrt_output_type,[cbrt_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype ceil(gentype)
> +  ceil_input_values = base_input_values
> +  ceil_input_type = ['float','float2','float4','float8','float16']
> +  ceil_output_type = ['float','float2','float4','float8','float16']
> +  ceilUtests = func('ceil','ceil',[ceil_input_type],ceil_output_type,[ceil_input_values],'0 * FLT_ULP')
> +  
> +  ##### gentype copysign(gentype x, gentype y)
> +  copysign_base_values = base_input_values
> +  copysign_input_values1 = []
> +  copysign_input_values2 = []
> +  copysign_input_values1,copysign_input_values2=gene2ValuesLoop(copysign_input_values1,copysign_input_values2,copysign_base_values)
> +  copysign_input_type1 = ['float','float2','float4','float8','float16']
> +  copysign_input_type2 = ['float','float2','float4','float8','float16']
> +  copysign_output_type = ['float','float2','float4','float8','float16']
> +  copysignUtests = func('copysign','copysign',[copysign_input_type1,copysign_input_type2],copysign_output_type,[copysign_input_values1,copysign_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentype cos(gentype)
> +  cos_input_values = base_input_values
> +  cos_input_type = ['float','float2','float4','float8','float16']
> +  cos_output_type = ['float','float2','float4','float8','float16']
> +  cosUtests = func('cos','cos',[cos_input_type],cos_output_type,[cos_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype cosh(gentype)
> +  cosh_input_values = base_input_values
> +  cosh_input_type = ['float','float2','float4','float8','float16']
> +  cosh_output_type = ['float','float2','float4','float8','float16']
> +  coshUtests = func('cosh','cosh',[cosh_input_type],cosh_output_type,[cosh_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype cospi(gentype x)
> +  cospi_input_values = base_input_values
> +  cospi_input_type = ['float','float2','float4','float8','float16']
> +  cospi_output_type = ['float','float2','float4','float8','float16']
> +  cospi_cpu_func='''
> +static float cospi(float x){
> +  return cos(M_PI * x);
> +} '''
> +  cospiUtests = func('cospi','cospi',[cospi_input_type],cospi_output_type,[cospi_input_values],'2 * FLT_ULP',cospi_cpu_func)
> +  
> +  ##### gentype erf(gentype)
> +  erf_input_values = base_input_values
> +  erf_input_type = ['float','float2','float4','float8','float16']
> +  erf_output_type = ['float','float2','float4','float8','float16']
> +  erfUtests = func('erf','erf',[erf_input_type],erf_output_type,[erf_input_values],'16 * FLT_ULP')
> +  
> +  ##### gentype erfc(gentype)
> +  erfc_input_values = base_input_values
> +  erfc_input_type = ['float','float2','float4','float8','float16']
> +  erfc_output_type = ['float','float2','float4','float8','float16']
> +  erfcUtests = func('erfc','erfc',[erfc_input_type],erfc_output_type,[erfc_input_values],'16 * FLT_ULP')
> +  
> +  ##### gentype exp(gentype x)
> +  exp_input_values = base_input_values
> +  exp_input_type = ['float','float2','float4','float8','float16']
> +  exp_output_type = ['float','float2','float4','float8','float16']
> +  expUtests = func('exp','exp',[exp_input_type],exp_output_type,[exp_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype exp2(gentype)
> +  exp2_input_values = base_input_values
> +  exp2_input_type = ['float','float2','float4','float8','float16']
> +  exp2_output_type = ['float','float2','float4','float8','float16']
> +  exp2Utests = func('exp2','exp2',[exp2_input_type],exp2_output_type,[exp2_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype exp10(gentype)
> +  exp10_input_values = base_input_values
> +  exp10_input_type = ['float','float2','float4','float8','float16']
> +  exp10_output_type = ['float','float2','float4','float8','float16']
> +  exp10Utests = func('exp10','exp10',[exp10_input_type],exp10_output_type,[exp10_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype expm1(gentype x)
> +  expm1_input_values = base_input_values
> +  expm1_input_type = ['float','float2','float4','float8','float16']
> +  expm1_output_type = ['float','float2','float4','float8','float16']
> +  expm1Utests = func('expm1','expm1',[expm1_input_type],expm1_output_type,[expm1_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype fabs(gentype)
> +  fabs_input_values = base_input_values
> +  fabs_input_type = ['float','float2','float4','float8','float16']
> +  fabs_output_type = ['float','float2','float4','float8','float16']
> +  fabsUtests = func('fabs','fabs',[fabs_input_type],fabs_output_type,[fabs_input_values],'0 * FLT_ULP')
> +  
> +  ##### gentype fdim(gentype x, gentype y)
> +  fdim_base_values = base_input_values
> +  fdim_input_values1 = []
> +  fdim_input_values2 = []
> +  fdim_input_values1,fdim_input_values2=gene2ValuesLoop(fdim_input_values1,fdim_input_values2,fdim_base_values)
> +  fdim_input_type1 = ['float','float2','float4','float8','float16']
> +  fdim_input_type2 = ['float','float2','float4','float8','float16']
> +  fdim_output_type = ['float','float2','float4','float8','float16']
> +  fdimUtests = func('fdim','fdim',[fdim_input_type1,fdim_input_type2],fdim_output_type,[fdim_input_values1,fdim_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentype floor(gentype)
> +  floor_input_values = base_input_values
> +  floor_input_type = ['float','float2','float4','float8','float16']
> +  floor_output_type = ['float','float2','float4','float8','float16']
> +  floorUtests = func('floor','floor',[floor_input_type],floor_output_type,[floor_input_values],'0 * FLT_ULP')
> +  
> +  ##### gentype fma(gentype a, gentype b, gentype c)
> +  fma_base_values = base_input_values
> +  fma_input_values1 = []
> +  fma_input_values2 = []
> +  fma_input_values3 = []
> +  fma_input_values1,fma_input_values2,fma_input_values3=gene3ValuesLoop(fma_input_values1,fma_input_values2,fma_input_values3,fma_base_values)
> +  fma_input_type1 = ['float','float2','float4','float8','float16']
> +  fma_input_type2 = ['float','float2','float4','float8','float16']
> +  fma_input_type3 = ['float','float2','float4','float8','float16']
> +  fma_output_type = ['float','float2','float4','float8','float16']
> +  fmaUtests = func('fma','fma',[fma_input_type1,fma_input_type2,fma_input_type3],fma_output_type,[fma_input_values1,fma_input_values2,fma_input_values3],'0 * FLT_ULP')
> +  
> +  ##### gentype fmax(gentype x, gentype y)
> +  fmax_base_values = base_input_values
> +  fmax_input_values1 = []
> +  fmax_input_values2 = []
> +  fmax_input_values1,fmax_input_values2=gene2ValuesLoop(fmax_input_values1,fmax_input_values2,fmax_base_values)
> +  fmax_input_type1 = ['float','float2','float4','float8','float16']
> +  fmax_input_type2 = ['float','float2','float4','float8','float16']
> +  fmax_output_type = ['float','float2','float4','float8','float16']
> +  fmaxUtests = func('fmax','fmax',[fmax_input_type1,fmax_input_type2],fmax_output_type,[fmax_input_values1,fmax_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentypef fmax(gentypef x, float y)
> +#  fmax_gentypef_base_values = base_input_values
> +#  fmax_gentypef_input_values1 = []
> +#  fmax_gentypef_input_values2 = []
> +#  fmax_gentypef_input_values2,fmax_gentypef_input_values1=gene2ValuesLoop(fmax_gentypef_input_values1,fmax_gentypef_input_values2,fmax_gentypef_base_values)
> +#  fmax_gentypef_input_type1 = ['float','float2','float4','float8','float16']
> +#  fmax_gentypef_input_type2 = ['float','float','float','float','float']
> +#  fmax_gentypef_output_type = ['float','float2','float4','float8','float16']
> +#  ##### gentypef fmax(gentypef x, float y)
> +#  fmax_gentypefUtests = func('gentypef_fmax','gentypef_fmax',[fmax_gentypef_input_type1,fmax_gentypef_input_type2],fmax_gentypef_output_type,[fmax_gentypef_input_values1,fmax_gentypef_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentype fmin(gentype x, gentype y)
> +  fmin_base_values = base_input_values
> +  fmin_input_values1 = []
> +  fmin_input_values2 = []
> +  fmin_input_values1,fmin_input_values2=gene2ValuesLoop(fmin_input_values1,fmin_input_values2,fmin_base_values)
> +  fmin_input_type1 = ['float','float2','float4','float8','float16']
> +  fmin_input_type2 = ['float','float2','float4','float8','float16']
> +  fmin_output_type = ['float','float2','float4','float8','float16']
> +  fminUtests = func('fmin','fmin',[fmin_input_type1,fmin_input_type2],fmin_output_type,[fmin_input_values1,fmin_input_values2],'0 * FLT_ULP')
> +  
> +#  ##### gentypef fmin(gentypef x, float y)
> +#  fmin_gentypef_base_values = base_input_values
> +#  fmin_gentypef_input_values1 = []
> +#  fmin_gentypef_input_values2 = []
> +#  fmin_gentypef_input_values2,fmin_gentypef_input_values1=gene2ValuesLoop(fmin_gentypef_input_values1,fmin_gentypef_input_values2,fmin_gentypef_base_values)
> +#  fmin_gentypef_input_type1 = ['float','float2','float4','float8','float16']
> +#  fmin_gentypef_input_type2 = ['float','float','float','float','float']
> +#  fmin_gentypef_output_type = ['float','float2','float4','float8','float16']
> +#  ##### gentypef fmin(gentypef x, float y)
> +#  fmin_gentypefUtests = func('gentypef_fmin','gentypef_fmin',[fmin_gentypef_input_type1,fmin_gentypef_input_type2],fmin_gentypef_output_type,[fmin_gentypef_input_values1,fmin_gentypef_input_values2],'0 * FLT_ULP')
> +#  
> +  ##### gentype fmod(gentype x, gentype y)
> +  fmod_base_values = base_input_values
> +  fmod_input_values1 = []
> +  fmod_input_values2 = []
> +  fmod_input_values1,fmod_input_values2=gene2ValuesLoop(fmod_input_values1,fmod_input_values2,fmod_base_values)
> +  fmod_input_type1 = ['float','float2','float4','float8','float16']
> +  fmod_input_type2 = ['float','float2','float4','float8','float16']
> +  fmod_output_type = ['float','float2','float4','float8','float16']
> +  fmodUtests = func('fmod','fmod',[fmod_input_type1,fmod_input_type2],fmod_output_type,[fmod_input_values1,fmod_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentype hypot(gentype x, gentype y)
> +  hypot_base_values = base_input_values
> +  hypot_input_values1 = []
> +  hypot_input_values2 = []
> +  hypot_input_values1,hypot_input_values2=gene2ValuesLoop(hypot_input_values1,hypot_input_values2,hypot_base_values)
> +  hypot_input_type1 = ['float','float2','float4','float8','float16']
> +  hypot_input_type2 = ['float','float2','float4','float8','float16']
> +  hypot_output_type = ['float','float2','float4','float8','float16']
> +  hypotUtests = func('hypot','hypot',[hypot_input_type1,hypot_input_type2],hypot_output_type,[hypot_input_values1,hypot_input_values2],'4 * FLT_ULP')
> +  
> +  ##### intn ilogb(floartn x)
> +  ilogb_input_values = base_input_values
> +  ilogb_input_type = ['float','float2','float4','float8','float16']
> +  ilogb_output_type = ['int','int2','int4','int8','int16']
> +  ilogbUtests = func('ilogb','ilogb',[ilogb_input_type],ilogb_output_type,[ilogb_input_values],'0 * INT_ULP')
> +
> +  ##### gentype lgamma(gentype x)
> +  lgamma_input_values = base_input_values
> +  lgamma_input_type = ['float','float2','float4','float8','float16']
> +  lgamma_output_type = ['float','float2','float4','float8','float16']
> +  lgammaUtests = func('lgamma','lgamma',[lgamma_input_type],lgamma_output_type,[lgamma_input_values],'4 * FLT_ULP')
> +
> +  ##### gentype log(gentype)
> +  log_input_values = base_input_values
> +  log_input_type = ['float','float2','float4','float8','float16']
> +  log_output_type = ['float','float2','float4','float8','float16']
> +  logUtests = func('log','log',[log_input_type],log_output_type,[log_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype log2(gentype)
> +  log2_input_values = base_input_values
> +  log2_input_type = ['float','float2','float4','float8','float16']
> +  log2_output_type = ['float','float2','float4','float8','float16']
> +  log2Utests = func('log2','log2',[log2_input_type],log2_output_type,[log2_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype log10(gentype)
> +  log10_input_values = base_input_values
> +  log10_input_type = ['float','float2','float4','float8','float16']
> +  log10_output_type = ['float','float2','float4','float8','float16']
> +  log10Utests = func('log10','log10',[log10_input_type],log10_output_type,[log10_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype log1p(gentype x)
> +  log1p_input_values = base_input_values
> +  log1p_input_type = ['float','float2','float4','float8','float16']
> +  log1p_output_type = ['float','float2','float4','float8','float16']
> +  log1pUtests = func('log1p','log1p',[log1p_input_type],log1p_output_type,[log1p_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype logb(gentype x)
> +  logb_input_values = base_input_values
> +  logb_input_type = ['float','float2','float4','float8','float16']
> +  logb_output_type = ['float','float2','float4','float8','float16']
> +  logbUtests = func('logb','logb',[logb_input_type],logb_output_type,[logb_input_values],'0 * FLT_ULP')
> +  
> +  ##### gentype maxmag(gentype x, gentype y)
> +  maxmag_base_values = base_input_values
> +  maxmag_input_values1 = []
> +  maxmag_input_values2 = []
> +  maxmag_input_values1,maxmag_input_values2=gene2ValuesLoop(maxmag_input_values1,maxmag_input_values2,maxmag_base_values)
> +  maxmag_input_type1 = ['float','float2','float4','float8','float16']
> +  maxmag_input_type2 = ['float','float2','float4','float8','float16']
> +  maxmag_output_type = ['float','float2','float4','float8','float16']
> +  maxmag_cpu_func='''
> +static float maxmag(float x, float y){
> +  if(fabs(x) > fabs(y))
> +    return x;
> +  else if (fabs(x) < fabs(y))
> +    return y;
> +  else
> +    return fmax(x,y);
> +} '''
> +  maxmagUtests = func('maxmag','maxmag',[maxmag_input_type1,maxmag_input_type2],maxmag_output_type,[maxmag_input_values1,maxmag_input_values2],'0 * FLT_ULP',maxmag_cpu_func)
> +  
> +  ##### gentype minmag(gentype x, gentype y)
> +  minmag_base_values = base_input_values
> +  minmag_input_values1 = []
> +  minmag_input_values2 = []
> +  minmag_input_values1,minmag_input_values2=gene2ValuesLoop(minmag_input_values1,minmag_input_values2,minmag_base_values)
> +  minmag_input_type1 = ['float','float2','float4','float8','float16']
> +  minmag_input_type2 = ['float','float2','float4','float8','float16']
> +  minmag_output_type = ['float','float2','float4','float8','float16']
> +  minmag_cpu_func='''
> +static float minmag(float x, float y){
> +  if(fabs(x) < fabs(y))
> +    return x;
> +  else if (fabs(x) > fabs(y))
> +    return y;
> +  else
> +    return fmin(x,y);
> +} '''
> +  minmagUtests = func('minmag','minmag',[minmag_input_type1,minmag_input_type2],minmag_output_type,[minmag_input_values1,minmag_input_values2],'0 * FLT_ULP',minmag_cpu_func)
> +  
> +#  ##### floatn nan(uintn nancode)
> +#  nan_input_values = base_input_values
> +#  nan_input_type = ['uint','uint2','uint4','uint8','uint16']
> +#  nan_output_type = ['float','float2','float4','float8','float16']
> +#  nanUtests = func('nan','nan',[nan_input_type],nan_output_type,[nan_input_values],'0 * FLT_ULP')
> +  
> +  ##### gentype nextafter(gentype x, gentype y)
> +  nextafter_base_values = base_input_values
> +  nextafter_input_values1 = []
> +  nextafter_input_values2 = []
> +  nextafter_input_values1,nextafter_input_values2=gene2ValuesLoop(nextafter_input_values1,nextafter_input_values2,nextafter_base_values)
> +  nextafter_input_type1 = ['float','float2','float4','float8','float16']
> +  nextafter_input_type2 = ['float','float2','float4','float8','float16']
> +  nextafter_output_type = ['float','float2','float4','float8','float16']
> +  nextafterUtests = func('nextafter','nextafter',[nextafter_input_type1,nextafter_input_type2],nextafter_output_type,[nextafter_input_values1,nextafter_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentype pow(gentype x, gentype y)
> +  pow_base_values = base_input_values
> +  pow_input_values1 = []
> +  pow_input_values2 = []
> +  pow_input_values1,pow_input_values2=gene2ValuesLoop(pow_input_values1,pow_input_values2,pow_base_values)
> +  pow_input_type1 = ['float','float2','float4','float8','float16']
> +  pow_input_type2 = ['float','float2','float4','float8','float16']
> +  pow_output_type = ['float','float2','float4','float8','float16']
> +  powUtests = func('pow','pow',[pow_input_type1,pow_input_type2],pow_output_type,[pow_input_values1,pow_input_values2],'16 * FLT_ULP')
> +  
> +  ##### floatn pown(floatn x, intn y)
> +  pown_input_values1 = [FLT_MAX_POSI,FLT_MIN_NEGA,FLT_MIN_POSI,FLT_MAX_NEGA,80, -80, 3.14, -3.14, -0.5, 0.5, 1, -1, 0.0,6,-6,1500.24,-1500.24]
> +  pown_input_values2 = [-1,-2,-3,4,5,6,7,8,9,10,11,12,13,14,15,16,12]
> +  pown_input_type1 = ['float','float2','float4','float8','float16']
> +  pown_input_type2 = ['int','int2','int4','int8','int16']
> +  pown_output_type = ['float','float2','float4','float8','float16']
> +  pown_cpu_func='''
> +static float pown(float x, int y){
> +    return pow(x,y);
> +} '''
> +  pownUtests = func('pown','pown',[pown_input_type1,pown_input_type2],pown_output_type,[pown_input_values1,pown_input_values2],'16 * FLT_ULP', pown_cpu_func)
> +  
> +  ##### gentype powr(gentype x, gentype y)
> +  powr_input_values1 = [FLT_MAX_POSI,FLT_MIN_NEGA,FLT_MIN_POSI,FLT_MAX_NEGA,80, -80, 3.14, -3.14, -0.5, 0.5, 1, -1, 0.0,6,-6,1500.24,-1500.24]
> +  powr_input_values2 = [1,2,3.14,4,5,6,7,8,9.889,10,11,12,13,14.33,15,0,12]
> +  powr_input_type1 = ['float','float2','float4','float8','float16']
> +  powr_input_type2 = ['float','float2','float4','float8','float16']
> +  powr_output_type = ['float','float2','float4','float8','float16']
> +  powr_cpu_func='''
> +static float powr(float x, int y){
> +    return pow(x,y);
> +} '''
> +  powrUtests = func('powr','powr',[powr_input_type1,powr_input_type2],powr_output_type,[powr_input_values1,powr_input_values2],'16 * FLT_ULP', powr_cpu_func)
> +  
> +  ##### gentype remainder(gentype x, gentype y)
> +  remainder_base_values = base_input_values
> +  remainder_input_values1 = []
> +  remainder_input_values2 = []
> +  remainder_input_values1,remainder_input_values2=gene2ValuesLoop(remainder_input_values1,remainder_input_values2,remainder_base_values)
> +  remainder_input_type1 = ['float','float2','float4','float8','float16']
> +  remainder_input_type2 = ['float','float2','float4','float8','float16']
> +  remainder_output_type = ['float','float2','float4','float8','float16']
> +  remainderUtests = func('remainder','remainder',[remainder_input_type1,remainder_input_type2],remainder_output_type,[remainder_input_values1,remainder_input_values2],'0 * FLT_ULP')
> +  
> +  ##### gentype rint(gentype x)
> +  rint_input_values = base_input_values
> +  rint_input_type = ['float','float2','float4','float8','float16']
> +  rint_output_type = ['float','float2','float4','float8','float16']
> +  rintUtests = func('rint','rint',[rint_input_type],rint_output_type,[rint_input_values],'0 * FLT_ULP')
> +  
> +  ##### floatn rootn(floatn x, intn y)
> +  rootn_input_values1 = [FLT_MAX_POSI,FLT_MIN_NEGA,FLT_MIN_POSI,FLT_MAX_NEGA,80, -80, 3.14, -3.14, -0.5, 0.5, 1, -1, 0.0,6,-6,1500.24,-1500.24,2,3,4]
> +  rootn_input_values2 = [-1,-2,-3,2,3,6,7,8,9,2,11,12,13,14,15,16,2,2,2,2]
> +  rootn_input_type1 = ['float','float2','float4','float8','float16']
> +  rootn_input_type2 = ['int','int2','int4','int8','int16']
> +  rootn_output_type = ['float','float2','float4','float8','float16']
> +  rootn_cpu_func='''
> +static float rootn(float x, int y){
> +    return pow(x,1.0/y);
> +} '''
> +  rootnUtests = func('rootn','rootn',[rootn_input_type1,rootn_input_type2],rootn_output_type,[rootn_input_values1,rootn_input_values2],'4 * FLT_ULP',rootn_cpu_func)
> +  
> +  ##### gentype round(gentype x)
> +  round_input_values = base_input_values
> +  round_input_type = ['float','float2','float4','float8','float16']
> +  round_output_type = ['float','float2','float4','float8','float16']
> +  roundUtests = func('round','round',[round_input_type],round_output_type,[round_input_values],'0 * FLT_ULP')
> +  
> +  ##### gentype rsqrt(gentype)
> +  rsqrt_input_values = base_input_values
> +  rsqrt_input_type = ['float','float2','float4','float8','float16']
> +  rsqrt_output_type = ['float','float2','float4','float8','float16']
> +  rsqrt_cpu_func='''
> +static float rsqrt(float x)
> +{ return 1/sqrt(x);} '''
> +  rsqrtUtests = func('rsqrt','rsqrt',[rsqrt_input_type],rsqrt_output_type,[rsqrt_input_values],'4 * FLT_ULP', rsqrt_cpu_func)
> +
> + 
> +  ##### gentype sin(gentype)
> +  sin_input_values = base_input_values
> +  sin_input_type = ['float','float2','float4','float8','float16']
> +  sin_output_type = ['float','float2','float4','float8','float16']
> +  sinUtests = func('sin','sin',[sin_input_type],sin_output_type,[sin_input_values],'4 * FLT_ULP')
> +  
> +#  ##### gentype sincos(gentype)
> +#  sincos_input_values1 = [FLT_MAX_POSI,FLT_MIN_NEGA,FLT_MIN_POSI,FLT_MAX_NEGA,80, -80, 3.14, -3.14, -0.5, 0.5, 1, -1, 0.0,6,-6,1500.24,-1500.24]
> +#  sincos_input_values2 = []
> +#  sincos_input_type1 = ['float','float2','float4','float8','float16']
> +#  sincos_input_type2 = ['float','float2','float4','float8','float16']
> +#  sincos_output_type = ['float','float2','float4','float8','float16']
> +#  ###### gentype sincos(gentype)
> +#  #  sincosUtests = func('sincos','sincos',[sincos_input_type1,sincos_input_type2],sincos_output_type,[sincos_input_values1,sincos_input_values2],'4 * FLT_ULP')
> +  
> +  ##### gentype sinh(gentype)
> +  sinh_input_values = base_input_values
> +  sinh_input_type = ['float','float2','float4','float8','float16']
> +  sinh_output_type = ['float','float2','float4','float8','float16']
> +  sinhUtests = func('sinh','sinh',[sinh_input_type],sinh_output_type,[sinh_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype sinpi(gentype x)
> +  sinpi_input_values = base_input_values
> +  sinpi_input_type = ['float','float2','float4','float8','float16']
> +  sinpi_output_type = ['float','float2','float4','float8','float16']
> +  sinpi_cpu_func='''
> +static float sinpi(float x){
> +  return sin(M_PI*x);
> +} '''
> +  sinpiUtests = func('sinpi','sinpi',[sinpi_input_type],sinpi_output_type,[sinpi_input_values],'4 * FLT_ULP',sinpi_cpu_func)
> +  
> +  ##### gentype sqrt(gentype)
> +  sqrt_input_values = base_input_values
> +  sqrt_input_type = ['float','float2','float4','float8','float16']
> +  sqrt_output_type = ['float','float2','float4','float8','float16']
> +  sqrtUtests = func('sqrt','sqrt',[sqrt_input_type],sqrt_output_type,[sqrt_input_values],'4 * FLT_ULP')
> +  
> +  ##### gentype tan(gentype)
> +  tan_input_values = base_input_values
> +  tan_input_type = ['float','float2','float4','float8','float16']
> +  tan_output_type = ['float','float2','float4','float8','float16']
> +  tanUtests = func('tan','tan',[tan_input_type],tan_output_type,[tan_input_values],'5 * FLT_ULP')
> +  
> +  ##### gentype tanh(gentype)
> +  tanh_input_values = base_input_values
> +  tanh_input_type = ['float','float2','float4','float8','float16']
> +  tanh_output_type = ['float','float2','float4','float8','float16']
> +  tanhUtests = func('tanh','tanh',[tanh_input_type],tanh_output_type,[tanh_input_values],'5 * FLT_ULP')
> +  
> +  ##### gentype tanpi(gentype x)
> +  tanpi_input_values = base_input_values
> +  tanpi_input_type = ['float','float2','float4','float8','float16']
> +  tanpi_output_type = ['float','float2','float4','float8','float16']
> +  tanpi_cpu_func='''
> +static float tanpi(float x){
> +  return tan(M_PI*x);
> +} '''
> +  tanpiUtests = func('tanpi','tanpi',[tanpi_input_type],tanpi_output_type,[tanpi_input_values],'4 * FLT_ULP',tanpi_cpu_func)
> +  
> +  ##### gentype tgamma(gentype)
> +  tgamma_input_values = base_input_values
> +  tgamma_input_type = ['float','float2','float4','float8','float16']
> +  tgamma_output_type = ['float','float2','float4','float8','float16']
> +  tgammaUtests = func('tgamma','tgamma',[tgamma_input_type],tgamma_output_type,[tgamma_input_values],'16 * FLT_ULP')
> +  
> +  ##### gentype trunc(gentype)
> +  trunc_input_values = base_input_values
> +  trunc_input_type = ['float','float2','float4','float8','float16']
> +  trunc_output_type = ['float','float2','float4','float8','float16']
> +  truncUtests = func('trunc','trunc',[trunc_input_type],trunc_output_type,[trunc_input_values],'0 * FLT_ULP')
> +
> +if __name__ == "__main__":
> +  main()
> -- 
> 1.7.6.4
> 
> _______________________________________________
> Beignet mailing list
> Beignet at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/beignet


More information about the Beignet mailing list