bbob_2009_functions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BBOB 2009 TEST SUITE FUNCTIONS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def c1(x):\n",
    "    if x > 0:\n",
    "        result = 10\n",
    "    else:\n",
    "        result = 5.5\n",
    "    return result\n",
    "    \n",
    "def c2(x):\n",
    "    if x > 0:\n",
    "        result = 7.9\n",
    "    else:\n",
    "        result = 3.1\n",
    "    return result\n",
    "    \n",
    "def x_hat(x):\n",
    "    if x != 0:\n",
    "        result = np.log10(np.abs(x))\n",
    "    else:\n",
    "        result = 0\n",
    "    return result\n",
    "    \n",
    "def ill_conditioning(x):\n",
    "    result = np.sign(x)*np.exp(x_hat(x)+0.049*(math.sin(c1(x)*x_hat(x))+math.sin(c2(x)*x_hat(x))))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # sphere function function 1 (SOLVED, D=20) DONE\n",
    "\n",
    "class function_1:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "    \n",
    "    def rosenbrock_fitness(self, coor_list, radius=0):\n",
    "        result = 0\n",
    "        for i in range(self.rosenbrock_degree):\n",
    "            result += (coor_list[i]-self.x_opt_list[i])**2\n",
    "        result -= radius\n",
    "\n",
    "        return result "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ellipsoidal function function 2 (SOLVED, D=20)\n",
    "\n",
    "class function_2:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "    \n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "        result = 0\n",
    "        for i in range(self.rosenbrock_degree):\n",
    "            result += np.power(10,6*((i)/(self.rosenbrock_degree-1)))*np.power(ill_conditioning(coor_list[i]-self.x_opt_list[i]),2)\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# modified rastrigin function: function 3 (SOLVED, D=20)\n",
    "\n",
    "class function_13:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        def delta_entry(index, alpha=10.0):\n",
    "            result = np.power(alpha, 0.5*((index)/(self.rosenbrock_degree-1)))\n",
    "            return result\n",
    "\n",
    "        def t_asy(x, index, beta=0.2):\n",
    "            if x > 0:\n",
    "                result = np.power(x, 1+beta*(index/(self.rosenbrock_degree-1))*np.power(x,0.5))\n",
    "            else:\n",
    "                result = x\n",
    "            return result\n",
    "\n",
    "        first_term = 0\n",
    "        second_term = 0\n",
    "        for i in range(self.rosenbrock_degree):\n",
    "            first_term += math.cos(2*math.pi*delta_entry(i)*t_asy(ill_conditioning(coor_list[i]-self.x_opt_list[i]), i)) # cos term\n",
    "            second_term += np.power(delta_entry(i)*t_asy(ill_conditioning(coor_list[i]-self.x_opt_list[i]), i), 2)\n",
    "\n",
    "        result = 10*(degree - first_term) + second_term\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Buche-Rastrigin Function function 4 (SOLVED, D=20)\n",
    "\n",
    "class function_14:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        def s_i_first(z_i, i):\n",
    "            if i % 2 == 0:\n",
    "                result = 10*np.power(10,0.5*(i/(self.rosenbrock_degree-1)))\n",
    "            else:\n",
    "                result = np.power(10,0.5*(i/(self.rosenbrock_degree-1)))\n",
    "            return result\n",
    "\n",
    "        def z_i_first(x, i):\n",
    "            s_i = s_i_first(x, i)\n",
    "            z_i = s_i+ill_conditioning(x)\n",
    "            return z_i\n",
    "\n",
    "        def z_i_second(x, i):\n",
    "            z_i = z_i_first(x, i)\n",
    "            if (i % 2 == 0) and (z_i > 0):\n",
    "                s_i = 10*np.power(10,0.5*(i/(self.rosenbrock_degree-1)))\n",
    "            else:\n",
    "                s_i = np.power(10,0.5*(i/(self.rosenbrock_degree-1)))\n",
    "            z_i_second = s_i*ill_conditioning(x)\n",
    "\n",
    "            return z_i_second\n",
    "\n",
    "        def f_pen(x):\n",
    "            result = np.power(np.max([0, np.abs(x)-5]), 2)\n",
    "            return result\n",
    "\n",
    "        first_term = 0\n",
    "        second_term = 0\n",
    "        third_term = 0\n",
    "        for i in range(self.rosenbrock_degree):\n",
    "            first_term += math.cos(2*math.pi*z_i_second(coor_list[i]-self.x_opt_list[i], i)) # cos term\n",
    "            second_term += np.power(z_i_second(coor_list[i]-self.x_opt_list[i], i),2)\n",
    "            third_term += f_pen(coor_list[i])\n",
    "\n",
    "        result = 10 * (self.rosenbrock_degree - first_term) + second_term + 100*third_term \n",
    "\n",
    "        return result\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Linear slope: function 5 (SOLVED, D=20) DONE\n",
    "\n",
    "class function_3:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        random_vec = np.random.randint(0,2,self.rosenbrock_degree)\n",
    "        random_vec[random_vec == 0] = -1\n",
    "        self.x_opt_list = 5 * random_vec\n",
    "    \n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        def sign_func(x, i):\n",
    "            result = np.sign(x)*np.power(10, i/(self.rosenbrock_degree-1))\n",
    "            return result\n",
    "\n",
    "        def z_func(x, x_opt):\n",
    "            if x_opt*x < 25:\n",
    "                z = x\n",
    "            else:\n",
    "                z = x_opt\n",
    "            return z\n",
    "\n",
    "        def f_pen(x):\n",
    "            result = np.power(np.max([0, np.abs(x)-5]), 2)\n",
    "            return result\n",
    "\n",
    "        result = 0\n",
    "        pen_term = 0\n",
    "        for i in range(self.rosenbrock_degree):\n",
    "            result += 5*np.abs(sign_func(self.x_opt_list[i], i)) - sign_func(self.x_opt_list[i], i)*z_func(coor_list[i], self.x_opt_list[i])\n",
    "            pen_term += f_pen(coor_list[i])\n",
    "\n",
    "        result += pen_term\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# attractive sector function: function 6 (SOLVED, D=20) DONE\n",
    "\n",
    "class function_4:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.A_2 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "        self.Q_2, _ = np.linalg.qr(self.A_2)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        def delta_matrix(alpha=10.0):\n",
    "            result = np.diag([np.power(alpha, 0.5*((index)/(self.rosenbrock_degree-1))) for index in range(self.rosenbrock_degree)])\n",
    "            return result\n",
    "\n",
    "        def s_func(x, z):\n",
    "            if z*x > 0:\n",
    "                result = 10**2\n",
    "            else:\n",
    "                result = 1\n",
    "            return result\n",
    "\n",
    "        z = np.matmul(self.Q_2, np.matmul(delta_matrix(), np.matmul(self.Q_1, (coor_list-self.x_opt_list))))\n",
    "\n",
    "        result = 0\n",
    "        for index in range(self.rosenbrock_degree):\n",
    "            result += np.power(s_func(self.x_opt_list[index], z[index])*z[index], 2)\n",
    "        result = ill_conditioning(np.power(result, 0.9))\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step ellipsoidal function: function 7 \n",
    "\n",
    "class function_5:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.A_2 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "        self.Q_2, _ = np.linalg.qr(self.A_2)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        def delta_matrix(alpha=10.0):\n",
    "            result = np.diag([np.power(alpha, 0.5*((index)/(self.rosenbrock_degree-1))) for index in range(self.rosenbrock_degree)])\n",
    "            return result\n",
    "\n",
    "        def z_tilde_func(z):\n",
    "            result_array = np.zeros(z.shape[0])\n",
    "            result_array[np.abs(z) < 0.5] = (np.floor(z+0.5))[np.abs(z) < 0.5]\n",
    "            result_array[np.abs(z) >= 0.5] = (np.floor(10*z+0.5)/10)[np.abs(z) >= 0.5]\n",
    "\n",
    "            return result_array\n",
    "\n",
    "        def f_pen(x):\n",
    "            result = np.power(np.max([0, np.abs(x)-5]), 2)\n",
    "            return result\n",
    "\n",
    "        z_hat = np.matmul(delta_matrix(), np.matmul(self.Q_1, (coor_list-self.x_opt_list)))\n",
    "        z_tilde = z_tilde_func(z_hat)\n",
    "        z = np.matmul(self.Q_2, z_tilde)\n",
    "\n",
    "        first_term = 0\n",
    "        pen_term = 0\n",
    "        for index in range(self.rosenbrock_degree):\n",
    "            first_term += np.power(10, 2*(index/(self.rosenbrock_degree-1)))*np.power(z[index], 2)\n",
    "            pen_term += f_pen(coor_list[index])\n",
    "\n",
    "        result = 0.1*np.max([np.abs(z_hat[0])/np.power(10,4), first_term])+pen_term\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rosenbrock function function 8 (SOLVED, D=20) DONE\n",
    "\n",
    "class function_6:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-3, high=3, size=self.rosenbrock_degree)\n",
    "    \n",
    "    def rosenbrock_fitness(self, coor_list, f_opt=0):\n",
    "        result = 0\n",
    "\n",
    "        def z_func(x, x_opt):\n",
    "            z = np.max([1, (np.sqrt(self.rosenbrock_degree)/8)])*(x-x_opt)+1\n",
    "            return z\n",
    "\n",
    "        for i in range(self.rosenbrock_degree-1):\n",
    "            result +=  100*(z_func(coor_list[i], self.x_opt_list[i])**2-z_func(coor_list[i+1], self.x_opt_list[i+1]))**2+(z_func(coor_list[i],  self.x_opt_list[i])-1)**2 \n",
    "\n",
    "        return result + f_opt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rosenbrock function rotated: function 9 (SOLVED, D=20) DONE\n",
    "\n",
    "class function_7:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-3, high=3, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list, f_opt=0):\n",
    "\n",
    "        z = np.max([1,(np.sqrt(self.rosenbrock_degree)/8)])*np.matmul(self.Q_1, coor_list) + np.ones(self.rosenbrock_degree)/2\n",
    "\n",
    "        result = 0\n",
    "        for i in range(self.rosenbrock_degree-1):\n",
    "            result +=  100*(z[i]**2-z[i+1])**2+(z[i]-1)**2 \n",
    "\n",
    "        return result + f_opt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ellipsoidal rotated: function 10 \n",
    "\n",
    "class function_8:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        z = np.matmul(self.Q_1, (coor_list-self.x_opt_list))\n",
    "\n",
    "        result = 0\n",
    "        for i in range(self.rosenbrock_degree):\n",
    "            result += np.power(10,6*((i)/(self.rosenbrock_degree-1)))*np.power(ill_conditioning(z[i]),2)\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# discus function: function 11 (D=20)\n",
    "\n",
    "class function_9:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        z = np.matmul(self.Q_1, (coor_list-self.x_opt_list))\n",
    "\n",
    "        first_term = 0\n",
    "        for i in range(1, self.rosenbrock_degree):\n",
    "            first_term += np.power(ill_conditioning(z[i]),2)\n",
    "        result = np.power(10,6)*z[0]**2+first_term\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bent cigar: function 12 (D=20) DONE\n",
    "\n",
    "class function_10:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-3, high=3, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        def t_asy(x, beta=0.5):\n",
    "            array = np.zeros(self.rosenbrock_degree)\n",
    "            for index in range(self.rosenbrock_degree):\n",
    "                if x[index] > 0:\n",
    "                    result = np.power(x[index], 1+beta*(index/(self.rosenbrock_degree-1))*np.power(x[index],0.5))\n",
    "                else:\n",
    "                    result = x[index]\n",
    "                array[index] = result\n",
    "            return array\n",
    "\n",
    "        z = np.matmul(self.Q_1, t_asy(np.matmul(self.Q_1, (coor_list-self.x_opt_list))))\n",
    "    \n",
    "        first_term = 0\n",
    "        for i in range(1, self.rosenbrock_degree):\n",
    "            first_term += np.power(z[i], 2)\n",
    "        result = z[0]**2+np.power(10,6)*first_term\n",
    "\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sharp ridge: function 13 (D=20) DONE\n",
    "\n",
    "class function_11:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "        self.A_2 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_2, _ = np.linalg.qr(self.A_2)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "\n",
    "        def delta_matrix(alpha=10.0):\n",
    "            result = np.diag([np.power(alpha, 0.5*((index)/(self.rosenbrock_degree-1))) for index in range(self.rosenbrock_degree)])\n",
    "            return result\n",
    "\n",
    "        z = np.matmul(self.Q_2, np.matmul(delta_matrix(), np.matmul(self.Q_1, (coor_list-self.x_opt_list))))\n",
    "\n",
    "        second_term = 0\n",
    "        for index in range(1, self.rosenbrock_degree):\n",
    "            second_term += np.power(z[index], 2)\n",
    "        second_term = 100 * np.sqrt(second_term)\n",
    "\n",
    "        result = np.power(z[0], 2) + second_term\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# different powers: function 14 (D=20) DONE!!\n",
    "\n",
    "class function_12:\n",
    "    def __init__(self, random_seed, rosenbrock_degree):\n",
    "        self.random_seed = random_seed\n",
    "        self.rosenbrock_degree = rosenbrock_degree\n",
    "        np.random.seed(random_seed)\n",
    "        self.x_opt_list = np.random.uniform(low=-5, high=5, size=self.rosenbrock_degree)\n",
    "        self.A_1 = np.random.randn(self.rosenbrock_degree, self.rosenbrock_degree)\n",
    "        self.Q_1, _ = np.linalg.qr(self.A_1)\n",
    "\n",
    "    def rosenbrock_fitness(self, coor_list):\n",
    "\n",
    "        z = np.matmul(self.Q_1, (coor_list-self.x_opt_list))\n",
    "\n",
    "        result = 0\n",
    "        for index in range(self.rosenbrock_degree):\n",
    "            result += np.power(np.abs(z[index]), (2+4*(index/(self.rosenbrock_degree-1))))\n",
    "\n",
    "        result = np.sqrt(result)\n",
    "\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}