示例#1
0
double F10::compute(double*x){
  int i;
  double result=0.0;

  if(Ovector==NULL)
    {
      Ovector = readOvector();
      Pvector = readPermVector();
      r25 = readR(25);
      r50 = readR(50);
      r100 = readR(100);
      s = readS(s_size);
      w = readW(s_size);
    }
  for(i=0;i<dimension;i++)
    {
      anotherz[i]=x[i]-Ovector[i];
    }
  
  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVector(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * ackley(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }

  update(result);
  return(result);
}
示例#2
0
double F4::compute(double*x){
  int    i;
  double result = 0.0;

  if(Ovector == NULL) {
    Ovector = readOvector();
    Pvector = readPermVector();
    r25 = readR(25);
    r50 = readR(50);
    r100 = readR(100);
    s = readS(s_size);
    w = readW(s_size);
  }
  
  for(i = 0; i < dimension; i++) {
    anotherz[i] = x[i] - Ovector[i];
  }

  // for (int i = 0; i < dimension; ++i)
  //   {
  //     cout<<anotherz[i]<<endl;
  //   }
  // cout<<endl;

  // // T_{osz}
  // transform_osz(anotherz);
  
  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVector(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * elliptic(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }
  
  // one separable part without rotation
  double* z = new double[dimension-c];
  for (i = c; i < dimension; i++)
    {
      // cout<<i-c<<" "<<Pvector[i]<<" "<<anotherz[Pvector[i]]<<endl;
      z[i-c] = anotherz[Pvector[i]];
    }
  
  // cout<<"sep\n"<<elliptic(z, dimension-c)<<endl;
  
  result += elliptic(z, dimension-c);
  delete[] z;

//  printf("Rotated Part = %1.16E\n", rot_elliptic(anotherz1,nonSeparableGroupSize) * 1e6);
//  printf("Separable Part = %1.16E\n", elliptic(anotherz2,dimension - nonSeparableGroupSize));

  return(result);
}
示例#3
0
double F7::compute(double*x){
  int    i;
  double result = 0.0;

  if(Ovector == NULL) {
    Ovector = readOvector();
    Pvector = readPermVector();
    r25 = readR(25);
    r50 = readR(50);
    r100 = readR(100);
    s = readS(s_size);
    w = readW(s_size);
  }

  for(i = 0; i < dimension; i++) {
    anotherz[i] = x[i] - Ovector[i];
  }

  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVector(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * schwefel(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }
  
  // one separable part without rotation
  double* z = new double[dimension-c];
  for (i = c; i < dimension; i++)
    {
      // cout<<i-c<<" "<<Pvector[i]<<" "<<anotherz[Pvector[i]]<<endl;
      z[i-c] = anotherz[Pvector[i]];
    }
  
  result += sphere(z, dimension-c);
  delete []z;

  return(result);
}
示例#4
0
double F14::compute(double*x){
  int i;
  double result=0.0;
  
  if(OvectorVec == NULL)
    {
      s = readS(s_size);
      OvectorVec = readOvectorVec();
      // // inspect OvectorVec
      // for (int i = 0; i < s_size; ++i)
      //   {
      //     for (int j=0; j< s[i]; j++)
      //       {
      //         printf("%.1f\t",OvectorVec[i][j]);
      //       }
      //     printf("\n");
      //   }
      Pvector = readPermVector();
      r25 = readR(25);
      r50 = readR(50);
      r100 = readR(100);
      w = readW(s_size);
    }

  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVectorConflict(i, c, x);
      // cout<<"done rot"<<endl;
      result += w[i] * schwefel(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }

  update(result);
  return(result);
}
/*
 * Parameters:
 * pRegister::int the block in the file where the string will be write
 * Returns:
 * The read of the position in string
 * 
 * Reads a string from the file 
 */
void* Disk_File::readO(int pOffset) {
    //    string result="";
    //    switch(pID){
    //        case caseCharArray:
    //        {
    //            
    //            char Read[pSize];
    //            fstream fs(_Path,  ios::in | ios::out |ios::binary);
    //            move(pRegister, pDisp+ _registerHeaderSize, &fs);
    //            fs.read((char*)&Read, pSize);
    //            fs.close();
    //            result = Read;
    //            break;
    //        }
    //        case caseInteger:
    //        {
    //            int iRead= 0;
    //            fstream fs(_Path,  ios::in | ios::out |ios::binary);
    //            move(pRegister, pDisp+ _registerHeaderSize, &fs);
    //            fs.read((char*)&iRead, pSize);
    //            fs.close();
    //            result = to_string(iRead);
    //            break;
    //        }
    //        case caseFloat:
    //        {
    //            float fRead= 0;
    //            fstream fs(_Path,  ios::in | ios::out |ios::binary);
    //            move(pRegister, pDisp+ _registerHeaderSize, &fs);
    //            fs.read((char*)&fRead, sizeof(fRead));
    //            fs.close();
    //            result = to_string(fRead);
    //            break;
    //        }
    //        case caseByte:
    //        {
    //            if(pSize==1){
    //                char bRead;
    //                fstream fs(_Path,  ios::in | ios::out |ios::binary);
    //                move(pRegister, pDisp+ _registerHeaderSize, &fs);
    //                fs.read((char*)&bRead, pSize);
    //                fs.close();
    //                result = bRead;
    //            }else{
    //                throw -1;// Poner el codigo de error
    //            }
    //            break;
    //        }
    //        case caseShort:
    //        {
    //            short iRead= 0;
    //            fstream fs(_Path,  ios::in | ios::out |ios::binary);
    //            move(pRegister, pDisp+ _registerHeaderSize, &fs);
    //            fs.read((char*)&iRead, pSize);
    //            fs.close();
    //            result = to_string(iRead);
    //            break;
    //        }
    //        case caseBigInt:
    //        {
    //            if(pSize%4==0){
    //                int cycle=pSize/sizeof(int);
    //                for(int i=0; i<cycle; i++){
    //                    int iRead= 0;
    //                    fstream fs(_Path,  ios::in | ios::out |ios::binary);
    //                    move(pRegister, pDisp+(i*4)+_registerHeaderSize, &fs);
    //                    fs.read((char*)&iRead, pSize);
    //                    fs.close();
    //                    result.append(to_string(iRead).c_str());
    //                }
    //            }
    //            else{
    //                throw -1; //Falta poDisk_File.cpp:415:10: error: invalid use of incomplete type ‘std::fstream {aka class std::basic_fstream<char>}’nerle el verdadero error
    //            }
    //            break;
    //        }
    //        default:
    //        {
    //            throw -1;// poner error para cuando el id no es correcto
    //        }
    //    }
    //        
    //    return result;
    readR(this->getRegisterNumberOffset(pOffset));
}
示例#6
0
/*********************************************************************************************************
** Function name:           readR
** Descriptions:            calculate gas concentration of each channel from slave MCU
** Parameters:
                            gas - gas type
** Returns:
                            float value - concentration of the gas
*********************************************************************************************************/
float MutichannelGasSensor::calcGas(int gas)
{
    if(!is_connected)
    {
        if(readR0() >= 0) is_connected = 1;
        else return -1.0f;
    }

    if(readR() < 0)
        return -2.0f;

    float ratio0 = (float)res[0] / res0[0];
    float ratio1 = (float)res[1] / res0[1];
    float ratio2 = (float)res[2] / res0[2];

    float c = 0;

    switch(gas)
    {
        case CO:
        {
            if(ratio1 < 0.01) ratio1 = 0.01;
            if(ratio1 > 3) ratio1 = 3;
            //c = pow(10, 0.6) / pow(ratio1, 1.2);
            c = pow(ratio1, -1.179)*4.385;  //mod by jack
            break;
        }
        case NO2:
        {
            if(ratio2 < 0.07) ratio2 = 0.07;
            if(ratio2 > 40) ratio2 = 40;
            //c = ratio2 / pow(10, 0.8);
            c = pow(ratio2, 1.007)/6.855;  //mod by jack
            break;
        }
        case NH3:
        {
            if(ratio0 < 0.04) ratio0 = 0.04;
            if(ratio0 > 0.8) ratio0 = 0.8;
            //c = 1 / (ratio0 * ratio0 * pow(10, 0.4));
            c = pow(ratio0, -1.67)/1.47;  //modi by jack
            break;
        }
        case C3H8:  //add by jack
        {
            if(ratio0 < 0.23) ratio0 = 0.23;
            if(ratio0 > 0.8) ratio0 = 0.8;
            c = pow(ratio0, -2.518)*570.164;
            break;
        }
        case C4H10:  //add by jack
        {
            if(ratio0 < 0.15) ratio0 = 0.15;
            if(ratio0 > 0.65) ratio0 = 0.65;
            c = pow(ratio0, -2.138)*398.107;
            break;
        }
        case CH4:  //add by jack
        {
            if(ratio1 < 0.5) ratio1 = 0.5;
            if(ratio1 > 0.7) ratio1 = 0.7;
            c = pow(ratio1, -4.363)*630.957;
            break;
        }
        case H2:  //add by jack
        {
            if(ratio1 < 0.04) ratio1 = 0.04;
            if(ratio1 > 0.8) ratio1 = 0.8;
            c = pow(ratio1, -1.8)*0.73;
            break;
        }
        case C2H5OH:  //add by jack
        {
            if(ratio1 < 0.04) ratio1 = 0.04;
            if(ratio1 > 1.1) ratio1 = 1.1;
            c = pow(ratio1, -1.552)*1.622;
            break;
        }
        default:
            break;
    }

    return isnan(c)?-3:c;
}