vout1d.br

用于GPU通用计算的编程语言BrookGPU 0.4

   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else {
      output=input2[newindex];
   }
}

kernel void BRT_TYPE1dstreamCombine3(BRT_TYPE input0[],
                           BRT_TYPE input1[],
                           BRT_TYPE input2[],
                           float modulus,
                           float offset,
                           BRT_TYPE oldoutput<>,
                           out BRT_TYPE output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void BRT_TYPE1dstreamCombine4f(BRT_TYPE input0[],
                            BRT_TYPE input1[],
                            BRT_TYPE input2[],
                            BRT_TYPE input3[],
                            float modulus,
                            out BRT_TYPE output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else {
      output=input3[newindex];
   }
}

kernel void BRT_TYPE1dstreamCombine4(BRT_TYPE input0[],
                           BRT_TYPE input1[],
                           BRT_TYPE input2[],
                           BRT_TYPE input3[],
                           float modulus,
                           float offset,
                           BRT_TYPE oldoutput<>,
                           out BRT_TYPE output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus,  newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void BRT_TYPE1dstreamCombine5f(BRT_TYPE input0[],
                            BRT_TYPE input1[],
                            BRT_TYPE input2[],
                            BRT_TYPE input3[],
                            BRT_TYPE input4[],
                            float modulus,
                            out BRT_TYPE output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else {
      output=input4[newindex];
   }
}
/*
kernel void BRT_TYPEstreamCombine5(BRT_TYPE input0[],
                           BRT_TYPE input1[],
                           BRT_TYPE input2[],
                           BRT_TYPE input3[],
                           BRT_TYPE input4[],
                           float modulus,
                           float offset,
                           BRT_TYPE oldoutput<>,
                           out BRT_TYPE output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else {
      output=oldoutput;
   }
}


kernel void BRT_TYPEstreamCombine6f(BRT_TYPE input0[],
                            BRT_TYPE input1[],
                            BRT_TYPE input2[],
                            BRT_TYPE input3[],
                            BRT_TYPE input4[],
                            BRT_TYPE input5[],
                            float modulus,
                            out BRT_TYPE output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus,  newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else {
      output=input5[newindex];
   }
}

kernel void BRT_TYPEstreamCombine6(BRT_TYPE input0[],
                           BRT_TYPE input1[],
                           BRT_TYPE input2[],
                           BRT_TYPE input3[],
                           BRT_TYPE input4[],
                           BRT_TYPE input5[],
                           float modulus,
                           float offset,
                           BRT_TYPE oldoutput<>,
                           out BRT_TYPE output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void BRT_TYPEstreamCombine7f(BRT_TYPE input0[],
                            BRT_TYPE input1[],
                            BRT_TYPE input2[],
                            BRT_TYPE input3[],
                            BRT_TYPE input4[],
                            BRT_TYPE input5[],
                            BRT_TYPE input6[],
                            float modulus,
                            out BRT_TYPE output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else {
      output=input6[newindex];
   }
}

kernel void BRT_TYPEstreamCombine7(BRT_TYPE input0[],
                           BRT_TYPE input1[],
                           BRT_TYPE input2[],
                           BRT_TYPE input3[],
                           BRT_TYPE input4[],
                           BRT_TYPE input5[],
                           BRT_TYPE input6[],
                           float modulus,
                           float offset,
                           BRT_TYPE oldoutput<>,
                           out BRT_TYPE output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else if (whichmod==6) {
      output=input6[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void BRT_TYPEstreamCombine8f(BRT_TYPE input0[],
                            BRT_TYPE input1[],
                            BRT_TYPE input2[],
                            BRT_TYPE input3[],
                            BRT_TYPE input4[],
                            BRT_TYPE input5[],
                            BRT_TYPE input6[],
                            BRT_TYPE input7[],
                            float modulus,
                            out BRT_TYPE output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];