TwoDoubles f10(double* x) {
/* ellipsoid with monotone transformation, condition 1e6*/
int i, j, rseed; /*Loop over dim*/
static unsigned int funcId = 10;
static double condition = 1e6;
double Fadd, Fval, Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++)
{
tmx[i] = 0.;
for (j = 0; j < DIM; j++) {
tmx[i] += rotation[i][j] * (x[j] - Xopt[j]);
}
}
monotoneTFosc(tmx);
/* COMPUTATION core*/
for (i = 0; i < DIM; i++)
{
Ftrue += pow(condition, ((double)i)/((double)(DIM-1))) * tmx[i] * tmx[i];
}
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
void CovarianceVisual::setMessage(const geometry_msgs::PoseWithCovariance& msg)
{
// Construct pose position and orientation.
const geometry_msgs::Point& p = msg.pose.position;
const geometry_msgs::Quaternion& q = msg.pose.orientation;
Ogre::Vector3 position(p.x, p.y, p.z);
Ogre::Quaternion orientation(q.w, q.x, q.y, q.z);
// Set position and orientation for axes scene node.
if(!position.isNaN())
axes_->setPosition(position);
else
ROS_WARN_STREAM_THROTTLE(1, "position contains NaN: " << position);
if(!orientation.isNaN())
axes_->setOrientation (orientation);
else
ROS_WARN_STREAM_THROTTLE(1, "orientation contains NaN: " << orientation);
// check for NaN in covariance
for (unsigned i = 0; i < 3; ++i)
{
if(isnan(msg.covariance[i]))
{
ROS_WARN_THROTTLE(1, "covariance contains NaN");
return;
}
}
// Compute eigen values and vectors for both shapes.
std::pair<Eigen::Matrix3d, Eigen::Vector3d> positionEigenVectorsAndValues(computeEigenValuesAndVectors(msg, 0));
std::pair<Eigen::Matrix3d, Eigen::Vector3d> orientationEigenVectorsAndValues(computeEigenValuesAndVectors(msg, 3));
Ogre::Quaternion positionQuaternion(computeRotation(msg, positionEigenVectorsAndValues));
Ogre::Quaternion orientationQuaternion(computeRotation(msg, orientationEigenVectorsAndValues));
positionNode_->setOrientation(positionQuaternion);
orientationNode_->setOrientation(orientationQuaternion);
// Compute scaling.
//Ogre::Vector3 axesScaling(1, 1, 1);
//axesScaling *= scaleFactor_;
Ogre::Vector3 positionScaling
(std::sqrt (positionEigenVectorsAndValues.second[0]),
std::sqrt (positionEigenVectorsAndValues.second[1]),
std::sqrt (positionEigenVectorsAndValues.second[2]));
positionScaling *= scaleFactor_;
Ogre::Vector3 orientationScaling
(std::sqrt (orientationEigenVectorsAndValues.second[0]),
std::sqrt (orientationEigenVectorsAndValues.second[1]),
std::sqrt (orientationEigenVectorsAndValues.second[2]));
orientationScaling *= scaleFactor_;
// Set the scaling.
/*if(!axesScaling.isNaN())
axes_->setScale(axesScaling);
else
ROS_WARN_STREAM("axesScaling contains NaN: " << axesScaling);*/
if(!positionScaling.isNaN())
positionNode_->setScale(positionScaling);
else
ROS_WARN_STREAM("positionScaling contains NaN: " << positionScaling);
if(!orientationScaling.isNaN())
orientationNode_->setScale(orientationScaling);
else
ROS_WARN_STREAM("orientationScaling contains NaN: " << orientationScaling);
// Debugging.
ROS_INFO_STREAM_THROTTLE
(1.,
"Position:\n"
<< position << "\n"
<< "Positional part 3x3 eigen values:\n"
<< positionEigenVectorsAndValues.second << "\n"
<< "Positional part 3x3 eigen vectors:\n"
<< positionEigenVectorsAndValues.first << "\n"
<< "Sphere orientation:\n"
<< positionQuaternion << "\n"
<< positionQuaternion.getRoll () << " "
<< positionQuaternion.getPitch () << " "
<< positionQuaternion.getYaw () << "\n"
<< "Sphere scaling:\n"
<< positionScaling << "\n"
<< "Rotational part 3x3 eigen values:\n"
<< orientationEigenVectorsAndValues.second << "\n"
<< "Rotational part 3x3 eigen vectors:\n"
<< orientationEigenVectorsAndValues.first << "\n"
<< "Cone orientation:\n"
<< orientationQuaternion << "\n"
<< orientationQuaternion.getRoll () << " "
<< orientationQuaternion.getPitch () << " "
<< orientationQuaternion.getYaw () << "\n"
<< "Cone scaling:\n"
<< orientationScaling
);
}
void TumblerWindow::keyPressEvent ( QKeyEvent * event)
{
TumblerStruct *xtum = mTum;
float tstep = xtum->tstep;
int key = event->key();
int shift = event->modifiers() & Qt::ShiftModifier;
int ctrl = event->modifiers() & Qt::ControlModifier;
int keypad = event->modifiers() & Qt::KeypadModifier;
int dodraw = 1;
int handled = 1;
int newdata = 1;
float xrot, yrot, zrot;
if (inputTestMetaKey(event))
return;
if (utilCloseKey(event)) {
close();
return;
}
inputConvertNumLock(key, keypad);
if (key == hotSliderKey()) {
mCtrlPressed = true;
grabKeyboard();
return;
}
switch(key){
case Qt::Key_B:
xtum->bbox = 1 - xtum->bbox;
newdata = 0;
break;
case Qt::Key_S:
if (shift || ctrl){
// Snapshots
draw(xtum);
b3dKeySnapshot("tumbler", shift, ctrl, NULL);
dodraw = 0;
} else {
// Toggle stereo
xtum->stereo = 1 - xtum->stereo;
setSlice(xtum);
newdata = 0;
}
break;
case Qt::Key_Comma:
xtum->tstep /= sqrt(2.);
if (xtum->tstep < 1.)
xtum->tstep = 1.;
break;
case Qt::Key_Period:
xtum->tstep *= sqrt(2.);
if (xtum->tstep > 16.)
xtum->tstep = 16.;
break;
case Qt::Key_Plus:
case Qt::Key_Equal:
if (xtum->zoom < XTUM_MAX_ZOOM) {
xtum->zoom++;
diaSetSpinBox(mZoomBox, xtum->zoom);
setSlice(xtum);
newdata = 0;
} else
dodraw = 0;
break;
case Qt::Key_Minus:
if (xtum->zoom > 1) {
xtum->zoom--;
diaSetSpinBox(mZoomBox, xtum->zoom);
setSlice(xtum);
newdata = 0;
} else
dodraw = 0;
break;
case Qt::Key_PageDown:
case Qt::Key_PageUp:
case Qt::Key_Up:
case Qt::Key_Down:
case Qt::Key_Right:
case Qt::Key_Left:
if (keypad) {
// Someone with a better eye than mine may see that the directions
// of X and Y need to be reversed
xrot = (key == Qt::Key_Up ? tstep : 0.) -
(key == Qt::Key_Down ? tstep : 0.);
yrot = (key == Qt::Key_Right ? tstep : 0.) -
(key == Qt::Key_Left ? tstep : 0.);
zrot = (key == Qt::Key_PageUp ? tstep : 0.) -
(key == Qt::Key_PageDown ? tstep : 0.);
computeRotation(xrot, yrot, zrot);
} else
handled = 0;
break;
case Qt::Key_F5:
if (xtum->minval >= 3) {
xtum->minval -= 3;
mSliders->setValue(0, xtum->minval);
} else
dodraw = 0;
break;
case Qt::Key_F6:
if (xtum->minval < xtum->maxval - 3) {
xtum->minval += 3;
mSliders->setValue(0, xtum->minval);
} else
dodraw = 0;
break;
case Qt::Key_F7:
if (xtum->maxval > xtum->minval + 3) {
xtum->maxval -= 3;
mSliders->setValue(1, xtum->maxval);
} else
dodraw = 0;
break;
case Qt::Key_F8:
if (xtum->maxval <= 255 - 3) {
xtum->maxval += 3;
mSliders->setValue(1, xtum->maxval);
} else
dodraw = 0;
break;
default:
handled = 0;
break;
}
// If key not handled, call the default processor
if (!handled) {
inputQDefaultKeys(event, xtum->vi);
return;
}
// Do the draws as needed
if (dodraw && newdata)
newData(xtum);
if (dodraw)
draw(xtum);
}
TwoDoubles f115(double* x) {
/* step-ellipsoid with Cauchy noise, condition 100*/
int i, j, rseed; /*Loop over dim*/
static int funcId = 115;
static int rrseed = 7;
static double condition = 100.;
static double alpha = 10.;
double x1, Fadd, Fval, tmp, Fpen = 0., Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = rrseed + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += 100. * Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++) {
tmpvect[i] = 0.;
tmp = sqrt(pow(condition/10., ((double)i)/((double)(DIM-1))));
for (j = 0; j < DIM; j++) {
tmpvect[i] += tmp * rot2[i][j] * (x[j] - Xopt[j]);
}
}
x1 = tmpvect[0];
for (i = 0; i < DIM; i++) {
if (fabs(tmpvect[i]) > 0.5)
{
tmpvect[i] = round(tmpvect[i]);
}
else
{
tmpvect[i] = round(alpha * tmpvect[i])/alpha;
}
}
for (i = 0; i < DIM; i++) {
tmx[i] = 0.;
for (j = 0; j < DIM; j++) {
tmx[i] += rotation[i][j] * tmpvect[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM; i++)
{
Ftrue += pow(condition, ((double)i)/((double)(DIM-1))) * tmx[i] * tmx[i];
}
Ftrue = 0.1 * fmax(1e-4 * fabs(x1), Ftrue);
Fval = FCauchy(Ftrue, 1., 0.2);
Ftrue += Fadd;
Fval += Fadd;
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f130(double* x) {
/* Gallagher with 101 Gaussian peaks with Cauchy noise, condition up to 1000, one global rotation*/
int i, j, k, rseed; /*Loop over dim*/
static int funcId = 130;
static int rrseed = 21;
static double fitvalues[2] = {1.1, 9.1};
static double maxcondition = 1000.;
static double arrCondition[NHIGHPEAKS21];
static double peakvalues[NHIGHPEAKS21];
static double a = 0.1;
double tmp2, f = 0., Fadd, Fval, tmp, Fpen = 0., Ftrue = 0.;
double fac = -0.5 / (double)DIM;
TwoDoubles res;
if (!isInitDone)
{
rseed = rrseed + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeRotation(rotation, rseed, DIM);
peaks = peaks21;
unif(peaks, NHIGHPEAKS21 - 1, rseed);
rperm = rperm21;
for (i = 0; i < NHIGHPEAKS21 - 1; i++)
rperm[i] = i;
qsort(rperm, NHIGHPEAKS21 - 1, sizeof(int), compare_doubles);
/* Random permutation*/
arrCondition[0] = sqrt(maxcondition);
peakvalues[0] = 10;
for (i = 1; i < NHIGHPEAKS21; i++)
{
arrCondition[i] = pow(maxcondition, (double)(rperm[i-1])/((double)(NHIGHPEAKS21-2)));
peakvalues[i] = (double)(i-1)/(double)(NHIGHPEAKS21-2) * (fitvalues[1] - fitvalues[0]) + fitvalues[0];
}
arrScales = arrScales21;
for (i = 0; i < NHIGHPEAKS21; i++)
{
unif(peaks, DIM, rseed + 1000 * i);
for (j = 0; j < DIM; j++)
rperm[j] = j;
qsort(rperm, DIM, sizeof(int), compare_doubles);
for (j = 0; j < DIM; j++)
{
arrScales[i][j] = pow(arrCondition[i], ((double)rperm[j])/((double)(DIM-1)) - 0.5);
}
}
unif(peaks, DIM * NHIGHPEAKS21, rseed);
Xlocal = Xlocal21;
for (i = 0; i < DIM; i++)
{
Xopt[i] = 0.8 * (10. * peaks[i] -5.);
for (j = 0; j < NHIGHPEAKS21; j++)
{
Xlocal[i][j] = 0.;
for (k = 0; k < DIM; k++)
{
Xlocal[i][j] += rotation[i][k] * (10. * peaks[j * DIM + k] -5.);
}
if (j == 0)
Xlocal[i][j] *= 0.8;
}
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += 100. * Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++)
{
tmx[i] = 0.;
for (j = 0; j < DIM; j++)
{
tmx[i] += rotation[i][j] * x[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < NHIGHPEAKS21; i++)
{
tmp2 = 0.;
for (j = 0; j < DIM; j++)
{
tmp2 += arrScales[i][j] * (tmx[j] - Xlocal[j][i]) * (tmx[j] - Xlocal[j][i]);
}
tmp2 = peakvalues[i] * exp(fac * tmp2);
f = fmax(f, tmp2);
}
f = 10 - f;
/*monotoneTFosc*/
if (f > 0)
{
Ftrue = log(f)/a;
Ftrue = pow(exp(Ftrue + 0.49*(sin(Ftrue) + sin(0.79*Ftrue))), a);
}
else if (f < 0)
{
Ftrue = log(-f)/a;
Ftrue = -pow(exp(Ftrue + 0.49*(sin(0.55 * Ftrue) + sin(0.31*Ftrue))), a);
}
else
Ftrue = f;
Ftrue *= Ftrue;
Fval = FCauchy(Ftrue, 1., 0.2);
Ftrue += Fadd;
Fval += Fadd;
/* free(Xopt); //Not used!*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f127(double* x) {
/* F8F2 sum of Griewank-Rosenbrock 2-D blocks with seldom Cauchy noise*/
int i, j, rseed; /*Loop over dim*/
static int funcId = 127;
static int rrseed = 19;
static double scales;
double F2, Fadd, Fval, tmp, Fpen = 0., Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = rrseed + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
/* computeXopt(rseed, DIM);*/
scales = fmax(1., sqrt((double)DIM) / 8.);
computeRotation(rotation, rseed, DIM);
/* for (i = 0; i < DIM; i++)
{
Xopt[i] = 0.;
for (j = 0; j < DIM; j++)
{
Xopt[i] += rotation[j][i] * 0.5/scales;
//computed only if Xopt is returned which is not the case at this point.
}
}*/
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += 100. * Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++) {
tmx[i] = 0.5;
for (j = 0; j < DIM; j++) {
tmx[i] += scales * rotation[i][j] * x[j];
}
}
/* COMPUTATION core*/
tmp = 0.;
for (i = 0; i < DIM - 1; i++)
{
F2 = 100. * (tmx[i] * tmx[i] - tmx[i+1]) * (tmx[i] * tmx[i] - tmx[i+1]) + (1 - tmx[i]) * (1 - tmx[i]);
tmp += F2 / 4000. - cos(F2);
}
Ftrue = 1. + 1. * tmp / (double)(DIM - 1);
Fval = FCauchy(Ftrue, 1., 0.2);
Ftrue += Fadd;
Fval += Fadd;
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f124(double* x) {
/* Schaffers F7 with seldom Cauchy noise, with asymmetric non-linear transformation, condition 10*/
int i, j, rseed; /*Loop over dim*/
static int funcId = 124;
static int rrseed = 17;
static double condition = 10.;
static double beta = 0.5;
double Fadd, Fval, tmp, Fpen = 0., Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = rrseed + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += 100. * Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++)
{
tmpvect[i] = 0.;
for (j = 0; j < DIM; j++)
{
tmpvect[i] += rotation[i][j] * (x[j] - Xopt[j]);
}
if (tmpvect[i] > 0)
tmpvect[i] = pow(tmpvect[i], 1 + beta * ((double)i)/((double)(DIM-1)) * sqrt(tmpvect[i]));
}
for (i = 0; i < DIM; i++)
{
tmx[i] = 0.;
tmp = pow(sqrt(condition), ((double)i)/((double)(DIM-1)));
for (j = 0; j < DIM; j++)
{
tmx[i] += tmp * rot2[i][j] * tmpvect[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM - 1; i++)
{
tmp = tmx[i] * tmx[i] + tmx[i+1] * tmx[i+1];
Ftrue += pow(tmp, 0.25) * (pow(sin(50. * pow(tmp, 0.1)), 2.) + 1.);
}
Ftrue = pow(Ftrue/(double)(DIM - 1), 2.);
Fval = FCauchy(Ftrue, 1., 0.2);
Ftrue += Fadd;
Fval += Fadd;
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f16(double* x) {
/* Weierstrass, condition 100*/
int i, j, k, rseed; /*Loop over dim*/
static unsigned int funcId = 16;
static double condition = 100.;
static double aK[12];
static double bK[12];
static double F0;
double tmp, Fadd, Fval, Fpen = 0., Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
for (i = 0; i < DIM; i++)
{
for (j = 0; j < DIM; j++)
{
linearTF[i][j] = 0.;
for (k = 0; k < DIM; k++) {
linearTF[i][j] += rotation[i][k] * pow(1./sqrt(condition), ((double)k)/((double)(DIM-1))) * rot2[k][j];
}
}
}
F0 = 0.;
for (i = 0; i < 12; i ++) /* number of summands, 20 in CEC2005, 10/12 saves 30% of time*/
{
aK[i] = pow(0.5, (double)i);
bK[i] = pow(3., (double)i);
F0 += aK[i] * cos(2 * M_PI * bK[i] * 0.5);
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += 10./(double)DIM * Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++)
{
tmpvect[i] = 0.;
for (j = 0; j < DIM; j++)
{
tmpvect[i] += rotation[i][j] * (x[j] - Xopt[j]);
}
}
monotoneTFosc(tmpvect);
for (i = 0; i < DIM; i++)
{
tmx[i] = 0.;
for (j = 0; j < DIM; j++)
{
tmx[i] += linearTF[i][j] * tmpvect[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM; i++)
{
tmp = 0.;
for (j = 0; j < 12; j++)
{
tmp += cos(2 * M_PI * (tmx[i] + 0.5) * bK[j]) * aK[j];
}
Ftrue += tmp;
}
Ftrue = 10. * pow(Ftrue/(double)DIM - F0, 3.);
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f15(double* x) {
/* Rastrigin with asymmetric non-linear distortion, "condition" 10*/
int i, j, k, rseed; /*Loop over dim*/
static unsigned int funcId = 15;
static double condition = 10.;
static double beta = 0.2;
double tmp = 0., tmp2 = 0., Fadd, Fval, Ftrue;
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
for (i = 0; i < DIM; i++)
{
for (j = 0; j < DIM; j++)
{
linearTF[i][j] = 0.;
for (k = 0; k < DIM; k++) {
linearTF[i][j] += rotation[i][k] * pow(sqrt(condition), ((double)k)/((double)(DIM-1))) * rot2[k][j];
}
}
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++)
{
tmpvect[i] = 0.;
for (j = 0; j < DIM; j++)
{
tmpvect[i] += rotation[i][j] * (x[j] - Xopt[j]);
}
}
monotoneTFosc(tmpvect);
for (i = 0; i < DIM; i++)
{
if (tmpvect[i] > 0)
tmpvect[i] = pow(tmpvect[i], 1 + beta * ((double)i)/((double)(DIM-1)) * sqrt(tmpvect[i]));
}
for (i = 0; i < DIM; i++)
{
tmx[i] = 0.;
for (j = 0; j < DIM; j++)
{
tmx[i] += linearTF[i][j] * tmpvect[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM; i++)
{
tmp += cos(2. * M_PI * tmx[i]);
tmp2 += tmx[i] * tmx[i];
}
Ftrue = 10. * ((double)DIM - tmp) + tmp2;
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f9(double* x) {
/* Rosenbrock, rotated*/
int i, j, rseed; /*Loop over dim*/
static unsigned int funcId = 9;
double scales, tmp, Fadd, Fval, Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
/* computeXopt(rseed, DIM);*/
computeRotation(rotation, rseed, DIM);
scales = fmax(1., sqrt(DIM) / 8.);
for (i = 0; i < DIM; i ++)
{
for (j = 0; j < DIM; j++)
linearTF[i][j] = scales * rotation[i][j];
}
/* for (i = 0; i < DIM; i++)
{
Xopt[i] = 0.;
for (j = 0; j < DIM; j++)
{
Xopt[i] += linearTF[j][i] * 0.5/scales/scales;
//computed only if Xopt is returned which is not the case at this point.
}
}*/
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++) {
tmx[i] = 0.5;
for (j = 0; j < DIM; j++) {
tmx[i] += linearTF[i][j] * x[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM - 1; i++)
{
tmp = (tmx[i] * tmx[i] - tmx[i+1]);
Ftrue += tmp * tmp;
}
Ftrue *= 1e2;
for (i = 0; i < DIM - 1; i ++)
{
tmp = (tmx[i] - 1.);
Ftrue += tmp * tmp;
}
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f6(double* x) {
/* attractive sector function*/
int i, j, k, rseed; /*Loop over dim*/
static unsigned int funcId = 6;
static double alpha = 100.;
double Fadd, Fval, Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
static double condition = 10.;
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
/* decouple scaling from function definition*/
for (i = 0; i < DIM; i ++)
{
for (j = 0; j < DIM; j++)
{
linearTF[i][j] = 0.;
for (k = 0; k < DIM; k++) {
linearTF[i][j] += rotation[i][k] * pow(sqrt(condition), ((double)k)/((double)(DIM-1))) * rot2[k][j];
}
}
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++) {
tmx[i] = 0.;
for (j = 0; j < DIM; j++) {
tmx[i] += linearTF[i][j] * (x[j] - Xopt[j]);
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM; i++)
{
if (tmx[i] * Xopt[i] > 0)
tmx[i] *= alpha;
Ftrue += tmx[i] * tmx[i];
}
/*MonotoneTFosc...*/
if (Ftrue > 0)
{
Ftrue = pow(exp(log(Ftrue)/0.1 + 0.49*(sin(log(Ftrue)/0.1) + sin(0.79*log(Ftrue)/0.1))), 0.1);
}
else if (Ftrue < 0)
{
Ftrue = -pow(exp(log(-Ftrue)/0.1 + 0.49*(sin(0.55 * log(-Ftrue)/0.1) + sin(0.31*log(-Ftrue)/0.1))), 0.1);
}
Ftrue = pow(Ftrue, 0.9);
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f24(double* x) {
/* Lunacek bi-Rastrigin, condition 100*/
/* in PPSN 2008, Rastrigin part rotated and scaled*/
int i, j, k, rseed; /*Loop over dim*/
static unsigned int funcId = 24;
static double condition = 100.;
static double mu1 = 2.5;
double Fadd, Fpen = 0., tmp, Ftrue = 0., tmp2 = 0., tmp3 = 0., tmp4 = 0., Fval;
double s = 1. - 0.5 / (sqrt((double)(DIM + 20)) - 4.1);
static double d = 1.;
double mu2 = -sqrt((mu1 * mu1 - d) / s);
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
gauss(tmpvect, DIM, rseed);
for (i = 0; i < DIM; i++)
{
Xopt[i] = 0.5 * mu1;
if (tmpvect[i] < 0.)
Xopt[i] *= -1.;
}
for (i = 0; i < DIM; i++)
{
for (j = 0; j < DIM; j++)
{
linearTF[i][j] = 0.;
for (k = 0; k < DIM; k++) {
linearTF[i][j] += rotation[i][k] * pow(sqrt(condition), ((double)k)/((double)(DIM-1))) * rot2[k][j];
}
}
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += 1e4 * Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++)
{
tmx[i] = 2. * x[i];
if (Xopt[i] < 0.)
tmx[i] *= -1.;
}
/* COMPUTATION core*/
tmp = 0.;
for (i = 0; i < DIM; i++)
{
tmp2 += (tmx[i] - mu1) * (tmx[i] - mu1);
tmp3 += (tmx[i] - mu2) * (tmx[i] - mu2);
tmp4 = 0.;
for (j = 0; j < DIM; j++)
{
tmp4 += linearTF[i][j] * (tmx[j] - mu1);
}
tmp += cos(2 * M_PI * tmp4);
}
Ftrue = fmin(tmp2, d * (double)DIM + s * tmp3) + 10. * ((double)DIM - tmp);
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f23(double* x) {
/* Katsuura function*/
int i, j, k, rseed; /*Loop over dim*/
static unsigned int funcId = 23;
static double condition = 100.;
double Fadd = 0., Fpen = 0., tmp, Ftrue = 0., arr, prod = 1., tmp2, Fval;
double *ptmx, *plinTF, *ptmp;
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
computeXopt(rseed, DIM);
computeRotation(rotation, rseed + 1000000, DIM);
computeRotation(rot2, rseed, DIM);
for (i = 0; i < DIM; i++)
{
for (j = 0; j < DIM; j++)
{
linearTF[i][j] = 0.;
for (k = 0; k < DIM; k++)
{
linearTF[i][j] += rotation[i][k] * pow(sqrt(condition), ((double)k)/(double)(DIM - 1)) * rot2[k][j];
}
}
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
for (i = 0; i < DIM; i++)
{
tmp = fabs(x[i]) - 5.;
if (tmp > 0.)
{
Fpen += tmp * tmp;
}
}
Fadd += Fpen;
/* TRANSFORMATION IN SEARCH SPACE*/
/* write rotated difference vector into tmx*/
for (j = 0; j < DIM; j++) /* store difference vector*/
tmpvect[j] = x[j] - Xopt[j];
for (i = 0; i < DIM; i++) {
tmx[i] = 0.;
ptmx = &tmx[i];
plinTF = linearTF[i];
ptmp = tmpvect;
for (j = 0; j < DIM; j++) {
*ptmx += *plinTF++ * *ptmp++;
}
}
/* for (i = 0; i < DIM; i++) {
tmx[i] = 0.;
for (j = 0; j < DIM; j++) {
tmx[i] += linearTF[i][j] * (x[j] - Xopt[j]);
}
}*/
/* COMPUTATION core*/
for (i = 0; i < DIM; i++)
{
tmp = 0.;
for (j = 1; j < 33; j++)
{
tmp2 = pow(2., (double)j);
arr = tmx[i] * tmp2;
tmp += fabs(arr - round(arr)) / tmp2;
}
tmp = 1. + tmp * (double)(i + 1);
prod *= tmp;
}
Ftrue = 10./(double)DIM/(double)DIM * (-1. + pow(prod, 10./pow((double)DIM, 1.2)));
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
TwoDoubles f19(double* x) {
/* F8F2 sum of Griewank-Rosenbrock 2-D blocks*/
int i, j, rseed; /*Loop over dim*/
static unsigned int funcId = 19;
double scales, F2, tmp = 0., tmp2, Fadd, Fval, Ftrue = 0.;
TwoDoubles res;
if (!isInitDone)
{
rseed = funcId + 10000 * trialid;
/*INITIALIZATION*/
Fopt = computeFopt(funcId, trialid);
/* computeXopt(rseed, DIM); Xopt is not used.*/
scales = fmax(1., sqrt(DIM) / 8.);
computeRotation(rotation, rseed, DIM);
for (i = 0; i < DIM; i ++)
{
for (j = 0; j < DIM; j++)
{
linearTF[i][j] = scales * rotation[i][j];
}
}
for (i = 0; i < DIM; i++)
{
Xopt[i] = 0.;
for (j = 0; j < DIM; j++)
{
Xopt[i] += linearTF[j][i] * 0.5/scales/scales;
}
}
isInitDone = 1;
}
Fadd = Fopt;
/* BOUNDARY HANDLING*/
/* TRANSFORMATION IN SEARCH SPACE*/
for (i = 0; i < DIM; i++) {
tmx[i] = 0.5;
for (j = 0; j < DIM; j++) {
tmx[i] += linearTF[i][j] * x[j];
}
}
/* COMPUTATION core*/
for (i = 0; i < DIM - 1; i++)
{
tmp2 = tmx[i] * tmx[i] -tmx[i+1];
F2 = 100. * tmp2 * tmp2;
tmp2 = 1 - tmx[i];
F2 += tmp2 * tmp2;
tmp += F2 / 4000. - cos(F2);
}
Ftrue = 10. + 10. * tmp / (double)(DIM - 1);
Ftrue += Fadd;
Fval = Ftrue; /* without noise*/
res.Fval = Fval;
res.Ftrue = Ftrue;
return res;
}
