test.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:b0c95c1ea05f4d6b70d9e45a7b6699292ccc4d318804005ff01884872742564f"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Cython with gcc -O3\n",
      "from atomic import test_compose_gF, test_range, compose_gF, test_dummy\n",
      "%timeit test_range()\n",
      "%timeit test_compose_gF(1, 1.5, 1.5, 1, 0.5)\n",
      "%timeit compose_gF(1, 1.5, 1.5, 1, 0.5, 0.0)\n",
      "%timeit test_dummy(1, 1.5, 1.5, 1, 0.5, 0.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 29.8 ns per loop\n",
        "1000 loops, best of 3: 1.19 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000000 loops, best of 3: 140 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000000 loops, best of 3: 131 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Cython with gcc -Ofast\n",
      "from atomic import test_compose_gF, test_range, compose_gF, test_dummy\n",
      "%timeit test_range()\n",
      "%timeit test_compose_gF(1, 1.5, 1.5, 1, 0.5)\n",
      "%timeit compose_gF(1, 1.5, 1.5, 1, 0.5, 0.0)\n",
      "%timeit test_dummy(1, 1.5, 1.5, 1, 0.5, 0.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 29.6 ns per loop\n",
        "10000 loops, best of 3: 80.9 \u00b5s per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000000 loops, best of 3: 140 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000000 loops, best of 3: 129 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# pypy\n",
      "from atomic import test_compose_gF, test_range, compose_gF, test_dummy\n",
      "%timeit test_range()\n",
      "%timeit test_compose_gF(1, 1.5, 1.5, 1, 0.5)\n",
      "%timeit compose_gF(1, 1.5, 1.5, 1, 0.5, 0.0)\n",
      "%timeit test_dummy(1, 1.5, 1.5, 1, 0.5, 0.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 203 \u00b5s per loop\n",
        "1000 loops, best of 3: 1.63 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000000 loops, best of 3: 21 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10000000 loops, best of 3: 20.3 ns per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "g_e = 2.00231930436153\n",
      "\n",
      "def compose_g(J_sum, J1, J2, g1, g2):\n",
      "    if not J_sum:\n",
      "        return 0.0\n",
      "    J_sum_2 = J_sum * (J_sum + 1)\n",
      "    J1_2 = J1 * (J1 + 1)\n",
      "    J2_2 = J2 * (J2 + 1)\n",
      "    return (g1 * (J_sum_2 + J1_2 - J2_2) +\n",
      "            g2 * (J_sum_2 + J2_2 - J1_2)) / 2 / J_sum_2\n",
      "\n",
      "def compose_gJ(J, L, S):\n",
      "    return compose_g(J, L, S, 1.0, g_e)\n",
      "\n",
      "def compose_gF(F, I, J, L, S, g_I):\n",
      "    return compose_g(F, I, J, g_I, compose_gJ(J, L, S))\n",
      "\n",
      "def test_dummy(F, I, J, L, S, g_I):\n",
      "    return 0\n",
      "\n",
      "def test_range():\n",
      "    for i in xrange(100000):\n",
      "        pass\n",
      "    return\n",
      "\n",
      "def test_compose_gF(F, I, J, L, S):\n",
      "    for i in xrange(100000):\n",
      "        g_I = i / 1000000.0\n",
      "        res = compose_gF(F, I, J, L, S, g_I)\n",
      "    return res"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "cdef double compose_g(double J_sum, double J1,\n",
      "                      double J2, double g1, double g2) nogil:\n",
      "    if not J_sum:\n",
      "        return 0.0\n",
      "    cdef double J_sum_2 = J_sum * (J_sum + 1)\n",
      "    cdef double J1_2 = J1 * (J1 + 1)\n",
      "    cdef double J2_2 = J2 * (J2 + 1)\n",
      "    return (g1 * (J_sum_2 + J1_2 - J2_2) +\n",
      "            g2 * (J_sum_2 + J2_2 - J1_2)) / 2 / J_sum_2\n",
      "\n",
      "cdef double compose_gJ(double J, double L, double S) nogil:\n",
      "    cdef double g_e = 2.00231930436153\n",
      "    return compose_g(J, L, S, 1.0, g_e)\n",
      "\n",
      "cpdef double compose_gF(double F, double I, double J, double L,\n",
      "                        double S, double g_I) nogil:\n",
      "    return compose_g(F, I, J, g_I, compose_gJ(J, L, S))\n",
      "\n",
      "cpdef int test_dummy(double F, double I, double J, double L,\n",
      "                     double S, double g_I) nogil:\n",
      "    return 0\n",
      "\n",
      "cpdef test_range():\n",
      "    for i in xrange(100000):\n",
      "        pass\n",
      "    return\n",
      "\n",
      "cpdef double test_compose_gF(double F, double I, double J, double L,\n",
      "                             double S) nogil:\n",
      "    cdef double g_I\n",
      "    cdef int i\n",
      "    for i in xrange(100000):\n",
      "        g_I = i / 1000000.0\n",
      "        res = compose_gF(F, I, J, L, S, g_I)\n",
      "    return res"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}