second_order_conic_programming_0020.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizer: [-1.707790, -2.044705, -0.852730, -2.544836, -2.485646] , fx = -1.7077904474950314\n"
     ]
    }
   ],
   "source": [
    "/**\n",
    " * Demonstrate how to solve a Second-Order Conic Programming (SOCP) problem using interior point method.\n",
    " * The initial guess is given by the SDPT3 algorithm.\n",
    " *\n",
    " * @author Haksun Li\n",
    " */\n",
    "\n",
    "%use s2\n",
    "import dev.nm.solver.IterativeSolution\n",
    "\n",
    "// construct an SOCP problem to solve\n",
    "fun problem() : SOCPGeneralProblem {\n",
    "    // min f'x\n",
    "    val f: Vector = DenseVector(1.0, 0.0, 0.0, 0.0, 0.0)\n",
    "\n",
    "    // The A's in the conic constraints.\n",
    "    val A1t: Matrix = DenseMatrix(arrayOf(doubleArrayOf(0.0, -1.0, 0.0, 1.0, 0.0), doubleArrayOf(0.0, 0.0, 1.0, 0.0, -1.0)))\n",
    "    val A2t: Matrix = DenseMatrix(arrayOf(doubleArrayOf(0.0, 0.5, 0.0, 0.0, 0.0), doubleArrayOf(0.0, 0.0, 1.0, 0.0, 0.0)))\n",
    "    val A3t: Matrix = DenseMatrix(arrayOf(doubleArrayOf(0.0, 0.0, 0.0, -0.7071, -0.7071), doubleArrayOf(0.0, 0.0, 0.0, -0.3536, 0.3536)))\n",
    "\n",
    "    // The b's in the conic constraints.\n",
    "    val b1: Vector = f\n",
    "    val b2: Vector = f.ZERO()\n",
    "    val b3: Vector = f.ZERO()\n",
    "\n",
    "    // The c's in the conic constraints.\n",
    "    val c1: Vector = DenseVector(2) // zero\n",
    "    val c2: Vector = DenseVector(-0.5, 0.0)\n",
    "    val c3: Vector = DenseVector(4.2426, -0.7071)\n",
    "\n",
    "    // The d's in the conic constraints.\n",
    "    val d = doubleArrayOf(0.0, 1.0, 1.0)\n",
    "    val constraints: kotlin.collections.List<SOCPGeneralConstraint> = java.util.Arrays.asList<SOCPGeneralConstraint>(\n",
    "        SOCPGeneralConstraint(A1t.t(), c1, b1, d[0]),\n",
    "        SOCPGeneralConstraint(A2t.t(), c2, b2, d[1]),\n",
    "        SOCPGeneralConstraint(A3t.t(), c3, b3, d[2])\n",
    "    )\n",
    "\n",
    "    // The SOCP problem to be solved.\n",
    "    val problem: SOCPGeneralProblem = SOCPGeneralProblem(\n",
    "        f, \n",
    "        constraints) // ||Ax + b|| <= c'x + d\n",
    "    return problem\n",
    "}\n",
    "\n",
    "// Uses interior point method to solve the given problem from a given starting point.\n",
    "val x0: Vector = DenseVector(1.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.0, 0.0)\n",
    "val s0: Vector = DenseVector(3.7, 1.0, -3.5, 1.0, 0.25, 0.5, 1.0, -0.35355, -0.1767)\n",
    "val y0: Vector = DenseVector(-3.7, -1.5, -0.5, -2.5, -4.0)\n",
    "// an initial guess\n",
    "val soln0 = PrimalDualSolution(x0, s0, y0)\n",
    "\n",
    "// construct an SOCP solver\n",
    "val solver = PrimalDualInteriorPointMinimizer(\n",
    "    1e-8,\n",
    "    20) // max number of iterations\n",
    "\n",
    "// solve the SOCP problem\n",
    "val p = problem()\n",
    "val soln: IterativeSolution<PrimalDualSolution> = solver.solve(p)\n",
    "soln.search() // Users do not provide initial guess.\n",
    "\n",
    "// the solution\n",
    "val y = soln.minimizer().y\n",
    "val fx = p.f().evaluate(y);\n",
    "println(\"minimizer: $y, fx = $fx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.5.30-dev-598"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}