if_then_else_for_but_stuff.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from app.ngp import Baseset\n",
    "from app.ngp import Individual\n",
    "from functools import partial\n",
    "import operator\n",
    "import types\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "class Counter(object):\n",
    "    n = 0\n",
    "    def incr(self):\n",
    "        self.n += 1\n",
    "        return self.n\n",
    "\n",
    "def forloop(a, func):\n",
    "    for _ in range(a):\n",
    "        result = func()\n",
    "    return result\n",
    "\n",
    "def part(func, arg1, arg2): \n",
    "    return partial(func, arg1, arg2)\n",
    "\n",
    "def if_then_else(condition, out1, out2):\n",
    "    if condition:\n",
    "        return out1()\n",
    "    else:\n",
    "        return out2()\n",
    "\n",
    "def NigelIsGood(cond):\n",
    "    return cond\n",
    "    \n",
    "f, b = Counter(), Counter()\n",
    "foo = part(forloop, 5, f.incr)\n",
    "bar = part(forloop, 10, b.incr)\n",
    "\n",
    "print(if_then_else(NigelIsGood(True), foo, bar))\n",
    "print(if_then_else(NigelIsGood(False), foo, bar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# random int\n",
    "# f, b (counters)\n",
    "# (counter).incr\n",
    "# if_then_else\n",
    "# forloop\n",
    "# gt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def test_grow_predicate_routines():\n",
    "    \"\"\"try some tricky primitives like forloops and if-then-else\"\"\"\n",
    "    def part(func, arg1, arg2):\n",
    "        return partial(func, arg1, arg2)\n",
    "\n",
    "    def ifthenelse(cond, part1, part2):\n",
    "        if cond:\n",
    "            return part1()\n",
    "        else:\n",
    "            return part2()\n",
    "\n",
    "    bset = Baseset()\n",
    "    bset.addEphemeralConstant(\"R10\", lambda: random.randint(0,10), int)\n",
    "    bset.addPrimitive(operator.gt, [int, int], bool)\n",
    "    bset.addPrimitive(operator.add, [int, int], int)\n",
    "    bset.addPrimitive(ifthenelse, [bool, types.FunctionType, types.FunctionType], object)\n",
    "    #bset.addPrimitive(part, [types.FunctionType, object, object], types.FunctionType)\n",
    "\n",
    "    prog = Individual(bset, [int, int], int)\n",
    "    for tree, pset in prog.routines:\n",
    "        print(pset.name, \":\", pset.ins, '->', pset.ret)\n",
    "        print(\"       \", tree)\n",
    "\n",
    "    print(prog.evaluate(-10, 5))\n",
    "    print(prog.evaluate(1, 8))\n",
    "    print(prog.evaluate(3, -200))\n",
    "    print(prog.evaluate(6, 5))\n",
    "    print(prog.evaluate(88, 8))\n",
    "    print(prog.evaluate(33, 40))\n",
    "    print(prog.evaluate(-6, 23))\n",
    "    print(prog.evaluate(42, 228))\n",
    "    print(prog.evaluate(31, -100))\n",
    "    print(prog.evaluate(-2000, 67))\n",
    "    print(prog.evaluate(90, -538))\n",
    "    print(prog.evaluate(-296, -250))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ADF0 : [<class 'int'>, <class 'int'>] -> <class 'int'>\n",
      "        gt(add(add(1, add(A1, A0)), add(gt(0, A0), add(A0, A1))), gt(add(A0, add(A1, A1)), gt(add(A1, 4), add(A1, A0))))\n",
      "ADF1 : [<class 'int'>, <class 'int'>, <class 'int'>, <class 'bool'>] -> <class 'int'>\n",
      "        ADF0(gt(A0, A3), ADF0(add(gt(A3, A3), gt(A3, A1)), A2))\n",
      "ADF2 : [<class 'int'>, <class 'int'>, <class 'int'>, <class 'bool'>, <class 'int'>] -> <class 'int'>\n",
      "        add(ADF0(ADF1(gt(A4, A1), gt(0, A1), add(A4, A0), ADF1(A3, A4, 8, A4)), ADF0(A1, add(A2, 9))), add(gt(A1, gt(A4, A4)), add(add(A2, A0), gt(A4, 7))))\n",
      "MAIN : [<class 'int'>, <class 'int'>] -> <class 'int'>\n",
      "        ADF1(gt(ADF1(gt(IN0, IN1), gt(IN0, IN1), ADF0(IN1, IN1), gt(IN0, IN0)), ADF0(4, gt(IN0, IN1))), gt(gt(gt(IN0, 1), ADF0(IN0, IN1)), gt(IN1, ADF0(IN1, IN0))), ADF1(gt(add(5, IN0), add(IN1, 8)), IN0, ADF0(IN0, 9), add(gt(IN0, 7), add(IN1, 4))), ADF2(ADF2(add(IN1, IN0), gt(2, IN0), gt(9, 7), ADF0(6, IN0), IN0), gt(gt(0, 0), add(IN1, 10)), gt(add(10, IN0), add(9, IN1)), add(gt(IN1, 0), gt(IN1, IN1)), 9))\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "test_grow_predicate_routines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}